Annotation of embedaddon/libxml2/xpath.c, revision 1.1
1.1 ! misho 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: #ifdef LIBXML_PATTERN_ENABLED
! 59: #define XPATH_STREAMING
! 60: #endif
! 61:
! 62: #define TODO \
! 63: xmlGenericError(xmlGenericErrorContext, \
! 64: "Unimplemented block at %s:%d\n", \
! 65: __FILE__, __LINE__);
! 66:
! 67: /*
! 68: * XP_OPTIMIZED_NON_ELEM_COMPARISON:
! 69: * If defined, this will use xmlXPathCmpNodesExt() instead of
! 70: * xmlXPathCmpNodes(). The new function is optimized comparison of
! 71: * non-element nodes; actually it will speed up comparison only if
! 72: * xmlXPathOrderDocElems() was called in order to index the elements of
! 73: * a tree in document order; Libxslt does such an indexing, thus it will
! 74: * benefit from this optimization.
! 75: */
! 76: #define XP_OPTIMIZED_NON_ELEM_COMPARISON
! 77:
! 78: /*
! 79: * XP_OPTIMIZED_FILTER_FIRST:
! 80: * If defined, this will optimize expressions like "key('foo', 'val')[b][1]"
! 81: * in a way, that it stop evaluation at the first node.
! 82: */
! 83: #define XP_OPTIMIZED_FILTER_FIRST
! 84:
! 85: /*
! 86: * XP_DEBUG_OBJ_USAGE:
! 87: * Internal flag to enable tracking of how much XPath objects have been
! 88: * created.
! 89: */
! 90: /* #define XP_DEBUG_OBJ_USAGE */
! 91:
! 92: /*
! 93: * TODO:
! 94: * There are a few spots where some tests are done which depend upon ascii
! 95: * data. These should be enhanced for full UTF8 support (see particularly
! 96: * any use of the macros IS_ASCII_CHARACTER and IS_ASCII_DIGIT)
! 97: */
! 98:
! 99: #if defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
! 100:
! 101: /************************************************************************
! 102: * *
! 103: * Floating point stuff *
! 104: * *
! 105: ************************************************************************/
! 106:
! 107: #ifndef TRIO_REPLACE_STDIO
! 108: #define TRIO_PUBLIC static
! 109: #endif
! 110: #include "trionan.c"
! 111:
! 112: /*
! 113: * The lack of portability of this section of the libc is annoying !
! 114: */
! 115: double xmlXPathNAN = 0;
! 116: double xmlXPathPINF = 1;
! 117: double xmlXPathNINF = -1;
! 118: static double xmlXPathNZERO = 0; /* not exported from headers */
! 119: static int xmlXPathInitialized = 0;
! 120:
! 121: /**
! 122: * xmlXPathInit:
! 123: *
! 124: * Initialize the XPath environment
! 125: */
! 126: void
! 127: xmlXPathInit(void) {
! 128: if (xmlXPathInitialized) return;
! 129:
! 130: xmlXPathPINF = trio_pinf();
! 131: xmlXPathNINF = trio_ninf();
! 132: xmlXPathNAN = trio_nan();
! 133: xmlXPathNZERO = trio_nzero();
! 134:
! 135: xmlXPathInitialized = 1;
! 136: }
! 137:
! 138: /**
! 139: * xmlXPathIsNaN:
! 140: * @val: a double value
! 141: *
! 142: * Provides a portable isnan() function to detect whether a double
! 143: * is a NotaNumber. Based on trio code
! 144: * http://sourceforge.net/projects/ctrio/
! 145: *
! 146: * Returns 1 if the value is a NaN, 0 otherwise
! 147: */
! 148: int
! 149: xmlXPathIsNaN(double val) {
! 150: return(trio_isnan(val));
! 151: }
! 152:
! 153: /**
! 154: * xmlXPathIsInf:
! 155: * @val: a double value
! 156: *
! 157: * Provides a portable isinf() function to detect whether a double
! 158: * is a +Infinite or -Infinite. Based on trio code
! 159: * http://sourceforge.net/projects/ctrio/
! 160: *
! 161: * Returns 1 vi the value is +Infinite, -1 if -Infinite, 0 otherwise
! 162: */
! 163: int
! 164: xmlXPathIsInf(double val) {
! 165: return(trio_isinf(val));
! 166: }
! 167:
! 168: #endif /* SCHEMAS or XPATH */
! 169: #ifdef LIBXML_XPATH_ENABLED
! 170: /**
! 171: * xmlXPathGetSign:
! 172: * @val: a double value
! 173: *
! 174: * Provides a portable function to detect the sign of a double
! 175: * Modified from trio code
! 176: * http://sourceforge.net/projects/ctrio/
! 177: *
! 178: * Returns 1 if the value is Negative, 0 if positive
! 179: */
! 180: static int
! 181: xmlXPathGetSign(double val) {
! 182: return(trio_signbit(val));
! 183: }
! 184:
! 185:
! 186: /*
! 187: * TODO: when compatibility allows remove all "fake node libxslt" strings
! 188: * the test should just be name[0] = ' '
! 189: */
! 190: #ifdef DEBUG_XPATH_EXPRESSION
! 191: #define DEBUG_STEP
! 192: #define DEBUG_EXPR
! 193: #define DEBUG_EVAL_COUNTS
! 194: #endif
! 195:
! 196: static xmlNs xmlXPathXMLNamespaceStruct = {
! 197: NULL,
! 198: XML_NAMESPACE_DECL,
! 199: XML_XML_NAMESPACE,
! 200: BAD_CAST "xml",
! 201: NULL,
! 202: NULL
! 203: };
! 204: static xmlNsPtr xmlXPathXMLNamespace = &xmlXPathXMLNamespaceStruct;
! 205: #ifndef LIBXML_THREAD_ENABLED
! 206: /*
! 207: * Optimizer is disabled only when threaded apps are detected while
! 208: * the library ain't compiled for thread safety.
! 209: */
! 210: static int xmlXPathDisableOptimizer = 0;
! 211: #endif
! 212:
! 213: /************************************************************************
! 214: * *
! 215: * Error handling routines *
! 216: * *
! 217: ************************************************************************/
! 218:
! 219: /**
! 220: * XP_ERRORNULL:
! 221: * @X: the error code
! 222: *
! 223: * Macro to raise an XPath error and return NULL.
! 224: */
! 225: #define XP_ERRORNULL(X) \
! 226: { xmlXPathErr(ctxt, X); return(NULL); }
! 227:
! 228: /*
! 229: * The array xmlXPathErrorMessages corresponds to the enum xmlXPathError
! 230: */
! 231: static const char *xmlXPathErrorMessages[] = {
! 232: "Ok\n",
! 233: "Number encoding\n",
! 234: "Unfinished literal\n",
! 235: "Start of literal\n",
! 236: "Expected $ for variable reference\n",
! 237: "Undefined variable\n",
! 238: "Invalid predicate\n",
! 239: "Invalid expression\n",
! 240: "Missing closing curly brace\n",
! 241: "Unregistered function\n",
! 242: "Invalid operand\n",
! 243: "Invalid type\n",
! 244: "Invalid number of arguments\n",
! 245: "Invalid context size\n",
! 246: "Invalid context position\n",
! 247: "Memory allocation error\n",
! 248: "Syntax error\n",
! 249: "Resource error\n",
! 250: "Sub resource error\n",
! 251: "Undefined namespace prefix\n",
! 252: "Encoding error\n",
! 253: "Char out of XML range\n",
! 254: "Invalid or incomplete context\n",
! 255: "?? Unknown error ??\n" /* Must be last in the list! */
! 256: };
! 257: #define MAXERRNO ((int)(sizeof(xmlXPathErrorMessages) / \
! 258: sizeof(xmlXPathErrorMessages[0])) - 1)
! 259: /**
! 260: * xmlXPathErrMemory:
! 261: * @ctxt: an XPath context
! 262: * @extra: extra informations
! 263: *
! 264: * Handle a redefinition of attribute error
! 265: */
! 266: static void
! 267: xmlXPathErrMemory(xmlXPathContextPtr ctxt, const char *extra)
! 268: {
! 269: if (ctxt != NULL) {
! 270: if (extra) {
! 271: xmlChar buf[200];
! 272:
! 273: xmlStrPrintf(buf, 200,
! 274: BAD_CAST "Memory allocation failed : %s\n",
! 275: extra);
! 276: ctxt->lastError.message = (char *) xmlStrdup(buf);
! 277: } else {
! 278: ctxt->lastError.message = (char *)
! 279: xmlStrdup(BAD_CAST "Memory allocation failed\n");
! 280: }
! 281: ctxt->lastError.domain = XML_FROM_XPATH;
! 282: ctxt->lastError.code = XML_ERR_NO_MEMORY;
! 283: if (ctxt->error != NULL)
! 284: ctxt->error(ctxt->userData, &ctxt->lastError);
! 285: } else {
! 286: if (extra)
! 287: __xmlRaiseError(NULL, NULL, NULL,
! 288: NULL, NULL, XML_FROM_XPATH,
! 289: XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0,
! 290: extra, NULL, NULL, 0, 0,
! 291: "Memory allocation failed : %s\n", extra);
! 292: else
! 293: __xmlRaiseError(NULL, NULL, NULL,
! 294: NULL, NULL, XML_FROM_XPATH,
! 295: XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0,
! 296: NULL, NULL, NULL, 0, 0,
! 297: "Memory allocation failed\n");
! 298: }
! 299: }
! 300:
! 301: /**
! 302: * xmlXPathPErrMemory:
! 303: * @ctxt: an XPath parser context
! 304: * @extra: extra informations
! 305: *
! 306: * Handle a redefinition of attribute error
! 307: */
! 308: static void
! 309: xmlXPathPErrMemory(xmlXPathParserContextPtr ctxt, const char *extra)
! 310: {
! 311: if (ctxt == NULL)
! 312: xmlXPathErrMemory(NULL, extra);
! 313: else {
! 314: ctxt->error = XPATH_MEMORY_ERROR;
! 315: xmlXPathErrMemory(ctxt->context, extra);
! 316: }
! 317: }
! 318:
! 319: /**
! 320: * xmlXPathErr:
! 321: * @ctxt: a XPath parser context
! 322: * @error: the error code
! 323: *
! 324: * Handle an XPath error
! 325: */
! 326: void
! 327: xmlXPathErr(xmlXPathParserContextPtr ctxt, int error)
! 328: {
! 329: if ((error < 0) || (error > MAXERRNO))
! 330: error = MAXERRNO;
! 331: if (ctxt == NULL) {
! 332: __xmlRaiseError(NULL, NULL, NULL,
! 333: NULL, NULL, XML_FROM_XPATH,
! 334: error + XML_XPATH_EXPRESSION_OK - XPATH_EXPRESSION_OK,
! 335: XML_ERR_ERROR, NULL, 0,
! 336: NULL, NULL, NULL, 0, 0,
! 337: "%s", xmlXPathErrorMessages[error]);
! 338: return;
! 339: }
! 340: ctxt->error = error;
! 341: if (ctxt->context == NULL) {
! 342: __xmlRaiseError(NULL, NULL, NULL,
! 343: NULL, NULL, XML_FROM_XPATH,
! 344: error + XML_XPATH_EXPRESSION_OK - XPATH_EXPRESSION_OK,
! 345: XML_ERR_ERROR, NULL, 0,
! 346: (const char *) ctxt->base, NULL, NULL,
! 347: ctxt->cur - ctxt->base, 0,
! 348: "%s", xmlXPathErrorMessages[error]);
! 349: return;
! 350: }
! 351:
! 352: /* cleanup current last error */
! 353: xmlResetError(&ctxt->context->lastError);
! 354:
! 355: ctxt->context->lastError.domain = XML_FROM_XPATH;
! 356: ctxt->context->lastError.code = error + XML_XPATH_EXPRESSION_OK -
! 357: XPATH_EXPRESSION_OK;
! 358: ctxt->context->lastError.level = XML_ERR_ERROR;
! 359: ctxt->context->lastError.str1 = (char *) xmlStrdup(ctxt->base);
! 360: ctxt->context->lastError.int1 = ctxt->cur - ctxt->base;
! 361: ctxt->context->lastError.node = ctxt->context->debugNode;
! 362: if (ctxt->context->error != NULL) {
! 363: ctxt->context->error(ctxt->context->userData,
! 364: &ctxt->context->lastError);
! 365: } else {
! 366: __xmlRaiseError(NULL, NULL, NULL,
! 367: NULL, ctxt->context->debugNode, XML_FROM_XPATH,
! 368: error + XML_XPATH_EXPRESSION_OK - XPATH_EXPRESSION_OK,
! 369: XML_ERR_ERROR, NULL, 0,
! 370: (const char *) ctxt->base, NULL, NULL,
! 371: ctxt->cur - ctxt->base, 0,
! 372: "%s", xmlXPathErrorMessages[error]);
! 373: }
! 374:
! 375: }
! 376:
! 377: /**
! 378: * xmlXPatherror:
! 379: * @ctxt: the XPath Parser context
! 380: * @file: the file name
! 381: * @line: the line number
! 382: * @no: the error number
! 383: *
! 384: * Formats an error message.
! 385: */
! 386: void
! 387: xmlXPatherror(xmlXPathParserContextPtr ctxt, const char *file ATTRIBUTE_UNUSED,
! 388: int line ATTRIBUTE_UNUSED, int no) {
! 389: xmlXPathErr(ctxt, no);
! 390: }
! 391:
! 392: /************************************************************************
! 393: * *
! 394: * Utilities *
! 395: * *
! 396: ************************************************************************/
! 397:
! 398: /**
! 399: * xsltPointerList:
! 400: *
! 401: * Pointer-list for various purposes.
! 402: */
! 403: typedef struct _xmlPointerList xmlPointerList;
! 404: typedef xmlPointerList *xmlPointerListPtr;
! 405: struct _xmlPointerList {
! 406: void **items;
! 407: int number;
! 408: int size;
! 409: };
! 410: /*
! 411: * TODO: Since such a list-handling is used in xmlschemas.c and libxslt
! 412: * and here, we should make the functions public.
! 413: */
! 414: static int
! 415: xmlPointerListAddSize(xmlPointerListPtr list,
! 416: void *item,
! 417: int initialSize)
! 418: {
! 419: if (list->items == NULL) {
! 420: if (initialSize <= 0)
! 421: initialSize = 1;
! 422: list->items = (void **) xmlMalloc(
! 423: initialSize * sizeof(void *));
! 424: if (list->items == NULL) {
! 425: xmlXPathErrMemory(NULL,
! 426: "xmlPointerListCreate: allocating item\n");
! 427: return(-1);
! 428: }
! 429: list->number = 0;
! 430: list->size = initialSize;
! 431: } else if (list->size <= list->number) {
! 432: list->size *= 2;
! 433: list->items = (void **) xmlRealloc(list->items,
! 434: list->size * sizeof(void *));
! 435: if (list->items == NULL) {
! 436: xmlXPathErrMemory(NULL,
! 437: "xmlPointerListCreate: re-allocating item\n");
! 438: list->size = 0;
! 439: return(-1);
! 440: }
! 441: }
! 442: list->items[list->number++] = item;
! 443: return(0);
! 444: }
! 445:
! 446: /**
! 447: * xsltPointerListCreate:
! 448: *
! 449: * Creates an xsltPointerList structure.
! 450: *
! 451: * Returns a xsltPointerList structure or NULL in case of an error.
! 452: */
! 453: static xmlPointerListPtr
! 454: xmlPointerListCreate(int initialSize)
! 455: {
! 456: xmlPointerListPtr ret;
! 457:
! 458: ret = xmlMalloc(sizeof(xmlPointerList));
! 459: if (ret == NULL) {
! 460: xmlXPathErrMemory(NULL,
! 461: "xmlPointerListCreate: allocating item\n");
! 462: return (NULL);
! 463: }
! 464: memset(ret, 0, sizeof(xmlPointerList));
! 465: if (initialSize > 0) {
! 466: xmlPointerListAddSize(ret, NULL, initialSize);
! 467: ret->number = 0;
! 468: }
! 469: return (ret);
! 470: }
! 471:
! 472: /**
! 473: * xsltPointerListFree:
! 474: *
! 475: * Frees the xsltPointerList structure. This does not free
! 476: * the content of the list.
! 477: */
! 478: static void
! 479: xmlPointerListFree(xmlPointerListPtr list)
! 480: {
! 481: if (list == NULL)
! 482: return;
! 483: if (list->items != NULL)
! 484: xmlFree(list->items);
! 485: xmlFree(list);
! 486: }
! 487:
! 488: /************************************************************************
! 489: * *
! 490: * Parser Types *
! 491: * *
! 492: ************************************************************************/
! 493:
! 494: /*
! 495: * Types are private:
! 496: */
! 497:
! 498: typedef enum {
! 499: XPATH_OP_END=0,
! 500: XPATH_OP_AND,
! 501: XPATH_OP_OR,
! 502: XPATH_OP_EQUAL,
! 503: XPATH_OP_CMP,
! 504: XPATH_OP_PLUS,
! 505: XPATH_OP_MULT,
! 506: XPATH_OP_UNION,
! 507: XPATH_OP_ROOT,
! 508: XPATH_OP_NODE,
! 509: XPATH_OP_RESET, /* 10 */
! 510: XPATH_OP_COLLECT,
! 511: XPATH_OP_VALUE, /* 12 */
! 512: XPATH_OP_VARIABLE,
! 513: XPATH_OP_FUNCTION,
! 514: XPATH_OP_ARG,
! 515: XPATH_OP_PREDICATE,
! 516: XPATH_OP_FILTER, /* 17 */
! 517: XPATH_OP_SORT /* 18 */
! 518: #ifdef LIBXML_XPTR_ENABLED
! 519: ,XPATH_OP_RANGETO
! 520: #endif
! 521: } xmlXPathOp;
! 522:
! 523: typedef enum {
! 524: AXIS_ANCESTOR = 1,
! 525: AXIS_ANCESTOR_OR_SELF,
! 526: AXIS_ATTRIBUTE,
! 527: AXIS_CHILD,
! 528: AXIS_DESCENDANT,
! 529: AXIS_DESCENDANT_OR_SELF,
! 530: AXIS_FOLLOWING,
! 531: AXIS_FOLLOWING_SIBLING,
! 532: AXIS_NAMESPACE,
! 533: AXIS_PARENT,
! 534: AXIS_PRECEDING,
! 535: AXIS_PRECEDING_SIBLING,
! 536: AXIS_SELF
! 537: } xmlXPathAxisVal;
! 538:
! 539: typedef enum {
! 540: NODE_TEST_NONE = 0,
! 541: NODE_TEST_TYPE = 1,
! 542: NODE_TEST_PI = 2,
! 543: NODE_TEST_ALL = 3,
! 544: NODE_TEST_NS = 4,
! 545: NODE_TEST_NAME = 5
! 546: } xmlXPathTestVal;
! 547:
! 548: typedef enum {
! 549: NODE_TYPE_NODE = 0,
! 550: NODE_TYPE_COMMENT = XML_COMMENT_NODE,
! 551: NODE_TYPE_TEXT = XML_TEXT_NODE,
! 552: NODE_TYPE_PI = XML_PI_NODE
! 553: } xmlXPathTypeVal;
! 554:
! 555: #define XP_REWRITE_DOS_CHILD_ELEM 1
! 556:
! 557: typedef struct _xmlXPathStepOp xmlXPathStepOp;
! 558: typedef xmlXPathStepOp *xmlXPathStepOpPtr;
! 559: struct _xmlXPathStepOp {
! 560: xmlXPathOp op; /* The identifier of the operation */
! 561: int ch1; /* First child */
! 562: int ch2; /* Second child */
! 563: int value;
! 564: int value2;
! 565: int value3;
! 566: void *value4;
! 567: void *value5;
! 568: void *cache;
! 569: void *cacheURI;
! 570: int rewriteType;
! 571: };
! 572:
! 573: struct _xmlXPathCompExpr {
! 574: int nbStep; /* Number of steps in this expression */
! 575: int maxStep; /* Maximum number of steps allocated */
! 576: xmlXPathStepOp *steps; /* ops for computation of this expression */
! 577: int last; /* index of last step in expression */
! 578: xmlChar *expr; /* the expression being computed */
! 579: xmlDictPtr dict; /* the dictionnary to use if any */
! 580: #ifdef DEBUG_EVAL_COUNTS
! 581: int nb;
! 582: xmlChar *string;
! 583: #endif
! 584: #ifdef XPATH_STREAMING
! 585: xmlPatternPtr stream;
! 586: #endif
! 587: };
! 588:
! 589: /************************************************************************
! 590: * *
! 591: * Forward declarations *
! 592: * *
! 593: ************************************************************************/
! 594: static void
! 595: xmlXPathFreeValueTree(xmlNodeSetPtr obj);
! 596: static void
! 597: xmlXPathReleaseObject(xmlXPathContextPtr ctxt, xmlXPathObjectPtr obj);
! 598: static int
! 599: xmlXPathCompOpEvalFirst(xmlXPathParserContextPtr ctxt,
! 600: xmlXPathStepOpPtr op, xmlNodePtr *first);
! 601: static int
! 602: xmlXPathCompOpEvalToBoolean(xmlXPathParserContextPtr ctxt,
! 603: xmlXPathStepOpPtr op,
! 604: int isPredicate);
! 605:
! 606: /************************************************************************
! 607: * *
! 608: * Parser Type functions *
! 609: * *
! 610: ************************************************************************/
! 611:
! 612: /**
! 613: * xmlXPathNewCompExpr:
! 614: *
! 615: * Create a new Xpath component
! 616: *
! 617: * Returns the newly allocated xmlXPathCompExprPtr or NULL in case of error
! 618: */
! 619: static xmlXPathCompExprPtr
! 620: xmlXPathNewCompExpr(void) {
! 621: xmlXPathCompExprPtr cur;
! 622:
! 623: cur = (xmlXPathCompExprPtr) xmlMalloc(sizeof(xmlXPathCompExpr));
! 624: if (cur == NULL) {
! 625: xmlXPathErrMemory(NULL, "allocating component\n");
! 626: return(NULL);
! 627: }
! 628: memset(cur, 0, sizeof(xmlXPathCompExpr));
! 629: cur->maxStep = 10;
! 630: cur->nbStep = 0;
! 631: cur->steps = (xmlXPathStepOp *) xmlMalloc(cur->maxStep *
! 632: sizeof(xmlXPathStepOp));
! 633: if (cur->steps == NULL) {
! 634: xmlXPathErrMemory(NULL, "allocating steps\n");
! 635: xmlFree(cur);
! 636: return(NULL);
! 637: }
! 638: memset(cur->steps, 0, cur->maxStep * sizeof(xmlXPathStepOp));
! 639: cur->last = -1;
! 640: #ifdef DEBUG_EVAL_COUNTS
! 641: cur->nb = 0;
! 642: #endif
! 643: return(cur);
! 644: }
! 645:
! 646: /**
! 647: * xmlXPathFreeCompExpr:
! 648: * @comp: an XPATH comp
! 649: *
! 650: * Free up the memory allocated by @comp
! 651: */
! 652: void
! 653: xmlXPathFreeCompExpr(xmlXPathCompExprPtr comp)
! 654: {
! 655: xmlXPathStepOpPtr op;
! 656: int i;
! 657:
! 658: if (comp == NULL)
! 659: return;
! 660: if (comp->dict == NULL) {
! 661: for (i = 0; i < comp->nbStep; i++) {
! 662: op = &comp->steps[i];
! 663: if (op->value4 != NULL) {
! 664: if (op->op == XPATH_OP_VALUE)
! 665: xmlXPathFreeObject(op->value4);
! 666: else
! 667: xmlFree(op->value4);
! 668: }
! 669: if (op->value5 != NULL)
! 670: xmlFree(op->value5);
! 671: }
! 672: } else {
! 673: for (i = 0; i < comp->nbStep; i++) {
! 674: op = &comp->steps[i];
! 675: if (op->value4 != NULL) {
! 676: if (op->op == XPATH_OP_VALUE)
! 677: xmlXPathFreeObject(op->value4);
! 678: }
! 679: }
! 680: xmlDictFree(comp->dict);
! 681: }
! 682: if (comp->steps != NULL) {
! 683: xmlFree(comp->steps);
! 684: }
! 685: #ifdef DEBUG_EVAL_COUNTS
! 686: if (comp->string != NULL) {
! 687: xmlFree(comp->string);
! 688: }
! 689: #endif
! 690: #ifdef XPATH_STREAMING
! 691: if (comp->stream != NULL) {
! 692: xmlFreePatternList(comp->stream);
! 693: }
! 694: #endif
! 695: if (comp->expr != NULL) {
! 696: xmlFree(comp->expr);
! 697: }
! 698:
! 699: xmlFree(comp);
! 700: }
! 701:
! 702: /**
! 703: * xmlXPathCompExprAdd:
! 704: * @comp: the compiled expression
! 705: * @ch1: first child index
! 706: * @ch2: second child index
! 707: * @op: an op
! 708: * @value: the first int value
! 709: * @value2: the second int value
! 710: * @value3: the third int value
! 711: * @value4: the first string value
! 712: * @value5: the second string value
! 713: *
! 714: * Add a step to an XPath Compiled Expression
! 715: *
! 716: * Returns -1 in case of failure, the index otherwise
! 717: */
! 718: static int
! 719: xmlXPathCompExprAdd(xmlXPathCompExprPtr comp, int ch1, int ch2,
! 720: xmlXPathOp op, int value,
! 721: int value2, int value3, void *value4, void *value5) {
! 722: if (comp->nbStep >= comp->maxStep) {
! 723: xmlXPathStepOp *real;
! 724:
! 725: comp->maxStep *= 2;
! 726: real = (xmlXPathStepOp *) xmlRealloc(comp->steps,
! 727: comp->maxStep * sizeof(xmlXPathStepOp));
! 728: if (real == NULL) {
! 729: comp->maxStep /= 2;
! 730: xmlXPathErrMemory(NULL, "adding step\n");
! 731: return(-1);
! 732: }
! 733: comp->steps = real;
! 734: }
! 735: comp->last = comp->nbStep;
! 736: comp->steps[comp->nbStep].rewriteType = 0;
! 737: comp->steps[comp->nbStep].ch1 = ch1;
! 738: comp->steps[comp->nbStep].ch2 = ch2;
! 739: comp->steps[comp->nbStep].op = op;
! 740: comp->steps[comp->nbStep].value = value;
! 741: comp->steps[comp->nbStep].value2 = value2;
! 742: comp->steps[comp->nbStep].value3 = value3;
! 743: if ((comp->dict != NULL) &&
! 744: ((op == XPATH_OP_FUNCTION) || (op == XPATH_OP_VARIABLE) ||
! 745: (op == XPATH_OP_COLLECT))) {
! 746: if (value4 != NULL) {
! 747: comp->steps[comp->nbStep].value4 = (xmlChar *)
! 748: (void *)xmlDictLookup(comp->dict, value4, -1);
! 749: xmlFree(value4);
! 750: } else
! 751: comp->steps[comp->nbStep].value4 = NULL;
! 752: if (value5 != NULL) {
! 753: comp->steps[comp->nbStep].value5 = (xmlChar *)
! 754: (void *)xmlDictLookup(comp->dict, value5, -1);
! 755: xmlFree(value5);
! 756: } else
! 757: comp->steps[comp->nbStep].value5 = NULL;
! 758: } else {
! 759: comp->steps[comp->nbStep].value4 = value4;
! 760: comp->steps[comp->nbStep].value5 = value5;
! 761: }
! 762: comp->steps[comp->nbStep].cache = NULL;
! 763: return(comp->nbStep++);
! 764: }
! 765:
! 766: /**
! 767: * xmlXPathCompSwap:
! 768: * @comp: the compiled expression
! 769: * @op: operation index
! 770: *
! 771: * Swaps 2 operations in the compiled expression
! 772: */
! 773: static void
! 774: xmlXPathCompSwap(xmlXPathStepOpPtr op) {
! 775: int tmp;
! 776:
! 777: #ifndef LIBXML_THREAD_ENABLED
! 778: /*
! 779: * Since this manipulates possibly shared variables, this is
! 780: * disabled if one detects that the library is used in a multithreaded
! 781: * application
! 782: */
! 783: if (xmlXPathDisableOptimizer)
! 784: return;
! 785: #endif
! 786:
! 787: tmp = op->ch1;
! 788: op->ch1 = op->ch2;
! 789: op->ch2 = tmp;
! 790: }
! 791:
! 792: #define PUSH_FULL_EXPR(op, op1, op2, val, val2, val3, val4, val5) \
! 793: xmlXPathCompExprAdd(ctxt->comp, (op1), (op2), \
! 794: (op), (val), (val2), (val3), (val4), (val5))
! 795: #define PUSH_LONG_EXPR(op, val, val2, val3, val4, val5) \
! 796: xmlXPathCompExprAdd(ctxt->comp, ctxt->comp->last, -1, \
! 797: (op), (val), (val2), (val3), (val4), (val5))
! 798:
! 799: #define PUSH_LEAVE_EXPR(op, val, val2) \
! 800: xmlXPathCompExprAdd(ctxt->comp, -1, -1, (op), (val), (val2), 0 ,NULL ,NULL)
! 801:
! 802: #define PUSH_UNARY_EXPR(op, ch, val, val2) \
! 803: xmlXPathCompExprAdd(ctxt->comp, (ch), -1, (op), (val), (val2), 0 ,NULL ,NULL)
! 804:
! 805: #define PUSH_BINARY_EXPR(op, ch1, ch2, val, val2) \
! 806: xmlXPathCompExprAdd(ctxt->comp, (ch1), (ch2), (op), \
! 807: (val), (val2), 0 ,NULL ,NULL)
! 808:
! 809: /************************************************************************
! 810: * *
! 811: * XPath object cache structures *
! 812: * *
! 813: ************************************************************************/
! 814:
! 815: /* #define XP_DEFAULT_CACHE_ON */
! 816:
! 817: #define XP_HAS_CACHE(c) ((c != NULL) && ((c)->cache != NULL))
! 818:
! 819: typedef struct _xmlXPathContextCache xmlXPathContextCache;
! 820: typedef xmlXPathContextCache *xmlXPathContextCachePtr;
! 821: struct _xmlXPathContextCache {
! 822: xmlPointerListPtr nodesetObjs; /* contains xmlXPathObjectPtr */
! 823: xmlPointerListPtr stringObjs; /* contains xmlXPathObjectPtr */
! 824: xmlPointerListPtr booleanObjs; /* contains xmlXPathObjectPtr */
! 825: xmlPointerListPtr numberObjs; /* contains xmlXPathObjectPtr */
! 826: xmlPointerListPtr miscObjs; /* contains xmlXPathObjectPtr */
! 827: int maxNodeset;
! 828: int maxString;
! 829: int maxBoolean;
! 830: int maxNumber;
! 831: int maxMisc;
! 832: #ifdef XP_DEBUG_OBJ_USAGE
! 833: int dbgCachedAll;
! 834: int dbgCachedNodeset;
! 835: int dbgCachedString;
! 836: int dbgCachedBool;
! 837: int dbgCachedNumber;
! 838: int dbgCachedPoint;
! 839: int dbgCachedRange;
! 840: int dbgCachedLocset;
! 841: int dbgCachedUsers;
! 842: int dbgCachedXSLTTree;
! 843: int dbgCachedUndefined;
! 844:
! 845:
! 846: int dbgReusedAll;
! 847: int dbgReusedNodeset;
! 848: int dbgReusedString;
! 849: int dbgReusedBool;
! 850: int dbgReusedNumber;
! 851: int dbgReusedPoint;
! 852: int dbgReusedRange;
! 853: int dbgReusedLocset;
! 854: int dbgReusedUsers;
! 855: int dbgReusedXSLTTree;
! 856: int dbgReusedUndefined;
! 857:
! 858: #endif
! 859: };
! 860:
! 861: /************************************************************************
! 862: * *
! 863: * Debugging related functions *
! 864: * *
! 865: ************************************************************************/
! 866:
! 867: #define STRANGE \
! 868: xmlGenericError(xmlGenericErrorContext, \
! 869: "Internal error at %s:%d\n", \
! 870: __FILE__, __LINE__);
! 871:
! 872: #ifdef LIBXML_DEBUG_ENABLED
! 873: static void
! 874: xmlXPathDebugDumpNode(FILE *output, xmlNodePtr cur, int depth) {
! 875: int i;
! 876: char shift[100];
! 877:
! 878: for (i = 0;((i < depth) && (i < 25));i++)
! 879: shift[2 * i] = shift[2 * i + 1] = ' ';
! 880: shift[2 * i] = shift[2 * i + 1] = 0;
! 881: if (cur == NULL) {
! 882: fprintf(output, "%s", shift);
! 883: fprintf(output, "Node is NULL !\n");
! 884: return;
! 885:
! 886: }
! 887:
! 888: if ((cur->type == XML_DOCUMENT_NODE) ||
! 889: (cur->type == XML_HTML_DOCUMENT_NODE)) {
! 890: fprintf(output, "%s", shift);
! 891: fprintf(output, " /\n");
! 892: } else if (cur->type == XML_ATTRIBUTE_NODE)
! 893: xmlDebugDumpAttr(output, (xmlAttrPtr)cur, depth);
! 894: else
! 895: xmlDebugDumpOneNode(output, cur, depth);
! 896: }
! 897: static void
! 898: xmlXPathDebugDumpNodeList(FILE *output, xmlNodePtr cur, int depth) {
! 899: xmlNodePtr tmp;
! 900: int i;
! 901: char shift[100];
! 902:
! 903: for (i = 0;((i < depth) && (i < 25));i++)
! 904: shift[2 * i] = shift[2 * i + 1] = ' ';
! 905: shift[2 * i] = shift[2 * i + 1] = 0;
! 906: if (cur == NULL) {
! 907: fprintf(output, "%s", shift);
! 908: fprintf(output, "Node is NULL !\n");
! 909: return;
! 910:
! 911: }
! 912:
! 913: while (cur != NULL) {
! 914: tmp = cur;
! 915: cur = cur->next;
! 916: xmlDebugDumpOneNode(output, tmp, depth);
! 917: }
! 918: }
! 919:
! 920: static void
! 921: xmlXPathDebugDumpNodeSet(FILE *output, xmlNodeSetPtr cur, int depth) {
! 922: int i;
! 923: char shift[100];
! 924:
! 925: for (i = 0;((i < depth) && (i < 25));i++)
! 926: shift[2 * i] = shift[2 * i + 1] = ' ';
! 927: shift[2 * i] = shift[2 * i + 1] = 0;
! 928:
! 929: if (cur == NULL) {
! 930: fprintf(output, "%s", shift);
! 931: fprintf(output, "NodeSet is NULL !\n");
! 932: return;
! 933:
! 934: }
! 935:
! 936: if (cur != NULL) {
! 937: fprintf(output, "Set contains %d nodes:\n", cur->nodeNr);
! 938: for (i = 0;i < cur->nodeNr;i++) {
! 939: fprintf(output, "%s", shift);
! 940: fprintf(output, "%d", i + 1);
! 941: xmlXPathDebugDumpNode(output, cur->nodeTab[i], depth + 1);
! 942: }
! 943: }
! 944: }
! 945:
! 946: static void
! 947: xmlXPathDebugDumpValueTree(FILE *output, xmlNodeSetPtr cur, int depth) {
! 948: int i;
! 949: char shift[100];
! 950:
! 951: for (i = 0;((i < depth) && (i < 25));i++)
! 952: shift[2 * i] = shift[2 * i + 1] = ' ';
! 953: shift[2 * i] = shift[2 * i + 1] = 0;
! 954:
! 955: if ((cur == NULL) || (cur->nodeNr == 0) || (cur->nodeTab[0] == NULL)) {
! 956: fprintf(output, "%s", shift);
! 957: fprintf(output, "Value Tree is NULL !\n");
! 958: return;
! 959:
! 960: }
! 961:
! 962: fprintf(output, "%s", shift);
! 963: fprintf(output, "%d", i + 1);
! 964: xmlXPathDebugDumpNodeList(output, cur->nodeTab[0]->children, depth + 1);
! 965: }
! 966: #if defined(LIBXML_XPTR_ENABLED)
! 967: static void
! 968: xmlXPathDebugDumpLocationSet(FILE *output, xmlLocationSetPtr cur, int depth) {
! 969: int i;
! 970: char shift[100];
! 971:
! 972: for (i = 0;((i < depth) && (i < 25));i++)
! 973: shift[2 * i] = shift[2 * i + 1] = ' ';
! 974: shift[2 * i] = shift[2 * i + 1] = 0;
! 975:
! 976: if (cur == NULL) {
! 977: fprintf(output, "%s", shift);
! 978: fprintf(output, "LocationSet is NULL !\n");
! 979: return;
! 980:
! 981: }
! 982:
! 983: for (i = 0;i < cur->locNr;i++) {
! 984: fprintf(output, "%s", shift);
! 985: fprintf(output, "%d : ", i + 1);
! 986: xmlXPathDebugDumpObject(output, cur->locTab[i], depth + 1);
! 987: }
! 988: }
! 989: #endif /* LIBXML_XPTR_ENABLED */
! 990:
! 991: /**
! 992: * xmlXPathDebugDumpObject:
! 993: * @output: the FILE * to dump the output
! 994: * @cur: the object to inspect
! 995: * @depth: indentation level
! 996: *
! 997: * Dump the content of the object for debugging purposes
! 998: */
! 999: void
! 1000: xmlXPathDebugDumpObject(FILE *output, xmlXPathObjectPtr cur, int depth) {
! 1001: int i;
! 1002: char shift[100];
! 1003:
! 1004: if (output == NULL) return;
! 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:
! 1011: fprintf(output, "%s", shift);
! 1012:
! 1013: if (cur == NULL) {
! 1014: fprintf(output, "Object is empty (NULL)\n");
! 1015: return;
! 1016: }
! 1017: switch(cur->type) {
! 1018: case XPATH_UNDEFINED:
! 1019: fprintf(output, "Object is uninitialized\n");
! 1020: break;
! 1021: case XPATH_NODESET:
! 1022: fprintf(output, "Object is a Node Set :\n");
! 1023: xmlXPathDebugDumpNodeSet(output, cur->nodesetval, depth);
! 1024: break;
! 1025: case XPATH_XSLT_TREE:
! 1026: fprintf(output, "Object is an XSLT value tree :\n");
! 1027: xmlXPathDebugDumpValueTree(output, cur->nodesetval, depth);
! 1028: break;
! 1029: case XPATH_BOOLEAN:
! 1030: fprintf(output, "Object is a Boolean : ");
! 1031: if (cur->boolval) fprintf(output, "true\n");
! 1032: else fprintf(output, "false\n");
! 1033: break;
! 1034: case XPATH_NUMBER:
! 1035: switch (xmlXPathIsInf(cur->floatval)) {
! 1036: case 1:
! 1037: fprintf(output, "Object is a number : Infinity\n");
! 1038: break;
! 1039: case -1:
! 1040: fprintf(output, "Object is a number : -Infinity\n");
! 1041: break;
! 1042: default:
! 1043: if (xmlXPathIsNaN(cur->floatval)) {
! 1044: fprintf(output, "Object is a number : NaN\n");
! 1045: } else if (cur->floatval == 0 && xmlXPathGetSign(cur->floatval) != 0) {
! 1046: fprintf(output, "Object is a number : 0\n");
! 1047: } else {
! 1048: fprintf(output, "Object is a number : %0g\n", cur->floatval);
! 1049: }
! 1050: }
! 1051: break;
! 1052: case XPATH_STRING:
! 1053: fprintf(output, "Object is a string : ");
! 1054: xmlDebugDumpString(output, cur->stringval);
! 1055: fprintf(output, "\n");
! 1056: break;
! 1057: case XPATH_POINT:
! 1058: fprintf(output, "Object is a point : index %d in node", cur->index);
! 1059: xmlXPathDebugDumpNode(output, (xmlNodePtr) cur->user, depth + 1);
! 1060: fprintf(output, "\n");
! 1061: break;
! 1062: case XPATH_RANGE:
! 1063: if ((cur->user2 == NULL) ||
! 1064: ((cur->user2 == cur->user) && (cur->index == cur->index2))) {
! 1065: fprintf(output, "Object is a collapsed range :\n");
! 1066: fprintf(output, "%s", shift);
! 1067: if (cur->index >= 0)
! 1068: fprintf(output, "index %d in ", cur->index);
! 1069: fprintf(output, "node\n");
! 1070: xmlXPathDebugDumpNode(output, (xmlNodePtr) cur->user,
! 1071: depth + 1);
! 1072: } else {
! 1073: fprintf(output, "Object is a range :\n");
! 1074: fprintf(output, "%s", shift);
! 1075: fprintf(output, "From ");
! 1076: if (cur->index >= 0)
! 1077: fprintf(output, "index %d in ", cur->index);
! 1078: fprintf(output, "node\n");
! 1079: xmlXPathDebugDumpNode(output, (xmlNodePtr) cur->user,
! 1080: depth + 1);
! 1081: fprintf(output, "%s", shift);
! 1082: fprintf(output, "To ");
! 1083: if (cur->index2 >= 0)
! 1084: fprintf(output, "index %d in ", cur->index2);
! 1085: fprintf(output, "node\n");
! 1086: xmlXPathDebugDumpNode(output, (xmlNodePtr) cur->user2,
! 1087: depth + 1);
! 1088: fprintf(output, "\n");
! 1089: }
! 1090: break;
! 1091: case XPATH_LOCATIONSET:
! 1092: #if defined(LIBXML_XPTR_ENABLED)
! 1093: fprintf(output, "Object is a Location Set:\n");
! 1094: xmlXPathDebugDumpLocationSet(output,
! 1095: (xmlLocationSetPtr) cur->user, depth);
! 1096: #endif
! 1097: break;
! 1098: case XPATH_USERS:
! 1099: fprintf(output, "Object is user defined\n");
! 1100: break;
! 1101: }
! 1102: }
! 1103:
! 1104: static void
! 1105: xmlXPathDebugDumpStepOp(FILE *output, xmlXPathCompExprPtr comp,
! 1106: xmlXPathStepOpPtr op, int depth) {
! 1107: int i;
! 1108: char shift[100];
! 1109:
! 1110: for (i = 0;((i < depth) && (i < 25));i++)
! 1111: shift[2 * i] = shift[2 * i + 1] = ' ';
! 1112: shift[2 * i] = shift[2 * i + 1] = 0;
! 1113:
! 1114: fprintf(output, "%s", shift);
! 1115: if (op == NULL) {
! 1116: fprintf(output, "Step is NULL\n");
! 1117: return;
! 1118: }
! 1119: switch (op->op) {
! 1120: case XPATH_OP_END:
! 1121: fprintf(output, "END"); break;
! 1122: case XPATH_OP_AND:
! 1123: fprintf(output, "AND"); break;
! 1124: case XPATH_OP_OR:
! 1125: fprintf(output, "OR"); break;
! 1126: case XPATH_OP_EQUAL:
! 1127: if (op->value)
! 1128: fprintf(output, "EQUAL =");
! 1129: else
! 1130: fprintf(output, "EQUAL !=");
! 1131: break;
! 1132: case XPATH_OP_CMP:
! 1133: if (op->value)
! 1134: fprintf(output, "CMP <");
! 1135: else
! 1136: fprintf(output, "CMP >");
! 1137: if (!op->value2)
! 1138: fprintf(output, "=");
! 1139: break;
! 1140: case XPATH_OP_PLUS:
! 1141: if (op->value == 0)
! 1142: fprintf(output, "PLUS -");
! 1143: else if (op->value == 1)
! 1144: fprintf(output, "PLUS +");
! 1145: else if (op->value == 2)
! 1146: fprintf(output, "PLUS unary -");
! 1147: else if (op->value == 3)
! 1148: fprintf(output, "PLUS unary - -");
! 1149: break;
! 1150: case XPATH_OP_MULT:
! 1151: if (op->value == 0)
! 1152: fprintf(output, "MULT *");
! 1153: else if (op->value == 1)
! 1154: fprintf(output, "MULT div");
! 1155: else
! 1156: fprintf(output, "MULT mod");
! 1157: break;
! 1158: case XPATH_OP_UNION:
! 1159: fprintf(output, "UNION"); break;
! 1160: case XPATH_OP_ROOT:
! 1161: fprintf(output, "ROOT"); break;
! 1162: case XPATH_OP_NODE:
! 1163: fprintf(output, "NODE"); break;
! 1164: case XPATH_OP_RESET:
! 1165: fprintf(output, "RESET"); break;
! 1166: case XPATH_OP_SORT:
! 1167: fprintf(output, "SORT"); break;
! 1168: case XPATH_OP_COLLECT: {
! 1169: xmlXPathAxisVal axis = (xmlXPathAxisVal)op->value;
! 1170: xmlXPathTestVal test = (xmlXPathTestVal)op->value2;
! 1171: xmlXPathTypeVal type = (xmlXPathTypeVal)op->value3;
! 1172: const xmlChar *prefix = op->value4;
! 1173: const xmlChar *name = op->value5;
! 1174:
! 1175: fprintf(output, "COLLECT ");
! 1176: switch (axis) {
! 1177: case AXIS_ANCESTOR:
! 1178: fprintf(output, " 'ancestors' "); break;
! 1179: case AXIS_ANCESTOR_OR_SELF:
! 1180: fprintf(output, " 'ancestors-or-self' "); break;
! 1181: case AXIS_ATTRIBUTE:
! 1182: fprintf(output, " 'attributes' "); break;
! 1183: case AXIS_CHILD:
! 1184: fprintf(output, " 'child' "); break;
! 1185: case AXIS_DESCENDANT:
! 1186: fprintf(output, " 'descendant' "); break;
! 1187: case AXIS_DESCENDANT_OR_SELF:
! 1188: fprintf(output, " 'descendant-or-self' "); break;
! 1189: case AXIS_FOLLOWING:
! 1190: fprintf(output, " 'following' "); break;
! 1191: case AXIS_FOLLOWING_SIBLING:
! 1192: fprintf(output, " 'following-siblings' "); break;
! 1193: case AXIS_NAMESPACE:
! 1194: fprintf(output, " 'namespace' "); break;
! 1195: case AXIS_PARENT:
! 1196: fprintf(output, " 'parent' "); break;
! 1197: case AXIS_PRECEDING:
! 1198: fprintf(output, " 'preceding' "); break;
! 1199: case AXIS_PRECEDING_SIBLING:
! 1200: fprintf(output, " 'preceding-sibling' "); break;
! 1201: case AXIS_SELF:
! 1202: fprintf(output, " 'self' "); break;
! 1203: }
! 1204: switch (test) {
! 1205: case NODE_TEST_NONE:
! 1206: fprintf(output, "'none' "); break;
! 1207: case NODE_TEST_TYPE:
! 1208: fprintf(output, "'type' "); break;
! 1209: case NODE_TEST_PI:
! 1210: fprintf(output, "'PI' "); break;
! 1211: case NODE_TEST_ALL:
! 1212: fprintf(output, "'all' "); break;
! 1213: case NODE_TEST_NS:
! 1214: fprintf(output, "'namespace' "); break;
! 1215: case NODE_TEST_NAME:
! 1216: fprintf(output, "'name' "); break;
! 1217: }
! 1218: switch (type) {
! 1219: case NODE_TYPE_NODE:
! 1220: fprintf(output, "'node' "); break;
! 1221: case NODE_TYPE_COMMENT:
! 1222: fprintf(output, "'comment' "); break;
! 1223: case NODE_TYPE_TEXT:
! 1224: fprintf(output, "'text' "); break;
! 1225: case NODE_TYPE_PI:
! 1226: fprintf(output, "'PI' "); break;
! 1227: }
! 1228: if (prefix != NULL)
! 1229: fprintf(output, "%s:", prefix);
! 1230: if (name != NULL)
! 1231: fprintf(output, "%s", (const char *) name);
! 1232: break;
! 1233:
! 1234: }
! 1235: case XPATH_OP_VALUE: {
! 1236: xmlXPathObjectPtr object = (xmlXPathObjectPtr) op->value4;
! 1237:
! 1238: fprintf(output, "ELEM ");
! 1239: xmlXPathDebugDumpObject(output, object, 0);
! 1240: goto finish;
! 1241: }
! 1242: case XPATH_OP_VARIABLE: {
! 1243: const xmlChar *prefix = op->value5;
! 1244: const xmlChar *name = op->value4;
! 1245:
! 1246: if (prefix != NULL)
! 1247: fprintf(output, "VARIABLE %s:%s", prefix, name);
! 1248: else
! 1249: fprintf(output, "VARIABLE %s", name);
! 1250: break;
! 1251: }
! 1252: case XPATH_OP_FUNCTION: {
! 1253: int nbargs = op->value;
! 1254: const xmlChar *prefix = op->value5;
! 1255: const xmlChar *name = op->value4;
! 1256:
! 1257: if (prefix != NULL)
! 1258: fprintf(output, "FUNCTION %s:%s(%d args)",
! 1259: prefix, name, nbargs);
! 1260: else
! 1261: fprintf(output, "FUNCTION %s(%d args)", name, nbargs);
! 1262: break;
! 1263: }
! 1264: case XPATH_OP_ARG: fprintf(output, "ARG"); break;
! 1265: case XPATH_OP_PREDICATE: fprintf(output, "PREDICATE"); break;
! 1266: case XPATH_OP_FILTER: fprintf(output, "FILTER"); break;
! 1267: #ifdef LIBXML_XPTR_ENABLED
! 1268: case XPATH_OP_RANGETO: fprintf(output, "RANGETO"); break;
! 1269: #endif
! 1270: default:
! 1271: fprintf(output, "UNKNOWN %d\n", op->op); return;
! 1272: }
! 1273: fprintf(output, "\n");
! 1274: finish:
! 1275: if (op->ch1 >= 0)
! 1276: xmlXPathDebugDumpStepOp(output, comp, &comp->steps[op->ch1], depth + 1);
! 1277: if (op->ch2 >= 0)
! 1278: xmlXPathDebugDumpStepOp(output, comp, &comp->steps[op->ch2], depth + 1);
! 1279: }
! 1280:
! 1281: /**
! 1282: * xmlXPathDebugDumpCompExpr:
! 1283: * @output: the FILE * for the output
! 1284: * @comp: the precompiled XPath expression
! 1285: * @depth: the indentation level.
! 1286: *
! 1287: * Dumps the tree of the compiled XPath expression.
! 1288: */
! 1289: void
! 1290: xmlXPathDebugDumpCompExpr(FILE *output, xmlXPathCompExprPtr comp,
! 1291: int depth) {
! 1292: int i;
! 1293: char shift[100];
! 1294:
! 1295: if ((output == NULL) || (comp == NULL)) return;
! 1296:
! 1297: for (i = 0;((i < depth) && (i < 25));i++)
! 1298: shift[2 * i] = shift[2 * i + 1] = ' ';
! 1299: shift[2 * i] = shift[2 * i + 1] = 0;
! 1300:
! 1301: fprintf(output, "%s", shift);
! 1302:
! 1303: fprintf(output, "Compiled Expression : %d elements\n",
! 1304: comp->nbStep);
! 1305: i = comp->last;
! 1306: xmlXPathDebugDumpStepOp(output, comp, &comp->steps[i], depth + 1);
! 1307: }
! 1308:
! 1309: #ifdef XP_DEBUG_OBJ_USAGE
! 1310:
! 1311: /*
! 1312: * XPath object usage related debugging variables.
! 1313: */
! 1314: static int xmlXPathDebugObjCounterUndefined = 0;
! 1315: static int xmlXPathDebugObjCounterNodeset = 0;
! 1316: static int xmlXPathDebugObjCounterBool = 0;
! 1317: static int xmlXPathDebugObjCounterNumber = 0;
! 1318: static int xmlXPathDebugObjCounterString = 0;
! 1319: static int xmlXPathDebugObjCounterPoint = 0;
! 1320: static int xmlXPathDebugObjCounterRange = 0;
! 1321: static int xmlXPathDebugObjCounterLocset = 0;
! 1322: static int xmlXPathDebugObjCounterUsers = 0;
! 1323: static int xmlXPathDebugObjCounterXSLTTree = 0;
! 1324: static int xmlXPathDebugObjCounterAll = 0;
! 1325:
! 1326: static int xmlXPathDebugObjTotalUndefined = 0;
! 1327: static int xmlXPathDebugObjTotalNodeset = 0;
! 1328: static int xmlXPathDebugObjTotalBool = 0;
! 1329: static int xmlXPathDebugObjTotalNumber = 0;
! 1330: static int xmlXPathDebugObjTotalString = 0;
! 1331: static int xmlXPathDebugObjTotalPoint = 0;
! 1332: static int xmlXPathDebugObjTotalRange = 0;
! 1333: static int xmlXPathDebugObjTotalLocset = 0;
! 1334: static int xmlXPathDebugObjTotalUsers = 0;
! 1335: static int xmlXPathDebugObjTotalXSLTTree = 0;
! 1336: static int xmlXPathDebugObjTotalAll = 0;
! 1337:
! 1338: static int xmlXPathDebugObjMaxUndefined = 0;
! 1339: static int xmlXPathDebugObjMaxNodeset = 0;
! 1340: static int xmlXPathDebugObjMaxBool = 0;
! 1341: static int xmlXPathDebugObjMaxNumber = 0;
! 1342: static int xmlXPathDebugObjMaxString = 0;
! 1343: static int xmlXPathDebugObjMaxPoint = 0;
! 1344: static int xmlXPathDebugObjMaxRange = 0;
! 1345: static int xmlXPathDebugObjMaxLocset = 0;
! 1346: static int xmlXPathDebugObjMaxUsers = 0;
! 1347: static int xmlXPathDebugObjMaxXSLTTree = 0;
! 1348: static int xmlXPathDebugObjMaxAll = 0;
! 1349:
! 1350: /* REVISIT TODO: Make this static when committing */
! 1351: static void
! 1352: xmlXPathDebugObjUsageReset(xmlXPathContextPtr ctxt)
! 1353: {
! 1354: if (ctxt != NULL) {
! 1355: if (ctxt->cache != NULL) {
! 1356: xmlXPathContextCachePtr cache =
! 1357: (xmlXPathContextCachePtr) ctxt->cache;
! 1358:
! 1359: cache->dbgCachedAll = 0;
! 1360: cache->dbgCachedNodeset = 0;
! 1361: cache->dbgCachedString = 0;
! 1362: cache->dbgCachedBool = 0;
! 1363: cache->dbgCachedNumber = 0;
! 1364: cache->dbgCachedPoint = 0;
! 1365: cache->dbgCachedRange = 0;
! 1366: cache->dbgCachedLocset = 0;
! 1367: cache->dbgCachedUsers = 0;
! 1368: cache->dbgCachedXSLTTree = 0;
! 1369: cache->dbgCachedUndefined = 0;
! 1370:
! 1371: cache->dbgReusedAll = 0;
! 1372: cache->dbgReusedNodeset = 0;
! 1373: cache->dbgReusedString = 0;
! 1374: cache->dbgReusedBool = 0;
! 1375: cache->dbgReusedNumber = 0;
! 1376: cache->dbgReusedPoint = 0;
! 1377: cache->dbgReusedRange = 0;
! 1378: cache->dbgReusedLocset = 0;
! 1379: cache->dbgReusedUsers = 0;
! 1380: cache->dbgReusedXSLTTree = 0;
! 1381: cache->dbgReusedUndefined = 0;
! 1382: }
! 1383: }
! 1384:
! 1385: xmlXPathDebugObjCounterUndefined = 0;
! 1386: xmlXPathDebugObjCounterNodeset = 0;
! 1387: xmlXPathDebugObjCounterBool = 0;
! 1388: xmlXPathDebugObjCounterNumber = 0;
! 1389: xmlXPathDebugObjCounterString = 0;
! 1390: xmlXPathDebugObjCounterPoint = 0;
! 1391: xmlXPathDebugObjCounterRange = 0;
! 1392: xmlXPathDebugObjCounterLocset = 0;
! 1393: xmlXPathDebugObjCounterUsers = 0;
! 1394: xmlXPathDebugObjCounterXSLTTree = 0;
! 1395: xmlXPathDebugObjCounterAll = 0;
! 1396:
! 1397: xmlXPathDebugObjTotalUndefined = 0;
! 1398: xmlXPathDebugObjTotalNodeset = 0;
! 1399: xmlXPathDebugObjTotalBool = 0;
! 1400: xmlXPathDebugObjTotalNumber = 0;
! 1401: xmlXPathDebugObjTotalString = 0;
! 1402: xmlXPathDebugObjTotalPoint = 0;
! 1403: xmlXPathDebugObjTotalRange = 0;
! 1404: xmlXPathDebugObjTotalLocset = 0;
! 1405: xmlXPathDebugObjTotalUsers = 0;
! 1406: xmlXPathDebugObjTotalXSLTTree = 0;
! 1407: xmlXPathDebugObjTotalAll = 0;
! 1408:
! 1409: xmlXPathDebugObjMaxUndefined = 0;
! 1410: xmlXPathDebugObjMaxNodeset = 0;
! 1411: xmlXPathDebugObjMaxBool = 0;
! 1412: xmlXPathDebugObjMaxNumber = 0;
! 1413: xmlXPathDebugObjMaxString = 0;
! 1414: xmlXPathDebugObjMaxPoint = 0;
! 1415: xmlXPathDebugObjMaxRange = 0;
! 1416: xmlXPathDebugObjMaxLocset = 0;
! 1417: xmlXPathDebugObjMaxUsers = 0;
! 1418: xmlXPathDebugObjMaxXSLTTree = 0;
! 1419: xmlXPathDebugObjMaxAll = 0;
! 1420:
! 1421: }
! 1422:
! 1423: static void
! 1424: xmlXPathDebugObjUsageRequested(xmlXPathContextPtr ctxt,
! 1425: xmlXPathObjectType objType)
! 1426: {
! 1427: int isCached = 0;
! 1428:
! 1429: if (ctxt != NULL) {
! 1430: if (ctxt->cache != NULL) {
! 1431: xmlXPathContextCachePtr cache =
! 1432: (xmlXPathContextCachePtr) ctxt->cache;
! 1433:
! 1434: isCached = 1;
! 1435:
! 1436: cache->dbgReusedAll++;
! 1437: switch (objType) {
! 1438: case XPATH_UNDEFINED:
! 1439: cache->dbgReusedUndefined++;
! 1440: break;
! 1441: case XPATH_NODESET:
! 1442: cache->dbgReusedNodeset++;
! 1443: break;
! 1444: case XPATH_BOOLEAN:
! 1445: cache->dbgReusedBool++;
! 1446: break;
! 1447: case XPATH_NUMBER:
! 1448: cache->dbgReusedNumber++;
! 1449: break;
! 1450: case XPATH_STRING:
! 1451: cache->dbgReusedString++;
! 1452: break;
! 1453: case XPATH_POINT:
! 1454: cache->dbgReusedPoint++;
! 1455: break;
! 1456: case XPATH_RANGE:
! 1457: cache->dbgReusedRange++;
! 1458: break;
! 1459: case XPATH_LOCATIONSET:
! 1460: cache->dbgReusedLocset++;
! 1461: break;
! 1462: case XPATH_USERS:
! 1463: cache->dbgReusedUsers++;
! 1464: break;
! 1465: case XPATH_XSLT_TREE:
! 1466: cache->dbgReusedXSLTTree++;
! 1467: break;
! 1468: default:
! 1469: break;
! 1470: }
! 1471: }
! 1472: }
! 1473:
! 1474: switch (objType) {
! 1475: case XPATH_UNDEFINED:
! 1476: if (! isCached)
! 1477: xmlXPathDebugObjTotalUndefined++;
! 1478: xmlXPathDebugObjCounterUndefined++;
! 1479: if (xmlXPathDebugObjCounterUndefined >
! 1480: xmlXPathDebugObjMaxUndefined)
! 1481: xmlXPathDebugObjMaxUndefined =
! 1482: xmlXPathDebugObjCounterUndefined;
! 1483: break;
! 1484: case XPATH_NODESET:
! 1485: if (! isCached)
! 1486: xmlXPathDebugObjTotalNodeset++;
! 1487: xmlXPathDebugObjCounterNodeset++;
! 1488: if (xmlXPathDebugObjCounterNodeset >
! 1489: xmlXPathDebugObjMaxNodeset)
! 1490: xmlXPathDebugObjMaxNodeset =
! 1491: xmlXPathDebugObjCounterNodeset;
! 1492: break;
! 1493: case XPATH_BOOLEAN:
! 1494: if (! isCached)
! 1495: xmlXPathDebugObjTotalBool++;
! 1496: xmlXPathDebugObjCounterBool++;
! 1497: if (xmlXPathDebugObjCounterBool >
! 1498: xmlXPathDebugObjMaxBool)
! 1499: xmlXPathDebugObjMaxBool =
! 1500: xmlXPathDebugObjCounterBool;
! 1501: break;
! 1502: case XPATH_NUMBER:
! 1503: if (! isCached)
! 1504: xmlXPathDebugObjTotalNumber++;
! 1505: xmlXPathDebugObjCounterNumber++;
! 1506: if (xmlXPathDebugObjCounterNumber >
! 1507: xmlXPathDebugObjMaxNumber)
! 1508: xmlXPathDebugObjMaxNumber =
! 1509: xmlXPathDebugObjCounterNumber;
! 1510: break;
! 1511: case XPATH_STRING:
! 1512: if (! isCached)
! 1513: xmlXPathDebugObjTotalString++;
! 1514: xmlXPathDebugObjCounterString++;
! 1515: if (xmlXPathDebugObjCounterString >
! 1516: xmlXPathDebugObjMaxString)
! 1517: xmlXPathDebugObjMaxString =
! 1518: xmlXPathDebugObjCounterString;
! 1519: break;
! 1520: case XPATH_POINT:
! 1521: if (! isCached)
! 1522: xmlXPathDebugObjTotalPoint++;
! 1523: xmlXPathDebugObjCounterPoint++;
! 1524: if (xmlXPathDebugObjCounterPoint >
! 1525: xmlXPathDebugObjMaxPoint)
! 1526: xmlXPathDebugObjMaxPoint =
! 1527: xmlXPathDebugObjCounterPoint;
! 1528: break;
! 1529: case XPATH_RANGE:
! 1530: if (! isCached)
! 1531: xmlXPathDebugObjTotalRange++;
! 1532: xmlXPathDebugObjCounterRange++;
! 1533: if (xmlXPathDebugObjCounterRange >
! 1534: xmlXPathDebugObjMaxRange)
! 1535: xmlXPathDebugObjMaxRange =
! 1536: xmlXPathDebugObjCounterRange;
! 1537: break;
! 1538: case XPATH_LOCATIONSET:
! 1539: if (! isCached)
! 1540: xmlXPathDebugObjTotalLocset++;
! 1541: xmlXPathDebugObjCounterLocset++;
! 1542: if (xmlXPathDebugObjCounterLocset >
! 1543: xmlXPathDebugObjMaxLocset)
! 1544: xmlXPathDebugObjMaxLocset =
! 1545: xmlXPathDebugObjCounterLocset;
! 1546: break;
! 1547: case XPATH_USERS:
! 1548: if (! isCached)
! 1549: xmlXPathDebugObjTotalUsers++;
! 1550: xmlXPathDebugObjCounterUsers++;
! 1551: if (xmlXPathDebugObjCounterUsers >
! 1552: xmlXPathDebugObjMaxUsers)
! 1553: xmlXPathDebugObjMaxUsers =
! 1554: xmlXPathDebugObjCounterUsers;
! 1555: break;
! 1556: case XPATH_XSLT_TREE:
! 1557: if (! isCached)
! 1558: xmlXPathDebugObjTotalXSLTTree++;
! 1559: xmlXPathDebugObjCounterXSLTTree++;
! 1560: if (xmlXPathDebugObjCounterXSLTTree >
! 1561: xmlXPathDebugObjMaxXSLTTree)
! 1562: xmlXPathDebugObjMaxXSLTTree =
! 1563: xmlXPathDebugObjCounterXSLTTree;
! 1564: break;
! 1565: default:
! 1566: break;
! 1567: }
! 1568: if (! isCached)
! 1569: xmlXPathDebugObjTotalAll++;
! 1570: xmlXPathDebugObjCounterAll++;
! 1571: if (xmlXPathDebugObjCounterAll >
! 1572: xmlXPathDebugObjMaxAll)
! 1573: xmlXPathDebugObjMaxAll =
! 1574: xmlXPathDebugObjCounterAll;
! 1575: }
! 1576:
! 1577: static void
! 1578: xmlXPathDebugObjUsageReleased(xmlXPathContextPtr ctxt,
! 1579: xmlXPathObjectType objType)
! 1580: {
! 1581: int isCached = 0;
! 1582:
! 1583: if (ctxt != NULL) {
! 1584: if (ctxt->cache != NULL) {
! 1585: xmlXPathContextCachePtr cache =
! 1586: (xmlXPathContextCachePtr) ctxt->cache;
! 1587:
! 1588: isCached = 1;
! 1589:
! 1590: cache->dbgCachedAll++;
! 1591: switch (objType) {
! 1592: case XPATH_UNDEFINED:
! 1593: cache->dbgCachedUndefined++;
! 1594: break;
! 1595: case XPATH_NODESET:
! 1596: cache->dbgCachedNodeset++;
! 1597: break;
! 1598: case XPATH_BOOLEAN:
! 1599: cache->dbgCachedBool++;
! 1600: break;
! 1601: case XPATH_NUMBER:
! 1602: cache->dbgCachedNumber++;
! 1603: break;
! 1604: case XPATH_STRING:
! 1605: cache->dbgCachedString++;
! 1606: break;
! 1607: case XPATH_POINT:
! 1608: cache->dbgCachedPoint++;
! 1609: break;
! 1610: case XPATH_RANGE:
! 1611: cache->dbgCachedRange++;
! 1612: break;
! 1613: case XPATH_LOCATIONSET:
! 1614: cache->dbgCachedLocset++;
! 1615: break;
! 1616: case XPATH_USERS:
! 1617: cache->dbgCachedUsers++;
! 1618: break;
! 1619: case XPATH_XSLT_TREE:
! 1620: cache->dbgCachedXSLTTree++;
! 1621: break;
! 1622: default:
! 1623: break;
! 1624: }
! 1625:
! 1626: }
! 1627: }
! 1628: switch (objType) {
! 1629: case XPATH_UNDEFINED:
! 1630: xmlXPathDebugObjCounterUndefined--;
! 1631: break;
! 1632: case XPATH_NODESET:
! 1633: xmlXPathDebugObjCounterNodeset--;
! 1634: break;
! 1635: case XPATH_BOOLEAN:
! 1636: xmlXPathDebugObjCounterBool--;
! 1637: break;
! 1638: case XPATH_NUMBER:
! 1639: xmlXPathDebugObjCounterNumber--;
! 1640: break;
! 1641: case XPATH_STRING:
! 1642: xmlXPathDebugObjCounterString--;
! 1643: break;
! 1644: case XPATH_POINT:
! 1645: xmlXPathDebugObjCounterPoint--;
! 1646: break;
! 1647: case XPATH_RANGE:
! 1648: xmlXPathDebugObjCounterRange--;
! 1649: break;
! 1650: case XPATH_LOCATIONSET:
! 1651: xmlXPathDebugObjCounterLocset--;
! 1652: break;
! 1653: case XPATH_USERS:
! 1654: xmlXPathDebugObjCounterUsers--;
! 1655: break;
! 1656: case XPATH_XSLT_TREE:
! 1657: xmlXPathDebugObjCounterXSLTTree--;
! 1658: break;
! 1659: default:
! 1660: break;
! 1661: }
! 1662: xmlXPathDebugObjCounterAll--;
! 1663: }
! 1664:
! 1665: /* REVISIT TODO: Make this static when committing */
! 1666: static void
! 1667: xmlXPathDebugObjUsageDisplay(xmlXPathContextPtr ctxt)
! 1668: {
! 1669: int reqAll, reqNodeset, reqString, reqBool, reqNumber,
! 1670: reqXSLTTree, reqUndefined;
! 1671: int caAll = 0, caNodeset = 0, caString = 0, caBool = 0,
! 1672: caNumber = 0, caXSLTTree = 0, caUndefined = 0;
! 1673: int reAll = 0, reNodeset = 0, reString = 0, reBool = 0,
! 1674: reNumber = 0, reXSLTTree = 0, reUndefined = 0;
! 1675: int leftObjs = xmlXPathDebugObjCounterAll;
! 1676:
! 1677: reqAll = xmlXPathDebugObjTotalAll;
! 1678: reqNodeset = xmlXPathDebugObjTotalNodeset;
! 1679: reqString = xmlXPathDebugObjTotalString;
! 1680: reqBool = xmlXPathDebugObjTotalBool;
! 1681: reqNumber = xmlXPathDebugObjTotalNumber;
! 1682: reqXSLTTree = xmlXPathDebugObjTotalXSLTTree;
! 1683: reqUndefined = xmlXPathDebugObjTotalUndefined;
! 1684:
! 1685: printf("# XPath object usage:\n");
! 1686:
! 1687: if (ctxt != NULL) {
! 1688: if (ctxt->cache != NULL) {
! 1689: xmlXPathContextCachePtr cache =
! 1690: (xmlXPathContextCachePtr) ctxt->cache;
! 1691:
! 1692: reAll = cache->dbgReusedAll;
! 1693: reqAll += reAll;
! 1694: reNodeset = cache->dbgReusedNodeset;
! 1695: reqNodeset += reNodeset;
! 1696: reString = cache->dbgReusedString;
! 1697: reqString += reString;
! 1698: reBool = cache->dbgReusedBool;
! 1699: reqBool += reBool;
! 1700: reNumber = cache->dbgReusedNumber;
! 1701: reqNumber += reNumber;
! 1702: reXSLTTree = cache->dbgReusedXSLTTree;
! 1703: reqXSLTTree += reXSLTTree;
! 1704: reUndefined = cache->dbgReusedUndefined;
! 1705: reqUndefined += reUndefined;
! 1706:
! 1707: caAll = cache->dbgCachedAll;
! 1708: caBool = cache->dbgCachedBool;
! 1709: caNodeset = cache->dbgCachedNodeset;
! 1710: caString = cache->dbgCachedString;
! 1711: caNumber = cache->dbgCachedNumber;
! 1712: caXSLTTree = cache->dbgCachedXSLTTree;
! 1713: caUndefined = cache->dbgCachedUndefined;
! 1714:
! 1715: if (cache->nodesetObjs)
! 1716: leftObjs -= cache->nodesetObjs->number;
! 1717: if (cache->stringObjs)
! 1718: leftObjs -= cache->stringObjs->number;
! 1719: if (cache->booleanObjs)
! 1720: leftObjs -= cache->booleanObjs->number;
! 1721: if (cache->numberObjs)
! 1722: leftObjs -= cache->numberObjs->number;
! 1723: if (cache->miscObjs)
! 1724: leftObjs -= cache->miscObjs->number;
! 1725: }
! 1726: }
! 1727:
! 1728: printf("# all\n");
! 1729: printf("# total : %d\n", reqAll);
! 1730: printf("# left : %d\n", leftObjs);
! 1731: printf("# created: %d\n", xmlXPathDebugObjTotalAll);
! 1732: printf("# reused : %d\n", reAll);
! 1733: printf("# max : %d\n", xmlXPathDebugObjMaxAll);
! 1734:
! 1735: printf("# node-sets\n");
! 1736: printf("# total : %d\n", reqNodeset);
! 1737: printf("# created: %d\n", xmlXPathDebugObjTotalNodeset);
! 1738: printf("# reused : %d\n", reNodeset);
! 1739: printf("# max : %d\n", xmlXPathDebugObjMaxNodeset);
! 1740:
! 1741: printf("# strings\n");
! 1742: printf("# total : %d\n", reqString);
! 1743: printf("# created: %d\n", xmlXPathDebugObjTotalString);
! 1744: printf("# reused : %d\n", reString);
! 1745: printf("# max : %d\n", xmlXPathDebugObjMaxString);
! 1746:
! 1747: printf("# booleans\n");
! 1748: printf("# total : %d\n", reqBool);
! 1749: printf("# created: %d\n", xmlXPathDebugObjTotalBool);
! 1750: printf("# reused : %d\n", reBool);
! 1751: printf("# max : %d\n", xmlXPathDebugObjMaxBool);
! 1752:
! 1753: printf("# numbers\n");
! 1754: printf("# total : %d\n", reqNumber);
! 1755: printf("# created: %d\n", xmlXPathDebugObjTotalNumber);
! 1756: printf("# reused : %d\n", reNumber);
! 1757: printf("# max : %d\n", xmlXPathDebugObjMaxNumber);
! 1758:
! 1759: printf("# XSLT result tree fragments\n");
! 1760: printf("# total : %d\n", reqXSLTTree);
! 1761: printf("# created: %d\n", xmlXPathDebugObjTotalXSLTTree);
! 1762: printf("# reused : %d\n", reXSLTTree);
! 1763: printf("# max : %d\n", xmlXPathDebugObjMaxXSLTTree);
! 1764:
! 1765: printf("# undefined\n");
! 1766: printf("# total : %d\n", reqUndefined);
! 1767: printf("# created: %d\n", xmlXPathDebugObjTotalUndefined);
! 1768: printf("# reused : %d\n", reUndefined);
! 1769: printf("# max : %d\n", xmlXPathDebugObjMaxUndefined);
! 1770:
! 1771: }
! 1772:
! 1773: #endif /* XP_DEBUG_OBJ_USAGE */
! 1774:
! 1775: #endif /* LIBXML_DEBUG_ENABLED */
! 1776:
! 1777: /************************************************************************
! 1778: * *
! 1779: * XPath object caching *
! 1780: * *
! 1781: ************************************************************************/
! 1782:
! 1783: /**
! 1784: * xmlXPathNewCache:
! 1785: *
! 1786: * Create a new object cache
! 1787: *
! 1788: * Returns the xmlXPathCache just allocated.
! 1789: */
! 1790: static xmlXPathContextCachePtr
! 1791: xmlXPathNewCache(void)
! 1792: {
! 1793: xmlXPathContextCachePtr ret;
! 1794:
! 1795: ret = (xmlXPathContextCachePtr) xmlMalloc(sizeof(xmlXPathContextCache));
! 1796: if (ret == NULL) {
! 1797: xmlXPathErrMemory(NULL, "creating object cache\n");
! 1798: return(NULL);
! 1799: }
! 1800: memset(ret, 0 , (size_t) sizeof(xmlXPathContextCache));
! 1801: ret->maxNodeset = 100;
! 1802: ret->maxString = 100;
! 1803: ret->maxBoolean = 100;
! 1804: ret->maxNumber = 100;
! 1805: ret->maxMisc = 100;
! 1806: return(ret);
! 1807: }
! 1808:
! 1809: static void
! 1810: xmlXPathCacheFreeObjectList(xmlPointerListPtr list)
! 1811: {
! 1812: int i;
! 1813: xmlXPathObjectPtr obj;
! 1814:
! 1815: if (list == NULL)
! 1816: return;
! 1817:
! 1818: for (i = 0; i < list->number; i++) {
! 1819: obj = list->items[i];
! 1820: /*
! 1821: * Note that it is already assured that we don't need to
! 1822: * look out for namespace nodes in the node-set.
! 1823: */
! 1824: if (obj->nodesetval != NULL) {
! 1825: if (obj->nodesetval->nodeTab != NULL)
! 1826: xmlFree(obj->nodesetval->nodeTab);
! 1827: xmlFree(obj->nodesetval);
! 1828: }
! 1829: xmlFree(obj);
! 1830: #ifdef XP_DEBUG_OBJ_USAGE
! 1831: xmlXPathDebugObjCounterAll--;
! 1832: #endif
! 1833: }
! 1834: xmlPointerListFree(list);
! 1835: }
! 1836:
! 1837: static void
! 1838: xmlXPathFreeCache(xmlXPathContextCachePtr cache)
! 1839: {
! 1840: if (cache == NULL)
! 1841: return;
! 1842: if (cache->nodesetObjs)
! 1843: xmlXPathCacheFreeObjectList(cache->nodesetObjs);
! 1844: if (cache->stringObjs)
! 1845: xmlXPathCacheFreeObjectList(cache->stringObjs);
! 1846: if (cache->booleanObjs)
! 1847: xmlXPathCacheFreeObjectList(cache->booleanObjs);
! 1848: if (cache->numberObjs)
! 1849: xmlXPathCacheFreeObjectList(cache->numberObjs);
! 1850: if (cache->miscObjs)
! 1851: xmlXPathCacheFreeObjectList(cache->miscObjs);
! 1852: xmlFree(cache);
! 1853: }
! 1854:
! 1855: /**
! 1856: * xmlXPathContextSetCache:
! 1857: *
! 1858: * @ctxt: the XPath context
! 1859: * @active: enables/disables (creates/frees) the cache
! 1860: * @value: a value with semantics dependant on @options
! 1861: * @options: options (currently only the value 0 is used)
! 1862: *
! 1863: * Creates/frees an object cache on the XPath context.
! 1864: * If activates XPath objects (xmlXPathObject) will be cached internally
! 1865: * to be reused.
! 1866: * @options:
! 1867: * 0: This will set the XPath object caching:
! 1868: * @value:
! 1869: * This will set the maximum number of XPath objects
! 1870: * to be cached per slot
! 1871: * There are 5 slots for: node-set, string, number, boolean, and
! 1872: * misc objects. Use <0 for the default number (100).
! 1873: * Other values for @options have currently no effect.
! 1874: *
! 1875: * Returns 0 if the setting succeeded, and -1 on API or internal errors.
! 1876: */
! 1877: int
! 1878: xmlXPathContextSetCache(xmlXPathContextPtr ctxt,
! 1879: int active,
! 1880: int value,
! 1881: int options)
! 1882: {
! 1883: if (ctxt == NULL)
! 1884: return(-1);
! 1885: if (active) {
! 1886: xmlXPathContextCachePtr cache;
! 1887:
! 1888: if (ctxt->cache == NULL) {
! 1889: ctxt->cache = xmlXPathNewCache();
! 1890: if (ctxt->cache == NULL)
! 1891: return(-1);
! 1892: }
! 1893: cache = (xmlXPathContextCachePtr) ctxt->cache;
! 1894: if (options == 0) {
! 1895: if (value < 0)
! 1896: value = 100;
! 1897: cache->maxNodeset = value;
! 1898: cache->maxString = value;
! 1899: cache->maxNumber = value;
! 1900: cache->maxBoolean = value;
! 1901: cache->maxMisc = value;
! 1902: }
! 1903: } else if (ctxt->cache != NULL) {
! 1904: xmlXPathFreeCache((xmlXPathContextCachePtr) ctxt->cache);
! 1905: ctxt->cache = NULL;
! 1906: }
! 1907: return(0);
! 1908: }
! 1909:
! 1910: /**
! 1911: * xmlXPathCacheWrapNodeSet:
! 1912: * @ctxt: the XPath context
! 1913: * @val: the NodePtr value
! 1914: *
! 1915: * This is the cached version of xmlXPathWrapNodeSet().
! 1916: * Wrap the Nodeset @val in a new xmlXPathObjectPtr
! 1917: *
! 1918: * Returns the created or reused object.
! 1919: */
! 1920: static xmlXPathObjectPtr
! 1921: xmlXPathCacheWrapNodeSet(xmlXPathContextPtr ctxt, xmlNodeSetPtr val)
! 1922: {
! 1923: if ((ctxt != NULL) && (ctxt->cache != NULL)) {
! 1924: xmlXPathContextCachePtr cache =
! 1925: (xmlXPathContextCachePtr) ctxt->cache;
! 1926:
! 1927: if ((cache->miscObjs != NULL) &&
! 1928: (cache->miscObjs->number != 0))
! 1929: {
! 1930: xmlXPathObjectPtr ret;
! 1931:
! 1932: ret = (xmlXPathObjectPtr)
! 1933: cache->miscObjs->items[--cache->miscObjs->number];
! 1934: ret->type = XPATH_NODESET;
! 1935: ret->nodesetval = val;
! 1936: #ifdef XP_DEBUG_OBJ_USAGE
! 1937: xmlXPathDebugObjUsageRequested(ctxt, XPATH_NODESET);
! 1938: #endif
! 1939: return(ret);
! 1940: }
! 1941: }
! 1942:
! 1943: return(xmlXPathWrapNodeSet(val));
! 1944:
! 1945: }
! 1946:
! 1947: /**
! 1948: * xmlXPathCacheWrapString:
! 1949: * @ctxt: the XPath context
! 1950: * @val: the xmlChar * value
! 1951: *
! 1952: * This is the cached version of xmlXPathWrapString().
! 1953: * Wraps the @val string into an XPath object.
! 1954: *
! 1955: * Returns the created or reused object.
! 1956: */
! 1957: static xmlXPathObjectPtr
! 1958: xmlXPathCacheWrapString(xmlXPathContextPtr ctxt, xmlChar *val)
! 1959: {
! 1960: if ((ctxt != NULL) && (ctxt->cache != NULL)) {
! 1961: xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache;
! 1962:
! 1963: if ((cache->stringObjs != NULL) &&
! 1964: (cache->stringObjs->number != 0))
! 1965: {
! 1966:
! 1967: xmlXPathObjectPtr ret;
! 1968:
! 1969: ret = (xmlXPathObjectPtr)
! 1970: cache->stringObjs->items[--cache->stringObjs->number];
! 1971: ret->type = XPATH_STRING;
! 1972: ret->stringval = val;
! 1973: #ifdef XP_DEBUG_OBJ_USAGE
! 1974: xmlXPathDebugObjUsageRequested(ctxt, XPATH_STRING);
! 1975: #endif
! 1976: return(ret);
! 1977: } else if ((cache->miscObjs != NULL) &&
! 1978: (cache->miscObjs->number != 0))
! 1979: {
! 1980: xmlXPathObjectPtr ret;
! 1981: /*
! 1982: * Fallback to misc-cache.
! 1983: */
! 1984: ret = (xmlXPathObjectPtr)
! 1985: cache->miscObjs->items[--cache->miscObjs->number];
! 1986:
! 1987: ret->type = XPATH_STRING;
! 1988: ret->stringval = val;
! 1989: #ifdef XP_DEBUG_OBJ_USAGE
! 1990: xmlXPathDebugObjUsageRequested(ctxt, XPATH_STRING);
! 1991: #endif
! 1992: return(ret);
! 1993: }
! 1994: }
! 1995: return(xmlXPathWrapString(val));
! 1996: }
! 1997:
! 1998: /**
! 1999: * xmlXPathCacheNewNodeSet:
! 2000: * @ctxt: the XPath context
! 2001: * @val: the NodePtr value
! 2002: *
! 2003: * This is the cached version of xmlXPathNewNodeSet().
! 2004: * Acquire an xmlXPathObjectPtr of type NodeSet and initialize
! 2005: * it with the single Node @val
! 2006: *
! 2007: * Returns the created or reused object.
! 2008: */
! 2009: static xmlXPathObjectPtr
! 2010: xmlXPathCacheNewNodeSet(xmlXPathContextPtr ctxt, xmlNodePtr val)
! 2011: {
! 2012: if ((ctxt != NULL) && (ctxt->cache)) {
! 2013: xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache;
! 2014:
! 2015: if ((cache->nodesetObjs != NULL) &&
! 2016: (cache->nodesetObjs->number != 0))
! 2017: {
! 2018: xmlXPathObjectPtr ret;
! 2019: /*
! 2020: * Use the nodset-cache.
! 2021: */
! 2022: ret = (xmlXPathObjectPtr)
! 2023: cache->nodesetObjs->items[--cache->nodesetObjs->number];
! 2024: ret->type = XPATH_NODESET;
! 2025: ret->boolval = 0;
! 2026: if (val) {
! 2027: if ((ret->nodesetval->nodeMax == 0) ||
! 2028: (val->type == XML_NAMESPACE_DECL))
! 2029: {
! 2030: xmlXPathNodeSetAddUnique(ret->nodesetval, val);
! 2031: } else {
! 2032: ret->nodesetval->nodeTab[0] = val;
! 2033: ret->nodesetval->nodeNr = 1;
! 2034: }
! 2035: }
! 2036: #ifdef XP_DEBUG_OBJ_USAGE
! 2037: xmlXPathDebugObjUsageRequested(ctxt, XPATH_NODESET);
! 2038: #endif
! 2039: return(ret);
! 2040: } else if ((cache->miscObjs != NULL) &&
! 2041: (cache->miscObjs->number != 0))
! 2042: {
! 2043: xmlXPathObjectPtr ret;
! 2044: /*
! 2045: * Fallback to misc-cache.
! 2046: */
! 2047:
! 2048: ret = (xmlXPathObjectPtr)
! 2049: cache->miscObjs->items[--cache->miscObjs->number];
! 2050:
! 2051: ret->type = XPATH_NODESET;
! 2052: ret->boolval = 0;
! 2053: ret->nodesetval = xmlXPathNodeSetCreate(val);
! 2054: #ifdef XP_DEBUG_OBJ_USAGE
! 2055: xmlXPathDebugObjUsageRequested(ctxt, XPATH_NODESET);
! 2056: #endif
! 2057: return(ret);
! 2058: }
! 2059: }
! 2060: return(xmlXPathNewNodeSet(val));
! 2061: }
! 2062:
! 2063: /**
! 2064: * xmlXPathCacheNewCString:
! 2065: * @ctxt: the XPath context
! 2066: * @val: the char * value
! 2067: *
! 2068: * This is the cached version of xmlXPathNewCString().
! 2069: * Acquire an xmlXPathObjectPtr of type string and of value @val
! 2070: *
! 2071: * Returns the created or reused object.
! 2072: */
! 2073: static xmlXPathObjectPtr
! 2074: xmlXPathCacheNewCString(xmlXPathContextPtr ctxt, const char *val)
! 2075: {
! 2076: if ((ctxt != NULL) && (ctxt->cache)) {
! 2077: xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache;
! 2078:
! 2079: if ((cache->stringObjs != NULL) &&
! 2080: (cache->stringObjs->number != 0))
! 2081: {
! 2082: xmlXPathObjectPtr ret;
! 2083:
! 2084: ret = (xmlXPathObjectPtr)
! 2085: cache->stringObjs->items[--cache->stringObjs->number];
! 2086:
! 2087: ret->type = XPATH_STRING;
! 2088: ret->stringval = xmlStrdup(BAD_CAST val);
! 2089: #ifdef XP_DEBUG_OBJ_USAGE
! 2090: xmlXPathDebugObjUsageRequested(ctxt, XPATH_STRING);
! 2091: #endif
! 2092: return(ret);
! 2093: } else if ((cache->miscObjs != NULL) &&
! 2094: (cache->miscObjs->number != 0))
! 2095: {
! 2096: xmlXPathObjectPtr ret;
! 2097:
! 2098: ret = (xmlXPathObjectPtr)
! 2099: cache->miscObjs->items[--cache->miscObjs->number];
! 2100:
! 2101: ret->type = XPATH_STRING;
! 2102: ret->stringval = xmlStrdup(BAD_CAST val);
! 2103: #ifdef XP_DEBUG_OBJ_USAGE
! 2104: xmlXPathDebugObjUsageRequested(ctxt, XPATH_STRING);
! 2105: #endif
! 2106: return(ret);
! 2107: }
! 2108: }
! 2109: return(xmlXPathNewCString(val));
! 2110: }
! 2111:
! 2112: /**
! 2113: * xmlXPathCacheNewString:
! 2114: * @ctxt: the XPath context
! 2115: * @val: the xmlChar * value
! 2116: *
! 2117: * This is the cached version of xmlXPathNewString().
! 2118: * Acquire an xmlXPathObjectPtr of type string and of value @val
! 2119: *
! 2120: * Returns the created or reused object.
! 2121: */
! 2122: static xmlXPathObjectPtr
! 2123: xmlXPathCacheNewString(xmlXPathContextPtr ctxt, const xmlChar *val)
! 2124: {
! 2125: if ((ctxt != NULL) && (ctxt->cache)) {
! 2126: xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache;
! 2127:
! 2128: if ((cache->stringObjs != NULL) &&
! 2129: (cache->stringObjs->number != 0))
! 2130: {
! 2131: xmlXPathObjectPtr ret;
! 2132:
! 2133: ret = (xmlXPathObjectPtr)
! 2134: cache->stringObjs->items[--cache->stringObjs->number];
! 2135: ret->type = XPATH_STRING;
! 2136: if (val != NULL)
! 2137: ret->stringval = xmlStrdup(val);
! 2138: else
! 2139: ret->stringval = xmlStrdup((const xmlChar *)"");
! 2140: #ifdef XP_DEBUG_OBJ_USAGE
! 2141: xmlXPathDebugObjUsageRequested(ctxt, XPATH_STRING);
! 2142: #endif
! 2143: return(ret);
! 2144: } else if ((cache->miscObjs != NULL) &&
! 2145: (cache->miscObjs->number != 0))
! 2146: {
! 2147: xmlXPathObjectPtr ret;
! 2148:
! 2149: ret = (xmlXPathObjectPtr)
! 2150: cache->miscObjs->items[--cache->miscObjs->number];
! 2151:
! 2152: ret->type = XPATH_STRING;
! 2153: if (val != NULL)
! 2154: ret->stringval = xmlStrdup(val);
! 2155: else
! 2156: ret->stringval = xmlStrdup((const xmlChar *)"");
! 2157: #ifdef XP_DEBUG_OBJ_USAGE
! 2158: xmlXPathDebugObjUsageRequested(ctxt, XPATH_STRING);
! 2159: #endif
! 2160: return(ret);
! 2161: }
! 2162: }
! 2163: return(xmlXPathNewString(val));
! 2164: }
! 2165:
! 2166: /**
! 2167: * xmlXPathCacheNewBoolean:
! 2168: * @ctxt: the XPath context
! 2169: * @val: the boolean value
! 2170: *
! 2171: * This is the cached version of xmlXPathNewBoolean().
! 2172: * Acquires an xmlXPathObjectPtr of type boolean and of value @val
! 2173: *
! 2174: * Returns the created or reused object.
! 2175: */
! 2176: static xmlXPathObjectPtr
! 2177: xmlXPathCacheNewBoolean(xmlXPathContextPtr ctxt, int val)
! 2178: {
! 2179: if ((ctxt != NULL) && (ctxt->cache)) {
! 2180: xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache;
! 2181:
! 2182: if ((cache->booleanObjs != NULL) &&
! 2183: (cache->booleanObjs->number != 0))
! 2184: {
! 2185: xmlXPathObjectPtr ret;
! 2186:
! 2187: ret = (xmlXPathObjectPtr)
! 2188: cache->booleanObjs->items[--cache->booleanObjs->number];
! 2189: ret->type = XPATH_BOOLEAN;
! 2190: ret->boolval = (val != 0);
! 2191: #ifdef XP_DEBUG_OBJ_USAGE
! 2192: xmlXPathDebugObjUsageRequested(ctxt, XPATH_BOOLEAN);
! 2193: #endif
! 2194: return(ret);
! 2195: } else if ((cache->miscObjs != NULL) &&
! 2196: (cache->miscObjs->number != 0))
! 2197: {
! 2198: xmlXPathObjectPtr ret;
! 2199:
! 2200: ret = (xmlXPathObjectPtr)
! 2201: cache->miscObjs->items[--cache->miscObjs->number];
! 2202:
! 2203: ret->type = XPATH_BOOLEAN;
! 2204: ret->boolval = (val != 0);
! 2205: #ifdef XP_DEBUG_OBJ_USAGE
! 2206: xmlXPathDebugObjUsageRequested(ctxt, XPATH_BOOLEAN);
! 2207: #endif
! 2208: return(ret);
! 2209: }
! 2210: }
! 2211: return(xmlXPathNewBoolean(val));
! 2212: }
! 2213:
! 2214: /**
! 2215: * xmlXPathCacheNewFloat:
! 2216: * @ctxt: the XPath context
! 2217: * @val: the double value
! 2218: *
! 2219: * This is the cached version of xmlXPathNewFloat().
! 2220: * Acquires an xmlXPathObjectPtr of type double and of value @val
! 2221: *
! 2222: * Returns the created or reused object.
! 2223: */
! 2224: static xmlXPathObjectPtr
! 2225: xmlXPathCacheNewFloat(xmlXPathContextPtr ctxt, double val)
! 2226: {
! 2227: if ((ctxt != NULL) && (ctxt->cache)) {
! 2228: xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache;
! 2229:
! 2230: if ((cache->numberObjs != NULL) &&
! 2231: (cache->numberObjs->number != 0))
! 2232: {
! 2233: xmlXPathObjectPtr ret;
! 2234:
! 2235: ret = (xmlXPathObjectPtr)
! 2236: cache->numberObjs->items[--cache->numberObjs->number];
! 2237: ret->type = XPATH_NUMBER;
! 2238: ret->floatval = val;
! 2239: #ifdef XP_DEBUG_OBJ_USAGE
! 2240: xmlXPathDebugObjUsageRequested(ctxt, XPATH_NUMBER);
! 2241: #endif
! 2242: return(ret);
! 2243: } else if ((cache->miscObjs != NULL) &&
! 2244: (cache->miscObjs->number != 0))
! 2245: {
! 2246: xmlXPathObjectPtr ret;
! 2247:
! 2248: ret = (xmlXPathObjectPtr)
! 2249: cache->miscObjs->items[--cache->miscObjs->number];
! 2250:
! 2251: ret->type = XPATH_NUMBER;
! 2252: ret->floatval = val;
! 2253: #ifdef XP_DEBUG_OBJ_USAGE
! 2254: xmlXPathDebugObjUsageRequested(ctxt, XPATH_NUMBER);
! 2255: #endif
! 2256: return(ret);
! 2257: }
! 2258: }
! 2259: return(xmlXPathNewFloat(val));
! 2260: }
! 2261:
! 2262: /**
! 2263: * xmlXPathCacheConvertString:
! 2264: * @ctxt: the XPath context
! 2265: * @val: an XPath object
! 2266: *
! 2267: * This is the cached version of xmlXPathConvertString().
! 2268: * Converts an existing object to its string() equivalent
! 2269: *
! 2270: * Returns a created or reused object, the old one is freed (cached)
! 2271: * (or the operation is done directly on @val)
! 2272: */
! 2273:
! 2274: static xmlXPathObjectPtr
! 2275: xmlXPathCacheConvertString(xmlXPathContextPtr ctxt, xmlXPathObjectPtr val) {
! 2276: xmlChar *res = NULL;
! 2277:
! 2278: if (val == NULL)
! 2279: return(xmlXPathCacheNewCString(ctxt, ""));
! 2280:
! 2281: switch (val->type) {
! 2282: case XPATH_UNDEFINED:
! 2283: #ifdef DEBUG_EXPR
! 2284: xmlGenericError(xmlGenericErrorContext, "STRING: undefined\n");
! 2285: #endif
! 2286: break;
! 2287: case XPATH_NODESET:
! 2288: case XPATH_XSLT_TREE:
! 2289: res = xmlXPathCastNodeSetToString(val->nodesetval);
! 2290: break;
! 2291: case XPATH_STRING:
! 2292: return(val);
! 2293: case XPATH_BOOLEAN:
! 2294: res = xmlXPathCastBooleanToString(val->boolval);
! 2295: break;
! 2296: case XPATH_NUMBER:
! 2297: res = xmlXPathCastNumberToString(val->floatval);
! 2298: break;
! 2299: case XPATH_USERS:
! 2300: case XPATH_POINT:
! 2301: case XPATH_RANGE:
! 2302: case XPATH_LOCATIONSET:
! 2303: TODO;
! 2304: break;
! 2305: }
! 2306: xmlXPathReleaseObject(ctxt, val);
! 2307: if (res == NULL)
! 2308: return(xmlXPathCacheNewCString(ctxt, ""));
! 2309: return(xmlXPathCacheWrapString(ctxt, res));
! 2310: }
! 2311:
! 2312: /**
! 2313: * xmlXPathCacheObjectCopy:
! 2314: * @ctxt: the XPath context
! 2315: * @val: the original object
! 2316: *
! 2317: * This is the cached version of xmlXPathObjectCopy().
! 2318: * Acquire a copy of a given object
! 2319: *
! 2320: * Returns a created or reused created object.
! 2321: */
! 2322: static xmlXPathObjectPtr
! 2323: xmlXPathCacheObjectCopy(xmlXPathContextPtr ctxt, xmlXPathObjectPtr val)
! 2324: {
! 2325: if (val == NULL)
! 2326: return(NULL);
! 2327:
! 2328: if (XP_HAS_CACHE(ctxt)) {
! 2329: switch (val->type) {
! 2330: case XPATH_NODESET:
! 2331: return(xmlXPathCacheWrapNodeSet(ctxt,
! 2332: xmlXPathNodeSetMerge(NULL, val->nodesetval)));
! 2333: case XPATH_STRING:
! 2334: return(xmlXPathCacheNewString(ctxt, val->stringval));
! 2335: case XPATH_BOOLEAN:
! 2336: return(xmlXPathCacheNewBoolean(ctxt, val->boolval));
! 2337: case XPATH_NUMBER:
! 2338: return(xmlXPathCacheNewFloat(ctxt, val->floatval));
! 2339: default:
! 2340: break;
! 2341: }
! 2342: }
! 2343: return(xmlXPathObjectCopy(val));
! 2344: }
! 2345:
! 2346: /**
! 2347: * xmlXPathCacheConvertBoolean:
! 2348: * @ctxt: the XPath context
! 2349: * @val: an XPath object
! 2350: *
! 2351: * This is the cached version of xmlXPathConvertBoolean().
! 2352: * Converts an existing object to its boolean() equivalent
! 2353: *
! 2354: * Returns a created or reused object, the old one is freed (or the operation
! 2355: * is done directly on @val)
! 2356: */
! 2357: static xmlXPathObjectPtr
! 2358: xmlXPathCacheConvertBoolean(xmlXPathContextPtr ctxt, xmlXPathObjectPtr val) {
! 2359: xmlXPathObjectPtr ret;
! 2360:
! 2361: if (val == NULL)
! 2362: return(xmlXPathCacheNewBoolean(ctxt, 0));
! 2363: if (val->type == XPATH_BOOLEAN)
! 2364: return(val);
! 2365: ret = xmlXPathCacheNewBoolean(ctxt, xmlXPathCastToBoolean(val));
! 2366: xmlXPathReleaseObject(ctxt, val);
! 2367: return(ret);
! 2368: }
! 2369:
! 2370: /**
! 2371: * xmlXPathCacheConvertNumber:
! 2372: * @ctxt: the XPath context
! 2373: * @val: an XPath object
! 2374: *
! 2375: * This is the cached version of xmlXPathConvertNumber().
! 2376: * Converts an existing object to its number() equivalent
! 2377: *
! 2378: * Returns a created or reused object, the old one is freed (or the operation
! 2379: * is done directly on @val)
! 2380: */
! 2381: static xmlXPathObjectPtr
! 2382: xmlXPathCacheConvertNumber(xmlXPathContextPtr ctxt, xmlXPathObjectPtr val) {
! 2383: xmlXPathObjectPtr ret;
! 2384:
! 2385: if (val == NULL)
! 2386: return(xmlXPathCacheNewFloat(ctxt, 0.0));
! 2387: if (val->type == XPATH_NUMBER)
! 2388: return(val);
! 2389: ret = xmlXPathCacheNewFloat(ctxt, xmlXPathCastToNumber(val));
! 2390: xmlXPathReleaseObject(ctxt, val);
! 2391: return(ret);
! 2392: }
! 2393:
! 2394: /************************************************************************
! 2395: * *
! 2396: * Parser stacks related functions and macros *
! 2397: * *
! 2398: ************************************************************************/
! 2399:
! 2400: /**
! 2401: * valuePop:
! 2402: * @ctxt: an XPath evaluation context
! 2403: *
! 2404: * Pops the top XPath object from the value stack
! 2405: *
! 2406: * Returns the XPath object just removed
! 2407: */
! 2408: xmlXPathObjectPtr
! 2409: valuePop(xmlXPathParserContextPtr ctxt)
! 2410: {
! 2411: xmlXPathObjectPtr ret;
! 2412:
! 2413: if ((ctxt == NULL) || (ctxt->valueNr <= 0))
! 2414: return (NULL);
! 2415: ctxt->valueNr--;
! 2416: if (ctxt->valueNr > 0)
! 2417: ctxt->value = ctxt->valueTab[ctxt->valueNr - 1];
! 2418: else
! 2419: ctxt->value = NULL;
! 2420: ret = ctxt->valueTab[ctxt->valueNr];
! 2421: ctxt->valueTab[ctxt->valueNr] = NULL;
! 2422: return (ret);
! 2423: }
! 2424: /**
! 2425: * valuePush:
! 2426: * @ctxt: an XPath evaluation context
! 2427: * @value: the XPath object
! 2428: *
! 2429: * Pushes a new XPath object on top of the value stack
! 2430: *
! 2431: * returns the number of items on the value stack
! 2432: */
! 2433: int
! 2434: valuePush(xmlXPathParserContextPtr ctxt, xmlXPathObjectPtr value)
! 2435: {
! 2436: if ((ctxt == NULL) || (value == NULL)) return(-1);
! 2437: if (ctxt->valueNr >= ctxt->valueMax) {
! 2438: xmlXPathObjectPtr *tmp;
! 2439:
! 2440: tmp = (xmlXPathObjectPtr *) xmlRealloc(ctxt->valueTab,
! 2441: 2 * ctxt->valueMax *
! 2442: sizeof(ctxt->valueTab[0]));
! 2443: if (tmp == NULL) {
! 2444: xmlGenericError(xmlGenericErrorContext, "realloc failed !\n");
! 2445: return (0);
! 2446: }
! 2447: ctxt->valueMax *= 2;
! 2448: ctxt->valueTab = tmp;
! 2449: }
! 2450: ctxt->valueTab[ctxt->valueNr] = value;
! 2451: ctxt->value = value;
! 2452: return (ctxt->valueNr++);
! 2453: }
! 2454:
! 2455: /**
! 2456: * xmlXPathPopBoolean:
! 2457: * @ctxt: an XPath parser context
! 2458: *
! 2459: * Pops a boolean from the stack, handling conversion if needed.
! 2460: * Check error with #xmlXPathCheckError.
! 2461: *
! 2462: * Returns the boolean
! 2463: */
! 2464: int
! 2465: xmlXPathPopBoolean (xmlXPathParserContextPtr ctxt) {
! 2466: xmlXPathObjectPtr obj;
! 2467: int ret;
! 2468:
! 2469: obj = valuePop(ctxt);
! 2470: if (obj == NULL) {
! 2471: xmlXPathSetError(ctxt, XPATH_INVALID_OPERAND);
! 2472: return(0);
! 2473: }
! 2474: if (obj->type != XPATH_BOOLEAN)
! 2475: ret = xmlXPathCastToBoolean(obj);
! 2476: else
! 2477: ret = obj->boolval;
! 2478: xmlXPathReleaseObject(ctxt->context, obj);
! 2479: return(ret);
! 2480: }
! 2481:
! 2482: /**
! 2483: * xmlXPathPopNumber:
! 2484: * @ctxt: an XPath parser context
! 2485: *
! 2486: * Pops a number from the stack, handling conversion if needed.
! 2487: * Check error with #xmlXPathCheckError.
! 2488: *
! 2489: * Returns the number
! 2490: */
! 2491: double
! 2492: xmlXPathPopNumber (xmlXPathParserContextPtr ctxt) {
! 2493: xmlXPathObjectPtr obj;
! 2494: double ret;
! 2495:
! 2496: obj = valuePop(ctxt);
! 2497: if (obj == NULL) {
! 2498: xmlXPathSetError(ctxt, XPATH_INVALID_OPERAND);
! 2499: return(0);
! 2500: }
! 2501: if (obj->type != XPATH_NUMBER)
! 2502: ret = xmlXPathCastToNumber(obj);
! 2503: else
! 2504: ret = obj->floatval;
! 2505: xmlXPathReleaseObject(ctxt->context, obj);
! 2506: return(ret);
! 2507: }
! 2508:
! 2509: /**
! 2510: * xmlXPathPopString:
! 2511: * @ctxt: an XPath parser context
! 2512: *
! 2513: * Pops a string from the stack, handling conversion if needed.
! 2514: * Check error with #xmlXPathCheckError.
! 2515: *
! 2516: * Returns the string
! 2517: */
! 2518: xmlChar *
! 2519: xmlXPathPopString (xmlXPathParserContextPtr ctxt) {
! 2520: xmlXPathObjectPtr obj;
! 2521: xmlChar * ret;
! 2522:
! 2523: obj = valuePop(ctxt);
! 2524: if (obj == NULL) {
! 2525: xmlXPathSetError(ctxt, XPATH_INVALID_OPERAND);
! 2526: return(NULL);
! 2527: }
! 2528: ret = xmlXPathCastToString(obj); /* this does required strdup */
! 2529: /* TODO: needs refactoring somewhere else */
! 2530: if (obj->stringval == ret)
! 2531: obj->stringval = NULL;
! 2532: xmlXPathReleaseObject(ctxt->context, obj);
! 2533: return(ret);
! 2534: }
! 2535:
! 2536: /**
! 2537: * xmlXPathPopNodeSet:
! 2538: * @ctxt: an XPath parser context
! 2539: *
! 2540: * Pops a node-set from the stack, handling conversion if needed.
! 2541: * Check error with #xmlXPathCheckError.
! 2542: *
! 2543: * Returns the node-set
! 2544: */
! 2545: xmlNodeSetPtr
! 2546: xmlXPathPopNodeSet (xmlXPathParserContextPtr ctxt) {
! 2547: xmlXPathObjectPtr obj;
! 2548: xmlNodeSetPtr ret;
! 2549:
! 2550: if (ctxt == NULL) return(NULL);
! 2551: if (ctxt->value == NULL) {
! 2552: xmlXPathSetError(ctxt, XPATH_INVALID_OPERAND);
! 2553: return(NULL);
! 2554: }
! 2555: if (!xmlXPathStackIsNodeSet(ctxt)) {
! 2556: xmlXPathSetTypeError(ctxt);
! 2557: return(NULL);
! 2558: }
! 2559: obj = valuePop(ctxt);
! 2560: ret = obj->nodesetval;
! 2561: #if 0
! 2562: /* to fix memory leak of not clearing obj->user */
! 2563: if (obj->boolval && obj->user != NULL)
! 2564: xmlFreeNodeList((xmlNodePtr) obj->user);
! 2565: #endif
! 2566: obj->nodesetval = NULL;
! 2567: xmlXPathReleaseObject(ctxt->context, obj);
! 2568: return(ret);
! 2569: }
! 2570:
! 2571: /**
! 2572: * xmlXPathPopExternal:
! 2573: * @ctxt: an XPath parser context
! 2574: *
! 2575: * Pops an external object from the stack, handling conversion if needed.
! 2576: * Check error with #xmlXPathCheckError.
! 2577: *
! 2578: * Returns the object
! 2579: */
! 2580: void *
! 2581: xmlXPathPopExternal (xmlXPathParserContextPtr ctxt) {
! 2582: xmlXPathObjectPtr obj;
! 2583: void * ret;
! 2584:
! 2585: if ((ctxt == NULL) || (ctxt->value == NULL)) {
! 2586: xmlXPathSetError(ctxt, XPATH_INVALID_OPERAND);
! 2587: return(NULL);
! 2588: }
! 2589: if (ctxt->value->type != XPATH_USERS) {
! 2590: xmlXPathSetTypeError(ctxt);
! 2591: return(NULL);
! 2592: }
! 2593: obj = valuePop(ctxt);
! 2594: ret = obj->user;
! 2595: obj->user = NULL;
! 2596: xmlXPathReleaseObject(ctxt->context, obj);
! 2597: return(ret);
! 2598: }
! 2599:
! 2600: /*
! 2601: * Macros for accessing the content. Those should be used only by the parser,
! 2602: * and not exported.
! 2603: *
! 2604: * Dirty macros, i.e. one need to make assumption on the context to use them
! 2605: *
! 2606: * CUR_PTR return the current pointer to the xmlChar to be parsed.
! 2607: * CUR returns the current xmlChar value, i.e. a 8 bit value
! 2608: * in ISO-Latin or UTF-8.
! 2609: * This should be used internally by the parser
! 2610: * only to compare to ASCII values otherwise it would break when
! 2611: * running with UTF-8 encoding.
! 2612: * NXT(n) returns the n'th next xmlChar. Same as CUR is should be used only
! 2613: * to compare on ASCII based substring.
! 2614: * SKIP(n) Skip n xmlChar, and must also be used only to skip ASCII defined
! 2615: * strings within the parser.
! 2616: * CURRENT Returns the current char value, with the full decoding of
! 2617: * UTF-8 if we are using this mode. It returns an int.
! 2618: * NEXT Skip to the next character, this does the proper decoding
! 2619: * in UTF-8 mode. It also pop-up unfinished entities on the fly.
! 2620: * It returns the pointer to the current xmlChar.
! 2621: */
! 2622:
! 2623: #define CUR (*ctxt->cur)
! 2624: #define SKIP(val) ctxt->cur += (val)
! 2625: #define NXT(val) ctxt->cur[(val)]
! 2626: #define CUR_PTR ctxt->cur
! 2627: #define CUR_CHAR(l) xmlXPathCurrentChar(ctxt, &l)
! 2628:
! 2629: #define COPY_BUF(l,b,i,v) \
! 2630: if (l == 1) b[i++] = (xmlChar) v; \
! 2631: else i += xmlCopyChar(l,&b[i],v)
! 2632:
! 2633: #define NEXTL(l) ctxt->cur += l
! 2634:
! 2635: #define SKIP_BLANKS \
! 2636: while (IS_BLANK_CH(*(ctxt->cur))) NEXT
! 2637:
! 2638: #define CURRENT (*ctxt->cur)
! 2639: #define NEXT ((*ctxt->cur) ? ctxt->cur++: ctxt->cur)
! 2640:
! 2641:
! 2642: #ifndef DBL_DIG
! 2643: #define DBL_DIG 16
! 2644: #endif
! 2645: #ifndef DBL_EPSILON
! 2646: #define DBL_EPSILON 1E-9
! 2647: #endif
! 2648:
! 2649: #define UPPER_DOUBLE 1E9
! 2650: #define LOWER_DOUBLE 1E-5
! 2651: #define LOWER_DOUBLE_EXP 5
! 2652:
! 2653: #define INTEGER_DIGITS DBL_DIG
! 2654: #define FRACTION_DIGITS (DBL_DIG + 1 + (LOWER_DOUBLE_EXP))
! 2655: #define EXPONENT_DIGITS (3 + 2)
! 2656:
! 2657: /**
! 2658: * xmlXPathFormatNumber:
! 2659: * @number: number to format
! 2660: * @buffer: output buffer
! 2661: * @buffersize: size of output buffer
! 2662: *
! 2663: * Convert the number into a string representation.
! 2664: */
! 2665: static void
! 2666: xmlXPathFormatNumber(double number, char buffer[], int buffersize)
! 2667: {
! 2668: switch (xmlXPathIsInf(number)) {
! 2669: case 1:
! 2670: if (buffersize > (int)sizeof("Infinity"))
! 2671: snprintf(buffer, buffersize, "Infinity");
! 2672: break;
! 2673: case -1:
! 2674: if (buffersize > (int)sizeof("-Infinity"))
! 2675: snprintf(buffer, buffersize, "-Infinity");
! 2676: break;
! 2677: default:
! 2678: if (xmlXPathIsNaN(number)) {
! 2679: if (buffersize > (int)sizeof("NaN"))
! 2680: snprintf(buffer, buffersize, "NaN");
! 2681: } else if (number == 0 && xmlXPathGetSign(number) != 0) {
! 2682: snprintf(buffer, buffersize, "0");
! 2683: } else if (number == ((int) number)) {
! 2684: char work[30];
! 2685: char *ptr, *cur;
! 2686: int value = (int) number;
! 2687:
! 2688: ptr = &buffer[0];
! 2689: if (value == 0) {
! 2690: *ptr++ = '0';
! 2691: } else {
! 2692: snprintf(work, 29, "%d", value);
! 2693: cur = &work[0];
! 2694: while ((*cur) && (ptr - buffer < buffersize)) {
! 2695: *ptr++ = *cur++;
! 2696: }
! 2697: }
! 2698: if (ptr - buffer < buffersize) {
! 2699: *ptr = 0;
! 2700: } else if (buffersize > 0) {
! 2701: ptr--;
! 2702: *ptr = 0;
! 2703: }
! 2704: } else {
! 2705: /*
! 2706: For the dimension of work,
! 2707: DBL_DIG is number of significant digits
! 2708: EXPONENT is only needed for "scientific notation"
! 2709: 3 is sign, decimal point, and terminating zero
! 2710: LOWER_DOUBLE_EXP is max number of leading zeroes in fraction
! 2711: Note that this dimension is slightly (a few characters)
! 2712: larger than actually necessary.
! 2713: */
! 2714: char work[DBL_DIG + EXPONENT_DIGITS + 3 + LOWER_DOUBLE_EXP];
! 2715: int integer_place, fraction_place;
! 2716: char *ptr;
! 2717: char *after_fraction;
! 2718: double absolute_value;
! 2719: int size;
! 2720:
! 2721: absolute_value = fabs(number);
! 2722:
! 2723: /*
! 2724: * First choose format - scientific or regular floating point.
! 2725: * In either case, result is in work, and after_fraction points
! 2726: * just past the fractional part.
! 2727: */
! 2728: if ( ((absolute_value > UPPER_DOUBLE) ||
! 2729: (absolute_value < LOWER_DOUBLE)) &&
! 2730: (absolute_value != 0.0) ) {
! 2731: /* Use scientific notation */
! 2732: integer_place = DBL_DIG + EXPONENT_DIGITS + 1;
! 2733: fraction_place = DBL_DIG - 1;
! 2734: size = snprintf(work, sizeof(work),"%*.*e",
! 2735: integer_place, fraction_place, number);
! 2736: while ((size > 0) && (work[size] != 'e')) size--;
! 2737:
! 2738: }
! 2739: else {
! 2740: /* Use regular notation */
! 2741: if (absolute_value > 0.0) {
! 2742: integer_place = (int)log10(absolute_value);
! 2743: if (integer_place > 0)
! 2744: fraction_place = DBL_DIG - integer_place - 1;
! 2745: else
! 2746: fraction_place = DBL_DIG - integer_place;
! 2747: } else {
! 2748: fraction_place = 1;
! 2749: }
! 2750: size = snprintf(work, sizeof(work), "%0.*f",
! 2751: fraction_place, number);
! 2752: }
! 2753:
! 2754: /* Remove fractional trailing zeroes */
! 2755: after_fraction = work + size;
! 2756: ptr = after_fraction;
! 2757: while (*(--ptr) == '0')
! 2758: ;
! 2759: if (*ptr != '.')
! 2760: ptr++;
! 2761: while ((*ptr++ = *after_fraction++) != 0);
! 2762:
! 2763: /* Finally copy result back to caller */
! 2764: size = strlen(work) + 1;
! 2765: if (size > buffersize) {
! 2766: work[buffersize - 1] = 0;
! 2767: size = buffersize;
! 2768: }
! 2769: memmove(buffer, work, size);
! 2770: }
! 2771: break;
! 2772: }
! 2773: }
! 2774:
! 2775:
! 2776: /************************************************************************
! 2777: * *
! 2778: * Routines to handle NodeSets *
! 2779: * *
! 2780: ************************************************************************/
! 2781:
! 2782: /**
! 2783: * xmlXPathOrderDocElems:
! 2784: * @doc: an input document
! 2785: *
! 2786: * Call this routine to speed up XPath computation on static documents.
! 2787: * This stamps all the element nodes with the document order
! 2788: * Like for line information, the order is kept in the element->content
! 2789: * field, the value stored is actually - the node number (starting at -1)
! 2790: * to be able to differentiate from line numbers.
! 2791: *
! 2792: * Returns the number of elements found in the document or -1 in case
! 2793: * of error.
! 2794: */
! 2795: long
! 2796: xmlXPathOrderDocElems(xmlDocPtr doc) {
! 2797: long count = 0;
! 2798: xmlNodePtr cur;
! 2799:
! 2800: if (doc == NULL)
! 2801: return(-1);
! 2802: cur = doc->children;
! 2803: while (cur != NULL) {
! 2804: if (cur->type == XML_ELEMENT_NODE) {
! 2805: cur->content = (void *) (-(++count));
! 2806: if (cur->children != NULL) {
! 2807: cur = cur->children;
! 2808: continue;
! 2809: }
! 2810: }
! 2811: if (cur->next != NULL) {
! 2812: cur = cur->next;
! 2813: continue;
! 2814: }
! 2815: do {
! 2816: cur = cur->parent;
! 2817: if (cur == NULL)
! 2818: break;
! 2819: if (cur == (xmlNodePtr) doc) {
! 2820: cur = NULL;
! 2821: break;
! 2822: }
! 2823: if (cur->next != NULL) {
! 2824: cur = cur->next;
! 2825: break;
! 2826: }
! 2827: } while (cur != NULL);
! 2828: }
! 2829: return(count);
! 2830: }
! 2831:
! 2832: /**
! 2833: * xmlXPathCmpNodes:
! 2834: * @node1: the first node
! 2835: * @node2: the second node
! 2836: *
! 2837: * Compare two nodes w.r.t document order
! 2838: *
! 2839: * Returns -2 in case of error 1 if first point < second point, 0 if
! 2840: * it's the same node, -1 otherwise
! 2841: */
! 2842: int
! 2843: xmlXPathCmpNodes(xmlNodePtr node1, xmlNodePtr node2) {
! 2844: int depth1, depth2;
! 2845: int attr1 = 0, attr2 = 0;
! 2846: xmlNodePtr attrNode1 = NULL, attrNode2 = NULL;
! 2847: xmlNodePtr cur, root;
! 2848:
! 2849: if ((node1 == NULL) || (node2 == NULL))
! 2850: return(-2);
! 2851: /*
! 2852: * a couple of optimizations which will avoid computations in most cases
! 2853: */
! 2854: if (node1 == node2) /* trivial case */
! 2855: return(0);
! 2856: if (node1->type == XML_ATTRIBUTE_NODE) {
! 2857: attr1 = 1;
! 2858: attrNode1 = node1;
! 2859: node1 = node1->parent;
! 2860: }
! 2861: if (node2->type == XML_ATTRIBUTE_NODE) {
! 2862: attr2 = 1;
! 2863: attrNode2 = node2;
! 2864: node2 = node2->parent;
! 2865: }
! 2866: if (node1 == node2) {
! 2867: if (attr1 == attr2) {
! 2868: /* not required, but we keep attributes in order */
! 2869: if (attr1 != 0) {
! 2870: cur = attrNode2->prev;
! 2871: while (cur != NULL) {
! 2872: if (cur == attrNode1)
! 2873: return (1);
! 2874: cur = cur->prev;
! 2875: }
! 2876: return (-1);
! 2877: }
! 2878: return(0);
! 2879: }
! 2880: if (attr2 == 1)
! 2881: return(1);
! 2882: return(-1);
! 2883: }
! 2884: if ((node1->type == XML_NAMESPACE_DECL) ||
! 2885: (node2->type == XML_NAMESPACE_DECL))
! 2886: return(1);
! 2887: if (node1 == node2->prev)
! 2888: return(1);
! 2889: if (node1 == node2->next)
! 2890: return(-1);
! 2891:
! 2892: /*
! 2893: * Speedup using document order if availble.
! 2894: */
! 2895: if ((node1->type == XML_ELEMENT_NODE) &&
! 2896: (node2->type == XML_ELEMENT_NODE) &&
! 2897: (0 > (long) node1->content) &&
! 2898: (0 > (long) node2->content) &&
! 2899: (node1->doc == node2->doc)) {
! 2900: long l1, l2;
! 2901:
! 2902: l1 = -((long) node1->content);
! 2903: l2 = -((long) node2->content);
! 2904: if (l1 < l2)
! 2905: return(1);
! 2906: if (l1 > l2)
! 2907: return(-1);
! 2908: }
! 2909:
! 2910: /*
! 2911: * compute depth to root
! 2912: */
! 2913: for (depth2 = 0, cur = node2;cur->parent != NULL;cur = cur->parent) {
! 2914: if (cur == node1)
! 2915: return(1);
! 2916: depth2++;
! 2917: }
! 2918: root = cur;
! 2919: for (depth1 = 0, cur = node1;cur->parent != NULL;cur = cur->parent) {
! 2920: if (cur == node2)
! 2921: return(-1);
! 2922: depth1++;
! 2923: }
! 2924: /*
! 2925: * Distinct document (or distinct entities :-( ) case.
! 2926: */
! 2927: if (root != cur) {
! 2928: return(-2);
! 2929: }
! 2930: /*
! 2931: * get the nearest common ancestor.
! 2932: */
! 2933: while (depth1 > depth2) {
! 2934: depth1--;
! 2935: node1 = node1->parent;
! 2936: }
! 2937: while (depth2 > depth1) {
! 2938: depth2--;
! 2939: node2 = node2->parent;
! 2940: }
! 2941: while (node1->parent != node2->parent) {
! 2942: node1 = node1->parent;
! 2943: node2 = node2->parent;
! 2944: /* should not happen but just in case ... */
! 2945: if ((node1 == NULL) || (node2 == NULL))
! 2946: return(-2);
! 2947: }
! 2948: /*
! 2949: * Find who's first.
! 2950: */
! 2951: if (node1 == node2->prev)
! 2952: return(1);
! 2953: if (node1 == node2->next)
! 2954: return(-1);
! 2955: /*
! 2956: * Speedup using document order if availble.
! 2957: */
! 2958: if ((node1->type == XML_ELEMENT_NODE) &&
! 2959: (node2->type == XML_ELEMENT_NODE) &&
! 2960: (0 > (long) node1->content) &&
! 2961: (0 > (long) node2->content) &&
! 2962: (node1->doc == node2->doc)) {
! 2963: long l1, l2;
! 2964:
! 2965: l1 = -((long) node1->content);
! 2966: l2 = -((long) node2->content);
! 2967: if (l1 < l2)
! 2968: return(1);
! 2969: if (l1 > l2)
! 2970: return(-1);
! 2971: }
! 2972:
! 2973: for (cur = node1->next;cur != NULL;cur = cur->next)
! 2974: if (cur == node2)
! 2975: return(1);
! 2976: return(-1); /* assume there is no sibling list corruption */
! 2977: }
! 2978:
! 2979: #ifdef XP_OPTIMIZED_NON_ELEM_COMPARISON
! 2980: /**
! 2981: * xmlXPathCmpNodesExt:
! 2982: * @node1: the first node
! 2983: * @node2: the second node
! 2984: *
! 2985: * Compare two nodes w.r.t document order.
! 2986: * This one is optimized for handling of non-element nodes.
! 2987: *
! 2988: * Returns -2 in case of error 1 if first point < second point, 0 if
! 2989: * it's the same node, -1 otherwise
! 2990: */
! 2991: static int
! 2992: xmlXPathCmpNodesExt(xmlNodePtr node1, xmlNodePtr node2) {
! 2993: int depth1, depth2;
! 2994: int misc = 0, precedence1 = 0, precedence2 = 0;
! 2995: xmlNodePtr miscNode1 = NULL, miscNode2 = NULL;
! 2996: xmlNodePtr cur, root;
! 2997: long l1, l2;
! 2998:
! 2999: if ((node1 == NULL) || (node2 == NULL))
! 3000: return(-2);
! 3001:
! 3002: if (node1 == node2)
! 3003: return(0);
! 3004:
! 3005: /*
! 3006: * a couple of optimizations which will avoid computations in most cases
! 3007: */
! 3008: switch (node1->type) {
! 3009: case XML_ELEMENT_NODE:
! 3010: if (node2->type == XML_ELEMENT_NODE) {
! 3011: if ((0 > (long) node1->content) && /* TODO: Would a != 0 suffice here? */
! 3012: (0 > (long) node2->content) &&
! 3013: (node1->doc == node2->doc))
! 3014: {
! 3015: l1 = -((long) node1->content);
! 3016: l2 = -((long) node2->content);
! 3017: if (l1 < l2)
! 3018: return(1);
! 3019: if (l1 > l2)
! 3020: return(-1);
! 3021: } else
! 3022: goto turtle_comparison;
! 3023: }
! 3024: break;
! 3025: case XML_ATTRIBUTE_NODE:
! 3026: precedence1 = 1; /* element is owner */
! 3027: miscNode1 = node1;
! 3028: node1 = node1->parent;
! 3029: misc = 1;
! 3030: break;
! 3031: case XML_TEXT_NODE:
! 3032: case XML_CDATA_SECTION_NODE:
! 3033: case XML_COMMENT_NODE:
! 3034: case XML_PI_NODE: {
! 3035: miscNode1 = node1;
! 3036: /*
! 3037: * Find nearest element node.
! 3038: */
! 3039: if (node1->prev != NULL) {
! 3040: do {
! 3041: node1 = node1->prev;
! 3042: if (node1->type == XML_ELEMENT_NODE) {
! 3043: precedence1 = 3; /* element in prev-sibl axis */
! 3044: break;
! 3045: }
! 3046: if (node1->prev == NULL) {
! 3047: precedence1 = 2; /* element is parent */
! 3048: /*
! 3049: * URGENT TODO: Are there any cases, where the
! 3050: * parent of such a node is not an element node?
! 3051: */
! 3052: node1 = node1->parent;
! 3053: break;
! 3054: }
! 3055: } while (1);
! 3056: } else {
! 3057: precedence1 = 2; /* element is parent */
! 3058: node1 = node1->parent;
! 3059: }
! 3060: if ((node1 == NULL) || (node1->type != XML_ELEMENT_NODE) ||
! 3061: (0 <= (long) node1->content)) {
! 3062: /*
! 3063: * Fallback for whatever case.
! 3064: */
! 3065: node1 = miscNode1;
! 3066: precedence1 = 0;
! 3067: } else
! 3068: misc = 1;
! 3069: }
! 3070: break;
! 3071: case XML_NAMESPACE_DECL:
! 3072: /*
! 3073: * TODO: why do we return 1 for namespace nodes?
! 3074: */
! 3075: return(1);
! 3076: default:
! 3077: break;
! 3078: }
! 3079: switch (node2->type) {
! 3080: case XML_ELEMENT_NODE:
! 3081: break;
! 3082: case XML_ATTRIBUTE_NODE:
! 3083: precedence2 = 1; /* element is owner */
! 3084: miscNode2 = node2;
! 3085: node2 = node2->parent;
! 3086: misc = 1;
! 3087: break;
! 3088: case XML_TEXT_NODE:
! 3089: case XML_CDATA_SECTION_NODE:
! 3090: case XML_COMMENT_NODE:
! 3091: case XML_PI_NODE: {
! 3092: miscNode2 = node2;
! 3093: if (node2->prev != NULL) {
! 3094: do {
! 3095: node2 = node2->prev;
! 3096: if (node2->type == XML_ELEMENT_NODE) {
! 3097: precedence2 = 3; /* element in prev-sibl axis */
! 3098: break;
! 3099: }
! 3100: if (node2->prev == NULL) {
! 3101: precedence2 = 2; /* element is parent */
! 3102: node2 = node2->parent;
! 3103: break;
! 3104: }
! 3105: } while (1);
! 3106: } else {
! 3107: precedence2 = 2; /* element is parent */
! 3108: node2 = node2->parent;
! 3109: }
! 3110: if ((node2 == NULL) || (node2->type != XML_ELEMENT_NODE) ||
! 3111: (0 <= (long) node1->content))
! 3112: {
! 3113: node2 = miscNode2;
! 3114: precedence2 = 0;
! 3115: } else
! 3116: misc = 1;
! 3117: }
! 3118: break;
! 3119: case XML_NAMESPACE_DECL:
! 3120: return(1);
! 3121: default:
! 3122: break;
! 3123: }
! 3124: if (misc) {
! 3125: if (node1 == node2) {
! 3126: if (precedence1 == precedence2) {
! 3127: /*
! 3128: * The ugly case; but normally there aren't many
! 3129: * adjacent non-element nodes around.
! 3130: */
! 3131: cur = miscNode2->prev;
! 3132: while (cur != NULL) {
! 3133: if (cur == miscNode1)
! 3134: return(1);
! 3135: if (cur->type == XML_ELEMENT_NODE)
! 3136: return(-1);
! 3137: cur = cur->prev;
! 3138: }
! 3139: return (-1);
! 3140: } else {
! 3141: /*
! 3142: * Evaluate based on higher precedence wrt to the element.
! 3143: * TODO: This assumes attributes are sorted before content.
! 3144: * Is this 100% correct?
! 3145: */
! 3146: if (precedence1 < precedence2)
! 3147: return(1);
! 3148: else
! 3149: return(-1);
! 3150: }
! 3151: }
! 3152: /*
! 3153: * Special case: One of the helper-elements is contained by the other.
! 3154: * <foo>
! 3155: * <node2>
! 3156: * <node1>Text-1(precedence1 == 2)</node1>
! 3157: * </node2>
! 3158: * Text-6(precedence2 == 3)
! 3159: * </foo>
! 3160: */
! 3161: if ((precedence2 == 3) && (precedence1 > 1)) {
! 3162: cur = node1->parent;
! 3163: while (cur) {
! 3164: if (cur == node2)
! 3165: return(1);
! 3166: cur = cur->parent;
! 3167: }
! 3168: }
! 3169: if ((precedence1 == 3) && (precedence2 > 1)) {
! 3170: cur = node2->parent;
! 3171: while (cur) {
! 3172: if (cur == node1)
! 3173: return(-1);
! 3174: cur = cur->parent;
! 3175: }
! 3176: }
! 3177: }
! 3178:
! 3179: /*
! 3180: * Speedup using document order if availble.
! 3181: */
! 3182: if ((node1->type == XML_ELEMENT_NODE) &&
! 3183: (node2->type == XML_ELEMENT_NODE) &&
! 3184: (0 > (long) node1->content) &&
! 3185: (0 > (long) node2->content) &&
! 3186: (node1->doc == node2->doc)) {
! 3187:
! 3188: l1 = -((long) node1->content);
! 3189: l2 = -((long) node2->content);
! 3190: if (l1 < l2)
! 3191: return(1);
! 3192: if (l1 > l2)
! 3193: return(-1);
! 3194: }
! 3195:
! 3196: turtle_comparison:
! 3197:
! 3198: if (node1 == node2->prev)
! 3199: return(1);
! 3200: if (node1 == node2->next)
! 3201: return(-1);
! 3202: /*
! 3203: * compute depth to root
! 3204: */
! 3205: for (depth2 = 0, cur = node2;cur->parent != NULL;cur = cur->parent) {
! 3206: if (cur == node1)
! 3207: return(1);
! 3208: depth2++;
! 3209: }
! 3210: root = cur;
! 3211: for (depth1 = 0, cur = node1;cur->parent != NULL;cur = cur->parent) {
! 3212: if (cur == node2)
! 3213: return(-1);
! 3214: depth1++;
! 3215: }
! 3216: /*
! 3217: * Distinct document (or distinct entities :-( ) case.
! 3218: */
! 3219: if (root != cur) {
! 3220: return(-2);
! 3221: }
! 3222: /*
! 3223: * get the nearest common ancestor.
! 3224: */
! 3225: while (depth1 > depth2) {
! 3226: depth1--;
! 3227: node1 = node1->parent;
! 3228: }
! 3229: while (depth2 > depth1) {
! 3230: depth2--;
! 3231: node2 = node2->parent;
! 3232: }
! 3233: while (node1->parent != node2->parent) {
! 3234: node1 = node1->parent;
! 3235: node2 = node2->parent;
! 3236: /* should not happen but just in case ... */
! 3237: if ((node1 == NULL) || (node2 == NULL))
! 3238: return(-2);
! 3239: }
! 3240: /*
! 3241: * Find who's first.
! 3242: */
! 3243: if (node1 == node2->prev)
! 3244: return(1);
! 3245: if (node1 == node2->next)
! 3246: return(-1);
! 3247: /*
! 3248: * Speedup using document order if availble.
! 3249: */
! 3250: if ((node1->type == XML_ELEMENT_NODE) &&
! 3251: (node2->type == XML_ELEMENT_NODE) &&
! 3252: (0 > (long) node1->content) &&
! 3253: (0 > (long) node2->content) &&
! 3254: (node1->doc == node2->doc)) {
! 3255:
! 3256: l1 = -((long) node1->content);
! 3257: l2 = -((long) node2->content);
! 3258: if (l1 < l2)
! 3259: return(1);
! 3260: if (l1 > l2)
! 3261: return(-1);
! 3262: }
! 3263:
! 3264: for (cur = node1->next;cur != NULL;cur = cur->next)
! 3265: if (cur == node2)
! 3266: return(1);
! 3267: return(-1); /* assume there is no sibling list corruption */
! 3268: }
! 3269: #endif /* XP_OPTIMIZED_NON_ELEM_COMPARISON */
! 3270:
! 3271: /**
! 3272: * xmlXPathNodeSetSort:
! 3273: * @set: the node set
! 3274: *
! 3275: * Sort the node set in document order
! 3276: */
! 3277: void
! 3278: xmlXPathNodeSetSort(xmlNodeSetPtr set) {
! 3279: int i, j, incr, len;
! 3280: xmlNodePtr tmp;
! 3281:
! 3282: if (set == NULL)
! 3283: return;
! 3284:
! 3285: /* Use Shell's sort to sort the node-set */
! 3286: len = set->nodeNr;
! 3287: for (incr = len / 2; incr > 0; incr /= 2) {
! 3288: for (i = incr; i < len; i++) {
! 3289: j = i - incr;
! 3290: while (j >= 0) {
! 3291: #ifdef XP_OPTIMIZED_NON_ELEM_COMPARISON
! 3292: if (xmlXPathCmpNodesExt(set->nodeTab[j],
! 3293: set->nodeTab[j + incr]) == -1)
! 3294: #else
! 3295: if (xmlXPathCmpNodes(set->nodeTab[j],
! 3296: set->nodeTab[j + incr]) == -1)
! 3297: #endif
! 3298: {
! 3299: tmp = set->nodeTab[j];
! 3300: set->nodeTab[j] = set->nodeTab[j + incr];
! 3301: set->nodeTab[j + incr] = tmp;
! 3302: j -= incr;
! 3303: } else
! 3304: break;
! 3305: }
! 3306: }
! 3307: }
! 3308: }
! 3309:
! 3310: #define XML_NODESET_DEFAULT 10
! 3311: /**
! 3312: * xmlXPathNodeSetDupNs:
! 3313: * @node: the parent node of the namespace XPath node
! 3314: * @ns: the libxml namespace declaration node.
! 3315: *
! 3316: * Namespace node in libxml don't match the XPath semantic. In a node set
! 3317: * the namespace nodes are duplicated and the next pointer is set to the
! 3318: * parent node in the XPath semantic.
! 3319: *
! 3320: * Returns the newly created object.
! 3321: */
! 3322: static xmlNodePtr
! 3323: xmlXPathNodeSetDupNs(xmlNodePtr node, xmlNsPtr ns) {
! 3324: xmlNsPtr cur;
! 3325:
! 3326: if ((ns == NULL) || (ns->type != XML_NAMESPACE_DECL))
! 3327: return(NULL);
! 3328: if ((node == NULL) || (node->type == XML_NAMESPACE_DECL))
! 3329: return((xmlNodePtr) ns);
! 3330:
! 3331: /*
! 3332: * Allocate a new Namespace and fill the fields.
! 3333: */
! 3334: cur = (xmlNsPtr) xmlMalloc(sizeof(xmlNs));
! 3335: if (cur == NULL) {
! 3336: xmlXPathErrMemory(NULL, "duplicating namespace\n");
! 3337: return(NULL);
! 3338: }
! 3339: memset(cur, 0, sizeof(xmlNs));
! 3340: cur->type = XML_NAMESPACE_DECL;
! 3341: if (ns->href != NULL)
! 3342: cur->href = xmlStrdup(ns->href);
! 3343: if (ns->prefix != NULL)
! 3344: cur->prefix = xmlStrdup(ns->prefix);
! 3345: cur->next = (xmlNsPtr) node;
! 3346: return((xmlNodePtr) cur);
! 3347: }
! 3348:
! 3349: /**
! 3350: * xmlXPathNodeSetFreeNs:
! 3351: * @ns: the XPath namespace node found in a nodeset.
! 3352: *
! 3353: * Namespace nodes in libxml don't match the XPath semantic. In a node set
! 3354: * the namespace nodes are duplicated and the next pointer is set to the
! 3355: * parent node in the XPath semantic. Check if such a node needs to be freed
! 3356: */
! 3357: void
! 3358: xmlXPathNodeSetFreeNs(xmlNsPtr ns) {
! 3359: if ((ns == NULL) || (ns->type != XML_NAMESPACE_DECL))
! 3360: return;
! 3361:
! 3362: if ((ns->next != NULL) && (ns->next->type != XML_NAMESPACE_DECL)) {
! 3363: if (ns->href != NULL)
! 3364: xmlFree((xmlChar *)ns->href);
! 3365: if (ns->prefix != NULL)
! 3366: xmlFree((xmlChar *)ns->prefix);
! 3367: xmlFree(ns);
! 3368: }
! 3369: }
! 3370:
! 3371: /**
! 3372: * xmlXPathNodeSetCreate:
! 3373: * @val: an initial xmlNodePtr, or NULL
! 3374: *
! 3375: * Create a new xmlNodeSetPtr of type double and of value @val
! 3376: *
! 3377: * Returns the newly created object.
! 3378: */
! 3379: xmlNodeSetPtr
! 3380: xmlXPathNodeSetCreate(xmlNodePtr val) {
! 3381: xmlNodeSetPtr ret;
! 3382:
! 3383: ret = (xmlNodeSetPtr) xmlMalloc(sizeof(xmlNodeSet));
! 3384: if (ret == NULL) {
! 3385: xmlXPathErrMemory(NULL, "creating nodeset\n");
! 3386: return(NULL);
! 3387: }
! 3388: memset(ret, 0 , (size_t) sizeof(xmlNodeSet));
! 3389: if (val != NULL) {
! 3390: ret->nodeTab = (xmlNodePtr *) xmlMalloc(XML_NODESET_DEFAULT *
! 3391: sizeof(xmlNodePtr));
! 3392: if (ret->nodeTab == NULL) {
! 3393: xmlXPathErrMemory(NULL, "creating nodeset\n");
! 3394: xmlFree(ret);
! 3395: return(NULL);
! 3396: }
! 3397: memset(ret->nodeTab, 0 ,
! 3398: XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
! 3399: ret->nodeMax = XML_NODESET_DEFAULT;
! 3400: if (val->type == XML_NAMESPACE_DECL) {
! 3401: xmlNsPtr ns = (xmlNsPtr) val;
! 3402:
! 3403: ret->nodeTab[ret->nodeNr++] =
! 3404: xmlXPathNodeSetDupNs((xmlNodePtr) ns->next, ns);
! 3405: } else
! 3406: ret->nodeTab[ret->nodeNr++] = val;
! 3407: }
! 3408: return(ret);
! 3409: }
! 3410:
! 3411: /**
! 3412: * xmlXPathNodeSetCreateSize:
! 3413: * @size: the initial size of the set
! 3414: *
! 3415: * Create a new xmlNodeSetPtr of type double and of value @val
! 3416: *
! 3417: * Returns the newly created object.
! 3418: */
! 3419: static xmlNodeSetPtr
! 3420: xmlXPathNodeSetCreateSize(int size) {
! 3421: xmlNodeSetPtr ret;
! 3422:
! 3423: ret = (xmlNodeSetPtr) xmlMalloc(sizeof(xmlNodeSet));
! 3424: if (ret == NULL) {
! 3425: xmlXPathErrMemory(NULL, "creating nodeset\n");
! 3426: return(NULL);
! 3427: }
! 3428: memset(ret, 0 , (size_t) sizeof(xmlNodeSet));
! 3429: if (size < XML_NODESET_DEFAULT)
! 3430: size = XML_NODESET_DEFAULT;
! 3431: ret->nodeTab = (xmlNodePtr *) xmlMalloc(size * sizeof(xmlNodePtr));
! 3432: if (ret->nodeTab == NULL) {
! 3433: xmlXPathErrMemory(NULL, "creating nodeset\n");
! 3434: xmlFree(ret);
! 3435: return(NULL);
! 3436: }
! 3437: memset(ret->nodeTab, 0 , size * (size_t) sizeof(xmlNodePtr));
! 3438: ret->nodeMax = size;
! 3439: return(ret);
! 3440: }
! 3441:
! 3442: /**
! 3443: * xmlXPathNodeSetContains:
! 3444: * @cur: the node-set
! 3445: * @val: the node
! 3446: *
! 3447: * checks whether @cur contains @val
! 3448: *
! 3449: * Returns true (1) if @cur contains @val, false (0) otherwise
! 3450: */
! 3451: int
! 3452: xmlXPathNodeSetContains (xmlNodeSetPtr cur, xmlNodePtr val) {
! 3453: int i;
! 3454:
! 3455: if ((cur == NULL) || (val == NULL)) return(0);
! 3456: if (val->type == XML_NAMESPACE_DECL) {
! 3457: for (i = 0; i < cur->nodeNr; i++) {
! 3458: if (cur->nodeTab[i]->type == XML_NAMESPACE_DECL) {
! 3459: xmlNsPtr ns1, ns2;
! 3460:
! 3461: ns1 = (xmlNsPtr) val;
! 3462: ns2 = (xmlNsPtr) cur->nodeTab[i];
! 3463: if (ns1 == ns2)
! 3464: return(1);
! 3465: if ((ns1->next != NULL) && (ns2->next == ns1->next) &&
! 3466: (xmlStrEqual(ns1->prefix, ns2->prefix)))
! 3467: return(1);
! 3468: }
! 3469: }
! 3470: } else {
! 3471: for (i = 0; i < cur->nodeNr; i++) {
! 3472: if (cur->nodeTab[i] == val)
! 3473: return(1);
! 3474: }
! 3475: }
! 3476: return(0);
! 3477: }
! 3478:
! 3479: /**
! 3480: * xmlXPathNodeSetAddNs:
! 3481: * @cur: the initial node set
! 3482: * @node: the hosting node
! 3483: * @ns: a the namespace node
! 3484: *
! 3485: * add a new namespace node to an existing NodeSet
! 3486: */
! 3487: void
! 3488: xmlXPathNodeSetAddNs(xmlNodeSetPtr cur, xmlNodePtr node, xmlNsPtr ns) {
! 3489: int i;
! 3490:
! 3491:
! 3492: if ((cur == NULL) || (ns == NULL) || (node == NULL) ||
! 3493: (ns->type != XML_NAMESPACE_DECL) ||
! 3494: (node->type != XML_ELEMENT_NODE))
! 3495: return;
! 3496:
! 3497: /* @@ with_ns to check whether namespace nodes should be looked at @@ */
! 3498: /*
! 3499: * prevent duplicates
! 3500: */
! 3501: for (i = 0;i < cur->nodeNr;i++) {
! 3502: if ((cur->nodeTab[i] != NULL) &&
! 3503: (cur->nodeTab[i]->type == XML_NAMESPACE_DECL) &&
! 3504: (((xmlNsPtr)cur->nodeTab[i])->next == (xmlNsPtr) node) &&
! 3505: (xmlStrEqual(ns->prefix, ((xmlNsPtr)cur->nodeTab[i])->prefix)))
! 3506: return;
! 3507: }
! 3508:
! 3509: /*
! 3510: * grow the nodeTab if needed
! 3511: */
! 3512: if (cur->nodeMax == 0) {
! 3513: cur->nodeTab = (xmlNodePtr *) xmlMalloc(XML_NODESET_DEFAULT *
! 3514: sizeof(xmlNodePtr));
! 3515: if (cur->nodeTab == NULL) {
! 3516: xmlXPathErrMemory(NULL, "growing nodeset\n");
! 3517: return;
! 3518: }
! 3519: memset(cur->nodeTab, 0 ,
! 3520: XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
! 3521: cur->nodeMax = XML_NODESET_DEFAULT;
! 3522: } else if (cur->nodeNr == cur->nodeMax) {
! 3523: xmlNodePtr *temp;
! 3524:
! 3525: cur->nodeMax *= 2;
! 3526: temp = (xmlNodePtr *) xmlRealloc(cur->nodeTab, cur->nodeMax *
! 3527: sizeof(xmlNodePtr));
! 3528: if (temp == NULL) {
! 3529: xmlXPathErrMemory(NULL, "growing nodeset\n");
! 3530: return;
! 3531: }
! 3532: cur->nodeTab = temp;
! 3533: }
! 3534: cur->nodeTab[cur->nodeNr++] = xmlXPathNodeSetDupNs(node, ns);
! 3535: }
! 3536:
! 3537: /**
! 3538: * xmlXPathNodeSetAdd:
! 3539: * @cur: the initial node set
! 3540: * @val: a new xmlNodePtr
! 3541: *
! 3542: * add a new xmlNodePtr to an existing NodeSet
! 3543: */
! 3544: void
! 3545: xmlXPathNodeSetAdd(xmlNodeSetPtr cur, xmlNodePtr val) {
! 3546: int i;
! 3547:
! 3548: if ((cur == NULL) || (val == NULL)) return;
! 3549:
! 3550: #if 0
! 3551: if ((val->type == XML_ELEMENT_NODE) && (val->name[0] == ' '))
! 3552: return; /* an XSLT fake node */
! 3553: #endif
! 3554:
! 3555: /* @@ with_ns to check whether namespace nodes should be looked at @@ */
! 3556: /*
! 3557: * prevent duplcates
! 3558: */
! 3559: for (i = 0;i < cur->nodeNr;i++)
! 3560: if (cur->nodeTab[i] == val) return;
! 3561:
! 3562: /*
! 3563: * grow the nodeTab if needed
! 3564: */
! 3565: if (cur->nodeMax == 0) {
! 3566: cur->nodeTab = (xmlNodePtr *) xmlMalloc(XML_NODESET_DEFAULT *
! 3567: sizeof(xmlNodePtr));
! 3568: if (cur->nodeTab == NULL) {
! 3569: xmlXPathErrMemory(NULL, "growing nodeset\n");
! 3570: return;
! 3571: }
! 3572: memset(cur->nodeTab, 0 ,
! 3573: XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
! 3574: cur->nodeMax = XML_NODESET_DEFAULT;
! 3575: } else if (cur->nodeNr == cur->nodeMax) {
! 3576: xmlNodePtr *temp;
! 3577:
! 3578: cur->nodeMax *= 2;
! 3579: temp = (xmlNodePtr *) xmlRealloc(cur->nodeTab, cur->nodeMax *
! 3580: sizeof(xmlNodePtr));
! 3581: if (temp == NULL) {
! 3582: xmlXPathErrMemory(NULL, "growing nodeset\n");
! 3583: return;
! 3584: }
! 3585: cur->nodeTab = temp;
! 3586: }
! 3587: if (val->type == XML_NAMESPACE_DECL) {
! 3588: xmlNsPtr ns = (xmlNsPtr) val;
! 3589:
! 3590: cur->nodeTab[cur->nodeNr++] =
! 3591: xmlXPathNodeSetDupNs((xmlNodePtr) ns->next, ns);
! 3592: } else
! 3593: cur->nodeTab[cur->nodeNr++] = val;
! 3594: }
! 3595:
! 3596: /**
! 3597: * xmlXPathNodeSetAddUnique:
! 3598: * @cur: the initial node set
! 3599: * @val: a new xmlNodePtr
! 3600: *
! 3601: * add a new xmlNodePtr to an existing NodeSet, optimized version
! 3602: * when we are sure the node is not already in the set.
! 3603: */
! 3604: void
! 3605: xmlXPathNodeSetAddUnique(xmlNodeSetPtr cur, xmlNodePtr val) {
! 3606: if ((cur == NULL) || (val == NULL)) return;
! 3607:
! 3608: #if 0
! 3609: if ((val->type == XML_ELEMENT_NODE) && (val->name[0] == ' '))
! 3610: return; /* an XSLT fake node */
! 3611: #endif
! 3612:
! 3613: /* @@ with_ns to check whether namespace nodes should be looked at @@ */
! 3614: /*
! 3615: * grow the nodeTab if needed
! 3616: */
! 3617: if (cur->nodeMax == 0) {
! 3618: cur->nodeTab = (xmlNodePtr *) xmlMalloc(XML_NODESET_DEFAULT *
! 3619: sizeof(xmlNodePtr));
! 3620: if (cur->nodeTab == NULL) {
! 3621: xmlXPathErrMemory(NULL, "growing nodeset\n");
! 3622: return;
! 3623: }
! 3624: memset(cur->nodeTab, 0 ,
! 3625: XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
! 3626: cur->nodeMax = XML_NODESET_DEFAULT;
! 3627: } else if (cur->nodeNr == cur->nodeMax) {
! 3628: xmlNodePtr *temp;
! 3629:
! 3630: cur->nodeMax *= 2;
! 3631: temp = (xmlNodePtr *) xmlRealloc(cur->nodeTab, cur->nodeMax *
! 3632: sizeof(xmlNodePtr));
! 3633: if (temp == NULL) {
! 3634: xmlXPathErrMemory(NULL, "growing nodeset\n");
! 3635: return;
! 3636: }
! 3637: cur->nodeTab = temp;
! 3638: }
! 3639: if (val->type == XML_NAMESPACE_DECL) {
! 3640: xmlNsPtr ns = (xmlNsPtr) val;
! 3641:
! 3642: cur->nodeTab[cur->nodeNr++] =
! 3643: xmlXPathNodeSetDupNs((xmlNodePtr) ns->next, ns);
! 3644: } else
! 3645: cur->nodeTab[cur->nodeNr++] = val;
! 3646: }
! 3647:
! 3648: /**
! 3649: * xmlXPathNodeSetMerge:
! 3650: * @val1: the first NodeSet or NULL
! 3651: * @val2: the second NodeSet
! 3652: *
! 3653: * Merges two nodesets, all nodes from @val2 are added to @val1
! 3654: * if @val1 is NULL, a new set is created and copied from @val2
! 3655: *
! 3656: * Returns @val1 once extended or NULL in case of error.
! 3657: */
! 3658: xmlNodeSetPtr
! 3659: xmlXPathNodeSetMerge(xmlNodeSetPtr val1, xmlNodeSetPtr val2) {
! 3660: int i, j, initNr, skip;
! 3661: xmlNodePtr n1, n2;
! 3662:
! 3663: if (val2 == NULL) return(val1);
! 3664: if (val1 == NULL) {
! 3665: val1 = xmlXPathNodeSetCreate(NULL);
! 3666: if (val1 == NULL)
! 3667: return (NULL);
! 3668: #if 0
! 3669: /*
! 3670: * TODO: The optimization won't work in every case, since
! 3671: * those nasty namespace nodes need to be added with
! 3672: * xmlXPathNodeSetDupNs() to the set; thus a pure
! 3673: * memcpy is not possible.
! 3674: * If there was a flag on the nodesetval, indicating that
! 3675: * some temporary nodes are in, that would be helpfull.
! 3676: */
! 3677: /*
! 3678: * Optimization: Create an equally sized node-set
! 3679: * and memcpy the content.
! 3680: */
! 3681: val1 = xmlXPathNodeSetCreateSize(val2->nodeNr);
! 3682: if (val1 == NULL)
! 3683: return(NULL);
! 3684: if (val2->nodeNr != 0) {
! 3685: if (val2->nodeNr == 1)
! 3686: *(val1->nodeTab) = *(val2->nodeTab);
! 3687: else {
! 3688: memcpy(val1->nodeTab, val2->nodeTab,
! 3689: val2->nodeNr * sizeof(xmlNodePtr));
! 3690: }
! 3691: val1->nodeNr = val2->nodeNr;
! 3692: }
! 3693: return(val1);
! 3694: #endif
! 3695: }
! 3696:
! 3697: /* @@ with_ns to check whether namespace nodes should be looked at @@ */
! 3698: initNr = val1->nodeNr;
! 3699:
! 3700: for (i = 0;i < val2->nodeNr;i++) {
! 3701: n2 = val2->nodeTab[i];
! 3702: /*
! 3703: * check against duplicates
! 3704: */
! 3705: skip = 0;
! 3706: for (j = 0; j < initNr; j++) {
! 3707: n1 = val1->nodeTab[j];
! 3708: if (n1 == n2) {
! 3709: skip = 1;
! 3710: break;
! 3711: } else if ((n1->type == XML_NAMESPACE_DECL) &&
! 3712: (n2->type == XML_NAMESPACE_DECL)) {
! 3713: if ((((xmlNsPtr) n1)->next == ((xmlNsPtr) n2)->next) &&
! 3714: (xmlStrEqual(((xmlNsPtr) n1)->prefix,
! 3715: ((xmlNsPtr) n2)->prefix)))
! 3716: {
! 3717: skip = 1;
! 3718: break;
! 3719: }
! 3720: }
! 3721: }
! 3722: if (skip)
! 3723: continue;
! 3724:
! 3725: /*
! 3726: * grow the nodeTab if needed
! 3727: */
! 3728: if (val1->nodeMax == 0) {
! 3729: val1->nodeTab = (xmlNodePtr *) xmlMalloc(XML_NODESET_DEFAULT *
! 3730: sizeof(xmlNodePtr));
! 3731: if (val1->nodeTab == NULL) {
! 3732: xmlXPathErrMemory(NULL, "merging nodeset\n");
! 3733: return(NULL);
! 3734: }
! 3735: memset(val1->nodeTab, 0 ,
! 3736: XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
! 3737: val1->nodeMax = XML_NODESET_DEFAULT;
! 3738: } else if (val1->nodeNr == val1->nodeMax) {
! 3739: xmlNodePtr *temp;
! 3740:
! 3741: val1->nodeMax *= 2;
! 3742: temp = (xmlNodePtr *) xmlRealloc(val1->nodeTab, val1->nodeMax *
! 3743: sizeof(xmlNodePtr));
! 3744: if (temp == NULL) {
! 3745: xmlXPathErrMemory(NULL, "merging nodeset\n");
! 3746: return(NULL);
! 3747: }
! 3748: val1->nodeTab = temp;
! 3749: }
! 3750: if (n2->type == XML_NAMESPACE_DECL) {
! 3751: xmlNsPtr ns = (xmlNsPtr) n2;
! 3752:
! 3753: val1->nodeTab[val1->nodeNr++] =
! 3754: xmlXPathNodeSetDupNs((xmlNodePtr) ns->next, ns);
! 3755: } else
! 3756: val1->nodeTab[val1->nodeNr++] = n2;
! 3757: }
! 3758:
! 3759: return(val1);
! 3760: }
! 3761:
! 3762: #if 0 /* xmlXPathNodeSetMergeUnique() is currently not used anymore */
! 3763: /**
! 3764: * xmlXPathNodeSetMergeUnique:
! 3765: * @val1: the first NodeSet or NULL
! 3766: * @val2: the second NodeSet
! 3767: *
! 3768: * Merges two nodesets, all nodes from @val2 are added to @val1
! 3769: * if @val1 is NULL, a new set is created and copied from @val2
! 3770: *
! 3771: * Returns @val1 once extended or NULL in case of error.
! 3772: */
! 3773: static xmlNodeSetPtr
! 3774: xmlXPathNodeSetMergeUnique(xmlNodeSetPtr val1, xmlNodeSetPtr val2) {
! 3775: int i;
! 3776:
! 3777: if (val2 == NULL) return(val1);
! 3778: if (val1 == NULL) {
! 3779: val1 = xmlXPathNodeSetCreate(NULL);
! 3780: }
! 3781: if (val1 == NULL)
! 3782: return (NULL);
! 3783:
! 3784: /* @@ with_ns to check whether namespace nodes should be looked at @@ */
! 3785:
! 3786: for (i = 0;i < val2->nodeNr;i++) {
! 3787: /*
! 3788: * grow the nodeTab if needed
! 3789: */
! 3790: if (val1->nodeMax == 0) {
! 3791: val1->nodeTab = (xmlNodePtr *) xmlMalloc(XML_NODESET_DEFAULT *
! 3792: sizeof(xmlNodePtr));
! 3793: if (val1->nodeTab == NULL) {
! 3794: xmlXPathErrMemory(NULL, "merging nodeset\n");
! 3795: return(NULL);
! 3796: }
! 3797: memset(val1->nodeTab, 0 ,
! 3798: XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
! 3799: val1->nodeMax = XML_NODESET_DEFAULT;
! 3800: } else if (val1->nodeNr == val1->nodeMax) {
! 3801: xmlNodePtr *temp;
! 3802:
! 3803: val1->nodeMax *= 2;
! 3804: temp = (xmlNodePtr *) xmlRealloc(val1->nodeTab, val1->nodeMax *
! 3805: sizeof(xmlNodePtr));
! 3806: if (temp == NULL) {
! 3807: xmlXPathErrMemory(NULL, "merging nodeset\n");
! 3808: return(NULL);
! 3809: }
! 3810: val1->nodeTab = temp;
! 3811: }
! 3812: if (val2->nodeTab[i]->type == XML_NAMESPACE_DECL) {
! 3813: xmlNsPtr ns = (xmlNsPtr) val2->nodeTab[i];
! 3814:
! 3815: val1->nodeTab[val1->nodeNr++] =
! 3816: xmlXPathNodeSetDupNs((xmlNodePtr) ns->next, ns);
! 3817: } else
! 3818: val1->nodeTab[val1->nodeNr++] = val2->nodeTab[i];
! 3819: }
! 3820:
! 3821: return(val1);
! 3822: }
! 3823: #endif /* xmlXPathNodeSetMergeUnique() is currently not used anymore */
! 3824:
! 3825: /**
! 3826: * xmlXPathNodeSetMergeAndClear:
! 3827: * @set1: the first NodeSet or NULL
! 3828: * @set2: the second NodeSet
! 3829: * @hasSet2NsNodes: 1 if set2 contains namespaces nodes
! 3830: *
! 3831: * Merges two nodesets, all nodes from @set2 are added to @set1
! 3832: * if @set1 is NULL, a new set is created and copied from @set2.
! 3833: * Checks for duplicate nodes. Clears set2.
! 3834: *
! 3835: * Returns @set1 once extended or NULL in case of error.
! 3836: */
! 3837: static xmlNodeSetPtr
! 3838: xmlXPathNodeSetMergeAndClear(xmlNodeSetPtr set1, xmlNodeSetPtr set2,
! 3839: int hasNullEntries)
! 3840: {
! 3841: if ((set1 == NULL) && (hasNullEntries == 0)) {
! 3842: /*
! 3843: * Note that doing a memcpy of the list, namespace nodes are
! 3844: * just assigned to set1, since set2 is cleared anyway.
! 3845: */
! 3846: set1 = xmlXPathNodeSetCreateSize(set2->nodeNr);
! 3847: if (set1 == NULL)
! 3848: return(NULL);
! 3849: if (set2->nodeNr != 0) {
! 3850: memcpy(set1->nodeTab, set2->nodeTab,
! 3851: set2->nodeNr * sizeof(xmlNodePtr));
! 3852: set1->nodeNr = set2->nodeNr;
! 3853: }
! 3854: } else {
! 3855: int i, j, initNbSet1;
! 3856: xmlNodePtr n1, n2;
! 3857:
! 3858: if (set1 == NULL)
! 3859: set1 = xmlXPathNodeSetCreate(NULL);
! 3860: if (set1 == NULL)
! 3861: return (NULL);
! 3862:
! 3863: initNbSet1 = set1->nodeNr;
! 3864: for (i = 0;i < set2->nodeNr;i++) {
! 3865: n2 = set2->nodeTab[i];
! 3866: /*
! 3867: * Skip NULLed entries.
! 3868: */
! 3869: if (n2 == NULL)
! 3870: continue;
! 3871: /*
! 3872: * Skip duplicates.
! 3873: */
! 3874: for (j = 0; j < initNbSet1; j++) {
! 3875: n1 = set1->nodeTab[j];
! 3876: if (n1 == n2) {
! 3877: goto skip_node;
! 3878: } else if ((n1->type == XML_NAMESPACE_DECL) &&
! 3879: (n2->type == XML_NAMESPACE_DECL))
! 3880: {
! 3881: if ((((xmlNsPtr) n1)->next == ((xmlNsPtr) n2)->next) &&
! 3882: (xmlStrEqual(((xmlNsPtr) n1)->prefix,
! 3883: ((xmlNsPtr) n2)->prefix)))
! 3884: {
! 3885: /*
! 3886: * Free the namespace node.
! 3887: */
! 3888: set2->nodeTab[i] = NULL;
! 3889: xmlXPathNodeSetFreeNs((xmlNsPtr) n2);
! 3890: goto skip_node;
! 3891: }
! 3892: }
! 3893: }
! 3894: /*
! 3895: * grow the nodeTab if needed
! 3896: */
! 3897: if (set1->nodeMax == 0) {
! 3898: set1->nodeTab = (xmlNodePtr *) xmlMalloc(
! 3899: XML_NODESET_DEFAULT * sizeof(xmlNodePtr));
! 3900: if (set1->nodeTab == NULL) {
! 3901: xmlXPathErrMemory(NULL, "merging nodeset\n");
! 3902: return(NULL);
! 3903: }
! 3904: memset(set1->nodeTab, 0,
! 3905: XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
! 3906: set1->nodeMax = XML_NODESET_DEFAULT;
! 3907: } else if (set1->nodeNr >= set1->nodeMax) {
! 3908: xmlNodePtr *temp;
! 3909:
! 3910: set1->nodeMax *= 2;
! 3911: temp = (xmlNodePtr *) xmlRealloc(
! 3912: set1->nodeTab, set1->nodeMax * sizeof(xmlNodePtr));
! 3913: if (temp == NULL) {
! 3914: xmlXPathErrMemory(NULL, "merging nodeset\n");
! 3915: return(NULL);
! 3916: }
! 3917: set1->nodeTab = temp;
! 3918: }
! 3919: if (n2->type == XML_NAMESPACE_DECL) {
! 3920: xmlNsPtr ns = (xmlNsPtr) n2;
! 3921:
! 3922: set1->nodeTab[set1->nodeNr++] =
! 3923: xmlXPathNodeSetDupNs((xmlNodePtr) ns->next, ns);
! 3924: } else
! 3925: set1->nodeTab[set1->nodeNr++] = n2;
! 3926: skip_node:
! 3927: {}
! 3928: }
! 3929: }
! 3930: set2->nodeNr = 0;
! 3931: return(set1);
! 3932: }
! 3933:
! 3934: /**
! 3935: * xmlXPathNodeSetMergeAndClearNoDupls:
! 3936: * @set1: the first NodeSet or NULL
! 3937: * @set2: the second NodeSet
! 3938: * @hasSet2NsNodes: 1 if set2 contains namespaces nodes
! 3939: *
! 3940: * Merges two nodesets, all nodes from @set2 are added to @set1
! 3941: * if @set1 is NULL, a new set is created and copied from @set2.
! 3942: * Doesn't chack for duplicate nodes. Clears set2.
! 3943: *
! 3944: * Returns @set1 once extended or NULL in case of error.
! 3945: */
! 3946: static xmlNodeSetPtr
! 3947: xmlXPathNodeSetMergeAndClearNoDupls(xmlNodeSetPtr set1, xmlNodeSetPtr set2,
! 3948: int hasNullEntries)
! 3949: {
! 3950: if (set2 == NULL)
! 3951: return(set1);
! 3952: if ((set1 == NULL) && (hasNullEntries == 0)) {
! 3953: /*
! 3954: * Note that doing a memcpy of the list, namespace nodes are
! 3955: * just assigned to set1, since set2 is cleared anyway.
! 3956: */
! 3957: set1 = xmlXPathNodeSetCreateSize(set2->nodeNr);
! 3958: if (set1 == NULL)
! 3959: return(NULL);
! 3960: if (set2->nodeNr != 0) {
! 3961: memcpy(set1->nodeTab, set2->nodeTab,
! 3962: set2->nodeNr * sizeof(xmlNodePtr));
! 3963: set1->nodeNr = set2->nodeNr;
! 3964: }
! 3965: } else {
! 3966: int i;
! 3967: xmlNodePtr n2;
! 3968:
! 3969: if (set1 == NULL)
! 3970: set1 = xmlXPathNodeSetCreate(NULL);
! 3971: if (set1 == NULL)
! 3972: return (NULL);
! 3973:
! 3974: for (i = 0;i < set2->nodeNr;i++) {
! 3975: n2 = set2->nodeTab[i];
! 3976: /*
! 3977: * Skip NULLed entries.
! 3978: */
! 3979: if (n2 == NULL)
! 3980: continue;
! 3981: if (set1->nodeMax == 0) {
! 3982: set1->nodeTab = (xmlNodePtr *) xmlMalloc(
! 3983: XML_NODESET_DEFAULT * sizeof(xmlNodePtr));
! 3984: if (set1->nodeTab == NULL) {
! 3985: xmlXPathErrMemory(NULL, "merging nodeset\n");
! 3986: return(NULL);
! 3987: }
! 3988: memset(set1->nodeTab, 0,
! 3989: XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
! 3990: set1->nodeMax = XML_NODESET_DEFAULT;
! 3991: } else if (set1->nodeNr >= set1->nodeMax) {
! 3992: xmlNodePtr *temp;
! 3993:
! 3994: set1->nodeMax *= 2;
! 3995: temp = (xmlNodePtr *) xmlRealloc(
! 3996: set1->nodeTab, set1->nodeMax * sizeof(xmlNodePtr));
! 3997: if (temp == NULL) {
! 3998: xmlXPathErrMemory(NULL, "merging nodeset\n");
! 3999: return(NULL);
! 4000: }
! 4001: set1->nodeTab = temp;
! 4002: }
! 4003: set1->nodeTab[set1->nodeNr++] = n2;
! 4004: }
! 4005: }
! 4006: set2->nodeNr = 0;
! 4007: return(set1);
! 4008: }
! 4009:
! 4010: /**
! 4011: * xmlXPathNodeSetDel:
! 4012: * @cur: the initial node set
! 4013: * @val: an xmlNodePtr
! 4014: *
! 4015: * Removes an xmlNodePtr from an existing NodeSet
! 4016: */
! 4017: void
! 4018: xmlXPathNodeSetDel(xmlNodeSetPtr cur, xmlNodePtr val) {
! 4019: int i;
! 4020:
! 4021: if (cur == NULL) return;
! 4022: if (val == NULL) return;
! 4023:
! 4024: /*
! 4025: * find node in nodeTab
! 4026: */
! 4027: for (i = 0;i < cur->nodeNr;i++)
! 4028: if (cur->nodeTab[i] == val) break;
! 4029:
! 4030: if (i >= cur->nodeNr) { /* not found */
! 4031: #ifdef DEBUG
! 4032: xmlGenericError(xmlGenericErrorContext,
! 4033: "xmlXPathNodeSetDel: Node %s wasn't found in NodeList\n",
! 4034: val->name);
! 4035: #endif
! 4036: return;
! 4037: }
! 4038: if ((cur->nodeTab[i] != NULL) &&
! 4039: (cur->nodeTab[i]->type == XML_NAMESPACE_DECL))
! 4040: xmlXPathNodeSetFreeNs((xmlNsPtr) cur->nodeTab[i]);
! 4041: cur->nodeNr--;
! 4042: for (;i < cur->nodeNr;i++)
! 4043: cur->nodeTab[i] = cur->nodeTab[i + 1];
! 4044: cur->nodeTab[cur->nodeNr] = NULL;
! 4045: }
! 4046:
! 4047: /**
! 4048: * xmlXPathNodeSetRemove:
! 4049: * @cur: the initial node set
! 4050: * @val: the index to remove
! 4051: *
! 4052: * Removes an entry from an existing NodeSet list.
! 4053: */
! 4054: void
! 4055: xmlXPathNodeSetRemove(xmlNodeSetPtr cur, int val) {
! 4056: if (cur == NULL) return;
! 4057: if (val >= cur->nodeNr) return;
! 4058: if ((cur->nodeTab[val] != NULL) &&
! 4059: (cur->nodeTab[val]->type == XML_NAMESPACE_DECL))
! 4060: xmlXPathNodeSetFreeNs((xmlNsPtr) cur->nodeTab[val]);
! 4061: cur->nodeNr--;
! 4062: for (;val < cur->nodeNr;val++)
! 4063: cur->nodeTab[val] = cur->nodeTab[val + 1];
! 4064: cur->nodeTab[cur->nodeNr] = NULL;
! 4065: }
! 4066:
! 4067: /**
! 4068: * xmlXPathFreeNodeSet:
! 4069: * @obj: the xmlNodeSetPtr to free
! 4070: *
! 4071: * Free the NodeSet compound (not the actual nodes !).
! 4072: */
! 4073: void
! 4074: xmlXPathFreeNodeSet(xmlNodeSetPtr obj) {
! 4075: if (obj == NULL) return;
! 4076: if (obj->nodeTab != NULL) {
! 4077: int i;
! 4078:
! 4079: /* @@ with_ns to check whether namespace nodes should be looked at @@ */
! 4080: for (i = 0;i < obj->nodeNr;i++)
! 4081: if ((obj->nodeTab[i] != NULL) &&
! 4082: (obj->nodeTab[i]->type == XML_NAMESPACE_DECL))
! 4083: xmlXPathNodeSetFreeNs((xmlNsPtr) obj->nodeTab[i]);
! 4084: xmlFree(obj->nodeTab);
! 4085: }
! 4086: xmlFree(obj);
! 4087: }
! 4088:
! 4089: /**
! 4090: * xmlXPathNodeSetClear:
! 4091: * @set: the node set to clear
! 4092: *
! 4093: * Clears the list from all temporary XPath objects (e.g. namespace nodes
! 4094: * are feed), but does *not* free the list itself. Sets the length of the
! 4095: * list to 0.
! 4096: */
! 4097: static void
! 4098: xmlXPathNodeSetClear(xmlNodeSetPtr set, int hasNsNodes)
! 4099: {
! 4100: if ((set == NULL) || (set->nodeNr <= 0))
! 4101: return;
! 4102: else if (hasNsNodes) {
! 4103: int i;
! 4104: xmlNodePtr node;
! 4105:
! 4106: for (i = 0; i < set->nodeNr; i++) {
! 4107: node = set->nodeTab[i];
! 4108: if ((node != NULL) &&
! 4109: (node->type == XML_NAMESPACE_DECL))
! 4110: xmlXPathNodeSetFreeNs((xmlNsPtr) node);
! 4111: }
! 4112: }
! 4113: set->nodeNr = 0;
! 4114: }
! 4115:
! 4116: /**
! 4117: * xmlXPathNodeSetClearFromPos:
! 4118: * @set: the node set to be cleared
! 4119: * @pos: the start position to clear from
! 4120: *
! 4121: * Clears the list from temporary XPath objects (e.g. namespace nodes
! 4122: * are feed) starting with the entry at @pos, but does *not* free the list
! 4123: * itself. Sets the length of the list to @pos.
! 4124: */
! 4125: static void
! 4126: xmlXPathNodeSetClearFromPos(xmlNodeSetPtr set, int pos, int hasNsNodes)
! 4127: {
! 4128: if ((set == NULL) || (set->nodeNr <= 0) || (pos >= set->nodeNr))
! 4129: return;
! 4130: else if ((hasNsNodes)) {
! 4131: int i;
! 4132: xmlNodePtr node;
! 4133:
! 4134: for (i = pos; i < set->nodeNr; i++) {
! 4135: node = set->nodeTab[i];
! 4136: if ((node != NULL) &&
! 4137: (node->type == XML_NAMESPACE_DECL))
! 4138: xmlXPathNodeSetFreeNs((xmlNsPtr) node);
! 4139: }
! 4140: }
! 4141: set->nodeNr = pos;
! 4142: }
! 4143:
! 4144: /**
! 4145: * xmlXPathFreeValueTree:
! 4146: * @obj: the xmlNodeSetPtr to free
! 4147: *
! 4148: * Free the NodeSet compound and the actual tree, this is different
! 4149: * from xmlXPathFreeNodeSet()
! 4150: */
! 4151: static void
! 4152: xmlXPathFreeValueTree(xmlNodeSetPtr obj) {
! 4153: int i;
! 4154:
! 4155: if (obj == NULL) return;
! 4156:
! 4157: if (obj->nodeTab != NULL) {
! 4158: for (i = 0;i < obj->nodeNr;i++) {
! 4159: if (obj->nodeTab[i] != NULL) {
! 4160: if (obj->nodeTab[i]->type == XML_NAMESPACE_DECL) {
! 4161: xmlXPathNodeSetFreeNs((xmlNsPtr) obj->nodeTab[i]);
! 4162: } else {
! 4163: xmlFreeNodeList(obj->nodeTab[i]);
! 4164: }
! 4165: }
! 4166: }
! 4167: xmlFree(obj->nodeTab);
! 4168: }
! 4169: xmlFree(obj);
! 4170: }
! 4171:
! 4172: #if defined(DEBUG) || defined(DEBUG_STEP)
! 4173: /**
! 4174: * xmlGenericErrorContextNodeSet:
! 4175: * @output: a FILE * for the output
! 4176: * @obj: the xmlNodeSetPtr to display
! 4177: *
! 4178: * Quick display of a NodeSet
! 4179: */
! 4180: void
! 4181: xmlGenericErrorContextNodeSet(FILE *output, xmlNodeSetPtr obj) {
! 4182: int i;
! 4183:
! 4184: if (output == NULL) output = xmlGenericErrorContext;
! 4185: if (obj == NULL) {
! 4186: fprintf(output, "NodeSet == NULL !\n");
! 4187: return;
! 4188: }
! 4189: if (obj->nodeNr == 0) {
! 4190: fprintf(output, "NodeSet is empty\n");
! 4191: return;
! 4192: }
! 4193: if (obj->nodeTab == NULL) {
! 4194: fprintf(output, " nodeTab == NULL !\n");
! 4195: return;
! 4196: }
! 4197: for (i = 0; i < obj->nodeNr; i++) {
! 4198: if (obj->nodeTab[i] == NULL) {
! 4199: fprintf(output, " NULL !\n");
! 4200: return;
! 4201: }
! 4202: if ((obj->nodeTab[i]->type == XML_DOCUMENT_NODE) ||
! 4203: (obj->nodeTab[i]->type == XML_HTML_DOCUMENT_NODE))
! 4204: fprintf(output, " /");
! 4205: else if (obj->nodeTab[i]->name == NULL)
! 4206: fprintf(output, " noname!");
! 4207: else fprintf(output, " %s", obj->nodeTab[i]->name);
! 4208: }
! 4209: fprintf(output, "\n");
! 4210: }
! 4211: #endif
! 4212:
! 4213: /**
! 4214: * xmlXPathNewNodeSet:
! 4215: * @val: the NodePtr value
! 4216: *
! 4217: * Create a new xmlXPathObjectPtr of type NodeSet and initialize
! 4218: * it with the single Node @val
! 4219: *
! 4220: * Returns the newly created object.
! 4221: */
! 4222: xmlXPathObjectPtr
! 4223: xmlXPathNewNodeSet(xmlNodePtr val) {
! 4224: xmlXPathObjectPtr ret;
! 4225:
! 4226: ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
! 4227: if (ret == NULL) {
! 4228: xmlXPathErrMemory(NULL, "creating nodeset\n");
! 4229: return(NULL);
! 4230: }
! 4231: memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
! 4232: ret->type = XPATH_NODESET;
! 4233: ret->boolval = 0;
! 4234: ret->nodesetval = xmlXPathNodeSetCreate(val);
! 4235: /* @@ with_ns to check whether namespace nodes should be looked at @@ */
! 4236: #ifdef XP_DEBUG_OBJ_USAGE
! 4237: xmlXPathDebugObjUsageRequested(NULL, XPATH_NODESET);
! 4238: #endif
! 4239: return(ret);
! 4240: }
! 4241:
! 4242: /**
! 4243: * xmlXPathNewValueTree:
! 4244: * @val: the NodePtr value
! 4245: *
! 4246: * Create a new xmlXPathObjectPtr of type Value Tree (XSLT) and initialize
! 4247: * it with the tree root @val
! 4248: *
! 4249: * Returns the newly created object.
! 4250: */
! 4251: xmlXPathObjectPtr
! 4252: xmlXPathNewValueTree(xmlNodePtr val) {
! 4253: xmlXPathObjectPtr ret;
! 4254:
! 4255: ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
! 4256: if (ret == NULL) {
! 4257: xmlXPathErrMemory(NULL, "creating result value tree\n");
! 4258: return(NULL);
! 4259: }
! 4260: memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
! 4261: ret->type = XPATH_XSLT_TREE;
! 4262: ret->boolval = 1;
! 4263: ret->user = (void *) val;
! 4264: ret->nodesetval = xmlXPathNodeSetCreate(val);
! 4265: #ifdef XP_DEBUG_OBJ_USAGE
! 4266: xmlXPathDebugObjUsageRequested(NULL, XPATH_XSLT_TREE);
! 4267: #endif
! 4268: return(ret);
! 4269: }
! 4270:
! 4271: /**
! 4272: * xmlXPathNewNodeSetList:
! 4273: * @val: an existing NodeSet
! 4274: *
! 4275: * Create a new xmlXPathObjectPtr of type NodeSet and initialize
! 4276: * it with the Nodeset @val
! 4277: *
! 4278: * Returns the newly created object.
! 4279: */
! 4280: xmlXPathObjectPtr
! 4281: xmlXPathNewNodeSetList(xmlNodeSetPtr val)
! 4282: {
! 4283: xmlXPathObjectPtr ret;
! 4284: int i;
! 4285:
! 4286: if (val == NULL)
! 4287: ret = NULL;
! 4288: else if (val->nodeTab == NULL)
! 4289: ret = xmlXPathNewNodeSet(NULL);
! 4290: else {
! 4291: ret = xmlXPathNewNodeSet(val->nodeTab[0]);
! 4292: if (ret)
! 4293: for (i = 1; i < val->nodeNr; ++i)
! 4294: xmlXPathNodeSetAddUnique(ret->nodesetval, val->nodeTab[i]);
! 4295: }
! 4296:
! 4297: return (ret);
! 4298: }
! 4299:
! 4300: /**
! 4301: * xmlXPathWrapNodeSet:
! 4302: * @val: the NodePtr value
! 4303: *
! 4304: * Wrap the Nodeset @val in a new xmlXPathObjectPtr
! 4305: *
! 4306: * Returns the newly created object.
! 4307: */
! 4308: xmlXPathObjectPtr
! 4309: xmlXPathWrapNodeSet(xmlNodeSetPtr val) {
! 4310: xmlXPathObjectPtr ret;
! 4311:
! 4312: ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
! 4313: if (ret == NULL) {
! 4314: xmlXPathErrMemory(NULL, "creating node set object\n");
! 4315: return(NULL);
! 4316: }
! 4317: memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
! 4318: ret->type = XPATH_NODESET;
! 4319: ret->nodesetval = val;
! 4320: #ifdef XP_DEBUG_OBJ_USAGE
! 4321: xmlXPathDebugObjUsageRequested(NULL, XPATH_NODESET);
! 4322: #endif
! 4323: return(ret);
! 4324: }
! 4325:
! 4326: /**
! 4327: * xmlXPathFreeNodeSetList:
! 4328: * @obj: an existing NodeSetList object
! 4329: *
! 4330: * Free up the xmlXPathObjectPtr @obj but don't deallocate the objects in
! 4331: * the list contrary to xmlXPathFreeObject().
! 4332: */
! 4333: void
! 4334: xmlXPathFreeNodeSetList(xmlXPathObjectPtr obj) {
! 4335: if (obj == NULL) return;
! 4336: #ifdef XP_DEBUG_OBJ_USAGE
! 4337: xmlXPathDebugObjUsageReleased(NULL, obj->type);
! 4338: #endif
! 4339: xmlFree(obj);
! 4340: }
! 4341:
! 4342: /**
! 4343: * xmlXPathDifference:
! 4344: * @nodes1: a node-set
! 4345: * @nodes2: a node-set
! 4346: *
! 4347: * Implements the EXSLT - Sets difference() function:
! 4348: * node-set set:difference (node-set, node-set)
! 4349: *
! 4350: * Returns the difference between the two node sets, or nodes1 if
! 4351: * nodes2 is empty
! 4352: */
! 4353: xmlNodeSetPtr
! 4354: xmlXPathDifference (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
! 4355: xmlNodeSetPtr ret;
! 4356: int i, l1;
! 4357: xmlNodePtr cur;
! 4358:
! 4359: if (xmlXPathNodeSetIsEmpty(nodes2))
! 4360: return(nodes1);
! 4361:
! 4362: ret = xmlXPathNodeSetCreate(NULL);
! 4363: if (xmlXPathNodeSetIsEmpty(nodes1))
! 4364: return(ret);
! 4365:
! 4366: l1 = xmlXPathNodeSetGetLength(nodes1);
! 4367:
! 4368: for (i = 0; i < l1; i++) {
! 4369: cur = xmlXPathNodeSetItem(nodes1, i);
! 4370: if (!xmlXPathNodeSetContains(nodes2, cur))
! 4371: xmlXPathNodeSetAddUnique(ret, cur);
! 4372: }
! 4373: return(ret);
! 4374: }
! 4375:
! 4376: /**
! 4377: * xmlXPathIntersection:
! 4378: * @nodes1: a node-set
! 4379: * @nodes2: a node-set
! 4380: *
! 4381: * Implements the EXSLT - Sets intersection() function:
! 4382: * node-set set:intersection (node-set, node-set)
! 4383: *
! 4384: * Returns a node set comprising the nodes that are within both the
! 4385: * node sets passed as arguments
! 4386: */
! 4387: xmlNodeSetPtr
! 4388: xmlXPathIntersection (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
! 4389: xmlNodeSetPtr ret = xmlXPathNodeSetCreate(NULL);
! 4390: int i, l1;
! 4391: xmlNodePtr cur;
! 4392:
! 4393: if (ret == NULL)
! 4394: return(ret);
! 4395: if (xmlXPathNodeSetIsEmpty(nodes1))
! 4396: return(ret);
! 4397: if (xmlXPathNodeSetIsEmpty(nodes2))
! 4398: return(ret);
! 4399:
! 4400: l1 = xmlXPathNodeSetGetLength(nodes1);
! 4401:
! 4402: for (i = 0; i < l1; i++) {
! 4403: cur = xmlXPathNodeSetItem(nodes1, i);
! 4404: if (xmlXPathNodeSetContains(nodes2, cur))
! 4405: xmlXPathNodeSetAddUnique(ret, cur);
! 4406: }
! 4407: return(ret);
! 4408: }
! 4409:
! 4410: /**
! 4411: * xmlXPathDistinctSorted:
! 4412: * @nodes: a node-set, sorted by document order
! 4413: *
! 4414: * Implements the EXSLT - Sets distinct() function:
! 4415: * node-set set:distinct (node-set)
! 4416: *
! 4417: * Returns a subset of the nodes contained in @nodes, or @nodes if
! 4418: * it is empty
! 4419: */
! 4420: xmlNodeSetPtr
! 4421: xmlXPathDistinctSorted (xmlNodeSetPtr nodes) {
! 4422: xmlNodeSetPtr ret;
! 4423: xmlHashTablePtr hash;
! 4424: int i, l;
! 4425: xmlChar * strval;
! 4426: xmlNodePtr cur;
! 4427:
! 4428: if (xmlXPathNodeSetIsEmpty(nodes))
! 4429: return(nodes);
! 4430:
! 4431: ret = xmlXPathNodeSetCreate(NULL);
! 4432: if (ret == NULL)
! 4433: return(ret);
! 4434: l = xmlXPathNodeSetGetLength(nodes);
! 4435: hash = xmlHashCreate (l);
! 4436: for (i = 0; i < l; i++) {
! 4437: cur = xmlXPathNodeSetItem(nodes, i);
! 4438: strval = xmlXPathCastNodeToString(cur);
! 4439: if (xmlHashLookup(hash, strval) == NULL) {
! 4440: xmlHashAddEntry(hash, strval, strval);
! 4441: xmlXPathNodeSetAddUnique(ret, cur);
! 4442: } else {
! 4443: xmlFree(strval);
! 4444: }
! 4445: }
! 4446: xmlHashFree(hash, (xmlHashDeallocator) xmlFree);
! 4447: return(ret);
! 4448: }
! 4449:
! 4450: /**
! 4451: * xmlXPathDistinct:
! 4452: * @nodes: a node-set
! 4453: *
! 4454: * Implements the EXSLT - Sets distinct() function:
! 4455: * node-set set:distinct (node-set)
! 4456: * @nodes is sorted by document order, then #exslSetsDistinctSorted
! 4457: * is called with the sorted node-set
! 4458: *
! 4459: * Returns a subset of the nodes contained in @nodes, or @nodes if
! 4460: * it is empty
! 4461: */
! 4462: xmlNodeSetPtr
! 4463: xmlXPathDistinct (xmlNodeSetPtr nodes) {
! 4464: if (xmlXPathNodeSetIsEmpty(nodes))
! 4465: return(nodes);
! 4466:
! 4467: xmlXPathNodeSetSort(nodes);
! 4468: return(xmlXPathDistinctSorted(nodes));
! 4469: }
! 4470:
! 4471: /**
! 4472: * xmlXPathHasSameNodes:
! 4473: * @nodes1: a node-set
! 4474: * @nodes2: a node-set
! 4475: *
! 4476: * Implements the EXSLT - Sets has-same-nodes function:
! 4477: * boolean set:has-same-node(node-set, node-set)
! 4478: *
! 4479: * Returns true (1) if @nodes1 shares any node with @nodes2, false (0)
! 4480: * otherwise
! 4481: */
! 4482: int
! 4483: xmlXPathHasSameNodes (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
! 4484: int i, l;
! 4485: xmlNodePtr cur;
! 4486:
! 4487: if (xmlXPathNodeSetIsEmpty(nodes1) ||
! 4488: xmlXPathNodeSetIsEmpty(nodes2))
! 4489: return(0);
! 4490:
! 4491: l = xmlXPathNodeSetGetLength(nodes1);
! 4492: for (i = 0; i < l; i++) {
! 4493: cur = xmlXPathNodeSetItem(nodes1, i);
! 4494: if (xmlXPathNodeSetContains(nodes2, cur))
! 4495: return(1);
! 4496: }
! 4497: return(0);
! 4498: }
! 4499:
! 4500: /**
! 4501: * xmlXPathNodeLeadingSorted:
! 4502: * @nodes: a node-set, sorted by document order
! 4503: * @node: a node
! 4504: *
! 4505: * Implements the EXSLT - Sets leading() function:
! 4506: * node-set set:leading (node-set, node-set)
! 4507: *
! 4508: * Returns the nodes in @nodes that precede @node in document order,
! 4509: * @nodes if @node is NULL or an empty node-set if @nodes
! 4510: * doesn't contain @node
! 4511: */
! 4512: xmlNodeSetPtr
! 4513: xmlXPathNodeLeadingSorted (xmlNodeSetPtr nodes, xmlNodePtr node) {
! 4514: int i, l;
! 4515: xmlNodePtr cur;
! 4516: xmlNodeSetPtr ret;
! 4517:
! 4518: if (node == NULL)
! 4519: return(nodes);
! 4520:
! 4521: ret = xmlXPathNodeSetCreate(NULL);
! 4522: if (ret == NULL)
! 4523: return(ret);
! 4524: if (xmlXPathNodeSetIsEmpty(nodes) ||
! 4525: (!xmlXPathNodeSetContains(nodes, node)))
! 4526: return(ret);
! 4527:
! 4528: l = xmlXPathNodeSetGetLength(nodes);
! 4529: for (i = 0; i < l; i++) {
! 4530: cur = xmlXPathNodeSetItem(nodes, i);
! 4531: if (cur == node)
! 4532: break;
! 4533: xmlXPathNodeSetAddUnique(ret, cur);
! 4534: }
! 4535: return(ret);
! 4536: }
! 4537:
! 4538: /**
! 4539: * xmlXPathNodeLeading:
! 4540: * @nodes: a node-set
! 4541: * @node: a node
! 4542: *
! 4543: * Implements the EXSLT - Sets leading() function:
! 4544: * node-set set:leading (node-set, node-set)
! 4545: * @nodes is sorted by document order, then #exslSetsNodeLeadingSorted
! 4546: * is called.
! 4547: *
! 4548: * Returns the nodes in @nodes that precede @node in document order,
! 4549: * @nodes if @node is NULL or an empty node-set if @nodes
! 4550: * doesn't contain @node
! 4551: */
! 4552: xmlNodeSetPtr
! 4553: xmlXPathNodeLeading (xmlNodeSetPtr nodes, xmlNodePtr node) {
! 4554: xmlXPathNodeSetSort(nodes);
! 4555: return(xmlXPathNodeLeadingSorted(nodes, node));
! 4556: }
! 4557:
! 4558: /**
! 4559: * xmlXPathLeadingSorted:
! 4560: * @nodes1: a node-set, sorted by document order
! 4561: * @nodes2: a node-set, sorted by document order
! 4562: *
! 4563: * Implements the EXSLT - Sets leading() function:
! 4564: * node-set set:leading (node-set, node-set)
! 4565: *
! 4566: * Returns the nodes in @nodes1 that precede the first node in @nodes2
! 4567: * in document order, @nodes1 if @nodes2 is NULL or empty or
! 4568: * an empty node-set if @nodes1 doesn't contain @nodes2
! 4569: */
! 4570: xmlNodeSetPtr
! 4571: xmlXPathLeadingSorted (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
! 4572: if (xmlXPathNodeSetIsEmpty(nodes2))
! 4573: return(nodes1);
! 4574: return(xmlXPathNodeLeadingSorted(nodes1,
! 4575: xmlXPathNodeSetItem(nodes2, 1)));
! 4576: }
! 4577:
! 4578: /**
! 4579: * xmlXPathLeading:
! 4580: * @nodes1: a node-set
! 4581: * @nodes2: a node-set
! 4582: *
! 4583: * Implements the EXSLT - Sets leading() function:
! 4584: * node-set set:leading (node-set, node-set)
! 4585: * @nodes1 and @nodes2 are sorted by document order, then
! 4586: * #exslSetsLeadingSorted is called.
! 4587: *
! 4588: * Returns the nodes in @nodes1 that precede the first node in @nodes2
! 4589: * in document order, @nodes1 if @nodes2 is NULL or empty or
! 4590: * an empty node-set if @nodes1 doesn't contain @nodes2
! 4591: */
! 4592: xmlNodeSetPtr
! 4593: xmlXPathLeading (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
! 4594: if (xmlXPathNodeSetIsEmpty(nodes2))
! 4595: return(nodes1);
! 4596: if (xmlXPathNodeSetIsEmpty(nodes1))
! 4597: return(xmlXPathNodeSetCreate(NULL));
! 4598: xmlXPathNodeSetSort(nodes1);
! 4599: xmlXPathNodeSetSort(nodes2);
! 4600: return(xmlXPathNodeLeadingSorted(nodes1,
! 4601: xmlXPathNodeSetItem(nodes2, 1)));
! 4602: }
! 4603:
! 4604: /**
! 4605: * xmlXPathNodeTrailingSorted:
! 4606: * @nodes: a node-set, sorted by document order
! 4607: * @node: a node
! 4608: *
! 4609: * Implements the EXSLT - Sets trailing() function:
! 4610: * node-set set:trailing (node-set, node-set)
! 4611: *
! 4612: * Returns the nodes in @nodes that follow @node in document order,
! 4613: * @nodes if @node is NULL or an empty node-set if @nodes
! 4614: * doesn't contain @node
! 4615: */
! 4616: xmlNodeSetPtr
! 4617: xmlXPathNodeTrailingSorted (xmlNodeSetPtr nodes, xmlNodePtr node) {
! 4618: int i, l;
! 4619: xmlNodePtr cur;
! 4620: xmlNodeSetPtr ret;
! 4621:
! 4622: if (node == NULL)
! 4623: return(nodes);
! 4624:
! 4625: ret = xmlXPathNodeSetCreate(NULL);
! 4626: if (ret == NULL)
! 4627: return(ret);
! 4628: if (xmlXPathNodeSetIsEmpty(nodes) ||
! 4629: (!xmlXPathNodeSetContains(nodes, node)))
! 4630: return(ret);
! 4631:
! 4632: l = xmlXPathNodeSetGetLength(nodes);
! 4633: for (i = l - 1; i >= 0; i--) {
! 4634: cur = xmlXPathNodeSetItem(nodes, i);
! 4635: if (cur == node)
! 4636: break;
! 4637: xmlXPathNodeSetAddUnique(ret, cur);
! 4638: }
! 4639: xmlXPathNodeSetSort(ret); /* bug 413451 */
! 4640: return(ret);
! 4641: }
! 4642:
! 4643: /**
! 4644: * xmlXPathNodeTrailing:
! 4645: * @nodes: a node-set
! 4646: * @node: a node
! 4647: *
! 4648: * Implements the EXSLT - Sets trailing() function:
! 4649: * node-set set:trailing (node-set, node-set)
! 4650: * @nodes is sorted by document order, then #xmlXPathNodeTrailingSorted
! 4651: * is called.
! 4652: *
! 4653: * Returns the nodes in @nodes that follow @node in document order,
! 4654: * @nodes if @node is NULL or an empty node-set if @nodes
! 4655: * doesn't contain @node
! 4656: */
! 4657: xmlNodeSetPtr
! 4658: xmlXPathNodeTrailing (xmlNodeSetPtr nodes, xmlNodePtr node) {
! 4659: xmlXPathNodeSetSort(nodes);
! 4660: return(xmlXPathNodeTrailingSorted(nodes, node));
! 4661: }
! 4662:
! 4663: /**
! 4664: * xmlXPathTrailingSorted:
! 4665: * @nodes1: a node-set, sorted by document order
! 4666: * @nodes2: a node-set, sorted by document order
! 4667: *
! 4668: * Implements the EXSLT - Sets trailing() function:
! 4669: * node-set set:trailing (node-set, node-set)
! 4670: *
! 4671: * Returns the nodes in @nodes1 that follow the first node in @nodes2
! 4672: * in document order, @nodes1 if @nodes2 is NULL or empty or
! 4673: * an empty node-set if @nodes1 doesn't contain @nodes2
! 4674: */
! 4675: xmlNodeSetPtr
! 4676: xmlXPathTrailingSorted (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
! 4677: if (xmlXPathNodeSetIsEmpty(nodes2))
! 4678: return(nodes1);
! 4679: return(xmlXPathNodeTrailingSorted(nodes1,
! 4680: xmlXPathNodeSetItem(nodes2, 0)));
! 4681: }
! 4682:
! 4683: /**
! 4684: * xmlXPathTrailing:
! 4685: * @nodes1: a node-set
! 4686: * @nodes2: a node-set
! 4687: *
! 4688: * Implements the EXSLT - Sets trailing() function:
! 4689: * node-set set:trailing (node-set, node-set)
! 4690: * @nodes1 and @nodes2 are sorted by document order, then
! 4691: * #xmlXPathTrailingSorted is called.
! 4692: *
! 4693: * Returns the nodes in @nodes1 that follow the first node in @nodes2
! 4694: * in document order, @nodes1 if @nodes2 is NULL or empty or
! 4695: * an empty node-set if @nodes1 doesn't contain @nodes2
! 4696: */
! 4697: xmlNodeSetPtr
! 4698: xmlXPathTrailing (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
! 4699: if (xmlXPathNodeSetIsEmpty(nodes2))
! 4700: return(nodes1);
! 4701: if (xmlXPathNodeSetIsEmpty(nodes1))
! 4702: return(xmlXPathNodeSetCreate(NULL));
! 4703: xmlXPathNodeSetSort(nodes1);
! 4704: xmlXPathNodeSetSort(nodes2);
! 4705: return(xmlXPathNodeTrailingSorted(nodes1,
! 4706: xmlXPathNodeSetItem(nodes2, 0)));
! 4707: }
! 4708:
! 4709: /************************************************************************
! 4710: * *
! 4711: * Routines to handle extra functions *
! 4712: * *
! 4713: ************************************************************************/
! 4714:
! 4715: /**
! 4716: * xmlXPathRegisterFunc:
! 4717: * @ctxt: the XPath context
! 4718: * @name: the function name
! 4719: * @f: the function implementation or NULL
! 4720: *
! 4721: * Register a new function. If @f is NULL it unregisters the function
! 4722: *
! 4723: * Returns 0 in case of success, -1 in case of error
! 4724: */
! 4725: int
! 4726: xmlXPathRegisterFunc(xmlXPathContextPtr ctxt, const xmlChar *name,
! 4727: xmlXPathFunction f) {
! 4728: return(xmlXPathRegisterFuncNS(ctxt, name, NULL, f));
! 4729: }
! 4730:
! 4731: /**
! 4732: * xmlXPathRegisterFuncNS:
! 4733: * @ctxt: the XPath context
! 4734: * @name: the function name
! 4735: * @ns_uri: the function namespace URI
! 4736: * @f: the function implementation or NULL
! 4737: *
! 4738: * Register a new function. If @f is NULL it unregisters the function
! 4739: *
! 4740: * Returns 0 in case of success, -1 in case of error
! 4741: */
! 4742: int
! 4743: xmlXPathRegisterFuncNS(xmlXPathContextPtr ctxt, const xmlChar *name,
! 4744: const xmlChar *ns_uri, xmlXPathFunction f) {
! 4745: if (ctxt == NULL)
! 4746: return(-1);
! 4747: if (name == NULL)
! 4748: return(-1);
! 4749:
! 4750: if (ctxt->funcHash == NULL)
! 4751: ctxt->funcHash = xmlHashCreate(0);
! 4752: if (ctxt->funcHash == NULL)
! 4753: return(-1);
! 4754: if (f == NULL)
! 4755: return(xmlHashRemoveEntry2(ctxt->funcHash, name, ns_uri, NULL));
! 4756: return(xmlHashAddEntry2(ctxt->funcHash, name, ns_uri, XML_CAST_FPTR(f)));
! 4757: }
! 4758:
! 4759: /**
! 4760: * xmlXPathRegisterFuncLookup:
! 4761: * @ctxt: the XPath context
! 4762: * @f: the lookup function
! 4763: * @funcCtxt: the lookup data
! 4764: *
! 4765: * Registers an external mechanism to do function lookup.
! 4766: */
! 4767: void
! 4768: xmlXPathRegisterFuncLookup (xmlXPathContextPtr ctxt,
! 4769: xmlXPathFuncLookupFunc f,
! 4770: void *funcCtxt) {
! 4771: if (ctxt == NULL)
! 4772: return;
! 4773: ctxt->funcLookupFunc = f;
! 4774: ctxt->funcLookupData = funcCtxt;
! 4775: }
! 4776:
! 4777: /**
! 4778: * xmlXPathFunctionLookup:
! 4779: * @ctxt: the XPath context
! 4780: * @name: the function name
! 4781: *
! 4782: * Search in the Function array of the context for the given
! 4783: * function.
! 4784: *
! 4785: * Returns the xmlXPathFunction or NULL if not found
! 4786: */
! 4787: xmlXPathFunction
! 4788: xmlXPathFunctionLookup(xmlXPathContextPtr ctxt, const xmlChar *name) {
! 4789: if (ctxt == NULL)
! 4790: return (NULL);
! 4791:
! 4792: if (ctxt->funcLookupFunc != NULL) {
! 4793: xmlXPathFunction ret;
! 4794: xmlXPathFuncLookupFunc f;
! 4795:
! 4796: f = ctxt->funcLookupFunc;
! 4797: ret = f(ctxt->funcLookupData, name, NULL);
! 4798: if (ret != NULL)
! 4799: return(ret);
! 4800: }
! 4801: return(xmlXPathFunctionLookupNS(ctxt, name, NULL));
! 4802: }
! 4803:
! 4804: /**
! 4805: * xmlXPathFunctionLookupNS:
! 4806: * @ctxt: the XPath context
! 4807: * @name: the function name
! 4808: * @ns_uri: the function namespace URI
! 4809: *
! 4810: * Search in the Function array of the context for the given
! 4811: * function.
! 4812: *
! 4813: * Returns the xmlXPathFunction or NULL if not found
! 4814: */
! 4815: xmlXPathFunction
! 4816: xmlXPathFunctionLookupNS(xmlXPathContextPtr ctxt, const xmlChar *name,
! 4817: const xmlChar *ns_uri) {
! 4818: xmlXPathFunction ret;
! 4819:
! 4820: if (ctxt == NULL)
! 4821: return(NULL);
! 4822: if (name == NULL)
! 4823: return(NULL);
! 4824:
! 4825: if (ctxt->funcLookupFunc != NULL) {
! 4826: xmlXPathFuncLookupFunc f;
! 4827:
! 4828: f = ctxt->funcLookupFunc;
! 4829: ret = f(ctxt->funcLookupData, name, ns_uri);
! 4830: if (ret != NULL)
! 4831: return(ret);
! 4832: }
! 4833:
! 4834: if (ctxt->funcHash == NULL)
! 4835: return(NULL);
! 4836:
! 4837: XML_CAST_FPTR(ret) = xmlHashLookup2(ctxt->funcHash, name, ns_uri);
! 4838: return(ret);
! 4839: }
! 4840:
! 4841: /**
! 4842: * xmlXPathRegisteredFuncsCleanup:
! 4843: * @ctxt: the XPath context
! 4844: *
! 4845: * Cleanup the XPath context data associated to registered functions
! 4846: */
! 4847: void
! 4848: xmlXPathRegisteredFuncsCleanup(xmlXPathContextPtr ctxt) {
! 4849: if (ctxt == NULL)
! 4850: return;
! 4851:
! 4852: xmlHashFree(ctxt->funcHash, NULL);
! 4853: ctxt->funcHash = NULL;
! 4854: }
! 4855:
! 4856: /************************************************************************
! 4857: * *
! 4858: * Routines to handle Variables *
! 4859: * *
! 4860: ************************************************************************/
! 4861:
! 4862: /**
! 4863: * xmlXPathRegisterVariable:
! 4864: * @ctxt: the XPath context
! 4865: * @name: the variable name
! 4866: * @value: the variable value or NULL
! 4867: *
! 4868: * Register a new variable value. If @value is NULL it unregisters
! 4869: * the variable
! 4870: *
! 4871: * Returns 0 in case of success, -1 in case of error
! 4872: */
! 4873: int
! 4874: xmlXPathRegisterVariable(xmlXPathContextPtr ctxt, const xmlChar *name,
! 4875: xmlXPathObjectPtr value) {
! 4876: return(xmlXPathRegisterVariableNS(ctxt, name, NULL, value));
! 4877: }
! 4878:
! 4879: /**
! 4880: * xmlXPathRegisterVariableNS:
! 4881: * @ctxt: the XPath context
! 4882: * @name: the variable name
! 4883: * @ns_uri: the variable namespace URI
! 4884: * @value: the variable value or NULL
! 4885: *
! 4886: * Register a new variable value. If @value is NULL it unregisters
! 4887: * the variable
! 4888: *
! 4889: * Returns 0 in case of success, -1 in case of error
! 4890: */
! 4891: int
! 4892: xmlXPathRegisterVariableNS(xmlXPathContextPtr ctxt, const xmlChar *name,
! 4893: const xmlChar *ns_uri,
! 4894: xmlXPathObjectPtr value) {
! 4895: if (ctxt == NULL)
! 4896: return(-1);
! 4897: if (name == NULL)
! 4898: return(-1);
! 4899:
! 4900: if (ctxt->varHash == NULL)
! 4901: ctxt->varHash = xmlHashCreate(0);
! 4902: if (ctxt->varHash == NULL)
! 4903: return(-1);
! 4904: if (value == NULL)
! 4905: return(xmlHashRemoveEntry2(ctxt->varHash, name, ns_uri,
! 4906: (xmlHashDeallocator)xmlXPathFreeObject));
! 4907: return(xmlHashUpdateEntry2(ctxt->varHash, name, ns_uri,
! 4908: (void *) value,
! 4909: (xmlHashDeallocator)xmlXPathFreeObject));
! 4910: }
! 4911:
! 4912: /**
! 4913: * xmlXPathRegisterVariableLookup:
! 4914: * @ctxt: the XPath context
! 4915: * @f: the lookup function
! 4916: * @data: the lookup data
! 4917: *
! 4918: * register an external mechanism to do variable lookup
! 4919: */
! 4920: void
! 4921: xmlXPathRegisterVariableLookup(xmlXPathContextPtr ctxt,
! 4922: xmlXPathVariableLookupFunc f, void *data) {
! 4923: if (ctxt == NULL)
! 4924: return;
! 4925: ctxt->varLookupFunc = f;
! 4926: ctxt->varLookupData = data;
! 4927: }
! 4928:
! 4929: /**
! 4930: * xmlXPathVariableLookup:
! 4931: * @ctxt: the XPath context
! 4932: * @name: the variable name
! 4933: *
! 4934: * Search in the Variable array of the context for the given
! 4935: * variable value.
! 4936: *
! 4937: * Returns a copy of the value or NULL if not found
! 4938: */
! 4939: xmlXPathObjectPtr
! 4940: xmlXPathVariableLookup(xmlXPathContextPtr ctxt, const xmlChar *name) {
! 4941: if (ctxt == NULL)
! 4942: return(NULL);
! 4943:
! 4944: if (ctxt->varLookupFunc != NULL) {
! 4945: xmlXPathObjectPtr ret;
! 4946:
! 4947: ret = ((xmlXPathVariableLookupFunc)ctxt->varLookupFunc)
! 4948: (ctxt->varLookupData, name, NULL);
! 4949: return(ret);
! 4950: }
! 4951: return(xmlXPathVariableLookupNS(ctxt, name, NULL));
! 4952: }
! 4953:
! 4954: /**
! 4955: * xmlXPathVariableLookupNS:
! 4956: * @ctxt: the XPath context
! 4957: * @name: the variable name
! 4958: * @ns_uri: the variable namespace URI
! 4959: *
! 4960: * Search in the Variable array of the context for the given
! 4961: * variable value.
! 4962: *
! 4963: * Returns the a copy of the value or NULL if not found
! 4964: */
! 4965: xmlXPathObjectPtr
! 4966: xmlXPathVariableLookupNS(xmlXPathContextPtr ctxt, const xmlChar *name,
! 4967: const xmlChar *ns_uri) {
! 4968: if (ctxt == NULL)
! 4969: return(NULL);
! 4970:
! 4971: if (ctxt->varLookupFunc != NULL) {
! 4972: xmlXPathObjectPtr ret;
! 4973:
! 4974: ret = ((xmlXPathVariableLookupFunc)ctxt->varLookupFunc)
! 4975: (ctxt->varLookupData, name, ns_uri);
! 4976: if (ret != NULL) return(ret);
! 4977: }
! 4978:
! 4979: if (ctxt->varHash == NULL)
! 4980: return(NULL);
! 4981: if (name == NULL)
! 4982: return(NULL);
! 4983:
! 4984: return(xmlXPathCacheObjectCopy(ctxt, (xmlXPathObjectPtr)
! 4985: xmlHashLookup2(ctxt->varHash, name, ns_uri)));
! 4986: }
! 4987:
! 4988: /**
! 4989: * xmlXPathRegisteredVariablesCleanup:
! 4990: * @ctxt: the XPath context
! 4991: *
! 4992: * Cleanup the XPath context data associated to registered variables
! 4993: */
! 4994: void
! 4995: xmlXPathRegisteredVariablesCleanup(xmlXPathContextPtr ctxt) {
! 4996: if (ctxt == NULL)
! 4997: return;
! 4998:
! 4999: xmlHashFree(ctxt->varHash, (xmlHashDeallocator)xmlXPathFreeObject);
! 5000: ctxt->varHash = NULL;
! 5001: }
! 5002:
! 5003: /**
! 5004: * xmlXPathRegisterNs:
! 5005: * @ctxt: the XPath context
! 5006: * @prefix: the namespace prefix cannot be NULL or empty string
! 5007: * @ns_uri: the namespace name
! 5008: *
! 5009: * Register a new namespace. If @ns_uri is NULL it unregisters
! 5010: * the namespace
! 5011: *
! 5012: * Returns 0 in case of success, -1 in case of error
! 5013: */
! 5014: int
! 5015: xmlXPathRegisterNs(xmlXPathContextPtr ctxt, const xmlChar *prefix,
! 5016: const xmlChar *ns_uri) {
! 5017: if (ctxt == NULL)
! 5018: return(-1);
! 5019: if (prefix == NULL)
! 5020: return(-1);
! 5021: if (prefix[0] == 0)
! 5022: return(-1);
! 5023:
! 5024: if (ctxt->nsHash == NULL)
! 5025: ctxt->nsHash = xmlHashCreate(10);
! 5026: if (ctxt->nsHash == NULL)
! 5027: return(-1);
! 5028: if (ns_uri == NULL)
! 5029: return(xmlHashRemoveEntry(ctxt->nsHash, prefix,
! 5030: (xmlHashDeallocator)xmlFree));
! 5031: return(xmlHashUpdateEntry(ctxt->nsHash, prefix, (void *) xmlStrdup(ns_uri),
! 5032: (xmlHashDeallocator)xmlFree));
! 5033: }
! 5034:
! 5035: /**
! 5036: * xmlXPathNsLookup:
! 5037: * @ctxt: the XPath context
! 5038: * @prefix: the namespace prefix value
! 5039: *
! 5040: * Search in the namespace declaration array of the context for the given
! 5041: * namespace name associated to the given prefix
! 5042: *
! 5043: * Returns the value or NULL if not found
! 5044: */
! 5045: const xmlChar *
! 5046: xmlXPathNsLookup(xmlXPathContextPtr ctxt, const xmlChar *prefix) {
! 5047: if (ctxt == NULL)
! 5048: return(NULL);
! 5049: if (prefix == NULL)
! 5050: return(NULL);
! 5051:
! 5052: #ifdef XML_XML_NAMESPACE
! 5053: if (xmlStrEqual(prefix, (const xmlChar *) "xml"))
! 5054: return(XML_XML_NAMESPACE);
! 5055: #endif
! 5056:
! 5057: if (ctxt->namespaces != NULL) {
! 5058: int i;
! 5059:
! 5060: for (i = 0;i < ctxt->nsNr;i++) {
! 5061: if ((ctxt->namespaces[i] != NULL) &&
! 5062: (xmlStrEqual(ctxt->namespaces[i]->prefix, prefix)))
! 5063: return(ctxt->namespaces[i]->href);
! 5064: }
! 5065: }
! 5066:
! 5067: return((const xmlChar *) xmlHashLookup(ctxt->nsHash, prefix));
! 5068: }
! 5069:
! 5070: /**
! 5071: * xmlXPathRegisteredNsCleanup:
! 5072: * @ctxt: the XPath context
! 5073: *
! 5074: * Cleanup the XPath context data associated to registered variables
! 5075: */
! 5076: void
! 5077: xmlXPathRegisteredNsCleanup(xmlXPathContextPtr ctxt) {
! 5078: if (ctxt == NULL)
! 5079: return;
! 5080:
! 5081: xmlHashFree(ctxt->nsHash, (xmlHashDeallocator)xmlFree);
! 5082: ctxt->nsHash = NULL;
! 5083: }
! 5084:
! 5085: /************************************************************************
! 5086: * *
! 5087: * Routines to handle Values *
! 5088: * *
! 5089: ************************************************************************/
! 5090:
! 5091: /* Allocations are terrible, one needs to optimize all this !!! */
! 5092:
! 5093: /**
! 5094: * xmlXPathNewFloat:
! 5095: * @val: the double value
! 5096: *
! 5097: * Create a new xmlXPathObjectPtr of type double and of value @val
! 5098: *
! 5099: * Returns the newly created object.
! 5100: */
! 5101: xmlXPathObjectPtr
! 5102: xmlXPathNewFloat(double val) {
! 5103: xmlXPathObjectPtr ret;
! 5104:
! 5105: ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
! 5106: if (ret == NULL) {
! 5107: xmlXPathErrMemory(NULL, "creating float object\n");
! 5108: return(NULL);
! 5109: }
! 5110: memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
! 5111: ret->type = XPATH_NUMBER;
! 5112: ret->floatval = val;
! 5113: #ifdef XP_DEBUG_OBJ_USAGE
! 5114: xmlXPathDebugObjUsageRequested(NULL, XPATH_NUMBER);
! 5115: #endif
! 5116: return(ret);
! 5117: }
! 5118:
! 5119: /**
! 5120: * xmlXPathNewBoolean:
! 5121: * @val: the boolean value
! 5122: *
! 5123: * Create a new xmlXPathObjectPtr of type boolean and of value @val
! 5124: *
! 5125: * Returns the newly created object.
! 5126: */
! 5127: xmlXPathObjectPtr
! 5128: xmlXPathNewBoolean(int val) {
! 5129: xmlXPathObjectPtr ret;
! 5130:
! 5131: ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
! 5132: if (ret == NULL) {
! 5133: xmlXPathErrMemory(NULL, "creating boolean object\n");
! 5134: return(NULL);
! 5135: }
! 5136: memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
! 5137: ret->type = XPATH_BOOLEAN;
! 5138: ret->boolval = (val != 0);
! 5139: #ifdef XP_DEBUG_OBJ_USAGE
! 5140: xmlXPathDebugObjUsageRequested(NULL, XPATH_BOOLEAN);
! 5141: #endif
! 5142: return(ret);
! 5143: }
! 5144:
! 5145: /**
! 5146: * xmlXPathNewString:
! 5147: * @val: the xmlChar * value
! 5148: *
! 5149: * Create a new xmlXPathObjectPtr of type string and of value @val
! 5150: *
! 5151: * Returns the newly created object.
! 5152: */
! 5153: xmlXPathObjectPtr
! 5154: xmlXPathNewString(const xmlChar *val) {
! 5155: xmlXPathObjectPtr ret;
! 5156:
! 5157: ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
! 5158: if (ret == NULL) {
! 5159: xmlXPathErrMemory(NULL, "creating string object\n");
! 5160: return(NULL);
! 5161: }
! 5162: memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
! 5163: ret->type = XPATH_STRING;
! 5164: if (val != NULL)
! 5165: ret->stringval = xmlStrdup(val);
! 5166: else
! 5167: ret->stringval = xmlStrdup((const xmlChar *)"");
! 5168: #ifdef XP_DEBUG_OBJ_USAGE
! 5169: xmlXPathDebugObjUsageRequested(NULL, XPATH_STRING);
! 5170: #endif
! 5171: return(ret);
! 5172: }
! 5173:
! 5174: /**
! 5175: * xmlXPathWrapString:
! 5176: * @val: the xmlChar * value
! 5177: *
! 5178: * Wraps the @val string into an XPath object.
! 5179: *
! 5180: * Returns the newly created object.
! 5181: */
! 5182: xmlXPathObjectPtr
! 5183: xmlXPathWrapString (xmlChar *val) {
! 5184: xmlXPathObjectPtr ret;
! 5185:
! 5186: ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
! 5187: if (ret == NULL) {
! 5188: xmlXPathErrMemory(NULL, "creating string object\n");
! 5189: return(NULL);
! 5190: }
! 5191: memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
! 5192: ret->type = XPATH_STRING;
! 5193: ret->stringval = val;
! 5194: #ifdef XP_DEBUG_OBJ_USAGE
! 5195: xmlXPathDebugObjUsageRequested(NULL, XPATH_STRING);
! 5196: #endif
! 5197: return(ret);
! 5198: }
! 5199:
! 5200: /**
! 5201: * xmlXPathNewCString:
! 5202: * @val: the char * value
! 5203: *
! 5204: * Create a new xmlXPathObjectPtr of type string and of value @val
! 5205: *
! 5206: * Returns the newly created object.
! 5207: */
! 5208: xmlXPathObjectPtr
! 5209: xmlXPathNewCString(const char *val) {
! 5210: xmlXPathObjectPtr ret;
! 5211:
! 5212: ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
! 5213: if (ret == NULL) {
! 5214: xmlXPathErrMemory(NULL, "creating string object\n");
! 5215: return(NULL);
! 5216: }
! 5217: memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
! 5218: ret->type = XPATH_STRING;
! 5219: ret->stringval = xmlStrdup(BAD_CAST val);
! 5220: #ifdef XP_DEBUG_OBJ_USAGE
! 5221: xmlXPathDebugObjUsageRequested(NULL, XPATH_STRING);
! 5222: #endif
! 5223: return(ret);
! 5224: }
! 5225:
! 5226: /**
! 5227: * xmlXPathWrapCString:
! 5228: * @val: the char * value
! 5229: *
! 5230: * Wraps a string into an XPath object.
! 5231: *
! 5232: * Returns the newly created object.
! 5233: */
! 5234: xmlXPathObjectPtr
! 5235: xmlXPathWrapCString (char * val) {
! 5236: return(xmlXPathWrapString((xmlChar *)(val)));
! 5237: }
! 5238:
! 5239: /**
! 5240: * xmlXPathWrapExternal:
! 5241: * @val: the user data
! 5242: *
! 5243: * Wraps the @val data into an XPath object.
! 5244: *
! 5245: * Returns the newly created object.
! 5246: */
! 5247: xmlXPathObjectPtr
! 5248: xmlXPathWrapExternal (void *val) {
! 5249: xmlXPathObjectPtr ret;
! 5250:
! 5251: ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
! 5252: if (ret == NULL) {
! 5253: xmlXPathErrMemory(NULL, "creating user object\n");
! 5254: return(NULL);
! 5255: }
! 5256: memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
! 5257: ret->type = XPATH_USERS;
! 5258: ret->user = val;
! 5259: #ifdef XP_DEBUG_OBJ_USAGE
! 5260: xmlXPathDebugObjUsageRequested(NULL, XPATH_USERS);
! 5261: #endif
! 5262: return(ret);
! 5263: }
! 5264:
! 5265: /**
! 5266: * xmlXPathObjectCopy:
! 5267: * @val: the original object
! 5268: *
! 5269: * allocate a new copy of a given object
! 5270: *
! 5271: * Returns the newly created object.
! 5272: */
! 5273: xmlXPathObjectPtr
! 5274: xmlXPathObjectCopy(xmlXPathObjectPtr val) {
! 5275: xmlXPathObjectPtr ret;
! 5276:
! 5277: if (val == NULL)
! 5278: return(NULL);
! 5279:
! 5280: ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
! 5281: if (ret == NULL) {
! 5282: xmlXPathErrMemory(NULL, "copying object\n");
! 5283: return(NULL);
! 5284: }
! 5285: memcpy(ret, val , (size_t) sizeof(xmlXPathObject));
! 5286: #ifdef XP_DEBUG_OBJ_USAGE
! 5287: xmlXPathDebugObjUsageRequested(NULL, val->type);
! 5288: #endif
! 5289: switch (val->type) {
! 5290: case XPATH_BOOLEAN:
! 5291: case XPATH_NUMBER:
! 5292: case XPATH_POINT:
! 5293: case XPATH_RANGE:
! 5294: break;
! 5295: case XPATH_STRING:
! 5296: ret->stringval = xmlStrdup(val->stringval);
! 5297: break;
! 5298: case XPATH_XSLT_TREE:
! 5299: #if 0
! 5300: /*
! 5301: Removed 11 July 2004 - the current handling of xslt tmpRVT nodes means that
! 5302: this previous handling is no longer correct, and can cause some serious
! 5303: problems (ref. bug 145547)
! 5304: */
! 5305: if ((val->nodesetval != NULL) &&
! 5306: (val->nodesetval->nodeTab != NULL)) {
! 5307: xmlNodePtr cur, tmp;
! 5308: xmlDocPtr top;
! 5309:
! 5310: ret->boolval = 1;
! 5311: top = xmlNewDoc(NULL);
! 5312: top->name = (char *)
! 5313: xmlStrdup(val->nodesetval->nodeTab[0]->name);
! 5314: ret->user = top;
! 5315: if (top != NULL) {
! 5316: top->doc = top;
! 5317: cur = val->nodesetval->nodeTab[0]->children;
! 5318: while (cur != NULL) {
! 5319: tmp = xmlDocCopyNode(cur, top, 1);
! 5320: xmlAddChild((xmlNodePtr) top, tmp);
! 5321: cur = cur->next;
! 5322: }
! 5323: }
! 5324:
! 5325: ret->nodesetval = xmlXPathNodeSetCreate((xmlNodePtr) top);
! 5326: } else
! 5327: ret->nodesetval = xmlXPathNodeSetCreate(NULL);
! 5328: /* Deallocate the copied tree value */
! 5329: break;
! 5330: #endif
! 5331: case XPATH_NODESET:
! 5332: ret->nodesetval = xmlXPathNodeSetMerge(NULL, val->nodesetval);
! 5333: /* Do not deallocate the copied tree value */
! 5334: ret->boolval = 0;
! 5335: break;
! 5336: case XPATH_LOCATIONSET:
! 5337: #ifdef LIBXML_XPTR_ENABLED
! 5338: {
! 5339: xmlLocationSetPtr loc = val->user;
! 5340: ret->user = (void *) xmlXPtrLocationSetMerge(NULL, loc);
! 5341: break;
! 5342: }
! 5343: #endif
! 5344: case XPATH_USERS:
! 5345: ret->user = val->user;
! 5346: break;
! 5347: case XPATH_UNDEFINED:
! 5348: xmlGenericError(xmlGenericErrorContext,
! 5349: "xmlXPathObjectCopy: unsupported type %d\n",
! 5350: val->type);
! 5351: break;
! 5352: }
! 5353: return(ret);
! 5354: }
! 5355:
! 5356: /**
! 5357: * xmlXPathFreeObject:
! 5358: * @obj: the object to free
! 5359: *
! 5360: * Free up an xmlXPathObjectPtr object.
! 5361: */
! 5362: void
! 5363: xmlXPathFreeObject(xmlXPathObjectPtr obj) {
! 5364: if (obj == NULL) return;
! 5365: if ((obj->type == XPATH_NODESET) || (obj->type == XPATH_XSLT_TREE)) {
! 5366: if (obj->boolval) {
! 5367: #if 0
! 5368: if (obj->user != NULL) {
! 5369: xmlXPathFreeNodeSet(obj->nodesetval);
! 5370: xmlFreeNodeList((xmlNodePtr) obj->user);
! 5371: } else
! 5372: #endif
! 5373: obj->type = XPATH_XSLT_TREE; /* TODO: Just for debugging. */
! 5374: if (obj->nodesetval != NULL)
! 5375: xmlXPathFreeValueTree(obj->nodesetval);
! 5376: } else {
! 5377: if (obj->nodesetval != NULL)
! 5378: xmlXPathFreeNodeSet(obj->nodesetval);
! 5379: }
! 5380: #ifdef LIBXML_XPTR_ENABLED
! 5381: } else if (obj->type == XPATH_LOCATIONSET) {
! 5382: if (obj->user != NULL)
! 5383: xmlXPtrFreeLocationSet(obj->user);
! 5384: #endif
! 5385: } else if (obj->type == XPATH_STRING) {
! 5386: if (obj->stringval != NULL)
! 5387: xmlFree(obj->stringval);
! 5388: }
! 5389: #ifdef XP_DEBUG_OBJ_USAGE
! 5390: xmlXPathDebugObjUsageReleased(NULL, obj->type);
! 5391: #endif
! 5392: xmlFree(obj);
! 5393: }
! 5394:
! 5395: /**
! 5396: * xmlXPathReleaseObject:
! 5397: * @obj: the xmlXPathObjectPtr to free or to cache
! 5398: *
! 5399: * Depending on the state of the cache this frees the given
! 5400: * XPath object or stores it in the cache.
! 5401: */
! 5402: static void
! 5403: xmlXPathReleaseObject(xmlXPathContextPtr ctxt, xmlXPathObjectPtr obj)
! 5404: {
! 5405: #define XP_CACHE_ADD(sl, o) if (sl == NULL) { \
! 5406: sl = xmlPointerListCreate(10); if (sl == NULL) goto free_obj; } \
! 5407: if (xmlPointerListAddSize(sl, obj, 0) == -1) goto free_obj;
! 5408:
! 5409: #define XP_CACHE_WANTS(sl, n) ((sl == NULL) || ((sl)->number < n))
! 5410:
! 5411: if (obj == NULL)
! 5412: return;
! 5413: if ((ctxt == NULL) || (ctxt->cache == NULL)) {
! 5414: xmlXPathFreeObject(obj);
! 5415: } else {
! 5416: xmlXPathContextCachePtr cache =
! 5417: (xmlXPathContextCachePtr) ctxt->cache;
! 5418:
! 5419: switch (obj->type) {
! 5420: case XPATH_NODESET:
! 5421: case XPATH_XSLT_TREE:
! 5422: if (obj->nodesetval != NULL) {
! 5423: if (obj->boolval) {
! 5424: /*
! 5425: * It looks like the @boolval is used for
! 5426: * evaluation if this an XSLT Result Tree Fragment.
! 5427: * TODO: Check if this assumption is correct.
! 5428: */
! 5429: obj->type = XPATH_XSLT_TREE; /* just for debugging */
! 5430: xmlXPathFreeValueTree(obj->nodesetval);
! 5431: obj->nodesetval = NULL;
! 5432: } else if ((obj->nodesetval->nodeMax <= 40) &&
! 5433: (XP_CACHE_WANTS(cache->nodesetObjs,
! 5434: cache->maxNodeset)))
! 5435: {
! 5436: XP_CACHE_ADD(cache->nodesetObjs, obj);
! 5437: goto obj_cached;
! 5438: } else {
! 5439: xmlXPathFreeNodeSet(obj->nodesetval);
! 5440: obj->nodesetval = NULL;
! 5441: }
! 5442: }
! 5443: break;
! 5444: case XPATH_STRING:
! 5445: if (obj->stringval != NULL)
! 5446: xmlFree(obj->stringval);
! 5447:
! 5448: if (XP_CACHE_WANTS(cache->stringObjs, cache->maxString)) {
! 5449: XP_CACHE_ADD(cache->stringObjs, obj);
! 5450: goto obj_cached;
! 5451: }
! 5452: break;
! 5453: case XPATH_BOOLEAN:
! 5454: if (XP_CACHE_WANTS(cache->booleanObjs, cache->maxBoolean)) {
! 5455: XP_CACHE_ADD(cache->booleanObjs, obj);
! 5456: goto obj_cached;
! 5457: }
! 5458: break;
! 5459: case XPATH_NUMBER:
! 5460: if (XP_CACHE_WANTS(cache->numberObjs, cache->maxNumber)) {
! 5461: XP_CACHE_ADD(cache->numberObjs, obj);
! 5462: goto obj_cached;
! 5463: }
! 5464: break;
! 5465: #ifdef LIBXML_XPTR_ENABLED
! 5466: case XPATH_LOCATIONSET:
! 5467: if (obj->user != NULL) {
! 5468: xmlXPtrFreeLocationSet(obj->user);
! 5469: }
! 5470: goto free_obj;
! 5471: #endif
! 5472: default:
! 5473: goto free_obj;
! 5474: }
! 5475:
! 5476: /*
! 5477: * Fallback to adding to the misc-objects slot.
! 5478: */
! 5479: if (XP_CACHE_WANTS(cache->miscObjs, cache->maxMisc)) {
! 5480: XP_CACHE_ADD(cache->miscObjs, obj);
! 5481: } else
! 5482: goto free_obj;
! 5483:
! 5484: obj_cached:
! 5485:
! 5486: #ifdef XP_DEBUG_OBJ_USAGE
! 5487: xmlXPathDebugObjUsageReleased(ctxt, obj->type);
! 5488: #endif
! 5489:
! 5490: if (obj->nodesetval != NULL) {
! 5491: xmlNodeSetPtr tmpset = obj->nodesetval;
! 5492:
! 5493: /*
! 5494: * TODO: Due to those nasty ns-nodes, we need to traverse
! 5495: * the list and free the ns-nodes.
! 5496: * URGENT TODO: Check if it's actually slowing things down.
! 5497: * Maybe we shouldn't try to preserve the list.
! 5498: */
! 5499: if (tmpset->nodeNr > 1) {
! 5500: int i;
! 5501: xmlNodePtr node;
! 5502:
! 5503: for (i = 0; i < tmpset->nodeNr; i++) {
! 5504: node = tmpset->nodeTab[i];
! 5505: if ((node != NULL) &&
! 5506: (node->type == XML_NAMESPACE_DECL))
! 5507: {
! 5508: xmlXPathNodeSetFreeNs((xmlNsPtr) node);
! 5509: }
! 5510: }
! 5511: } else if (tmpset->nodeNr == 1) {
! 5512: if ((tmpset->nodeTab[0] != NULL) &&
! 5513: (tmpset->nodeTab[0]->type == XML_NAMESPACE_DECL))
! 5514: xmlXPathNodeSetFreeNs((xmlNsPtr) tmpset->nodeTab[0]);
! 5515: }
! 5516: tmpset->nodeNr = 0;
! 5517: memset(obj, 0, sizeof(xmlXPathObject));
! 5518: obj->nodesetval = tmpset;
! 5519: } else
! 5520: memset(obj, 0, sizeof(xmlXPathObject));
! 5521:
! 5522: return;
! 5523:
! 5524: free_obj:
! 5525: /*
! 5526: * Cache is full; free the object.
! 5527: */
! 5528: if (obj->nodesetval != NULL)
! 5529: xmlXPathFreeNodeSet(obj->nodesetval);
! 5530: #ifdef XP_DEBUG_OBJ_USAGE
! 5531: xmlXPathDebugObjUsageReleased(NULL, obj->type);
! 5532: #endif
! 5533: xmlFree(obj);
! 5534: }
! 5535: return;
! 5536: }
! 5537:
! 5538:
! 5539: /************************************************************************
! 5540: * *
! 5541: * Type Casting Routines *
! 5542: * *
! 5543: ************************************************************************/
! 5544:
! 5545: /**
! 5546: * xmlXPathCastBooleanToString:
! 5547: * @val: a boolean
! 5548: *
! 5549: * Converts a boolean to its string value.
! 5550: *
! 5551: * Returns a newly allocated string.
! 5552: */
! 5553: xmlChar *
! 5554: xmlXPathCastBooleanToString (int val) {
! 5555: xmlChar *ret;
! 5556: if (val)
! 5557: ret = xmlStrdup((const xmlChar *) "true");
! 5558: else
! 5559: ret = xmlStrdup((const xmlChar *) "false");
! 5560: return(ret);
! 5561: }
! 5562:
! 5563: /**
! 5564: * xmlXPathCastNumberToString:
! 5565: * @val: a number
! 5566: *
! 5567: * Converts a number to its string value.
! 5568: *
! 5569: * Returns a newly allocated string.
! 5570: */
! 5571: xmlChar *
! 5572: xmlXPathCastNumberToString (double val) {
! 5573: xmlChar *ret;
! 5574: switch (xmlXPathIsInf(val)) {
! 5575: case 1:
! 5576: ret = xmlStrdup((const xmlChar *) "Infinity");
! 5577: break;
! 5578: case -1:
! 5579: ret = xmlStrdup((const xmlChar *) "-Infinity");
! 5580: break;
! 5581: default:
! 5582: if (xmlXPathIsNaN(val)) {
! 5583: ret = xmlStrdup((const xmlChar *) "NaN");
! 5584: } else if (val == 0 && xmlXPathGetSign(val) != 0) {
! 5585: ret = xmlStrdup((const xmlChar *) "0");
! 5586: } else {
! 5587: /* could be improved */
! 5588: char buf[100];
! 5589: xmlXPathFormatNumber(val, buf, 99);
! 5590: buf[99] = 0;
! 5591: ret = xmlStrdup((const xmlChar *) buf);
! 5592: }
! 5593: }
! 5594: return(ret);
! 5595: }
! 5596:
! 5597: /**
! 5598: * xmlXPathCastNodeToString:
! 5599: * @node: a node
! 5600: *
! 5601: * Converts a node to its string value.
! 5602: *
! 5603: * Returns a newly allocated string.
! 5604: */
! 5605: xmlChar *
! 5606: xmlXPathCastNodeToString (xmlNodePtr node) {
! 5607: xmlChar *ret;
! 5608: if ((ret = xmlNodeGetContent(node)) == NULL)
! 5609: ret = xmlStrdup((const xmlChar *) "");
! 5610: return(ret);
! 5611: }
! 5612:
! 5613: /**
! 5614: * xmlXPathCastNodeSetToString:
! 5615: * @ns: a node-set
! 5616: *
! 5617: * Converts a node-set to its string value.
! 5618: *
! 5619: * Returns a newly allocated string.
! 5620: */
! 5621: xmlChar *
! 5622: xmlXPathCastNodeSetToString (xmlNodeSetPtr ns) {
! 5623: if ((ns == NULL) || (ns->nodeNr == 0) || (ns->nodeTab == NULL))
! 5624: return(xmlStrdup((const xmlChar *) ""));
! 5625:
! 5626: if (ns->nodeNr > 1)
! 5627: xmlXPathNodeSetSort(ns);
! 5628: return(xmlXPathCastNodeToString(ns->nodeTab[0]));
! 5629: }
! 5630:
! 5631: /**
! 5632: * xmlXPathCastToString:
! 5633: * @val: an XPath object
! 5634: *
! 5635: * Converts an existing object to its string() equivalent
! 5636: *
! 5637: * Returns the allocated string value of the object, NULL in case of error.
! 5638: * It's up to the caller to free the string memory with xmlFree().
! 5639: */
! 5640: xmlChar *
! 5641: xmlXPathCastToString(xmlXPathObjectPtr val) {
! 5642: xmlChar *ret = NULL;
! 5643:
! 5644: if (val == NULL)
! 5645: return(xmlStrdup((const xmlChar *) ""));
! 5646: switch (val->type) {
! 5647: case XPATH_UNDEFINED:
! 5648: #ifdef DEBUG_EXPR
! 5649: xmlGenericError(xmlGenericErrorContext, "String: undefined\n");
! 5650: #endif
! 5651: ret = xmlStrdup((const xmlChar *) "");
! 5652: break;
! 5653: case XPATH_NODESET:
! 5654: case XPATH_XSLT_TREE:
! 5655: ret = xmlXPathCastNodeSetToString(val->nodesetval);
! 5656: break;
! 5657: case XPATH_STRING:
! 5658: return(xmlStrdup(val->stringval));
! 5659: case XPATH_BOOLEAN:
! 5660: ret = xmlXPathCastBooleanToString(val->boolval);
! 5661: break;
! 5662: case XPATH_NUMBER: {
! 5663: ret = xmlXPathCastNumberToString(val->floatval);
! 5664: break;
! 5665: }
! 5666: case XPATH_USERS:
! 5667: case XPATH_POINT:
! 5668: case XPATH_RANGE:
! 5669: case XPATH_LOCATIONSET:
! 5670: TODO
! 5671: ret = xmlStrdup((const xmlChar *) "");
! 5672: break;
! 5673: }
! 5674: return(ret);
! 5675: }
! 5676:
! 5677: /**
! 5678: * xmlXPathConvertString:
! 5679: * @val: an XPath object
! 5680: *
! 5681: * Converts an existing object to its string() equivalent
! 5682: *
! 5683: * Returns the new object, the old one is freed (or the operation
! 5684: * is done directly on @val)
! 5685: */
! 5686: xmlXPathObjectPtr
! 5687: xmlXPathConvertString(xmlXPathObjectPtr val) {
! 5688: xmlChar *res = NULL;
! 5689:
! 5690: if (val == NULL)
! 5691: return(xmlXPathNewCString(""));
! 5692:
! 5693: switch (val->type) {
! 5694: case XPATH_UNDEFINED:
! 5695: #ifdef DEBUG_EXPR
! 5696: xmlGenericError(xmlGenericErrorContext, "STRING: undefined\n");
! 5697: #endif
! 5698: break;
! 5699: case XPATH_NODESET:
! 5700: case XPATH_XSLT_TREE:
! 5701: res = xmlXPathCastNodeSetToString(val->nodesetval);
! 5702: break;
! 5703: case XPATH_STRING:
! 5704: return(val);
! 5705: case XPATH_BOOLEAN:
! 5706: res = xmlXPathCastBooleanToString(val->boolval);
! 5707: break;
! 5708: case XPATH_NUMBER:
! 5709: res = xmlXPathCastNumberToString(val->floatval);
! 5710: break;
! 5711: case XPATH_USERS:
! 5712: case XPATH_POINT:
! 5713: case XPATH_RANGE:
! 5714: case XPATH_LOCATIONSET:
! 5715: TODO;
! 5716: break;
! 5717: }
! 5718: xmlXPathFreeObject(val);
! 5719: if (res == NULL)
! 5720: return(xmlXPathNewCString(""));
! 5721: return(xmlXPathWrapString(res));
! 5722: }
! 5723:
! 5724: /**
! 5725: * xmlXPathCastBooleanToNumber:
! 5726: * @val: a boolean
! 5727: *
! 5728: * Converts a boolean to its number value
! 5729: *
! 5730: * Returns the number value
! 5731: */
! 5732: double
! 5733: xmlXPathCastBooleanToNumber(int val) {
! 5734: if (val)
! 5735: return(1.0);
! 5736: return(0.0);
! 5737: }
! 5738:
! 5739: /**
! 5740: * xmlXPathCastStringToNumber:
! 5741: * @val: a string
! 5742: *
! 5743: * Converts a string to its number value
! 5744: *
! 5745: * Returns the number value
! 5746: */
! 5747: double
! 5748: xmlXPathCastStringToNumber(const xmlChar * val) {
! 5749: return(xmlXPathStringEvalNumber(val));
! 5750: }
! 5751:
! 5752: /**
! 5753: * xmlXPathCastNodeToNumber:
! 5754: * @node: a node
! 5755: *
! 5756: * Converts a node to its number value
! 5757: *
! 5758: * Returns the number value
! 5759: */
! 5760: double
! 5761: xmlXPathCastNodeToNumber (xmlNodePtr node) {
! 5762: xmlChar *strval;
! 5763: double ret;
! 5764:
! 5765: if (node == NULL)
! 5766: return(xmlXPathNAN);
! 5767: strval = xmlXPathCastNodeToString(node);
! 5768: if (strval == NULL)
! 5769: return(xmlXPathNAN);
! 5770: ret = xmlXPathCastStringToNumber(strval);
! 5771: xmlFree(strval);
! 5772:
! 5773: return(ret);
! 5774: }
! 5775:
! 5776: /**
! 5777: * xmlXPathCastNodeSetToNumber:
! 5778: * @ns: a node-set
! 5779: *
! 5780: * Converts a node-set to its number value
! 5781: *
! 5782: * Returns the number value
! 5783: */
! 5784: double
! 5785: xmlXPathCastNodeSetToNumber (xmlNodeSetPtr ns) {
! 5786: xmlChar *str;
! 5787: double ret;
! 5788:
! 5789: if (ns == NULL)
! 5790: return(xmlXPathNAN);
! 5791: str = xmlXPathCastNodeSetToString(ns);
! 5792: ret = xmlXPathCastStringToNumber(str);
! 5793: xmlFree(str);
! 5794: return(ret);
! 5795: }
! 5796:
! 5797: /**
! 5798: * xmlXPathCastToNumber:
! 5799: * @val: an XPath object
! 5800: *
! 5801: * Converts an XPath object to its number value
! 5802: *
! 5803: * Returns the number value
! 5804: */
! 5805: double
! 5806: xmlXPathCastToNumber(xmlXPathObjectPtr val) {
! 5807: double ret = 0.0;
! 5808:
! 5809: if (val == NULL)
! 5810: return(xmlXPathNAN);
! 5811: switch (val->type) {
! 5812: case XPATH_UNDEFINED:
! 5813: #ifdef DEGUB_EXPR
! 5814: xmlGenericError(xmlGenericErrorContext, "NUMBER: undefined\n");
! 5815: #endif
! 5816: ret = xmlXPathNAN;
! 5817: break;
! 5818: case XPATH_NODESET:
! 5819: case XPATH_XSLT_TREE:
! 5820: ret = xmlXPathCastNodeSetToNumber(val->nodesetval);
! 5821: break;
! 5822: case XPATH_STRING:
! 5823: ret = xmlXPathCastStringToNumber(val->stringval);
! 5824: break;
! 5825: case XPATH_NUMBER:
! 5826: ret = val->floatval;
! 5827: break;
! 5828: case XPATH_BOOLEAN:
! 5829: ret = xmlXPathCastBooleanToNumber(val->boolval);
! 5830: break;
! 5831: case XPATH_USERS:
! 5832: case XPATH_POINT:
! 5833: case XPATH_RANGE:
! 5834: case XPATH_LOCATIONSET:
! 5835: TODO;
! 5836: ret = xmlXPathNAN;
! 5837: break;
! 5838: }
! 5839: return(ret);
! 5840: }
! 5841:
! 5842: /**
! 5843: * xmlXPathConvertNumber:
! 5844: * @val: an XPath object
! 5845: *
! 5846: * Converts an existing object to its number() equivalent
! 5847: *
! 5848: * Returns the new object, the old one is freed (or the operation
! 5849: * is done directly on @val)
! 5850: */
! 5851: xmlXPathObjectPtr
! 5852: xmlXPathConvertNumber(xmlXPathObjectPtr val) {
! 5853: xmlXPathObjectPtr ret;
! 5854:
! 5855: if (val == NULL)
! 5856: return(xmlXPathNewFloat(0.0));
! 5857: if (val->type == XPATH_NUMBER)
! 5858: return(val);
! 5859: ret = xmlXPathNewFloat(xmlXPathCastToNumber(val));
! 5860: xmlXPathFreeObject(val);
! 5861: return(ret);
! 5862: }
! 5863:
! 5864: /**
! 5865: * xmlXPathCastNumberToBoolean:
! 5866: * @val: a number
! 5867: *
! 5868: * Converts a number to its boolean value
! 5869: *
! 5870: * Returns the boolean value
! 5871: */
! 5872: int
! 5873: xmlXPathCastNumberToBoolean (double val) {
! 5874: if (xmlXPathIsNaN(val) || (val == 0.0))
! 5875: return(0);
! 5876: return(1);
! 5877: }
! 5878:
! 5879: /**
! 5880: * xmlXPathCastStringToBoolean:
! 5881: * @val: a string
! 5882: *
! 5883: * Converts a string to its boolean value
! 5884: *
! 5885: * Returns the boolean value
! 5886: */
! 5887: int
! 5888: xmlXPathCastStringToBoolean (const xmlChar *val) {
! 5889: if ((val == NULL) || (xmlStrlen(val) == 0))
! 5890: return(0);
! 5891: return(1);
! 5892: }
! 5893:
! 5894: /**
! 5895: * xmlXPathCastNodeSetToBoolean:
! 5896: * @ns: a node-set
! 5897: *
! 5898: * Converts a node-set to its boolean value
! 5899: *
! 5900: * Returns the boolean value
! 5901: */
! 5902: int
! 5903: xmlXPathCastNodeSetToBoolean (xmlNodeSetPtr ns) {
! 5904: if ((ns == NULL) || (ns->nodeNr == 0))
! 5905: return(0);
! 5906: return(1);
! 5907: }
! 5908:
! 5909: /**
! 5910: * xmlXPathCastToBoolean:
! 5911: * @val: an XPath object
! 5912: *
! 5913: * Converts an XPath object to its boolean value
! 5914: *
! 5915: * Returns the boolean value
! 5916: */
! 5917: int
! 5918: xmlXPathCastToBoolean (xmlXPathObjectPtr val) {
! 5919: int ret = 0;
! 5920:
! 5921: if (val == NULL)
! 5922: return(0);
! 5923: switch (val->type) {
! 5924: case XPATH_UNDEFINED:
! 5925: #ifdef DEBUG_EXPR
! 5926: xmlGenericError(xmlGenericErrorContext, "BOOLEAN: undefined\n");
! 5927: #endif
! 5928: ret = 0;
! 5929: break;
! 5930: case XPATH_NODESET:
! 5931: case XPATH_XSLT_TREE:
! 5932: ret = xmlXPathCastNodeSetToBoolean(val->nodesetval);
! 5933: break;
! 5934: case XPATH_STRING:
! 5935: ret = xmlXPathCastStringToBoolean(val->stringval);
! 5936: break;
! 5937: case XPATH_NUMBER:
! 5938: ret = xmlXPathCastNumberToBoolean(val->floatval);
! 5939: break;
! 5940: case XPATH_BOOLEAN:
! 5941: ret = val->boolval;
! 5942: break;
! 5943: case XPATH_USERS:
! 5944: case XPATH_POINT:
! 5945: case XPATH_RANGE:
! 5946: case XPATH_LOCATIONSET:
! 5947: TODO;
! 5948: ret = 0;
! 5949: break;
! 5950: }
! 5951: return(ret);
! 5952: }
! 5953:
! 5954:
! 5955: /**
! 5956: * xmlXPathConvertBoolean:
! 5957: * @val: an XPath object
! 5958: *
! 5959: * Converts an existing object to its boolean() equivalent
! 5960: *
! 5961: * Returns the new object, the old one is freed (or the operation
! 5962: * is done directly on @val)
! 5963: */
! 5964: xmlXPathObjectPtr
! 5965: xmlXPathConvertBoolean(xmlXPathObjectPtr val) {
! 5966: xmlXPathObjectPtr ret;
! 5967:
! 5968: if (val == NULL)
! 5969: return(xmlXPathNewBoolean(0));
! 5970: if (val->type == XPATH_BOOLEAN)
! 5971: return(val);
! 5972: ret = xmlXPathNewBoolean(xmlXPathCastToBoolean(val));
! 5973: xmlXPathFreeObject(val);
! 5974: return(ret);
! 5975: }
! 5976:
! 5977: /************************************************************************
! 5978: * *
! 5979: * Routines to handle XPath contexts *
! 5980: * *
! 5981: ************************************************************************/
! 5982:
! 5983: /**
! 5984: * xmlXPathNewContext:
! 5985: * @doc: the XML document
! 5986: *
! 5987: * Create a new xmlXPathContext
! 5988: *
! 5989: * Returns the xmlXPathContext just allocated. The caller will need to free it.
! 5990: */
! 5991: xmlXPathContextPtr
! 5992: xmlXPathNewContext(xmlDocPtr doc) {
! 5993: xmlXPathContextPtr ret;
! 5994:
! 5995: ret = (xmlXPathContextPtr) xmlMalloc(sizeof(xmlXPathContext));
! 5996: if (ret == NULL) {
! 5997: xmlXPathErrMemory(NULL, "creating context\n");
! 5998: return(NULL);
! 5999: }
! 6000: memset(ret, 0 , (size_t) sizeof(xmlXPathContext));
! 6001: ret->doc = doc;
! 6002: ret->node = NULL;
! 6003:
! 6004: ret->varHash = NULL;
! 6005:
! 6006: ret->nb_types = 0;
! 6007: ret->max_types = 0;
! 6008: ret->types = NULL;
! 6009:
! 6010: ret->funcHash = xmlHashCreate(0);
! 6011:
! 6012: ret->nb_axis = 0;
! 6013: ret->max_axis = 0;
! 6014: ret->axis = NULL;
! 6015:
! 6016: ret->nsHash = NULL;
! 6017: ret->user = NULL;
! 6018:
! 6019: ret->contextSize = -1;
! 6020: ret->proximityPosition = -1;
! 6021:
! 6022: #ifdef XP_DEFAULT_CACHE_ON
! 6023: if (xmlXPathContextSetCache(ret, 1, -1, 0) == -1) {
! 6024: xmlXPathFreeContext(ret);
! 6025: return(NULL);
! 6026: }
! 6027: #endif
! 6028:
! 6029: xmlXPathRegisterAllFunctions(ret);
! 6030:
! 6031: return(ret);
! 6032: }
! 6033:
! 6034: /**
! 6035: * xmlXPathFreeContext:
! 6036: * @ctxt: the context to free
! 6037: *
! 6038: * Free up an xmlXPathContext
! 6039: */
! 6040: void
! 6041: xmlXPathFreeContext(xmlXPathContextPtr ctxt) {
! 6042: if (ctxt == NULL) return;
! 6043:
! 6044: if (ctxt->cache != NULL)
! 6045: xmlXPathFreeCache((xmlXPathContextCachePtr) ctxt->cache);
! 6046: xmlXPathRegisteredNsCleanup(ctxt);
! 6047: xmlXPathRegisteredFuncsCleanup(ctxt);
! 6048: xmlXPathRegisteredVariablesCleanup(ctxt);
! 6049: xmlResetError(&ctxt->lastError);
! 6050: xmlFree(ctxt);
! 6051: }
! 6052:
! 6053: /************************************************************************
! 6054: * *
! 6055: * Routines to handle XPath parser contexts *
! 6056: * *
! 6057: ************************************************************************/
! 6058:
! 6059: #define CHECK_CTXT(ctxt) \
! 6060: if (ctxt == NULL) { \
! 6061: __xmlRaiseError(NULL, NULL, NULL, \
! 6062: NULL, NULL, XML_FROM_XPATH, \
! 6063: XML_ERR_INTERNAL_ERROR, XML_ERR_FATAL, \
! 6064: __FILE__, __LINE__, \
! 6065: NULL, NULL, NULL, 0, 0, \
! 6066: "NULL context pointer\n"); \
! 6067: return(NULL); \
! 6068: } \
! 6069:
! 6070: #define CHECK_CTXT_NEG(ctxt) \
! 6071: if (ctxt == NULL) { \
! 6072: __xmlRaiseError(NULL, NULL, NULL, \
! 6073: NULL, NULL, XML_FROM_XPATH, \
! 6074: XML_ERR_INTERNAL_ERROR, XML_ERR_FATAL, \
! 6075: __FILE__, __LINE__, \
! 6076: NULL, NULL, NULL, 0, 0, \
! 6077: "NULL context pointer\n"); \
! 6078: return(-1); \
! 6079: } \
! 6080:
! 6081:
! 6082: #define CHECK_CONTEXT(ctxt) \
! 6083: if ((ctxt == NULL) || (ctxt->doc == NULL) || \
! 6084: (ctxt->doc->children == NULL)) { \
! 6085: xmlXPatherror(ctxt, __FILE__, __LINE__, XPATH_INVALID_CTXT); \
! 6086: return(NULL); \
! 6087: }
! 6088:
! 6089:
! 6090: /**
! 6091: * xmlXPathNewParserContext:
! 6092: * @str: the XPath expression
! 6093: * @ctxt: the XPath context
! 6094: *
! 6095: * Create a new xmlXPathParserContext
! 6096: *
! 6097: * Returns the xmlXPathParserContext just allocated.
! 6098: */
! 6099: xmlXPathParserContextPtr
! 6100: xmlXPathNewParserContext(const xmlChar *str, xmlXPathContextPtr ctxt) {
! 6101: xmlXPathParserContextPtr ret;
! 6102:
! 6103: ret = (xmlXPathParserContextPtr) xmlMalloc(sizeof(xmlXPathParserContext));
! 6104: if (ret == NULL) {
! 6105: xmlXPathErrMemory(ctxt, "creating parser context\n");
! 6106: return(NULL);
! 6107: }
! 6108: memset(ret, 0 , (size_t) sizeof(xmlXPathParserContext));
! 6109: ret->cur = ret->base = str;
! 6110: ret->context = ctxt;
! 6111:
! 6112: ret->comp = xmlXPathNewCompExpr();
! 6113: if (ret->comp == NULL) {
! 6114: xmlFree(ret->valueTab);
! 6115: xmlFree(ret);
! 6116: return(NULL);
! 6117: }
! 6118: if ((ctxt != NULL) && (ctxt->dict != NULL)) {
! 6119: ret->comp->dict = ctxt->dict;
! 6120: xmlDictReference(ret->comp->dict);
! 6121: }
! 6122:
! 6123: return(ret);
! 6124: }
! 6125:
! 6126: /**
! 6127: * xmlXPathCompParserContext:
! 6128: * @comp: the XPath compiled expression
! 6129: * @ctxt: the XPath context
! 6130: *
! 6131: * Create a new xmlXPathParserContext when processing a compiled expression
! 6132: *
! 6133: * Returns the xmlXPathParserContext just allocated.
! 6134: */
! 6135: static xmlXPathParserContextPtr
! 6136: xmlXPathCompParserContext(xmlXPathCompExprPtr comp, xmlXPathContextPtr ctxt) {
! 6137: xmlXPathParserContextPtr ret;
! 6138:
! 6139: ret = (xmlXPathParserContextPtr) xmlMalloc(sizeof(xmlXPathParserContext));
! 6140: if (ret == NULL) {
! 6141: xmlXPathErrMemory(ctxt, "creating evaluation context\n");
! 6142: return(NULL);
! 6143: }
! 6144: memset(ret, 0 , (size_t) sizeof(xmlXPathParserContext));
! 6145:
! 6146: /* Allocate the value stack */
! 6147: ret->valueTab = (xmlXPathObjectPtr *)
! 6148: xmlMalloc(10 * sizeof(xmlXPathObjectPtr));
! 6149: if (ret->valueTab == NULL) {
! 6150: xmlFree(ret);
! 6151: xmlXPathErrMemory(ctxt, "creating evaluation context\n");
! 6152: return(NULL);
! 6153: }
! 6154: ret->valueNr = 0;
! 6155: ret->valueMax = 10;
! 6156: ret->value = NULL;
! 6157:
! 6158: ret->context = ctxt;
! 6159: ret->comp = comp;
! 6160:
! 6161: return(ret);
! 6162: }
! 6163:
! 6164: /**
! 6165: * xmlXPathFreeParserContext:
! 6166: * @ctxt: the context to free
! 6167: *
! 6168: * Free up an xmlXPathParserContext
! 6169: */
! 6170: void
! 6171: xmlXPathFreeParserContext(xmlXPathParserContextPtr ctxt) {
! 6172: if (ctxt->valueTab != NULL) {
! 6173: xmlFree(ctxt->valueTab);
! 6174: }
! 6175: if (ctxt->comp != NULL) {
! 6176: #ifdef XPATH_STREAMING
! 6177: if (ctxt->comp->stream != NULL) {
! 6178: xmlFreePatternList(ctxt->comp->stream);
! 6179: ctxt->comp->stream = NULL;
! 6180: }
! 6181: #endif
! 6182: xmlXPathFreeCompExpr(ctxt->comp);
! 6183: }
! 6184: xmlFree(ctxt);
! 6185: }
! 6186:
! 6187: /************************************************************************
! 6188: * *
! 6189: * The implicit core function library *
! 6190: * *
! 6191: ************************************************************************/
! 6192:
! 6193: /**
! 6194: * xmlXPathNodeValHash:
! 6195: * @node: a node pointer
! 6196: *
! 6197: * Function computing the beginning of the string value of the node,
! 6198: * used to speed up comparisons
! 6199: *
! 6200: * Returns an int usable as a hash
! 6201: */
! 6202: static unsigned int
! 6203: xmlXPathNodeValHash(xmlNodePtr node) {
! 6204: int len = 2;
! 6205: const xmlChar * string = NULL;
! 6206: xmlNodePtr tmp = NULL;
! 6207: unsigned int ret = 0;
! 6208:
! 6209: if (node == NULL)
! 6210: return(0);
! 6211:
! 6212: if (node->type == XML_DOCUMENT_NODE) {
! 6213: tmp = xmlDocGetRootElement((xmlDocPtr) node);
! 6214: if (tmp == NULL)
! 6215: node = node->children;
! 6216: else
! 6217: node = tmp;
! 6218:
! 6219: if (node == NULL)
! 6220: return(0);
! 6221: }
! 6222:
! 6223: switch (node->type) {
! 6224: case XML_COMMENT_NODE:
! 6225: case XML_PI_NODE:
! 6226: case XML_CDATA_SECTION_NODE:
! 6227: case XML_TEXT_NODE:
! 6228: string = node->content;
! 6229: if (string == NULL)
! 6230: return(0);
! 6231: if (string[0] == 0)
! 6232: return(0);
! 6233: return(((unsigned int) string[0]) +
! 6234: (((unsigned int) string[1]) << 8));
! 6235: case XML_NAMESPACE_DECL:
! 6236: string = ((xmlNsPtr)node)->href;
! 6237: if (string == NULL)
! 6238: return(0);
! 6239: if (string[0] == 0)
! 6240: return(0);
! 6241: return(((unsigned int) string[0]) +
! 6242: (((unsigned int) string[1]) << 8));
! 6243: case XML_ATTRIBUTE_NODE:
! 6244: tmp = ((xmlAttrPtr) node)->children;
! 6245: break;
! 6246: case XML_ELEMENT_NODE:
! 6247: tmp = node->children;
! 6248: break;
! 6249: default:
! 6250: return(0);
! 6251: }
! 6252: while (tmp != NULL) {
! 6253: switch (tmp->type) {
! 6254: case XML_COMMENT_NODE:
! 6255: case XML_PI_NODE:
! 6256: case XML_CDATA_SECTION_NODE:
! 6257: case XML_TEXT_NODE:
! 6258: string = tmp->content;
! 6259: break;
! 6260: case XML_NAMESPACE_DECL:
! 6261: string = ((xmlNsPtr)tmp)->href;
! 6262: break;
! 6263: default:
! 6264: break;
! 6265: }
! 6266: if ((string != NULL) && (string[0] != 0)) {
! 6267: if (len == 1) {
! 6268: return(ret + (((unsigned int) string[0]) << 8));
! 6269: }
! 6270: if (string[1] == 0) {
! 6271: len = 1;
! 6272: ret = (unsigned int) string[0];
! 6273: } else {
! 6274: return(((unsigned int) string[0]) +
! 6275: (((unsigned int) string[1]) << 8));
! 6276: }
! 6277: }
! 6278: /*
! 6279: * Skip to next node
! 6280: */
! 6281: if ((tmp->children != NULL) && (tmp->type != XML_DTD_NODE)) {
! 6282: if (tmp->children->type != XML_ENTITY_DECL) {
! 6283: tmp = tmp->children;
! 6284: continue;
! 6285: }
! 6286: }
! 6287: if (tmp == node)
! 6288: break;
! 6289:
! 6290: if (tmp->next != NULL) {
! 6291: tmp = tmp->next;
! 6292: continue;
! 6293: }
! 6294:
! 6295: do {
! 6296: tmp = tmp->parent;
! 6297: if (tmp == NULL)
! 6298: break;
! 6299: if (tmp == node) {
! 6300: tmp = NULL;
! 6301: break;
! 6302: }
! 6303: if (tmp->next != NULL) {
! 6304: tmp = tmp->next;
! 6305: break;
! 6306: }
! 6307: } while (tmp != NULL);
! 6308: }
! 6309: return(ret);
! 6310: }
! 6311:
! 6312: /**
! 6313: * xmlXPathStringHash:
! 6314: * @string: a string
! 6315: *
! 6316: * Function computing the beginning of the string value of the node,
! 6317: * used to speed up comparisons
! 6318: *
! 6319: * Returns an int usable as a hash
! 6320: */
! 6321: static unsigned int
! 6322: xmlXPathStringHash(const xmlChar * string) {
! 6323: if (string == NULL)
! 6324: return((unsigned int) 0);
! 6325: if (string[0] == 0)
! 6326: return(0);
! 6327: return(((unsigned int) string[0]) +
! 6328: (((unsigned int) string[1]) << 8));
! 6329: }
! 6330:
! 6331: /**
! 6332: * xmlXPathCompareNodeSetFloat:
! 6333: * @ctxt: the XPath Parser context
! 6334: * @inf: less than (1) or greater than (0)
! 6335: * @strict: is the comparison strict
! 6336: * @arg: the node set
! 6337: * @f: the value
! 6338: *
! 6339: * Implement the compare operation between a nodeset and a number
! 6340: * @ns < @val (1, 1, ...
! 6341: * @ns <= @val (1, 0, ...
! 6342: * @ns > @val (0, 1, ...
! 6343: * @ns >= @val (0, 0, ...
! 6344: *
! 6345: * If one object to be compared is a node-set and the other is a number,
! 6346: * then the comparison will be true if and only if there is a node in the
! 6347: * node-set such that the result of performing the comparison on the number
! 6348: * to be compared and on the result of converting the string-value of that
! 6349: * node to a number using the number function is true.
! 6350: *
! 6351: * Returns 0 or 1 depending on the results of the test.
! 6352: */
! 6353: static int
! 6354: xmlXPathCompareNodeSetFloat(xmlXPathParserContextPtr ctxt, int inf, int strict,
! 6355: xmlXPathObjectPtr arg, xmlXPathObjectPtr f) {
! 6356: int i, ret = 0;
! 6357: xmlNodeSetPtr ns;
! 6358: xmlChar *str2;
! 6359:
! 6360: if ((f == NULL) || (arg == NULL) ||
! 6361: ((arg->type != XPATH_NODESET) && (arg->type != XPATH_XSLT_TREE))) {
! 6362: xmlXPathReleaseObject(ctxt->context, arg);
! 6363: xmlXPathReleaseObject(ctxt->context, f);
! 6364: return(0);
! 6365: }
! 6366: ns = arg->nodesetval;
! 6367: if (ns != NULL) {
! 6368: for (i = 0;i < ns->nodeNr;i++) {
! 6369: str2 = xmlXPathCastNodeToString(ns->nodeTab[i]);
! 6370: if (str2 != NULL) {
! 6371: valuePush(ctxt,
! 6372: xmlXPathCacheNewString(ctxt->context, str2));
! 6373: xmlFree(str2);
! 6374: xmlXPathNumberFunction(ctxt, 1);
! 6375: valuePush(ctxt, xmlXPathCacheObjectCopy(ctxt->context, f));
! 6376: ret = xmlXPathCompareValues(ctxt, inf, strict);
! 6377: if (ret)
! 6378: break;
! 6379: }
! 6380: }
! 6381: }
! 6382: xmlXPathReleaseObject(ctxt->context, arg);
! 6383: xmlXPathReleaseObject(ctxt->context, f);
! 6384: return(ret);
! 6385: }
! 6386:
! 6387: /**
! 6388: * xmlXPathCompareNodeSetString:
! 6389: * @ctxt: the XPath Parser context
! 6390: * @inf: less than (1) or greater than (0)
! 6391: * @strict: is the comparison strict
! 6392: * @arg: the node set
! 6393: * @s: the value
! 6394: *
! 6395: * Implement the compare operation between a nodeset and a string
! 6396: * @ns < @val (1, 1, ...
! 6397: * @ns <= @val (1, 0, ...
! 6398: * @ns > @val (0, 1, ...
! 6399: * @ns >= @val (0, 0, ...
! 6400: *
! 6401: * If one object to be compared is a node-set and the other is a string,
! 6402: * then the comparison will be true if and only if there is a node in
! 6403: * the node-set such that the result of performing the comparison on the
! 6404: * string-value of the node and the other string is true.
! 6405: *
! 6406: * Returns 0 or 1 depending on the results of the test.
! 6407: */
! 6408: static int
! 6409: xmlXPathCompareNodeSetString(xmlXPathParserContextPtr ctxt, int inf, int strict,
! 6410: xmlXPathObjectPtr arg, xmlXPathObjectPtr s) {
! 6411: int i, ret = 0;
! 6412: xmlNodeSetPtr ns;
! 6413: xmlChar *str2;
! 6414:
! 6415: if ((s == NULL) || (arg == NULL) ||
! 6416: ((arg->type != XPATH_NODESET) && (arg->type != XPATH_XSLT_TREE))) {
! 6417: xmlXPathReleaseObject(ctxt->context, arg);
! 6418: xmlXPathReleaseObject(ctxt->context, s);
! 6419: return(0);
! 6420: }
! 6421: ns = arg->nodesetval;
! 6422: if (ns != NULL) {
! 6423: for (i = 0;i < ns->nodeNr;i++) {
! 6424: str2 = xmlXPathCastNodeToString(ns->nodeTab[i]);
! 6425: if (str2 != NULL) {
! 6426: valuePush(ctxt,
! 6427: xmlXPathCacheNewString(ctxt->context, str2));
! 6428: xmlFree(str2);
! 6429: valuePush(ctxt, xmlXPathCacheObjectCopy(ctxt->context, s));
! 6430: ret = xmlXPathCompareValues(ctxt, inf, strict);
! 6431: if (ret)
! 6432: break;
! 6433: }
! 6434: }
! 6435: }
! 6436: xmlXPathReleaseObject(ctxt->context, arg);
! 6437: xmlXPathReleaseObject(ctxt->context, s);
! 6438: return(ret);
! 6439: }
! 6440:
! 6441: /**
! 6442: * xmlXPathCompareNodeSets:
! 6443: * @inf: less than (1) or greater than (0)
! 6444: * @strict: is the comparison strict
! 6445: * @arg1: the first node set object
! 6446: * @arg2: the second node set object
! 6447: *
! 6448: * Implement the compare operation on nodesets:
! 6449: *
! 6450: * If both objects to be compared are node-sets, then the comparison
! 6451: * will be true if and only if there is a node in the first node-set
! 6452: * and a node in the second node-set such that the result of performing
! 6453: * the comparison on the string-values of the two nodes is true.
! 6454: * ....
! 6455: * When neither object to be compared is a node-set and the operator
! 6456: * is <=, <, >= or >, then the objects are compared by converting both
! 6457: * objects to numbers and comparing the numbers according to IEEE 754.
! 6458: * ....
! 6459: * The number function converts its argument to a number as follows:
! 6460: * - a string that consists of optional whitespace followed by an
! 6461: * optional minus sign followed by a Number followed by whitespace
! 6462: * is converted to the IEEE 754 number that is nearest (according
! 6463: * to the IEEE 754 round-to-nearest rule) to the mathematical value
! 6464: * represented by the string; any other string is converted to NaN
! 6465: *
! 6466: * Conclusion all nodes need to be converted first to their string value
! 6467: * and then the comparison must be done when possible
! 6468: */
! 6469: static int
! 6470: xmlXPathCompareNodeSets(int inf, int strict,
! 6471: xmlXPathObjectPtr arg1, xmlXPathObjectPtr arg2) {
! 6472: int i, j, init = 0;
! 6473: double val1;
! 6474: double *values2;
! 6475: int ret = 0;
! 6476: xmlNodeSetPtr ns1;
! 6477: xmlNodeSetPtr ns2;
! 6478:
! 6479: if ((arg1 == NULL) ||
! 6480: ((arg1->type != XPATH_NODESET) && (arg1->type != XPATH_XSLT_TREE))) {
! 6481: xmlXPathFreeObject(arg2);
! 6482: return(0);
! 6483: }
! 6484: if ((arg2 == NULL) ||
! 6485: ((arg2->type != XPATH_NODESET) && (arg2->type != XPATH_XSLT_TREE))) {
! 6486: xmlXPathFreeObject(arg1);
! 6487: xmlXPathFreeObject(arg2);
! 6488: return(0);
! 6489: }
! 6490:
! 6491: ns1 = arg1->nodesetval;
! 6492: ns2 = arg2->nodesetval;
! 6493:
! 6494: if ((ns1 == NULL) || (ns1->nodeNr <= 0)) {
! 6495: xmlXPathFreeObject(arg1);
! 6496: xmlXPathFreeObject(arg2);
! 6497: return(0);
! 6498: }
! 6499: if ((ns2 == NULL) || (ns2->nodeNr <= 0)) {
! 6500: xmlXPathFreeObject(arg1);
! 6501: xmlXPathFreeObject(arg2);
! 6502: return(0);
! 6503: }
! 6504:
! 6505: values2 = (double *) xmlMalloc(ns2->nodeNr * sizeof(double));
! 6506: if (values2 == NULL) {
! 6507: xmlXPathErrMemory(NULL, "comparing nodesets\n");
! 6508: xmlXPathFreeObject(arg1);
! 6509: xmlXPathFreeObject(arg2);
! 6510: return(0);
! 6511: }
! 6512: for (i = 0;i < ns1->nodeNr;i++) {
! 6513: val1 = xmlXPathCastNodeToNumber(ns1->nodeTab[i]);
! 6514: if (xmlXPathIsNaN(val1))
! 6515: continue;
! 6516: for (j = 0;j < ns2->nodeNr;j++) {
! 6517: if (init == 0) {
! 6518: values2[j] = xmlXPathCastNodeToNumber(ns2->nodeTab[j]);
! 6519: }
! 6520: if (xmlXPathIsNaN(values2[j]))
! 6521: continue;
! 6522: if (inf && strict)
! 6523: ret = (val1 < values2[j]);
! 6524: else if (inf && !strict)
! 6525: ret = (val1 <= values2[j]);
! 6526: else if (!inf && strict)
! 6527: ret = (val1 > values2[j]);
! 6528: else if (!inf && !strict)
! 6529: ret = (val1 >= values2[j]);
! 6530: if (ret)
! 6531: break;
! 6532: }
! 6533: if (ret)
! 6534: break;
! 6535: init = 1;
! 6536: }
! 6537: xmlFree(values2);
! 6538: xmlXPathFreeObject(arg1);
! 6539: xmlXPathFreeObject(arg2);
! 6540: return(ret);
! 6541: }
! 6542:
! 6543: /**
! 6544: * xmlXPathCompareNodeSetValue:
! 6545: * @ctxt: the XPath Parser context
! 6546: * @inf: less than (1) or greater than (0)
! 6547: * @strict: is the comparison strict
! 6548: * @arg: the node set
! 6549: * @val: the value
! 6550: *
! 6551: * Implement the compare operation between a nodeset and a value
! 6552: * @ns < @val (1, 1, ...
! 6553: * @ns <= @val (1, 0, ...
! 6554: * @ns > @val (0, 1, ...
! 6555: * @ns >= @val (0, 0, ...
! 6556: *
! 6557: * If one object to be compared is a node-set and the other is a boolean,
! 6558: * then the comparison will be true if and only if the result of performing
! 6559: * the comparison on the boolean and on the result of converting
! 6560: * the node-set to a boolean using the boolean function is true.
! 6561: *
! 6562: * Returns 0 or 1 depending on the results of the test.
! 6563: */
! 6564: static int
! 6565: xmlXPathCompareNodeSetValue(xmlXPathParserContextPtr ctxt, int inf, int strict,
! 6566: xmlXPathObjectPtr arg, xmlXPathObjectPtr val) {
! 6567: if ((val == NULL) || (arg == NULL) ||
! 6568: ((arg->type != XPATH_NODESET) && (arg->type != XPATH_XSLT_TREE)))
! 6569: return(0);
! 6570:
! 6571: switch(val->type) {
! 6572: case XPATH_NUMBER:
! 6573: return(xmlXPathCompareNodeSetFloat(ctxt, inf, strict, arg, val));
! 6574: case XPATH_NODESET:
! 6575: case XPATH_XSLT_TREE:
! 6576: return(xmlXPathCompareNodeSets(inf, strict, arg, val));
! 6577: case XPATH_STRING:
! 6578: return(xmlXPathCompareNodeSetString(ctxt, inf, strict, arg, val));
! 6579: case XPATH_BOOLEAN:
! 6580: valuePush(ctxt, arg);
! 6581: xmlXPathBooleanFunction(ctxt, 1);
! 6582: valuePush(ctxt, val);
! 6583: return(xmlXPathCompareValues(ctxt, inf, strict));
! 6584: default:
! 6585: TODO
! 6586: }
! 6587: return(0);
! 6588: }
! 6589:
! 6590: /**
! 6591: * xmlXPathEqualNodeSetString:
! 6592: * @arg: the nodeset object argument
! 6593: * @str: the string to compare to.
! 6594: * @neq: flag to show whether for '=' (0) or '!=' (1)
! 6595: *
! 6596: * Implement the equal operation on XPath objects content: @arg1 == @arg2
! 6597: * If one object to be compared is a node-set and the other is a string,
! 6598: * then the comparison will be true if and only if there is a node in
! 6599: * the node-set such that the result of performing the comparison on the
! 6600: * string-value of the node and the other string is true.
! 6601: *
! 6602: * Returns 0 or 1 depending on the results of the test.
! 6603: */
! 6604: static int
! 6605: xmlXPathEqualNodeSetString(xmlXPathObjectPtr arg, const xmlChar * str, int neq)
! 6606: {
! 6607: int i;
! 6608: xmlNodeSetPtr ns;
! 6609: xmlChar *str2;
! 6610: unsigned int hash;
! 6611:
! 6612: if ((str == NULL) || (arg == NULL) ||
! 6613: ((arg->type != XPATH_NODESET) && (arg->type != XPATH_XSLT_TREE)))
! 6614: return (0);
! 6615: ns = arg->nodesetval;
! 6616: /*
! 6617: * A NULL nodeset compared with a string is always false
! 6618: * (since there is no node equal, and no node not equal)
! 6619: */
! 6620: if ((ns == NULL) || (ns->nodeNr <= 0) )
! 6621: return (0);
! 6622: hash = xmlXPathStringHash(str);
! 6623: for (i = 0; i < ns->nodeNr; i++) {
! 6624: if (xmlXPathNodeValHash(ns->nodeTab[i]) == hash) {
! 6625: str2 = xmlNodeGetContent(ns->nodeTab[i]);
! 6626: if ((str2 != NULL) && (xmlStrEqual(str, str2))) {
! 6627: xmlFree(str2);
! 6628: if (neq)
! 6629: continue;
! 6630: return (1);
! 6631: } else if ((str2 == NULL) && (xmlStrEqual(str, BAD_CAST ""))) {
! 6632: if (neq)
! 6633: continue;
! 6634: return (1);
! 6635: } else if (neq) {
! 6636: if (str2 != NULL)
! 6637: xmlFree(str2);
! 6638: return (1);
! 6639: }
! 6640: if (str2 != NULL)
! 6641: xmlFree(str2);
! 6642: } else if (neq)
! 6643: return (1);
! 6644: }
! 6645: return (0);
! 6646: }
! 6647:
! 6648: /**
! 6649: * xmlXPathEqualNodeSetFloat:
! 6650: * @arg: the nodeset object argument
! 6651: * @f: the float to compare to
! 6652: * @neq: flag to show whether to compare '=' (0) or '!=' (1)
! 6653: *
! 6654: * Implement the equal operation on XPath objects content: @arg1 == @arg2
! 6655: * If one object to be compared is a node-set and the other is a number,
! 6656: * then the comparison will be true if and only if there is a node in
! 6657: * the node-set such that the result of performing the comparison on the
! 6658: * number to be compared and on the result of converting the string-value
! 6659: * of that node to a number using the number function is true.
! 6660: *
! 6661: * Returns 0 or 1 depending on the results of the test.
! 6662: */
! 6663: static int
! 6664: xmlXPathEqualNodeSetFloat(xmlXPathParserContextPtr ctxt,
! 6665: xmlXPathObjectPtr arg, double f, int neq) {
! 6666: int i, ret=0;
! 6667: xmlNodeSetPtr ns;
! 6668: xmlChar *str2;
! 6669: xmlXPathObjectPtr val;
! 6670: double v;
! 6671:
! 6672: if ((arg == NULL) ||
! 6673: ((arg->type != XPATH_NODESET) && (arg->type != XPATH_XSLT_TREE)))
! 6674: return(0);
! 6675:
! 6676: ns = arg->nodesetval;
! 6677: if (ns != NULL) {
! 6678: for (i=0;i<ns->nodeNr;i++) {
! 6679: str2 = xmlXPathCastNodeToString(ns->nodeTab[i]);
! 6680: if (str2 != NULL) {
! 6681: valuePush(ctxt, xmlXPathCacheNewString(ctxt->context, str2));
! 6682: xmlFree(str2);
! 6683: xmlXPathNumberFunction(ctxt, 1);
! 6684: val = valuePop(ctxt);
! 6685: v = val->floatval;
! 6686: xmlXPathReleaseObject(ctxt->context, val);
! 6687: if (!xmlXPathIsNaN(v)) {
! 6688: if ((!neq) && (v==f)) {
! 6689: ret = 1;
! 6690: break;
! 6691: } else if ((neq) && (v!=f)) {
! 6692: ret = 1;
! 6693: break;
! 6694: }
! 6695: } else { /* NaN is unequal to any value */
! 6696: if (neq)
! 6697: ret = 1;
! 6698: }
! 6699: }
! 6700: }
! 6701: }
! 6702:
! 6703: return(ret);
! 6704: }
! 6705:
! 6706:
! 6707: /**
! 6708: * xmlXPathEqualNodeSets:
! 6709: * @arg1: first nodeset object argument
! 6710: * @arg2: second nodeset object argument
! 6711: * @neq: flag to show whether to test '=' (0) or '!=' (1)
! 6712: *
! 6713: * Implement the equal / not equal operation on XPath nodesets:
! 6714: * @arg1 == @arg2 or @arg1 != @arg2
! 6715: * If both objects to be compared are node-sets, then the comparison
! 6716: * will be true if and only if there is a node in the first node-set and
! 6717: * a node in the second node-set such that the result of performing the
! 6718: * comparison on the string-values of the two nodes is true.
! 6719: *
! 6720: * (needless to say, this is a costly operation)
! 6721: *
! 6722: * Returns 0 or 1 depending on the results of the test.
! 6723: */
! 6724: static int
! 6725: xmlXPathEqualNodeSets(xmlXPathObjectPtr arg1, xmlXPathObjectPtr arg2, int neq) {
! 6726: int i, j;
! 6727: unsigned int *hashs1;
! 6728: unsigned int *hashs2;
! 6729: xmlChar **values1;
! 6730: xmlChar **values2;
! 6731: int ret = 0;
! 6732: xmlNodeSetPtr ns1;
! 6733: xmlNodeSetPtr ns2;
! 6734:
! 6735: if ((arg1 == NULL) ||
! 6736: ((arg1->type != XPATH_NODESET) && (arg1->type != XPATH_XSLT_TREE)))
! 6737: return(0);
! 6738: if ((arg2 == NULL) ||
! 6739: ((arg2->type != XPATH_NODESET) && (arg2->type != XPATH_XSLT_TREE)))
! 6740: return(0);
! 6741:
! 6742: ns1 = arg1->nodesetval;
! 6743: ns2 = arg2->nodesetval;
! 6744:
! 6745: if ((ns1 == NULL) || (ns1->nodeNr <= 0))
! 6746: return(0);
! 6747: if ((ns2 == NULL) || (ns2->nodeNr <= 0))
! 6748: return(0);
! 6749:
! 6750: /*
! 6751: * for equal, check if there is a node pertaining to both sets
! 6752: */
! 6753: if (neq == 0)
! 6754: for (i = 0;i < ns1->nodeNr;i++)
! 6755: for (j = 0;j < ns2->nodeNr;j++)
! 6756: if (ns1->nodeTab[i] == ns2->nodeTab[j])
! 6757: return(1);
! 6758:
! 6759: values1 = (xmlChar **) xmlMalloc(ns1->nodeNr * sizeof(xmlChar *));
! 6760: if (values1 == NULL) {
! 6761: xmlXPathErrMemory(NULL, "comparing nodesets\n");
! 6762: return(0);
! 6763: }
! 6764: hashs1 = (unsigned int *) xmlMalloc(ns1->nodeNr * sizeof(unsigned int));
! 6765: if (hashs1 == NULL) {
! 6766: xmlXPathErrMemory(NULL, "comparing nodesets\n");
! 6767: xmlFree(values1);
! 6768: return(0);
! 6769: }
! 6770: memset(values1, 0, ns1->nodeNr * sizeof(xmlChar *));
! 6771: values2 = (xmlChar **) xmlMalloc(ns2->nodeNr * sizeof(xmlChar *));
! 6772: if (values2 == NULL) {
! 6773: xmlXPathErrMemory(NULL, "comparing nodesets\n");
! 6774: xmlFree(hashs1);
! 6775: xmlFree(values1);
! 6776: return(0);
! 6777: }
! 6778: hashs2 = (unsigned int *) xmlMalloc(ns2->nodeNr * sizeof(unsigned int));
! 6779: if (hashs2 == NULL) {
! 6780: xmlXPathErrMemory(NULL, "comparing nodesets\n");
! 6781: xmlFree(hashs1);
! 6782: xmlFree(values1);
! 6783: xmlFree(values2);
! 6784: return(0);
! 6785: }
! 6786: memset(values2, 0, ns2->nodeNr * sizeof(xmlChar *));
! 6787: for (i = 0;i < ns1->nodeNr;i++) {
! 6788: hashs1[i] = xmlXPathNodeValHash(ns1->nodeTab[i]);
! 6789: for (j = 0;j < ns2->nodeNr;j++) {
! 6790: if (i == 0)
! 6791: hashs2[j] = xmlXPathNodeValHash(ns2->nodeTab[j]);
! 6792: if (hashs1[i] != hashs2[j]) {
! 6793: if (neq) {
! 6794: ret = 1;
! 6795: break;
! 6796: }
! 6797: }
! 6798: else {
! 6799: if (values1[i] == NULL)
! 6800: values1[i] = xmlNodeGetContent(ns1->nodeTab[i]);
! 6801: if (values2[j] == NULL)
! 6802: values2[j] = xmlNodeGetContent(ns2->nodeTab[j]);
! 6803: ret = xmlStrEqual(values1[i], values2[j]) ^ neq;
! 6804: if (ret)
! 6805: break;
! 6806: }
! 6807: }
! 6808: if (ret)
! 6809: break;
! 6810: }
! 6811: for (i = 0;i < ns1->nodeNr;i++)
! 6812: if (values1[i] != NULL)
! 6813: xmlFree(values1[i]);
! 6814: for (j = 0;j < ns2->nodeNr;j++)
! 6815: if (values2[j] != NULL)
! 6816: xmlFree(values2[j]);
! 6817: xmlFree(values1);
! 6818: xmlFree(values2);
! 6819: xmlFree(hashs1);
! 6820: xmlFree(hashs2);
! 6821: return(ret);
! 6822: }
! 6823:
! 6824: static int
! 6825: xmlXPathEqualValuesCommon(xmlXPathParserContextPtr ctxt,
! 6826: xmlXPathObjectPtr arg1, xmlXPathObjectPtr arg2) {
! 6827: int ret = 0;
! 6828: /*
! 6829: *At this point we are assured neither arg1 nor arg2
! 6830: *is a nodeset, so we can just pick the appropriate routine.
! 6831: */
! 6832: switch (arg1->type) {
! 6833: case XPATH_UNDEFINED:
! 6834: #ifdef DEBUG_EXPR
! 6835: xmlGenericError(xmlGenericErrorContext,
! 6836: "Equal: undefined\n");
! 6837: #endif
! 6838: break;
! 6839: case XPATH_BOOLEAN:
! 6840: switch (arg2->type) {
! 6841: case XPATH_UNDEFINED:
! 6842: #ifdef DEBUG_EXPR
! 6843: xmlGenericError(xmlGenericErrorContext,
! 6844: "Equal: undefined\n");
! 6845: #endif
! 6846: break;
! 6847: case XPATH_BOOLEAN:
! 6848: #ifdef DEBUG_EXPR
! 6849: xmlGenericError(xmlGenericErrorContext,
! 6850: "Equal: %d boolean %d \n",
! 6851: arg1->boolval, arg2->boolval);
! 6852: #endif
! 6853: ret = (arg1->boolval == arg2->boolval);
! 6854: break;
! 6855: case XPATH_NUMBER:
! 6856: ret = (arg1->boolval ==
! 6857: xmlXPathCastNumberToBoolean(arg2->floatval));
! 6858: break;
! 6859: case XPATH_STRING:
! 6860: if ((arg2->stringval == NULL) ||
! 6861: (arg2->stringval[0] == 0)) ret = 0;
! 6862: else
! 6863: ret = 1;
! 6864: ret = (arg1->boolval == ret);
! 6865: break;
! 6866: case XPATH_USERS:
! 6867: case XPATH_POINT:
! 6868: case XPATH_RANGE:
! 6869: case XPATH_LOCATIONSET:
! 6870: TODO
! 6871: break;
! 6872: case XPATH_NODESET:
! 6873: case XPATH_XSLT_TREE:
! 6874: break;
! 6875: }
! 6876: break;
! 6877: case XPATH_NUMBER:
! 6878: switch (arg2->type) {
! 6879: case XPATH_UNDEFINED:
! 6880: #ifdef DEBUG_EXPR
! 6881: xmlGenericError(xmlGenericErrorContext,
! 6882: "Equal: undefined\n");
! 6883: #endif
! 6884: break;
! 6885: case XPATH_BOOLEAN:
! 6886: ret = (arg2->boolval==
! 6887: xmlXPathCastNumberToBoolean(arg1->floatval));
! 6888: break;
! 6889: case XPATH_STRING:
! 6890: valuePush(ctxt, arg2);
! 6891: xmlXPathNumberFunction(ctxt, 1);
! 6892: arg2 = valuePop(ctxt);
! 6893: /* no break on purpose */
! 6894: case XPATH_NUMBER:
! 6895: /* Hand check NaN and Infinity equalities */
! 6896: if (xmlXPathIsNaN(arg1->floatval) ||
! 6897: xmlXPathIsNaN(arg2->floatval)) {
! 6898: ret = 0;
! 6899: } else if (xmlXPathIsInf(arg1->floatval) == 1) {
! 6900: if (xmlXPathIsInf(arg2->floatval) == 1)
! 6901: ret = 1;
! 6902: else
! 6903: ret = 0;
! 6904: } else if (xmlXPathIsInf(arg1->floatval) == -1) {
! 6905: if (xmlXPathIsInf(arg2->floatval) == -1)
! 6906: ret = 1;
! 6907: else
! 6908: ret = 0;
! 6909: } else if (xmlXPathIsInf(arg2->floatval) == 1) {
! 6910: if (xmlXPathIsInf(arg1->floatval) == 1)
! 6911: ret = 1;
! 6912: else
! 6913: ret = 0;
! 6914: } else if (xmlXPathIsInf(arg2->floatval) == -1) {
! 6915: if (xmlXPathIsInf(arg1->floatval) == -1)
! 6916: ret = 1;
! 6917: else
! 6918: ret = 0;
! 6919: } else {
! 6920: ret = (arg1->floatval == arg2->floatval);
! 6921: }
! 6922: break;
! 6923: case XPATH_USERS:
! 6924: case XPATH_POINT:
! 6925: case XPATH_RANGE:
! 6926: case XPATH_LOCATIONSET:
! 6927: TODO
! 6928: break;
! 6929: case XPATH_NODESET:
! 6930: case XPATH_XSLT_TREE:
! 6931: break;
! 6932: }
! 6933: break;
! 6934: case XPATH_STRING:
! 6935: switch (arg2->type) {
! 6936: case XPATH_UNDEFINED:
! 6937: #ifdef DEBUG_EXPR
! 6938: xmlGenericError(xmlGenericErrorContext,
! 6939: "Equal: undefined\n");
! 6940: #endif
! 6941: break;
! 6942: case XPATH_BOOLEAN:
! 6943: if ((arg1->stringval == NULL) ||
! 6944: (arg1->stringval[0] == 0)) ret = 0;
! 6945: else
! 6946: ret = 1;
! 6947: ret = (arg2->boolval == ret);
! 6948: break;
! 6949: case XPATH_STRING:
! 6950: ret = xmlStrEqual(arg1->stringval, arg2->stringval);
! 6951: break;
! 6952: case XPATH_NUMBER:
! 6953: valuePush(ctxt, arg1);
! 6954: xmlXPathNumberFunction(ctxt, 1);
! 6955: arg1 = valuePop(ctxt);
! 6956: /* Hand check NaN and Infinity equalities */
! 6957: if (xmlXPathIsNaN(arg1->floatval) ||
! 6958: xmlXPathIsNaN(arg2->floatval)) {
! 6959: ret = 0;
! 6960: } else if (xmlXPathIsInf(arg1->floatval) == 1) {
! 6961: if (xmlXPathIsInf(arg2->floatval) == 1)
! 6962: ret = 1;
! 6963: else
! 6964: ret = 0;
! 6965: } else if (xmlXPathIsInf(arg1->floatval) == -1) {
! 6966: if (xmlXPathIsInf(arg2->floatval) == -1)
! 6967: ret = 1;
! 6968: else
! 6969: ret = 0;
! 6970: } else if (xmlXPathIsInf(arg2->floatval) == 1) {
! 6971: if (xmlXPathIsInf(arg1->floatval) == 1)
! 6972: ret = 1;
! 6973: else
! 6974: ret = 0;
! 6975: } else if (xmlXPathIsInf(arg2->floatval) == -1) {
! 6976: if (xmlXPathIsInf(arg1->floatval) == -1)
! 6977: ret = 1;
! 6978: else
! 6979: ret = 0;
! 6980: } else {
! 6981: ret = (arg1->floatval == arg2->floatval);
! 6982: }
! 6983: break;
! 6984: case XPATH_USERS:
! 6985: case XPATH_POINT:
! 6986: case XPATH_RANGE:
! 6987: case XPATH_LOCATIONSET:
! 6988: TODO
! 6989: break;
! 6990: case XPATH_NODESET:
! 6991: case XPATH_XSLT_TREE:
! 6992: break;
! 6993: }
! 6994: break;
! 6995: case XPATH_USERS:
! 6996: case XPATH_POINT:
! 6997: case XPATH_RANGE:
! 6998: case XPATH_LOCATIONSET:
! 6999: TODO
! 7000: break;
! 7001: case XPATH_NODESET:
! 7002: case XPATH_XSLT_TREE:
! 7003: break;
! 7004: }
! 7005: xmlXPathReleaseObject(ctxt->context, arg1);
! 7006: xmlXPathReleaseObject(ctxt->context, arg2);
! 7007: return(ret);
! 7008: }
! 7009:
! 7010: /**
! 7011: * xmlXPathEqualValues:
! 7012: * @ctxt: the XPath Parser context
! 7013: *
! 7014: * Implement the equal operation on XPath objects content: @arg1 == @arg2
! 7015: *
! 7016: * Returns 0 or 1 depending on the results of the test.
! 7017: */
! 7018: int
! 7019: xmlXPathEqualValues(xmlXPathParserContextPtr ctxt) {
! 7020: xmlXPathObjectPtr arg1, arg2, argtmp;
! 7021: int ret = 0;
! 7022:
! 7023: if ((ctxt == NULL) || (ctxt->context == NULL)) return(0);
! 7024: arg2 = valuePop(ctxt);
! 7025: arg1 = valuePop(ctxt);
! 7026: if ((arg1 == NULL) || (arg2 == NULL)) {
! 7027: if (arg1 != NULL)
! 7028: xmlXPathReleaseObject(ctxt->context, arg1);
! 7029: else
! 7030: xmlXPathReleaseObject(ctxt->context, arg2);
! 7031: XP_ERROR0(XPATH_INVALID_OPERAND);
! 7032: }
! 7033:
! 7034: if (arg1 == arg2) {
! 7035: #ifdef DEBUG_EXPR
! 7036: xmlGenericError(xmlGenericErrorContext,
! 7037: "Equal: by pointer\n");
! 7038: #endif
! 7039: xmlXPathFreeObject(arg1);
! 7040: return(1);
! 7041: }
! 7042:
! 7043: /*
! 7044: *If either argument is a nodeset, it's a 'special case'
! 7045: */
! 7046: if ((arg2->type == XPATH_NODESET) || (arg2->type == XPATH_XSLT_TREE) ||
! 7047: (arg1->type == XPATH_NODESET) || (arg1->type == XPATH_XSLT_TREE)) {
! 7048: /*
! 7049: *Hack it to assure arg1 is the nodeset
! 7050: */
! 7051: if ((arg1->type != XPATH_NODESET) && (arg1->type != XPATH_XSLT_TREE)) {
! 7052: argtmp = arg2;
! 7053: arg2 = arg1;
! 7054: arg1 = argtmp;
! 7055: }
! 7056: switch (arg2->type) {
! 7057: case XPATH_UNDEFINED:
! 7058: #ifdef DEBUG_EXPR
! 7059: xmlGenericError(xmlGenericErrorContext,
! 7060: "Equal: undefined\n");
! 7061: #endif
! 7062: break;
! 7063: case XPATH_NODESET:
! 7064: case XPATH_XSLT_TREE:
! 7065: ret = xmlXPathEqualNodeSets(arg1, arg2, 0);
! 7066: break;
! 7067: case XPATH_BOOLEAN:
! 7068: if ((arg1->nodesetval == NULL) ||
! 7069: (arg1->nodesetval->nodeNr == 0)) ret = 0;
! 7070: else
! 7071: ret = 1;
! 7072: ret = (ret == arg2->boolval);
! 7073: break;
! 7074: case XPATH_NUMBER:
! 7075: ret = xmlXPathEqualNodeSetFloat(ctxt, arg1, arg2->floatval, 0);
! 7076: break;
! 7077: case XPATH_STRING:
! 7078: ret = xmlXPathEqualNodeSetString(arg1, arg2->stringval, 0);
! 7079: break;
! 7080: case XPATH_USERS:
! 7081: case XPATH_POINT:
! 7082: case XPATH_RANGE:
! 7083: case XPATH_LOCATIONSET:
! 7084: TODO
! 7085: break;
! 7086: }
! 7087: xmlXPathReleaseObject(ctxt->context, arg1);
! 7088: xmlXPathReleaseObject(ctxt->context, arg2);
! 7089: return(ret);
! 7090: }
! 7091:
! 7092: return (xmlXPathEqualValuesCommon(ctxt, arg1, arg2));
! 7093: }
! 7094:
! 7095: /**
! 7096: * xmlXPathNotEqualValues:
! 7097: * @ctxt: the XPath Parser context
! 7098: *
! 7099: * Implement the equal operation on XPath objects content: @arg1 == @arg2
! 7100: *
! 7101: * Returns 0 or 1 depending on the results of the test.
! 7102: */
! 7103: int
! 7104: xmlXPathNotEqualValues(xmlXPathParserContextPtr ctxt) {
! 7105: xmlXPathObjectPtr arg1, arg2, argtmp;
! 7106: int ret = 0;
! 7107:
! 7108: if ((ctxt == NULL) || (ctxt->context == NULL)) return(0);
! 7109: arg2 = valuePop(ctxt);
! 7110: arg1 = valuePop(ctxt);
! 7111: if ((arg1 == NULL) || (arg2 == NULL)) {
! 7112: if (arg1 != NULL)
! 7113: xmlXPathReleaseObject(ctxt->context, arg1);
! 7114: else
! 7115: xmlXPathReleaseObject(ctxt->context, arg2);
! 7116: XP_ERROR0(XPATH_INVALID_OPERAND);
! 7117: }
! 7118:
! 7119: if (arg1 == arg2) {
! 7120: #ifdef DEBUG_EXPR
! 7121: xmlGenericError(xmlGenericErrorContext,
! 7122: "NotEqual: by pointer\n");
! 7123: #endif
! 7124: xmlXPathReleaseObject(ctxt->context, arg1);
! 7125: return(0);
! 7126: }
! 7127:
! 7128: /*
! 7129: *If either argument is a nodeset, it's a 'special case'
! 7130: */
! 7131: if ((arg2->type == XPATH_NODESET) || (arg2->type == XPATH_XSLT_TREE) ||
! 7132: (arg1->type == XPATH_NODESET) || (arg1->type == XPATH_XSLT_TREE)) {
! 7133: /*
! 7134: *Hack it to assure arg1 is the nodeset
! 7135: */
! 7136: if ((arg1->type != XPATH_NODESET) && (arg1->type != XPATH_XSLT_TREE)) {
! 7137: argtmp = arg2;
! 7138: arg2 = arg1;
! 7139: arg1 = argtmp;
! 7140: }
! 7141: switch (arg2->type) {
! 7142: case XPATH_UNDEFINED:
! 7143: #ifdef DEBUG_EXPR
! 7144: xmlGenericError(xmlGenericErrorContext,
! 7145: "NotEqual: undefined\n");
! 7146: #endif
! 7147: break;
! 7148: case XPATH_NODESET:
! 7149: case XPATH_XSLT_TREE:
! 7150: ret = xmlXPathEqualNodeSets(arg1, arg2, 1);
! 7151: break;
! 7152: case XPATH_BOOLEAN:
! 7153: if ((arg1->nodesetval == NULL) ||
! 7154: (arg1->nodesetval->nodeNr == 0)) ret = 0;
! 7155: else
! 7156: ret = 1;
! 7157: ret = (ret != arg2->boolval);
! 7158: break;
! 7159: case XPATH_NUMBER:
! 7160: ret = xmlXPathEqualNodeSetFloat(ctxt, arg1, arg2->floatval, 1);
! 7161: break;
! 7162: case XPATH_STRING:
! 7163: ret = xmlXPathEqualNodeSetString(arg1, arg2->stringval,1);
! 7164: break;
! 7165: case XPATH_USERS:
! 7166: case XPATH_POINT:
! 7167: case XPATH_RANGE:
! 7168: case XPATH_LOCATIONSET:
! 7169: TODO
! 7170: break;
! 7171: }
! 7172: xmlXPathReleaseObject(ctxt->context, arg1);
! 7173: xmlXPathReleaseObject(ctxt->context, arg2);
! 7174: return(ret);
! 7175: }
! 7176:
! 7177: return (!xmlXPathEqualValuesCommon(ctxt, arg1, arg2));
! 7178: }
! 7179:
! 7180: /**
! 7181: * xmlXPathCompareValues:
! 7182: * @ctxt: the XPath Parser context
! 7183: * @inf: less than (1) or greater than (0)
! 7184: * @strict: is the comparison strict
! 7185: *
! 7186: * Implement the compare operation on XPath objects:
! 7187: * @arg1 < @arg2 (1, 1, ...
! 7188: * @arg1 <= @arg2 (1, 0, ...
! 7189: * @arg1 > @arg2 (0, 1, ...
! 7190: * @arg1 >= @arg2 (0, 0, ...
! 7191: *
! 7192: * When neither object to be compared is a node-set and the operator is
! 7193: * <=, <, >=, >, then the objects are compared by converted both objects
! 7194: * to numbers and comparing the numbers according to IEEE 754. The <
! 7195: * comparison will be true if and only if the first number is less than the
! 7196: * second number. The <= comparison will be true if and only if the first
! 7197: * number is less than or equal to the second number. The > comparison
! 7198: * will be true if and only if the first number is greater than the second
! 7199: * number. The >= comparison will be true if and only if the first number
! 7200: * is greater than or equal to the second number.
! 7201: *
! 7202: * Returns 1 if the comparison succeeded, 0 if it failed
! 7203: */
! 7204: int
! 7205: xmlXPathCompareValues(xmlXPathParserContextPtr ctxt, int inf, int strict) {
! 7206: int ret = 0, arg1i = 0, arg2i = 0;
! 7207: xmlXPathObjectPtr arg1, arg2;
! 7208:
! 7209: if ((ctxt == NULL) || (ctxt->context == NULL)) return(0);
! 7210: arg2 = valuePop(ctxt);
! 7211: arg1 = valuePop(ctxt);
! 7212: if ((arg1 == NULL) || (arg2 == NULL)) {
! 7213: if (arg1 != NULL)
! 7214: xmlXPathReleaseObject(ctxt->context, arg1);
! 7215: else
! 7216: xmlXPathReleaseObject(ctxt->context, arg2);
! 7217: XP_ERROR0(XPATH_INVALID_OPERAND);
! 7218: }
! 7219:
! 7220: if ((arg2->type == XPATH_NODESET) || (arg2->type == XPATH_XSLT_TREE) ||
! 7221: (arg1->type == XPATH_NODESET) || (arg1->type == XPATH_XSLT_TREE)) {
! 7222: /*
! 7223: * If either argument is a XPATH_NODESET or XPATH_XSLT_TREE the two arguments
! 7224: * are not freed from within this routine; they will be freed from the
! 7225: * called routine, e.g. xmlXPathCompareNodeSets or xmlXPathCompareNodeSetValue
! 7226: */
! 7227: if (((arg2->type == XPATH_NODESET) || (arg2->type == XPATH_XSLT_TREE)) &&
! 7228: ((arg1->type == XPATH_NODESET) || (arg1->type == XPATH_XSLT_TREE))){
! 7229: ret = xmlXPathCompareNodeSets(inf, strict, arg1, arg2);
! 7230: } else {
! 7231: if ((arg1->type == XPATH_NODESET) || (arg1->type == XPATH_XSLT_TREE)) {
! 7232: ret = xmlXPathCompareNodeSetValue(ctxt, inf, strict,
! 7233: arg1, arg2);
! 7234: } else {
! 7235: ret = xmlXPathCompareNodeSetValue(ctxt, !inf, strict,
! 7236: arg2, arg1);
! 7237: }
! 7238: }
! 7239: return(ret);
! 7240: }
! 7241:
! 7242: if (arg1->type != XPATH_NUMBER) {
! 7243: valuePush(ctxt, arg1);
! 7244: xmlXPathNumberFunction(ctxt, 1);
! 7245: arg1 = valuePop(ctxt);
! 7246: }
! 7247: if (arg1->type != XPATH_NUMBER) {
! 7248: xmlXPathFreeObject(arg1);
! 7249: xmlXPathFreeObject(arg2);
! 7250: XP_ERROR0(XPATH_INVALID_OPERAND);
! 7251: }
! 7252: if (arg2->type != XPATH_NUMBER) {
! 7253: valuePush(ctxt, arg2);
! 7254: xmlXPathNumberFunction(ctxt, 1);
! 7255: arg2 = valuePop(ctxt);
! 7256: }
! 7257: if (arg2->type != XPATH_NUMBER) {
! 7258: xmlXPathReleaseObject(ctxt->context, arg1);
! 7259: xmlXPathReleaseObject(ctxt->context, arg2);
! 7260: XP_ERROR0(XPATH_INVALID_OPERAND);
! 7261: }
! 7262: /*
! 7263: * Add tests for infinity and nan
! 7264: * => feedback on 3.4 for Inf and NaN
! 7265: */
! 7266: /* Hand check NaN and Infinity comparisons */
! 7267: if (xmlXPathIsNaN(arg1->floatval) || xmlXPathIsNaN(arg2->floatval)) {
! 7268: ret=0;
! 7269: } else {
! 7270: arg1i=xmlXPathIsInf(arg1->floatval);
! 7271: arg2i=xmlXPathIsInf(arg2->floatval);
! 7272: if (inf && strict) {
! 7273: if ((arg1i == -1 && arg2i != -1) ||
! 7274: (arg2i == 1 && arg1i != 1)) {
! 7275: ret = 1;
! 7276: } else if (arg1i == 0 && arg2i == 0) {
! 7277: ret = (arg1->floatval < arg2->floatval);
! 7278: } else {
! 7279: ret = 0;
! 7280: }
! 7281: }
! 7282: else if (inf && !strict) {
! 7283: if (arg1i == -1 || arg2i == 1) {
! 7284: ret = 1;
! 7285: } else if (arg1i == 0 && arg2i == 0) {
! 7286: ret = (arg1->floatval <= arg2->floatval);
! 7287: } else {
! 7288: ret = 0;
! 7289: }
! 7290: }
! 7291: else if (!inf && strict) {
! 7292: if ((arg1i == 1 && arg2i != 1) ||
! 7293: (arg2i == -1 && arg1i != -1)) {
! 7294: ret = 1;
! 7295: } else if (arg1i == 0 && arg2i == 0) {
! 7296: ret = (arg1->floatval > arg2->floatval);
! 7297: } else {
! 7298: ret = 0;
! 7299: }
! 7300: }
! 7301: else if (!inf && !strict) {
! 7302: if (arg1i == 1 || arg2i == -1) {
! 7303: ret = 1;
! 7304: } else if (arg1i == 0 && arg2i == 0) {
! 7305: ret = (arg1->floatval >= arg2->floatval);
! 7306: } else {
! 7307: ret = 0;
! 7308: }
! 7309: }
! 7310: }
! 7311: xmlXPathReleaseObject(ctxt->context, arg1);
! 7312: xmlXPathReleaseObject(ctxt->context, arg2);
! 7313: return(ret);
! 7314: }
! 7315:
! 7316: /**
! 7317: * xmlXPathValueFlipSign:
! 7318: * @ctxt: the XPath Parser context
! 7319: *
! 7320: * Implement the unary - operation on an XPath object
! 7321: * The numeric operators convert their operands to numbers as if
! 7322: * by calling the number function.
! 7323: */
! 7324: void
! 7325: xmlXPathValueFlipSign(xmlXPathParserContextPtr ctxt) {
! 7326: if ((ctxt == NULL) || (ctxt->context == NULL)) return;
! 7327: CAST_TO_NUMBER;
! 7328: CHECK_TYPE(XPATH_NUMBER);
! 7329: if (xmlXPathIsNaN(ctxt->value->floatval))
! 7330: ctxt->value->floatval=xmlXPathNAN;
! 7331: else if (xmlXPathIsInf(ctxt->value->floatval) == 1)
! 7332: ctxt->value->floatval=xmlXPathNINF;
! 7333: else if (xmlXPathIsInf(ctxt->value->floatval) == -1)
! 7334: ctxt->value->floatval=xmlXPathPINF;
! 7335: else if (ctxt->value->floatval == 0) {
! 7336: if (xmlXPathGetSign(ctxt->value->floatval) == 0)
! 7337: ctxt->value->floatval = xmlXPathNZERO;
! 7338: else
! 7339: ctxt->value->floatval = 0;
! 7340: }
! 7341: else
! 7342: ctxt->value->floatval = - ctxt->value->floatval;
! 7343: }
! 7344:
! 7345: /**
! 7346: * xmlXPathAddValues:
! 7347: * @ctxt: the XPath Parser context
! 7348: *
! 7349: * Implement the add operation on XPath objects:
! 7350: * The numeric operators convert their operands to numbers as if
! 7351: * by calling the number function.
! 7352: */
! 7353: void
! 7354: xmlXPathAddValues(xmlXPathParserContextPtr ctxt) {
! 7355: xmlXPathObjectPtr arg;
! 7356: double val;
! 7357:
! 7358: arg = valuePop(ctxt);
! 7359: if (arg == NULL)
! 7360: XP_ERROR(XPATH_INVALID_OPERAND);
! 7361: val = xmlXPathCastToNumber(arg);
! 7362: xmlXPathReleaseObject(ctxt->context, arg);
! 7363: CAST_TO_NUMBER;
! 7364: CHECK_TYPE(XPATH_NUMBER);
! 7365: ctxt->value->floatval += val;
! 7366: }
! 7367:
! 7368: /**
! 7369: * xmlXPathSubValues:
! 7370: * @ctxt: the XPath Parser context
! 7371: *
! 7372: * Implement the subtraction operation on XPath objects:
! 7373: * The numeric operators convert their operands to numbers as if
! 7374: * by calling the number function.
! 7375: */
! 7376: void
! 7377: xmlXPathSubValues(xmlXPathParserContextPtr ctxt) {
! 7378: xmlXPathObjectPtr arg;
! 7379: double val;
! 7380:
! 7381: arg = valuePop(ctxt);
! 7382: if (arg == NULL)
! 7383: XP_ERROR(XPATH_INVALID_OPERAND);
! 7384: val = xmlXPathCastToNumber(arg);
! 7385: xmlXPathReleaseObject(ctxt->context, arg);
! 7386: CAST_TO_NUMBER;
! 7387: CHECK_TYPE(XPATH_NUMBER);
! 7388: ctxt->value->floatval -= val;
! 7389: }
! 7390:
! 7391: /**
! 7392: * xmlXPathMultValues:
! 7393: * @ctxt: the XPath Parser context
! 7394: *
! 7395: * Implement the multiply operation on XPath objects:
! 7396: * The numeric operators convert their operands to numbers as if
! 7397: * by calling the number function.
! 7398: */
! 7399: void
! 7400: xmlXPathMultValues(xmlXPathParserContextPtr ctxt) {
! 7401: xmlXPathObjectPtr arg;
! 7402: double val;
! 7403:
! 7404: arg = valuePop(ctxt);
! 7405: if (arg == NULL)
! 7406: XP_ERROR(XPATH_INVALID_OPERAND);
! 7407: val = xmlXPathCastToNumber(arg);
! 7408: xmlXPathReleaseObject(ctxt->context, arg);
! 7409: CAST_TO_NUMBER;
! 7410: CHECK_TYPE(XPATH_NUMBER);
! 7411: ctxt->value->floatval *= val;
! 7412: }
! 7413:
! 7414: /**
! 7415: * xmlXPathDivValues:
! 7416: * @ctxt: the XPath Parser context
! 7417: *
! 7418: * Implement the div operation on XPath objects @arg1 / @arg2:
! 7419: * The numeric operators convert their operands to numbers as if
! 7420: * by calling the number function.
! 7421: */
! 7422: void
! 7423: xmlXPathDivValues(xmlXPathParserContextPtr ctxt) {
! 7424: xmlXPathObjectPtr arg;
! 7425: double val;
! 7426:
! 7427: arg = valuePop(ctxt);
! 7428: if (arg == NULL)
! 7429: XP_ERROR(XPATH_INVALID_OPERAND);
! 7430: val = xmlXPathCastToNumber(arg);
! 7431: xmlXPathReleaseObject(ctxt->context, arg);
! 7432: CAST_TO_NUMBER;
! 7433: CHECK_TYPE(XPATH_NUMBER);
! 7434: if (xmlXPathIsNaN(val) || xmlXPathIsNaN(ctxt->value->floatval))
! 7435: ctxt->value->floatval = xmlXPathNAN;
! 7436: else if (val == 0 && xmlXPathGetSign(val) != 0) {
! 7437: if (ctxt->value->floatval == 0)
! 7438: ctxt->value->floatval = xmlXPathNAN;
! 7439: else if (ctxt->value->floatval > 0)
! 7440: ctxt->value->floatval = xmlXPathNINF;
! 7441: else if (ctxt->value->floatval < 0)
! 7442: ctxt->value->floatval = xmlXPathPINF;
! 7443: }
! 7444: else if (val == 0) {
! 7445: if (ctxt->value->floatval == 0)
! 7446: ctxt->value->floatval = xmlXPathNAN;
! 7447: else if (ctxt->value->floatval > 0)
! 7448: ctxt->value->floatval = xmlXPathPINF;
! 7449: else if (ctxt->value->floatval < 0)
! 7450: ctxt->value->floatval = xmlXPathNINF;
! 7451: } else
! 7452: ctxt->value->floatval /= val;
! 7453: }
! 7454:
! 7455: /**
! 7456: * xmlXPathModValues:
! 7457: * @ctxt: the XPath Parser context
! 7458: *
! 7459: * Implement the mod operation on XPath objects: @arg1 / @arg2
! 7460: * The numeric operators convert their operands to numbers as if
! 7461: * by calling the number function.
! 7462: */
! 7463: void
! 7464: xmlXPathModValues(xmlXPathParserContextPtr ctxt) {
! 7465: xmlXPathObjectPtr arg;
! 7466: double arg1, arg2;
! 7467:
! 7468: arg = valuePop(ctxt);
! 7469: if (arg == NULL)
! 7470: XP_ERROR(XPATH_INVALID_OPERAND);
! 7471: arg2 = xmlXPathCastToNumber(arg);
! 7472: xmlXPathReleaseObject(ctxt->context, arg);
! 7473: CAST_TO_NUMBER;
! 7474: CHECK_TYPE(XPATH_NUMBER);
! 7475: arg1 = ctxt->value->floatval;
! 7476: if (arg2 == 0)
! 7477: ctxt->value->floatval = xmlXPathNAN;
! 7478: else {
! 7479: ctxt->value->floatval = fmod(arg1, arg2);
! 7480: }
! 7481: }
! 7482:
! 7483: /************************************************************************
! 7484: * *
! 7485: * The traversal functions *
! 7486: * *
! 7487: ************************************************************************/
! 7488:
! 7489: /*
! 7490: * A traversal function enumerates nodes along an axis.
! 7491: * Initially it must be called with NULL, and it indicates
! 7492: * termination on the axis by returning NULL.
! 7493: */
! 7494: typedef xmlNodePtr (*xmlXPathTraversalFunction)
! 7495: (xmlXPathParserContextPtr ctxt, xmlNodePtr cur);
! 7496:
! 7497: /*
! 7498: * xmlXPathTraversalFunctionExt:
! 7499: * A traversal function enumerates nodes along an axis.
! 7500: * Initially it must be called with NULL, and it indicates
! 7501: * termination on the axis by returning NULL.
! 7502: * The context node of the traversal is specified via @contextNode.
! 7503: */
! 7504: typedef xmlNodePtr (*xmlXPathTraversalFunctionExt)
! 7505: (xmlNodePtr cur, xmlNodePtr contextNode);
! 7506:
! 7507: /*
! 7508: * xmlXPathNodeSetMergeFunction:
! 7509: * Used for merging node sets in xmlXPathCollectAndTest().
! 7510: */
! 7511: typedef xmlNodeSetPtr (*xmlXPathNodeSetMergeFunction)
! 7512: (xmlNodeSetPtr, xmlNodeSetPtr, int);
! 7513:
! 7514:
! 7515: /**
! 7516: * xmlXPathNextSelf:
! 7517: * @ctxt: the XPath Parser context
! 7518: * @cur: the current node in the traversal
! 7519: *
! 7520: * Traversal function for the "self" direction
! 7521: * The self axis contains just the context node itself
! 7522: *
! 7523: * Returns the next element following that axis
! 7524: */
! 7525: xmlNodePtr
! 7526: xmlXPathNextSelf(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
! 7527: if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
! 7528: if (cur == NULL)
! 7529: return(ctxt->context->node);
! 7530: return(NULL);
! 7531: }
! 7532:
! 7533: /**
! 7534: * xmlXPathNextChild:
! 7535: * @ctxt: the XPath Parser context
! 7536: * @cur: the current node in the traversal
! 7537: *
! 7538: * Traversal function for the "child" direction
! 7539: * The child axis contains the children of the context node in document order.
! 7540: *
! 7541: * Returns the next element following that axis
! 7542: */
! 7543: xmlNodePtr
! 7544: xmlXPathNextChild(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
! 7545: if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
! 7546: if (cur == NULL) {
! 7547: if (ctxt->context->node == NULL) return(NULL);
! 7548: switch (ctxt->context->node->type) {
! 7549: case XML_ELEMENT_NODE:
! 7550: case XML_TEXT_NODE:
! 7551: case XML_CDATA_SECTION_NODE:
! 7552: case XML_ENTITY_REF_NODE:
! 7553: case XML_ENTITY_NODE:
! 7554: case XML_PI_NODE:
! 7555: case XML_COMMENT_NODE:
! 7556: case XML_NOTATION_NODE:
! 7557: case XML_DTD_NODE:
! 7558: return(ctxt->context->node->children);
! 7559: case XML_DOCUMENT_NODE:
! 7560: case XML_DOCUMENT_TYPE_NODE:
! 7561: case XML_DOCUMENT_FRAG_NODE:
! 7562: case XML_HTML_DOCUMENT_NODE:
! 7563: #ifdef LIBXML_DOCB_ENABLED
! 7564: case XML_DOCB_DOCUMENT_NODE:
! 7565: #endif
! 7566: return(((xmlDocPtr) ctxt->context->node)->children);
! 7567: case XML_ELEMENT_DECL:
! 7568: case XML_ATTRIBUTE_DECL:
! 7569: case XML_ENTITY_DECL:
! 7570: case XML_ATTRIBUTE_NODE:
! 7571: case XML_NAMESPACE_DECL:
! 7572: case XML_XINCLUDE_START:
! 7573: case XML_XINCLUDE_END:
! 7574: return(NULL);
! 7575: }
! 7576: return(NULL);
! 7577: }
! 7578: if ((cur->type == XML_DOCUMENT_NODE) ||
! 7579: (cur->type == XML_HTML_DOCUMENT_NODE))
! 7580: return(NULL);
! 7581: return(cur->next);
! 7582: }
! 7583:
! 7584: /**
! 7585: * xmlXPathNextChildElement:
! 7586: * @ctxt: the XPath Parser context
! 7587: * @cur: the current node in the traversal
! 7588: *
! 7589: * Traversal function for the "child" direction and nodes of type element.
! 7590: * The child axis contains the children of the context node in document order.
! 7591: *
! 7592: * Returns the next element following that axis
! 7593: */
! 7594: static xmlNodePtr
! 7595: xmlXPathNextChildElement(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
! 7596: if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
! 7597: if (cur == NULL) {
! 7598: cur = ctxt->context->node;
! 7599: if (cur == NULL) return(NULL);
! 7600: /*
! 7601: * Get the first element child.
! 7602: */
! 7603: switch (cur->type) {
! 7604: case XML_ELEMENT_NODE:
! 7605: case XML_DOCUMENT_FRAG_NODE:
! 7606: case XML_ENTITY_REF_NODE: /* URGENT TODO: entify-refs as well? */
! 7607: case XML_ENTITY_NODE:
! 7608: cur = cur->children;
! 7609: if (cur != NULL) {
! 7610: if (cur->type == XML_ELEMENT_NODE)
! 7611: return(cur);
! 7612: do {
! 7613: cur = cur->next;
! 7614: } while ((cur != NULL) &&
! 7615: (cur->type != XML_ELEMENT_NODE));
! 7616: return(cur);
! 7617: }
! 7618: return(NULL);
! 7619: case XML_DOCUMENT_NODE:
! 7620: case XML_HTML_DOCUMENT_NODE:
! 7621: #ifdef LIBXML_DOCB_ENABLED
! 7622: case XML_DOCB_DOCUMENT_NODE:
! 7623: #endif
! 7624: return(xmlDocGetRootElement((xmlDocPtr) cur));
! 7625: default:
! 7626: return(NULL);
! 7627: }
! 7628: return(NULL);
! 7629: }
! 7630: /*
! 7631: * Get the next sibling element node.
! 7632: */
! 7633: switch (cur->type) {
! 7634: case XML_ELEMENT_NODE:
! 7635: case XML_TEXT_NODE:
! 7636: case XML_ENTITY_REF_NODE:
! 7637: case XML_ENTITY_NODE:
! 7638: case XML_CDATA_SECTION_NODE:
! 7639: case XML_PI_NODE:
! 7640: case XML_COMMENT_NODE:
! 7641: case XML_XINCLUDE_END:
! 7642: break;
! 7643: /* case XML_DTD_NODE: */ /* URGENT TODO: DTD-node as well? */
! 7644: default:
! 7645: return(NULL);
! 7646: }
! 7647: if (cur->next != NULL) {
! 7648: if (cur->next->type == XML_ELEMENT_NODE)
! 7649: return(cur->next);
! 7650: cur = cur->next;
! 7651: do {
! 7652: cur = cur->next;
! 7653: } while ((cur != NULL) && (cur->type != XML_ELEMENT_NODE));
! 7654: return(cur);
! 7655: }
! 7656: return(NULL);
! 7657: }
! 7658:
! 7659: /**
! 7660: * xmlXPathNextDescendantOrSelfElemParent:
! 7661: * @ctxt: the XPath Parser context
! 7662: * @cur: the current node in the traversal
! 7663: *
! 7664: * Traversal function for the "descendant-or-self" axis.
! 7665: * Additionally it returns only nodes which can be parents of
! 7666: * element nodes.
! 7667: *
! 7668: *
! 7669: * Returns the next element following that axis
! 7670: */
! 7671: static xmlNodePtr
! 7672: xmlXPathNextDescendantOrSelfElemParent(xmlNodePtr cur,
! 7673: xmlNodePtr contextNode)
! 7674: {
! 7675: if (cur == NULL) {
! 7676: if (contextNode == NULL)
! 7677: return(NULL);
! 7678: switch (contextNode->type) {
! 7679: case XML_ELEMENT_NODE:
! 7680: case XML_XINCLUDE_START:
! 7681: case XML_DOCUMENT_FRAG_NODE:
! 7682: case XML_DOCUMENT_NODE:
! 7683: #ifdef LIBXML_DOCB_ENABLED
! 7684: case XML_DOCB_DOCUMENT_NODE:
! 7685: #endif
! 7686: case XML_HTML_DOCUMENT_NODE:
! 7687: return(contextNode);
! 7688: default:
! 7689: return(NULL);
! 7690: }
! 7691: return(NULL);
! 7692: } else {
! 7693: xmlNodePtr start = cur;
! 7694:
! 7695: while (cur != NULL) {
! 7696: switch (cur->type) {
! 7697: case XML_ELEMENT_NODE:
! 7698: /* TODO: OK to have XInclude here? */
! 7699: case XML_XINCLUDE_START:
! 7700: case XML_DOCUMENT_FRAG_NODE:
! 7701: if (cur != start)
! 7702: return(cur);
! 7703: if (cur->children != NULL) {
! 7704: cur = cur->children;
! 7705: continue;
! 7706: }
! 7707: break;
! 7708: /* Not sure if we need those here. */
! 7709: case XML_DOCUMENT_NODE:
! 7710: #ifdef LIBXML_DOCB_ENABLED
! 7711: case XML_DOCB_DOCUMENT_NODE:
! 7712: #endif
! 7713: case XML_HTML_DOCUMENT_NODE:
! 7714: if (cur != start)
! 7715: return(cur);
! 7716: return(xmlDocGetRootElement((xmlDocPtr) cur));
! 7717: default:
! 7718: break;
! 7719: }
! 7720:
! 7721: next_sibling:
! 7722: if ((cur == NULL) || (cur == contextNode))
! 7723: return(NULL);
! 7724: if (cur->next != NULL) {
! 7725: cur = cur->next;
! 7726: } else {
! 7727: cur = cur->parent;
! 7728: goto next_sibling;
! 7729: }
! 7730: }
! 7731: }
! 7732: return(NULL);
! 7733: }
! 7734:
! 7735: /**
! 7736: * xmlXPathNextDescendant:
! 7737: * @ctxt: the XPath Parser context
! 7738: * @cur: the current node in the traversal
! 7739: *
! 7740: * Traversal function for the "descendant" direction
! 7741: * the descendant axis contains the descendants of the context node in document
! 7742: * order; a descendant is a child or a child of a child and so on.
! 7743: *
! 7744: * Returns the next element following that axis
! 7745: */
! 7746: xmlNodePtr
! 7747: xmlXPathNextDescendant(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
! 7748: if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
! 7749: if (cur == NULL) {
! 7750: if (ctxt->context->node == NULL)
! 7751: return(NULL);
! 7752: if ((ctxt->context->node->type == XML_ATTRIBUTE_NODE) ||
! 7753: (ctxt->context->node->type == XML_NAMESPACE_DECL))
! 7754: return(NULL);
! 7755:
! 7756: if (ctxt->context->node == (xmlNodePtr) ctxt->context->doc)
! 7757: return(ctxt->context->doc->children);
! 7758: return(ctxt->context->node->children);
! 7759: }
! 7760:
! 7761: if (cur->children != NULL) {
! 7762: /*
! 7763: * Do not descend on entities declarations
! 7764: */
! 7765: if (cur->children->type != XML_ENTITY_DECL) {
! 7766: cur = cur->children;
! 7767: /*
! 7768: * Skip DTDs
! 7769: */
! 7770: if (cur->type != XML_DTD_NODE)
! 7771: return(cur);
! 7772: }
! 7773: }
! 7774:
! 7775: if (cur == ctxt->context->node) return(NULL);
! 7776:
! 7777: while (cur->next != NULL) {
! 7778: cur = cur->next;
! 7779: if ((cur->type != XML_ENTITY_DECL) &&
! 7780: (cur->type != XML_DTD_NODE))
! 7781: return(cur);
! 7782: }
! 7783:
! 7784: do {
! 7785: cur = cur->parent;
! 7786: if (cur == NULL) break;
! 7787: if (cur == ctxt->context->node) return(NULL);
! 7788: if (cur->next != NULL) {
! 7789: cur = cur->next;
! 7790: return(cur);
! 7791: }
! 7792: } while (cur != NULL);
! 7793: return(cur);
! 7794: }
! 7795:
! 7796: /**
! 7797: * xmlXPathNextDescendantOrSelf:
! 7798: * @ctxt: the XPath Parser context
! 7799: * @cur: the current node in the traversal
! 7800: *
! 7801: * Traversal function for the "descendant-or-self" direction
! 7802: * the descendant-or-self axis contains the context node and the descendants
! 7803: * of the context node in document order; thus the context node is the first
! 7804: * node on the axis, and the first child of the context node is the second node
! 7805: * on the axis
! 7806: *
! 7807: * Returns the next element following that axis
! 7808: */
! 7809: xmlNodePtr
! 7810: xmlXPathNextDescendantOrSelf(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
! 7811: if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
! 7812: if (cur == NULL) {
! 7813: if (ctxt->context->node == NULL)
! 7814: return(NULL);
! 7815: if ((ctxt->context->node->type == XML_ATTRIBUTE_NODE) ||
! 7816: (ctxt->context->node->type == XML_NAMESPACE_DECL))
! 7817: return(NULL);
! 7818: return(ctxt->context->node);
! 7819: }
! 7820:
! 7821: return(xmlXPathNextDescendant(ctxt, cur));
! 7822: }
! 7823:
! 7824: /**
! 7825: * xmlXPathNextParent:
! 7826: * @ctxt: the XPath Parser context
! 7827: * @cur: the current node in the traversal
! 7828: *
! 7829: * Traversal function for the "parent" direction
! 7830: * The parent axis contains the parent of the context node, if there is one.
! 7831: *
! 7832: * Returns the next element following that axis
! 7833: */
! 7834: xmlNodePtr
! 7835: xmlXPathNextParent(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
! 7836: if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
! 7837: /*
! 7838: * the parent of an attribute or namespace node is the element
! 7839: * to which the attribute or namespace node is attached
! 7840: * Namespace handling !!!
! 7841: */
! 7842: if (cur == NULL) {
! 7843: if (ctxt->context->node == NULL) return(NULL);
! 7844: switch (ctxt->context->node->type) {
! 7845: case XML_ELEMENT_NODE:
! 7846: case XML_TEXT_NODE:
! 7847: case XML_CDATA_SECTION_NODE:
! 7848: case XML_ENTITY_REF_NODE:
! 7849: case XML_ENTITY_NODE:
! 7850: case XML_PI_NODE:
! 7851: case XML_COMMENT_NODE:
! 7852: case XML_NOTATION_NODE:
! 7853: case XML_DTD_NODE:
! 7854: case XML_ELEMENT_DECL:
! 7855: case XML_ATTRIBUTE_DECL:
! 7856: case XML_XINCLUDE_START:
! 7857: case XML_XINCLUDE_END:
! 7858: case XML_ENTITY_DECL:
! 7859: if (ctxt->context->node->parent == NULL)
! 7860: return((xmlNodePtr) ctxt->context->doc);
! 7861: if ((ctxt->context->node->parent->type == XML_ELEMENT_NODE) &&
! 7862: ((ctxt->context->node->parent->name[0] == ' ') ||
! 7863: (xmlStrEqual(ctxt->context->node->parent->name,
! 7864: BAD_CAST "fake node libxslt"))))
! 7865: return(NULL);
! 7866: return(ctxt->context->node->parent);
! 7867: case XML_ATTRIBUTE_NODE: {
! 7868: xmlAttrPtr att = (xmlAttrPtr) ctxt->context->node;
! 7869:
! 7870: return(att->parent);
! 7871: }
! 7872: case XML_DOCUMENT_NODE:
! 7873: case XML_DOCUMENT_TYPE_NODE:
! 7874: case XML_DOCUMENT_FRAG_NODE:
! 7875: case XML_HTML_DOCUMENT_NODE:
! 7876: #ifdef LIBXML_DOCB_ENABLED
! 7877: case XML_DOCB_DOCUMENT_NODE:
! 7878: #endif
! 7879: return(NULL);
! 7880: case XML_NAMESPACE_DECL: {
! 7881: xmlNsPtr ns = (xmlNsPtr) ctxt->context->node;
! 7882:
! 7883: if ((ns->next != NULL) &&
! 7884: (ns->next->type != XML_NAMESPACE_DECL))
! 7885: return((xmlNodePtr) ns->next);
! 7886: return(NULL);
! 7887: }
! 7888: }
! 7889: }
! 7890: return(NULL);
! 7891: }
! 7892:
! 7893: /**
! 7894: * xmlXPathNextAncestor:
! 7895: * @ctxt: the XPath Parser context
! 7896: * @cur: the current node in the traversal
! 7897: *
! 7898: * Traversal function for the "ancestor" direction
! 7899: * the ancestor axis contains the ancestors of the context node; the ancestors
! 7900: * of the context node consist of the parent of context node and the parent's
! 7901: * parent and so on; the nodes are ordered in reverse document order; thus the
! 7902: * parent is the first node on the axis, and the parent's parent is the second
! 7903: * node on the axis
! 7904: *
! 7905: * Returns the next element following that axis
! 7906: */
! 7907: xmlNodePtr
! 7908: xmlXPathNextAncestor(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
! 7909: if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
! 7910: /*
! 7911: * the parent of an attribute or namespace node is the element
! 7912: * to which the attribute or namespace node is attached
! 7913: * !!!!!!!!!!!!!
! 7914: */
! 7915: if (cur == NULL) {
! 7916: if (ctxt->context->node == NULL) return(NULL);
! 7917: switch (ctxt->context->node->type) {
! 7918: case XML_ELEMENT_NODE:
! 7919: case XML_TEXT_NODE:
! 7920: case XML_CDATA_SECTION_NODE:
! 7921: case XML_ENTITY_REF_NODE:
! 7922: case XML_ENTITY_NODE:
! 7923: case XML_PI_NODE:
! 7924: case XML_COMMENT_NODE:
! 7925: case XML_DTD_NODE:
! 7926: case XML_ELEMENT_DECL:
! 7927: case XML_ATTRIBUTE_DECL:
! 7928: case XML_ENTITY_DECL:
! 7929: case XML_NOTATION_NODE:
! 7930: case XML_XINCLUDE_START:
! 7931: case XML_XINCLUDE_END:
! 7932: if (ctxt->context->node->parent == NULL)
! 7933: return((xmlNodePtr) ctxt->context->doc);
! 7934: if ((ctxt->context->node->parent->type == XML_ELEMENT_NODE) &&
! 7935: ((ctxt->context->node->parent->name[0] == ' ') ||
! 7936: (xmlStrEqual(ctxt->context->node->parent->name,
! 7937: BAD_CAST "fake node libxslt"))))
! 7938: return(NULL);
! 7939: return(ctxt->context->node->parent);
! 7940: case XML_ATTRIBUTE_NODE: {
! 7941: xmlAttrPtr tmp = (xmlAttrPtr) ctxt->context->node;
! 7942:
! 7943: return(tmp->parent);
! 7944: }
! 7945: case XML_DOCUMENT_NODE:
! 7946: case XML_DOCUMENT_TYPE_NODE:
! 7947: case XML_DOCUMENT_FRAG_NODE:
! 7948: case XML_HTML_DOCUMENT_NODE:
! 7949: #ifdef LIBXML_DOCB_ENABLED
! 7950: case XML_DOCB_DOCUMENT_NODE:
! 7951: #endif
! 7952: return(NULL);
! 7953: case XML_NAMESPACE_DECL: {
! 7954: xmlNsPtr ns = (xmlNsPtr) ctxt->context->node;
! 7955:
! 7956: if ((ns->next != NULL) &&
! 7957: (ns->next->type != XML_NAMESPACE_DECL))
! 7958: return((xmlNodePtr) ns->next);
! 7959: /* Bad, how did that namespace end up here ? */
! 7960: return(NULL);
! 7961: }
! 7962: }
! 7963: return(NULL);
! 7964: }
! 7965: if (cur == ctxt->context->doc->children)
! 7966: return((xmlNodePtr) ctxt->context->doc);
! 7967: if (cur == (xmlNodePtr) ctxt->context->doc)
! 7968: return(NULL);
! 7969: switch (cur->type) {
! 7970: case XML_ELEMENT_NODE:
! 7971: case XML_TEXT_NODE:
! 7972: case XML_CDATA_SECTION_NODE:
! 7973: case XML_ENTITY_REF_NODE:
! 7974: case XML_ENTITY_NODE:
! 7975: case XML_PI_NODE:
! 7976: case XML_COMMENT_NODE:
! 7977: case XML_NOTATION_NODE:
! 7978: case XML_DTD_NODE:
! 7979: case XML_ELEMENT_DECL:
! 7980: case XML_ATTRIBUTE_DECL:
! 7981: case XML_ENTITY_DECL:
! 7982: case XML_XINCLUDE_START:
! 7983: case XML_XINCLUDE_END:
! 7984: if (cur->parent == NULL)
! 7985: return(NULL);
! 7986: if ((cur->parent->type == XML_ELEMENT_NODE) &&
! 7987: ((cur->parent->name[0] == ' ') ||
! 7988: (xmlStrEqual(cur->parent->name,
! 7989: BAD_CAST "fake node libxslt"))))
! 7990: return(NULL);
! 7991: return(cur->parent);
! 7992: case XML_ATTRIBUTE_NODE: {
! 7993: xmlAttrPtr att = (xmlAttrPtr) ctxt->context->node;
! 7994:
! 7995: return(att->parent);
! 7996: }
! 7997: case XML_NAMESPACE_DECL: {
! 7998: xmlNsPtr ns = (xmlNsPtr) ctxt->context->node;
! 7999:
! 8000: if ((ns->next != NULL) &&
! 8001: (ns->next->type != XML_NAMESPACE_DECL))
! 8002: return((xmlNodePtr) ns->next);
! 8003: /* Bad, how did that namespace end up here ? */
! 8004: return(NULL);
! 8005: }
! 8006: case XML_DOCUMENT_NODE:
! 8007: case XML_DOCUMENT_TYPE_NODE:
! 8008: case XML_DOCUMENT_FRAG_NODE:
! 8009: case XML_HTML_DOCUMENT_NODE:
! 8010: #ifdef LIBXML_DOCB_ENABLED
! 8011: case XML_DOCB_DOCUMENT_NODE:
! 8012: #endif
! 8013: return(NULL);
! 8014: }
! 8015: return(NULL);
! 8016: }
! 8017:
! 8018: /**
! 8019: * xmlXPathNextAncestorOrSelf:
! 8020: * @ctxt: the XPath Parser context
! 8021: * @cur: the current node in the traversal
! 8022: *
! 8023: * Traversal function for the "ancestor-or-self" direction
! 8024: * he ancestor-or-self axis contains the context node and ancestors of
! 8025: * the context node in reverse document order; thus the context node is
! 8026: * the first node on the axis, and the context node's parent the second;
! 8027: * parent here is defined the same as with the parent axis.
! 8028: *
! 8029: * Returns the next element following that axis
! 8030: */
! 8031: xmlNodePtr
! 8032: xmlXPathNextAncestorOrSelf(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
! 8033: if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
! 8034: if (cur == NULL)
! 8035: return(ctxt->context->node);
! 8036: return(xmlXPathNextAncestor(ctxt, cur));
! 8037: }
! 8038:
! 8039: /**
! 8040: * xmlXPathNextFollowingSibling:
! 8041: * @ctxt: the XPath Parser context
! 8042: * @cur: the current node in the traversal
! 8043: *
! 8044: * Traversal function for the "following-sibling" direction
! 8045: * The following-sibling axis contains the following siblings of the context
! 8046: * node in document order.
! 8047: *
! 8048: * Returns the next element following that axis
! 8049: */
! 8050: xmlNodePtr
! 8051: xmlXPathNextFollowingSibling(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
! 8052: if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
! 8053: if ((ctxt->context->node->type == XML_ATTRIBUTE_NODE) ||
! 8054: (ctxt->context->node->type == XML_NAMESPACE_DECL))
! 8055: return(NULL);
! 8056: if (cur == (xmlNodePtr) ctxt->context->doc)
! 8057: return(NULL);
! 8058: if (cur == NULL)
! 8059: return(ctxt->context->node->next);
! 8060: return(cur->next);
! 8061: }
! 8062:
! 8063: /**
! 8064: * xmlXPathNextPrecedingSibling:
! 8065: * @ctxt: the XPath Parser context
! 8066: * @cur: the current node in the traversal
! 8067: *
! 8068: * Traversal function for the "preceding-sibling" direction
! 8069: * The preceding-sibling axis contains the preceding siblings of the context
! 8070: * node in reverse document order; the first preceding sibling is first on the
! 8071: * axis; the sibling preceding that node is the second on the axis and so on.
! 8072: *
! 8073: * Returns the next element following that axis
! 8074: */
! 8075: xmlNodePtr
! 8076: xmlXPathNextPrecedingSibling(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
! 8077: if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
! 8078: if ((ctxt->context->node->type == XML_ATTRIBUTE_NODE) ||
! 8079: (ctxt->context->node->type == XML_NAMESPACE_DECL))
! 8080: return(NULL);
! 8081: if (cur == (xmlNodePtr) ctxt->context->doc)
! 8082: return(NULL);
! 8083: if (cur == NULL)
! 8084: return(ctxt->context->node->prev);
! 8085: if ((cur->prev != NULL) && (cur->prev->type == XML_DTD_NODE)) {
! 8086: cur = cur->prev;
! 8087: if (cur == NULL)
! 8088: return(ctxt->context->node->prev);
! 8089: }
! 8090: return(cur->prev);
! 8091: }
! 8092:
! 8093: /**
! 8094: * xmlXPathNextFollowing:
! 8095: * @ctxt: the XPath Parser context
! 8096: * @cur: the current node in the traversal
! 8097: *
! 8098: * Traversal function for the "following" direction
! 8099: * The following axis contains all nodes in the same document as the context
! 8100: * node that are after the context node in document order, excluding any
! 8101: * descendants and excluding attribute nodes and namespace nodes; the nodes
! 8102: * are ordered in document order
! 8103: *
! 8104: * Returns the next element following that axis
! 8105: */
! 8106: xmlNodePtr
! 8107: xmlXPathNextFollowing(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
! 8108: if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
! 8109: if ((cur != NULL) && (cur->type != XML_ATTRIBUTE_NODE) &&
! 8110: (cur->type != XML_NAMESPACE_DECL) && (cur->children != NULL))
! 8111: return(cur->children);
! 8112:
! 8113: if (cur == NULL) {
! 8114: cur = ctxt->context->node;
! 8115: if (cur->type == XML_NAMESPACE_DECL)
! 8116: return(NULL);
! 8117: if (cur->type == XML_ATTRIBUTE_NODE)
! 8118: cur = cur->parent;
! 8119: }
! 8120: if (cur == NULL) return(NULL) ; /* ERROR */
! 8121: if (cur->next != NULL) return(cur->next) ;
! 8122: do {
! 8123: cur = cur->parent;
! 8124: if (cur == NULL) break;
! 8125: if (cur == (xmlNodePtr) ctxt->context->doc) return(NULL);
! 8126: if (cur->next != NULL) return(cur->next);
! 8127: } while (cur != NULL);
! 8128: return(cur);
! 8129: }
! 8130:
! 8131: /*
! 8132: * xmlXPathIsAncestor:
! 8133: * @ancestor: the ancestor node
! 8134: * @node: the current node
! 8135: *
! 8136: * Check that @ancestor is a @node's ancestor
! 8137: *
! 8138: * returns 1 if @ancestor is a @node's ancestor, 0 otherwise.
! 8139: */
! 8140: static int
! 8141: xmlXPathIsAncestor(xmlNodePtr ancestor, xmlNodePtr node) {
! 8142: if ((ancestor == NULL) || (node == NULL)) return(0);
! 8143: /* nodes need to be in the same document */
! 8144: if (ancestor->doc != node->doc) return(0);
! 8145: /* avoid searching if ancestor or node is the root node */
! 8146: if (ancestor == (xmlNodePtr) node->doc) return(1);
! 8147: if (node == (xmlNodePtr) ancestor->doc) return(0);
! 8148: while (node->parent != NULL) {
! 8149: if (node->parent == ancestor)
! 8150: return(1);
! 8151: node = node->parent;
! 8152: }
! 8153: return(0);
! 8154: }
! 8155:
! 8156: /**
! 8157: * xmlXPathNextPreceding:
! 8158: * @ctxt: the XPath Parser context
! 8159: * @cur: the current node in the traversal
! 8160: *
! 8161: * Traversal function for the "preceding" direction
! 8162: * the preceding axis contains all nodes in the same document as the context
! 8163: * node that are before the context node in document order, excluding any
! 8164: * ancestors and excluding attribute nodes and namespace nodes; the nodes are
! 8165: * ordered in reverse document order
! 8166: *
! 8167: * Returns the next element following that axis
! 8168: */
! 8169: xmlNodePtr
! 8170: xmlXPathNextPreceding(xmlXPathParserContextPtr ctxt, xmlNodePtr cur)
! 8171: {
! 8172: if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
! 8173: if (cur == NULL) {
! 8174: cur = ctxt->context->node;
! 8175: if (cur->type == XML_NAMESPACE_DECL)
! 8176: return(NULL);
! 8177: if (cur->type == XML_ATTRIBUTE_NODE)
! 8178: return(cur->parent);
! 8179: }
! 8180: if (cur == NULL)
! 8181: return (NULL);
! 8182: if ((cur->prev != NULL) && (cur->prev->type == XML_DTD_NODE))
! 8183: cur = cur->prev;
! 8184: do {
! 8185: if (cur->prev != NULL) {
! 8186: for (cur = cur->prev; cur->last != NULL; cur = cur->last) ;
! 8187: return (cur);
! 8188: }
! 8189:
! 8190: cur = cur->parent;
! 8191: if (cur == NULL)
! 8192: return (NULL);
! 8193: if (cur == ctxt->context->doc->children)
! 8194: return (NULL);
! 8195: } while (xmlXPathIsAncestor(cur, ctxt->context->node));
! 8196: return (cur);
! 8197: }
! 8198:
! 8199: /**
! 8200: * xmlXPathNextPrecedingInternal:
! 8201: * @ctxt: the XPath Parser context
! 8202: * @cur: the current node in the traversal
! 8203: *
! 8204: * Traversal function for the "preceding" direction
! 8205: * the preceding axis contains all nodes in the same document as the context
! 8206: * node that are before the context node in document order, excluding any
! 8207: * ancestors and excluding attribute nodes and namespace nodes; the nodes are
! 8208: * ordered in reverse document order
! 8209: * This is a faster implementation but internal only since it requires a
! 8210: * state kept in the parser context: ctxt->ancestor.
! 8211: *
! 8212: * Returns the next element following that axis
! 8213: */
! 8214: static xmlNodePtr
! 8215: xmlXPathNextPrecedingInternal(xmlXPathParserContextPtr ctxt,
! 8216: xmlNodePtr cur)
! 8217: {
! 8218: if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
! 8219: if (cur == NULL) {
! 8220: cur = ctxt->context->node;
! 8221: if (cur == NULL)
! 8222: return (NULL);
! 8223: if (cur->type == XML_NAMESPACE_DECL)
! 8224: return (NULL);
! 8225: ctxt->ancestor = cur->parent;
! 8226: }
! 8227: if ((cur->prev != NULL) && (cur->prev->type == XML_DTD_NODE))
! 8228: cur = cur->prev;
! 8229: while (cur->prev == NULL) {
! 8230: cur = cur->parent;
! 8231: if (cur == NULL)
! 8232: return (NULL);
! 8233: if (cur == ctxt->context->doc->children)
! 8234: return (NULL);
! 8235: if (cur != ctxt->ancestor)
! 8236: return (cur);
! 8237: ctxt->ancestor = cur->parent;
! 8238: }
! 8239: cur = cur->prev;
! 8240: while (cur->last != NULL)
! 8241: cur = cur->last;
! 8242: return (cur);
! 8243: }
! 8244:
! 8245: /**
! 8246: * xmlXPathNextNamespace:
! 8247: * @ctxt: the XPath Parser context
! 8248: * @cur: the current attribute in the traversal
! 8249: *
! 8250: * Traversal function for the "namespace" direction
! 8251: * the namespace axis contains the namespace nodes of the context node;
! 8252: * the order of nodes on this axis is implementation-defined; the axis will
! 8253: * be empty unless the context node is an element
! 8254: *
! 8255: * We keep the XML namespace node at the end of the list.
! 8256: *
! 8257: * Returns the next element following that axis
! 8258: */
! 8259: xmlNodePtr
! 8260: xmlXPathNextNamespace(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
! 8261: if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
! 8262: if (ctxt->context->node->type != XML_ELEMENT_NODE) return(NULL);
! 8263: if (ctxt->context->tmpNsList == NULL && cur != (xmlNodePtr) xmlXPathXMLNamespace) {
! 8264: if (ctxt->context->tmpNsList != NULL)
! 8265: xmlFree(ctxt->context->tmpNsList);
! 8266: ctxt->context->tmpNsList =
! 8267: xmlGetNsList(ctxt->context->doc, ctxt->context->node);
! 8268: ctxt->context->tmpNsNr = 0;
! 8269: if (ctxt->context->tmpNsList != NULL) {
! 8270: while (ctxt->context->tmpNsList[ctxt->context->tmpNsNr] != NULL) {
! 8271: ctxt->context->tmpNsNr++;
! 8272: }
! 8273: }
! 8274: return((xmlNodePtr) xmlXPathXMLNamespace);
! 8275: }
! 8276: if (ctxt->context->tmpNsNr > 0) {
! 8277: return (xmlNodePtr)ctxt->context->tmpNsList[--ctxt->context->tmpNsNr];
! 8278: } else {
! 8279: if (ctxt->context->tmpNsList != NULL)
! 8280: xmlFree(ctxt->context->tmpNsList);
! 8281: ctxt->context->tmpNsList = NULL;
! 8282: return(NULL);
! 8283: }
! 8284: }
! 8285:
! 8286: /**
! 8287: * xmlXPathNextAttribute:
! 8288: * @ctxt: the XPath Parser context
! 8289: * @cur: the current attribute in the traversal
! 8290: *
! 8291: * Traversal function for the "attribute" direction
! 8292: * TODO: support DTD inherited default attributes
! 8293: *
! 8294: * Returns the next element following that axis
! 8295: */
! 8296: xmlNodePtr
! 8297: xmlXPathNextAttribute(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
! 8298: if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
! 8299: if (ctxt->context->node == NULL)
! 8300: return(NULL);
! 8301: if (ctxt->context->node->type != XML_ELEMENT_NODE)
! 8302: return(NULL);
! 8303: if (cur == NULL) {
! 8304: if (ctxt->context->node == (xmlNodePtr) ctxt->context->doc)
! 8305: return(NULL);
! 8306: return((xmlNodePtr)ctxt->context->node->properties);
! 8307: }
! 8308: return((xmlNodePtr)cur->next);
! 8309: }
! 8310:
! 8311: /************************************************************************
! 8312: * *
! 8313: * NodeTest Functions *
! 8314: * *
! 8315: ************************************************************************/
! 8316:
! 8317: #define IS_FUNCTION 200
! 8318:
! 8319:
! 8320: /************************************************************************
! 8321: * *
! 8322: * Implicit tree core function library *
! 8323: * *
! 8324: ************************************************************************/
! 8325:
! 8326: /**
! 8327: * xmlXPathRoot:
! 8328: * @ctxt: the XPath Parser context
! 8329: *
! 8330: * Initialize the context to the root of the document
! 8331: */
! 8332: void
! 8333: xmlXPathRoot(xmlXPathParserContextPtr ctxt) {
! 8334: if ((ctxt == NULL) || (ctxt->context == NULL))
! 8335: return;
! 8336: ctxt->context->node = (xmlNodePtr) ctxt->context->doc;
! 8337: valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context,
! 8338: ctxt->context->node));
! 8339: }
! 8340:
! 8341: /************************************************************************
! 8342: * *
! 8343: * The explicit core function library *
! 8344: *http://www.w3.org/Style/XSL/Group/1999/07/xpath-19990705.html#corelib *
! 8345: * *
! 8346: ************************************************************************/
! 8347:
! 8348:
! 8349: /**
! 8350: * xmlXPathLastFunction:
! 8351: * @ctxt: the XPath Parser context
! 8352: * @nargs: the number of arguments
! 8353: *
! 8354: * Implement the last() XPath function
! 8355: * number last()
! 8356: * The last function returns the number of nodes in the context node list.
! 8357: */
! 8358: void
! 8359: xmlXPathLastFunction(xmlXPathParserContextPtr ctxt, int nargs) {
! 8360: CHECK_ARITY(0);
! 8361: if (ctxt->context->contextSize >= 0) {
! 8362: valuePush(ctxt,
! 8363: xmlXPathCacheNewFloat(ctxt->context,
! 8364: (double) ctxt->context->contextSize));
! 8365: #ifdef DEBUG_EXPR
! 8366: xmlGenericError(xmlGenericErrorContext,
! 8367: "last() : %d\n", ctxt->context->contextSize);
! 8368: #endif
! 8369: } else {
! 8370: XP_ERROR(XPATH_INVALID_CTXT_SIZE);
! 8371: }
! 8372: }
! 8373:
! 8374: /**
! 8375: * xmlXPathPositionFunction:
! 8376: * @ctxt: the XPath Parser context
! 8377: * @nargs: the number of arguments
! 8378: *
! 8379: * Implement the position() XPath function
! 8380: * number position()
! 8381: * The position function returns the position of the context node in the
! 8382: * context node list. The first position is 1, and so the last position
! 8383: * will be equal to last().
! 8384: */
! 8385: void
! 8386: xmlXPathPositionFunction(xmlXPathParserContextPtr ctxt, int nargs) {
! 8387: CHECK_ARITY(0);
! 8388: if (ctxt->context->proximityPosition >= 0) {
! 8389: valuePush(ctxt,
! 8390: xmlXPathCacheNewFloat(ctxt->context,
! 8391: (double) ctxt->context->proximityPosition));
! 8392: #ifdef DEBUG_EXPR
! 8393: xmlGenericError(xmlGenericErrorContext, "position() : %d\n",
! 8394: ctxt->context->proximityPosition);
! 8395: #endif
! 8396: } else {
! 8397: XP_ERROR(XPATH_INVALID_CTXT_POSITION);
! 8398: }
! 8399: }
! 8400:
! 8401: /**
! 8402: * xmlXPathCountFunction:
! 8403: * @ctxt: the XPath Parser context
! 8404: * @nargs: the number of arguments
! 8405: *
! 8406: * Implement the count() XPath function
! 8407: * number count(node-set)
! 8408: */
! 8409: void
! 8410: xmlXPathCountFunction(xmlXPathParserContextPtr ctxt, int nargs) {
! 8411: xmlXPathObjectPtr cur;
! 8412:
! 8413: CHECK_ARITY(1);
! 8414: if ((ctxt->value == NULL) ||
! 8415: ((ctxt->value->type != XPATH_NODESET) &&
! 8416: (ctxt->value->type != XPATH_XSLT_TREE)))
! 8417: XP_ERROR(XPATH_INVALID_TYPE);
! 8418: cur = valuePop(ctxt);
! 8419:
! 8420: if ((cur == NULL) || (cur->nodesetval == NULL))
! 8421: valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, (double) 0));
! 8422: else if ((cur->type == XPATH_NODESET) || (cur->type == XPATH_XSLT_TREE)) {
! 8423: valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context,
! 8424: (double) cur->nodesetval->nodeNr));
! 8425: } else {
! 8426: if ((cur->nodesetval->nodeNr != 1) ||
! 8427: (cur->nodesetval->nodeTab == NULL)) {
! 8428: valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, (double) 0));
! 8429: } else {
! 8430: xmlNodePtr tmp;
! 8431: int i = 0;
! 8432:
! 8433: tmp = cur->nodesetval->nodeTab[0];
! 8434: if (tmp != NULL) {
! 8435: tmp = tmp->children;
! 8436: while (tmp != NULL) {
! 8437: tmp = tmp->next;
! 8438: i++;
! 8439: }
! 8440: }
! 8441: valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, (double) i));
! 8442: }
! 8443: }
! 8444: xmlXPathReleaseObject(ctxt->context, cur);
! 8445: }
! 8446:
! 8447: /**
! 8448: * xmlXPathGetElementsByIds:
! 8449: * @doc: the document
! 8450: * @ids: a whitespace separated list of IDs
! 8451: *
! 8452: * Selects elements by their unique ID.
! 8453: *
! 8454: * Returns a node-set of selected elements.
! 8455: */
! 8456: static xmlNodeSetPtr
! 8457: xmlXPathGetElementsByIds (xmlDocPtr doc, const xmlChar *ids) {
! 8458: xmlNodeSetPtr ret;
! 8459: const xmlChar *cur = ids;
! 8460: xmlChar *ID;
! 8461: xmlAttrPtr attr;
! 8462: xmlNodePtr elem = NULL;
! 8463:
! 8464: if (ids == NULL) return(NULL);
! 8465:
! 8466: ret = xmlXPathNodeSetCreate(NULL);
! 8467: if (ret == NULL)
! 8468: return(ret);
! 8469:
! 8470: while (IS_BLANK_CH(*cur)) cur++;
! 8471: while (*cur != 0) {
! 8472: while ((!IS_BLANK_CH(*cur)) && (*cur != 0))
! 8473: cur++;
! 8474:
! 8475: ID = xmlStrndup(ids, cur - ids);
! 8476: if (ID != NULL) {
! 8477: /*
! 8478: * We used to check the fact that the value passed
! 8479: * was an NCName, but this generated much troubles for
! 8480: * me and Aleksey Sanin, people blatantly violated that
! 8481: * constaint, like Visa3D spec.
! 8482: * if (xmlValidateNCName(ID, 1) == 0)
! 8483: */
! 8484: attr = xmlGetID(doc, ID);
! 8485: if (attr != NULL) {
! 8486: if (attr->type == XML_ATTRIBUTE_NODE)
! 8487: elem = attr->parent;
! 8488: else if (attr->type == XML_ELEMENT_NODE)
! 8489: elem = (xmlNodePtr) attr;
! 8490: else
! 8491: elem = NULL;
! 8492: if (elem != NULL)
! 8493: xmlXPathNodeSetAdd(ret, elem);
! 8494: }
! 8495: xmlFree(ID);
! 8496: }
! 8497:
! 8498: while (IS_BLANK_CH(*cur)) cur++;
! 8499: ids = cur;
! 8500: }
! 8501: return(ret);
! 8502: }
! 8503:
! 8504: /**
! 8505: * xmlXPathIdFunction:
! 8506: * @ctxt: the XPath Parser context
! 8507: * @nargs: the number of arguments
! 8508: *
! 8509: * Implement the id() XPath function
! 8510: * node-set id(object)
! 8511: * The id function selects elements by their unique ID
! 8512: * (see [5.2.1 Unique IDs]). When the argument to id is of type node-set,
! 8513: * then the result is the union of the result of applying id to the
! 8514: * string value of each of the nodes in the argument node-set. When the
! 8515: * argument to id is of any other type, the argument is converted to a
! 8516: * string as if by a call to the string function; the string is split
! 8517: * into a whitespace-separated list of tokens (whitespace is any sequence
! 8518: * of characters matching the production S); the result is a node-set
! 8519: * containing the elements in the same document as the context node that
! 8520: * have a unique ID equal to any of the tokens in the list.
! 8521: */
! 8522: void
! 8523: xmlXPathIdFunction(xmlXPathParserContextPtr ctxt, int nargs) {
! 8524: xmlChar *tokens;
! 8525: xmlNodeSetPtr ret;
! 8526: xmlXPathObjectPtr obj;
! 8527:
! 8528: CHECK_ARITY(1);
! 8529: obj = valuePop(ctxt);
! 8530: if (obj == NULL) XP_ERROR(XPATH_INVALID_OPERAND);
! 8531: if ((obj->type == XPATH_NODESET) || (obj->type == XPATH_XSLT_TREE)) {
! 8532: xmlNodeSetPtr ns;
! 8533: int i;
! 8534:
! 8535: ret = xmlXPathNodeSetCreate(NULL);
! 8536: /*
! 8537: * FIXME -- in an out-of-memory condition this will behave badly.
! 8538: * The solution is not clear -- we already popped an item from
! 8539: * ctxt, so the object is in a corrupt state.
! 8540: */
! 8541:
! 8542: if (obj->nodesetval != NULL) {
! 8543: for (i = 0; i < obj->nodesetval->nodeNr; i++) {
! 8544: tokens =
! 8545: xmlXPathCastNodeToString(obj->nodesetval->nodeTab[i]);
! 8546: ns = xmlXPathGetElementsByIds(ctxt->context->doc, tokens);
! 8547: ret = xmlXPathNodeSetMerge(ret, ns);
! 8548: xmlXPathFreeNodeSet(ns);
! 8549: if (tokens != NULL)
! 8550: xmlFree(tokens);
! 8551: }
! 8552: }
! 8553: xmlXPathReleaseObject(ctxt->context, obj);
! 8554: valuePush(ctxt, xmlXPathCacheWrapNodeSet(ctxt->context, ret));
! 8555: return;
! 8556: }
! 8557: obj = xmlXPathCacheConvertString(ctxt->context, obj);
! 8558: ret = xmlXPathGetElementsByIds(ctxt->context->doc, obj->stringval);
! 8559: valuePush(ctxt, xmlXPathCacheWrapNodeSet(ctxt->context, ret));
! 8560: xmlXPathReleaseObject(ctxt->context, obj);
! 8561: return;
! 8562: }
! 8563:
! 8564: /**
! 8565: * xmlXPathLocalNameFunction:
! 8566: * @ctxt: the XPath Parser context
! 8567: * @nargs: the number of arguments
! 8568: *
! 8569: * Implement the local-name() XPath function
! 8570: * string local-name(node-set?)
! 8571: * The local-name function returns a string containing the local part
! 8572: * of the name of the node in the argument node-set that is first in
! 8573: * document order. If the node-set is empty or the first node has no
! 8574: * name, an empty string is returned. If the argument is omitted it
! 8575: * defaults to the context node.
! 8576: */
! 8577: void
! 8578: xmlXPathLocalNameFunction(xmlXPathParserContextPtr ctxt, int nargs) {
! 8579: xmlXPathObjectPtr cur;
! 8580:
! 8581: if (ctxt == NULL) return;
! 8582:
! 8583: if (nargs == 0) {
! 8584: valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context,
! 8585: ctxt->context->node));
! 8586: nargs = 1;
! 8587: }
! 8588:
! 8589: CHECK_ARITY(1);
! 8590: if ((ctxt->value == NULL) ||
! 8591: ((ctxt->value->type != XPATH_NODESET) &&
! 8592: (ctxt->value->type != XPATH_XSLT_TREE)))
! 8593: XP_ERROR(XPATH_INVALID_TYPE);
! 8594: cur = valuePop(ctxt);
! 8595:
! 8596: if ((cur->nodesetval == NULL) || (cur->nodesetval->nodeNr == 0)) {
! 8597: valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, ""));
! 8598: } else {
! 8599: int i = 0; /* Should be first in document order !!!!! */
! 8600: switch (cur->nodesetval->nodeTab[i]->type) {
! 8601: case XML_ELEMENT_NODE:
! 8602: case XML_ATTRIBUTE_NODE:
! 8603: case XML_PI_NODE:
! 8604: if (cur->nodesetval->nodeTab[i]->name[0] == ' ')
! 8605: valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, ""));
! 8606: else
! 8607: valuePush(ctxt,
! 8608: xmlXPathCacheNewString(ctxt->context,
! 8609: cur->nodesetval->nodeTab[i]->name));
! 8610: break;
! 8611: case XML_NAMESPACE_DECL:
! 8612: valuePush(ctxt, xmlXPathCacheNewString(ctxt->context,
! 8613: ((xmlNsPtr)cur->nodesetval->nodeTab[i])->prefix));
! 8614: break;
! 8615: default:
! 8616: valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, ""));
! 8617: }
! 8618: }
! 8619: xmlXPathReleaseObject(ctxt->context, cur);
! 8620: }
! 8621:
! 8622: /**
! 8623: * xmlXPathNamespaceURIFunction:
! 8624: * @ctxt: the XPath Parser context
! 8625: * @nargs: the number of arguments
! 8626: *
! 8627: * Implement the namespace-uri() XPath function
! 8628: * string namespace-uri(node-set?)
! 8629: * The namespace-uri function returns a string containing the
! 8630: * namespace URI of the expanded name of the node in the argument
! 8631: * node-set that is first in document order. If the node-set is empty,
! 8632: * the first node has no name, or the expanded name has no namespace
! 8633: * URI, an empty string is returned. If the argument is omitted it
! 8634: * defaults to the context node.
! 8635: */
! 8636: void
! 8637: xmlXPathNamespaceURIFunction(xmlXPathParserContextPtr ctxt, int nargs) {
! 8638: xmlXPathObjectPtr cur;
! 8639:
! 8640: if (ctxt == NULL) return;
! 8641:
! 8642: if (nargs == 0) {
! 8643: valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context,
! 8644: ctxt->context->node));
! 8645: nargs = 1;
! 8646: }
! 8647: CHECK_ARITY(1);
! 8648: if ((ctxt->value == NULL) ||
! 8649: ((ctxt->value->type != XPATH_NODESET) &&
! 8650: (ctxt->value->type != XPATH_XSLT_TREE)))
! 8651: XP_ERROR(XPATH_INVALID_TYPE);
! 8652: cur = valuePop(ctxt);
! 8653:
! 8654: if ((cur->nodesetval == NULL) || (cur->nodesetval->nodeNr == 0)) {
! 8655: valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, ""));
! 8656: } else {
! 8657: int i = 0; /* Should be first in document order !!!!! */
! 8658: switch (cur->nodesetval->nodeTab[i]->type) {
! 8659: case XML_ELEMENT_NODE:
! 8660: case XML_ATTRIBUTE_NODE:
! 8661: if (cur->nodesetval->nodeTab[i]->ns == NULL)
! 8662: valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, ""));
! 8663: else
! 8664: valuePush(ctxt, xmlXPathCacheNewString(ctxt->context,
! 8665: cur->nodesetval->nodeTab[i]->ns->href));
! 8666: break;
! 8667: default:
! 8668: valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, ""));
! 8669: }
! 8670: }
! 8671: xmlXPathReleaseObject(ctxt->context, cur);
! 8672: }
! 8673:
! 8674: /**
! 8675: * xmlXPathNameFunction:
! 8676: * @ctxt: the XPath Parser context
! 8677: * @nargs: the number of arguments
! 8678: *
! 8679: * Implement the name() XPath function
! 8680: * string name(node-set?)
! 8681: * The name function returns a string containing a QName representing
! 8682: * the name of the node in the argument node-set that is first in document
! 8683: * order. The QName must represent the name with respect to the namespace
! 8684: * declarations in effect on the node whose name is being represented.
! 8685: * Typically, this will be the form in which the name occurred in the XML
! 8686: * source. This need not be the case if there are namespace declarations
! 8687: * in effect on the node that associate multiple prefixes with the same
! 8688: * namespace. However, an implementation may include information about
! 8689: * the original prefix in its representation of nodes; in this case, an
! 8690: * implementation can ensure that the returned string is always the same
! 8691: * as the QName used in the XML source. If the argument it omitted it
! 8692: * defaults to the context node.
! 8693: * Libxml keep the original prefix so the "real qualified name" used is
! 8694: * returned.
! 8695: */
! 8696: static void
! 8697: xmlXPathNameFunction(xmlXPathParserContextPtr ctxt, int nargs)
! 8698: {
! 8699: xmlXPathObjectPtr cur;
! 8700:
! 8701: if (nargs == 0) {
! 8702: valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context,
! 8703: ctxt->context->node));
! 8704: nargs = 1;
! 8705: }
! 8706:
! 8707: CHECK_ARITY(1);
! 8708: if ((ctxt->value == NULL) ||
! 8709: ((ctxt->value->type != XPATH_NODESET) &&
! 8710: (ctxt->value->type != XPATH_XSLT_TREE)))
! 8711: XP_ERROR(XPATH_INVALID_TYPE);
! 8712: cur = valuePop(ctxt);
! 8713:
! 8714: if ((cur->nodesetval == NULL) || (cur->nodesetval->nodeNr == 0)) {
! 8715: valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, ""));
! 8716: } else {
! 8717: int i = 0; /* Should be first in document order !!!!! */
! 8718:
! 8719: switch (cur->nodesetval->nodeTab[i]->type) {
! 8720: case XML_ELEMENT_NODE:
! 8721: case XML_ATTRIBUTE_NODE:
! 8722: if (cur->nodesetval->nodeTab[i]->name[0] == ' ')
! 8723: valuePush(ctxt,
! 8724: xmlXPathCacheNewCString(ctxt->context, ""));
! 8725: else if ((cur->nodesetval->nodeTab[i]->ns == NULL) ||
! 8726: (cur->nodesetval->nodeTab[i]->ns->prefix == NULL)) {
! 8727: valuePush(ctxt,
! 8728: xmlXPathCacheNewString(ctxt->context,
! 8729: cur->nodesetval->nodeTab[i]->name));
! 8730: } else {
! 8731: xmlChar *fullname;
! 8732:
! 8733: fullname = xmlBuildQName(cur->nodesetval->nodeTab[i]->name,
! 8734: cur->nodesetval->nodeTab[i]->ns->prefix,
! 8735: NULL, 0);
! 8736: if (fullname == cur->nodesetval->nodeTab[i]->name)
! 8737: fullname = xmlStrdup(cur->nodesetval->nodeTab[i]->name);
! 8738: if (fullname == NULL) {
! 8739: XP_ERROR(XPATH_MEMORY_ERROR);
! 8740: }
! 8741: valuePush(ctxt, xmlXPathCacheWrapString(
! 8742: ctxt->context, fullname));
! 8743: }
! 8744: break;
! 8745: default:
! 8746: valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context,
! 8747: cur->nodesetval->nodeTab[i]));
! 8748: xmlXPathLocalNameFunction(ctxt, 1);
! 8749: }
! 8750: }
! 8751: xmlXPathReleaseObject(ctxt->context, cur);
! 8752: }
! 8753:
! 8754:
! 8755: /**
! 8756: * xmlXPathStringFunction:
! 8757: * @ctxt: the XPath Parser context
! 8758: * @nargs: the number of arguments
! 8759: *
! 8760: * Implement the string() XPath function
! 8761: * string string(object?)
! 8762: * The string function converts an object to a string as follows:
! 8763: * - A node-set is converted to a string by returning the value of
! 8764: * the node in the node-set that is first in document order.
! 8765: * If the node-set is empty, an empty string is returned.
! 8766: * - A number is converted to a string as follows
! 8767: * + NaN is converted to the string NaN
! 8768: * + positive zero is converted to the string 0
! 8769: * + negative zero is converted to the string 0
! 8770: * + positive infinity is converted to the string Infinity
! 8771: * + negative infinity is converted to the string -Infinity
! 8772: * + if the number is an integer, the number is represented in
! 8773: * decimal form as a Number with no decimal point and no leading
! 8774: * zeros, preceded by a minus sign (-) if the number is negative
! 8775: * + otherwise, the number is represented in decimal form as a
! 8776: * Number including a decimal point with at least one digit
! 8777: * before the decimal point and at least one digit after the
! 8778: * decimal point, preceded by a minus sign (-) if the number
! 8779: * is negative; there must be no leading zeros before the decimal
! 8780: * point apart possibly from the one required digit immediately
! 8781: * before the decimal point; beyond the one required digit
! 8782: * after the decimal point there must be as many, but only as
! 8783: * many, more digits as are needed to uniquely distinguish the
! 8784: * number from all other IEEE 754 numeric values.
! 8785: * - The boolean false value is converted to the string false.
! 8786: * The boolean true value is converted to the string true.
! 8787: *
! 8788: * If the argument is omitted, it defaults to a node-set with the
! 8789: * context node as its only member.
! 8790: */
! 8791: void
! 8792: xmlXPathStringFunction(xmlXPathParserContextPtr ctxt, int nargs) {
! 8793: xmlXPathObjectPtr cur;
! 8794:
! 8795: if (ctxt == NULL) return;
! 8796: if (nargs == 0) {
! 8797: valuePush(ctxt,
! 8798: xmlXPathCacheWrapString(ctxt->context,
! 8799: xmlXPathCastNodeToString(ctxt->context->node)));
! 8800: return;
! 8801: }
! 8802:
! 8803: CHECK_ARITY(1);
! 8804: cur = valuePop(ctxt);
! 8805: if (cur == NULL) XP_ERROR(XPATH_INVALID_OPERAND);
! 8806: valuePush(ctxt, xmlXPathCacheConvertString(ctxt->context, cur));
! 8807: }
! 8808:
! 8809: /**
! 8810: * xmlXPathStringLengthFunction:
! 8811: * @ctxt: the XPath Parser context
! 8812: * @nargs: the number of arguments
! 8813: *
! 8814: * Implement the string-length() XPath function
! 8815: * number string-length(string?)
! 8816: * The string-length returns the number of characters in the string
! 8817: * (see [3.6 Strings]). If the argument is omitted, it defaults to
! 8818: * the context node converted to a string, in other words the value
! 8819: * of the context node.
! 8820: */
! 8821: void
! 8822: xmlXPathStringLengthFunction(xmlXPathParserContextPtr ctxt, int nargs) {
! 8823: xmlXPathObjectPtr cur;
! 8824:
! 8825: if (nargs == 0) {
! 8826: if ((ctxt == NULL) || (ctxt->context == NULL))
! 8827: return;
! 8828: if (ctxt->context->node == NULL) {
! 8829: valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, 0));
! 8830: } else {
! 8831: xmlChar *content;
! 8832:
! 8833: content = xmlXPathCastNodeToString(ctxt->context->node);
! 8834: valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context,
! 8835: xmlUTF8Strlen(content)));
! 8836: xmlFree(content);
! 8837: }
! 8838: return;
! 8839: }
! 8840: CHECK_ARITY(1);
! 8841: CAST_TO_STRING;
! 8842: CHECK_TYPE(XPATH_STRING);
! 8843: cur = valuePop(ctxt);
! 8844: valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context,
! 8845: xmlUTF8Strlen(cur->stringval)));
! 8846: xmlXPathReleaseObject(ctxt->context, cur);
! 8847: }
! 8848:
! 8849: /**
! 8850: * xmlXPathConcatFunction:
! 8851: * @ctxt: the XPath Parser context
! 8852: * @nargs: the number of arguments
! 8853: *
! 8854: * Implement the concat() XPath function
! 8855: * string concat(string, string, string*)
! 8856: * The concat function returns the concatenation of its arguments.
! 8857: */
! 8858: void
! 8859: xmlXPathConcatFunction(xmlXPathParserContextPtr ctxt, int nargs) {
! 8860: xmlXPathObjectPtr cur, newobj;
! 8861: xmlChar *tmp;
! 8862:
! 8863: if (ctxt == NULL) return;
! 8864: if (nargs < 2) {
! 8865: CHECK_ARITY(2);
! 8866: }
! 8867:
! 8868: CAST_TO_STRING;
! 8869: cur = valuePop(ctxt);
! 8870: if ((cur == NULL) || (cur->type != XPATH_STRING)) {
! 8871: xmlXPathReleaseObject(ctxt->context, cur);
! 8872: return;
! 8873: }
! 8874: nargs--;
! 8875:
! 8876: while (nargs > 0) {
! 8877: CAST_TO_STRING;
! 8878: newobj = valuePop(ctxt);
! 8879: if ((newobj == NULL) || (newobj->type != XPATH_STRING)) {
! 8880: xmlXPathReleaseObject(ctxt->context, newobj);
! 8881: xmlXPathReleaseObject(ctxt->context, cur);
! 8882: XP_ERROR(XPATH_INVALID_TYPE);
! 8883: }
! 8884: tmp = xmlStrcat(newobj->stringval, cur->stringval);
! 8885: newobj->stringval = cur->stringval;
! 8886: cur->stringval = tmp;
! 8887: xmlXPathReleaseObject(ctxt->context, newobj);
! 8888: nargs--;
! 8889: }
! 8890: valuePush(ctxt, cur);
! 8891: }
! 8892:
! 8893: /**
! 8894: * xmlXPathContainsFunction:
! 8895: * @ctxt: the XPath Parser context
! 8896: * @nargs: the number of arguments
! 8897: *
! 8898: * Implement the contains() XPath function
! 8899: * boolean contains(string, string)
! 8900: * The contains function returns true if the first argument string
! 8901: * contains the second argument string, and otherwise returns false.
! 8902: */
! 8903: void
! 8904: xmlXPathContainsFunction(xmlXPathParserContextPtr ctxt, int nargs) {
! 8905: xmlXPathObjectPtr hay, needle;
! 8906:
! 8907: CHECK_ARITY(2);
! 8908: CAST_TO_STRING;
! 8909: CHECK_TYPE(XPATH_STRING);
! 8910: needle = valuePop(ctxt);
! 8911: CAST_TO_STRING;
! 8912: hay = valuePop(ctxt);
! 8913:
! 8914: if ((hay == NULL) || (hay->type != XPATH_STRING)) {
! 8915: xmlXPathReleaseObject(ctxt->context, hay);
! 8916: xmlXPathReleaseObject(ctxt->context, needle);
! 8917: XP_ERROR(XPATH_INVALID_TYPE);
! 8918: }
! 8919: if (xmlStrstr(hay->stringval, needle->stringval))
! 8920: valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, 1));
! 8921: else
! 8922: valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, 0));
! 8923: xmlXPathReleaseObject(ctxt->context, hay);
! 8924: xmlXPathReleaseObject(ctxt->context, needle);
! 8925: }
! 8926:
! 8927: /**
! 8928: * xmlXPathStartsWithFunction:
! 8929: * @ctxt: the XPath Parser context
! 8930: * @nargs: the number of arguments
! 8931: *
! 8932: * Implement the starts-with() XPath function
! 8933: * boolean starts-with(string, string)
! 8934: * The starts-with function returns true if the first argument string
! 8935: * starts with the second argument string, and otherwise returns false.
! 8936: */
! 8937: void
! 8938: xmlXPathStartsWithFunction(xmlXPathParserContextPtr ctxt, int nargs) {
! 8939: xmlXPathObjectPtr hay, needle;
! 8940: int n;
! 8941:
! 8942: CHECK_ARITY(2);
! 8943: CAST_TO_STRING;
! 8944: CHECK_TYPE(XPATH_STRING);
! 8945: needle = valuePop(ctxt);
! 8946: CAST_TO_STRING;
! 8947: hay = valuePop(ctxt);
! 8948:
! 8949: if ((hay == NULL) || (hay->type != XPATH_STRING)) {
! 8950: xmlXPathReleaseObject(ctxt->context, hay);
! 8951: xmlXPathReleaseObject(ctxt->context, needle);
! 8952: XP_ERROR(XPATH_INVALID_TYPE);
! 8953: }
! 8954: n = xmlStrlen(needle->stringval);
! 8955: if (xmlStrncmp(hay->stringval, needle->stringval, n))
! 8956: valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, 0));
! 8957: else
! 8958: valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, 1));
! 8959: xmlXPathReleaseObject(ctxt->context, hay);
! 8960: xmlXPathReleaseObject(ctxt->context, needle);
! 8961: }
! 8962:
! 8963: /**
! 8964: * xmlXPathSubstringFunction:
! 8965: * @ctxt: the XPath Parser context
! 8966: * @nargs: the number of arguments
! 8967: *
! 8968: * Implement the substring() XPath function
! 8969: * string substring(string, number, number?)
! 8970: * The substring function returns the substring of the first argument
! 8971: * starting at the position specified in the second argument with
! 8972: * length specified in the third argument. For example,
! 8973: * substring("12345",2,3) returns "234". If the third argument is not
! 8974: * specified, it returns the substring starting at the position specified
! 8975: * in the second argument and continuing to the end of the string. For
! 8976: * example, substring("12345",2) returns "2345". More precisely, each
! 8977: * character in the string (see [3.6 Strings]) is considered to have a
! 8978: * numeric position: the position of the first character is 1, the position
! 8979: * of the second character is 2 and so on. The returned substring contains
! 8980: * those characters for which the position of the character is greater than
! 8981: * or equal to the second argument and, if the third argument is specified,
! 8982: * less than the sum of the second and third arguments; the comparisons
! 8983: * and addition used for the above follow the standard IEEE 754 rules. Thus:
! 8984: * - substring("12345", 1.5, 2.6) returns "234"
! 8985: * - substring("12345", 0, 3) returns "12"
! 8986: * - substring("12345", 0 div 0, 3) returns ""
! 8987: * - substring("12345", 1, 0 div 0) returns ""
! 8988: * - substring("12345", -42, 1 div 0) returns "12345"
! 8989: * - substring("12345", -1 div 0, 1 div 0) returns ""
! 8990: */
! 8991: void
! 8992: xmlXPathSubstringFunction(xmlXPathParserContextPtr ctxt, int nargs) {
! 8993: xmlXPathObjectPtr str, start, len;
! 8994: double le=0, in;
! 8995: int i, l, m;
! 8996: xmlChar *ret;
! 8997:
! 8998: if (nargs < 2) {
! 8999: CHECK_ARITY(2);
! 9000: }
! 9001: if (nargs > 3) {
! 9002: CHECK_ARITY(3);
! 9003: }
! 9004: /*
! 9005: * take care of possible last (position) argument
! 9006: */
! 9007: if (nargs == 3) {
! 9008: CAST_TO_NUMBER;
! 9009: CHECK_TYPE(XPATH_NUMBER);
! 9010: len = valuePop(ctxt);
! 9011: le = len->floatval;
! 9012: xmlXPathReleaseObject(ctxt->context, len);
! 9013: }
! 9014:
! 9015: CAST_TO_NUMBER;
! 9016: CHECK_TYPE(XPATH_NUMBER);
! 9017: start = valuePop(ctxt);
! 9018: in = start->floatval;
! 9019: xmlXPathReleaseObject(ctxt->context, start);
! 9020: CAST_TO_STRING;
! 9021: CHECK_TYPE(XPATH_STRING);
! 9022: str = valuePop(ctxt);
! 9023: m = xmlUTF8Strlen((const unsigned char *)str->stringval);
! 9024:
! 9025: /*
! 9026: * If last pos not present, calculate last position
! 9027: */
! 9028: if (nargs != 3) {
! 9029: le = (double)m;
! 9030: if (in < 1.0)
! 9031: in = 1.0;
! 9032: }
! 9033:
! 9034: /* Need to check for the special cases where either
! 9035: * the index is NaN, the length is NaN, or both
! 9036: * arguments are infinity (relying on Inf + -Inf = NaN)
! 9037: */
! 9038: if (!xmlXPathIsInf(in) && !xmlXPathIsNaN(in + le)) {
! 9039: /*
! 9040: * To meet the requirements of the spec, the arguments
! 9041: * must be converted to integer format before
! 9042: * initial index calculations are done
! 9043: *
! 9044: * First we go to integer form, rounding up
! 9045: * and checking for special cases
! 9046: */
! 9047: i = (int) in;
! 9048: if (((double)i)+0.5 <= in) i++;
! 9049:
! 9050: if (xmlXPathIsInf(le) == 1) {
! 9051: l = m;
! 9052: if (i < 1)
! 9053: i = 1;
! 9054: }
! 9055: else if (xmlXPathIsInf(le) == -1 || le < 0.0)
! 9056: l = 0;
! 9057: else {
! 9058: l = (int) le;
! 9059: if (((double)l)+0.5 <= le) l++;
! 9060: }
! 9061:
! 9062: /* Now we normalize inidices */
! 9063: i -= 1;
! 9064: l += i;
! 9065: if (i < 0)
! 9066: i = 0;
! 9067: if (l > m)
! 9068: l = m;
! 9069:
! 9070: /* number of chars to copy */
! 9071: l -= i;
! 9072:
! 9073: ret = xmlUTF8Strsub(str->stringval, i, l);
! 9074: }
! 9075: else {
! 9076: ret = NULL;
! 9077: }
! 9078: if (ret == NULL)
! 9079: valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, ""));
! 9080: else {
! 9081: valuePush(ctxt, xmlXPathCacheNewString(ctxt->context, ret));
! 9082: xmlFree(ret);
! 9083: }
! 9084: xmlXPathReleaseObject(ctxt->context, str);
! 9085: }
! 9086:
! 9087: /**
! 9088: * xmlXPathSubstringBeforeFunction:
! 9089: * @ctxt: the XPath Parser context
! 9090: * @nargs: the number of arguments
! 9091: *
! 9092: * Implement the substring-before() XPath function
! 9093: * string substring-before(string, string)
! 9094: * The substring-before function returns the substring of the first
! 9095: * argument string that precedes the first occurrence of the second
! 9096: * argument string in the first argument string, or the empty string
! 9097: * if the first argument string does not contain the second argument
! 9098: * string. For example, substring-before("1999/04/01","/") returns 1999.
! 9099: */
! 9100: void
! 9101: xmlXPathSubstringBeforeFunction(xmlXPathParserContextPtr ctxt, int nargs) {
! 9102: xmlXPathObjectPtr str;
! 9103: xmlXPathObjectPtr find;
! 9104: xmlBufferPtr target;
! 9105: const xmlChar *point;
! 9106: int offset;
! 9107:
! 9108: CHECK_ARITY(2);
! 9109: CAST_TO_STRING;
! 9110: find = valuePop(ctxt);
! 9111: CAST_TO_STRING;
! 9112: str = valuePop(ctxt);
! 9113:
! 9114: target = xmlBufferCreate();
! 9115: if (target) {
! 9116: point = xmlStrstr(str->stringval, find->stringval);
! 9117: if (point) {
! 9118: offset = (int)(point - str->stringval);
! 9119: xmlBufferAdd(target, str->stringval, offset);
! 9120: }
! 9121: valuePush(ctxt, xmlXPathCacheNewString(ctxt->context,
! 9122: xmlBufferContent(target)));
! 9123: xmlBufferFree(target);
! 9124: }
! 9125: xmlXPathReleaseObject(ctxt->context, str);
! 9126: xmlXPathReleaseObject(ctxt->context, find);
! 9127: }
! 9128:
! 9129: /**
! 9130: * xmlXPathSubstringAfterFunction:
! 9131: * @ctxt: the XPath Parser context
! 9132: * @nargs: the number of arguments
! 9133: *
! 9134: * Implement the substring-after() XPath function
! 9135: * string substring-after(string, string)
! 9136: * The substring-after function returns the substring of the first
! 9137: * argument string that follows the first occurrence of the second
! 9138: * argument string in the first argument string, or the empty stringi
! 9139: * if the first argument string does not contain the second argument
! 9140: * string. For example, substring-after("1999/04/01","/") returns 04/01,
! 9141: * and substring-after("1999/04/01","19") returns 99/04/01.
! 9142: */
! 9143: void
! 9144: xmlXPathSubstringAfterFunction(xmlXPathParserContextPtr ctxt, int nargs) {
! 9145: xmlXPathObjectPtr str;
! 9146: xmlXPathObjectPtr find;
! 9147: xmlBufferPtr target;
! 9148: const xmlChar *point;
! 9149: int offset;
! 9150:
! 9151: CHECK_ARITY(2);
! 9152: CAST_TO_STRING;
! 9153: find = valuePop(ctxt);
! 9154: CAST_TO_STRING;
! 9155: str = valuePop(ctxt);
! 9156:
! 9157: target = xmlBufferCreate();
! 9158: if (target) {
! 9159: point = xmlStrstr(str->stringval, find->stringval);
! 9160: if (point) {
! 9161: offset = (int)(point - str->stringval) + xmlStrlen(find->stringval);
! 9162: xmlBufferAdd(target, &str->stringval[offset],
! 9163: xmlStrlen(str->stringval) - offset);
! 9164: }
! 9165: valuePush(ctxt, xmlXPathCacheNewString(ctxt->context,
! 9166: xmlBufferContent(target)));
! 9167: xmlBufferFree(target);
! 9168: }
! 9169: xmlXPathReleaseObject(ctxt->context, str);
! 9170: xmlXPathReleaseObject(ctxt->context, find);
! 9171: }
! 9172:
! 9173: /**
! 9174: * xmlXPathNormalizeFunction:
! 9175: * @ctxt: the XPath Parser context
! 9176: * @nargs: the number of arguments
! 9177: *
! 9178: * Implement the normalize-space() XPath function
! 9179: * string normalize-space(string?)
! 9180: * The normalize-space function returns the argument string with white
! 9181: * space normalized by stripping leading and trailing whitespace
! 9182: * and replacing sequences of whitespace characters by a single
! 9183: * space. Whitespace characters are the same allowed by the S production
! 9184: * in XML. If the argument is omitted, it defaults to the context
! 9185: * node converted to a string, in other words the value of the context node.
! 9186: */
! 9187: void
! 9188: xmlXPathNormalizeFunction(xmlXPathParserContextPtr ctxt, int nargs) {
! 9189: xmlXPathObjectPtr obj = NULL;
! 9190: xmlChar *source = NULL;
! 9191: xmlBufferPtr target;
! 9192: xmlChar blank;
! 9193:
! 9194: if (ctxt == NULL) return;
! 9195: if (nargs == 0) {
! 9196: /* Use current context node */
! 9197: valuePush(ctxt,
! 9198: xmlXPathCacheWrapString(ctxt->context,
! 9199: xmlXPathCastNodeToString(ctxt->context->node)));
! 9200: nargs = 1;
! 9201: }
! 9202:
! 9203: CHECK_ARITY(1);
! 9204: CAST_TO_STRING;
! 9205: CHECK_TYPE(XPATH_STRING);
! 9206: obj = valuePop(ctxt);
! 9207: source = obj->stringval;
! 9208:
! 9209: target = xmlBufferCreate();
! 9210: if (target && source) {
! 9211:
! 9212: /* Skip leading whitespaces */
! 9213: while (IS_BLANK_CH(*source))
! 9214: source++;
! 9215:
! 9216: /* Collapse intermediate whitespaces, and skip trailing whitespaces */
! 9217: blank = 0;
! 9218: while (*source) {
! 9219: if (IS_BLANK_CH(*source)) {
! 9220: blank = 0x20;
! 9221: } else {
! 9222: if (blank) {
! 9223: xmlBufferAdd(target, &blank, 1);
! 9224: blank = 0;
! 9225: }
! 9226: xmlBufferAdd(target, source, 1);
! 9227: }
! 9228: source++;
! 9229: }
! 9230: valuePush(ctxt, xmlXPathCacheNewString(ctxt->context,
! 9231: xmlBufferContent(target)));
! 9232: xmlBufferFree(target);
! 9233: }
! 9234: xmlXPathReleaseObject(ctxt->context, obj);
! 9235: }
! 9236:
! 9237: /**
! 9238: * xmlXPathTranslateFunction:
! 9239: * @ctxt: the XPath Parser context
! 9240: * @nargs: the number of arguments
! 9241: *
! 9242: * Implement the translate() XPath function
! 9243: * string translate(string, string, string)
! 9244: * The translate function returns the first argument string with
! 9245: * occurrences of characters in the second argument string replaced
! 9246: * by the character at the corresponding position in the third argument
! 9247: * string. For example, translate("bar","abc","ABC") returns the string
! 9248: * BAr. If there is a character in the second argument string with no
! 9249: * character at a corresponding position in the third argument string
! 9250: * (because the second argument string is longer than the third argument
! 9251: * string), then occurrences of that character in the first argument
! 9252: * string are removed. For example, translate("--aaa--","abc-","ABC")
! 9253: * returns "AAA". If a character occurs more than once in second
! 9254: * argument string, then the first occurrence determines the replacement
! 9255: * character. If the third argument string is longer than the second
! 9256: * argument string, then excess characters are ignored.
! 9257: */
! 9258: void
! 9259: xmlXPathTranslateFunction(xmlXPathParserContextPtr ctxt, int nargs) {
! 9260: xmlXPathObjectPtr str;
! 9261: xmlXPathObjectPtr from;
! 9262: xmlXPathObjectPtr to;
! 9263: xmlBufferPtr target;
! 9264: int offset, max;
! 9265: xmlChar ch;
! 9266: const xmlChar *point;
! 9267: xmlChar *cptr;
! 9268:
! 9269: CHECK_ARITY(3);
! 9270:
! 9271: CAST_TO_STRING;
! 9272: to = valuePop(ctxt);
! 9273: CAST_TO_STRING;
! 9274: from = valuePop(ctxt);
! 9275: CAST_TO_STRING;
! 9276: str = valuePop(ctxt);
! 9277:
! 9278: target = xmlBufferCreate();
! 9279: if (target) {
! 9280: max = xmlUTF8Strlen(to->stringval);
! 9281: for (cptr = str->stringval; (ch=*cptr); ) {
! 9282: offset = xmlUTF8Strloc(from->stringval, cptr);
! 9283: if (offset >= 0) {
! 9284: if (offset < max) {
! 9285: point = xmlUTF8Strpos(to->stringval, offset);
! 9286: if (point)
! 9287: xmlBufferAdd(target, point, xmlUTF8Strsize(point, 1));
! 9288: }
! 9289: } else
! 9290: xmlBufferAdd(target, cptr, xmlUTF8Strsize(cptr, 1));
! 9291:
! 9292: /* Step to next character in input */
! 9293: cptr++;
! 9294: if ( ch & 0x80 ) {
! 9295: /* if not simple ascii, verify proper format */
! 9296: if ( (ch & 0xc0) != 0xc0 ) {
! 9297: xmlGenericError(xmlGenericErrorContext,
! 9298: "xmlXPathTranslateFunction: Invalid UTF8 string\n");
! 9299: break;
! 9300: }
! 9301: /* then skip over remaining bytes for this char */
! 9302: while ( (ch <<= 1) & 0x80 )
! 9303: if ( (*cptr++ & 0xc0) != 0x80 ) {
! 9304: xmlGenericError(xmlGenericErrorContext,
! 9305: "xmlXPathTranslateFunction: Invalid UTF8 string\n");
! 9306: break;
! 9307: }
! 9308: if (ch & 0x80) /* must have had error encountered */
! 9309: break;
! 9310: }
! 9311: }
! 9312: }
! 9313: valuePush(ctxt, xmlXPathCacheNewString(ctxt->context,
! 9314: xmlBufferContent(target)));
! 9315: xmlBufferFree(target);
! 9316: xmlXPathReleaseObject(ctxt->context, str);
! 9317: xmlXPathReleaseObject(ctxt->context, from);
! 9318: xmlXPathReleaseObject(ctxt->context, to);
! 9319: }
! 9320:
! 9321: /**
! 9322: * xmlXPathBooleanFunction:
! 9323: * @ctxt: the XPath Parser context
! 9324: * @nargs: the number of arguments
! 9325: *
! 9326: * Implement the boolean() XPath function
! 9327: * boolean boolean(object)
! 9328: * The boolean function converts its argument to a boolean as follows:
! 9329: * - a number is true if and only if it is neither positive or
! 9330: * negative zero nor NaN
! 9331: * - a node-set is true if and only if it is non-empty
! 9332: * - a string is true if and only if its length is non-zero
! 9333: */
! 9334: void
! 9335: xmlXPathBooleanFunction(xmlXPathParserContextPtr ctxt, int nargs) {
! 9336: xmlXPathObjectPtr cur;
! 9337:
! 9338: CHECK_ARITY(1);
! 9339: cur = valuePop(ctxt);
! 9340: if (cur == NULL) XP_ERROR(XPATH_INVALID_OPERAND);
! 9341: cur = xmlXPathCacheConvertBoolean(ctxt->context, cur);
! 9342: valuePush(ctxt, cur);
! 9343: }
! 9344:
! 9345: /**
! 9346: * xmlXPathNotFunction:
! 9347: * @ctxt: the XPath Parser context
! 9348: * @nargs: the number of arguments
! 9349: *
! 9350: * Implement the not() XPath function
! 9351: * boolean not(boolean)
! 9352: * The not function returns true if its argument is false,
! 9353: * and false otherwise.
! 9354: */
! 9355: void
! 9356: xmlXPathNotFunction(xmlXPathParserContextPtr ctxt, int nargs) {
! 9357: CHECK_ARITY(1);
! 9358: CAST_TO_BOOLEAN;
! 9359: CHECK_TYPE(XPATH_BOOLEAN);
! 9360: ctxt->value->boolval = ! ctxt->value->boolval;
! 9361: }
! 9362:
! 9363: /**
! 9364: * xmlXPathTrueFunction:
! 9365: * @ctxt: the XPath Parser context
! 9366: * @nargs: the number of arguments
! 9367: *
! 9368: * Implement the true() XPath function
! 9369: * boolean true()
! 9370: */
! 9371: void
! 9372: xmlXPathTrueFunction(xmlXPathParserContextPtr ctxt, int nargs) {
! 9373: CHECK_ARITY(0);
! 9374: valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, 1));
! 9375: }
! 9376:
! 9377: /**
! 9378: * xmlXPathFalseFunction:
! 9379: * @ctxt: the XPath Parser context
! 9380: * @nargs: the number of arguments
! 9381: *
! 9382: * Implement the false() XPath function
! 9383: * boolean false()
! 9384: */
! 9385: void
! 9386: xmlXPathFalseFunction(xmlXPathParserContextPtr ctxt, int nargs) {
! 9387: CHECK_ARITY(0);
! 9388: valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, 0));
! 9389: }
! 9390:
! 9391: /**
! 9392: * xmlXPathLangFunction:
! 9393: * @ctxt: the XPath Parser context
! 9394: * @nargs: the number of arguments
! 9395: *
! 9396: * Implement the lang() XPath function
! 9397: * boolean lang(string)
! 9398: * The lang function returns true or false depending on whether the
! 9399: * language of the context node as specified by xml:lang attributes
! 9400: * is the same as or is a sublanguage of the language specified by
! 9401: * the argument string. The language of the context node is determined
! 9402: * by the value of the xml:lang attribute on the context node, or, if
! 9403: * the context node has no xml:lang attribute, by the value of the
! 9404: * xml:lang attribute on the nearest ancestor of the context node that
! 9405: * has an xml:lang attribute. If there is no such attribute, then lang
! 9406: * returns false. If there is such an attribute, then lang returns
! 9407: * true if the attribute value is equal to the argument ignoring case,
! 9408: * or if there is some suffix starting with - such that the attribute
! 9409: * value is equal to the argument ignoring that suffix of the attribute
! 9410: * value and ignoring case.
! 9411: */
! 9412: void
! 9413: xmlXPathLangFunction(xmlXPathParserContextPtr ctxt, int nargs) {
! 9414: xmlXPathObjectPtr val = NULL;
! 9415: const xmlChar *theLang = NULL;
! 9416: const xmlChar *lang;
! 9417: int ret = 0;
! 9418: int i;
! 9419:
! 9420: CHECK_ARITY(1);
! 9421: CAST_TO_STRING;
! 9422: CHECK_TYPE(XPATH_STRING);
! 9423: val = valuePop(ctxt);
! 9424: lang = val->stringval;
! 9425: theLang = xmlNodeGetLang(ctxt->context->node);
! 9426: if ((theLang != NULL) && (lang != NULL)) {
! 9427: for (i = 0;lang[i] != 0;i++)
! 9428: if (toupper(lang[i]) != toupper(theLang[i]))
! 9429: goto not_equal;
! 9430: if ((theLang[i] == 0) || (theLang[i] == '-'))
! 9431: ret = 1;
! 9432: }
! 9433: not_equal:
! 9434: if (theLang != NULL)
! 9435: xmlFree((void *)theLang);
! 9436:
! 9437: xmlXPathReleaseObject(ctxt->context, val);
! 9438: valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, ret));
! 9439: }
! 9440:
! 9441: /**
! 9442: * xmlXPathNumberFunction:
! 9443: * @ctxt: the XPath Parser context
! 9444: * @nargs: the number of arguments
! 9445: *
! 9446: * Implement the number() XPath function
! 9447: * number number(object?)
! 9448: */
! 9449: void
! 9450: xmlXPathNumberFunction(xmlXPathParserContextPtr ctxt, int nargs) {
! 9451: xmlXPathObjectPtr cur;
! 9452: double res;
! 9453:
! 9454: if (ctxt == NULL) return;
! 9455: if (nargs == 0) {
! 9456: if (ctxt->context->node == NULL) {
! 9457: valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, 0.0));
! 9458: } else {
! 9459: xmlChar* content = xmlNodeGetContent(ctxt->context->node);
! 9460:
! 9461: res = xmlXPathStringEvalNumber(content);
! 9462: valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, res));
! 9463: xmlFree(content);
! 9464: }
! 9465: return;
! 9466: }
! 9467:
! 9468: CHECK_ARITY(1);
! 9469: cur = valuePop(ctxt);
! 9470: valuePush(ctxt, xmlXPathCacheConvertNumber(ctxt->context, cur));
! 9471: }
! 9472:
! 9473: /**
! 9474: * xmlXPathSumFunction:
! 9475: * @ctxt: the XPath Parser context
! 9476: * @nargs: the number of arguments
! 9477: *
! 9478: * Implement the sum() XPath function
! 9479: * number sum(node-set)
! 9480: * The sum function returns the sum of the values of the nodes in
! 9481: * the argument node-set.
! 9482: */
! 9483: void
! 9484: xmlXPathSumFunction(xmlXPathParserContextPtr ctxt, int nargs) {
! 9485: xmlXPathObjectPtr cur;
! 9486: int i;
! 9487: double res = 0.0;
! 9488:
! 9489: CHECK_ARITY(1);
! 9490: if ((ctxt->value == NULL) ||
! 9491: ((ctxt->value->type != XPATH_NODESET) &&
! 9492: (ctxt->value->type != XPATH_XSLT_TREE)))
! 9493: XP_ERROR(XPATH_INVALID_TYPE);
! 9494: cur = valuePop(ctxt);
! 9495:
! 9496: if ((cur->nodesetval != NULL) && (cur->nodesetval->nodeNr != 0)) {
! 9497: for (i = 0; i < cur->nodesetval->nodeNr; i++) {
! 9498: res += xmlXPathCastNodeToNumber(cur->nodesetval->nodeTab[i]);
! 9499: }
! 9500: }
! 9501: valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, res));
! 9502: xmlXPathReleaseObject(ctxt->context, cur);
! 9503: }
! 9504:
! 9505: /*
! 9506: * To assure working code on multiple platforms, we want to only depend
! 9507: * upon the characteristic truncation of converting a floating point value
! 9508: * to an integer. Unfortunately, because of the different storage sizes
! 9509: * of our internal floating point value (double) and integer (int), we
! 9510: * can't directly convert (see bug 301162). This macro is a messy
! 9511: * 'workaround'
! 9512: */
! 9513: #define XTRUNC(f, v) \
! 9514: f = fmod((v), INT_MAX); \
! 9515: f = (v) - (f) + (double)((int)(f));
! 9516:
! 9517: /**
! 9518: * xmlXPathFloorFunction:
! 9519: * @ctxt: the XPath Parser context
! 9520: * @nargs: the number of arguments
! 9521: *
! 9522: * Implement the floor() XPath function
! 9523: * number floor(number)
! 9524: * The floor function returns the largest (closest to positive infinity)
! 9525: * number that is not greater than the argument and that is an integer.
! 9526: */
! 9527: void
! 9528: xmlXPathFloorFunction(xmlXPathParserContextPtr ctxt, int nargs) {
! 9529: double f;
! 9530:
! 9531: CHECK_ARITY(1);
! 9532: CAST_TO_NUMBER;
! 9533: CHECK_TYPE(XPATH_NUMBER);
! 9534:
! 9535: XTRUNC(f, ctxt->value->floatval);
! 9536: if (f != ctxt->value->floatval) {
! 9537: if (ctxt->value->floatval > 0)
! 9538: ctxt->value->floatval = f;
! 9539: else
! 9540: ctxt->value->floatval = f - 1;
! 9541: }
! 9542: }
! 9543:
! 9544: /**
! 9545: * xmlXPathCeilingFunction:
! 9546: * @ctxt: the XPath Parser context
! 9547: * @nargs: the number of arguments
! 9548: *
! 9549: * Implement the ceiling() XPath function
! 9550: * number ceiling(number)
! 9551: * The ceiling function returns the smallest (closest to negative infinity)
! 9552: * number that is not less than the argument and that is an integer.
! 9553: */
! 9554: void
! 9555: xmlXPathCeilingFunction(xmlXPathParserContextPtr ctxt, int nargs) {
! 9556: double f;
! 9557:
! 9558: CHECK_ARITY(1);
! 9559: CAST_TO_NUMBER;
! 9560: CHECK_TYPE(XPATH_NUMBER);
! 9561:
! 9562: #if 0
! 9563: ctxt->value->floatval = ceil(ctxt->value->floatval);
! 9564: #else
! 9565: XTRUNC(f, ctxt->value->floatval);
! 9566: if (f != ctxt->value->floatval) {
! 9567: if (ctxt->value->floatval > 0)
! 9568: ctxt->value->floatval = f + 1;
! 9569: else {
! 9570: if (ctxt->value->floatval < 0 && f == 0)
! 9571: ctxt->value->floatval = xmlXPathNZERO;
! 9572: else
! 9573: ctxt->value->floatval = f;
! 9574: }
! 9575:
! 9576: }
! 9577: #endif
! 9578: }
! 9579:
! 9580: /**
! 9581: * xmlXPathRoundFunction:
! 9582: * @ctxt: the XPath Parser context
! 9583: * @nargs: the number of arguments
! 9584: *
! 9585: * Implement the round() XPath function
! 9586: * number round(number)
! 9587: * The round function returns the number that is closest to the
! 9588: * argument and that is an integer. If there are two such numbers,
! 9589: * then the one that is even is returned.
! 9590: */
! 9591: void
! 9592: xmlXPathRoundFunction(xmlXPathParserContextPtr ctxt, int nargs) {
! 9593: double f;
! 9594:
! 9595: CHECK_ARITY(1);
! 9596: CAST_TO_NUMBER;
! 9597: CHECK_TYPE(XPATH_NUMBER);
! 9598:
! 9599: if ((xmlXPathIsNaN(ctxt->value->floatval)) ||
! 9600: (xmlXPathIsInf(ctxt->value->floatval) == 1) ||
! 9601: (xmlXPathIsInf(ctxt->value->floatval) == -1) ||
! 9602: (ctxt->value->floatval == 0.0))
! 9603: return;
! 9604:
! 9605: XTRUNC(f, ctxt->value->floatval);
! 9606: if (ctxt->value->floatval < 0) {
! 9607: if (ctxt->value->floatval < f - 0.5)
! 9608: ctxt->value->floatval = f - 1;
! 9609: else
! 9610: ctxt->value->floatval = f;
! 9611: if (ctxt->value->floatval == 0)
! 9612: ctxt->value->floatval = xmlXPathNZERO;
! 9613: } else {
! 9614: if (ctxt->value->floatval < f + 0.5)
! 9615: ctxt->value->floatval = f;
! 9616: else
! 9617: ctxt->value->floatval = f + 1;
! 9618: }
! 9619: }
! 9620:
! 9621: /************************************************************************
! 9622: * *
! 9623: * The Parser *
! 9624: * *
! 9625: ************************************************************************/
! 9626:
! 9627: /*
! 9628: * a few forward declarations since we use a recursive call based
! 9629: * implementation.
! 9630: */
! 9631: static void xmlXPathCompileExpr(xmlXPathParserContextPtr ctxt, int sort);
! 9632: static void xmlXPathCompPredicate(xmlXPathParserContextPtr ctxt, int filter);
! 9633: static void xmlXPathCompLocationPath(xmlXPathParserContextPtr ctxt);
! 9634: static void xmlXPathCompRelativeLocationPath(xmlXPathParserContextPtr ctxt);
! 9635: static xmlChar * xmlXPathParseNameComplex(xmlXPathParserContextPtr ctxt,
! 9636: int qualified);
! 9637:
! 9638: /**
! 9639: * xmlXPathCurrentChar:
! 9640: * @ctxt: the XPath parser context
! 9641: * @cur: pointer to the beginning of the char
! 9642: * @len: pointer to the length of the char read
! 9643: *
! 9644: * The current char value, if using UTF-8 this may actually span multiple
! 9645: * bytes in the input buffer.
! 9646: *
! 9647: * Returns the current char value and its length
! 9648: */
! 9649:
! 9650: static int
! 9651: xmlXPathCurrentChar(xmlXPathParserContextPtr ctxt, int *len) {
! 9652: unsigned char c;
! 9653: unsigned int val;
! 9654: const xmlChar *cur;
! 9655:
! 9656: if (ctxt == NULL)
! 9657: return(0);
! 9658: cur = ctxt->cur;
! 9659:
! 9660: /*
! 9661: * We are supposed to handle UTF8, check it's valid
! 9662: * From rfc2044: encoding of the Unicode values on UTF-8:
! 9663: *
! 9664: * UCS-4 range (hex.) UTF-8 octet sequence (binary)
! 9665: * 0000 0000-0000 007F 0xxxxxxx
! 9666: * 0000 0080-0000 07FF 110xxxxx 10xxxxxx
! 9667: * 0000 0800-0000 FFFF 1110xxxx 10xxxxxx 10xxxxxx
! 9668: *
! 9669: * Check for the 0x110000 limit too
! 9670: */
! 9671: c = *cur;
! 9672: if (c & 0x80) {
! 9673: if ((cur[1] & 0xc0) != 0x80)
! 9674: goto encoding_error;
! 9675: if ((c & 0xe0) == 0xe0) {
! 9676:
! 9677: if ((cur[2] & 0xc0) != 0x80)
! 9678: goto encoding_error;
! 9679: if ((c & 0xf0) == 0xf0) {
! 9680: if (((c & 0xf8) != 0xf0) ||
! 9681: ((cur[3] & 0xc0) != 0x80))
! 9682: goto encoding_error;
! 9683: /* 4-byte code */
! 9684: *len = 4;
! 9685: val = (cur[0] & 0x7) << 18;
! 9686: val |= (cur[1] & 0x3f) << 12;
! 9687: val |= (cur[2] & 0x3f) << 6;
! 9688: val |= cur[3] & 0x3f;
! 9689: } else {
! 9690: /* 3-byte code */
! 9691: *len = 3;
! 9692: val = (cur[0] & 0xf) << 12;
! 9693: val |= (cur[1] & 0x3f) << 6;
! 9694: val |= cur[2] & 0x3f;
! 9695: }
! 9696: } else {
! 9697: /* 2-byte code */
! 9698: *len = 2;
! 9699: val = (cur[0] & 0x1f) << 6;
! 9700: val |= cur[1] & 0x3f;
! 9701: }
! 9702: if (!IS_CHAR(val)) {
! 9703: XP_ERROR0(XPATH_INVALID_CHAR_ERROR);
! 9704: }
! 9705: return(val);
! 9706: } else {
! 9707: /* 1-byte code */
! 9708: *len = 1;
! 9709: return((int) *cur);
! 9710: }
! 9711: encoding_error:
! 9712: /*
! 9713: * If we detect an UTF8 error that probably means that the
! 9714: * input encoding didn't get properly advertised in the
! 9715: * declaration header. Report the error and switch the encoding
! 9716: * to ISO-Latin-1 (if you don't like this policy, just declare the
! 9717: * encoding !)
! 9718: */
! 9719: *len = 0;
! 9720: XP_ERROR0(XPATH_ENCODING_ERROR);
! 9721: }
! 9722:
! 9723: /**
! 9724: * xmlXPathParseNCName:
! 9725: * @ctxt: the XPath Parser context
! 9726: *
! 9727: * parse an XML namespace non qualified name.
! 9728: *
! 9729: * [NS 3] NCName ::= (Letter | '_') (NCNameChar)*
! 9730: *
! 9731: * [NS 4] NCNameChar ::= Letter | Digit | '.' | '-' | '_' |
! 9732: * CombiningChar | Extender
! 9733: *
! 9734: * Returns the namespace name or NULL
! 9735: */
! 9736:
! 9737: xmlChar *
! 9738: xmlXPathParseNCName(xmlXPathParserContextPtr ctxt) {
! 9739: const xmlChar *in;
! 9740: xmlChar *ret;
! 9741: int count = 0;
! 9742:
! 9743: if ((ctxt == NULL) || (ctxt->cur == NULL)) return(NULL);
! 9744: /*
! 9745: * Accelerator for simple ASCII names
! 9746: */
! 9747: in = ctxt->cur;
! 9748: if (((*in >= 0x61) && (*in <= 0x7A)) ||
! 9749: ((*in >= 0x41) && (*in <= 0x5A)) ||
! 9750: (*in == '_')) {
! 9751: in++;
! 9752: while (((*in >= 0x61) && (*in <= 0x7A)) ||
! 9753: ((*in >= 0x41) && (*in <= 0x5A)) ||
! 9754: ((*in >= 0x30) && (*in <= 0x39)) ||
! 9755: (*in == '_') || (*in == '.') ||
! 9756: (*in == '-'))
! 9757: in++;
! 9758: if ((*in == ' ') || (*in == '>') || (*in == '/') ||
! 9759: (*in == '[') || (*in == ']') || (*in == ':') ||
! 9760: (*in == '@') || (*in == '*')) {
! 9761: count = in - ctxt->cur;
! 9762: if (count == 0)
! 9763: return(NULL);
! 9764: ret = xmlStrndup(ctxt->cur, count);
! 9765: ctxt->cur = in;
! 9766: return(ret);
! 9767: }
! 9768: }
! 9769: return(xmlXPathParseNameComplex(ctxt, 0));
! 9770: }
! 9771:
! 9772:
! 9773: /**
! 9774: * xmlXPathParseQName:
! 9775: * @ctxt: the XPath Parser context
! 9776: * @prefix: a xmlChar **
! 9777: *
! 9778: * parse an XML qualified name
! 9779: *
! 9780: * [NS 5] QName ::= (Prefix ':')? LocalPart
! 9781: *
! 9782: * [NS 6] Prefix ::= NCName
! 9783: *
! 9784: * [NS 7] LocalPart ::= NCName
! 9785: *
! 9786: * Returns the function returns the local part, and prefix is updated
! 9787: * to get the Prefix if any.
! 9788: */
! 9789:
! 9790: static xmlChar *
! 9791: xmlXPathParseQName(xmlXPathParserContextPtr ctxt, xmlChar **prefix) {
! 9792: xmlChar *ret = NULL;
! 9793:
! 9794: *prefix = NULL;
! 9795: ret = xmlXPathParseNCName(ctxt);
! 9796: if (ret && CUR == ':') {
! 9797: *prefix = ret;
! 9798: NEXT;
! 9799: ret = xmlXPathParseNCName(ctxt);
! 9800: }
! 9801: return(ret);
! 9802: }
! 9803:
! 9804: /**
! 9805: * xmlXPathParseName:
! 9806: * @ctxt: the XPath Parser context
! 9807: *
! 9808: * parse an XML name
! 9809: *
! 9810: * [4] NameChar ::= Letter | Digit | '.' | '-' | '_' | ':' |
! 9811: * CombiningChar | Extender
! 9812: *
! 9813: * [5] Name ::= (Letter | '_' | ':') (NameChar)*
! 9814: *
! 9815: * Returns the namespace name or NULL
! 9816: */
! 9817:
! 9818: xmlChar *
! 9819: xmlXPathParseName(xmlXPathParserContextPtr ctxt) {
! 9820: const xmlChar *in;
! 9821: xmlChar *ret;
! 9822: int count = 0;
! 9823:
! 9824: if ((ctxt == NULL) || (ctxt->cur == NULL)) return(NULL);
! 9825: /*
! 9826: * Accelerator for simple ASCII names
! 9827: */
! 9828: in = ctxt->cur;
! 9829: if (((*in >= 0x61) && (*in <= 0x7A)) ||
! 9830: ((*in >= 0x41) && (*in <= 0x5A)) ||
! 9831: (*in == '_') || (*in == ':')) {
! 9832: in++;
! 9833: while (((*in >= 0x61) && (*in <= 0x7A)) ||
! 9834: ((*in >= 0x41) && (*in <= 0x5A)) ||
! 9835: ((*in >= 0x30) && (*in <= 0x39)) ||
! 9836: (*in == '_') || (*in == '-') ||
! 9837: (*in == ':') || (*in == '.'))
! 9838: in++;
! 9839: if ((*in > 0) && (*in < 0x80)) {
! 9840: count = in - ctxt->cur;
! 9841: ret = xmlStrndup(ctxt->cur, count);
! 9842: ctxt->cur = in;
! 9843: return(ret);
! 9844: }
! 9845: }
! 9846: return(xmlXPathParseNameComplex(ctxt, 1));
! 9847: }
! 9848:
! 9849: static xmlChar *
! 9850: xmlXPathParseNameComplex(xmlXPathParserContextPtr ctxt, int qualified) {
! 9851: xmlChar buf[XML_MAX_NAMELEN + 5];
! 9852: int len = 0, l;
! 9853: int c;
! 9854:
! 9855: /*
! 9856: * Handler for more complex cases
! 9857: */
! 9858: c = CUR_CHAR(l);
! 9859: if ((c == ' ') || (c == '>') || (c == '/') || /* accelerators */
! 9860: (c == '[') || (c == ']') || (c == '@') || /* accelerators */
! 9861: (c == '*') || /* accelerators */
! 9862: (!IS_LETTER(c) && (c != '_') &&
! 9863: ((qualified) && (c != ':')))) {
! 9864: return(NULL);
! 9865: }
! 9866:
! 9867: while ((c != ' ') && (c != '>') && (c != '/') && /* test bigname.xml */
! 9868: ((IS_LETTER(c)) || (IS_DIGIT(c)) ||
! 9869: (c == '.') || (c == '-') ||
! 9870: (c == '_') || ((qualified) && (c == ':')) ||
! 9871: (IS_COMBINING(c)) ||
! 9872: (IS_EXTENDER(c)))) {
! 9873: COPY_BUF(l,buf,len,c);
! 9874: NEXTL(l);
! 9875: c = CUR_CHAR(l);
! 9876: if (len >= XML_MAX_NAMELEN) {
! 9877: /*
! 9878: * Okay someone managed to make a huge name, so he's ready to pay
! 9879: * for the processing speed.
! 9880: */
! 9881: xmlChar *buffer;
! 9882: int max = len * 2;
! 9883:
! 9884: buffer = (xmlChar *) xmlMallocAtomic(max * sizeof(xmlChar));
! 9885: if (buffer == NULL) {
! 9886: XP_ERRORNULL(XPATH_MEMORY_ERROR);
! 9887: }
! 9888: memcpy(buffer, buf, len);
! 9889: while ((IS_LETTER(c)) || (IS_DIGIT(c)) || /* test bigname.xml */
! 9890: (c == '.') || (c == '-') ||
! 9891: (c == '_') || ((qualified) && (c == ':')) ||
! 9892: (IS_COMBINING(c)) ||
! 9893: (IS_EXTENDER(c))) {
! 9894: if (len + 10 > max) {
! 9895: max *= 2;
! 9896: buffer = (xmlChar *) xmlRealloc(buffer,
! 9897: max * sizeof(xmlChar));
! 9898: if (buffer == NULL) {
! 9899: XP_ERRORNULL(XPATH_MEMORY_ERROR);
! 9900: }
! 9901: }
! 9902: COPY_BUF(l,buffer,len,c);
! 9903: NEXTL(l);
! 9904: c = CUR_CHAR(l);
! 9905: }
! 9906: buffer[len] = 0;
! 9907: return(buffer);
! 9908: }
! 9909: }
! 9910: if (len == 0)
! 9911: return(NULL);
! 9912: return(xmlStrndup(buf, len));
! 9913: }
! 9914:
! 9915: #define MAX_FRAC 20
! 9916:
! 9917: /*
! 9918: * These are used as divisors for the fractional part of a number.
! 9919: * Since the table includes 1.0 (representing '0' fractional digits),
! 9920: * it must be dimensioned at MAX_FRAC+1 (bug 133921)
! 9921: */
! 9922: static double my_pow10[MAX_FRAC+1] = {
! 9923: 1.0, 10.0, 100.0, 1000.0, 10000.0,
! 9924: 100000.0, 1000000.0, 10000000.0, 100000000.0, 1000000000.0,
! 9925: 10000000000.0, 100000000000.0, 1000000000000.0, 10000000000000.0,
! 9926: 100000000000000.0,
! 9927: 1000000000000000.0, 10000000000000000.0, 100000000000000000.0,
! 9928: 1000000000000000000.0, 10000000000000000000.0, 100000000000000000000.0
! 9929: };
! 9930:
! 9931: /**
! 9932: * xmlXPathStringEvalNumber:
! 9933: * @str: A string to scan
! 9934: *
! 9935: * [30a] Float ::= Number ('e' Digits?)?
! 9936: *
! 9937: * [30] Number ::= Digits ('.' Digits?)?
! 9938: * | '.' Digits
! 9939: * [31] Digits ::= [0-9]+
! 9940: *
! 9941: * Compile a Number in the string
! 9942: * In complement of the Number expression, this function also handles
! 9943: * negative values : '-' Number.
! 9944: *
! 9945: * Returns the double value.
! 9946: */
! 9947: double
! 9948: xmlXPathStringEvalNumber(const xmlChar *str) {
! 9949: const xmlChar *cur = str;
! 9950: double ret;
! 9951: int ok = 0;
! 9952: int isneg = 0;
! 9953: int exponent = 0;
! 9954: int is_exponent_negative = 0;
! 9955: #ifdef __GNUC__
! 9956: unsigned long tmp = 0;
! 9957: double temp;
! 9958: #endif
! 9959: if (cur == NULL) return(0);
! 9960: while (IS_BLANK_CH(*cur)) cur++;
! 9961: if ((*cur != '.') && ((*cur < '0') || (*cur > '9')) && (*cur != '-')) {
! 9962: return(xmlXPathNAN);
! 9963: }
! 9964: if (*cur == '-') {
! 9965: isneg = 1;
! 9966: cur++;
! 9967: }
! 9968:
! 9969: #ifdef __GNUC__
! 9970: /*
! 9971: * tmp/temp is a workaround against a gcc compiler bug
! 9972: * http://veillard.com/gcc.bug
! 9973: */
! 9974: ret = 0;
! 9975: while ((*cur >= '0') && (*cur <= '9')) {
! 9976: ret = ret * 10;
! 9977: tmp = (*cur - '0');
! 9978: ok = 1;
! 9979: cur++;
! 9980: temp = (double) tmp;
! 9981: ret = ret + temp;
! 9982: }
! 9983: #else
! 9984: ret = 0;
! 9985: while ((*cur >= '0') && (*cur <= '9')) {
! 9986: ret = ret * 10 + (*cur - '0');
! 9987: ok = 1;
! 9988: cur++;
! 9989: }
! 9990: #endif
! 9991:
! 9992: if (*cur == '.') {
! 9993: int v, frac = 0;
! 9994: double fraction = 0;
! 9995:
! 9996: cur++;
! 9997: if (((*cur < '0') || (*cur > '9')) && (!ok)) {
! 9998: return(xmlXPathNAN);
! 9999: }
! 10000: while (((*cur >= '0') && (*cur <= '9')) && (frac < MAX_FRAC)) {
! 10001: v = (*cur - '0');
! 10002: fraction = fraction * 10 + v;
! 10003: frac = frac + 1;
! 10004: cur++;
! 10005: }
! 10006: fraction /= my_pow10[frac];
! 10007: ret = ret + fraction;
! 10008: while ((*cur >= '0') && (*cur <= '9'))
! 10009: cur++;
! 10010: }
! 10011: if ((*cur == 'e') || (*cur == 'E')) {
! 10012: cur++;
! 10013: if (*cur == '-') {
! 10014: is_exponent_negative = 1;
! 10015: cur++;
! 10016: } else if (*cur == '+') {
! 10017: cur++;
! 10018: }
! 10019: while ((*cur >= '0') && (*cur <= '9')) {
! 10020: exponent = exponent * 10 + (*cur - '0');
! 10021: cur++;
! 10022: }
! 10023: }
! 10024: while (IS_BLANK_CH(*cur)) cur++;
! 10025: if (*cur != 0) return(xmlXPathNAN);
! 10026: if (isneg) ret = -ret;
! 10027: if (is_exponent_negative) exponent = -exponent;
! 10028: ret *= pow(10.0, (double)exponent);
! 10029: return(ret);
! 10030: }
! 10031:
! 10032: /**
! 10033: * xmlXPathCompNumber:
! 10034: * @ctxt: the XPath Parser context
! 10035: *
! 10036: * [30] Number ::= Digits ('.' Digits?)?
! 10037: * | '.' Digits
! 10038: * [31] Digits ::= [0-9]+
! 10039: *
! 10040: * Compile a Number, then push it on the stack
! 10041: *
! 10042: */
! 10043: static void
! 10044: xmlXPathCompNumber(xmlXPathParserContextPtr ctxt)
! 10045: {
! 10046: double ret = 0.0;
! 10047: double mult = 1;
! 10048: int ok = 0;
! 10049: int exponent = 0;
! 10050: int is_exponent_negative = 0;
! 10051: #ifdef __GNUC__
! 10052: unsigned long tmp = 0;
! 10053: double temp;
! 10054: #endif
! 10055:
! 10056: CHECK_ERROR;
! 10057: if ((CUR != '.') && ((CUR < '0') || (CUR > '9'))) {
! 10058: XP_ERROR(XPATH_NUMBER_ERROR);
! 10059: }
! 10060: #ifdef __GNUC__
! 10061: /*
! 10062: * tmp/temp is a workaround against a gcc compiler bug
! 10063: * http://veillard.com/gcc.bug
! 10064: */
! 10065: ret = 0;
! 10066: while ((CUR >= '0') && (CUR <= '9')) {
! 10067: ret = ret * 10;
! 10068: tmp = (CUR - '0');
! 10069: ok = 1;
! 10070: NEXT;
! 10071: temp = (double) tmp;
! 10072: ret = ret + temp;
! 10073: }
! 10074: #else
! 10075: ret = 0;
! 10076: while ((CUR >= '0') && (CUR <= '9')) {
! 10077: ret = ret * 10 + (CUR - '0');
! 10078: ok = 1;
! 10079: NEXT;
! 10080: }
! 10081: #endif
! 10082: if (CUR == '.') {
! 10083: int v, frac = 0;
! 10084: double fraction = 0;
! 10085:
! 10086: NEXT;
! 10087: if (((CUR < '0') || (CUR > '9')) && (!ok)) {
! 10088: XP_ERROR(XPATH_NUMBER_ERROR);
! 10089: }
! 10090: while ((CUR >= '0') && (CUR <= '9') && (frac < MAX_FRAC)) {
! 10091: v = (CUR - '0');
! 10092: fraction = fraction * 10 + v;
! 10093: frac = frac + 1;
! 10094: NEXT;
! 10095: }
! 10096: fraction /= my_pow10[frac];
! 10097: ret = ret + fraction;
! 10098: while ((CUR >= '0') && (CUR <= '9'))
! 10099: NEXT;
! 10100: }
! 10101: if ((CUR == 'e') || (CUR == 'E')) {
! 10102: NEXT;
! 10103: if (CUR == '-') {
! 10104: is_exponent_negative = 1;
! 10105: NEXT;
! 10106: } else if (CUR == '+') {
! 10107: NEXT;
! 10108: }
! 10109: while ((CUR >= '0') && (CUR <= '9')) {
! 10110: exponent = exponent * 10 + (CUR - '0');
! 10111: NEXT;
! 10112: }
! 10113: if (is_exponent_negative)
! 10114: exponent = -exponent;
! 10115: ret *= pow(10.0, (double) exponent);
! 10116: }
! 10117: PUSH_LONG_EXPR(XPATH_OP_VALUE, XPATH_NUMBER, 0, 0,
! 10118: xmlXPathCacheNewFloat(ctxt->context, ret), NULL);
! 10119: }
! 10120:
! 10121: /**
! 10122: * xmlXPathParseLiteral:
! 10123: * @ctxt: the XPath Parser context
! 10124: *
! 10125: * Parse a Literal
! 10126: *
! 10127: * [29] Literal ::= '"' [^"]* '"'
! 10128: * | "'" [^']* "'"
! 10129: *
! 10130: * Returns the value found or NULL in case of error
! 10131: */
! 10132: static xmlChar *
! 10133: xmlXPathParseLiteral(xmlXPathParserContextPtr ctxt) {
! 10134: const xmlChar *q;
! 10135: xmlChar *ret = NULL;
! 10136:
! 10137: if (CUR == '"') {
! 10138: NEXT;
! 10139: q = CUR_PTR;
! 10140: while ((IS_CHAR_CH(CUR)) && (CUR != '"'))
! 10141: NEXT;
! 10142: if (!IS_CHAR_CH(CUR)) {
! 10143: XP_ERRORNULL(XPATH_UNFINISHED_LITERAL_ERROR);
! 10144: } else {
! 10145: ret = xmlStrndup(q, CUR_PTR - q);
! 10146: NEXT;
! 10147: }
! 10148: } else if (CUR == '\'') {
! 10149: NEXT;
! 10150: q = CUR_PTR;
! 10151: while ((IS_CHAR_CH(CUR)) && (CUR != '\''))
! 10152: NEXT;
! 10153: if (!IS_CHAR_CH(CUR)) {
! 10154: XP_ERRORNULL(XPATH_UNFINISHED_LITERAL_ERROR);
! 10155: } else {
! 10156: ret = xmlStrndup(q, CUR_PTR - q);
! 10157: NEXT;
! 10158: }
! 10159: } else {
! 10160: XP_ERRORNULL(XPATH_START_LITERAL_ERROR);
! 10161: }
! 10162: return(ret);
! 10163: }
! 10164:
! 10165: /**
! 10166: * xmlXPathCompLiteral:
! 10167: * @ctxt: the XPath Parser context
! 10168: *
! 10169: * Parse a Literal and push it on the stack.
! 10170: *
! 10171: * [29] Literal ::= '"' [^"]* '"'
! 10172: * | "'" [^']* "'"
! 10173: *
! 10174: * TODO: xmlXPathCompLiteral memory allocation could be improved.
! 10175: */
! 10176: static void
! 10177: xmlXPathCompLiteral(xmlXPathParserContextPtr ctxt) {
! 10178: const xmlChar *q;
! 10179: xmlChar *ret = NULL;
! 10180:
! 10181: if (CUR == '"') {
! 10182: NEXT;
! 10183: q = CUR_PTR;
! 10184: while ((IS_CHAR_CH(CUR)) && (CUR != '"'))
! 10185: NEXT;
! 10186: if (!IS_CHAR_CH(CUR)) {
! 10187: XP_ERROR(XPATH_UNFINISHED_LITERAL_ERROR);
! 10188: } else {
! 10189: ret = xmlStrndup(q, CUR_PTR - q);
! 10190: NEXT;
! 10191: }
! 10192: } else if (CUR == '\'') {
! 10193: NEXT;
! 10194: q = CUR_PTR;
! 10195: while ((IS_CHAR_CH(CUR)) && (CUR != '\''))
! 10196: NEXT;
! 10197: if (!IS_CHAR_CH(CUR)) {
! 10198: XP_ERROR(XPATH_UNFINISHED_LITERAL_ERROR);
! 10199: } else {
! 10200: ret = xmlStrndup(q, CUR_PTR - q);
! 10201: NEXT;
! 10202: }
! 10203: } else {
! 10204: XP_ERROR(XPATH_START_LITERAL_ERROR);
! 10205: }
! 10206: if (ret == NULL) return;
! 10207: PUSH_LONG_EXPR(XPATH_OP_VALUE, XPATH_STRING, 0, 0,
! 10208: xmlXPathCacheNewString(ctxt->context, ret), NULL);
! 10209: xmlFree(ret);
! 10210: }
! 10211:
! 10212: /**
! 10213: * xmlXPathCompVariableReference:
! 10214: * @ctxt: the XPath Parser context
! 10215: *
! 10216: * Parse a VariableReference, evaluate it and push it on the stack.
! 10217: *
! 10218: * The variable bindings consist of a mapping from variable names
! 10219: * to variable values. The value of a variable is an object, which can be
! 10220: * of any of the types that are possible for the value of an expression,
! 10221: * and may also be of additional types not specified here.
! 10222: *
! 10223: * Early evaluation is possible since:
! 10224: * The variable bindings [...] used to evaluate a subexpression are
! 10225: * always the same as those used to evaluate the containing expression.
! 10226: *
! 10227: * [36] VariableReference ::= '$' QName
! 10228: */
! 10229: static void
! 10230: xmlXPathCompVariableReference(xmlXPathParserContextPtr ctxt) {
! 10231: xmlChar *name;
! 10232: xmlChar *prefix;
! 10233:
! 10234: SKIP_BLANKS;
! 10235: if (CUR != '$') {
! 10236: XP_ERROR(XPATH_VARIABLE_REF_ERROR);
! 10237: }
! 10238: NEXT;
! 10239: name = xmlXPathParseQName(ctxt, &prefix);
! 10240: if (name == NULL) {
! 10241: XP_ERROR(XPATH_VARIABLE_REF_ERROR);
! 10242: }
! 10243: ctxt->comp->last = -1;
! 10244: PUSH_LONG_EXPR(XPATH_OP_VARIABLE, 0, 0, 0,
! 10245: name, prefix);
! 10246: SKIP_BLANKS;
! 10247: if ((ctxt->context != NULL) && (ctxt->context->flags & XML_XPATH_NOVAR)) {
! 10248: XP_ERROR(XPATH_UNDEF_VARIABLE_ERROR);
! 10249: }
! 10250: }
! 10251:
! 10252: /**
! 10253: * xmlXPathIsNodeType:
! 10254: * @name: a name string
! 10255: *
! 10256: * Is the name given a NodeType one.
! 10257: *
! 10258: * [38] NodeType ::= 'comment'
! 10259: * | 'text'
! 10260: * | 'processing-instruction'
! 10261: * | 'node'
! 10262: *
! 10263: * Returns 1 if true 0 otherwise
! 10264: */
! 10265: int
! 10266: xmlXPathIsNodeType(const xmlChar *name) {
! 10267: if (name == NULL)
! 10268: return(0);
! 10269:
! 10270: if (xmlStrEqual(name, BAD_CAST "node"))
! 10271: return(1);
! 10272: if (xmlStrEqual(name, BAD_CAST "text"))
! 10273: return(1);
! 10274: if (xmlStrEqual(name, BAD_CAST "comment"))
! 10275: return(1);
! 10276: if (xmlStrEqual(name, BAD_CAST "processing-instruction"))
! 10277: return(1);
! 10278: return(0);
! 10279: }
! 10280:
! 10281: /**
! 10282: * xmlXPathCompFunctionCall:
! 10283: * @ctxt: the XPath Parser context
! 10284: *
! 10285: * [16] FunctionCall ::= FunctionName '(' ( Argument ( ',' Argument)*)? ')'
! 10286: * [17] Argument ::= Expr
! 10287: *
! 10288: * Compile a function call, the evaluation of all arguments are
! 10289: * pushed on the stack
! 10290: */
! 10291: static void
! 10292: xmlXPathCompFunctionCall(xmlXPathParserContextPtr ctxt) {
! 10293: xmlChar *name;
! 10294: xmlChar *prefix;
! 10295: int nbargs = 0;
! 10296: int sort = 1;
! 10297:
! 10298: name = xmlXPathParseQName(ctxt, &prefix);
! 10299: if (name == NULL) {
! 10300: xmlFree(prefix);
! 10301: XP_ERROR(XPATH_EXPR_ERROR);
! 10302: }
! 10303: SKIP_BLANKS;
! 10304: #ifdef DEBUG_EXPR
! 10305: if (prefix == NULL)
! 10306: xmlGenericError(xmlGenericErrorContext, "Calling function %s\n",
! 10307: name);
! 10308: else
! 10309: xmlGenericError(xmlGenericErrorContext, "Calling function %s:%s\n",
! 10310: prefix, name);
! 10311: #endif
! 10312:
! 10313: if (CUR != '(') {
! 10314: XP_ERROR(XPATH_EXPR_ERROR);
! 10315: }
! 10316: NEXT;
! 10317: SKIP_BLANKS;
! 10318:
! 10319: /*
! 10320: * Optimization for count(): we don't need the node-set to be sorted.
! 10321: */
! 10322: if ((prefix == NULL) && (name[0] == 'c') &&
! 10323: xmlStrEqual(name, BAD_CAST "count"))
! 10324: {
! 10325: sort = 0;
! 10326: }
! 10327: ctxt->comp->last = -1;
! 10328: if (CUR != ')') {
! 10329: while (CUR != 0) {
! 10330: int op1 = ctxt->comp->last;
! 10331: ctxt->comp->last = -1;
! 10332: xmlXPathCompileExpr(ctxt, sort);
! 10333: if (ctxt->error != XPATH_EXPRESSION_OK) {
! 10334: xmlFree(name);
! 10335: xmlFree(prefix);
! 10336: return;
! 10337: }
! 10338: PUSH_BINARY_EXPR(XPATH_OP_ARG, op1, ctxt->comp->last, 0, 0);
! 10339: nbargs++;
! 10340: if (CUR == ')') break;
! 10341: if (CUR != ',') {
! 10342: XP_ERROR(XPATH_EXPR_ERROR);
! 10343: }
! 10344: NEXT;
! 10345: SKIP_BLANKS;
! 10346: }
! 10347: }
! 10348: PUSH_LONG_EXPR(XPATH_OP_FUNCTION, nbargs, 0, 0,
! 10349: name, prefix);
! 10350: NEXT;
! 10351: SKIP_BLANKS;
! 10352: }
! 10353:
! 10354: /**
! 10355: * xmlXPathCompPrimaryExpr:
! 10356: * @ctxt: the XPath Parser context
! 10357: *
! 10358: * [15] PrimaryExpr ::= VariableReference
! 10359: * | '(' Expr ')'
! 10360: * | Literal
! 10361: * | Number
! 10362: * | FunctionCall
! 10363: *
! 10364: * Compile a primary expression.
! 10365: */
! 10366: static void
! 10367: xmlXPathCompPrimaryExpr(xmlXPathParserContextPtr ctxt) {
! 10368: SKIP_BLANKS;
! 10369: if (CUR == '$') xmlXPathCompVariableReference(ctxt);
! 10370: else if (CUR == '(') {
! 10371: NEXT;
! 10372: SKIP_BLANKS;
! 10373: xmlXPathCompileExpr(ctxt, 1);
! 10374: CHECK_ERROR;
! 10375: if (CUR != ')') {
! 10376: XP_ERROR(XPATH_EXPR_ERROR);
! 10377: }
! 10378: NEXT;
! 10379: SKIP_BLANKS;
! 10380: } else if (IS_ASCII_DIGIT(CUR) || (CUR == '.' && IS_ASCII_DIGIT(NXT(1)))) {
! 10381: xmlXPathCompNumber(ctxt);
! 10382: } else if ((CUR == '\'') || (CUR == '"')) {
! 10383: xmlXPathCompLiteral(ctxt);
! 10384: } else {
! 10385: xmlXPathCompFunctionCall(ctxt);
! 10386: }
! 10387: SKIP_BLANKS;
! 10388: }
! 10389:
! 10390: /**
! 10391: * xmlXPathCompFilterExpr:
! 10392: * @ctxt: the XPath Parser context
! 10393: *
! 10394: * [20] FilterExpr ::= PrimaryExpr
! 10395: * | FilterExpr Predicate
! 10396: *
! 10397: * Compile a filter expression.
! 10398: * Square brackets are used to filter expressions in the same way that
! 10399: * they are used in location paths. It is an error if the expression to
! 10400: * be filtered does not evaluate to a node-set. The context node list
! 10401: * used for evaluating the expression in square brackets is the node-set
! 10402: * to be filtered listed in document order.
! 10403: */
! 10404:
! 10405: static void
! 10406: xmlXPathCompFilterExpr(xmlXPathParserContextPtr ctxt) {
! 10407: xmlXPathCompPrimaryExpr(ctxt);
! 10408: CHECK_ERROR;
! 10409: SKIP_BLANKS;
! 10410:
! 10411: while (CUR == '[') {
! 10412: xmlXPathCompPredicate(ctxt, 1);
! 10413: SKIP_BLANKS;
! 10414: }
! 10415:
! 10416:
! 10417: }
! 10418:
! 10419: /**
! 10420: * xmlXPathScanName:
! 10421: * @ctxt: the XPath Parser context
! 10422: *
! 10423: * Trickery: parse an XML name but without consuming the input flow
! 10424: * Needed to avoid insanity in the parser state.
! 10425: *
! 10426: * [4] NameChar ::= Letter | Digit | '.' | '-' | '_' | ':' |
! 10427: * CombiningChar | Extender
! 10428: *
! 10429: * [5] Name ::= (Letter | '_' | ':') (NameChar)*
! 10430: *
! 10431: * [6] Names ::= Name (S Name)*
! 10432: *
! 10433: * Returns the Name parsed or NULL
! 10434: */
! 10435:
! 10436: static xmlChar *
! 10437: xmlXPathScanName(xmlXPathParserContextPtr ctxt) {
! 10438: int len = 0, l;
! 10439: int c;
! 10440: const xmlChar *cur;
! 10441: xmlChar *ret;
! 10442:
! 10443: cur = ctxt->cur;
! 10444:
! 10445: c = CUR_CHAR(l);
! 10446: if ((c == ' ') || (c == '>') || (c == '/') || /* accelerators */
! 10447: (!IS_LETTER(c) && (c != '_') &&
! 10448: (c != ':'))) {
! 10449: return(NULL);
! 10450: }
! 10451:
! 10452: while ((c != ' ') && (c != '>') && (c != '/') && /* test bigname.xml */
! 10453: ((IS_LETTER(c)) || (IS_DIGIT(c)) ||
! 10454: (c == '.') || (c == '-') ||
! 10455: (c == '_') || (c == ':') ||
! 10456: (IS_COMBINING(c)) ||
! 10457: (IS_EXTENDER(c)))) {
! 10458: len += l;
! 10459: NEXTL(l);
! 10460: c = CUR_CHAR(l);
! 10461: }
! 10462: ret = xmlStrndup(cur, ctxt->cur - cur);
! 10463: ctxt->cur = cur;
! 10464: return(ret);
! 10465: }
! 10466:
! 10467: /**
! 10468: * xmlXPathCompPathExpr:
! 10469: * @ctxt: the XPath Parser context
! 10470: *
! 10471: * [19] PathExpr ::= LocationPath
! 10472: * | FilterExpr
! 10473: * | FilterExpr '/' RelativeLocationPath
! 10474: * | FilterExpr '//' RelativeLocationPath
! 10475: *
! 10476: * Compile a path expression.
! 10477: * The / operator and // operators combine an arbitrary expression
! 10478: * and a relative location path. It is an error if the expression
! 10479: * does not evaluate to a node-set.
! 10480: * The / operator does composition in the same way as when / is
! 10481: * used in a location path. As in location paths, // is short for
! 10482: * /descendant-or-self::node()/.
! 10483: */
! 10484:
! 10485: static void
! 10486: xmlXPathCompPathExpr(xmlXPathParserContextPtr ctxt) {
! 10487: int lc = 1; /* Should we branch to LocationPath ? */
! 10488: xmlChar *name = NULL; /* we may have to preparse a name to find out */
! 10489:
! 10490: SKIP_BLANKS;
! 10491: if ((CUR == '$') || (CUR == '(') ||
! 10492: (IS_ASCII_DIGIT(CUR)) ||
! 10493: (CUR == '\'') || (CUR == '"') ||
! 10494: (CUR == '.' && IS_ASCII_DIGIT(NXT(1)))) {
! 10495: lc = 0;
! 10496: } else if (CUR == '*') {
! 10497: /* relative or absolute location path */
! 10498: lc = 1;
! 10499: } else if (CUR == '/') {
! 10500: /* relative or absolute location path */
! 10501: lc = 1;
! 10502: } else if (CUR == '@') {
! 10503: /* relative abbreviated attribute location path */
! 10504: lc = 1;
! 10505: } else if (CUR == '.') {
! 10506: /* relative abbreviated attribute location path */
! 10507: lc = 1;
! 10508: } else {
! 10509: /*
! 10510: * Problem is finding if we have a name here whether it's:
! 10511: * - a nodetype
! 10512: * - a function call in which case it's followed by '('
! 10513: * - an axis in which case it's followed by ':'
! 10514: * - a element name
! 10515: * We do an a priori analysis here rather than having to
! 10516: * maintain parsed token content through the recursive function
! 10517: * calls. This looks uglier but makes the code easier to
! 10518: * read/write/debug.
! 10519: */
! 10520: SKIP_BLANKS;
! 10521: name = xmlXPathScanName(ctxt);
! 10522: if ((name != NULL) && (xmlStrstr(name, (xmlChar *) "::") != NULL)) {
! 10523: #ifdef DEBUG_STEP
! 10524: xmlGenericError(xmlGenericErrorContext,
! 10525: "PathExpr: Axis\n");
! 10526: #endif
! 10527: lc = 1;
! 10528: xmlFree(name);
! 10529: } else if (name != NULL) {
! 10530: int len =xmlStrlen(name);
! 10531:
! 10532:
! 10533: while (NXT(len) != 0) {
! 10534: if (NXT(len) == '/') {
! 10535: /* element name */
! 10536: #ifdef DEBUG_STEP
! 10537: xmlGenericError(xmlGenericErrorContext,
! 10538: "PathExpr: AbbrRelLocation\n");
! 10539: #endif
! 10540: lc = 1;
! 10541: break;
! 10542: } else if (IS_BLANK_CH(NXT(len))) {
! 10543: /* ignore blanks */
! 10544: ;
! 10545: } else if (NXT(len) == ':') {
! 10546: #ifdef DEBUG_STEP
! 10547: xmlGenericError(xmlGenericErrorContext,
! 10548: "PathExpr: AbbrRelLocation\n");
! 10549: #endif
! 10550: lc = 1;
! 10551: break;
! 10552: } else if ((NXT(len) == '(')) {
! 10553: /* Note Type or Function */
! 10554: if (xmlXPathIsNodeType(name)) {
! 10555: #ifdef DEBUG_STEP
! 10556: xmlGenericError(xmlGenericErrorContext,
! 10557: "PathExpr: Type search\n");
! 10558: #endif
! 10559: lc = 1;
! 10560: } else {
! 10561: #ifdef DEBUG_STEP
! 10562: xmlGenericError(xmlGenericErrorContext,
! 10563: "PathExpr: function call\n");
! 10564: #endif
! 10565: lc = 0;
! 10566: }
! 10567: break;
! 10568: } else if ((NXT(len) == '[')) {
! 10569: /* element name */
! 10570: #ifdef DEBUG_STEP
! 10571: xmlGenericError(xmlGenericErrorContext,
! 10572: "PathExpr: AbbrRelLocation\n");
! 10573: #endif
! 10574: lc = 1;
! 10575: break;
! 10576: } else if ((NXT(len) == '<') || (NXT(len) == '>') ||
! 10577: (NXT(len) == '=')) {
! 10578: lc = 1;
! 10579: break;
! 10580: } else {
! 10581: lc = 1;
! 10582: break;
! 10583: }
! 10584: len++;
! 10585: }
! 10586: if (NXT(len) == 0) {
! 10587: #ifdef DEBUG_STEP
! 10588: xmlGenericError(xmlGenericErrorContext,
! 10589: "PathExpr: AbbrRelLocation\n");
! 10590: #endif
! 10591: /* element name */
! 10592: lc = 1;
! 10593: }
! 10594: xmlFree(name);
! 10595: } else {
! 10596: /* make sure all cases are covered explicitly */
! 10597: XP_ERROR(XPATH_EXPR_ERROR);
! 10598: }
! 10599: }
! 10600:
! 10601: if (lc) {
! 10602: if (CUR == '/') {
! 10603: PUSH_LEAVE_EXPR(XPATH_OP_ROOT, 0, 0);
! 10604: } else {
! 10605: PUSH_LEAVE_EXPR(XPATH_OP_NODE, 0, 0);
! 10606: }
! 10607: xmlXPathCompLocationPath(ctxt);
! 10608: } else {
! 10609: xmlXPathCompFilterExpr(ctxt);
! 10610: CHECK_ERROR;
! 10611: if ((CUR == '/') && (NXT(1) == '/')) {
! 10612: SKIP(2);
! 10613: SKIP_BLANKS;
! 10614:
! 10615: PUSH_LONG_EXPR(XPATH_OP_COLLECT, AXIS_DESCENDANT_OR_SELF,
! 10616: NODE_TEST_TYPE, NODE_TYPE_NODE, NULL, NULL);
! 10617: PUSH_UNARY_EXPR(XPATH_OP_RESET, ctxt->comp->last, 1, 0);
! 10618:
! 10619: xmlXPathCompRelativeLocationPath(ctxt);
! 10620: } else if (CUR == '/') {
! 10621: xmlXPathCompRelativeLocationPath(ctxt);
! 10622: }
! 10623: }
! 10624: SKIP_BLANKS;
! 10625: }
! 10626:
! 10627: /**
! 10628: * xmlXPathCompUnionExpr:
! 10629: * @ctxt: the XPath Parser context
! 10630: *
! 10631: * [18] UnionExpr ::= PathExpr
! 10632: * | UnionExpr '|' PathExpr
! 10633: *
! 10634: * Compile an union expression.
! 10635: */
! 10636:
! 10637: static void
! 10638: xmlXPathCompUnionExpr(xmlXPathParserContextPtr ctxt) {
! 10639: xmlXPathCompPathExpr(ctxt);
! 10640: CHECK_ERROR;
! 10641: SKIP_BLANKS;
! 10642: while (CUR == '|') {
! 10643: int op1 = ctxt->comp->last;
! 10644: PUSH_LEAVE_EXPR(XPATH_OP_NODE, 0, 0);
! 10645:
! 10646: NEXT;
! 10647: SKIP_BLANKS;
! 10648: xmlXPathCompPathExpr(ctxt);
! 10649:
! 10650: PUSH_BINARY_EXPR(XPATH_OP_UNION, op1, ctxt->comp->last, 0, 0);
! 10651:
! 10652: SKIP_BLANKS;
! 10653: }
! 10654: }
! 10655:
! 10656: /**
! 10657: * xmlXPathCompUnaryExpr:
! 10658: * @ctxt: the XPath Parser context
! 10659: *
! 10660: * [27] UnaryExpr ::= UnionExpr
! 10661: * | '-' UnaryExpr
! 10662: *
! 10663: * Compile an unary expression.
! 10664: */
! 10665:
! 10666: static void
! 10667: xmlXPathCompUnaryExpr(xmlXPathParserContextPtr ctxt) {
! 10668: int minus = 0;
! 10669: int found = 0;
! 10670:
! 10671: SKIP_BLANKS;
! 10672: while (CUR == '-') {
! 10673: minus = 1 - minus;
! 10674: found = 1;
! 10675: NEXT;
! 10676: SKIP_BLANKS;
! 10677: }
! 10678:
! 10679: xmlXPathCompUnionExpr(ctxt);
! 10680: CHECK_ERROR;
! 10681: if (found) {
! 10682: if (minus)
! 10683: PUSH_UNARY_EXPR(XPATH_OP_PLUS, ctxt->comp->last, 2, 0);
! 10684: else
! 10685: PUSH_UNARY_EXPR(XPATH_OP_PLUS, ctxt->comp->last, 3, 0);
! 10686: }
! 10687: }
! 10688:
! 10689: /**
! 10690: * xmlXPathCompMultiplicativeExpr:
! 10691: * @ctxt: the XPath Parser context
! 10692: *
! 10693: * [26] MultiplicativeExpr ::= UnaryExpr
! 10694: * | MultiplicativeExpr MultiplyOperator UnaryExpr
! 10695: * | MultiplicativeExpr 'div' UnaryExpr
! 10696: * | MultiplicativeExpr 'mod' UnaryExpr
! 10697: * [34] MultiplyOperator ::= '*'
! 10698: *
! 10699: * Compile an Additive expression.
! 10700: */
! 10701:
! 10702: static void
! 10703: xmlXPathCompMultiplicativeExpr(xmlXPathParserContextPtr ctxt) {
! 10704: xmlXPathCompUnaryExpr(ctxt);
! 10705: CHECK_ERROR;
! 10706: SKIP_BLANKS;
! 10707: while ((CUR == '*') ||
! 10708: ((CUR == 'd') && (NXT(1) == 'i') && (NXT(2) == 'v')) ||
! 10709: ((CUR == 'm') && (NXT(1) == 'o') && (NXT(2) == 'd'))) {
! 10710: int op = -1;
! 10711: int op1 = ctxt->comp->last;
! 10712:
! 10713: if (CUR == '*') {
! 10714: op = 0;
! 10715: NEXT;
! 10716: } else if (CUR == 'd') {
! 10717: op = 1;
! 10718: SKIP(3);
! 10719: } else if (CUR == 'm') {
! 10720: op = 2;
! 10721: SKIP(3);
! 10722: }
! 10723: SKIP_BLANKS;
! 10724: xmlXPathCompUnaryExpr(ctxt);
! 10725: CHECK_ERROR;
! 10726: PUSH_BINARY_EXPR(XPATH_OP_MULT, op1, ctxt->comp->last, op, 0);
! 10727: SKIP_BLANKS;
! 10728: }
! 10729: }
! 10730:
! 10731: /**
! 10732: * xmlXPathCompAdditiveExpr:
! 10733: * @ctxt: the XPath Parser context
! 10734: *
! 10735: * [25] AdditiveExpr ::= MultiplicativeExpr
! 10736: * | AdditiveExpr '+' MultiplicativeExpr
! 10737: * | AdditiveExpr '-' MultiplicativeExpr
! 10738: *
! 10739: * Compile an Additive expression.
! 10740: */
! 10741:
! 10742: static void
! 10743: xmlXPathCompAdditiveExpr(xmlXPathParserContextPtr ctxt) {
! 10744:
! 10745: xmlXPathCompMultiplicativeExpr(ctxt);
! 10746: CHECK_ERROR;
! 10747: SKIP_BLANKS;
! 10748: while ((CUR == '+') || (CUR == '-')) {
! 10749: int plus;
! 10750: int op1 = ctxt->comp->last;
! 10751:
! 10752: if (CUR == '+') plus = 1;
! 10753: else plus = 0;
! 10754: NEXT;
! 10755: SKIP_BLANKS;
! 10756: xmlXPathCompMultiplicativeExpr(ctxt);
! 10757: CHECK_ERROR;
! 10758: PUSH_BINARY_EXPR(XPATH_OP_PLUS, op1, ctxt->comp->last, plus, 0);
! 10759: SKIP_BLANKS;
! 10760: }
! 10761: }
! 10762:
! 10763: /**
! 10764: * xmlXPathCompRelationalExpr:
! 10765: * @ctxt: the XPath Parser context
! 10766: *
! 10767: * [24] RelationalExpr ::= AdditiveExpr
! 10768: * | RelationalExpr '<' AdditiveExpr
! 10769: * | RelationalExpr '>' AdditiveExpr
! 10770: * | RelationalExpr '<=' AdditiveExpr
! 10771: * | RelationalExpr '>=' AdditiveExpr
! 10772: *
! 10773: * A <= B > C is allowed ? Answer from James, yes with
! 10774: * (AdditiveExpr <= AdditiveExpr) > AdditiveExpr
! 10775: * which is basically what got implemented.
! 10776: *
! 10777: * Compile a Relational expression, then push the result
! 10778: * on the stack
! 10779: */
! 10780:
! 10781: static void
! 10782: xmlXPathCompRelationalExpr(xmlXPathParserContextPtr ctxt) {
! 10783: xmlXPathCompAdditiveExpr(ctxt);
! 10784: CHECK_ERROR;
! 10785: SKIP_BLANKS;
! 10786: while ((CUR == '<') ||
! 10787: (CUR == '>') ||
! 10788: ((CUR == '<') && (NXT(1) == '=')) ||
! 10789: ((CUR == '>') && (NXT(1) == '='))) {
! 10790: int inf, strict;
! 10791: int op1 = ctxt->comp->last;
! 10792:
! 10793: if (CUR == '<') inf = 1;
! 10794: else inf = 0;
! 10795: if (NXT(1) == '=') strict = 0;
! 10796: else strict = 1;
! 10797: NEXT;
! 10798: if (!strict) NEXT;
! 10799: SKIP_BLANKS;
! 10800: xmlXPathCompAdditiveExpr(ctxt);
! 10801: CHECK_ERROR;
! 10802: PUSH_BINARY_EXPR(XPATH_OP_CMP, op1, ctxt->comp->last, inf, strict);
! 10803: SKIP_BLANKS;
! 10804: }
! 10805: }
! 10806:
! 10807: /**
! 10808: * xmlXPathCompEqualityExpr:
! 10809: * @ctxt: the XPath Parser context
! 10810: *
! 10811: * [23] EqualityExpr ::= RelationalExpr
! 10812: * | EqualityExpr '=' RelationalExpr
! 10813: * | EqualityExpr '!=' RelationalExpr
! 10814: *
! 10815: * A != B != C is allowed ? Answer from James, yes with
! 10816: * (RelationalExpr = RelationalExpr) = RelationalExpr
! 10817: * (RelationalExpr != RelationalExpr) != RelationalExpr
! 10818: * which is basically what got implemented.
! 10819: *
! 10820: * Compile an Equality expression.
! 10821: *
! 10822: */
! 10823: static void
! 10824: xmlXPathCompEqualityExpr(xmlXPathParserContextPtr ctxt) {
! 10825: xmlXPathCompRelationalExpr(ctxt);
! 10826: CHECK_ERROR;
! 10827: SKIP_BLANKS;
! 10828: while ((CUR == '=') || ((CUR == '!') && (NXT(1) == '='))) {
! 10829: int eq;
! 10830: int op1 = ctxt->comp->last;
! 10831:
! 10832: if (CUR == '=') eq = 1;
! 10833: else eq = 0;
! 10834: NEXT;
! 10835: if (!eq) NEXT;
! 10836: SKIP_BLANKS;
! 10837: xmlXPathCompRelationalExpr(ctxt);
! 10838: CHECK_ERROR;
! 10839: PUSH_BINARY_EXPR(XPATH_OP_EQUAL, op1, ctxt->comp->last, eq, 0);
! 10840: SKIP_BLANKS;
! 10841: }
! 10842: }
! 10843:
! 10844: /**
! 10845: * xmlXPathCompAndExpr:
! 10846: * @ctxt: the XPath Parser context
! 10847: *
! 10848: * [22] AndExpr ::= EqualityExpr
! 10849: * | AndExpr 'and' EqualityExpr
! 10850: *
! 10851: * Compile an AND expression.
! 10852: *
! 10853: */
! 10854: static void
! 10855: xmlXPathCompAndExpr(xmlXPathParserContextPtr ctxt) {
! 10856: xmlXPathCompEqualityExpr(ctxt);
! 10857: CHECK_ERROR;
! 10858: SKIP_BLANKS;
! 10859: while ((CUR == 'a') && (NXT(1) == 'n') && (NXT(2) == 'd')) {
! 10860: int op1 = ctxt->comp->last;
! 10861: SKIP(3);
! 10862: SKIP_BLANKS;
! 10863: xmlXPathCompEqualityExpr(ctxt);
! 10864: CHECK_ERROR;
! 10865: PUSH_BINARY_EXPR(XPATH_OP_AND, op1, ctxt->comp->last, 0, 0);
! 10866: SKIP_BLANKS;
! 10867: }
! 10868: }
! 10869:
! 10870: /**
! 10871: * xmlXPathCompileExpr:
! 10872: * @ctxt: the XPath Parser context
! 10873: *
! 10874: * [14] Expr ::= OrExpr
! 10875: * [21] OrExpr ::= AndExpr
! 10876: * | OrExpr 'or' AndExpr
! 10877: *
! 10878: * Parse and compile an expression
! 10879: */
! 10880: static void
! 10881: xmlXPathCompileExpr(xmlXPathParserContextPtr ctxt, int sort) {
! 10882: xmlXPathCompAndExpr(ctxt);
! 10883: CHECK_ERROR;
! 10884: SKIP_BLANKS;
! 10885: while ((CUR == 'o') && (NXT(1) == 'r')) {
! 10886: int op1 = ctxt->comp->last;
! 10887: SKIP(2);
! 10888: SKIP_BLANKS;
! 10889: xmlXPathCompAndExpr(ctxt);
! 10890: CHECK_ERROR;
! 10891: PUSH_BINARY_EXPR(XPATH_OP_OR, op1, ctxt->comp->last, 0, 0);
! 10892: SKIP_BLANKS;
! 10893: }
! 10894: if ((sort) && (ctxt->comp->steps[ctxt->comp->last].op != XPATH_OP_VALUE)) {
! 10895: /* more ops could be optimized too */
! 10896: /*
! 10897: * This is the main place to eliminate sorting for
! 10898: * operations which don't require a sorted node-set.
! 10899: * E.g. count().
! 10900: */
! 10901: PUSH_UNARY_EXPR(XPATH_OP_SORT, ctxt->comp->last , 0, 0);
! 10902: }
! 10903: }
! 10904:
! 10905: /**
! 10906: * xmlXPathCompPredicate:
! 10907: * @ctxt: the XPath Parser context
! 10908: * @filter: act as a filter
! 10909: *
! 10910: * [8] Predicate ::= '[' PredicateExpr ']'
! 10911: * [9] PredicateExpr ::= Expr
! 10912: *
! 10913: * Compile a predicate expression
! 10914: */
! 10915: static void
! 10916: xmlXPathCompPredicate(xmlXPathParserContextPtr ctxt, int filter) {
! 10917: int op1 = ctxt->comp->last;
! 10918:
! 10919: SKIP_BLANKS;
! 10920: if (CUR != '[') {
! 10921: XP_ERROR(XPATH_INVALID_PREDICATE_ERROR);
! 10922: }
! 10923: NEXT;
! 10924: SKIP_BLANKS;
! 10925:
! 10926: ctxt->comp->last = -1;
! 10927: /*
! 10928: * This call to xmlXPathCompileExpr() will deactivate sorting
! 10929: * of the predicate result.
! 10930: * TODO: Sorting is still activated for filters, since I'm not
! 10931: * sure if needed. Normally sorting should not be needed, since
! 10932: * a filter can only diminish the number of items in a sequence,
! 10933: * but won't change its order; so if the initial sequence is sorted,
! 10934: * subsequent sorting is not needed.
! 10935: */
! 10936: if (! filter)
! 10937: xmlXPathCompileExpr(ctxt, 0);
! 10938: else
! 10939: xmlXPathCompileExpr(ctxt, 1);
! 10940: CHECK_ERROR;
! 10941:
! 10942: if (CUR != ']') {
! 10943: XP_ERROR(XPATH_INVALID_PREDICATE_ERROR);
! 10944: }
! 10945:
! 10946: if (filter)
! 10947: PUSH_BINARY_EXPR(XPATH_OP_FILTER, op1, ctxt->comp->last, 0, 0);
! 10948: else
! 10949: PUSH_BINARY_EXPR(XPATH_OP_PREDICATE, op1, ctxt->comp->last, 0, 0);
! 10950:
! 10951: NEXT;
! 10952: SKIP_BLANKS;
! 10953: }
! 10954:
! 10955: /**
! 10956: * xmlXPathCompNodeTest:
! 10957: * @ctxt: the XPath Parser context
! 10958: * @test: pointer to a xmlXPathTestVal
! 10959: * @type: pointer to a xmlXPathTypeVal
! 10960: * @prefix: placeholder for a possible name prefix
! 10961: *
! 10962: * [7] NodeTest ::= NameTest
! 10963: * | NodeType '(' ')'
! 10964: * | 'processing-instruction' '(' Literal ')'
! 10965: *
! 10966: * [37] NameTest ::= '*'
! 10967: * | NCName ':' '*'
! 10968: * | QName
! 10969: * [38] NodeType ::= 'comment'
! 10970: * | 'text'
! 10971: * | 'processing-instruction'
! 10972: * | 'node'
! 10973: *
! 10974: * Returns the name found and updates @test, @type and @prefix appropriately
! 10975: */
! 10976: static xmlChar *
! 10977: xmlXPathCompNodeTest(xmlXPathParserContextPtr ctxt, xmlXPathTestVal *test,
! 10978: xmlXPathTypeVal *type, const xmlChar **prefix,
! 10979: xmlChar *name) {
! 10980: int blanks;
! 10981:
! 10982: if ((test == NULL) || (type == NULL) || (prefix == NULL)) {
! 10983: STRANGE;
! 10984: return(NULL);
! 10985: }
! 10986: *type = (xmlXPathTypeVal) 0;
! 10987: *test = (xmlXPathTestVal) 0;
! 10988: *prefix = NULL;
! 10989: SKIP_BLANKS;
! 10990:
! 10991: if ((name == NULL) && (CUR == '*')) {
! 10992: /*
! 10993: * All elements
! 10994: */
! 10995: NEXT;
! 10996: *test = NODE_TEST_ALL;
! 10997: return(NULL);
! 10998: }
! 10999:
! 11000: if (name == NULL)
! 11001: name = xmlXPathParseNCName(ctxt);
! 11002: if (name == NULL) {
! 11003: XP_ERRORNULL(XPATH_EXPR_ERROR);
! 11004: }
! 11005:
! 11006: blanks = IS_BLANK_CH(CUR);
! 11007: SKIP_BLANKS;
! 11008: if (CUR == '(') {
! 11009: NEXT;
! 11010: /*
! 11011: * NodeType or PI search
! 11012: */
! 11013: if (xmlStrEqual(name, BAD_CAST "comment"))
! 11014: *type = NODE_TYPE_COMMENT;
! 11015: else if (xmlStrEqual(name, BAD_CAST "node"))
! 11016: *type = NODE_TYPE_NODE;
! 11017: else if (xmlStrEqual(name, BAD_CAST "processing-instruction"))
! 11018: *type = NODE_TYPE_PI;
! 11019: else if (xmlStrEqual(name, BAD_CAST "text"))
! 11020: *type = NODE_TYPE_TEXT;
! 11021: else {
! 11022: if (name != NULL)
! 11023: xmlFree(name);
! 11024: XP_ERRORNULL(XPATH_EXPR_ERROR);
! 11025: }
! 11026:
! 11027: *test = NODE_TEST_TYPE;
! 11028:
! 11029: SKIP_BLANKS;
! 11030: if (*type == NODE_TYPE_PI) {
! 11031: /*
! 11032: * Specific case: search a PI by name.
! 11033: */
! 11034: if (name != NULL)
! 11035: xmlFree(name);
! 11036: name = NULL;
! 11037: if (CUR != ')') {
! 11038: name = xmlXPathParseLiteral(ctxt);
! 11039: CHECK_ERROR NULL;
! 11040: *test = NODE_TEST_PI;
! 11041: SKIP_BLANKS;
! 11042: }
! 11043: }
! 11044: if (CUR != ')') {
! 11045: if (name != NULL)
! 11046: xmlFree(name);
! 11047: XP_ERRORNULL(XPATH_UNCLOSED_ERROR);
! 11048: }
! 11049: NEXT;
! 11050: return(name);
! 11051: }
! 11052: *test = NODE_TEST_NAME;
! 11053: if ((!blanks) && (CUR == ':')) {
! 11054: NEXT;
! 11055:
! 11056: /*
! 11057: * Since currently the parser context don't have a
! 11058: * namespace list associated:
! 11059: * The namespace name for this prefix can be computed
! 11060: * only at evaluation time. The compilation is done
! 11061: * outside of any context.
! 11062: */
! 11063: #if 0
! 11064: *prefix = xmlXPathNsLookup(ctxt->context, name);
! 11065: if (name != NULL)
! 11066: xmlFree(name);
! 11067: if (*prefix == NULL) {
! 11068: XP_ERROR0(XPATH_UNDEF_PREFIX_ERROR);
! 11069: }
! 11070: #else
! 11071: *prefix = name;
! 11072: #endif
! 11073:
! 11074: if (CUR == '*') {
! 11075: /*
! 11076: * All elements
! 11077: */
! 11078: NEXT;
! 11079: *test = NODE_TEST_ALL;
! 11080: return(NULL);
! 11081: }
! 11082:
! 11083: name = xmlXPathParseNCName(ctxt);
! 11084: if (name == NULL) {
! 11085: XP_ERRORNULL(XPATH_EXPR_ERROR);
! 11086: }
! 11087: }
! 11088: return(name);
! 11089: }
! 11090:
! 11091: /**
! 11092: * xmlXPathIsAxisName:
! 11093: * @name: a preparsed name token
! 11094: *
! 11095: * [6] AxisName ::= 'ancestor'
! 11096: * | 'ancestor-or-self'
! 11097: * | 'attribute'
! 11098: * | 'child'
! 11099: * | 'descendant'
! 11100: * | 'descendant-or-self'
! 11101: * | 'following'
! 11102: * | 'following-sibling'
! 11103: * | 'namespace'
! 11104: * | 'parent'
! 11105: * | 'preceding'
! 11106: * | 'preceding-sibling'
! 11107: * | 'self'
! 11108: *
! 11109: * Returns the axis or 0
! 11110: */
! 11111: static xmlXPathAxisVal
! 11112: xmlXPathIsAxisName(const xmlChar *name) {
! 11113: xmlXPathAxisVal ret = (xmlXPathAxisVal) 0;
! 11114: switch (name[0]) {
! 11115: case 'a':
! 11116: if (xmlStrEqual(name, BAD_CAST "ancestor"))
! 11117: ret = AXIS_ANCESTOR;
! 11118: if (xmlStrEqual(name, BAD_CAST "ancestor-or-self"))
! 11119: ret = AXIS_ANCESTOR_OR_SELF;
! 11120: if (xmlStrEqual(name, BAD_CAST "attribute"))
! 11121: ret = AXIS_ATTRIBUTE;
! 11122: break;
! 11123: case 'c':
! 11124: if (xmlStrEqual(name, BAD_CAST "child"))
! 11125: ret = AXIS_CHILD;
! 11126: break;
! 11127: case 'd':
! 11128: if (xmlStrEqual(name, BAD_CAST "descendant"))
! 11129: ret = AXIS_DESCENDANT;
! 11130: if (xmlStrEqual(name, BAD_CAST "descendant-or-self"))
! 11131: ret = AXIS_DESCENDANT_OR_SELF;
! 11132: break;
! 11133: case 'f':
! 11134: if (xmlStrEqual(name, BAD_CAST "following"))
! 11135: ret = AXIS_FOLLOWING;
! 11136: if (xmlStrEqual(name, BAD_CAST "following-sibling"))
! 11137: ret = AXIS_FOLLOWING_SIBLING;
! 11138: break;
! 11139: case 'n':
! 11140: if (xmlStrEqual(name, BAD_CAST "namespace"))
! 11141: ret = AXIS_NAMESPACE;
! 11142: break;
! 11143: case 'p':
! 11144: if (xmlStrEqual(name, BAD_CAST "parent"))
! 11145: ret = AXIS_PARENT;
! 11146: if (xmlStrEqual(name, BAD_CAST "preceding"))
! 11147: ret = AXIS_PRECEDING;
! 11148: if (xmlStrEqual(name, BAD_CAST "preceding-sibling"))
! 11149: ret = AXIS_PRECEDING_SIBLING;
! 11150: break;
! 11151: case 's':
! 11152: if (xmlStrEqual(name, BAD_CAST "self"))
! 11153: ret = AXIS_SELF;
! 11154: break;
! 11155: }
! 11156: return(ret);
! 11157: }
! 11158:
! 11159: /**
! 11160: * xmlXPathCompStep:
! 11161: * @ctxt: the XPath Parser context
! 11162: *
! 11163: * [4] Step ::= AxisSpecifier NodeTest Predicate*
! 11164: * | AbbreviatedStep
! 11165: *
! 11166: * [12] AbbreviatedStep ::= '.' | '..'
! 11167: *
! 11168: * [5] AxisSpecifier ::= AxisName '::'
! 11169: * | AbbreviatedAxisSpecifier
! 11170: *
! 11171: * [13] AbbreviatedAxisSpecifier ::= '@'?
! 11172: *
! 11173: * Modified for XPtr range support as:
! 11174: *
! 11175: * [4xptr] Step ::= AxisSpecifier NodeTest Predicate*
! 11176: * | AbbreviatedStep
! 11177: * | 'range-to' '(' Expr ')' Predicate*
! 11178: *
! 11179: * Compile one step in a Location Path
! 11180: * A location step of . is short for self::node(). This is
! 11181: * particularly useful in conjunction with //. For example, the
! 11182: * location path .//para is short for
! 11183: * self::node()/descendant-or-self::node()/child::para
! 11184: * and so will select all para descendant elements of the context
! 11185: * node.
! 11186: * Similarly, a location step of .. is short for parent::node().
! 11187: * For example, ../title is short for parent::node()/child::title
! 11188: * and so will select the title children of the parent of the context
! 11189: * node.
! 11190: */
! 11191: static void
! 11192: xmlXPathCompStep(xmlXPathParserContextPtr ctxt) {
! 11193: #ifdef LIBXML_XPTR_ENABLED
! 11194: int rangeto = 0;
! 11195: int op2 = -1;
! 11196: #endif
! 11197:
! 11198: SKIP_BLANKS;
! 11199: if ((CUR == '.') && (NXT(1) == '.')) {
! 11200: SKIP(2);
! 11201: SKIP_BLANKS;
! 11202: PUSH_LONG_EXPR(XPATH_OP_COLLECT, AXIS_PARENT,
! 11203: NODE_TEST_TYPE, NODE_TYPE_NODE, NULL, NULL);
! 11204: } else if (CUR == '.') {
! 11205: NEXT;
! 11206: SKIP_BLANKS;
! 11207: } else {
! 11208: xmlChar *name = NULL;
! 11209: const xmlChar *prefix = NULL;
! 11210: xmlXPathTestVal test = (xmlXPathTestVal) 0;
! 11211: xmlXPathAxisVal axis = (xmlXPathAxisVal) 0;
! 11212: xmlXPathTypeVal type = (xmlXPathTypeVal) 0;
! 11213: int op1;
! 11214:
! 11215: /*
! 11216: * The modification needed for XPointer change to the production
! 11217: */
! 11218: #ifdef LIBXML_XPTR_ENABLED
! 11219: if (ctxt->xptr) {
! 11220: name = xmlXPathParseNCName(ctxt);
! 11221: if ((name != NULL) && (xmlStrEqual(name, BAD_CAST "range-to"))) {
! 11222: op2 = ctxt->comp->last;
! 11223: xmlFree(name);
! 11224: SKIP_BLANKS;
! 11225: if (CUR != '(') {
! 11226: XP_ERROR(XPATH_EXPR_ERROR);
! 11227: }
! 11228: NEXT;
! 11229: SKIP_BLANKS;
! 11230:
! 11231: xmlXPathCompileExpr(ctxt, 1);
! 11232: /* PUSH_BINARY_EXPR(XPATH_OP_RANGETO, op2, ctxt->comp->last, 0, 0); */
! 11233: CHECK_ERROR;
! 11234:
! 11235: SKIP_BLANKS;
! 11236: if (CUR != ')') {
! 11237: XP_ERROR(XPATH_EXPR_ERROR);
! 11238: }
! 11239: NEXT;
! 11240: rangeto = 1;
! 11241: goto eval_predicates;
! 11242: }
! 11243: }
! 11244: #endif
! 11245: if (CUR == '*') {
! 11246: axis = AXIS_CHILD;
! 11247: } else {
! 11248: if (name == NULL)
! 11249: name = xmlXPathParseNCName(ctxt);
! 11250: if (name != NULL) {
! 11251: axis = xmlXPathIsAxisName(name);
! 11252: if (axis != 0) {
! 11253: SKIP_BLANKS;
! 11254: if ((CUR == ':') && (NXT(1) == ':')) {
! 11255: SKIP(2);
! 11256: xmlFree(name);
! 11257: name = NULL;
! 11258: } else {
! 11259: /* an element name can conflict with an axis one :-\ */
! 11260: axis = AXIS_CHILD;
! 11261: }
! 11262: } else {
! 11263: axis = AXIS_CHILD;
! 11264: }
! 11265: } else if (CUR == '@') {
! 11266: NEXT;
! 11267: axis = AXIS_ATTRIBUTE;
! 11268: } else {
! 11269: axis = AXIS_CHILD;
! 11270: }
! 11271: }
! 11272:
! 11273: if (ctxt->error != XPATH_EXPRESSION_OK) {
! 11274: xmlFree(name);
! 11275: return;
! 11276: }
! 11277:
! 11278: name = xmlXPathCompNodeTest(ctxt, &test, &type, &prefix, name);
! 11279: if (test == 0)
! 11280: return;
! 11281:
! 11282: if ((prefix != NULL) && (ctxt->context != NULL) &&
! 11283: (ctxt->context->flags & XML_XPATH_CHECKNS)) {
! 11284: if (xmlXPathNsLookup(ctxt->context, prefix) == NULL) {
! 11285: xmlXPathErr(ctxt, XPATH_UNDEF_PREFIX_ERROR);
! 11286: }
! 11287: }
! 11288: #ifdef DEBUG_STEP
! 11289: xmlGenericError(xmlGenericErrorContext,
! 11290: "Basis : computing new set\n");
! 11291: #endif
! 11292:
! 11293: #ifdef DEBUG_STEP
! 11294: xmlGenericError(xmlGenericErrorContext, "Basis : ");
! 11295: if (ctxt->value == NULL)
! 11296: xmlGenericError(xmlGenericErrorContext, "no value\n");
! 11297: else if (ctxt->value->nodesetval == NULL)
! 11298: xmlGenericError(xmlGenericErrorContext, "Empty\n");
! 11299: else
! 11300: xmlGenericErrorContextNodeSet(stdout, ctxt->value->nodesetval);
! 11301: #endif
! 11302:
! 11303: #ifdef LIBXML_XPTR_ENABLED
! 11304: eval_predicates:
! 11305: #endif
! 11306: op1 = ctxt->comp->last;
! 11307: ctxt->comp->last = -1;
! 11308:
! 11309: SKIP_BLANKS;
! 11310: while (CUR == '[') {
! 11311: xmlXPathCompPredicate(ctxt, 0);
! 11312: }
! 11313:
! 11314: #ifdef LIBXML_XPTR_ENABLED
! 11315: if (rangeto) {
! 11316: PUSH_BINARY_EXPR(XPATH_OP_RANGETO, op2, op1, 0, 0);
! 11317: } else
! 11318: #endif
! 11319: PUSH_FULL_EXPR(XPATH_OP_COLLECT, op1, ctxt->comp->last, axis,
! 11320: test, type, (void *)prefix, (void *)name);
! 11321:
! 11322: }
! 11323: #ifdef DEBUG_STEP
! 11324: xmlGenericError(xmlGenericErrorContext, "Step : ");
! 11325: if (ctxt->value == NULL)
! 11326: xmlGenericError(xmlGenericErrorContext, "no value\n");
! 11327: else if (ctxt->value->nodesetval == NULL)
! 11328: xmlGenericError(xmlGenericErrorContext, "Empty\n");
! 11329: else
! 11330: xmlGenericErrorContextNodeSet(xmlGenericErrorContext,
! 11331: ctxt->value->nodesetval);
! 11332: #endif
! 11333: }
! 11334:
! 11335: /**
! 11336: * xmlXPathCompRelativeLocationPath:
! 11337: * @ctxt: the XPath Parser context
! 11338: *
! 11339: * [3] RelativeLocationPath ::= Step
! 11340: * | RelativeLocationPath '/' Step
! 11341: * | AbbreviatedRelativeLocationPath
! 11342: * [11] AbbreviatedRelativeLocationPath ::= RelativeLocationPath '//' Step
! 11343: *
! 11344: * Compile a relative location path.
! 11345: */
! 11346: static void
! 11347: xmlXPathCompRelativeLocationPath
! 11348: (xmlXPathParserContextPtr ctxt) {
! 11349: SKIP_BLANKS;
! 11350: if ((CUR == '/') && (NXT(1) == '/')) {
! 11351: SKIP(2);
! 11352: SKIP_BLANKS;
! 11353: PUSH_LONG_EXPR(XPATH_OP_COLLECT, AXIS_DESCENDANT_OR_SELF,
! 11354: NODE_TEST_TYPE, NODE_TYPE_NODE, NULL, NULL);
! 11355: } else if (CUR == '/') {
! 11356: NEXT;
! 11357: SKIP_BLANKS;
! 11358: }
! 11359: xmlXPathCompStep(ctxt);
! 11360: CHECK_ERROR;
! 11361: SKIP_BLANKS;
! 11362: while (CUR == '/') {
! 11363: if ((CUR == '/') && (NXT(1) == '/')) {
! 11364: SKIP(2);
! 11365: SKIP_BLANKS;
! 11366: PUSH_LONG_EXPR(XPATH_OP_COLLECT, AXIS_DESCENDANT_OR_SELF,
! 11367: NODE_TEST_TYPE, NODE_TYPE_NODE, NULL, NULL);
! 11368: xmlXPathCompStep(ctxt);
! 11369: } else if (CUR == '/') {
! 11370: NEXT;
! 11371: SKIP_BLANKS;
! 11372: xmlXPathCompStep(ctxt);
! 11373: }
! 11374: SKIP_BLANKS;
! 11375: }
! 11376: }
! 11377:
! 11378: /**
! 11379: * xmlXPathCompLocationPath:
! 11380: * @ctxt: the XPath Parser context
! 11381: *
! 11382: * [1] LocationPath ::= RelativeLocationPath
! 11383: * | AbsoluteLocationPath
! 11384: * [2] AbsoluteLocationPath ::= '/' RelativeLocationPath?
! 11385: * | AbbreviatedAbsoluteLocationPath
! 11386: * [10] AbbreviatedAbsoluteLocationPath ::=
! 11387: * '//' RelativeLocationPath
! 11388: *
! 11389: * Compile a location path
! 11390: *
! 11391: * // is short for /descendant-or-self::node()/. For example,
! 11392: * //para is short for /descendant-or-self::node()/child::para and
! 11393: * so will select any para element in the document (even a para element
! 11394: * that is a document element will be selected by //para since the
! 11395: * document element node is a child of the root node); div//para is
! 11396: * short for div/descendant-or-self::node()/child::para and so will
! 11397: * select all para descendants of div children.
! 11398: */
! 11399: static void
! 11400: xmlXPathCompLocationPath(xmlXPathParserContextPtr ctxt) {
! 11401: SKIP_BLANKS;
! 11402: if (CUR != '/') {
! 11403: xmlXPathCompRelativeLocationPath(ctxt);
! 11404: } else {
! 11405: while (CUR == '/') {
! 11406: if ((CUR == '/') && (NXT(1) == '/')) {
! 11407: SKIP(2);
! 11408: SKIP_BLANKS;
! 11409: PUSH_LONG_EXPR(XPATH_OP_COLLECT, AXIS_DESCENDANT_OR_SELF,
! 11410: NODE_TEST_TYPE, NODE_TYPE_NODE, NULL, NULL);
! 11411: xmlXPathCompRelativeLocationPath(ctxt);
! 11412: } else if (CUR == '/') {
! 11413: NEXT;
! 11414: SKIP_BLANKS;
! 11415: if ((CUR != 0 ) &&
! 11416: ((IS_ASCII_LETTER(CUR)) || (CUR == '_') || (CUR == '.') ||
! 11417: (CUR == '@') || (CUR == '*')))
! 11418: xmlXPathCompRelativeLocationPath(ctxt);
! 11419: }
! 11420: CHECK_ERROR;
! 11421: }
! 11422: }
! 11423: }
! 11424:
! 11425: /************************************************************************
! 11426: * *
! 11427: * XPath precompiled expression evaluation *
! 11428: * *
! 11429: ************************************************************************/
! 11430:
! 11431: static int
! 11432: xmlXPathCompOpEval(xmlXPathParserContextPtr ctxt, xmlXPathStepOpPtr op);
! 11433:
! 11434: #ifdef DEBUG_STEP
! 11435: static void
! 11436: xmlXPathDebugDumpStepAxis(xmlXPathStepOpPtr op,
! 11437: int nbNodes)
! 11438: {
! 11439: xmlGenericError(xmlGenericErrorContext, "new step : ");
! 11440: switch (op->value) {
! 11441: case AXIS_ANCESTOR:
! 11442: xmlGenericError(xmlGenericErrorContext, "axis 'ancestors' ");
! 11443: break;
! 11444: case AXIS_ANCESTOR_OR_SELF:
! 11445: xmlGenericError(xmlGenericErrorContext,
! 11446: "axis 'ancestors-or-self' ");
! 11447: break;
! 11448: case AXIS_ATTRIBUTE:
! 11449: xmlGenericError(xmlGenericErrorContext, "axis 'attributes' ");
! 11450: break;
! 11451: case AXIS_CHILD:
! 11452: xmlGenericError(xmlGenericErrorContext, "axis 'child' ");
! 11453: break;
! 11454: case AXIS_DESCENDANT:
! 11455: xmlGenericError(xmlGenericErrorContext, "axis 'descendant' ");
! 11456: break;
! 11457: case AXIS_DESCENDANT_OR_SELF:
! 11458: xmlGenericError(xmlGenericErrorContext,
! 11459: "axis 'descendant-or-self' ");
! 11460: break;
! 11461: case AXIS_FOLLOWING:
! 11462: xmlGenericError(xmlGenericErrorContext, "axis 'following' ");
! 11463: break;
! 11464: case AXIS_FOLLOWING_SIBLING:
! 11465: xmlGenericError(xmlGenericErrorContext,
! 11466: "axis 'following-siblings' ");
! 11467: break;
! 11468: case AXIS_NAMESPACE:
! 11469: xmlGenericError(xmlGenericErrorContext, "axis 'namespace' ");
! 11470: break;
! 11471: case AXIS_PARENT:
! 11472: xmlGenericError(xmlGenericErrorContext, "axis 'parent' ");
! 11473: break;
! 11474: case AXIS_PRECEDING:
! 11475: xmlGenericError(xmlGenericErrorContext, "axis 'preceding' ");
! 11476: break;
! 11477: case AXIS_PRECEDING_SIBLING:
! 11478: xmlGenericError(xmlGenericErrorContext,
! 11479: "axis 'preceding-sibling' ");
! 11480: break;
! 11481: case AXIS_SELF:
! 11482: xmlGenericError(xmlGenericErrorContext, "axis 'self' ");
! 11483: break;
! 11484: }
! 11485: xmlGenericError(xmlGenericErrorContext,
! 11486: " context contains %d nodes\n", nbNodes);
! 11487: switch (op->value2) {
! 11488: case NODE_TEST_NONE:
! 11489: xmlGenericError(xmlGenericErrorContext,
! 11490: " searching for none !!!\n");
! 11491: break;
! 11492: case NODE_TEST_TYPE:
! 11493: xmlGenericError(xmlGenericErrorContext,
! 11494: " searching for type %d\n", op->value3);
! 11495: break;
! 11496: case NODE_TEST_PI:
! 11497: xmlGenericError(xmlGenericErrorContext,
! 11498: " searching for PI !!!\n");
! 11499: break;
! 11500: case NODE_TEST_ALL:
! 11501: xmlGenericError(xmlGenericErrorContext,
! 11502: " searching for *\n");
! 11503: break;
! 11504: case NODE_TEST_NS:
! 11505: xmlGenericError(xmlGenericErrorContext,
! 11506: " searching for namespace %s\n",
! 11507: op->value5);
! 11508: break;
! 11509: case NODE_TEST_NAME:
! 11510: xmlGenericError(xmlGenericErrorContext,
! 11511: " searching for name %s\n", op->value5);
! 11512: if (op->value4)
! 11513: xmlGenericError(xmlGenericErrorContext,
! 11514: " with namespace %s\n", op->value4);
! 11515: break;
! 11516: }
! 11517: xmlGenericError(xmlGenericErrorContext, "Testing : ");
! 11518: }
! 11519: #endif /* DEBUG_STEP */
! 11520:
! 11521: static int
! 11522: xmlXPathCompOpEvalPredicate(xmlXPathParserContextPtr ctxt,
! 11523: xmlXPathStepOpPtr op,
! 11524: xmlNodeSetPtr set,
! 11525: int contextSize,
! 11526: int hasNsNodes)
! 11527: {
! 11528: if (op->ch1 != -1) {
! 11529: xmlXPathCompExprPtr comp = ctxt->comp;
! 11530: /*
! 11531: * Process inner predicates first.
! 11532: */
! 11533: if (comp->steps[op->ch1].op != XPATH_OP_PREDICATE) {
! 11534: /*
! 11535: * TODO: raise an internal error.
! 11536: */
! 11537: }
! 11538: contextSize = xmlXPathCompOpEvalPredicate(ctxt,
! 11539: &comp->steps[op->ch1], set, contextSize, hasNsNodes);
! 11540: CHECK_ERROR0;
! 11541: if (contextSize <= 0)
! 11542: return(0);
! 11543: }
! 11544: if (op->ch2 != -1) {
! 11545: xmlXPathContextPtr xpctxt = ctxt->context;
! 11546: xmlNodePtr contextNode, oldContextNode;
! 11547: xmlDocPtr oldContextDoc;
! 11548: int i, res, contextPos = 0, newContextSize;
! 11549: xmlXPathStepOpPtr exprOp;
! 11550: xmlXPathObjectPtr contextObj = NULL, exprRes = NULL;
! 11551:
! 11552: #ifdef LIBXML_XPTR_ENABLED
! 11553: /*
! 11554: * URGENT TODO: Check the following:
! 11555: * We don't expect location sets if evaluating prediates, right?
! 11556: * Only filters should expect location sets, right?
! 11557: */
! 11558: #endif
! 11559: /*
! 11560: * SPEC XPath 1.0:
! 11561: * "For each node in the node-set to be filtered, the
! 11562: * PredicateExpr is evaluated with that node as the
! 11563: * context node, with the number of nodes in the
! 11564: * node-set as the context size, and with the proximity
! 11565: * position of the node in the node-set with respect to
! 11566: * the axis as the context position;"
! 11567: * @oldset is the node-set" to be filtered.
! 11568: *
! 11569: * SPEC XPath 1.0:
! 11570: * "only predicates change the context position and
! 11571: * context size (see [2.4 Predicates])."
! 11572: * Example:
! 11573: * node-set context pos
! 11574: * nA 1
! 11575: * nB 2
! 11576: * nC 3
! 11577: * After applying predicate [position() > 1] :
! 11578: * node-set context pos
! 11579: * nB 1
! 11580: * nC 2
! 11581: */
! 11582: oldContextNode = xpctxt->node;
! 11583: oldContextDoc = xpctxt->doc;
! 11584: /*
! 11585: * Get the expression of this predicate.
! 11586: */
! 11587: exprOp = &ctxt->comp->steps[op->ch2];
! 11588: newContextSize = 0;
! 11589: for (i = 0; i < set->nodeNr; i++) {
! 11590: if (set->nodeTab[i] == NULL)
! 11591: continue;
! 11592:
! 11593: contextNode = set->nodeTab[i];
! 11594: xpctxt->node = contextNode;
! 11595: xpctxt->contextSize = contextSize;
! 11596: xpctxt->proximityPosition = ++contextPos;
! 11597:
! 11598: /*
! 11599: * Also set the xpath document in case things like
! 11600: * key() are evaluated in the predicate.
! 11601: */
! 11602: if ((contextNode->type != XML_NAMESPACE_DECL) &&
! 11603: (contextNode->doc != NULL))
! 11604: xpctxt->doc = contextNode->doc;
! 11605: /*
! 11606: * Evaluate the predicate expression with 1 context node
! 11607: * at a time; this node is packaged into a node set; this
! 11608: * node set is handed over to the evaluation mechanism.
! 11609: */
! 11610: if (contextObj == NULL)
! 11611: contextObj = xmlXPathCacheNewNodeSet(xpctxt, contextNode);
! 11612: else
! 11613: xmlXPathNodeSetAddUnique(contextObj->nodesetval,
! 11614: contextNode);
! 11615:
! 11616: valuePush(ctxt, contextObj);
! 11617:
! 11618: res = xmlXPathCompOpEvalToBoolean(ctxt, exprOp, 1);
! 11619:
! 11620: if ((ctxt->error != XPATH_EXPRESSION_OK) || (res == -1)) {
! 11621: xmlXPathNodeSetClear(set, hasNsNodes);
! 11622: newContextSize = 0;
! 11623: goto evaluation_exit;
! 11624: }
! 11625:
! 11626: if (res != 0) {
! 11627: newContextSize++;
! 11628: } else {
! 11629: /*
! 11630: * Remove the entry from the initial node set.
! 11631: */
! 11632: set->nodeTab[i] = NULL;
! 11633: if (contextNode->type == XML_NAMESPACE_DECL)
! 11634: xmlXPathNodeSetFreeNs((xmlNsPtr) contextNode);
! 11635: }
! 11636: if (ctxt->value == contextObj) {
! 11637: /*
! 11638: * Don't free the temporary XPath object holding the
! 11639: * context node, in order to avoid massive recreation
! 11640: * inside this loop.
! 11641: */
! 11642: valuePop(ctxt);
! 11643: xmlXPathNodeSetClear(contextObj->nodesetval, hasNsNodes);
! 11644: } else {
! 11645: /*
! 11646: * TODO: The object was lost in the evaluation machinery.
! 11647: * Can this happen? Maybe in internal-error cases.
! 11648: */
! 11649: contextObj = NULL;
! 11650: }
! 11651: }
! 11652:
! 11653: if (contextObj != NULL) {
! 11654: if (ctxt->value == contextObj)
! 11655: valuePop(ctxt);
! 11656: xmlXPathReleaseObject(xpctxt, contextObj);
! 11657: }
! 11658: evaluation_exit:
! 11659: if (exprRes != NULL)
! 11660: xmlXPathReleaseObject(ctxt->context, exprRes);
! 11661: /*
! 11662: * Reset/invalidate the context.
! 11663: */
! 11664: xpctxt->node = oldContextNode;
! 11665: xpctxt->doc = oldContextDoc;
! 11666: xpctxt->contextSize = -1;
! 11667: xpctxt->proximityPosition = -1;
! 11668: return(newContextSize);
! 11669: }
! 11670: return(contextSize);
! 11671: }
! 11672:
! 11673: static int
! 11674: xmlXPathCompOpEvalPositionalPredicate(xmlXPathParserContextPtr ctxt,
! 11675: xmlXPathStepOpPtr op,
! 11676: xmlNodeSetPtr set,
! 11677: int contextSize,
! 11678: int minPos,
! 11679: int maxPos,
! 11680: int hasNsNodes)
! 11681: {
! 11682: if (op->ch1 != -1) {
! 11683: xmlXPathCompExprPtr comp = ctxt->comp;
! 11684: if (comp->steps[op->ch1].op != XPATH_OP_PREDICATE) {
! 11685: /*
! 11686: * TODO: raise an internal error.
! 11687: */
! 11688: }
! 11689: contextSize = xmlXPathCompOpEvalPredicate(ctxt,
! 11690: &comp->steps[op->ch1], set, contextSize, hasNsNodes);
! 11691: CHECK_ERROR0;
! 11692: if (contextSize <= 0)
! 11693: return(0);
! 11694: }
! 11695: /*
! 11696: * Check if the node set contains a sufficient number of nodes for
! 11697: * the requested range.
! 11698: */
! 11699: if (contextSize < minPos) {
! 11700: xmlXPathNodeSetClear(set, hasNsNodes);
! 11701: return(0);
! 11702: }
! 11703: if (op->ch2 == -1) {
! 11704: /*
! 11705: * TODO: Can this ever happen?
! 11706: */
! 11707: return (contextSize);
! 11708: } else {
! 11709: xmlDocPtr oldContextDoc;
! 11710: int i, pos = 0, newContextSize = 0, contextPos = 0, res;
! 11711: xmlXPathStepOpPtr exprOp;
! 11712: xmlXPathObjectPtr contextObj = NULL, exprRes = NULL;
! 11713: xmlNodePtr oldContextNode, contextNode = NULL;
! 11714: xmlXPathContextPtr xpctxt = ctxt->context;
! 11715:
! 11716: #ifdef LIBXML_XPTR_ENABLED
! 11717: /*
! 11718: * URGENT TODO: Check the following:
! 11719: * We don't expect location sets if evaluating prediates, right?
! 11720: * Only filters should expect location sets, right?
! 11721: */
! 11722: #endif /* LIBXML_XPTR_ENABLED */
! 11723:
! 11724: /*
! 11725: * Save old context.
! 11726: */
! 11727: oldContextNode = xpctxt->node;
! 11728: oldContextDoc = xpctxt->doc;
! 11729: /*
! 11730: * Get the expression of this predicate.
! 11731: */
! 11732: exprOp = &ctxt->comp->steps[op->ch2];
! 11733: for (i = 0; i < set->nodeNr; i++) {
! 11734: if (set->nodeTab[i] == NULL)
! 11735: continue;
! 11736:
! 11737: contextNode = set->nodeTab[i];
! 11738: xpctxt->node = contextNode;
! 11739: xpctxt->contextSize = contextSize;
! 11740: xpctxt->proximityPosition = ++contextPos;
! 11741:
! 11742: /*
! 11743: * Initialize the new set.
! 11744: * Also set the xpath document in case things like
! 11745: * key() evaluation are attempted on the predicate
! 11746: */
! 11747: if ((contextNode->type != XML_NAMESPACE_DECL) &&
! 11748: (contextNode->doc != NULL))
! 11749: xpctxt->doc = contextNode->doc;
! 11750: /*
! 11751: * Evaluate the predicate expression with 1 context node
! 11752: * at a time; this node is packaged into a node set; this
! 11753: * node set is handed over to the evaluation mechanism.
! 11754: */
! 11755: if (contextObj == NULL)
! 11756: contextObj = xmlXPathCacheNewNodeSet(xpctxt, contextNode);
! 11757: else
! 11758: xmlXPathNodeSetAddUnique(contextObj->nodesetval,
! 11759: contextNode);
! 11760:
! 11761: valuePush(ctxt, contextObj);
! 11762: res = xmlXPathCompOpEvalToBoolean(ctxt, exprOp, 1);
! 11763:
! 11764: if ((ctxt->error != XPATH_EXPRESSION_OK) || (res == -1)) {
! 11765: xmlXPathObjectPtr tmp;
! 11766: /* pop the result */
! 11767: tmp = valuePop(ctxt);
! 11768: xmlXPathReleaseObject(xpctxt, tmp);
! 11769: /* then pop off contextObj, which will be freed later */
! 11770: valuePop(ctxt);
! 11771: goto evaluation_error;
! 11772: }
! 11773:
! 11774: if (res)
! 11775: pos++;
! 11776:
! 11777: if (res && (pos >= minPos) && (pos <= maxPos)) {
! 11778: /*
! 11779: * Fits in the requested range.
! 11780: */
! 11781: newContextSize++;
! 11782: if (minPos == maxPos) {
! 11783: /*
! 11784: * Only 1 node was requested.
! 11785: */
! 11786: if (contextNode->type == XML_NAMESPACE_DECL) {
! 11787: /*
! 11788: * As always: take care of those nasty
! 11789: * namespace nodes.
! 11790: */
! 11791: set->nodeTab[i] = NULL;
! 11792: }
! 11793: xmlXPathNodeSetClear(set, hasNsNodes);
! 11794: set->nodeNr = 1;
! 11795: set->nodeTab[0] = contextNode;
! 11796: goto evaluation_exit;
! 11797: }
! 11798: if (pos == maxPos) {
! 11799: /*
! 11800: * We are done.
! 11801: */
! 11802: xmlXPathNodeSetClearFromPos(set, i +1, hasNsNodes);
! 11803: goto evaluation_exit;
! 11804: }
! 11805: } else {
! 11806: /*
! 11807: * Remove the entry from the initial node set.
! 11808: */
! 11809: set->nodeTab[i] = NULL;
! 11810: if (contextNode->type == XML_NAMESPACE_DECL)
! 11811: xmlXPathNodeSetFreeNs((xmlNsPtr) contextNode);
! 11812: }
! 11813: if (exprRes != NULL) {
! 11814: xmlXPathReleaseObject(ctxt->context, exprRes);
! 11815: exprRes = NULL;
! 11816: }
! 11817: if (ctxt->value == contextObj) {
! 11818: /*
! 11819: * Don't free the temporary XPath object holding the
! 11820: * context node, in order to avoid massive recreation
! 11821: * inside this loop.
! 11822: */
! 11823: valuePop(ctxt);
! 11824: xmlXPathNodeSetClear(contextObj->nodesetval, hasNsNodes);
! 11825: } else {
! 11826: /*
! 11827: * The object was lost in the evaluation machinery.
! 11828: * Can this happen? Maybe in case of internal-errors.
! 11829: */
! 11830: contextObj = NULL;
! 11831: }
! 11832: }
! 11833: goto evaluation_exit;
! 11834:
! 11835: evaluation_error:
! 11836: xmlXPathNodeSetClear(set, hasNsNodes);
! 11837: newContextSize = 0;
! 11838:
! 11839: evaluation_exit:
! 11840: if (contextObj != NULL) {
! 11841: if (ctxt->value == contextObj)
! 11842: valuePop(ctxt);
! 11843: xmlXPathReleaseObject(xpctxt, contextObj);
! 11844: }
! 11845: if (exprRes != NULL)
! 11846: xmlXPathReleaseObject(ctxt->context, exprRes);
! 11847: /*
! 11848: * Reset/invalidate the context.
! 11849: */
! 11850: xpctxt->node = oldContextNode;
! 11851: xpctxt->doc = oldContextDoc;
! 11852: xpctxt->contextSize = -1;
! 11853: xpctxt->proximityPosition = -1;
! 11854: return(newContextSize);
! 11855: }
! 11856: return(contextSize);
! 11857: }
! 11858:
! 11859: static int
! 11860: xmlXPathIsPositionalPredicate(xmlXPathParserContextPtr ctxt,
! 11861: xmlXPathStepOpPtr op,
! 11862: int *maxPos)
! 11863: {
! 11864:
! 11865: xmlXPathStepOpPtr exprOp;
! 11866:
! 11867: /*
! 11868: * BIG NOTE: This is not intended for XPATH_OP_FILTER yet!
! 11869: */
! 11870:
! 11871: /*
! 11872: * If not -1, then ch1 will point to:
! 11873: * 1) For predicates (XPATH_OP_PREDICATE):
! 11874: * - an inner predicate operator
! 11875: * 2) For filters (XPATH_OP_FILTER):
! 11876: * - an inner filter operater OR
! 11877: * - an expression selecting the node set.
! 11878: * E.g. "key('a', 'b')" or "(//foo | //bar)".
! 11879: */
! 11880: if ((op->op != XPATH_OP_PREDICATE) && (op->op != XPATH_OP_FILTER))
! 11881: return(0);
! 11882:
! 11883: if (op->ch2 != -1) {
! 11884: exprOp = &ctxt->comp->steps[op->ch2];
! 11885: } else
! 11886: return(0);
! 11887:
! 11888: if ((exprOp != NULL) &&
! 11889: (exprOp->op == XPATH_OP_VALUE) &&
! 11890: (exprOp->value4 != NULL) &&
! 11891: (((xmlXPathObjectPtr) exprOp->value4)->type == XPATH_NUMBER))
! 11892: {
! 11893: /*
! 11894: * We have a "[n]" predicate here.
! 11895: * TODO: Unfortunately this simplistic test here is not
! 11896: * able to detect a position() predicate in compound
! 11897: * expressions like "[@attr = 'a" and position() = 1],
! 11898: * and even not the usage of position() in
! 11899: * "[position() = 1]"; thus - obviously - a position-range,
! 11900: * like it "[position() < 5]", is also not detected.
! 11901: * Maybe we could rewrite the AST to ease the optimization.
! 11902: */
! 11903: *maxPos = (int) ((xmlXPathObjectPtr) exprOp->value4)->floatval;
! 11904:
! 11905: if (((xmlXPathObjectPtr) exprOp->value4)->floatval ==
! 11906: (float) *maxPos)
! 11907: {
! 11908: return(1);
! 11909: }
! 11910: }
! 11911: return(0);
! 11912: }
! 11913:
! 11914: static int
! 11915: xmlXPathNodeCollectAndTest(xmlXPathParserContextPtr ctxt,
! 11916: xmlXPathStepOpPtr op,
! 11917: xmlNodePtr * first, xmlNodePtr * last,
! 11918: int toBool)
! 11919: {
! 11920:
! 11921: #define XP_TEST_HIT \
! 11922: if (hasAxisRange != 0) { \
! 11923: if (++pos == maxPos) { \
! 11924: addNode(seq, cur); \
! 11925: goto axis_range_end; } \
! 11926: } else { \
! 11927: addNode(seq, cur); \
! 11928: if (breakOnFirstHit) goto first_hit; }
! 11929:
! 11930: #define XP_TEST_HIT_NS \
! 11931: if (hasAxisRange != 0) { \
! 11932: if (++pos == maxPos) { \
! 11933: hasNsNodes = 1; \
! 11934: xmlXPathNodeSetAddNs(seq, xpctxt->node, (xmlNsPtr) cur); \
! 11935: goto axis_range_end; } \
! 11936: } else { \
! 11937: hasNsNodes = 1; \
! 11938: xmlXPathNodeSetAddNs(seq, \
! 11939: xpctxt->node, (xmlNsPtr) cur); \
! 11940: if (breakOnFirstHit) goto first_hit; }
! 11941:
! 11942: xmlXPathAxisVal axis = (xmlXPathAxisVal) op->value;
! 11943: xmlXPathTestVal test = (xmlXPathTestVal) op->value2;
! 11944: xmlXPathTypeVal type = (xmlXPathTypeVal) op->value3;
! 11945: const xmlChar *prefix = op->value4;
! 11946: const xmlChar *name = op->value5;
! 11947: const xmlChar *URI = NULL;
! 11948:
! 11949: #ifdef DEBUG_STEP
! 11950: int nbMatches = 0, prevMatches = 0;
! 11951: #endif
! 11952: int total = 0, hasNsNodes = 0;
! 11953: /* The popped object holding the context nodes */
! 11954: xmlXPathObjectPtr obj;
! 11955: /* The set of context nodes for the node tests */
! 11956: xmlNodeSetPtr contextSeq;
! 11957: int contextIdx;
! 11958: xmlNodePtr contextNode;
! 11959: /* The context node for a compound traversal */
! 11960: xmlNodePtr outerContextNode;
! 11961: /* The final resulting node set wrt to all context nodes */
! 11962: xmlNodeSetPtr outSeq;
! 11963: /*
! 11964: * The temporary resulting node set wrt 1 context node.
! 11965: * Used to feed predicate evaluation.
! 11966: */
! 11967: xmlNodeSetPtr seq;
! 11968: xmlNodePtr cur;
! 11969: /* First predicate operator */
! 11970: xmlXPathStepOpPtr predOp;
! 11971: int maxPos; /* The requested position() (when a "[n]" predicate) */
! 11972: int hasPredicateRange, hasAxisRange, pos, size, newSize;
! 11973: int breakOnFirstHit;
! 11974:
! 11975: xmlXPathTraversalFunction next = NULL;
! 11976: /* compound axis traversal */
! 11977: xmlXPathTraversalFunctionExt outerNext = NULL;
! 11978: void (*addNode) (xmlNodeSetPtr, xmlNodePtr);
! 11979: xmlXPathNodeSetMergeFunction mergeAndClear;
! 11980: xmlNodePtr oldContextNode;
! 11981: xmlXPathContextPtr xpctxt = ctxt->context;
! 11982:
! 11983:
! 11984: CHECK_TYPE0(XPATH_NODESET);
! 11985: obj = valuePop(ctxt);
! 11986: /*
! 11987: * Setup namespaces.
! 11988: */
! 11989: if (prefix != NULL) {
! 11990: URI = xmlXPathNsLookup(xpctxt, prefix);
! 11991: if (URI == NULL) {
! 11992: xmlXPathReleaseObject(xpctxt, obj);
! 11993: XP_ERROR0(XPATH_UNDEF_PREFIX_ERROR);
! 11994: }
! 11995: }
! 11996: /*
! 11997: * Setup axis.
! 11998: *
! 11999: * MAYBE FUTURE TODO: merging optimizations:
! 12000: * - If the nodes to be traversed wrt to the initial nodes and
! 12001: * the current axis cannot overlap, then we could avoid searching
! 12002: * for duplicates during the merge.
! 12003: * But the question is how/when to evaluate if they cannot overlap.
! 12004: * Example: if we know that for two initial nodes, the one is
! 12005: * not in the ancestor-or-self axis of the other, then we could safely
! 12006: * avoid a duplicate-aware merge, if the axis to be traversed is e.g.
! 12007: * the descendant-or-self axis.
! 12008: */
! 12009: mergeAndClear = xmlXPathNodeSetMergeAndClear;
! 12010: switch (axis) {
! 12011: case AXIS_ANCESTOR:
! 12012: first = NULL;
! 12013: next = xmlXPathNextAncestor;
! 12014: break;
! 12015: case AXIS_ANCESTOR_OR_SELF:
! 12016: first = NULL;
! 12017: next = xmlXPathNextAncestorOrSelf;
! 12018: break;
! 12019: case AXIS_ATTRIBUTE:
! 12020: first = NULL;
! 12021: last = NULL;
! 12022: next = xmlXPathNextAttribute;
! 12023: mergeAndClear = xmlXPathNodeSetMergeAndClearNoDupls;
! 12024: break;
! 12025: case AXIS_CHILD:
! 12026: last = NULL;
! 12027: if (op->rewriteType == XP_REWRITE_DOS_CHILD_ELEM) {
! 12028: /*
! 12029: * This iterator will give us only nodes which can
! 12030: * hold element nodes.
! 12031: */
! 12032: outerNext = xmlXPathNextDescendantOrSelfElemParent;
! 12033: }
! 12034: if (((test == NODE_TEST_NAME) || (test == NODE_TEST_ALL)) &&
! 12035: (type == NODE_TYPE_NODE))
! 12036: {
! 12037: /*
! 12038: * Optimization if an element node type is 'element'.
! 12039: */
! 12040: next = xmlXPathNextChildElement;
! 12041: } else
! 12042: next = xmlXPathNextChild;
! 12043: mergeAndClear = xmlXPathNodeSetMergeAndClearNoDupls;
! 12044: break;
! 12045: case AXIS_DESCENDANT:
! 12046: last = NULL;
! 12047: next = xmlXPathNextDescendant;
! 12048: break;
! 12049: case AXIS_DESCENDANT_OR_SELF:
! 12050: last = NULL;
! 12051: next = xmlXPathNextDescendantOrSelf;
! 12052: break;
! 12053: case AXIS_FOLLOWING:
! 12054: last = NULL;
! 12055: next = xmlXPathNextFollowing;
! 12056: break;
! 12057: case AXIS_FOLLOWING_SIBLING:
! 12058: last = NULL;
! 12059: next = xmlXPathNextFollowingSibling;
! 12060: break;
! 12061: case AXIS_NAMESPACE:
! 12062: first = NULL;
! 12063: last = NULL;
! 12064: next = (xmlXPathTraversalFunction) xmlXPathNextNamespace;
! 12065: mergeAndClear = xmlXPathNodeSetMergeAndClearNoDupls;
! 12066: break;
! 12067: case AXIS_PARENT:
! 12068: first = NULL;
! 12069: next = xmlXPathNextParent;
! 12070: break;
! 12071: case AXIS_PRECEDING:
! 12072: first = NULL;
! 12073: next = xmlXPathNextPrecedingInternal;
! 12074: break;
! 12075: case AXIS_PRECEDING_SIBLING:
! 12076: first = NULL;
! 12077: next = xmlXPathNextPrecedingSibling;
! 12078: break;
! 12079: case AXIS_SELF:
! 12080: first = NULL;
! 12081: last = NULL;
! 12082: next = xmlXPathNextSelf;
! 12083: mergeAndClear = xmlXPathNodeSetMergeAndClearNoDupls;
! 12084: break;
! 12085: }
! 12086:
! 12087: #ifdef DEBUG_STEP
! 12088: xmlXPathDebugDumpStepAxis(op,
! 12089: (obj->nodesetval != NULL) ? obj->nodesetval->nodeNr : 0);
! 12090: #endif
! 12091:
! 12092: if (next == NULL) {
! 12093: xmlXPathReleaseObject(xpctxt, obj);
! 12094: return(0);
! 12095: }
! 12096: contextSeq = obj->nodesetval;
! 12097: if ((contextSeq == NULL) || (contextSeq->nodeNr <= 0)) {
! 12098: xmlXPathReleaseObject(xpctxt, obj);
! 12099: valuePush(ctxt, xmlXPathCacheWrapNodeSet(xpctxt, NULL));
! 12100: return(0);
! 12101: }
! 12102: /*
! 12103: * Predicate optimization ---------------------------------------------
! 12104: * If this step has a last predicate, which contains a position(),
! 12105: * then we'll optimize (although not exactly "position()", but only
! 12106: * the short-hand form, i.e., "[n]".
! 12107: *
! 12108: * Example - expression "/foo[parent::bar][1]":
! 12109: *
! 12110: * COLLECT 'child' 'name' 'node' foo -- op (we are here)
! 12111: * ROOT -- op->ch1
! 12112: * PREDICATE -- op->ch2 (predOp)
! 12113: * PREDICATE -- predOp->ch1 = [parent::bar]
! 12114: * SORT
! 12115: * COLLECT 'parent' 'name' 'node' bar
! 12116: * NODE
! 12117: * ELEM Object is a number : 1 -- predOp->ch2 = [1]
! 12118: *
! 12119: */
! 12120: maxPos = 0;
! 12121: predOp = NULL;
! 12122: hasPredicateRange = 0;
! 12123: hasAxisRange = 0;
! 12124: if (op->ch2 != -1) {
! 12125: /*
! 12126: * There's at least one predicate. 16 == XPATH_OP_PREDICATE
! 12127: */
! 12128: predOp = &ctxt->comp->steps[op->ch2];
! 12129: if (xmlXPathIsPositionalPredicate(ctxt, predOp, &maxPos)) {
! 12130: if (predOp->ch1 != -1) {
! 12131: /*
! 12132: * Use the next inner predicate operator.
! 12133: */
! 12134: predOp = &ctxt->comp->steps[predOp->ch1];
! 12135: hasPredicateRange = 1;
! 12136: } else {
! 12137: /*
! 12138: * There's no other predicate than the [n] predicate.
! 12139: */
! 12140: predOp = NULL;
! 12141: hasAxisRange = 1;
! 12142: }
! 12143: }
! 12144: }
! 12145: breakOnFirstHit = ((toBool) && (predOp == NULL)) ? 1 : 0;
! 12146: /*
! 12147: * Axis traversal -----------------------------------------------------
! 12148: */
! 12149: /*
! 12150: * 2.3 Node Tests
! 12151: * - For the attribute axis, the principal node type is attribute.
! 12152: * - For the namespace axis, the principal node type is namespace.
! 12153: * - For other axes, the principal node type is element.
! 12154: *
! 12155: * A node test * is true for any node of the
! 12156: * principal node type. For example, child::* will
! 12157: * select all element children of the context node
! 12158: */
! 12159: oldContextNode = xpctxt->node;
! 12160: addNode = xmlXPathNodeSetAddUnique;
! 12161: outSeq = NULL;
! 12162: seq = NULL;
! 12163: outerContextNode = NULL;
! 12164: contextNode = NULL;
! 12165: contextIdx = 0;
! 12166:
! 12167:
! 12168: while ((contextIdx < contextSeq->nodeNr) || (contextNode != NULL)) {
! 12169: if (outerNext != NULL) {
! 12170: /*
! 12171: * This is a compound traversal.
! 12172: */
! 12173: if (contextNode == NULL) {
! 12174: /*
! 12175: * Set the context for the outer traversal.
! 12176: */
! 12177: outerContextNode = contextSeq->nodeTab[contextIdx++];
! 12178: contextNode = outerNext(NULL, outerContextNode);
! 12179: } else
! 12180: contextNode = outerNext(contextNode, outerContextNode);
! 12181: if (contextNode == NULL)
! 12182: continue;
! 12183: /*
! 12184: * Set the context for the main traversal.
! 12185: */
! 12186: xpctxt->node = contextNode;
! 12187: } else
! 12188: xpctxt->node = contextSeq->nodeTab[contextIdx++];
! 12189:
! 12190: if (seq == NULL) {
! 12191: seq = xmlXPathNodeSetCreate(NULL);
! 12192: if (seq == NULL) {
! 12193: total = 0;
! 12194: goto error;
! 12195: }
! 12196: }
! 12197: /*
! 12198: * Traverse the axis and test the nodes.
! 12199: */
! 12200: pos = 0;
! 12201: cur = NULL;
! 12202: hasNsNodes = 0;
! 12203: do {
! 12204: cur = next(ctxt, cur);
! 12205: if (cur == NULL)
! 12206: break;
! 12207:
! 12208: /*
! 12209: * QUESTION TODO: What does the "first" and "last" stuff do?
! 12210: */
! 12211: if ((first != NULL) && (*first != NULL)) {
! 12212: if (*first == cur)
! 12213: break;
! 12214: if (((total % 256) == 0) &&
! 12215: #ifdef XP_OPTIMIZED_NON_ELEM_COMPARISON
! 12216: (xmlXPathCmpNodesExt(*first, cur) >= 0))
! 12217: #else
! 12218: (xmlXPathCmpNodes(*first, cur) >= 0))
! 12219: #endif
! 12220: {
! 12221: break;
! 12222: }
! 12223: }
! 12224: if ((last != NULL) && (*last != NULL)) {
! 12225: if (*last == cur)
! 12226: break;
! 12227: if (((total % 256) == 0) &&
! 12228: #ifdef XP_OPTIMIZED_NON_ELEM_COMPARISON
! 12229: (xmlXPathCmpNodesExt(cur, *last) >= 0))
! 12230: #else
! 12231: (xmlXPathCmpNodes(cur, *last) >= 0))
! 12232: #endif
! 12233: {
! 12234: break;
! 12235: }
! 12236: }
! 12237:
! 12238: total++;
! 12239:
! 12240: #ifdef DEBUG_STEP
! 12241: xmlGenericError(xmlGenericErrorContext, " %s", cur->name);
! 12242: #endif
! 12243:
! 12244: switch (test) {
! 12245: case NODE_TEST_NONE:
! 12246: total = 0;
! 12247: STRANGE
! 12248: goto error;
! 12249: case NODE_TEST_TYPE:
! 12250: /*
! 12251: * TODO: Don't we need to use
! 12252: * xmlXPathNodeSetAddNs() for namespace nodes here?
! 12253: * Surprisingly, some c14n tests fail, if we do this.
! 12254: */
! 12255: if (type == NODE_TYPE_NODE) {
! 12256: switch (cur->type) {
! 12257: case XML_DOCUMENT_NODE:
! 12258: case XML_HTML_DOCUMENT_NODE:
! 12259: #ifdef LIBXML_DOCB_ENABLED
! 12260: case XML_DOCB_DOCUMENT_NODE:
! 12261: #endif
! 12262: case XML_ELEMENT_NODE:
! 12263: case XML_ATTRIBUTE_NODE:
! 12264: case XML_PI_NODE:
! 12265: case XML_COMMENT_NODE:
! 12266: case XML_CDATA_SECTION_NODE:
! 12267: case XML_TEXT_NODE:
! 12268: case XML_NAMESPACE_DECL:
! 12269: XP_TEST_HIT
! 12270: break;
! 12271: default:
! 12272: break;
! 12273: }
! 12274: } else if (cur->type == type) {
! 12275: if (type == XML_NAMESPACE_DECL)
! 12276: XP_TEST_HIT_NS
! 12277: else
! 12278: XP_TEST_HIT
! 12279: } else if ((type == NODE_TYPE_TEXT) &&
! 12280: (cur->type == XML_CDATA_SECTION_NODE))
! 12281: {
! 12282: XP_TEST_HIT
! 12283: }
! 12284: break;
! 12285: case NODE_TEST_PI:
! 12286: if ((cur->type == XML_PI_NODE) &&
! 12287: ((name == NULL) || xmlStrEqual(name, cur->name)))
! 12288: {
! 12289: XP_TEST_HIT
! 12290: }
! 12291: break;
! 12292: case NODE_TEST_ALL:
! 12293: if (axis == AXIS_ATTRIBUTE) {
! 12294: if (cur->type == XML_ATTRIBUTE_NODE)
! 12295: {
! 12296: XP_TEST_HIT
! 12297: }
! 12298: } else if (axis == AXIS_NAMESPACE) {
! 12299: if (cur->type == XML_NAMESPACE_DECL)
! 12300: {
! 12301: XP_TEST_HIT_NS
! 12302: }
! 12303: } else {
! 12304: if (cur->type == XML_ELEMENT_NODE) {
! 12305: if (prefix == NULL)
! 12306: {
! 12307: XP_TEST_HIT
! 12308:
! 12309: } else if ((cur->ns != NULL) &&
! 12310: (xmlStrEqual(URI, cur->ns->href)))
! 12311: {
! 12312: XP_TEST_HIT
! 12313: }
! 12314: }
! 12315: }
! 12316: break;
! 12317: case NODE_TEST_NS:{
! 12318: TODO;
! 12319: break;
! 12320: }
! 12321: case NODE_TEST_NAME:
! 12322: if (axis == AXIS_ATTRIBUTE) {
! 12323: if (cur->type != XML_ATTRIBUTE_NODE)
! 12324: break;
! 12325: } else if (axis == AXIS_NAMESPACE) {
! 12326: if (cur->type != XML_NAMESPACE_DECL)
! 12327: break;
! 12328: } else {
! 12329: if (cur->type != XML_ELEMENT_NODE)
! 12330: break;
! 12331: }
! 12332: switch (cur->type) {
! 12333: case XML_ELEMENT_NODE:
! 12334: if (xmlStrEqual(name, cur->name)) {
! 12335: if (prefix == NULL) {
! 12336: if (cur->ns == NULL)
! 12337: {
! 12338: XP_TEST_HIT
! 12339: }
! 12340: } else {
! 12341: if ((cur->ns != NULL) &&
! 12342: (xmlStrEqual(URI, cur->ns->href)))
! 12343: {
! 12344: XP_TEST_HIT
! 12345: }
! 12346: }
! 12347: }
! 12348: break;
! 12349: case XML_ATTRIBUTE_NODE:{
! 12350: xmlAttrPtr attr = (xmlAttrPtr) cur;
! 12351:
! 12352: if (xmlStrEqual(name, attr->name)) {
! 12353: if (prefix == NULL) {
! 12354: if ((attr->ns == NULL) ||
! 12355: (attr->ns->prefix == NULL))
! 12356: {
! 12357: XP_TEST_HIT
! 12358: }
! 12359: } else {
! 12360: if ((attr->ns != NULL) &&
! 12361: (xmlStrEqual(URI,
! 12362: attr->ns->href)))
! 12363: {
! 12364: XP_TEST_HIT
! 12365: }
! 12366: }
! 12367: }
! 12368: break;
! 12369: }
! 12370: case XML_NAMESPACE_DECL:
! 12371: if (cur->type == XML_NAMESPACE_DECL) {
! 12372: xmlNsPtr ns = (xmlNsPtr) cur;
! 12373:
! 12374: if ((ns->prefix != NULL) && (name != NULL)
! 12375: && (xmlStrEqual(ns->prefix, name)))
! 12376: {
! 12377: XP_TEST_HIT_NS
! 12378: }
! 12379: }
! 12380: break;
! 12381: default:
! 12382: break;
! 12383: }
! 12384: break;
! 12385: } /* switch(test) */
! 12386: } while (cur != NULL);
! 12387:
! 12388: goto apply_predicates;
! 12389:
! 12390: axis_range_end: /* ----------------------------------------------------- */
! 12391: /*
! 12392: * We have a "/foo[n]", and position() = n was reached.
! 12393: * Note that we can have as well "/foo/::parent::foo[1]", so
! 12394: * a duplicate-aware merge is still needed.
! 12395: * Merge with the result.
! 12396: */
! 12397: if (outSeq == NULL) {
! 12398: outSeq = seq;
! 12399: seq = NULL;
! 12400: } else
! 12401: outSeq = mergeAndClear(outSeq, seq, 0);
! 12402: /*
! 12403: * Break if only a true/false result was requested.
! 12404: */
! 12405: if (toBool)
! 12406: break;
! 12407: continue;
! 12408:
! 12409: first_hit: /* ---------------------------------------------------------- */
! 12410: /*
! 12411: * Break if only a true/false result was requested and
! 12412: * no predicates existed and a node test succeeded.
! 12413: */
! 12414: if (outSeq == NULL) {
! 12415: outSeq = seq;
! 12416: seq = NULL;
! 12417: } else
! 12418: outSeq = mergeAndClear(outSeq, seq, 0);
! 12419: break;
! 12420:
! 12421: #ifdef DEBUG_STEP
! 12422: if (seq != NULL)
! 12423: nbMatches += seq->nodeNr;
! 12424: #endif
! 12425:
! 12426: apply_predicates: /* --------------------------------------------------- */
! 12427: /*
! 12428: * Apply predicates.
! 12429: */
! 12430: if ((predOp != NULL) && (seq->nodeNr > 0)) {
! 12431: /*
! 12432: * E.g. when we have a "/foo[some expression][n]".
! 12433: */
! 12434: /*
! 12435: * QUESTION TODO: The old predicate evaluation took into
! 12436: * account location-sets.
! 12437: * (E.g. ctxt->value->type == XPATH_LOCATIONSET)
! 12438: * Do we expect such a set here?
! 12439: * All what I learned now from the evaluation semantics
! 12440: * does not indicate that a location-set will be processed
! 12441: * here, so this looks OK.
! 12442: */
! 12443: /*
! 12444: * Iterate over all predicates, starting with the outermost
! 12445: * predicate.
! 12446: * TODO: Problem: we cannot execute the inner predicates first
! 12447: * since we cannot go back *up* the operator tree!
! 12448: * Options we have:
! 12449: * 1) Use of recursive functions (like is it currently done
! 12450: * via xmlXPathCompOpEval())
! 12451: * 2) Add a predicate evaluation information stack to the
! 12452: * context struct
! 12453: * 3) Change the way the operators are linked; we need a
! 12454: * "parent" field on xmlXPathStepOp
! 12455: *
! 12456: * For the moment, I'll try to solve this with a recursive
! 12457: * function: xmlXPathCompOpEvalPredicate().
! 12458: */
! 12459: size = seq->nodeNr;
! 12460: if (hasPredicateRange != 0)
! 12461: newSize = xmlXPathCompOpEvalPositionalPredicate(ctxt,
! 12462: predOp, seq, size, maxPos, maxPos, hasNsNodes);
! 12463: else
! 12464: newSize = xmlXPathCompOpEvalPredicate(ctxt,
! 12465: predOp, seq, size, hasNsNodes);
! 12466:
! 12467: if (ctxt->error != XPATH_EXPRESSION_OK) {
! 12468: total = 0;
! 12469: goto error;
! 12470: }
! 12471: /*
! 12472: * Add the filtered set of nodes to the result node set.
! 12473: */
! 12474: if (newSize == 0) {
! 12475: /*
! 12476: * The predicates filtered all nodes out.
! 12477: */
! 12478: xmlXPathNodeSetClear(seq, hasNsNodes);
! 12479: } else if (seq->nodeNr > 0) {
! 12480: /*
! 12481: * Add to result set.
! 12482: */
! 12483: if (outSeq == NULL) {
! 12484: if (size != newSize) {
! 12485: /*
! 12486: * We need to merge and clear here, since
! 12487: * the sequence will contained NULLed entries.
! 12488: */
! 12489: outSeq = mergeAndClear(NULL, seq, 1);
! 12490: } else {
! 12491: outSeq = seq;
! 12492: seq = NULL;
! 12493: }
! 12494: } else
! 12495: outSeq = mergeAndClear(outSeq, seq,
! 12496: (size != newSize) ? 1: 0);
! 12497: /*
! 12498: * Break if only a true/false result was requested.
! 12499: */
! 12500: if (toBool)
! 12501: break;
! 12502: }
! 12503: } else if (seq->nodeNr > 0) {
! 12504: /*
! 12505: * Add to result set.
! 12506: */
! 12507: if (outSeq == NULL) {
! 12508: outSeq = seq;
! 12509: seq = NULL;
! 12510: } else {
! 12511: outSeq = mergeAndClear(outSeq, seq, 0);
! 12512: }
! 12513: }
! 12514: }
! 12515:
! 12516: error:
! 12517: if ((obj->boolval) && (obj->user != NULL)) {
! 12518: /*
! 12519: * QUESTION TODO: What does this do and why?
! 12520: * TODO: Do we have to do this also for the "error"
! 12521: * cleanup further down?
! 12522: */
! 12523: ctxt->value->boolval = 1;
! 12524: ctxt->value->user = obj->user;
! 12525: obj->user = NULL;
! 12526: obj->boolval = 0;
! 12527: }
! 12528: xmlXPathReleaseObject(xpctxt, obj);
! 12529:
! 12530: /*
! 12531: * Ensure we return at least an emtpy set.
! 12532: */
! 12533: if (outSeq == NULL) {
! 12534: if ((seq != NULL) && (seq->nodeNr == 0))
! 12535: outSeq = seq;
! 12536: else
! 12537: outSeq = xmlXPathNodeSetCreate(NULL);
! 12538: /* XXX what if xmlXPathNodeSetCreate returned NULL here? */
! 12539: }
! 12540: if ((seq != NULL) && (seq != outSeq)) {
! 12541: xmlXPathFreeNodeSet(seq);
! 12542: }
! 12543: /*
! 12544: * Hand over the result. Better to push the set also in
! 12545: * case of errors.
! 12546: */
! 12547: valuePush(ctxt, xmlXPathCacheWrapNodeSet(xpctxt, outSeq));
! 12548: /*
! 12549: * Reset the context node.
! 12550: */
! 12551: xpctxt->node = oldContextNode;
! 12552:
! 12553: #ifdef DEBUG_STEP
! 12554: xmlGenericError(xmlGenericErrorContext,
! 12555: "\nExamined %d nodes, found %d nodes at that step\n",
! 12556: total, nbMatches);
! 12557: #endif
! 12558:
! 12559: return(total);
! 12560: }
! 12561:
! 12562: static int
! 12563: xmlXPathCompOpEvalFilterFirst(xmlXPathParserContextPtr ctxt,
! 12564: xmlXPathStepOpPtr op, xmlNodePtr * first);
! 12565:
! 12566: /**
! 12567: * xmlXPathCompOpEvalFirst:
! 12568: * @ctxt: the XPath parser context with the compiled expression
! 12569: * @op: an XPath compiled operation
! 12570: * @first: the first elem found so far
! 12571: *
! 12572: * Evaluate the Precompiled XPath operation searching only the first
! 12573: * element in document order
! 12574: *
! 12575: * Returns the number of examined objects.
! 12576: */
! 12577: static int
! 12578: xmlXPathCompOpEvalFirst(xmlXPathParserContextPtr ctxt,
! 12579: xmlXPathStepOpPtr op, xmlNodePtr * first)
! 12580: {
! 12581: int total = 0, cur;
! 12582: xmlXPathCompExprPtr comp;
! 12583: xmlXPathObjectPtr arg1, arg2;
! 12584:
! 12585: CHECK_ERROR0;
! 12586: comp = ctxt->comp;
! 12587: switch (op->op) {
! 12588: case XPATH_OP_END:
! 12589: return (0);
! 12590: case XPATH_OP_UNION:
! 12591: total =
! 12592: xmlXPathCompOpEvalFirst(ctxt, &comp->steps[op->ch1],
! 12593: first);
! 12594: CHECK_ERROR0;
! 12595: if ((ctxt->value != NULL)
! 12596: && (ctxt->value->type == XPATH_NODESET)
! 12597: && (ctxt->value->nodesetval != NULL)
! 12598: && (ctxt->value->nodesetval->nodeNr >= 1)) {
! 12599: /*
! 12600: * limit tree traversing to first node in the result
! 12601: */
! 12602: /*
! 12603: * OPTIMIZE TODO: This implicitely sorts
! 12604: * the result, even if not needed. E.g. if the argument
! 12605: * of the count() function, no sorting is needed.
! 12606: * OPTIMIZE TODO: How do we know if the node-list wasn't
! 12607: * aready sorted?
! 12608: */
! 12609: if (ctxt->value->nodesetval->nodeNr > 1)
! 12610: xmlXPathNodeSetSort(ctxt->value->nodesetval);
! 12611: *first = ctxt->value->nodesetval->nodeTab[0];
! 12612: }
! 12613: cur =
! 12614: xmlXPathCompOpEvalFirst(ctxt, &comp->steps[op->ch2],
! 12615: first);
! 12616: CHECK_ERROR0;
! 12617: CHECK_TYPE0(XPATH_NODESET);
! 12618: arg2 = valuePop(ctxt);
! 12619:
! 12620: CHECK_TYPE0(XPATH_NODESET);
! 12621: arg1 = valuePop(ctxt);
! 12622:
! 12623: arg1->nodesetval = xmlXPathNodeSetMerge(arg1->nodesetval,
! 12624: arg2->nodesetval);
! 12625: valuePush(ctxt, arg1);
! 12626: xmlXPathReleaseObject(ctxt->context, arg2);
! 12627: /* optimizer */
! 12628: if (total > cur)
! 12629: xmlXPathCompSwap(op);
! 12630: return (total + cur);
! 12631: case XPATH_OP_ROOT:
! 12632: xmlXPathRoot(ctxt);
! 12633: return (0);
! 12634: case XPATH_OP_NODE:
! 12635: if (op->ch1 != -1)
! 12636: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
! 12637: CHECK_ERROR0;
! 12638: if (op->ch2 != -1)
! 12639: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
! 12640: CHECK_ERROR0;
! 12641: valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context,
! 12642: ctxt->context->node));
! 12643: return (total);
! 12644: case XPATH_OP_RESET:
! 12645: if (op->ch1 != -1)
! 12646: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
! 12647: CHECK_ERROR0;
! 12648: if (op->ch2 != -1)
! 12649: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
! 12650: CHECK_ERROR0;
! 12651: ctxt->context->node = NULL;
! 12652: return (total);
! 12653: case XPATH_OP_COLLECT:{
! 12654: if (op->ch1 == -1)
! 12655: return (total);
! 12656:
! 12657: total = xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
! 12658: CHECK_ERROR0;
! 12659:
! 12660: total += xmlXPathNodeCollectAndTest(ctxt, op, first, NULL, 0);
! 12661: return (total);
! 12662: }
! 12663: case XPATH_OP_VALUE:
! 12664: valuePush(ctxt,
! 12665: xmlXPathCacheObjectCopy(ctxt->context,
! 12666: (xmlXPathObjectPtr) op->value4));
! 12667: return (0);
! 12668: case XPATH_OP_SORT:
! 12669: if (op->ch1 != -1)
! 12670: total +=
! 12671: xmlXPathCompOpEvalFirst(ctxt, &comp->steps[op->ch1],
! 12672: first);
! 12673: CHECK_ERROR0;
! 12674: if ((ctxt->value != NULL)
! 12675: && (ctxt->value->type == XPATH_NODESET)
! 12676: && (ctxt->value->nodesetval != NULL)
! 12677: && (ctxt->value->nodesetval->nodeNr > 1))
! 12678: xmlXPathNodeSetSort(ctxt->value->nodesetval);
! 12679: return (total);
! 12680: #ifdef XP_OPTIMIZED_FILTER_FIRST
! 12681: case XPATH_OP_FILTER:
! 12682: total += xmlXPathCompOpEvalFilterFirst(ctxt, op, first);
! 12683: return (total);
! 12684: #endif
! 12685: default:
! 12686: return (xmlXPathCompOpEval(ctxt, op));
! 12687: }
! 12688: }
! 12689:
! 12690: /**
! 12691: * xmlXPathCompOpEvalLast:
! 12692: * @ctxt: the XPath parser context with the compiled expression
! 12693: * @op: an XPath compiled operation
! 12694: * @last: the last elem found so far
! 12695: *
! 12696: * Evaluate the Precompiled XPath operation searching only the last
! 12697: * element in document order
! 12698: *
! 12699: * Returns the number of nodes traversed
! 12700: */
! 12701: static int
! 12702: xmlXPathCompOpEvalLast(xmlXPathParserContextPtr ctxt, xmlXPathStepOpPtr op,
! 12703: xmlNodePtr * last)
! 12704: {
! 12705: int total = 0, cur;
! 12706: xmlXPathCompExprPtr comp;
! 12707: xmlXPathObjectPtr arg1, arg2;
! 12708: xmlNodePtr bak;
! 12709: xmlDocPtr bakd;
! 12710: int pp;
! 12711: int cs;
! 12712:
! 12713: CHECK_ERROR0;
! 12714: comp = ctxt->comp;
! 12715: switch (op->op) {
! 12716: case XPATH_OP_END:
! 12717: return (0);
! 12718: case XPATH_OP_UNION:
! 12719: bakd = ctxt->context->doc;
! 12720: bak = ctxt->context->node;
! 12721: pp = ctxt->context->proximityPosition;
! 12722: cs = ctxt->context->contextSize;
! 12723: total =
! 12724: xmlXPathCompOpEvalLast(ctxt, &comp->steps[op->ch1], last);
! 12725: CHECK_ERROR0;
! 12726: if ((ctxt->value != NULL)
! 12727: && (ctxt->value->type == XPATH_NODESET)
! 12728: && (ctxt->value->nodesetval != NULL)
! 12729: && (ctxt->value->nodesetval->nodeNr >= 1)) {
! 12730: /*
! 12731: * limit tree traversing to first node in the result
! 12732: */
! 12733: if (ctxt->value->nodesetval->nodeNr > 1)
! 12734: xmlXPathNodeSetSort(ctxt->value->nodesetval);
! 12735: *last =
! 12736: ctxt->value->nodesetval->nodeTab[ctxt->value->
! 12737: nodesetval->nodeNr -
! 12738: 1];
! 12739: }
! 12740: ctxt->context->doc = bakd;
! 12741: ctxt->context->node = bak;
! 12742: ctxt->context->proximityPosition = pp;
! 12743: ctxt->context->contextSize = cs;
! 12744: cur =
! 12745: xmlXPathCompOpEvalLast(ctxt, &comp->steps[op->ch2], last);
! 12746: CHECK_ERROR0;
! 12747: if ((ctxt->value != NULL)
! 12748: && (ctxt->value->type == XPATH_NODESET)
! 12749: && (ctxt->value->nodesetval != NULL)
! 12750: && (ctxt->value->nodesetval->nodeNr >= 1)) { /* TODO: NOP ? */
! 12751: }
! 12752: CHECK_TYPE0(XPATH_NODESET);
! 12753: arg2 = valuePop(ctxt);
! 12754:
! 12755: CHECK_TYPE0(XPATH_NODESET);
! 12756: arg1 = valuePop(ctxt);
! 12757:
! 12758: arg1->nodesetval = xmlXPathNodeSetMerge(arg1->nodesetval,
! 12759: arg2->nodesetval);
! 12760: valuePush(ctxt, arg1);
! 12761: xmlXPathReleaseObject(ctxt->context, arg2);
! 12762: /* optimizer */
! 12763: if (total > cur)
! 12764: xmlXPathCompSwap(op);
! 12765: return (total + cur);
! 12766: case XPATH_OP_ROOT:
! 12767: xmlXPathRoot(ctxt);
! 12768: return (0);
! 12769: case XPATH_OP_NODE:
! 12770: if (op->ch1 != -1)
! 12771: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
! 12772: CHECK_ERROR0;
! 12773: if (op->ch2 != -1)
! 12774: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
! 12775: CHECK_ERROR0;
! 12776: valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context,
! 12777: ctxt->context->node));
! 12778: return (total);
! 12779: case XPATH_OP_RESET:
! 12780: if (op->ch1 != -1)
! 12781: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
! 12782: CHECK_ERROR0;
! 12783: if (op->ch2 != -1)
! 12784: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
! 12785: CHECK_ERROR0;
! 12786: ctxt->context->node = NULL;
! 12787: return (total);
! 12788: case XPATH_OP_COLLECT:{
! 12789: if (op->ch1 == -1)
! 12790: return (0);
! 12791:
! 12792: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
! 12793: CHECK_ERROR0;
! 12794:
! 12795: total += xmlXPathNodeCollectAndTest(ctxt, op, NULL, last, 0);
! 12796: return (total);
! 12797: }
! 12798: case XPATH_OP_VALUE:
! 12799: valuePush(ctxt,
! 12800: xmlXPathCacheObjectCopy(ctxt->context,
! 12801: (xmlXPathObjectPtr) op->value4));
! 12802: return (0);
! 12803: case XPATH_OP_SORT:
! 12804: if (op->ch1 != -1)
! 12805: total +=
! 12806: xmlXPathCompOpEvalLast(ctxt, &comp->steps[op->ch1],
! 12807: last);
! 12808: CHECK_ERROR0;
! 12809: if ((ctxt->value != NULL)
! 12810: && (ctxt->value->type == XPATH_NODESET)
! 12811: && (ctxt->value->nodesetval != NULL)
! 12812: && (ctxt->value->nodesetval->nodeNr > 1))
! 12813: xmlXPathNodeSetSort(ctxt->value->nodesetval);
! 12814: return (total);
! 12815: default:
! 12816: return (xmlXPathCompOpEval(ctxt, op));
! 12817: }
! 12818: }
! 12819:
! 12820: #ifdef XP_OPTIMIZED_FILTER_FIRST
! 12821: static int
! 12822: xmlXPathCompOpEvalFilterFirst(xmlXPathParserContextPtr ctxt,
! 12823: xmlXPathStepOpPtr op, xmlNodePtr * first)
! 12824: {
! 12825: int total = 0;
! 12826: xmlXPathCompExprPtr comp;
! 12827: xmlXPathObjectPtr res;
! 12828: xmlXPathObjectPtr obj;
! 12829: xmlNodeSetPtr oldset;
! 12830: xmlNodePtr oldnode;
! 12831: xmlDocPtr oldDoc;
! 12832: int i;
! 12833:
! 12834: CHECK_ERROR0;
! 12835: comp = ctxt->comp;
! 12836: /*
! 12837: * Optimization for ()[last()] selection i.e. the last elem
! 12838: */
! 12839: if ((op->ch1 != -1) && (op->ch2 != -1) &&
! 12840: (comp->steps[op->ch1].op == XPATH_OP_SORT) &&
! 12841: (comp->steps[op->ch2].op == XPATH_OP_SORT)) {
! 12842: int f = comp->steps[op->ch2].ch1;
! 12843:
! 12844: if ((f != -1) &&
! 12845: (comp->steps[f].op == XPATH_OP_FUNCTION) &&
! 12846: (comp->steps[f].value5 == NULL) &&
! 12847: (comp->steps[f].value == 0) &&
! 12848: (comp->steps[f].value4 != NULL) &&
! 12849: (xmlStrEqual
! 12850: (comp->steps[f].value4, BAD_CAST "last"))) {
! 12851: xmlNodePtr last = NULL;
! 12852:
! 12853: total +=
! 12854: xmlXPathCompOpEvalLast(ctxt,
! 12855: &comp->steps[op->ch1],
! 12856: &last);
! 12857: CHECK_ERROR0;
! 12858: /*
! 12859: * The nodeset should be in document order,
! 12860: * Keep only the last value
! 12861: */
! 12862: if ((ctxt->value != NULL) &&
! 12863: (ctxt->value->type == XPATH_NODESET) &&
! 12864: (ctxt->value->nodesetval != NULL) &&
! 12865: (ctxt->value->nodesetval->nodeTab != NULL) &&
! 12866: (ctxt->value->nodesetval->nodeNr > 1)) {
! 12867: ctxt->value->nodesetval->nodeTab[0] =
! 12868: ctxt->value->nodesetval->nodeTab[ctxt->
! 12869: value->
! 12870: nodesetval->
! 12871: nodeNr -
! 12872: 1];
! 12873: ctxt->value->nodesetval->nodeNr = 1;
! 12874: *first = *(ctxt->value->nodesetval->nodeTab);
! 12875: }
! 12876: return (total);
! 12877: }
! 12878: }
! 12879:
! 12880: if (op->ch1 != -1)
! 12881: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
! 12882: CHECK_ERROR0;
! 12883: if (op->ch2 == -1)
! 12884: return (total);
! 12885: if (ctxt->value == NULL)
! 12886: return (total);
! 12887:
! 12888: #ifdef LIBXML_XPTR_ENABLED
! 12889: oldnode = ctxt->context->node;
! 12890: /*
! 12891: * Hum are we filtering the result of an XPointer expression
! 12892: */
! 12893: if (ctxt->value->type == XPATH_LOCATIONSET) {
! 12894: xmlXPathObjectPtr tmp = NULL;
! 12895: xmlLocationSetPtr newlocset = NULL;
! 12896: xmlLocationSetPtr oldlocset;
! 12897:
! 12898: /*
! 12899: * Extract the old locset, and then evaluate the result of the
! 12900: * expression for all the element in the locset. use it to grow
! 12901: * up a new locset.
! 12902: */
! 12903: CHECK_TYPE0(XPATH_LOCATIONSET);
! 12904: obj = valuePop(ctxt);
! 12905: oldlocset = obj->user;
! 12906: ctxt->context->node = NULL;
! 12907:
! 12908: if ((oldlocset == NULL) || (oldlocset->locNr == 0)) {
! 12909: ctxt->context->contextSize = 0;
! 12910: ctxt->context->proximityPosition = 0;
! 12911: if (op->ch2 != -1)
! 12912: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
! 12913: res = valuePop(ctxt);
! 12914: if (res != NULL) {
! 12915: xmlXPathReleaseObject(ctxt->context, res);
! 12916: }
! 12917: valuePush(ctxt, obj);
! 12918: CHECK_ERROR0;
! 12919: return (total);
! 12920: }
! 12921: newlocset = xmlXPtrLocationSetCreate(NULL);
! 12922:
! 12923: for (i = 0; i < oldlocset->locNr; i++) {
! 12924: /*
! 12925: * Run the evaluation with a node list made of a
! 12926: * single item in the nodelocset.
! 12927: */
! 12928: ctxt->context->node = oldlocset->locTab[i]->user;
! 12929: ctxt->context->contextSize = oldlocset->locNr;
! 12930: ctxt->context->proximityPosition = i + 1;
! 12931: if (tmp == NULL) {
! 12932: tmp = xmlXPathCacheNewNodeSet(ctxt->context,
! 12933: ctxt->context->node);
! 12934: } else {
! 12935: xmlXPathNodeSetAddUnique(tmp->nodesetval,
! 12936: ctxt->context->node);
! 12937: }
! 12938: valuePush(ctxt, tmp);
! 12939: if (op->ch2 != -1)
! 12940: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
! 12941: if (ctxt->error != XPATH_EXPRESSION_OK) {
! 12942: xmlXPathFreeObject(obj);
! 12943: return(0);
! 12944: }
! 12945: /*
! 12946: * The result of the evaluation need to be tested to
! 12947: * decided whether the filter succeeded or not
! 12948: */
! 12949: res = valuePop(ctxt);
! 12950: if (xmlXPathEvaluatePredicateResult(ctxt, res)) {
! 12951: xmlXPtrLocationSetAdd(newlocset,
! 12952: xmlXPathCacheObjectCopy(ctxt->context,
! 12953: oldlocset->locTab[i]));
! 12954: }
! 12955: /*
! 12956: * Cleanup
! 12957: */
! 12958: if (res != NULL) {
! 12959: xmlXPathReleaseObject(ctxt->context, res);
! 12960: }
! 12961: if (ctxt->value == tmp) {
! 12962: valuePop(ctxt);
! 12963: xmlXPathNodeSetClear(tmp->nodesetval, 1);
! 12964: /*
! 12965: * REVISIT TODO: Don't create a temporary nodeset
! 12966: * for everly iteration.
! 12967: */
! 12968: /* OLD: xmlXPathFreeObject(res); */
! 12969: } else
! 12970: tmp = NULL;
! 12971: ctxt->context->node = NULL;
! 12972: /*
! 12973: * Only put the first node in the result, then leave.
! 12974: */
! 12975: if (newlocset->locNr > 0) {
! 12976: *first = (xmlNodePtr) oldlocset->locTab[i]->user;
! 12977: break;
! 12978: }
! 12979: }
! 12980: if (tmp != NULL) {
! 12981: xmlXPathReleaseObject(ctxt->context, tmp);
! 12982: }
! 12983: /*
! 12984: * The result is used as the new evaluation locset.
! 12985: */
! 12986: xmlXPathReleaseObject(ctxt->context, obj);
! 12987: ctxt->context->node = NULL;
! 12988: ctxt->context->contextSize = -1;
! 12989: ctxt->context->proximityPosition = -1;
! 12990: valuePush(ctxt, xmlXPtrWrapLocationSet(newlocset));
! 12991: ctxt->context->node = oldnode;
! 12992: return (total);
! 12993: }
! 12994: #endif /* LIBXML_XPTR_ENABLED */
! 12995:
! 12996: /*
! 12997: * Extract the old set, and then evaluate the result of the
! 12998: * expression for all the element in the set. use it to grow
! 12999: * up a new set.
! 13000: */
! 13001: CHECK_TYPE0(XPATH_NODESET);
! 13002: obj = valuePop(ctxt);
! 13003: oldset = obj->nodesetval;
! 13004:
! 13005: oldnode = ctxt->context->node;
! 13006: oldDoc = ctxt->context->doc;
! 13007: ctxt->context->node = NULL;
! 13008:
! 13009: if ((oldset == NULL) || (oldset->nodeNr == 0)) {
! 13010: ctxt->context->contextSize = 0;
! 13011: ctxt->context->proximityPosition = 0;
! 13012: /* QUESTION TODO: Why was this code commented out?
! 13013: if (op->ch2 != -1)
! 13014: total +=
! 13015: xmlXPathCompOpEval(ctxt,
! 13016: &comp->steps[op->ch2]);
! 13017: CHECK_ERROR0;
! 13018: res = valuePop(ctxt);
! 13019: if (res != NULL)
! 13020: xmlXPathFreeObject(res);
! 13021: */
! 13022: valuePush(ctxt, obj);
! 13023: ctxt->context->node = oldnode;
! 13024: CHECK_ERROR0;
! 13025: } else {
! 13026: xmlNodeSetPtr newset;
! 13027: xmlXPathObjectPtr tmp = NULL;
! 13028: /*
! 13029: * Initialize the new set.
! 13030: * Also set the xpath document in case things like
! 13031: * key() evaluation are attempted on the predicate
! 13032: */
! 13033: newset = xmlXPathNodeSetCreate(NULL);
! 13034: /* XXX what if xmlXPathNodeSetCreate returned NULL? */
! 13035:
! 13036: for (i = 0; i < oldset->nodeNr; i++) {
! 13037: /*
! 13038: * Run the evaluation with a node list made of
! 13039: * a single item in the nodeset.
! 13040: */
! 13041: ctxt->context->node = oldset->nodeTab[i];
! 13042: if ((oldset->nodeTab[i]->type != XML_NAMESPACE_DECL) &&
! 13043: (oldset->nodeTab[i]->doc != NULL))
! 13044: ctxt->context->doc = oldset->nodeTab[i]->doc;
! 13045: if (tmp == NULL) {
! 13046: tmp = xmlXPathCacheNewNodeSet(ctxt->context,
! 13047: ctxt->context->node);
! 13048: } else {
! 13049: xmlXPathNodeSetAddUnique(tmp->nodesetval,
! 13050: ctxt->context->node);
! 13051: }
! 13052: valuePush(ctxt, tmp);
! 13053: ctxt->context->contextSize = oldset->nodeNr;
! 13054: ctxt->context->proximityPosition = i + 1;
! 13055: if (op->ch2 != -1)
! 13056: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
! 13057: if (ctxt->error != XPATH_EXPRESSION_OK) {
! 13058: xmlXPathFreeNodeSet(newset);
! 13059: xmlXPathFreeObject(obj);
! 13060: return(0);
! 13061: }
! 13062: /*
! 13063: * The result of the evaluation needs to be tested to
! 13064: * decide whether the filter succeeded or not
! 13065: */
! 13066: res = valuePop(ctxt);
! 13067: if (xmlXPathEvaluatePredicateResult(ctxt, res)) {
! 13068: xmlXPathNodeSetAdd(newset, oldset->nodeTab[i]);
! 13069: }
! 13070: /*
! 13071: * Cleanup
! 13072: */
! 13073: if (res != NULL) {
! 13074: xmlXPathReleaseObject(ctxt->context, res);
! 13075: }
! 13076: if (ctxt->value == tmp) {
! 13077: valuePop(ctxt);
! 13078: /*
! 13079: * Don't free the temporary nodeset
! 13080: * in order to avoid massive recreation inside this
! 13081: * loop.
! 13082: */
! 13083: xmlXPathNodeSetClear(tmp->nodesetval, 1);
! 13084: } else
! 13085: tmp = NULL;
! 13086: ctxt->context->node = NULL;
! 13087: /*
! 13088: * Only put the first node in the result, then leave.
! 13089: */
! 13090: if (newset->nodeNr > 0) {
! 13091: *first = *(newset->nodeTab);
! 13092: break;
! 13093: }
! 13094: }
! 13095: if (tmp != NULL) {
! 13096: xmlXPathReleaseObject(ctxt->context, tmp);
! 13097: }
! 13098: /*
! 13099: * The result is used as the new evaluation set.
! 13100: */
! 13101: xmlXPathReleaseObject(ctxt->context, obj);
! 13102: ctxt->context->node = NULL;
! 13103: ctxt->context->contextSize = -1;
! 13104: ctxt->context->proximityPosition = -1;
! 13105: /* may want to move this past the '}' later */
! 13106: ctxt->context->doc = oldDoc;
! 13107: valuePush(ctxt, xmlXPathCacheWrapNodeSet(ctxt->context, newset));
! 13108: }
! 13109: ctxt->context->node = oldnode;
! 13110: return(total);
! 13111: }
! 13112: #endif /* XP_OPTIMIZED_FILTER_FIRST */
! 13113:
! 13114: /**
! 13115: * xmlXPathCompOpEval:
! 13116: * @ctxt: the XPath parser context with the compiled expression
! 13117: * @op: an XPath compiled operation
! 13118: *
! 13119: * Evaluate the Precompiled XPath operation
! 13120: * Returns the number of nodes traversed
! 13121: */
! 13122: static int
! 13123: xmlXPathCompOpEval(xmlXPathParserContextPtr ctxt, xmlXPathStepOpPtr op)
! 13124: {
! 13125: int total = 0;
! 13126: int equal, ret;
! 13127: xmlXPathCompExprPtr comp;
! 13128: xmlXPathObjectPtr arg1, arg2;
! 13129: xmlNodePtr bak;
! 13130: xmlDocPtr bakd;
! 13131: int pp;
! 13132: int cs;
! 13133:
! 13134: CHECK_ERROR0;
! 13135: comp = ctxt->comp;
! 13136: switch (op->op) {
! 13137: case XPATH_OP_END:
! 13138: return (0);
! 13139: case XPATH_OP_AND:
! 13140: bakd = ctxt->context->doc;
! 13141: bak = ctxt->context->node;
! 13142: pp = ctxt->context->proximityPosition;
! 13143: cs = ctxt->context->contextSize;
! 13144: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
! 13145: CHECK_ERROR0;
! 13146: xmlXPathBooleanFunction(ctxt, 1);
! 13147: if ((ctxt->value == NULL) || (ctxt->value->boolval == 0))
! 13148: return (total);
! 13149: arg2 = valuePop(ctxt);
! 13150: ctxt->context->doc = bakd;
! 13151: ctxt->context->node = bak;
! 13152: ctxt->context->proximityPosition = pp;
! 13153: ctxt->context->contextSize = cs;
! 13154: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
! 13155: if (ctxt->error) {
! 13156: xmlXPathFreeObject(arg2);
! 13157: return(0);
! 13158: }
! 13159: xmlXPathBooleanFunction(ctxt, 1);
! 13160: arg1 = valuePop(ctxt);
! 13161: arg1->boolval &= arg2->boolval;
! 13162: valuePush(ctxt, arg1);
! 13163: xmlXPathReleaseObject(ctxt->context, arg2);
! 13164: return (total);
! 13165: case XPATH_OP_OR:
! 13166: bakd = ctxt->context->doc;
! 13167: bak = ctxt->context->node;
! 13168: pp = ctxt->context->proximityPosition;
! 13169: cs = ctxt->context->contextSize;
! 13170: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
! 13171: CHECK_ERROR0;
! 13172: xmlXPathBooleanFunction(ctxt, 1);
! 13173: if ((ctxt->value == NULL) || (ctxt->value->boolval == 1))
! 13174: return (total);
! 13175: arg2 = valuePop(ctxt);
! 13176: ctxt->context->doc = bakd;
! 13177: ctxt->context->node = bak;
! 13178: ctxt->context->proximityPosition = pp;
! 13179: ctxt->context->contextSize = cs;
! 13180: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
! 13181: if (ctxt->error) {
! 13182: xmlXPathFreeObject(arg2);
! 13183: return(0);
! 13184: }
! 13185: xmlXPathBooleanFunction(ctxt, 1);
! 13186: arg1 = valuePop(ctxt);
! 13187: arg1->boolval |= arg2->boolval;
! 13188: valuePush(ctxt, arg1);
! 13189: xmlXPathReleaseObject(ctxt->context, arg2);
! 13190: return (total);
! 13191: case XPATH_OP_EQUAL:
! 13192: bakd = ctxt->context->doc;
! 13193: bak = ctxt->context->node;
! 13194: pp = ctxt->context->proximityPosition;
! 13195: cs = ctxt->context->contextSize;
! 13196: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
! 13197: CHECK_ERROR0;
! 13198: ctxt->context->doc = bakd;
! 13199: ctxt->context->node = bak;
! 13200: ctxt->context->proximityPosition = pp;
! 13201: ctxt->context->contextSize = cs;
! 13202: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
! 13203: CHECK_ERROR0;
! 13204: if (op->value)
! 13205: equal = xmlXPathEqualValues(ctxt);
! 13206: else
! 13207: equal = xmlXPathNotEqualValues(ctxt);
! 13208: valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, equal));
! 13209: return (total);
! 13210: case XPATH_OP_CMP:
! 13211: bakd = ctxt->context->doc;
! 13212: bak = ctxt->context->node;
! 13213: pp = ctxt->context->proximityPosition;
! 13214: cs = ctxt->context->contextSize;
! 13215: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
! 13216: CHECK_ERROR0;
! 13217: ctxt->context->doc = bakd;
! 13218: ctxt->context->node = bak;
! 13219: ctxt->context->proximityPosition = pp;
! 13220: ctxt->context->contextSize = cs;
! 13221: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
! 13222: CHECK_ERROR0;
! 13223: ret = xmlXPathCompareValues(ctxt, op->value, op->value2);
! 13224: valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, ret));
! 13225: return (total);
! 13226: case XPATH_OP_PLUS:
! 13227: bakd = ctxt->context->doc;
! 13228: bak = ctxt->context->node;
! 13229: pp = ctxt->context->proximityPosition;
! 13230: cs = ctxt->context->contextSize;
! 13231: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
! 13232: CHECK_ERROR0;
! 13233: if (op->ch2 != -1) {
! 13234: ctxt->context->doc = bakd;
! 13235: ctxt->context->node = bak;
! 13236: ctxt->context->proximityPosition = pp;
! 13237: ctxt->context->contextSize = cs;
! 13238: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
! 13239: }
! 13240: CHECK_ERROR0;
! 13241: if (op->value == 0)
! 13242: xmlXPathSubValues(ctxt);
! 13243: else if (op->value == 1)
! 13244: xmlXPathAddValues(ctxt);
! 13245: else if (op->value == 2)
! 13246: xmlXPathValueFlipSign(ctxt);
! 13247: else if (op->value == 3) {
! 13248: CAST_TO_NUMBER;
! 13249: CHECK_TYPE0(XPATH_NUMBER);
! 13250: }
! 13251: return (total);
! 13252: case XPATH_OP_MULT:
! 13253: bakd = ctxt->context->doc;
! 13254: bak = ctxt->context->node;
! 13255: pp = ctxt->context->proximityPosition;
! 13256: cs = ctxt->context->contextSize;
! 13257: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
! 13258: CHECK_ERROR0;
! 13259: ctxt->context->doc = bakd;
! 13260: ctxt->context->node = bak;
! 13261: ctxt->context->proximityPosition = pp;
! 13262: ctxt->context->contextSize = cs;
! 13263: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
! 13264: CHECK_ERROR0;
! 13265: if (op->value == 0)
! 13266: xmlXPathMultValues(ctxt);
! 13267: else if (op->value == 1)
! 13268: xmlXPathDivValues(ctxt);
! 13269: else if (op->value == 2)
! 13270: xmlXPathModValues(ctxt);
! 13271: return (total);
! 13272: case XPATH_OP_UNION:
! 13273: bakd = ctxt->context->doc;
! 13274: bak = ctxt->context->node;
! 13275: pp = ctxt->context->proximityPosition;
! 13276: cs = ctxt->context->contextSize;
! 13277: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
! 13278: CHECK_ERROR0;
! 13279: ctxt->context->doc = bakd;
! 13280: ctxt->context->node = bak;
! 13281: ctxt->context->proximityPosition = pp;
! 13282: ctxt->context->contextSize = cs;
! 13283: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
! 13284: CHECK_ERROR0;
! 13285: CHECK_TYPE0(XPATH_NODESET);
! 13286: arg2 = valuePop(ctxt);
! 13287:
! 13288: CHECK_TYPE0(XPATH_NODESET);
! 13289: arg1 = valuePop(ctxt);
! 13290:
! 13291: if ((arg1->nodesetval == NULL) ||
! 13292: ((arg2->nodesetval != NULL) &&
! 13293: (arg2->nodesetval->nodeNr != 0)))
! 13294: {
! 13295: arg1->nodesetval = xmlXPathNodeSetMerge(arg1->nodesetval,
! 13296: arg2->nodesetval);
! 13297: }
! 13298:
! 13299: valuePush(ctxt, arg1);
! 13300: xmlXPathReleaseObject(ctxt->context, arg2);
! 13301: return (total);
! 13302: case XPATH_OP_ROOT:
! 13303: xmlXPathRoot(ctxt);
! 13304: return (total);
! 13305: case XPATH_OP_NODE:
! 13306: if (op->ch1 != -1)
! 13307: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
! 13308: CHECK_ERROR0;
! 13309: if (op->ch2 != -1)
! 13310: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
! 13311: CHECK_ERROR0;
! 13312: valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context,
! 13313: ctxt->context->node));
! 13314: return (total);
! 13315: case XPATH_OP_RESET:
! 13316: if (op->ch1 != -1)
! 13317: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
! 13318: CHECK_ERROR0;
! 13319: if (op->ch2 != -1)
! 13320: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
! 13321: CHECK_ERROR0;
! 13322: ctxt->context->node = NULL;
! 13323: return (total);
! 13324: case XPATH_OP_COLLECT:{
! 13325: if (op->ch1 == -1)
! 13326: return (total);
! 13327:
! 13328: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
! 13329: CHECK_ERROR0;
! 13330:
! 13331: total += xmlXPathNodeCollectAndTest(ctxt, op, NULL, NULL, 0);
! 13332: return (total);
! 13333: }
! 13334: case XPATH_OP_VALUE:
! 13335: valuePush(ctxt,
! 13336: xmlXPathCacheObjectCopy(ctxt->context,
! 13337: (xmlXPathObjectPtr) op->value4));
! 13338: return (total);
! 13339: case XPATH_OP_VARIABLE:{
! 13340: xmlXPathObjectPtr val;
! 13341:
! 13342: if (op->ch1 != -1)
! 13343: total +=
! 13344: xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
! 13345: if (op->value5 == NULL) {
! 13346: val = xmlXPathVariableLookup(ctxt->context, op->value4);
! 13347: if (val == NULL) {
! 13348: ctxt->error = XPATH_UNDEF_VARIABLE_ERROR;
! 13349: return(0);
! 13350: }
! 13351: valuePush(ctxt, val);
! 13352: } else {
! 13353: const xmlChar *URI;
! 13354:
! 13355: URI = xmlXPathNsLookup(ctxt->context, op->value5);
! 13356: if (URI == NULL) {
! 13357: xmlGenericError(xmlGenericErrorContext,
! 13358: "xmlXPathCompOpEval: variable %s bound to undefined prefix %s\n",
! 13359: (char *) op->value4, (char *)op->value5);
! 13360: return (total);
! 13361: }
! 13362: val = xmlXPathVariableLookupNS(ctxt->context,
! 13363: op->value4, URI);
! 13364: if (val == NULL) {
! 13365: ctxt->error = XPATH_UNDEF_VARIABLE_ERROR;
! 13366: return(0);
! 13367: }
! 13368: valuePush(ctxt, val);
! 13369: }
! 13370: return (total);
! 13371: }
! 13372: case XPATH_OP_FUNCTION:{
! 13373: xmlXPathFunction func;
! 13374: const xmlChar *oldFunc, *oldFuncURI;
! 13375: int i;
! 13376:
! 13377: if (op->ch1 != -1)
! 13378: total +=
! 13379: xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
! 13380: if (ctxt->valueNr < op->value) {
! 13381: xmlGenericError(xmlGenericErrorContext,
! 13382: "xmlXPathCompOpEval: parameter error\n");
! 13383: ctxt->error = XPATH_INVALID_OPERAND;
! 13384: return (total);
! 13385: }
! 13386: for (i = 0; i < op->value; i++)
! 13387: if (ctxt->valueTab[(ctxt->valueNr - 1) - i] == NULL) {
! 13388: xmlGenericError(xmlGenericErrorContext,
! 13389: "xmlXPathCompOpEval: parameter error\n");
! 13390: ctxt->error = XPATH_INVALID_OPERAND;
! 13391: return (total);
! 13392: }
! 13393: if (op->cache != NULL)
! 13394: XML_CAST_FPTR(func) = op->cache;
! 13395: else {
! 13396: const xmlChar *URI = NULL;
! 13397:
! 13398: if (op->value5 == NULL)
! 13399: func =
! 13400: xmlXPathFunctionLookup(ctxt->context,
! 13401: op->value4);
! 13402: else {
! 13403: URI = xmlXPathNsLookup(ctxt->context, op->value5);
! 13404: if (URI == NULL) {
! 13405: xmlGenericError(xmlGenericErrorContext,
! 13406: "xmlXPathCompOpEval: function %s bound to undefined prefix %s\n",
! 13407: (char *)op->value4, (char *)op->value5);
! 13408: return (total);
! 13409: }
! 13410: func = xmlXPathFunctionLookupNS(ctxt->context,
! 13411: op->value4, URI);
! 13412: }
! 13413: if (func == NULL) {
! 13414: xmlGenericError(xmlGenericErrorContext,
! 13415: "xmlXPathCompOpEval: function %s not found\n",
! 13416: (char *)op->value4);
! 13417: XP_ERROR0(XPATH_UNKNOWN_FUNC_ERROR);
! 13418: }
! 13419: op->cache = XML_CAST_FPTR(func);
! 13420: op->cacheURI = (void *) URI;
! 13421: }
! 13422: oldFunc = ctxt->context->function;
! 13423: oldFuncURI = ctxt->context->functionURI;
! 13424: ctxt->context->function = op->value4;
! 13425: ctxt->context->functionURI = op->cacheURI;
! 13426: func(ctxt, op->value);
! 13427: ctxt->context->function = oldFunc;
! 13428: ctxt->context->functionURI = oldFuncURI;
! 13429: return (total);
! 13430: }
! 13431: case XPATH_OP_ARG:
! 13432: bakd = ctxt->context->doc;
! 13433: bak = ctxt->context->node;
! 13434: pp = ctxt->context->proximityPosition;
! 13435: cs = ctxt->context->contextSize;
! 13436: if (op->ch1 != -1)
! 13437: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
! 13438: ctxt->context->contextSize = cs;
! 13439: ctxt->context->proximityPosition = pp;
! 13440: ctxt->context->node = bak;
! 13441: ctxt->context->doc = bakd;
! 13442: CHECK_ERROR0;
! 13443: if (op->ch2 != -1) {
! 13444: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
! 13445: ctxt->context->doc = bakd;
! 13446: ctxt->context->node = bak;
! 13447: CHECK_ERROR0;
! 13448: }
! 13449: return (total);
! 13450: case XPATH_OP_PREDICATE:
! 13451: case XPATH_OP_FILTER:{
! 13452: xmlXPathObjectPtr res;
! 13453: xmlXPathObjectPtr obj, tmp;
! 13454: xmlNodeSetPtr newset = NULL;
! 13455: xmlNodeSetPtr oldset;
! 13456: xmlNodePtr oldnode;
! 13457: xmlDocPtr oldDoc;
! 13458: int i;
! 13459:
! 13460: /*
! 13461: * Optimization for ()[1] selection i.e. the first elem
! 13462: */
! 13463: if ((op->ch1 != -1) && (op->ch2 != -1) &&
! 13464: #ifdef XP_OPTIMIZED_FILTER_FIRST
! 13465: /*
! 13466: * FILTER TODO: Can we assume that the inner processing
! 13467: * will result in an ordered list if we have an
! 13468: * XPATH_OP_FILTER?
! 13469: * What about an additional field or flag on
! 13470: * xmlXPathObject like @sorted ? This way we wouln'd need
! 13471: * to assume anything, so it would be more robust and
! 13472: * easier to optimize.
! 13473: */
! 13474: ((comp->steps[op->ch1].op == XPATH_OP_SORT) || /* 18 */
! 13475: (comp->steps[op->ch1].op == XPATH_OP_FILTER)) && /* 17 */
! 13476: #else
! 13477: (comp->steps[op->ch1].op == XPATH_OP_SORT) &&
! 13478: #endif
! 13479: (comp->steps[op->ch2].op == XPATH_OP_VALUE)) { /* 12 */
! 13480: xmlXPathObjectPtr val;
! 13481:
! 13482: val = comp->steps[op->ch2].value4;
! 13483: if ((val != NULL) && (val->type == XPATH_NUMBER) &&
! 13484: (val->floatval == 1.0)) {
! 13485: xmlNodePtr first = NULL;
! 13486:
! 13487: total +=
! 13488: xmlXPathCompOpEvalFirst(ctxt,
! 13489: &comp->steps[op->ch1],
! 13490: &first);
! 13491: CHECK_ERROR0;
! 13492: /*
! 13493: * The nodeset should be in document order,
! 13494: * Keep only the first value
! 13495: */
! 13496: if ((ctxt->value != NULL) &&
! 13497: (ctxt->value->type == XPATH_NODESET) &&
! 13498: (ctxt->value->nodesetval != NULL) &&
! 13499: (ctxt->value->nodesetval->nodeNr > 1))
! 13500: ctxt->value->nodesetval->nodeNr = 1;
! 13501: return (total);
! 13502: }
! 13503: }
! 13504: /*
! 13505: * Optimization for ()[last()] selection i.e. the last elem
! 13506: */
! 13507: if ((op->ch1 != -1) && (op->ch2 != -1) &&
! 13508: (comp->steps[op->ch1].op == XPATH_OP_SORT) &&
! 13509: (comp->steps[op->ch2].op == XPATH_OP_SORT)) {
! 13510: int f = comp->steps[op->ch2].ch1;
! 13511:
! 13512: if ((f != -1) &&
! 13513: (comp->steps[f].op == XPATH_OP_FUNCTION) &&
! 13514: (comp->steps[f].value5 == NULL) &&
! 13515: (comp->steps[f].value == 0) &&
! 13516: (comp->steps[f].value4 != NULL) &&
! 13517: (xmlStrEqual
! 13518: (comp->steps[f].value4, BAD_CAST "last"))) {
! 13519: xmlNodePtr last = NULL;
! 13520:
! 13521: total +=
! 13522: xmlXPathCompOpEvalLast(ctxt,
! 13523: &comp->steps[op->ch1],
! 13524: &last);
! 13525: CHECK_ERROR0;
! 13526: /*
! 13527: * The nodeset should be in document order,
! 13528: * Keep only the last value
! 13529: */
! 13530: if ((ctxt->value != NULL) &&
! 13531: (ctxt->value->type == XPATH_NODESET) &&
! 13532: (ctxt->value->nodesetval != NULL) &&
! 13533: (ctxt->value->nodesetval->nodeTab != NULL) &&
! 13534: (ctxt->value->nodesetval->nodeNr > 1)) {
! 13535: ctxt->value->nodesetval->nodeTab[0] =
! 13536: ctxt->value->nodesetval->nodeTab[ctxt->
! 13537: value->
! 13538: nodesetval->
! 13539: nodeNr -
! 13540: 1];
! 13541: ctxt->value->nodesetval->nodeNr = 1;
! 13542: }
! 13543: return (total);
! 13544: }
! 13545: }
! 13546: /*
! 13547: * Process inner predicates first.
! 13548: * Example "index[parent::book][1]":
! 13549: * ...
! 13550: * PREDICATE <-- we are here "[1]"
! 13551: * PREDICATE <-- process "[parent::book]" first
! 13552: * SORT
! 13553: * COLLECT 'parent' 'name' 'node' book
! 13554: * NODE
! 13555: * ELEM Object is a number : 1
! 13556: */
! 13557: if (op->ch1 != -1)
! 13558: total +=
! 13559: xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
! 13560: CHECK_ERROR0;
! 13561: if (op->ch2 == -1)
! 13562: return (total);
! 13563: if (ctxt->value == NULL)
! 13564: return (total);
! 13565:
! 13566: oldnode = ctxt->context->node;
! 13567:
! 13568: #ifdef LIBXML_XPTR_ENABLED
! 13569: /*
! 13570: * Hum are we filtering the result of an XPointer expression
! 13571: */
! 13572: if (ctxt->value->type == XPATH_LOCATIONSET) {
! 13573: xmlLocationSetPtr newlocset = NULL;
! 13574: xmlLocationSetPtr oldlocset;
! 13575:
! 13576: /*
! 13577: * Extract the old locset, and then evaluate the result of the
! 13578: * expression for all the element in the locset. use it to grow
! 13579: * up a new locset.
! 13580: */
! 13581: CHECK_TYPE0(XPATH_LOCATIONSET);
! 13582: obj = valuePop(ctxt);
! 13583: oldlocset = obj->user;
! 13584: ctxt->context->node = NULL;
! 13585:
! 13586: if ((oldlocset == NULL) || (oldlocset->locNr == 0)) {
! 13587: ctxt->context->contextSize = 0;
! 13588: ctxt->context->proximityPosition = 0;
! 13589: if (op->ch2 != -1)
! 13590: total +=
! 13591: xmlXPathCompOpEval(ctxt,
! 13592: &comp->steps[op->ch2]);
! 13593: res = valuePop(ctxt);
! 13594: if (res != NULL) {
! 13595: xmlXPathReleaseObject(ctxt->context, res);
! 13596: }
! 13597: valuePush(ctxt, obj);
! 13598: CHECK_ERROR0;
! 13599: return (total);
! 13600: }
! 13601: newlocset = xmlXPtrLocationSetCreate(NULL);
! 13602:
! 13603: for (i = 0; i < oldlocset->locNr; i++) {
! 13604: /*
! 13605: * Run the evaluation with a node list made of a
! 13606: * single item in the nodelocset.
! 13607: */
! 13608: ctxt->context->node = oldlocset->locTab[i]->user;
! 13609: ctxt->context->contextSize = oldlocset->locNr;
! 13610: ctxt->context->proximityPosition = i + 1;
! 13611: tmp = xmlXPathCacheNewNodeSet(ctxt->context,
! 13612: ctxt->context->node);
! 13613: valuePush(ctxt, tmp);
! 13614:
! 13615: if (op->ch2 != -1)
! 13616: total +=
! 13617: xmlXPathCompOpEval(ctxt,
! 13618: &comp->steps[op->ch2]);
! 13619: if (ctxt->error != XPATH_EXPRESSION_OK) {
! 13620: xmlXPathFreeObject(obj);
! 13621: return(0);
! 13622: }
! 13623:
! 13624: /*
! 13625: * The result of the evaluation need to be tested to
! 13626: * decided whether the filter succeeded or not
! 13627: */
! 13628: res = valuePop(ctxt);
! 13629: if (xmlXPathEvaluatePredicateResult(ctxt, res)) {
! 13630: xmlXPtrLocationSetAdd(newlocset,
! 13631: xmlXPathObjectCopy
! 13632: (oldlocset->locTab[i]));
! 13633: }
! 13634:
! 13635: /*
! 13636: * Cleanup
! 13637: */
! 13638: if (res != NULL) {
! 13639: xmlXPathReleaseObject(ctxt->context, res);
! 13640: }
! 13641: if (ctxt->value == tmp) {
! 13642: res = valuePop(ctxt);
! 13643: xmlXPathReleaseObject(ctxt->context, res);
! 13644: }
! 13645:
! 13646: ctxt->context->node = NULL;
! 13647: }
! 13648:
! 13649: /*
! 13650: * The result is used as the new evaluation locset.
! 13651: */
! 13652: xmlXPathReleaseObject(ctxt->context, obj);
! 13653: ctxt->context->node = NULL;
! 13654: ctxt->context->contextSize = -1;
! 13655: ctxt->context->proximityPosition = -1;
! 13656: valuePush(ctxt, xmlXPtrWrapLocationSet(newlocset));
! 13657: ctxt->context->node = oldnode;
! 13658: return (total);
! 13659: }
! 13660: #endif /* LIBXML_XPTR_ENABLED */
! 13661:
! 13662: /*
! 13663: * Extract the old set, and then evaluate the result of the
! 13664: * expression for all the element in the set. use it to grow
! 13665: * up a new set.
! 13666: */
! 13667: CHECK_TYPE0(XPATH_NODESET);
! 13668: obj = valuePop(ctxt);
! 13669: oldset = obj->nodesetval;
! 13670:
! 13671: oldnode = ctxt->context->node;
! 13672: oldDoc = ctxt->context->doc;
! 13673: ctxt->context->node = NULL;
! 13674:
! 13675: if ((oldset == NULL) || (oldset->nodeNr == 0)) {
! 13676: ctxt->context->contextSize = 0;
! 13677: ctxt->context->proximityPosition = 0;
! 13678: /*
! 13679: if (op->ch2 != -1)
! 13680: total +=
! 13681: xmlXPathCompOpEval(ctxt,
! 13682: &comp->steps[op->ch2]);
! 13683: CHECK_ERROR0;
! 13684: res = valuePop(ctxt);
! 13685: if (res != NULL)
! 13686: xmlXPathFreeObject(res);
! 13687: */
! 13688: valuePush(ctxt, obj);
! 13689: ctxt->context->node = oldnode;
! 13690: CHECK_ERROR0;
! 13691: } else {
! 13692: tmp = NULL;
! 13693: /*
! 13694: * Initialize the new set.
! 13695: * Also set the xpath document in case things like
! 13696: * key() evaluation are attempted on the predicate
! 13697: */
! 13698: newset = xmlXPathNodeSetCreate(NULL);
! 13699: /*
! 13700: * SPEC XPath 1.0:
! 13701: * "For each node in the node-set to be filtered, the
! 13702: * PredicateExpr is evaluated with that node as the
! 13703: * context node, with the number of nodes in the
! 13704: * node-set as the context size, and with the proximity
! 13705: * position of the node in the node-set with respect to
! 13706: * the axis as the context position;"
! 13707: * @oldset is the node-set" to be filtered.
! 13708: *
! 13709: * SPEC XPath 1.0:
! 13710: * "only predicates change the context position and
! 13711: * context size (see [2.4 Predicates])."
! 13712: * Example:
! 13713: * node-set context pos
! 13714: * nA 1
! 13715: * nB 2
! 13716: * nC 3
! 13717: * After applying predicate [position() > 1] :
! 13718: * node-set context pos
! 13719: * nB 1
! 13720: * nC 2
! 13721: *
! 13722: * removed the first node in the node-set, then
! 13723: * the context position of the
! 13724: */
! 13725: for (i = 0; i < oldset->nodeNr; i++) {
! 13726: /*
! 13727: * Run the evaluation with a node list made of
! 13728: * a single item in the nodeset.
! 13729: */
! 13730: ctxt->context->node = oldset->nodeTab[i];
! 13731: if ((oldset->nodeTab[i]->type != XML_NAMESPACE_DECL) &&
! 13732: (oldset->nodeTab[i]->doc != NULL))
! 13733: ctxt->context->doc = oldset->nodeTab[i]->doc;
! 13734: if (tmp == NULL) {
! 13735: tmp = xmlXPathCacheNewNodeSet(ctxt->context,
! 13736: ctxt->context->node);
! 13737: } else {
! 13738: xmlXPathNodeSetAddUnique(tmp->nodesetval,
! 13739: ctxt->context->node);
! 13740: }
! 13741: valuePush(ctxt, tmp);
! 13742: ctxt->context->contextSize = oldset->nodeNr;
! 13743: ctxt->context->proximityPosition = i + 1;
! 13744: /*
! 13745: * Evaluate the predicate against the context node.
! 13746: * Can/should we optimize position() predicates
! 13747: * here (e.g. "[1]")?
! 13748: */
! 13749: if (op->ch2 != -1)
! 13750: total +=
! 13751: xmlXPathCompOpEval(ctxt,
! 13752: &comp->steps[op->ch2]);
! 13753: if (ctxt->error != XPATH_EXPRESSION_OK) {
! 13754: xmlXPathFreeNodeSet(newset);
! 13755: xmlXPathFreeObject(obj);
! 13756: return(0);
! 13757: }
! 13758:
! 13759: /*
! 13760: * The result of the evaluation needs to be tested to
! 13761: * decide whether the filter succeeded or not
! 13762: */
! 13763: /*
! 13764: * OPTIMIZE TODO: Can we use
! 13765: * xmlXPathNodeSetAdd*Unique()* instead?
! 13766: */
! 13767: res = valuePop(ctxt);
! 13768: if (xmlXPathEvaluatePredicateResult(ctxt, res)) {
! 13769: xmlXPathNodeSetAdd(newset, oldset->nodeTab[i]);
! 13770: }
! 13771:
! 13772: /*
! 13773: * Cleanup
! 13774: */
! 13775: if (res != NULL) {
! 13776: xmlXPathReleaseObject(ctxt->context, res);
! 13777: }
! 13778: if (ctxt->value == tmp) {
! 13779: valuePop(ctxt);
! 13780: xmlXPathNodeSetClear(tmp->nodesetval, 1);
! 13781: /*
! 13782: * Don't free the temporary nodeset
! 13783: * in order to avoid massive recreation inside this
! 13784: * loop.
! 13785: */
! 13786: } else
! 13787: tmp = NULL;
! 13788: ctxt->context->node = NULL;
! 13789: }
! 13790: if (tmp != NULL)
! 13791: xmlXPathReleaseObject(ctxt->context, tmp);
! 13792: /*
! 13793: * The result is used as the new evaluation set.
! 13794: */
! 13795: xmlXPathReleaseObject(ctxt->context, obj);
! 13796: ctxt->context->node = NULL;
! 13797: ctxt->context->contextSize = -1;
! 13798: ctxt->context->proximityPosition = -1;
! 13799: /* may want to move this past the '}' later */
! 13800: ctxt->context->doc = oldDoc;
! 13801: valuePush(ctxt,
! 13802: xmlXPathCacheWrapNodeSet(ctxt->context, newset));
! 13803: }
! 13804: ctxt->context->node = oldnode;
! 13805: return (total);
! 13806: }
! 13807: case XPATH_OP_SORT:
! 13808: if (op->ch1 != -1)
! 13809: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
! 13810: CHECK_ERROR0;
! 13811: if ((ctxt->value != NULL) &&
! 13812: (ctxt->value->type == XPATH_NODESET) &&
! 13813: (ctxt->value->nodesetval != NULL) &&
! 13814: (ctxt->value->nodesetval->nodeNr > 1))
! 13815: {
! 13816: xmlXPathNodeSetSort(ctxt->value->nodesetval);
! 13817: }
! 13818: return (total);
! 13819: #ifdef LIBXML_XPTR_ENABLED
! 13820: case XPATH_OP_RANGETO:{
! 13821: xmlXPathObjectPtr range;
! 13822: xmlXPathObjectPtr res, obj;
! 13823: xmlXPathObjectPtr tmp;
! 13824: xmlLocationSetPtr newlocset = NULL;
! 13825: xmlLocationSetPtr oldlocset;
! 13826: xmlNodeSetPtr oldset;
! 13827: int i, j;
! 13828:
! 13829: if (op->ch1 != -1)
! 13830: total +=
! 13831: xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
! 13832: if (op->ch2 == -1)
! 13833: return (total);
! 13834:
! 13835: if (ctxt->value->type == XPATH_LOCATIONSET) {
! 13836: /*
! 13837: * Extract the old locset, and then evaluate the result of the
! 13838: * expression for all the element in the locset. use it to grow
! 13839: * up a new locset.
! 13840: */
! 13841: CHECK_TYPE0(XPATH_LOCATIONSET);
! 13842: obj = valuePop(ctxt);
! 13843: oldlocset = obj->user;
! 13844:
! 13845: if ((oldlocset == NULL) || (oldlocset->locNr == 0)) {
! 13846: ctxt->context->node = NULL;
! 13847: ctxt->context->contextSize = 0;
! 13848: ctxt->context->proximityPosition = 0;
! 13849: total += xmlXPathCompOpEval(ctxt,&comp->steps[op->ch2]);
! 13850: res = valuePop(ctxt);
! 13851: if (res != NULL) {
! 13852: xmlXPathReleaseObject(ctxt->context, res);
! 13853: }
! 13854: valuePush(ctxt, obj);
! 13855: CHECK_ERROR0;
! 13856: return (total);
! 13857: }
! 13858: newlocset = xmlXPtrLocationSetCreate(NULL);
! 13859:
! 13860: for (i = 0; i < oldlocset->locNr; i++) {
! 13861: /*
! 13862: * Run the evaluation with a node list made of a
! 13863: * single item in the nodelocset.
! 13864: */
! 13865: ctxt->context->node = oldlocset->locTab[i]->user;
! 13866: ctxt->context->contextSize = oldlocset->locNr;
! 13867: ctxt->context->proximityPosition = i + 1;
! 13868: tmp = xmlXPathCacheNewNodeSet(ctxt->context,
! 13869: ctxt->context->node);
! 13870: valuePush(ctxt, tmp);
! 13871:
! 13872: if (op->ch2 != -1)
! 13873: total +=
! 13874: xmlXPathCompOpEval(ctxt,
! 13875: &comp->steps[op->ch2]);
! 13876: if (ctxt->error != XPATH_EXPRESSION_OK) {
! 13877: xmlXPathFreeObject(obj);
! 13878: return(0);
! 13879: }
! 13880:
! 13881: res = valuePop(ctxt);
! 13882: if (res->type == XPATH_LOCATIONSET) {
! 13883: xmlLocationSetPtr rloc =
! 13884: (xmlLocationSetPtr)res->user;
! 13885: for (j=0; j<rloc->locNr; j++) {
! 13886: range = xmlXPtrNewRange(
! 13887: oldlocset->locTab[i]->user,
! 13888: oldlocset->locTab[i]->index,
! 13889: rloc->locTab[j]->user2,
! 13890: rloc->locTab[j]->index2);
! 13891: if (range != NULL) {
! 13892: xmlXPtrLocationSetAdd(newlocset, range);
! 13893: }
! 13894: }
! 13895: } else {
! 13896: range = xmlXPtrNewRangeNodeObject(
! 13897: (xmlNodePtr)oldlocset->locTab[i]->user, res);
! 13898: if (range != NULL) {
! 13899: xmlXPtrLocationSetAdd(newlocset,range);
! 13900: }
! 13901: }
! 13902:
! 13903: /*
! 13904: * Cleanup
! 13905: */
! 13906: if (res != NULL) {
! 13907: xmlXPathReleaseObject(ctxt->context, res);
! 13908: }
! 13909: if (ctxt->value == tmp) {
! 13910: res = valuePop(ctxt);
! 13911: xmlXPathReleaseObject(ctxt->context, res);
! 13912: }
! 13913:
! 13914: ctxt->context->node = NULL;
! 13915: }
! 13916: } else { /* Not a location set */
! 13917: CHECK_TYPE0(XPATH_NODESET);
! 13918: obj = valuePop(ctxt);
! 13919: oldset = obj->nodesetval;
! 13920: ctxt->context->node = NULL;
! 13921:
! 13922: newlocset = xmlXPtrLocationSetCreate(NULL);
! 13923:
! 13924: if (oldset != NULL) {
! 13925: for (i = 0; i < oldset->nodeNr; i++) {
! 13926: /*
! 13927: * Run the evaluation with a node list made of a single item
! 13928: * in the nodeset.
! 13929: */
! 13930: ctxt->context->node = oldset->nodeTab[i];
! 13931: /*
! 13932: * OPTIMIZE TODO: Avoid recreation for every iteration.
! 13933: */
! 13934: tmp = xmlXPathCacheNewNodeSet(ctxt->context,
! 13935: ctxt->context->node);
! 13936: valuePush(ctxt, tmp);
! 13937:
! 13938: if (op->ch2 != -1)
! 13939: total +=
! 13940: xmlXPathCompOpEval(ctxt,
! 13941: &comp->steps[op->ch2]);
! 13942: if (ctxt->error != XPATH_EXPRESSION_OK) {
! 13943: xmlXPathFreeObject(obj);
! 13944: return(0);
! 13945: }
! 13946:
! 13947: res = valuePop(ctxt);
! 13948: range =
! 13949: xmlXPtrNewRangeNodeObject(oldset->nodeTab[i],
! 13950: res);
! 13951: if (range != NULL) {
! 13952: xmlXPtrLocationSetAdd(newlocset, range);
! 13953: }
! 13954:
! 13955: /*
! 13956: * Cleanup
! 13957: */
! 13958: if (res != NULL) {
! 13959: xmlXPathReleaseObject(ctxt->context, res);
! 13960: }
! 13961: if (ctxt->value == tmp) {
! 13962: res = valuePop(ctxt);
! 13963: xmlXPathReleaseObject(ctxt->context, res);
! 13964: }
! 13965:
! 13966: ctxt->context->node = NULL;
! 13967: }
! 13968: }
! 13969: }
! 13970:
! 13971: /*
! 13972: * The result is used as the new evaluation set.
! 13973: */
! 13974: xmlXPathReleaseObject(ctxt->context, obj);
! 13975: ctxt->context->node = NULL;
! 13976: ctxt->context->contextSize = -1;
! 13977: ctxt->context->proximityPosition = -1;
! 13978: valuePush(ctxt, xmlXPtrWrapLocationSet(newlocset));
! 13979: return (total);
! 13980: }
! 13981: #endif /* LIBXML_XPTR_ENABLED */
! 13982: }
! 13983: xmlGenericError(xmlGenericErrorContext,
! 13984: "XPath: unknown precompiled operation %d\n", op->op);
! 13985: return (total);
! 13986: }
! 13987:
! 13988: /**
! 13989: * xmlXPathCompOpEvalToBoolean:
! 13990: * @ctxt: the XPath parser context
! 13991: *
! 13992: * Evaluates if the expression evaluates to true.
! 13993: *
! 13994: * Returns 1 if true, 0 if false and -1 on API or internal errors.
! 13995: */
! 13996: static int
! 13997: xmlXPathCompOpEvalToBoolean(xmlXPathParserContextPtr ctxt,
! 13998: xmlXPathStepOpPtr op,
! 13999: int isPredicate)
! 14000: {
! 14001: xmlXPathObjectPtr resObj = NULL;
! 14002:
! 14003: start:
! 14004: /* comp = ctxt->comp; */
! 14005: switch (op->op) {
! 14006: case XPATH_OP_END:
! 14007: return (0);
! 14008: case XPATH_OP_VALUE:
! 14009: resObj = (xmlXPathObjectPtr) op->value4;
! 14010: if (isPredicate)
! 14011: return(xmlXPathEvaluatePredicateResult(ctxt, resObj));
! 14012: return(xmlXPathCastToBoolean(resObj));
! 14013: case XPATH_OP_SORT:
! 14014: /*
! 14015: * We don't need sorting for boolean results. Skip this one.
! 14016: */
! 14017: if (op->ch1 != -1) {
! 14018: op = &ctxt->comp->steps[op->ch1];
! 14019: goto start;
! 14020: }
! 14021: return(0);
! 14022: case XPATH_OP_COLLECT:
! 14023: if (op->ch1 == -1)
! 14024: return(0);
! 14025:
! 14026: xmlXPathCompOpEval(ctxt, &ctxt->comp->steps[op->ch1]);
! 14027: if (ctxt->error != XPATH_EXPRESSION_OK)
! 14028: return(-1);
! 14029:
! 14030: xmlXPathNodeCollectAndTest(ctxt, op, NULL, NULL, 1);
! 14031: if (ctxt->error != XPATH_EXPRESSION_OK)
! 14032: return(-1);
! 14033:
! 14034: resObj = valuePop(ctxt);
! 14035: if (resObj == NULL)
! 14036: return(-1);
! 14037: break;
! 14038: default:
! 14039: /*
! 14040: * Fallback to call xmlXPathCompOpEval().
! 14041: */
! 14042: xmlXPathCompOpEval(ctxt, op);
! 14043: if (ctxt->error != XPATH_EXPRESSION_OK)
! 14044: return(-1);
! 14045:
! 14046: resObj = valuePop(ctxt);
! 14047: if (resObj == NULL)
! 14048: return(-1);
! 14049: break;
! 14050: }
! 14051:
! 14052: if (resObj) {
! 14053: int res;
! 14054:
! 14055: if (resObj->type == XPATH_BOOLEAN) {
! 14056: res = resObj->boolval;
! 14057: } else if (isPredicate) {
! 14058: /*
! 14059: * For predicates a result of type "number" is handled
! 14060: * differently:
! 14061: * SPEC XPath 1.0:
! 14062: * "If the result is a number, the result will be converted
! 14063: * to true if the number is equal to the context position
! 14064: * and will be converted to false otherwise;"
! 14065: */
! 14066: res = xmlXPathEvaluatePredicateResult(ctxt, resObj);
! 14067: } else {
! 14068: res = xmlXPathCastToBoolean(resObj);
! 14069: }
! 14070: xmlXPathReleaseObject(ctxt->context, resObj);
! 14071: return(res);
! 14072: }
! 14073:
! 14074: return(0);
! 14075: }
! 14076:
! 14077: #ifdef XPATH_STREAMING
! 14078: /**
! 14079: * xmlXPathRunStreamEval:
! 14080: * @ctxt: the XPath parser context with the compiled expression
! 14081: *
! 14082: * Evaluate the Precompiled Streamable XPath expression in the given context.
! 14083: */
! 14084: static int
! 14085: xmlXPathRunStreamEval(xmlXPathContextPtr ctxt, xmlPatternPtr comp,
! 14086: xmlXPathObjectPtr *resultSeq, int toBool)
! 14087: {
! 14088: int max_depth, min_depth;
! 14089: int from_root;
! 14090: int ret, depth;
! 14091: int eval_all_nodes;
! 14092: xmlNodePtr cur = NULL, limit = NULL;
! 14093: xmlStreamCtxtPtr patstream = NULL;
! 14094:
! 14095: int nb_nodes = 0;
! 14096:
! 14097: if ((ctxt == NULL) || (comp == NULL))
! 14098: return(-1);
! 14099: max_depth = xmlPatternMaxDepth(comp);
! 14100: if (max_depth == -1)
! 14101: return(-1);
! 14102: if (max_depth == -2)
! 14103: max_depth = 10000;
! 14104: min_depth = xmlPatternMinDepth(comp);
! 14105: if (min_depth == -1)
! 14106: return(-1);
! 14107: from_root = xmlPatternFromRoot(comp);
! 14108: if (from_root < 0)
! 14109: return(-1);
! 14110: #if 0
! 14111: printf("stream eval: depth %d from root %d\n", max_depth, from_root);
! 14112: #endif
! 14113:
! 14114: if (! toBool) {
! 14115: if (resultSeq == NULL)
! 14116: return(-1);
! 14117: *resultSeq = xmlXPathCacheNewNodeSet(ctxt, NULL);
! 14118: if (*resultSeq == NULL)
! 14119: return(-1);
! 14120: }
! 14121:
! 14122: /*
! 14123: * handle the special cases of "/" amd "." being matched
! 14124: */
! 14125: if (min_depth == 0) {
! 14126: if (from_root) {
! 14127: /* Select "/" */
! 14128: if (toBool)
! 14129: return(1);
! 14130: xmlXPathNodeSetAddUnique((*resultSeq)->nodesetval,
! 14131: (xmlNodePtr) ctxt->doc);
! 14132: } else {
! 14133: /* Select "self::node()" */
! 14134: if (toBool)
! 14135: return(1);
! 14136: xmlXPathNodeSetAddUnique((*resultSeq)->nodesetval, ctxt->node);
! 14137: }
! 14138: }
! 14139: if (max_depth == 0) {
! 14140: return(0);
! 14141: }
! 14142:
! 14143: if (from_root) {
! 14144: cur = (xmlNodePtr)ctxt->doc;
! 14145: } else if (ctxt->node != NULL) {
! 14146: switch (ctxt->node->type) {
! 14147: case XML_ELEMENT_NODE:
! 14148: case XML_DOCUMENT_NODE:
! 14149: case XML_DOCUMENT_FRAG_NODE:
! 14150: case XML_HTML_DOCUMENT_NODE:
! 14151: #ifdef LIBXML_DOCB_ENABLED
! 14152: case XML_DOCB_DOCUMENT_NODE:
! 14153: #endif
! 14154: cur = ctxt->node;
! 14155: break;
! 14156: case XML_ATTRIBUTE_NODE:
! 14157: case XML_TEXT_NODE:
! 14158: case XML_CDATA_SECTION_NODE:
! 14159: case XML_ENTITY_REF_NODE:
! 14160: case XML_ENTITY_NODE:
! 14161: case XML_PI_NODE:
! 14162: case XML_COMMENT_NODE:
! 14163: case XML_NOTATION_NODE:
! 14164: case XML_DTD_NODE:
! 14165: case XML_DOCUMENT_TYPE_NODE:
! 14166: case XML_ELEMENT_DECL:
! 14167: case XML_ATTRIBUTE_DECL:
! 14168: case XML_ENTITY_DECL:
! 14169: case XML_NAMESPACE_DECL:
! 14170: case XML_XINCLUDE_START:
! 14171: case XML_XINCLUDE_END:
! 14172: break;
! 14173: }
! 14174: limit = cur;
! 14175: }
! 14176: if (cur == NULL) {
! 14177: return(0);
! 14178: }
! 14179:
! 14180: patstream = xmlPatternGetStreamCtxt(comp);
! 14181: if (patstream == NULL) {
! 14182: /*
! 14183: * QUESTION TODO: Is this an error?
! 14184: */
! 14185: return(0);
! 14186: }
! 14187:
! 14188: eval_all_nodes = xmlStreamWantsAnyNode(patstream);
! 14189:
! 14190: if (from_root) {
! 14191: ret = xmlStreamPush(patstream, NULL, NULL);
! 14192: if (ret < 0) {
! 14193: } else if (ret == 1) {
! 14194: if (toBool)
! 14195: goto return_1;
! 14196: xmlXPathNodeSetAddUnique((*resultSeq)->nodesetval, cur);
! 14197: }
! 14198: }
! 14199: depth = 0;
! 14200: goto scan_children;
! 14201: next_node:
! 14202: do {
! 14203: nb_nodes++;
! 14204:
! 14205: switch (cur->type) {
! 14206: case XML_ELEMENT_NODE:
! 14207: case XML_TEXT_NODE:
! 14208: case XML_CDATA_SECTION_NODE:
! 14209: case XML_COMMENT_NODE:
! 14210: case XML_PI_NODE:
! 14211: if (cur->type == XML_ELEMENT_NODE) {
! 14212: ret = xmlStreamPush(patstream, cur->name,
! 14213: (cur->ns ? cur->ns->href : NULL));
! 14214: } else if (eval_all_nodes)
! 14215: ret = xmlStreamPushNode(patstream, NULL, NULL, cur->type);
! 14216: else
! 14217: break;
! 14218:
! 14219: if (ret < 0) {
! 14220: /* NOP. */
! 14221: } else if (ret == 1) {
! 14222: if (toBool)
! 14223: goto return_1;
! 14224: xmlXPathNodeSetAddUnique((*resultSeq)->nodesetval, cur);
! 14225: }
! 14226: if ((cur->children == NULL) || (depth >= max_depth)) {
! 14227: ret = xmlStreamPop(patstream);
! 14228: while (cur->next != NULL) {
! 14229: cur = cur->next;
! 14230: if ((cur->type != XML_ENTITY_DECL) &&
! 14231: (cur->type != XML_DTD_NODE))
! 14232: goto next_node;
! 14233: }
! 14234: }
! 14235: default:
! 14236: break;
! 14237: }
! 14238:
! 14239: scan_children:
! 14240: if ((cur->children != NULL) && (depth < max_depth)) {
! 14241: /*
! 14242: * Do not descend on entities declarations
! 14243: */
! 14244: if (cur->children->type != XML_ENTITY_DECL) {
! 14245: cur = cur->children;
! 14246: depth++;
! 14247: /*
! 14248: * Skip DTDs
! 14249: */
! 14250: if (cur->type != XML_DTD_NODE)
! 14251: continue;
! 14252: }
! 14253: }
! 14254:
! 14255: if (cur == limit)
! 14256: break;
! 14257:
! 14258: while (cur->next != NULL) {
! 14259: cur = cur->next;
! 14260: if ((cur->type != XML_ENTITY_DECL) &&
! 14261: (cur->type != XML_DTD_NODE))
! 14262: goto next_node;
! 14263: }
! 14264:
! 14265: do {
! 14266: cur = cur->parent;
! 14267: depth--;
! 14268: if ((cur == NULL) || (cur == limit))
! 14269: goto done;
! 14270: if (cur->type == XML_ELEMENT_NODE) {
! 14271: ret = xmlStreamPop(patstream);
! 14272: } else if ((eval_all_nodes) &&
! 14273: ((cur->type == XML_TEXT_NODE) ||
! 14274: (cur->type == XML_CDATA_SECTION_NODE) ||
! 14275: (cur->type == XML_COMMENT_NODE) ||
! 14276: (cur->type == XML_PI_NODE)))
! 14277: {
! 14278: ret = xmlStreamPop(patstream);
! 14279: }
! 14280: if (cur->next != NULL) {
! 14281: cur = cur->next;
! 14282: break;
! 14283: }
! 14284: } while (cur != NULL);
! 14285:
! 14286: } while ((cur != NULL) && (depth >= 0));
! 14287:
! 14288: done:
! 14289:
! 14290: #if 0
! 14291: printf("stream eval: checked %d nodes selected %d\n",
! 14292: nb_nodes, retObj->nodesetval->nodeNr);
! 14293: #endif
! 14294:
! 14295: if (patstream)
! 14296: xmlFreeStreamCtxt(patstream);
! 14297: return(0);
! 14298:
! 14299: return_1:
! 14300: if (patstream)
! 14301: xmlFreeStreamCtxt(patstream);
! 14302: return(1);
! 14303: }
! 14304: #endif /* XPATH_STREAMING */
! 14305:
! 14306: /**
! 14307: * xmlXPathRunEval:
! 14308: * @ctxt: the XPath parser context with the compiled expression
! 14309: * @toBool: evaluate to a boolean result
! 14310: *
! 14311: * Evaluate the Precompiled XPath expression in the given context.
! 14312: */
! 14313: static int
! 14314: xmlXPathRunEval(xmlXPathParserContextPtr ctxt, int toBool)
! 14315: {
! 14316: xmlXPathCompExprPtr comp;
! 14317:
! 14318: if ((ctxt == NULL) || (ctxt->comp == NULL))
! 14319: return(-1);
! 14320:
! 14321: if (ctxt->valueTab == NULL) {
! 14322: /* Allocate the value stack */
! 14323: ctxt->valueTab = (xmlXPathObjectPtr *)
! 14324: xmlMalloc(10 * sizeof(xmlXPathObjectPtr));
! 14325: if (ctxt->valueTab == NULL) {
! 14326: xmlXPathPErrMemory(ctxt, "creating evaluation context\n");
! 14327: xmlFree(ctxt);
! 14328: }
! 14329: ctxt->valueNr = 0;
! 14330: ctxt->valueMax = 10;
! 14331: ctxt->value = NULL;
! 14332: }
! 14333: #ifdef XPATH_STREAMING
! 14334: if (ctxt->comp->stream) {
! 14335: int res;
! 14336:
! 14337: if (toBool) {
! 14338: /*
! 14339: * Evaluation to boolean result.
! 14340: */
! 14341: res = xmlXPathRunStreamEval(ctxt->context,
! 14342: ctxt->comp->stream, NULL, 1);
! 14343: if (res != -1)
! 14344: return(res);
! 14345: } else {
! 14346: xmlXPathObjectPtr resObj = NULL;
! 14347:
! 14348: /*
! 14349: * Evaluation to a sequence.
! 14350: */
! 14351: res = xmlXPathRunStreamEval(ctxt->context,
! 14352: ctxt->comp->stream, &resObj, 0);
! 14353:
! 14354: if ((res != -1) && (resObj != NULL)) {
! 14355: valuePush(ctxt, resObj);
! 14356: return(0);
! 14357: }
! 14358: if (resObj != NULL)
! 14359: xmlXPathReleaseObject(ctxt->context, resObj);
! 14360: }
! 14361: /*
! 14362: * QUESTION TODO: This falls back to normal XPath evaluation
! 14363: * if res == -1. Is this intended?
! 14364: */
! 14365: }
! 14366: #endif
! 14367: comp = ctxt->comp;
! 14368: if (comp->last < 0) {
! 14369: xmlGenericError(xmlGenericErrorContext,
! 14370: "xmlXPathRunEval: last is less than zero\n");
! 14371: return(-1);
! 14372: }
! 14373: if (toBool)
! 14374: return(xmlXPathCompOpEvalToBoolean(ctxt,
! 14375: &comp->steps[comp->last], 0));
! 14376: else
! 14377: xmlXPathCompOpEval(ctxt, &comp->steps[comp->last]);
! 14378:
! 14379: return(0);
! 14380: }
! 14381:
! 14382: /************************************************************************
! 14383: * *
! 14384: * Public interfaces *
! 14385: * *
! 14386: ************************************************************************/
! 14387:
! 14388: /**
! 14389: * xmlXPathEvalPredicate:
! 14390: * @ctxt: the XPath context
! 14391: * @res: the Predicate Expression evaluation result
! 14392: *
! 14393: * Evaluate a predicate result for the current node.
! 14394: * A PredicateExpr is evaluated by evaluating the Expr and converting
! 14395: * the result to a boolean. If the result is a number, the result will
! 14396: * be converted to true if the number is equal to the position of the
! 14397: * context node in the context node list (as returned by the position
! 14398: * function) and will be converted to false otherwise; if the result
! 14399: * is not a number, then the result will be converted as if by a call
! 14400: * to the boolean function.
! 14401: *
! 14402: * Returns 1 if predicate is true, 0 otherwise
! 14403: */
! 14404: int
! 14405: xmlXPathEvalPredicate(xmlXPathContextPtr ctxt, xmlXPathObjectPtr res) {
! 14406: if ((ctxt == NULL) || (res == NULL)) return(0);
! 14407: switch (res->type) {
! 14408: case XPATH_BOOLEAN:
! 14409: return(res->boolval);
! 14410: case XPATH_NUMBER:
! 14411: return(res->floatval == ctxt->proximityPosition);
! 14412: case XPATH_NODESET:
! 14413: case XPATH_XSLT_TREE:
! 14414: if (res->nodesetval == NULL)
! 14415: return(0);
! 14416: return(res->nodesetval->nodeNr != 0);
! 14417: case XPATH_STRING:
! 14418: return((res->stringval != NULL) &&
! 14419: (xmlStrlen(res->stringval) != 0));
! 14420: default:
! 14421: STRANGE
! 14422: }
! 14423: return(0);
! 14424: }
! 14425:
! 14426: /**
! 14427: * xmlXPathEvaluatePredicateResult:
! 14428: * @ctxt: the XPath Parser context
! 14429: * @res: the Predicate Expression evaluation result
! 14430: *
! 14431: * Evaluate a predicate result for the current node.
! 14432: * A PredicateExpr is evaluated by evaluating the Expr and converting
! 14433: * the result to a boolean. If the result is a number, the result will
! 14434: * be converted to true if the number is equal to the position of the
! 14435: * context node in the context node list (as returned by the position
! 14436: * function) and will be converted to false otherwise; if the result
! 14437: * is not a number, then the result will be converted as if by a call
! 14438: * to the boolean function.
! 14439: *
! 14440: * Returns 1 if predicate is true, 0 otherwise
! 14441: */
! 14442: int
! 14443: xmlXPathEvaluatePredicateResult(xmlXPathParserContextPtr ctxt,
! 14444: xmlXPathObjectPtr res) {
! 14445: if ((ctxt == NULL) || (res == NULL)) return(0);
! 14446: switch (res->type) {
! 14447: case XPATH_BOOLEAN:
! 14448: return(res->boolval);
! 14449: case XPATH_NUMBER:
! 14450: #if defined(__BORLANDC__) || (defined(_MSC_VER) && (_MSC_VER == 1200))
! 14451: return((res->floatval == ctxt->context->proximityPosition) &&
! 14452: (!xmlXPathIsNaN(res->floatval))); /* MSC pbm Mark Vakoc !*/
! 14453: #else
! 14454: return(res->floatval == ctxt->context->proximityPosition);
! 14455: #endif
! 14456: case XPATH_NODESET:
! 14457: case XPATH_XSLT_TREE:
! 14458: if (res->nodesetval == NULL)
! 14459: return(0);
! 14460: return(res->nodesetval->nodeNr != 0);
! 14461: case XPATH_STRING:
! 14462: return((res->stringval != NULL) && (res->stringval[0] != 0));
! 14463: #ifdef LIBXML_XPTR_ENABLED
! 14464: case XPATH_LOCATIONSET:{
! 14465: xmlLocationSetPtr ptr = res->user;
! 14466: if (ptr == NULL)
! 14467: return(0);
! 14468: return (ptr->locNr != 0);
! 14469: }
! 14470: #endif
! 14471: default:
! 14472: STRANGE
! 14473: }
! 14474: return(0);
! 14475: }
! 14476:
! 14477: #ifdef XPATH_STREAMING
! 14478: /**
! 14479: * xmlXPathTryStreamCompile:
! 14480: * @ctxt: an XPath context
! 14481: * @str: the XPath expression
! 14482: *
! 14483: * Try to compile the XPath expression as a streamable subset.
! 14484: *
! 14485: * Returns the compiled expression or NULL if failed to compile.
! 14486: */
! 14487: static xmlXPathCompExprPtr
! 14488: xmlXPathTryStreamCompile(xmlXPathContextPtr ctxt, const xmlChar *str) {
! 14489: /*
! 14490: * Optimization: use streaming patterns when the XPath expression can
! 14491: * be compiled to a stream lookup
! 14492: */
! 14493: xmlPatternPtr stream;
! 14494: xmlXPathCompExprPtr comp;
! 14495: xmlDictPtr dict = NULL;
! 14496: const xmlChar **namespaces = NULL;
! 14497: xmlNsPtr ns;
! 14498: int i, j;
! 14499:
! 14500: if ((!xmlStrchr(str, '[')) && (!xmlStrchr(str, '(')) &&
! 14501: (!xmlStrchr(str, '@'))) {
! 14502: const xmlChar *tmp;
! 14503:
! 14504: /*
! 14505: * We don't try to handle expressions using the verbose axis
! 14506: * specifiers ("::"), just the simplied form at this point.
! 14507: * Additionally, if there is no list of namespaces available and
! 14508: * there's a ":" in the expression, indicating a prefixed QName,
! 14509: * then we won't try to compile either. xmlPatterncompile() needs
! 14510: * to have a list of namespaces at compilation time in order to
! 14511: * compile prefixed name tests.
! 14512: */
! 14513: tmp = xmlStrchr(str, ':');
! 14514: if ((tmp != NULL) &&
! 14515: ((ctxt == NULL) || (ctxt->nsNr == 0) || (tmp[1] == ':')))
! 14516: return(NULL);
! 14517:
! 14518: if (ctxt != NULL) {
! 14519: dict = ctxt->dict;
! 14520: if (ctxt->nsNr > 0) {
! 14521: namespaces = xmlMalloc(2 * (ctxt->nsNr + 1) * sizeof(xmlChar*));
! 14522: if (namespaces == NULL) {
! 14523: xmlXPathErrMemory(ctxt, "allocating namespaces array\n");
! 14524: return(NULL);
! 14525: }
! 14526: for (i = 0, j = 0; (j < ctxt->nsNr); j++) {
! 14527: ns = ctxt->namespaces[j];
! 14528: namespaces[i++] = ns->href;
! 14529: namespaces[i++] = ns->prefix;
! 14530: }
! 14531: namespaces[i++] = NULL;
! 14532: namespaces[i] = NULL;
! 14533: }
! 14534: }
! 14535:
! 14536: stream = xmlPatterncompile(str, dict, XML_PATTERN_XPATH,
! 14537: &namespaces[0]);
! 14538: if (namespaces != NULL) {
! 14539: xmlFree((xmlChar **)namespaces);
! 14540: }
! 14541: if ((stream != NULL) && (xmlPatternStreamable(stream) == 1)) {
! 14542: comp = xmlXPathNewCompExpr();
! 14543: if (comp == NULL) {
! 14544: xmlXPathErrMemory(ctxt, "allocating streamable expression\n");
! 14545: return(NULL);
! 14546: }
! 14547: comp->stream = stream;
! 14548: comp->dict = dict;
! 14549: if (comp->dict)
! 14550: xmlDictReference(comp->dict);
! 14551: return(comp);
! 14552: }
! 14553: xmlFreePattern(stream);
! 14554: }
! 14555: return(NULL);
! 14556: }
! 14557: #endif /* XPATH_STREAMING */
! 14558:
! 14559: static int
! 14560: xmlXPathCanRewriteDosExpression(xmlChar *expr)
! 14561: {
! 14562: if (expr == NULL)
! 14563: return(0);
! 14564: do {
! 14565: if ((*expr == '/') && (*(++expr) == '/'))
! 14566: return(1);
! 14567: } while (*expr++);
! 14568: return(0);
! 14569: }
! 14570: static void
! 14571: xmlXPathRewriteDOSExpression(xmlXPathCompExprPtr comp, xmlXPathStepOpPtr op)
! 14572: {
! 14573: /*
! 14574: * Try to rewrite "descendant-or-self::node()/foo" to an optimized
! 14575: * internal representation.
! 14576: */
! 14577: if (op->ch1 != -1) {
! 14578: if ((op->op == XPATH_OP_COLLECT /* 11 */) &&
! 14579: ((xmlXPathAxisVal) op->value == AXIS_CHILD /* 4 */) &&
! 14580: ((xmlXPathTestVal) op->value2 == NODE_TEST_NAME /* 5 */) &&
! 14581: ((xmlXPathTypeVal) op->value3 == NODE_TYPE_NODE /* 0 */))
! 14582: {
! 14583: /*
! 14584: * This is a "child::foo"
! 14585: */
! 14586: xmlXPathStepOpPtr prevop = &comp->steps[op->ch1];
! 14587:
! 14588: if ((prevop->op == XPATH_OP_COLLECT /* 11 */) &&
! 14589: (prevop->ch1 != -1) &&
! 14590: ((xmlXPathAxisVal) prevop->value ==
! 14591: AXIS_DESCENDANT_OR_SELF) &&
! 14592: (prevop->ch2 == -1) &&
! 14593: ((xmlXPathTestVal) prevop->value2 == NODE_TEST_TYPE) &&
! 14594: ((xmlXPathTypeVal) prevop->value3 == NODE_TYPE_NODE) &&
! 14595: (comp->steps[prevop->ch1].op == XPATH_OP_ROOT))
! 14596: {
! 14597: /*
! 14598: * This is a "/descendant-or-self::node()" without predicates.
! 14599: * Eliminate it.
! 14600: */
! 14601: op->ch1 = prevop->ch1;
! 14602: op->rewriteType = XP_REWRITE_DOS_CHILD_ELEM;
! 14603: }
! 14604: }
! 14605: if (op->ch1 != -1)
! 14606: xmlXPathRewriteDOSExpression(comp, &comp->steps[op->ch1]);
! 14607: }
! 14608: if (op->ch2 != -1)
! 14609: xmlXPathRewriteDOSExpression(comp, &comp->steps[op->ch2]);
! 14610: }
! 14611:
! 14612: /**
! 14613: * xmlXPathCtxtCompile:
! 14614: * @ctxt: an XPath context
! 14615: * @str: the XPath expression
! 14616: *
! 14617: * Compile an XPath expression
! 14618: *
! 14619: * Returns the xmlXPathCompExprPtr resulting from the compilation or NULL.
! 14620: * the caller has to free the object.
! 14621: */
! 14622: xmlXPathCompExprPtr
! 14623: xmlXPathCtxtCompile(xmlXPathContextPtr ctxt, const xmlChar *str) {
! 14624: xmlXPathParserContextPtr pctxt;
! 14625: xmlXPathCompExprPtr comp;
! 14626:
! 14627: #ifdef XPATH_STREAMING
! 14628: comp = xmlXPathTryStreamCompile(ctxt, str);
! 14629: if (comp != NULL)
! 14630: return(comp);
! 14631: #endif
! 14632:
! 14633: xmlXPathInit();
! 14634:
! 14635: pctxt = xmlXPathNewParserContext(str, ctxt);
! 14636: if (pctxt == NULL)
! 14637: return NULL;
! 14638: xmlXPathCompileExpr(pctxt, 1);
! 14639:
! 14640: if( pctxt->error != XPATH_EXPRESSION_OK )
! 14641: {
! 14642: xmlXPathFreeParserContext(pctxt);
! 14643: return(NULL);
! 14644: }
! 14645:
! 14646: if (*pctxt->cur != 0) {
! 14647: /*
! 14648: * aleksey: in some cases this line prints *second* error message
! 14649: * (see bug #78858) and probably this should be fixed.
! 14650: * However, we are not sure that all error messages are printed
! 14651: * out in other places. It's not critical so we leave it as-is for now
! 14652: */
! 14653: xmlXPatherror(pctxt, __FILE__, __LINE__, XPATH_EXPR_ERROR);
! 14654: comp = NULL;
! 14655: } else {
! 14656: comp = pctxt->comp;
! 14657: pctxt->comp = NULL;
! 14658: }
! 14659: xmlXPathFreeParserContext(pctxt);
! 14660:
! 14661: if (comp != NULL) {
! 14662: comp->expr = xmlStrdup(str);
! 14663: #ifdef DEBUG_EVAL_COUNTS
! 14664: comp->string = xmlStrdup(str);
! 14665: comp->nb = 0;
! 14666: #endif
! 14667: if ((comp->expr != NULL) &&
! 14668: (comp->nbStep > 2) &&
! 14669: (comp->last >= 0) &&
! 14670: (xmlXPathCanRewriteDosExpression(comp->expr) == 1))
! 14671: {
! 14672: xmlXPathRewriteDOSExpression(comp, &comp->steps[comp->last]);
! 14673: }
! 14674: }
! 14675: return(comp);
! 14676: }
! 14677:
! 14678: /**
! 14679: * xmlXPathCompile:
! 14680: * @str: the XPath expression
! 14681: *
! 14682: * Compile an XPath expression
! 14683: *
! 14684: * Returns the xmlXPathCompExprPtr resulting from the compilation or NULL.
! 14685: * the caller has to free the object.
! 14686: */
! 14687: xmlXPathCompExprPtr
! 14688: xmlXPathCompile(const xmlChar *str) {
! 14689: return(xmlXPathCtxtCompile(NULL, str));
! 14690: }
! 14691:
! 14692: /**
! 14693: * xmlXPathCompiledEvalInternal:
! 14694: * @comp: the compiled XPath expression
! 14695: * @ctxt: the XPath context
! 14696: * @resObj: the resulting XPath object or NULL
! 14697: * @toBool: 1 if only a boolean result is requested
! 14698: *
! 14699: * Evaluate the Precompiled XPath expression in the given context.
! 14700: * The caller has to free @resObj.
! 14701: *
! 14702: * Returns the xmlXPathObjectPtr resulting from the evaluation or NULL.
! 14703: * the caller has to free the object.
! 14704: */
! 14705: static int
! 14706: xmlXPathCompiledEvalInternal(xmlXPathCompExprPtr comp,
! 14707: xmlXPathContextPtr ctxt,
! 14708: xmlXPathObjectPtr *resObj,
! 14709: int toBool)
! 14710: {
! 14711: xmlXPathParserContextPtr pctxt;
! 14712: #ifndef LIBXML_THREAD_ENABLED
! 14713: static int reentance = 0;
! 14714: #endif
! 14715: int res;
! 14716:
! 14717: CHECK_CTXT_NEG(ctxt)
! 14718:
! 14719: if (comp == NULL)
! 14720: return(-1);
! 14721: xmlXPathInit();
! 14722:
! 14723: #ifndef LIBXML_THREAD_ENABLED
! 14724: reentance++;
! 14725: if (reentance > 1)
! 14726: xmlXPathDisableOptimizer = 1;
! 14727: #endif
! 14728:
! 14729: #ifdef DEBUG_EVAL_COUNTS
! 14730: comp->nb++;
! 14731: if ((comp->string != NULL) && (comp->nb > 100)) {
! 14732: fprintf(stderr, "100 x %s\n", comp->string);
! 14733: comp->nb = 0;
! 14734: }
! 14735: #endif
! 14736: pctxt = xmlXPathCompParserContext(comp, ctxt);
! 14737: res = xmlXPathRunEval(pctxt, toBool);
! 14738:
! 14739: if (resObj) {
! 14740: if (pctxt->value == NULL) {
! 14741: xmlGenericError(xmlGenericErrorContext,
! 14742: "xmlXPathCompiledEval: evaluation failed\n");
! 14743: *resObj = NULL;
! 14744: } else {
! 14745: *resObj = valuePop(pctxt);
! 14746: }
! 14747: }
! 14748:
! 14749: /*
! 14750: * Pop all remaining objects from the stack.
! 14751: */
! 14752: if (pctxt->valueNr > 0) {
! 14753: xmlXPathObjectPtr tmp;
! 14754: int stack = 0;
! 14755:
! 14756: do {
! 14757: tmp = valuePop(pctxt);
! 14758: if (tmp != NULL) {
! 14759: stack++;
! 14760: xmlXPathReleaseObject(ctxt, tmp);
! 14761: }
! 14762: } while (tmp != NULL);
! 14763: if ((stack != 0) &&
! 14764: ((toBool) || ((resObj) && (*resObj))))
! 14765: {
! 14766: xmlGenericError(xmlGenericErrorContext,
! 14767: "xmlXPathCompiledEval: %d objects left on the stack.\n",
! 14768: stack);
! 14769: }
! 14770: }
! 14771:
! 14772: if ((pctxt->error != XPATH_EXPRESSION_OK) && (resObj) && (*resObj)) {
! 14773: xmlXPathFreeObject(*resObj);
! 14774: *resObj = NULL;
! 14775: }
! 14776: pctxt->comp = NULL;
! 14777: xmlXPathFreeParserContext(pctxt);
! 14778: #ifndef LIBXML_THREAD_ENABLED
! 14779: reentance--;
! 14780: #endif
! 14781:
! 14782: return(res);
! 14783: }
! 14784:
! 14785: /**
! 14786: * xmlXPathCompiledEval:
! 14787: * @comp: the compiled XPath expression
! 14788: * @ctx: the XPath context
! 14789: *
! 14790: * Evaluate the Precompiled XPath expression in the given context.
! 14791: *
! 14792: * Returns the xmlXPathObjectPtr resulting from the evaluation or NULL.
! 14793: * the caller has to free the object.
! 14794: */
! 14795: xmlXPathObjectPtr
! 14796: xmlXPathCompiledEval(xmlXPathCompExprPtr comp, xmlXPathContextPtr ctx)
! 14797: {
! 14798: xmlXPathObjectPtr res = NULL;
! 14799:
! 14800: xmlXPathCompiledEvalInternal(comp, ctx, &res, 0);
! 14801: return(res);
! 14802: }
! 14803:
! 14804: /**
! 14805: * xmlXPathCompiledEvalToBoolean:
! 14806: * @comp: the compiled XPath expression
! 14807: * @ctxt: the XPath context
! 14808: *
! 14809: * Applies the XPath boolean() function on the result of the given
! 14810: * compiled expression.
! 14811: *
! 14812: * Returns 1 if the expression evaluated to true, 0 if to false and
! 14813: * -1 in API and internal errors.
! 14814: */
! 14815: int
! 14816: xmlXPathCompiledEvalToBoolean(xmlXPathCompExprPtr comp,
! 14817: xmlXPathContextPtr ctxt)
! 14818: {
! 14819: return(xmlXPathCompiledEvalInternal(comp, ctxt, NULL, 1));
! 14820: }
! 14821:
! 14822: /**
! 14823: * xmlXPathEvalExpr:
! 14824: * @ctxt: the XPath Parser context
! 14825: *
! 14826: * Parse and evaluate an XPath expression in the given context,
! 14827: * then push the result on the context stack
! 14828: */
! 14829: void
! 14830: xmlXPathEvalExpr(xmlXPathParserContextPtr ctxt) {
! 14831: #ifdef XPATH_STREAMING
! 14832: xmlXPathCompExprPtr comp;
! 14833: #endif
! 14834:
! 14835: if (ctxt == NULL) return;
! 14836:
! 14837: #ifdef XPATH_STREAMING
! 14838: comp = xmlXPathTryStreamCompile(ctxt->context, ctxt->base);
! 14839: if (comp != NULL) {
! 14840: if (ctxt->comp != NULL)
! 14841: xmlXPathFreeCompExpr(ctxt->comp);
! 14842: ctxt->comp = comp;
! 14843: if (ctxt->cur != NULL)
! 14844: while (*ctxt->cur != 0) ctxt->cur++;
! 14845: } else
! 14846: #endif
! 14847: {
! 14848: xmlXPathCompileExpr(ctxt, 1);
! 14849: /*
! 14850: * In this scenario the expression string will sit in ctxt->base.
! 14851: */
! 14852: if ((ctxt->error == XPATH_EXPRESSION_OK) &&
! 14853: (ctxt->comp != NULL) &&
! 14854: (ctxt->base != NULL) &&
! 14855: (ctxt->comp->nbStep > 2) &&
! 14856: (ctxt->comp->last >= 0) &&
! 14857: (xmlXPathCanRewriteDosExpression((xmlChar *) ctxt->base) == 1))
! 14858: {
! 14859: xmlXPathRewriteDOSExpression(ctxt->comp,
! 14860: &ctxt->comp->steps[ctxt->comp->last]);
! 14861: }
! 14862: }
! 14863: CHECK_ERROR;
! 14864: xmlXPathRunEval(ctxt, 0);
! 14865: }
! 14866:
! 14867: /**
! 14868: * xmlXPathEval:
! 14869: * @str: the XPath expression
! 14870: * @ctx: the XPath context
! 14871: *
! 14872: * Evaluate the XPath Location Path in the given context.
! 14873: *
! 14874: * Returns the xmlXPathObjectPtr resulting from the evaluation or NULL.
! 14875: * the caller has to free the object.
! 14876: */
! 14877: xmlXPathObjectPtr
! 14878: xmlXPathEval(const xmlChar *str, xmlXPathContextPtr ctx) {
! 14879: xmlXPathParserContextPtr ctxt;
! 14880: xmlXPathObjectPtr res, tmp, init = NULL;
! 14881: int stack = 0;
! 14882:
! 14883: CHECK_CTXT(ctx)
! 14884:
! 14885: xmlXPathInit();
! 14886:
! 14887: ctxt = xmlXPathNewParserContext(str, ctx);
! 14888: if (ctxt == NULL)
! 14889: return NULL;
! 14890: xmlXPathEvalExpr(ctxt);
! 14891:
! 14892: if (ctxt->value == NULL) {
! 14893: xmlGenericError(xmlGenericErrorContext,
! 14894: "xmlXPathEval: evaluation failed\n");
! 14895: res = NULL;
! 14896: } else if ((*ctxt->cur != 0) && (ctxt->comp != NULL)
! 14897: #ifdef XPATH_STREAMING
! 14898: && (ctxt->comp->stream == NULL)
! 14899: #endif
! 14900: ) {
! 14901: xmlXPatherror(ctxt, __FILE__, __LINE__, XPATH_EXPR_ERROR);
! 14902: res = NULL;
! 14903: } else {
! 14904: res = valuePop(ctxt);
! 14905: }
! 14906:
! 14907: do {
! 14908: tmp = valuePop(ctxt);
! 14909: if (tmp != NULL) {
! 14910: if (tmp != init)
! 14911: stack++;
! 14912: xmlXPathReleaseObject(ctx, tmp);
! 14913: }
! 14914: } while (tmp != NULL);
! 14915: if ((stack != 0) && (res != NULL)) {
! 14916: xmlGenericError(xmlGenericErrorContext,
! 14917: "xmlXPathEval: %d object left on the stack\n",
! 14918: stack);
! 14919: }
! 14920: if (ctxt->error != XPATH_EXPRESSION_OK) {
! 14921: xmlXPathFreeObject(res);
! 14922: res = NULL;
! 14923: }
! 14924:
! 14925: xmlXPathFreeParserContext(ctxt);
! 14926: return(res);
! 14927: }
! 14928:
! 14929: /**
! 14930: * xmlXPathEvalExpression:
! 14931: * @str: the XPath expression
! 14932: * @ctxt: the XPath context
! 14933: *
! 14934: * Evaluate the XPath expression in the given context.
! 14935: *
! 14936: * Returns the xmlXPathObjectPtr resulting from the evaluation or NULL.
! 14937: * the caller has to free the object.
! 14938: */
! 14939: xmlXPathObjectPtr
! 14940: xmlXPathEvalExpression(const xmlChar *str, xmlXPathContextPtr ctxt) {
! 14941: xmlXPathParserContextPtr pctxt;
! 14942: xmlXPathObjectPtr res, tmp;
! 14943: int stack = 0;
! 14944:
! 14945: CHECK_CTXT(ctxt)
! 14946:
! 14947: xmlXPathInit();
! 14948:
! 14949: pctxt = xmlXPathNewParserContext(str, ctxt);
! 14950: if (pctxt == NULL)
! 14951: return NULL;
! 14952: xmlXPathEvalExpr(pctxt);
! 14953:
! 14954: if ((*pctxt->cur != 0) || (pctxt->error != XPATH_EXPRESSION_OK)) {
! 14955: xmlXPatherror(pctxt, __FILE__, __LINE__, XPATH_EXPR_ERROR);
! 14956: res = NULL;
! 14957: } else {
! 14958: res = valuePop(pctxt);
! 14959: }
! 14960: do {
! 14961: tmp = valuePop(pctxt);
! 14962: if (tmp != NULL) {
! 14963: xmlXPathReleaseObject(ctxt, tmp);
! 14964: stack++;
! 14965: }
! 14966: } while (tmp != NULL);
! 14967: if ((stack != 0) && (res != NULL)) {
! 14968: xmlGenericError(xmlGenericErrorContext,
! 14969: "xmlXPathEvalExpression: %d object left on the stack\n",
! 14970: stack);
! 14971: }
! 14972: xmlXPathFreeParserContext(pctxt);
! 14973: return(res);
! 14974: }
! 14975:
! 14976: /************************************************************************
! 14977: * *
! 14978: * Extra functions not pertaining to the XPath spec *
! 14979: * *
! 14980: ************************************************************************/
! 14981: /**
! 14982: * xmlXPathEscapeUriFunction:
! 14983: * @ctxt: the XPath Parser context
! 14984: * @nargs: the number of arguments
! 14985: *
! 14986: * Implement the escape-uri() XPath function
! 14987: * string escape-uri(string $str, bool $escape-reserved)
! 14988: *
! 14989: * This function applies the URI escaping rules defined in section 2 of [RFC
! 14990: * 2396] to the string supplied as $uri-part, which typically represents all
! 14991: * or part of a URI. The effect of the function is to replace any special
! 14992: * character in the string by an escape sequence of the form %xx%yy...,
! 14993: * where xxyy... is the hexadecimal representation of the octets used to
! 14994: * represent the character in UTF-8.
! 14995: *
! 14996: * The set of characters that are escaped depends on the setting of the
! 14997: * boolean argument $escape-reserved.
! 14998: *
! 14999: * If $escape-reserved is true, all characters are escaped other than lower
! 15000: * case letters a-z, upper case letters A-Z, digits 0-9, and the characters
! 15001: * referred to in [RFC 2396] as "marks": specifically, "-" | "_" | "." | "!"
! 15002: * | "~" | "*" | "'" | "(" | ")". The "%" character itself is escaped only
! 15003: * if it is not followed by two hexadecimal digits (that is, 0-9, a-f, and
! 15004: * A-F).
! 15005: *
! 15006: * If $escape-reserved is false, the behavior differs in that characters
! 15007: * referred to in [RFC 2396] as reserved characters are not escaped. These
! 15008: * characters are ";" | "/" | "?" | ":" | "@" | "&" | "=" | "+" | "$" | ",".
! 15009: *
! 15010: * [RFC 2396] does not define whether escaped URIs should use lower case or
! 15011: * upper case for hexadecimal digits. To ensure that escaped URIs can be
! 15012: * compared using string comparison functions, this function must always use
! 15013: * the upper-case letters A-F.
! 15014: *
! 15015: * Generally, $escape-reserved should be set to true when escaping a string
! 15016: * that is to form a single part of a URI, and to false when escaping an
! 15017: * entire URI or URI reference.
! 15018: *
! 15019: * In the case of non-ascii characters, the string is encoded according to
! 15020: * utf-8 and then converted according to RFC 2396.
! 15021: *
! 15022: * Examples
! 15023: * xf:escape-uri ("gopher://spinaltap.micro.umn.edu/00/Weather/California/Los%20Angeles#ocean"), true())
! 15024: * returns "gopher%3A%2F%2Fspinaltap.micro.umn.edu%2F00%2FWeather%2FCalifornia%2FLos%20Angeles%23ocean"
! 15025: * xf:escape-uri ("gopher://spinaltap.micro.umn.edu/00/Weather/California/Los%20Angeles#ocean"), false())
! 15026: * returns "gopher://spinaltap.micro.umn.edu/00/Weather/California/Los%20Angeles%23ocean"
! 15027: *
! 15028: */
! 15029: static void
! 15030: xmlXPathEscapeUriFunction(xmlXPathParserContextPtr ctxt, int nargs) {
! 15031: xmlXPathObjectPtr str;
! 15032: int escape_reserved;
! 15033: xmlBufferPtr target;
! 15034: xmlChar *cptr;
! 15035: xmlChar escape[4];
! 15036:
! 15037: CHECK_ARITY(2);
! 15038:
! 15039: escape_reserved = xmlXPathPopBoolean(ctxt);
! 15040:
! 15041: CAST_TO_STRING;
! 15042: str = valuePop(ctxt);
! 15043:
! 15044: target = xmlBufferCreate();
! 15045:
! 15046: escape[0] = '%';
! 15047: escape[3] = 0;
! 15048:
! 15049: if (target) {
! 15050: for (cptr = str->stringval; *cptr; cptr++) {
! 15051: if ((*cptr >= 'A' && *cptr <= 'Z') ||
! 15052: (*cptr >= 'a' && *cptr <= 'z') ||
! 15053: (*cptr >= '0' && *cptr <= '9') ||
! 15054: *cptr == '-' || *cptr == '_' || *cptr == '.' ||
! 15055: *cptr == '!' || *cptr == '~' || *cptr == '*' ||
! 15056: *cptr == '\''|| *cptr == '(' || *cptr == ')' ||
! 15057: (*cptr == '%' &&
! 15058: ((cptr[1] >= 'A' && cptr[1] <= 'F') ||
! 15059: (cptr[1] >= 'a' && cptr[1] <= 'f') ||
! 15060: (cptr[1] >= '0' && cptr[1] <= '9')) &&
! 15061: ((cptr[2] >= 'A' && cptr[2] <= 'F') ||
! 15062: (cptr[2] >= 'a' && cptr[2] <= 'f') ||
! 15063: (cptr[2] >= '0' && cptr[2] <= '9'))) ||
! 15064: (!escape_reserved &&
! 15065: (*cptr == ';' || *cptr == '/' || *cptr == '?' ||
! 15066: *cptr == ':' || *cptr == '@' || *cptr == '&' ||
! 15067: *cptr == '=' || *cptr == '+' || *cptr == '$' ||
! 15068: *cptr == ','))) {
! 15069: xmlBufferAdd(target, cptr, 1);
! 15070: } else {
! 15071: if ((*cptr >> 4) < 10)
! 15072: escape[1] = '0' + (*cptr >> 4);
! 15073: else
! 15074: escape[1] = 'A' - 10 + (*cptr >> 4);
! 15075: if ((*cptr & 0xF) < 10)
! 15076: escape[2] = '0' + (*cptr & 0xF);
! 15077: else
! 15078: escape[2] = 'A' - 10 + (*cptr & 0xF);
! 15079:
! 15080: xmlBufferAdd(target, &escape[0], 3);
! 15081: }
! 15082: }
! 15083: }
! 15084: valuePush(ctxt, xmlXPathCacheNewString(ctxt->context,
! 15085: xmlBufferContent(target)));
! 15086: xmlBufferFree(target);
! 15087: xmlXPathReleaseObject(ctxt->context, str);
! 15088: }
! 15089:
! 15090: /**
! 15091: * xmlXPathRegisterAllFunctions:
! 15092: * @ctxt: the XPath context
! 15093: *
! 15094: * Registers all default XPath functions in this context
! 15095: */
! 15096: void
! 15097: xmlXPathRegisterAllFunctions(xmlXPathContextPtr ctxt)
! 15098: {
! 15099: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"boolean",
! 15100: xmlXPathBooleanFunction);
! 15101: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"ceiling",
! 15102: xmlXPathCeilingFunction);
! 15103: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"count",
! 15104: xmlXPathCountFunction);
! 15105: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"concat",
! 15106: xmlXPathConcatFunction);
! 15107: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"contains",
! 15108: xmlXPathContainsFunction);
! 15109: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"id",
! 15110: xmlXPathIdFunction);
! 15111: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"false",
! 15112: xmlXPathFalseFunction);
! 15113: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"floor",
! 15114: xmlXPathFloorFunction);
! 15115: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"last",
! 15116: xmlXPathLastFunction);
! 15117: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"lang",
! 15118: xmlXPathLangFunction);
! 15119: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"local-name",
! 15120: xmlXPathLocalNameFunction);
! 15121: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"not",
! 15122: xmlXPathNotFunction);
! 15123: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"name",
! 15124: xmlXPathNameFunction);
! 15125: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"namespace-uri",
! 15126: xmlXPathNamespaceURIFunction);
! 15127: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"normalize-space",
! 15128: xmlXPathNormalizeFunction);
! 15129: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"number",
! 15130: xmlXPathNumberFunction);
! 15131: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"position",
! 15132: xmlXPathPositionFunction);
! 15133: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"round",
! 15134: xmlXPathRoundFunction);
! 15135: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"string",
! 15136: xmlXPathStringFunction);
! 15137: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"string-length",
! 15138: xmlXPathStringLengthFunction);
! 15139: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"starts-with",
! 15140: xmlXPathStartsWithFunction);
! 15141: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"substring",
! 15142: xmlXPathSubstringFunction);
! 15143: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"substring-before",
! 15144: xmlXPathSubstringBeforeFunction);
! 15145: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"substring-after",
! 15146: xmlXPathSubstringAfterFunction);
! 15147: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"sum",
! 15148: xmlXPathSumFunction);
! 15149: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"true",
! 15150: xmlXPathTrueFunction);
! 15151: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"translate",
! 15152: xmlXPathTranslateFunction);
! 15153:
! 15154: xmlXPathRegisterFuncNS(ctxt, (const xmlChar *)"escape-uri",
! 15155: (const xmlChar *)"http://www.w3.org/2002/08/xquery-functions",
! 15156: xmlXPathEscapeUriFunction);
! 15157: }
! 15158:
! 15159: #endif /* LIBXML_XPATH_ENABLED */
! 15160: #define bottom_xpath
! 15161: #include "elfgcchack.h"
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to xpath.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libxml2