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 (at) 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 "Stack usage errror\n", 256 "?? Unknown error ??\n" /* Must be last in the list! */ 257 }; 258 #define MAXERRNO ((int)(sizeof(xmlXPathErrorMessages) / \ 259 sizeof(xmlXPathErrorMessages[0])) - 1) 260 /** 261 * xmlXPathErrMemory: 262 * @ctxt: an XPath context 263 * @extra: extra informations 264 * 265 * Handle a redefinition of attribute error 266 */ 267 static void 268 xmlXPathErrMemory(xmlXPathContextPtr ctxt, const char *extra) 269 { 270 if (ctxt != NULL) { 271 if (extra) { 272 xmlChar buf[200]; 273 274 xmlStrPrintf(buf, 200, 275 BAD_CAST "Memory allocation failed : %s\n", 276 extra); 277 ctxt->lastError.message = (char *) xmlStrdup(buf); 278 } else { 279 ctxt->lastError.message = (char *) 280 xmlStrdup(BAD_CAST "Memory allocation failed\n"); 281 } 282 ctxt->lastError.domain = XML_FROM_XPATH; 283 ctxt->lastError.code = XML_ERR_NO_MEMORY; 284 if (ctxt->error != NULL) 285 ctxt->error(ctxt->userData, &ctxt->lastError); 286 } else { 287 if (extra) 288 __xmlRaiseError(NULL, NULL, NULL, 289 NULL, NULL, XML_FROM_XPATH, 290 XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0, 291 extra, NULL, NULL, 0, 0, 292 "Memory allocation failed : %s\n", extra); 293 else 294 __xmlRaiseError(NULL, NULL, NULL, 295 NULL, NULL, XML_FROM_XPATH, 296 XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0, 297 NULL, NULL, NULL, 0, 0, 298 "Memory allocation failed\n"); 299 } 300 } 301 302 /** 303 * xmlXPathPErrMemory: 304 * @ctxt: an XPath parser context 305 * @extra: extra informations 306 * 307 * Handle a redefinition of attribute error 308 */ 309 static void 310 xmlXPathPErrMemory(xmlXPathParserContextPtr ctxt, const char *extra) 311 { 312 if (ctxt == NULL) 313 xmlXPathErrMemory(NULL, extra); 314 else { 315 ctxt->error = XPATH_MEMORY_ERROR; 316 xmlXPathErrMemory(ctxt->context, extra); 317 } 318 } 319 320 /** 321 * xmlXPathErr: 322 * @ctxt: a XPath parser context 323 * @error: the error code 324 * 325 * Handle an XPath error 326 */ 327 void 328 xmlXPathErr(xmlXPathParserContextPtr ctxt, int error) 329 { 330 if ((error < 0) || (error > MAXERRNO)) 331 error = MAXERRNO; 332 if (ctxt == NULL) { 333 __xmlRaiseError(NULL, NULL, NULL, 334 NULL, NULL, XML_FROM_XPATH, 335 error + XML_XPATH_EXPRESSION_OK - XPATH_EXPRESSION_OK, 336 XML_ERR_ERROR, NULL, 0, 337 NULL, NULL, NULL, 0, 0, 338 "%s", xmlXPathErrorMessages[error]); 339 return; 340 } 341 ctxt->error = error; 342 if (ctxt->context == NULL) { 343 __xmlRaiseError(NULL, NULL, NULL, 344 NULL, NULL, XML_FROM_XPATH, 345 error + XML_XPATH_EXPRESSION_OK - XPATH_EXPRESSION_OK, 346 XML_ERR_ERROR, NULL, 0, 347 (const char *) ctxt->base, NULL, NULL, 348 ctxt->cur - ctxt->base, 0, 349 "%s", xmlXPathErrorMessages[error]); 350 return; 351 } 352 353 /* cleanup current last error */ 354 xmlResetError(&ctxt->context->lastError); 355 356 ctxt->context->lastError.domain = XML_FROM_XPATH; 357 ctxt->context->lastError.code = error + XML_XPATH_EXPRESSION_OK - 358 XPATH_EXPRESSION_OK; 359 ctxt->context->lastError.level = XML_ERR_ERROR; 360 ctxt->context->lastError.str1 = (char *) xmlStrdup(ctxt->base); 361 ctxt->context->lastError.int1 = ctxt->cur - ctxt->base; 362 ctxt->context->lastError.node = ctxt->context->debugNode; 363 if (ctxt->context->error != NULL) { 364 ctxt->context->error(ctxt->context->userData, 365 &ctxt->context->lastError); 366 } else { 367 __xmlRaiseError(NULL, NULL, NULL, 368 NULL, ctxt->context->debugNode, XML_FROM_XPATH, 369 error + XML_XPATH_EXPRESSION_OK - XPATH_EXPRESSION_OK, 370 XML_ERR_ERROR, NULL, 0, 371 (const char *) ctxt->base, NULL, NULL, 372 ctxt->cur - ctxt->base, 0, 373 "%s", xmlXPathErrorMessages[error]); 374 } 375 376 } 377 378 /** 379 * xmlXPatherror: 380 * @ctxt: the XPath Parser context 381 * @file: the file name 382 * @line: the line number 383 * @no: the error number 384 * 385 * Formats an error message. 386 */ 387 void 388 xmlXPatherror(xmlXPathParserContextPtr ctxt, const char *file ATTRIBUTE_UNUSED, 389 int line ATTRIBUTE_UNUSED, int no) { 390 xmlXPathErr(ctxt, no); 391 } 392 393 /************************************************************************ 394 * * 395 * Utilities * 396 * * 397 ************************************************************************/ 398 399 /** 400 * xsltPointerList: 401 * 402 * Pointer-list for various purposes. 403 */ 404 typedef struct _xmlPointerList xmlPointerList; 405 typedef xmlPointerList *xmlPointerListPtr; 406 struct _xmlPointerList { 407 void **items; 408 int number; 409 int size; 410 }; 411 /* 412 * TODO: Since such a list-handling is used in xmlschemas.c and libxslt 413 * and here, we should make the functions public. 414 */ 415 static int 416 xmlPointerListAddSize(xmlPointerListPtr list, 417 void *item, 418 int initialSize) 419 { 420 if (list->items == NULL) { 421 if (initialSize <= 0) 422 initialSize = 1; 423 list->items = (void **) xmlMalloc( 424 initialSize * sizeof(void *)); 425 if (list->items == NULL) { 426 xmlXPathErrMemory(NULL, 427 "xmlPointerListCreate: allocating item\n"); 428 return(-1); 429 } 430 list->number = 0; 431 list->size = initialSize; 432 } else if (list->size <= list->number) { 433 list->size *= 2; 434 list->items = (void **) xmlRealloc(list->items, 435 list->size * sizeof(void *)); 436 if (list->items == NULL) { 437 xmlXPathErrMemory(NULL, 438 "xmlPointerListCreate: re-allocating item\n"); 439 list->size = 0; 440 return(-1); 441 } 442 } 443 list->items[list->number++] = item; 444 return(0); 445 } 446 447 /** 448 * xsltPointerListCreate: 449 * 450 * Creates an xsltPointerList structure. 451 * 452 * Returns a xsltPointerList structure or NULL in case of an error. 453 */ 454 static xmlPointerListPtr 455 xmlPointerListCreate(int initialSize) 456 { 457 xmlPointerListPtr ret; 458 459 ret = xmlMalloc(sizeof(xmlPointerList)); 460 if (ret == NULL) { 461 xmlXPathErrMemory(NULL, 462 "xmlPointerListCreate: allocating item\n"); 463 return (NULL); 464 } 465 memset(ret, 0, sizeof(xmlPointerList)); 466 if (initialSize > 0) { 467 xmlPointerListAddSize(ret, NULL, initialSize); 468 ret->number = 0; 469 } 470 return (ret); 471 } 472 473 /** 474 * xsltPointerListFree: 475 * 476 * Frees the xsltPointerList structure. This does not free 477 * the content of the list. 478 */ 479 static void 480 xmlPointerListFree(xmlPointerListPtr list) 481 { 482 if (list == NULL) 483 return; 484 if (list->items != NULL) 485 xmlFree(list->items); 486 xmlFree(list); 487 } 488 489 /************************************************************************ 490 * * 491 * Parser Types * 492 * * 493 ************************************************************************/ 494 495 /* 496 * Types are private: 497 */ 498 499 typedef enum { 500 XPATH_OP_END=0, 501 XPATH_OP_AND, 502 XPATH_OP_OR, 503 XPATH_OP_EQUAL, 504 XPATH_OP_CMP, 505 XPATH_OP_PLUS, 506 XPATH_OP_MULT, 507 XPATH_OP_UNION, 508 XPATH_OP_ROOT, 509 XPATH_OP_NODE, 510 XPATH_OP_RESET, /* 10 */ 511 XPATH_OP_COLLECT, 512 XPATH_OP_VALUE, /* 12 */ 513 XPATH_OP_VARIABLE, 514 XPATH_OP_FUNCTION, 515 XPATH_OP_ARG, 516 XPATH_OP_PREDICATE, 517 XPATH_OP_FILTER, /* 17 */ 518 XPATH_OP_SORT /* 18 */ 519 #ifdef LIBXML_XPTR_ENABLED 520 ,XPATH_OP_RANGETO 521 #endif 522 } xmlXPathOp; 523 524 typedef enum { 525 AXIS_ANCESTOR = 1, 526 AXIS_ANCESTOR_OR_SELF, 527 AXIS_ATTRIBUTE, 528 AXIS_CHILD, 529 AXIS_DESCENDANT, 530 AXIS_DESCENDANT_OR_SELF, 531 AXIS_FOLLOWING, 532 AXIS_FOLLOWING_SIBLING, 533 AXIS_NAMESPACE, 534 AXIS_PARENT, 535 AXIS_PRECEDING, 536 AXIS_PRECEDING_SIBLING, 537 AXIS_SELF 538 } xmlXPathAxisVal; 539 540 typedef enum { 541 NODE_TEST_NONE = 0, 542 NODE_TEST_TYPE = 1, 543 NODE_TEST_PI = 2, 544 NODE_TEST_ALL = 3, 545 NODE_TEST_NS = 4, 546 NODE_TEST_NAME = 5 547 } xmlXPathTestVal; 548 549 typedef enum { 550 NODE_TYPE_NODE = 0, 551 NODE_TYPE_COMMENT = XML_COMMENT_NODE, 552 NODE_TYPE_TEXT = XML_TEXT_NODE, 553 NODE_TYPE_PI = XML_PI_NODE 554 } xmlXPathTypeVal; 555 556 #define XP_REWRITE_DOS_CHILD_ELEM 1 557 558 typedef struct _xmlXPathStepOp xmlXPathStepOp; 559 typedef xmlXPathStepOp *xmlXPathStepOpPtr; 560 struct _xmlXPathStepOp { 561 xmlXPathOp op; /* The identifier of the operation */ 562 int ch1; /* First child */ 563 int ch2; /* Second child */ 564 int value; 565 int value2; 566 int value3; 567 void *value4; 568 void *value5; 569 void *cache; 570 void *cacheURI; 571 int rewriteType; 572 }; 573 574 struct _xmlXPathCompExpr { 575 int nbStep; /* Number of steps in this expression */ 576 int maxStep; /* Maximum number of steps allocated */ 577 xmlXPathStepOp *steps; /* ops for computation of this expression */ 578 int last; /* index of last step in expression */ 579 xmlChar *expr; /* the expression being computed */ 580 xmlDictPtr dict; /* the dictionnary to use if any */ 581 #ifdef DEBUG_EVAL_COUNTS 582 int nb; 583 xmlChar *string; 584 #endif 585 #ifdef XPATH_STREAMING 586 xmlPatternPtr stream; 587 #endif 588 }; 589 590 /************************************************************************ 591 * * 592 * Forward declarations * 593 * * 594 ************************************************************************/ 595 static void 596 xmlXPathFreeValueTree(xmlNodeSetPtr obj); 597 static void 598 xmlXPathReleaseObject(xmlXPathContextPtr ctxt, xmlXPathObjectPtr obj); 599 static int 600 xmlXPathCompOpEvalFirst(xmlXPathParserContextPtr ctxt, 601 xmlXPathStepOpPtr op, xmlNodePtr *first); 602 static int 603 xmlXPathCompOpEvalToBoolean(xmlXPathParserContextPtr ctxt, 604 xmlXPathStepOpPtr op, 605 int isPredicate); 606 607 /************************************************************************ 608 * * 609 * Parser Type functions * 610 * * 611 ************************************************************************/ 612 613 /** 614 * xmlXPathNewCompExpr: 615 * 616 * Create a new Xpath component 617 * 618 * Returns the newly allocated xmlXPathCompExprPtr or NULL in case of error 619 */ 620 static xmlXPathCompExprPtr 621 xmlXPathNewCompExpr(void) { 622 xmlXPathCompExprPtr cur; 623 624 cur = (xmlXPathCompExprPtr) xmlMalloc(sizeof(xmlXPathCompExpr)); 625 if (cur == NULL) { 626 xmlXPathErrMemory(NULL, "allocating component\n"); 627 return(NULL); 628 } 629 memset(cur, 0, sizeof(xmlXPathCompExpr)); 630 cur->maxStep = 10; 631 cur->nbStep = 0; 632 cur->steps = (xmlXPathStepOp *) xmlMalloc(cur->maxStep * 633 sizeof(xmlXPathStepOp)); 634 if (cur->steps == NULL) { 635 xmlXPathErrMemory(NULL, "allocating steps\n"); 636 xmlFree(cur); 637 return(NULL); 638 } 639 memset(cur->steps, 0, cur->maxStep * sizeof(xmlXPathStepOp)); 640 cur->last = -1; 641 #ifdef DEBUG_EVAL_COUNTS 642 cur->nb = 0; 643 #endif 644 return(cur); 645 } 646 647 /** 648 * xmlXPathFreeCompExpr: 649 * @comp: an XPATH comp 650 * 651 * Free up the memory allocated by @comp 652 */ 653 void 654 xmlXPathFreeCompExpr(xmlXPathCompExprPtr comp) 655 { 656 xmlXPathStepOpPtr op; 657 int i; 658 659 if (comp == NULL) 660 return; 661 if (comp->dict == NULL) { 662 for (i = 0; i < comp->nbStep; i++) { 663 op = &comp->steps[i]; 664 if (op->value4 != NULL) { 665 if (op->op == XPATH_OP_VALUE) 666 xmlXPathFreeObject(op->value4); 667 else 668 xmlFree(op->value4); 669 } 670 if (op->value5 != NULL) 671 xmlFree(op->value5); 672 } 673 } else { 674 for (i = 0; i < comp->nbStep; i++) { 675 op = &comp->steps[i]; 676 if (op->value4 != NULL) { 677 if (op->op == XPATH_OP_VALUE) 678 xmlXPathFreeObject(op->value4); 679 } 680 } 681 xmlDictFree(comp->dict); 682 } 683 if (comp->steps != NULL) { 684 xmlFree(comp->steps); 685 } 686 #ifdef DEBUG_EVAL_COUNTS 687 if (comp->string != NULL) { 688 xmlFree(comp->string); 689 } 690 #endif 691 #ifdef XPATH_STREAMING 692 if (comp->stream != NULL) { 693 xmlFreePatternList(comp->stream); 694 } 695 #endif 696 if (comp->expr != NULL) { 697 xmlFree(comp->expr); 698 } 699 700 xmlFree(comp); 701 } 702 703 /** 704 * xmlXPathCompExprAdd: 705 * @comp: the compiled expression 706 * @ch1: first child index 707 * @ch2: second child index 708 * @op: an op 709 * @value: the first int value 710 * @value2: the second int value 711 * @value3: the third int value 712 * @value4: the first string value 713 * @value5: the second string value 714 * 715 * Add a step to an XPath Compiled Expression 716 * 717 * Returns -1 in case of failure, the index otherwise 718 */ 719 static int 720 xmlXPathCompExprAdd(xmlXPathCompExprPtr comp, int ch1, int ch2, 721 xmlXPathOp op, int value, 722 int value2, int value3, void *value4, void *value5) { 723 if (comp->nbStep >= comp->maxStep) { 724 xmlXPathStepOp *real; 725 726 comp->maxStep *= 2; 727 real = (xmlXPathStepOp *) xmlRealloc(comp->steps, 728 comp->maxStep * sizeof(xmlXPathStepOp)); 729 if (real == NULL) { 730 comp->maxStep /= 2; 731 xmlXPathErrMemory(NULL, "adding step\n"); 732 return(-1); 733 } 734 comp->steps = real; 735 } 736 comp->last = comp->nbStep; 737 comp->steps[comp->nbStep].rewriteType = 0; 738 comp->steps[comp->nbStep].ch1 = ch1; 739 comp->steps[comp->nbStep].ch2 = ch2; 740 comp->steps[comp->nbStep].op = op; 741 comp->steps[comp->nbStep].value = value; 742 comp->steps[comp->nbStep].value2 = value2; 743 comp->steps[comp->nbStep].value3 = value3; 744 if ((comp->dict != NULL) && 745 ((op == XPATH_OP_FUNCTION) || (op == XPATH_OP_VARIABLE) || 746 (op == XPATH_OP_COLLECT))) { 747 if (value4 != NULL) { 748 comp->steps[comp->nbStep].value4 = (xmlChar *) 749 (void *)xmlDictLookup(comp->dict, value4, -1); 750 xmlFree(value4); 751 } else 752 comp->steps[comp->nbStep].value4 = NULL; 753 if (value5 != NULL) { 754 comp->steps[comp->nbStep].value5 = (xmlChar *) 755 (void *)xmlDictLookup(comp->dict, value5, -1); 756 xmlFree(value5); 757 } else 758 comp->steps[comp->nbStep].value5 = NULL; 759 } else { 760 comp->steps[comp->nbStep].value4 = value4; 761 comp->steps[comp->nbStep].value5 = value5; 762 } 763 comp->steps[comp->nbStep].cache = NULL; 764 return(comp->nbStep++); 765 } 766 767 /** 768 * xmlXPathCompSwap: 769 * @comp: the compiled expression 770 * @op: operation index 771 * 772 * Swaps 2 operations in the compiled expression 773 */ 774 static void 775 xmlXPathCompSwap(xmlXPathStepOpPtr op) { 776 int tmp; 777 778 #ifndef LIBXML_THREAD_ENABLED 779 /* 780 * Since this manipulates possibly shared variables, this is 781 * disabled if one detects that the library is used in a multithreaded 782 * application 783 */ 784 if (xmlXPathDisableOptimizer) 785 return; 786 #endif 787 788 tmp = op->ch1; 789 op->ch1 = op->ch2; 790 op->ch2 = tmp; 791 } 792 793 #define PUSH_FULL_EXPR(op, op1, op2, val, val2, val3, val4, val5) \ 794 xmlXPathCompExprAdd(ctxt->comp, (op1), (op2), \ 795 (op), (val), (val2), (val3), (val4), (val5)) 796 #define PUSH_LONG_EXPR(op, val, val2, val3, val4, val5) \ 797 xmlXPathCompExprAdd(ctxt->comp, ctxt->comp->last, -1, \ 798 (op), (val), (val2), (val3), (val4), (val5)) 799 800 #define PUSH_LEAVE_EXPR(op, val, val2) \ 801 xmlXPathCompExprAdd(ctxt->comp, -1, -1, (op), (val), (val2), 0 ,NULL ,NULL) 802 803 #define PUSH_UNARY_EXPR(op, ch, val, val2) \ 804 xmlXPathCompExprAdd(ctxt->comp, (ch), -1, (op), (val), (val2), 0 ,NULL ,NULL) 805 806 #define PUSH_BINARY_EXPR(op, ch1, ch2, val, val2) \ 807 xmlXPathCompExprAdd(ctxt->comp, (ch1), (ch2), (op), \ 808 (val), (val2), 0 ,NULL ,NULL) 809 810 /************************************************************************ 811 * * 812 * XPath object cache structures * 813 * * 814 ************************************************************************/ 815 816 /* #define XP_DEFAULT_CACHE_ON */ 817 818 #define XP_HAS_CACHE(c) ((c != NULL) && ((c)->cache != NULL)) 819 820 typedef struct _xmlXPathContextCache xmlXPathContextCache; 821 typedef xmlXPathContextCache *xmlXPathContextCachePtr; 822 struct _xmlXPathContextCache { 823 xmlPointerListPtr nodesetObjs; /* contains xmlXPathObjectPtr */ 824 xmlPointerListPtr stringObjs; /* contains xmlXPathObjectPtr */ 825 xmlPointerListPtr booleanObjs; /* contains xmlXPathObjectPtr */ 826 xmlPointerListPtr numberObjs; /* contains xmlXPathObjectPtr */ 827 xmlPointerListPtr miscObjs; /* contains xmlXPathObjectPtr */ 828 int maxNodeset; 829 int maxString; 830 int maxBoolean; 831 int maxNumber; 832 int maxMisc; 833 #ifdef XP_DEBUG_OBJ_USAGE 834 int dbgCachedAll; 835 int dbgCachedNodeset; 836 int dbgCachedString; 837 int dbgCachedBool; 838 int dbgCachedNumber; 839 int dbgCachedPoint; 840 int dbgCachedRange; 841 int dbgCachedLocset; 842 int dbgCachedUsers; 843 int dbgCachedXSLTTree; 844 int dbgCachedUndefined; 845 846 847 int dbgReusedAll; 848 int dbgReusedNodeset; 849 int dbgReusedString; 850 int dbgReusedBool; 851 int dbgReusedNumber; 852 int dbgReusedPoint; 853 int dbgReusedRange; 854 int dbgReusedLocset; 855 int dbgReusedUsers; 856 int dbgReusedXSLTTree; 857 int dbgReusedUndefined; 858 859 #endif 860 }; 861 862 /************************************************************************ 863 * * 864 * Debugging related functions * 865 * * 866 ************************************************************************/ 867 868 #define STRANGE \ 869 xmlGenericError(xmlGenericErrorContext, \ 870 "Internal error at %s:%d\n", \ 871 __FILE__, __LINE__); 872 873 #ifdef LIBXML_DEBUG_ENABLED 874 static void 875 xmlXPathDebugDumpNode(FILE *output, xmlNodePtr cur, int depth) { 876 int i; 877 char shift[100]; 878 879 for (i = 0;((i < depth) && (i < 25));i++) 880 shift[2 * i] = shift[2 * i + 1] = ' '; 881 shift[2 * i] = shift[2 * i + 1] = 0; 882 if (cur == NULL) { 883 fprintf(output, "%s", shift); 884 fprintf(output, "Node is NULL !\n"); 885 return; 886 887 } 888 889 if ((cur->type == XML_DOCUMENT_NODE) || 890 (cur->type == XML_HTML_DOCUMENT_NODE)) { 891 fprintf(output, "%s", shift); 892 fprintf(output, " /\n"); 893 } else if (cur->type == XML_ATTRIBUTE_NODE) 894 xmlDebugDumpAttr(output, (xmlAttrPtr)cur, depth); 895 else 896 xmlDebugDumpOneNode(output, cur, depth); 897 } 898 static void 899 xmlXPathDebugDumpNodeList(FILE *output, xmlNodePtr cur, int depth) { 900 xmlNodePtr tmp; 901 int i; 902 char shift[100]; 903 904 for (i = 0;((i < depth) && (i < 25));i++) 905 shift[2 * i] = shift[2 * i + 1] = ' '; 906 shift[2 * i] = shift[2 * i + 1] = 0; 907 if (cur == NULL) { 908 fprintf(output, "%s", shift); 909 fprintf(output, "Node is NULL !\n"); 910 return; 911 912 } 913 914 while (cur != NULL) { 915 tmp = cur; 916 cur = cur->next; 917 xmlDebugDumpOneNode(output, tmp, depth); 918 } 919 } 920 921 static void 922 xmlXPathDebugDumpNodeSet(FILE *output, xmlNodeSetPtr cur, int depth) { 923 int i; 924 char shift[100]; 925 926 for (i = 0;((i < depth) && (i < 25));i++) 927 shift[2 * i] = shift[2 * i + 1] = ' '; 928 shift[2 * i] = shift[2 * i + 1] = 0; 929 930 if (cur == NULL) { 931 fprintf(output, "%s", shift); 932 fprintf(output, "NodeSet is NULL !\n"); 933 return; 934 935 } 936 937 if (cur != NULL) { 938 fprintf(output, "Set contains %d nodes:\n", cur->nodeNr); 939 for (i = 0;i < cur->nodeNr;i++) { 940 fprintf(output, "%s", shift); 941 fprintf(output, "%d", i + 1); 942 xmlXPathDebugDumpNode(output, cur->nodeTab[i], depth + 1); 943 } 944 } 945 } 946 947 static void 948 xmlXPathDebugDumpValueTree(FILE *output, xmlNodeSetPtr cur, int depth) { 949 int i; 950 char shift[100]; 951 952 for (i = 0;((i < depth) && (i < 25));i++) 953 shift[2 * i] = shift[2 * i + 1] = ' '; 954 shift[2 * i] = shift[2 * i + 1] = 0; 955 956 if ((cur == NULL) || (cur->nodeNr == 0) || (cur->nodeTab[0] == NULL)) { 957 fprintf(output, "%s", shift); 958 fprintf(output, "Value Tree is NULL !\n"); 959 return; 960 961 } 962 963 fprintf(output, "%s", shift); 964 fprintf(output, "%d", i + 1); 965 xmlXPathDebugDumpNodeList(output, cur->nodeTab[0]->children, depth + 1); 966 } 967 #if defined(LIBXML_XPTR_ENABLED) 968 static void 969 xmlXPathDebugDumpLocationSet(FILE *output, xmlLocationSetPtr cur, int depth) { 970 int i; 971 char shift[100]; 972 973 for (i = 0;((i < depth) && (i < 25));i++) 974 shift[2 * i] = shift[2 * i + 1] = ' '; 975 shift[2 * i] = shift[2 * i + 1] = 0; 976 977 if (cur == NULL) { 978 fprintf(output, "%s", shift); 979 fprintf(output, "LocationSet is NULL !\n"); 980 return; 981 982 } 983 984 for (i = 0;i < cur->locNr;i++) { 985 fprintf(output, "%s", shift); 986 fprintf(output, "%d : ", i + 1); 987 xmlXPathDebugDumpObject(output, cur->locTab[i], depth + 1); 988 } 989 } 990 #endif /* LIBXML_XPTR_ENABLED */ 991 992 /** 993 * xmlXPathDebugDumpObject: 994 * @output: the FILE * to dump the output 995 * @cur: the object to inspect 996 * @depth: indentation level 997 * 998 * Dump the content of the object for debugging purposes 999 */ 1000 void 1001 xmlXPathDebugDumpObject(FILE *output, xmlXPathObjectPtr cur, int depth) { 1002 int i; 1003 char shift[100]; 1004 1005 if (output == NULL) return; 1006 1007 for (i = 0;((i < depth) && (i < 25));i++) 1008 shift[2 * i] = shift[2 * i + 1] = ' '; 1009 shift[2 * i] = shift[2 * i + 1] = 0; 1010 1011 1012 fprintf(output, "%s", shift); 1013 1014 if (cur == NULL) { 1015 fprintf(output, "Object is empty (NULL)\n"); 1016 return; 1017 } 1018 switch(cur->type) { 1019 case XPATH_UNDEFINED: 1020 fprintf(output, "Object is uninitialized\n"); 1021 break; 1022 case XPATH_NODESET: 1023 fprintf(output, "Object is a Node Set :\n"); 1024 xmlXPathDebugDumpNodeSet(output, cur->nodesetval, depth); 1025 break; 1026 case XPATH_XSLT_TREE: 1027 fprintf(output, "Object is an XSLT value tree :\n"); 1028 xmlXPathDebugDumpValueTree(output, cur->nodesetval, depth); 1029 break; 1030 case XPATH_BOOLEAN: 1031 fprintf(output, "Object is a Boolean : "); 1032 if (cur->boolval) fprintf(output, "true\n"); 1033 else fprintf(output, "false\n"); 1034 break; 1035 case XPATH_NUMBER: 1036 switch (xmlXPathIsInf(cur->floatval)) { 1037 case 1: 1038 fprintf(output, "Object is a number : Infinity\n"); 1039 break; 1040 case -1: 1041 fprintf(output, "Object is a number : -Infinity\n"); 1042 break; 1043 default: 1044 if (xmlXPathIsNaN(cur->floatval)) { 1045 fprintf(output, "Object is a number : NaN\n"); 1046 } else if (cur->floatval == 0 && xmlXPathGetSign(cur->floatval) != 0) { 1047 fprintf(output, "Object is a number : 0\n"); 1048 } else { 1049 fprintf(output, "Object is a number : %0g\n", cur->floatval); 1050 } 1051 } 1052 break; 1053 case XPATH_STRING: 1054 fprintf(output, "Object is a string : "); 1055 xmlDebugDumpString(output, cur->stringval); 1056 fprintf(output, "\n"); 1057 break; 1058 case XPATH_POINT: 1059 fprintf(output, "Object is a point : index %d in node", cur->index); 1060 xmlXPathDebugDumpNode(output, (xmlNodePtr) cur->user, depth + 1); 1061 fprintf(output, "\n"); 1062 break; 1063 case XPATH_RANGE: 1064 if ((cur->user2 == NULL) || 1065 ((cur->user2 == cur->user) && (cur->index == cur->index2))) { 1066 fprintf(output, "Object is a collapsed range :\n"); 1067 fprintf(output, "%s", shift); 1068 if (cur->index >= 0) 1069 fprintf(output, "index %d in ", cur->index); 1070 fprintf(output, "node\n"); 1071 xmlXPathDebugDumpNode(output, (xmlNodePtr) cur->user, 1072 depth + 1); 1073 } else { 1074 fprintf(output, "Object is a range :\n"); 1075 fprintf(output, "%s", shift); 1076 fprintf(output, "From "); 1077 if (cur->index >= 0) 1078 fprintf(output, "index %d in ", cur->index); 1079 fprintf(output, "node\n"); 1080 xmlXPathDebugDumpNode(output, (xmlNodePtr) cur->user, 1081 depth + 1); 1082 fprintf(output, "%s", shift); 1083 fprintf(output, "To "); 1084 if (cur->index2 >= 0) 1085 fprintf(output, "index %d in ", cur->index2); 1086 fprintf(output, "node\n"); 1087 xmlXPathDebugDumpNode(output, (xmlNodePtr) cur->user2, 1088 depth + 1); 1089 fprintf(output, "\n"); 1090 } 1091 break; 1092 case XPATH_LOCATIONSET: 1093 #if defined(LIBXML_XPTR_ENABLED) 1094 fprintf(output, "Object is a Location Set:\n"); 1095 xmlXPathDebugDumpLocationSet(output, 1096 (xmlLocationSetPtr) cur->user, depth); 1097 #endif 1098 break; 1099 case XPATH_USERS: 1100 fprintf(output, "Object is user defined\n"); 1101 break; 1102 } 1103 } 1104 1105 static void 1106 xmlXPathDebugDumpStepOp(FILE *output, xmlXPathCompExprPtr comp, 1107 xmlXPathStepOpPtr op, int depth) { 1108 int i; 1109 char shift[100]; 1110 1111 for (i = 0;((i < depth) && (i < 25));i++) 1112 shift[2 * i] = shift[2 * i + 1] = ' '; 1113 shift[2 * i] = shift[2 * i + 1] = 0; 1114 1115 fprintf(output, "%s", shift); 1116 if (op == NULL) { 1117 fprintf(output, "Step is NULL\n"); 1118 return; 1119 } 1120 switch (op->op) { 1121 case XPATH_OP_END: 1122 fprintf(output, "END"); break; 1123 case XPATH_OP_AND: 1124 fprintf(output, "AND"); break; 1125 case XPATH_OP_OR: 1126 fprintf(output, "OR"); break; 1127 case XPATH_OP_EQUAL: 1128 if (op->value) 1129 fprintf(output, "EQUAL ="); 1130 else 1131 fprintf(output, "EQUAL !="); 1132 break; 1133 case XPATH_OP_CMP: 1134 if (op->value) 1135 fprintf(output, "CMP <"); 1136 else 1137 fprintf(output, "CMP >"); 1138 if (!op->value2) 1139 fprintf(output, "="); 1140 break; 1141 case XPATH_OP_PLUS: 1142 if (op->value == 0) 1143 fprintf(output, "PLUS -"); 1144 else if (op->value == 1) 1145 fprintf(output, "PLUS +"); 1146 else if (op->value == 2) 1147 fprintf(output, "PLUS unary -"); 1148 else if (op->value == 3) 1149 fprintf(output, "PLUS unary - -"); 1150 break; 1151 case XPATH_OP_MULT: 1152 if (op->value == 0) 1153 fprintf(output, "MULT *"); 1154 else if (op->value == 1) 1155 fprintf(output, "MULT div"); 1156 else 1157 fprintf(output, "MULT mod"); 1158 break; 1159 case XPATH_OP_UNION: 1160 fprintf(output, "UNION"); break; 1161 case XPATH_OP_ROOT: 1162 fprintf(output, "ROOT"); break; 1163 case XPATH_OP_NODE: 1164 fprintf(output, "NODE"); break; 1165 case XPATH_OP_RESET: 1166 fprintf(output, "RESET"); break; 1167 case XPATH_OP_SORT: 1168 fprintf(output, "SORT"); break; 1169 case XPATH_OP_COLLECT: { 1170 xmlXPathAxisVal axis = (xmlXPathAxisVal)op->value; 1171 xmlXPathTestVal test = (xmlXPathTestVal)op->value2; 1172 xmlXPathTypeVal type = (xmlXPathTypeVal)op->value3; 1173 const xmlChar *prefix = op->value4; 1174 const xmlChar *name = op->value5; 1175 1176 fprintf(output, "COLLECT "); 1177 switch (axis) { 1178 case AXIS_ANCESTOR: 1179 fprintf(output, " 'ancestors' "); break; 1180 case AXIS_ANCESTOR_OR_SELF: 1181 fprintf(output, " 'ancestors-or-self' "); break; 1182 case AXIS_ATTRIBUTE: 1183 fprintf(output, " 'attributes' "); break; 1184 case AXIS_CHILD: 1185 fprintf(output, " 'child' "); break; 1186 case AXIS_DESCENDANT: 1187 fprintf(output, " 'descendant' "); break; 1188 case AXIS_DESCENDANT_OR_SELF: 1189 fprintf(output, " 'descendant-or-self' "); break; 1190 case AXIS_FOLLOWING: 1191 fprintf(output, " 'following' "); break; 1192 case AXIS_FOLLOWING_SIBLING: 1193 fprintf(output, " 'following-siblings' "); break; 1194 case AXIS_NAMESPACE: 1195 fprintf(output, " 'namespace' "); break; 1196 case AXIS_PARENT: 1197 fprintf(output, " 'parent' "); break; 1198 case AXIS_PRECEDING: 1199 fprintf(output, " 'preceding' "); break; 1200 case AXIS_PRECEDING_SIBLING: 1201 fprintf(output, " 'preceding-sibling' "); break; 1202 case AXIS_SELF: 1203 fprintf(output, " 'self' "); break; 1204 } 1205 switch (test) { 1206 case NODE_TEST_NONE: 1207 fprintf(output, "'none' "); break; 1208 case NODE_TEST_TYPE: 1209 fprintf(output, "'type' "); break; 1210 case NODE_TEST_PI: 1211 fprintf(output, "'PI' "); break; 1212 case NODE_TEST_ALL: 1213 fprintf(output, "'all' "); break; 1214 case NODE_TEST_NS: 1215 fprintf(output, "'namespace' "); break; 1216 case NODE_TEST_NAME: 1217 fprintf(output, "'name' "); break; 1218 } 1219 switch (type) { 1220 case NODE_TYPE_NODE: 1221 fprintf(output, "'node' "); break; 1222 case NODE_TYPE_COMMENT: 1223 fprintf(output, "'comment' "); break; 1224 case NODE_TYPE_TEXT: 1225 fprintf(output, "'text' "); break; 1226 case NODE_TYPE_PI: 1227 fprintf(output, "'PI' "); break; 1228 } 1229 if (prefix != NULL) 1230 fprintf(output, "%s:", prefix); 1231 if (name != NULL) 1232 fprintf(output, "%s", (const char *) name); 1233 break; 1234 1235 } 1236 case XPATH_OP_VALUE: { 1237 xmlXPathObjectPtr object = (xmlXPathObjectPtr) op->value4; 1238 1239 fprintf(output, "ELEM "); 1240 xmlXPathDebugDumpObject(output, object, 0); 1241 goto finish; 1242 } 1243 case XPATH_OP_VARIABLE: { 1244 const xmlChar *prefix = op->value5; 1245 const xmlChar *name = op->value4; 1246 1247 if (prefix != NULL) 1248 fprintf(output, "VARIABLE %s:%s", prefix, name); 1249 else 1250 fprintf(output, "VARIABLE %s", name); 1251 break; 1252 } 1253 case XPATH_OP_FUNCTION: { 1254 int nbargs = op->value; 1255 const xmlChar *prefix = op->value5; 1256 const xmlChar *name = op->value4; 1257 1258 if (prefix != NULL) 1259 fprintf(output, "FUNCTION %s:%s(%d args)", 1260 prefix, name, nbargs); 1261 else 1262 fprintf(output, "FUNCTION %s(%d args)", name, nbargs); 1263 break; 1264 } 1265 case XPATH_OP_ARG: fprintf(output, "ARG"); break; 1266 case XPATH_OP_PREDICATE: fprintf(output, "PREDICATE"); break; 1267 case XPATH_OP_FILTER: fprintf(output, "FILTER"); break; 1268 #ifdef LIBXML_XPTR_ENABLED 1269 case XPATH_OP_RANGETO: fprintf(output, "RANGETO"); break; 1270 #endif 1271 default: 1272 fprintf(output, "UNKNOWN %d\n", op->op); return; 1273 } 1274 fprintf(output, "\n"); 1275 finish: 1276 if (op->ch1 >= 0) 1277 xmlXPathDebugDumpStepOp(output, comp, &comp->steps[op->ch1], depth + 1); 1278 if (op->ch2 >= 0) 1279 xmlXPathDebugDumpStepOp(output, comp, &comp->steps[op->ch2], depth + 1); 1280 } 1281 1282 /** 1283 * xmlXPathDebugDumpCompExpr: 1284 * @output: the FILE * for the output 1285 * @comp: the precompiled XPath expression 1286 * @depth: the indentation level. 1287 * 1288 * Dumps the tree of the compiled XPath expression. 1289 */ 1290 void 1291 xmlXPathDebugDumpCompExpr(FILE *output, xmlXPathCompExprPtr comp, 1292 int depth) { 1293 int i; 1294 char shift[100]; 1295 1296 if ((output == NULL) || (comp == NULL)) return; 1297 1298 for (i = 0;((i < depth) && (i < 25));i++) 1299 shift[2 * i] = shift[2 * i + 1] = ' '; 1300 shift[2 * i] = shift[2 * i + 1] = 0; 1301 1302 fprintf(output, "%s", shift); 1303 1304 fprintf(output, "Compiled Expression : %d elements\n", 1305 comp->nbStep); 1306 i = comp->last; 1307 xmlXPathDebugDumpStepOp(output, comp, &comp->steps[i], depth + 1); 1308 } 1309 1310 #ifdef XP_DEBUG_OBJ_USAGE 1311 1312 /* 1313 * XPath object usage related debugging variables. 1314 */ 1315 static int xmlXPathDebugObjCounterUndefined = 0; 1316 static int xmlXPathDebugObjCounterNodeset = 0; 1317 static int xmlXPathDebugObjCounterBool = 0; 1318 static int xmlXPathDebugObjCounterNumber = 0; 1319 static int xmlXPathDebugObjCounterString = 0; 1320 static int xmlXPathDebugObjCounterPoint = 0; 1321 static int xmlXPathDebugObjCounterRange = 0; 1322 static int xmlXPathDebugObjCounterLocset = 0; 1323 static int xmlXPathDebugObjCounterUsers = 0; 1324 static int xmlXPathDebugObjCounterXSLTTree = 0; 1325 static int xmlXPathDebugObjCounterAll = 0; 1326 1327 static int xmlXPathDebugObjTotalUndefined = 0; 1328 static int xmlXPathDebugObjTotalNodeset = 0; 1329 static int xmlXPathDebugObjTotalBool = 0; 1330 static int xmlXPathDebugObjTotalNumber = 0; 1331 static int xmlXPathDebugObjTotalString = 0; 1332 static int xmlXPathDebugObjTotalPoint = 0; 1333 static int xmlXPathDebugObjTotalRange = 0; 1334 static int xmlXPathDebugObjTotalLocset = 0; 1335 static int xmlXPathDebugObjTotalUsers = 0; 1336 static int xmlXPathDebugObjTotalXSLTTree = 0; 1337 static int xmlXPathDebugObjTotalAll = 0; 1338 1339 static int xmlXPathDebugObjMaxUndefined = 0; 1340 static int xmlXPathDebugObjMaxNodeset = 0; 1341 static int xmlXPathDebugObjMaxBool = 0; 1342 static int xmlXPathDebugObjMaxNumber = 0; 1343 static int xmlXPathDebugObjMaxString = 0; 1344 static int xmlXPathDebugObjMaxPoint = 0; 1345 static int xmlXPathDebugObjMaxRange = 0; 1346 static int xmlXPathDebugObjMaxLocset = 0; 1347 static int xmlXPathDebugObjMaxUsers = 0; 1348 static int xmlXPathDebugObjMaxXSLTTree = 0; 1349 static int xmlXPathDebugObjMaxAll = 0; 1350 1351 /* REVISIT TODO: Make this static when committing */ 1352 static void 1353 xmlXPathDebugObjUsageReset(xmlXPathContextPtr ctxt) 1354 { 1355 if (ctxt != NULL) { 1356 if (ctxt->cache != NULL) { 1357 xmlXPathContextCachePtr cache = 1358 (xmlXPathContextCachePtr) ctxt->cache; 1359 1360 cache->dbgCachedAll = 0; 1361 cache->dbgCachedNodeset = 0; 1362 cache->dbgCachedString = 0; 1363 cache->dbgCachedBool = 0; 1364 cache->dbgCachedNumber = 0; 1365 cache->dbgCachedPoint = 0; 1366 cache->dbgCachedRange = 0; 1367 cache->dbgCachedLocset = 0; 1368 cache->dbgCachedUsers = 0; 1369 cache->dbgCachedXSLTTree = 0; 1370 cache->dbgCachedUndefined = 0; 1371 1372 cache->dbgReusedAll = 0; 1373 cache->dbgReusedNodeset = 0; 1374 cache->dbgReusedString = 0; 1375 cache->dbgReusedBool = 0; 1376 cache->dbgReusedNumber = 0; 1377 cache->dbgReusedPoint = 0; 1378 cache->dbgReusedRange = 0; 1379 cache->dbgReusedLocset = 0; 1380 cache->dbgReusedUsers = 0; 1381 cache->dbgReusedXSLTTree = 0; 1382 cache->dbgReusedUndefined = 0; 1383 } 1384 } 1385 1386 xmlXPathDebugObjCounterUndefined = 0; 1387 xmlXPathDebugObjCounterNodeset = 0; 1388 xmlXPathDebugObjCounterBool = 0; 1389 xmlXPathDebugObjCounterNumber = 0; 1390 xmlXPathDebugObjCounterString = 0; 1391 xmlXPathDebugObjCounterPoint = 0; 1392 xmlXPathDebugObjCounterRange = 0; 1393 xmlXPathDebugObjCounterLocset = 0; 1394 xmlXPathDebugObjCounterUsers = 0; 1395 xmlXPathDebugObjCounterXSLTTree = 0; 1396 xmlXPathDebugObjCounterAll = 0; 1397 1398 xmlXPathDebugObjTotalUndefined = 0; 1399 xmlXPathDebugObjTotalNodeset = 0; 1400 xmlXPathDebugObjTotalBool = 0; 1401 xmlXPathDebugObjTotalNumber = 0; 1402 xmlXPathDebugObjTotalString = 0; 1403 xmlXPathDebugObjTotalPoint = 0; 1404 xmlXPathDebugObjTotalRange = 0; 1405 xmlXPathDebugObjTotalLocset = 0; 1406 xmlXPathDebugObjTotalUsers = 0; 1407 xmlXPathDebugObjTotalXSLTTree = 0; 1408 xmlXPathDebugObjTotalAll = 0; 1409 1410 xmlXPathDebugObjMaxUndefined = 0; 1411 xmlXPathDebugObjMaxNodeset = 0; 1412 xmlXPathDebugObjMaxBool = 0; 1413 xmlXPathDebugObjMaxNumber = 0; 1414 xmlXPathDebugObjMaxString = 0; 1415 xmlXPathDebugObjMaxPoint = 0; 1416 xmlXPathDebugObjMaxRange = 0; 1417 xmlXPathDebugObjMaxLocset = 0; 1418 xmlXPathDebugObjMaxUsers = 0; 1419 xmlXPathDebugObjMaxXSLTTree = 0; 1420 xmlXPathDebugObjMaxAll = 0; 1421 1422 } 1423 1424 static void 1425 xmlXPathDebugObjUsageRequested(xmlXPathContextPtr ctxt, 1426 xmlXPathObjectType objType) 1427 { 1428 int isCached = 0; 1429 1430 if (ctxt != NULL) { 1431 if (ctxt->cache != NULL) { 1432 xmlXPathContextCachePtr cache = 1433 (xmlXPathContextCachePtr) ctxt->cache; 1434 1435 isCached = 1; 1436 1437 cache->dbgReusedAll++; 1438 switch (objType) { 1439 case XPATH_UNDEFINED: 1440 cache->dbgReusedUndefined++; 1441 break; 1442 case XPATH_NODESET: 1443 cache->dbgReusedNodeset++; 1444 break; 1445 case XPATH_BOOLEAN: 1446 cache->dbgReusedBool++; 1447 break; 1448 case XPATH_NUMBER: 1449 cache->dbgReusedNumber++; 1450 break; 1451 case XPATH_STRING: 1452 cache->dbgReusedString++; 1453 break; 1454 case XPATH_POINT: 1455 cache->dbgReusedPoint++; 1456 break; 1457 case XPATH_RANGE: 1458 cache->dbgReusedRange++; 1459 break; 1460 case XPATH_LOCATIONSET: 1461 cache->dbgReusedLocset++; 1462 break; 1463 case XPATH_USERS: 1464 cache->dbgReusedUsers++; 1465 break; 1466 case XPATH_XSLT_TREE: 1467 cache->dbgReusedXSLTTree++; 1468 break; 1469 default: 1470 break; 1471 } 1472 } 1473 } 1474 1475 switch (objType) { 1476 case XPATH_UNDEFINED: 1477 if (! isCached) 1478 xmlXPathDebugObjTotalUndefined++; 1479 xmlXPathDebugObjCounterUndefined++; 1480 if (xmlXPathDebugObjCounterUndefined > 1481 xmlXPathDebugObjMaxUndefined) 1482 xmlXPathDebugObjMaxUndefined = 1483 xmlXPathDebugObjCounterUndefined; 1484 break; 1485 case XPATH_NODESET: 1486 if (! isCached) 1487 xmlXPathDebugObjTotalNodeset++; 1488 xmlXPathDebugObjCounterNodeset++; 1489 if (xmlXPathDebugObjCounterNodeset > 1490 xmlXPathDebugObjMaxNodeset) 1491 xmlXPathDebugObjMaxNodeset = 1492 xmlXPathDebugObjCounterNodeset; 1493 break; 1494 case XPATH_BOOLEAN: 1495 if (! isCached) 1496 xmlXPathDebugObjTotalBool++; 1497 xmlXPathDebugObjCounterBool++; 1498 if (xmlXPathDebugObjCounterBool > 1499 xmlXPathDebugObjMaxBool) 1500 xmlXPathDebugObjMaxBool = 1501 xmlXPathDebugObjCounterBool; 1502 break; 1503 case XPATH_NUMBER: 1504 if (! isCached) 1505 xmlXPathDebugObjTotalNumber++; 1506 xmlXPathDebugObjCounterNumber++; 1507 if (xmlXPathDebugObjCounterNumber > 1508 xmlXPathDebugObjMaxNumber) 1509 xmlXPathDebugObjMaxNumber = 1510 xmlXPathDebugObjCounterNumber; 1511 break; 1512 case XPATH_STRING: 1513 if (! isCached) 1514 xmlXPathDebugObjTotalString++; 1515 xmlXPathDebugObjCounterString++; 1516 if (xmlXPathDebugObjCounterString > 1517 xmlXPathDebugObjMaxString) 1518 xmlXPathDebugObjMaxString = 1519 xmlXPathDebugObjCounterString; 1520 break; 1521 case XPATH_POINT: 1522 if (! isCached) 1523 xmlXPathDebugObjTotalPoint++; 1524 xmlXPathDebugObjCounterPoint++; 1525 if (xmlXPathDebugObjCounterPoint > 1526 xmlXPathDebugObjMaxPoint) 1527 xmlXPathDebugObjMaxPoint = 1528 xmlXPathDebugObjCounterPoint; 1529 break; 1530 case XPATH_RANGE: 1531 if (! isCached) 1532 xmlXPathDebugObjTotalRange++; 1533 xmlXPathDebugObjCounterRange++; 1534 if (xmlXPathDebugObjCounterRange > 1535 xmlXPathDebugObjMaxRange) 1536 xmlXPathDebugObjMaxRange = 1537 xmlXPathDebugObjCounterRange; 1538 break; 1539 case XPATH_LOCATIONSET: 1540 if (! isCached) 1541 xmlXPathDebugObjTotalLocset++; 1542 xmlXPathDebugObjCounterLocset++; 1543 if (xmlXPathDebugObjCounterLocset > 1544 xmlXPathDebugObjMaxLocset) 1545 xmlXPathDebugObjMaxLocset = 1546 xmlXPathDebugObjCounterLocset; 1547 break; 1548 case XPATH_USERS: 1549 if (! isCached) 1550 xmlXPathDebugObjTotalUsers++; 1551 xmlXPathDebugObjCounterUsers++; 1552 if (xmlXPathDebugObjCounterUsers > 1553 xmlXPathDebugObjMaxUsers) 1554 xmlXPathDebugObjMaxUsers = 1555 xmlXPathDebugObjCounterUsers; 1556 break; 1557 case XPATH_XSLT_TREE: 1558 if (! isCached) 1559 xmlXPathDebugObjTotalXSLTTree++; 1560 xmlXPathDebugObjCounterXSLTTree++; 1561 if (xmlXPathDebugObjCounterXSLTTree > 1562 xmlXPathDebugObjMaxXSLTTree) 1563 xmlXPathDebugObjMaxXSLTTree = 1564 xmlXPathDebugObjCounterXSLTTree; 1565 break; 1566 default: 1567 break; 1568 } 1569 if (! isCached) 1570 xmlXPathDebugObjTotalAll++; 1571 xmlXPathDebugObjCounterAll++; 1572 if (xmlXPathDebugObjCounterAll > 1573 xmlXPathDebugObjMaxAll) 1574 xmlXPathDebugObjMaxAll = 1575 xmlXPathDebugObjCounterAll; 1576 } 1577 1578 static void 1579 xmlXPathDebugObjUsageReleased(xmlXPathContextPtr ctxt, 1580 xmlXPathObjectType objType) 1581 { 1582 int isCached = 0; 1583 1584 if (ctxt != NULL) { 1585 if (ctxt->cache != NULL) { 1586 xmlXPathContextCachePtr cache = 1587 (xmlXPathContextCachePtr) ctxt->cache; 1588 1589 isCached = 1; 1590 1591 cache->dbgCachedAll++; 1592 switch (objType) { 1593 case XPATH_UNDEFINED: 1594 cache->dbgCachedUndefined++; 1595 break; 1596 case XPATH_NODESET: 1597 cache->dbgCachedNodeset++; 1598 break; 1599 case XPATH_BOOLEAN: 1600 cache->dbgCachedBool++; 1601 break; 1602 case XPATH_NUMBER: 1603 cache->dbgCachedNumber++; 1604 break; 1605 case XPATH_STRING: 1606 cache->dbgCachedString++; 1607 break; 1608 case XPATH_POINT: 1609 cache->dbgCachedPoint++; 1610 break; 1611 case XPATH_RANGE: 1612 cache->dbgCachedRange++; 1613 break; 1614 case XPATH_LOCATIONSET: 1615 cache->dbgCachedLocset++; 1616 break; 1617 case XPATH_USERS: 1618 cache->dbgCachedUsers++; 1619 break; 1620 case XPATH_XSLT_TREE: 1621 cache->dbgCachedXSLTTree++; 1622 break; 1623 default: 1624 break; 1625 } 1626 1627 } 1628 } 1629 switch (objType) { 1630 case XPATH_UNDEFINED: 1631 xmlXPathDebugObjCounterUndefined--; 1632 break; 1633 case XPATH_NODESET: 1634 xmlXPathDebugObjCounterNodeset--; 1635 break; 1636 case XPATH_BOOLEAN: 1637 xmlXPathDebugObjCounterBool--; 1638 break; 1639 case XPATH_NUMBER: 1640 xmlXPathDebugObjCounterNumber--; 1641 break; 1642 case XPATH_STRING: 1643 xmlXPathDebugObjCounterString--; 1644 break; 1645 case XPATH_POINT: 1646 xmlXPathDebugObjCounterPoint--; 1647 break; 1648 case XPATH_RANGE: 1649 xmlXPathDebugObjCounterRange--; 1650 break; 1651 case XPATH_LOCATIONSET: 1652 xmlXPathDebugObjCounterLocset--; 1653 break; 1654 case XPATH_USERS: 1655 xmlXPathDebugObjCounterUsers--; 1656 break; 1657 case XPATH_XSLT_TREE: 1658 xmlXPathDebugObjCounterXSLTTree--; 1659 break; 1660 default: 1661 break; 1662 } 1663 xmlXPathDebugObjCounterAll--; 1664 } 1665 1666 /* REVISIT TODO: Make this static when committing */ 1667 static void 1668 xmlXPathDebugObjUsageDisplay(xmlXPathContextPtr ctxt) 1669 { 1670 int reqAll, reqNodeset, reqString, reqBool, reqNumber, 1671 reqXSLTTree, reqUndefined; 1672 int caAll = 0, caNodeset = 0, caString = 0, caBool = 0, 1673 caNumber = 0, caXSLTTree = 0, caUndefined = 0; 1674 int reAll = 0, reNodeset = 0, reString = 0, reBool = 0, 1675 reNumber = 0, reXSLTTree = 0, reUndefined = 0; 1676 int leftObjs = xmlXPathDebugObjCounterAll; 1677 1678 reqAll = xmlXPathDebugObjTotalAll; 1679 reqNodeset = xmlXPathDebugObjTotalNodeset; 1680 reqString = xmlXPathDebugObjTotalString; 1681 reqBool = xmlXPathDebugObjTotalBool; 1682 reqNumber = xmlXPathDebugObjTotalNumber; 1683 reqXSLTTree = xmlXPathDebugObjTotalXSLTTree; 1684 reqUndefined = xmlXPathDebugObjTotalUndefined; 1685 1686 printf("# XPath object usage:\n"); 1687 1688 if (ctxt != NULL) { 1689 if (ctxt->cache != NULL) { 1690 xmlXPathContextCachePtr cache = 1691 (xmlXPathContextCachePtr) ctxt->cache; 1692 1693 reAll = cache->dbgReusedAll; 1694 reqAll += reAll; 1695 reNodeset = cache->dbgReusedNodeset; 1696 reqNodeset += reNodeset; 1697 reString = cache->dbgReusedString; 1698 reqString += reString; 1699 reBool = cache->dbgReusedBool; 1700 reqBool += reBool; 1701 reNumber = cache->dbgReusedNumber; 1702 reqNumber += reNumber; 1703 reXSLTTree = cache->dbgReusedXSLTTree; 1704 reqXSLTTree += reXSLTTree; 1705 reUndefined = cache->dbgReusedUndefined; 1706 reqUndefined += reUndefined; 1707 1708 caAll = cache->dbgCachedAll; 1709 caBool = cache->dbgCachedBool; 1710 caNodeset = cache->dbgCachedNodeset; 1711 caString = cache->dbgCachedString; 1712 caNumber = cache->dbgCachedNumber; 1713 caXSLTTree = cache->dbgCachedXSLTTree; 1714 caUndefined = cache->dbgCachedUndefined; 1715 1716 if (cache->nodesetObjs) 1717 leftObjs -= cache->nodesetObjs->number; 1718 if (cache->stringObjs) 1719 leftObjs -= cache->stringObjs->number; 1720 if (cache->booleanObjs) 1721 leftObjs -= cache->booleanObjs->number; 1722 if (cache->numberObjs) 1723 leftObjs -= cache->numberObjs->number; 1724 if (cache->miscObjs) 1725 leftObjs -= cache->miscObjs->number; 1726 } 1727 } 1728 1729 printf("# all\n"); 1730 printf("# total : %d\n", reqAll); 1731 printf("# left : %d\n", leftObjs); 1732 printf("# created: %d\n", xmlXPathDebugObjTotalAll); 1733 printf("# reused : %d\n", reAll); 1734 printf("# max : %d\n", xmlXPathDebugObjMaxAll); 1735 1736 printf("# node-sets\n"); 1737 printf("# total : %d\n", reqNodeset); 1738 printf("# created: %d\n", xmlXPathDebugObjTotalNodeset); 1739 printf("# reused : %d\n", reNodeset); 1740 printf("# max : %d\n", xmlXPathDebugObjMaxNodeset); 1741 1742 printf("# strings\n"); 1743 printf("# total : %d\n", reqString); 1744 printf("# created: %d\n", xmlXPathDebugObjTotalString); 1745 printf("# reused : %d\n", reString); 1746 printf("# max : %d\n", xmlXPathDebugObjMaxString); 1747 1748 printf("# booleans\n"); 1749 printf("# total : %d\n", reqBool); 1750 printf("# created: %d\n", xmlXPathDebugObjTotalBool); 1751 printf("# reused : %d\n", reBool); 1752 printf("# max : %d\n", xmlXPathDebugObjMaxBool); 1753 1754 printf("# numbers\n"); 1755 printf("# total : %d\n", reqNumber); 1756 printf("# created: %d\n", xmlXPathDebugObjTotalNumber); 1757 printf("# reused : %d\n", reNumber); 1758 printf("# max : %d\n", xmlXPathDebugObjMaxNumber); 1759 1760 printf("# XSLT result tree fragments\n"); 1761 printf("# total : %d\n", reqXSLTTree); 1762 printf("# created: %d\n", xmlXPathDebugObjTotalXSLTTree); 1763 printf("# reused : %d\n", reXSLTTree); 1764 printf("# max : %d\n", xmlXPathDebugObjMaxXSLTTree); 1765 1766 printf("# undefined\n"); 1767 printf("# total : %d\n", reqUndefined); 1768 printf("# created: %d\n", xmlXPathDebugObjTotalUndefined); 1769 printf("# reused : %d\n", reUndefined); 1770 printf("# max : %d\n", xmlXPathDebugObjMaxUndefined); 1771 1772 } 1773 1774 #endif /* XP_DEBUG_OBJ_USAGE */ 1775 1776 #endif /* LIBXML_DEBUG_ENABLED */ 1777 1778 /************************************************************************ 1779 * * 1780 * XPath object caching * 1781 * * 1782 ************************************************************************/ 1783 1784 /** 1785 * xmlXPathNewCache: 1786 * 1787 * Create a new object cache 1788 * 1789 * Returns the xmlXPathCache just allocated. 1790 */ 1791 static xmlXPathContextCachePtr 1792 xmlXPathNewCache(void) 1793 { 1794 xmlXPathContextCachePtr ret; 1795 1796 ret = (xmlXPathContextCachePtr) xmlMalloc(sizeof(xmlXPathContextCache)); 1797 if (ret == NULL) { 1798 xmlXPathErrMemory(NULL, "creating object cache\n"); 1799 return(NULL); 1800 } 1801 memset(ret, 0 , (size_t) sizeof(xmlXPathContextCache)); 1802 ret->maxNodeset = 100; 1803 ret->maxString = 100; 1804 ret->maxBoolean = 100; 1805 ret->maxNumber = 100; 1806 ret->maxMisc = 100; 1807 return(ret); 1808 } 1809 1810 static void 1811 xmlXPathCacheFreeObjectList(xmlPointerListPtr list) 1812 { 1813 int i; 1814 xmlXPathObjectPtr obj; 1815 1816 if (list == NULL) 1817 return; 1818 1819 for (i = 0; i < list->number; i++) { 1820 obj = list->items[i]; 1821 /* 1822 * Note that it is already assured that we don't need to 1823 * look out for namespace nodes in the node-set. 1824 */ 1825 if (obj->nodesetval != NULL) { 1826 if (obj->nodesetval->nodeTab != NULL) 1827 xmlFree(obj->nodesetval->nodeTab); 1828 xmlFree(obj->nodesetval); 1829 } 1830 xmlFree(obj); 1831 #ifdef XP_DEBUG_OBJ_USAGE 1832 xmlXPathDebugObjCounterAll--; 1833 #endif 1834 } 1835 xmlPointerListFree(list); 1836 } 1837 1838 static void 1839 xmlXPathFreeCache(xmlXPathContextCachePtr cache) 1840 { 1841 if (cache == NULL) 1842 return; 1843 if (cache->nodesetObjs) 1844 xmlXPathCacheFreeObjectList(cache->nodesetObjs); 1845 if (cache->stringObjs) 1846 xmlXPathCacheFreeObjectList(cache->stringObjs); 1847 if (cache->booleanObjs) 1848 xmlXPathCacheFreeObjectList(cache->booleanObjs); 1849 if (cache->numberObjs) 1850 xmlXPathCacheFreeObjectList(cache->numberObjs); 1851 if (cache->miscObjs) 1852 xmlXPathCacheFreeObjectList(cache->miscObjs); 1853 xmlFree(cache); 1854 } 1855 1856 /** 1857 * xmlXPathContextSetCache: 1858 * 1859 * @ctxt: the XPath context 1860 * @active: enables/disables (creates/frees) the cache 1861 * @value: a value with semantics dependant on @options 1862 * @options: options (currently only the value 0 is used) 1863 * 1864 * Creates/frees an object cache on the XPath context. 1865 * If activates XPath objects (xmlXPathObject) will be cached internally 1866 * to be reused. 1867 * @options: 1868 * 0: This will set the XPath object caching: 1869 * @value: 1870 * This will set the maximum number of XPath objects 1871 * to be cached per slot 1872 * There are 5 slots for: node-set, string, number, boolean, and 1873 * misc objects. Use <0 for the default number (100). 1874 * Other values for @options have currently no effect. 1875 * 1876 * Returns 0 if the setting succeeded, and -1 on API or internal errors. 1877 */ 1878 int 1879 xmlXPathContextSetCache(xmlXPathContextPtr ctxt, 1880 int active, 1881 int value, 1882 int options) 1883 { 1884 if (ctxt == NULL) 1885 return(-1); 1886 if (active) { 1887 xmlXPathContextCachePtr cache; 1888 1889 if (ctxt->cache == NULL) { 1890 ctxt->cache = xmlXPathNewCache(); 1891 if (ctxt->cache == NULL) 1892 return(-1); 1893 } 1894 cache = (xmlXPathContextCachePtr) ctxt->cache; 1895 if (options == 0) { 1896 if (value < 0) 1897 value = 100; 1898 cache->maxNodeset = value; 1899 cache->maxString = value; 1900 cache->maxNumber = value; 1901 cache->maxBoolean = value; 1902 cache->maxMisc = value; 1903 } 1904 } else if (ctxt->cache != NULL) { 1905 xmlXPathFreeCache((xmlXPathContextCachePtr) ctxt->cache); 1906 ctxt->cache = NULL; 1907 } 1908 return(0); 1909 } 1910 1911 /** 1912 * xmlXPathCacheWrapNodeSet: 1913 * @ctxt: the XPath context 1914 * @val: the NodePtr value 1915 * 1916 * This is the cached version of xmlXPathWrapNodeSet(). 1917 * Wrap the Nodeset @val in a new xmlXPathObjectPtr 1918 * 1919 * Returns the created or reused object. 1920 */ 1921 static xmlXPathObjectPtr 1922 xmlXPathCacheWrapNodeSet(xmlXPathContextPtr ctxt, xmlNodeSetPtr val) 1923 { 1924 if ((ctxt != NULL) && (ctxt->cache != NULL)) { 1925 xmlXPathContextCachePtr cache = 1926 (xmlXPathContextCachePtr) ctxt->cache; 1927 1928 if ((cache->miscObjs != NULL) && 1929 (cache->miscObjs->number != 0)) 1930 { 1931 xmlXPathObjectPtr ret; 1932 1933 ret = (xmlXPathObjectPtr) 1934 cache->miscObjs->items[--cache->miscObjs->number]; 1935 ret->type = XPATH_NODESET; 1936 ret->nodesetval = val; 1937 #ifdef XP_DEBUG_OBJ_USAGE 1938 xmlXPathDebugObjUsageRequested(ctxt, XPATH_NODESET); 1939 #endif 1940 return(ret); 1941 } 1942 } 1943 1944 return(xmlXPathWrapNodeSet(val)); 1945 1946 } 1947 1948 /** 1949 * xmlXPathCacheWrapString: 1950 * @ctxt: the XPath context 1951 * @val: the xmlChar * value 1952 * 1953 * This is the cached version of xmlXPathWrapString(). 1954 * Wraps the @val string into an XPath object. 1955 * 1956 * Returns the created or reused object. 1957 */ 1958 static xmlXPathObjectPtr 1959 xmlXPathCacheWrapString(xmlXPathContextPtr ctxt, xmlChar *val) 1960 { 1961 if ((ctxt != NULL) && (ctxt->cache != NULL)) { 1962 xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache; 1963 1964 if ((cache->stringObjs != NULL) && 1965 (cache->stringObjs->number != 0)) 1966 { 1967 1968 xmlXPathObjectPtr ret; 1969 1970 ret = (xmlXPathObjectPtr) 1971 cache->stringObjs->items[--cache->stringObjs->number]; 1972 ret->type = XPATH_STRING; 1973 ret->stringval = val; 1974 #ifdef XP_DEBUG_OBJ_USAGE 1975 xmlXPathDebugObjUsageRequested(ctxt, XPATH_STRING); 1976 #endif 1977 return(ret); 1978 } else if ((cache->miscObjs != NULL) && 1979 (cache->miscObjs->number != 0)) 1980 { 1981 xmlXPathObjectPtr ret; 1982 /* 1983 * Fallback to misc-cache. 1984 */ 1985 ret = (xmlXPathObjectPtr) 1986 cache->miscObjs->items[--cache->miscObjs->number]; 1987 1988 ret->type = XPATH_STRING; 1989 ret->stringval = val; 1990 #ifdef XP_DEBUG_OBJ_USAGE 1991 xmlXPathDebugObjUsageRequested(ctxt, XPATH_STRING); 1992 #endif 1993 return(ret); 1994 } 1995 } 1996 return(xmlXPathWrapString(val)); 1997 } 1998 1999 /** 2000 * xmlXPathCacheNewNodeSet: 2001 * @ctxt: the XPath context 2002 * @val: the NodePtr value 2003 * 2004 * This is the cached version of xmlXPathNewNodeSet(). 2005 * Acquire an xmlXPathObjectPtr of type NodeSet and initialize 2006 * it with the single Node @val 2007 * 2008 * Returns the created or reused object. 2009 */ 2010 static xmlXPathObjectPtr 2011 xmlXPathCacheNewNodeSet(xmlXPathContextPtr ctxt, xmlNodePtr val) 2012 { 2013 if ((ctxt != NULL) && (ctxt->cache)) { 2014 xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache; 2015 2016 if ((cache->nodesetObjs != NULL) && 2017 (cache->nodesetObjs->number != 0)) 2018 { 2019 xmlXPathObjectPtr ret; 2020 /* 2021 * Use the nodset-cache. 2022 */ 2023 ret = (xmlXPathObjectPtr) 2024 cache->nodesetObjs->items[--cache->nodesetObjs->number]; 2025 ret->type = XPATH_NODESET; 2026 ret->boolval = 0; 2027 if (val) { 2028 if ((ret->nodesetval->nodeMax == 0) || 2029 (val->type == XML_NAMESPACE_DECL)) 2030 { 2031 xmlXPathNodeSetAddUnique(ret->nodesetval, val); 2032 } else { 2033 ret->nodesetval->nodeTab[0] = val; 2034 ret->nodesetval->nodeNr = 1; 2035 } 2036 } 2037 #ifdef XP_DEBUG_OBJ_USAGE 2038 xmlXPathDebugObjUsageRequested(ctxt, XPATH_NODESET); 2039 #endif 2040 return(ret); 2041 } else if ((cache->miscObjs != NULL) && 2042 (cache->miscObjs->number != 0)) 2043 { 2044 xmlXPathObjectPtr ret; 2045 /* 2046 * Fallback to misc-cache. 2047 */ 2048 2049 ret = (xmlXPathObjectPtr) 2050 cache->miscObjs->items[--cache->miscObjs->number]; 2051 2052 ret->type = XPATH_NODESET; 2053 ret->boolval = 0; 2054 ret->nodesetval = xmlXPathNodeSetCreate(val); 2055 #ifdef XP_DEBUG_OBJ_USAGE 2056 xmlXPathDebugObjUsageRequested(ctxt, XPATH_NODESET); 2057 #endif 2058 return(ret); 2059 } 2060 } 2061 return(xmlXPathNewNodeSet(val)); 2062 } 2063 2064 /** 2065 * xmlXPathCacheNewCString: 2066 * @ctxt: the XPath context 2067 * @val: the char * value 2068 * 2069 * This is the cached version of xmlXPathNewCString(). 2070 * Acquire an xmlXPathObjectPtr of type string and of value @val 2071 * 2072 * Returns the created or reused object. 2073 */ 2074 static xmlXPathObjectPtr 2075 xmlXPathCacheNewCString(xmlXPathContextPtr ctxt, const char *val) 2076 { 2077 if ((ctxt != NULL) && (ctxt->cache)) { 2078 xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache; 2079 2080 if ((cache->stringObjs != NULL) && 2081 (cache->stringObjs->number != 0)) 2082 { 2083 xmlXPathObjectPtr ret; 2084 2085 ret = (xmlXPathObjectPtr) 2086 cache->stringObjs->items[--cache->stringObjs->number]; 2087 2088 ret->type = XPATH_STRING; 2089 ret->stringval = xmlStrdup(BAD_CAST val); 2090 #ifdef XP_DEBUG_OBJ_USAGE 2091 xmlXPathDebugObjUsageRequested(ctxt, XPATH_STRING); 2092 #endif 2093 return(ret); 2094 } else if ((cache->miscObjs != NULL) && 2095 (cache->miscObjs->number != 0)) 2096 { 2097 xmlXPathObjectPtr ret; 2098 2099 ret = (xmlXPathObjectPtr) 2100 cache->miscObjs->items[--cache->miscObjs->number]; 2101 2102 ret->type = XPATH_STRING; 2103 ret->stringval = xmlStrdup(BAD_CAST val); 2104 #ifdef XP_DEBUG_OBJ_USAGE 2105 xmlXPathDebugObjUsageRequested(ctxt, XPATH_STRING); 2106 #endif 2107 return(ret); 2108 } 2109 } 2110 return(xmlXPathNewCString(val)); 2111 } 2112 2113 /** 2114 * xmlXPathCacheNewString: 2115 * @ctxt: the XPath context 2116 * @val: the xmlChar * value 2117 * 2118 * This is the cached version of xmlXPathNewString(). 2119 * Acquire an xmlXPathObjectPtr of type string and of value @val 2120 * 2121 * Returns the created or reused object. 2122 */ 2123 static xmlXPathObjectPtr 2124 xmlXPathCacheNewString(xmlXPathContextPtr ctxt, const xmlChar *val) 2125 { 2126 if ((ctxt != NULL) && (ctxt->cache)) { 2127 xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache; 2128 2129 if ((cache->stringObjs != NULL) && 2130 (cache->stringObjs->number != 0)) 2131 { 2132 xmlXPathObjectPtr ret; 2133 2134 ret = (xmlXPathObjectPtr) 2135 cache->stringObjs->items[--cache->stringObjs->number]; 2136 ret->type = XPATH_STRING; 2137 if (val != NULL) 2138 ret->stringval = xmlStrdup(val); 2139 else 2140 ret->stringval = xmlStrdup((const xmlChar *)""); 2141 #ifdef XP_DEBUG_OBJ_USAGE 2142 xmlXPathDebugObjUsageRequested(ctxt, XPATH_STRING); 2143 #endif 2144 return(ret); 2145 } else if ((cache->miscObjs != NULL) && 2146 (cache->miscObjs->number != 0)) 2147 { 2148 xmlXPathObjectPtr ret; 2149 2150 ret = (xmlXPathObjectPtr) 2151 cache->miscObjs->items[--cache->miscObjs->number]; 2152 2153 ret->type = XPATH_STRING; 2154 if (val != NULL) 2155 ret->stringval = xmlStrdup(val); 2156 else 2157 ret->stringval = xmlStrdup((const xmlChar *)""); 2158 #ifdef XP_DEBUG_OBJ_USAGE 2159 xmlXPathDebugObjUsageRequested(ctxt, XPATH_STRING); 2160 #endif 2161 return(ret); 2162 } 2163 } 2164 return(xmlXPathNewString(val)); 2165 } 2166 2167 /** 2168 * xmlXPathCacheNewBoolean: 2169 * @ctxt: the XPath context 2170 * @val: the boolean value 2171 * 2172 * This is the cached version of xmlXPathNewBoolean(). 2173 * Acquires an xmlXPathObjectPtr of type boolean and of value @val 2174 * 2175 * Returns the created or reused object. 2176 */ 2177 static xmlXPathObjectPtr 2178 xmlXPathCacheNewBoolean(xmlXPathContextPtr ctxt, int val) 2179 { 2180 if ((ctxt != NULL) && (ctxt->cache)) { 2181 xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache; 2182 2183 if ((cache->booleanObjs != NULL) && 2184 (cache->booleanObjs->number != 0)) 2185 { 2186 xmlXPathObjectPtr ret; 2187 2188 ret = (xmlXPathObjectPtr) 2189 cache->booleanObjs->items[--cache->booleanObjs->number]; 2190 ret->type = XPATH_BOOLEAN; 2191 ret->boolval = (val != 0); 2192 #ifdef XP_DEBUG_OBJ_USAGE 2193 xmlXPathDebugObjUsageRequested(ctxt, XPATH_BOOLEAN); 2194 #endif 2195 return(ret); 2196 } else if ((cache->miscObjs != NULL) && 2197 (cache->miscObjs->number != 0)) 2198 { 2199 xmlXPathObjectPtr ret; 2200 2201 ret = (xmlXPathObjectPtr) 2202 cache->miscObjs->items[--cache->miscObjs->number]; 2203 2204 ret->type = XPATH_BOOLEAN; 2205 ret->boolval = (val != 0); 2206 #ifdef XP_DEBUG_OBJ_USAGE 2207 xmlXPathDebugObjUsageRequested(ctxt, XPATH_BOOLEAN); 2208 #endif 2209 return(ret); 2210 } 2211 } 2212 return(xmlXPathNewBoolean(val)); 2213 } 2214 2215 /** 2216 * xmlXPathCacheNewFloat: 2217 * @ctxt: the XPath context 2218 * @val: the double value 2219 * 2220 * This is the cached version of xmlXPathNewFloat(). 2221 * Acquires an xmlXPathObjectPtr of type double and of value @val 2222 * 2223 * Returns the created or reused object. 2224 */ 2225 static xmlXPathObjectPtr 2226 xmlXPathCacheNewFloat(xmlXPathContextPtr ctxt, double val) 2227 { 2228 if ((ctxt != NULL) && (ctxt->cache)) { 2229 xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache; 2230 2231 if ((cache->numberObjs != NULL) && 2232 (cache->numberObjs->number != 0)) 2233 { 2234 xmlXPathObjectPtr ret; 2235 2236 ret = (xmlXPathObjectPtr) 2237 cache->numberObjs->items[--cache->numberObjs->number]; 2238 ret->type = XPATH_NUMBER; 2239 ret->floatval = val; 2240 #ifdef XP_DEBUG_OBJ_USAGE 2241 xmlXPathDebugObjUsageRequested(ctxt, XPATH_NUMBER); 2242 #endif 2243 return(ret); 2244 } else if ((cache->miscObjs != NULL) && 2245 (cache->miscObjs->number != 0)) 2246 { 2247 xmlXPathObjectPtr ret; 2248 2249 ret = (xmlXPathObjectPtr) 2250 cache->miscObjs->items[--cache->miscObjs->number]; 2251 2252 ret->type = XPATH_NUMBER; 2253 ret->floatval = val; 2254 #ifdef XP_DEBUG_OBJ_USAGE 2255 xmlXPathDebugObjUsageRequested(ctxt, XPATH_NUMBER); 2256 #endif 2257 return(ret); 2258 } 2259 } 2260 return(xmlXPathNewFloat(val)); 2261 } 2262 2263 /** 2264 * xmlXPathCacheConvertString: 2265 * @ctxt: the XPath context 2266 * @val: an XPath object 2267 * 2268 * This is the cached version of xmlXPathConvertString(). 2269 * Converts an existing object to its string() equivalent 2270 * 2271 * Returns a created or reused object, the old one is freed (cached) 2272 * (or the operation is done directly on @val) 2273 */ 2274 2275 static xmlXPathObjectPtr 2276 xmlXPathCacheConvertString(xmlXPathContextPtr ctxt, xmlXPathObjectPtr val) { 2277 xmlChar *res = NULL; 2278 2279 if (val == NULL) 2280 return(xmlXPathCacheNewCString(ctxt, "")); 2281 2282 switch (val->type) { 2283 case XPATH_UNDEFINED: 2284 #ifdef DEBUG_EXPR 2285 xmlGenericError(xmlGenericErrorContext, "STRING: undefined\n"); 2286 #endif 2287 break; 2288 case XPATH_NODESET: 2289 case XPATH_XSLT_TREE: 2290 res = xmlXPathCastNodeSetToString(val->nodesetval); 2291 break; 2292 case XPATH_STRING: 2293 return(val); 2294 case XPATH_BOOLEAN: 2295 res = xmlXPathCastBooleanToString(val->boolval); 2296 break; 2297 case XPATH_NUMBER: 2298 res = xmlXPathCastNumberToString(val->floatval); 2299 break; 2300 case XPATH_USERS: 2301 case XPATH_POINT: 2302 case XPATH_RANGE: 2303 case XPATH_LOCATIONSET: 2304 TODO; 2305 break; 2306 } 2307 xmlXPathReleaseObject(ctxt, val); 2308 if (res == NULL) 2309 return(xmlXPathCacheNewCString(ctxt, "")); 2310 return(xmlXPathCacheWrapString(ctxt, res)); 2311 } 2312 2313 /** 2314 * xmlXPathCacheObjectCopy: 2315 * @ctxt: the XPath context 2316 * @val: the original object 2317 * 2318 * This is the cached version of xmlXPathObjectCopy(). 2319 * Acquire a copy of a given object 2320 * 2321 * Returns a created or reused created object. 2322 */ 2323 static xmlXPathObjectPtr 2324 xmlXPathCacheObjectCopy(xmlXPathContextPtr ctxt, xmlXPathObjectPtr val) 2325 { 2326 if (val == NULL) 2327 return(NULL); 2328 2329 if (XP_HAS_CACHE(ctxt)) { 2330 switch (val->type) { 2331 case XPATH_NODESET: 2332 return(xmlXPathCacheWrapNodeSet(ctxt, 2333 xmlXPathNodeSetMerge(NULL, val->nodesetval))); 2334 case XPATH_STRING: 2335 return(xmlXPathCacheNewString(ctxt, val->stringval)); 2336 case XPATH_BOOLEAN: 2337 return(xmlXPathCacheNewBoolean(ctxt, val->boolval)); 2338 case XPATH_NUMBER: 2339 return(xmlXPathCacheNewFloat(ctxt, val->floatval)); 2340 default: 2341 break; 2342 } 2343 } 2344 return(xmlXPathObjectCopy(val)); 2345 } 2346 2347 /** 2348 * xmlXPathCacheConvertBoolean: 2349 * @ctxt: the XPath context 2350 * @val: an XPath object 2351 * 2352 * This is the cached version of xmlXPathConvertBoolean(). 2353 * Converts an existing object to its boolean() equivalent 2354 * 2355 * Returns a created or reused object, the old one is freed (or the operation 2356 * is done directly on @val) 2357 */ 2358 static xmlXPathObjectPtr 2359 xmlXPathCacheConvertBoolean(xmlXPathContextPtr ctxt, xmlXPathObjectPtr val) { 2360 xmlXPathObjectPtr ret; 2361 2362 if (val == NULL) 2363 return(xmlXPathCacheNewBoolean(ctxt, 0)); 2364 if (val->type == XPATH_BOOLEAN) 2365 return(val); 2366 ret = xmlXPathCacheNewBoolean(ctxt, xmlXPathCastToBoolean(val)); 2367 xmlXPathReleaseObject(ctxt, val); 2368 return(ret); 2369 } 2370 2371 /** 2372 * xmlXPathCacheConvertNumber: 2373 * @ctxt: the XPath context 2374 * @val: an XPath object 2375 * 2376 * This is the cached version of xmlXPathConvertNumber(). 2377 * Converts an existing object to its number() equivalent 2378 * 2379 * Returns a created or reused object, the old one is freed (or the operation 2380 * is done directly on @val) 2381 */ 2382 static xmlXPathObjectPtr 2383 xmlXPathCacheConvertNumber(xmlXPathContextPtr ctxt, xmlXPathObjectPtr val) { 2384 xmlXPathObjectPtr ret; 2385 2386 if (val == NULL) 2387 return(xmlXPathCacheNewFloat(ctxt, 0.0)); 2388 if (val->type == XPATH_NUMBER) 2389 return(val); 2390 ret = xmlXPathCacheNewFloat(ctxt, xmlXPathCastToNumber(val)); 2391 xmlXPathReleaseObject(ctxt, val); 2392 return(ret); 2393 } 2394 2395 /************************************************************************ 2396 * * 2397 * Parser stacks related functions and macros * 2398 * * 2399 ************************************************************************/ 2400 2401 /** 2402 * xmlXPathSetFrame: 2403 * @ctxt: an XPath parser context 2404 * 2405 * Set the callee evaluation frame 2406 * 2407 * Returns the previous frame value to be restored once done 2408 */ 2409 static int 2410 xmlXPathSetFrame(xmlXPathParserContextPtr ctxt) { 2411 int ret; 2412 2413 if (ctxt == NULL) 2414 return(0); 2415 ret = ctxt->valueFrame; 2416 ctxt->valueFrame = ctxt->valueNr; 2417 return(ret); 2418 } 2419 2420 /** 2421 * xmlXPathPopFrame: 2422 * @ctxt: an XPath parser context 2423 * @frame: the previous frame value 2424 * 2425 * Remove the callee evaluation frame 2426 */ 2427 static void 2428 xmlXPathPopFrame(xmlXPathParserContextPtr ctxt, int frame) { 2429 if (ctxt == NULL) 2430 return; 2431 if (ctxt->valueNr < ctxt->valueFrame) { 2432 xmlXPatherror(ctxt, __FILE__, __LINE__, XPATH_STACK_ERROR); 2433 } 2434 ctxt->valueFrame = frame; 2435 } 2436 2437 /** 2438 * valuePop: 2439 * @ctxt: an XPath evaluation context 2440 * 2441 * Pops the top XPath object from the value stack 2442 * 2443 * Returns the XPath object just removed 2444 */ 2445 xmlXPathObjectPtr 2446 valuePop(xmlXPathParserContextPtr ctxt) 2447 { 2448 xmlXPathObjectPtr ret; 2449 2450 if ((ctxt == NULL) || (ctxt->valueNr <= 0)) 2451 return (NULL); 2452 2453 if (ctxt->valueNr <= ctxt->valueFrame) { 2454 xmlXPatherror(ctxt, __FILE__, __LINE__, XPATH_STACK_ERROR); 2455 return (NULL); 2456 } 2457 2458 ctxt->valueNr--; 2459 if (ctxt->valueNr > 0) 2460 ctxt->value = ctxt->valueTab[ctxt->valueNr - 1]; 2461 else 2462 ctxt->value = NULL; 2463 ret = ctxt->valueTab[ctxt->valueNr]; 2464 ctxt->valueTab[ctxt->valueNr] = NULL; 2465 return (ret); 2466 } 2467 /** 2468 * valuePush: 2469 * @ctxt: an XPath evaluation context 2470 * @value: the XPath object 2471 * 2472 * Pushes a new XPath object on top of the value stack 2473 * 2474 * returns the number of items on the value stack 2475 */ 2476 int 2477 valuePush(xmlXPathParserContextPtr ctxt, xmlXPathObjectPtr value) 2478 { 2479 if ((ctxt == NULL) || (value == NULL)) return(-1); 2480 if (ctxt->valueNr >= ctxt->valueMax) { 2481 xmlXPathObjectPtr *tmp; 2482 2483 tmp = (xmlXPathObjectPtr *) xmlRealloc(ctxt->valueTab, 2484 2 * ctxt->valueMax * 2485 sizeof(ctxt->valueTab[0])); 2486 if (tmp == NULL) { 2487 xmlGenericError(xmlGenericErrorContext, "realloc failed !\n"); 2488 ctxt->error = XPATH_MEMORY_ERROR; 2489 return (0); 2490 } 2491 ctxt->valueMax *= 2; 2492 ctxt->valueTab = tmp; 2493 } 2494 ctxt->valueTab[ctxt->valueNr] = value; 2495 ctxt->value = value; 2496 return (ctxt->valueNr++); 2497 } 2498 2499 /** 2500 * xmlXPathPopBoolean: 2501 * @ctxt: an XPath parser context 2502 * 2503 * Pops a boolean from the stack, handling conversion if needed. 2504 * Check error with #xmlXPathCheckError. 2505 * 2506 * Returns the boolean 2507 */ 2508 int 2509 xmlXPathPopBoolean (xmlXPathParserContextPtr ctxt) { 2510 xmlXPathObjectPtr obj; 2511 int ret; 2512 2513 obj = valuePop(ctxt); 2514 if (obj == NULL) { 2515 xmlXPathSetError(ctxt, XPATH_INVALID_OPERAND); 2516 return(0); 2517 } 2518 if (obj->type != XPATH_BOOLEAN) 2519 ret = xmlXPathCastToBoolean(obj); 2520 else 2521 ret = obj->boolval; 2522 xmlXPathReleaseObject(ctxt->context, obj); 2523 return(ret); 2524 } 2525 2526 /** 2527 * xmlXPathPopNumber: 2528 * @ctxt: an XPath parser context 2529 * 2530 * Pops a number from the stack, handling conversion if needed. 2531 * Check error with #xmlXPathCheckError. 2532 * 2533 * Returns the number 2534 */ 2535 double 2536 xmlXPathPopNumber (xmlXPathParserContextPtr ctxt) { 2537 xmlXPathObjectPtr obj; 2538 double ret; 2539 2540 obj = valuePop(ctxt); 2541 if (obj == NULL) { 2542 xmlXPathSetError(ctxt, XPATH_INVALID_OPERAND); 2543 return(0); 2544 } 2545 if (obj->type != XPATH_NUMBER) 2546 ret = xmlXPathCastToNumber(obj); 2547 else 2548 ret = obj->floatval; 2549 xmlXPathReleaseObject(ctxt->context, obj); 2550 return(ret); 2551 } 2552 2553 /** 2554 * xmlXPathPopString: 2555 * @ctxt: an XPath parser context 2556 * 2557 * Pops a string from the stack, handling conversion if needed. 2558 * Check error with #xmlXPathCheckError. 2559 * 2560 * Returns the string 2561 */ 2562 xmlChar * 2563 xmlXPathPopString (xmlXPathParserContextPtr ctxt) { 2564 xmlXPathObjectPtr obj; 2565 xmlChar * ret; 2566 2567 obj = valuePop(ctxt); 2568 if (obj == NULL) { 2569 xmlXPathSetError(ctxt, XPATH_INVALID_OPERAND); 2570 return(NULL); 2571 } 2572 ret = xmlXPathCastToString(obj); /* this does required strdup */ 2573 /* TODO: needs refactoring somewhere else */ 2574 if (obj->stringval == ret) 2575 obj->stringval = NULL; 2576 xmlXPathReleaseObject(ctxt->context, obj); 2577 return(ret); 2578 } 2579 2580 /** 2581 * xmlXPathPopNodeSet: 2582 * @ctxt: an XPath parser context 2583 * 2584 * Pops a node-set from the stack, handling conversion if needed. 2585 * Check error with #xmlXPathCheckError. 2586 * 2587 * Returns the node-set 2588 */ 2589 xmlNodeSetPtr 2590 xmlXPathPopNodeSet (xmlXPathParserContextPtr ctxt) { 2591 xmlXPathObjectPtr obj; 2592 xmlNodeSetPtr ret; 2593 2594 if (ctxt == NULL) return(NULL); 2595 if (ctxt->value == NULL) { 2596 xmlXPathSetError(ctxt, XPATH_INVALID_OPERAND); 2597 return(NULL); 2598 } 2599 if (!xmlXPathStackIsNodeSet(ctxt)) { 2600 xmlXPathSetTypeError(ctxt); 2601 return(NULL); 2602 } 2603 obj = valuePop(ctxt); 2604 ret = obj->nodesetval; 2605 #if 0 2606 /* to fix memory leak of not clearing obj->user */ 2607 if (obj->boolval && obj->user != NULL) 2608 xmlFreeNodeList((xmlNodePtr) obj->user); 2609 #endif 2610 obj->nodesetval = NULL; 2611 xmlXPathReleaseObject(ctxt->context, obj); 2612 return(ret); 2613 } 2614 2615 /** 2616 * xmlXPathPopExternal: 2617 * @ctxt: an XPath parser context 2618 * 2619 * Pops an external object from the stack, handling conversion if needed. 2620 * Check error with #xmlXPathCheckError. 2621 * 2622 * Returns the object 2623 */ 2624 void * 2625 xmlXPathPopExternal (xmlXPathParserContextPtr ctxt) { 2626 xmlXPathObjectPtr obj; 2627 void * ret; 2628 2629 if ((ctxt == NULL) || (ctxt->value == NULL)) { 2630 xmlXPathSetError(ctxt, XPATH_INVALID_OPERAND); 2631 return(NULL); 2632 } 2633 if (ctxt->value->type != XPATH_USERS) { 2634 xmlXPathSetTypeError(ctxt); 2635 return(NULL); 2636 } 2637 obj = valuePop(ctxt); 2638 ret = obj->user; 2639 obj->user = NULL; 2640 xmlXPathReleaseObject(ctxt->context, obj); 2641 return(ret); 2642 } 2643 2644 /* 2645 * Macros for accessing the content. Those should be used only by the parser, 2646 * and not exported. 2647 * 2648 * Dirty macros, i.e. one need to make assumption on the context to use them 2649 * 2650 * CUR_PTR return the current pointer to the xmlChar to be parsed. 2651 * CUR returns the current xmlChar value, i.e. a 8 bit value 2652 * in ISO-Latin or UTF-8. 2653 * This should be used internally by the parser 2654 * only to compare to ASCII values otherwise it would break when 2655 * running with UTF-8 encoding. 2656 * NXT(n) returns the n'th next xmlChar. Same as CUR is should be used only 2657 * to compare on ASCII based substring. 2658 * SKIP(n) Skip n xmlChar, and must also be used only to skip ASCII defined 2659 * strings within the parser. 2660 * CURRENT Returns the current char value, with the full decoding of 2661 * UTF-8 if we are using this mode. It returns an int. 2662 * NEXT Skip to the next character, this does the proper decoding 2663 * in UTF-8 mode. It also pop-up unfinished entities on the fly. 2664 * It returns the pointer to the current xmlChar. 2665 */ 2666 2667 #define CUR (*ctxt->cur) 2668 #define SKIP(val) ctxt->cur += (val) 2669 #define NXT(val) ctxt->cur[(val)] 2670 #define CUR_PTR ctxt->cur 2671 #define CUR_CHAR(l) xmlXPathCurrentChar(ctxt, &l) 2672 2673 #define COPY_BUF(l,b,i,v) \ 2674 if (l == 1) b[i++] = (xmlChar) v; \ 2675 else i += xmlCopyChar(l,&b[i],v) 2676 2677 #define NEXTL(l) ctxt->cur += l 2678 2679 #define SKIP_BLANKS \ 2680 while (IS_BLANK_CH(*(ctxt->cur))) NEXT 2681 2682 #define CURRENT (*ctxt->cur) 2683 #define NEXT ((*ctxt->cur) ? ctxt->cur++: ctxt->cur) 2684 2685 2686 #ifndef DBL_DIG 2687 #define DBL_DIG 16 2688 #endif 2689 #ifndef DBL_EPSILON 2690 #define DBL_EPSILON 1E-9 2691 #endif 2692 2693 #define UPPER_DOUBLE 1E9 2694 #define LOWER_DOUBLE 1E-5 2695 #define LOWER_DOUBLE_EXP 5 2696 2697 #define INTEGER_DIGITS DBL_DIG 2698 #define FRACTION_DIGITS (DBL_DIG + 1 + (LOWER_DOUBLE_EXP)) 2699 #define EXPONENT_DIGITS (3 + 2) 2700 2701 /** 2702 * xmlXPathFormatNumber: 2703 * @number: number to format 2704 * @buffer: output buffer 2705 * @buffersize: size of output buffer 2706 * 2707 * Convert the number into a string representation. 2708 */ 2709 static void 2710 xmlXPathFormatNumber(double number, char buffer[], int buffersize) 2711 { 2712 switch (xmlXPathIsInf(number)) { 2713 case 1: 2714 if (buffersize > (int)sizeof("Infinity")) 2715 snprintf(buffer, buffersize, "Infinity"); 2716 break; 2717 case -1: 2718 if (buffersize > (int)sizeof("-Infinity")) 2719 snprintf(buffer, buffersize, "-Infinity"); 2720 break; 2721 default: 2722 if (xmlXPathIsNaN(number)) { 2723 if (buffersize > (int)sizeof("NaN")) 2724 snprintf(buffer, buffersize, "NaN"); 2725 } else if (number == 0 && xmlXPathGetSign(number) != 0) { 2726 snprintf(buffer, buffersize, "0"); 2727 } else if (number == ((int) number)) { 2728 char work[30]; 2729 char *ptr, *cur; 2730 int value = (int) number; 2731 2732 ptr = &buffer[0]; 2733 if (value == 0) { 2734 *ptr++ = '0'; 2735 } else { 2736 snprintf(work, 29, "%d", value); 2737 cur = &work[0]; 2738 while ((*cur) && (ptr - buffer < buffersize)) { 2739 *ptr++ = *cur++; 2740 } 2741 } 2742 if (ptr - buffer < buffersize) { 2743 *ptr = 0; 2744 } else if (buffersize > 0) { 2745 ptr--; 2746 *ptr = 0; 2747 } 2748 } else { 2749 /* 2750 For the dimension of work, 2751 DBL_DIG is number of significant digits 2752 EXPONENT is only needed for "scientific notation" 2753 3 is sign, decimal point, and terminating zero 2754 LOWER_DOUBLE_EXP is max number of leading zeroes in fraction 2755 Note that this dimension is slightly (a few characters) 2756 larger than actually necessary. 2757 */ 2758 char work[DBL_DIG + EXPONENT_DIGITS + 3 + LOWER_DOUBLE_EXP]; 2759 int integer_place, fraction_place; 2760 char *ptr; 2761 char *after_fraction; 2762 double absolute_value; 2763 int size; 2764 2765 absolute_value = fabs(number); 2766 2767 /* 2768 * First choose format - scientific or regular floating point. 2769 * In either case, result is in work, and after_fraction points 2770 * just past the fractional part. 2771 */ 2772 if ( ((absolute_value > UPPER_DOUBLE) || 2773 (absolute_value < LOWER_DOUBLE)) && 2774 (absolute_value != 0.0) ) { 2775 /* Use scientific notation */ 2776 integer_place = DBL_DIG + EXPONENT_DIGITS + 1; 2777 fraction_place = DBL_DIG - 1; 2778 size = snprintf(work, sizeof(work),"%*.*e", 2779 integer_place, fraction_place, number); 2780 while ((size > 0) && (work[size] != 'e')) size--; 2781 2782 } 2783 else { 2784 /* Use regular notation */ 2785 if (absolute_value > 0.0) { 2786 integer_place = (int)log10(absolute_value); 2787 if (integer_place > 0) 2788 fraction_place = DBL_DIG - integer_place - 1; 2789 else 2790 fraction_place = DBL_DIG - integer_place; 2791 } else { 2792 fraction_place = 1; 2793 } 2794 size = snprintf(work, sizeof(work), "%0.*f", 2795 fraction_place, number); 2796 } 2797 2798 /* Remove fractional trailing zeroes */ 2799 after_fraction = work + size; 2800 ptr = after_fraction; 2801 while (*(--ptr) == '0') 2802 ; 2803 if (*ptr != '.') 2804 ptr++; 2805 while ((*ptr++ = *after_fraction++) != 0); 2806 2807 /* Finally copy result back to caller */ 2808 size = strlen(work) + 1; 2809 if (size > buffersize && buffersize <= (int)sizeof(work)) { 2810 work[buffersize - 1] = 0; 2811 size = buffersize; 2812 } 2813 memmove(buffer, work, size); 2814 } 2815 break; 2816 } 2817 } 2818 2819 2820 /************************************************************************ 2821 * * 2822 * Routines to handle NodeSets * 2823 * * 2824 ************************************************************************/ 2825 2826 /** 2827 * xmlXPathOrderDocElems: 2828 * @doc: an input document 2829 * 2830 * Call this routine to speed up XPath computation on static documents. 2831 * This stamps all the element nodes with the document order 2832 * Like for line information, the order is kept in the element->content 2833 * field, the value stored is actually - the node number (starting at -1) 2834 * to be able to differentiate from line numbers. 2835 * 2836 * Returns the number of elements found in the document or -1 in case 2837 * of error. 2838 */ 2839 long 2840 xmlXPathOrderDocElems(xmlDocPtr doc) { 2841 long count = 0; 2842 xmlNodePtr cur; 2843 2844 if (doc == NULL) 2845 return(-1); 2846 cur = doc->children; 2847 while (cur != NULL) { 2848 if (cur->type == XML_ELEMENT_NODE) { 2849 cur->content = (void *) (-(++count)); 2850 if (cur->children != NULL) { 2851 cur = cur->children; 2852 continue; 2853 } 2854 } 2855 if (cur->next != NULL) { 2856 cur = cur->next; 2857 continue; 2858 } 2859 do { 2860 cur = cur->parent; 2861 if (cur == NULL) 2862 break; 2863 if (cur == (xmlNodePtr) doc) { 2864 cur = NULL; 2865 break; 2866 } 2867 if (cur->next != NULL) { 2868 cur = cur->next; 2869 break; 2870 } 2871 } while (cur != NULL); 2872 } 2873 return(count); 2874 } 2875 2876 /** 2877 * xmlXPathCmpNodes: 2878 * @node1: the first node 2879 * @node2: the second node 2880 * 2881 * Compare two nodes w.r.t document order 2882 * 2883 * Returns -2 in case of error 1 if first point < second point, 0 if 2884 * it's the same node, -1 otherwise 2885 */ 2886 int 2887 xmlXPathCmpNodes(xmlNodePtr node1, xmlNodePtr node2) { 2888 int depth1, depth2; 2889 int attr1 = 0, attr2 = 0; 2890 xmlNodePtr attrNode1 = NULL, attrNode2 = NULL; 2891 xmlNodePtr cur, root; 2892 2893 if ((node1 == NULL) || (node2 == NULL)) 2894 return(-2); 2895 /* 2896 * a couple of optimizations which will avoid computations in most cases 2897 */ 2898 if (node1 == node2) /* trivial case */ 2899 return(0); 2900 if (node1->type == XML_ATTRIBUTE_NODE) { 2901 attr1 = 1; 2902 attrNode1 = node1; 2903 node1 = node1->parent; 2904 } 2905 if (node2->type == XML_ATTRIBUTE_NODE) { 2906 attr2 = 1; 2907 attrNode2 = node2; 2908 node2 = node2->parent; 2909 } 2910 if (node1 == node2) { 2911 if (attr1 == attr2) { 2912 /* not required, but we keep attributes in order */ 2913 if (attr1 != 0) { 2914 cur = attrNode2->prev; 2915 while (cur != NULL) { 2916 if (cur == attrNode1) 2917 return (1); 2918 cur = cur->prev; 2919 } 2920 return (-1); 2921 } 2922 return(0); 2923 } 2924 if (attr2 == 1) 2925 return(1); 2926 return(-1); 2927 } 2928 if ((node1->type == XML_NAMESPACE_DECL) || 2929 (node2->type == XML_NAMESPACE_DECL)) 2930 return(1); 2931 if (node1 == node2->prev) 2932 return(1); 2933 if (node1 == node2->next) 2934 return(-1); 2935 2936 /* 2937 * Speedup using document order if availble. 2938 */ 2939 if ((node1->type == XML_ELEMENT_NODE) && 2940 (node2->type == XML_ELEMENT_NODE) && 2941 (0 > (long) node1->content) && 2942 (0 > (long) node2->content) && 2943 (node1->doc == node2->doc)) { 2944 long l1, l2; 2945 2946 l1 = -((long) node1->content); 2947 l2 = -((long) node2->content); 2948 if (l1 < l2) 2949 return(1); 2950 if (l1 > l2) 2951 return(-1); 2952 } 2953 2954 /* 2955 * compute depth to root 2956 */ 2957 for (depth2 = 0, cur = node2;cur->parent != NULL;cur = cur->parent) { 2958 if (cur == node1) 2959 return(1); 2960 depth2++; 2961 } 2962 root = cur; 2963 for (depth1 = 0, cur = node1;cur->parent != NULL;cur = cur->parent) { 2964 if (cur == node2) 2965 return(-1); 2966 depth1++; 2967 } 2968 /* 2969 * Distinct document (or distinct entities :-( ) case. 2970 */ 2971 if (root != cur) { 2972 return(-2); 2973 } 2974 /* 2975 * get the nearest common ancestor. 2976 */ 2977 while (depth1 > depth2) { 2978 depth1--; 2979 node1 = node1->parent; 2980 } 2981 while (depth2 > depth1) { 2982 depth2--; 2983 node2 = node2->parent; 2984 } 2985 while (node1->parent != node2->parent) { 2986 node1 = node1->parent; 2987 node2 = node2->parent; 2988 /* should not happen but just in case ... */ 2989 if ((node1 == NULL) || (node2 == NULL)) 2990 return(-2); 2991 } 2992 /* 2993 * Find who's first. 2994 */ 2995 if (node1 == node2->prev) 2996 return(1); 2997 if (node1 == node2->next) 2998 return(-1); 2999 /* 3000 * Speedup using document order if availble. 3001 */ 3002 if ((node1->type == XML_ELEMENT_NODE) && 3003 (node2->type == XML_ELEMENT_NODE) && 3004 (0 > (long) node1->content) && 3005 (0 > (long) node2->content) && 3006 (node1->doc == node2->doc)) { 3007 long l1, l2; 3008 3009 l1 = -((long) node1->content); 3010 l2 = -((long) node2->content); 3011 if (l1 < l2) 3012 return(1); 3013 if (l1 > l2) 3014 return(-1); 3015 } 3016 3017 for (cur = node1->next;cur != NULL;cur = cur->next) 3018 if (cur == node2) 3019 return(1); 3020 return(-1); /* assume there is no sibling list corruption */ 3021 } 3022 3023 #ifdef XP_OPTIMIZED_NON_ELEM_COMPARISON 3024 /** 3025 * xmlXPathCmpNodesExt: 3026 * @node1: the first node 3027 * @node2: the second node 3028 * 3029 * Compare two nodes w.r.t document order. 3030 * This one is optimized for handling of non-element nodes. 3031 * 3032 * Returns -2 in case of error 1 if first point < second point, 0 if 3033 * it's the same node, -1 otherwise 3034 */ 3035 static int 3036 xmlXPathCmpNodesExt(xmlNodePtr node1, xmlNodePtr node2) { 3037 int depth1, depth2; 3038 int misc = 0, precedence1 = 0, precedence2 = 0; 3039 xmlNodePtr miscNode1 = NULL, miscNode2 = NULL; 3040 xmlNodePtr cur, root; 3041 long l1, l2; 3042 3043 if ((node1 == NULL) || (node2 == NULL)) 3044 return(-2); 3045 3046 if (node1 == node2) 3047 return(0); 3048 3049 /* 3050 * a couple of optimizations which will avoid computations in most cases 3051 */ 3052 switch (node1->type) { 3053 case XML_ELEMENT_NODE: 3054 if (node2->type == XML_ELEMENT_NODE) { 3055 if ((0 > (long) node1->content) && /* TODO: Would a != 0 suffice here? */ 3056 (0 > (long) node2->content) && 3057 (node1->doc == node2->doc)) 3058 { 3059 l1 = -((long) node1->content); 3060 l2 = -((long) node2->content); 3061 if (l1 < l2) 3062 return(1); 3063 if (l1 > l2) 3064 return(-1); 3065 } else 3066 goto turtle_comparison; 3067 } 3068 break; 3069 case XML_ATTRIBUTE_NODE: 3070 precedence1 = 1; /* element is owner */ 3071 miscNode1 = node1; 3072 node1 = node1->parent; 3073 misc = 1; 3074 break; 3075 case XML_TEXT_NODE: 3076 case XML_CDATA_SECTION_NODE: 3077 case XML_COMMENT_NODE: 3078 case XML_PI_NODE: { 3079 miscNode1 = node1; 3080 /* 3081 * Find nearest element node. 3082 */ 3083 if (node1->prev != NULL) { 3084 do { 3085 node1 = node1->prev; 3086 if (node1->type == XML_ELEMENT_NODE) { 3087 precedence1 = 3; /* element in prev-sibl axis */ 3088 break; 3089 } 3090 if (node1->prev == NULL) { 3091 precedence1 = 2; /* element is parent */ 3092 /* 3093 * URGENT TODO: Are there any cases, where the 3094 * parent of such a node is not an element node? 3095 */ 3096 node1 = node1->parent; 3097 break; 3098 } 3099 } while (1); 3100 } else { 3101 precedence1 = 2; /* element is parent */ 3102 node1 = node1->parent; 3103 } 3104 if ((node1 == NULL) || (node1->type != XML_ELEMENT_NODE) || 3105 (0 <= (long) node1->content)) { 3106 /* 3107 * Fallback for whatever case. 3108 */ 3109 node1 = miscNode1; 3110 precedence1 = 0; 3111 } else 3112 misc = 1; 3113 } 3114 break; 3115 case XML_NAMESPACE_DECL: 3116 /* 3117 * TODO: why do we return 1 for namespace nodes? 3118 */ 3119 return(1); 3120 default: 3121 break; 3122 } 3123 switch (node2->type) { 3124 case XML_ELEMENT_NODE: 3125 break; 3126 case XML_ATTRIBUTE_NODE: 3127 precedence2 = 1; /* element is owner */ 3128 miscNode2 = node2; 3129 node2 = node2->parent; 3130 misc = 1; 3131 break; 3132 case XML_TEXT_NODE: 3133 case XML_CDATA_SECTION_NODE: 3134 case XML_COMMENT_NODE: 3135 case XML_PI_NODE: { 3136 miscNode2 = node2; 3137 if (node2->prev != NULL) { 3138 do { 3139 node2 = node2->prev; 3140 if (node2->type == XML_ELEMENT_NODE) { 3141 precedence2 = 3; /* element in prev-sibl axis */ 3142 break; 3143 } 3144 if (node2->prev == NULL) { 3145 precedence2 = 2; /* element is parent */ 3146 node2 = node2->parent; 3147 break; 3148 } 3149 } while (1); 3150 } else { 3151 precedence2 = 2; /* element is parent */ 3152 node2 = node2->parent; 3153 } 3154 if ((node2 == NULL) || (node2->type != XML_ELEMENT_NODE) || 3155 (0 <= (long) node1->content)) 3156 { 3157 node2 = miscNode2; 3158 precedence2 = 0; 3159 } else 3160 misc = 1; 3161 } 3162 break; 3163 case XML_NAMESPACE_DECL: 3164 return(1); 3165 default: 3166 break; 3167 } 3168 if (misc) { 3169 if (node1 == node2) { 3170 if (precedence1 == precedence2) { 3171 /* 3172 * The ugly case; but normally there aren't many 3173 * adjacent non-element nodes around. 3174 */ 3175 cur = miscNode2->prev; 3176 while (cur != NULL) { 3177 if (cur == miscNode1) 3178 return(1); 3179 if (cur->type == XML_ELEMENT_NODE) 3180 return(-1); 3181 cur = cur->prev; 3182 } 3183 return (-1); 3184 } else { 3185 /* 3186 * Evaluate based on higher precedence wrt to the element. 3187 * TODO: This assumes attributes are sorted before content. 3188 * Is this 100% correct? 3189 */ 3190 if (precedence1 < precedence2) 3191 return(1); 3192 else 3193 return(-1); 3194 } 3195 } 3196 /* 3197 * Special case: One of the helper-elements is contained by the other. 3198 * <foo> 3199 * <node2> 3200 * <node1>Text-1(precedence1 == 2)</node1> 3201 * </node2> 3202 * Text-6(precedence2 == 3) 3203 * </foo> 3204 */ 3205 if ((precedence2 == 3) && (precedence1 > 1)) { 3206 cur = node1->parent; 3207 while (cur) { 3208 if (cur == node2) 3209 return(1); 3210 cur = cur->parent; 3211 } 3212 } 3213 if ((precedence1 == 3) && (precedence2 > 1)) { 3214 cur = node2->parent; 3215 while (cur) { 3216 if (cur == node1) 3217 return(-1); 3218 cur = cur->parent; 3219 } 3220 } 3221 } 3222 3223 /* 3224 * Speedup using document order if availble. 3225 */ 3226 if ((node1->type == XML_ELEMENT_NODE) && 3227 (node2->type == XML_ELEMENT_NODE) && 3228 (0 > (long) node1->content) && 3229 (0 > (long) node2->content) && 3230 (node1->doc == node2->doc)) { 3231 3232 l1 = -((long) node1->content); 3233 l2 = -((long) node2->content); 3234 if (l1 < l2) 3235 return(1); 3236 if (l1 > l2) 3237 return(-1); 3238 } 3239 3240 turtle_comparison: 3241 3242 if (node1 == node2->prev) 3243 return(1); 3244 if (node1 == node2->next) 3245 return(-1); 3246 /* 3247 * compute depth to root 3248 */ 3249 for (depth2 = 0, cur = node2;cur->parent != NULL;cur = cur->parent) { 3250 if (cur == node1) 3251 return(1); 3252 depth2++; 3253 } 3254 root = cur; 3255 for (depth1 = 0, cur = node1;cur->parent != NULL;cur = cur->parent) { 3256 if (cur == node2) 3257 return(-1); 3258 depth1++; 3259 } 3260 /* 3261 * Distinct document (or distinct entities :-( ) case. 3262 */ 3263 if (root != cur) { 3264 return(-2); 3265 } 3266 /* 3267 * get the nearest common ancestor. 3268 */ 3269 while (depth1 > depth2) { 3270 depth1--; 3271 node1 = node1->parent; 3272 } 3273 while (depth2 > depth1) { 3274 depth2--; 3275 node2 = node2->parent; 3276 } 3277 while (node1->parent != node2->parent) { 3278 node1 = node1->parent; 3279 node2 = node2->parent; 3280 /* should not happen but just in case ... */ 3281 if ((node1 == NULL) || (node2 == NULL)) 3282 return(-2); 3283 } 3284 /* 3285 * Find who's first. 3286 */ 3287 if (node1 == node2->prev) 3288 return(1); 3289 if (node1 == node2->next) 3290 return(-1); 3291 /* 3292 * Speedup using document order if availble. 3293 */ 3294 if ((node1->type == XML_ELEMENT_NODE) && 3295 (node2->type == XML_ELEMENT_NODE) && 3296 (0 > (long) node1->content) && 3297 (0 > (long) node2->content) && 3298 (node1->doc == node2->doc)) { 3299 3300 l1 = -((long) node1->content); 3301 l2 = -((long) node2->content); 3302 if (l1 < l2) 3303 return(1); 3304 if (l1 > l2) 3305 return(-1); 3306 } 3307 3308 for (cur = node1->next;cur != NULL;cur = cur->next) 3309 if (cur == node2) 3310 return(1); 3311 return(-1); /* assume there is no sibling list corruption */ 3312 } 3313 #endif /* XP_OPTIMIZED_NON_ELEM_COMPARISON */ 3314 3315 /** 3316 * xmlXPathNodeSetSort: 3317 * @set: the node set 3318 * 3319 * Sort the node set in document order 3320 */ 3321 void 3322 xmlXPathNodeSetSort(xmlNodeSetPtr set) { 3323 int i, j, incr, len; 3324 xmlNodePtr tmp; 3325 3326 if (set == NULL) 3327 return; 3328 3329 /* Use Shell's sort to sort the node-set */ 3330 len = set->nodeNr; 3331 for (incr = len / 2; incr > 0; incr /= 2) { 3332 for (i = incr; i < len; i++) { 3333 j = i - incr; 3334 while (j >= 0) { 3335 #ifdef XP_OPTIMIZED_NON_ELEM_COMPARISON 3336 if (xmlXPathCmpNodesExt(set->nodeTab[j], 3337 set->nodeTab[j + incr]) == -1) 3338 #else 3339 if (xmlXPathCmpNodes(set->nodeTab[j], 3340 set->nodeTab[j + incr]) == -1) 3341 #endif 3342 { 3343 tmp = set->nodeTab[j]; 3344 set->nodeTab[j] = set->nodeTab[j + incr]; 3345 set->nodeTab[j + incr] = tmp; 3346 j -= incr; 3347 } else 3348 break; 3349 } 3350 } 3351 } 3352 } 3353 3354 #define XML_NODESET_DEFAULT 10 3355 /** 3356 * xmlXPathNodeSetDupNs: 3357 * @node: the parent node of the namespace XPath node 3358 * @ns: the libxml namespace declaration node. 3359 * 3360 * Namespace node in libxml don't match the XPath semantic. In a node set 3361 * the namespace nodes are duplicated and the next pointer is set to the 3362 * parent node in the XPath semantic. 3363 * 3364 * Returns the newly created object. 3365 */ 3366 static xmlNodePtr 3367 xmlXPathNodeSetDupNs(xmlNodePtr node, xmlNsPtr ns) { 3368 xmlNsPtr cur; 3369 3370 if ((ns == NULL) || (ns->type != XML_NAMESPACE_DECL)) 3371 return(NULL); 3372 if ((node == NULL) || (node->type == XML_NAMESPACE_DECL)) 3373 return((xmlNodePtr) ns); 3374 3375 /* 3376 * Allocate a new Namespace and fill the fields. 3377 */ 3378 cur = (xmlNsPtr) xmlMalloc(sizeof(xmlNs)); 3379 if (cur == NULL) { 3380 xmlXPathErrMemory(NULL, "duplicating namespace\n"); 3381 return(NULL); 3382 } 3383 memset(cur, 0, sizeof(xmlNs)); 3384 cur->type = XML_NAMESPACE_DECL; 3385 if (ns->href != NULL) 3386 cur->href = xmlStrdup(ns->href); 3387 if (ns->prefix != NULL) 3388 cur->prefix = xmlStrdup(ns->prefix); 3389 cur->next = (xmlNsPtr) node; 3390 return((xmlNodePtr) cur); 3391 } 3392 3393 /** 3394 * xmlXPathNodeSetFreeNs: 3395 * @ns: the XPath namespace node found in a nodeset. 3396 * 3397 * Namespace nodes in libxml don't match the XPath semantic. In a node set 3398 * the namespace nodes are duplicated and the next pointer is set to the 3399 * parent node in the XPath semantic. Check if such a node needs to be freed 3400 */ 3401 void 3402 xmlXPathNodeSetFreeNs(xmlNsPtr ns) { 3403 if ((ns == NULL) || (ns->type != XML_NAMESPACE_DECL)) 3404 return; 3405 3406 if ((ns->next != NULL) && (ns->next->type != XML_NAMESPACE_DECL)) { 3407 if (ns->href != NULL) 3408 xmlFree((xmlChar *)ns->href); 3409 if (ns->prefix != NULL) 3410 xmlFree((xmlChar *)ns->prefix); 3411 xmlFree(ns); 3412 } 3413 } 3414 3415 /** 3416 * xmlXPathNodeSetCreate: 3417 * @val: an initial xmlNodePtr, or NULL 3418 * 3419 * Create a new xmlNodeSetPtr of type double and of value @val 3420 * 3421 * Returns the newly created object. 3422 */ 3423 xmlNodeSetPtr 3424 xmlXPathNodeSetCreate(xmlNodePtr val) { 3425 xmlNodeSetPtr ret; 3426 3427 ret = (xmlNodeSetPtr) xmlMalloc(sizeof(xmlNodeSet)); 3428 if (ret == NULL) { 3429 xmlXPathErrMemory(NULL, "creating nodeset\n"); 3430 return(NULL); 3431 } 3432 memset(ret, 0 , (size_t) sizeof(xmlNodeSet)); 3433 if (val != NULL) { 3434 ret->nodeTab = (xmlNodePtr *) xmlMalloc(XML_NODESET_DEFAULT * 3435 sizeof(xmlNodePtr)); 3436 if (ret->nodeTab == NULL) { 3437 xmlXPathErrMemory(NULL, "creating nodeset\n"); 3438 xmlFree(ret); 3439 return(NULL); 3440 } 3441 memset(ret->nodeTab, 0 , 3442 XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr)); 3443 ret->nodeMax = XML_NODESET_DEFAULT; 3444 if (val->type == XML_NAMESPACE_DECL) { 3445 xmlNsPtr ns = (xmlNsPtr) val; 3446 3447 ret->nodeTab[ret->nodeNr++] = 3448 xmlXPathNodeSetDupNs((xmlNodePtr) ns->next, ns); 3449 } else 3450 ret->nodeTab[ret->nodeNr++] = val; 3451 } 3452 return(ret); 3453 } 3454 3455 /** 3456 * xmlXPathNodeSetCreateSize: 3457 * @size: the initial size of the set 3458 * 3459 * Create a new xmlNodeSetPtr of type double and of value @val 3460 * 3461 * Returns the newly created object. 3462 */ 3463 static xmlNodeSetPtr 3464 xmlXPathNodeSetCreateSize(int size) { 3465 xmlNodeSetPtr ret; 3466 3467 ret = (xmlNodeSetPtr) xmlMalloc(sizeof(xmlNodeSet)); 3468 if (ret == NULL) { 3469 xmlXPathErrMemory(NULL, "creating nodeset\n"); 3470 return(NULL); 3471 } 3472 memset(ret, 0 , (size_t) sizeof(xmlNodeSet)); 3473 if (size < XML_NODESET_DEFAULT) 3474 size = XML_NODESET_DEFAULT; 3475 ret->nodeTab = (xmlNodePtr *) xmlMalloc(size * sizeof(xmlNodePtr)); 3476 if (ret->nodeTab == NULL) { 3477 xmlXPathErrMemory(NULL, "creating nodeset\n"); 3478 xmlFree(ret); 3479 return(NULL); 3480 } 3481 memset(ret->nodeTab, 0 , size * (size_t) sizeof(xmlNodePtr)); 3482 ret->nodeMax = size; 3483 return(ret); 3484 } 3485 3486 /** 3487 * xmlXPathNodeSetContains: 3488 * @cur: the node-set 3489 * @val: the node 3490 * 3491 * checks whether @cur contains @val 3492 * 3493 * Returns true (1) if @cur contains @val, false (0) otherwise 3494 */ 3495 int 3496 xmlXPathNodeSetContains (xmlNodeSetPtr cur, xmlNodePtr val) { 3497 int i; 3498 3499 if ((cur == NULL) || (val == NULL)) return(0); 3500 if (val->type == XML_NAMESPACE_DECL) { 3501 for (i = 0; i < cur->nodeNr; i++) { 3502 if (cur->nodeTab[i]->type == XML_NAMESPACE_DECL) { 3503 xmlNsPtr ns1, ns2; 3504 3505 ns1 = (xmlNsPtr) val; 3506 ns2 = (xmlNsPtr) cur->nodeTab[i]; 3507 if (ns1 == ns2) 3508 return(1); 3509 if ((ns1->next != NULL) && (ns2->next == ns1->next) && 3510 (xmlStrEqual(ns1->prefix, ns2->prefix))) 3511 return(1); 3512 } 3513 } 3514 } else { 3515 for (i = 0; i < cur->nodeNr; i++) { 3516 if (cur->nodeTab[i] == val) 3517 return(1); 3518 } 3519 } 3520 return(0); 3521 } 3522 3523 /** 3524 * xmlXPathNodeSetAddNs: 3525 * @cur: the initial node set 3526 * @node: the hosting node 3527 * @ns: a the namespace node 3528 * 3529 * add a new namespace node to an existing NodeSet 3530 */ 3531 void 3532 xmlXPathNodeSetAddNs(xmlNodeSetPtr cur, xmlNodePtr node, xmlNsPtr ns) { 3533 int i; 3534 3535 3536 if ((cur == NULL) || (ns == NULL) || (node == NULL) || 3537 (ns->type != XML_NAMESPACE_DECL) || 3538 (node->type != XML_ELEMENT_NODE)) 3539 return; 3540 3541 /* @@ with_ns to check whether namespace nodes should be looked at @@ */ 3542 /* 3543 * prevent duplicates 3544 */ 3545 for (i = 0;i < cur->nodeNr;i++) { 3546 if ((cur->nodeTab[i] != NULL) && 3547 (cur->nodeTab[i]->type == XML_NAMESPACE_DECL) && 3548 (((xmlNsPtr)cur->nodeTab[i])->next == (xmlNsPtr) node) && 3549 (xmlStrEqual(ns->prefix, ((xmlNsPtr)cur->nodeTab[i])->prefix))) 3550 return; 3551 } 3552 3553 /* 3554 * grow the nodeTab if needed 3555 */ 3556 if (cur->nodeMax == 0) { 3557 cur->nodeTab = (xmlNodePtr *) xmlMalloc(XML_NODESET_DEFAULT * 3558 sizeof(xmlNodePtr)); 3559 if (cur->nodeTab == NULL) { 3560 xmlXPathErrMemory(NULL, "growing nodeset\n"); 3561 return; 3562 } 3563 memset(cur->nodeTab, 0 , 3564 XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr)); 3565 cur->nodeMax = XML_NODESET_DEFAULT; 3566 } else if (cur->nodeNr == cur->nodeMax) { 3567 xmlNodePtr *temp; 3568 3569 temp = (xmlNodePtr *) xmlRealloc(cur->nodeTab, cur->nodeMax * 2 * 3570 sizeof(xmlNodePtr)); 3571 if (temp == NULL) { 3572 xmlXPathErrMemory(NULL, "growing nodeset\n"); 3573 return; 3574 } 3575 cur->nodeMax *= 2; 3576 cur->nodeTab = temp; 3577 } 3578 cur->nodeTab[cur->nodeNr++] = xmlXPathNodeSetDupNs(node, ns); 3579 } 3580 3581 /** 3582 * xmlXPathNodeSetAdd: 3583 * @cur: the initial node set 3584 * @val: a new xmlNodePtr 3585 * 3586 * add a new xmlNodePtr to an existing NodeSet 3587 */ 3588 void 3589 xmlXPathNodeSetAdd(xmlNodeSetPtr cur, xmlNodePtr val) { 3590 int i; 3591 3592 if ((cur == NULL) || (val == NULL)) return; 3593 3594 #if 0 3595 if ((val->type == XML_ELEMENT_NODE) && (val->name[0] == ' ')) 3596 return; /* an XSLT fake node */ 3597 #endif 3598 3599 /* @@ with_ns to check whether namespace nodes should be looked at @@ */ 3600 /* 3601 * prevent duplcates 3602 */ 3603 for (i = 0;i < cur->nodeNr;i++) 3604 if (cur->nodeTab[i] == val) return; 3605 3606 /* 3607 * grow the nodeTab if needed 3608 */ 3609 if (cur->nodeMax == 0) { 3610 cur->nodeTab = (xmlNodePtr *) xmlMalloc(XML_NODESET_DEFAULT * 3611 sizeof(xmlNodePtr)); 3612 if (cur->nodeTab == NULL) { 3613 xmlXPathErrMemory(NULL, "growing nodeset\n"); 3614 return; 3615 } 3616 memset(cur->nodeTab, 0 , 3617 XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr)); 3618 cur->nodeMax = XML_NODESET_DEFAULT; 3619 } else if (cur->nodeNr == cur->nodeMax) { 3620 xmlNodePtr *temp; 3621 3622 temp = (xmlNodePtr *) xmlRealloc(cur->nodeTab, cur->nodeMax * 2 * 3623 sizeof(xmlNodePtr)); 3624 if (temp == NULL) { 3625 xmlXPathErrMemory(NULL, "growing nodeset\n"); 3626 return; 3627 } 3628 cur->nodeMax *= 2; 3629 cur->nodeTab = temp; 3630 } 3631 if (val->type == XML_NAMESPACE_DECL) { 3632 xmlNsPtr ns = (xmlNsPtr) val; 3633 3634 cur->nodeTab[cur->nodeNr++] = 3635 xmlXPathNodeSetDupNs((xmlNodePtr) ns->next, ns); 3636 } else 3637 cur->nodeTab[cur->nodeNr++] = val; 3638 } 3639 3640 /** 3641 * xmlXPathNodeSetAddUnique: 3642 * @cur: the initial node set 3643 * @val: a new xmlNodePtr 3644 * 3645 * add a new xmlNodePtr to an existing NodeSet, optimized version 3646 * when we are sure the node is not already in the set. 3647 */ 3648 void 3649 xmlXPathNodeSetAddUnique(xmlNodeSetPtr cur, xmlNodePtr val) { 3650 if ((cur == NULL) || (val == NULL)) return; 3651 3652 #if 0 3653 if ((val->type == XML_ELEMENT_NODE) && (val->name[0] == ' ')) 3654 return; /* an XSLT fake node */ 3655 #endif 3656 3657 /* @@ with_ns to check whether namespace nodes should be looked at @@ */ 3658 /* 3659 * grow the nodeTab if needed 3660 */ 3661 if (cur->nodeMax == 0) { 3662 cur->nodeTab = (xmlNodePtr *) xmlMalloc(XML_NODESET_DEFAULT * 3663 sizeof(xmlNodePtr)); 3664 if (cur->nodeTab == NULL) { 3665 xmlXPathErrMemory(NULL, "growing nodeset\n"); 3666 return; 3667 } 3668 memset(cur->nodeTab, 0 , 3669 XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr)); 3670 cur->nodeMax = XML_NODESET_DEFAULT; 3671 } else if (cur->nodeNr == cur->nodeMax) { 3672 xmlNodePtr *temp; 3673 3674 temp = (xmlNodePtr *) xmlRealloc(cur->nodeTab, cur->nodeMax * 2 * 3675 sizeof(xmlNodePtr)); 3676 if (temp == NULL) { 3677 xmlXPathErrMemory(NULL, "growing nodeset\n"); 3678 return; 3679 } 3680 cur->nodeTab = temp; 3681 cur->nodeMax *= 2; 3682 } 3683 if (val->type == XML_NAMESPACE_DECL) { 3684 xmlNsPtr ns = (xmlNsPtr) val; 3685 3686 cur->nodeTab[cur->nodeNr++] = 3687 xmlXPathNodeSetDupNs((xmlNodePtr) ns->next, ns); 3688 } else 3689 cur->nodeTab[cur->nodeNr++] = val; 3690 } 3691 3692 /** 3693 * xmlXPathNodeSetMerge: 3694 * @val1: the first NodeSet or NULL 3695 * @val2: the second NodeSet 3696 * 3697 * Merges two nodesets, all nodes from @val2 are added to @val1 3698 * if @val1 is NULL, a new set is created and copied from @val2 3699 * 3700 * Returns @val1 once extended or NULL in case of error. 3701 */ 3702 xmlNodeSetPtr 3703 xmlXPathNodeSetMerge(xmlNodeSetPtr val1, xmlNodeSetPtr val2) { 3704 int i, j, initNr, skip; 3705 xmlNodePtr n1, n2; 3706 3707 if (val2 == NULL) return(val1); 3708 if (val1 == NULL) { 3709 val1 = xmlXPathNodeSetCreate(NULL); 3710 if (val1 == NULL) 3711 return (NULL); 3712 #if 0 3713 /* 3714 * TODO: The optimization won't work in every case, since 3715 * those nasty namespace nodes need to be added with 3716 * xmlXPathNodeSetDupNs() to the set; thus a pure 3717 * memcpy is not possible. 3718 * If there was a flag on the nodesetval, indicating that 3719 * some temporary nodes are in, that would be helpfull. 3720 */ 3721 /* 3722 * Optimization: Create an equally sized node-set 3723 * and memcpy the content. 3724 */ 3725 val1 = xmlXPathNodeSetCreateSize(val2->nodeNr); 3726 if (val1 == NULL) 3727 return(NULL); 3728 if (val2->nodeNr != 0) { 3729 if (val2->nodeNr == 1) 3730 *(val1->nodeTab) = *(val2->nodeTab); 3731 else { 3732 memcpy(val1->nodeTab, val2->nodeTab, 3733 val2->nodeNr * sizeof(xmlNodePtr)); 3734 } 3735 val1->nodeNr = val2->nodeNr; 3736 } 3737 return(val1); 3738 #endif 3739 } 3740 3741 /* @@ with_ns to check whether namespace nodes should be looked at @@ */ 3742 initNr = val1->nodeNr; 3743 3744 for (i = 0;i < val2->nodeNr;i++) { 3745 n2 = val2->nodeTab[i]; 3746 /* 3747 * check against duplicates 3748 */ 3749 skip = 0; 3750 for (j = 0; j < initNr; j++) { 3751 n1 = val1->nodeTab[j]; 3752 if (n1 == n2) { 3753 skip = 1; 3754 break; 3755 } else if ((n1->type == XML_NAMESPACE_DECL) && 3756 (n2->type == XML_NAMESPACE_DECL)) { 3757 if ((((xmlNsPtr) n1)->next == ((xmlNsPtr) n2)->next) && 3758 (xmlStrEqual(((xmlNsPtr) n1)->prefix, 3759 ((xmlNsPtr) n2)->prefix))) 3760 { 3761 skip = 1; 3762 break; 3763 } 3764 } 3765 } 3766 if (skip) 3767 continue; 3768 3769 /* 3770 * grow the nodeTab if needed 3771 */ 3772 if (val1->nodeMax == 0) { 3773 val1->nodeTab = (xmlNodePtr *) xmlMalloc(XML_NODESET_DEFAULT * 3774 sizeof(xmlNodePtr)); 3775 if (val1->nodeTab == NULL) { 3776 xmlXPathErrMemory(NULL, "merging nodeset\n"); 3777 return(NULL); 3778 } 3779 memset(val1->nodeTab, 0 , 3780 XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr)); 3781 val1->nodeMax = XML_NODESET_DEFAULT; 3782 } else if (val1->nodeNr == val1->nodeMax) { 3783 xmlNodePtr *temp; 3784 3785 temp = (xmlNodePtr *) xmlRealloc(val1->nodeTab, val1->nodeMax * 2 * 3786 sizeof(xmlNodePtr)); 3787 if (temp == NULL) { 3788 xmlXPathErrMemory(NULL, "merging nodeset\n"); 3789 return(NULL); 3790 } 3791 val1->nodeTab = temp; 3792 val1->nodeMax *= 2; 3793 } 3794 if (n2->type == XML_NAMESPACE_DECL) { 3795 xmlNsPtr ns = (xmlNsPtr) n2; 3796 3797 val1->nodeTab[val1->nodeNr++] = 3798 xmlXPathNodeSetDupNs((xmlNodePtr) ns->next, ns); 3799 } else 3800 val1->nodeTab[val1->nodeNr++] = n2; 3801 } 3802 3803 return(val1); 3804 } 3805 3806 #if 0 /* xmlXPathNodeSetMergeUnique() is currently not used anymore */ 3807 /** 3808 * xmlXPathNodeSetMergeUnique: 3809 * @val1: the first NodeSet or NULL 3810 * @val2: the second NodeSet 3811 * 3812 * Merges two nodesets, all nodes from @val2 are added to @val1 3813 * if @val1 is NULL, a new set is created and copied from @val2 3814 * 3815 * Returns @val1 once extended or NULL in case of error. 3816 */ 3817 static xmlNodeSetPtr 3818 xmlXPathNodeSetMergeUnique(xmlNodeSetPtr val1, xmlNodeSetPtr val2) { 3819 int i; 3820 3821 if (val2 == NULL) return(val1); 3822 if (val1 == NULL) { 3823 val1 = xmlXPathNodeSetCreate(NULL); 3824 } 3825 if (val1 == NULL) 3826 return (NULL); 3827 3828 /* @@ with_ns to check whether namespace nodes should be looked at @@ */ 3829 3830 for (i = 0;i < val2->nodeNr;i++) { 3831 /* 3832 * grow the nodeTab if needed 3833 */ 3834 if (val1->nodeMax == 0) { 3835 val1->nodeTab = (xmlNodePtr *) xmlMalloc(XML_NODESET_DEFAULT * 3836 sizeof(xmlNodePtr)); 3837 if (val1->nodeTab == NULL) { 3838 xmlXPathErrMemory(NULL, "merging nodeset\n"); 3839 return(NULL); 3840 } 3841 memset(val1->nodeTab, 0 , 3842 XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr)); 3843 val1->nodeMax = XML_NODESET_DEFAULT; 3844 } else if (val1->nodeNr == val1->nodeMax) { 3845 xmlNodePtr *temp; 3846 3847 val1->nodeMax *= 2; 3848 temp = (xmlNodePtr *) xmlRealloc(val1->nodeTab, val1->nodeMax * 3849 sizeof(xmlNodePtr)); 3850 if (temp == NULL) { 3851 xmlXPathErrMemory(NULL, "merging nodeset\n"); 3852 return(NULL); 3853 } 3854 val1->nodeTab = temp; 3855 } 3856 if (val2->nodeTab[i]->type == XML_NAMESPACE_DECL) { 3857 xmlNsPtr ns = (xmlNsPtr) val2->nodeTab[i]; 3858 3859 val1->nodeTab[val1->nodeNr++] = 3860 xmlXPathNodeSetDupNs((xmlNodePtr) ns->next, ns); 3861 } else 3862 val1->nodeTab[val1->nodeNr++] = val2->nodeTab[i]; 3863 } 3864 3865 return(val1); 3866 } 3867 #endif /* xmlXPathNodeSetMergeUnique() is currently not used anymore */ 3868 3869 /** 3870 * xmlXPathNodeSetMergeAndClear: 3871 * @set1: the first NodeSet or NULL 3872 * @set2: the second NodeSet 3873 * @hasSet2NsNodes: 1 if set2 contains namespaces nodes 3874 * 3875 * Merges two nodesets, all nodes from @set2 are added to @set1 3876 * if @set1 is NULL, a new set is created and copied from @set2. 3877 * Checks for duplicate nodes. Clears set2. 3878 * 3879 * Returns @set1 once extended or NULL in case of error. 3880 */ 3881 static xmlNodeSetPtr 3882 xmlXPathNodeSetMergeAndClear(xmlNodeSetPtr set1, xmlNodeSetPtr set2, 3883 int hasNullEntries) 3884 { 3885 if ((set1 == NULL) && (hasNullEntries == 0)) { 3886 /* 3887 * Note that doing a memcpy of the list, namespace nodes are 3888 * just assigned to set1, since set2 is cleared anyway. 3889 */ 3890 set1 = xmlXPathNodeSetCreateSize(set2->nodeNr); 3891 if (set1 == NULL) 3892 return(NULL); 3893 if (set2->nodeNr != 0) { 3894 memcpy(set1->nodeTab, set2->nodeTab, 3895 set2->nodeNr * sizeof(xmlNodePtr)); 3896 set1->nodeNr = set2->nodeNr; 3897 } 3898 } else { 3899 int i, j, initNbSet1; 3900 xmlNodePtr n1, n2; 3901 3902 if (set1 == NULL) 3903 set1 = xmlXPathNodeSetCreate(NULL); 3904 if (set1 == NULL) 3905 return (NULL); 3906 3907 initNbSet1 = set1->nodeNr; 3908 for (i = 0;i < set2->nodeNr;i++) { 3909 n2 = set2->nodeTab[i]; 3910 /* 3911 * Skip NULLed entries. 3912 */ 3913 if (n2 == NULL) 3914 continue; 3915 /* 3916 * Skip duplicates. 3917 */ 3918 for (j = 0; j < initNbSet1; j++) { 3919 n1 = set1->nodeTab[j]; 3920 if (n1 == n2) { 3921 goto skip_node; 3922 } else if ((n1->type == XML_NAMESPACE_DECL) && 3923 (n2->type == XML_NAMESPACE_DECL)) 3924 { 3925 if ((((xmlNsPtr) n1)->next == ((xmlNsPtr) n2)->next) && 3926 (xmlStrEqual(((xmlNsPtr) n1)->prefix, 3927 ((xmlNsPtr) n2)->prefix))) 3928 { 3929 /* 3930 * Free the namespace node. 3931 */ 3932 set2->nodeTab[i] = NULL; 3933 xmlXPathNodeSetFreeNs((xmlNsPtr) n2); 3934 goto skip_node; 3935 } 3936 } 3937 } 3938 /* 3939 * grow the nodeTab if needed 3940 */ 3941 if (set1->nodeMax == 0) { 3942 set1->nodeTab = (xmlNodePtr *) xmlMalloc( 3943 XML_NODESET_DEFAULT * sizeof(xmlNodePtr)); 3944 if (set1->nodeTab == NULL) { 3945 xmlXPathErrMemory(NULL, "merging nodeset\n"); 3946 return(NULL); 3947 } 3948 memset(set1->nodeTab, 0, 3949 XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr)); 3950 set1->nodeMax = XML_NODESET_DEFAULT; 3951 } else if (set1->nodeNr >= set1->nodeMax) { 3952 xmlNodePtr *temp; 3953 3954 temp = (xmlNodePtr *) xmlRealloc( 3955 set1->nodeTab, set1->nodeMax * 2 * sizeof(xmlNodePtr)); 3956 if (temp == NULL) { 3957 xmlXPathErrMemory(NULL, "merging nodeset\n"); 3958 return(NULL); 3959 } 3960 set1->nodeTab = temp; 3961 set1->nodeMax *= 2; 3962 } 3963 if (n2->type == XML_NAMESPACE_DECL) { 3964 xmlNsPtr ns = (xmlNsPtr) n2; 3965 3966 set1->nodeTab[set1->nodeNr++] = 3967 xmlXPathNodeSetDupNs((xmlNodePtr) ns->next, ns); 3968 } else 3969 set1->nodeTab[set1->nodeNr++] = n2; 3970 skip_node: 3971 {} 3972 } 3973 } 3974 set2->nodeNr = 0; 3975 return(set1); 3976 } 3977 3978 /** 3979 * xmlXPathNodeSetMergeAndClearNoDupls: 3980 * @set1: the first NodeSet or NULL 3981 * @set2: the second NodeSet 3982 * @hasSet2NsNodes: 1 if set2 contains namespaces nodes 3983 * 3984 * Merges two nodesets, all nodes from @set2 are added to @set1 3985 * if @set1 is NULL, a new set is created and copied from @set2. 3986 * Doesn't chack for duplicate nodes. Clears set2. 3987 * 3988 * Returns @set1 once extended or NULL in case of error. 3989 */ 3990 static xmlNodeSetPtr 3991 xmlXPathNodeSetMergeAndClearNoDupls(xmlNodeSetPtr set1, xmlNodeSetPtr set2, 3992 int hasNullEntries) 3993 { 3994 if (set2 == NULL) 3995 return(set1); 3996 if ((set1 == NULL) && (hasNullEntries == 0)) { 3997 /* 3998 * Note that doing a memcpy of the list, namespace nodes are 3999 * just assigned to set1, since set2 is cleared anyway. 4000 */ 4001 set1 = xmlXPathNodeSetCreateSize(set2->nodeNr); 4002 if (set1 == NULL) 4003 return(NULL); 4004 if (set2->nodeNr != 0) { 4005 memcpy(set1->nodeTab, set2->nodeTab, 4006 set2->nodeNr * sizeof(xmlNodePtr)); 4007 set1->nodeNr = set2->nodeNr; 4008 } 4009 } else { 4010 int i; 4011 xmlNodePtr n2; 4012 4013 if (set1 == NULL) 4014 set1 = xmlXPathNodeSetCreate(NULL); 4015 if (set1 == NULL) 4016 return (NULL); 4017 4018 for (i = 0;i < set2->nodeNr;i++) { 4019 n2 = set2->nodeTab[i]; 4020 /* 4021 * Skip NULLed entries. 4022 */ 4023 if (n2 == NULL) 4024 continue; 4025 if (set1->nodeMax == 0) { 4026 set1->nodeTab = (xmlNodePtr *) xmlMalloc( 4027 XML_NODESET_DEFAULT * sizeof(xmlNodePtr)); 4028 if (set1->nodeTab == NULL) { 4029 xmlXPathErrMemory(NULL, "merging nodeset\n"); 4030 return(NULL); 4031 } 4032 memset(set1->nodeTab, 0, 4033 XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr)); 4034 set1->nodeMax = XML_NODESET_DEFAULT; 4035 } else if (set1->nodeNr >= set1->nodeMax) { 4036 xmlNodePtr *temp; 4037 4038 temp = (xmlNodePtr *) xmlRealloc( 4039 set1->nodeTab, set1->nodeMax * 2 * sizeof(xmlNodePtr)); 4040 if (temp == NULL) { 4041 xmlXPathErrMemory(NULL, "merging nodeset\n"); 4042 return(NULL); 4043 } 4044 set1->nodeTab = temp; 4045 set1->nodeMax *= 2; 4046 } 4047 set1->nodeTab[set1->nodeNr++] = n2; 4048 } 4049 } 4050 set2->nodeNr = 0; 4051 return(set1); 4052 } 4053 4054 /** 4055 * xmlXPathNodeSetDel: 4056 * @cur: the initial node set 4057 * @val: an xmlNodePtr 4058 * 4059 * Removes an xmlNodePtr from an existing NodeSet 4060 */ 4061 void 4062 xmlXPathNodeSetDel(xmlNodeSetPtr cur, xmlNodePtr val) { 4063 int i; 4064 4065 if (cur == NULL) return; 4066 if (val == NULL) return; 4067 4068 /* 4069 * find node in nodeTab 4070 */ 4071 for (i = 0;i < cur->nodeNr;i++) 4072 if (cur->nodeTab[i] == val) break; 4073 4074 if (i >= cur->nodeNr) { /* not found */ 4075 #ifdef DEBUG 4076 xmlGenericError(xmlGenericErrorContext, 4077 "xmlXPathNodeSetDel: Node %s wasn't found in NodeList\n", 4078 val->name); 4079 #endif 4080 return; 4081 } 4082 if ((cur->nodeTab[i] != NULL) && 4083 (cur->nodeTab[i]->type == XML_NAMESPACE_DECL)) 4084 xmlXPathNodeSetFreeNs((xmlNsPtr) cur->nodeTab[i]); 4085 cur->nodeNr--; 4086 for (;i < cur->nodeNr;i++) 4087 cur->nodeTab[i] = cur->nodeTab[i + 1]; 4088 cur->nodeTab[cur->nodeNr] = NULL; 4089 } 4090 4091 /** 4092 * xmlXPathNodeSetRemove: 4093 * @cur: the initial node set 4094 * @val: the index to remove 4095 * 4096 * Removes an entry from an existing NodeSet list. 4097 */ 4098 void 4099 xmlXPathNodeSetRemove(xmlNodeSetPtr cur, int val) { 4100 if (cur == NULL) return; 4101 if (val >= cur->nodeNr) return; 4102 if ((cur->nodeTab[val] != NULL) && 4103 (cur->nodeTab[val]->type == XML_NAMESPACE_DECL)) 4104 xmlXPathNodeSetFreeNs((xmlNsPtr) cur->nodeTab[val]); 4105 cur->nodeNr--; 4106 for (;val < cur->nodeNr;val++) 4107 cur->nodeTab[val] = cur->nodeTab[val + 1]; 4108 cur->nodeTab[cur->nodeNr] = NULL; 4109 } 4110 4111 /** 4112 * xmlXPathFreeNodeSet: 4113 * @obj: the xmlNodeSetPtr to free 4114 * 4115 * Free the NodeSet compound (not the actual nodes !). 4116 */ 4117 void 4118 xmlXPathFreeNodeSet(xmlNodeSetPtr obj) { 4119 if (obj == NULL) return; 4120 if (obj->nodeTab != NULL) { 4121 int i; 4122 4123 /* @@ with_ns to check whether namespace nodes should be looked at @@ */ 4124 for (i = 0;i < obj->nodeNr;i++) 4125 if ((obj->nodeTab[i] != NULL) && 4126 (obj->nodeTab[i]->type == XML_NAMESPACE_DECL)) 4127 xmlXPathNodeSetFreeNs((xmlNsPtr) obj->nodeTab[i]); 4128 xmlFree(obj->nodeTab); 4129 } 4130 xmlFree(obj); 4131 } 4132 4133 /** 4134 * xmlXPathNodeSetClear: 4135 * @set: the node set to clear 4136 * 4137 * Clears the list from all temporary XPath objects (e.g. namespace nodes 4138 * are feed), but does *not* free the list itself. Sets the length of the 4139 * list to 0. 4140 */ 4141 static void 4142 xmlXPathNodeSetClear(xmlNodeSetPtr set, int hasNsNodes) 4143 { 4144 if ((set == NULL) || (set->nodeNr <= 0)) 4145 return; 4146 else if (hasNsNodes) { 4147 int i; 4148 xmlNodePtr node; 4149 4150 for (i = 0; i < set->nodeNr; i++) { 4151 node = set->nodeTab[i]; 4152 if ((node != NULL) && 4153 (node->type == XML_NAMESPACE_DECL)) 4154 xmlXPathNodeSetFreeNs((xmlNsPtr) node); 4155 } 4156 } 4157 set->nodeNr = 0; 4158 } 4159 4160 /** 4161 * xmlXPathNodeSetClearFromPos: 4162 * @set: the node set to be cleared 4163 * @pos: the start position to clear from 4164 * 4165 * Clears the list from temporary XPath objects (e.g. namespace nodes 4166 * are feed) starting with the entry at @pos, but does *not* free the list 4167 * itself. Sets the length of the list to @pos. 4168 */ 4169 static void 4170 xmlXPathNodeSetClearFromPos(xmlNodeSetPtr set, int pos, int hasNsNodes) 4171 { 4172 if ((set == NULL) || (set->nodeNr <= 0) || (pos >= set->nodeNr)) 4173 return; 4174 else if ((hasNsNodes)) { 4175 int i; 4176 xmlNodePtr node; 4177 4178 for (i = pos; i < set->nodeNr; i++) { 4179 node = set->nodeTab[i]; 4180 if ((node != NULL) && 4181 (node->type == XML_NAMESPACE_DECL)) 4182 xmlXPathNodeSetFreeNs((xmlNsPtr) node); 4183 } 4184 } 4185 set->nodeNr = pos; 4186 } 4187 4188 /** 4189 * xmlXPathFreeValueTree: 4190 * @obj: the xmlNodeSetPtr to free 4191 * 4192 * Free the NodeSet compound and the actual tree, this is different 4193 * from xmlXPathFreeNodeSet() 4194 */ 4195 static void 4196 xmlXPathFreeValueTree(xmlNodeSetPtr obj) { 4197 int i; 4198 4199 if (obj == NULL) return; 4200 4201 if (obj->nodeTab != NULL) { 4202 for (i = 0;i < obj->nodeNr;i++) { 4203 if (obj->nodeTab[i] != NULL) { 4204 if (obj->nodeTab[i]->type == XML_NAMESPACE_DECL) { 4205 xmlXPathNodeSetFreeNs((xmlNsPtr) obj->nodeTab[i]); 4206 } else { 4207 xmlFreeNodeList(obj->nodeTab[i]); 4208 } 4209 } 4210 } 4211 xmlFree(obj->nodeTab); 4212 } 4213 xmlFree(obj); 4214 } 4215 4216 #if defined(DEBUG) || defined(DEBUG_STEP) 4217 /** 4218 * xmlGenericErrorContextNodeSet: 4219 * @output: a FILE * for the output 4220 * @obj: the xmlNodeSetPtr to display 4221 * 4222 * Quick display of a NodeSet 4223 */ 4224 void 4225 xmlGenericErrorContextNodeSet(FILE *output, xmlNodeSetPtr obj) { 4226 int i; 4227 4228 if (output == NULL) output = xmlGenericErrorContext; 4229 if (obj == NULL) { 4230 fprintf(output, "NodeSet == NULL !\n"); 4231 return; 4232 } 4233 if (obj->nodeNr == 0) { 4234 fprintf(output, "NodeSet is empty\n"); 4235 return; 4236 } 4237 if (obj->nodeTab == NULL) { 4238 fprintf(output, " nodeTab == NULL !\n"); 4239 return; 4240 } 4241 for (i = 0; i < obj->nodeNr; i++) { 4242 if (obj->nodeTab[i] == NULL) { 4243 fprintf(output, " NULL !\n"); 4244 return; 4245 } 4246 if ((obj->nodeTab[i]->type == XML_DOCUMENT_NODE) || 4247 (obj->nodeTab[i]->type == XML_HTML_DOCUMENT_NODE)) 4248 fprintf(output, " /"); 4249 else if (obj->nodeTab[i]->name == NULL) 4250 fprintf(output, " noname!"); 4251 else fprintf(output, " %s", obj->nodeTab[i]->name); 4252 } 4253 fprintf(output, "\n"); 4254 } 4255 #endif 4256 4257 /** 4258 * xmlXPathNewNodeSet: 4259 * @val: the NodePtr value 4260 * 4261 * Create a new xmlXPathObjectPtr of type NodeSet and initialize 4262 * it with the single Node @val 4263 * 4264 * Returns the newly created object. 4265 */ 4266 xmlXPathObjectPtr 4267 xmlXPathNewNodeSet(xmlNodePtr val) { 4268 xmlXPathObjectPtr ret; 4269 4270 ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject)); 4271 if (ret == NULL) { 4272 xmlXPathErrMemory(NULL, "creating nodeset\n"); 4273 return(NULL); 4274 } 4275 memset(ret, 0 , (size_t) sizeof(xmlXPathObject)); 4276 ret->type = XPATH_NODESET; 4277 ret->boolval = 0; 4278 ret->nodesetval = xmlXPathNodeSetCreate(val); 4279 /* @@ with_ns to check whether namespace nodes should be looked at @@ */ 4280 #ifdef XP_DEBUG_OBJ_USAGE 4281 xmlXPathDebugObjUsageRequested(NULL, XPATH_NODESET); 4282 #endif 4283 return(ret); 4284 } 4285 4286 /** 4287 * xmlXPathNewValueTree: 4288 * @val: the NodePtr value 4289 * 4290 * Create a new xmlXPathObjectPtr of type Value Tree (XSLT) and initialize 4291 * it with the tree root @val 4292 * 4293 * Returns the newly created object. 4294 */ 4295 xmlXPathObjectPtr 4296 xmlXPathNewValueTree(xmlNodePtr val) { 4297 xmlXPathObjectPtr ret; 4298 4299 ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject)); 4300 if (ret == NULL) { 4301 xmlXPathErrMemory(NULL, "creating result value tree\n"); 4302 return(NULL); 4303 } 4304 memset(ret, 0 , (size_t) sizeof(xmlXPathObject)); 4305 ret->type = XPATH_XSLT_TREE; 4306 ret->boolval = 1; 4307 ret->user = (void *) val; 4308 ret->nodesetval = xmlXPathNodeSetCreate(val); 4309 #ifdef XP_DEBUG_OBJ_USAGE 4310 xmlXPathDebugObjUsageRequested(NULL, XPATH_XSLT_TREE); 4311 #endif 4312 return(ret); 4313 } 4314 4315 /** 4316 * xmlXPathNewNodeSetList: 4317 * @val: an existing NodeSet 4318 * 4319 * Create a new xmlXPathObjectPtr of type NodeSet and initialize 4320 * it with the Nodeset @val 4321 * 4322 * Returns the newly created object. 4323 */ 4324 xmlXPathObjectPtr 4325 xmlXPathNewNodeSetList(xmlNodeSetPtr val) 4326 { 4327 xmlXPathObjectPtr ret; 4328 int i; 4329 4330 if (val == NULL) 4331 ret = NULL; 4332 else if (val->nodeTab == NULL) 4333 ret = xmlXPathNewNodeSet(NULL); 4334 else { 4335 ret = xmlXPathNewNodeSet(val->nodeTab[0]); 4336 if (ret) 4337 for (i = 1; i < val->nodeNr; ++i) 4338 xmlXPathNodeSetAddUnique(ret->nodesetval, val->nodeTab[i]); 4339 } 4340 4341 return (ret); 4342 } 4343 4344 /** 4345 * xmlXPathWrapNodeSet: 4346 * @val: the NodePtr value 4347 * 4348 * Wrap the Nodeset @val in a new xmlXPathObjectPtr 4349 * 4350 * Returns the newly created object. 4351 */ 4352 xmlXPathObjectPtr 4353 xmlXPathWrapNodeSet(xmlNodeSetPtr val) { 4354 xmlXPathObjectPtr ret; 4355 4356 ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject)); 4357 if (ret == NULL) { 4358 xmlXPathErrMemory(NULL, "creating node set object\n"); 4359 return(NULL); 4360 } 4361 memset(ret, 0 , (size_t) sizeof(xmlXPathObject)); 4362 ret->type = XPATH_NODESET; 4363 ret->nodesetval = val; 4364 #ifdef XP_DEBUG_OBJ_USAGE 4365 xmlXPathDebugObjUsageRequested(NULL, XPATH_NODESET); 4366 #endif 4367 return(ret); 4368 } 4369 4370 /** 4371 * xmlXPathFreeNodeSetList: 4372 * @obj: an existing NodeSetList object 4373 * 4374 * Free up the xmlXPathObjectPtr @obj but don't deallocate the objects in 4375 * the list contrary to xmlXPathFreeObject(). 4376 */ 4377 void 4378 xmlXPathFreeNodeSetList(xmlXPathObjectPtr obj) { 4379 if (obj == NULL) return; 4380 #ifdef XP_DEBUG_OBJ_USAGE 4381 xmlXPathDebugObjUsageReleased(NULL, obj->type); 4382 #endif 4383 xmlFree(obj); 4384 } 4385 4386 /** 4387 * xmlXPathDifference: 4388 * @nodes1: a node-set 4389 * @nodes2: a node-set 4390 * 4391 * Implements the EXSLT - Sets difference() function: 4392 * node-set set:difference (node-set, node-set) 4393 * 4394 * Returns the difference between the two node sets, or nodes1 if 4395 * nodes2 is empty 4396 */ 4397 xmlNodeSetPtr 4398 xmlXPathDifference (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) { 4399 xmlNodeSetPtr ret; 4400 int i, l1; 4401 xmlNodePtr cur; 4402 4403 if (xmlXPathNodeSetIsEmpty(nodes2)) 4404 return(nodes1); 4405 4406 ret = xmlXPathNodeSetCreate(NULL); 4407 if (xmlXPathNodeSetIsEmpty(nodes1)) 4408 return(ret); 4409 4410 l1 = xmlXPathNodeSetGetLength(nodes1); 4411 4412 for (i = 0; i < l1; i++) { 4413 cur = xmlXPathNodeSetItem(nodes1, i); 4414 if (!xmlXPathNodeSetContains(nodes2, cur)) 4415 xmlXPathNodeSetAddUnique(ret, cur); 4416 } 4417 return(ret); 4418 } 4419 4420 /** 4421 * xmlXPathIntersection: 4422 * @nodes1: a node-set 4423 * @nodes2: a node-set 4424 * 4425 * Implements the EXSLT - Sets intersection() function: 4426 * node-set set:intersection (node-set, node-set) 4427 * 4428 * Returns a node set comprising the nodes that are within both the 4429 * node sets passed as arguments 4430 */ 4431 xmlNodeSetPtr 4432 xmlXPathIntersection (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) { 4433 xmlNodeSetPtr ret = xmlXPathNodeSetCreate(NULL); 4434 int i, l1; 4435 xmlNodePtr cur; 4436 4437 if (ret == NULL) 4438 return(ret); 4439 if (xmlXPathNodeSetIsEmpty(nodes1)) 4440 return(ret); 4441 if (xmlXPathNodeSetIsEmpty(nodes2)) 4442 return(ret); 4443 4444 l1 = xmlXPathNodeSetGetLength(nodes1); 4445 4446 for (i = 0; i < l1; i++) { 4447 cur = xmlXPathNodeSetItem(nodes1, i); 4448 if (xmlXPathNodeSetContains(nodes2, cur)) 4449 xmlXPathNodeSetAddUnique(ret, cur); 4450 } 4451 return(ret); 4452 } 4453 4454 /** 4455 * xmlXPathDistinctSorted: 4456 * @nodes: a node-set, sorted by document order 4457 * 4458 * Implements the EXSLT - Sets distinct() function: 4459 * node-set set:distinct (node-set) 4460 * 4461 * Returns a subset of the nodes contained in @nodes, or @nodes if 4462 * it is empty 4463 */ 4464 xmlNodeSetPtr 4465 xmlXPathDistinctSorted (xmlNodeSetPtr nodes) { 4466 xmlNodeSetPtr ret; 4467 xmlHashTablePtr hash; 4468 int i, l; 4469 xmlChar * strval; 4470 xmlNodePtr cur; 4471 4472 if (xmlXPathNodeSetIsEmpty(nodes)) 4473 return(nodes); 4474 4475 ret = xmlXPathNodeSetCreate(NULL); 4476 if (ret == NULL) 4477 return(ret); 4478 l = xmlXPathNodeSetGetLength(nodes); 4479 hash = xmlHashCreate (l); 4480 for (i = 0; i < l; i++) { 4481 cur = xmlXPathNodeSetItem(nodes, i); 4482 strval = xmlXPathCastNodeToString(cur); 4483 if (xmlHashLookup(hash, strval) == NULL) { 4484 xmlHashAddEntry(hash, strval, strval); 4485 xmlXPathNodeSetAddUnique(ret, cur); 4486 } else { 4487 xmlFree(strval); 4488 } 4489 } 4490 xmlHashFree(hash, (xmlHashDeallocator) xmlFree); 4491 return(ret); 4492 } 4493 4494 /** 4495 * xmlXPathDistinct: 4496 * @nodes: a node-set 4497 * 4498 * Implements the EXSLT - Sets distinct() function: 4499 * node-set set:distinct (node-set) 4500 * @nodes is sorted by document order, then #exslSetsDistinctSorted 4501 * is called with the sorted node-set 4502 * 4503 * Returns a subset of the nodes contained in @nodes, or @nodes if 4504 * it is empty 4505 */ 4506 xmlNodeSetPtr 4507 xmlXPathDistinct (xmlNodeSetPtr nodes) { 4508 if (xmlXPathNodeSetIsEmpty(nodes)) 4509 return(nodes); 4510 4511 xmlXPathNodeSetSort(nodes); 4512 return(xmlXPathDistinctSorted(nodes)); 4513 } 4514 4515 /** 4516 * xmlXPathHasSameNodes: 4517 * @nodes1: a node-set 4518 * @nodes2: a node-set 4519 * 4520 * Implements the EXSLT - Sets has-same-nodes function: 4521 * boolean set:has-same-node(node-set, node-set) 4522 * 4523 * Returns true (1) if @nodes1 shares any node with @nodes2, false (0) 4524 * otherwise 4525 */ 4526 int 4527 xmlXPathHasSameNodes (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) { 4528 int i, l; 4529 xmlNodePtr cur; 4530 4531 if (xmlXPathNodeSetIsEmpty(nodes1) || 4532 xmlXPathNodeSetIsEmpty(nodes2)) 4533 return(0); 4534 4535 l = xmlXPathNodeSetGetLength(nodes1); 4536 for (i = 0; i < l; i++) { 4537 cur = xmlXPathNodeSetItem(nodes1, i); 4538 if (xmlXPathNodeSetContains(nodes2, cur)) 4539 return(1); 4540 } 4541 return(0); 4542 } 4543 4544 /** 4545 * xmlXPathNodeLeadingSorted: 4546 * @nodes: a node-set, sorted by document order 4547 * @node: a node 4548 * 4549 * Implements the EXSLT - Sets leading() function: 4550 * node-set set:leading (node-set, node-set) 4551 * 4552 * Returns the nodes in @nodes that precede @node in document order, 4553 * @nodes if @node is NULL or an empty node-set if @nodes 4554 * doesn't contain @node 4555 */ 4556 xmlNodeSetPtr 4557 xmlXPathNodeLeadingSorted (xmlNodeSetPtr nodes, xmlNodePtr node) { 4558 int i, l; 4559 xmlNodePtr cur; 4560 xmlNodeSetPtr ret; 4561 4562 if (node == NULL) 4563 return(nodes); 4564 4565 ret = xmlXPathNodeSetCreate(NULL); 4566 if (ret == NULL) 4567 return(ret); 4568 if (xmlXPathNodeSetIsEmpty(nodes) || 4569 (!xmlXPathNodeSetContains(nodes, node))) 4570 return(ret); 4571 4572 l = xmlXPathNodeSetGetLength(nodes); 4573 for (i = 0; i < l; i++) { 4574 cur = xmlXPathNodeSetItem(nodes, i); 4575 if (cur == node) 4576 break; 4577 xmlXPathNodeSetAddUnique(ret, cur); 4578 } 4579 return(ret); 4580 } 4581 4582 /** 4583 * xmlXPathNodeLeading: 4584 * @nodes: a node-set 4585 * @node: a node 4586 * 4587 * Implements the EXSLT - Sets leading() function: 4588 * node-set set:leading (node-set, node-set) 4589 * @nodes is sorted by document order, then #exslSetsNodeLeadingSorted 4590 * is called. 4591 * 4592 * Returns the nodes in @nodes that precede @node in document order, 4593 * @nodes if @node is NULL or an empty node-set if @nodes 4594 * doesn't contain @node 4595 */ 4596 xmlNodeSetPtr 4597 xmlXPathNodeLeading (xmlNodeSetPtr nodes, xmlNodePtr node) { 4598 xmlXPathNodeSetSort(nodes); 4599 return(xmlXPathNodeLeadingSorted(nodes, node)); 4600 } 4601 4602 /** 4603 * xmlXPathLeadingSorted: 4604 * @nodes1: a node-set, sorted by document order 4605 * @nodes2: a node-set, sorted by document order 4606 * 4607 * Implements the EXSLT - Sets leading() function: 4608 * node-set set:leading (node-set, node-set) 4609 * 4610 * Returns the nodes in @nodes1 that precede the first node in @nodes2 4611 * in document order, @nodes1 if @nodes2 is NULL or empty or 4612 * an empty node-set if @nodes1 doesn't contain @nodes2 4613 */ 4614 xmlNodeSetPtr 4615 xmlXPathLeadingSorted (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) { 4616 if (xmlXPathNodeSetIsEmpty(nodes2)) 4617 return(nodes1); 4618 return(xmlXPathNodeLeadingSorted(nodes1, 4619 xmlXPathNodeSetItem(nodes2, 1))); 4620 } 4621 4622 /** 4623 * xmlXPathLeading: 4624 * @nodes1: a node-set 4625 * @nodes2: a node-set 4626 * 4627 * Implements the EXSLT - Sets leading() function: 4628 * node-set set:leading (node-set, node-set) 4629 * @nodes1 and @nodes2 are sorted by document order, then 4630 * #exslSetsLeadingSorted is called. 4631 * 4632 * Returns the nodes in @nodes1 that precede the first node in @nodes2 4633 * in document order, @nodes1 if @nodes2 is NULL or empty or 4634 * an empty node-set if @nodes1 doesn't contain @nodes2 4635 */ 4636 xmlNodeSetPtr 4637 xmlXPathLeading (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) { 4638 if (xmlXPathNodeSetIsEmpty(nodes2)) 4639 return(nodes1); 4640 if (xmlXPathNodeSetIsEmpty(nodes1)) 4641 return(xmlXPathNodeSetCreate(NULL)); 4642 xmlXPathNodeSetSort(nodes1); 4643 xmlXPathNodeSetSort(nodes2); 4644 return(xmlXPathNodeLeadingSorted(nodes1, 4645 xmlXPathNodeSetItem(nodes2, 1))); 4646 } 4647 4648 /** 4649 * xmlXPathNodeTrailingSorted: 4650 * @nodes: a node-set, sorted by document order 4651 * @node: a node 4652 * 4653 * Implements the EXSLT - Sets trailing() function: 4654 * node-set set:trailing (node-set, node-set) 4655 * 4656 * Returns the nodes in @nodes that follow @node in document order, 4657 * @nodes if @node is NULL or an empty node-set if @nodes 4658 * doesn't contain @node 4659 */ 4660 xmlNodeSetPtr 4661 xmlXPathNodeTrailingSorted (xmlNodeSetPtr nodes, xmlNodePtr node) { 4662 int i, l; 4663 xmlNodePtr cur; 4664 xmlNodeSetPtr ret; 4665 4666 if (node == NULL) 4667 return(nodes); 4668 4669 ret = xmlXPathNodeSetCreate(NULL); 4670 if (ret == NULL) 4671 return(ret); 4672 if (xmlXPathNodeSetIsEmpty(nodes) || 4673 (!xmlXPathNodeSetContains(nodes, node))) 4674 return(ret); 4675 4676 l = xmlXPathNodeSetGetLength(nodes); 4677 for (i = l - 1; i >= 0; i--) { 4678 cur = xmlXPathNodeSetItem(nodes, i); 4679 if (cur == node) 4680 break; 4681 xmlXPathNodeSetAddUnique(ret, cur); 4682 } 4683 xmlXPathNodeSetSort(ret); /* bug 413451 */ 4684 return(ret); 4685 } 4686 4687 /** 4688 * xmlXPathNodeTrailing: 4689 * @nodes: a node-set 4690 * @node: a node 4691 * 4692 * Implements the EXSLT - Sets trailing() function: 4693 * node-set set:trailing (node-set, node-set) 4694 * @nodes is sorted by document order, then #xmlXPathNodeTrailingSorted 4695 * is called. 4696 * 4697 * Returns the nodes in @nodes that follow @node in document order, 4698 * @nodes if @node is NULL or an empty node-set if @nodes 4699 * doesn't contain @node 4700 */ 4701 xmlNodeSetPtr 4702 xmlXPathNodeTrailing (xmlNodeSetPtr nodes, xmlNodePtr node) { 4703 xmlXPathNodeSetSort(nodes); 4704 return(xmlXPathNodeTrailingSorted(nodes, node)); 4705 } 4706 4707 /** 4708 * xmlXPathTrailingSorted: 4709 * @nodes1: a node-set, sorted by document order 4710 * @nodes2: a node-set, sorted by document order 4711 * 4712 * Implements the EXSLT - Sets trailing() function: 4713 * node-set set:trailing (node-set, node-set) 4714 * 4715 * Returns the nodes in @nodes1 that follow the first node in @nodes2 4716 * in document order, @nodes1 if @nodes2 is NULL or empty or 4717 * an empty node-set if @nodes1 doesn't contain @nodes2 4718 */ 4719 xmlNodeSetPtr 4720 xmlXPathTrailingSorted (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) { 4721 if (xmlXPathNodeSetIsEmpty(nodes2)) 4722 return(nodes1); 4723 return(xmlXPathNodeTrailingSorted(nodes1, 4724 xmlXPathNodeSetItem(nodes2, 0))); 4725 } 4726 4727 /** 4728 * xmlXPathTrailing: 4729 * @nodes1: a node-set 4730 * @nodes2: a node-set 4731 * 4732 * Implements the EXSLT - Sets trailing() function: 4733 * node-set set:trailing (node-set, node-set) 4734 * @nodes1 and @nodes2 are sorted by document order, then 4735 * #xmlXPathTrailingSorted is called. 4736 * 4737 * Returns the nodes in @nodes1 that follow the first node in @nodes2 4738 * in document order, @nodes1 if @nodes2 is NULL or empty or 4739 * an empty node-set if @nodes1 doesn't contain @nodes2 4740 */ 4741 xmlNodeSetPtr 4742 xmlXPathTrailing (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) { 4743 if (xmlXPathNodeSetIsEmpty(nodes2)) 4744 return(nodes1); 4745 if (xmlXPathNodeSetIsEmpty(nodes1)) 4746 return(xmlXPathNodeSetCreate(NULL)); 4747 xmlXPathNodeSetSort(nodes1); 4748 xmlXPathNodeSetSort(nodes2); 4749 return(xmlXPathNodeTrailingSorted(nodes1, 4750 xmlXPathNodeSetItem(nodes2, 0))); 4751 } 4752 4753 /************************************************************************ 4754 * * 4755 * Routines to handle extra functions * 4756 * * 4757 ************************************************************************/ 4758 4759 /** 4760 * xmlXPathRegisterFunc: 4761 * @ctxt: the XPath context 4762 * @name: the function name 4763 * @f: the function implementation or NULL 4764 * 4765 * Register a new function. If @f is NULL it unregisters the function 4766 * 4767 * Returns 0 in case of success, -1 in case of error 4768 */ 4769 int 4770 xmlXPathRegisterFunc(xmlXPathContextPtr ctxt, const xmlChar *name, 4771 xmlXPathFunction f) { 4772 return(xmlXPathRegisterFuncNS(ctxt, name, NULL, f)); 4773 } 4774 4775 /** 4776 * xmlXPathRegisterFuncNS: 4777 * @ctxt: the XPath context 4778 * @name: the function name 4779 * @ns_uri: the function namespace URI 4780 * @f: the function implementation or NULL 4781 * 4782 * Register a new function. If @f is NULL it unregisters the function 4783 * 4784 * Returns 0 in case of success, -1 in case of error 4785 */ 4786 int 4787 xmlXPathRegisterFuncNS(xmlXPathContextPtr ctxt, const xmlChar *name, 4788 const xmlChar *ns_uri, xmlXPathFunction f) { 4789 if (ctxt == NULL) 4790 return(-1); 4791 if (name == NULL) 4792 return(-1); 4793 4794 if (ctxt->funcHash == NULL) 4795 ctxt->funcHash = xmlHashCreate(0); 4796 if (ctxt->funcHash == NULL) 4797 return(-1); 4798 if (f == NULL) 4799 return(xmlHashRemoveEntry2(ctxt->funcHash, name, ns_uri, NULL)); 4800 return(xmlHashAddEntry2(ctxt->funcHash, name, ns_uri, XML_CAST_FPTR(f))); 4801 } 4802 4803 /** 4804 * xmlXPathRegisterFuncLookup: 4805 * @ctxt: the XPath context 4806 * @f: the lookup function 4807 * @funcCtxt: the lookup data 4808 * 4809 * Registers an external mechanism to do function lookup. 4810 */ 4811 void 4812 xmlXPathRegisterFuncLookup (xmlXPathContextPtr ctxt, 4813 xmlXPathFuncLookupFunc f, 4814 void *funcCtxt) { 4815 if (ctxt == NULL) 4816 return; 4817 ctxt->funcLookupFunc = f; 4818 ctxt->funcLookupData = funcCtxt; 4819 } 4820 4821 /** 4822 * xmlXPathFunctionLookup: 4823 * @ctxt: the XPath context 4824 * @name: the function name 4825 * 4826 * Search in the Function array of the context for the given 4827 * function. 4828 * 4829 * Returns the xmlXPathFunction or NULL if not found 4830 */ 4831 xmlXPathFunction 4832 xmlXPathFunctionLookup(xmlXPathContextPtr ctxt, const xmlChar *name) { 4833 if (ctxt == NULL) 4834 return (NULL); 4835 4836 if (ctxt->funcLookupFunc != NULL) { 4837 xmlXPathFunction ret; 4838 xmlXPathFuncLookupFunc f; 4839 4840 f = ctxt->funcLookupFunc; 4841 ret = f(ctxt->funcLookupData, name, NULL); 4842 if (ret != NULL) 4843 return(ret); 4844 } 4845 return(xmlXPathFunctionLookupNS(ctxt, name, NULL)); 4846 } 4847 4848 /** 4849 * xmlXPathFunctionLookupNS: 4850 * @ctxt: the XPath context 4851 * @name: the function name 4852 * @ns_uri: the function namespace URI 4853 * 4854 * Search in the Function array of the context for the given 4855 * function. 4856 * 4857 * Returns the xmlXPathFunction or NULL if not found 4858 */ 4859 xmlXPathFunction 4860 xmlXPathFunctionLookupNS(xmlXPathContextPtr ctxt, const xmlChar *name, 4861 const xmlChar *ns_uri) { 4862 xmlXPathFunction ret; 4863 4864 if (ctxt == NULL) 4865 return(NULL); 4866 if (name == NULL) 4867 return(NULL); 4868 4869 if (ctxt->funcLookupFunc != NULL) { 4870 xmlXPathFuncLookupFunc f; 4871 4872 f = ctxt->funcLookupFunc; 4873 ret = f(ctxt->funcLookupData, name, ns_uri); 4874 if (ret != NULL) 4875 return(ret); 4876 } 4877 4878 if (ctxt->funcHash == NULL) 4879 return(NULL); 4880 4881 XML_CAST_FPTR(ret) = xmlHashLookup2(ctxt->funcHash, name, ns_uri); 4882 return(ret); 4883 } 4884 4885 /** 4886 * xmlXPathRegisteredFuncsCleanup: 4887 * @ctxt: the XPath context 4888 * 4889 * Cleanup the XPath context data associated to registered functions 4890 */ 4891 void 4892 xmlXPathRegisteredFuncsCleanup(xmlXPathContextPtr ctxt) { 4893 if (ctxt == NULL) 4894 return; 4895 4896 xmlHashFree(ctxt->funcHash, NULL); 4897 ctxt->funcHash = NULL; 4898 } 4899 4900 /************************************************************************ 4901 * * 4902 * Routines to handle Variables * 4903 * * 4904 ************************************************************************/ 4905 4906 /** 4907 * xmlXPathRegisterVariable: 4908 * @ctxt: the XPath context 4909 * @name: the variable name 4910 * @value: the variable value or NULL 4911 * 4912 * Register a new variable value. If @value is NULL it unregisters 4913 * the variable 4914 * 4915 * Returns 0 in case of success, -1 in case of error 4916 */ 4917 int 4918 xmlXPathRegisterVariable(xmlXPathContextPtr ctxt, const xmlChar *name, 4919 xmlXPathObjectPtr value) { 4920 return(xmlXPathRegisterVariableNS(ctxt, name, NULL, value)); 4921 } 4922 4923 /** 4924 * xmlXPathRegisterVariableNS: 4925 * @ctxt: the XPath context 4926 * @name: the variable name 4927 * @ns_uri: the variable namespace URI 4928 * @value: the variable value or NULL 4929 * 4930 * Register a new variable value. If @value is NULL it unregisters 4931 * the variable 4932 * 4933 * Returns 0 in case of success, -1 in case of error 4934 */ 4935 int 4936 xmlXPathRegisterVariableNS(xmlXPathContextPtr ctxt, const xmlChar *name, 4937 const xmlChar *ns_uri, 4938 xmlXPathObjectPtr value) { 4939 if (ctxt == NULL) 4940 return(-1); 4941 if (name == NULL) 4942 return(-1); 4943 4944 if (ctxt->varHash == NULL) 4945 ctxt->varHash = xmlHashCreate(0); 4946 if (ctxt->varHash == NULL) 4947 return(-1); 4948 if (value == NULL) 4949 return(xmlHashRemoveEntry2(ctxt->varHash, name, ns_uri, 4950 (xmlHashDeallocator)xmlXPathFreeObject)); 4951 return(xmlHashUpdateEntry2(ctxt->varHash, name, ns_uri, 4952 (void *) value, 4953 (xmlHashDeallocator)xmlXPathFreeObject)); 4954 } 4955 4956 /** 4957 * xmlXPathRegisterVariableLookup: 4958 * @ctxt: the XPath context 4959 * @f: the lookup function 4960 * @data: the lookup data 4961 * 4962 * register an external mechanism to do variable lookup 4963 */ 4964 void 4965 xmlXPathRegisterVariableLookup(xmlXPathContextPtr ctxt, 4966 xmlXPathVariableLookupFunc f, void *data) { 4967 if (ctxt == NULL) 4968 return; 4969 ctxt->varLookupFunc = f; 4970 ctxt->varLookupData = data; 4971 } 4972 4973 /** 4974 * xmlXPathVariableLookup: 4975 * @ctxt: the XPath context 4976 * @name: the variable name 4977 * 4978 * Search in the Variable array of the context for the given 4979 * variable value. 4980 * 4981 * Returns a copy of the value or NULL if not found 4982 */ 4983 xmlXPathObjectPtr 4984 xmlXPathVariableLookup(xmlXPathContextPtr ctxt, const xmlChar *name) { 4985 if (ctxt == NULL) 4986 return(NULL); 4987 4988 if (ctxt->varLookupFunc != NULL) { 4989 xmlXPathObjectPtr ret; 4990 4991 ret = ((xmlXPathVariableLookupFunc)ctxt->varLookupFunc) 4992 (ctxt->varLookupData, name, NULL); 4993 return(ret); 4994 } 4995 return(xmlXPathVariableLookupNS(ctxt, name, NULL)); 4996 } 4997 4998 /** 4999 * xmlXPathVariableLookupNS: 5000 * @ctxt: the XPath context 5001 * @name: the variable name 5002 * @ns_uri: the variable namespace URI 5003 * 5004 * Search in the Variable array of the context for the given 5005 * variable value. 5006 * 5007 * Returns the a copy of the value or NULL if not found 5008 */ 5009 xmlXPathObjectPtr 5010 xmlXPathVariableLookupNS(xmlXPathContextPtr ctxt, const xmlChar *name, 5011 const xmlChar *ns_uri) { 5012 if (ctxt == NULL) 5013 return(NULL); 5014 5015 if (ctxt->varLookupFunc != NULL) { 5016 xmlXPathObjectPtr ret; 5017 5018 ret = ((xmlXPathVariableLookupFunc)ctxt->varLookupFunc) 5019 (ctxt->varLookupData, name, ns_uri); 5020 if (ret != NULL) return(ret); 5021 } 5022 5023 if (ctxt->varHash == NULL) 5024 return(NULL); 5025 if (name == NULL) 5026 return(NULL); 5027 5028 return(xmlXPathCacheObjectCopy(ctxt, (xmlXPathObjectPtr) 5029 xmlHashLookup2(ctxt->varHash, name, ns_uri))); 5030 } 5031 5032 /** 5033 * xmlXPathRegisteredVariablesCleanup: 5034 * @ctxt: the XPath context 5035 * 5036 * Cleanup the XPath context data associated to registered variables 5037 */ 5038 void 5039 xmlXPathRegisteredVariablesCleanup(xmlXPathContextPtr ctxt) { 5040 if (ctxt == NULL) 5041 return; 5042 5043 xmlHashFree(ctxt->varHash, (xmlHashDeallocator)xmlXPathFreeObject); 5044 ctxt->varHash = NULL; 5045 } 5046 5047 /** 5048 * xmlXPathRegisterNs: 5049 * @ctxt: the XPath context 5050 * @prefix: the namespace prefix cannot be NULL or empty string 5051 * @ns_uri: the namespace name 5052 * 5053 * Register a new namespace. If @ns_uri is NULL it unregisters 5054 * the namespace 5055 * 5056 * Returns 0 in case of success, -1 in case of error 5057 */ 5058 int 5059 xmlXPathRegisterNs(xmlXPathContextPtr ctxt, const xmlChar *prefix, 5060 const xmlChar *ns_uri) { 5061 if (ctxt == NULL) 5062 return(-1); 5063 if (prefix == NULL) 5064 return(-1); 5065 if (prefix[0] == 0) 5066 return(-1); 5067 5068 if (ctxt->nsHash == NULL) 5069 ctxt->nsHash = xmlHashCreate(10); 5070 if (ctxt->nsHash == NULL) 5071 return(-1); 5072 if (ns_uri == NULL) 5073 return(xmlHashRemoveEntry(ctxt->nsHash, prefix, 5074 (xmlHashDeallocator)xmlFree)); 5075 return(xmlHashUpdateEntry(ctxt->nsHash, prefix, (void *) xmlStrdup(ns_uri), 5076 (xmlHashDeallocator)xmlFree)); 5077 } 5078 5079 /** 5080 * xmlXPathNsLookup: 5081 * @ctxt: the XPath context 5082 * @prefix: the namespace prefix value 5083 * 5084 * Search in the namespace declaration array of the context for the given 5085 * namespace name associated to the given prefix 5086 * 5087 * Returns the value or NULL if not found 5088 */ 5089 const xmlChar * 5090 xmlXPathNsLookup(xmlXPathContextPtr ctxt, const xmlChar *prefix) { 5091 if (ctxt == NULL) 5092 return(NULL); 5093 if (prefix == NULL) 5094 return(NULL); 5095 5096 #ifdef XML_XML_NAMESPACE 5097 if (xmlStrEqual(prefix, (const xmlChar *) "xml")) 5098 return(XML_XML_NAMESPACE); 5099 #endif 5100 5101 if (ctxt->namespaces != NULL) { 5102 int i; 5103 5104 for (i = 0;i < ctxt->nsNr;i++) { 5105 if ((ctxt->namespaces[i] != NULL) && 5106 (xmlStrEqual(ctxt->namespaces[i]->prefix, prefix))) 5107 return(ctxt->namespaces[i]->href); 5108 } 5109 } 5110 5111 return((const xmlChar *) xmlHashLookup(ctxt->nsHash, prefix)); 5112 } 5113 5114 /** 5115 * xmlXPathRegisteredNsCleanup: 5116 * @ctxt: the XPath context 5117 * 5118 * Cleanup the XPath context data associated to registered variables 5119 */ 5120 void 5121 xmlXPathRegisteredNsCleanup(xmlXPathContextPtr ctxt) { 5122 if (ctxt == NULL) 5123 return; 5124 5125 xmlHashFree(ctxt->nsHash, (xmlHashDeallocator)xmlFree); 5126 ctxt->nsHash = NULL; 5127 } 5128 5129 /************************************************************************ 5130 * * 5131 * Routines to handle Values * 5132 * * 5133 ************************************************************************/ 5134 5135 /* Allocations are terrible, one needs to optimize all this !!! */ 5136 5137 /** 5138 * xmlXPathNewFloat: 5139 * @val: the double value 5140 * 5141 * Create a new xmlXPathObjectPtr of type double and of value @val 5142 * 5143 * Returns the newly created object. 5144 */ 5145 xmlXPathObjectPtr 5146 xmlXPathNewFloat(double val) { 5147 xmlXPathObjectPtr ret; 5148 5149 ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject)); 5150 if (ret == NULL) { 5151 xmlXPathErrMemory(NULL, "creating float object\n"); 5152 return(NULL); 5153 } 5154 memset(ret, 0 , (size_t) sizeof(xmlXPathObject)); 5155 ret->type = XPATH_NUMBER; 5156 ret->floatval = val; 5157 #ifdef XP_DEBUG_OBJ_USAGE 5158 xmlXPathDebugObjUsageRequested(NULL, XPATH_NUMBER); 5159 #endif 5160 return(ret); 5161 } 5162 5163 /** 5164 * xmlXPathNewBoolean: 5165 * @val: the boolean value 5166 * 5167 * Create a new xmlXPathObjectPtr of type boolean and of value @val 5168 * 5169 * Returns the newly created object. 5170 */ 5171 xmlXPathObjectPtr 5172 xmlXPathNewBoolean(int val) { 5173 xmlXPathObjectPtr ret; 5174 5175 ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject)); 5176 if (ret == NULL) { 5177 xmlXPathErrMemory(NULL, "creating boolean object\n"); 5178 return(NULL); 5179 } 5180 memset(ret, 0 , (size_t) sizeof(xmlXPathObject)); 5181 ret->type = XPATH_BOOLEAN; 5182 ret->boolval = (val != 0); 5183 #ifdef XP_DEBUG_OBJ_USAGE 5184 xmlXPathDebugObjUsageRequested(NULL, XPATH_BOOLEAN); 5185 #endif 5186 return(ret); 5187 } 5188 5189 /** 5190 * xmlXPathNewString: 5191 * @val: the xmlChar * value 5192 * 5193 * Create a new xmlXPathObjectPtr of type string and of value @val 5194 * 5195 * Returns the newly created object. 5196 */ 5197 xmlXPathObjectPtr 5198 xmlXPathNewString(const xmlChar *val) { 5199 xmlXPathObjectPtr ret; 5200 5201 ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject)); 5202 if (ret == NULL) { 5203 xmlXPathErrMemory(NULL, "creating string object\n"); 5204 return(NULL); 5205 } 5206 memset(ret, 0 , (size_t) sizeof(xmlXPathObject)); 5207 ret->type = XPATH_STRING; 5208 if (val != NULL) 5209 ret->stringval = xmlStrdup(val); 5210 else 5211 ret->stringval = xmlStrdup((const xmlChar *)""); 5212 #ifdef XP_DEBUG_OBJ_USAGE 5213 xmlXPathDebugObjUsageRequested(NULL, XPATH_STRING); 5214 #endif 5215 return(ret); 5216 } 5217 5218 /** 5219 * xmlXPathWrapString: 5220 * @val: the xmlChar * value 5221 * 5222 * Wraps the @val string into an XPath object. 5223 * 5224 * Returns the newly created object. 5225 */ 5226 xmlXPathObjectPtr 5227 xmlXPathWrapString (xmlChar *val) { 5228 xmlXPathObjectPtr ret; 5229 5230 ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject)); 5231 if (ret == NULL) { 5232 xmlXPathErrMemory(NULL, "creating string object\n"); 5233 return(NULL); 5234 } 5235 memset(ret, 0 , (size_t) sizeof(xmlXPathObject)); 5236 ret->type = XPATH_STRING; 5237 ret->stringval = val; 5238 #ifdef XP_DEBUG_OBJ_USAGE 5239 xmlXPathDebugObjUsageRequested(NULL, XPATH_STRING); 5240 #endif 5241 return(ret); 5242 } 5243 5244 /** 5245 * xmlXPathNewCString: 5246 * @val: the char * value 5247 * 5248 * Create a new xmlXPathObjectPtr of type string and of value @val 5249 * 5250 * Returns the newly created object. 5251 */ 5252 xmlXPathObjectPtr 5253 xmlXPathNewCString(const char *val) { 5254 xmlXPathObjectPtr ret; 5255 5256 ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject)); 5257 if (ret == NULL) { 5258 xmlXPathErrMemory(NULL, "creating string object\n"); 5259 return(NULL); 5260 } 5261 memset(ret, 0 , (size_t) sizeof(xmlXPathObject)); 5262 ret->type = XPATH_STRING; 5263 ret->stringval = xmlStrdup(BAD_CAST val); 5264 #ifdef XP_DEBUG_OBJ_USAGE 5265 xmlXPathDebugObjUsageRequested(NULL, XPATH_STRING); 5266 #endif 5267 return(ret); 5268 } 5269 5270 /** 5271 * xmlXPathWrapCString: 5272 * @val: the char * value 5273 * 5274 * Wraps a string into an XPath object. 5275 * 5276 * Returns the newly created object. 5277 */ 5278 xmlXPathObjectPtr 5279 xmlXPathWrapCString (char * val) { 5280 return(xmlXPathWrapString((xmlChar *)(val))); 5281 } 5282 5283 /** 5284 * xmlXPathWrapExternal: 5285 * @val: the user data 5286 * 5287 * Wraps the @val data into an XPath object. 5288 * 5289 * Returns the newly created object. 5290 */ 5291 xmlXPathObjectPtr 5292 xmlXPathWrapExternal (void *val) { 5293 xmlXPathObjectPtr ret; 5294 5295 ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject)); 5296 if (ret == NULL) { 5297 xmlXPathErrMemory(NULL, "creating user object\n"); 5298 return(NULL); 5299 } 5300 memset(ret, 0 , (size_t) sizeof(xmlXPathObject)); 5301 ret->type = XPATH_USERS; 5302 ret->user = val; 5303 #ifdef XP_DEBUG_OBJ_USAGE 5304 xmlXPathDebugObjUsageRequested(NULL, XPATH_USERS); 5305 #endif 5306 return(ret); 5307 } 5308 5309 /** 5310 * xmlXPathObjectCopy: 5311 * @val: the original object 5312 * 5313 * allocate a new copy of a given object 5314 * 5315 * Returns the newly created object. 5316 */ 5317 xmlXPathObjectPtr 5318 xmlXPathObjectCopy(xmlXPathObjectPtr val) { 5319 xmlXPathObjectPtr ret; 5320 5321 if (val == NULL) 5322 return(NULL); 5323 5324 ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject)); 5325 if (ret == NULL) { 5326 xmlXPathErrMemory(NULL, "copying object\n"); 5327 return(NULL); 5328 } 5329 memcpy(ret, val , (size_t) sizeof(xmlXPathObject)); 5330 #ifdef XP_DEBUG_OBJ_USAGE 5331 xmlXPathDebugObjUsageRequested(NULL, val->type); 5332 #endif 5333 switch (val->type) { 5334 case XPATH_BOOLEAN: 5335 case XPATH_NUMBER: 5336 case XPATH_POINT: 5337 case XPATH_RANGE: 5338 break; 5339 case XPATH_STRING: 5340 ret->stringval = xmlStrdup(val->stringval); 5341 break; 5342 case XPATH_XSLT_TREE: 5343 #if 0 5344 /* 5345 Removed 11 July 2004 - the current handling of xslt tmpRVT nodes means that 5346 this previous handling is no longer correct, and can cause some serious 5347 problems (ref. bug 145547) 5348 */ 5349 if ((val->nodesetval != NULL) && 5350 (val->nodesetval->nodeTab != NULL)) { 5351 xmlNodePtr cur, tmp; 5352 xmlDocPtr top; 5353 5354 ret->boolval = 1; 5355 top = xmlNewDoc(NULL); 5356 top->name = (char *) 5357 xmlStrdup(val->nodesetval->nodeTab[0]->name); 5358 ret->user = top; 5359 if (top != NULL) { 5360 top->doc = top; 5361 cur = val->nodesetval->nodeTab[0]->children; 5362 while (cur != NULL) { 5363 tmp = xmlDocCopyNode(cur, top, 1); 5364 xmlAddChild((xmlNodePtr) top, tmp); 5365 cur = cur->next; 5366 } 5367 } 5368 5369 ret->nodesetval = xmlXPathNodeSetCreate((xmlNodePtr) top); 5370 } else 5371 ret->nodesetval = xmlXPathNodeSetCreate(NULL); 5372 /* Deallocate the copied tree value */ 5373 break; 5374 #endif 5375 case XPATH_NODESET: 5376 ret->nodesetval = xmlXPathNodeSetMerge(NULL, val->nodesetval); 5377 /* Do not deallocate the copied tree value */ 5378 ret->boolval = 0; 5379 break; 5380 case XPATH_LOCATIONSET: 5381 #ifdef LIBXML_XPTR_ENABLED 5382 { 5383 xmlLocationSetPtr loc = val->user; 5384 ret->user = (void *) xmlXPtrLocationSetMerge(NULL, loc); 5385 break; 5386 } 5387 #endif 5388 case XPATH_USERS: 5389 ret->user = val->user; 5390 break; 5391 case XPATH_UNDEFINED: 5392 xmlGenericError(xmlGenericErrorContext, 5393 "xmlXPathObjectCopy: unsupported type %d\n", 5394 val->type); 5395 break; 5396 } 5397 return(ret); 5398 } 5399 5400 /** 5401 * xmlXPathFreeObject: 5402 * @obj: the object to free 5403 * 5404 * Free up an xmlXPathObjectPtr object. 5405 */ 5406 void 5407 xmlXPathFreeObject(xmlXPathObjectPtr obj) { 5408 if (obj == NULL) return; 5409 if ((obj->type == XPATH_NODESET) || (obj->type == XPATH_XSLT_TREE)) { 5410 if (obj->boolval) { 5411 #if 0 5412 if (obj->user != NULL) { 5413 xmlXPathFreeNodeSet(obj->nodesetval); 5414 xmlFreeNodeList((xmlNodePtr) obj->user); 5415 } else 5416 #endif 5417 obj->type = XPATH_XSLT_TREE; /* TODO: Just for debugging. */ 5418 if (obj->nodesetval != NULL) 5419 xmlXPathFreeValueTree(obj->nodesetval); 5420 } else { 5421 if (obj->nodesetval != NULL) 5422 xmlXPathFreeNodeSet(obj->nodesetval); 5423 } 5424 #ifdef LIBXML_XPTR_ENABLED 5425 } else if (obj->type == XPATH_LOCATIONSET) { 5426 if (obj->user != NULL) 5427 xmlXPtrFreeLocationSet(obj->user); 5428 #endif 5429 } else if (obj->type == XPATH_STRING) { 5430 if (obj->stringval != NULL) 5431 xmlFree(obj->stringval); 5432 } 5433 #ifdef XP_DEBUG_OBJ_USAGE 5434 xmlXPathDebugObjUsageReleased(NULL, obj->type); 5435 #endif 5436 xmlFree(obj); 5437 } 5438 5439 /** 5440 * xmlXPathReleaseObject: 5441 * @obj: the xmlXPathObjectPtr to free or to cache 5442 * 5443 * Depending on the state of the cache this frees the given 5444 * XPath object or stores it in the cache. 5445 */ 5446 static void 5447 xmlXPathReleaseObject(xmlXPathContextPtr ctxt, xmlXPathObjectPtr obj) 5448 { 5449 #define XP_CACHE_ADD(sl, o) if (sl == NULL) { \ 5450 sl = xmlPointerListCreate(10); if (sl == NULL) goto free_obj; } \ 5451 if (xmlPointerListAddSize(sl, obj, 0) == -1) goto free_obj; 5452 5453 #define XP_CACHE_WANTS(sl, n) ((sl == NULL) || ((sl)->number < n)) 5454 5455 if (obj == NULL) 5456 return; 5457 if ((ctxt == NULL) || (ctxt->cache == NULL)) { 5458 xmlXPathFreeObject(obj); 5459 } else { 5460 xmlXPathContextCachePtr cache = 5461 (xmlXPathContextCachePtr) ctxt->cache; 5462 5463 switch (obj->type) { 5464 case XPATH_NODESET: 5465 case XPATH_XSLT_TREE: 5466 if (obj->nodesetval != NULL) { 5467 if (obj->boolval) { 5468 /* 5469 * It looks like the @boolval is used for 5470 * evaluation if this an XSLT Result Tree Fragment. 5471 * TODO: Check if this assumption is correct. 5472 */ 5473 obj->type = XPATH_XSLT_TREE; /* just for debugging */ 5474 xmlXPathFreeValueTree(obj->nodesetval); 5475 obj->nodesetval = NULL; 5476 } else if ((obj->nodesetval->nodeMax <= 40) && 5477 (XP_CACHE_WANTS(cache->nodesetObjs, 5478 cache->maxNodeset))) 5479 { 5480 XP_CACHE_ADD(cache->nodesetObjs, obj); 5481 goto obj_cached; 5482 } else { 5483 xmlXPathFreeNodeSet(obj->nodesetval); 5484 obj->nodesetval = NULL; 5485 } 5486 } 5487 break; 5488 case XPATH_STRING: 5489 if (obj->stringval != NULL) 5490 xmlFree(obj->stringval); 5491 5492 if (XP_CACHE_WANTS(cache->stringObjs, cache->maxString)) { 5493 XP_CACHE_ADD(cache->stringObjs, obj); 5494 goto obj_cached; 5495 } 5496 break; 5497 case XPATH_BOOLEAN: 5498 if (XP_CACHE_WANTS(cache->booleanObjs, cache->maxBoolean)) { 5499 XP_CACHE_ADD(cache->booleanObjs, obj); 5500 goto obj_cached; 5501 } 5502 break; 5503 case XPATH_NUMBER: 5504 if (XP_CACHE_WANTS(cache->numberObjs, cache->maxNumber)) { 5505 XP_CACHE_ADD(cache->numberObjs, obj); 5506 goto obj_cached; 5507 } 5508 break; 5509 #ifdef LIBXML_XPTR_ENABLED 5510 case XPATH_LOCATIONSET: 5511 if (obj->user != NULL) { 5512 xmlXPtrFreeLocationSet(obj->user); 5513 } 5514 goto free_obj; 5515 #endif 5516 default: 5517 goto free_obj; 5518 } 5519 5520 /* 5521 * Fallback to adding to the misc-objects slot. 5522 */ 5523 if (XP_CACHE_WANTS(cache->miscObjs, cache->maxMisc)) { 5524 XP_CACHE_ADD(cache->miscObjs, obj); 5525 } else 5526 goto free_obj; 5527 5528 obj_cached: 5529 5530 #ifdef XP_DEBUG_OBJ_USAGE 5531 xmlXPathDebugObjUsageReleased(ctxt, obj->type); 5532 #endif 5533 5534 if (obj->nodesetval != NULL) { 5535 xmlNodeSetPtr tmpset = obj->nodesetval; 5536 5537 /* 5538 * TODO: Due to those nasty ns-nodes, we need to traverse 5539 * the list and free the ns-nodes. 5540 * URGENT TODO: Check if it's actually slowing things down. 5541 * Maybe we shouldn't try to preserve the list. 5542 */ 5543 if (tmpset->nodeNr > 1) { 5544 int i; 5545 xmlNodePtr node; 5546 5547 for (i = 0; i < tmpset->nodeNr; i++) { 5548 node = tmpset->nodeTab[i]; 5549 if ((node != NULL) && 5550 (node->type == XML_NAMESPACE_DECL)) 5551 { 5552 xmlXPathNodeSetFreeNs((xmlNsPtr) node); 5553 } 5554 } 5555 } else if (tmpset->nodeNr == 1) { 5556 if ((tmpset->nodeTab[0] != NULL) && 5557 (tmpset->nodeTab[0]->type == XML_NAMESPACE_DECL)) 5558 xmlXPathNodeSetFreeNs((xmlNsPtr) tmpset->nodeTab[0]); 5559 } 5560 tmpset->nodeNr = 0; 5561 memset(obj, 0, sizeof(xmlXPathObject)); 5562 obj->nodesetval = tmpset; 5563 } else 5564 memset(obj, 0, sizeof(xmlXPathObject)); 5565 5566 return; 5567 5568 free_obj: 5569 /* 5570 * Cache is full; free the object. 5571 */ 5572 if (obj->nodesetval != NULL) 5573 xmlXPathFreeNodeSet(obj->nodesetval); 5574 #ifdef XP_DEBUG_OBJ_USAGE 5575 xmlXPathDebugObjUsageReleased(NULL, obj->type); 5576 #endif 5577 xmlFree(obj); 5578 } 5579 return; 5580 } 5581 5582 5583 /************************************************************************ 5584 * * 5585 * Type Casting Routines * 5586 * * 5587 ************************************************************************/ 5588 5589 /** 5590 * xmlXPathCastBooleanToString: 5591 * @val: a boolean 5592 * 5593 * Converts a boolean to its string value. 5594 * 5595 * Returns a newly allocated string. 5596 */ 5597 xmlChar * 5598 xmlXPathCastBooleanToString (int val) { 5599 xmlChar *ret; 5600 if (val) 5601 ret = xmlStrdup((const xmlChar *) "true"); 5602 else 5603 ret = xmlStrdup((const xmlChar *) "false"); 5604 return(ret); 5605 } 5606 5607 /** 5608 * xmlXPathCastNumberToString: 5609 * @val: a number 5610 * 5611 * Converts a number to its string value. 5612 * 5613 * Returns a newly allocated string. 5614 */ 5615 xmlChar * 5616 xmlXPathCastNumberToString (double val) { 5617 xmlChar *ret; 5618 switch (xmlXPathIsInf(val)) { 5619 case 1: 5620 ret = xmlStrdup((const xmlChar *) "Infinity"); 5621 break; 5622 case -1: 5623 ret = xmlStrdup((const xmlChar *) "-Infinity"); 5624 break; 5625 default: 5626 if (xmlXPathIsNaN(val)) { 5627 ret = xmlStrdup((const xmlChar *) "NaN"); 5628 } else if (val == 0 && xmlXPathGetSign(val) != 0) { 5629 ret = xmlStrdup((const xmlChar *) "0"); 5630 } else { 5631 /* could be improved */ 5632 char buf[100]; 5633 xmlXPathFormatNumber(val, buf, 99); 5634 buf[99] = 0; 5635 ret = xmlStrdup((const xmlChar *) buf); 5636 } 5637 } 5638 return(ret); 5639 } 5640 5641 /** 5642 * xmlXPathCastNodeToString: 5643 * @node: a node 5644 * 5645 * Converts a node to its string value. 5646 * 5647 * Returns a newly allocated string. 5648 */ 5649 xmlChar * 5650 xmlXPathCastNodeToString (xmlNodePtr node) { 5651 xmlChar *ret; 5652 if ((ret = xmlNodeGetContent(node)) == NULL) 5653 ret = xmlStrdup((const xmlChar *) ""); 5654 return(ret); 5655 } 5656 5657 /** 5658 * xmlXPathCastNodeSetToString: 5659 * @ns: a node-set 5660 * 5661 * Converts a node-set to its string value. 5662 * 5663 * Returns a newly allocated string. 5664 */ 5665 xmlChar * 5666 xmlXPathCastNodeSetToString (xmlNodeSetPtr ns) { 5667 if ((ns == NULL) || (ns->nodeNr == 0) || (ns->nodeTab == NULL)) 5668 return(xmlStrdup((const xmlChar *) "")); 5669 5670 if (ns->nodeNr > 1) 5671 xmlXPathNodeSetSort(ns); 5672 return(xmlXPathCastNodeToString(ns->nodeTab[0])); 5673 } 5674 5675 /** 5676 * xmlXPathCastToString: 5677 * @val: an XPath object 5678 * 5679 * Converts an existing object to its string() equivalent 5680 * 5681 * Returns the allocated string value of the object, NULL in case of error. 5682 * It's up to the caller to free the string memory with xmlFree(). 5683 */ 5684 xmlChar * 5685 xmlXPathCastToString(xmlXPathObjectPtr val) { 5686 xmlChar *ret = NULL; 5687 5688 if (val == NULL) 5689 return(xmlStrdup((const xmlChar *) "")); 5690 switch (val->type) { 5691 case XPATH_UNDEFINED: 5692 #ifdef DEBUG_EXPR 5693 xmlGenericError(xmlGenericErrorContext, "String: undefined\n"); 5694 #endif 5695 ret = xmlStrdup((const xmlChar *) ""); 5696 break; 5697 case XPATH_NODESET: 5698 case XPATH_XSLT_TREE: 5699 ret = xmlXPathCastNodeSetToString(val->nodesetval); 5700 break; 5701 case XPATH_STRING: 5702 return(xmlStrdup(val->stringval)); 5703 case XPATH_BOOLEAN: 5704 ret = xmlXPathCastBooleanToString(val->boolval); 5705 break; 5706 case XPATH_NUMBER: { 5707 ret = xmlXPathCastNumberToString(val->floatval); 5708 break; 5709 } 5710 case XPATH_USERS: 5711 case XPATH_POINT: 5712 case XPATH_RANGE: 5713 case XPATH_LOCATIONSET: 5714 TODO 5715 ret = xmlStrdup((const xmlChar *) ""); 5716 break; 5717 } 5718 return(ret); 5719 } 5720 5721 /** 5722 * xmlXPathConvertString: 5723 * @val: an XPath object 5724 * 5725 * Converts an existing object to its string() equivalent 5726 * 5727 * Returns the new object, the old one is freed (or the operation 5728 * is done directly on @val) 5729 */ 5730 xmlXPathObjectPtr 5731 xmlXPathConvertString(xmlXPathObjectPtr val) { 5732 xmlChar *res = NULL; 5733 5734 if (val == NULL) 5735 return(xmlXPathNewCString("")); 5736 5737 switch (val->type) { 5738 case XPATH_UNDEFINED: 5739 #ifdef DEBUG_EXPR 5740 xmlGenericError(xmlGenericErrorContext, "STRING: undefined\n"); 5741 #endif 5742 break; 5743 case XPATH_NODESET: 5744 case XPATH_XSLT_TREE: 5745 res = xmlXPathCastNodeSetToString(val->nodesetval); 5746 break; 5747 case XPATH_STRING: 5748 return(val); 5749 case XPATH_BOOLEAN: 5750 res = xmlXPathCastBooleanToString(val->boolval); 5751 break; 5752 case XPATH_NUMBER: 5753 res = xmlXPathCastNumberToString(val->floatval); 5754 break; 5755 case XPATH_USERS: 5756 case XPATH_POINT: 5757 case XPATH_RANGE: 5758 case XPATH_LOCATIONSET: 5759 TODO; 5760 break; 5761 } 5762 xmlXPathFreeObject(val); 5763 if (res == NULL) 5764 return(xmlXPathNewCString("")); 5765 return(xmlXPathWrapString(res)); 5766 } 5767 5768 /** 5769 * xmlXPathCastBooleanToNumber: 5770 * @val: a boolean 5771 * 5772 * Converts a boolean to its number value 5773 * 5774 * Returns the number value 5775 */ 5776 double 5777 xmlXPathCastBooleanToNumber(int val) { 5778 if (val) 5779 return(1.0); 5780 return(0.0); 5781 } 5782 5783 /** 5784 * xmlXPathCastStringToNumber: 5785 * @val: a string 5786 * 5787 * Converts a string to its number value 5788 * 5789 * Returns the number value 5790 */ 5791 double 5792 xmlXPathCastStringToNumber(const xmlChar * val) { 5793 return(xmlXPathStringEvalNumber(val)); 5794 } 5795 5796 /** 5797 * xmlXPathCastNodeToNumber: 5798 * @node: a node 5799 * 5800 * Converts a node to its number value 5801 * 5802 * Returns the number value 5803 */ 5804 double 5805 xmlXPathCastNodeToNumber (xmlNodePtr node) { 5806 xmlChar *strval; 5807 double ret; 5808 5809 if (node == NULL) 5810 return(xmlXPathNAN); 5811 strval = xmlXPathCastNodeToString(node); 5812 if (strval == NULL) 5813 return(xmlXPathNAN); 5814 ret = xmlXPathCastStringToNumber(strval); 5815 xmlFree(strval); 5816 5817 return(ret); 5818 } 5819 5820 /** 5821 * xmlXPathCastNodeSetToNumber: 5822 * @ns: a node-set 5823 * 5824 * Converts a node-set to its number value 5825 * 5826 * Returns the number value 5827 */ 5828 double 5829 xmlXPathCastNodeSetToNumber (xmlNodeSetPtr ns) { 5830 xmlChar *str; 5831 double ret; 5832 5833 if (ns == NULL) 5834 return(xmlXPathNAN); 5835 str = xmlXPathCastNodeSetToString(ns); 5836 ret = xmlXPathCastStringToNumber(str); 5837 xmlFree(str); 5838 return(ret); 5839 } 5840 5841 /** 5842 * xmlXPathCastToNumber: 5843 * @val: an XPath object 5844 * 5845 * Converts an XPath object to its number value 5846 * 5847 * Returns the number value 5848 */ 5849 double 5850 xmlXPathCastToNumber(xmlXPathObjectPtr val) { 5851 double ret = 0.0; 5852 5853 if (val == NULL) 5854 return(xmlXPathNAN); 5855 switch (val->type) { 5856 case XPATH_UNDEFINED: 5857 #ifdef DEGUB_EXPR 5858 xmlGenericError(xmlGenericErrorContext, "NUMBER: undefined\n"); 5859 #endif 5860 ret = xmlXPathNAN; 5861 break; 5862 case XPATH_NODESET: 5863 case XPATH_XSLT_TREE: 5864 ret = xmlXPathCastNodeSetToNumber(val->nodesetval); 5865 break; 5866 case XPATH_STRING: 5867 ret = xmlXPathCastStringToNumber(val->stringval); 5868 break; 5869 case XPATH_NUMBER: 5870 ret = val->floatval; 5871 break; 5872 case XPATH_BOOLEAN: 5873 ret = xmlXPathCastBooleanToNumber(val->boolval); 5874 break; 5875 case XPATH_USERS: 5876 case XPATH_POINT: 5877 case XPATH_RANGE: 5878 case XPATH_LOCATIONSET: 5879 TODO; 5880 ret = xmlXPathNAN; 5881 break; 5882 } 5883 return(ret); 5884 } 5885 5886 /** 5887 * xmlXPathConvertNumber: 5888 * @val: an XPath object 5889 * 5890 * Converts an existing object to its number() equivalent 5891 * 5892 * Returns the new object, the old one is freed (or the operation 5893 * is done directly on @val) 5894 */ 5895 xmlXPathObjectPtr 5896 xmlXPathConvertNumber(xmlXPathObjectPtr val) { 5897 xmlXPathObjectPtr ret; 5898 5899 if (val == NULL) 5900 return(xmlXPathNewFloat(0.0)); 5901 if (val->type == XPATH_NUMBER) 5902 return(val); 5903 ret = xmlXPathNewFloat(xmlXPathCastToNumber(val)); 5904 xmlXPathFreeObject(val); 5905 return(ret); 5906 } 5907 5908 /** 5909 * xmlXPathCastNumberToBoolean: 5910 * @val: a number 5911 * 5912 * Converts a number to its boolean value 5913 * 5914 * Returns the boolean value 5915 */ 5916 int 5917 xmlXPathCastNumberToBoolean (double val) { 5918 if (xmlXPathIsNaN(val) || (val == 0.0)) 5919 return(0); 5920 return(1); 5921 } 5922 5923 /** 5924 * xmlXPathCastStringToBoolean: 5925 * @val: a string 5926 * 5927 * Converts a string to its boolean value 5928 * 5929 * Returns the boolean value 5930 */ 5931 int 5932 xmlXPathCastStringToBoolean (const xmlChar *val) { 5933 if ((val == NULL) || (xmlStrlen(val) == 0)) 5934 return(0); 5935 return(1); 5936 } 5937 5938 /** 5939 * xmlXPathCastNodeSetToBoolean: 5940 * @ns: a node-set 5941 * 5942 * Converts a node-set to its boolean value 5943 * 5944 * Returns the boolean value 5945 */ 5946 int 5947 xmlXPathCastNodeSetToBoolean (xmlNodeSetPtr ns) { 5948 if ((ns == NULL) || (ns->nodeNr == 0)) 5949 return(0); 5950 return(1); 5951 } 5952 5953 /** 5954 * xmlXPathCastToBoolean: 5955 * @val: an XPath object 5956 * 5957 * Converts an XPath object to its boolean value 5958 * 5959 * Returns the boolean value 5960 */ 5961 int 5962 xmlXPathCastToBoolean (xmlXPathObjectPtr val) { 5963 int ret = 0; 5964 5965 if (val == NULL) 5966 return(0); 5967 switch (val->type) { 5968 case XPATH_UNDEFINED: 5969 #ifdef DEBUG_EXPR 5970 xmlGenericError(xmlGenericErrorContext, "BOOLEAN: undefined\n"); 5971 #endif 5972 ret = 0; 5973 break; 5974 case XPATH_NODESET: 5975 case XPATH_XSLT_TREE: 5976 ret = xmlXPathCastNodeSetToBoolean(val->nodesetval); 5977 break; 5978 case XPATH_STRING: 5979 ret = xmlXPathCastStringToBoolean(val->stringval); 5980 break; 5981 case XPATH_NUMBER: 5982 ret = xmlXPathCastNumberToBoolean(val->floatval); 5983 break; 5984 case XPATH_BOOLEAN: 5985 ret = val->boolval; 5986 break; 5987 case XPATH_USERS: 5988 case XPATH_POINT: 5989 case XPATH_RANGE: 5990 case XPATH_LOCATIONSET: 5991 TODO; 5992 ret = 0; 5993 break; 5994 } 5995 return(ret); 5996 } 5997 5998 5999 /** 6000 * xmlXPathConvertBoolean: 6001 * @val: an XPath object 6002 * 6003 * Converts an existing object to its boolean() equivalent 6004 * 6005 * Returns the new object, the old one is freed (or the operation 6006 * is done directly on @val) 6007 */ 6008 xmlXPathObjectPtr 6009 xmlXPathConvertBoolean(xmlXPathObjectPtr val) { 6010 xmlXPathObjectPtr ret; 6011 6012 if (val == NULL) 6013 return(xmlXPathNewBoolean(0)); 6014 if (val->type == XPATH_BOOLEAN) 6015 return(val); 6016 ret = xmlXPathNewBoolean(xmlXPathCastToBoolean(val)); 6017 xmlXPathFreeObject(val); 6018 return(ret); 6019 } 6020 6021 /************************************************************************ 6022 * * 6023 * Routines to handle XPath contexts * 6024 * * 6025 ************************************************************************/ 6026 6027 /** 6028 * xmlXPathNewContext: 6029 * @doc: the XML document 6030 * 6031 * Create a new xmlXPathContext 6032 * 6033 * Returns the xmlXPathContext just allocated. The caller will need to free it. 6034 */ 6035 xmlXPathContextPtr 6036 xmlXPathNewContext(xmlDocPtr doc) { 6037 xmlXPathContextPtr ret; 6038 6039 ret = (xmlXPathContextPtr) xmlMalloc(sizeof(xmlXPathContext)); 6040 if (ret == NULL) { 6041 xmlXPathErrMemory(NULL, "creating context\n"); 6042 return(NULL); 6043 } 6044 memset(ret, 0 , (size_t) sizeof(xmlXPathContext)); 6045 ret->doc = doc; 6046 ret->node = NULL; 6047 6048 ret->varHash = NULL; 6049 6050 ret->nb_types = 0; 6051 ret->max_types = 0; 6052 ret->types = NULL; 6053 6054 ret->funcHash = xmlHashCreate(0); 6055 6056 ret->nb_axis = 0; 6057 ret->max_axis = 0; 6058 ret->axis = NULL; 6059 6060 ret->nsHash = NULL; 6061 ret->user = NULL; 6062 6063 ret->contextSize = -1; 6064 ret->proximityPosition = -1; 6065 6066 #ifdef XP_DEFAULT_CACHE_ON 6067 if (xmlXPathContextSetCache(ret, 1, -1, 0) == -1) { 6068 xmlXPathFreeContext(ret); 6069 return(NULL); 6070 } 6071 #endif 6072 6073 xmlXPathRegisterAllFunctions(ret); 6074 6075 return(ret); 6076 } 6077 6078 /** 6079 * xmlXPathFreeContext: 6080 * @ctxt: the context to free 6081 * 6082 * Free up an xmlXPathContext 6083 */ 6084 void 6085 xmlXPathFreeContext(xmlXPathContextPtr ctxt) { 6086 if (ctxt == NULL) return; 6087 6088 if (ctxt->cache != NULL) 6089 xmlXPathFreeCache((xmlXPathContextCachePtr) ctxt->cache); 6090 xmlXPathRegisteredNsCleanup(ctxt); 6091 xmlXPathRegisteredFuncsCleanup(ctxt); 6092 xmlXPathRegisteredVariablesCleanup(ctxt); 6093 xmlResetError(&ctxt->lastError); 6094 xmlFree(ctxt); 6095 } 6096 6097 /************************************************************************ 6098 * * 6099 * Routines to handle XPath parser contexts * 6100 * * 6101 ************************************************************************/ 6102 6103 #define CHECK_CTXT(ctxt) \ 6104 if (ctxt == NULL) { \ 6105 __xmlRaiseError(NULL, NULL, NULL, \ 6106 NULL, NULL, XML_FROM_XPATH, \ 6107 XML_ERR_INTERNAL_ERROR, XML_ERR_FATAL, \ 6108 __FILE__, __LINE__, \ 6109 NULL, NULL, NULL, 0, 0, \ 6110 "NULL context pointer\n"); \ 6111 return(NULL); \ 6112 } \ 6113 6114 #define CHECK_CTXT_NEG(ctxt) \ 6115 if (ctxt == NULL) { \ 6116 __xmlRaiseError(NULL, NULL, NULL, \ 6117 NULL, NULL, XML_FROM_XPATH, \ 6118 XML_ERR_INTERNAL_ERROR, XML_ERR_FATAL, \ 6119 __FILE__, __LINE__, \ 6120 NULL, NULL, NULL, 0, 0, \ 6121 "NULL context pointer\n"); \ 6122 return(-1); \ 6123 } \ 6124 6125 6126 #define CHECK_CONTEXT(ctxt) \ 6127 if ((ctxt == NULL) || (ctxt->doc == NULL) || \ 6128 (ctxt->doc->children == NULL)) { \ 6129 xmlXPatherror(ctxt, __FILE__, __LINE__, XPATH_INVALID_CTXT); \ 6130 return(NULL); \ 6131 } 6132 6133 6134 /** 6135 * xmlXPathNewParserContext: 6136 * @str: the XPath expression 6137 * @ctxt: the XPath context 6138 * 6139 * Create a new xmlXPathParserContext 6140 * 6141 * Returns the xmlXPathParserContext just allocated. 6142 */ 6143 xmlXPathParserContextPtr 6144 xmlXPathNewParserContext(const xmlChar *str, xmlXPathContextPtr ctxt) { 6145 xmlXPathParserContextPtr ret; 6146 6147 ret = (xmlXPathParserContextPtr) xmlMalloc(sizeof(xmlXPathParserContext)); 6148 if (ret == NULL) { 6149 xmlXPathErrMemory(ctxt, "creating parser context\n"); 6150 return(NULL); 6151 } 6152 memset(ret, 0 , (size_t) sizeof(xmlXPathParserContext)); 6153 ret->cur = ret->base = str; 6154 ret->context = ctxt; 6155 6156 ret->comp = xmlXPathNewCompExpr(); 6157 if (ret->comp == NULL) { 6158 xmlFree(ret->valueTab); 6159 xmlFree(ret); 6160 return(NULL); 6161 } 6162 if ((ctxt != NULL) && (ctxt->dict != NULL)) { 6163 ret->comp->dict = ctxt->dict; 6164 xmlDictReference(ret->comp->dict); 6165 } 6166 6167 return(ret); 6168 } 6169 6170 /** 6171 * xmlXPathCompParserContext: 6172 * @comp: the XPath compiled expression 6173 * @ctxt: the XPath context 6174 * 6175 * Create a new xmlXPathParserContext when processing a compiled expression 6176 * 6177 * Returns the xmlXPathParserContext just allocated. 6178 */ 6179 static xmlXPathParserContextPtr 6180 xmlXPathCompParserContext(xmlXPathCompExprPtr comp, xmlXPathContextPtr ctxt) { 6181 xmlXPathParserContextPtr ret; 6182 6183 ret = (xmlXPathParserContextPtr) xmlMalloc(sizeof(xmlXPathParserContext)); 6184 if (ret == NULL) { 6185 xmlXPathErrMemory(ctxt, "creating evaluation context\n"); 6186 return(NULL); 6187 } 6188 memset(ret, 0 , (size_t) sizeof(xmlXPathParserContext)); 6189 6190 /* Allocate the value stack */ 6191 ret->valueTab = (xmlXPathObjectPtr *) 6192 xmlMalloc(10 * sizeof(xmlXPathObjectPtr)); 6193 if (ret->valueTab == NULL) { 6194 xmlFree(ret); 6195 xmlXPathErrMemory(ctxt, "creating evaluation context\n"); 6196 return(NULL); 6197 } 6198 ret->valueNr = 0; 6199 ret->valueMax = 10; 6200 ret->value = NULL; 6201 ret->valueFrame = 0; 6202 6203 ret->context = ctxt; 6204 ret->comp = comp; 6205 6206 return(ret); 6207 } 6208 6209 /** 6210 * xmlXPathFreeParserContext: 6211 * @ctxt: the context to free 6212 * 6213 * Free up an xmlXPathParserContext 6214 */ 6215 void 6216 xmlXPathFreeParserContext(xmlXPathParserContextPtr ctxt) { 6217 if (ctxt->valueTab != NULL) { 6218 xmlFree(ctxt->valueTab); 6219 } 6220 if (ctxt->comp != NULL) { 6221 #ifdef XPATH_STREAMING 6222 if (ctxt->comp->stream != NULL) { 6223 xmlFreePatternList(ctxt->comp->stream); 6224 ctxt->comp->stream = NULL; 6225 } 6226 #endif 6227 xmlXPathFreeCompExpr(ctxt->comp); 6228 } 6229 xmlFree(ctxt); 6230 } 6231 6232 /************************************************************************ 6233 * * 6234 * The implicit core function library * 6235 * * 6236 ************************************************************************/ 6237 6238 /** 6239 * xmlXPathNodeValHash: 6240 * @node: a node pointer 6241 * 6242 * Function computing the beginning of the string value of the node, 6243 * used to speed up comparisons 6244 * 6245 * Returns an int usable as a hash 6246 */ 6247 static unsigned int 6248 xmlXPathNodeValHash(xmlNodePtr node) { 6249 int len = 2; 6250 const xmlChar * string = NULL; 6251 xmlNodePtr tmp = NULL; 6252 unsigned int ret = 0; 6253 6254 if (node == NULL) 6255 return(0); 6256 6257 if (node->type == XML_DOCUMENT_NODE) { 6258 tmp = xmlDocGetRootElement((xmlDocPtr) node); 6259 if (tmp == NULL) 6260 node = node->children; 6261 else 6262 node = tmp; 6263 6264 if (node == NULL) 6265 return(0); 6266 } 6267 6268 switch (node->type) { 6269 case XML_COMMENT_NODE: 6270 case XML_PI_NODE: 6271 case XML_CDATA_SECTION_NODE: 6272 case XML_TEXT_NODE: 6273 string = node->content; 6274 if (string == NULL) 6275 return(0); 6276 if (string[0] == 0) 6277 return(0); 6278 return(((unsigned int) string[0]) + 6279 (((unsigned int) string[1]) << 8)); 6280 case XML_NAMESPACE_DECL: 6281 string = ((xmlNsPtr)node)->href; 6282 if (string == NULL) 6283 return(0); 6284 if (string[0] == 0) 6285 return(0); 6286 return(((unsigned int) string[0]) + 6287 (((unsigned int) string[1]) << 8)); 6288 case XML_ATTRIBUTE_NODE: 6289 tmp = ((xmlAttrPtr) node)->children; 6290 break; 6291 case XML_ELEMENT_NODE: 6292 tmp = node->children; 6293 break; 6294 default: 6295 return(0); 6296 } 6297 while (tmp != NULL) { 6298 switch (tmp->type) { 6299 case XML_COMMENT_NODE: 6300 case XML_PI_NODE: 6301 case XML_CDATA_SECTION_NODE: 6302 case XML_TEXT_NODE: 6303 string = tmp->content; 6304 break; 6305 case XML_NAMESPACE_DECL: 6306 string = ((xmlNsPtr)tmp)->href; 6307 break; 6308 default: 6309 break; 6310 } 6311 if ((string != NULL) && (string[0] != 0)) { 6312 if (len == 1) { 6313 return(ret + (((unsigned int) string[0]) << 8)); 6314 } 6315 if (string[1] == 0) { 6316 len = 1; 6317 ret = (unsigned int) string[0]; 6318 } else { 6319 return(((unsigned int) string[0]) + 6320 (((unsigned int) string[1]) << 8)); 6321 } 6322 } 6323 /* 6324 * Skip to next node 6325 */ 6326 if ((tmp->children != NULL) && (tmp->type != XML_DTD_NODE)) { 6327 if (tmp->children->type != XML_ENTITY_DECL) { 6328 tmp = tmp->children; 6329 continue; 6330 } 6331 } 6332 if (tmp == node) 6333 break; 6334 6335 if (tmp->next != NULL) { 6336 tmp = tmp->next; 6337 continue; 6338 } 6339 6340 do { 6341 tmp = tmp->parent; 6342 if (tmp == NULL) 6343 break; 6344 if (tmp == node) { 6345 tmp = NULL; 6346 break; 6347 } 6348 if (tmp->next != NULL) { 6349 tmp = tmp->next; 6350 break; 6351 } 6352 } while (tmp != NULL); 6353 } 6354 return(ret); 6355 } 6356 6357 /** 6358 * xmlXPathStringHash: 6359 * @string: a string 6360 * 6361 * Function computing the beginning of the string value of the node, 6362 * used to speed up comparisons 6363 * 6364 * Returns an int usable as a hash 6365 */ 6366 static unsigned int 6367 xmlXPathStringHash(const xmlChar * string) { 6368 if (string == NULL) 6369 return((unsigned int) 0); 6370 if (string[0] == 0) 6371 return(0); 6372 return(((unsigned int) string[0]) + 6373 (((unsigned int) string[1]) << 8)); 6374 } 6375 6376 /** 6377 * xmlXPathCompareNodeSetFloat: 6378 * @ctxt: the XPath Parser context 6379 * @inf: less than (1) or greater than (0) 6380 * @strict: is the comparison strict 6381 * @arg: the node set 6382 * @f: the value 6383 * 6384 * Implement the compare operation between a nodeset and a number 6385 * @ns < @val (1, 1, ... 6386 * @ns <= @val (1, 0, ... 6387 * @ns > @val (0, 1, ... 6388 * @ns >= @val (0, 0, ... 6389 * 6390 * If one object to be compared is a node-set and the other is a number, 6391 * then the comparison will be true if and only if there is a node in the 6392 * node-set such that the result of performing the comparison on the number 6393 * to be compared and on the result of converting the string-value of that 6394 * node to a number using the number function is true. 6395 * 6396 * Returns 0 or 1 depending on the results of the test. 6397 */ 6398 static int 6399 xmlXPathCompareNodeSetFloat(xmlXPathParserContextPtr ctxt, int inf, int strict, 6400 xmlXPathObjectPtr arg, xmlXPathObjectPtr f) { 6401 int i, ret = 0; 6402 xmlNodeSetPtr ns; 6403 xmlChar *str2; 6404 6405 if ((f == NULL) || (arg == NULL) || 6406 ((arg->type != XPATH_NODESET) && (arg->type != XPATH_XSLT_TREE))) { 6407 xmlXPathReleaseObject(ctxt->context, arg); 6408 xmlXPathReleaseObject(ctxt->context, f); 6409 return(0); 6410 } 6411 ns = arg->nodesetval; 6412 if (ns != NULL) { 6413 for (i = 0;i < ns->nodeNr;i++) { 6414 str2 = xmlXPathCastNodeToString(ns->nodeTab[i]); 6415 if (str2 != NULL) { 6416 valuePush(ctxt, 6417 xmlXPathCacheNewString(ctxt->context, str2)); 6418 xmlFree(str2); 6419 xmlXPathNumberFunction(ctxt, 1); 6420 valuePush(ctxt, xmlXPathCacheObjectCopy(ctxt->context, f)); 6421 ret = xmlXPathCompareValues(ctxt, inf, strict); 6422 if (ret) 6423 break; 6424 } 6425 } 6426 } 6427 xmlXPathReleaseObject(ctxt->context, arg); 6428 xmlXPathReleaseObject(ctxt->context, f); 6429 return(ret); 6430 } 6431 6432 /** 6433 * xmlXPathCompareNodeSetString: 6434 * @ctxt: the XPath Parser context 6435 * @inf: less than (1) or greater than (0) 6436 * @strict: is the comparison strict 6437 * @arg: the node set 6438 * @s: the value 6439 * 6440 * Implement the compare operation between a nodeset and a string 6441 * @ns < @val (1, 1, ... 6442 * @ns <= @val (1, 0, ... 6443 * @ns > @val (0, 1, ... 6444 * @ns >= @val (0, 0, ... 6445 * 6446 * If one object to be compared is a node-set and the other is a string, 6447 * then the comparison will be true if and only if there is a node in 6448 * the node-set such that the result of performing the comparison on the 6449 * string-value of the node and the other string is true. 6450 * 6451 * Returns 0 or 1 depending on the results of the test. 6452 */ 6453 static int 6454 xmlXPathCompareNodeSetString(xmlXPathParserContextPtr ctxt, int inf, int strict, 6455 xmlXPathObjectPtr arg, xmlXPathObjectPtr s) { 6456 int i, ret = 0; 6457 xmlNodeSetPtr ns; 6458 xmlChar *str2; 6459 6460 if ((s == NULL) || (arg == NULL) || 6461 ((arg->type != XPATH_NODESET) && (arg->type != XPATH_XSLT_TREE))) { 6462 xmlXPathReleaseObject(ctxt->context, arg); 6463 xmlXPathReleaseObject(ctxt->context, s); 6464 return(0); 6465 } 6466 ns = arg->nodesetval; 6467 if (ns != NULL) { 6468 for (i = 0;i < ns->nodeNr;i++) { 6469 str2 = xmlXPathCastNodeToString(ns->nodeTab[i]); 6470 if (str2 != NULL) { 6471 valuePush(ctxt, 6472 xmlXPathCacheNewString(ctxt->context, str2)); 6473 xmlFree(str2); 6474 valuePush(ctxt, xmlXPathCacheObjectCopy(ctxt->context, s)); 6475 ret = xmlXPathCompareValues(ctxt, inf, strict); 6476 if (ret) 6477 break; 6478 } 6479 } 6480 } 6481 xmlXPathReleaseObject(ctxt->context, arg); 6482 xmlXPathReleaseObject(ctxt->context, s); 6483 return(ret); 6484 } 6485 6486 /** 6487 * xmlXPathCompareNodeSets: 6488 * @inf: less than (1) or greater than (0) 6489 * @strict: is the comparison strict 6490 * @arg1: the first node set object 6491 * @arg2: the second node set object 6492 * 6493 * Implement the compare operation on nodesets: 6494 * 6495 * If both objects to be compared are node-sets, then the comparison 6496 * will be true if and only if there is a node in the first node-set 6497 * and a node in the second node-set such that the result of performing 6498 * the comparison on the string-values of the two nodes is true. 6499 * .... 6500 * When neither object to be compared is a node-set and the operator 6501 * is <=, <, >= or >, then the objects are compared by converting both 6502 * objects to numbers and comparing the numbers according to IEEE 754. 6503 * .... 6504 * The number function converts its argument to a number as follows: 6505 * - a string that consists of optional whitespace followed by an 6506 * optional minus sign followed by a Number followed by whitespace 6507 * is converted to the IEEE 754 number that is nearest (according 6508 * to the IEEE 754 round-to-nearest rule) to the mathematical value 6509 * represented by the string; any other string is converted to NaN 6510 * 6511 * Conclusion all nodes need to be converted first to their string value 6512 * and then the comparison must be done when possible 6513 */ 6514 static int 6515 xmlXPathCompareNodeSets(int inf, int strict, 6516 xmlXPathObjectPtr arg1, xmlXPathObjectPtr arg2) { 6517 int i, j, init = 0; 6518 double val1; 6519 double *values2; 6520 int ret = 0; 6521 xmlNodeSetPtr ns1; 6522 xmlNodeSetPtr ns2; 6523 6524 if ((arg1 == NULL) || 6525 ((arg1->type != XPATH_NODESET) && (arg1->type != XPATH_XSLT_TREE))) { 6526 xmlXPathFreeObject(arg2); 6527 return(0); 6528 } 6529 if ((arg2 == NULL) || 6530 ((arg2->type != XPATH_NODESET) && (arg2->type != XPATH_XSLT_TREE))) { 6531 xmlXPathFreeObject(arg1); 6532 xmlXPathFreeObject(arg2); 6533 return(0); 6534 } 6535 6536 ns1 = arg1->nodesetval; 6537 ns2 = arg2->nodesetval; 6538 6539 if ((ns1 == NULL) || (ns1->nodeNr <= 0)) { 6540 xmlXPathFreeObject(arg1); 6541 xmlXPathFreeObject(arg2); 6542 return(0); 6543 } 6544 if ((ns2 == NULL) || (ns2->nodeNr <= 0)) { 6545 xmlXPathFreeObject(arg1); 6546 xmlXPathFreeObject(arg2); 6547 return(0); 6548 } 6549 6550 values2 = (double *) xmlMalloc(ns2->nodeNr * sizeof(double)); 6551 if (values2 == NULL) { 6552 xmlXPathErrMemory(NULL, "comparing nodesets\n"); 6553 xmlXPathFreeObject(arg1); 6554 xmlXPathFreeObject(arg2); 6555 return(0); 6556 } 6557 for (i = 0;i < ns1->nodeNr;i++) { 6558 val1 = xmlXPathCastNodeToNumber(ns1->nodeTab[i]); 6559 if (xmlXPathIsNaN(val1)) 6560 continue; 6561 for (j = 0;j < ns2->nodeNr;j++) { 6562 if (init == 0) { 6563 values2[j] = xmlXPathCastNodeToNumber(ns2->nodeTab[j]); 6564 } 6565 if (xmlXPathIsNaN(values2[j])) 6566 continue; 6567 if (inf && strict) 6568 ret = (val1 < values2[j]); 6569 else if (inf && !strict) 6570 ret = (val1 <= values2[j]); 6571 else if (!inf && strict) 6572 ret = (val1 > values2[j]); 6573 else if (!inf && !strict) 6574 ret = (val1 >= values2[j]); 6575 if (ret) 6576 break; 6577 } 6578 if (ret) 6579 break; 6580 init = 1; 6581 } 6582 xmlFree(values2); 6583 xmlXPathFreeObject(arg1); 6584 xmlXPathFreeObject(arg2); 6585 return(ret); 6586 } 6587 6588 /** 6589 * xmlXPathCompareNodeSetValue: 6590 * @ctxt: the XPath Parser context 6591 * @inf: less than (1) or greater than (0) 6592 * @strict: is the comparison strict 6593 * @arg: the node set 6594 * @val: the value 6595 * 6596 * Implement the compare operation between a nodeset and a value 6597 * @ns < @val (1, 1, ... 6598 * @ns <= @val (1, 0, ... 6599 * @ns > @val (0, 1, ... 6600 * @ns >= @val (0, 0, ... 6601 * 6602 * If one object to be compared is a node-set and the other is a boolean, 6603 * then the comparison will be true if and only if the result of performing 6604 * the comparison on the boolean and on the result of converting 6605 * the node-set to a boolean using the boolean function is true. 6606 * 6607 * Returns 0 or 1 depending on the results of the test. 6608 */ 6609 static int 6610 xmlXPathCompareNodeSetValue(xmlXPathParserContextPtr ctxt, int inf, int strict, 6611 xmlXPathObjectPtr arg, xmlXPathObjectPtr val) { 6612 if ((val == NULL) || (arg == NULL) || 6613 ((arg->type != XPATH_NODESET) && (arg->type != XPATH_XSLT_TREE))) 6614 return(0); 6615 6616 switch(val->type) { 6617 case XPATH_NUMBER: 6618 return(xmlXPathCompareNodeSetFloat(ctxt, inf, strict, arg, val)); 6619 case XPATH_NODESET: 6620 case XPATH_XSLT_TREE: 6621 return(xmlXPathCompareNodeSets(inf, strict, arg, val)); 6622 case XPATH_STRING: 6623 return(xmlXPathCompareNodeSetString(ctxt, inf, strict, arg, val)); 6624 case XPATH_BOOLEAN: 6625 valuePush(ctxt, arg); 6626 xmlXPathBooleanFunction(ctxt, 1); 6627 valuePush(ctxt, val); 6628 return(xmlXPathCompareValues(ctxt, inf, strict)); 6629 default: 6630 TODO 6631 } 6632 return(0); 6633 } 6634 6635 /** 6636 * xmlXPathEqualNodeSetString: 6637 * @arg: the nodeset object argument 6638 * @str: the string to compare to. 6639 * @neq: flag to show whether for '=' (0) or '!=' (1) 6640 * 6641 * Implement the equal operation on XPath objects content: @arg1 == @arg2 6642 * If one object to be compared is a node-set and the other is a string, 6643 * then the comparison will be true if and only if there is a node in 6644 * the node-set such that the result of performing the comparison on the 6645 * string-value of the node and the other string is true. 6646 * 6647 * Returns 0 or 1 depending on the results of the test. 6648 */ 6649 static int 6650 xmlXPathEqualNodeSetString(xmlXPathObjectPtr arg, const xmlChar * str, int neq) 6651 { 6652 int i; 6653 xmlNodeSetPtr ns; 6654 xmlChar *str2; 6655 unsigned int hash; 6656 6657 if ((str == NULL) || (arg == NULL) || 6658 ((arg->type != XPATH_NODESET) && (arg->type != XPATH_XSLT_TREE))) 6659 return (0); 6660 ns = arg->nodesetval; 6661 /* 6662 * A NULL nodeset compared with a string is always false 6663 * (since there is no node equal, and no node not equal) 6664 */ 6665 if ((ns == NULL) || (ns->nodeNr <= 0) ) 6666 return (0); 6667 hash = xmlXPathStringHash(str); 6668 for (i = 0; i < ns->nodeNr; i++) { 6669 if (xmlXPathNodeValHash(ns->nodeTab[i]) == hash) { 6670 str2 = xmlNodeGetContent(ns->nodeTab[i]); 6671 if ((str2 != NULL) && (xmlStrEqual(str, str2))) { 6672 xmlFree(str2); 6673 if (neq) 6674 continue; 6675 return (1); 6676 } else if ((str2 == NULL) && (xmlStrEqual(str, BAD_CAST ""))) { 6677 if (neq) 6678 continue; 6679 return (1); 6680 } else if (neq) { 6681 if (str2 != NULL) 6682 xmlFree(str2); 6683 return (1); 6684 } 6685 if (str2 != NULL) 6686 xmlFree(str2); 6687 } else if (neq) 6688 return (1); 6689 } 6690 return (0); 6691 } 6692 6693 /** 6694 * xmlXPathEqualNodeSetFloat: 6695 * @arg: the nodeset object argument 6696 * @f: the float to compare to 6697 * @neq: flag to show whether to compare '=' (0) or '!=' (1) 6698 * 6699 * Implement the equal operation on XPath objects content: @arg1 == @arg2 6700 * If one object to be compared is a node-set and the other is a number, 6701 * then the comparison will be true if and only if there is a node in 6702 * the node-set such that the result of performing the comparison on the 6703 * number to be compared and on the result of converting the string-value 6704 * of that node to a number using the number function is true. 6705 * 6706 * Returns 0 or 1 depending on the results of the test. 6707 */ 6708 static int 6709 xmlXPathEqualNodeSetFloat(xmlXPathParserContextPtr ctxt, 6710 xmlXPathObjectPtr arg, double f, int neq) { 6711 int i, ret=0; 6712 xmlNodeSetPtr ns; 6713 xmlChar *str2; 6714 xmlXPathObjectPtr val; 6715 double v; 6716 6717 if ((arg == NULL) || 6718 ((arg->type != XPATH_NODESET) && (arg->type != XPATH_XSLT_TREE))) 6719 return(0); 6720 6721 ns = arg->nodesetval; 6722 if (ns != NULL) { 6723 for (i=0;i<ns->nodeNr;i++) { 6724 str2 = xmlXPathCastNodeToString(ns->nodeTab[i]); 6725 if (str2 != NULL) { 6726 valuePush(ctxt, xmlXPathCacheNewString(ctxt->context, str2)); 6727 xmlFree(str2); 6728 xmlXPathNumberFunction(ctxt, 1); 6729 val = valuePop(ctxt); 6730 v = val->floatval; 6731 xmlXPathReleaseObject(ctxt->context, val); 6732 if (!xmlXPathIsNaN(v)) { 6733 if ((!neq) && (v==f)) { 6734 ret = 1; 6735 break; 6736 } else if ((neq) && (v!=f)) { 6737 ret = 1; 6738 break; 6739 } 6740 } else { /* NaN is unequal to any value */ 6741 if (neq) 6742 ret = 1; 6743 } 6744 } 6745 } 6746 } 6747 6748 return(ret); 6749 } 6750 6751 6752 /** 6753 * xmlXPathEqualNodeSets: 6754 * @arg1: first nodeset object argument 6755 * @arg2: second nodeset object argument 6756 * @neq: flag to show whether to test '=' (0) or '!=' (1) 6757 * 6758 * Implement the equal / not equal operation on XPath nodesets: 6759 * @arg1 == @arg2 or @arg1 != @arg2 6760 * If both objects to be compared are node-sets, then the comparison 6761 * will be true if and only if there is a node in the first node-set and 6762 * a node in the second node-set such that the result of performing the 6763 * comparison on the string-values of the two nodes is true. 6764 * 6765 * (needless to say, this is a costly operation) 6766 * 6767 * Returns 0 or 1 depending on the results of the test. 6768 */ 6769 static int 6770 xmlXPathEqualNodeSets(xmlXPathObjectPtr arg1, xmlXPathObjectPtr arg2, int neq) { 6771 int i, j; 6772 unsigned int *hashs1; 6773 unsigned int *hashs2; 6774 xmlChar **values1; 6775 xmlChar **values2; 6776 int ret = 0; 6777 xmlNodeSetPtr ns1; 6778 xmlNodeSetPtr ns2; 6779 6780 if ((arg1 == NULL) || 6781 ((arg1->type != XPATH_NODESET) && (arg1->type != XPATH_XSLT_TREE))) 6782 return(0); 6783 if ((arg2 == NULL) || 6784 ((arg2->type != XPATH_NODESET) && (arg2->type != XPATH_XSLT_TREE))) 6785 return(0); 6786 6787 ns1 = arg1->nodesetval; 6788 ns2 = arg2->nodesetval; 6789 6790 if ((ns1 == NULL) || (ns1->nodeNr <= 0)) 6791 return(0); 6792 if ((ns2 == NULL) || (ns2->nodeNr <= 0)) 6793 return(0); 6794 6795 /* 6796 * for equal, check if there is a node pertaining to both sets 6797 */ 6798 if (neq == 0) 6799 for (i = 0;i < ns1->nodeNr;i++) 6800 for (j = 0;j < ns2->nodeNr;j++) 6801 if (ns1->nodeTab[i] == ns2->nodeTab[j]) 6802 return(1); 6803 6804 values1 = (xmlChar **) xmlMalloc(ns1->nodeNr * sizeof(xmlChar *)); 6805 if (values1 == NULL) { 6806 xmlXPathErrMemory(NULL, "comparing nodesets\n"); 6807 return(0); 6808 } 6809 hashs1 = (unsigned int *) xmlMalloc(ns1->nodeNr * sizeof(unsigned int)); 6810 if (hashs1 == NULL) { 6811 xmlXPathErrMemory(NULL, "comparing nodesets\n"); 6812 xmlFree(values1); 6813 return(0); 6814 } 6815 memset(values1, 0, ns1->nodeNr * sizeof(xmlChar *)); 6816 values2 = (xmlChar **) xmlMalloc(ns2->nodeNr * sizeof(xmlChar *)); 6817 if (values2 == NULL) { 6818 xmlXPathErrMemory(NULL, "comparing nodesets\n"); 6819 xmlFree(hashs1); 6820 xmlFree(values1); 6821 return(0); 6822 } 6823 hashs2 = (unsigned int *) xmlMalloc(ns2->nodeNr * sizeof(unsigned int)); 6824 if (hashs2 == NULL) { 6825 xmlXPathErrMemory(NULL, "comparing nodesets\n"); 6826 xmlFree(hashs1); 6827 xmlFree(values1); 6828 xmlFree(values2); 6829 return(0); 6830 } 6831 memset(values2, 0, ns2->nodeNr * sizeof(xmlChar *)); 6832 for (i = 0;i < ns1->nodeNr;i++) { 6833 hashs1[i] = xmlXPathNodeValHash(ns1->nodeTab[i]); 6834 for (j = 0;j < ns2->nodeNr;j++) { 6835 if (i == 0) 6836 hashs2[j] = xmlXPathNodeValHash(ns2->nodeTab[j]); 6837 if (hashs1[i] != hashs2[j]) { 6838 if (neq) { 6839 ret = 1; 6840 break; 6841 } 6842 } 6843 else { 6844 if (values1[i] == NULL) 6845 values1[i] = xmlNodeGetContent(ns1->nodeTab[i]); 6846 if (values2[j] == NULL) 6847 values2[j] = xmlNodeGetContent(ns2->nodeTab[j]); 6848 ret = xmlStrEqual(values1[i], values2[j]) ^ neq; 6849 if (ret) 6850 break; 6851 } 6852 } 6853 if (ret) 6854 break; 6855 } 6856 for (i = 0;i < ns1->nodeNr;i++) 6857 if (values1[i] != NULL) 6858 xmlFree(values1[i]); 6859 for (j = 0;j < ns2->nodeNr;j++) 6860 if (values2[j] != NULL) 6861 xmlFree(values2[j]); 6862 xmlFree(values1); 6863 xmlFree(values2); 6864 xmlFree(hashs1); 6865 xmlFree(hashs2); 6866 return(ret); 6867 } 6868 6869 static int 6870 xmlXPathEqualValuesCommon(xmlXPathParserContextPtr ctxt, 6871 xmlXPathObjectPtr arg1, xmlXPathObjectPtr arg2) { 6872 int ret = 0; 6873 /* 6874 *At this point we are assured neither arg1 nor arg2 6875 *is a nodeset, so we can just pick the appropriate routine. 6876 */ 6877 switch (arg1->type) { 6878 case XPATH_UNDEFINED: 6879 #ifdef DEBUG_EXPR 6880 xmlGenericError(xmlGenericErrorContext, 6881 "Equal: undefined\n"); 6882 #endif 6883 break; 6884 case XPATH_BOOLEAN: 6885 switch (arg2->type) { 6886 case XPATH_UNDEFINED: 6887 #ifdef DEBUG_EXPR 6888 xmlGenericError(xmlGenericErrorContext, 6889 "Equal: undefined\n"); 6890 #endif 6891 break; 6892 case XPATH_BOOLEAN: 6893 #ifdef DEBUG_EXPR 6894 xmlGenericError(xmlGenericErrorContext, 6895 "Equal: %d boolean %d \n", 6896 arg1->boolval, arg2->boolval); 6897 #endif 6898 ret = (arg1->boolval == arg2->boolval); 6899 break; 6900 case XPATH_NUMBER: 6901 ret = (arg1->boolval == 6902 xmlXPathCastNumberToBoolean(arg2->floatval)); 6903 break; 6904 case XPATH_STRING: 6905 if ((arg2->stringval == NULL) || 6906 (arg2->stringval[0] == 0)) ret = 0; 6907 else 6908 ret = 1; 6909 ret = (arg1->boolval == ret); 6910 break; 6911 case XPATH_USERS: 6912 case XPATH_POINT: 6913 case XPATH_RANGE: 6914 case XPATH_LOCATIONSET: 6915 TODO 6916 break; 6917 case XPATH_NODESET: 6918 case XPATH_XSLT_TREE: 6919 break; 6920 } 6921 break; 6922 case XPATH_NUMBER: 6923 switch (arg2->type) { 6924 case XPATH_UNDEFINED: 6925 #ifdef DEBUG_EXPR 6926 xmlGenericError(xmlGenericErrorContext, 6927 "Equal: undefined\n"); 6928 #endif 6929 break; 6930 case XPATH_BOOLEAN: 6931 ret = (arg2->boolval== 6932 xmlXPathCastNumberToBoolean(arg1->floatval)); 6933 break; 6934 case XPATH_STRING: 6935 valuePush(ctxt, arg2); 6936 xmlXPathNumberFunction(ctxt, 1); 6937 arg2 = valuePop(ctxt); 6938 /* no break on purpose */ 6939 case XPATH_NUMBER: 6940 /* Hand check NaN and Infinity equalities */ 6941 if (xmlXPathIsNaN(arg1->floatval) || 6942 xmlXPathIsNaN(arg2->floatval)) { 6943 ret = 0; 6944 } else if (xmlXPathIsInf(arg1->floatval) == 1) { 6945 if (xmlXPathIsInf(arg2->floatval) == 1) 6946 ret = 1; 6947 else 6948 ret = 0; 6949 } else if (xmlXPathIsInf(arg1->floatval) == -1) { 6950 if (xmlXPathIsInf(arg2->floatval) == -1) 6951 ret = 1; 6952 else 6953 ret = 0; 6954 } else if (xmlXPathIsInf(arg2->floatval) == 1) { 6955 if (xmlXPathIsInf(arg1->floatval) == 1) 6956 ret = 1; 6957 else 6958 ret = 0; 6959 } else if (xmlXPathIsInf(arg2->floatval) == -1) { 6960 if (xmlXPathIsInf(arg1->floatval) == -1) 6961 ret = 1; 6962 else 6963 ret = 0; 6964 } else { 6965 ret = (arg1->floatval == arg2->floatval); 6966 } 6967 break; 6968 case XPATH_USERS: 6969 case XPATH_POINT: 6970 case XPATH_RANGE: 6971 case XPATH_LOCATIONSET: 6972 TODO 6973 break; 6974 case XPATH_NODESET: 6975 case XPATH_XSLT_TREE: 6976 break; 6977 } 6978 break; 6979 case XPATH_STRING: 6980 switch (arg2->type) { 6981 case XPATH_UNDEFINED: 6982 #ifdef DEBUG_EXPR 6983 xmlGenericError(xmlGenericErrorContext, 6984 "Equal: undefined\n"); 6985 #endif 6986 break; 6987 case XPATH_BOOLEAN: 6988 if ((arg1->stringval == NULL) || 6989 (arg1->stringval[0] == 0)) ret = 0; 6990 else 6991 ret = 1; 6992 ret = (arg2->boolval == ret); 6993 break; 6994 case XPATH_STRING: 6995 ret = xmlStrEqual(arg1->stringval, arg2->stringval); 6996 break; 6997 case XPATH_NUMBER: 6998 valuePush(ctxt, arg1); 6999 xmlXPathNumberFunction(ctxt, 1); 7000 arg1 = valuePop(ctxt); 7001 /* Hand check NaN and Infinity equalities */ 7002 if (xmlXPathIsNaN(arg1->floatval) || 7003 xmlXPathIsNaN(arg2->floatval)) { 7004 ret = 0; 7005 } else if (xmlXPathIsInf(arg1->floatval) == 1) { 7006 if (xmlXPathIsInf(arg2->floatval) == 1) 7007 ret = 1; 7008 else 7009 ret = 0; 7010 } else if (xmlXPathIsInf(arg1->floatval) == -1) { 7011 if (xmlXPathIsInf(arg2->floatval) == -1) 7012 ret = 1; 7013 else 7014 ret = 0; 7015 } else if (xmlXPathIsInf(arg2->floatval) == 1) { 7016 if (xmlXPathIsInf(arg1->floatval) == 1) 7017 ret = 1; 7018 else 7019 ret = 0; 7020 } else if (xmlXPathIsInf(arg2->floatval) == -1) { 7021 if (xmlXPathIsInf(arg1->floatval) == -1) 7022 ret = 1; 7023 else 7024 ret = 0; 7025 } else { 7026 ret = (arg1->floatval == arg2->floatval); 7027 } 7028 break; 7029 case XPATH_USERS: 7030 case XPATH_POINT: 7031 case XPATH_RANGE: 7032 case XPATH_LOCATIONSET: 7033 TODO 7034 break; 7035 case XPATH_NODESET: 7036 case XPATH_XSLT_TREE: 7037 break; 7038 } 7039 break; 7040 case XPATH_USERS: 7041 case XPATH_POINT: 7042 case XPATH_RANGE: 7043 case XPATH_LOCATIONSET: 7044 TODO 7045 break; 7046 case XPATH_NODESET: 7047 case XPATH_XSLT_TREE: 7048 break; 7049 } 7050 xmlXPathReleaseObject(ctxt->context, arg1); 7051 xmlXPathReleaseObject(ctxt->context, arg2); 7052 return(ret); 7053 } 7054 7055 /** 7056 * xmlXPathEqualValues: 7057 * @ctxt: the XPath Parser context 7058 * 7059 * Implement the equal operation on XPath objects content: @arg1 == @arg2 7060 * 7061 * Returns 0 or 1 depending on the results of the test. 7062 */ 7063 int 7064 xmlXPathEqualValues(xmlXPathParserContextPtr ctxt) { 7065 xmlXPathObjectPtr arg1, arg2, argtmp; 7066 int ret = 0; 7067 7068 if ((ctxt == NULL) || (ctxt->context == NULL)) return(0); 7069 arg2 = valuePop(ctxt); 7070 arg1 = valuePop(ctxt); 7071 if ((arg1 == NULL) || (arg2 == NULL)) { 7072 if (arg1 != NULL) 7073 xmlXPathReleaseObject(ctxt->context, arg1); 7074 else 7075 xmlXPathReleaseObject(ctxt->context, arg2); 7076 XP_ERROR0(XPATH_INVALID_OPERAND); 7077 } 7078 7079 if (arg1 == arg2) { 7080 #ifdef DEBUG_EXPR 7081 xmlGenericError(xmlGenericErrorContext, 7082 "Equal: by pointer\n"); 7083 #endif 7084 xmlXPathFreeObject(arg1); 7085 return(1); 7086 } 7087 7088 /* 7089 *If either argument is a nodeset, it's a 'special case' 7090 */ 7091 if ((arg2->type == XPATH_NODESET) || (arg2->type == XPATH_XSLT_TREE) || 7092 (arg1->type == XPATH_NODESET) || (arg1->type == XPATH_XSLT_TREE)) { 7093 /* 7094 *Hack it to assure arg1 is the nodeset 7095 */ 7096 if ((arg1->type != XPATH_NODESET) && (arg1->type != XPATH_XSLT_TREE)) { 7097 argtmp = arg2; 7098 arg2 = arg1; 7099 arg1 = argtmp; 7100 } 7101 switch (arg2->type) { 7102 case XPATH_UNDEFINED: 7103 #ifdef DEBUG_EXPR 7104 xmlGenericError(xmlGenericErrorContext, 7105 "Equal: undefined\n"); 7106 #endif 7107 break; 7108 case XPATH_NODESET: 7109 case XPATH_XSLT_TREE: 7110 ret = xmlXPathEqualNodeSets(arg1, arg2, 0); 7111 break; 7112 case XPATH_BOOLEAN: 7113 if ((arg1->nodesetval == NULL) || 7114 (arg1->nodesetval->nodeNr == 0)) ret = 0; 7115 else 7116 ret = 1; 7117 ret = (ret == arg2->boolval); 7118 break; 7119 case XPATH_NUMBER: 7120 ret = xmlXPathEqualNodeSetFloat(ctxt, arg1, arg2->floatval, 0); 7121 break; 7122 case XPATH_STRING: 7123 ret = xmlXPathEqualNodeSetString(arg1, arg2->stringval, 0); 7124 break; 7125 case XPATH_USERS: 7126 case XPATH_POINT: 7127 case XPATH_RANGE: 7128 case XPATH_LOCATIONSET: 7129 TODO 7130 break; 7131 } 7132 xmlXPathReleaseObject(ctxt->context, arg1); 7133 xmlXPathReleaseObject(ctxt->context, arg2); 7134 return(ret); 7135 } 7136 7137 return (xmlXPathEqualValuesCommon(ctxt, arg1, arg2)); 7138 } 7139 7140 /** 7141 * xmlXPathNotEqualValues: 7142 * @ctxt: the XPath Parser context 7143 * 7144 * Implement the equal operation on XPath objects content: @arg1 == @arg2 7145 * 7146 * Returns 0 or 1 depending on the results of the test. 7147 */ 7148 int 7149 xmlXPathNotEqualValues(xmlXPathParserContextPtr ctxt) { 7150 xmlXPathObjectPtr arg1, arg2, argtmp; 7151 int ret = 0; 7152 7153 if ((ctxt == NULL) || (ctxt->context == NULL)) return(0); 7154 arg2 = valuePop(ctxt); 7155 arg1 = valuePop(ctxt); 7156 if ((arg1 == NULL) || (arg2 == NULL)) { 7157 if (arg1 != NULL) 7158 xmlXPathReleaseObject(ctxt->context, arg1); 7159 else 7160 xmlXPathReleaseObject(ctxt->context, arg2); 7161 XP_ERROR0(XPATH_INVALID_OPERAND); 7162 } 7163 7164 if (arg1 == arg2) { 7165 #ifdef DEBUG_EXPR 7166 xmlGenericError(xmlGenericErrorContext, 7167 "NotEqual: by pointer\n"); 7168 #endif 7169 xmlXPathReleaseObject(ctxt->context, arg1); 7170 return(0); 7171 } 7172 7173 /* 7174 *If either argument is a nodeset, it's a 'special case' 7175 */ 7176 if ((arg2->type == XPATH_NODESET) || (arg2->type == XPATH_XSLT_TREE) || 7177 (arg1->type == XPATH_NODESET) || (arg1->type == XPATH_XSLT_TREE)) { 7178 /* 7179 *Hack it to assure arg1 is the nodeset 7180 */ 7181 if ((arg1->type != XPATH_NODESET) && (arg1->type != XPATH_XSLT_TREE)) { 7182 argtmp = arg2; 7183 arg2 = arg1; 7184 arg1 = argtmp; 7185 } 7186 switch (arg2->type) { 7187 case XPATH_UNDEFINED: 7188 #ifdef DEBUG_EXPR 7189 xmlGenericError(xmlGenericErrorContext, 7190 "NotEqual: undefined\n"); 7191 #endif 7192 break; 7193 case XPATH_NODESET: 7194 case XPATH_XSLT_TREE: 7195 ret = xmlXPathEqualNodeSets(arg1, arg2, 1); 7196 break; 7197 case XPATH_BOOLEAN: 7198 if ((arg1->nodesetval == NULL) || 7199 (arg1->nodesetval->nodeNr == 0)) ret = 0; 7200 else 7201 ret = 1; 7202 ret = (ret != arg2->boolval); 7203 break; 7204 case XPATH_NUMBER: 7205 ret = xmlXPathEqualNodeSetFloat(ctxt, arg1, arg2->floatval, 1); 7206 break; 7207 case XPATH_STRING: 7208 ret = xmlXPathEqualNodeSetString(arg1, arg2->stringval,1); 7209 break; 7210 case XPATH_USERS: 7211 case XPATH_POINT: 7212 case XPATH_RANGE: 7213 case XPATH_LOCATIONSET: 7214 TODO 7215 break; 7216 } 7217 xmlXPathReleaseObject(ctxt->context, arg1); 7218 xmlXPathReleaseObject(ctxt->context, arg2); 7219 return(ret); 7220 } 7221 7222 return (!xmlXPathEqualValuesCommon(ctxt, arg1, arg2)); 7223 } 7224 7225 /** 7226 * xmlXPathCompareValues: 7227 * @ctxt: the XPath Parser context 7228 * @inf: less than (1) or greater than (0) 7229 * @strict: is the comparison strict 7230 * 7231 * Implement the compare operation on XPath objects: 7232 * @arg1 < @arg2 (1, 1, ... 7233 * @arg1 <= @arg2 (1, 0, ... 7234 * @arg1 > @arg2 (0, 1, ... 7235 * @arg1 >= @arg2 (0, 0, ... 7236 * 7237 * When neither object to be compared is a node-set and the operator is 7238 * <=, <, >=, >, then the objects are compared by converted both objects 7239 * to numbers and comparing the numbers according to IEEE 754. The < 7240 * comparison will be true if and only if the first number is less than the 7241 * second number. The <= comparison will be true if and only if the first 7242 * number is less than or equal to the second number. The > comparison 7243 * will be true if and only if the first number is greater than the second 7244 * number. The >= comparison will be true if and only if the first number 7245 * is greater than or equal to the second number. 7246 * 7247 * Returns 1 if the comparison succeeded, 0 if it failed 7248 */ 7249 int 7250 xmlXPathCompareValues(xmlXPathParserContextPtr ctxt, int inf, int strict) { 7251 int ret = 0, arg1i = 0, arg2i = 0; 7252 xmlXPathObjectPtr arg1, arg2; 7253 7254 if ((ctxt == NULL) || (ctxt->context == NULL)) return(0); 7255 arg2 = valuePop(ctxt); 7256 arg1 = valuePop(ctxt); 7257 if ((arg1 == NULL) || (arg2 == NULL)) { 7258 if (arg1 != NULL) 7259 xmlXPathReleaseObject(ctxt->context, arg1); 7260 else 7261 xmlXPathReleaseObject(ctxt->context, arg2); 7262 XP_ERROR0(XPATH_INVALID_OPERAND); 7263 } 7264 7265 if ((arg2->type == XPATH_NODESET) || (arg2->type == XPATH_XSLT_TREE) || 7266 (arg1->type == XPATH_NODESET) || (arg1->type == XPATH_XSLT_TREE)) { 7267 /* 7268 * If either argument is a XPATH_NODESET or XPATH_XSLT_TREE the two arguments 7269 * are not freed from within this routine; they will be freed from the 7270 * called routine, e.g. xmlXPathCompareNodeSets or xmlXPathCompareNodeSetValue 7271 */ 7272 if (((arg2->type == XPATH_NODESET) || (arg2->type == XPATH_XSLT_TREE)) && 7273 ((arg1->type == XPATH_NODESET) || (arg1->type == XPATH_XSLT_TREE))){ 7274 ret = xmlXPathCompareNodeSets(inf, strict, arg1, arg2); 7275 } else { 7276 if ((arg1->type == XPATH_NODESET) || (arg1->type == XPATH_XSLT_TREE)) { 7277 ret = xmlXPathCompareNodeSetValue(ctxt, inf, strict, 7278 arg1, arg2); 7279 } else { 7280 ret = xmlXPathCompareNodeSetValue(ctxt, !inf, strict, 7281 arg2, arg1); 7282 } 7283 } 7284 return(ret); 7285 } 7286 7287 if (arg1->type != XPATH_NUMBER) { 7288 valuePush(ctxt, arg1); 7289 xmlXPathNumberFunction(ctxt, 1); 7290 arg1 = valuePop(ctxt); 7291 } 7292 if (arg1->type != XPATH_NUMBER) { 7293 xmlXPathFreeObject(arg1); 7294 xmlXPathFreeObject(arg2); 7295 XP_ERROR0(XPATH_INVALID_OPERAND); 7296 } 7297 if (arg2->type != XPATH_NUMBER) { 7298 valuePush(ctxt, arg2); 7299 xmlXPathNumberFunction(ctxt, 1); 7300 arg2 = valuePop(ctxt); 7301 } 7302 if (arg2->type != XPATH_NUMBER) { 7303 xmlXPathReleaseObject(ctxt->context, arg1); 7304 xmlXPathReleaseObject(ctxt->context, arg2); 7305 XP_ERROR0(XPATH_INVALID_OPERAND); 7306 } 7307 /* 7308 * Add tests for infinity and nan 7309 * => feedback on 3.4 for Inf and NaN 7310 */ 7311 /* Hand check NaN and Infinity comparisons */ 7312 if (xmlXPathIsNaN(arg1->floatval) || xmlXPathIsNaN(arg2->floatval)) { 7313 ret=0; 7314 } else { 7315 arg1i=xmlXPathIsInf(arg1->floatval); 7316 arg2i=xmlXPathIsInf(arg2->floatval); 7317 if (inf && strict) { 7318 if ((arg1i == -1 && arg2i != -1) || 7319 (arg2i == 1 && arg1i != 1)) { 7320 ret = 1; 7321 } else if (arg1i == 0 && arg2i == 0) { 7322 ret = (arg1->floatval < arg2->floatval); 7323 } else { 7324 ret = 0; 7325 } 7326 } 7327 else if (inf && !strict) { 7328 if (arg1i == -1 || arg2i == 1) { 7329 ret = 1; 7330 } else if (arg1i == 0 && arg2i == 0) { 7331 ret = (arg1->floatval <= arg2->floatval); 7332 } else { 7333 ret = 0; 7334 } 7335 } 7336 else if (!inf && strict) { 7337 if ((arg1i == 1 && arg2i != 1) || 7338 (arg2i == -1 && arg1i != -1)) { 7339 ret = 1; 7340 } else if (arg1i == 0 && arg2i == 0) { 7341 ret = (arg1->floatval > arg2->floatval); 7342 } else { 7343 ret = 0; 7344 } 7345 } 7346 else if (!inf && !strict) { 7347 if (arg1i == 1 || arg2i == -1) { 7348 ret = 1; 7349 } else if (arg1i == 0 && arg2i == 0) { 7350 ret = (arg1->floatval >= arg2->floatval); 7351 } else { 7352 ret = 0; 7353 } 7354 } 7355 } 7356 xmlXPathReleaseObject(ctxt->context, arg1); 7357 xmlXPathReleaseObject(ctxt->context, arg2); 7358 return(ret); 7359 } 7360 7361 /** 7362 * xmlXPathValueFlipSign: 7363 * @ctxt: the XPath Parser context 7364 * 7365 * Implement the unary - operation on an XPath object 7366 * The numeric operators convert their operands to numbers as if 7367 * by calling the number function. 7368 */ 7369 void 7370 xmlXPathValueFlipSign(xmlXPathParserContextPtr ctxt) { 7371 if ((ctxt == NULL) || (ctxt->context == NULL)) return; 7372 CAST_TO_NUMBER; 7373 CHECK_TYPE(XPATH_NUMBER); 7374 if (xmlXPathIsNaN(ctxt->value->floatval)) 7375 ctxt->value->floatval=xmlXPathNAN; 7376 else if (xmlXPathIsInf(ctxt->value->floatval) == 1) 7377 ctxt->value->floatval=xmlXPathNINF; 7378 else if (xmlXPathIsInf(ctxt->value->floatval) == -1) 7379 ctxt->value->floatval=xmlXPathPINF; 7380 else if (ctxt->value->floatval == 0) { 7381 if (xmlXPathGetSign(ctxt->value->floatval) == 0) 7382 ctxt->value->floatval = xmlXPathNZERO; 7383 else 7384 ctxt->value->floatval = 0; 7385 } 7386 else 7387 ctxt->value->floatval = - ctxt->value->floatval; 7388 } 7389 7390 /** 7391 * xmlXPathAddValues: 7392 * @ctxt: the XPath Parser context 7393 * 7394 * Implement the add operation on XPath objects: 7395 * The numeric operators convert their operands to numbers as if 7396 * by calling the number function. 7397 */ 7398 void 7399 xmlXPathAddValues(xmlXPathParserContextPtr ctxt) { 7400 xmlXPathObjectPtr arg; 7401 double val; 7402 7403 arg = valuePop(ctxt); 7404 if (arg == NULL) 7405 XP_ERROR(XPATH_INVALID_OPERAND); 7406 val = xmlXPathCastToNumber(arg); 7407 xmlXPathReleaseObject(ctxt->context, arg); 7408 CAST_TO_NUMBER; 7409 CHECK_TYPE(XPATH_NUMBER); 7410 ctxt->value->floatval += val; 7411 } 7412 7413 /** 7414 * xmlXPathSubValues: 7415 * @ctxt: the XPath Parser context 7416 * 7417 * Implement the subtraction operation on XPath objects: 7418 * The numeric operators convert their operands to numbers as if 7419 * by calling the number function. 7420 */ 7421 void 7422 xmlXPathSubValues(xmlXPathParserContextPtr ctxt) { 7423 xmlXPathObjectPtr arg; 7424 double val; 7425 7426 arg = valuePop(ctxt); 7427 if (arg == NULL) 7428 XP_ERROR(XPATH_INVALID_OPERAND); 7429 val = xmlXPathCastToNumber(arg); 7430 xmlXPathReleaseObject(ctxt->context, arg); 7431 CAST_TO_NUMBER; 7432 CHECK_TYPE(XPATH_NUMBER); 7433 ctxt->value->floatval -= val; 7434 } 7435 7436 /** 7437 * xmlXPathMultValues: 7438 * @ctxt: the XPath Parser context 7439 * 7440 * Implement the multiply operation on XPath objects: 7441 * The numeric operators convert their operands to numbers as if 7442 * by calling the number function. 7443 */ 7444 void 7445 xmlXPathMultValues(xmlXPathParserContextPtr ctxt) { 7446 xmlXPathObjectPtr arg; 7447 double val; 7448 7449 arg = valuePop(ctxt); 7450 if (arg == NULL) 7451 XP_ERROR(XPATH_INVALID_OPERAND); 7452 val = xmlXPathCastToNumber(arg); 7453 xmlXPathReleaseObject(ctxt->context, arg); 7454 CAST_TO_NUMBER; 7455 CHECK_TYPE(XPATH_NUMBER); 7456 ctxt->value->floatval *= val; 7457 } 7458 7459 /** 7460 * xmlXPathDivValues: 7461 * @ctxt: the XPath Parser context 7462 * 7463 * Implement the div operation on XPath objects @arg1 / @arg2: 7464 * The numeric operators convert their operands to numbers as if 7465 * by calling the number function. 7466 */ 7467 void 7468 xmlXPathDivValues(xmlXPathParserContextPtr ctxt) { 7469 xmlXPathObjectPtr arg; 7470 double val; 7471 7472 arg = valuePop(ctxt); 7473 if (arg == NULL) 7474 XP_ERROR(XPATH_INVALID_OPERAND); 7475 val = xmlXPathCastToNumber(arg); 7476 xmlXPathReleaseObject(ctxt->context, arg); 7477 CAST_TO_NUMBER; 7478 CHECK_TYPE(XPATH_NUMBER); 7479 if (xmlXPathIsNaN(val) || xmlXPathIsNaN(ctxt->value->floatval)) 7480 ctxt->value->floatval = xmlXPathNAN; 7481 else if (val == 0 && xmlXPathGetSign(val) != 0) { 7482 if (ctxt->value->floatval == 0) 7483 ctxt->value->floatval = xmlXPathNAN; 7484 else if (ctxt->value->floatval > 0) 7485 ctxt->value->floatval = xmlXPathNINF; 7486 else if (ctxt->value->floatval < 0) 7487 ctxt->value->floatval = xmlXPathPINF; 7488 } 7489 else if (val == 0) { 7490 if (ctxt->value->floatval == 0) 7491 ctxt->value->floatval = xmlXPathNAN; 7492 else if (ctxt->value->floatval > 0) 7493 ctxt->value->floatval = xmlXPathPINF; 7494 else if (ctxt->value->floatval < 0) 7495 ctxt->value->floatval = xmlXPathNINF; 7496 } else 7497 ctxt->value->floatval /= val; 7498 } 7499 7500 /** 7501 * xmlXPathModValues: 7502 * @ctxt: the XPath Parser context 7503 * 7504 * Implement the mod operation on XPath objects: @arg1 / @arg2 7505 * The numeric operators convert their operands to numbers as if 7506 * by calling the number function. 7507 */ 7508 void 7509 xmlXPathModValues(xmlXPathParserContextPtr ctxt) { 7510 xmlXPathObjectPtr arg; 7511 double arg1, arg2; 7512 7513 arg = valuePop(ctxt); 7514 if (arg == NULL) 7515 XP_ERROR(XPATH_INVALID_OPERAND); 7516 arg2 = xmlXPathCastToNumber(arg); 7517 xmlXPathReleaseObject(ctxt->context, arg); 7518 CAST_TO_NUMBER; 7519 CHECK_TYPE(XPATH_NUMBER); 7520 arg1 = ctxt->value->floatval; 7521 if (arg2 == 0) 7522 ctxt->value->floatval = xmlXPathNAN; 7523 else { 7524 ctxt->value->floatval = fmod(arg1, arg2); 7525 } 7526 } 7527 7528 /************************************************************************ 7529 * * 7530 * The traversal functions * 7531 * * 7532 ************************************************************************/ 7533 7534 /* 7535 * A traversal function enumerates nodes along an axis. 7536 * Initially it must be called with NULL, and it indicates 7537 * termination on the axis by returning NULL. 7538 */ 7539 typedef xmlNodePtr (*xmlXPathTraversalFunction) 7540 (xmlXPathParserContextPtr ctxt, xmlNodePtr cur); 7541 7542 /* 7543 * xmlXPathTraversalFunctionExt: 7544 * A traversal function enumerates nodes along an axis. 7545 * Initially it must be called with NULL, and it indicates 7546 * termination on the axis by returning NULL. 7547 * The context node of the traversal is specified via @contextNode. 7548 */ 7549 typedef xmlNodePtr (*xmlXPathTraversalFunctionExt) 7550 (xmlNodePtr cur, xmlNodePtr contextNode); 7551 7552 /* 7553 * xmlXPathNodeSetMergeFunction: 7554 * Used for merging node sets in xmlXPathCollectAndTest(). 7555 */ 7556 typedef xmlNodeSetPtr (*xmlXPathNodeSetMergeFunction) 7557 (xmlNodeSetPtr, xmlNodeSetPtr, int); 7558 7559 7560 /** 7561 * xmlXPathNextSelf: 7562 * @ctxt: the XPath Parser context 7563 * @cur: the current node in the traversal 7564 * 7565 * Traversal function for the "self" direction 7566 * The self axis contains just the context node itself 7567 * 7568 * Returns the next element following that axis 7569 */ 7570 xmlNodePtr 7571 xmlXPathNextSelf(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) { 7572 if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL); 7573 if (cur == NULL) 7574 return(ctxt->context->node); 7575 return(NULL); 7576 } 7577 7578 /** 7579 * xmlXPathNextChild: 7580 * @ctxt: the XPath Parser context 7581 * @cur: the current node in the traversal 7582 * 7583 * Traversal function for the "child" direction 7584 * The child axis contains the children of the context node in document order. 7585 * 7586 * Returns the next element following that axis 7587 */ 7588 xmlNodePtr 7589 xmlXPathNextChild(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) { 7590 if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL); 7591 if (cur == NULL) { 7592 if (ctxt->context->node == NULL) return(NULL); 7593 switch (ctxt->context->node->type) { 7594 case XML_ELEMENT_NODE: 7595 case XML_TEXT_NODE: 7596 case XML_CDATA_SECTION_NODE: 7597 case XML_ENTITY_REF_NODE: 7598 case XML_ENTITY_NODE: 7599 case XML_PI_NODE: 7600 case XML_COMMENT_NODE: 7601 case XML_NOTATION_NODE: 7602 case XML_DTD_NODE: 7603 return(ctxt->context->node->children); 7604 case XML_DOCUMENT_NODE: 7605 case XML_DOCUMENT_TYPE_NODE: 7606 case XML_DOCUMENT_FRAG_NODE: 7607 case XML_HTML_DOCUMENT_NODE: 7608 #ifdef LIBXML_DOCB_ENABLED 7609 case XML_DOCB_DOCUMENT_NODE: 7610 #endif 7611 return(((xmlDocPtr) ctxt->context->node)->children); 7612 case XML_ELEMENT_DECL: 7613 case XML_ATTRIBUTE_DECL: 7614 case XML_ENTITY_DECL: 7615 case XML_ATTRIBUTE_NODE: 7616 case XML_NAMESPACE_DECL: 7617 case XML_XINCLUDE_START: 7618 case XML_XINCLUDE_END: 7619 return(NULL); 7620 } 7621 return(NULL); 7622 } 7623 if ((cur->type == XML_DOCUMENT_NODE) || 7624 (cur->type == XML_HTML_DOCUMENT_NODE)) 7625 return(NULL); 7626 return(cur->next); 7627 } 7628 7629 /** 7630 * xmlXPathNextChildElement: 7631 * @ctxt: the XPath Parser context 7632 * @cur: the current node in the traversal 7633 * 7634 * Traversal function for the "child" direction and nodes of type element. 7635 * The child axis contains the children of the context node in document order. 7636 * 7637 * Returns the next element following that axis 7638 */ 7639 static xmlNodePtr 7640 xmlXPathNextChildElement(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) { 7641 if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL); 7642 if (cur == NULL) { 7643 cur = ctxt->context->node; 7644 if (cur == NULL) return(NULL); 7645 /* 7646 * Get the first element child. 7647 */ 7648 switch (cur->type) { 7649 case XML_ELEMENT_NODE: 7650 case XML_DOCUMENT_FRAG_NODE: 7651 case XML_ENTITY_REF_NODE: /* URGENT TODO: entify-refs as well? */ 7652 case XML_ENTITY_NODE: 7653 cur = cur->children; 7654 if (cur != NULL) { 7655 if (cur->type == XML_ELEMENT_NODE) 7656 return(cur); 7657 do { 7658 cur = cur->next; 7659 } while ((cur != NULL) && 7660 (cur->type != XML_ELEMENT_NODE)); 7661 return(cur); 7662 } 7663 return(NULL); 7664 case XML_DOCUMENT_NODE: 7665 case XML_HTML_DOCUMENT_NODE: 7666 #ifdef LIBXML_DOCB_ENABLED 7667 case XML_DOCB_DOCUMENT_NODE: 7668 #endif 7669 return(xmlDocGetRootElement((xmlDocPtr) cur)); 7670 default: 7671 return(NULL); 7672 } 7673 return(NULL); 7674 } 7675 /* 7676 * Get the next sibling element node. 7677 */ 7678 switch (cur->type) { 7679 case XML_ELEMENT_NODE: 7680 case XML_TEXT_NODE: 7681 case XML_ENTITY_REF_NODE: 7682 case XML_ENTITY_NODE: 7683 case XML_CDATA_SECTION_NODE: 7684 case XML_PI_NODE: 7685 case XML_COMMENT_NODE: 7686 case XML_XINCLUDE_END: 7687 break; 7688 /* case XML_DTD_NODE: */ /* URGENT TODO: DTD-node as well? */ 7689 default: 7690 return(NULL); 7691 } 7692 if (cur->next != NULL) { 7693 if (cur->next->type == XML_ELEMENT_NODE) 7694 return(cur->next); 7695 cur = cur->next; 7696 do { 7697 cur = cur->next; 7698 } while ((cur != NULL) && (cur->type != XML_ELEMENT_NODE)); 7699 return(cur); 7700 } 7701 return(NULL); 7702 } 7703 7704 /** 7705 * xmlXPathNextDescendantOrSelfElemParent: 7706 * @ctxt: the XPath Parser context 7707 * @cur: the current node in the traversal 7708 * 7709 * Traversal function for the "descendant-or-self" axis. 7710 * Additionally it returns only nodes which can be parents of 7711 * element nodes. 7712 * 7713 * 7714 * Returns the next element following that axis 7715 */ 7716 static xmlNodePtr 7717 xmlXPathNextDescendantOrSelfElemParent(xmlNodePtr cur, 7718 xmlNodePtr contextNode) 7719 { 7720 if (cur == NULL) { 7721 if (contextNode == NULL) 7722 return(NULL); 7723 switch (contextNode->type) { 7724 case XML_ELEMENT_NODE: 7725 case XML_XINCLUDE_START: 7726 case XML_DOCUMENT_FRAG_NODE: 7727 case XML_DOCUMENT_NODE: 7728 #ifdef LIBXML_DOCB_ENABLED 7729 case XML_DOCB_DOCUMENT_NODE: 7730 #endif 7731 case XML_HTML_DOCUMENT_NODE: 7732 return(contextNode); 7733 default: 7734 return(NULL); 7735 } 7736 return(NULL); 7737 } else { 7738 xmlNodePtr start = cur; 7739 7740 while (cur != NULL) { 7741 switch (cur->type) { 7742 case XML_ELEMENT_NODE: 7743 /* TODO: OK to have XInclude here? */ 7744 case XML_XINCLUDE_START: 7745 case XML_DOCUMENT_FRAG_NODE: 7746 if (cur != start) 7747 return(cur); 7748 if (cur->children != NULL) { 7749 cur = cur->children; 7750 continue; 7751 } 7752 break; 7753 /* Not sure if we need those here. */ 7754 case XML_DOCUMENT_NODE: 7755 #ifdef LIBXML_DOCB_ENABLED 7756 case XML_DOCB_DOCUMENT_NODE: 7757 #endif 7758 case XML_HTML_DOCUMENT_NODE: 7759 if (cur != start) 7760 return(cur); 7761 return(xmlDocGetRootElement((xmlDocPtr) cur)); 7762 default: 7763 break; 7764 } 7765 7766 next_sibling: 7767 if ((cur == NULL) || (cur == contextNode)) 7768 return(NULL); 7769 if (cur->next != NULL) { 7770 cur = cur->next; 7771 } else { 7772 cur = cur->parent; 7773 goto next_sibling; 7774 } 7775 } 7776 } 7777 return(NULL); 7778 } 7779 7780 /** 7781 * xmlXPathNextDescendant: 7782 * @ctxt: the XPath Parser context 7783 * @cur: the current node in the traversal 7784 * 7785 * Traversal function for the "descendant" direction 7786 * the descendant axis contains the descendants of the context node in document 7787 * order; a descendant is a child or a child of a child and so on. 7788 * 7789 * Returns the next element following that axis 7790 */ 7791 xmlNodePtr 7792 xmlXPathNextDescendant(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) { 7793 if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL); 7794 if (cur == NULL) { 7795 if (ctxt->context->node == NULL) 7796 return(NULL); 7797 if ((ctxt->context->node->type == XML_ATTRIBUTE_NODE) || 7798 (ctxt->context->node->type == XML_NAMESPACE_DECL)) 7799 return(NULL); 7800 7801 if (ctxt->context->node == (xmlNodePtr) ctxt->context->doc) 7802 return(ctxt->context->doc->children); 7803 return(ctxt->context->node->children); 7804 } 7805 7806 if (cur->children != NULL) { 7807 /* 7808 * Do not descend on entities declarations 7809 */ 7810 if (cur->children->type != XML_ENTITY_DECL) { 7811 cur = cur->children; 7812 /* 7813 * Skip DTDs 7814 */ 7815 if (cur->type != XML_DTD_NODE) 7816 return(cur); 7817 } 7818 } 7819 7820 if (cur == ctxt->context->node) return(NULL); 7821 7822 while (cur->next != NULL) { 7823 cur = cur->next; 7824 if ((cur->type != XML_ENTITY_DECL) && 7825 (cur->type != XML_DTD_NODE)) 7826 return(cur); 7827 } 7828 7829 do { 7830 cur = cur->parent; 7831 if (cur == NULL) break; 7832 if (cur == ctxt->context->node) return(NULL); 7833 if (cur->next != NULL) { 7834 cur = cur->next; 7835 return(cur); 7836 } 7837 } while (cur != NULL); 7838 return(cur); 7839 } 7840 7841 /** 7842 * xmlXPathNextDescendantOrSelf: 7843 * @ctxt: the XPath Parser context 7844 * @cur: the current node in the traversal 7845 * 7846 * Traversal function for the "descendant-or-self" direction 7847 * the descendant-or-self axis contains the context node and the descendants 7848 * of the context node in document order; thus the context node is the first 7849 * node on the axis, and the first child of the context node is the second node 7850 * on the axis 7851 * 7852 * Returns the next element following that axis 7853 */ 7854 xmlNodePtr 7855 xmlXPathNextDescendantOrSelf(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) { 7856 if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL); 7857 if (cur == NULL) { 7858 if (ctxt->context->node == NULL) 7859 return(NULL); 7860 if ((ctxt->context->node->type == XML_ATTRIBUTE_NODE) || 7861 (ctxt->context->node->type == XML_NAMESPACE_DECL)) 7862 return(NULL); 7863 return(ctxt->context->node); 7864 } 7865 7866 return(xmlXPathNextDescendant(ctxt, cur)); 7867 } 7868 7869 /** 7870 * xmlXPathNextParent: 7871 * @ctxt: the XPath Parser context 7872 * @cur: the current node in the traversal 7873 * 7874 * Traversal function for the "parent" direction 7875 * The parent axis contains the parent of the context node, if there is one. 7876 * 7877 * Returns the next element following that axis 7878 */ 7879 xmlNodePtr 7880 xmlXPathNextParent(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) { 7881 if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL); 7882 /* 7883 * the parent of an attribute or namespace node is the element 7884 * to which the attribute or namespace node is attached 7885 * Namespace handling !!! 7886 */ 7887 if (cur == NULL) { 7888 if (ctxt->context->node == NULL) return(NULL); 7889 switch (ctxt->context->node->type) { 7890 case XML_ELEMENT_NODE: 7891 case XML_TEXT_NODE: 7892 case XML_CDATA_SECTION_NODE: 7893 case XML_ENTITY_REF_NODE: 7894 case XML_ENTITY_NODE: 7895 case XML_PI_NODE: 7896 case XML_COMMENT_NODE: 7897 case XML_NOTATION_NODE: 7898 case XML_DTD_NODE: 7899 case XML_ELEMENT_DECL: 7900 case XML_ATTRIBUTE_DECL: 7901 case XML_XINCLUDE_START: 7902 case XML_XINCLUDE_END: 7903 case XML_ENTITY_DECL: 7904 if (ctxt->context->node->parent == NULL) 7905 return((xmlNodePtr) ctxt->context->doc); 7906 if ((ctxt->context->node->parent->type == XML_ELEMENT_NODE) && 7907 ((ctxt->context->node->parent->name[0] == ' ') || 7908 (xmlStrEqual(ctxt->context->node->parent->name, 7909 BAD_CAST "fake node libxslt")))) 7910 return(NULL); 7911 return(ctxt->context->node->parent); 7912 case XML_ATTRIBUTE_NODE: { 7913 xmlAttrPtr att = (xmlAttrPtr) ctxt->context->node; 7914 7915 return(att->parent); 7916 } 7917 case XML_DOCUMENT_NODE: 7918 case XML_DOCUMENT_TYPE_NODE: 7919 case XML_DOCUMENT_FRAG_NODE: 7920 case XML_HTML_DOCUMENT_NODE: 7921 #ifdef LIBXML_DOCB_ENABLED 7922 case XML_DOCB_DOCUMENT_NODE: 7923 #endif 7924 return(NULL); 7925 case XML_NAMESPACE_DECL: { 7926 xmlNsPtr ns = (xmlNsPtr) ctxt->context->node; 7927 7928 if ((ns->next != NULL) && 7929 (ns->next->type != XML_NAMESPACE_DECL)) 7930 return((xmlNodePtr) ns->next); 7931 return(NULL); 7932 } 7933 } 7934 } 7935 return(NULL); 7936 } 7937 7938 /** 7939 * xmlXPathNextAncestor: 7940 * @ctxt: the XPath Parser context 7941 * @cur: the current node in the traversal 7942 * 7943 * Traversal function for the "ancestor" direction 7944 * the ancestor axis contains the ancestors of the context node; the ancestors 7945 * of the context node consist of the parent of context node and the parent's 7946 * parent and so on; the nodes are ordered in reverse document order; thus the 7947 * parent is the first node on the axis, and the parent's parent is the second 7948 * node on the axis 7949 * 7950 * Returns the next element following that axis 7951 */ 7952 xmlNodePtr 7953 xmlXPathNextAncestor(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) { 7954 if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL); 7955 /* 7956 * the parent of an attribute or namespace node is the element 7957 * to which the attribute or namespace node is attached 7958 * !!!!!!!!!!!!! 7959 */ 7960 if (cur == NULL) { 7961 if (ctxt->context->node == NULL) return(NULL); 7962 switch (ctxt->context->node->type) { 7963 case XML_ELEMENT_NODE: 7964 case XML_TEXT_NODE: 7965 case XML_CDATA_SECTION_NODE: 7966 case XML_ENTITY_REF_NODE: 7967 case XML_ENTITY_NODE: 7968 case XML_PI_NODE: 7969 case XML_COMMENT_NODE: 7970 case XML_DTD_NODE: 7971 case XML_ELEMENT_DECL: 7972 case XML_ATTRIBUTE_DECL: 7973 case XML_ENTITY_DECL: 7974 case XML_NOTATION_NODE: 7975 case XML_XINCLUDE_START: 7976 case XML_XINCLUDE_END: 7977 if (ctxt->context->node->parent == NULL) 7978 return((xmlNodePtr) ctxt->context->doc); 7979 if ((ctxt->context->node->parent->type == XML_ELEMENT_NODE) && 7980 ((ctxt->context->node->parent->name[0] == ' ') || 7981 (xmlStrEqual(ctxt->context->node->parent->name, 7982 BAD_CAST "fake node libxslt")))) 7983 return(NULL); 7984 return(ctxt->context->node->parent); 7985 case XML_ATTRIBUTE_NODE: { 7986 xmlAttrPtr tmp = (xmlAttrPtr) ctxt->context->node; 7987 7988 return(tmp->parent); 7989 } 7990 case XML_DOCUMENT_NODE: 7991 case XML_DOCUMENT_TYPE_NODE: 7992 case XML_DOCUMENT_FRAG_NODE: 7993 case XML_HTML_DOCUMENT_NODE: 7994 #ifdef LIBXML_DOCB_ENABLED 7995 case XML_DOCB_DOCUMENT_NODE: 7996 #endif 7997 return(NULL); 7998 case XML_NAMESPACE_DECL: { 7999 xmlNsPtr ns = (xmlNsPtr) ctxt->context->node; 8000 8001 if ((ns->next != NULL) && 8002 (ns->next->type != XML_NAMESPACE_DECL)) 8003 return((xmlNodePtr) ns->next); 8004 /* Bad, how did that namespace end up here ? */ 8005 return(NULL); 8006 } 8007 } 8008 return(NULL); 8009 } 8010 if (cur == ctxt->context->doc->children) 8011 return((xmlNodePtr) ctxt->context->doc); 8012 if (cur == (xmlNodePtr) ctxt->context->doc) 8013 return(NULL); 8014 switch (cur->type) { 8015 case XML_ELEMENT_NODE: 8016 case XML_TEXT_NODE: 8017 case XML_CDATA_SECTION_NODE: 8018 case XML_ENTITY_REF_NODE: 8019 case XML_ENTITY_NODE: 8020 case XML_PI_NODE: 8021 case XML_COMMENT_NODE: 8022 case XML_NOTATION_NODE: 8023 case XML_DTD_NODE: 8024 case XML_ELEMENT_DECL: 8025 case XML_ATTRIBUTE_DECL: 8026 case XML_ENTITY_DECL: 8027 case XML_XINCLUDE_START: 8028 case XML_XINCLUDE_END: 8029 if (cur->parent == NULL) 8030 return(NULL); 8031 if ((cur->parent->type == XML_ELEMENT_NODE) && 8032 ((cur->parent->name[0] == ' ') || 8033 (xmlStrEqual(cur->parent->name, 8034 BAD_CAST "fake node libxslt")))) 8035 return(NULL); 8036 return(cur->parent); 8037 case XML_ATTRIBUTE_NODE: { 8038 xmlAttrPtr att = (xmlAttrPtr) ctxt->context->node; 8039 8040 return(att->parent); 8041 } 8042 case XML_NAMESPACE_DECL: { 8043 xmlNsPtr ns = (xmlNsPtr) ctxt->context->node; 8044 8045 if ((ns->next != NULL) && 8046 (ns->next->type != XML_NAMESPACE_DECL)) 8047 return((xmlNodePtr) ns->next); 8048 /* Bad, how did that namespace end up here ? */ 8049 return(NULL); 8050 } 8051 case XML_DOCUMENT_NODE: 8052 case XML_DOCUMENT_TYPE_NODE: 8053 case XML_DOCUMENT_FRAG_NODE: 8054 case XML_HTML_DOCUMENT_NODE: 8055 #ifdef LIBXML_DOCB_ENABLED 8056 case XML_DOCB_DOCUMENT_NODE: 8057 #endif 8058 return(NULL); 8059 } 8060 return(NULL); 8061 } 8062 8063 /** 8064 * xmlXPathNextAncestorOrSelf: 8065 * @ctxt: the XPath Parser context 8066 * @cur: the current node in the traversal 8067 * 8068 * Traversal function for the "ancestor-or-self" direction 8069 * he ancestor-or-self axis contains the context node and ancestors of 8070 * the context node in reverse document order; thus the context node is 8071 * the first node on the axis, and the context node's parent the second; 8072 * parent here is defined the same as with the parent axis. 8073 * 8074 * Returns the next element following that axis 8075 */ 8076 xmlNodePtr 8077 xmlXPathNextAncestorOrSelf(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) { 8078 if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL); 8079 if (cur == NULL) 8080 return(ctxt->context->node); 8081 return(xmlXPathNextAncestor(ctxt, cur)); 8082 } 8083 8084 /** 8085 * xmlXPathNextFollowingSibling: 8086 * @ctxt: the XPath Parser context 8087 * @cur: the current node in the traversal 8088 * 8089 * Traversal function for the "following-sibling" direction 8090 * The following-sibling axis contains the following siblings of the context 8091 * node in document order. 8092 * 8093 * Returns the next element following that axis 8094 */ 8095 xmlNodePtr 8096 xmlXPathNextFollowingSibling(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) { 8097 if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL); 8098 if ((ctxt->context->node->type == XML_ATTRIBUTE_NODE) || 8099 (ctxt->context->node->type == XML_NAMESPACE_DECL)) 8100 return(NULL); 8101 if (cur == (xmlNodePtr) ctxt->context->doc) 8102 return(NULL); 8103 if (cur == NULL) 8104 return(ctxt->context->node->next); 8105 return(cur->next); 8106 } 8107 8108 /** 8109 * xmlXPathNextPrecedingSibling: 8110 * @ctxt: the XPath Parser context 8111 * @cur: the current node in the traversal 8112 * 8113 * Traversal function for the "preceding-sibling" direction 8114 * The preceding-sibling axis contains the preceding siblings of the context 8115 * node in reverse document order; the first preceding sibling is first on the 8116 * axis; the sibling preceding that node is the second on the axis and so on. 8117 * 8118 * Returns the next element following that axis 8119 */ 8120 xmlNodePtr 8121 xmlXPathNextPrecedingSibling(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) { 8122 if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL); 8123 if ((ctxt->context->node->type == XML_ATTRIBUTE_NODE) || 8124 (ctxt->context->node->type == XML_NAMESPACE_DECL)) 8125 return(NULL); 8126 if (cur == (xmlNodePtr) ctxt->context->doc) 8127 return(NULL); 8128 if (cur == NULL) 8129 return(ctxt->context->node->prev); 8130 if ((cur->prev != NULL) && (cur->prev->type == XML_DTD_NODE)) { 8131 cur = cur->prev; 8132 if (cur == NULL) 8133 return(ctxt->context->node->prev); 8134 } 8135 return(cur->prev); 8136 } 8137 8138 /** 8139 * xmlXPathNextFollowing: 8140 * @ctxt: the XPath Parser context 8141 * @cur: the current node in the traversal 8142 * 8143 * Traversal function for the "following" direction 8144 * The following axis contains all nodes in the same document as the context 8145 * node that are after the context node in document order, excluding any 8146 * descendants and excluding attribute nodes and namespace nodes; the nodes 8147 * are ordered in document order 8148 * 8149 * Returns the next element following that axis 8150 */ 8151 xmlNodePtr 8152 xmlXPathNextFollowing(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) { 8153 if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL); 8154 if ((cur != NULL) && (cur->type != XML_ATTRIBUTE_NODE) && 8155 (cur->type != XML_NAMESPACE_DECL) && (cur->children != NULL)) 8156 return(cur->children); 8157 8158 if (cur == NULL) { 8159 cur = ctxt->context->node; 8160 if (cur->type == XML_NAMESPACE_DECL) 8161 return(NULL); 8162 if (cur->type == XML_ATTRIBUTE_NODE) 8163 cur = cur->parent; 8164 } 8165 if (cur == NULL) return(NULL) ; /* ERROR */ 8166 if (cur->next != NULL) return(cur->next) ; 8167 do { 8168 cur = cur->parent; 8169 if (cur == NULL) break; 8170 if (cur == (xmlNodePtr) ctxt->context->doc) return(NULL); 8171 if (cur->next != NULL) return(cur->next); 8172 } while (cur != NULL); 8173 return(cur); 8174 } 8175 8176 /* 8177 * xmlXPathIsAncestor: 8178 * @ancestor: the ancestor node 8179 * @node: the current node 8180 * 8181 * Check that @ancestor is a @node's ancestor 8182 * 8183 * returns 1 if @ancestor is a @node's ancestor, 0 otherwise. 8184 */ 8185 static int 8186 xmlXPathIsAncestor(xmlNodePtr ancestor, xmlNodePtr node) { 8187 if ((ancestor == NULL) || (node == NULL)) return(0); 8188 /* nodes need to be in the same document */ 8189 if (ancestor->doc != node->doc) return(0); 8190 /* avoid searching if ancestor or node is the root node */ 8191 if (ancestor == (xmlNodePtr) node->doc) return(1); 8192 if (node == (xmlNodePtr) ancestor->doc) return(0); 8193 while (node->parent != NULL) { 8194 if (node->parent == ancestor) 8195 return(1); 8196 node = node->parent; 8197 } 8198 return(0); 8199 } 8200 8201 /** 8202 * xmlXPathNextPreceding: 8203 * @ctxt: the XPath Parser context 8204 * @cur: the current node in the traversal 8205 * 8206 * Traversal function for the "preceding" direction 8207 * the preceding axis contains all nodes in the same document as the context 8208 * node that are before the context node in document order, excluding any 8209 * ancestors and excluding attribute nodes and namespace nodes; the nodes are 8210 * ordered in reverse document order 8211 * 8212 * Returns the next element following that axis 8213 */ 8214 xmlNodePtr 8215 xmlXPathNextPreceding(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) 8216 { 8217 if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL); 8218 if (cur == NULL) { 8219 cur = ctxt->context->node; 8220 if (cur->type == XML_NAMESPACE_DECL) 8221 return(NULL); 8222 if (cur->type == XML_ATTRIBUTE_NODE) 8223 return(cur->parent); 8224 } 8225 if (cur == NULL) 8226 return (NULL); 8227 if ((cur->prev != NULL) && (cur->prev->type == XML_DTD_NODE)) 8228 cur = cur->prev; 8229 do { 8230 if (cur->prev != NULL) { 8231 for (cur = cur->prev; cur->last != NULL; cur = cur->last) ; 8232 return (cur); 8233 } 8234 8235 cur = cur->parent; 8236 if (cur == NULL) 8237 return (NULL); 8238 if (cur == ctxt->context->doc->children) 8239 return (NULL); 8240 } while (xmlXPathIsAncestor(cur, ctxt->context->node)); 8241 return (cur); 8242 } 8243 8244 /** 8245 * xmlXPathNextPrecedingInternal: 8246 * @ctxt: the XPath Parser context 8247 * @cur: the current node in the traversal 8248 * 8249 * Traversal function for the "preceding" direction 8250 * the preceding axis contains all nodes in the same document as the context 8251 * node that are before the context node in document order, excluding any 8252 * ancestors and excluding attribute nodes and namespace nodes; the nodes are 8253 * ordered in reverse document order 8254 * This is a faster implementation but internal only since it requires a 8255 * state kept in the parser context: ctxt->ancestor. 8256 * 8257 * Returns the next element following that axis 8258 */ 8259 static xmlNodePtr 8260 xmlXPathNextPrecedingInternal(xmlXPathParserContextPtr ctxt, 8261 xmlNodePtr cur) 8262 { 8263 if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL); 8264 if (cur == NULL) { 8265 cur = ctxt->context->node; 8266 if (cur == NULL) 8267 return (NULL); 8268 if (cur->type == XML_NAMESPACE_DECL) 8269 return (NULL); 8270 ctxt->ancestor = cur->parent; 8271 } 8272 if ((cur->prev != NULL) && (cur->prev->type == XML_DTD_NODE)) 8273 cur = cur->prev; 8274 while (cur->prev == NULL) { 8275 cur = cur->parent; 8276 if (cur == NULL) 8277 return (NULL); 8278 if (cur == ctxt->context->doc->children) 8279 return (NULL); 8280 if (cur != ctxt->ancestor) 8281 return (cur); 8282 ctxt->ancestor = cur->parent; 8283 } 8284 cur = cur->prev; 8285 while (cur->last != NULL) 8286 cur = cur->last; 8287 return (cur); 8288 } 8289 8290 /** 8291 * xmlXPathNextNamespace: 8292 * @ctxt: the XPath Parser context 8293 * @cur: the current attribute in the traversal 8294 * 8295 * Traversal function for the "namespace" direction 8296 * the namespace axis contains the namespace nodes of the context node; 8297 * the order of nodes on this axis is implementation-defined; the axis will 8298 * be empty unless the context node is an element 8299 * 8300 * We keep the XML namespace node at the end of the list. 8301 * 8302 * Returns the next element following that axis 8303 */ 8304 xmlNodePtr 8305 xmlXPathNextNamespace(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) { 8306 if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL); 8307 if (ctxt->context->node->type != XML_ELEMENT_NODE) return(NULL); 8308 if (ctxt->context->tmpNsList == NULL && cur != (xmlNodePtr) xmlXPathXMLNamespace) { 8309 if (ctxt->context->tmpNsList != NULL) 8310 xmlFree(ctxt->context->tmpNsList); 8311 ctxt->context->tmpNsList = 8312 xmlGetNsList(ctxt->context->doc, ctxt->context->node); 8313 ctxt->context->tmpNsNr = 0; 8314 if (ctxt->context->tmpNsList != NULL) { 8315 while (ctxt->context->tmpNsList[ctxt->context->tmpNsNr] != NULL) { 8316 ctxt->context->tmpNsNr++; 8317 } 8318 } 8319 return((xmlNodePtr) xmlXPathXMLNamespace); 8320 } 8321 if (ctxt->context->tmpNsNr > 0) { 8322 return (xmlNodePtr)ctxt->context->tmpNsList[--ctxt->context->tmpNsNr]; 8323 } else { 8324 if (ctxt->context->tmpNsList != NULL) 8325 xmlFree(ctxt->context->tmpNsList); 8326 ctxt->context->tmpNsList = NULL; 8327 return(NULL); 8328 } 8329 } 8330 8331 /** 8332 * xmlXPathNextAttribute: 8333 * @ctxt: the XPath Parser context 8334 * @cur: the current attribute in the traversal 8335 * 8336 * Traversal function for the "attribute" direction 8337 * TODO: support DTD inherited default attributes 8338 * 8339 * Returns the next element following that axis 8340 */ 8341 xmlNodePtr 8342 xmlXPathNextAttribute(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) { 8343 if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL); 8344 if (ctxt->context->node == NULL) 8345 return(NULL); 8346 if (ctxt->context->node->type != XML_ELEMENT_NODE) 8347 return(NULL); 8348 if (cur == NULL) { 8349 if (ctxt->context->node == (xmlNodePtr) ctxt->context->doc) 8350 return(NULL); 8351 return((xmlNodePtr)ctxt->context->node->properties); 8352 } 8353 return((xmlNodePtr)cur->next); 8354 } 8355 8356 /************************************************************************ 8357 * * 8358 * NodeTest Functions * 8359 * * 8360 ************************************************************************/ 8361 8362 #define IS_FUNCTION 200 8363 8364 8365 /************************************************************************ 8366 * * 8367 * Implicit tree core function library * 8368 * * 8369 ************************************************************************/ 8370 8371 /** 8372 * xmlXPathRoot: 8373 * @ctxt: the XPath Parser context 8374 * 8375 * Initialize the context to the root of the document 8376 */ 8377 void 8378 xmlXPathRoot(xmlXPathParserContextPtr ctxt) { 8379 if ((ctxt == NULL) || (ctxt->context == NULL)) 8380 return; 8381 ctxt->context->node = (xmlNodePtr) ctxt->context->doc; 8382 valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context, 8383 ctxt->context->node)); 8384 } 8385 8386 /************************************************************************ 8387 * * 8388 * The explicit core function library * 8389 *http://www.w3.org/Style/XSL/Group/1999/07/xpath-19990705.html#corelib * 8390 * * 8391 ************************************************************************/ 8392 8393 8394 /** 8395 * xmlXPathLastFunction: 8396 * @ctxt: the XPath Parser context 8397 * @nargs: the number of arguments 8398 * 8399 * Implement the last() XPath function 8400 * number last() 8401 * The last function returns the number of nodes in the context node list. 8402 */ 8403 void 8404 xmlXPathLastFunction(xmlXPathParserContextPtr ctxt, int nargs) { 8405 CHECK_ARITY(0); 8406 if (ctxt->context->contextSize >= 0) { 8407 valuePush(ctxt, 8408 xmlXPathCacheNewFloat(ctxt->context, 8409 (double) ctxt->context->contextSize)); 8410 #ifdef DEBUG_EXPR 8411 xmlGenericError(xmlGenericErrorContext, 8412 "last() : %d\n", ctxt->context->contextSize); 8413 #endif 8414 } else { 8415 XP_ERROR(XPATH_INVALID_CTXT_SIZE); 8416 } 8417 } 8418 8419 /** 8420 * xmlXPathPositionFunction: 8421 * @ctxt: the XPath Parser context 8422 * @nargs: the number of arguments 8423 * 8424 * Implement the position() XPath function 8425 * number position() 8426 * The position function returns the position of the context node in the 8427 * context node list. The first position is 1, and so the last position 8428 * will be equal to last(). 8429 */ 8430 void 8431 xmlXPathPositionFunction(xmlXPathParserContextPtr ctxt, int nargs) { 8432 CHECK_ARITY(0); 8433 if (ctxt->context->proximityPosition >= 0) { 8434 valuePush(ctxt, 8435 xmlXPathCacheNewFloat(ctxt->context, 8436 (double) ctxt->context->proximityPosition)); 8437 #ifdef DEBUG_EXPR 8438 xmlGenericError(xmlGenericErrorContext, "position() : %d\n", 8439 ctxt->context->proximityPosition); 8440 #endif 8441 } else { 8442 XP_ERROR(XPATH_INVALID_CTXT_POSITION); 8443 } 8444 } 8445 8446 /** 8447 * xmlXPathCountFunction: 8448 * @ctxt: the XPath Parser context 8449 * @nargs: the number of arguments 8450 * 8451 * Implement the count() XPath function 8452 * number count(node-set) 8453 */ 8454 void 8455 xmlXPathCountFunction(xmlXPathParserContextPtr ctxt, int nargs) { 8456 xmlXPathObjectPtr cur; 8457 8458 CHECK_ARITY(1); 8459 if ((ctxt->value == NULL) || 8460 ((ctxt->value->type != XPATH_NODESET) && 8461 (ctxt->value->type != XPATH_XSLT_TREE))) 8462 XP_ERROR(XPATH_INVALID_TYPE); 8463 cur = valuePop(ctxt); 8464 8465 if ((cur == NULL) || (cur->nodesetval == NULL)) 8466 valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, (double) 0)); 8467 else if ((cur->type == XPATH_NODESET) || (cur->type == XPATH_XSLT_TREE)) { 8468 valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, 8469 (double) cur->nodesetval->nodeNr)); 8470 } else { 8471 if ((cur->nodesetval->nodeNr != 1) || 8472 (cur->nodesetval->nodeTab == NULL)) { 8473 valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, (double) 0)); 8474 } else { 8475 xmlNodePtr tmp; 8476 int i = 0; 8477 8478 tmp = cur->nodesetval->nodeTab[0]; 8479 if (tmp != NULL) { 8480 tmp = tmp->children; 8481 while (tmp != NULL) { 8482 tmp = tmp->next; 8483 i++; 8484 } 8485 } 8486 valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, (double) i)); 8487 } 8488 } 8489 xmlXPathReleaseObject(ctxt->context, cur); 8490 } 8491 8492 /** 8493 * xmlXPathGetElementsByIds: 8494 * @doc: the document 8495 * @ids: a whitespace separated list of IDs 8496 * 8497 * Selects elements by their unique ID. 8498 * 8499 * Returns a node-set of selected elements. 8500 */ 8501 static xmlNodeSetPtr 8502 xmlXPathGetElementsByIds (xmlDocPtr doc, const xmlChar *ids) { 8503 xmlNodeSetPtr ret; 8504 const xmlChar *cur = ids; 8505 xmlChar *ID; 8506 xmlAttrPtr attr; 8507 xmlNodePtr elem = NULL; 8508 8509 if (ids == NULL) return(NULL); 8510 8511 ret = xmlXPathNodeSetCreate(NULL); 8512 if (ret == NULL) 8513 return(ret); 8514 8515 while (IS_BLANK_CH(*cur)) cur++; 8516 while (*cur != 0) { 8517 while ((!IS_BLANK_CH(*cur)) && (*cur != 0)) 8518 cur++; 8519 8520 ID = xmlStrndup(ids, cur - ids); 8521 if (ID != NULL) { 8522 /* 8523 * We used to check the fact that the value passed 8524 * was an NCName, but this generated much troubles for 8525 * me and Aleksey Sanin, people blatantly violated that 8526 * constaint, like Visa3D spec. 8527 * if (xmlValidateNCName(ID, 1) == 0) 8528 */ 8529 attr = xmlGetID(doc, ID); 8530 if (attr != NULL) { 8531 if (attr->type == XML_ATTRIBUTE_NODE) 8532 elem = attr->parent; 8533 else if (attr->type == XML_ELEMENT_NODE) 8534 elem = (xmlNodePtr) attr; 8535 else 8536 elem = NULL; 8537 if (elem != NULL) 8538 xmlXPathNodeSetAdd(ret, elem); 8539 } 8540 xmlFree(ID); 8541 } 8542 8543 while (IS_BLANK_CH(*cur)) cur++; 8544 ids = cur; 8545 } 8546 return(ret); 8547 } 8548 8549 /** 8550 * xmlXPathIdFunction: 8551 * @ctxt: the XPath Parser context 8552 * @nargs: the number of arguments 8553 * 8554 * Implement the id() XPath function 8555 * node-set id(object) 8556 * The id function selects elements by their unique ID 8557 * (see [5.2.1 Unique IDs]). When the argument to id is of type node-set, 8558 * then the result is the union of the result of applying id to the 8559 * string value of each of the nodes in the argument node-set. When the 8560 * argument to id is of any other type, the argument is converted to a 8561 * string as if by a call to the string function; the string is split 8562 * into a whitespace-separated list of tokens (whitespace is any sequence 8563 * of characters matching the production S); the result is a node-set 8564 * containing the elements in the same document as the context node that 8565 * have a unique ID equal to any of the tokens in the list. 8566 */ 8567 void 8568 xmlXPathIdFunction(xmlXPathParserContextPtr ctxt, int nargs) { 8569 xmlChar *tokens; 8570 xmlNodeSetPtr ret; 8571 xmlXPathObjectPtr obj; 8572 8573 CHECK_ARITY(1); 8574 obj = valuePop(ctxt); 8575 if (obj == NULL) XP_ERROR(XPATH_INVALID_OPERAND); 8576 if ((obj->type == XPATH_NODESET) || (obj->type == XPATH_XSLT_TREE)) { 8577 xmlNodeSetPtr ns; 8578 int i; 8579 8580 ret = xmlXPathNodeSetCreate(NULL); 8581 /* 8582 * FIXME -- in an out-of-memory condition this will behave badly. 8583 * The solution is not clear -- we already popped an item from 8584 * ctxt, so the object is in a corrupt state. 8585 */ 8586 8587 if (obj->nodesetval != NULL) { 8588 for (i = 0; i < obj->nodesetval->nodeNr; i++) { 8589 tokens = 8590 xmlXPathCastNodeToString(obj->nodesetval->nodeTab[i]); 8591 ns = xmlXPathGetElementsByIds(ctxt->context->doc, tokens); 8592 ret = xmlXPathNodeSetMerge(ret, ns); 8593 xmlXPathFreeNodeSet(ns); 8594 if (tokens != NULL) 8595 xmlFree(tokens); 8596 } 8597 } 8598 xmlXPathReleaseObject(ctxt->context, obj); 8599 valuePush(ctxt, xmlXPathCacheWrapNodeSet(ctxt->context, ret)); 8600 return; 8601 } 8602 obj = xmlXPathCacheConvertString(ctxt->context, obj); 8603 ret = xmlXPathGetElementsByIds(ctxt->context->doc, obj->stringval); 8604 valuePush(ctxt, xmlXPathCacheWrapNodeSet(ctxt->context, ret)); 8605 xmlXPathReleaseObject(ctxt->context, obj); 8606 return; 8607 } 8608 8609 /** 8610 * xmlXPathLocalNameFunction: 8611 * @ctxt: the XPath Parser context 8612 * @nargs: the number of arguments 8613 * 8614 * Implement the local-name() XPath function 8615 * string local-name(node-set?) 8616 * The local-name function returns a string containing the local part 8617 * of the name of the node in the argument node-set that is first in 8618 * document order. If the node-set is empty or the first node has no 8619 * name, an empty string is returned. If the argument is omitted it 8620 * defaults to the context node. 8621 */ 8622 void 8623 xmlXPathLocalNameFunction(xmlXPathParserContextPtr ctxt, int nargs) { 8624 xmlXPathObjectPtr cur; 8625 8626 if (ctxt == NULL) return; 8627 8628 if (nargs == 0) { 8629 valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context, 8630 ctxt->context->node)); 8631 nargs = 1; 8632 } 8633 8634 CHECK_ARITY(1); 8635 if ((ctxt->value == NULL) || 8636 ((ctxt->value->type != XPATH_NODESET) && 8637 (ctxt->value->type != XPATH_XSLT_TREE))) 8638 XP_ERROR(XPATH_INVALID_TYPE); 8639 cur = valuePop(ctxt); 8640 8641 if ((cur->nodesetval == NULL) || (cur->nodesetval->nodeNr == 0)) { 8642 valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, "")); 8643 } else { 8644 int i = 0; /* Should be first in document order !!!!! */ 8645 switch (cur->nodesetval->nodeTab[i]->type) { 8646 case XML_ELEMENT_NODE: 8647 case XML_ATTRIBUTE_NODE: 8648 case XML_PI_NODE: 8649 if (cur->nodesetval->nodeTab[i]->name[0] == ' ') 8650 valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, "")); 8651 else 8652 valuePush(ctxt, 8653 xmlXPathCacheNewString(ctxt->context, 8654 cur->nodesetval->nodeTab[i]->name)); 8655 break; 8656 case XML_NAMESPACE_DECL: 8657 valuePush(ctxt, xmlXPathCacheNewString(ctxt->context, 8658 ((xmlNsPtr)cur->nodesetval->nodeTab[i])->prefix)); 8659 break; 8660 default: 8661 valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, "")); 8662 } 8663 } 8664 xmlXPathReleaseObject(ctxt->context, cur); 8665 } 8666 8667 /** 8668 * xmlXPathNamespaceURIFunction: 8669 * @ctxt: the XPath Parser context 8670 * @nargs: the number of arguments 8671 * 8672 * Implement the namespace-uri() XPath function 8673 * string namespace-uri(node-set?) 8674 * The namespace-uri function returns a string containing the 8675 * namespace URI of the expanded name of the node in the argument 8676 * node-set that is first in document order. If the node-set is empty, 8677 * the first node has no name, or the expanded name has no namespace 8678 * URI, an empty string is returned. If the argument is omitted it 8679 * defaults to the context node. 8680 */ 8681 void 8682 xmlXPathNamespaceURIFunction(xmlXPathParserContextPtr ctxt, int nargs) { 8683 xmlXPathObjectPtr cur; 8684 8685 if (ctxt == NULL) return; 8686 8687 if (nargs == 0) { 8688 valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context, 8689 ctxt->context->node)); 8690 nargs = 1; 8691 } 8692 CHECK_ARITY(1); 8693 if ((ctxt->value == NULL) || 8694 ((ctxt->value->type != XPATH_NODESET) && 8695 (ctxt->value->type != XPATH_XSLT_TREE))) 8696 XP_ERROR(XPATH_INVALID_TYPE); 8697 cur = valuePop(ctxt); 8698 8699 if ((cur->nodesetval == NULL) || (cur->nodesetval->nodeNr == 0)) { 8700 valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, "")); 8701 } else { 8702 int i = 0; /* Should be first in document order !!!!! */ 8703 switch (cur->nodesetval->nodeTab[i]->type) { 8704 case XML_ELEMENT_NODE: 8705 case XML_ATTRIBUTE_NODE: 8706 if (cur->nodesetval->nodeTab[i]->ns == NULL) 8707 valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, "")); 8708 else 8709 valuePush(ctxt, xmlXPathCacheNewString(ctxt->context, 8710 cur->nodesetval->nodeTab[i]->ns->href)); 8711 break; 8712 default: 8713 valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, "")); 8714 } 8715 } 8716 xmlXPathReleaseObject(ctxt->context, cur); 8717 } 8718 8719 /** 8720 * xmlXPathNameFunction: 8721 * @ctxt: the XPath Parser context 8722 * @nargs: the number of arguments 8723 * 8724 * Implement the name() XPath function 8725 * string name(node-set?) 8726 * The name function returns a string containing a QName representing 8727 * the name of the node in the argument node-set that is first in document 8728 * order. The QName must represent the name with respect to the namespace 8729 * declarations in effect on the node whose name is being represented. 8730 * Typically, this will be the form in which the name occurred in the XML 8731 * source. This need not be the case if there are namespace declarations 8732 * in effect on the node that associate multiple prefixes with the same 8733 * namespace. However, an implementation may include information about 8734 * the original prefix in its representation of nodes; in this case, an 8735 * implementation can ensure that the returned string is always the same 8736 * as the QName used in the XML source. If the argument it omitted it 8737 * defaults to the context node. 8738 * Libxml keep the original prefix so the "real qualified name" used is 8739 * returned. 8740 */ 8741 static void 8742 xmlXPathNameFunction(xmlXPathParserContextPtr ctxt, int nargs) 8743 { 8744 xmlXPathObjectPtr cur; 8745 8746 if (nargs == 0) { 8747 valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context, 8748 ctxt->context->node)); 8749 nargs = 1; 8750 } 8751 8752 CHECK_ARITY(1); 8753 if ((ctxt->value == NULL) || 8754 ((ctxt->value->type != XPATH_NODESET) && 8755 (ctxt->value->type != XPATH_XSLT_TREE))) 8756 XP_ERROR(XPATH_INVALID_TYPE); 8757 cur = valuePop(ctxt); 8758 8759 if ((cur->nodesetval == NULL) || (cur->nodesetval->nodeNr == 0)) { 8760 valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, "")); 8761 } else { 8762 int i = 0; /* Should be first in document order !!!!! */ 8763 8764 switch (cur->nodesetval->nodeTab[i]->type) { 8765 case XML_ELEMENT_NODE: 8766 case XML_ATTRIBUTE_NODE: 8767 if (cur->nodesetval->nodeTab[i]->name[0] == ' ') 8768 valuePush(ctxt, 8769 xmlXPathCacheNewCString(ctxt->context, "")); 8770 else if ((cur->nodesetval->nodeTab[i]->ns == NULL) || 8771 (cur->nodesetval->nodeTab[i]->ns->prefix == NULL)) { 8772 valuePush(ctxt, 8773 xmlXPathCacheNewString(ctxt->context, 8774 cur->nodesetval->nodeTab[i]->name)); 8775 } else { 8776 xmlChar *fullname; 8777 8778 fullname = xmlBuildQName(cur->nodesetval->nodeTab[i]->name, 8779 cur->nodesetval->nodeTab[i]->ns->prefix, 8780 NULL, 0); 8781 if (fullname == cur->nodesetval->nodeTab[i]->name) 8782 fullname = xmlStrdup(cur->nodesetval->nodeTab[i]->name); 8783 if (fullname == NULL) { 8784 XP_ERROR(XPATH_MEMORY_ERROR); 8785 } 8786 valuePush(ctxt, xmlXPathCacheWrapString( 8787 ctxt->context, fullname)); 8788 } 8789 break; 8790 default: 8791 valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context, 8792 cur->nodesetval->nodeTab[i])); 8793 xmlXPathLocalNameFunction(ctxt, 1); 8794 } 8795 } 8796 xmlXPathReleaseObject(ctxt->context, cur); 8797 } 8798 8799 8800 /** 8801 * xmlXPathStringFunction: 8802 * @ctxt: the XPath Parser context 8803 * @nargs: the number of arguments 8804 * 8805 * Implement the string() XPath function 8806 * string string(object?) 8807 * The string function converts an object to a string as follows: 8808 * - A node-set is converted to a string by returning the value of 8809 * the node in the node-set that is first in document order. 8810 * If the node-set is empty, an empty string is returned. 8811 * - A number is converted to a string as follows 8812 * + NaN is converted to the string NaN 8813 * + positive zero is converted to the string 0 8814 * + negative zero is converted to the string 0 8815 * + positive infinity is converted to the string Infinity 8816 * + negative infinity is converted to the string -Infinity 8817 * + if the number is an integer, the number is represented in 8818 * decimal form as a Number with no decimal point and no leading 8819 * zeros, preceded by a minus sign (-) if the number is negative 8820 * + otherwise, the number is represented in decimal form as a 8821 * Number including a decimal point with at least one digit 8822 * before the decimal point and at least one digit after the 8823 * decimal point, preceded by a minus sign (-) if the number 8824 * is negative; there must be no leading zeros before the decimal 8825 * point apart possibly from the one required digit immediately 8826 * before the decimal point; beyond the one required digit 8827 * after the decimal point there must be as many, but only as 8828 * many, more digits as are needed to uniquely distinguish the 8829 * number from all other IEEE 754 numeric values. 8830 * - The boolean false value is converted to the string false. 8831 * The boolean true value is converted to the string true. 8832 * 8833 * If the argument is omitted, it defaults to a node-set with the 8834 * context node as its only member. 8835 */ 8836 void 8837 xmlXPathStringFunction(xmlXPathParserContextPtr ctxt, int nargs) { 8838 xmlXPathObjectPtr cur; 8839 8840 if (ctxt == NULL) return; 8841 if (nargs == 0) { 8842 valuePush(ctxt, 8843 xmlXPathCacheWrapString(ctxt->context, 8844 xmlXPathCastNodeToString(ctxt->context->node))); 8845 return; 8846 } 8847 8848 CHECK_ARITY(1); 8849 cur = valuePop(ctxt); 8850 if (cur == NULL) XP_ERROR(XPATH_INVALID_OPERAND); 8851 valuePush(ctxt, xmlXPathCacheConvertString(ctxt->context, cur)); 8852 } 8853 8854 /** 8855 * xmlXPathStringLengthFunction: 8856 * @ctxt: the XPath Parser context 8857 * @nargs: the number of arguments 8858 * 8859 * Implement the string-length() XPath function 8860 * number string-length(string?) 8861 * The string-length returns the number of characters in the string 8862 * (see [3.6 Strings]). If the argument is omitted, it defaults to 8863 * the context node converted to a string, in other words the value 8864 * of the context node. 8865 */ 8866 void 8867 xmlXPathStringLengthFunction(xmlXPathParserContextPtr ctxt, int nargs) { 8868 xmlXPathObjectPtr cur; 8869 8870 if (nargs == 0) { 8871 if ((ctxt == NULL) || (ctxt->context == NULL)) 8872 return; 8873 if (ctxt->context->node == NULL) { 8874 valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, 0)); 8875 } else { 8876 xmlChar *content; 8877 8878 content = xmlXPathCastNodeToString(ctxt->context->node); 8879 valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, 8880 xmlUTF8Strlen(content))); 8881 xmlFree(content); 8882 } 8883 return; 8884 } 8885 CHECK_ARITY(1); 8886 CAST_TO_STRING; 8887 CHECK_TYPE(XPATH_STRING); 8888 cur = valuePop(ctxt); 8889 valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, 8890 xmlUTF8Strlen(cur->stringval))); 8891 xmlXPathReleaseObject(ctxt->context, cur); 8892 } 8893 8894 /** 8895 * xmlXPathConcatFunction: 8896 * @ctxt: the XPath Parser context 8897 * @nargs: the number of arguments 8898 * 8899 * Implement the concat() XPath function 8900 * string concat(string, string, string*) 8901 * The concat function returns the concatenation of its arguments. 8902 */ 8903 void 8904 xmlXPathConcatFunction(xmlXPathParserContextPtr ctxt, int nargs) { 8905 xmlXPathObjectPtr cur, newobj; 8906 xmlChar *tmp; 8907 8908 if (ctxt == NULL) return; 8909 if (nargs < 2) { 8910 CHECK_ARITY(2); 8911 } 8912 8913 CAST_TO_STRING; 8914 cur = valuePop(ctxt); 8915 if ((cur == NULL) || (cur->type != XPATH_STRING)) { 8916 xmlXPathReleaseObject(ctxt->context, cur); 8917 return; 8918 } 8919 nargs--; 8920 8921 while (nargs > 0) { 8922 CAST_TO_STRING; 8923 newobj = valuePop(ctxt); 8924 if ((newobj == NULL) || (newobj->type != XPATH_STRING)) { 8925 xmlXPathReleaseObject(ctxt->context, newobj); 8926 xmlXPathReleaseObject(ctxt->context, cur); 8927 XP_ERROR(XPATH_INVALID_TYPE); 8928 } 8929 tmp = xmlStrcat(newobj->stringval, cur->stringval); 8930 newobj->stringval = cur->stringval; 8931 cur->stringval = tmp; 8932 xmlXPathReleaseObject(ctxt->context, newobj); 8933 nargs--; 8934 } 8935 valuePush(ctxt, cur); 8936 } 8937 8938 /** 8939 * xmlXPathContainsFunction: 8940 * @ctxt: the XPath Parser context 8941 * @nargs: the number of arguments 8942 * 8943 * Implement the contains() XPath function 8944 * boolean contains(string, string) 8945 * The contains function returns true if the first argument string 8946 * contains the second argument string, and otherwise returns false. 8947 */ 8948 void 8949 xmlXPathContainsFunction(xmlXPathParserContextPtr ctxt, int nargs) { 8950 xmlXPathObjectPtr hay, needle; 8951 8952 CHECK_ARITY(2); 8953 CAST_TO_STRING; 8954 CHECK_TYPE(XPATH_STRING); 8955 needle = valuePop(ctxt); 8956 CAST_TO_STRING; 8957 hay = valuePop(ctxt); 8958 8959 if ((hay == NULL) || (hay->type != XPATH_STRING)) { 8960 xmlXPathReleaseObject(ctxt->context, hay); 8961 xmlXPathReleaseObject(ctxt->context, needle); 8962 XP_ERROR(XPATH_INVALID_TYPE); 8963 } 8964 if (xmlStrstr(hay->stringval, needle->stringval)) 8965 valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, 1)); 8966 else 8967 valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, 0)); 8968 xmlXPathReleaseObject(ctxt->context, hay); 8969 xmlXPathReleaseObject(ctxt->context, needle); 8970 } 8971 8972 /** 8973 * xmlXPathStartsWithFunction: 8974 * @ctxt: the XPath Parser context 8975 * @nargs: the number of arguments 8976 * 8977 * Implement the starts-with() XPath function 8978 * boolean starts-with(string, string) 8979 * The starts-with function returns true if the first argument string 8980 * starts with the second argument string, and otherwise returns false. 8981 */ 8982 void 8983 xmlXPathStartsWithFunction(xmlXPathParserContextPtr ctxt, int nargs) { 8984 xmlXPathObjectPtr hay, needle; 8985 int n; 8986 8987 CHECK_ARITY(2); 8988 CAST_TO_STRING; 8989 CHECK_TYPE(XPATH_STRING); 8990 needle = valuePop(ctxt); 8991 CAST_TO_STRING; 8992 hay = valuePop(ctxt); 8993 8994 if ((hay == NULL) || (hay->type != XPATH_STRING)) { 8995 xmlXPathReleaseObject(ctxt->context, hay); 8996 xmlXPathReleaseObject(ctxt->context, needle); 8997 XP_ERROR(XPATH_INVALID_TYPE); 8998 } 8999 n = xmlStrlen(needle->stringval); 9000 if (xmlStrncmp(hay->stringval, needle->stringval, n)) 9001 valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, 0)); 9002 else 9003 valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, 1)); 9004 xmlXPathReleaseObject(ctxt->context, hay); 9005 xmlXPathReleaseObject(ctxt->context, needle); 9006 } 9007 9008 /** 9009 * xmlXPathSubstringFunction: 9010 * @ctxt: the XPath Parser context 9011 * @nargs: the number of arguments 9012 * 9013 * Implement the substring() XPath function 9014 * string substring(string, number, number?) 9015 * The substring function returns the substring of the first argument 9016 * starting at the position specified in the second argument with 9017 * length specified in the third argument. For example, 9018 * substring("12345",2,3) returns "234". If the third argument is not 9019 * specified, it returns the substring starting at the position specified 9020 * in the second argument and continuing to the end of the string. For 9021 * example, substring("12345",2) returns "2345". More precisely, each 9022 * character in the string (see [3.6 Strings]) is considered to have a 9023 * numeric position: the position of the first character is 1, the position 9024 * of the second character is 2 and so on. The returned substring contains 9025 * those characters for which the position of the character is greater than 9026 * or equal to the second argument and, if the third argument is specified, 9027 * less than the sum of the second and third arguments; the comparisons 9028 * and addition used for the above follow the standard IEEE 754 rules. Thus: 9029 * - substring("12345", 1.5, 2.6) returns "234" 9030 * - substring("12345", 0, 3) returns "12" 9031 * - substring("12345", 0 div 0, 3) returns "" 9032 * - substring("12345", 1, 0 div 0) returns "" 9033 * - substring("12345", -42, 1 div 0) returns "12345" 9034 * - substring("12345", -1 div 0, 1 div 0) returns "" 9035 */ 9036 void 9037 xmlXPathSubstringFunction(xmlXPathParserContextPtr ctxt, int nargs) { 9038 xmlXPathObjectPtr str, start, len; 9039 double le=0, in; 9040 int i, l, m; 9041 xmlChar *ret; 9042 9043 if (nargs < 2) { 9044 CHECK_ARITY(2); 9045 } 9046 if (nargs > 3) { 9047 CHECK_ARITY(3); 9048 } 9049 /* 9050 * take care of possible last (position) argument 9051 */ 9052 if (nargs == 3) { 9053 CAST_TO_NUMBER; 9054 CHECK_TYPE(XPATH_NUMBER); 9055 len = valuePop(ctxt); 9056 le = len->floatval; 9057 xmlXPathReleaseObject(ctxt->context, len); 9058 } 9059 9060 CAST_TO_NUMBER; 9061 CHECK_TYPE(XPATH_NUMBER); 9062 start = valuePop(ctxt); 9063 in = start->floatval; 9064 xmlXPathReleaseObject(ctxt->context, start); 9065 CAST_TO_STRING; 9066 CHECK_TYPE(XPATH_STRING); 9067 str = valuePop(ctxt); 9068 m = xmlUTF8Strlen((const unsigned char *)str->stringval); 9069 9070 /* 9071 * If last pos not present, calculate last position 9072 */ 9073 if (nargs != 3) { 9074 le = (double)m; 9075 if (in < 1.0) 9076 in = 1.0; 9077 } 9078 9079 /* Need to check for the special cases where either 9080 * the index is NaN, the length is NaN, or both 9081 * arguments are infinity (relying on Inf + -Inf = NaN) 9082 */ 9083 if (!xmlXPathIsInf(in) && !xmlXPathIsNaN(in + le)) { 9084 /* 9085 * To meet the requirements of the spec, the arguments 9086 * must be converted to integer format before 9087 * initial index calculations are done 9088 * 9089 * First we go to integer form, rounding up 9090 * and checking for special cases 9091 */ 9092 i = (int) in; 9093 if (((double)i)+0.5 <= in) i++; 9094 9095 if (xmlXPathIsInf(le) == 1) { 9096 l = m; 9097 if (i < 1) 9098 i = 1; 9099 } 9100 else if (xmlXPathIsInf(le) == -1 || le < 0.0) 9101 l = 0; 9102 else { 9103 l = (int) le; 9104 if (((double)l)+0.5 <= le) l++; 9105 } 9106 9107 /* Now we normalize inidices */ 9108 i -= 1; 9109 l += i; 9110 if (i < 0) 9111 i = 0; 9112 if (l > m) 9113 l = m; 9114 9115 /* number of chars to copy */ 9116 l -= i; 9117 9118 ret = xmlUTF8Strsub(str->stringval, i, l); 9119 } 9120 else { 9121 ret = NULL; 9122 } 9123 if (ret == NULL) 9124 valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, "")); 9125 else { 9126 valuePush(ctxt, xmlXPathCacheNewString(ctxt->context, ret)); 9127 xmlFree(ret); 9128 } 9129 xmlXPathReleaseObject(ctxt->context, str); 9130 } 9131 9132 /** 9133 * xmlXPathSubstringBeforeFunction: 9134 * @ctxt: the XPath Parser context 9135 * @nargs: the number of arguments 9136 * 9137 * Implement the substring-before() XPath function 9138 * string substring-before(string, string) 9139 * The substring-before function returns the substring of the first 9140 * argument string that precedes the first occurrence of the second 9141 * argument string in the first argument string, or the empty string 9142 * if the first argument string does not contain the second argument 9143 * string. For example, substring-before("1999/04/01","/") returns 1999. 9144 */ 9145 void 9146 xmlXPathSubstringBeforeFunction(xmlXPathParserContextPtr ctxt, int nargs) { 9147 xmlXPathObjectPtr str; 9148 xmlXPathObjectPtr find; 9149 xmlBufferPtr target; 9150 const xmlChar *point; 9151 int offset; 9152 9153 CHECK_ARITY(2); 9154 CAST_TO_STRING; 9155 find = valuePop(ctxt); 9156 CAST_TO_STRING; 9157 str = valuePop(ctxt); 9158 9159 target = xmlBufferCreate(); 9160 if (target) { 9161 point = xmlStrstr(str->stringval, find->stringval); 9162 if (point) { 9163 offset = (int)(point - str->stringval); 9164 xmlBufferAdd(target, str->stringval, offset); 9165 } 9166 valuePush(ctxt, xmlXPathCacheNewString(ctxt->context, 9167 xmlBufferContent(target))); 9168 xmlBufferFree(target); 9169 } 9170 xmlXPathReleaseObject(ctxt->context, str); 9171 xmlXPathReleaseObject(ctxt->context, find); 9172 } 9173 9174 /** 9175 * xmlXPathSubstringAfterFunction: 9176 * @ctxt: the XPath Parser context 9177 * @nargs: the number of arguments 9178 * 9179 * Implement the substring-after() XPath function 9180 * string substring-after(string, string) 9181 * The substring-after function returns the substring of the first 9182 * argument string that follows the first occurrence of the second 9183 * argument string in the first argument string, or the empty stringi 9184 * if the first argument string does not contain the second argument 9185 * string. For example, substring-after("1999/04/01","/") returns 04/01, 9186 * and substring-after("1999/04/01","19") returns 99/04/01. 9187 */ 9188 void 9189 xmlXPathSubstringAfterFunction(xmlXPathParserContextPtr ctxt, int nargs) { 9190 xmlXPathObjectPtr str; 9191 xmlXPathObjectPtr find; 9192 xmlBufferPtr target; 9193 const xmlChar *point; 9194 int offset; 9195 9196 CHECK_ARITY(2); 9197 CAST_TO_STRING; 9198 find = valuePop(ctxt); 9199 CAST_TO_STRING; 9200 str = valuePop(ctxt); 9201 9202 target = xmlBufferCreate(); 9203 if (target) { 9204 point = xmlStrstr(str->stringval, find->stringval); 9205 if (point) { 9206 offset = (int)(point - str->stringval) + xmlStrlen(find->stringval); 9207 xmlBufferAdd(target, &str->stringval[offset], 9208 xmlStrlen(str->stringval) - offset); 9209 } 9210 valuePush(ctxt, xmlXPathCacheNewString(ctxt->context, 9211 xmlBufferContent(target))); 9212 xmlBufferFree(target); 9213 } 9214 xmlXPathReleaseObject(ctxt->context, str); 9215 xmlXPathReleaseObject(ctxt->context, find); 9216 } 9217 9218 /** 9219 * xmlXPathNormalizeFunction: 9220 * @ctxt: the XPath Parser context 9221 * @nargs: the number of arguments 9222 * 9223 * Implement the normalize-space() XPath function 9224 * string normalize-space(string?) 9225 * The normalize-space function returns the argument string with white 9226 * space normalized by stripping leading and trailing whitespace 9227 * and replacing sequences of whitespace characters by a single 9228 * space. Whitespace characters are the same allowed by the S production 9229 * in XML. If the argument is omitted, it defaults to the context 9230 * node converted to a string, in other words the value of the context node. 9231 */ 9232 void 9233 xmlXPathNormalizeFunction(xmlXPathParserContextPtr ctxt, int nargs) { 9234 xmlXPathObjectPtr obj = NULL; 9235 xmlChar *source = NULL; 9236 xmlBufferPtr target; 9237 xmlChar blank; 9238 9239 if (ctxt == NULL) return; 9240 if (nargs == 0) { 9241 /* Use current context node */ 9242 valuePush(ctxt, 9243 xmlXPathCacheWrapString(ctxt->context, 9244 xmlXPathCastNodeToString(ctxt->context->node))); 9245 nargs = 1; 9246 } 9247 9248 CHECK_ARITY(1); 9249 CAST_TO_STRING; 9250 CHECK_TYPE(XPATH_STRING); 9251 obj = valuePop(ctxt); 9252 source = obj->stringval; 9253 9254 target = xmlBufferCreate(); 9255 if (target && source) { 9256 9257 /* Skip leading whitespaces */ 9258 while (IS_BLANK_CH(*source)) 9259 source++; 9260 9261 /* Collapse intermediate whitespaces, and skip trailing whitespaces */ 9262 blank = 0; 9263 while (*source) { 9264 if (IS_BLANK_CH(*source)) { 9265 blank = 0x20; 9266 } else { 9267 if (blank) { 9268 xmlBufferAdd(target, &blank, 1); 9269 blank = 0; 9270 } 9271 xmlBufferAdd(target, source, 1); 9272 } 9273 source++; 9274 } 9275 valuePush(ctxt, xmlXPathCacheNewString(ctxt->context, 9276 xmlBufferContent(target))); 9277 xmlBufferFree(target); 9278 } 9279 xmlXPathReleaseObject(ctxt->context, obj); 9280 } 9281 9282 /** 9283 * xmlXPathTranslateFunction: 9284 * @ctxt: the XPath Parser context 9285 * @nargs: the number of arguments 9286 * 9287 * Implement the translate() XPath function 9288 * string translate(string, string, string) 9289 * The translate function returns the first argument string with 9290 * occurrences of characters in the second argument string replaced 9291 * by the character at the corresponding position in the third argument 9292 * string. For example, translate("bar","abc","ABC") returns the string 9293 * BAr. If there is a character in the second argument string with no 9294 * character at a corresponding position in the third argument string 9295 * (because the second argument string is longer than the third argument 9296 * string), then occurrences of that character in the first argument 9297 * string are removed. For example, translate("--aaa--","abc-","ABC") 9298 * returns "AAA". If a character occurs more than once in second 9299 * argument string, then the first occurrence determines the replacement 9300 * character. If the third argument string is longer than the second 9301 * argument string, then excess characters are ignored. 9302 */ 9303 void 9304 xmlXPathTranslateFunction(xmlXPathParserContextPtr ctxt, int nargs) { 9305 xmlXPathObjectPtr str; 9306 xmlXPathObjectPtr from; 9307 xmlXPathObjectPtr to; 9308 xmlBufferPtr target; 9309 int offset, max; 9310 xmlChar ch; 9311 const xmlChar *point; 9312 xmlChar *cptr; 9313 9314 CHECK_ARITY(3); 9315 9316 CAST_TO_STRING; 9317 to = valuePop(ctxt); 9318 CAST_TO_STRING; 9319 from = valuePop(ctxt); 9320 CAST_TO_STRING; 9321 str = valuePop(ctxt); 9322 9323 target = xmlBufferCreate(); 9324 if (target) { 9325 max = xmlUTF8Strlen(to->stringval); 9326 for (cptr = str->stringval; (ch=*cptr); ) { 9327 offset = xmlUTF8Strloc(from->stringval, cptr); 9328 if (offset >= 0) { 9329 if (offset < max) { 9330 point = xmlUTF8Strpos(to->stringval, offset); 9331 if (point) 9332 xmlBufferAdd(target, point, xmlUTF8Strsize(point, 1)); 9333 } 9334 } else 9335 xmlBufferAdd(target, cptr, xmlUTF8Strsize(cptr, 1)); 9336 9337 /* Step to next character in input */ 9338 cptr++; 9339 if ( ch & 0x80 ) { 9340 /* if not simple ascii, verify proper format */ 9341 if ( (ch & 0xc0) != 0xc0 ) { 9342 xmlGenericError(xmlGenericErrorContext, 9343 "xmlXPathTranslateFunction: Invalid UTF8 string\n"); 9344 /* not asserting an XPath error is probably better */ 9345 break; 9346 } 9347 /* then skip over remaining bytes for this char */ 9348 while ( (ch <<= 1) & 0x80 ) 9349 if ( (*cptr++ & 0xc0) != 0x80 ) { 9350 xmlGenericError(xmlGenericErrorContext, 9351 "xmlXPathTranslateFunction: Invalid UTF8 string\n"); 9352 /* not asserting an XPath error is probably better */ 9353 break; 9354 } 9355 if (ch & 0x80) /* must have had error encountered */ 9356 break; 9357 } 9358 } 9359 } 9360 valuePush(ctxt, xmlXPathCacheNewString(ctxt->context, 9361 xmlBufferContent(target))); 9362 xmlBufferFree(target); 9363 xmlXPathReleaseObject(ctxt->context, str); 9364 xmlXPathReleaseObject(ctxt->context, from); 9365 xmlXPathReleaseObject(ctxt->context, to); 9366 } 9367 9368 /** 9369 * xmlXPathBooleanFunction: 9370 * @ctxt: the XPath Parser context 9371 * @nargs: the number of arguments 9372 * 9373 * Implement the boolean() XPath function 9374 * boolean boolean(object) 9375 * The boolean function converts its argument to a boolean as follows: 9376 * - a number is true if and only if it is neither positive or 9377 * negative zero nor NaN 9378 * - a node-set is true if and only if it is non-empty 9379 * - a string is true if and only if its length is non-zero 9380 */ 9381 void 9382 xmlXPathBooleanFunction(xmlXPathParserContextPtr ctxt, int nargs) { 9383 xmlXPathObjectPtr cur; 9384 9385 CHECK_ARITY(1); 9386 cur = valuePop(ctxt); 9387 if (cur == NULL) XP_ERROR(XPATH_INVALID_OPERAND); 9388 cur = xmlXPathCacheConvertBoolean(ctxt->context, cur); 9389 valuePush(ctxt, cur); 9390 } 9391 9392 /** 9393 * xmlXPathNotFunction: 9394 * @ctxt: the XPath Parser context 9395 * @nargs: the number of arguments 9396 * 9397 * Implement the not() XPath function 9398 * boolean not(boolean) 9399 * The not function returns true if its argument is false, 9400 * and false otherwise. 9401 */ 9402 void 9403 xmlXPathNotFunction(xmlXPathParserContextPtr ctxt, int nargs) { 9404 CHECK_ARITY(1); 9405 CAST_TO_BOOLEAN; 9406 CHECK_TYPE(XPATH_BOOLEAN); 9407 ctxt->value->boolval = ! ctxt->value->boolval; 9408 } 9409 9410 /** 9411 * xmlXPathTrueFunction: 9412 * @ctxt: the XPath Parser context 9413 * @nargs: the number of arguments 9414 * 9415 * Implement the true() XPath function 9416 * boolean true() 9417 */ 9418 void 9419 xmlXPathTrueFunction(xmlXPathParserContextPtr ctxt, int nargs) { 9420 CHECK_ARITY(0); 9421 valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, 1)); 9422 } 9423 9424 /** 9425 * xmlXPathFalseFunction: 9426 * @ctxt: the XPath Parser context 9427 * @nargs: the number of arguments 9428 * 9429 * Implement the false() XPath function 9430 * boolean false() 9431 */ 9432 void 9433 xmlXPathFalseFunction(xmlXPathParserContextPtr ctxt, int nargs) { 9434 CHECK_ARITY(0); 9435 valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, 0)); 9436 } 9437 9438 /** 9439 * xmlXPathLangFunction: 9440 * @ctxt: the XPath Parser context 9441 * @nargs: the number of arguments 9442 * 9443 * Implement the lang() XPath function 9444 * boolean lang(string) 9445 * The lang function returns true or false depending on whether the 9446 * language of the context node as specified by xml:lang attributes 9447 * is the same as or is a sublanguage of the language specified by 9448 * the argument string. The language of the context node is determined 9449 * by the value of the xml:lang attribute on the context node, or, if 9450 * the context node has no xml:lang attribute, by the value of the 9451 * xml:lang attribute on the nearest ancestor of the context node that 9452 * has an xml:lang attribute. If there is no such attribute, then lang 9453 * returns false. If there is such an attribute, then lang returns 9454 * true if the attribute value is equal to the argument ignoring case, 9455 * or if there is some suffix starting with - such that the attribute 9456 * value is equal to the argument ignoring that suffix of the attribute 9457 * value and ignoring case. 9458 */ 9459 void 9460 xmlXPathLangFunction(xmlXPathParserContextPtr ctxt, int nargs) { 9461 xmlXPathObjectPtr val = NULL; 9462 const xmlChar *theLang = NULL; 9463 const xmlChar *lang; 9464 int ret = 0; 9465 int i; 9466 9467 CHECK_ARITY(1); 9468 CAST_TO_STRING; 9469 CHECK_TYPE(XPATH_STRING); 9470 val = valuePop(ctxt); 9471 lang = val->stringval; 9472 theLang = xmlNodeGetLang(ctxt->context->node); 9473 if ((theLang != NULL) && (lang != NULL)) { 9474 for (i = 0;lang[i] != 0;i++) 9475 if (toupper(lang[i]) != toupper(theLang[i])) 9476 goto not_equal; 9477 if ((theLang[i] == 0) || (theLang[i] == '-')) 9478 ret = 1; 9479 } 9480 not_equal: 9481 if (theLang != NULL) 9482 xmlFree((void *)theLang); 9483 9484 xmlXPathReleaseObject(ctxt->context, val); 9485 valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, ret)); 9486 } 9487 9488 /** 9489 * xmlXPathNumberFunction: 9490 * @ctxt: the XPath Parser context 9491 * @nargs: the number of arguments 9492 * 9493 * Implement the number() XPath function 9494 * number number(object?) 9495 */ 9496 void 9497 xmlXPathNumberFunction(xmlXPathParserContextPtr ctxt, int nargs) { 9498 xmlXPathObjectPtr cur; 9499 double res; 9500 9501 if (ctxt == NULL) return; 9502 if (nargs == 0) { 9503 if (ctxt->context->node == NULL) { 9504 valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, 0.0)); 9505 } else { 9506 xmlChar* content = xmlNodeGetContent(ctxt->context->node); 9507 9508 res = xmlXPathStringEvalNumber(content); 9509 valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, res)); 9510 xmlFree(content); 9511 } 9512 return; 9513 } 9514 9515 CHECK_ARITY(1); 9516 cur = valuePop(ctxt); 9517 valuePush(ctxt, xmlXPathCacheConvertNumber(ctxt->context, cur)); 9518 } 9519 9520 /** 9521 * xmlXPathSumFunction: 9522 * @ctxt: the XPath Parser context 9523 * @nargs: the number of arguments 9524 * 9525 * Implement the sum() XPath function 9526 * number sum(node-set) 9527 * The sum function returns the sum of the values of the nodes in 9528 * the argument node-set. 9529 */ 9530 void 9531 xmlXPathSumFunction(xmlXPathParserContextPtr ctxt, int nargs) { 9532 xmlXPathObjectPtr cur; 9533 int i; 9534 double res = 0.0; 9535 9536 CHECK_ARITY(1); 9537 if ((ctxt->value == NULL) || 9538 ((ctxt->value->type != XPATH_NODESET) && 9539 (ctxt->value->type != XPATH_XSLT_TREE))) 9540 XP_ERROR(XPATH_INVALID_TYPE); 9541 cur = valuePop(ctxt); 9542 9543 if ((cur->nodesetval != NULL) && (cur->nodesetval->nodeNr != 0)) { 9544 for (i = 0; i < cur->nodesetval->nodeNr; i++) { 9545 res += xmlXPathCastNodeToNumber(cur->nodesetval->nodeTab[i]); 9546 } 9547 } 9548 valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, res)); 9549 xmlXPathReleaseObject(ctxt->context, cur); 9550 } 9551 9552 /* 9553 * To assure working code on multiple platforms, we want to only depend 9554 * upon the characteristic truncation of converting a floating point value 9555 * to an integer. Unfortunately, because of the different storage sizes 9556 * of our internal floating point value (double) and integer (int), we 9557 * can't directly convert (see bug 301162). This macro is a messy 9558 * 'workaround' 9559 */ 9560 #define XTRUNC(f, v) \ 9561 f = fmod((v), INT_MAX); \ 9562 f = (v) - (f) + (double)((int)(f)); 9563 9564 /** 9565 * xmlXPathFloorFunction: 9566 * @ctxt: the XPath Parser context 9567 * @nargs: the number of arguments 9568 * 9569 * Implement the floor() XPath function 9570 * number floor(number) 9571 * The floor function returns the largest (closest to positive infinity) 9572 * number that is not greater than the argument and that is an integer. 9573 */ 9574 void 9575 xmlXPathFloorFunction(xmlXPathParserContextPtr ctxt, int nargs) { 9576 double f; 9577 9578 CHECK_ARITY(1); 9579 CAST_TO_NUMBER; 9580 CHECK_TYPE(XPATH_NUMBER); 9581 9582 XTRUNC(f, ctxt->value->floatval); 9583 if (f != ctxt->value->floatval) { 9584 if (ctxt->value->floatval > 0) 9585 ctxt->value->floatval = f; 9586 else 9587 ctxt->value->floatval = f - 1; 9588 } 9589 } 9590 9591 /** 9592 * xmlXPathCeilingFunction: 9593 * @ctxt: the XPath Parser context 9594 * @nargs: the number of arguments 9595 * 9596 * Implement the ceiling() XPath function 9597 * number ceiling(number) 9598 * The ceiling function returns the smallest (closest to negative infinity) 9599 * number that is not less than the argument and that is an integer. 9600 */ 9601 void 9602 xmlXPathCeilingFunction(xmlXPathParserContextPtr ctxt, int nargs) { 9603 double f; 9604 9605 CHECK_ARITY(1); 9606 CAST_TO_NUMBER; 9607 CHECK_TYPE(XPATH_NUMBER); 9608 9609 #if 0 9610 ctxt->value->floatval = ceil(ctxt->value->floatval); 9611 #else 9612 XTRUNC(f, ctxt->value->floatval); 9613 if (f != ctxt->value->floatval) { 9614 if (ctxt->value->floatval > 0) 9615 ctxt->value->floatval = f + 1; 9616 else { 9617 if (ctxt->value->floatval < 0 && f == 0) 9618 ctxt->value->floatval = xmlXPathNZERO; 9619 else 9620 ctxt->value->floatval = f; 9621 } 9622 9623 } 9624 #endif 9625 } 9626 9627 /** 9628 * xmlXPathRoundFunction: 9629 * @ctxt: the XPath Parser context 9630 * @nargs: the number of arguments 9631 * 9632 * Implement the round() XPath function 9633 * number round(number) 9634 * The round function returns the number that is closest to the 9635 * argument and that is an integer. If there are two such numbers, 9636 * then the one that is even is returned. 9637 */ 9638 void 9639 xmlXPathRoundFunction(xmlXPathParserContextPtr ctxt, int nargs) { 9640 double f; 9641 9642 CHECK_ARITY(1); 9643 CAST_TO_NUMBER; 9644 CHECK_TYPE(XPATH_NUMBER); 9645 9646 if ((xmlXPathIsNaN(ctxt->value->floatval)) || 9647 (xmlXPathIsInf(ctxt->value->floatval) == 1) || 9648 (xmlXPathIsInf(ctxt->value->floatval) == -1) || 9649 (ctxt->value->floatval == 0.0)) 9650 return; 9651 9652 XTRUNC(f, ctxt->value->floatval); 9653 if (ctxt->value->floatval < 0) { 9654 if (ctxt->value->floatval < f - 0.5) 9655 ctxt->value->floatval = f - 1; 9656 else 9657 ctxt->value->floatval = f; 9658 if (ctxt->value->floatval == 0) 9659 ctxt->value->floatval = xmlXPathNZERO; 9660 } else { 9661 if (ctxt->value->floatval < f + 0.5) 9662 ctxt->value->floatval = f; 9663 else 9664 ctxt->value->floatval = f + 1; 9665 } 9666 } 9667 9668 /************************************************************************ 9669 * * 9670 * The Parser * 9671 * * 9672 ************************************************************************/ 9673 9674 /* 9675 * a few forward declarations since we use a recursive call based 9676 * implementation. 9677 */ 9678 static void xmlXPathCompileExpr(xmlXPathParserContextPtr ctxt, int sort); 9679 static void xmlXPathCompPredicate(xmlXPathParserContextPtr ctxt, int filter); 9680 static void xmlXPathCompLocationPath(xmlXPathParserContextPtr ctxt); 9681 static void xmlXPathCompRelativeLocationPath(xmlXPathParserContextPtr ctxt); 9682 static xmlChar * xmlXPathParseNameComplex(xmlXPathParserContextPtr ctxt, 9683 int qualified); 9684 9685 /** 9686 * xmlXPathCurrentChar: 9687 * @ctxt: the XPath parser context 9688 * @cur: pointer to the beginning of the char 9689 * @len: pointer to the length of the char read 9690 * 9691 * The current char value, if using UTF-8 this may actually span multiple 9692 * bytes in the input buffer. 9693 * 9694 * Returns the current char value and its length 9695 */ 9696 9697 static int 9698 xmlXPathCurrentChar(xmlXPathParserContextPtr ctxt, int *len) { 9699 unsigned char c; 9700 unsigned int val; 9701 const xmlChar *cur; 9702 9703 if (ctxt == NULL) 9704 return(0); 9705 cur = ctxt->cur; 9706 9707 /* 9708 * We are supposed to handle UTF8, check it's valid 9709 * From rfc2044: encoding of the Unicode values on UTF-8: 9710 * 9711 * UCS-4 range (hex.) UTF-8 octet sequence (binary) 9712 * 0000 0000-0000 007F 0xxxxxxx 9713 * 0000 0080-0000 07FF 110xxxxx 10xxxxxx 9714 * 0000 0800-0000 FFFF 1110xxxx 10xxxxxx 10xxxxxx 9715 * 9716 * Check for the 0x110000 limit too 9717 */ 9718 c = *cur; 9719 if (c & 0x80) { 9720 if ((cur[1] & 0xc0) != 0x80) 9721 goto encoding_error; 9722 if ((c & 0xe0) == 0xe0) { 9723 9724 if ((cur[2] & 0xc0) != 0x80) 9725 goto encoding_error; 9726 if ((c & 0xf0) == 0xf0) { 9727 if (((c & 0xf8) != 0xf0) || 9728 ((cur[3] & 0xc0) != 0x80)) 9729 goto encoding_error; 9730 /* 4-byte code */ 9731 *len = 4; 9732 val = (cur[0] & 0x7) << 18; 9733 val |= (cur[1] & 0x3f) << 12; 9734 val |= (cur[2] & 0x3f) << 6; 9735 val |= cur[3] & 0x3f; 9736 } else { 9737 /* 3-byte code */ 9738 *len = 3; 9739 val = (cur[0] & 0xf) << 12; 9740 val |= (cur[1] & 0x3f) << 6; 9741 val |= cur[2] & 0x3f; 9742 } 9743 } else { 9744 /* 2-byte code */ 9745 *len = 2; 9746 val = (cur[0] & 0x1f) << 6; 9747 val |= cur[1] & 0x3f; 9748 } 9749 if (!IS_CHAR(val)) { 9750 XP_ERROR0(XPATH_INVALID_CHAR_ERROR); 9751 } 9752 return(val); 9753 } else { 9754 /* 1-byte code */ 9755 *len = 1; 9756 return((int) *cur); 9757 } 9758 encoding_error: 9759 /* 9760 * If we detect an UTF8 error that probably means that the 9761 * input encoding didn't get properly advertised in the 9762 * declaration header. Report the error and switch the encoding 9763 * to ISO-Latin-1 (if you don't like this policy, just declare the 9764 * encoding !) 9765 */ 9766 *len = 0; 9767 XP_ERROR0(XPATH_ENCODING_ERROR); 9768 } 9769 9770 /** 9771 * xmlXPathParseNCName: 9772 * @ctxt: the XPath Parser context 9773 * 9774 * parse an XML namespace non qualified name. 9775 * 9776 * [NS 3] NCName ::= (Letter | '_') (NCNameChar)* 9777 * 9778 * [NS 4] NCNameChar ::= Letter | Digit | '.' | '-' | '_' | 9779 * CombiningChar | Extender 9780 * 9781 * Returns the namespace name or NULL 9782 */ 9783 9784 xmlChar * 9785 xmlXPathParseNCName(xmlXPathParserContextPtr ctxt) { 9786 const xmlChar *in; 9787 xmlChar *ret; 9788 int count = 0; 9789 9790 if ((ctxt == NULL) || (ctxt->cur == NULL)) return(NULL); 9791 /* 9792 * Accelerator for simple ASCII names 9793 */ 9794 in = ctxt->cur; 9795 if (((*in >= 0x61) && (*in <= 0x7A)) || 9796 ((*in >= 0x41) && (*in <= 0x5A)) || 9797 (*in == '_')) { 9798 in++; 9799 while (((*in >= 0x61) && (*in <= 0x7A)) || 9800 ((*in >= 0x41) && (*in <= 0x5A)) || 9801 ((*in >= 0x30) && (*in <= 0x39)) || 9802 (*in == '_') || (*in == '.') || 9803 (*in == '-')) 9804 in++; 9805 if ((*in == ' ') || (*in == '>') || (*in == '/') || 9806 (*in == '[') || (*in == ']') || (*in == ':') || 9807 (*in == '@') || (*in == '*')) { 9808 count = in - ctxt->cur; 9809 if (count == 0) 9810 return(NULL); 9811 ret = xmlStrndup(ctxt->cur, count); 9812 ctxt->cur = in; 9813 return(ret); 9814 } 9815 } 9816 return(xmlXPathParseNameComplex(ctxt, 0)); 9817 } 9818 9819 9820 /** 9821 * xmlXPathParseQName: 9822 * @ctxt: the XPath Parser context 9823 * @prefix: a xmlChar ** 9824 * 9825 * parse an XML qualified name 9826 * 9827 * [NS 5] QName ::= (Prefix ':')? LocalPart 9828 * 9829 * [NS 6] Prefix ::= NCName 9830 * 9831 * [NS 7] LocalPart ::= NCName 9832 * 9833 * Returns the function returns the local part, and prefix is updated 9834 * to get the Prefix if any. 9835 */ 9836 9837 static xmlChar * 9838 xmlXPathParseQName(xmlXPathParserContextPtr ctxt, xmlChar **prefix) { 9839 xmlChar *ret = NULL; 9840 9841 *prefix = NULL; 9842 ret = xmlXPathParseNCName(ctxt); 9843 if (ret && CUR == ':') { 9844 *prefix = ret; 9845 NEXT; 9846 ret = xmlXPathParseNCName(ctxt); 9847 } 9848 return(ret); 9849 } 9850 9851 /** 9852 * xmlXPathParseName: 9853 * @ctxt: the XPath Parser context 9854 * 9855 * parse an XML name 9856 * 9857 * [4] NameChar ::= Letter | Digit | '.' | '-' | '_' | ':' | 9858 * CombiningChar | Extender 9859 * 9860 * [5] Name ::= (Letter | '_' | ':') (NameChar)* 9861 * 9862 * Returns the namespace name or NULL 9863 */ 9864 9865 xmlChar * 9866 xmlXPathParseName(xmlXPathParserContextPtr ctxt) { 9867 const xmlChar *in; 9868 xmlChar *ret; 9869 int count = 0; 9870 9871 if ((ctxt == NULL) || (ctxt->cur == NULL)) return(NULL); 9872 /* 9873 * Accelerator for simple ASCII names 9874 */ 9875 in = ctxt->cur; 9876 if (((*in >= 0x61) && (*in <= 0x7A)) || 9877 ((*in >= 0x41) && (*in <= 0x5A)) || 9878 (*in == '_') || (*in == ':')) { 9879 in++; 9880 while (((*in >= 0x61) && (*in <= 0x7A)) || 9881 ((*in >= 0x41) && (*in <= 0x5A)) || 9882 ((*in >= 0x30) && (*in <= 0x39)) || 9883 (*in == '_') || (*in == '-') || 9884 (*in == ':') || (*in == '.')) 9885 in++; 9886 if ((*in > 0) && (*in < 0x80)) { 9887 count = in - ctxt->cur; 9888 ret = xmlStrndup(ctxt->cur, count); 9889 ctxt->cur = in; 9890 return(ret); 9891 } 9892 } 9893 return(xmlXPathParseNameComplex(ctxt, 1)); 9894 } 9895 9896 static xmlChar * 9897 xmlXPathParseNameComplex(xmlXPathParserContextPtr ctxt, int qualified) { 9898 xmlChar buf[XML_MAX_NAMELEN + 5]; 9899 int len = 0, l; 9900 int c; 9901 9902 /* 9903 * Handler for more complex cases 9904 */ 9905 c = CUR_CHAR(l); 9906 if ((c == ' ') || (c == '>') || (c == '/') || /* accelerators */ 9907 (c == '[') || (c == ']') || (c == '@') || /* accelerators */ 9908 (c == '*') || /* accelerators */ 9909 (!IS_LETTER(c) && (c != '_') && 9910 ((qualified) && (c != ':')))) { 9911 return(NULL); 9912 } 9913 9914 while ((c != ' ') && (c != '>') && (c != '/') && /* test bigname.xml */ 9915 ((IS_LETTER(c)) || (IS_DIGIT(c)) || 9916 (c == '.') || (c == '-') || 9917 (c == '_') || ((qualified) && (c == ':')) || 9918 (IS_COMBINING(c)) || 9919 (IS_EXTENDER(c)))) { 9920 COPY_BUF(l,buf,len,c); 9921 NEXTL(l); 9922 c = CUR_CHAR(l); 9923 if (len >= XML_MAX_NAMELEN) { 9924 /* 9925 * Okay someone managed to make a huge name, so he's ready to pay 9926 * for the processing speed. 9927 */ 9928 xmlChar *buffer; 9929 int max = len * 2; 9930 9931 buffer = (xmlChar *) xmlMallocAtomic(max * sizeof(xmlChar)); 9932 if (buffer == NULL) { 9933 XP_ERRORNULL(XPATH_MEMORY_ERROR); 9934 } 9935 memcpy(buffer, buf, len); 9936 while ((IS_LETTER(c)) || (IS_DIGIT(c)) || /* test bigname.xml */ 9937 (c == '.') || (c == '-') || 9938 (c == '_') || ((qualified) && (c == ':')) || 9939 (IS_COMBINING(c)) || 9940 (IS_EXTENDER(c))) { 9941 if (len + 10 > max) { 9942 max *= 2; 9943 buffer = (xmlChar *) xmlRealloc(buffer, 9944 max * sizeof(xmlChar)); 9945 if (buffer == NULL) { 9946 XP_ERRORNULL(XPATH_MEMORY_ERROR); 9947 } 9948 } 9949 COPY_BUF(l,buffer,len,c); 9950 NEXTL(l); 9951 c = CUR_CHAR(l); 9952 } 9953 buffer[len] = 0; 9954 return(buffer); 9955 } 9956 } 9957 if (len == 0) 9958 return(NULL); 9959 return(xmlStrndup(buf, len)); 9960 } 9961 9962 #define MAX_FRAC 20 9963 9964 /* 9965 * These are used as divisors for the fractional part of a number. 9966 * Since the table includes 1.0 (representing '0' fractional digits), 9967 * it must be dimensioned at MAX_FRAC+1 (bug 133921) 9968 */ 9969 static double my_pow10[MAX_FRAC+1] = { 9970 1.0, 10.0, 100.0, 1000.0, 10000.0, 9971 100000.0, 1000000.0, 10000000.0, 100000000.0, 1000000000.0, 9972 10000000000.0, 100000000000.0, 1000000000000.0, 10000000000000.0, 9973 100000000000000.0, 9974 1000000000000000.0, 10000000000000000.0, 100000000000000000.0, 9975 1000000000000000000.0, 10000000000000000000.0, 100000000000000000000.0 9976 }; 9977 9978 /** 9979 * xmlXPathStringEvalNumber: 9980 * @str: A string to scan 9981 * 9982 * [30a] Float ::= Number ('e' Digits?)? 9983 * 9984 * [30] Number ::= Digits ('.' Digits?)? 9985 * | '.' Digits 9986 * [31] Digits ::= [0-9]+ 9987 * 9988 * Compile a Number in the string 9989 * In complement of the Number expression, this function also handles 9990 * negative values : '-' Number. 9991 * 9992 * Returns the double value. 9993 */ 9994 double 9995 xmlXPathStringEvalNumber(const xmlChar *str) { 9996 const xmlChar *cur = str; 9997 double ret; 9998 int ok = 0; 9999 int isneg = 0; 10000 int exponent = 0; 10001 int is_exponent_negative = 0; 10002 #ifdef __GNUC__ 10003 unsigned long tmp = 0; 10004 double temp; 10005 #endif 10006 if (cur == NULL) return(0); 10007 while (IS_BLANK_CH(*cur)) cur++; 10008 if ((*cur != '.') && ((*cur < '0') || (*cur > '9')) && (*cur != '-')) { 10009 return(xmlXPathNAN); 10010 } 10011 if (*cur == '-') { 10012 isneg = 1; 10013 cur++; 10014 } 10015 10016 #ifdef __GNUC__ 10017 /* 10018 * tmp/temp is a workaround against a gcc compiler bug 10019 * http://veillard.com/gcc.bug 10020 */ 10021 ret = 0; 10022 while ((*cur >= '0') && (*cur <= '9')) { 10023 ret = ret * 10; 10024 tmp = (*cur - '0'); 10025 ok = 1; 10026 cur++; 10027 temp = (double) tmp; 10028 ret = ret + temp; 10029 } 10030 #else 10031 ret = 0; 10032 while ((*cur >= '0') && (*cur <= '9')) { 10033 ret = ret * 10 + (*cur - '0'); 10034 ok = 1; 10035 cur++; 10036 } 10037 #endif 10038 10039 if (*cur == '.') { 10040 int v, frac = 0; 10041 double fraction = 0; 10042 10043 cur++; 10044 if (((*cur < '0') || (*cur > '9')) && (!ok)) { 10045 return(xmlXPathNAN); 10046 } 10047 while (((*cur >= '0') && (*cur <= '9')) && (frac < MAX_FRAC)) { 10048 v = (*cur - '0'); 10049 fraction = fraction * 10 + v; 10050 frac = frac + 1; 10051 cur++; 10052 } 10053 fraction /= my_pow10[frac]; 10054 ret = ret + fraction; 10055 while ((*cur >= '0') && (*cur <= '9')) 10056 cur++; 10057 } 10058 if ((*cur == 'e') || (*cur == 'E')) { 10059 cur++; 10060 if (*cur == '-') { 10061 is_exponent_negative = 1; 10062 cur++; 10063 } else if (*cur == '+') { 10064 cur++; 10065 } 10066 while ((*cur >= '0') && (*cur <= '9')) { 10067 exponent = exponent * 10 + (*cur - '0'); 10068 cur++; 10069 } 10070 } 10071 while (IS_BLANK_CH(*cur)) cur++; 10072 if (*cur != 0) return(xmlXPathNAN); 10073 if (isneg) ret = -ret; 10074 if (is_exponent_negative) exponent = -exponent; 10075 ret *= pow(10.0, (double)exponent); 10076 return(ret); 10077 } 10078 10079 /** 10080 * xmlXPathCompNumber: 10081 * @ctxt: the XPath Parser context 10082 * 10083 * [30] Number ::= Digits ('.' Digits?)? 10084 * | '.' Digits 10085 * [31] Digits ::= [0-9]+ 10086 * 10087 * Compile a Number, then push it on the stack 10088 * 10089 */ 10090 static void 10091 xmlXPathCompNumber(xmlXPathParserContextPtr ctxt) 10092 { 10093 double ret = 0.0; 10094 int ok = 0; 10095 int exponent = 0; 10096 int is_exponent_negative = 0; 10097 #ifdef __GNUC__ 10098 unsigned long tmp = 0; 10099 double temp; 10100 #endif 10101 10102 CHECK_ERROR; 10103 if ((CUR != '.') && ((CUR < '0') || (CUR > '9'))) { 10104 XP_ERROR(XPATH_NUMBER_ERROR); 10105 } 10106 #ifdef __GNUC__ 10107 /* 10108 * tmp/temp is a workaround against a gcc compiler bug 10109 * http://veillard.com/gcc.bug 10110 */ 10111 ret = 0; 10112 while ((CUR >= '0') && (CUR <= '9')) { 10113 ret = ret * 10; 10114 tmp = (CUR - '0'); 10115 ok = 1; 10116 NEXT; 10117 temp = (double) tmp; 10118 ret = ret + temp; 10119 } 10120 #else 10121 ret = 0; 10122 while ((CUR >= '0') && (CUR <= '9')) { 10123 ret = ret * 10 + (CUR - '0'); 10124 ok = 1; 10125 NEXT; 10126 } 10127 #endif 10128 if (CUR == '.') { 10129 int v, frac = 0; 10130 double fraction = 0; 10131 10132 NEXT; 10133 if (((CUR < '0') || (CUR > '9')) && (!ok)) { 10134 XP_ERROR(XPATH_NUMBER_ERROR); 10135 } 10136 while ((CUR >= '0') && (CUR <= '9') && (frac < MAX_FRAC)) { 10137 v = (CUR - '0'); 10138 fraction = fraction * 10 + v; 10139 frac = frac + 1; 10140 NEXT; 10141 } 10142 fraction /= my_pow10[frac]; 10143 ret = ret + fraction; 10144 while ((CUR >= '0') && (CUR <= '9')) 10145 NEXT; 10146 } 10147 if ((CUR == 'e') || (CUR == 'E')) { 10148 NEXT; 10149 if (CUR == '-') { 10150 is_exponent_negative = 1; 10151 NEXT; 10152 } else if (CUR == '+') { 10153 NEXT; 10154 } 10155 while ((CUR >= '0') && (CUR <= '9')) { 10156 exponent = exponent * 10 + (CUR - '0'); 10157 NEXT; 10158 } 10159 if (is_exponent_negative) 10160 exponent = -exponent; 10161 ret *= pow(10.0, (double) exponent); 10162 } 10163 PUSH_LONG_EXPR(XPATH_OP_VALUE, XPATH_NUMBER, 0, 0, 10164 xmlXPathCacheNewFloat(ctxt->context, ret), NULL); 10165 } 10166 10167 /** 10168 * xmlXPathParseLiteral: 10169 * @ctxt: the XPath Parser context 10170 * 10171 * Parse a Literal 10172 * 10173 * [29] Literal ::= '"' [^"]* '"' 10174 * | "'" [^']* "'" 10175 * 10176 * Returns the value found or NULL in case of error 10177 */ 10178 static xmlChar * 10179 xmlXPathParseLiteral(xmlXPathParserContextPtr ctxt) { 10180 const xmlChar *q; 10181 xmlChar *ret = NULL; 10182 10183 if (CUR == '"') { 10184 NEXT; 10185 q = CUR_PTR; 10186 while ((IS_CHAR_CH(CUR)) && (CUR != '"')) 10187 NEXT; 10188 if (!IS_CHAR_CH(CUR)) { 10189 XP_ERRORNULL(XPATH_UNFINISHED_LITERAL_ERROR); 10190 } else { 10191 ret = xmlStrndup(q, CUR_PTR - q); 10192 NEXT; 10193 } 10194 } else if (CUR == '\'') { 10195 NEXT; 10196 q = CUR_PTR; 10197 while ((IS_CHAR_CH(CUR)) && (CUR != '\'')) 10198 NEXT; 10199 if (!IS_CHAR_CH(CUR)) { 10200 XP_ERRORNULL(XPATH_UNFINISHED_LITERAL_ERROR); 10201 } else { 10202 ret = xmlStrndup(q, CUR_PTR - q); 10203 NEXT; 10204 } 10205 } else { 10206 XP_ERRORNULL(XPATH_START_LITERAL_ERROR); 10207 } 10208 return(ret); 10209 } 10210 10211 /** 10212 * xmlXPathCompLiteral: 10213 * @ctxt: the XPath Parser context 10214 * 10215 * Parse a Literal and push it on the stack. 10216 * 10217 * [29] Literal ::= '"' [^"]* '"' 10218 * | "'" [^']* "'" 10219 * 10220 * TODO: xmlXPathCompLiteral memory allocation could be improved. 10221 */ 10222 static void 10223 xmlXPathCompLiteral(xmlXPathParserContextPtr ctxt) { 10224 const xmlChar *q; 10225 xmlChar *ret = NULL; 10226 10227 if (CUR == '"') { 10228 NEXT; 10229 q = CUR_PTR; 10230 while ((IS_CHAR_CH(CUR)) && (CUR != '"')) 10231 NEXT; 10232 if (!IS_CHAR_CH(CUR)) { 10233 XP_ERROR(XPATH_UNFINISHED_LITERAL_ERROR); 10234 } else { 10235 ret = xmlStrndup(q, CUR_PTR - q); 10236 NEXT; 10237 } 10238 } else if (CUR == '\'') { 10239 NEXT; 10240 q = CUR_PTR; 10241 while ((IS_CHAR_CH(CUR)) && (CUR != '\'')) 10242 NEXT; 10243 if (!IS_CHAR_CH(CUR)) { 10244 XP_ERROR(XPATH_UNFINISHED_LITERAL_ERROR); 10245 } else { 10246 ret = xmlStrndup(q, CUR_PTR - q); 10247 NEXT; 10248 } 10249 } else { 10250 XP_ERROR(XPATH_START_LITERAL_ERROR); 10251 } 10252 if (ret == NULL) return; 10253 PUSH_LONG_EXPR(XPATH_OP_VALUE, XPATH_STRING, 0, 0, 10254 xmlXPathCacheNewString(ctxt->context, ret), NULL); 10255 xmlFree(ret); 10256 } 10257 10258 /** 10259 * xmlXPathCompVariableReference: 10260 * @ctxt: the XPath Parser context 10261 * 10262 * Parse a VariableReference, evaluate it and push it on the stack. 10263 * 10264 * The variable bindings consist of a mapping from variable names 10265 * to variable values. The value of a variable is an object, which can be 10266 * of any of the types that are possible for the value of an expression, 10267 * and may also be of additional types not specified here. 10268 * 10269 * Early evaluation is possible since: 10270 * The variable bindings [...] used to evaluate a subexpression are 10271 * always the same as those used to evaluate the containing expression. 10272 * 10273 * [36] VariableReference ::= '$' QName 10274 */ 10275 static void 10276 xmlXPathCompVariableReference(xmlXPathParserContextPtr ctxt) { 10277 xmlChar *name; 10278 xmlChar *prefix; 10279 10280 SKIP_BLANKS; 10281 if (CUR != '$') { 10282 XP_ERROR(XPATH_VARIABLE_REF_ERROR); 10283 } 10284 NEXT; 10285 name = xmlXPathParseQName(ctxt, &prefix); 10286 if (name == NULL) { 10287 XP_ERROR(XPATH_VARIABLE_REF_ERROR); 10288 } 10289 ctxt->comp->last = -1; 10290 PUSH_LONG_EXPR(XPATH_OP_VARIABLE, 0, 0, 0, 10291 name, prefix); 10292 SKIP_BLANKS; 10293 if ((ctxt->context != NULL) && (ctxt->context->flags & XML_XPATH_NOVAR)) { 10294 XP_ERROR(XPATH_UNDEF_VARIABLE_ERROR); 10295 } 10296 } 10297 10298 /** 10299 * xmlXPathIsNodeType: 10300 * @name: a name string 10301 * 10302 * Is the name given a NodeType one. 10303 * 10304 * [38] NodeType ::= 'comment' 10305 * | 'text' 10306 * | 'processing-instruction' 10307 * | 'node' 10308 * 10309 * Returns 1 if true 0 otherwise 10310 */ 10311 int 10312 xmlXPathIsNodeType(const xmlChar *name) { 10313 if (name == NULL) 10314 return(0); 10315 10316 if (xmlStrEqual(name, BAD_CAST "node")) 10317 return(1); 10318 if (xmlStrEqual(name, BAD_CAST "text")) 10319 return(1); 10320 if (xmlStrEqual(name, BAD_CAST "comment")) 10321 return(1); 10322 if (xmlStrEqual(name, BAD_CAST "processing-instruction")) 10323 return(1); 10324 return(0); 10325 } 10326 10327 /** 10328 * xmlXPathCompFunctionCall: 10329 * @ctxt: the XPath Parser context 10330 * 10331 * [16] FunctionCall ::= FunctionName '(' ( Argument ( ',' Argument)*)? ')' 10332 * [17] Argument ::= Expr 10333 * 10334 * Compile a function call, the evaluation of all arguments are 10335 * pushed on the stack 10336 */ 10337 static void 10338 xmlXPathCompFunctionCall(xmlXPathParserContextPtr ctxt) { 10339 xmlChar *name; 10340 xmlChar *prefix; 10341 int nbargs = 0; 10342 int sort = 1; 10343 10344 name = xmlXPathParseQName(ctxt, &prefix); 10345 if (name == NULL) { 10346 xmlFree(prefix); 10347 XP_ERROR(XPATH_EXPR_ERROR); 10348 } 10349 SKIP_BLANKS; 10350 #ifdef DEBUG_EXPR 10351 if (prefix == NULL) 10352 xmlGenericError(xmlGenericErrorContext, "Calling function %s\n", 10353 name); 10354 else 10355 xmlGenericError(xmlGenericErrorContext, "Calling function %s:%s\n", 10356 prefix, name); 10357 #endif 10358 10359 if (CUR != '(') { 10360 XP_ERROR(XPATH_EXPR_ERROR); 10361 } 10362 NEXT; 10363 SKIP_BLANKS; 10364 10365 /* 10366 * Optimization for count(): we don't need the node-set to be sorted. 10367 */ 10368 if ((prefix == NULL) && (name[0] == 'c') && 10369 xmlStrEqual(name, BAD_CAST "count")) 10370 { 10371 sort = 0; 10372 } 10373 ctxt->comp->last = -1; 10374 if (CUR != ')') { 10375 while (CUR != 0) { 10376 int op1 = ctxt->comp->last; 10377 ctxt->comp->last = -1; 10378 xmlXPathCompileExpr(ctxt, sort); 10379 if (ctxt->error != XPATH_EXPRESSION_OK) { 10380 xmlFree(name); 10381 xmlFree(prefix); 10382 return; 10383 } 10384 PUSH_BINARY_EXPR(XPATH_OP_ARG, op1, ctxt->comp->last, 0, 0); 10385 nbargs++; 10386 if (CUR == ')') break; 10387 if (CUR != ',') { 10388 XP_ERROR(XPATH_EXPR_ERROR); 10389 } 10390 NEXT; 10391 SKIP_BLANKS; 10392 } 10393 } 10394 PUSH_LONG_EXPR(XPATH_OP_FUNCTION, nbargs, 0, 0, 10395 name, prefix); 10396 NEXT; 10397 SKIP_BLANKS; 10398 } 10399 10400 /** 10401 * xmlXPathCompPrimaryExpr: 10402 * @ctxt: the XPath Parser context 10403 * 10404 * [15] PrimaryExpr ::= VariableReference 10405 * | '(' Expr ')' 10406 * | Literal 10407 * | Number 10408 * | FunctionCall 10409 * 10410 * Compile a primary expression. 10411 */ 10412 static void 10413 xmlXPathCompPrimaryExpr(xmlXPathParserContextPtr ctxt) { 10414 SKIP_BLANKS; 10415 if (CUR == '$') xmlXPathCompVariableReference(ctxt); 10416 else if (CUR == '(') { 10417 NEXT; 10418 SKIP_BLANKS; 10419 xmlXPathCompileExpr(ctxt, 1); 10420 CHECK_ERROR; 10421 if (CUR != ')') { 10422 XP_ERROR(XPATH_EXPR_ERROR); 10423 } 10424 NEXT; 10425 SKIP_BLANKS; 10426 } else if (IS_ASCII_DIGIT(CUR) || (CUR == '.' && IS_ASCII_DIGIT(NXT(1)))) { 10427 xmlXPathCompNumber(ctxt); 10428 } else if ((CUR == '\'') || (CUR == '"')) { 10429 xmlXPathCompLiteral(ctxt); 10430 } else { 10431 xmlXPathCompFunctionCall(ctxt); 10432 } 10433 SKIP_BLANKS; 10434 } 10435 10436 /** 10437 * xmlXPathCompFilterExpr: 10438 * @ctxt: the XPath Parser context 10439 * 10440 * [20] FilterExpr ::= PrimaryExpr 10441 * | FilterExpr Predicate 10442 * 10443 * Compile a filter expression. 10444 * Square brackets are used to filter expressions in the same way that 10445 * they are used in location paths. It is an error if the expression to 10446 * be filtered does not evaluate to a node-set. The context node list 10447 * used for evaluating the expression in square brackets is the node-set 10448 * to be filtered listed in document order. 10449 */ 10450 10451 static void 10452 xmlXPathCompFilterExpr(xmlXPathParserContextPtr ctxt) { 10453 xmlXPathCompPrimaryExpr(ctxt); 10454 CHECK_ERROR; 10455 SKIP_BLANKS; 10456 10457 while (CUR == '[') { 10458 xmlXPathCompPredicate(ctxt, 1); 10459 SKIP_BLANKS; 10460 } 10461 10462 10463 } 10464 10465 /** 10466 * xmlXPathScanName: 10467 * @ctxt: the XPath Parser context 10468 * 10469 * Trickery: parse an XML name but without consuming the input flow 10470 * Needed to avoid insanity in the parser state. 10471 * 10472 * [4] NameChar ::= Letter | Digit | '.' | '-' | '_' | ':' | 10473 * CombiningChar | Extender 10474 * 10475 * [5] Name ::= (Letter | '_' | ':') (NameChar)* 10476 * 10477 * [6] Names ::= Name (S Name)* 10478 * 10479 * Returns the Name parsed or NULL 10480 */ 10481 10482 static xmlChar * 10483 xmlXPathScanName(xmlXPathParserContextPtr ctxt) { 10484 int len = 0, l; 10485 int c; 10486 const xmlChar *cur; 10487 xmlChar *ret; 10488 10489 cur = ctxt->cur; 10490 10491 c = CUR_CHAR(l); 10492 if ((c == ' ') || (c == '>') || (c == '/') || /* accelerators */ 10493 (!IS_LETTER(c) && (c != '_') && 10494 (c != ':'))) { 10495 return(NULL); 10496 } 10497 10498 while ((c != ' ') && (c != '>') && (c != '/') && /* test bigname.xml */ 10499 ((IS_LETTER(c)) || (IS_DIGIT(c)) || 10500 (c == '.') || (c == '-') || 10501 (c == '_') || (c == ':') || 10502 (IS_COMBINING(c)) || 10503 (IS_EXTENDER(c)))) { 10504 len += l; 10505 NEXTL(l); 10506 c = CUR_CHAR(l); 10507 } 10508 ret = xmlStrndup(cur, ctxt->cur - cur); 10509 ctxt->cur = cur; 10510 return(ret); 10511 } 10512 10513 /** 10514 * xmlXPathCompPathExpr: 10515 * @ctxt: the XPath Parser context 10516 * 10517 * [19] PathExpr ::= LocationPath 10518 * | FilterExpr 10519 * | FilterExpr '/' RelativeLocationPath 10520 * | FilterExpr '//' RelativeLocationPath 10521 * 10522 * Compile a path expression. 10523 * The / operator and // operators combine an arbitrary expression 10524 * and a relative location path. It is an error if the expression 10525 * does not evaluate to a node-set. 10526 * The / operator does composition in the same way as when / is 10527 * used in a location path. As in location paths, // is short for 10528 * /descendant-or-self::node()/. 10529 */ 10530 10531 static void 10532 xmlXPathCompPathExpr(xmlXPathParserContextPtr ctxt) { 10533 int lc = 1; /* Should we branch to LocationPath ? */ 10534 xmlChar *name = NULL; /* we may have to preparse a name to find out */ 10535 10536 SKIP_BLANKS; 10537 if ((CUR == '$') || (CUR == '(') || 10538 (IS_ASCII_DIGIT(CUR)) || 10539 (CUR == '\'') || (CUR == '"') || 10540 (CUR == '.' && IS_ASCII_DIGIT(NXT(1)))) { 10541 lc = 0; 10542 } else if (CUR == '*') { 10543 /* relative or absolute location path */ 10544 lc = 1; 10545 } else if (CUR == '/') { 10546 /* relative or absolute location path */ 10547 lc = 1; 10548 } else if (CUR == '@') { 10549 /* relative abbreviated attribute location path */ 10550 lc = 1; 10551 } else if (CUR == '.') { 10552 /* relative abbreviated attribute location path */ 10553 lc = 1; 10554 } else { 10555 /* 10556 * Problem is finding if we have a name here whether it's: 10557 * - a nodetype 10558 * - a function call in which case it's followed by '(' 10559 * - an axis in which case it's followed by ':' 10560 * - a element name 10561 * We do an a priori analysis here rather than having to 10562 * maintain parsed token content through the recursive function 10563 * calls. This looks uglier but makes the code easier to 10564 * read/write/debug. 10565 */ 10566 SKIP_BLANKS; 10567 name = xmlXPathScanName(ctxt); 10568 if ((name != NULL) && (xmlStrstr(name, (xmlChar *) "::") != NULL)) { 10569 #ifdef DEBUG_STEP 10570 xmlGenericError(xmlGenericErrorContext, 10571 "PathExpr: Axis\n"); 10572 #endif 10573 lc = 1; 10574 xmlFree(name); 10575 } else if (name != NULL) { 10576 int len =xmlStrlen(name); 10577 10578 10579 while (NXT(len) != 0) { 10580 if (NXT(len) == '/') { 10581 /* element name */ 10582 #ifdef DEBUG_STEP 10583 xmlGenericError(xmlGenericErrorContext, 10584 "PathExpr: AbbrRelLocation\n"); 10585 #endif 10586 lc = 1; 10587 break; 10588 } else if (IS_BLANK_CH(NXT(len))) { 10589 /* ignore blanks */ 10590 ; 10591 } else if (NXT(len) == ':') { 10592 #ifdef DEBUG_STEP 10593 xmlGenericError(xmlGenericErrorContext, 10594 "PathExpr: AbbrRelLocation\n"); 10595 #endif 10596 lc = 1; 10597 break; 10598 } else if ((NXT(len) == '(')) { 10599 /* Note Type or Function */ 10600 if (xmlXPathIsNodeType(name)) { 10601 #ifdef DEBUG_STEP 10602 xmlGenericError(xmlGenericErrorContext, 10603 "PathExpr: Type search\n"); 10604 #endif 10605 lc = 1; 10606 } else { 10607 #ifdef DEBUG_STEP 10608 xmlGenericError(xmlGenericErrorContext, 10609 "PathExpr: function call\n"); 10610 #endif 10611 lc = 0; 10612 } 10613 break; 10614 } else if ((NXT(len) == '[')) { 10615 /* element name */ 10616 #ifdef DEBUG_STEP 10617 xmlGenericError(xmlGenericErrorContext, 10618 "PathExpr: AbbrRelLocation\n"); 10619 #endif 10620 lc = 1; 10621 break; 10622 } else if ((NXT(len) == '<') || (NXT(len) == '>') || 10623 (NXT(len) == '=')) { 10624 lc = 1; 10625 break; 10626 } else { 10627 lc = 1; 10628 break; 10629 } 10630 len++; 10631 } 10632 if (NXT(len) == 0) { 10633 #ifdef DEBUG_STEP 10634 xmlGenericError(xmlGenericErrorContext, 10635 "PathExpr: AbbrRelLocation\n"); 10636 #endif 10637 /* element name */ 10638 lc = 1; 10639 } 10640 xmlFree(name); 10641 } else { 10642 /* make sure all cases are covered explicitly */ 10643 XP_ERROR(XPATH_EXPR_ERROR); 10644 } 10645 } 10646 10647 if (lc) { 10648 if (CUR == '/') { 10649 PUSH_LEAVE_EXPR(XPATH_OP_ROOT, 0, 0); 10650 } else { 10651 PUSH_LEAVE_EXPR(XPATH_OP_NODE, 0, 0); 10652 } 10653 xmlXPathCompLocationPath(ctxt); 10654 } else { 10655 xmlXPathCompFilterExpr(ctxt); 10656 CHECK_ERROR; 10657 if ((CUR == '/') && (NXT(1) == '/')) { 10658 SKIP(2); 10659 SKIP_BLANKS; 10660 10661 PUSH_LONG_EXPR(XPATH_OP_COLLECT, AXIS_DESCENDANT_OR_SELF, 10662 NODE_TEST_TYPE, NODE_TYPE_NODE, NULL, NULL); 10663 PUSH_UNARY_EXPR(XPATH_OP_RESET, ctxt->comp->last, 1, 0); 10664 10665 xmlXPathCompRelativeLocationPath(ctxt); 10666 } else if (CUR == '/') { 10667 xmlXPathCompRelativeLocationPath(ctxt); 10668 } 10669 } 10670 SKIP_BLANKS; 10671 } 10672 10673 /** 10674 * xmlXPathCompUnionExpr: 10675 * @ctxt: the XPath Parser context 10676 * 10677 * [18] UnionExpr ::= PathExpr 10678 * | UnionExpr '|' PathExpr 10679 * 10680 * Compile an union expression. 10681 */ 10682 10683 static void 10684 xmlXPathCompUnionExpr(xmlXPathParserContextPtr ctxt) { 10685 xmlXPathCompPathExpr(ctxt); 10686 CHECK_ERROR; 10687 SKIP_BLANKS; 10688 while (CUR == '|') { 10689 int op1 = ctxt->comp->last; 10690 PUSH_LEAVE_EXPR(XPATH_OP_NODE, 0, 0); 10691 10692 NEXT; 10693 SKIP_BLANKS; 10694 xmlXPathCompPathExpr(ctxt); 10695 10696 PUSH_BINARY_EXPR(XPATH_OP_UNION, op1, ctxt->comp->last, 0, 0); 10697 10698 SKIP_BLANKS; 10699 } 10700 } 10701 10702 /** 10703 * xmlXPathCompUnaryExpr: 10704 * @ctxt: the XPath Parser context 10705 * 10706 * [27] UnaryExpr ::= UnionExpr 10707 * | '-' UnaryExpr 10708 * 10709 * Compile an unary expression. 10710 */ 10711 10712 static void 10713 xmlXPathCompUnaryExpr(xmlXPathParserContextPtr ctxt) { 10714 int minus = 0; 10715 int found = 0; 10716 10717 SKIP_BLANKS; 10718 while (CUR == '-') { 10719 minus = 1 - minus; 10720 found = 1; 10721 NEXT; 10722 SKIP_BLANKS; 10723 } 10724 10725 xmlXPathCompUnionExpr(ctxt); 10726 CHECK_ERROR; 10727 if (found) { 10728 if (minus) 10729 PUSH_UNARY_EXPR(XPATH_OP_PLUS, ctxt->comp->last, 2, 0); 10730 else 10731 PUSH_UNARY_EXPR(XPATH_OP_PLUS, ctxt->comp->last, 3, 0); 10732 } 10733 } 10734 10735 /** 10736 * xmlXPathCompMultiplicativeExpr: 10737 * @ctxt: the XPath Parser context 10738 * 10739 * [26] MultiplicativeExpr ::= UnaryExpr 10740 * | MultiplicativeExpr MultiplyOperator UnaryExpr 10741 * | MultiplicativeExpr 'div' UnaryExpr 10742 * | MultiplicativeExpr 'mod' UnaryExpr 10743 * [34] MultiplyOperator ::= '*' 10744 * 10745 * Compile an Additive expression. 10746 */ 10747 10748 static void 10749 xmlXPathCompMultiplicativeExpr(xmlXPathParserContextPtr ctxt) { 10750 xmlXPathCompUnaryExpr(ctxt); 10751 CHECK_ERROR; 10752 SKIP_BLANKS; 10753 while ((CUR == '*') || 10754 ((CUR == 'd') && (NXT(1) == 'i') && (NXT(2) == 'v')) || 10755 ((CUR == 'm') && (NXT(1) == 'o') && (NXT(2) == 'd'))) { 10756 int op = -1; 10757 int op1 = ctxt->comp->last; 10758 10759 if (CUR == '*') { 10760 op = 0; 10761 NEXT; 10762 } else if (CUR == 'd') { 10763 op = 1; 10764 SKIP(3); 10765 } else if (CUR == 'm') { 10766 op = 2; 10767 SKIP(3); 10768 } 10769 SKIP_BLANKS; 10770 xmlXPathCompUnaryExpr(ctxt); 10771 CHECK_ERROR; 10772 PUSH_BINARY_EXPR(XPATH_OP_MULT, op1, ctxt->comp->last, op, 0); 10773 SKIP_BLANKS; 10774 } 10775 } 10776 10777 /** 10778 * xmlXPathCompAdditiveExpr: 10779 * @ctxt: the XPath Parser context 10780 * 10781 * [25] AdditiveExpr ::= MultiplicativeExpr 10782 * | AdditiveExpr '+' MultiplicativeExpr 10783 * | AdditiveExpr '-' MultiplicativeExpr 10784 * 10785 * Compile an Additive expression. 10786 */ 10787 10788 static void 10789 xmlXPathCompAdditiveExpr(xmlXPathParserContextPtr ctxt) { 10790 10791 xmlXPathCompMultiplicativeExpr(ctxt); 10792 CHECK_ERROR; 10793 SKIP_BLANKS; 10794 while ((CUR == '+') || (CUR == '-')) { 10795 int plus; 10796 int op1 = ctxt->comp->last; 10797 10798 if (CUR == '+') plus = 1; 10799 else plus = 0; 10800 NEXT; 10801 SKIP_BLANKS; 10802 xmlXPathCompMultiplicativeExpr(ctxt); 10803 CHECK_ERROR; 10804 PUSH_BINARY_EXPR(XPATH_OP_PLUS, op1, ctxt->comp->last, plus, 0); 10805 SKIP_BLANKS; 10806 } 10807 } 10808 10809 /** 10810 * xmlXPathCompRelationalExpr: 10811 * @ctxt: the XPath Parser context 10812 * 10813 * [24] RelationalExpr ::= AdditiveExpr 10814 * | RelationalExpr '<' AdditiveExpr 10815 * | RelationalExpr '>' AdditiveExpr 10816 * | RelationalExpr '<=' AdditiveExpr 10817 * | RelationalExpr '>=' AdditiveExpr 10818 * 10819 * A <= B > C is allowed ? Answer from James, yes with 10820 * (AdditiveExpr <= AdditiveExpr) > AdditiveExpr 10821 * which is basically what got implemented. 10822 * 10823 * Compile a Relational expression, then push the result 10824 * on the stack 10825 */ 10826 10827 static void 10828 xmlXPathCompRelationalExpr(xmlXPathParserContextPtr ctxt) { 10829 xmlXPathCompAdditiveExpr(ctxt); 10830 CHECK_ERROR; 10831 SKIP_BLANKS; 10832 while ((CUR == '<') || 10833 (CUR == '>') || 10834 ((CUR == '<') && (NXT(1) == '=')) || 10835 ((CUR == '>') && (NXT(1) == '='))) { 10836 int inf, strict; 10837 int op1 = ctxt->comp->last; 10838 10839 if (CUR == '<') inf = 1; 10840 else inf = 0; 10841 if (NXT(1) == '=') strict = 0; 10842 else strict = 1; 10843 NEXT; 10844 if (!strict) NEXT; 10845 SKIP_BLANKS; 10846 xmlXPathCompAdditiveExpr(ctxt); 10847 CHECK_ERROR; 10848 PUSH_BINARY_EXPR(XPATH_OP_CMP, op1, ctxt->comp->last, inf, strict); 10849 SKIP_BLANKS; 10850 } 10851 } 10852 10853 /** 10854 * xmlXPathCompEqualityExpr: 10855 * @ctxt: the XPath Parser context 10856 * 10857 * [23] EqualityExpr ::= RelationalExpr 10858 * | EqualityExpr '=' RelationalExpr 10859 * | EqualityExpr '!=' RelationalExpr 10860 * 10861 * A != B != C is allowed ? Answer from James, yes with 10862 * (RelationalExpr = RelationalExpr) = RelationalExpr 10863 * (RelationalExpr != RelationalExpr) != RelationalExpr 10864 * which is basically what got implemented. 10865 * 10866 * Compile an Equality expression. 10867 * 10868 */ 10869 static void 10870 xmlXPathCompEqualityExpr(xmlXPathParserContextPtr ctxt) { 10871 xmlXPathCompRelationalExpr(ctxt); 10872 CHECK_ERROR; 10873 SKIP_BLANKS; 10874 while ((CUR == '=') || ((CUR == '!') && (NXT(1) == '='))) { 10875 int eq; 10876 int op1 = ctxt->comp->last; 10877 10878 if (CUR == '=') eq = 1; 10879 else eq = 0; 10880 NEXT; 10881 if (!eq) NEXT; 10882 SKIP_BLANKS; 10883 xmlXPathCompRelationalExpr(ctxt); 10884 CHECK_ERROR; 10885 PUSH_BINARY_EXPR(XPATH_OP_EQUAL, op1, ctxt->comp->last, eq, 0); 10886 SKIP_BLANKS; 10887 } 10888 } 10889 10890 /** 10891 * xmlXPathCompAndExpr: 10892 * @ctxt: the XPath Parser context 10893 * 10894 * [22] AndExpr ::= EqualityExpr 10895 * | AndExpr 'and' EqualityExpr 10896 * 10897 * Compile an AND expression. 10898 * 10899 */ 10900 static void 10901 xmlXPathCompAndExpr(xmlXPathParserContextPtr ctxt) { 10902 xmlXPathCompEqualityExpr(ctxt); 10903 CHECK_ERROR; 10904 SKIP_BLANKS; 10905 while ((CUR == 'a') && (NXT(1) == 'n') && (NXT(2) == 'd')) { 10906 int op1 = ctxt->comp->last; 10907 SKIP(3); 10908 SKIP_BLANKS; 10909 xmlXPathCompEqualityExpr(ctxt); 10910 CHECK_ERROR; 10911 PUSH_BINARY_EXPR(XPATH_OP_AND, op1, ctxt->comp->last, 0, 0); 10912 SKIP_BLANKS; 10913 } 10914 } 10915 10916 /** 10917 * xmlXPathCompileExpr: 10918 * @ctxt: the XPath Parser context 10919 * 10920 * [14] Expr ::= OrExpr 10921 * [21] OrExpr ::= AndExpr 10922 * | OrExpr 'or' AndExpr 10923 * 10924 * Parse and compile an expression 10925 */ 10926 static void 10927 xmlXPathCompileExpr(xmlXPathParserContextPtr ctxt, int sort) { 10928 xmlXPathCompAndExpr(ctxt); 10929 CHECK_ERROR; 10930 SKIP_BLANKS; 10931 while ((CUR == 'o') && (NXT(1) == 'r')) { 10932 int op1 = ctxt->comp->last; 10933 SKIP(2); 10934 SKIP_BLANKS; 10935 xmlXPathCompAndExpr(ctxt); 10936 CHECK_ERROR; 10937 PUSH_BINARY_EXPR(XPATH_OP_OR, op1, ctxt->comp->last, 0, 0); 10938 SKIP_BLANKS; 10939 } 10940 if ((sort) && (ctxt->comp->steps[ctxt->comp->last].op != XPATH_OP_VALUE)) { 10941 /* more ops could be optimized too */ 10942 /* 10943 * This is the main place to eliminate sorting for 10944 * operations which don't require a sorted node-set. 10945 * E.g. count(). 10946 */ 10947 PUSH_UNARY_EXPR(XPATH_OP_SORT, ctxt->comp->last , 0, 0); 10948 } 10949 } 10950 10951 /** 10952 * xmlXPathCompPredicate: 10953 * @ctxt: the XPath Parser context 10954 * @filter: act as a filter 10955 * 10956 * [8] Predicate ::= '[' PredicateExpr ']' 10957 * [9] PredicateExpr ::= Expr 10958 * 10959 * Compile a predicate expression 10960 */ 10961 static void 10962 xmlXPathCompPredicate(xmlXPathParserContextPtr ctxt, int filter) { 10963 int op1 = ctxt->comp->last; 10964 10965 SKIP_BLANKS; 10966 if (CUR != '[') { 10967 XP_ERROR(XPATH_INVALID_PREDICATE_ERROR); 10968 } 10969 NEXT; 10970 SKIP_BLANKS; 10971 10972 ctxt->comp->last = -1; 10973 /* 10974 * This call to xmlXPathCompileExpr() will deactivate sorting 10975 * of the predicate result. 10976 * TODO: Sorting is still activated for filters, since I'm not 10977 * sure if needed. Normally sorting should not be needed, since 10978 * a filter can only diminish the number of items in a sequence, 10979 * but won't change its order; so if the initial sequence is sorted, 10980 * subsequent sorting is not needed. 10981 */ 10982 if (! filter) 10983 xmlXPathCompileExpr(ctxt, 0); 10984 else 10985 xmlXPathCompileExpr(ctxt, 1); 10986 CHECK_ERROR; 10987 10988 if (CUR != ']') { 10989 XP_ERROR(XPATH_INVALID_PREDICATE_ERROR); 10990 } 10991 10992 if (filter) 10993 PUSH_BINARY_EXPR(XPATH_OP_FILTER, op1, ctxt->comp->last, 0, 0); 10994 else 10995 PUSH_BINARY_EXPR(XPATH_OP_PREDICATE, op1, ctxt->comp->last, 0, 0); 10996 10997 NEXT; 10998 SKIP_BLANKS; 10999 } 11000 11001 /** 11002 * xmlXPathCompNodeTest: 11003 * @ctxt: the XPath Parser context 11004 * @test: pointer to a xmlXPathTestVal 11005 * @type: pointer to a xmlXPathTypeVal 11006 * @prefix: placeholder for a possible name prefix 11007 * 11008 * [7] NodeTest ::= NameTest 11009 * | NodeType '(' ')' 11010 * | 'processing-instruction' '(' Literal ')' 11011 * 11012 * [37] NameTest ::= '*' 11013 * | NCName ':' '*' 11014 * | QName 11015 * [38] NodeType ::= 'comment' 11016 * | 'text' 11017 * | 'processing-instruction' 11018 * | 'node' 11019 * 11020 * Returns the name found and updates @test, @type and @prefix appropriately 11021 */ 11022 static xmlChar * 11023 xmlXPathCompNodeTest(xmlXPathParserContextPtr ctxt, xmlXPathTestVal *test, 11024 xmlXPathTypeVal *type, const xmlChar **prefix, 11025 xmlChar *name) { 11026 int blanks; 11027 11028 if ((test == NULL) || (type == NULL) || (prefix == NULL)) { 11029 STRANGE; 11030 return(NULL); 11031 } 11032 *type = (xmlXPathTypeVal) 0; 11033 *test = (xmlXPathTestVal) 0; 11034 *prefix = NULL; 11035 SKIP_BLANKS; 11036 11037 if ((name == NULL) && (CUR == '*')) { 11038 /* 11039 * All elements 11040 */ 11041 NEXT; 11042 *test = NODE_TEST_ALL; 11043 return(NULL); 11044 } 11045 11046 if (name == NULL) 11047 name = xmlXPathParseNCName(ctxt); 11048 if (name == NULL) { 11049 XP_ERRORNULL(XPATH_EXPR_ERROR); 11050 } 11051 11052 blanks = IS_BLANK_CH(CUR); 11053 SKIP_BLANKS; 11054 if (CUR == '(') { 11055 NEXT; 11056 /* 11057 * NodeType or PI search 11058 */ 11059 if (xmlStrEqual(name, BAD_CAST "comment")) 11060 *type = NODE_TYPE_COMMENT; 11061 else if (xmlStrEqual(name, BAD_CAST "node")) 11062 *type = NODE_TYPE_NODE; 11063 else if (xmlStrEqual(name, BAD_CAST "processing-instruction")) 11064 *type = NODE_TYPE_PI; 11065 else if (xmlStrEqual(name, BAD_CAST "text")) 11066 *type = NODE_TYPE_TEXT; 11067 else { 11068 if (name != NULL) 11069 xmlFree(name); 11070 XP_ERRORNULL(XPATH_EXPR_ERROR); 11071 } 11072 11073 *test = NODE_TEST_TYPE; 11074 11075 SKIP_BLANKS; 11076 if (*type == NODE_TYPE_PI) { 11077 /* 11078 * Specific case: search a PI by name. 11079 */ 11080 if (name != NULL) 11081 xmlFree(name); 11082 name = NULL; 11083 if (CUR != ')') { 11084 name = xmlXPathParseLiteral(ctxt); 11085 CHECK_ERROR NULL; 11086 *test = NODE_TEST_PI; 11087 SKIP_BLANKS; 11088 } 11089 } 11090 if (CUR != ')') { 11091 if (name != NULL) 11092 xmlFree(name); 11093 XP_ERRORNULL(XPATH_UNCLOSED_ERROR); 11094 } 11095 NEXT; 11096 return(name); 11097 } 11098 *test = NODE_TEST_NAME; 11099 if ((!blanks) && (CUR == ':')) { 11100 NEXT; 11101 11102 /* 11103 * Since currently the parser context don't have a 11104 * namespace list associated: 11105 * The namespace name for this prefix can be computed 11106 * only at evaluation time. The compilation is done 11107 * outside of any context. 11108 */ 11109 #if 0 11110 *prefix = xmlXPathNsLookup(ctxt->context, name); 11111 if (name != NULL) 11112 xmlFree(name); 11113 if (*prefix == NULL) { 11114 XP_ERROR0(XPATH_UNDEF_PREFIX_ERROR); 11115 } 11116 #else 11117 *prefix = name; 11118 #endif 11119 11120 if (CUR == '*') { 11121 /* 11122 * All elements 11123 */ 11124 NEXT; 11125 *test = NODE_TEST_ALL; 11126 return(NULL); 11127 } 11128 11129 name = xmlXPathParseNCName(ctxt); 11130 if (name == NULL) { 11131 XP_ERRORNULL(XPATH_EXPR_ERROR); 11132 } 11133 } 11134 return(name); 11135 } 11136 11137 /** 11138 * xmlXPathIsAxisName: 11139 * @name: a preparsed name token 11140 * 11141 * [6] AxisName ::= 'ancestor' 11142 * | 'ancestor-or-self' 11143 * | 'attribute' 11144 * | 'child' 11145 * | 'descendant' 11146 * | 'descendant-or-self' 11147 * | 'following' 11148 * | 'following-sibling' 11149 * | 'namespace' 11150 * | 'parent' 11151 * | 'preceding' 11152 * | 'preceding-sibling' 11153 * | 'self' 11154 * 11155 * Returns the axis or 0 11156 */ 11157 static xmlXPathAxisVal 11158 xmlXPathIsAxisName(const xmlChar *name) { 11159 xmlXPathAxisVal ret = (xmlXPathAxisVal) 0; 11160 switch (name[0]) { 11161 case 'a': 11162 if (xmlStrEqual(name, BAD_CAST "ancestor")) 11163 ret = AXIS_ANCESTOR; 11164 if (xmlStrEqual(name, BAD_CAST "ancestor-or-self")) 11165 ret = AXIS_ANCESTOR_OR_SELF; 11166 if (xmlStrEqual(name, BAD_CAST "attribute")) 11167 ret = AXIS_ATTRIBUTE; 11168 break; 11169 case 'c': 11170 if (xmlStrEqual(name, BAD_CAST "child")) 11171 ret = AXIS_CHILD; 11172 break; 11173 case 'd': 11174 if (xmlStrEqual(name, BAD_CAST "descendant")) 11175 ret = AXIS_DESCENDANT; 11176 if (xmlStrEqual(name, BAD_CAST "descendant-or-self")) 11177 ret = AXIS_DESCENDANT_OR_SELF; 11178 break; 11179 case 'f': 11180 if (xmlStrEqual(name, BAD_CAST "following")) 11181 ret = AXIS_FOLLOWING; 11182 if (xmlStrEqual(name, BAD_CAST "following-sibling")) 11183 ret = AXIS_FOLLOWING_SIBLING; 11184 break; 11185 case 'n': 11186 if (xmlStrEqual(name, BAD_CAST "namespace")) 11187 ret = AXIS_NAMESPACE; 11188 break; 11189 case 'p': 11190 if (xmlStrEqual(name, BAD_CAST "parent")) 11191 ret = AXIS_PARENT; 11192 if (xmlStrEqual(name, BAD_CAST "preceding")) 11193 ret = AXIS_PRECEDING; 11194 if (xmlStrEqual(name, BAD_CAST "preceding-sibling")) 11195 ret = AXIS_PRECEDING_SIBLING; 11196 break; 11197 case 's': 11198 if (xmlStrEqual(name, BAD_CAST "self")) 11199 ret = AXIS_SELF; 11200 break; 11201 } 11202 return(ret); 11203 } 11204 11205 /** 11206 * xmlXPathCompStep: 11207 * @ctxt: the XPath Parser context 11208 * 11209 * [4] Step ::= AxisSpecifier NodeTest Predicate* 11210 * | AbbreviatedStep 11211 * 11212 * [12] AbbreviatedStep ::= '.' | '..' 11213 * 11214 * [5] AxisSpecifier ::= AxisName '::' 11215 * | AbbreviatedAxisSpecifier 11216 * 11217 * [13] AbbreviatedAxisSpecifier ::= '@'? 11218 * 11219 * Modified for XPtr range support as: 11220 * 11221 * [4xptr] Step ::= AxisSpecifier NodeTest Predicate* 11222 * | AbbreviatedStep 11223 * | 'range-to' '(' Expr ')' Predicate* 11224 * 11225 * Compile one step in a Location Path 11226 * A location step of . is short for self::node(). This is 11227 * particularly useful in conjunction with //. For example, the 11228 * location path .//para is short for 11229 * self::node()/descendant-or-self::node()/child::para 11230 * and so will select all para descendant elements of the context 11231 * node. 11232 * Similarly, a location step of .. is short for parent::node(). 11233 * For example, ../title is short for parent::node()/child::title 11234 * and so will select the title children of the parent of the context 11235 * node. 11236 */ 11237 static void 11238 xmlXPathCompStep(xmlXPathParserContextPtr ctxt) { 11239 #ifdef LIBXML_XPTR_ENABLED 11240 int rangeto = 0; 11241 int op2 = -1; 11242 #endif 11243 11244 SKIP_BLANKS; 11245 if ((CUR == '.') && (NXT(1) == '.')) { 11246 SKIP(2); 11247 SKIP_BLANKS; 11248 PUSH_LONG_EXPR(XPATH_OP_COLLECT, AXIS_PARENT, 11249 NODE_TEST_TYPE, NODE_TYPE_NODE, NULL, NULL); 11250 } else if (CUR == '.') { 11251 NEXT; 11252 SKIP_BLANKS; 11253 } else { 11254 xmlChar *name = NULL; 11255 const xmlChar *prefix = NULL; 11256 xmlXPathTestVal test = (xmlXPathTestVal) 0; 11257 xmlXPathAxisVal axis = (xmlXPathAxisVal) 0; 11258 xmlXPathTypeVal type = (xmlXPathTypeVal) 0; 11259 int op1; 11260 11261 /* 11262 * The modification needed for XPointer change to the production 11263 */ 11264 #ifdef LIBXML_XPTR_ENABLED 11265 if (ctxt->xptr) { 11266 name = xmlXPathParseNCName(ctxt); 11267 if ((name != NULL) && (xmlStrEqual(name, BAD_CAST "range-to"))) { 11268 op2 = ctxt->comp->last; 11269 xmlFree(name); 11270 SKIP_BLANKS; 11271 if (CUR != '(') { 11272 XP_ERROR(XPATH_EXPR_ERROR); 11273 } 11274 NEXT; 11275 SKIP_BLANKS; 11276 11277 xmlXPathCompileExpr(ctxt, 1); 11278 /* PUSH_BINARY_EXPR(XPATH_OP_RANGETO, op2, ctxt->comp->last, 0, 0); */ 11279 CHECK_ERROR; 11280 11281 SKIP_BLANKS; 11282 if (CUR != ')') { 11283 XP_ERROR(XPATH_EXPR_ERROR); 11284 } 11285 NEXT; 11286 rangeto = 1; 11287 goto eval_predicates; 11288 } 11289 } 11290 #endif 11291 if (CUR == '*') { 11292 axis = AXIS_CHILD; 11293 } else { 11294 if (name == NULL) 11295 name = xmlXPathParseNCName(ctxt); 11296 if (name != NULL) { 11297 axis = xmlXPathIsAxisName(name); 11298 if (axis != 0) { 11299 SKIP_BLANKS; 11300 if ((CUR == ':') && (NXT(1) == ':')) { 11301 SKIP(2); 11302 xmlFree(name); 11303 name = NULL; 11304 } else { 11305 /* an element name can conflict with an axis one :-\ */ 11306 axis = AXIS_CHILD; 11307 } 11308 } else { 11309 axis = AXIS_CHILD; 11310 } 11311 } else if (CUR == '@') { 11312 NEXT; 11313 axis = AXIS_ATTRIBUTE; 11314 } else { 11315 axis = AXIS_CHILD; 11316 } 11317 } 11318 11319 if (ctxt->error != XPATH_EXPRESSION_OK) { 11320 xmlFree(name); 11321 return; 11322 } 11323 11324 name = xmlXPathCompNodeTest(ctxt, &test, &type, &prefix, name); 11325 if (test == 0) 11326 return; 11327 11328 if ((prefix != NULL) && (ctxt->context != NULL) && 11329 (ctxt->context->flags & XML_XPATH_CHECKNS)) { 11330 if (xmlXPathNsLookup(ctxt->context, prefix) == NULL) { 11331 xmlXPathErr(ctxt, XPATH_UNDEF_PREFIX_ERROR); 11332 } 11333 } 11334 #ifdef DEBUG_STEP 11335 xmlGenericError(xmlGenericErrorContext, 11336 "Basis : computing new set\n"); 11337 #endif 11338 11339 #ifdef DEBUG_STEP 11340 xmlGenericError(xmlGenericErrorContext, "Basis : "); 11341 if (ctxt->value == NULL) 11342 xmlGenericError(xmlGenericErrorContext, "no value\n"); 11343 else if (ctxt->value->nodesetval == NULL) 11344 xmlGenericError(xmlGenericErrorContext, "Empty\n"); 11345 else 11346 xmlGenericErrorContextNodeSet(stdout, ctxt->value->nodesetval); 11347 #endif 11348 11349 #ifdef LIBXML_XPTR_ENABLED 11350 eval_predicates: 11351 #endif 11352 op1 = ctxt->comp->last; 11353 ctxt->comp->last = -1; 11354 11355 SKIP_BLANKS; 11356 while (CUR == '[') { 11357 xmlXPathCompPredicate(ctxt, 0); 11358 } 11359 11360 #ifdef LIBXML_XPTR_ENABLED 11361 if (rangeto) { 11362 PUSH_BINARY_EXPR(XPATH_OP_RANGETO, op2, op1, 0, 0); 11363 } else 11364 #endif 11365 PUSH_FULL_EXPR(XPATH_OP_COLLECT, op1, ctxt->comp->last, axis, 11366 test, type, (void *)prefix, (void *)name); 11367 11368 } 11369 #ifdef DEBUG_STEP 11370 xmlGenericError(xmlGenericErrorContext, "Step : "); 11371 if (ctxt->value == NULL) 11372 xmlGenericError(xmlGenericErrorContext, "no value\n"); 11373 else if (ctxt->value->nodesetval == NULL) 11374 xmlGenericError(xmlGenericErrorContext, "Empty\n"); 11375 else 11376 xmlGenericErrorContextNodeSet(xmlGenericErrorContext, 11377 ctxt->value->nodesetval); 11378 #endif 11379 } 11380 11381 /** 11382 * xmlXPathCompRelativeLocationPath: 11383 * @ctxt: the XPath Parser context 11384 * 11385 * [3] RelativeLocationPath ::= Step 11386 * | RelativeLocationPath '/' Step 11387 * | AbbreviatedRelativeLocationPath 11388 * [11] AbbreviatedRelativeLocationPath ::= RelativeLocationPath '//' Step 11389 * 11390 * Compile a relative location path. 11391 */ 11392 static void 11393 xmlXPathCompRelativeLocationPath 11394 (xmlXPathParserContextPtr ctxt) { 11395 SKIP_BLANKS; 11396 if ((CUR == '/') && (NXT(1) == '/')) { 11397 SKIP(2); 11398 SKIP_BLANKS; 11399 PUSH_LONG_EXPR(XPATH_OP_COLLECT, AXIS_DESCENDANT_OR_SELF, 11400 NODE_TEST_TYPE, NODE_TYPE_NODE, NULL, NULL); 11401 } else if (CUR == '/') { 11402 NEXT; 11403 SKIP_BLANKS; 11404 } 11405 xmlXPathCompStep(ctxt); 11406 CHECK_ERROR; 11407 SKIP_BLANKS; 11408 while (CUR == '/') { 11409 if ((CUR == '/') && (NXT(1) == '/')) { 11410 SKIP(2); 11411 SKIP_BLANKS; 11412 PUSH_LONG_EXPR(XPATH_OP_COLLECT, AXIS_DESCENDANT_OR_SELF, 11413 NODE_TEST_TYPE, NODE_TYPE_NODE, NULL, NULL); 11414 xmlXPathCompStep(ctxt); 11415 } else if (CUR == '/') { 11416 NEXT; 11417 SKIP_BLANKS; 11418 xmlXPathCompStep(ctxt); 11419 } 11420 SKIP_BLANKS; 11421 } 11422 } 11423 11424 /** 11425 * xmlXPathCompLocationPath: 11426 * @ctxt: the XPath Parser context 11427 * 11428 * [1] LocationPath ::= RelativeLocationPath 11429 * | AbsoluteLocationPath 11430 * [2] AbsoluteLocationPath ::= '/' RelativeLocationPath? 11431 * | AbbreviatedAbsoluteLocationPath 11432 * [10] AbbreviatedAbsoluteLocationPath ::= 11433 * '//' RelativeLocationPath 11434 * 11435 * Compile a location path 11436 * 11437 * // is short for /descendant-or-self::node()/. For example, 11438 * //para is short for /descendant-or-self::node()/child::para and 11439 * so will select any para element in the document (even a para element 11440 * that is a document element will be selected by //para since the 11441 * document element node is a child of the root node); div//para is 11442 * short for div/descendant-or-self::node()/child::para and so will 11443 * select all para descendants of div children. 11444 */ 11445 static void 11446 xmlXPathCompLocationPath(xmlXPathParserContextPtr ctxt) { 11447 SKIP_BLANKS; 11448 if (CUR != '/') { 11449 xmlXPathCompRelativeLocationPath(ctxt); 11450 } else { 11451 while (CUR == '/') { 11452 if ((CUR == '/') && (NXT(1) == '/')) { 11453 SKIP(2); 11454 SKIP_BLANKS; 11455 PUSH_LONG_EXPR(XPATH_OP_COLLECT, AXIS_DESCENDANT_OR_SELF, 11456 NODE_TEST_TYPE, NODE_TYPE_NODE, NULL, NULL); 11457 xmlXPathCompRelativeLocationPath(ctxt); 11458 } else if (CUR == '/') { 11459 NEXT; 11460 SKIP_BLANKS; 11461 if ((CUR != 0 ) && 11462 ((IS_ASCII_LETTER(CUR)) || (CUR == '_') || (CUR == '.') || 11463 (CUR == '@') || (CUR == '*'))) 11464 xmlXPathCompRelativeLocationPath(ctxt); 11465 } 11466 CHECK_ERROR; 11467 } 11468 } 11469 } 11470 11471 /************************************************************************ 11472 * * 11473 * XPath precompiled expression evaluation * 11474 * * 11475 ************************************************************************/ 11476 11477 static int 11478 xmlXPathCompOpEval(xmlXPathParserContextPtr ctxt, xmlXPathStepOpPtr op); 11479 11480 #ifdef DEBUG_STEP 11481 static void 11482 xmlXPathDebugDumpStepAxis(xmlXPathStepOpPtr op, 11483 int nbNodes) 11484 { 11485 xmlGenericError(xmlGenericErrorContext, "new step : "); 11486 switch (op->value) { 11487 case AXIS_ANCESTOR: 11488 xmlGenericError(xmlGenericErrorContext, "axis 'ancestors' "); 11489 break; 11490 case AXIS_ANCESTOR_OR_SELF: 11491 xmlGenericError(xmlGenericErrorContext, 11492 "axis 'ancestors-or-self' "); 11493 break; 11494 case AXIS_ATTRIBUTE: 11495 xmlGenericError(xmlGenericErrorContext, "axis 'attributes' "); 11496 break; 11497 case AXIS_CHILD: 11498 xmlGenericError(xmlGenericErrorContext, "axis 'child' "); 11499 break; 11500 case AXIS_DESCENDANT: 11501 xmlGenericError(xmlGenericErrorContext, "axis 'descendant' "); 11502 break; 11503 case AXIS_DESCENDANT_OR_SELF: 11504 xmlGenericError(xmlGenericErrorContext, 11505 "axis 'descendant-or-self' "); 11506 break; 11507 case AXIS_FOLLOWING: 11508 xmlGenericError(xmlGenericErrorContext, "axis 'following' "); 11509 break; 11510 case AXIS_FOLLOWING_SIBLING: 11511 xmlGenericError(xmlGenericErrorContext, 11512 "axis 'following-siblings' "); 11513 break; 11514 case AXIS_NAMESPACE: 11515 xmlGenericError(xmlGenericErrorContext, "axis 'namespace' "); 11516 break; 11517 case AXIS_PARENT: 11518 xmlGenericError(xmlGenericErrorContext, "axis 'parent' "); 11519 break; 11520 case AXIS_PRECEDING: 11521 xmlGenericError(xmlGenericErrorContext, "axis 'preceding' "); 11522 break; 11523 case AXIS_PRECEDING_SIBLING: 11524 xmlGenericError(xmlGenericErrorContext, 11525 "axis 'preceding-sibling' "); 11526 break; 11527 case AXIS_SELF: 11528 xmlGenericError(xmlGenericErrorContext, "axis 'self' "); 11529 break; 11530 } 11531 xmlGenericError(xmlGenericErrorContext, 11532 " context contains %d nodes\n", nbNodes); 11533 switch (op->value2) { 11534 case NODE_TEST_NONE: 11535 xmlGenericError(xmlGenericErrorContext, 11536 " searching for none !!!\n"); 11537 break; 11538 case NODE_TEST_TYPE: 11539 xmlGenericError(xmlGenericErrorContext, 11540 " searching for type %d\n", op->value3); 11541 break; 11542 case NODE_TEST_PI: 11543 xmlGenericError(xmlGenericErrorContext, 11544 " searching for PI !!!\n"); 11545 break; 11546 case NODE_TEST_ALL: 11547 xmlGenericError(xmlGenericErrorContext, 11548 " searching for *\n"); 11549 break; 11550 case NODE_TEST_NS: 11551 xmlGenericError(xmlGenericErrorContext, 11552 " searching for namespace %s\n", 11553 op->value5); 11554 break; 11555 case NODE_TEST_NAME: 11556 xmlGenericError(xmlGenericErrorContext, 11557 " searching for name %s\n", op->value5); 11558 if (op->value4) 11559 xmlGenericError(xmlGenericErrorContext, 11560 " with namespace %s\n", op->value4); 11561 break; 11562 } 11563 xmlGenericError(xmlGenericErrorContext, "Testing : "); 11564 } 11565 #endif /* DEBUG_STEP */ 11566 11567 static int 11568 xmlXPathCompOpEvalPredicate(xmlXPathParserContextPtr ctxt, 11569 xmlXPathStepOpPtr op, 11570 xmlNodeSetPtr set, 11571 int contextSize, 11572 int hasNsNodes) 11573 { 11574 if (op->ch1 != -1) { 11575 xmlXPathCompExprPtr comp = ctxt->comp; 11576 /* 11577 * Process inner predicates first. 11578 */ 11579 if (comp->steps[op->ch1].op != XPATH_OP_PREDICATE) { 11580 /* 11581 * TODO: raise an internal error. 11582 */ 11583 } 11584 contextSize = xmlXPathCompOpEvalPredicate(ctxt, 11585 &comp->steps[op->ch1], set, contextSize, hasNsNodes); 11586 CHECK_ERROR0; 11587 if (contextSize <= 0) 11588 return(0); 11589 } 11590 if (op->ch2 != -1) { 11591 xmlXPathContextPtr xpctxt = ctxt->context; 11592 xmlNodePtr contextNode, oldContextNode; 11593 xmlDocPtr oldContextDoc; 11594 int i, res, contextPos = 0, newContextSize; 11595 xmlXPathStepOpPtr exprOp; 11596 xmlXPathObjectPtr contextObj = NULL, exprRes = NULL; 11597 11598 #ifdef LIBXML_XPTR_ENABLED 11599 /* 11600 * URGENT TODO: Check the following: 11601 * We don't expect location sets if evaluating prediates, right? 11602 * Only filters should expect location sets, right? 11603 */ 11604 #endif 11605 /* 11606 * SPEC XPath 1.0: 11607 * "For each node in the node-set to be filtered, the 11608 * PredicateExpr is evaluated with that node as the 11609 * context node, with the number of nodes in the 11610 * node-set as the context size, and with the proximity 11611 * position of the node in the node-set with respect to 11612 * the axis as the context position;" 11613 * @oldset is the node-set" to be filtered. 11614 * 11615 * SPEC XPath 1.0: 11616 * "only predicates change the context position and 11617 * context size (see [2.4 Predicates])." 11618 * Example: 11619 * node-set context pos 11620 * nA 1 11621 * nB 2 11622 * nC 3 11623 * After applying predicate [position() > 1] : 11624 * node-set context pos 11625 * nB 1 11626 * nC 2 11627 */ 11628 oldContextNode = xpctxt->node; 11629 oldContextDoc = xpctxt->doc; 11630 /* 11631 * Get the expression of this predicate. 11632 */ 11633 exprOp = &ctxt->comp->steps[op->ch2]; 11634 newContextSize = 0; 11635 for (i = 0; i < set->nodeNr; i++) { 11636 if (set->nodeTab[i] == NULL) 11637 continue; 11638 11639 contextNode = set->nodeTab[i]; 11640 xpctxt->node = contextNode; 11641 xpctxt->contextSize = contextSize; 11642 xpctxt->proximityPosition = ++contextPos; 11643 11644 /* 11645 * Also set the xpath document in case things like 11646 * key() are evaluated in the predicate. 11647 */ 11648 if ((contextNode->type != XML_NAMESPACE_DECL) && 11649 (contextNode->doc != NULL)) 11650 xpctxt->doc = contextNode->doc; 11651 /* 11652 * Evaluate the predicate expression with 1 context node 11653 * at a time; this node is packaged into a node set; this 11654 * node set is handed over to the evaluation mechanism. 11655 */ 11656 if (contextObj == NULL) 11657 contextObj = xmlXPathCacheNewNodeSet(xpctxt, contextNode); 11658 else 11659 xmlXPathNodeSetAddUnique(contextObj->nodesetval, 11660 contextNode); 11661 11662 valuePush(ctxt, contextObj); 11663 11664 res = xmlXPathCompOpEvalToBoolean(ctxt, exprOp, 1); 11665 11666 if ((ctxt->error != XPATH_EXPRESSION_OK) || (res == -1)) { 11667 xmlXPathNodeSetClear(set, hasNsNodes); 11668 newContextSize = 0; 11669 goto evaluation_exit; 11670 } 11671 11672 if (res != 0) { 11673 newContextSize++; 11674 } else { 11675 /* 11676 * Remove the entry from the initial node set. 11677 */ 11678 set->nodeTab[i] = NULL; 11679 if (contextNode->type == XML_NAMESPACE_DECL) 11680 xmlXPathNodeSetFreeNs((xmlNsPtr) contextNode); 11681 } 11682 if (ctxt->value == contextObj) { 11683 /* 11684 * Don't free the temporary XPath object holding the 11685 * context node, in order to avoid massive recreation 11686 * inside this loop. 11687 */ 11688 valuePop(ctxt); 11689 xmlXPathNodeSetClear(contextObj->nodesetval, hasNsNodes); 11690 } else { 11691 /* 11692 * TODO: The object was lost in the evaluation machinery. 11693 * Can this happen? Maybe in internal-error cases. 11694 */ 11695 contextObj = NULL; 11696 } 11697 } 11698 11699 if (contextObj != NULL) { 11700 if (ctxt->value == contextObj) 11701 valuePop(ctxt); 11702 xmlXPathReleaseObject(xpctxt, contextObj); 11703 } 11704 evaluation_exit: 11705 if (exprRes != NULL) 11706 xmlXPathReleaseObject(ctxt->context, exprRes); 11707 /* 11708 * Reset/invalidate the context. 11709 */ 11710 xpctxt->node = oldContextNode; 11711 xpctxt->doc = oldContextDoc; 11712 xpctxt->contextSize = -1; 11713 xpctxt->proximityPosition = -1; 11714 return(newContextSize); 11715 } 11716 return(contextSize); 11717 } 11718 11719 static int 11720 xmlXPathCompOpEvalPositionalPredicate(xmlXPathParserContextPtr ctxt, 11721 xmlXPathStepOpPtr op, 11722 xmlNodeSetPtr set, 11723 int contextSize, 11724 int minPos, 11725 int maxPos, 11726 int hasNsNodes) 11727 { 11728 if (op->ch1 != -1) { 11729 xmlXPathCompExprPtr comp = ctxt->comp; 11730 if (comp->steps[op->ch1].op != XPATH_OP_PREDICATE) { 11731 /* 11732 * TODO: raise an internal error. 11733 */ 11734 } 11735 contextSize = xmlXPathCompOpEvalPredicate(ctxt, 11736 &comp->steps[op->ch1], set, contextSize, hasNsNodes); 11737 CHECK_ERROR0; 11738 if (contextSize <= 0) 11739 return(0); 11740 } 11741 /* 11742 * Check if the node set contains a sufficient number of nodes for 11743 * the requested range. 11744 */ 11745 if (contextSize < minPos) { 11746 xmlXPathNodeSetClear(set, hasNsNodes); 11747 return(0); 11748 } 11749 if (op->ch2 == -1) { 11750 /* 11751 * TODO: Can this ever happen? 11752 */ 11753 return (contextSize); 11754 } else { 11755 xmlDocPtr oldContextDoc; 11756 int i, pos = 0, newContextSize = 0, contextPos = 0, res; 11757 xmlXPathStepOpPtr exprOp; 11758 xmlXPathObjectPtr contextObj = NULL, exprRes = NULL; 11759 xmlNodePtr oldContextNode, contextNode = NULL; 11760 xmlXPathContextPtr xpctxt = ctxt->context; 11761 int frame; 11762 11763 #ifdef LIBXML_XPTR_ENABLED 11764 /* 11765 * URGENT TODO: Check the following: 11766 * We don't expect location sets if evaluating prediates, right? 11767 * Only filters should expect location sets, right? 11768 */ 11769 #endif /* LIBXML_XPTR_ENABLED */ 11770 11771 /* 11772 * Save old context. 11773 */ 11774 oldContextNode = xpctxt->node; 11775 oldContextDoc = xpctxt->doc; 11776 /* 11777 * Get the expression of this predicate. 11778 */ 11779 exprOp = &ctxt->comp->steps[op->ch2]; 11780 for (i = 0; i < set->nodeNr; i++) { 11781 xmlXPathObjectPtr tmp; 11782 11783 if (set->nodeTab[i] == NULL) 11784 continue; 11785 11786 contextNode = set->nodeTab[i]; 11787 xpctxt->node = contextNode; 11788 xpctxt->contextSize = contextSize; 11789 xpctxt->proximityPosition = ++contextPos; 11790 11791 /* 11792 * Initialize the new set. 11793 * Also set the xpath document in case things like 11794 * key() evaluation are attempted on the predicate 11795 */ 11796 if ((contextNode->type != XML_NAMESPACE_DECL) && 11797 (contextNode->doc != NULL)) 11798 xpctxt->doc = contextNode->doc; 11799 /* 11800 * Evaluate the predicate expression with 1 context node 11801 * at a time; this node is packaged into a node set; this 11802 * node set is handed over to the evaluation mechanism. 11803 */ 11804 if (contextObj == NULL) 11805 contextObj = xmlXPathCacheNewNodeSet(xpctxt, contextNode); 11806 else 11807 xmlXPathNodeSetAddUnique(contextObj->nodesetval, 11808 contextNode); 11809 11810 frame = xmlXPathSetFrame(ctxt); 11811 valuePush(ctxt, contextObj); 11812 res = xmlXPathCompOpEvalToBoolean(ctxt, exprOp, 1); 11813 tmp = valuePop(ctxt); 11814 xmlXPathPopFrame(ctxt, frame); 11815 11816 if ((ctxt->error != XPATH_EXPRESSION_OK) || (res == -1)) { 11817 while (tmp != contextObj) { 11818 /* 11819 * Free up the result 11820 * then pop off contextObj, which will be freed later 11821 */ 11822 xmlXPathReleaseObject(xpctxt, tmp); 11823 tmp = valuePop(ctxt); 11824 } 11825 goto evaluation_error; 11826 } 11827 /* push the result back onto the stack */ 11828 valuePush(ctxt, tmp); 11829 11830 if (res) 11831 pos++; 11832 11833 if (res && (pos >= minPos) && (pos <= maxPos)) { 11834 /* 11835 * Fits in the requested range. 11836 */ 11837 newContextSize++; 11838 if (minPos == maxPos) { 11839 /* 11840 * Only 1 node was requested. 11841 */ 11842 if (contextNode->type == XML_NAMESPACE_DECL) { 11843 /* 11844 * As always: take care of those nasty 11845 * namespace nodes. 11846 */ 11847 set->nodeTab[i] = NULL; 11848 } 11849 xmlXPathNodeSetClear(set, hasNsNodes); 11850 set->nodeNr = 1; 11851 set->nodeTab[0] = contextNode; 11852 goto evaluation_exit; 11853 } 11854 if (pos == maxPos) { 11855 /* 11856 * We are done. 11857 */ 11858 xmlXPathNodeSetClearFromPos(set, i +1, hasNsNodes); 11859 goto evaluation_exit; 11860 } 11861 } else { 11862 /* 11863 * Remove the entry from the initial node set. 11864 */ 11865 set->nodeTab[i] = NULL; 11866 if (contextNode->type == XML_NAMESPACE_DECL) 11867 xmlXPathNodeSetFreeNs((xmlNsPtr) contextNode); 11868 } 11869 if (exprRes != NULL) { 11870 xmlXPathReleaseObject(ctxt->context, exprRes); 11871 exprRes = NULL; 11872 } 11873 if (ctxt->value == contextObj) { 11874 /* 11875 * Don't free the temporary XPath object holding the 11876 * context node, in order to avoid massive recreation 11877 * inside this loop. 11878 */ 11879 valuePop(ctxt); 11880 xmlXPathNodeSetClear(contextObj->nodesetval, hasNsNodes); 11881 } else { 11882 /* 11883 * The object was lost in the evaluation machinery. 11884 * Can this happen? Maybe in case of internal-errors. 11885 */ 11886 contextObj = NULL; 11887 } 11888 } 11889 goto evaluation_exit; 11890 11891 evaluation_error: 11892 xmlXPathNodeSetClear(set, hasNsNodes); 11893 newContextSize = 0; 11894 11895 evaluation_exit: 11896 if (contextObj != NULL) { 11897 if (ctxt->value == contextObj) 11898 valuePop(ctxt); 11899 xmlXPathReleaseObject(xpctxt, contextObj); 11900 } 11901 if (exprRes != NULL) 11902 xmlXPathReleaseObject(ctxt->context, exprRes); 11903 /* 11904 * Reset/invalidate the context. 11905 */ 11906 xpctxt->node = oldContextNode; 11907 xpctxt->doc = oldContextDoc; 11908 xpctxt->contextSize = -1; 11909 xpctxt->proximityPosition = -1; 11910 return(newContextSize); 11911 } 11912 return(contextSize); 11913 } 11914 11915 static int 11916 xmlXPathIsPositionalPredicate(xmlXPathParserContextPtr ctxt, 11917 xmlXPathStepOpPtr op, 11918 int *maxPos) 11919 { 11920 11921 xmlXPathStepOpPtr exprOp; 11922 11923 /* 11924 * BIG NOTE: This is not intended for XPATH_OP_FILTER yet! 11925 */ 11926 11927 /* 11928 * If not -1, then ch1 will point to: 11929 * 1) For predicates (XPATH_OP_PREDICATE): 11930 * - an inner predicate operator 11931 * 2) For filters (XPATH_OP_FILTER): 11932 * - an inner filter operater OR 11933 * - an expression selecting the node set. 11934 * E.g. "key('a', 'b')" or "(//foo | //bar)". 11935 */ 11936 if ((op->op != XPATH_OP_PREDICATE) && (op->op != XPATH_OP_FILTER)) 11937 return(0); 11938 11939 if (op->ch2 != -1) { 11940 exprOp = &ctxt->comp->steps[op->ch2]; 11941 } else 11942 return(0); 11943 11944 if ((exprOp != NULL) && 11945 (exprOp->op == XPATH_OP_VALUE) && 11946 (exprOp->value4 != NULL) && 11947 (((xmlXPathObjectPtr) exprOp->value4)->type == XPATH_NUMBER)) 11948 { 11949 /* 11950 * We have a "[n]" predicate here. 11951 * TODO: Unfortunately this simplistic test here is not 11952 * able to detect a position() predicate in compound 11953 * expressions like "[@attr = 'a" and position() = 1], 11954 * and even not the usage of position() in 11955 * "[position() = 1]"; thus - obviously - a position-range, 11956 * like it "[position() < 5]", is also not detected. 11957 * Maybe we could rewrite the AST to ease the optimization. 11958 */ 11959 *maxPos = (int) ((xmlXPathObjectPtr) exprOp->value4)->floatval; 11960 11961 if (((xmlXPathObjectPtr) exprOp->value4)->floatval == 11962 (float) *maxPos) 11963 { 11964 return(1); 11965 } 11966 } 11967 return(0); 11968 } 11969 11970 static int 11971 xmlXPathNodeCollectAndTest(xmlXPathParserContextPtr ctxt, 11972 xmlXPathStepOpPtr op, 11973 xmlNodePtr * first, xmlNodePtr * last, 11974 int toBool) 11975 { 11976 11977 #define XP_TEST_HIT \ 11978 if (hasAxisRange != 0) { \ 11979 if (++pos == maxPos) { \ 11980 addNode(seq, cur); \ 11981 goto axis_range_end; } \ 11982 } else { \ 11983 addNode(seq, cur); \ 11984 if (breakOnFirstHit) goto first_hit; } 11985 11986 #define XP_TEST_HIT_NS \ 11987 if (hasAxisRange != 0) { \ 11988 if (++pos == maxPos) { \ 11989 hasNsNodes = 1; \ 11990 xmlXPathNodeSetAddNs(seq, xpctxt->node, (xmlNsPtr) cur); \ 11991 goto axis_range_end; } \ 11992 } else { \ 11993 hasNsNodes = 1; \ 11994 xmlXPathNodeSetAddNs(seq, \ 11995 xpctxt->node, (xmlNsPtr) cur); \ 11996 if (breakOnFirstHit) goto first_hit; } 11997 11998 xmlXPathAxisVal axis = (xmlXPathAxisVal) op->value; 11999 xmlXPathTestVal test = (xmlXPathTestVal) op->value2; 12000 xmlXPathTypeVal type = (xmlXPathTypeVal) op->value3; 12001 const xmlChar *prefix = op->value4; 12002 const xmlChar *name = op->value5; 12003 const xmlChar *URI = NULL; 12004 12005 #ifdef DEBUG_STEP 12006 int nbMatches = 0, prevMatches = 0; 12007 #endif 12008 int total = 0, hasNsNodes = 0; 12009 /* The popped object holding the context nodes */ 12010 xmlXPathObjectPtr obj; 12011 /* The set of context nodes for the node tests */ 12012 xmlNodeSetPtr contextSeq; 12013 int contextIdx; 12014 xmlNodePtr contextNode; 12015 /* The context node for a compound traversal */ 12016 xmlNodePtr outerContextNode; 12017 /* The final resulting node set wrt to all context nodes */ 12018 xmlNodeSetPtr outSeq; 12019 /* 12020 * The temporary resulting node set wrt 1 context node. 12021 * Used to feed predicate evaluation. 12022 */ 12023 xmlNodeSetPtr seq; 12024 xmlNodePtr cur; 12025 /* First predicate operator */ 12026 xmlXPathStepOpPtr predOp; 12027 int maxPos; /* The requested position() (when a "[n]" predicate) */ 12028 int hasPredicateRange, hasAxisRange, pos, size, newSize; 12029 int breakOnFirstHit; 12030 12031 xmlXPathTraversalFunction next = NULL; 12032 /* compound axis traversal */ 12033 xmlXPathTraversalFunctionExt outerNext = NULL; 12034 void (*addNode) (xmlNodeSetPtr, xmlNodePtr); 12035 xmlXPathNodeSetMergeFunction mergeAndClear; 12036 xmlNodePtr oldContextNode; 12037 xmlXPathContextPtr xpctxt = ctxt->context; 12038 12039 12040 CHECK_TYPE0(XPATH_NODESET); 12041 obj = valuePop(ctxt); 12042 /* 12043 * Setup namespaces. 12044 */ 12045 if (prefix != NULL) { 12046 URI = xmlXPathNsLookup(xpctxt, prefix); 12047 if (URI == NULL) { 12048 xmlXPathReleaseObject(xpctxt, obj); 12049 XP_ERROR0(XPATH_UNDEF_PREFIX_ERROR); 12050 } 12051 } 12052 /* 12053 * Setup axis. 12054 * 12055 * MAYBE FUTURE TODO: merging optimizations: 12056 * - If the nodes to be traversed wrt to the initial nodes and 12057 * the current axis cannot overlap, then we could avoid searching 12058 * for duplicates during the merge. 12059 * But the question is how/when to evaluate if they cannot overlap. 12060 * Example: if we know that for two initial nodes, the one is 12061 * not in the ancestor-or-self axis of the other, then we could safely 12062 * avoid a duplicate-aware merge, if the axis to be traversed is e.g. 12063 * the descendant-or-self axis. 12064 */ 12065 mergeAndClear = xmlXPathNodeSetMergeAndClear; 12066 switch (axis) { 12067 case AXIS_ANCESTOR: 12068 first = NULL; 12069 next = xmlXPathNextAncestor; 12070 break; 12071 case AXIS_ANCESTOR_OR_SELF: 12072 first = NULL; 12073 next = xmlXPathNextAncestorOrSelf; 12074 break; 12075 case AXIS_ATTRIBUTE: 12076 first = NULL; 12077 last = NULL; 12078 next = xmlXPathNextAttribute; 12079 mergeAndClear = xmlXPathNodeSetMergeAndClearNoDupls; 12080 break; 12081 case AXIS_CHILD: 12082 last = NULL; 12083 if (op->rewriteType == XP_REWRITE_DOS_CHILD_ELEM) { 12084 /* 12085 * This iterator will give us only nodes which can 12086 * hold element nodes. 12087 */ 12088 outerNext = xmlXPathNextDescendantOrSelfElemParent; 12089 } 12090 if (((test == NODE_TEST_NAME) || (test == NODE_TEST_ALL)) && 12091 (type == NODE_TYPE_NODE)) 12092 { 12093 /* 12094 * Optimization if an element node type is 'element'. 12095 */ 12096 next = xmlXPathNextChildElement; 12097 } else 12098 next = xmlXPathNextChild; 12099 mergeAndClear = xmlXPathNodeSetMergeAndClearNoDupls; 12100 break; 12101 case AXIS_DESCENDANT: 12102 last = NULL; 12103 next = xmlXPathNextDescendant; 12104 break; 12105 case AXIS_DESCENDANT_OR_SELF: 12106 last = NULL; 12107 next = xmlXPathNextDescendantOrSelf; 12108 break; 12109 case AXIS_FOLLOWING: 12110 last = NULL; 12111 next = xmlXPathNextFollowing; 12112 break; 12113 case AXIS_FOLLOWING_SIBLING: 12114 last = NULL; 12115 next = xmlXPathNextFollowingSibling; 12116 break; 12117 case AXIS_NAMESPACE: 12118 first = NULL; 12119 last = NULL; 12120 next = (xmlXPathTraversalFunction) xmlXPathNextNamespace; 12121 mergeAndClear = xmlXPathNodeSetMergeAndClearNoDupls; 12122 break; 12123 case AXIS_PARENT: 12124 first = NULL; 12125 next = xmlXPathNextParent; 12126 break; 12127 case AXIS_PRECEDING: 12128 first = NULL; 12129 next = xmlXPathNextPrecedingInternal; 12130 break; 12131 case AXIS_PRECEDING_SIBLING: 12132 first = NULL; 12133 next = xmlXPathNextPrecedingSibling; 12134 break; 12135 case AXIS_SELF: 12136 first = NULL; 12137 last = NULL; 12138 next = xmlXPathNextSelf; 12139 mergeAndClear = xmlXPathNodeSetMergeAndClearNoDupls; 12140 break; 12141 } 12142 12143 #ifdef DEBUG_STEP 12144 xmlXPathDebugDumpStepAxis(op, 12145 (obj->nodesetval != NULL) ? obj->nodesetval->nodeNr : 0); 12146 #endif 12147 12148 if (next == NULL) { 12149 xmlXPathReleaseObject(xpctxt, obj); 12150 return(0); 12151 } 12152 contextSeq = obj->nodesetval; 12153 if ((contextSeq == NULL) || (contextSeq->nodeNr <= 0)) { 12154 xmlXPathReleaseObject(xpctxt, obj); 12155 valuePush(ctxt, xmlXPathCacheWrapNodeSet(xpctxt, NULL)); 12156 return(0); 12157 } 12158 /* 12159 * Predicate optimization --------------------------------------------- 12160 * If this step has a last predicate, which contains a position(), 12161 * then we'll optimize (although not exactly "position()", but only 12162 * the short-hand form, i.e., "[n]". 12163 * 12164 * Example - expression "/foo[parent::bar][1]": 12165 * 12166 * COLLECT 'child' 'name' 'node' foo -- op (we are here) 12167 * ROOT -- op->ch1 12168 * PREDICATE -- op->ch2 (predOp) 12169 * PREDICATE -- predOp->ch1 = [parent::bar] 12170 * SORT 12171 * COLLECT 'parent' 'name' 'node' bar 12172 * NODE 12173 * ELEM Object is a number : 1 -- predOp->ch2 = [1] 12174 * 12175 */ 12176 maxPos = 0; 12177 predOp = NULL; 12178 hasPredicateRange = 0; 12179 hasAxisRange = 0; 12180 if (op->ch2 != -1) { 12181 /* 12182 * There's at least one predicate. 16 == XPATH_OP_PREDICATE 12183 */ 12184 predOp = &ctxt->comp->steps[op->ch2]; 12185 if (xmlXPathIsPositionalPredicate(ctxt, predOp, &maxPos)) { 12186 if (predOp->ch1 != -1) { 12187 /* 12188 * Use the next inner predicate operator. 12189 */ 12190 predOp = &ctxt->comp->steps[predOp->ch1]; 12191 hasPredicateRange = 1; 12192 } else { 12193 /* 12194 * There's no other predicate than the [n] predicate. 12195 */ 12196 predOp = NULL; 12197 hasAxisRange = 1; 12198 } 12199 } 12200 } 12201 breakOnFirstHit = ((toBool) && (predOp == NULL)) ? 1 : 0; 12202 /* 12203 * Axis traversal ----------------------------------------------------- 12204 */ 12205 /* 12206 * 2.3 Node Tests 12207 * - For the attribute axis, the principal node type is attribute. 12208 * - For the namespace axis, the principal node type is namespace. 12209 * - For other axes, the principal node type is element. 12210 * 12211 * A node test * is true for any node of the 12212 * principal node type. For example, child::* will 12213 * select all element children of the context node 12214 */ 12215 oldContextNode = xpctxt->node; 12216 addNode = xmlXPathNodeSetAddUnique; 12217 outSeq = NULL; 12218 seq = NULL; 12219 outerContextNode = NULL; 12220 contextNode = NULL; 12221 contextIdx = 0; 12222 12223 12224 while ((contextIdx < contextSeq->nodeNr) || (contextNode != NULL)) { 12225 if (outerNext != NULL) { 12226 /* 12227 * This is a compound traversal. 12228 */ 12229 if (contextNode == NULL) { 12230 /* 12231 * Set the context for the outer traversal. 12232 */ 12233 outerContextNode = contextSeq->nodeTab[contextIdx++]; 12234 contextNode = outerNext(NULL, outerContextNode); 12235 } else 12236 contextNode = outerNext(contextNode, outerContextNode); 12237 if (contextNode == NULL) 12238 continue; 12239 /* 12240 * Set the context for the main traversal. 12241 */ 12242 xpctxt->node = contextNode; 12243 } else 12244 xpctxt->node = contextSeq->nodeTab[contextIdx++]; 12245 12246 if (seq == NULL) { 12247 seq = xmlXPathNodeSetCreate(NULL); 12248 if (seq == NULL) { 12249 total = 0; 12250 goto error; 12251 } 12252 } 12253 /* 12254 * Traverse the axis and test the nodes. 12255 */ 12256 pos = 0; 12257 cur = NULL; 12258 hasNsNodes = 0; 12259 do { 12260 cur = next(ctxt, cur); 12261 if (cur == NULL) 12262 break; 12263 12264 /* 12265 * QUESTION TODO: What does the "first" and "last" stuff do? 12266 */ 12267 if ((first != NULL) && (*first != NULL)) { 12268 if (*first == cur) 12269 break; 12270 if (((total % 256) == 0) && 12271 #ifdef XP_OPTIMIZED_NON_ELEM_COMPARISON 12272 (xmlXPathCmpNodesExt(*first, cur) >= 0)) 12273 #else 12274 (xmlXPathCmpNodes(*first, cur) >= 0)) 12275 #endif 12276 { 12277 break; 12278 } 12279 } 12280 if ((last != NULL) && (*last != NULL)) { 12281 if (*last == cur) 12282 break; 12283 if (((total % 256) == 0) && 12284 #ifdef XP_OPTIMIZED_NON_ELEM_COMPARISON 12285 (xmlXPathCmpNodesExt(cur, *last) >= 0)) 12286 #else 12287 (xmlXPathCmpNodes(cur, *last) >= 0)) 12288 #endif 12289 { 12290 break; 12291 } 12292 } 12293 12294 total++; 12295 12296 #ifdef DEBUG_STEP 12297 xmlGenericError(xmlGenericErrorContext, " %s", cur->name); 12298 #endif 12299 12300 switch (test) { 12301 case NODE_TEST_NONE: 12302 total = 0; 12303 STRANGE 12304 goto error; 12305 case NODE_TEST_TYPE: 12306 /* 12307 * TODO: Don't we need to use 12308 * xmlXPathNodeSetAddNs() for namespace nodes here? 12309 * Surprisingly, some c14n tests fail, if we do this. 12310 */ 12311 if (type == NODE_TYPE_NODE) { 12312 switch (cur->type) { 12313 case XML_DOCUMENT_NODE: 12314 case XML_HTML_DOCUMENT_NODE: 12315 #ifdef LIBXML_DOCB_ENABLED 12316 case XML_DOCB_DOCUMENT_NODE: 12317 #endif 12318 case XML_ELEMENT_NODE: 12319 case XML_ATTRIBUTE_NODE: 12320 case XML_PI_NODE: 12321 case XML_COMMENT_NODE: 12322 case XML_CDATA_SECTION_NODE: 12323 case XML_TEXT_NODE: 12324 case XML_NAMESPACE_DECL: 12325 XP_TEST_HIT 12326 break; 12327 default: 12328 break; 12329 } 12330 } else if (cur->type == type) { 12331 if (type == XML_NAMESPACE_DECL) 12332 XP_TEST_HIT_NS 12333 else 12334 XP_TEST_HIT 12335 } else if ((type == NODE_TYPE_TEXT) && 12336 (cur->type == XML_CDATA_SECTION_NODE)) 12337 { 12338 XP_TEST_HIT 12339 } 12340 break; 12341 case NODE_TEST_PI: 12342 if ((cur->type == XML_PI_NODE) && 12343 ((name == NULL) || xmlStrEqual(name, cur->name))) 12344 { 12345 XP_TEST_HIT 12346 } 12347 break; 12348 case NODE_TEST_ALL: 12349 if (axis == AXIS_ATTRIBUTE) { 12350 if (cur->type == XML_ATTRIBUTE_NODE) 12351 { 12352 XP_TEST_HIT 12353 } 12354 } else if (axis == AXIS_NAMESPACE) { 12355 if (cur->type == XML_NAMESPACE_DECL) 12356 { 12357 XP_TEST_HIT_NS 12358 } 12359 } else { 12360 if (cur->type == XML_ELEMENT_NODE) { 12361 if (prefix == NULL) 12362 { 12363 XP_TEST_HIT 12364 12365 } else if ((cur->ns != NULL) && 12366 (xmlStrEqual(URI, cur->ns->href))) 12367 { 12368 XP_TEST_HIT 12369 } 12370 } 12371 } 12372 break; 12373 case NODE_TEST_NS:{ 12374 TODO; 12375 break; 12376 } 12377 case NODE_TEST_NAME: 12378 if (axis == AXIS_ATTRIBUTE) { 12379 if (cur->type != XML_ATTRIBUTE_NODE) 12380 break; 12381 } else if (axis == AXIS_NAMESPACE) { 12382 if (cur->type != XML_NAMESPACE_DECL) 12383 break; 12384 } else { 12385 if (cur->type != XML_ELEMENT_NODE) 12386 break; 12387 } 12388 switch (cur->type) { 12389 case XML_ELEMENT_NODE: 12390 if (xmlStrEqual(name, cur->name)) { 12391 if (prefix == NULL) { 12392 if (cur->ns == NULL) 12393 { 12394 XP_TEST_HIT 12395 } 12396 } else { 12397 if ((cur->ns != NULL) && 12398 (xmlStrEqual(URI, cur->ns->href))) 12399 { 12400 XP_TEST_HIT 12401 } 12402 } 12403 } 12404 break; 12405 case XML_ATTRIBUTE_NODE:{ 12406 xmlAttrPtr attr = (xmlAttrPtr) cur; 12407 12408 if (xmlStrEqual(name, attr->name)) { 12409 if (prefix == NULL) { 12410 if ((attr->ns == NULL) || 12411 (attr->ns->prefix == NULL)) 12412 { 12413 XP_TEST_HIT 12414 } 12415 } else { 12416 if ((attr->ns != NULL) && 12417 (xmlStrEqual(URI, 12418 attr->ns->href))) 12419 { 12420 XP_TEST_HIT 12421 } 12422 } 12423 } 12424 break; 12425 } 12426 case XML_NAMESPACE_DECL: 12427 if (cur->type == XML_NAMESPACE_DECL) { 12428 xmlNsPtr ns = (xmlNsPtr) cur; 12429 12430 if ((ns->prefix != NULL) && (name != NULL) 12431 && (xmlStrEqual(ns->prefix, name))) 12432 { 12433 XP_TEST_HIT_NS 12434 } 12435 } 12436 break; 12437 default: 12438 break; 12439 } 12440 break; 12441 } /* switch(test) */ 12442 } while (cur != NULL); 12443 12444 goto apply_predicates; 12445 12446 axis_range_end: /* ----------------------------------------------------- */ 12447 /* 12448 * We have a "/foo[n]", and position() = n was reached. 12449 * Note that we can have as well "/foo/::parent::foo[1]", so 12450 * a duplicate-aware merge is still needed. 12451 * Merge with the result. 12452 */ 12453 if (outSeq == NULL) { 12454 outSeq = seq; 12455 seq = NULL; 12456 } else 12457 outSeq = mergeAndClear(outSeq, seq, 0); 12458 /* 12459 * Break if only a true/false result was requested. 12460 */ 12461 if (toBool) 12462 break; 12463 continue; 12464 12465 first_hit: /* ---------------------------------------------------------- */ 12466 /* 12467 * Break if only a true/false result was requested and 12468 * no predicates existed and a node test succeeded. 12469 */ 12470 if (outSeq == NULL) { 12471 outSeq = seq; 12472 seq = NULL; 12473 } else 12474 outSeq = mergeAndClear(outSeq, seq, 0); 12475 break; 12476 12477 #ifdef DEBUG_STEP 12478 if (seq != NULL) 12479 nbMatches += seq->nodeNr; 12480 #endif 12481 12482 apply_predicates: /* --------------------------------------------------- */ 12483 /* 12484 * Apply predicates. 12485 */ 12486 if ((predOp != NULL) && (seq->nodeNr > 0)) { 12487 /* 12488 * E.g. when we have a "/foo[some expression][n]". 12489 */ 12490 /* 12491 * QUESTION TODO: The old predicate evaluation took into 12492 * account location-sets. 12493 * (E.g. ctxt->value->type == XPATH_LOCATIONSET) 12494 * Do we expect such a set here? 12495 * All what I learned now from the evaluation semantics 12496 * does not indicate that a location-set will be processed 12497 * here, so this looks OK. 12498 */ 12499 /* 12500 * Iterate over all predicates, starting with the outermost 12501 * predicate. 12502 * TODO: Problem: we cannot execute the inner predicates first 12503 * since we cannot go back *up* the operator tree! 12504 * Options we have: 12505 * 1) Use of recursive functions (like is it currently done 12506 * via xmlXPathCompOpEval()) 12507 * 2) Add a predicate evaluation information stack to the 12508 * context struct 12509 * 3) Change the way the operators are linked; we need a 12510 * "parent" field on xmlXPathStepOp 12511 * 12512 * For the moment, I'll try to solve this with a recursive 12513 * function: xmlXPathCompOpEvalPredicate(). 12514 */ 12515 size = seq->nodeNr; 12516 if (hasPredicateRange != 0) 12517 newSize = xmlXPathCompOpEvalPositionalPredicate(ctxt, 12518 predOp, seq, size, maxPos, maxPos, hasNsNodes); 12519 else 12520 newSize = xmlXPathCompOpEvalPredicate(ctxt, 12521 predOp, seq, size, hasNsNodes); 12522 12523 if (ctxt->error != XPATH_EXPRESSION_OK) { 12524 total = 0; 12525 goto error; 12526 } 12527 /* 12528 * Add the filtered set of nodes to the result node set. 12529 */ 12530 if (newSize == 0) { 12531 /* 12532 * The predicates filtered all nodes out. 12533 */ 12534 xmlXPathNodeSetClear(seq, hasNsNodes); 12535 } else if (seq->nodeNr > 0) { 12536 /* 12537 * Add to result set. 12538 */ 12539 if (outSeq == NULL) { 12540 if (size != newSize) { 12541 /* 12542 * We need to merge and clear here, since 12543 * the sequence will contained NULLed entries. 12544 */ 12545 outSeq = mergeAndClear(NULL, seq, 1); 12546 } else { 12547 outSeq = seq; 12548 seq = NULL; 12549 } 12550 } else 12551 outSeq = mergeAndClear(outSeq, seq, 12552 (size != newSize) ? 1: 0); 12553 /* 12554 * Break if only a true/false result was requested. 12555 */ 12556 if (toBool) 12557 break; 12558 } 12559 } else if (seq->nodeNr > 0) { 12560 /* 12561 * Add to result set. 12562 */ 12563 if (outSeq == NULL) { 12564 outSeq = seq; 12565 seq = NULL; 12566 } else { 12567 outSeq = mergeAndClear(outSeq, seq, 0); 12568 } 12569 } 12570 } 12571 12572 error: 12573 if ((obj->boolval) && (obj->user != NULL)) { 12574 /* 12575 * QUESTION TODO: What does this do and why? 12576 * TODO: Do we have to do this also for the "error" 12577 * cleanup further down? 12578 */ 12579 ctxt->value->boolval = 1; 12580 ctxt->value->user = obj->user; 12581 obj->user = NULL; 12582 obj->boolval = 0; 12583 } 12584 xmlXPathReleaseObject(xpctxt, obj); 12585 12586 /* 12587 * Ensure we return at least an emtpy set. 12588 */ 12589 if (outSeq == NULL) { 12590 if ((seq != NULL) && (seq->nodeNr == 0)) 12591 outSeq = seq; 12592 else 12593 outSeq = xmlXPathNodeSetCreate(NULL); 12594 /* XXX what if xmlXPathNodeSetCreate returned NULL here? */ 12595 } 12596 if ((seq != NULL) && (seq != outSeq)) { 12597 xmlXPathFreeNodeSet(seq); 12598 } 12599 /* 12600 * Hand over the result. Better to push the set also in 12601 * case of errors. 12602 */ 12603 valuePush(ctxt, xmlXPathCacheWrapNodeSet(xpctxt, outSeq)); 12604 /* 12605 * Reset the context node. 12606 */ 12607 xpctxt->node = oldContextNode; 12608 12609 #ifdef DEBUG_STEP 12610 xmlGenericError(xmlGenericErrorContext, 12611 "\nExamined %d nodes, found %d nodes at that step\n", 12612 total, nbMatches); 12613 #endif 12614 12615 return(total); 12616 } 12617 12618 static int 12619 xmlXPathCompOpEvalFilterFirst(xmlXPathParserContextPtr ctxt, 12620 xmlXPathStepOpPtr op, xmlNodePtr * first); 12621 12622 /** 12623 * xmlXPathCompOpEvalFirst: 12624 * @ctxt: the XPath parser context with the compiled expression 12625 * @op: an XPath compiled operation 12626 * @first: the first elem found so far 12627 * 12628 * Evaluate the Precompiled XPath operation searching only the first 12629 * element in document order 12630 * 12631 * Returns the number of examined objects. 12632 */ 12633 static int 12634 xmlXPathCompOpEvalFirst(xmlXPathParserContextPtr ctxt, 12635 xmlXPathStepOpPtr op, xmlNodePtr * first) 12636 { 12637 int total = 0, cur; 12638 xmlXPathCompExprPtr comp; 12639 xmlXPathObjectPtr arg1, arg2; 12640 12641 CHECK_ERROR0; 12642 comp = ctxt->comp; 12643 switch (op->op) { 12644 case XPATH_OP_END: 12645 return (0); 12646 case XPATH_OP_UNION: 12647 total = 12648 xmlXPathCompOpEvalFirst(ctxt, &comp->steps[op->ch1], 12649 first); 12650 CHECK_ERROR0; 12651 if ((ctxt->value != NULL) 12652 && (ctxt->value->type == XPATH_NODESET) 12653 && (ctxt->value->nodesetval != NULL) 12654 && (ctxt->value->nodesetval->nodeNr >= 1)) { 12655 /* 12656 * limit tree traversing to first node in the result 12657 */ 12658 /* 12659 * OPTIMIZE TODO: This implicitely sorts 12660 * the result, even if not needed. E.g. if the argument 12661 * of the count() function, no sorting is needed. 12662 * OPTIMIZE TODO: How do we know if the node-list wasn't 12663 * aready sorted? 12664 */ 12665 if (ctxt->value->nodesetval->nodeNr > 1) 12666 xmlXPathNodeSetSort(ctxt->value->nodesetval); 12667 *first = ctxt->value->nodesetval->nodeTab[0]; 12668 } 12669 cur = 12670 xmlXPathCompOpEvalFirst(ctxt, &comp->steps[op->ch2], 12671 first); 12672 CHECK_ERROR0; 12673 CHECK_TYPE0(XPATH_NODESET); 12674 arg2 = valuePop(ctxt); 12675 12676 CHECK_TYPE0(XPATH_NODESET); 12677 arg1 = valuePop(ctxt); 12678 12679 arg1->nodesetval = xmlXPathNodeSetMerge(arg1->nodesetval, 12680 arg2->nodesetval); 12681 valuePush(ctxt, arg1); 12682 xmlXPathReleaseObject(ctxt->context, arg2); 12683 /* optimizer */ 12684 if (total > cur) 12685 xmlXPathCompSwap(op); 12686 return (total + cur); 12687 case XPATH_OP_ROOT: 12688 xmlXPathRoot(ctxt); 12689 return (0); 12690 case XPATH_OP_NODE: 12691 if (op->ch1 != -1) 12692 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]); 12693 CHECK_ERROR0; 12694 if (op->ch2 != -1) 12695 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]); 12696 CHECK_ERROR0; 12697 valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context, 12698 ctxt->context->node)); 12699 return (total); 12700 case XPATH_OP_RESET: 12701 if (op->ch1 != -1) 12702 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]); 12703 CHECK_ERROR0; 12704 if (op->ch2 != -1) 12705 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]); 12706 CHECK_ERROR0; 12707 ctxt->context->node = NULL; 12708 return (total); 12709 case XPATH_OP_COLLECT:{ 12710 if (op->ch1 == -1) 12711 return (total); 12712 12713 total = xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]); 12714 CHECK_ERROR0; 12715 12716 total += xmlXPathNodeCollectAndTest(ctxt, op, first, NULL, 0); 12717 return (total); 12718 } 12719 case XPATH_OP_VALUE: 12720 valuePush(ctxt, 12721 xmlXPathCacheObjectCopy(ctxt->context, 12722 (xmlXPathObjectPtr) op->value4)); 12723 return (0); 12724 case XPATH_OP_SORT: 12725 if (op->ch1 != -1) 12726 total += 12727 xmlXPathCompOpEvalFirst(ctxt, &comp->steps[op->ch1], 12728 first); 12729 CHECK_ERROR0; 12730 if ((ctxt->value != NULL) 12731 && (ctxt->value->type == XPATH_NODESET) 12732 && (ctxt->value->nodesetval != NULL) 12733 && (ctxt->value->nodesetval->nodeNr > 1)) 12734 xmlXPathNodeSetSort(ctxt->value->nodesetval); 12735 return (total); 12736 #ifdef XP_OPTIMIZED_FILTER_FIRST 12737 case XPATH_OP_FILTER: 12738 total += xmlXPathCompOpEvalFilterFirst(ctxt, op, first); 12739 return (total); 12740 #endif 12741 default: 12742 return (xmlXPathCompOpEval(ctxt, op)); 12743 } 12744 } 12745 12746 /** 12747 * xmlXPathCompOpEvalLast: 12748 * @ctxt: the XPath parser context with the compiled expression 12749 * @op: an XPath compiled operation 12750 * @last: the last elem found so far 12751 * 12752 * Evaluate the Precompiled XPath operation searching only the last 12753 * element in document order 12754 * 12755 * Returns the number of nodes traversed 12756 */ 12757 static int 12758 xmlXPathCompOpEvalLast(xmlXPathParserContextPtr ctxt, xmlXPathStepOpPtr op, 12759 xmlNodePtr * last) 12760 { 12761 int total = 0, cur; 12762 xmlXPathCompExprPtr comp; 12763 xmlXPathObjectPtr arg1, arg2; 12764 xmlNodePtr bak; 12765 xmlDocPtr bakd; 12766 int pp; 12767 int cs; 12768 12769 CHECK_ERROR0; 12770 comp = ctxt->comp; 12771 switch (op->op) { 12772 case XPATH_OP_END: 12773 return (0); 12774 case XPATH_OP_UNION: 12775 bakd = ctxt->context->doc; 12776 bak = ctxt->context->node; 12777 pp = ctxt->context->proximityPosition; 12778 cs = ctxt->context->contextSize; 12779 total = 12780 xmlXPathCompOpEvalLast(ctxt, &comp->steps[op->ch1], last); 12781 CHECK_ERROR0; 12782 if ((ctxt->value != NULL) 12783 && (ctxt->value->type == XPATH_NODESET) 12784 && (ctxt->value->nodesetval != NULL) 12785 && (ctxt->value->nodesetval->nodeNr >= 1)) { 12786 /* 12787 * limit tree traversing to first node in the result 12788 */ 12789 if (ctxt->value->nodesetval->nodeNr > 1) 12790 xmlXPathNodeSetSort(ctxt->value->nodesetval); 12791 *last = 12792 ctxt->value->nodesetval->nodeTab[ctxt->value-> 12793 nodesetval->nodeNr - 12794 1]; 12795 } 12796 ctxt->context->doc = bakd; 12797 ctxt->context->node = bak; 12798 ctxt->context->proximityPosition = pp; 12799 ctxt->context->contextSize = cs; 12800 cur = 12801 xmlXPathCompOpEvalLast(ctxt, &comp->steps[op->ch2], last); 12802 CHECK_ERROR0; 12803 if ((ctxt->value != NULL) 12804 && (ctxt->value->type == XPATH_NODESET) 12805 && (ctxt->value->nodesetval != NULL) 12806 && (ctxt->value->nodesetval->nodeNr >= 1)) { /* TODO: NOP ? */ 12807 } 12808 CHECK_TYPE0(XPATH_NODESET); 12809 arg2 = valuePop(ctxt); 12810 12811 CHECK_TYPE0(XPATH_NODESET); 12812 arg1 = valuePop(ctxt); 12813 12814 arg1->nodesetval = xmlXPathNodeSetMerge(arg1->nodesetval, 12815 arg2->nodesetval); 12816 valuePush(ctxt, arg1); 12817 xmlXPathReleaseObject(ctxt->context, arg2); 12818 /* optimizer */ 12819 if (total > cur) 12820 xmlXPathCompSwap(op); 12821 return (total + cur); 12822 case XPATH_OP_ROOT: 12823 xmlXPathRoot(ctxt); 12824 return (0); 12825 case XPATH_OP_NODE: 12826 if (op->ch1 != -1) 12827 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]); 12828 CHECK_ERROR0; 12829 if (op->ch2 != -1) 12830 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]); 12831 CHECK_ERROR0; 12832 valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context, 12833 ctxt->context->node)); 12834 return (total); 12835 case XPATH_OP_RESET: 12836 if (op->ch1 != -1) 12837 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]); 12838 CHECK_ERROR0; 12839 if (op->ch2 != -1) 12840 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]); 12841 CHECK_ERROR0; 12842 ctxt->context->node = NULL; 12843 return (total); 12844 case XPATH_OP_COLLECT:{ 12845 if (op->ch1 == -1) 12846 return (0); 12847 12848 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]); 12849 CHECK_ERROR0; 12850 12851 total += xmlXPathNodeCollectAndTest(ctxt, op, NULL, last, 0); 12852 return (total); 12853 } 12854 case XPATH_OP_VALUE: 12855 valuePush(ctxt, 12856 xmlXPathCacheObjectCopy(ctxt->context, 12857 (xmlXPathObjectPtr) op->value4)); 12858 return (0); 12859 case XPATH_OP_SORT: 12860 if (op->ch1 != -1) 12861 total += 12862 xmlXPathCompOpEvalLast(ctxt, &comp->steps[op->ch1], 12863 last); 12864 CHECK_ERROR0; 12865 if ((ctxt->value != NULL) 12866 && (ctxt->value->type == XPATH_NODESET) 12867 && (ctxt->value->nodesetval != NULL) 12868 && (ctxt->value->nodesetval->nodeNr > 1)) 12869 xmlXPathNodeSetSort(ctxt->value->nodesetval); 12870 return (total); 12871 default: 12872 return (xmlXPathCompOpEval(ctxt, op)); 12873 } 12874 } 12875 12876 #ifdef XP_OPTIMIZED_FILTER_FIRST 12877 static int 12878 xmlXPathCompOpEvalFilterFirst(xmlXPathParserContextPtr ctxt, 12879 xmlXPathStepOpPtr op, xmlNodePtr * first) 12880 { 12881 int total = 0; 12882 xmlXPathCompExprPtr comp; 12883 xmlXPathObjectPtr res; 12884 xmlXPathObjectPtr obj; 12885 xmlNodeSetPtr oldset; 12886 xmlNodePtr oldnode; 12887 xmlDocPtr oldDoc; 12888 int i; 12889 12890 CHECK_ERROR0; 12891 comp = ctxt->comp; 12892 /* 12893 * Optimization for ()[last()] selection i.e. the last elem 12894 */ 12895 if ((op->ch1 != -1) && (op->ch2 != -1) && 12896 (comp->steps[op->ch1].op == XPATH_OP_SORT) && 12897 (comp->steps[op->ch2].op == XPATH_OP_SORT)) { 12898 int f = comp->steps[op->ch2].ch1; 12899 12900 if ((f != -1) && 12901 (comp->steps[f].op == XPATH_OP_FUNCTION) && 12902 (comp->steps[f].value5 == NULL) && 12903 (comp->steps[f].value == 0) && 12904 (comp->steps[f].value4 != NULL) && 12905 (xmlStrEqual 12906 (comp->steps[f].value4, BAD_CAST "last"))) { 12907 xmlNodePtr last = NULL; 12908 12909 total += 12910 xmlXPathCompOpEvalLast(ctxt, 12911 &comp->steps[op->ch1], 12912 &last); 12913 CHECK_ERROR0; 12914 /* 12915 * The nodeset should be in document order, 12916 * Keep only the last value 12917 */ 12918 if ((ctxt->value != NULL) && 12919 (ctxt->value->type == XPATH_NODESET) && 12920 (ctxt->value->nodesetval != NULL) && 12921 (ctxt->value->nodesetval->nodeTab != NULL) && 12922 (ctxt->value->nodesetval->nodeNr > 1)) { 12923 ctxt->value->nodesetval->nodeTab[0] = 12924 ctxt->value->nodesetval->nodeTab[ctxt-> 12925 value-> 12926 nodesetval-> 12927 nodeNr - 12928 1]; 12929 ctxt->value->nodesetval->nodeNr = 1; 12930 *first = *(ctxt->value->nodesetval->nodeTab); 12931 } 12932 return (total); 12933 } 12934 } 12935 12936 if (op->ch1 != -1) 12937 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]); 12938 CHECK_ERROR0; 12939 if (op->ch2 == -1) 12940 return (total); 12941 if (ctxt->value == NULL) 12942 return (total); 12943 12944 #ifdef LIBXML_XPTR_ENABLED 12945 oldnode = ctxt->context->node; 12946 /* 12947 * Hum are we filtering the result of an XPointer expression 12948 */ 12949 if (ctxt->value->type == XPATH_LOCATIONSET) { 12950 xmlXPathObjectPtr tmp = NULL; 12951 xmlLocationSetPtr newlocset = NULL; 12952 xmlLocationSetPtr oldlocset; 12953 12954 /* 12955 * Extract the old locset, and then evaluate the result of the 12956 * expression for all the element in the locset. use it to grow 12957 * up a new locset. 12958 */ 12959 CHECK_TYPE0(XPATH_LOCATIONSET); 12960 obj = valuePop(ctxt); 12961 oldlocset = obj->user; 12962 ctxt->context->node = NULL; 12963 12964 if ((oldlocset == NULL) || (oldlocset->locNr == 0)) { 12965 ctxt->context->contextSize = 0; 12966 ctxt->context->proximityPosition = 0; 12967 if (op->ch2 != -1) 12968 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]); 12969 res = valuePop(ctxt); 12970 if (res != NULL) { 12971 xmlXPathReleaseObject(ctxt->context, res); 12972 } 12973 valuePush(ctxt, obj); 12974 CHECK_ERROR0; 12975 return (total); 12976 } 12977 newlocset = xmlXPtrLocationSetCreate(NULL); 12978 12979 for (i = 0; i < oldlocset->locNr; i++) { 12980 /* 12981 * Run the evaluation with a node list made of a 12982 * single item in the nodelocset. 12983 */ 12984 ctxt->context->node = oldlocset->locTab[i]->user; 12985 ctxt->context->contextSize = oldlocset->locNr; 12986 ctxt->context->proximityPosition = i + 1; 12987 if (tmp == NULL) { 12988 tmp = xmlXPathCacheNewNodeSet(ctxt->context, 12989 ctxt->context->node); 12990 } else { 12991 xmlXPathNodeSetAddUnique(tmp->nodesetval, 12992 ctxt->context->node); 12993 } 12994 valuePush(ctxt, tmp); 12995 if (op->ch2 != -1) 12996 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]); 12997 if (ctxt->error != XPATH_EXPRESSION_OK) { 12998 xmlXPathFreeObject(obj); 12999 return(0); 13000 } 13001 /* 13002 * The result of the evaluation need to be tested to 13003 * decided whether the filter succeeded or not 13004 */ 13005 res = valuePop(ctxt); 13006 if (xmlXPathEvaluatePredicateResult(ctxt, res)) { 13007 xmlXPtrLocationSetAdd(newlocset, 13008 xmlXPathCacheObjectCopy(ctxt->context, 13009 oldlocset->locTab[i])); 13010 } 13011 /* 13012 * Cleanup 13013 */ 13014 if (res != NULL) { 13015 xmlXPathReleaseObject(ctxt->context, res); 13016 } 13017 if (ctxt->value == tmp) { 13018 valuePop(ctxt); 13019 xmlXPathNodeSetClear(tmp->nodesetval, 1); 13020 /* 13021 * REVISIT TODO: Don't create a temporary nodeset 13022 * for everly iteration. 13023 */ 13024 /* OLD: xmlXPathFreeObject(res); */ 13025 } else 13026 tmp = NULL; 13027 ctxt->context->node = NULL; 13028 /* 13029 * Only put the first node in the result, then leave. 13030 */ 13031 if (newlocset->locNr > 0) { 13032 *first = (xmlNodePtr) oldlocset->locTab[i]->user; 13033 break; 13034 } 13035 } 13036 if (tmp != NULL) { 13037 xmlXPathReleaseObject(ctxt->context, tmp); 13038 } 13039 /* 13040 * The result is used as the new evaluation locset. 13041 */ 13042 xmlXPathReleaseObject(ctxt->context, obj); 13043 ctxt->context->node = NULL; 13044 ctxt->context->contextSize = -1; 13045 ctxt->context->proximityPosition = -1; 13046 valuePush(ctxt, xmlXPtrWrapLocationSet(newlocset)); 13047 ctxt->context->node = oldnode; 13048 return (total); 13049 } 13050 #endif /* LIBXML_XPTR_ENABLED */ 13051 13052 /* 13053 * Extract the old set, and then evaluate the result of the 13054 * expression for all the element in the set. use it to grow 13055 * up a new set. 13056 */ 13057 CHECK_TYPE0(XPATH_NODESET); 13058 obj = valuePop(ctxt); 13059 oldset = obj->nodesetval; 13060 13061 oldnode = ctxt->context->node; 13062 oldDoc = ctxt->context->doc; 13063 ctxt->context->node = NULL; 13064 13065 if ((oldset == NULL) || (oldset->nodeNr == 0)) { 13066 ctxt->context->contextSize = 0; 13067 ctxt->context->proximityPosition = 0; 13068 /* QUESTION TODO: Why was this code commented out? 13069 if (op->ch2 != -1) 13070 total += 13071 xmlXPathCompOpEval(ctxt, 13072 &comp->steps[op->ch2]); 13073 CHECK_ERROR0; 13074 res = valuePop(ctxt); 13075 if (res != NULL) 13076 xmlXPathFreeObject(res); 13077 */ 13078 valuePush(ctxt, obj); 13079 ctxt->context->node = oldnode; 13080 CHECK_ERROR0; 13081 } else { 13082 xmlNodeSetPtr newset; 13083 xmlXPathObjectPtr tmp = NULL; 13084 /* 13085 * Initialize the new set. 13086 * Also set the xpath document in case things like 13087 * key() evaluation are attempted on the predicate 13088 */ 13089 newset = xmlXPathNodeSetCreate(NULL); 13090 /* XXX what if xmlXPathNodeSetCreate returned NULL? */ 13091 13092 for (i = 0; i < oldset->nodeNr; i++) { 13093 /* 13094 * Run the evaluation with a node list made of 13095 * a single item in the nodeset. 13096 */ 13097 ctxt->context->node = oldset->nodeTab[i]; 13098 if ((oldset->nodeTab[i]->type != XML_NAMESPACE_DECL) && 13099 (oldset->nodeTab[i]->doc != NULL)) 13100 ctxt->context->doc = oldset->nodeTab[i]->doc; 13101 if (tmp == NULL) { 13102 tmp = xmlXPathCacheNewNodeSet(ctxt->context, 13103 ctxt->context->node); 13104 } else { 13105 xmlXPathNodeSetAddUnique(tmp->nodesetval, 13106 ctxt->context->node); 13107 } 13108 valuePush(ctxt, tmp); 13109 ctxt->context->contextSize = oldset->nodeNr; 13110 ctxt->context->proximityPosition = i + 1; 13111 if (op->ch2 != -1) 13112 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]); 13113 if (ctxt->error != XPATH_EXPRESSION_OK) { 13114 xmlXPathFreeNodeSet(newset); 13115 xmlXPathFreeObject(obj); 13116 return(0); 13117 } 13118 /* 13119 * The result of the evaluation needs to be tested to 13120 * decide whether the filter succeeded or not 13121 */ 13122 res = valuePop(ctxt); 13123 if (xmlXPathEvaluatePredicateResult(ctxt, res)) { 13124 xmlXPathNodeSetAdd(newset, oldset->nodeTab[i]); 13125 } 13126 /* 13127 * Cleanup 13128 */ 13129 if (res != NULL) { 13130 xmlXPathReleaseObject(ctxt->context, res); 13131 } 13132 if (ctxt->value == tmp) { 13133 valuePop(ctxt); 13134 /* 13135 * Don't free the temporary nodeset 13136 * in order to avoid massive recreation inside this 13137 * loop. 13138 */ 13139 xmlXPathNodeSetClear(tmp->nodesetval, 1); 13140 } else 13141 tmp = NULL; 13142 ctxt->context->node = NULL; 13143 /* 13144 * Only put the first node in the result, then leave. 13145 */ 13146 if (newset->nodeNr > 0) { 13147 *first = *(newset->nodeTab); 13148 break; 13149 } 13150 } 13151 if (tmp != NULL) { 13152 xmlXPathReleaseObject(ctxt->context, tmp); 13153 } 13154 /* 13155 * The result is used as the new evaluation set. 13156 */ 13157 xmlXPathReleaseObject(ctxt->context, obj); 13158 ctxt->context->node = NULL; 13159 ctxt->context->contextSize = -1; 13160 ctxt->context->proximityPosition = -1; 13161 /* may want to move this past the '}' later */ 13162 ctxt->context->doc = oldDoc; 13163 valuePush(ctxt, xmlXPathCacheWrapNodeSet(ctxt->context, newset)); 13164 } 13165 ctxt->context->node = oldnode; 13166 return(total); 13167 } 13168 #endif /* XP_OPTIMIZED_FILTER_FIRST */ 13169 13170 /** 13171 * xmlXPathCompOpEval: 13172 * @ctxt: the XPath parser context with the compiled expression 13173 * @op: an XPath compiled operation 13174 * 13175 * Evaluate the Precompiled XPath operation 13176 * Returns the number of nodes traversed 13177 */ 13178 static int 13179 xmlXPathCompOpEval(xmlXPathParserContextPtr ctxt, xmlXPathStepOpPtr op) 13180 { 13181 int total = 0; 13182 int equal, ret; 13183 xmlXPathCompExprPtr comp; 13184 xmlXPathObjectPtr arg1, arg2; 13185 xmlNodePtr bak; 13186 xmlDocPtr bakd; 13187 int pp; 13188 int cs; 13189 13190 CHECK_ERROR0; 13191 comp = ctxt->comp; 13192 switch (op->op) { 13193 case XPATH_OP_END: 13194 return (0); 13195 case XPATH_OP_AND: 13196 bakd = ctxt->context->doc; 13197 bak = ctxt->context->node; 13198 pp = ctxt->context->proximityPosition; 13199 cs = ctxt->context->contextSize; 13200 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]); 13201 CHECK_ERROR0; 13202 xmlXPathBooleanFunction(ctxt, 1); 13203 if ((ctxt->value == NULL) || (ctxt->value->boolval == 0)) 13204 return (total); 13205 arg2 = valuePop(ctxt); 13206 ctxt->context->doc = bakd; 13207 ctxt->context->node = bak; 13208 ctxt->context->proximityPosition = pp; 13209 ctxt->context->contextSize = cs; 13210 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]); 13211 if (ctxt->error) { 13212 xmlXPathFreeObject(arg2); 13213 return(0); 13214 } 13215 xmlXPathBooleanFunction(ctxt, 1); 13216 arg1 = valuePop(ctxt); 13217 arg1->boolval &= arg2->boolval; 13218 valuePush(ctxt, arg1); 13219 xmlXPathReleaseObject(ctxt->context, arg2); 13220 return (total); 13221 case XPATH_OP_OR: 13222 bakd = ctxt->context->doc; 13223 bak = ctxt->context->node; 13224 pp = ctxt->context->proximityPosition; 13225 cs = ctxt->context->contextSize; 13226 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]); 13227 CHECK_ERROR0; 13228 xmlXPathBooleanFunction(ctxt, 1); 13229 if ((ctxt->value == NULL) || (ctxt->value->boolval == 1)) 13230 return (total); 13231 arg2 = valuePop(ctxt); 13232 ctxt->context->doc = bakd; 13233 ctxt->context->node = bak; 13234 ctxt->context->proximityPosition = pp; 13235 ctxt->context->contextSize = cs; 13236 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]); 13237 if (ctxt->error) { 13238 xmlXPathFreeObject(arg2); 13239 return(0); 13240 } 13241 xmlXPathBooleanFunction(ctxt, 1); 13242 arg1 = valuePop(ctxt); 13243 arg1->boolval |= arg2->boolval; 13244 valuePush(ctxt, arg1); 13245 xmlXPathReleaseObject(ctxt->context, arg2); 13246 return (total); 13247 case XPATH_OP_EQUAL: 13248 bakd = ctxt->context->doc; 13249 bak = ctxt->context->node; 13250 pp = ctxt->context->proximityPosition; 13251 cs = ctxt->context->contextSize; 13252 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]); 13253 CHECK_ERROR0; 13254 ctxt->context->doc = bakd; 13255 ctxt->context->node = bak; 13256 ctxt->context->proximityPosition = pp; 13257 ctxt->context->contextSize = cs; 13258 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]); 13259 CHECK_ERROR0; 13260 if (op->value) 13261 equal = xmlXPathEqualValues(ctxt); 13262 else 13263 equal = xmlXPathNotEqualValues(ctxt); 13264 valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, equal)); 13265 return (total); 13266 case XPATH_OP_CMP: 13267 bakd = ctxt->context->doc; 13268 bak = ctxt->context->node; 13269 pp = ctxt->context->proximityPosition; 13270 cs = ctxt->context->contextSize; 13271 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]); 13272 CHECK_ERROR0; 13273 ctxt->context->doc = bakd; 13274 ctxt->context->node = bak; 13275 ctxt->context->proximityPosition = pp; 13276 ctxt->context->contextSize = cs; 13277 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]); 13278 CHECK_ERROR0; 13279 ret = xmlXPathCompareValues(ctxt, op->value, op->value2); 13280 valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, ret)); 13281 return (total); 13282 case XPATH_OP_PLUS: 13283 bakd = ctxt->context->doc; 13284 bak = ctxt->context->node; 13285 pp = ctxt->context->proximityPosition; 13286 cs = ctxt->context->contextSize; 13287 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]); 13288 CHECK_ERROR0; 13289 if (op->ch2 != -1) { 13290 ctxt->context->doc = bakd; 13291 ctxt->context->node = bak; 13292 ctxt->context->proximityPosition = pp; 13293 ctxt->context->contextSize = cs; 13294 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]); 13295 } 13296 CHECK_ERROR0; 13297 if (op->value == 0) 13298 xmlXPathSubValues(ctxt); 13299 else if (op->value == 1) 13300 xmlXPathAddValues(ctxt); 13301 else if (op->value == 2) 13302 xmlXPathValueFlipSign(ctxt); 13303 else if (op->value == 3) { 13304 CAST_TO_NUMBER; 13305 CHECK_TYPE0(XPATH_NUMBER); 13306 } 13307 return (total); 13308 case XPATH_OP_MULT: 13309 bakd = ctxt->context->doc; 13310 bak = ctxt->context->node; 13311 pp = ctxt->context->proximityPosition; 13312 cs = ctxt->context->contextSize; 13313 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]); 13314 CHECK_ERROR0; 13315 ctxt->context->doc = bakd; 13316 ctxt->context->node = bak; 13317 ctxt->context->proximityPosition = pp; 13318 ctxt->context->contextSize = cs; 13319 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]); 13320 CHECK_ERROR0; 13321 if (op->value == 0) 13322 xmlXPathMultValues(ctxt); 13323 else if (op->value == 1) 13324 xmlXPathDivValues(ctxt); 13325 else if (op->value == 2) 13326 xmlXPathModValues(ctxt); 13327 return (total); 13328 case XPATH_OP_UNION: 13329 bakd = ctxt->context->doc; 13330 bak = ctxt->context->node; 13331 pp = ctxt->context->proximityPosition; 13332 cs = ctxt->context->contextSize; 13333 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]); 13334 CHECK_ERROR0; 13335 ctxt->context->doc = bakd; 13336 ctxt->context->node = bak; 13337 ctxt->context->proximityPosition = pp; 13338 ctxt->context->contextSize = cs; 13339 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]); 13340 CHECK_ERROR0; 13341 CHECK_TYPE0(XPATH_NODESET); 13342 arg2 = valuePop(ctxt); 13343 13344 CHECK_TYPE0(XPATH_NODESET); 13345 arg1 = valuePop(ctxt); 13346 13347 if ((arg1->nodesetval == NULL) || 13348 ((arg2->nodesetval != NULL) && 13349 (arg2->nodesetval->nodeNr != 0))) 13350 { 13351 arg1->nodesetval = xmlXPathNodeSetMerge(arg1->nodesetval, 13352 arg2->nodesetval); 13353 } 13354 13355 valuePush(ctxt, arg1); 13356 xmlXPathReleaseObject(ctxt->context, arg2); 13357 return (total); 13358 case XPATH_OP_ROOT: 13359 xmlXPathRoot(ctxt); 13360 return (total); 13361 case XPATH_OP_NODE: 13362 if (op->ch1 != -1) 13363 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]); 13364 CHECK_ERROR0; 13365 if (op->ch2 != -1) 13366 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]); 13367 CHECK_ERROR0; 13368 valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context, 13369 ctxt->context->node)); 13370 return (total); 13371 case XPATH_OP_RESET: 13372 if (op->ch1 != -1) 13373 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]); 13374 CHECK_ERROR0; 13375 if (op->ch2 != -1) 13376 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]); 13377 CHECK_ERROR0; 13378 ctxt->context->node = NULL; 13379 return (total); 13380 case XPATH_OP_COLLECT:{ 13381 if (op->ch1 == -1) 13382 return (total); 13383 13384 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]); 13385 CHECK_ERROR0; 13386 13387 total += xmlXPathNodeCollectAndTest(ctxt, op, NULL, NULL, 0); 13388 return (total); 13389 } 13390 case XPATH_OP_VALUE: 13391 valuePush(ctxt, 13392 xmlXPathCacheObjectCopy(ctxt->context, 13393 (xmlXPathObjectPtr) op->value4)); 13394 return (total); 13395 case XPATH_OP_VARIABLE:{ 13396 xmlXPathObjectPtr val; 13397 13398 if (op->ch1 != -1) 13399 total += 13400 xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]); 13401 if (op->value5 == NULL) { 13402 val = xmlXPathVariableLookup(ctxt->context, op->value4); 13403 if (val == NULL) { 13404 ctxt->error = XPATH_UNDEF_VARIABLE_ERROR; 13405 return(0); 13406 } 13407 valuePush(ctxt, val); 13408 } else { 13409 const xmlChar *URI; 13410 13411 URI = xmlXPathNsLookup(ctxt->context, op->value5); 13412 if (URI == NULL) { 13413 xmlGenericError(xmlGenericErrorContext, 13414 "xmlXPathCompOpEval: variable %s bound to undefined prefix %s\n", 13415 (char *) op->value4, (char *)op->value5); 13416 ctxt->error = XPATH_UNDEF_PREFIX_ERROR; 13417 return (total); 13418 } 13419 val = xmlXPathVariableLookupNS(ctxt->context, 13420 op->value4, URI); 13421 if (val == NULL) { 13422 ctxt->error = XPATH_UNDEF_VARIABLE_ERROR; 13423 return(0); 13424 } 13425 valuePush(ctxt, val); 13426 } 13427 return (total); 13428 } 13429 case XPATH_OP_FUNCTION:{ 13430 xmlXPathFunction func; 13431 const xmlChar *oldFunc, *oldFuncURI; 13432 int i; 13433 int frame; 13434 13435 frame = xmlXPathSetFrame(ctxt); 13436 if (op->ch1 != -1) 13437 total += 13438 xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]); 13439 if (ctxt->valueNr < op->value) { 13440 xmlGenericError(xmlGenericErrorContext, 13441 "xmlXPathCompOpEval: parameter error\n"); 13442 ctxt->error = XPATH_INVALID_OPERAND; 13443 xmlXPathPopFrame(ctxt, frame); 13444 return (total); 13445 } 13446 for (i = 0; i < op->value; i++) { 13447 if (ctxt->valueTab[(ctxt->valueNr - 1) - i] == NULL) { 13448 xmlGenericError(xmlGenericErrorContext, 13449 "xmlXPathCompOpEval: parameter error\n"); 13450 ctxt->error = XPATH_INVALID_OPERAND; 13451 xmlXPathPopFrame(ctxt, frame); 13452 return (total); 13453 } 13454 } 13455 if (op->cache != NULL) 13456 XML_CAST_FPTR(func) = op->cache; 13457 else { 13458 const xmlChar *URI = NULL; 13459 13460 if (op->value5 == NULL) 13461 func = 13462 xmlXPathFunctionLookup(ctxt->context, 13463 op->value4); 13464 else { 13465 URI = xmlXPathNsLookup(ctxt->context, op->value5); 13466 if (URI == NULL) { 13467 xmlGenericError(xmlGenericErrorContext, 13468 "xmlXPathCompOpEval: function %s bound to undefined prefix %s\n", 13469 (char *)op->value4, (char *)op->value5); 13470 xmlXPathPopFrame(ctxt, frame); 13471 ctxt->error = XPATH_UNDEF_PREFIX_ERROR; 13472 return (total); 13473 } 13474 func = xmlXPathFunctionLookupNS(ctxt->context, 13475 op->value4, URI); 13476 } 13477 if (func == NULL) { 13478 xmlGenericError(xmlGenericErrorContext, 13479 "xmlXPathCompOpEval: function %s not found\n", 13480 (char *)op->value4); 13481 XP_ERROR0(XPATH_UNKNOWN_FUNC_ERROR); 13482 } 13483 op->cache = XML_CAST_FPTR(func); 13484 op->cacheURI = (void *) URI; 13485 } 13486 oldFunc = ctxt->context->function; 13487 oldFuncURI = ctxt->context->functionURI; 13488 ctxt->context->function = op->value4; 13489 ctxt->context->functionURI = op->cacheURI; 13490 func(ctxt, op->value); 13491 ctxt->context->function = oldFunc; 13492 ctxt->context->functionURI = oldFuncURI; 13493 xmlXPathPopFrame(ctxt, frame); 13494 return (total); 13495 } 13496 case XPATH_OP_ARG: 13497 bakd = ctxt->context->doc; 13498 bak = ctxt->context->node; 13499 pp = ctxt->context->proximityPosition; 13500 cs = ctxt->context->contextSize; 13501 if (op->ch1 != -1) 13502 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]); 13503 ctxt->context->contextSize = cs; 13504 ctxt->context->proximityPosition = pp; 13505 ctxt->context->node = bak; 13506 ctxt->context->doc = bakd; 13507 CHECK_ERROR0; 13508 if (op->ch2 != -1) { 13509 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]); 13510 ctxt->context->doc = bakd; 13511 ctxt->context->node = bak; 13512 CHECK_ERROR0; 13513 } 13514 return (total); 13515 case XPATH_OP_PREDICATE: 13516 case XPATH_OP_FILTER:{ 13517 xmlXPathObjectPtr res; 13518 xmlXPathObjectPtr obj, tmp; 13519 xmlNodeSetPtr newset = NULL; 13520 xmlNodeSetPtr oldset; 13521 xmlNodePtr oldnode; 13522 xmlDocPtr oldDoc; 13523 int i; 13524 13525 /* 13526 * Optimization for ()[1] selection i.e. the first elem 13527 */ 13528 if ((op->ch1 != -1) && (op->ch2 != -1) && 13529 #ifdef XP_OPTIMIZED_FILTER_FIRST 13530 /* 13531 * FILTER TODO: Can we assume that the inner processing 13532 * will result in an ordered list if we have an 13533 * XPATH_OP_FILTER? 13534 * What about an additional field or flag on 13535 * xmlXPathObject like @sorted ? This way we wouln'd need 13536 * to assume anything, so it would be more robust and 13537 * easier to optimize. 13538 */ 13539 ((comp->steps[op->ch1].op == XPATH_OP_SORT) || /* 18 */ 13540 (comp->steps[op->ch1].op == XPATH_OP_FILTER)) && /* 17 */ 13541 #else 13542 (comp->steps[op->ch1].op == XPATH_OP_SORT) && 13543 #endif 13544 (comp->steps[op->ch2].op == XPATH_OP_VALUE)) { /* 12 */ 13545 xmlXPathObjectPtr val; 13546 13547 val = comp->steps[op->ch2].value4; 13548 if ((val != NULL) && (val->type == XPATH_NUMBER) && 13549 (val->floatval == 1.0)) { 13550 xmlNodePtr first = NULL; 13551 13552 total += 13553 xmlXPathCompOpEvalFirst(ctxt, 13554 &comp->steps[op->ch1], 13555 &first); 13556 CHECK_ERROR0; 13557 /* 13558 * The nodeset should be in document order, 13559 * Keep only the first value 13560 */ 13561 if ((ctxt->value != NULL) && 13562 (ctxt->value->type == XPATH_NODESET) && 13563 (ctxt->value->nodesetval != NULL) && 13564 (ctxt->value->nodesetval->nodeNr > 1)) 13565 ctxt->value->nodesetval->nodeNr = 1; 13566 return (total); 13567 } 13568 } 13569 /* 13570 * Optimization for ()[last()] selection i.e. the last elem 13571 */ 13572 if ((op->ch1 != -1) && (op->ch2 != -1) && 13573 (comp->steps[op->ch1].op == XPATH_OP_SORT) && 13574 (comp->steps[op->ch2].op == XPATH_OP_SORT)) { 13575 int f = comp->steps[op->ch2].ch1; 13576 13577 if ((f != -1) && 13578 (comp->steps[f].op == XPATH_OP_FUNCTION) && 13579 (comp->steps[f].value5 == NULL) && 13580 (comp->steps[f].value == 0) && 13581 (comp->steps[f].value4 != NULL) && 13582 (xmlStrEqual 13583 (comp->steps[f].value4, BAD_CAST "last"))) { 13584 xmlNodePtr last = NULL; 13585 13586 total += 13587 xmlXPathCompOpEvalLast(ctxt, 13588 &comp->steps[op->ch1], 13589 &last); 13590 CHECK_ERROR0; 13591 /* 13592 * The nodeset should be in document order, 13593 * Keep only the last value 13594 */ 13595 if ((ctxt->value != NULL) && 13596 (ctxt->value->type == XPATH_NODESET) && 13597 (ctxt->value->nodesetval != NULL) && 13598 (ctxt->value->nodesetval->nodeTab != NULL) && 13599 (ctxt->value->nodesetval->nodeNr > 1)) { 13600 ctxt->value->nodesetval->nodeTab[0] = 13601 ctxt->value->nodesetval->nodeTab[ctxt-> 13602 value-> 13603 nodesetval-> 13604 nodeNr - 13605 1]; 13606 ctxt->value->nodesetval->nodeNr = 1; 13607 } 13608 return (total); 13609 } 13610 } 13611 /* 13612 * Process inner predicates first. 13613 * Example "index[parent::book][1]": 13614 * ... 13615 * PREDICATE <-- we are here "[1]" 13616 * PREDICATE <-- process "[parent::book]" first 13617 * SORT 13618 * COLLECT 'parent' 'name' 'node' book 13619 * NODE 13620 * ELEM Object is a number : 1 13621 */ 13622 if (op->ch1 != -1) 13623 total += 13624 xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]); 13625 CHECK_ERROR0; 13626 if (op->ch2 == -1) 13627 return (total); 13628 if (ctxt->value == NULL) 13629 return (total); 13630 13631 oldnode = ctxt->context->node; 13632 13633 #ifdef LIBXML_XPTR_ENABLED 13634 /* 13635 * Hum are we filtering the result of an XPointer expression 13636 */ 13637 if (ctxt->value->type == XPATH_LOCATIONSET) { 13638 xmlLocationSetPtr newlocset = NULL; 13639 xmlLocationSetPtr oldlocset; 13640 13641 /* 13642 * Extract the old locset, and then evaluate the result of the 13643 * expression for all the element in the locset. use it to grow 13644 * up a new locset. 13645 */ 13646 CHECK_TYPE0(XPATH_LOCATIONSET); 13647 obj = valuePop(ctxt); 13648 oldlocset = obj->user; 13649 ctxt->context->node = NULL; 13650 13651 if ((oldlocset == NULL) || (oldlocset->locNr == 0)) { 13652 ctxt->context->contextSize = 0; 13653 ctxt->context->proximityPosition = 0; 13654 if (op->ch2 != -1) 13655 total += 13656 xmlXPathCompOpEval(ctxt, 13657 &comp->steps[op->ch2]); 13658 res = valuePop(ctxt); 13659 if (res != NULL) { 13660 xmlXPathReleaseObject(ctxt->context, res); 13661 } 13662 valuePush(ctxt, obj); 13663 CHECK_ERROR0; 13664 return (total); 13665 } 13666 newlocset = xmlXPtrLocationSetCreate(NULL); 13667 13668 for (i = 0; i < oldlocset->locNr; i++) { 13669 /* 13670 * Run the evaluation with a node list made of a 13671 * single item in the nodelocset. 13672 */ 13673 ctxt->context->node = oldlocset->locTab[i]->user; 13674 ctxt->context->contextSize = oldlocset->locNr; 13675 ctxt->context->proximityPosition = i + 1; 13676 tmp = xmlXPathCacheNewNodeSet(ctxt->context, 13677 ctxt->context->node); 13678 valuePush(ctxt, tmp); 13679 13680 if (op->ch2 != -1) 13681 total += 13682 xmlXPathCompOpEval(ctxt, 13683 &comp->steps[op->ch2]); 13684 if (ctxt->error != XPATH_EXPRESSION_OK) { 13685 xmlXPathFreeObject(obj); 13686 return(0); 13687 } 13688 13689 /* 13690 * The result of the evaluation need to be tested to 13691 * decided whether the filter succeeded or not 13692 */ 13693 res = valuePop(ctxt); 13694 if (xmlXPathEvaluatePredicateResult(ctxt, res)) { 13695 xmlXPtrLocationSetAdd(newlocset, 13696 xmlXPathObjectCopy 13697 (oldlocset->locTab[i])); 13698 } 13699 13700 /* 13701 * Cleanup 13702 */ 13703 if (res != NULL) { 13704 xmlXPathReleaseObject(ctxt->context, res); 13705 } 13706 if (ctxt->value == tmp) { 13707 res = valuePop(ctxt); 13708 xmlXPathReleaseObject(ctxt->context, res); 13709 } 13710 13711 ctxt->context->node = NULL; 13712 } 13713 13714 /* 13715 * The result is used as the new evaluation locset. 13716 */ 13717 xmlXPathReleaseObject(ctxt->context, obj); 13718 ctxt->context->node = NULL; 13719 ctxt->context->contextSize = -1; 13720 ctxt->context->proximityPosition = -1; 13721 valuePush(ctxt, xmlXPtrWrapLocationSet(newlocset)); 13722 ctxt->context->node = oldnode; 13723 return (total); 13724 } 13725 #endif /* LIBXML_XPTR_ENABLED */ 13726 13727 /* 13728 * Extract the old set, and then evaluate the result of the 13729 * expression for all the element in the set. use it to grow 13730 * up a new set. 13731 */ 13732 CHECK_TYPE0(XPATH_NODESET); 13733 obj = valuePop(ctxt); 13734 oldset = obj->nodesetval; 13735 13736 oldnode = ctxt->context->node; 13737 oldDoc = ctxt->context->doc; 13738 ctxt->context->node = NULL; 13739 13740 if ((oldset == NULL) || (oldset->nodeNr == 0)) { 13741 ctxt->context->contextSize = 0; 13742 ctxt->context->proximityPosition = 0; 13743 /* 13744 if (op->ch2 != -1) 13745 total += 13746 xmlXPathCompOpEval(ctxt, 13747 &comp->steps[op->ch2]); 13748 CHECK_ERROR0; 13749 res = valuePop(ctxt); 13750 if (res != NULL) 13751 xmlXPathFreeObject(res); 13752 */ 13753 valuePush(ctxt, obj); 13754 ctxt->context->node = oldnode; 13755 CHECK_ERROR0; 13756 } else { 13757 tmp = NULL; 13758 /* 13759 * Initialize the new set. 13760 * Also set the xpath document in case things like 13761 * key() evaluation are attempted on the predicate 13762 */ 13763 newset = xmlXPathNodeSetCreate(NULL); 13764 /* 13765 * SPEC XPath 1.0: 13766 * "For each node in the node-set to be filtered, the 13767 * PredicateExpr is evaluated with that node as the 13768 * context node, with the number of nodes in the 13769 * node-set as the context size, and with the proximity 13770 * position of the node in the node-set with respect to 13771 * the axis as the context position;" 13772 * @oldset is the node-set" to be filtered. 13773 * 13774 * SPEC XPath 1.0: 13775 * "only predicates change the context position and 13776 * context size (see [2.4 Predicates])." 13777 * Example: 13778 * node-set context pos 13779 * nA 1 13780 * nB 2 13781 * nC 3 13782 * After applying predicate [position() > 1] : 13783 * node-set context pos 13784 * nB 1 13785 * nC 2 13786 * 13787 * removed the first node in the node-set, then 13788 * the context position of the 13789 */ 13790 for (i = 0; i < oldset->nodeNr; i++) { 13791 /* 13792 * Run the evaluation with a node list made of 13793 * a single item in the nodeset. 13794 */ 13795 ctxt->context->node = oldset->nodeTab[i]; 13796 if ((oldset->nodeTab[i]->type != XML_NAMESPACE_DECL) && 13797 (oldset->nodeTab[i]->doc != NULL)) 13798 ctxt->context->doc = oldset->nodeTab[i]->doc; 13799 if (tmp == NULL) { 13800 tmp = xmlXPathCacheNewNodeSet(ctxt->context, 13801 ctxt->context->node); 13802 } else { 13803 xmlXPathNodeSetAddUnique(tmp->nodesetval, 13804 ctxt->context->node); 13805 } 13806 valuePush(ctxt, tmp); 13807 ctxt->context->contextSize = oldset->nodeNr; 13808 ctxt->context->proximityPosition = i + 1; 13809 /* 13810 * Evaluate the predicate against the context node. 13811 * Can/should we optimize position() predicates 13812 * here (e.g. "[1]")? 13813 */ 13814 if (op->ch2 != -1) 13815 total += 13816 xmlXPathCompOpEval(ctxt, 13817 &comp->steps[op->ch2]); 13818 if (ctxt->error != XPATH_EXPRESSION_OK) { 13819 xmlXPathFreeNodeSet(newset); 13820 xmlXPathFreeObject(obj); 13821 return(0); 13822 } 13823 13824 /* 13825 * The result of the evaluation needs to be tested to 13826 * decide whether the filter succeeded or not 13827 */ 13828 /* 13829 * OPTIMIZE TODO: Can we use 13830 * xmlXPathNodeSetAdd*Unique()* instead? 13831 */ 13832 res = valuePop(ctxt); 13833 if (xmlXPathEvaluatePredicateResult(ctxt, res)) { 13834 xmlXPathNodeSetAdd(newset, oldset->nodeTab[i]); 13835 } 13836 13837 /* 13838 * Cleanup 13839 */ 13840 if (res != NULL) { 13841 xmlXPathReleaseObject(ctxt->context, res); 13842 } 13843 if (ctxt->value == tmp) { 13844 valuePop(ctxt); 13845 xmlXPathNodeSetClear(tmp->nodesetval, 1); 13846 /* 13847 * Don't free the temporary nodeset 13848 * in order to avoid massive recreation inside this 13849 * loop. 13850 */ 13851 } else 13852 tmp = NULL; 13853 ctxt->context->node = NULL; 13854 } 13855 if (tmp != NULL) 13856 xmlXPathReleaseObject(ctxt->context, tmp); 13857 /* 13858 * The result is used as the new evaluation set. 13859 */ 13860 xmlXPathReleaseObject(ctxt->context, obj); 13861 ctxt->context->node = NULL; 13862 ctxt->context->contextSize = -1; 13863 ctxt->context->proximityPosition = -1; 13864 /* may want to move this past the '}' later */ 13865 ctxt->context->doc = oldDoc; 13866 valuePush(ctxt, 13867 xmlXPathCacheWrapNodeSet(ctxt->context, newset)); 13868 } 13869 ctxt->context->node = oldnode; 13870 return (total); 13871 } 13872 case XPATH_OP_SORT: 13873 if (op->ch1 != -1) 13874 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]); 13875 CHECK_ERROR0; 13876 if ((ctxt->value != NULL) && 13877 (ctxt->value->type == XPATH_NODESET) && 13878 (ctxt->value->nodesetval != NULL) && 13879 (ctxt->value->nodesetval->nodeNr > 1)) 13880 { 13881 xmlXPathNodeSetSort(ctxt->value->nodesetval); 13882 } 13883 return (total); 13884 #ifdef LIBXML_XPTR_ENABLED 13885 case XPATH_OP_RANGETO:{ 13886 xmlXPathObjectPtr range; 13887 xmlXPathObjectPtr res, obj; 13888 xmlXPathObjectPtr tmp; 13889 xmlLocationSetPtr newlocset = NULL; 13890 xmlLocationSetPtr oldlocset; 13891 xmlNodeSetPtr oldset; 13892 int i, j; 13893 13894 if (op->ch1 != -1) 13895 total += 13896 xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]); 13897 if (op->ch2 == -1) 13898 return (total); 13899 13900 if (ctxt->value->type == XPATH_LOCATIONSET) { 13901 /* 13902 * Extract the old locset, and then evaluate the result of the 13903 * expression for all the element in the locset. use it to grow 13904 * up a new locset. 13905 */ 13906 CHECK_TYPE0(XPATH_LOCATIONSET); 13907 obj = valuePop(ctxt); 13908 oldlocset = obj->user; 13909 13910 if ((oldlocset == NULL) || (oldlocset->locNr == 0)) { 13911 ctxt->context->node = NULL; 13912 ctxt->context->contextSize = 0; 13913 ctxt->context->proximityPosition = 0; 13914 total += xmlXPathCompOpEval(ctxt,&comp->steps[op->ch2]); 13915 res = valuePop(ctxt); 13916 if (res != NULL) { 13917 xmlXPathReleaseObject(ctxt->context, res); 13918 } 13919 valuePush(ctxt, obj); 13920 CHECK_ERROR0; 13921 return (total); 13922 } 13923 newlocset = xmlXPtrLocationSetCreate(NULL); 13924 13925 for (i = 0; i < oldlocset->locNr; i++) { 13926 /* 13927 * Run the evaluation with a node list made of a 13928 * single item in the nodelocset. 13929 */ 13930 ctxt->context->node = oldlocset->locTab[i]->user; 13931 ctxt->context->contextSize = oldlocset->locNr; 13932 ctxt->context->proximityPosition = i + 1; 13933 tmp = xmlXPathCacheNewNodeSet(ctxt->context, 13934 ctxt->context->node); 13935 valuePush(ctxt, tmp); 13936 13937 if (op->ch2 != -1) 13938 total += 13939 xmlXPathCompOpEval(ctxt, 13940 &comp->steps[op->ch2]); 13941 if (ctxt->error != XPATH_EXPRESSION_OK) { 13942 xmlXPathFreeObject(obj); 13943 return(0); 13944 } 13945 13946 res = valuePop(ctxt); 13947 if (res->type == XPATH_LOCATIONSET) { 13948 xmlLocationSetPtr rloc = 13949 (xmlLocationSetPtr)res->user; 13950 for (j=0; j<rloc->locNr; j++) { 13951 range = xmlXPtrNewRange( 13952 oldlocset->locTab[i]->user, 13953 oldlocset->locTab[i]->index, 13954 rloc->locTab[j]->user2, 13955 rloc->locTab[j]->index2); 13956 if (range != NULL) { 13957 xmlXPtrLocationSetAdd(newlocset, range); 13958 } 13959 } 13960 } else { 13961 range = xmlXPtrNewRangeNodeObject( 13962 (xmlNodePtr)oldlocset->locTab[i]->user, res); 13963 if (range != NULL) { 13964 xmlXPtrLocationSetAdd(newlocset,range); 13965 } 13966 } 13967 13968 /* 13969 * Cleanup 13970 */ 13971 if (res != NULL) { 13972 xmlXPathReleaseObject(ctxt->context, res); 13973 } 13974 if (ctxt->value == tmp) { 13975 res = valuePop(ctxt); 13976 xmlXPathReleaseObject(ctxt->context, res); 13977 } 13978 13979 ctxt->context->node = NULL; 13980 } 13981 } else { /* Not a location set */ 13982 CHECK_TYPE0(XPATH_NODESET); 13983 obj = valuePop(ctxt); 13984 oldset = obj->nodesetval; 13985 ctxt->context->node = NULL; 13986 13987 newlocset = xmlXPtrLocationSetCreate(NULL); 13988 13989 if (oldset != NULL) { 13990 for (i = 0; i < oldset->nodeNr; i++) { 13991 /* 13992 * Run the evaluation with a node list made of a single item 13993 * in the nodeset. 13994 */ 13995 ctxt->context->node = oldset->nodeTab[i]; 13996 /* 13997 * OPTIMIZE TODO: Avoid recreation for every iteration. 13998 */ 13999 tmp = xmlXPathCacheNewNodeSet(ctxt->context, 14000 ctxt->context->node); 14001 valuePush(ctxt, tmp); 14002 14003 if (op->ch2 != -1) 14004 total += 14005 xmlXPathCompOpEval(ctxt, 14006 &comp->steps[op->ch2]); 14007 if (ctxt->error != XPATH_EXPRESSION_OK) { 14008 xmlXPathFreeObject(obj); 14009 return(0); 14010 } 14011 14012 res = valuePop(ctxt); 14013 range = 14014 xmlXPtrNewRangeNodeObject(oldset->nodeTab[i], 14015 res); 14016 if (range != NULL) { 14017 xmlXPtrLocationSetAdd(newlocset, range); 14018 } 14019 14020 /* 14021 * Cleanup 14022 */ 14023 if (res != NULL) { 14024 xmlXPathReleaseObject(ctxt->context, res); 14025 } 14026 if (ctxt->value == tmp) { 14027 res = valuePop(ctxt); 14028 xmlXPathReleaseObject(ctxt->context, res); 14029 } 14030 14031 ctxt->context->node = NULL; 14032 } 14033 } 14034 } 14035 14036 /* 14037 * The result is used as the new evaluation set. 14038 */ 14039 xmlXPathReleaseObject(ctxt->context, obj); 14040 ctxt->context->node = NULL; 14041 ctxt->context->contextSize = -1; 14042 ctxt->context->proximityPosition = -1; 14043 valuePush(ctxt, xmlXPtrWrapLocationSet(newlocset)); 14044 return (total); 14045 } 14046 #endif /* LIBXML_XPTR_ENABLED */ 14047 } 14048 xmlGenericError(xmlGenericErrorContext, 14049 "XPath: unknown precompiled operation %d\n", op->op); 14050 ctxt->error = XPATH_INVALID_OPERAND; 14051 return (total); 14052 } 14053 14054 /** 14055 * xmlXPathCompOpEvalToBoolean: 14056 * @ctxt: the XPath parser context 14057 * 14058 * Evaluates if the expression evaluates to true. 14059 * 14060 * Returns 1 if true, 0 if false and -1 on API or internal errors. 14061 */ 14062 static int 14063 xmlXPathCompOpEvalToBoolean(xmlXPathParserContextPtr ctxt, 14064 xmlXPathStepOpPtr op, 14065 int isPredicate) 14066 { 14067 xmlXPathObjectPtr resObj = NULL; 14068 14069 start: 14070 /* comp = ctxt->comp; */ 14071 switch (op->op) { 14072 case XPATH_OP_END: 14073 return (0); 14074 case XPATH_OP_VALUE: 14075 resObj = (xmlXPathObjectPtr) op->value4; 14076 if (isPredicate) 14077 return(xmlXPathEvaluatePredicateResult(ctxt, resObj)); 14078 return(xmlXPathCastToBoolean(resObj)); 14079 case XPATH_OP_SORT: 14080 /* 14081 * We don't need sorting for boolean results. Skip this one. 14082 */ 14083 if (op->ch1 != -1) { 14084 op = &ctxt->comp->steps[op->ch1]; 14085 goto start; 14086 } 14087 return(0); 14088 case XPATH_OP_COLLECT: 14089 if (op->ch1 == -1) 14090 return(0); 14091 14092 xmlXPathCompOpEval(ctxt, &ctxt->comp->steps[op->ch1]); 14093 if (ctxt->error != XPATH_EXPRESSION_OK) 14094 return(-1); 14095 14096 xmlXPathNodeCollectAndTest(ctxt, op, NULL, NULL, 1); 14097 if (ctxt->error != XPATH_EXPRESSION_OK) 14098 return(-1); 14099 14100 resObj = valuePop(ctxt); 14101 if (resObj == NULL) 14102 return(-1); 14103 break; 14104 default: 14105 /* 14106 * Fallback to call xmlXPathCompOpEval(). 14107 */ 14108 xmlXPathCompOpEval(ctxt, op); 14109 if (ctxt->error != XPATH_EXPRESSION_OK) 14110 return(-1); 14111 14112 resObj = valuePop(ctxt); 14113 if (resObj == NULL) 14114 return(-1); 14115 break; 14116 } 14117 14118 if (resObj) { 14119 int res; 14120 14121 if (resObj->type == XPATH_BOOLEAN) { 14122 res = resObj->boolval; 14123 } else if (isPredicate) { 14124 /* 14125 * For predicates a result of type "number" is handled 14126 * differently: 14127 * SPEC XPath 1.0: 14128 * "If the result is a number, the result will be converted 14129 * to true if the number is equal to the context position 14130 * and will be converted to false otherwise;" 14131 */ 14132 res = xmlXPathEvaluatePredicateResult(ctxt, resObj); 14133 } else { 14134 res = xmlXPathCastToBoolean(resObj); 14135 } 14136 xmlXPathReleaseObject(ctxt->context, resObj); 14137 return(res); 14138 } 14139 14140 return(0); 14141 } 14142 14143 #ifdef XPATH_STREAMING 14144 /** 14145 * xmlXPathRunStreamEval: 14146 * @ctxt: the XPath parser context with the compiled expression 14147 * 14148 * Evaluate the Precompiled Streamable XPath expression in the given context. 14149 */ 14150 static int 14151 xmlXPathRunStreamEval(xmlXPathContextPtr ctxt, xmlPatternPtr comp, 14152 xmlXPathObjectPtr *resultSeq, int toBool) 14153 { 14154 int max_depth, min_depth; 14155 int from_root; 14156 int ret, depth; 14157 int eval_all_nodes; 14158 xmlNodePtr cur = NULL, limit = NULL; 14159 xmlStreamCtxtPtr patstream = NULL; 14160 14161 int nb_nodes = 0; 14162 14163 if ((ctxt == NULL) || (comp == NULL)) 14164 return(-1); 14165 max_depth = xmlPatternMaxDepth(comp); 14166 if (max_depth == -1) 14167 return(-1); 14168 if (max_depth == -2) 14169 max_depth = 10000; 14170 min_depth = xmlPatternMinDepth(comp); 14171 if (min_depth == -1) 14172 return(-1); 14173 from_root = xmlPatternFromRoot(comp); 14174 if (from_root < 0) 14175 return(-1); 14176 #if 0 14177 printf("stream eval: depth %d from root %d\n", max_depth, from_root); 14178 #endif 14179 14180 if (! toBool) { 14181 if (resultSeq == NULL) 14182 return(-1); 14183 *resultSeq = xmlXPathCacheNewNodeSet(ctxt, NULL); 14184 if (*resultSeq == NULL) 14185 return(-1); 14186 } 14187 14188 /* 14189 * handle the special cases of "/" amd "." being matched 14190 */ 14191 if (min_depth == 0) { 14192 if (from_root) { 14193 /* Select "/" */ 14194 if (toBool) 14195 return(1); 14196 xmlXPathNodeSetAddUnique((*resultSeq)->nodesetval, 14197 (xmlNodePtr) ctxt->doc); 14198 } else { 14199 /* Select "self::node()" */ 14200 if (toBool) 14201 return(1); 14202 xmlXPathNodeSetAddUnique((*resultSeq)->nodesetval, ctxt->node); 14203 } 14204 } 14205 if (max_depth == 0) { 14206 return(0); 14207 } 14208 14209 if (from_root) { 14210 cur = (xmlNodePtr)ctxt->doc; 14211 } else if (ctxt->node != NULL) { 14212 switch (ctxt->node->type) { 14213 case XML_ELEMENT_NODE: 14214 case XML_DOCUMENT_NODE: 14215 case XML_DOCUMENT_FRAG_NODE: 14216 case XML_HTML_DOCUMENT_NODE: 14217 #ifdef LIBXML_DOCB_ENABLED 14218 case XML_DOCB_DOCUMENT_NODE: 14219 #endif 14220 cur = ctxt->node; 14221 break; 14222 case XML_ATTRIBUTE_NODE: 14223 case XML_TEXT_NODE: 14224 case XML_CDATA_SECTION_NODE: 14225 case XML_ENTITY_REF_NODE: 14226 case XML_ENTITY_NODE: 14227 case XML_PI_NODE: 14228 case XML_COMMENT_NODE: 14229 case XML_NOTATION_NODE: 14230 case XML_DTD_NODE: 14231 case XML_DOCUMENT_TYPE_NODE: 14232 case XML_ELEMENT_DECL: 14233 case XML_ATTRIBUTE_DECL: 14234 case XML_ENTITY_DECL: 14235 case XML_NAMESPACE_DECL: 14236 case XML_XINCLUDE_START: 14237 case XML_XINCLUDE_END: 14238 break; 14239 } 14240 limit = cur; 14241 } 14242 if (cur == NULL) { 14243 return(0); 14244 } 14245 14246 patstream = xmlPatternGetStreamCtxt(comp); 14247 if (patstream == NULL) { 14248 /* 14249 * QUESTION TODO: Is this an error? 14250 */ 14251 return(0); 14252 } 14253 14254 eval_all_nodes = xmlStreamWantsAnyNode(patstream); 14255 14256 if (from_root) { 14257 ret = xmlStreamPush(patstream, NULL, NULL); 14258 if (ret < 0) { 14259 } else if (ret == 1) { 14260 if (toBool) 14261 goto return_1; 14262 xmlXPathNodeSetAddUnique((*resultSeq)->nodesetval, cur); 14263 } 14264 } 14265 depth = 0; 14266 goto scan_children; 14267 next_node: 14268 do { 14269 nb_nodes++; 14270 14271 switch (cur->type) { 14272 case XML_ELEMENT_NODE: 14273 case XML_TEXT_NODE: 14274 case XML_CDATA_SECTION_NODE: 14275 case XML_COMMENT_NODE: 14276 case XML_PI_NODE: 14277 if (cur->type == XML_ELEMENT_NODE) { 14278 ret = xmlStreamPush(patstream, cur->name, 14279 (cur->ns ? cur->ns->href : NULL)); 14280 } else if (eval_all_nodes) 14281 ret = xmlStreamPushNode(patstream, NULL, NULL, cur->type); 14282 else 14283 break; 14284 14285 if (ret < 0) { 14286 /* NOP. */ 14287 } else if (ret == 1) { 14288 if (toBool) 14289 goto return_1; 14290 xmlXPathNodeSetAddUnique((*resultSeq)->nodesetval, cur); 14291 } 14292 if ((cur->children == NULL) || (depth >= max_depth)) { 14293 ret = xmlStreamPop(patstream); 14294 while (cur->next != NULL) { 14295 cur = cur->next; 14296 if ((cur->type != XML_ENTITY_DECL) && 14297 (cur->type != XML_DTD_NODE)) 14298 goto next_node; 14299 } 14300 } 14301 default: 14302 break; 14303 } 14304 14305 scan_children: 14306 if ((cur->children != NULL) && (depth < max_depth)) { 14307 /* 14308 * Do not descend on entities declarations 14309 */ 14310 if (cur->children->type != XML_ENTITY_DECL) { 14311 cur = cur->children; 14312 depth++; 14313 /* 14314 * Skip DTDs 14315 */ 14316 if (cur->type != XML_DTD_NODE) 14317 continue; 14318 } 14319 } 14320 14321 if (cur == limit) 14322 break; 14323 14324 while (cur->next != NULL) { 14325 cur = cur->next; 14326 if ((cur->type != XML_ENTITY_DECL) && 14327 (cur->type != XML_DTD_NODE)) 14328 goto next_node; 14329 } 14330 14331 do { 14332 cur = cur->parent; 14333 depth--; 14334 if ((cur == NULL) || (cur == limit)) 14335 goto done; 14336 if (cur->type == XML_ELEMENT_NODE) { 14337 ret = xmlStreamPop(patstream); 14338 } else if ((eval_all_nodes) && 14339 ((cur->type == XML_TEXT_NODE) || 14340 (cur->type == XML_CDATA_SECTION_NODE) || 14341 (cur->type == XML_COMMENT_NODE) || 14342 (cur->type == XML_PI_NODE))) 14343 { 14344 ret = xmlStreamPop(patstream); 14345 } 14346 if (cur->next != NULL) { 14347 cur = cur->next; 14348 break; 14349 } 14350 } while (cur != NULL); 14351 14352 } while ((cur != NULL) && (depth >= 0)); 14353 14354 done: 14355 14356 #if 0 14357 printf("stream eval: checked %d nodes selected %d\n", 14358 nb_nodes, retObj->nodesetval->nodeNr); 14359 #endif 14360 14361 if (patstream) 14362 xmlFreeStreamCtxt(patstream); 14363 return(0); 14364 14365 return_1: 14366 if (patstream) 14367 xmlFreeStreamCtxt(patstream); 14368 return(1); 14369 } 14370 #endif /* XPATH_STREAMING */ 14371 14372 /** 14373 * xmlXPathRunEval: 14374 * @ctxt: the XPath parser context with the compiled expression 14375 * @toBool: evaluate to a boolean result 14376 * 14377 * Evaluate the Precompiled XPath expression in the given context. 14378 */ 14379 static int 14380 xmlXPathRunEval(xmlXPathParserContextPtr ctxt, int toBool) 14381 { 14382 xmlXPathCompExprPtr comp; 14383 14384 if ((ctxt == NULL) || (ctxt->comp == NULL)) 14385 return(-1); 14386 14387 if (ctxt->valueTab == NULL) { 14388 /* Allocate the value stack */ 14389 ctxt->valueTab = (xmlXPathObjectPtr *) 14390 xmlMalloc(10 * sizeof(xmlXPathObjectPtr)); 14391 if (ctxt->valueTab == NULL) { 14392 xmlXPathPErrMemory(ctxt, "creating evaluation context\n"); 14393 xmlFree(ctxt); 14394 } 14395 ctxt->valueNr = 0; 14396 ctxt->valueMax = 10; 14397 ctxt->value = NULL; 14398 ctxt->valueFrame = 0; 14399 } 14400 #ifdef XPATH_STREAMING 14401 if (ctxt->comp->stream) { 14402 int res; 14403 14404 if (toBool) { 14405 /* 14406 * Evaluation to boolean result. 14407 */ 14408 res = xmlXPathRunStreamEval(ctxt->context, 14409 ctxt->comp->stream, NULL, 1); 14410 if (res != -1) 14411 return(res); 14412 } else { 14413 xmlXPathObjectPtr resObj = NULL; 14414 14415 /* 14416 * Evaluation to a sequence. 14417 */ 14418 res = xmlXPathRunStreamEval(ctxt->context, 14419 ctxt->comp->stream, &resObj, 0); 14420 14421 if ((res != -1) && (resObj != NULL)) { 14422 valuePush(ctxt, resObj); 14423 return(0); 14424 } 14425 if (resObj != NULL) 14426 xmlXPathReleaseObject(ctxt->context, resObj); 14427 } 14428 /* 14429 * QUESTION TODO: This falls back to normal XPath evaluation 14430 * if res == -1. Is this intended? 14431 */ 14432 } 14433 #endif 14434 comp = ctxt->comp; 14435 if (comp->last < 0) { 14436 xmlGenericError(xmlGenericErrorContext, 14437 "xmlXPathRunEval: last is less than zero\n"); 14438 return(-1); 14439 } 14440 if (toBool) 14441 return(xmlXPathCompOpEvalToBoolean(ctxt, 14442 &comp->steps[comp->last], 0)); 14443 else 14444 xmlXPathCompOpEval(ctxt, &comp->steps[comp->last]); 14445 14446 return(0); 14447 } 14448 14449 /************************************************************************ 14450 * * 14451 * Public interfaces * 14452 * * 14453 ************************************************************************/ 14454 14455 /** 14456 * xmlXPathEvalPredicate: 14457 * @ctxt: the XPath context 14458 * @res: the Predicate Expression evaluation result 14459 * 14460 * Evaluate a predicate result for the current node. 14461 * A PredicateExpr is evaluated by evaluating the Expr and converting 14462 * the result to a boolean. If the result is a number, the result will 14463 * be converted to true if the number is equal to the position of the 14464 * context node in the context node list (as returned by the position 14465 * function) and will be converted to false otherwise; if the result 14466 * is not a number, then the result will be converted as if by a call 14467 * to the boolean function. 14468 * 14469 * Returns 1 if predicate is true, 0 otherwise 14470 */ 14471 int 14472 xmlXPathEvalPredicate(xmlXPathContextPtr ctxt, xmlXPathObjectPtr res) { 14473 if ((ctxt == NULL) || (res == NULL)) return(0); 14474 switch (res->type) { 14475 case XPATH_BOOLEAN: 14476 return(res->boolval); 14477 case XPATH_NUMBER: 14478 return(res->floatval == ctxt->proximityPosition); 14479 case XPATH_NODESET: 14480 case XPATH_XSLT_TREE: 14481 if (res->nodesetval == NULL) 14482 return(0); 14483 return(res->nodesetval->nodeNr != 0); 14484 case XPATH_STRING: 14485 return((res->stringval != NULL) && 14486 (xmlStrlen(res->stringval) != 0)); 14487 default: 14488 STRANGE 14489 } 14490 return(0); 14491 } 14492 14493 /** 14494 * xmlXPathEvaluatePredicateResult: 14495 * @ctxt: the XPath Parser context 14496 * @res: the Predicate Expression evaluation result 14497 * 14498 * Evaluate a predicate result for the current node. 14499 * A PredicateExpr is evaluated by evaluating the Expr and converting 14500 * the result to a boolean. If the result is a number, the result will 14501 * be converted to true if the number is equal to the position of the 14502 * context node in the context node list (as returned by the position 14503 * function) and will be converted to false otherwise; if the result 14504 * is not a number, then the result will be converted as if by a call 14505 * to the boolean function. 14506 * 14507 * Returns 1 if predicate is true, 0 otherwise 14508 */ 14509 int 14510 xmlXPathEvaluatePredicateResult(xmlXPathParserContextPtr ctxt, 14511 xmlXPathObjectPtr res) { 14512 if ((ctxt == NULL) || (res == NULL)) return(0); 14513 switch (res->type) { 14514 case XPATH_BOOLEAN: 14515 return(res->boolval); 14516 case XPATH_NUMBER: 14517 #if defined(__BORLANDC__) || (defined(_MSC_VER) && (_MSC_VER == 1200)) 14518 return((res->floatval == ctxt->context->proximityPosition) && 14519 (!xmlXPathIsNaN(res->floatval))); /* MSC pbm Mark Vakoc !*/ 14520 #else 14521 return(res->floatval == ctxt->context->proximityPosition); 14522 #endif 14523 case XPATH_NODESET: 14524 case XPATH_XSLT_TREE: 14525 if (res->nodesetval == NULL) 14526 return(0); 14527 return(res->nodesetval->nodeNr != 0); 14528 case XPATH_STRING: 14529 return((res->stringval != NULL) && (res->stringval[0] != 0)); 14530 #ifdef LIBXML_XPTR_ENABLED 14531 case XPATH_LOCATIONSET:{ 14532 xmlLocationSetPtr ptr = res->user; 14533 if (ptr == NULL) 14534 return(0); 14535 return (ptr->locNr != 0); 14536 } 14537 #endif 14538 default: 14539 STRANGE 14540 } 14541 return(0); 14542 } 14543 14544 #ifdef XPATH_STREAMING 14545 /** 14546 * xmlXPathTryStreamCompile: 14547 * @ctxt: an XPath context 14548 * @str: the XPath expression 14549 * 14550 * Try to compile the XPath expression as a streamable subset. 14551 * 14552 * Returns the compiled expression or NULL if failed to compile. 14553 */ 14554 static xmlXPathCompExprPtr 14555 xmlXPathTryStreamCompile(xmlXPathContextPtr ctxt, const xmlChar *str) { 14556 /* 14557 * Optimization: use streaming patterns when the XPath expression can 14558 * be compiled to a stream lookup 14559 */ 14560 xmlPatternPtr stream; 14561 xmlXPathCompExprPtr comp; 14562 xmlDictPtr dict = NULL; 14563 const xmlChar **namespaces = NULL; 14564 xmlNsPtr ns; 14565 int i, j; 14566 14567 if ((!xmlStrchr(str, '[')) && (!xmlStrchr(str, '(')) && 14568 (!xmlStrchr(str, '@'))) { 14569 const xmlChar *tmp; 14570 14571 /* 14572 * We don't try to handle expressions using the verbose axis 14573 * specifiers ("::"), just the simplied form at this point. 14574 * Additionally, if there is no list of namespaces available and 14575 * there's a ":" in the expression, indicating a prefixed QName, 14576 * then we won't try to compile either. xmlPatterncompile() needs 14577 * to have a list of namespaces at compilation time in order to 14578 * compile prefixed name tests. 14579 */ 14580 tmp = xmlStrchr(str, ':'); 14581 if ((tmp != NULL) && 14582 ((ctxt == NULL) || (ctxt->nsNr == 0) || (tmp[1] == ':'))) 14583 return(NULL); 14584 14585 if (ctxt != NULL) { 14586 dict = ctxt->dict; 14587 if (ctxt->nsNr > 0) { 14588 namespaces = xmlMalloc(2 * (ctxt->nsNr + 1) * sizeof(xmlChar*)); 14589 if (namespaces == NULL) { 14590 xmlXPathErrMemory(ctxt, "allocating namespaces array\n"); 14591 return(NULL); 14592 } 14593 for (i = 0, j = 0; (j < ctxt->nsNr); j++) { 14594 ns = ctxt->namespaces[j]; 14595 namespaces[i++] = ns->href; 14596 namespaces[i++] = ns->prefix; 14597 } 14598 namespaces[i++] = NULL; 14599 namespaces[i] = NULL; 14600 } 14601 } 14602 14603 stream = xmlPatterncompile(str, dict, XML_PATTERN_XPATH, 14604 &namespaces[0]); 14605 if (namespaces != NULL) { 14606 xmlFree((xmlChar **)namespaces); 14607 } 14608 if ((stream != NULL) && (xmlPatternStreamable(stream) == 1)) { 14609 comp = xmlXPathNewCompExpr(); 14610 if (comp == NULL) { 14611 xmlXPathErrMemory(ctxt, "allocating streamable expression\n"); 14612 return(NULL); 14613 } 14614 comp->stream = stream; 14615 comp->dict = dict; 14616 if (comp->dict) 14617 xmlDictReference(comp->dict); 14618 return(comp); 14619 } 14620 xmlFreePattern(stream); 14621 } 14622 return(NULL); 14623 } 14624 #endif /* XPATH_STREAMING */ 14625 14626 static int 14627 xmlXPathCanRewriteDosExpression(xmlChar *expr) 14628 { 14629 if (expr == NULL) 14630 return(0); 14631 do { 14632 if ((*expr == '/') && (*(++expr) == '/')) 14633 return(1); 14634 } while (*expr++); 14635 return(0); 14636 } 14637 static void 14638 xmlXPathRewriteDOSExpression(xmlXPathCompExprPtr comp, xmlXPathStepOpPtr op) 14639 { 14640 /* 14641 * Try to rewrite "descendant-or-self::node()/foo" to an optimized 14642 * internal representation. 14643 */ 14644 if (op->ch1 != -1) { 14645 if ((op->op == XPATH_OP_COLLECT /* 11 */) && 14646 ((xmlXPathAxisVal) op->value == AXIS_CHILD /* 4 */) && 14647 ((xmlXPathTestVal) op->value2 == NODE_TEST_NAME /* 5 */) && 14648 ((xmlXPathTypeVal) op->value3 == NODE_TYPE_NODE /* 0 */)) 14649 { 14650 /* 14651 * This is a "child::foo" 14652 */ 14653 xmlXPathStepOpPtr prevop = &comp->steps[op->ch1]; 14654 14655 if ((prevop->op == XPATH_OP_COLLECT /* 11 */) && 14656 (prevop->ch1 != -1) && 14657 ((xmlXPathAxisVal) prevop->value == 14658 AXIS_DESCENDANT_OR_SELF) && 14659 (prevop->ch2 == -1) && 14660 ((xmlXPathTestVal) prevop->value2 == NODE_TEST_TYPE) && 14661 ((xmlXPathTypeVal) prevop->value3 == NODE_TYPE_NODE) && 14662 (comp->steps[prevop->ch1].op == XPATH_OP_ROOT)) 14663 { 14664 /* 14665 * This is a "/descendant-or-self::node()" without predicates. 14666 * Eliminate it. 14667 */ 14668 op->ch1 = prevop->ch1; 14669 op->rewriteType = XP_REWRITE_DOS_CHILD_ELEM; 14670 } 14671 } 14672 if (op->ch1 != -1) 14673 xmlXPathRewriteDOSExpression(comp, &comp->steps[op->ch1]); 14674 } 14675 if (op->ch2 != -1) 14676 xmlXPathRewriteDOSExpression(comp, &comp->steps[op->ch2]); 14677 } 14678 14679 /** 14680 * xmlXPathCtxtCompile: 14681 * @ctxt: an XPath context 14682 * @str: the XPath expression 14683 * 14684 * Compile an XPath expression 14685 * 14686 * Returns the xmlXPathCompExprPtr resulting from the compilation or NULL. 14687 * the caller has to free the object. 14688 */ 14689 xmlXPathCompExprPtr 14690 xmlXPathCtxtCompile(xmlXPathContextPtr ctxt, const xmlChar *str) { 14691 xmlXPathParserContextPtr pctxt; 14692 xmlXPathCompExprPtr comp; 14693 14694 #ifdef XPATH_STREAMING 14695 comp = xmlXPathTryStreamCompile(ctxt, str); 14696 if (comp != NULL) 14697 return(comp); 14698 #endif 14699 14700 xmlXPathInit(); 14701 14702 pctxt = xmlXPathNewParserContext(str, ctxt); 14703 if (pctxt == NULL) 14704 return NULL; 14705 xmlXPathCompileExpr(pctxt, 1); 14706 14707 if( pctxt->error != XPATH_EXPRESSION_OK ) 14708 { 14709 xmlXPathFreeParserContext(pctxt); 14710 return(NULL); 14711 } 14712 14713 if (*pctxt->cur != 0) { 14714 /* 14715 * aleksey: in some cases this line prints *second* error message 14716 * (see bug #78858) and probably this should be fixed. 14717 * However, we are not sure that all error messages are printed 14718 * out in other places. It's not critical so we leave it as-is for now 14719 */ 14720 xmlXPatherror(pctxt, __FILE__, __LINE__, XPATH_EXPR_ERROR); 14721 comp = NULL; 14722 } else { 14723 comp = pctxt->comp; 14724 pctxt->comp = NULL; 14725 } 14726 xmlXPathFreeParserContext(pctxt); 14727 14728 if (comp != NULL) { 14729 comp->expr = xmlStrdup(str); 14730 #ifdef DEBUG_EVAL_COUNTS 14731 comp->string = xmlStrdup(str); 14732 comp->nb = 0; 14733 #endif 14734 if ((comp->expr != NULL) && 14735 (comp->nbStep > 2) && 14736 (comp->last >= 0) && 14737 (xmlXPathCanRewriteDosExpression(comp->expr) == 1)) 14738 { 14739 xmlXPathRewriteDOSExpression(comp, &comp->steps[comp->last]); 14740 } 14741 } 14742 return(comp); 14743 } 14744 14745 /** 14746 * xmlXPathCompile: 14747 * @str: the XPath expression 14748 * 14749 * Compile an XPath expression 14750 * 14751 * Returns the xmlXPathCompExprPtr resulting from the compilation or NULL. 14752 * the caller has to free the object. 14753 */ 14754 xmlXPathCompExprPtr 14755 xmlXPathCompile(const xmlChar *str) { 14756 return(xmlXPathCtxtCompile(NULL, str)); 14757 } 14758 14759 /** 14760 * xmlXPathCompiledEvalInternal: 14761 * @comp: the compiled XPath expression 14762 * @ctxt: the XPath context 14763 * @resObj: the resulting XPath object or NULL 14764 * @toBool: 1 if only a boolean result is requested 14765 * 14766 * Evaluate the Precompiled XPath expression in the given context. 14767 * The caller has to free @resObj. 14768 * 14769 * Returns the xmlXPathObjectPtr resulting from the evaluation or NULL. 14770 * the caller has to free the object. 14771 */ 14772 static int 14773 xmlXPathCompiledEvalInternal(xmlXPathCompExprPtr comp, 14774 xmlXPathContextPtr ctxt, 14775 xmlXPathObjectPtr *resObj, 14776 int toBool) 14777 { 14778 xmlXPathParserContextPtr pctxt; 14779 #ifndef LIBXML_THREAD_ENABLED 14780 static int reentance = 0; 14781 #endif 14782 int res; 14783 14784 CHECK_CTXT_NEG(ctxt) 14785 14786 if (comp == NULL) 14787 return(-1); 14788 xmlXPathInit(); 14789 14790 #ifndef LIBXML_THREAD_ENABLED 14791 reentance++; 14792 if (reentance > 1) 14793 xmlXPathDisableOptimizer = 1; 14794 #endif 14795 14796 #ifdef DEBUG_EVAL_COUNTS 14797 comp->nb++; 14798 if ((comp->string != NULL) && (comp->nb > 100)) { 14799 fprintf(stderr, "100 x %s\n", comp->string); 14800 comp->nb = 0; 14801 } 14802 #endif 14803 pctxt = xmlXPathCompParserContext(comp, ctxt); 14804 res = xmlXPathRunEval(pctxt, toBool); 14805 14806 if (resObj) { 14807 if (pctxt->value == NULL) { 14808 xmlGenericError(xmlGenericErrorContext, 14809 "xmlXPathCompiledEval: evaluation failed\n"); 14810 *resObj = NULL; 14811 } else { 14812 *resObj = valuePop(pctxt); 14813 } 14814 } 14815 14816 /* 14817 * Pop all remaining objects from the stack. 14818 */ 14819 if (pctxt->valueNr > 0) { 14820 xmlXPathObjectPtr tmp; 14821 int stack = 0; 14822 14823 do { 14824 tmp = valuePop(pctxt); 14825 if (tmp != NULL) { 14826 stack++; 14827 xmlXPathReleaseObject(ctxt, tmp); 14828 } 14829 } while (tmp != NULL); 14830 if ((stack != 0) && 14831 ((toBool) || ((resObj) && (*resObj)))) 14832 { 14833 xmlGenericError(xmlGenericErrorContext, 14834 "xmlXPathCompiledEval: %d objects left on the stack.\n", 14835 stack); 14836 } 14837 } 14838 14839 if ((pctxt->error != XPATH_EXPRESSION_OK) && (resObj) && (*resObj)) { 14840 xmlXPathFreeObject(*resObj); 14841 *resObj = NULL; 14842 } 14843 pctxt->comp = NULL; 14844 xmlXPathFreeParserContext(pctxt); 14845 #ifndef LIBXML_THREAD_ENABLED 14846 reentance--; 14847 #endif 14848 14849 return(res); 14850 } 14851 14852 /** 14853 * xmlXPathCompiledEval: 14854 * @comp: the compiled XPath expression 14855 * @ctx: the XPath context 14856 * 14857 * Evaluate the Precompiled XPath expression in the given context. 14858 * 14859 * Returns the xmlXPathObjectPtr resulting from the evaluation or NULL. 14860 * the caller has to free the object. 14861 */ 14862 xmlXPathObjectPtr 14863 xmlXPathCompiledEval(xmlXPathCompExprPtr comp, xmlXPathContextPtr ctx) 14864 { 14865 xmlXPathObjectPtr res = NULL; 14866 14867 xmlXPathCompiledEvalInternal(comp, ctx, &res, 0); 14868 return(res); 14869 } 14870 14871 /** 14872 * xmlXPathCompiledEvalToBoolean: 14873 * @comp: the compiled XPath expression 14874 * @ctxt: the XPath context 14875 * 14876 * Applies the XPath boolean() function on the result of the given 14877 * compiled expression. 14878 * 14879 * Returns 1 if the expression evaluated to true, 0 if to false and 14880 * -1 in API and internal errors. 14881 */ 14882 int 14883 xmlXPathCompiledEvalToBoolean(xmlXPathCompExprPtr comp, 14884 xmlXPathContextPtr ctxt) 14885 { 14886 return(xmlXPathCompiledEvalInternal(comp, ctxt, NULL, 1)); 14887 } 14888 14889 /** 14890 * xmlXPathEvalExpr: 14891 * @ctxt: the XPath Parser context 14892 * 14893 * Parse and evaluate an XPath expression in the given context, 14894 * then push the result on the context stack 14895 */ 14896 void 14897 xmlXPathEvalExpr(xmlXPathParserContextPtr ctxt) { 14898 #ifdef XPATH_STREAMING 14899 xmlXPathCompExprPtr comp; 14900 #endif 14901 14902 if (ctxt == NULL) return; 14903 14904 #ifdef XPATH_STREAMING 14905 comp = xmlXPathTryStreamCompile(ctxt->context, ctxt->base); 14906 if (comp != NULL) { 14907 if (ctxt->comp != NULL) 14908 xmlXPathFreeCompExpr(ctxt->comp); 14909 ctxt->comp = comp; 14910 if (ctxt->cur != NULL) 14911 while (*ctxt->cur != 0) ctxt->cur++; 14912 } else 14913 #endif 14914 { 14915 xmlXPathCompileExpr(ctxt, 1); 14916 /* 14917 * In this scenario the expression string will sit in ctxt->base. 14918 */ 14919 if ((ctxt->error == XPATH_EXPRESSION_OK) && 14920 (ctxt->comp != NULL) && 14921 (ctxt->base != NULL) && 14922 (ctxt->comp->nbStep > 2) && 14923 (ctxt->comp->last >= 0) && 14924 (xmlXPathCanRewriteDosExpression((xmlChar *) ctxt->base) == 1)) 14925 { 14926 xmlXPathRewriteDOSExpression(ctxt->comp, 14927 &ctxt->comp->steps[ctxt->comp->last]); 14928 } 14929 } 14930 CHECK_ERROR; 14931 xmlXPathRunEval(ctxt, 0); 14932 } 14933 14934 /** 14935 * xmlXPathEval: 14936 * @str: the XPath expression 14937 * @ctx: the XPath context 14938 * 14939 * Evaluate the XPath Location Path in the given context. 14940 * 14941 * Returns the xmlXPathObjectPtr resulting from the evaluation or NULL. 14942 * the caller has to free the object. 14943 */ 14944 xmlXPathObjectPtr 14945 xmlXPathEval(const xmlChar *str, xmlXPathContextPtr ctx) { 14946 xmlXPathParserContextPtr ctxt; 14947 xmlXPathObjectPtr res, tmp, init = NULL; 14948 int stack = 0; 14949 14950 CHECK_CTXT(ctx) 14951 14952 xmlXPathInit(); 14953 14954 ctxt = xmlXPathNewParserContext(str, ctx); 14955 if (ctxt == NULL) 14956 return NULL; 14957 xmlXPathEvalExpr(ctxt); 14958 14959 if (ctxt->value == NULL) { 14960 xmlGenericError(xmlGenericErrorContext, 14961 "xmlXPathEval: evaluation failed\n"); 14962 res = NULL; 14963 } else if ((*ctxt->cur != 0) && (ctxt->comp != NULL) 14964 #ifdef XPATH_STREAMING 14965 && (ctxt->comp->stream == NULL) 14966 #endif 14967 ) { 14968 xmlXPatherror(ctxt, __FILE__, __LINE__, XPATH_EXPR_ERROR); 14969 res = NULL; 14970 } else { 14971 res = valuePop(ctxt); 14972 } 14973 14974 do { 14975 tmp = valuePop(ctxt); 14976 if (tmp != NULL) { 14977 if (tmp != init) 14978 stack++; 14979 xmlXPathReleaseObject(ctx, tmp); 14980 } 14981 } while (tmp != NULL); 14982 if ((stack != 0) && (res != NULL)) { 14983 xmlGenericError(xmlGenericErrorContext, 14984 "xmlXPathEval: %d object left on the stack\n", 14985 stack); 14986 } 14987 if (ctxt->error != XPATH_EXPRESSION_OK) { 14988 xmlXPathFreeObject(res); 14989 res = NULL; 14990 } 14991 14992 xmlXPathFreeParserContext(ctxt); 14993 return(res); 14994 } 14995 14996 /** 14997 * xmlXPathEvalExpression: 14998 * @str: the XPath expression 14999 * @ctxt: the XPath context 15000 * 15001 * Evaluate the XPath expression in the given context. 15002 * 15003 * Returns the xmlXPathObjectPtr resulting from the evaluation or NULL. 15004 * the caller has to free the object. 15005 */ 15006 xmlXPathObjectPtr 15007 xmlXPathEvalExpression(const xmlChar *str, xmlXPathContextPtr ctxt) { 15008 xmlXPathParserContextPtr pctxt; 15009 xmlXPathObjectPtr res, tmp; 15010 int stack = 0; 15011 15012 CHECK_CTXT(ctxt) 15013 15014 xmlXPathInit(); 15015 15016 pctxt = xmlXPathNewParserContext(str, ctxt); 15017 if (pctxt == NULL) 15018 return NULL; 15019 xmlXPathEvalExpr(pctxt); 15020 15021 if ((*pctxt->cur != 0) || (pctxt->error != XPATH_EXPRESSION_OK)) { 15022 xmlXPatherror(pctxt, __FILE__, __LINE__, XPATH_EXPR_ERROR); 15023 res = NULL; 15024 } else { 15025 res = valuePop(pctxt); 15026 } 15027 do { 15028 tmp = valuePop(pctxt); 15029 if (tmp != NULL) { 15030 xmlXPathReleaseObject(ctxt, tmp); 15031 stack++; 15032 } 15033 } while (tmp != NULL); 15034 if ((stack != 0) && (res != NULL)) { 15035 xmlGenericError(xmlGenericErrorContext, 15036 "xmlXPathEvalExpression: %d object left on the stack\n", 15037 stack); 15038 } 15039 xmlXPathFreeParserContext(pctxt); 15040 return(res); 15041 } 15042 15043 /************************************************************************ 15044 * * 15045 * Extra functions not pertaining to the XPath spec * 15046 * * 15047 ************************************************************************/ 15048 /** 15049 * xmlXPathEscapeUriFunction: 15050 * @ctxt: the XPath Parser context 15051 * @nargs: the number of arguments 15052 * 15053 * Implement the escape-uri() XPath function 15054 * string escape-uri(string $str, bool $escape-reserved) 15055 * 15056 * This function applies the URI escaping rules defined in section 2 of [RFC 15057 * 2396] to the string supplied as $uri-part, which typically represents all 15058 * or part of a URI. The effect of the function is to replace any special 15059 * character in the string by an escape sequence of the form %xx%yy..., 15060 * where xxyy... is the hexadecimal representation of the octets used to 15061 * represent the character in UTF-8. 15062 * 15063 * The set of characters that are escaped depends on the setting of the 15064 * boolean argument $escape-reserved. 15065 * 15066 * If $escape-reserved is true, all characters are escaped other than lower 15067 * case letters a-z, upper case letters A-Z, digits 0-9, and the characters 15068 * referred to in [RFC 2396] as "marks": specifically, "-" | "_" | "." | "!" 15069 * | "~" | "*" | "'" | "(" | ")". The "%" character itself is escaped only 15070 * if it is not followed by two hexadecimal digits (that is, 0-9, a-f, and 15071 * A-F). 15072 * 15073 * If $escape-reserved is false, the behavior differs in that characters 15074 * referred to in [RFC 2396] as reserved characters are not escaped. These 15075 * characters are ";" | "/" | "?" | ":" | "@" | "&" | "=" | "+" | "$" | ",". 15076 * 15077 * [RFC 2396] does not define whether escaped URIs should use lower case or 15078 * upper case for hexadecimal digits. To ensure that escaped URIs can be 15079 * compared using string comparison functions, this function must always use 15080 * the upper-case letters A-F. 15081 * 15082 * Generally, $escape-reserved should be set to true when escaping a string 15083 * that is to form a single part of a URI, and to false when escaping an 15084 * entire URI or URI reference. 15085 * 15086 * In the case of non-ascii characters, the string is encoded according to 15087 * utf-8 and then converted according to RFC 2396. 15088 * 15089 * Examples 15090 * xf:escape-uri ("gopher://spinaltap.micro.umn.edu/00/Weather/California/Los%20Angeles#ocean"), true()) 15091 * returns "gopher%3A%2F%2Fspinaltap.micro.umn.edu%2F00%2FWeather%2FCalifornia%2FLos%20Angeles%23ocean" 15092 * xf:escape-uri ("gopher://spinaltap.micro.umn.edu/00/Weather/California/Los%20Angeles#ocean"), false()) 15093 * returns "gopher://spinaltap.micro.umn.edu/00/Weather/California/Los%20Angeles%23ocean" 15094 * 15095 */ 15096 static void 15097 xmlXPathEscapeUriFunction(xmlXPathParserContextPtr ctxt, int nargs) { 15098 xmlXPathObjectPtr str; 15099 int escape_reserved; 15100 xmlBufferPtr target; 15101 xmlChar *cptr; 15102 xmlChar escape[4]; 15103 15104 CHECK_ARITY(2); 15105 15106 escape_reserved = xmlXPathPopBoolean(ctxt); 15107 15108 CAST_TO_STRING; 15109 str = valuePop(ctxt); 15110 15111 target = xmlBufferCreate(); 15112 15113 escape[0] = '%'; 15114 escape[3] = 0; 15115 15116 if (target) { 15117 for (cptr = str->stringval; *cptr; cptr++) { 15118 if ((*cptr >= 'A' && *cptr <= 'Z') || 15119 (*cptr >= 'a' && *cptr <= 'z') || 15120 (*cptr >= '0' && *cptr <= '9') || 15121 *cptr == '-' || *cptr == '_' || *cptr == '.' || 15122 *cptr == '!' || *cptr == '~' || *cptr == '*' || 15123 *cptr == '\''|| *cptr == '(' || *cptr == ')' || 15124 (*cptr == '%' && 15125 ((cptr[1] >= 'A' && cptr[1] <= 'F') || 15126 (cptr[1] >= 'a' && cptr[1] <= 'f') || 15127 (cptr[1] >= '0' && cptr[1] <= '9')) && 15128 ((cptr[2] >= 'A' && cptr[2] <= 'F') || 15129 (cptr[2] >= 'a' && cptr[2] <= 'f') || 15130 (cptr[2] >= '0' && cptr[2] <= '9'))) || 15131 (!escape_reserved && 15132 (*cptr == ';' || *cptr == '/' || *cptr == '?' || 15133 *cptr == ':' || *cptr == '@' || *cptr == '&' || 15134 *cptr == '=' || *cptr == '+' || *cptr == '$' || 15135 *cptr == ','))) { 15136 xmlBufferAdd(target, cptr, 1); 15137 } else { 15138 if ((*cptr >> 4) < 10) 15139 escape[1] = '0' + (*cptr >> 4); 15140 else 15141 escape[1] = 'A' - 10 + (*cptr >> 4); 15142 if ((*cptr & 0xF) < 10) 15143 escape[2] = '0' + (*cptr & 0xF); 15144 else 15145 escape[2] = 'A' - 10 + (*cptr & 0xF); 15146 15147 xmlBufferAdd(target, &escape[0], 3); 15148 } 15149 } 15150 } 15151 valuePush(ctxt, xmlXPathCacheNewString(ctxt->context, 15152 xmlBufferContent(target))); 15153 xmlBufferFree(target); 15154 xmlXPathReleaseObject(ctxt->context, str); 15155 } 15156 15157 /** 15158 * xmlXPathRegisterAllFunctions: 15159 * @ctxt: the XPath context 15160 * 15161 * Registers all default XPath functions in this context 15162 */ 15163 void 15164 xmlXPathRegisterAllFunctions(xmlXPathContextPtr ctxt) 15165 { 15166 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"boolean", 15167 xmlXPathBooleanFunction); 15168 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"ceiling", 15169 xmlXPathCeilingFunction); 15170 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"count", 15171 xmlXPathCountFunction); 15172 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"concat", 15173 xmlXPathConcatFunction); 15174 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"contains", 15175 xmlXPathContainsFunction); 15176 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"id", 15177 xmlXPathIdFunction); 15178 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"false", 15179 xmlXPathFalseFunction); 15180 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"floor", 15181 xmlXPathFloorFunction); 15182 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"last", 15183 xmlXPathLastFunction); 15184 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"lang", 15185 xmlXPathLangFunction); 15186 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"local-name", 15187 xmlXPathLocalNameFunction); 15188 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"not", 15189 xmlXPathNotFunction); 15190 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"name", 15191 xmlXPathNameFunction); 15192 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"namespace-uri", 15193 xmlXPathNamespaceURIFunction); 15194 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"normalize-space", 15195 xmlXPathNormalizeFunction); 15196 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"number", 15197 xmlXPathNumberFunction); 15198 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"position", 15199 xmlXPathPositionFunction); 15200 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"round", 15201 xmlXPathRoundFunction); 15202 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"string", 15203 xmlXPathStringFunction); 15204 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"string-length", 15205 xmlXPathStringLengthFunction); 15206 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"starts-with", 15207 xmlXPathStartsWithFunction); 15208 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"substring", 15209 xmlXPathSubstringFunction); 15210 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"substring-before", 15211 xmlXPathSubstringBeforeFunction); 15212 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"substring-after", 15213 xmlXPathSubstringAfterFunction); 15214 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"sum", 15215 xmlXPathSumFunction); 15216 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"true", 15217 xmlXPathTrueFunction); 15218 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"translate", 15219 xmlXPathTranslateFunction); 15220 15221 xmlXPathRegisterFuncNS(ctxt, (const xmlChar *)"escape-uri", 15222 (const xmlChar *)"http://www.w3.org/2002/08/xquery-functions", 15223 xmlXPathEscapeUriFunction); 15224 } 15225 15226 #endif /* LIBXML_XPATH_ENABLED */ 15227 #define bottom_xpath 15228 #include "elfgcchack.h" 15229
