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 /* To avoid EBCDIC trouble when parsing on zOS */ 18 #if defined(__MVS__) 19 #pragma convert("ISO8859-1") 20 #endif 21 22 #define IN_LIBXML 23 #include "libxml.h" 24 25 #include <limits.h> 26 #include <string.h> 27 #include <stddef.h> 28 29 #ifdef HAVE_SYS_TYPES_H 30 #include <sys/types.h> 31 #endif 32 #ifdef HAVE_MATH_H 33 #include <math.h> 34 #endif 35 #ifdef HAVE_FLOAT_H 36 #include <float.h> 37 #endif 38 #ifdef HAVE_CTYPE_H 39 #include <ctype.h> 40 #endif 41 #ifdef HAVE_SIGNAL_H 42 #include <signal.h> 43 #endif 44 45 #include <libxml/xmlmemory.h> 46 #include <libxml/tree.h> 47 #include <libxml/valid.h> 48 #include <libxml/xpath.h> 49 #include <libxml/xpathInternals.h> 50 #include <libxml/parserInternals.h> 51 #include <libxml/hash.h> 52 #ifdef LIBXML_XPTR_ENABLED 53 #include <libxml/xpointer.h> 54 #endif 55 #ifdef LIBXML_DEBUG_ENABLED 56 #include <libxml/debugXML.h> 57 #endif 58 #include <libxml/xmlerror.h> 59 #include <libxml/threads.h> 60 #include <libxml/globals.h> 61 #ifdef LIBXML_PATTERN_ENABLED 62 #include <libxml/pattern.h> 63 #endif 64 65 #include "buf.h" 66 67 #ifdef LIBXML_PATTERN_ENABLED 68 #define XPATH_STREAMING 69 #endif 70 71 #define TODO \ 72 xmlGenericError(xmlGenericErrorContext, \ 73 "Unimplemented block at %s:%d\n", \ 74 __FILE__, __LINE__); 75 76 /** 77 * WITH_TIM_SORT: 78 * 79 * Use the Timsort algorithm provided in timsort.h to sort 80 * nodeset as this is a great improvement over the old Shell sort 81 * used in xmlXPathNodeSetSort() 82 */ 83 #define WITH_TIM_SORT 84 85 /* 86 * XP_OPTIMIZED_NON_ELEM_COMPARISON: 87 * If defined, this will use xmlXPathCmpNodesExt() instead of 88 * xmlXPathCmpNodes(). The new function is optimized comparison of 89 * non-element nodes; actually it will speed up comparison only if 90 * xmlXPathOrderDocElems() was called in order to index the elements of 91 * a tree in document order; Libxslt does such an indexing, thus it will 92 * benefit from this optimization. 93 */ 94 #define XP_OPTIMIZED_NON_ELEM_COMPARISON 95 96 /* 97 * XP_OPTIMIZED_FILTER_FIRST: 98 * If defined, this will optimize expressions like "key('foo', 'val')[b][1]" 99 * in a way, that it stop evaluation at the first node. 100 */ 101 #define XP_OPTIMIZED_FILTER_FIRST 102 103 /* 104 * XP_DEBUG_OBJ_USAGE: 105 * Internal flag to enable tracking of how much XPath objects have been 106 * created. 107 */ 108 /* #define XP_DEBUG_OBJ_USAGE */ 109 110 /* 111 * XPATH_MAX_STEPS: 112 * when compiling an XPath expression we arbitrary limit the maximum 113 * number of step operation in the compiled expression. 1000000 is 114 * an insanely large value which should never be reached under normal 115 * circumstances 116 */ 117 #define XPATH_MAX_STEPS 1000000 118 119 /* 120 * XPATH_MAX_STACK_DEPTH: 121 * when evaluating an XPath expression we arbitrary limit the maximum 122 * number of object allowed to be pushed on the stack. 1000000 is 123 * an insanely large value which should never be reached under normal 124 * circumstances 125 */ 126 #define XPATH_MAX_STACK_DEPTH 1000000 127 128 /* 129 * XPATH_MAX_NODESET_LENGTH: 130 * when evaluating an XPath expression nodesets are created and we 131 * arbitrary limit the maximum length of those node set. 10000000 is 132 * an insanely large value which should never be reached under normal 133 * circumstances, one would first need to construct an in memory tree 134 * with more than 10 millions nodes. 135 */ 136 #define XPATH_MAX_NODESET_LENGTH 10000000 137 138 /* 139 * TODO: 140 * There are a few spots where some tests are done which depend upon ascii 141 * data. These should be enhanced for full UTF8 support (see particularly 142 * any use of the macros IS_ASCII_CHARACTER and IS_ASCII_DIGIT) 143 */ 144 145 #ifdef XP_OPTIMIZED_NON_ELEM_COMPARISON 146 /** 147 * xmlXPathCmpNodesExt: 148 * @node1: the first node 149 * @node2: the second node 150 * 151 * Compare two nodes w.r.t document order. 152 * This one is optimized for handling of non-element nodes. 153 * 154 * Returns -2 in case of error 1 if first point < second point, 0 if 155 * it's the same node, -1 otherwise 156 */ 157 static int 158 xmlXPathCmpNodesExt(xmlNodePtr node1, xmlNodePtr node2) { 159 int depth1, depth2; 160 int misc = 0, precedence1 = 0, precedence2 = 0; 161 xmlNodePtr miscNode1 = NULL, miscNode2 = NULL; 162 xmlNodePtr cur, root; 163 ptrdiff_t l1, l2; 164 165 if ((node1 == NULL) || (node2 == NULL)) 166 return(-2); 167 168 if (node1 == node2) 169 return(0); 170 171 /* 172 * a couple of optimizations which will avoid computations in most cases 173 */ 174 switch (node1->type) { 175 case XML_ELEMENT_NODE: 176 if (node2->type == XML_ELEMENT_NODE) { 177 if ((0 > (ptrdiff_t) node1->content) && 178 (0 > (ptrdiff_t) node2->content) && 179 (node1->doc == node2->doc)) 180 { 181 l1 = -((ptrdiff_t) node1->content); 182 l2 = -((ptrdiff_t) node2->content); 183 if (l1 < l2) 184 return(1); 185 if (l1 > l2) 186 return(-1); 187 } else 188 goto turtle_comparison; 189 } 190 break; 191 case XML_ATTRIBUTE_NODE: 192 precedence1 = 1; /* element is owner */ 193 miscNode1 = node1; 194 node1 = node1->parent; 195 misc = 1; 196 break; 197 case XML_TEXT_NODE: 198 case XML_CDATA_SECTION_NODE: 199 case XML_COMMENT_NODE: 200 case XML_PI_NODE: { 201 miscNode1 = node1; 202 /* 203 * Find nearest element node. 204 */ 205 if (node1->prev != NULL) { 206 do { 207 node1 = node1->prev; 208 if (node1->type == XML_ELEMENT_NODE) { 209 precedence1 = 3; /* element in prev-sibl axis */ 210 break; 211 } 212 if (node1->prev == NULL) { 213 precedence1 = 2; /* element is parent */ 214 /* 215 * URGENT TODO: Are there any cases, where the 216 * parent of such a node is not an element node? 217 */ 218 node1 = node1->parent; 219 break; 220 } 221 } while (1); 222 } else { 223 precedence1 = 2; /* element is parent */ 224 node1 = node1->parent; 225 } 226 if ((node1 == NULL) || (node1->type != XML_ELEMENT_NODE) || 227 (0 <= (ptrdiff_t) node1->content)) { 228 /* 229 * Fallback for whatever case. 230 */ 231 node1 = miscNode1; 232 precedence1 = 0; 233 } else 234 misc = 1; 235 } 236 break; 237 case XML_NAMESPACE_DECL: 238 /* 239 * TODO: why do we return 1 for namespace nodes? 240 */ 241 return(1); 242 default: 243 break; 244 } 245 switch (node2->type) { 246 case XML_ELEMENT_NODE: 247 break; 248 case XML_ATTRIBUTE_NODE: 249 precedence2 = 1; /* element is owner */ 250 miscNode2 = node2; 251 node2 = node2->parent; 252 misc = 1; 253 break; 254 case XML_TEXT_NODE: 255 case XML_CDATA_SECTION_NODE: 256 case XML_COMMENT_NODE: 257 case XML_PI_NODE: { 258 miscNode2 = node2; 259 if (node2->prev != NULL) { 260 do { 261 node2 = node2->prev; 262 if (node2->type == XML_ELEMENT_NODE) { 263 precedence2 = 3; /* element in prev-sibl axis */ 264 break; 265 } 266 if (node2->prev == NULL) { 267 precedence2 = 2; /* element is parent */ 268 node2 = node2->parent; 269 break; 270 } 271 } while (1); 272 } else { 273 precedence2 = 2; /* element is parent */ 274 node2 = node2->parent; 275 } 276 if ((node2 == NULL) || (node2->type != XML_ELEMENT_NODE) || 277 (0 <= (ptrdiff_t) node2->content)) 278 { 279 node2 = miscNode2; 280 precedence2 = 0; 281 } else 282 misc = 1; 283 } 284 break; 285 case XML_NAMESPACE_DECL: 286 return(1); 287 default: 288 break; 289 } 290 if (misc) { 291 if (node1 == node2) { 292 if (precedence1 == precedence2) { 293 /* 294 * The ugly case; but normally there aren't many 295 * adjacent non-element nodes around. 296 */ 297 cur = miscNode2->prev; 298 while (cur != NULL) { 299 if (cur == miscNode1) 300 return(1); 301 if (cur->type == XML_ELEMENT_NODE) 302 return(-1); 303 cur = cur->prev; 304 } 305 return (-1); 306 } else { 307 /* 308 * Evaluate based on higher precedence wrt to the element. 309 * TODO: This assumes attributes are sorted before content. 310 * Is this 100% correct? 311 */ 312 if (precedence1 < precedence2) 313 return(1); 314 else 315 return(-1); 316 } 317 } 318 /* 319 * Special case: One of the helper-elements is contained by the other. 320 * <foo> 321 * <node2> 322 * <node1>Text-1(precedence1 == 2)</node1> 323 * </node2> 324 * Text-6(precedence2 == 3) 325 * </foo> 326 */ 327 if ((precedence2 == 3) && (precedence1 > 1)) { 328 cur = node1->parent; 329 while (cur) { 330 if (cur == node2) 331 return(1); 332 cur = cur->parent; 333 } 334 } 335 if ((precedence1 == 3) && (precedence2 > 1)) { 336 cur = node2->parent; 337 while (cur) { 338 if (cur == node1) 339 return(-1); 340 cur = cur->parent; 341 } 342 } 343 } 344 345 /* 346 * Speedup using document order if availble. 347 */ 348 if ((node1->type == XML_ELEMENT_NODE) && 349 (node2->type == XML_ELEMENT_NODE) && 350 (0 > (ptrdiff_t) node1->content) && 351 (0 > (ptrdiff_t) node2->content) && 352 (node1->doc == node2->doc)) { 353 354 l1 = -((ptrdiff_t) node1->content); 355 l2 = -((ptrdiff_t) node2->content); 356 if (l1 < l2) 357 return(1); 358 if (l1 > l2) 359 return(-1); 360 } 361 362 turtle_comparison: 363 364 if (node1 == node2->prev) 365 return(1); 366 if (node1 == node2->next) 367 return(-1); 368 /* 369 * compute depth to root 370 */ 371 for (depth2 = 0, cur = node2; cur->parent != NULL; cur = cur->parent) { 372 if (cur->parent == node1) 373 return(1); 374 depth2++; 375 } 376 root = cur; 377 for (depth1 = 0, cur = node1; cur->parent != NULL; cur = cur->parent) { 378 if (cur->parent == node2) 379 return(-1); 380 depth1++; 381 } 382 /* 383 * Distinct document (or distinct entities :-( ) case. 384 */ 385 if (root != cur) { 386 return(-2); 387 } 388 /* 389 * get the nearest common ancestor. 390 */ 391 while (depth1 > depth2) { 392 depth1--; 393 node1 = node1->parent; 394 } 395 while (depth2 > depth1) { 396 depth2--; 397 node2 = node2->parent; 398 } 399 while (node1->parent != node2->parent) { 400 node1 = node1->parent; 401 node2 = node2->parent; 402 /* should not happen but just in case ... */ 403 if ((node1 == NULL) || (node2 == NULL)) 404 return(-2); 405 } 406 /* 407 * Find who's first. 408 */ 409 if (node1 == node2->prev) 410 return(1); 411 if (node1 == node2->next) 412 return(-1); 413 /* 414 * Speedup using document order if availble. 415 */ 416 if ((node1->type == XML_ELEMENT_NODE) && 417 (node2->type == XML_ELEMENT_NODE) && 418 (0 > (ptrdiff_t) node1->content) && 419 (0 > (ptrdiff_t) node2->content) && 420 (node1->doc == node2->doc)) { 421 422 l1 = -((ptrdiff_t) node1->content); 423 l2 = -((ptrdiff_t) node2->content); 424 if (l1 < l2) 425 return(1); 426 if (l1 > l2) 427 return(-1); 428 } 429 430 for (cur = node1->next;cur != NULL;cur = cur->next) 431 if (cur == node2) 432 return(1); 433 return(-1); /* assume there is no sibling list corruption */ 434 } 435 #endif /* XP_OPTIMIZED_NON_ELEM_COMPARISON */ 436 437 /* 438 * Wrapper for the Timsort argorithm from timsort.h 439 */ 440 #ifdef WITH_TIM_SORT 441 #define SORT_NAME libxml_domnode 442 #define SORT_TYPE xmlNodePtr 443 /** 444 * wrap_cmp: 445 * @x: a node 446 * @y: another node 447 * 448 * Comparison function for the Timsort implementation 449 * 450 * Returns -2 in case of error -1 if first point < second point, 0 if 451 * it's the same node, +1 otherwise 452 */ 453 static 454 int wrap_cmp( xmlNodePtr x, xmlNodePtr y ); 455 #ifdef XP_OPTIMIZED_NON_ELEM_COMPARISON 456 static int wrap_cmp( xmlNodePtr x, xmlNodePtr y ) 457 { 458 int res = xmlXPathCmpNodesExt(x, y); 459 return res == -2 ? res : -res; 460 } 461 #else 462 static int wrap_cmp( xmlNodePtr x, xmlNodePtr y ) 463 { 464 int res = xmlXPathCmpNodes(x, y); 465 return res == -2 ? res : -res; 466 } 467 #endif 468 #define SORT_CMP(x, y) (wrap_cmp(x, y)) 469 #include "timsort.h" 470 #endif /* WITH_TIM_SORT */ 471 472 #if defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) 473 474 /************************************************************************ 475 * * 476 * Floating point stuff * 477 * * 478 ************************************************************************/ 479 480 #ifndef NAN 481 #define NAN (0.0 / 0.0) 482 #endif 483 484 #ifndef INFINITY 485 #define INFINITY HUGE_VAL 486 #endif 487 488 double xmlXPathNAN = NAN; 489 double xmlXPathPINF = INFINITY; 490 double xmlXPathNINF = -INFINITY; 491 492 /** 493 * xmlXPathInit: 494 * 495 * Initialize the XPath environment 496 * 497 * Does nothing but must be kept as public function. 498 */ 499 void 500 xmlXPathInit(void) { 501 } 502 503 /** 504 * xmlXPathIsNaN: 505 * @val: a double value 506 * 507 * Returns 1 if the value is a NaN, 0 otherwise 508 */ 509 int 510 xmlXPathIsNaN(double val) { 511 #ifdef isnan 512 return isnan(val); 513 #else 514 return !(val == val); 515 #endif 516 } 517 518 /** 519 * xmlXPathIsInf: 520 * @val: a double value 521 * 522 * Returns 1 if the value is +Infinite, -1 if -Infinite, 0 otherwise 523 */ 524 int 525 xmlXPathIsInf(double val) { 526 #ifdef isinf 527 return isinf(val) ? (val > 0 ? 1 : -1) : 0; 528 #else 529 if (val >= HUGE_VAL) 530 return 1; 531 if (val <= -HUGE_VAL) 532 return -1; 533 return 0; 534 #endif 535 } 536 537 #endif /* SCHEMAS or XPATH */ 538 539 #ifdef LIBXML_XPATH_ENABLED 540 541 /* 542 * TODO: when compatibility allows remove all "fake node libxslt" strings 543 * the test should just be name[0] = ' ' 544 */ 545 #ifdef DEBUG_XPATH_EXPRESSION 546 #define DEBUG_STEP 547 #define DEBUG_EXPR 548 #define DEBUG_EVAL_COUNTS 549 #endif 550 551 static xmlNs xmlXPathXMLNamespaceStruct = { 552 NULL, 553 XML_NAMESPACE_DECL, 554 XML_XML_NAMESPACE, 555 BAD_CAST "xml", 556 NULL, 557 NULL 558 }; 559 static xmlNsPtr xmlXPathXMLNamespace = &xmlXPathXMLNamespaceStruct; 560 #ifndef LIBXML_THREAD_ENABLED 561 /* 562 * Optimizer is disabled only when threaded apps are detected while 563 * the library ain't compiled for thread safety. 564 */ 565 static int xmlXPathDisableOptimizer = 0; 566 #endif 567 568 /************************************************************************ 569 * * 570 * Error handling routines * 571 * * 572 ************************************************************************/ 573 574 /** 575 * XP_ERRORNULL: 576 * @X: the error code 577 * 578 * Macro to raise an XPath error and return NULL. 579 */ 580 #define XP_ERRORNULL(X) \ 581 { xmlXPathErr(ctxt, X); return(NULL); } 582 583 /* 584 * The array xmlXPathErrorMessages corresponds to the enum xmlXPathError 585 */ 586 static const char *xmlXPathErrorMessages[] = { 587 "Ok\n", 588 "Number encoding\n", 589 "Unfinished literal\n", 590 "Start of literal\n", 591 "Expected $ for variable reference\n", 592 "Undefined variable\n", 593 "Invalid predicate\n", 594 "Invalid expression\n", 595 "Missing closing curly brace\n", 596 "Unregistered function\n", 597 "Invalid operand\n", 598 "Invalid type\n", 599 "Invalid number of arguments\n", 600 "Invalid context size\n", 601 "Invalid context position\n", 602 "Memory allocation error\n", 603 "Syntax error\n", 604 "Resource error\n", 605 "Sub resource error\n", 606 "Undefined namespace prefix\n", 607 "Encoding error\n", 608 "Char out of XML range\n", 609 "Invalid or incomplete context\n", 610 "Stack usage error\n", 611 "Forbidden variable\n", 612 "?? Unknown error ??\n" /* Must be last in the list! */ 613 }; 614 #define MAXERRNO ((int)(sizeof(xmlXPathErrorMessages) / \ 615 sizeof(xmlXPathErrorMessages[0])) - 1) 616 /** 617 * xmlXPathErrMemory: 618 * @ctxt: an XPath context 619 * @extra: extra informations 620 * 621 * Handle a redefinition of attribute error 622 */ 623 static void 624 xmlXPathErrMemory(xmlXPathContextPtr ctxt, const char *extra) 625 { 626 if (ctxt != NULL) { 627 if (extra) { 628 xmlChar buf[200]; 629 630 xmlStrPrintf(buf, 200, 631 "Memory allocation failed : %s\n", 632 extra); 633 ctxt->lastError.message = (char *) xmlStrdup(buf); 634 } else { 635 ctxt->lastError.message = (char *) 636 xmlStrdup(BAD_CAST "Memory allocation failed\n"); 637 } 638 ctxt->lastError.domain = XML_FROM_XPATH; 639 ctxt->lastError.code = XML_ERR_NO_MEMORY; 640 if (ctxt->error != NULL) 641 ctxt->error(ctxt->userData, &ctxt->lastError); 642 } else { 643 if (extra) 644 __xmlRaiseError(NULL, NULL, NULL, 645 NULL, NULL, XML_FROM_XPATH, 646 XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0, 647 extra, NULL, NULL, 0, 0, 648 "Memory allocation failed : %s\n", extra); 649 else 650 __xmlRaiseError(NULL, NULL, NULL, 651 NULL, NULL, XML_FROM_XPATH, 652 XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0, 653 NULL, NULL, NULL, 0, 0, 654 "Memory allocation failed\n"); 655 } 656 } 657 658 /** 659 * xmlXPathPErrMemory: 660 * @ctxt: an XPath parser context 661 * @extra: extra informations 662 * 663 * Handle a redefinition of attribute error 664 */ 665 static void 666 xmlXPathPErrMemory(xmlXPathParserContextPtr ctxt, const char *extra) 667 { 668 if (ctxt == NULL) 669 xmlXPathErrMemory(NULL, extra); 670 else { 671 ctxt->error = XPATH_MEMORY_ERROR; 672 xmlXPathErrMemory(ctxt->context, extra); 673 } 674 } 675 676 /** 677 * xmlXPathErr: 678 * @ctxt: a XPath parser context 679 * @error: the error code 680 * 681 * Handle an XPath error 682 */ 683 void 684 xmlXPathErr(xmlXPathParserContextPtr ctxt, int error) 685 { 686 if ((error < 0) || (error > MAXERRNO)) 687 error = MAXERRNO; 688 if (ctxt == NULL) { 689 __xmlRaiseError(NULL, NULL, NULL, 690 NULL, NULL, XML_FROM_XPATH, 691 error + XML_XPATH_EXPRESSION_OK - XPATH_EXPRESSION_OK, 692 XML_ERR_ERROR, NULL, 0, 693 NULL, NULL, NULL, 0, 0, 694 "%s", xmlXPathErrorMessages[error]); 695 return; 696 } 697 ctxt->error = error; 698 if (ctxt->context == NULL) { 699 __xmlRaiseError(NULL, NULL, NULL, 700 NULL, NULL, XML_FROM_XPATH, 701 error + XML_XPATH_EXPRESSION_OK - XPATH_EXPRESSION_OK, 702 XML_ERR_ERROR, NULL, 0, 703 (const char *) ctxt->base, NULL, NULL, 704 ctxt->cur - ctxt->base, 0, 705 "%s", xmlXPathErrorMessages[error]); 706 return; 707 } 708 709 /* cleanup current last error */ 710 xmlResetError(&ctxt->context->lastError); 711 712 ctxt->context->lastError.domain = XML_FROM_XPATH; 713 ctxt->context->lastError.code = error + XML_XPATH_EXPRESSION_OK - 714 XPATH_EXPRESSION_OK; 715 ctxt->context->lastError.level = XML_ERR_ERROR; 716 ctxt->context->lastError.str1 = (char *) xmlStrdup(ctxt->base); 717 ctxt->context->lastError.int1 = ctxt->cur - ctxt->base; 718 ctxt->context->lastError.node = ctxt->context->debugNode; 719 if (ctxt->context->error != NULL) { 720 ctxt->context->error(ctxt->context->userData, 721 &ctxt->context->lastError); 722 } else { 723 __xmlRaiseError(NULL, NULL, NULL, 724 NULL, ctxt->context->debugNode, XML_FROM_XPATH, 725 error + XML_XPATH_EXPRESSION_OK - XPATH_EXPRESSION_OK, 726 XML_ERR_ERROR, NULL, 0, 727 (const char *) ctxt->base, NULL, NULL, 728 ctxt->cur - ctxt->base, 0, 729 "%s", xmlXPathErrorMessages[error]); 730 } 731 732 } 733 734 /** 735 * xmlXPatherror: 736 * @ctxt: the XPath Parser context 737 * @file: the file name 738 * @line: the line number 739 * @no: the error number 740 * 741 * Formats an error message. 742 */ 743 void 744 xmlXPatherror(xmlXPathParserContextPtr ctxt, const char *file ATTRIBUTE_UNUSED, 745 int line ATTRIBUTE_UNUSED, int no) { 746 xmlXPathErr(ctxt, no); 747 } 748 749 /************************************************************************ 750 * * 751 * Utilities * 752 * * 753 ************************************************************************/ 754 755 /** 756 * xsltPointerList: 757 * 758 * Pointer-list for various purposes. 759 */ 760 typedef struct _xmlPointerList xmlPointerList; 761 typedef xmlPointerList *xmlPointerListPtr; 762 struct _xmlPointerList { 763 void **items; 764 int number; 765 int size; 766 }; 767 /* 768 * TODO: Since such a list-handling is used in xmlschemas.c and libxslt 769 * and here, we should make the functions public. 770 */ 771 static int 772 xmlPointerListAddSize(xmlPointerListPtr list, 773 void *item, 774 int initialSize) 775 { 776 if (list->items == NULL) { 777 if (initialSize <= 0) 778 initialSize = 1; 779 list->items = (void **) xmlMalloc(initialSize * sizeof(void *)); 780 if (list->items == NULL) { 781 xmlXPathErrMemory(NULL, 782 "xmlPointerListCreate: allocating item\n"); 783 return(-1); 784 } 785 list->number = 0; 786 list->size = initialSize; 787 } else if (list->size <= list->number) { 788 if (list->size > 50000000) { 789 xmlXPathErrMemory(NULL, 790 "xmlPointerListAddSize: re-allocating item\n"); 791 return(-1); 792 } 793 list->size *= 2; 794 list->items = (void **) xmlRealloc(list->items, 795 list->size * sizeof(void *)); 796 if (list->items == NULL) { 797 xmlXPathErrMemory(NULL, 798 "xmlPointerListAddSize: re-allocating item\n"); 799 list->size = 0; 800 return(-1); 801 } 802 } 803 list->items[list->number++] = item; 804 return(0); 805 } 806 807 /** 808 * xsltPointerListCreate: 809 * 810 * Creates an xsltPointerList structure. 811 * 812 * Returns a xsltPointerList structure or NULL in case of an error. 813 */ 814 static xmlPointerListPtr 815 xmlPointerListCreate(int initialSize) 816 { 817 xmlPointerListPtr ret; 818 819 ret = xmlMalloc(sizeof(xmlPointerList)); 820 if (ret == NULL) { 821 xmlXPathErrMemory(NULL, 822 "xmlPointerListCreate: allocating item\n"); 823 return (NULL); 824 } 825 memset(ret, 0, sizeof(xmlPointerList)); 826 if (initialSize > 0) { 827 xmlPointerListAddSize(ret, NULL, initialSize); 828 ret->number = 0; 829 } 830 return (ret); 831 } 832 833 /** 834 * xsltPointerListFree: 835 * 836 * Frees the xsltPointerList structure. This does not free 837 * the content of the list. 838 */ 839 static void 840 xmlPointerListFree(xmlPointerListPtr list) 841 { 842 if (list == NULL) 843 return; 844 if (list->items != NULL) 845 xmlFree(list->items); 846 xmlFree(list); 847 } 848 849 /************************************************************************ 850 * * 851 * Parser Types * 852 * * 853 ************************************************************************/ 854 855 /* 856 * Types are private: 857 */ 858 859 typedef enum { 860 XPATH_OP_END=0, 861 XPATH_OP_AND, 862 XPATH_OP_OR, 863 XPATH_OP_EQUAL, 864 XPATH_OP_CMP, 865 XPATH_OP_PLUS, 866 XPATH_OP_MULT, 867 XPATH_OP_UNION, 868 XPATH_OP_ROOT, 869 XPATH_OP_NODE, 870 XPATH_OP_RESET, /* 10 */ 871 XPATH_OP_COLLECT, 872 XPATH_OP_VALUE, /* 12 */ 873 XPATH_OP_VARIABLE, 874 XPATH_OP_FUNCTION, 875 XPATH_OP_ARG, 876 XPATH_OP_PREDICATE, 877 XPATH_OP_FILTER, /* 17 */ 878 XPATH_OP_SORT /* 18 */ 879 #ifdef LIBXML_XPTR_ENABLED 880 ,XPATH_OP_RANGETO 881 #endif 882 } xmlXPathOp; 883 884 typedef enum { 885 AXIS_ANCESTOR = 1, 886 AXIS_ANCESTOR_OR_SELF, 887 AXIS_ATTRIBUTE, 888 AXIS_CHILD, 889 AXIS_DESCENDANT, 890 AXIS_DESCENDANT_OR_SELF, 891 AXIS_FOLLOWING, 892 AXIS_FOLLOWING_SIBLING, 893 AXIS_NAMESPACE, 894 AXIS_PARENT, 895 AXIS_PRECEDING, 896 AXIS_PRECEDING_SIBLING, 897 AXIS_SELF 898 } xmlXPathAxisVal; 899 900 typedef enum { 901 NODE_TEST_NONE = 0, 902 NODE_TEST_TYPE = 1, 903 NODE_TEST_PI = 2, 904 NODE_TEST_ALL = 3, 905 NODE_TEST_NS = 4, 906 NODE_TEST_NAME = 5 907 } xmlXPathTestVal; 908 909 typedef enum { 910 NODE_TYPE_NODE = 0, 911 NODE_TYPE_COMMENT = XML_COMMENT_NODE, 912 NODE_TYPE_TEXT = XML_TEXT_NODE, 913 NODE_TYPE_PI = XML_PI_NODE 914 } xmlXPathTypeVal; 915 916 typedef struct _xmlXPathStepOp xmlXPathStepOp; 917 typedef xmlXPathStepOp *xmlXPathStepOpPtr; 918 struct _xmlXPathStepOp { 919 xmlXPathOp op; /* The identifier of the operation */ 920 int ch1; /* First child */ 921 int ch2; /* Second child */ 922 int value; 923 int value2; 924 int value3; 925 void *value4; 926 void *value5; 927 xmlXPathFunction cache; 928 void *cacheURI; 929 }; 930 931 struct _xmlXPathCompExpr { 932 int nbStep; /* Number of steps in this expression */ 933 int maxStep; /* Maximum number of steps allocated */ 934 xmlXPathStepOp *steps; /* ops for computation of this expression */ 935 int last; /* index of last step in expression */ 936 xmlChar *expr; /* the expression being computed */ 937 xmlDictPtr dict; /* the dictionary to use if any */ 938 #ifdef DEBUG_EVAL_COUNTS 939 int nb; 940 xmlChar *string; 941 #endif 942 #ifdef XPATH_STREAMING 943 xmlPatternPtr stream; 944 #endif 945 }; 946 947 /************************************************************************ 948 * * 949 * Forward declarations * 950 * * 951 ************************************************************************/ 952 static void 953 xmlXPathFreeValueTree(xmlNodeSetPtr obj); 954 static void 955 xmlXPathReleaseObject(xmlXPathContextPtr ctxt, xmlXPathObjectPtr obj); 956 static int 957 xmlXPathCompOpEvalFirst(xmlXPathParserContextPtr ctxt, 958 xmlXPathStepOpPtr op, xmlNodePtr *first); 959 static int 960 xmlXPathCompOpEvalToBoolean(xmlXPathParserContextPtr ctxt, 961 xmlXPathStepOpPtr op, 962 int isPredicate); 963 static void 964 xmlXPathFreeObjectEntry(void *obj, const xmlChar *name); 965 966 /************************************************************************ 967 * * 968 * Parser Type functions * 969 * * 970 ************************************************************************/ 971 972 /** 973 * xmlXPathNewCompExpr: 974 * 975 * Create a new Xpath component 976 * 977 * Returns the newly allocated xmlXPathCompExprPtr or NULL in case of error 978 */ 979 static xmlXPathCompExprPtr 980 xmlXPathNewCompExpr(void) { 981 xmlXPathCompExprPtr cur; 982 983 cur = (xmlXPathCompExprPtr) xmlMalloc(sizeof(xmlXPathCompExpr)); 984 if (cur == NULL) { 985 xmlXPathErrMemory(NULL, "allocating component\n"); 986 return(NULL); 987 } 988 memset(cur, 0, sizeof(xmlXPathCompExpr)); 989 cur->maxStep = 10; 990 cur->nbStep = 0; 991 cur->steps = (xmlXPathStepOp *) xmlMalloc(cur->maxStep * 992 sizeof(xmlXPathStepOp)); 993 if (cur->steps == NULL) { 994 xmlXPathErrMemory(NULL, "allocating steps\n"); 995 xmlFree(cur); 996 return(NULL); 997 } 998 memset(cur->steps, 0, cur->maxStep * sizeof(xmlXPathStepOp)); 999 cur->last = -1; 1000 #ifdef DEBUG_EVAL_COUNTS 1001 cur->nb = 0; 1002 #endif 1003 return(cur); 1004 } 1005 1006 /** 1007 * xmlXPathFreeCompExpr: 1008 * @comp: an XPATH comp 1009 * 1010 * Free up the memory allocated by @comp 1011 */ 1012 void 1013 xmlXPathFreeCompExpr(xmlXPathCompExprPtr comp) 1014 { 1015 xmlXPathStepOpPtr op; 1016 int i; 1017 1018 if (comp == NULL) 1019 return; 1020 if (comp->dict == NULL) { 1021 for (i = 0; i < comp->nbStep; i++) { 1022 op = &comp->steps[i]; 1023 if (op->value4 != NULL) { 1024 if (op->op == XPATH_OP_VALUE) 1025 xmlXPathFreeObject(op->value4); 1026 else 1027 xmlFree(op->value4); 1028 } 1029 if (op->value5 != NULL) 1030 xmlFree(op->value5); 1031 } 1032 } else { 1033 for (i = 0; i < comp->nbStep; i++) { 1034 op = &comp->steps[i]; 1035 if (op->value4 != NULL) { 1036 if (op->op == XPATH_OP_VALUE) 1037 xmlXPathFreeObject(op->value4); 1038 } 1039 } 1040 xmlDictFree(comp->dict); 1041 } 1042 if (comp->steps != NULL) { 1043 xmlFree(comp->steps); 1044 } 1045 #ifdef DEBUG_EVAL_COUNTS 1046 if (comp->string != NULL) { 1047 xmlFree(comp->string); 1048 } 1049 #endif 1050 #ifdef XPATH_STREAMING 1051 if (comp->stream != NULL) { 1052 xmlFreePatternList(comp->stream); 1053 } 1054 #endif 1055 if (comp->expr != NULL) { 1056 xmlFree(comp->expr); 1057 } 1058 1059 xmlFree(comp); 1060 } 1061 1062 /** 1063 * xmlXPathCompExprAdd: 1064 * @comp: the compiled expression 1065 * @ch1: first child index 1066 * @ch2: second child index 1067 * @op: an op 1068 * @value: the first int value 1069 * @value2: the second int value 1070 * @value3: the third int value 1071 * @value4: the first string value 1072 * @value5: the second string value 1073 * 1074 * Add a step to an XPath Compiled Expression 1075 * 1076 * Returns -1 in case of failure, the index otherwise 1077 */ 1078 static int 1079 xmlXPathCompExprAdd(xmlXPathCompExprPtr comp, int ch1, int ch2, 1080 xmlXPathOp op, int value, 1081 int value2, int value3, void *value4, void *value5) { 1082 if (comp->nbStep >= comp->maxStep) { 1083 xmlXPathStepOp *real; 1084 1085 if (comp->maxStep >= XPATH_MAX_STEPS) { 1086 xmlXPathErrMemory(NULL, "adding step\n"); 1087 return(-1); 1088 } 1089 comp->maxStep *= 2; 1090 real = (xmlXPathStepOp *) xmlRealloc(comp->steps, 1091 comp->maxStep * sizeof(xmlXPathStepOp)); 1092 if (real == NULL) { 1093 comp->maxStep /= 2; 1094 xmlXPathErrMemory(NULL, "adding step\n"); 1095 return(-1); 1096 } 1097 comp->steps = real; 1098 } 1099 comp->last = comp->nbStep; 1100 comp->steps[comp->nbStep].ch1 = ch1; 1101 comp->steps[comp->nbStep].ch2 = ch2; 1102 comp->steps[comp->nbStep].op = op; 1103 comp->steps[comp->nbStep].value = value; 1104 comp->steps[comp->nbStep].value2 = value2; 1105 comp->steps[comp->nbStep].value3 = value3; 1106 if ((comp->dict != NULL) && 1107 ((op == XPATH_OP_FUNCTION) || (op == XPATH_OP_VARIABLE) || 1108 (op == XPATH_OP_COLLECT))) { 1109 if (value4 != NULL) { 1110 comp->steps[comp->nbStep].value4 = (xmlChar *) 1111 (void *)xmlDictLookup(comp->dict, value4, -1); 1112 xmlFree(value4); 1113 } else 1114 comp->steps[comp->nbStep].value4 = NULL; 1115 if (value5 != NULL) { 1116 comp->steps[comp->nbStep].value5 = (xmlChar *) 1117 (void *)xmlDictLookup(comp->dict, value5, -1); 1118 xmlFree(value5); 1119 } else 1120 comp->steps[comp->nbStep].value5 = NULL; 1121 } else { 1122 comp->steps[comp->nbStep].value4 = value4; 1123 comp->steps[comp->nbStep].value5 = value5; 1124 } 1125 comp->steps[comp->nbStep].cache = NULL; 1126 return(comp->nbStep++); 1127 } 1128 1129 /** 1130 * xmlXPathCompSwap: 1131 * @comp: the compiled expression 1132 * @op: operation index 1133 * 1134 * Swaps 2 operations in the compiled expression 1135 */ 1136 static void 1137 xmlXPathCompSwap(xmlXPathStepOpPtr op) { 1138 int tmp; 1139 1140 #ifndef LIBXML_THREAD_ENABLED 1141 /* 1142 * Since this manipulates possibly shared variables, this is 1143 * disabled if one detects that the library is used in a multithreaded 1144 * application 1145 */ 1146 if (xmlXPathDisableOptimizer) 1147 return; 1148 #endif 1149 1150 tmp = op->ch1; 1151 op->ch1 = op->ch2; 1152 op->ch2 = tmp; 1153 } 1154 1155 #define PUSH_FULL_EXPR(op, op1, op2, val, val2, val3, val4, val5) \ 1156 xmlXPathCompExprAdd(ctxt->comp, (op1), (op2), \ 1157 (op), (val), (val2), (val3), (val4), (val5)) 1158 #define PUSH_LONG_EXPR(op, val, val2, val3, val4, val5) \ 1159 xmlXPathCompExprAdd(ctxt->comp, ctxt->comp->last, -1, \ 1160 (op), (val), (val2), (val3), (val4), (val5)) 1161 1162 #define PUSH_LEAVE_EXPR(op, val, val2) \ 1163 xmlXPathCompExprAdd(ctxt->comp, -1, -1, (op), (val), (val2), 0 ,NULL ,NULL) 1164 1165 #define PUSH_UNARY_EXPR(op, ch, val, val2) \ 1166 xmlXPathCompExprAdd(ctxt->comp, (ch), -1, (op), (val), (val2), 0 ,NULL ,NULL) 1167 1168 #define PUSH_BINARY_EXPR(op, ch1, ch2, val, val2) \ 1169 xmlXPathCompExprAdd(ctxt->comp, (ch1), (ch2), (op), \ 1170 (val), (val2), 0 ,NULL ,NULL) 1171 1172 /************************************************************************ 1173 * * 1174 * XPath object cache structures * 1175 * * 1176 ************************************************************************/ 1177 1178 /* #define XP_DEFAULT_CACHE_ON */ 1179 1180 #define XP_HAS_CACHE(c) ((c != NULL) && ((c)->cache != NULL)) 1181 1182 typedef struct _xmlXPathContextCache xmlXPathContextCache; 1183 typedef xmlXPathContextCache *xmlXPathContextCachePtr; 1184 struct _xmlXPathContextCache { 1185 xmlPointerListPtr nodesetObjs; /* contains xmlXPathObjectPtr */ 1186 xmlPointerListPtr stringObjs; /* contains xmlXPathObjectPtr */ 1187 xmlPointerListPtr booleanObjs; /* contains xmlXPathObjectPtr */ 1188 xmlPointerListPtr numberObjs; /* contains xmlXPathObjectPtr */ 1189 xmlPointerListPtr miscObjs; /* contains xmlXPathObjectPtr */ 1190 int maxNodeset; 1191 int maxString; 1192 int maxBoolean; 1193 int maxNumber; 1194 int maxMisc; 1195 #ifdef XP_DEBUG_OBJ_USAGE 1196 int dbgCachedAll; 1197 int dbgCachedNodeset; 1198 int dbgCachedString; 1199 int dbgCachedBool; 1200 int dbgCachedNumber; 1201 int dbgCachedPoint; 1202 int dbgCachedRange; 1203 int dbgCachedLocset; 1204 int dbgCachedUsers; 1205 int dbgCachedXSLTTree; 1206 int dbgCachedUndefined; 1207 1208 1209 int dbgReusedAll; 1210 int dbgReusedNodeset; 1211 int dbgReusedString; 1212 int dbgReusedBool; 1213 int dbgReusedNumber; 1214 int dbgReusedPoint; 1215 int dbgReusedRange; 1216 int dbgReusedLocset; 1217 int dbgReusedUsers; 1218 int dbgReusedXSLTTree; 1219 int dbgReusedUndefined; 1220 1221 #endif 1222 }; 1223 1224 /************************************************************************ 1225 * * 1226 * Debugging related functions * 1227 * * 1228 ************************************************************************/ 1229 1230 #define STRANGE \ 1231 xmlGenericError(xmlGenericErrorContext, \ 1232 "Internal error at %s:%d\n", \ 1233 __FILE__, __LINE__); 1234 1235 #ifdef LIBXML_DEBUG_ENABLED 1236 static void 1237 xmlXPathDebugDumpNode(FILE *output, xmlNodePtr cur, int depth) { 1238 int i; 1239 char shift[100]; 1240 1241 for (i = 0;((i < depth) && (i < 25));i++) 1242 shift[2 * i] = shift[2 * i + 1] = ' '; 1243 shift[2 * i] = shift[2 * i + 1] = 0; 1244 if (cur == NULL) { 1245 fprintf(output, "%s", shift); 1246 fprintf(output, "Node is NULL !\n"); 1247 return; 1248 1249 } 1250 1251 if ((cur->type == XML_DOCUMENT_NODE) || 1252 (cur->type == XML_HTML_DOCUMENT_NODE)) { 1253 fprintf(output, "%s", shift); 1254 fprintf(output, " /\n"); 1255 } else if (cur->type == XML_ATTRIBUTE_NODE) 1256 xmlDebugDumpAttr(output, (xmlAttrPtr)cur, depth); 1257 else 1258 xmlDebugDumpOneNode(output, cur, depth); 1259 } 1260 static void 1261 xmlXPathDebugDumpNodeList(FILE *output, xmlNodePtr cur, int depth) { 1262 xmlNodePtr tmp; 1263 int i; 1264 char shift[100]; 1265 1266 for (i = 0;((i < depth) && (i < 25));i++) 1267 shift[2 * i] = shift[2 * i + 1] = ' '; 1268 shift[2 * i] = shift[2 * i + 1] = 0; 1269 if (cur == NULL) { 1270 fprintf(output, "%s", shift); 1271 fprintf(output, "Node is NULL !\n"); 1272 return; 1273 1274 } 1275 1276 while (cur != NULL) { 1277 tmp = cur; 1278 cur = cur->next; 1279 xmlDebugDumpOneNode(output, tmp, depth); 1280 } 1281 } 1282 1283 static void 1284 xmlXPathDebugDumpNodeSet(FILE *output, xmlNodeSetPtr cur, int depth) { 1285 int i; 1286 char shift[100]; 1287 1288 for (i = 0;((i < depth) && (i < 25));i++) 1289 shift[2 * i] = shift[2 * i + 1] = ' '; 1290 shift[2 * i] = shift[2 * i + 1] = 0; 1291 1292 if (cur == NULL) { 1293 fprintf(output, "%s", shift); 1294 fprintf(output, "NodeSet is NULL !\n"); 1295 return; 1296 1297 } 1298 1299 if (cur != NULL) { 1300 fprintf(output, "Set contains %d nodes:\n", cur->nodeNr); 1301 for (i = 0;i < cur->nodeNr;i++) { 1302 fprintf(output, "%s", shift); 1303 fprintf(output, "%d", i + 1); 1304 xmlXPathDebugDumpNode(output, cur->nodeTab[i], depth + 1); 1305 } 1306 } 1307 } 1308 1309 static void 1310 xmlXPathDebugDumpValueTree(FILE *output, xmlNodeSetPtr cur, int depth) { 1311 int i; 1312 char shift[100]; 1313 1314 for (i = 0;((i < depth) && (i < 25));i++) 1315 shift[2 * i] = shift[2 * i + 1] = ' '; 1316 shift[2 * i] = shift[2 * i + 1] = 0; 1317 1318 if ((cur == NULL) || (cur->nodeNr == 0) || (cur->nodeTab[0] == NULL)) { 1319 fprintf(output, "%s", shift); 1320 fprintf(output, "Value Tree is NULL !\n"); 1321 return; 1322 1323 } 1324 1325 fprintf(output, "%s", shift); 1326 fprintf(output, "%d", i + 1); 1327 xmlXPathDebugDumpNodeList(output, cur->nodeTab[0]->children, depth + 1); 1328 } 1329 #if defined(LIBXML_XPTR_ENABLED) 1330 static void 1331 xmlXPathDebugDumpLocationSet(FILE *output, xmlLocationSetPtr cur, int depth) { 1332 int i; 1333 char shift[100]; 1334 1335 for (i = 0;((i < depth) && (i < 25));i++) 1336 shift[2 * i] = shift[2 * i + 1] = ' '; 1337 shift[2 * i] = shift[2 * i + 1] = 0; 1338 1339 if (cur == NULL) { 1340 fprintf(output, "%s", shift); 1341 fprintf(output, "LocationSet is NULL !\n"); 1342 return; 1343 1344 } 1345 1346 for (i = 0;i < cur->locNr;i++) { 1347 fprintf(output, "%s", shift); 1348 fprintf(output, "%d : ", i + 1); 1349 xmlXPathDebugDumpObject(output, cur->locTab[i], depth + 1); 1350 } 1351 } 1352 #endif /* LIBXML_XPTR_ENABLED */ 1353 1354 /** 1355 * xmlXPathDebugDumpObject: 1356 * @output: the FILE * to dump the output 1357 * @cur: the object to inspect 1358 * @depth: indentation level 1359 * 1360 * Dump the content of the object for debugging purposes 1361 */ 1362 void 1363 xmlXPathDebugDumpObject(FILE *output, xmlXPathObjectPtr cur, int depth) { 1364 int i; 1365 char shift[100]; 1366 1367 if (output == NULL) return; 1368 1369 for (i = 0;((i < depth) && (i < 25));i++) 1370 shift[2 * i] = shift[2 * i + 1] = ' '; 1371 shift[2 * i] = shift[2 * i + 1] = 0; 1372 1373 1374 fprintf(output, "%s", shift); 1375 1376 if (cur == NULL) { 1377 fprintf(output, "Object is empty (NULL)\n"); 1378 return; 1379 } 1380 switch(cur->type) { 1381 case XPATH_UNDEFINED: 1382 fprintf(output, "Object is uninitialized\n"); 1383 break; 1384 case XPATH_NODESET: 1385 fprintf(output, "Object is a Node Set :\n"); 1386 xmlXPathDebugDumpNodeSet(output, cur->nodesetval, depth); 1387 break; 1388 case XPATH_XSLT_TREE: 1389 fprintf(output, "Object is an XSLT value tree :\n"); 1390 xmlXPathDebugDumpValueTree(output, cur->nodesetval, depth); 1391 break; 1392 case XPATH_BOOLEAN: 1393 fprintf(output, "Object is a Boolean : "); 1394 if (cur->boolval) fprintf(output, "true\n"); 1395 else fprintf(output, "false\n"); 1396 break; 1397 case XPATH_NUMBER: 1398 switch (xmlXPathIsInf(cur->floatval)) { 1399 case 1: 1400 fprintf(output, "Object is a number : Infinity\n"); 1401 break; 1402 case -1: 1403 fprintf(output, "Object is a number : -Infinity\n"); 1404 break; 1405 default: 1406 if (xmlXPathIsNaN(cur->floatval)) { 1407 fprintf(output, "Object is a number : NaN\n"); 1408 } else if (cur->floatval == 0) { 1409 /* Omit sign for negative zero. */ 1410 fprintf(output, "Object is a number : 0\n"); 1411 } else { 1412 fprintf(output, "Object is a number : %0g\n", cur->floatval); 1413 } 1414 } 1415 break; 1416 case XPATH_STRING: 1417 fprintf(output, "Object is a string : "); 1418 xmlDebugDumpString(output, cur->stringval); 1419 fprintf(output, "\n"); 1420 break; 1421 case XPATH_POINT: 1422 fprintf(output, "Object is a point : index %d in node", cur->index); 1423 xmlXPathDebugDumpNode(output, (xmlNodePtr) cur->user, depth + 1); 1424 fprintf(output, "\n"); 1425 break; 1426 case XPATH_RANGE: 1427 if ((cur->user2 == NULL) || 1428 ((cur->user2 == cur->user) && (cur->index == cur->index2))) { 1429 fprintf(output, "Object is a collapsed range :\n"); 1430 fprintf(output, "%s", shift); 1431 if (cur->index >= 0) 1432 fprintf(output, "index %d in ", cur->index); 1433 fprintf(output, "node\n"); 1434 xmlXPathDebugDumpNode(output, (xmlNodePtr) cur->user, 1435 depth + 1); 1436 } else { 1437 fprintf(output, "Object is a range :\n"); 1438 fprintf(output, "%s", shift); 1439 fprintf(output, "From "); 1440 if (cur->index >= 0) 1441 fprintf(output, "index %d in ", cur->index); 1442 fprintf(output, "node\n"); 1443 xmlXPathDebugDumpNode(output, (xmlNodePtr) cur->user, 1444 depth + 1); 1445 fprintf(output, "%s", shift); 1446 fprintf(output, "To "); 1447 if (cur->index2 >= 0) 1448 fprintf(output, "index %d in ", cur->index2); 1449 fprintf(output, "node\n"); 1450 xmlXPathDebugDumpNode(output, (xmlNodePtr) cur->user2, 1451 depth + 1); 1452 fprintf(output, "\n"); 1453 } 1454 break; 1455 case XPATH_LOCATIONSET: 1456 #if defined(LIBXML_XPTR_ENABLED) 1457 fprintf(output, "Object is a Location Set:\n"); 1458 xmlXPathDebugDumpLocationSet(output, 1459 (xmlLocationSetPtr) cur->user, depth); 1460 #endif 1461 break; 1462 case XPATH_USERS: 1463 fprintf(output, "Object is user defined\n"); 1464 break; 1465 } 1466 } 1467 1468 static void 1469 xmlXPathDebugDumpStepOp(FILE *output, xmlXPathCompExprPtr comp, 1470 xmlXPathStepOpPtr op, int depth) { 1471 int i; 1472 char shift[100]; 1473 1474 for (i = 0;((i < depth) && (i < 25));i++) 1475 shift[2 * i] = shift[2 * i + 1] = ' '; 1476 shift[2 * i] = shift[2 * i + 1] = 0; 1477 1478 fprintf(output, "%s", shift); 1479 if (op == NULL) { 1480 fprintf(output, "Step is NULL\n"); 1481 return; 1482 } 1483 switch (op->op) { 1484 case XPATH_OP_END: 1485 fprintf(output, "END"); break; 1486 case XPATH_OP_AND: 1487 fprintf(output, "AND"); break; 1488 case XPATH_OP_OR: 1489 fprintf(output, "OR"); break; 1490 case XPATH_OP_EQUAL: 1491 if (op->value) 1492 fprintf(output, "EQUAL ="); 1493 else 1494 fprintf(output, "EQUAL !="); 1495 break; 1496 case XPATH_OP_CMP: 1497 if (op->value) 1498 fprintf(output, "CMP <"); 1499 else 1500 fprintf(output, "CMP >"); 1501 if (!op->value2) 1502 fprintf(output, "="); 1503 break; 1504 case XPATH_OP_PLUS: 1505 if (op->value == 0) 1506 fprintf(output, "PLUS -"); 1507 else if (op->value == 1) 1508 fprintf(output, "PLUS +"); 1509 else if (op->value == 2) 1510 fprintf(output, "PLUS unary -"); 1511 else if (op->value == 3) 1512 fprintf(output, "PLUS unary - -"); 1513 break; 1514 case XPATH_OP_MULT: 1515 if (op->value == 0) 1516 fprintf(output, "MULT *"); 1517 else if (op->value == 1) 1518 fprintf(output, "MULT div"); 1519 else 1520 fprintf(output, "MULT mod"); 1521 break; 1522 case XPATH_OP_UNION: 1523 fprintf(output, "UNION"); break; 1524 case XPATH_OP_ROOT: 1525 fprintf(output, "ROOT"); break; 1526 case XPATH_OP_NODE: 1527 fprintf(output, "NODE"); break; 1528 case XPATH_OP_RESET: 1529 fprintf(output, "RESET"); break; 1530 case XPATH_OP_SORT: 1531 fprintf(output, "SORT"); break; 1532 case XPATH_OP_COLLECT: { 1533 xmlXPathAxisVal axis = (xmlXPathAxisVal)op->value; 1534 xmlXPathTestVal test = (xmlXPathTestVal)op->value2; 1535 xmlXPathTypeVal type = (xmlXPathTypeVal)op->value3; 1536 const xmlChar *prefix = op->value4; 1537 const xmlChar *name = op->value5; 1538 1539 fprintf(output, "COLLECT "); 1540 switch (axis) { 1541 case AXIS_ANCESTOR: 1542 fprintf(output, " 'ancestors' "); break; 1543 case AXIS_ANCESTOR_OR_SELF: 1544 fprintf(output, " 'ancestors-or-self' "); break; 1545 case AXIS_ATTRIBUTE: 1546 fprintf(output, " 'attributes' "); break; 1547 case AXIS_CHILD: 1548 fprintf(output, " 'child' "); break; 1549 case AXIS_DESCENDANT: 1550 fprintf(output, " 'descendant' "); break; 1551 case AXIS_DESCENDANT_OR_SELF: 1552 fprintf(output, " 'descendant-or-self' "); break; 1553 case AXIS_FOLLOWING: 1554 fprintf(output, " 'following' "); break; 1555 case AXIS_FOLLOWING_SIBLING: 1556 fprintf(output, " 'following-siblings' "); break; 1557 case AXIS_NAMESPACE: 1558 fprintf(output, " 'namespace' "); break; 1559 case AXIS_PARENT: 1560 fprintf(output, " 'parent' "); break; 1561 case AXIS_PRECEDING: 1562 fprintf(output, " 'preceding' "); break; 1563 case AXIS_PRECEDING_SIBLING: 1564 fprintf(output, " 'preceding-sibling' "); break; 1565 case AXIS_SELF: 1566 fprintf(output, " 'self' "); break; 1567 } 1568 switch (test) { 1569 case NODE_TEST_NONE: 1570 fprintf(output, "'none' "); break; 1571 case NODE_TEST_TYPE: 1572 fprintf(output, "'type' "); break; 1573 case NODE_TEST_PI: 1574 fprintf(output, "'PI' "); break; 1575 case NODE_TEST_ALL: 1576 fprintf(output, "'all' "); break; 1577 case NODE_TEST_NS: 1578 fprintf(output, "'namespace' "); break; 1579 case NODE_TEST_NAME: 1580 fprintf(output, "'name' "); break; 1581 } 1582 switch (type) { 1583 case NODE_TYPE_NODE: 1584 fprintf(output, "'node' "); break; 1585 case NODE_TYPE_COMMENT: 1586 fprintf(output, "'comment' "); break; 1587 case NODE_TYPE_TEXT: 1588 fprintf(output, "'text' "); break; 1589 case NODE_TYPE_PI: 1590 fprintf(output, "'PI' "); break; 1591 } 1592 if (prefix != NULL) 1593 fprintf(output, "%s:", prefix); 1594 if (name != NULL) 1595 fprintf(output, "%s", (const char *) name); 1596 break; 1597 1598 } 1599 case XPATH_OP_VALUE: { 1600 xmlXPathObjectPtr object = (xmlXPathObjectPtr) op->value4; 1601 1602 fprintf(output, "ELEM "); 1603 xmlXPathDebugDumpObject(output, object, 0); 1604 goto finish; 1605 } 1606 case XPATH_OP_VARIABLE: { 1607 const xmlChar *prefix = op->value5; 1608 const xmlChar *name = op->value4; 1609 1610 if (prefix != NULL) 1611 fprintf(output, "VARIABLE %s:%s", prefix, name); 1612 else 1613 fprintf(output, "VARIABLE %s", name); 1614 break; 1615 } 1616 case XPATH_OP_FUNCTION: { 1617 int nbargs = op->value; 1618 const xmlChar *prefix = op->value5; 1619 const xmlChar *name = op->value4; 1620 1621 if (prefix != NULL) 1622 fprintf(output, "FUNCTION %s:%s(%d args)", 1623 prefix, name, nbargs); 1624 else 1625 fprintf(output, "FUNCTION %s(%d args)", name, nbargs); 1626 break; 1627 } 1628 case XPATH_OP_ARG: fprintf(output, "ARG"); break; 1629 case XPATH_OP_PREDICATE: fprintf(output, "PREDICATE"); break; 1630 case XPATH_OP_FILTER: fprintf(output, "FILTER"); break; 1631 #ifdef LIBXML_XPTR_ENABLED 1632 case XPATH_OP_RANGETO: fprintf(output, "RANGETO"); break; 1633 #endif 1634 default: 1635 fprintf(output, "UNKNOWN %d\n", op->op); return; 1636 } 1637 fprintf(output, "\n"); 1638 finish: 1639 if (op->ch1 >= 0) 1640 xmlXPathDebugDumpStepOp(output, comp, &comp->steps[op->ch1], depth + 1); 1641 if (op->ch2 >= 0) 1642 xmlXPathDebugDumpStepOp(output, comp, &comp->steps[op->ch2], depth + 1); 1643 } 1644 1645 /** 1646 * xmlXPathDebugDumpCompExpr: 1647 * @output: the FILE * for the output 1648 * @comp: the precompiled XPath expression 1649 * @depth: the indentation level. 1650 * 1651 * Dumps the tree of the compiled XPath expression. 1652 */ 1653 void 1654 xmlXPathDebugDumpCompExpr(FILE *output, xmlXPathCompExprPtr comp, 1655 int depth) { 1656 int i; 1657 char shift[100]; 1658 1659 if ((output == NULL) || (comp == NULL)) return; 1660 1661 for (i = 0;((i < depth) && (i < 25));i++) 1662 shift[2 * i] = shift[2 * i + 1] = ' '; 1663 shift[2 * i] = shift[2 * i + 1] = 0; 1664 1665 fprintf(output, "%s", shift); 1666 1667 #ifdef XPATH_STREAMING 1668 if (comp->stream) { 1669 fprintf(output, "Streaming Expression\n"); 1670 } else 1671 #endif 1672 { 1673 fprintf(output, "Compiled Expression : %d elements\n", 1674 comp->nbStep); 1675 i = comp->last; 1676 xmlXPathDebugDumpStepOp(output, comp, &comp->steps[i], depth + 1); 1677 } 1678 } 1679 1680 #ifdef XP_DEBUG_OBJ_USAGE 1681 1682 /* 1683 * XPath object usage related debugging variables. 1684 */ 1685 static int xmlXPathDebugObjCounterUndefined = 0; 1686 static int xmlXPathDebugObjCounterNodeset = 0; 1687 static int xmlXPathDebugObjCounterBool = 0; 1688 static int xmlXPathDebugObjCounterNumber = 0; 1689 static int xmlXPathDebugObjCounterString = 0; 1690 static int xmlXPathDebugObjCounterPoint = 0; 1691 static int xmlXPathDebugObjCounterRange = 0; 1692 static int xmlXPathDebugObjCounterLocset = 0; 1693 static int xmlXPathDebugObjCounterUsers = 0; 1694 static int xmlXPathDebugObjCounterXSLTTree = 0; 1695 static int xmlXPathDebugObjCounterAll = 0; 1696 1697 static int xmlXPathDebugObjTotalUndefined = 0; 1698 static int xmlXPathDebugObjTotalNodeset = 0; 1699 static int xmlXPathDebugObjTotalBool = 0; 1700 static int xmlXPathDebugObjTotalNumber = 0; 1701 static int xmlXPathDebugObjTotalString = 0; 1702 static int xmlXPathDebugObjTotalPoint = 0; 1703 static int xmlXPathDebugObjTotalRange = 0; 1704 static int xmlXPathDebugObjTotalLocset = 0; 1705 static int xmlXPathDebugObjTotalUsers = 0; 1706 static int xmlXPathDebugObjTotalXSLTTree = 0; 1707 static int xmlXPathDebugObjTotalAll = 0; 1708 1709 static int xmlXPathDebugObjMaxUndefined = 0; 1710 static int xmlXPathDebugObjMaxNodeset = 0; 1711 static int xmlXPathDebugObjMaxBool = 0; 1712 static int xmlXPathDebugObjMaxNumber = 0; 1713 static int xmlXPathDebugObjMaxString = 0; 1714 static int xmlXPathDebugObjMaxPoint = 0; 1715 static int xmlXPathDebugObjMaxRange = 0; 1716 static int xmlXPathDebugObjMaxLocset = 0; 1717 static int xmlXPathDebugObjMaxUsers = 0; 1718 static int xmlXPathDebugObjMaxXSLTTree = 0; 1719 static int xmlXPathDebugObjMaxAll = 0; 1720 1721 /* REVISIT TODO: Make this static when committing */ 1722 static void 1723 xmlXPathDebugObjUsageReset(xmlXPathContextPtr ctxt) 1724 { 1725 if (ctxt != NULL) { 1726 if (ctxt->cache != NULL) { 1727 xmlXPathContextCachePtr cache = 1728 (xmlXPathContextCachePtr) ctxt->cache; 1729 1730 cache->dbgCachedAll = 0; 1731 cache->dbgCachedNodeset = 0; 1732 cache->dbgCachedString = 0; 1733 cache->dbgCachedBool = 0; 1734 cache->dbgCachedNumber = 0; 1735 cache->dbgCachedPoint = 0; 1736 cache->dbgCachedRange = 0; 1737 cache->dbgCachedLocset = 0; 1738 cache->dbgCachedUsers = 0; 1739 cache->dbgCachedXSLTTree = 0; 1740 cache->dbgCachedUndefined = 0; 1741 1742 cache->dbgReusedAll = 0; 1743 cache->dbgReusedNodeset = 0; 1744 cache->dbgReusedString = 0; 1745 cache->dbgReusedBool = 0; 1746 cache->dbgReusedNumber = 0; 1747 cache->dbgReusedPoint = 0; 1748 cache->dbgReusedRange = 0; 1749 cache->dbgReusedLocset = 0; 1750 cache->dbgReusedUsers = 0; 1751 cache->dbgReusedXSLTTree = 0; 1752 cache->dbgReusedUndefined = 0; 1753 } 1754 } 1755 1756 xmlXPathDebugObjCounterUndefined = 0; 1757 xmlXPathDebugObjCounterNodeset = 0; 1758 xmlXPathDebugObjCounterBool = 0; 1759 xmlXPathDebugObjCounterNumber = 0; 1760 xmlXPathDebugObjCounterString = 0; 1761 xmlXPathDebugObjCounterPoint = 0; 1762 xmlXPathDebugObjCounterRange = 0; 1763 xmlXPathDebugObjCounterLocset = 0; 1764 xmlXPathDebugObjCounterUsers = 0; 1765 xmlXPathDebugObjCounterXSLTTree = 0; 1766 xmlXPathDebugObjCounterAll = 0; 1767 1768 xmlXPathDebugObjTotalUndefined = 0; 1769 xmlXPathDebugObjTotalNodeset = 0; 1770 xmlXPathDebugObjTotalBool = 0; 1771 xmlXPathDebugObjTotalNumber = 0; 1772 xmlXPathDebugObjTotalString = 0; 1773 xmlXPathDebugObjTotalPoint = 0; 1774 xmlXPathDebugObjTotalRange = 0; 1775 xmlXPathDebugObjTotalLocset = 0; 1776 xmlXPathDebugObjTotalUsers = 0; 1777 xmlXPathDebugObjTotalXSLTTree = 0; 1778 xmlXPathDebugObjTotalAll = 0; 1779 1780 xmlXPathDebugObjMaxUndefined = 0; 1781 xmlXPathDebugObjMaxNodeset = 0; 1782 xmlXPathDebugObjMaxBool = 0; 1783 xmlXPathDebugObjMaxNumber = 0; 1784 xmlXPathDebugObjMaxString = 0; 1785 xmlXPathDebugObjMaxPoint = 0; 1786 xmlXPathDebugObjMaxRange = 0; 1787 xmlXPathDebugObjMaxLocset = 0; 1788 xmlXPathDebugObjMaxUsers = 0; 1789 xmlXPathDebugObjMaxXSLTTree = 0; 1790 xmlXPathDebugObjMaxAll = 0; 1791 1792 } 1793 1794 static void 1795 xmlXPathDebugObjUsageRequested(xmlXPathContextPtr ctxt, 1796 xmlXPathObjectType objType) 1797 { 1798 int isCached = 0; 1799 1800 if (ctxt != NULL) { 1801 if (ctxt->cache != NULL) { 1802 xmlXPathContextCachePtr cache = 1803 (xmlXPathContextCachePtr) ctxt->cache; 1804 1805 isCached = 1; 1806 1807 cache->dbgReusedAll++; 1808 switch (objType) { 1809 case XPATH_UNDEFINED: 1810 cache->dbgReusedUndefined++; 1811 break; 1812 case XPATH_NODESET: 1813 cache->dbgReusedNodeset++; 1814 break; 1815 case XPATH_BOOLEAN: 1816 cache->dbgReusedBool++; 1817 break; 1818 case XPATH_NUMBER: 1819 cache->dbgReusedNumber++; 1820 break; 1821 case XPATH_STRING: 1822 cache->dbgReusedString++; 1823 break; 1824 case XPATH_POINT: 1825 cache->dbgReusedPoint++; 1826 break; 1827 case XPATH_RANGE: 1828 cache->dbgReusedRange++; 1829 break; 1830 case XPATH_LOCATIONSET: 1831 cache->dbgReusedLocset++; 1832 break; 1833 case XPATH_USERS: 1834 cache->dbgReusedUsers++; 1835 break; 1836 case XPATH_XSLT_TREE: 1837 cache->dbgReusedXSLTTree++; 1838 break; 1839 default: 1840 break; 1841 } 1842 } 1843 } 1844 1845 switch (objType) { 1846 case XPATH_UNDEFINED: 1847 if (! isCached) 1848 xmlXPathDebugObjTotalUndefined++; 1849 xmlXPathDebugObjCounterUndefined++; 1850 if (xmlXPathDebugObjCounterUndefined > 1851 xmlXPathDebugObjMaxUndefined) 1852 xmlXPathDebugObjMaxUndefined = 1853 xmlXPathDebugObjCounterUndefined; 1854 break; 1855 case XPATH_NODESET: 1856 if (! isCached) 1857 xmlXPathDebugObjTotalNodeset++; 1858 xmlXPathDebugObjCounterNodeset++; 1859 if (xmlXPathDebugObjCounterNodeset > 1860 xmlXPathDebugObjMaxNodeset) 1861 xmlXPathDebugObjMaxNodeset = 1862 xmlXPathDebugObjCounterNodeset; 1863 break; 1864 case XPATH_BOOLEAN: 1865 if (! isCached) 1866 xmlXPathDebugObjTotalBool++; 1867 xmlXPathDebugObjCounterBool++; 1868 if (xmlXPathDebugObjCounterBool > 1869 xmlXPathDebugObjMaxBool) 1870 xmlXPathDebugObjMaxBool = 1871 xmlXPathDebugObjCounterBool; 1872 break; 1873 case XPATH_NUMBER: 1874 if (! isCached) 1875 xmlXPathDebugObjTotalNumber++; 1876 xmlXPathDebugObjCounterNumber++; 1877 if (xmlXPathDebugObjCounterNumber > 1878 xmlXPathDebugObjMaxNumber) 1879 xmlXPathDebugObjMaxNumber = 1880 xmlXPathDebugObjCounterNumber; 1881 break; 1882 case XPATH_STRING: 1883 if (! isCached) 1884 xmlXPathDebugObjTotalString++; 1885 xmlXPathDebugObjCounterString++; 1886 if (xmlXPathDebugObjCounterString > 1887 xmlXPathDebugObjMaxString) 1888 xmlXPathDebugObjMaxString = 1889 xmlXPathDebugObjCounterString; 1890 break; 1891 case XPATH_POINT: 1892 if (! isCached) 1893 xmlXPathDebugObjTotalPoint++; 1894 xmlXPathDebugObjCounterPoint++; 1895 if (xmlXPathDebugObjCounterPoint > 1896 xmlXPathDebugObjMaxPoint) 1897 xmlXPathDebugObjMaxPoint = 1898 xmlXPathDebugObjCounterPoint; 1899 break; 1900 case XPATH_RANGE: 1901 if (! isCached) 1902 xmlXPathDebugObjTotalRange++; 1903 xmlXPathDebugObjCounterRange++; 1904 if (xmlXPathDebugObjCounterRange > 1905 xmlXPathDebugObjMaxRange) 1906 xmlXPathDebugObjMaxRange = 1907 xmlXPathDebugObjCounterRange; 1908 break; 1909 case XPATH_LOCATIONSET: 1910 if (! isCached) 1911 xmlXPathDebugObjTotalLocset++; 1912 xmlXPathDebugObjCounterLocset++; 1913 if (xmlXPathDebugObjCounterLocset > 1914 xmlXPathDebugObjMaxLocset) 1915 xmlXPathDebugObjMaxLocset = 1916 xmlXPathDebugObjCounterLocset; 1917 break; 1918 case XPATH_USERS: 1919 if (! isCached) 1920 xmlXPathDebugObjTotalUsers++; 1921 xmlXPathDebugObjCounterUsers++; 1922 if (xmlXPathDebugObjCounterUsers > 1923 xmlXPathDebugObjMaxUsers) 1924 xmlXPathDebugObjMaxUsers = 1925 xmlXPathDebugObjCounterUsers; 1926 break; 1927 case XPATH_XSLT_TREE: 1928 if (! isCached) 1929 xmlXPathDebugObjTotalXSLTTree++; 1930 xmlXPathDebugObjCounterXSLTTree++; 1931 if (xmlXPathDebugObjCounterXSLTTree > 1932 xmlXPathDebugObjMaxXSLTTree) 1933 xmlXPathDebugObjMaxXSLTTree = 1934 xmlXPathDebugObjCounterXSLTTree; 1935 break; 1936 default: 1937 break; 1938 } 1939 if (! isCached) 1940 xmlXPathDebugObjTotalAll++; 1941 xmlXPathDebugObjCounterAll++; 1942 if (xmlXPathDebugObjCounterAll > 1943 xmlXPathDebugObjMaxAll) 1944 xmlXPathDebugObjMaxAll = 1945 xmlXPathDebugObjCounterAll; 1946 } 1947 1948 static void 1949 xmlXPathDebugObjUsageReleased(xmlXPathContextPtr ctxt, 1950 xmlXPathObjectType objType) 1951 { 1952 int isCached = 0; 1953 1954 if (ctxt != NULL) { 1955 if (ctxt->cache != NULL) { 1956 xmlXPathContextCachePtr cache = 1957 (xmlXPathContextCachePtr) ctxt->cache; 1958 1959 isCached = 1; 1960 1961 cache->dbgCachedAll++; 1962 switch (objType) { 1963 case XPATH_UNDEFINED: 1964 cache->dbgCachedUndefined++; 1965 break; 1966 case XPATH_NODESET: 1967 cache->dbgCachedNodeset++; 1968 break; 1969 case XPATH_BOOLEAN: 1970 cache->dbgCachedBool++; 1971 break; 1972 case XPATH_NUMBER: 1973 cache->dbgCachedNumber++; 1974 break; 1975 case XPATH_STRING: 1976 cache->dbgCachedString++; 1977 break; 1978 case XPATH_POINT: 1979 cache->dbgCachedPoint++; 1980 break; 1981 case XPATH_RANGE: 1982 cache->dbgCachedRange++; 1983 break; 1984 case XPATH_LOCATIONSET: 1985 cache->dbgCachedLocset++; 1986 break; 1987 case XPATH_USERS: 1988 cache->dbgCachedUsers++; 1989 break; 1990 case XPATH_XSLT_TREE: 1991 cache->dbgCachedXSLTTree++; 1992 break; 1993 default: 1994 break; 1995 } 1996 1997 } 1998 } 1999 switch (objType) { 2000 case XPATH_UNDEFINED: 2001 xmlXPathDebugObjCounterUndefined--; 2002 break; 2003 case XPATH_NODESET: 2004 xmlXPathDebugObjCounterNodeset--; 2005 break; 2006 case XPATH_BOOLEAN: 2007 xmlXPathDebugObjCounterBool--; 2008 break; 2009 case XPATH_NUMBER: 2010 xmlXPathDebugObjCounterNumber--; 2011 break; 2012 case XPATH_STRING: 2013 xmlXPathDebugObjCounterString--; 2014 break; 2015 case XPATH_POINT: 2016 xmlXPathDebugObjCounterPoint--; 2017 break; 2018 case XPATH_RANGE: 2019 xmlXPathDebugObjCounterRange--; 2020 break; 2021 case XPATH_LOCATIONSET: 2022 xmlXPathDebugObjCounterLocset--; 2023 break; 2024 case XPATH_USERS: 2025 xmlXPathDebugObjCounterUsers--; 2026 break; 2027 case XPATH_XSLT_TREE: 2028 xmlXPathDebugObjCounterXSLTTree--; 2029 break; 2030 default: 2031 break; 2032 } 2033 xmlXPathDebugObjCounterAll--; 2034 } 2035 2036 /* REVISIT TODO: Make this static when committing */ 2037 static void 2038 xmlXPathDebugObjUsageDisplay(xmlXPathContextPtr ctxt) 2039 { 2040 int reqAll, reqNodeset, reqString, reqBool, reqNumber, 2041 reqXSLTTree, reqUndefined; 2042 int caAll = 0, caNodeset = 0, caString = 0, caBool = 0, 2043 caNumber = 0, caXSLTTree = 0, caUndefined = 0; 2044 int reAll = 0, reNodeset = 0, reString = 0, reBool = 0, 2045 reNumber = 0, reXSLTTree = 0, reUndefined = 0; 2046 int leftObjs = xmlXPathDebugObjCounterAll; 2047 2048 reqAll = xmlXPathDebugObjTotalAll; 2049 reqNodeset = xmlXPathDebugObjTotalNodeset; 2050 reqString = xmlXPathDebugObjTotalString; 2051 reqBool = xmlXPathDebugObjTotalBool; 2052 reqNumber = xmlXPathDebugObjTotalNumber; 2053 reqXSLTTree = xmlXPathDebugObjTotalXSLTTree; 2054 reqUndefined = xmlXPathDebugObjTotalUndefined; 2055 2056 printf("# XPath object usage:\n"); 2057 2058 if (ctxt != NULL) { 2059 if (ctxt->cache != NULL) { 2060 xmlXPathContextCachePtr cache = 2061 (xmlXPathContextCachePtr) ctxt->cache; 2062 2063 reAll = cache->dbgReusedAll; 2064 reqAll += reAll; 2065 reNodeset = cache->dbgReusedNodeset; 2066 reqNodeset += reNodeset; 2067 reString = cache->dbgReusedString; 2068 reqString += reString; 2069 reBool = cache->dbgReusedBool; 2070 reqBool += reBool; 2071 reNumber = cache->dbgReusedNumber; 2072 reqNumber += reNumber; 2073 reXSLTTree = cache->dbgReusedXSLTTree; 2074 reqXSLTTree += reXSLTTree; 2075 reUndefined = cache->dbgReusedUndefined; 2076 reqUndefined += reUndefined; 2077 2078 caAll = cache->dbgCachedAll; 2079 caBool = cache->dbgCachedBool; 2080 caNodeset = cache->dbgCachedNodeset; 2081 caString = cache->dbgCachedString; 2082 caNumber = cache->dbgCachedNumber; 2083 caXSLTTree = cache->dbgCachedXSLTTree; 2084 caUndefined = cache->dbgCachedUndefined; 2085 2086 if (cache->nodesetObjs) 2087 leftObjs -= cache->nodesetObjs->number; 2088 if (cache->stringObjs) 2089 leftObjs -= cache->stringObjs->number; 2090 if (cache->booleanObjs) 2091 leftObjs -= cache->booleanObjs->number; 2092 if (cache->numberObjs) 2093 leftObjs -= cache->numberObjs->number; 2094 if (cache->miscObjs) 2095 leftObjs -= cache->miscObjs->number; 2096 } 2097 } 2098 2099 printf("# all\n"); 2100 printf("# total : %d\n", reqAll); 2101 printf("# left : %d\n", leftObjs); 2102 printf("# created: %d\n", xmlXPathDebugObjTotalAll); 2103 printf("# reused : %d\n", reAll); 2104 printf("# max : %d\n", xmlXPathDebugObjMaxAll); 2105 2106 printf("# node-sets\n"); 2107 printf("# total : %d\n", reqNodeset); 2108 printf("# created: %d\n", xmlXPathDebugObjTotalNodeset); 2109 printf("# reused : %d\n", reNodeset); 2110 printf("# max : %d\n", xmlXPathDebugObjMaxNodeset); 2111 2112 printf("# strings\n"); 2113 printf("# total : %d\n", reqString); 2114 printf("# created: %d\n", xmlXPathDebugObjTotalString); 2115 printf("# reused : %d\n", reString); 2116 printf("# max : %d\n", xmlXPathDebugObjMaxString); 2117 2118 printf("# booleans\n"); 2119 printf("# total : %d\n", reqBool); 2120 printf("# created: %d\n", xmlXPathDebugObjTotalBool); 2121 printf("# reused : %d\n", reBool); 2122 printf("# max : %d\n", xmlXPathDebugObjMaxBool); 2123 2124 printf("# numbers\n"); 2125 printf("# total : %d\n", reqNumber); 2126 printf("# created: %d\n", xmlXPathDebugObjTotalNumber); 2127 printf("# reused : %d\n", reNumber); 2128 printf("# max : %d\n", xmlXPathDebugObjMaxNumber); 2129 2130 printf("# XSLT result tree fragments\n"); 2131 printf("# total : %d\n", reqXSLTTree); 2132 printf("# created: %d\n", xmlXPathDebugObjTotalXSLTTree); 2133 printf("# reused : %d\n", reXSLTTree); 2134 printf("# max : %d\n", xmlXPathDebugObjMaxXSLTTree); 2135 2136 printf("# undefined\n"); 2137 printf("# total : %d\n", reqUndefined); 2138 printf("# created: %d\n", xmlXPathDebugObjTotalUndefined); 2139 printf("# reused : %d\n", reUndefined); 2140 printf("# max : %d\n", xmlXPathDebugObjMaxUndefined); 2141 2142 } 2143 2144 #endif /* XP_DEBUG_OBJ_USAGE */ 2145 2146 #endif /* LIBXML_DEBUG_ENABLED */ 2147 2148 /************************************************************************ 2149 * * 2150 * XPath object caching * 2151 * * 2152 ************************************************************************/ 2153 2154 /** 2155 * xmlXPathNewCache: 2156 * 2157 * Create a new object cache 2158 * 2159 * Returns the xmlXPathCache just allocated. 2160 */ 2161 static xmlXPathContextCachePtr 2162 xmlXPathNewCache(void) 2163 { 2164 xmlXPathContextCachePtr ret; 2165 2166 ret = (xmlXPathContextCachePtr) xmlMalloc(sizeof(xmlXPathContextCache)); 2167 if (ret == NULL) { 2168 xmlXPathErrMemory(NULL, "creating object cache\n"); 2169 return(NULL); 2170 } 2171 memset(ret, 0 , (size_t) sizeof(xmlXPathContextCache)); 2172 ret->maxNodeset = 100; 2173 ret->maxString = 100; 2174 ret->maxBoolean = 100; 2175 ret->maxNumber = 100; 2176 ret->maxMisc = 100; 2177 return(ret); 2178 } 2179 2180 static void 2181 xmlXPathCacheFreeObjectList(xmlPointerListPtr list) 2182 { 2183 int i; 2184 xmlXPathObjectPtr obj; 2185 2186 if (list == NULL) 2187 return; 2188 2189 for (i = 0; i < list->number; i++) { 2190 obj = list->items[i]; 2191 /* 2192 * Note that it is already assured that we don't need to 2193 * look out for namespace nodes in the node-set. 2194 */ 2195 if (obj->nodesetval != NULL) { 2196 if (obj->nodesetval->nodeTab != NULL) 2197 xmlFree(obj->nodesetval->nodeTab); 2198 xmlFree(obj->nodesetval); 2199 } 2200 xmlFree(obj); 2201 #ifdef XP_DEBUG_OBJ_USAGE 2202 xmlXPathDebugObjCounterAll--; 2203 #endif 2204 } 2205 xmlPointerListFree(list); 2206 } 2207 2208 static void 2209 xmlXPathFreeCache(xmlXPathContextCachePtr cache) 2210 { 2211 if (cache == NULL) 2212 return; 2213 if (cache->nodesetObjs) 2214 xmlXPathCacheFreeObjectList(cache->nodesetObjs); 2215 if (cache->stringObjs) 2216 xmlXPathCacheFreeObjectList(cache->stringObjs); 2217 if (cache->booleanObjs) 2218 xmlXPathCacheFreeObjectList(cache->booleanObjs); 2219 if (cache->numberObjs) 2220 xmlXPathCacheFreeObjectList(cache->numberObjs); 2221 if (cache->miscObjs) 2222 xmlXPathCacheFreeObjectList(cache->miscObjs); 2223 xmlFree(cache); 2224 } 2225 2226 /** 2227 * xmlXPathContextSetCache: 2228 * 2229 * @ctxt: the XPath context 2230 * @active: enables/disables (creates/frees) the cache 2231 * @value: a value with semantics dependant on @options 2232 * @options: options (currently only the value 0 is used) 2233 * 2234 * Creates/frees an object cache on the XPath context. 2235 * If activates XPath objects (xmlXPathObject) will be cached internally 2236 * to be reused. 2237 * @options: 2238 * 0: This will set the XPath object caching: 2239 * @value: 2240 * This will set the maximum number of XPath objects 2241 * to be cached per slot 2242 * There are 5 slots for: node-set, string, number, boolean, and 2243 * misc objects. Use <0 for the default number (100). 2244 * Other values for @options have currently no effect. 2245 * 2246 * Returns 0 if the setting succeeded, and -1 on API or internal errors. 2247 */ 2248 int 2249 xmlXPathContextSetCache(xmlXPathContextPtr ctxt, 2250 int active, 2251 int value, 2252 int options) 2253 { 2254 if (ctxt == NULL) 2255 return(-1); 2256 if (active) { 2257 xmlXPathContextCachePtr cache; 2258 2259 if (ctxt->cache == NULL) { 2260 ctxt->cache = xmlXPathNewCache(); 2261 if (ctxt->cache == NULL) 2262 return(-1); 2263 } 2264 cache = (xmlXPathContextCachePtr) ctxt->cache; 2265 if (options == 0) { 2266 if (value < 0) 2267 value = 100; 2268 cache->maxNodeset = value; 2269 cache->maxString = value; 2270 cache->maxNumber = value; 2271 cache->maxBoolean = value; 2272 cache->maxMisc = value; 2273 } 2274 } else if (ctxt->cache != NULL) { 2275 xmlXPathFreeCache((xmlXPathContextCachePtr) ctxt->cache); 2276 ctxt->cache = NULL; 2277 } 2278 return(0); 2279 } 2280 2281 /** 2282 * xmlXPathCacheWrapNodeSet: 2283 * @ctxt: the XPath context 2284 * @val: the NodePtr value 2285 * 2286 * This is the cached version of xmlXPathWrapNodeSet(). 2287 * Wrap the Nodeset @val in a new xmlXPathObjectPtr 2288 * 2289 * Returns the created or reused object. 2290 */ 2291 static xmlXPathObjectPtr 2292 xmlXPathCacheWrapNodeSet(xmlXPathContextPtr ctxt, xmlNodeSetPtr val) 2293 { 2294 if ((ctxt != NULL) && (ctxt->cache != NULL)) { 2295 xmlXPathContextCachePtr cache = 2296 (xmlXPathContextCachePtr) ctxt->cache; 2297 2298 if ((cache->miscObjs != NULL) && 2299 (cache->miscObjs->number != 0)) 2300 { 2301 xmlXPathObjectPtr ret; 2302 2303 ret = (xmlXPathObjectPtr) 2304 cache->miscObjs->items[--cache->miscObjs->number]; 2305 ret->type = XPATH_NODESET; 2306 ret->nodesetval = val; 2307 #ifdef XP_DEBUG_OBJ_USAGE 2308 xmlXPathDebugObjUsageRequested(ctxt, XPATH_NODESET); 2309 #endif 2310 return(ret); 2311 } 2312 } 2313 2314 return(xmlXPathWrapNodeSet(val)); 2315 2316 } 2317 2318 /** 2319 * xmlXPathCacheWrapString: 2320 * @ctxt: the XPath context 2321 * @val: the xmlChar * value 2322 * 2323 * This is the cached version of xmlXPathWrapString(). 2324 * Wraps the @val string into an XPath object. 2325 * 2326 * Returns the created or reused object. 2327 */ 2328 static xmlXPathObjectPtr 2329 xmlXPathCacheWrapString(xmlXPathContextPtr ctxt, xmlChar *val) 2330 { 2331 if ((ctxt != NULL) && (ctxt->cache != NULL)) { 2332 xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache; 2333 2334 if ((cache->stringObjs != NULL) && 2335 (cache->stringObjs->number != 0)) 2336 { 2337 2338 xmlXPathObjectPtr ret; 2339 2340 ret = (xmlXPathObjectPtr) 2341 cache->stringObjs->items[--cache->stringObjs->number]; 2342 ret->type = XPATH_STRING; 2343 ret->stringval = val; 2344 #ifdef XP_DEBUG_OBJ_USAGE 2345 xmlXPathDebugObjUsageRequested(ctxt, XPATH_STRING); 2346 #endif 2347 return(ret); 2348 } else if ((cache->miscObjs != NULL) && 2349 (cache->miscObjs->number != 0)) 2350 { 2351 xmlXPathObjectPtr ret; 2352 /* 2353 * Fallback to misc-cache. 2354 */ 2355 ret = (xmlXPathObjectPtr) 2356 cache->miscObjs->items[--cache->miscObjs->number]; 2357 2358 ret->type = XPATH_STRING; 2359 ret->stringval = val; 2360 #ifdef XP_DEBUG_OBJ_USAGE 2361 xmlXPathDebugObjUsageRequested(ctxt, XPATH_STRING); 2362 #endif 2363 return(ret); 2364 } 2365 } 2366 return(xmlXPathWrapString(val)); 2367 } 2368 2369 /** 2370 * xmlXPathCacheNewNodeSet: 2371 * @ctxt: the XPath context 2372 * @val: the NodePtr value 2373 * 2374 * This is the cached version of xmlXPathNewNodeSet(). 2375 * Acquire an xmlXPathObjectPtr of type NodeSet and initialize 2376 * it with the single Node @val 2377 * 2378 * Returns the created or reused object. 2379 */ 2380 static xmlXPathObjectPtr 2381 xmlXPathCacheNewNodeSet(xmlXPathContextPtr ctxt, xmlNodePtr val) 2382 { 2383 if ((ctxt != NULL) && (ctxt->cache)) { 2384 xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache; 2385 2386 if ((cache->nodesetObjs != NULL) && 2387 (cache->nodesetObjs->number != 0)) 2388 { 2389 xmlXPathObjectPtr ret; 2390 /* 2391 * Use the nodset-cache. 2392 */ 2393 ret = (xmlXPathObjectPtr) 2394 cache->nodesetObjs->items[--cache->nodesetObjs->number]; 2395 ret->type = XPATH_NODESET; 2396 ret->boolval = 0; 2397 if (val) { 2398 if ((ret->nodesetval->nodeMax == 0) || 2399 (val->type == XML_NAMESPACE_DECL)) 2400 { 2401 xmlXPathNodeSetAddUnique(ret->nodesetval, val); 2402 } else { 2403 ret->nodesetval->nodeTab[0] = val; 2404 ret->nodesetval->nodeNr = 1; 2405 } 2406 } 2407 #ifdef XP_DEBUG_OBJ_USAGE 2408 xmlXPathDebugObjUsageRequested(ctxt, XPATH_NODESET); 2409 #endif 2410 return(ret); 2411 } else if ((cache->miscObjs != NULL) && 2412 (cache->miscObjs->number != 0)) 2413 { 2414 xmlXPathObjectPtr ret; 2415 /* 2416 * Fallback to misc-cache. 2417 */ 2418 2419 ret = (xmlXPathObjectPtr) 2420 cache->miscObjs->items[--cache->miscObjs->number]; 2421 2422 ret->type = XPATH_NODESET; 2423 ret->boolval = 0; 2424 ret->nodesetval = xmlXPathNodeSetCreate(val); 2425 if (ret->nodesetval == NULL) { 2426 ctxt->lastError.domain = XML_FROM_XPATH; 2427 ctxt->lastError.code = XML_ERR_NO_MEMORY; 2428 return(NULL); 2429 } 2430 #ifdef XP_DEBUG_OBJ_USAGE 2431 xmlXPathDebugObjUsageRequested(ctxt, XPATH_NODESET); 2432 #endif 2433 return(ret); 2434 } 2435 } 2436 return(xmlXPathNewNodeSet(val)); 2437 } 2438 2439 /** 2440 * xmlXPathCacheNewCString: 2441 * @ctxt: the XPath context 2442 * @val: the char * value 2443 * 2444 * This is the cached version of xmlXPathNewCString(). 2445 * Acquire an xmlXPathObjectPtr of type string and of value @val 2446 * 2447 * Returns the created or reused object. 2448 */ 2449 static xmlXPathObjectPtr 2450 xmlXPathCacheNewCString(xmlXPathContextPtr ctxt, const char *val) 2451 { 2452 if ((ctxt != NULL) && (ctxt->cache)) { 2453 xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache; 2454 2455 if ((cache->stringObjs != NULL) && 2456 (cache->stringObjs->number != 0)) 2457 { 2458 xmlXPathObjectPtr ret; 2459 2460 ret = (xmlXPathObjectPtr) 2461 cache->stringObjs->items[--cache->stringObjs->number]; 2462 2463 ret->type = XPATH_STRING; 2464 ret->stringval = xmlStrdup(BAD_CAST val); 2465 #ifdef XP_DEBUG_OBJ_USAGE 2466 xmlXPathDebugObjUsageRequested(ctxt, XPATH_STRING); 2467 #endif 2468 return(ret); 2469 } else if ((cache->miscObjs != NULL) && 2470 (cache->miscObjs->number != 0)) 2471 { 2472 xmlXPathObjectPtr ret; 2473 2474 ret = (xmlXPathObjectPtr) 2475 cache->miscObjs->items[--cache->miscObjs->number]; 2476 2477 ret->type = XPATH_STRING; 2478 ret->stringval = xmlStrdup(BAD_CAST val); 2479 #ifdef XP_DEBUG_OBJ_USAGE 2480 xmlXPathDebugObjUsageRequested(ctxt, XPATH_STRING); 2481 #endif 2482 return(ret); 2483 } 2484 } 2485 return(xmlXPathNewCString(val)); 2486 } 2487 2488 /** 2489 * xmlXPathCacheNewString: 2490 * @ctxt: the XPath context 2491 * @val: the xmlChar * value 2492 * 2493 * This is the cached version of xmlXPathNewString(). 2494 * Acquire an xmlXPathObjectPtr of type string and of value @val 2495 * 2496 * Returns the created or reused object. 2497 */ 2498 static xmlXPathObjectPtr 2499 xmlXPathCacheNewString(xmlXPathContextPtr ctxt, const xmlChar *val) 2500 { 2501 if ((ctxt != NULL) && (ctxt->cache)) { 2502 xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache; 2503 2504 if ((cache->stringObjs != NULL) && 2505 (cache->stringObjs->number != 0)) 2506 { 2507 xmlXPathObjectPtr ret; 2508 2509 ret = (xmlXPathObjectPtr) 2510 cache->stringObjs->items[--cache->stringObjs->number]; 2511 ret->type = XPATH_STRING; 2512 if (val != NULL) 2513 ret->stringval = xmlStrdup(val); 2514 else 2515 ret->stringval = xmlStrdup((const xmlChar *)""); 2516 #ifdef XP_DEBUG_OBJ_USAGE 2517 xmlXPathDebugObjUsageRequested(ctxt, XPATH_STRING); 2518 #endif 2519 return(ret); 2520 } else if ((cache->miscObjs != NULL) && 2521 (cache->miscObjs->number != 0)) 2522 { 2523 xmlXPathObjectPtr ret; 2524 2525 ret = (xmlXPathObjectPtr) 2526 cache->miscObjs->items[--cache->miscObjs->number]; 2527 2528 ret->type = XPATH_STRING; 2529 if (val != NULL) 2530 ret->stringval = xmlStrdup(val); 2531 else 2532 ret->stringval = xmlStrdup((const xmlChar *)""); 2533 #ifdef XP_DEBUG_OBJ_USAGE 2534 xmlXPathDebugObjUsageRequested(ctxt, XPATH_STRING); 2535 #endif 2536 return(ret); 2537 } 2538 } 2539 return(xmlXPathNewString(val)); 2540 } 2541 2542 /** 2543 * xmlXPathCacheNewBoolean: 2544 * @ctxt: the XPath context 2545 * @val: the boolean value 2546 * 2547 * This is the cached version of xmlXPathNewBoolean(). 2548 * Acquires an xmlXPathObjectPtr of type boolean and of value @val 2549 * 2550 * Returns the created or reused object. 2551 */ 2552 static xmlXPathObjectPtr 2553 xmlXPathCacheNewBoolean(xmlXPathContextPtr ctxt, int val) 2554 { 2555 if ((ctxt != NULL) && (ctxt->cache)) { 2556 xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache; 2557 2558 if ((cache->booleanObjs != NULL) && 2559 (cache->booleanObjs->number != 0)) 2560 { 2561 xmlXPathObjectPtr ret; 2562 2563 ret = (xmlXPathObjectPtr) 2564 cache->booleanObjs->items[--cache->booleanObjs->number]; 2565 ret->type = XPATH_BOOLEAN; 2566 ret->boolval = (val != 0); 2567 #ifdef XP_DEBUG_OBJ_USAGE 2568 xmlXPathDebugObjUsageRequested(ctxt, XPATH_BOOLEAN); 2569 #endif 2570 return(ret); 2571 } else if ((cache->miscObjs != NULL) && 2572 (cache->miscObjs->number != 0)) 2573 { 2574 xmlXPathObjectPtr ret; 2575 2576 ret = (xmlXPathObjectPtr) 2577 cache->miscObjs->items[--cache->miscObjs->number]; 2578 2579 ret->type = XPATH_BOOLEAN; 2580 ret->boolval = (val != 0); 2581 #ifdef XP_DEBUG_OBJ_USAGE 2582 xmlXPathDebugObjUsageRequested(ctxt, XPATH_BOOLEAN); 2583 #endif 2584 return(ret); 2585 } 2586 } 2587 return(xmlXPathNewBoolean(val)); 2588 } 2589 2590 /** 2591 * xmlXPathCacheNewFloat: 2592 * @ctxt: the XPath context 2593 * @val: the double value 2594 * 2595 * This is the cached version of xmlXPathNewFloat(). 2596 * Acquires an xmlXPathObjectPtr of type double and of value @val 2597 * 2598 * Returns the created or reused object. 2599 */ 2600 static xmlXPathObjectPtr 2601 xmlXPathCacheNewFloat(xmlXPathContextPtr ctxt, double val) 2602 { 2603 if ((ctxt != NULL) && (ctxt->cache)) { 2604 xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache; 2605 2606 if ((cache->numberObjs != NULL) && 2607 (cache->numberObjs->number != 0)) 2608 { 2609 xmlXPathObjectPtr ret; 2610 2611 ret = (xmlXPathObjectPtr) 2612 cache->numberObjs->items[--cache->numberObjs->number]; 2613 ret->type = XPATH_NUMBER; 2614 ret->floatval = val; 2615 #ifdef XP_DEBUG_OBJ_USAGE 2616 xmlXPathDebugObjUsageRequested(ctxt, XPATH_NUMBER); 2617 #endif 2618 return(ret); 2619 } else if ((cache->miscObjs != NULL) && 2620 (cache->miscObjs->number != 0)) 2621 { 2622 xmlXPathObjectPtr ret; 2623 2624 ret = (xmlXPathObjectPtr) 2625 cache->miscObjs->items[--cache->miscObjs->number]; 2626 2627 ret->type = XPATH_NUMBER; 2628 ret->floatval = val; 2629 #ifdef XP_DEBUG_OBJ_USAGE 2630 xmlXPathDebugObjUsageRequested(ctxt, XPATH_NUMBER); 2631 #endif 2632 return(ret); 2633 } 2634 } 2635 return(xmlXPathNewFloat(val)); 2636 } 2637 2638 /** 2639 * xmlXPathCacheConvertString: 2640 * @ctxt: the XPath context 2641 * @val: an XPath object 2642 * 2643 * This is the cached version of xmlXPathConvertString(). 2644 * Converts an existing object to its string() equivalent 2645 * 2646 * Returns a created or reused object, the old one is freed (cached) 2647 * (or the operation is done directly on @val) 2648 */ 2649 2650 static xmlXPathObjectPtr 2651 xmlXPathCacheConvertString(xmlXPathContextPtr ctxt, xmlXPathObjectPtr val) { 2652 xmlChar *res = NULL; 2653 2654 if (val == NULL) 2655 return(xmlXPathCacheNewCString(ctxt, "")); 2656 2657 switch (val->type) { 2658 case XPATH_UNDEFINED: 2659 #ifdef DEBUG_EXPR 2660 xmlGenericError(xmlGenericErrorContext, "STRING: undefined\n"); 2661 #endif 2662 break; 2663 case XPATH_NODESET: 2664 case XPATH_XSLT_TREE: 2665 res = xmlXPathCastNodeSetToString(val->nodesetval); 2666 break; 2667 case XPATH_STRING: 2668 return(val); 2669 case XPATH_BOOLEAN: 2670 res = xmlXPathCastBooleanToString(val->boolval); 2671 break; 2672 case XPATH_NUMBER: 2673 res = xmlXPathCastNumberToString(val->floatval); 2674 break; 2675 case XPATH_USERS: 2676 case XPATH_POINT: 2677 case XPATH_RANGE: 2678 case XPATH_LOCATIONSET: 2679 TODO; 2680 break; 2681 } 2682 xmlXPathReleaseObject(ctxt, val); 2683 if (res == NULL) 2684 return(xmlXPathCacheNewCString(ctxt, "")); 2685 return(xmlXPathCacheWrapString(ctxt, res)); 2686 } 2687 2688 /** 2689 * xmlXPathCacheObjectCopy: 2690 * @ctxt: the XPath context 2691 * @val: the original object 2692 * 2693 * This is the cached version of xmlXPathObjectCopy(). 2694 * Acquire a copy of a given object 2695 * 2696 * Returns a created or reused created object. 2697 */ 2698 static xmlXPathObjectPtr 2699 xmlXPathCacheObjectCopy(xmlXPathContextPtr ctxt, xmlXPathObjectPtr val) 2700 { 2701 if (val == NULL) 2702 return(NULL); 2703 2704 if (XP_HAS_CACHE(ctxt)) { 2705 switch (val->type) { 2706 case XPATH_NODESET: 2707 return(xmlXPathCacheWrapNodeSet(ctxt, 2708 xmlXPathNodeSetMerge(NULL, val->nodesetval))); 2709 case XPATH_STRING: 2710 return(xmlXPathCacheNewString(ctxt, val->stringval)); 2711 case XPATH_BOOLEAN: 2712 return(xmlXPathCacheNewBoolean(ctxt, val->boolval)); 2713 case XPATH_NUMBER: 2714 return(xmlXPathCacheNewFloat(ctxt, val->floatval)); 2715 default: 2716 break; 2717 } 2718 } 2719 return(xmlXPathObjectCopy(val)); 2720 } 2721 2722 /** 2723 * xmlXPathCacheConvertBoolean: 2724 * @ctxt: the XPath context 2725 * @val: an XPath object 2726 * 2727 * This is the cached version of xmlXPathConvertBoolean(). 2728 * Converts an existing object to its boolean() equivalent 2729 * 2730 * Returns a created or reused object, the old one is freed (or the operation 2731 * is done directly on @val) 2732 */ 2733 static xmlXPathObjectPtr 2734 xmlXPathCacheConvertBoolean(xmlXPathContextPtr ctxt, xmlXPathObjectPtr val) { 2735 xmlXPathObjectPtr ret; 2736 2737 if (val == NULL) 2738 return(xmlXPathCacheNewBoolean(ctxt, 0)); 2739 if (val->type == XPATH_BOOLEAN) 2740 return(val); 2741 ret = xmlXPathCacheNewBoolean(ctxt, xmlXPathCastToBoolean(val)); 2742 xmlXPathReleaseObject(ctxt, val); 2743 return(ret); 2744 } 2745 2746 /** 2747 * xmlXPathCacheConvertNumber: 2748 * @ctxt: the XPath context 2749 * @val: an XPath object 2750 * 2751 * This is the cached version of xmlXPathConvertNumber(). 2752 * Converts an existing object to its number() equivalent 2753 * 2754 * Returns a created or reused object, the old one is freed (or the operation 2755 * is done directly on @val) 2756 */ 2757 static xmlXPathObjectPtr 2758 xmlXPathCacheConvertNumber(xmlXPathContextPtr ctxt, xmlXPathObjectPtr val) { 2759 xmlXPathObjectPtr ret; 2760 2761 if (val == NULL) 2762 return(xmlXPathCacheNewFloat(ctxt, 0.0)); 2763 if (val->type == XPATH_NUMBER) 2764 return(val); 2765 ret = xmlXPathCacheNewFloat(ctxt, xmlXPathCastToNumber(val)); 2766 xmlXPathReleaseObject(ctxt, val); 2767 return(ret); 2768 } 2769 2770 /************************************************************************ 2771 * * 2772 * Parser stacks related functions and macros * 2773 * * 2774 ************************************************************************/ 2775 2776 /** 2777 * xmlXPathSetFrame: 2778 * @ctxt: an XPath parser context 2779 * 2780 * Set the callee evaluation frame 2781 * 2782 * Returns the previous frame value to be restored once done 2783 */ 2784 static int 2785 xmlXPathSetFrame(xmlXPathParserContextPtr ctxt) { 2786 int ret; 2787 2788 if (ctxt == NULL) 2789 return(0); 2790 ret = ctxt->valueFrame; 2791 ctxt->valueFrame = ctxt->valueNr; 2792 return(ret); 2793 } 2794 2795 /** 2796 * xmlXPathPopFrame: 2797 * @ctxt: an XPath parser context 2798 * @frame: the previous frame value 2799 * 2800 * Remove the callee evaluation frame 2801 */ 2802 static void 2803 xmlXPathPopFrame(xmlXPathParserContextPtr ctxt, int frame) { 2804 if (ctxt == NULL) 2805 return; 2806 if (ctxt->valueNr < ctxt->valueFrame) { 2807 xmlXPatherror(ctxt, __FILE__, __LINE__, XPATH_STACK_ERROR); 2808 } 2809 ctxt->valueFrame = frame; 2810 } 2811 2812 /** 2813 * valuePop: 2814 * @ctxt: an XPath evaluation context 2815 * 2816 * Pops the top XPath object from the value stack 2817 * 2818 * Returns the XPath object just removed 2819 */ 2820 xmlXPathObjectPtr 2821 valuePop(xmlXPathParserContextPtr ctxt) 2822 { 2823 xmlXPathObjectPtr ret; 2824 2825 if ((ctxt == NULL) || (ctxt->valueNr <= 0)) 2826 return (NULL); 2827 2828 if (ctxt->valueNr <= ctxt->valueFrame) { 2829 xmlXPatherror(ctxt, __FILE__, __LINE__, XPATH_STACK_ERROR); 2830 return (NULL); 2831 } 2832 2833 ctxt->valueNr--; 2834 if (ctxt->valueNr > 0) 2835 ctxt->value = ctxt->valueTab[ctxt->valueNr - 1]; 2836 else 2837 ctxt->value = NULL; 2838 ret = ctxt->valueTab[ctxt->valueNr]; 2839 ctxt->valueTab[ctxt->valueNr] = NULL; 2840 return (ret); 2841 } 2842 /** 2843 * valuePush: 2844 * @ctxt: an XPath evaluation context 2845 * @value: the XPath object 2846 * 2847 * Pushes a new XPath object on top of the value stack 2848 * 2849 * returns the number of items on the value stack 2850 */ 2851 int 2852 valuePush(xmlXPathParserContextPtr ctxt, xmlXPathObjectPtr value) 2853 { 2854 if ((ctxt == NULL) || (value == NULL)) return(-1); 2855 if (ctxt->valueNr >= ctxt->valueMax) { 2856 xmlXPathObjectPtr *tmp; 2857 2858 if (ctxt->valueMax >= XPATH_MAX_STACK_DEPTH) { 2859 xmlXPathErrMemory(NULL, "XPath stack depth limit reached\n"); 2860 ctxt->error = XPATH_MEMORY_ERROR; 2861 return (0); 2862 } 2863 tmp = (xmlXPathObjectPtr *) xmlRealloc(ctxt->valueTab, 2864 2 * ctxt->valueMax * 2865 sizeof(ctxt->valueTab[0])); 2866 if (tmp == NULL) { 2867 xmlXPathErrMemory(NULL, "pushing value\n"); 2868 ctxt->error = XPATH_MEMORY_ERROR; 2869 return (0); 2870 } 2871 ctxt->valueMax *= 2; 2872 ctxt->valueTab = tmp; 2873 } 2874 ctxt->valueTab[ctxt->valueNr] = value; 2875 ctxt->value = value; 2876 return (ctxt->valueNr++); 2877 } 2878 2879 /** 2880 * xmlXPathPopBoolean: 2881 * @ctxt: an XPath parser context 2882 * 2883 * Pops a boolean from the stack, handling conversion if needed. 2884 * Check error with #xmlXPathCheckError. 2885 * 2886 * Returns the boolean 2887 */ 2888 int 2889 xmlXPathPopBoolean (xmlXPathParserContextPtr ctxt) { 2890 xmlXPathObjectPtr obj; 2891 int ret; 2892 2893 obj = valuePop(ctxt); 2894 if (obj == NULL) { 2895 xmlXPathSetError(ctxt, XPATH_INVALID_OPERAND); 2896 return(0); 2897 } 2898 if (obj->type != XPATH_BOOLEAN) 2899 ret = xmlXPathCastToBoolean(obj); 2900 else 2901 ret = obj->boolval; 2902 xmlXPathReleaseObject(ctxt->context, obj); 2903 return(ret); 2904 } 2905 2906 /** 2907 * xmlXPathPopNumber: 2908 * @ctxt: an XPath parser context 2909 * 2910 * Pops a number from the stack, handling conversion if needed. 2911 * Check error with #xmlXPathCheckError. 2912 * 2913 * Returns the number 2914 */ 2915 double 2916 xmlXPathPopNumber (xmlXPathParserContextPtr ctxt) { 2917 xmlXPathObjectPtr obj; 2918 double ret; 2919 2920 obj = valuePop(ctxt); 2921 if (obj == NULL) { 2922 xmlXPathSetError(ctxt, XPATH_INVALID_OPERAND); 2923 return(0); 2924 } 2925 if (obj->type != XPATH_NUMBER) 2926 ret = xmlXPathCastToNumber(obj); 2927 else 2928 ret = obj->floatval; 2929 xmlXPathReleaseObject(ctxt->context, obj); 2930 return(ret); 2931 } 2932 2933 /** 2934 * xmlXPathPopString: 2935 * @ctxt: an XPath parser context 2936 * 2937 * Pops a string from the stack, handling conversion if needed. 2938 * Check error with #xmlXPathCheckError. 2939 * 2940 * Returns the string 2941 */ 2942 xmlChar * 2943 xmlXPathPopString (xmlXPathParserContextPtr ctxt) { 2944 xmlXPathObjectPtr obj; 2945 xmlChar * ret; 2946 2947 obj = valuePop(ctxt); 2948 if (obj == NULL) { 2949 xmlXPathSetError(ctxt, XPATH_INVALID_OPERAND); 2950 return(NULL); 2951 } 2952 ret = xmlXPathCastToString(obj); /* this does required strdup */ 2953 /* TODO: needs refactoring somewhere else */ 2954 if (obj->stringval == ret) 2955 obj->stringval = NULL; 2956 xmlXPathReleaseObject(ctxt->context, obj); 2957 return(ret); 2958 } 2959 2960 /** 2961 * xmlXPathPopNodeSet: 2962 * @ctxt: an XPath parser context 2963 * 2964 * Pops a node-set from the stack, handling conversion if needed. 2965 * Check error with #xmlXPathCheckError. 2966 * 2967 * Returns the node-set 2968 */ 2969 xmlNodeSetPtr 2970 xmlXPathPopNodeSet (xmlXPathParserContextPtr ctxt) { 2971 xmlXPathObjectPtr obj; 2972 xmlNodeSetPtr ret; 2973 2974 if (ctxt == NULL) return(NULL); 2975 if (ctxt->value == NULL) { 2976 xmlXPathSetError(ctxt, XPATH_INVALID_OPERAND); 2977 return(NULL); 2978 } 2979 if (!xmlXPathStackIsNodeSet(ctxt)) { 2980 xmlXPathSetTypeError(ctxt); 2981 return(NULL); 2982 } 2983 obj = valuePop(ctxt); 2984 ret = obj->nodesetval; 2985 #if 0 2986 /* to fix memory leak of not clearing obj->user */ 2987 if (obj->boolval && obj->user != NULL) 2988 xmlFreeNodeList((xmlNodePtr) obj->user); 2989 #endif 2990 obj->nodesetval = NULL; 2991 xmlXPathReleaseObject(ctxt->context, obj); 2992 return(ret); 2993 } 2994 2995 /** 2996 * xmlXPathPopExternal: 2997 * @ctxt: an XPath parser context 2998 * 2999 * Pops an external object from the stack, handling conversion if needed. 3000 * Check error with #xmlXPathCheckError. 3001 * 3002 * Returns the object 3003 */ 3004 void * 3005 xmlXPathPopExternal (xmlXPathParserContextPtr ctxt) { 3006 xmlXPathObjectPtr obj; 3007 void * ret; 3008 3009 if ((ctxt == NULL) || (ctxt->value == NULL)) { 3010 xmlXPathSetError(ctxt, XPATH_INVALID_OPERAND); 3011 return(NULL); 3012 } 3013 if (ctxt->value->type != XPATH_USERS) { 3014 xmlXPathSetTypeError(ctxt); 3015 return(NULL); 3016 } 3017 obj = valuePop(ctxt); 3018 ret = obj->user; 3019 obj->user = NULL; 3020 xmlXPathReleaseObject(ctxt->context, obj); 3021 return(ret); 3022 } 3023 3024 /* 3025 * Macros for accessing the content. Those should be used only by the parser, 3026 * and not exported. 3027 * 3028 * Dirty macros, i.e. one need to make assumption on the context to use them 3029 * 3030 * CUR_PTR return the current pointer to the xmlChar to be parsed. 3031 * CUR returns the current xmlChar value, i.e. a 8 bit value 3032 * in ISO-Latin or UTF-8. 3033 * This should be used internally by the parser 3034 * only to compare to ASCII values otherwise it would break when 3035 * running with UTF-8 encoding. 3036 * NXT(n) returns the n'th next xmlChar. Same as CUR is should be used only 3037 * to compare on ASCII based substring. 3038 * SKIP(n) Skip n xmlChar, and must also be used only to skip ASCII defined 3039 * strings within the parser. 3040 * CURRENT Returns the current char value, with the full decoding of 3041 * UTF-8 if we are using this mode. It returns an int. 3042 * NEXT Skip to the next character, this does the proper decoding 3043 * in UTF-8 mode. It also pop-up unfinished entities on the fly. 3044 * It returns the pointer to the current xmlChar. 3045 */ 3046 3047 #define CUR (*ctxt->cur) 3048 #define SKIP(val) ctxt->cur += (val) 3049 #define NXT(val) ctxt->cur[(val)] 3050 #define CUR_PTR ctxt->cur 3051 #define CUR_CHAR(l) xmlXPathCurrentChar(ctxt, &l) 3052 3053 #define COPY_BUF(l,b,i,v) \ 3054 if (l == 1) b[i++] = (xmlChar) v; \ 3055 else i += xmlCopyChar(l,&b[i],v) 3056 3057 #define NEXTL(l) ctxt->cur += l 3058 3059 #define SKIP_BLANKS \ 3060 while (IS_BLANK_CH(*(ctxt->cur))) NEXT 3061 3062 #define CURRENT (*ctxt->cur) 3063 #define NEXT ((*ctxt->cur) ? ctxt->cur++: ctxt->cur) 3064 3065 3066 #ifndef DBL_DIG 3067 #define DBL_DIG 16 3068 #endif 3069 #ifndef DBL_EPSILON 3070 #define DBL_EPSILON 1E-9 3071 #endif 3072 3073 #define UPPER_DOUBLE 1E9 3074 #define LOWER_DOUBLE 1E-5 3075 #define LOWER_DOUBLE_EXP 5 3076 3077 #define INTEGER_DIGITS DBL_DIG 3078 #define FRACTION_DIGITS (DBL_DIG + 1 + (LOWER_DOUBLE_EXP)) 3079 #define EXPONENT_DIGITS (3 + 2) 3080 3081 /** 3082 * xmlXPathFormatNumber: 3083 * @number: number to format 3084 * @buffer: output buffer 3085 * @buffersize: size of output buffer 3086 * 3087 * Convert the number into a string representation. 3088 */ 3089 static void 3090 xmlXPathFormatNumber(double number, char buffer[], int buffersize) 3091 { 3092 switch (xmlXPathIsInf(number)) { 3093 case 1: 3094 if (buffersize > (int)sizeof("Infinity")) 3095 snprintf(buffer, buffersize, "Infinity"); 3096 break; 3097 case -1: 3098 if (buffersize > (int)sizeof("-Infinity")) 3099 snprintf(buffer, buffersize, "-Infinity"); 3100 break; 3101 default: 3102 if (xmlXPathIsNaN(number)) { 3103 if (buffersize > (int)sizeof("NaN")) 3104 snprintf(buffer, buffersize, "NaN"); 3105 } else if (number == 0) { 3106 /* Omit sign for negative zero. */ 3107 snprintf(buffer, buffersize, "0"); 3108 } else if ((number > INT_MIN) && (number < INT_MAX) && 3109 (number == (int) number)) { 3110 char work[30]; 3111 char *ptr, *cur; 3112 int value = (int) number; 3113 3114 ptr = &buffer[0]; 3115 if (value == 0) { 3116 *ptr++ = '0'; 3117 } else { 3118 snprintf(work, 29, "%d", value); 3119 cur = &work[0]; 3120 while ((*cur) && (ptr - buffer < buffersize)) { 3121 *ptr++ = *cur++; 3122 } 3123 } 3124 if (ptr - buffer < buffersize) { 3125 *ptr = 0; 3126 } else if (buffersize > 0) { 3127 ptr--; 3128 *ptr = 0; 3129 } 3130 } else { 3131 /* 3132 For the dimension of work, 3133 DBL_DIG is number of significant digits 3134 EXPONENT is only needed for "scientific notation" 3135 3 is sign, decimal point, and terminating zero 3136 LOWER_DOUBLE_EXP is max number of leading zeroes in fraction 3137 Note that this dimension is slightly (a few characters) 3138 larger than actually necessary. 3139 */ 3140 char work[DBL_DIG + EXPONENT_DIGITS + 3 + LOWER_DOUBLE_EXP]; 3141 int integer_place, fraction_place; 3142 char *ptr; 3143 char *after_fraction; 3144 double absolute_value; 3145 int size; 3146 3147 absolute_value = fabs(number); 3148 3149 /* 3150 * First choose format - scientific or regular floating point. 3151 * In either case, result is in work, and after_fraction points 3152 * just past the fractional part. 3153 */ 3154 if ( ((absolute_value > UPPER_DOUBLE) || 3155 (absolute_value < LOWER_DOUBLE)) && 3156 (absolute_value != 0.0) ) { 3157 /* Use scientific notation */ 3158 integer_place = DBL_DIG + EXPONENT_DIGITS + 1; 3159 fraction_place = DBL_DIG - 1; 3160 size = snprintf(work, sizeof(work),"%*.*e", 3161 integer_place, fraction_place, number); 3162 while ((size > 0) && (work[size] != 'e')) size--; 3163 3164 } 3165 else { 3166 /* Use regular notation */ 3167 if (absolute_value > 0.0) { 3168 integer_place = (int)log10(absolute_value); 3169 if (integer_place > 0) 3170 fraction_place = DBL_DIG - integer_place - 1; 3171 else 3172 fraction_place = DBL_DIG - integer_place; 3173 } else { 3174 fraction_place = 1; 3175 } 3176 size = snprintf(work, sizeof(work), "%0.*f", 3177 fraction_place, number); 3178 } 3179 3180 /* Remove leading spaces sometimes inserted by snprintf */ 3181 while (work[0] == ' ') { 3182 for (ptr = &work[0];(ptr[0] = ptr[1]);ptr++); 3183 size--; 3184 } 3185 3186 /* Remove fractional trailing zeroes */ 3187 after_fraction = work + size; 3188 ptr = after_fraction; 3189 while (*(--ptr) == '0') 3190 ; 3191 if (*ptr != '.') 3192 ptr++; 3193 while ((*ptr++ = *after_fraction++) != 0); 3194 3195 /* Finally copy result back to caller */ 3196 size = strlen(work) + 1; 3197 if (size > buffersize) { 3198 work[buffersize - 1] = 0; 3199 size = buffersize; 3200 } 3201 memmove(buffer, work, size); 3202 } 3203 break; 3204 } 3205 } 3206 3207 3208 /************************************************************************ 3209 * * 3210 * Routines to handle NodeSets * 3211 * * 3212 ************************************************************************/ 3213 3214 /** 3215 * xmlXPathOrderDocElems: 3216 * @doc: an input document 3217 * 3218 * Call this routine to speed up XPath computation on static documents. 3219 * This stamps all the element nodes with the document order 3220 * Like for line information, the order is kept in the element->content 3221 * field, the value stored is actually - the node number (starting at -1) 3222 * to be able to differentiate from line numbers. 3223 * 3224 * Returns the number of elements found in the document or -1 in case 3225 * of error. 3226 */ 3227 long 3228 xmlXPathOrderDocElems(xmlDocPtr doc) { 3229 ptrdiff_t count = 0; 3230 xmlNodePtr cur; 3231 3232 if (doc == NULL) 3233 return(-1); 3234 cur = doc->children; 3235 while (cur != NULL) { 3236 if (cur->type == XML_ELEMENT_NODE) { 3237 cur->content = (void *) (-(++count)); 3238 if (cur->children != NULL) { 3239 cur = cur->children; 3240 continue; 3241 } 3242 } 3243 if (cur->next != NULL) { 3244 cur = cur->next; 3245 continue; 3246 } 3247 do { 3248 cur = cur->parent; 3249 if (cur == NULL) 3250 break; 3251 if (cur == (xmlNodePtr) doc) { 3252 cur = NULL; 3253 break; 3254 } 3255 if (cur->next != NULL) { 3256 cur = cur->next; 3257 break; 3258 } 3259 } while (cur != NULL); 3260 } 3261 return((long) count); 3262 } 3263 3264 /** 3265 * xmlXPathCmpNodes: 3266 * @node1: the first node 3267 * @node2: the second node 3268 * 3269 * Compare two nodes w.r.t document order 3270 * 3271 * Returns -2 in case of error 1 if first point < second point, 0 if 3272 * it's the same node, -1 otherwise 3273 */ 3274 int 3275 xmlXPathCmpNodes(xmlNodePtr node1, xmlNodePtr node2) { 3276 int depth1, depth2; 3277 int attr1 = 0, attr2 = 0; 3278 xmlNodePtr attrNode1 = NULL, attrNode2 = NULL; 3279 xmlNodePtr cur, root; 3280 3281 if ((node1 == NULL) || (node2 == NULL)) 3282 return(-2); 3283 /* 3284 * a couple of optimizations which will avoid computations in most cases 3285 */ 3286 if (node1 == node2) /* trivial case */ 3287 return(0); 3288 if (node1->type == XML_ATTRIBUTE_NODE) { 3289 attr1 = 1; 3290 attrNode1 = node1; 3291 node1 = node1->parent; 3292 } 3293 if (node2->type == XML_ATTRIBUTE_NODE) { 3294 attr2 = 1; 3295 attrNode2 = node2; 3296 node2 = node2->parent; 3297 } 3298 if (node1 == node2) { 3299 if (attr1 == attr2) { 3300 /* not required, but we keep attributes in order */ 3301 if (attr1 != 0) { 3302 cur = attrNode2->prev; 3303 while (cur != NULL) { 3304 if (cur == attrNode1) 3305 return (1); 3306 cur = cur->prev; 3307 } 3308 return (-1); 3309 } 3310 return(0); 3311 } 3312 if (attr2 == 1) 3313 return(1); 3314 return(-1); 3315 } 3316 if ((node1->type == XML_NAMESPACE_DECL) || 3317 (node2->type == XML_NAMESPACE_DECL)) 3318 return(1); 3319 if (node1 == node2->prev) 3320 return(1); 3321 if (node1 == node2->next) 3322 return(-1); 3323 3324 /* 3325 * Speedup using document order if availble. 3326 */ 3327 if ((node1->type == XML_ELEMENT_NODE) && 3328 (node2->type == XML_ELEMENT_NODE) && 3329 (0 > (ptrdiff_t) node1->content) && 3330 (0 > (ptrdiff_t) node2->content) && 3331 (node1->doc == node2->doc)) { 3332 ptrdiff_t l1, l2; 3333 3334 l1 = -((ptrdiff_t) node1->content); 3335 l2 = -((ptrdiff_t) node2->content); 3336 if (l1 < l2) 3337 return(1); 3338 if (l1 > l2) 3339 return(-1); 3340 } 3341 3342 /* 3343 * compute depth to root 3344 */ 3345 for (depth2 = 0, cur = node2;cur->parent != NULL;cur = cur->parent) { 3346 if (cur->parent == node1) 3347 return(1); 3348 depth2++; 3349 } 3350 root = cur; 3351 for (depth1 = 0, cur = node1;cur->parent != NULL;cur = cur->parent) { 3352 if (cur->parent == node2) 3353 return(-1); 3354 depth1++; 3355 } 3356 /* 3357 * Distinct document (or distinct entities :-( ) case. 3358 */ 3359 if (root != cur) { 3360 return(-2); 3361 } 3362 /* 3363 * get the nearest common ancestor. 3364 */ 3365 while (depth1 > depth2) { 3366 depth1--; 3367 node1 = node1->parent; 3368 } 3369 while (depth2 > depth1) { 3370 depth2--; 3371 node2 = node2->parent; 3372 } 3373 while (node1->parent != node2->parent) { 3374 node1 = node1->parent; 3375 node2 = node2->parent; 3376 /* should not happen but just in case ... */ 3377 if ((node1 == NULL) || (node2 == NULL)) 3378 return(-2); 3379 } 3380 /* 3381 * Find who's first. 3382 */ 3383 if (node1 == node2->prev) 3384 return(1); 3385 if (node1 == node2->next) 3386 return(-1); 3387 /* 3388 * Speedup using document order if availble. 3389 */ 3390 if ((node1->type == XML_ELEMENT_NODE) && 3391 (node2->type == XML_ELEMENT_NODE) && 3392 (0 > (ptrdiff_t) node1->content) && 3393 (0 > (ptrdiff_t) node2->content) && 3394 (node1->doc == node2->doc)) { 3395 ptrdiff_t l1, l2; 3396 3397 l1 = -((ptrdiff_t) node1->content); 3398 l2 = -((ptrdiff_t) node2->content); 3399 if (l1 < l2) 3400 return(1); 3401 if (l1 > l2) 3402 return(-1); 3403 } 3404 3405 for (cur = node1->next;cur != NULL;cur = cur->next) 3406 if (cur == node2) 3407 return(1); 3408 return(-1); /* assume there is no sibling list corruption */ 3409 } 3410 3411 /** 3412 * xmlXPathNodeSetSort: 3413 * @set: the node set 3414 * 3415 * Sort the node set in document order 3416 */ 3417 void 3418 xmlXPathNodeSetSort(xmlNodeSetPtr set) { 3419 #ifndef WITH_TIM_SORT 3420 int i, j, incr, len; 3421 xmlNodePtr tmp; 3422 #endif 3423 3424 if (set == NULL) 3425 return; 3426 3427 #ifndef WITH_TIM_SORT 3428 /* 3429 * Use the old Shell's sort implementation to sort the node-set 3430 * Timsort ought to be quite faster 3431 */ 3432 len = set->nodeNr; 3433 for (incr = len / 2; incr > 0; incr /= 2) { 3434 for (i = incr; i < len; i++) { 3435 j = i - incr; 3436 while (j >= 0) { 3437 #ifdef XP_OPTIMIZED_NON_ELEM_COMPARISON 3438 if (xmlXPathCmpNodesExt(set->nodeTab[j], 3439 set->nodeTab[j + incr]) == -1) 3440 #else 3441 if (xmlXPathCmpNodes(set->nodeTab[j], 3442 set->nodeTab[j + incr]) == -1) 3443 #endif 3444 { 3445 tmp = set->nodeTab[j]; 3446 set->nodeTab[j] = set->nodeTab[j + incr]; 3447 set->nodeTab[j + incr] = tmp; 3448 j -= incr; 3449 } else 3450 break; 3451 } 3452 } 3453 } 3454 #else /* WITH_TIM_SORT */ 3455 libxml_domnode_tim_sort(set->nodeTab, set->nodeNr); 3456 #endif /* WITH_TIM_SORT */ 3457 } 3458 3459 #define XML_NODESET_DEFAULT 10 3460 /** 3461 * xmlXPathNodeSetDupNs: 3462 * @node: the parent node of the namespace XPath node 3463 * @ns: the libxml namespace declaration node. 3464 * 3465 * Namespace node in libxml don't match the XPath semantic. In a node set 3466 * the namespace nodes are duplicated and the next pointer is set to the 3467 * parent node in the XPath semantic. 3468 * 3469 * Returns the newly created object. 3470 */ 3471 static xmlNodePtr 3472 xmlXPathNodeSetDupNs(xmlNodePtr node, xmlNsPtr ns) { 3473 xmlNsPtr cur; 3474 3475 if ((ns == NULL) || (ns->type != XML_NAMESPACE_DECL)) 3476 return(NULL); 3477 if ((node == NULL) || (node->type == XML_NAMESPACE_DECL)) 3478 return((xmlNodePtr) ns); 3479 3480 /* 3481 * Allocate a new Namespace and fill the fields. 3482 */ 3483 cur = (xmlNsPtr) xmlMalloc(sizeof(xmlNs)); 3484 if (cur == NULL) { 3485 xmlXPathErrMemory(NULL, "duplicating namespace\n"); 3486 return(NULL); 3487 } 3488 memset(cur, 0, sizeof(xmlNs)); 3489 cur->type = XML_NAMESPACE_DECL; 3490 if (ns->href != NULL) 3491 cur->href = xmlStrdup(ns->href); 3492 if (ns->prefix != NULL) 3493 cur->prefix = xmlStrdup(ns->prefix); 3494 cur->next = (xmlNsPtr) node; 3495 return((xmlNodePtr) cur); 3496 } 3497 3498 /** 3499 * xmlXPathNodeSetFreeNs: 3500 * @ns: the XPath namespace node found in a nodeset. 3501 * 3502 * Namespace nodes in libxml don't match the XPath semantic. In a node set 3503 * the namespace nodes are duplicated and the next pointer is set to the 3504 * parent node in the XPath semantic. Check if such a node needs to be freed 3505 */ 3506 void 3507 xmlXPathNodeSetFreeNs(xmlNsPtr ns) { 3508 if ((ns == NULL) || (ns->type != XML_NAMESPACE_DECL)) 3509 return; 3510 3511 if ((ns->next != NULL) && (ns->next->type != XML_NAMESPACE_DECL)) { 3512 if (ns->href != NULL) 3513 xmlFree((xmlChar *)ns->href); 3514 if (ns->prefix != NULL) 3515 xmlFree((xmlChar *)ns->prefix); 3516 xmlFree(ns); 3517 } 3518 } 3519 3520 /** 3521 * xmlXPathNodeSetCreate: 3522 * @val: an initial xmlNodePtr, or NULL 3523 * 3524 * Create a new xmlNodeSetPtr of type double and of value @val 3525 * 3526 * Returns the newly created object. 3527 */ 3528 xmlNodeSetPtr 3529 xmlXPathNodeSetCreate(xmlNodePtr val) { 3530 xmlNodeSetPtr ret; 3531 3532 ret = (xmlNodeSetPtr) xmlMalloc(sizeof(xmlNodeSet)); 3533 if (ret == NULL) { 3534 xmlXPathErrMemory(NULL, "creating nodeset\n"); 3535 return(NULL); 3536 } 3537 memset(ret, 0 , (size_t) sizeof(xmlNodeSet)); 3538 if (val != NULL) { 3539 ret->nodeTab = (xmlNodePtr *) xmlMalloc(XML_NODESET_DEFAULT * 3540 sizeof(xmlNodePtr)); 3541 if (ret->nodeTab == NULL) { 3542 xmlXPathErrMemory(NULL, "creating nodeset\n"); 3543 xmlFree(ret); 3544 return(NULL); 3545 } 3546 memset(ret->nodeTab, 0 , 3547 XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr)); 3548 ret->nodeMax = XML_NODESET_DEFAULT; 3549 if (val->type == XML_NAMESPACE_DECL) { 3550 xmlNsPtr ns = (xmlNsPtr) val; 3551 3552 ret->nodeTab[ret->nodeNr++] = 3553 xmlXPathNodeSetDupNs((xmlNodePtr) ns->next, ns); 3554 } else 3555 ret->nodeTab[ret->nodeNr++] = val; 3556 } 3557 return(ret); 3558 } 3559 3560 /** 3561 * xmlXPathNodeSetCreateSize: 3562 * @size: the initial size of the set 3563 * 3564 * Create a new xmlNodeSetPtr of type double and of value @val 3565 * 3566 * Returns the newly created object. 3567 */ 3568 static xmlNodeSetPtr 3569 xmlXPathNodeSetCreateSize(int size) { 3570 xmlNodeSetPtr ret; 3571 3572 ret = (xmlNodeSetPtr) xmlMalloc(sizeof(xmlNodeSet)); 3573 if (ret == NULL) { 3574 xmlXPathErrMemory(NULL, "creating nodeset\n"); 3575 return(NULL); 3576 } 3577 memset(ret, 0 , (size_t) sizeof(xmlNodeSet)); 3578 if (size < XML_NODESET_DEFAULT) 3579 size = XML_NODESET_DEFAULT; 3580 ret->nodeTab = (xmlNodePtr *) xmlMalloc(size * sizeof(xmlNodePtr)); 3581 if (ret->nodeTab == NULL) { 3582 xmlXPathErrMemory(NULL, "creating nodeset\n"); 3583 xmlFree(ret); 3584 return(NULL); 3585 } 3586 memset(ret->nodeTab, 0 , size * (size_t) sizeof(xmlNodePtr)); 3587 ret->nodeMax = size; 3588 return(ret); 3589 } 3590 3591 /** 3592 * xmlXPathNodeSetContains: 3593 * @cur: the node-set 3594 * @val: the node 3595 * 3596 * checks whether @cur contains @val 3597 * 3598 * Returns true (1) if @cur contains @val, false (0) otherwise 3599 */ 3600 int 3601 xmlXPathNodeSetContains (xmlNodeSetPtr cur, xmlNodePtr val) { 3602 int i; 3603 3604 if ((cur == NULL) || (val == NULL)) return(0); 3605 if (val->type == XML_NAMESPACE_DECL) { 3606 for (i = 0; i < cur->nodeNr; i++) { 3607 if (cur->nodeTab[i]->type == XML_NAMESPACE_DECL) { 3608 xmlNsPtr ns1, ns2; 3609 3610 ns1 = (xmlNsPtr) val; 3611 ns2 = (xmlNsPtr) cur->nodeTab[i]; 3612 if (ns1 == ns2) 3613 return(1); 3614 if ((ns1->next != NULL) && (ns2->next == ns1->next) && 3615 (xmlStrEqual(ns1->prefix, ns2->prefix))) 3616 return(1); 3617 } 3618 } 3619 } else { 3620 for (i = 0; i < cur->nodeNr; i++) { 3621 if (cur->nodeTab[i] == val) 3622 return(1); 3623 } 3624 } 3625 return(0); 3626 } 3627 3628 /** 3629 * xmlXPathNodeSetAddNs: 3630 * @cur: the initial node set 3631 * @node: the hosting node 3632 * @ns: a the namespace node 3633 * 3634 * add a new namespace node to an existing NodeSet 3635 * 3636 * Returns 0 in case of success and -1 in case of error 3637 */ 3638 int 3639 xmlXPathNodeSetAddNs(xmlNodeSetPtr cur, xmlNodePtr node, xmlNsPtr ns) { 3640 int i; 3641 3642 3643 if ((cur == NULL) || (ns == NULL) || (node == NULL) || 3644 (ns->type != XML_NAMESPACE_DECL) || 3645 (node->type != XML_ELEMENT_NODE)) 3646 return(-1); 3647 3648 /* @@ with_ns to check whether namespace nodes should be looked at @@ */ 3649 /* 3650 * prevent duplicates 3651 */ 3652 for (i = 0;i < cur->nodeNr;i++) { 3653 if ((cur->nodeTab[i] != NULL) && 3654 (cur->nodeTab[i]->type == XML_NAMESPACE_DECL) && 3655 (((xmlNsPtr)cur->nodeTab[i])->next == (xmlNsPtr) node) && 3656 (xmlStrEqual(ns->prefix, ((xmlNsPtr)cur->nodeTab[i])->prefix))) 3657 return(0); 3658 } 3659 3660 /* 3661 * grow the nodeTab if needed 3662 */ 3663 if (cur->nodeMax == 0) { 3664 cur->nodeTab = (xmlNodePtr *) xmlMalloc(XML_NODESET_DEFAULT * 3665 sizeof(xmlNodePtr)); 3666 if (cur->nodeTab == NULL) { 3667 xmlXPathErrMemory(NULL, "growing nodeset\n"); 3668 return(-1); 3669 } 3670 memset(cur->nodeTab, 0 , 3671 XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr)); 3672 cur->nodeMax = XML_NODESET_DEFAULT; 3673 } else if (cur->nodeNr == cur->nodeMax) { 3674 xmlNodePtr *temp; 3675 3676 if (cur->nodeMax >= XPATH_MAX_NODESET_LENGTH) { 3677 xmlXPathErrMemory(NULL, "growing nodeset hit limit\n"); 3678 return(-1); 3679 } 3680 temp = (xmlNodePtr *) xmlRealloc(cur->nodeTab, cur->nodeMax * 2 * 3681 sizeof(xmlNodePtr)); 3682 if (temp == NULL) { 3683 xmlXPathErrMemory(NULL, "growing nodeset\n"); 3684 return(-1); 3685 } 3686 cur->nodeMax *= 2; 3687 cur->nodeTab = temp; 3688 } 3689 cur->nodeTab[cur->nodeNr++] = xmlXPathNodeSetDupNs(node, ns); 3690 return(0); 3691 } 3692 3693 /** 3694 * xmlXPathNodeSetAdd: 3695 * @cur: the initial node set 3696 * @val: a new xmlNodePtr 3697 * 3698 * add a new xmlNodePtr to an existing NodeSet 3699 * 3700 * Returns 0 in case of success, and -1 in case of error 3701 */ 3702 int 3703 xmlXPathNodeSetAdd(xmlNodeSetPtr cur, xmlNodePtr val) { 3704 int i; 3705 3706 if ((cur == NULL) || (val == NULL)) return(-1); 3707 3708 /* @@ with_ns to check whether namespace nodes should be looked at @@ */ 3709 /* 3710 * prevent duplicates 3711 */ 3712 for (i = 0;i < cur->nodeNr;i++) 3713 if (cur->nodeTab[i] == val) return(0); 3714 3715 /* 3716 * grow the nodeTab if needed 3717 */ 3718 if (cur->nodeMax == 0) { 3719 cur->nodeTab = (xmlNodePtr *) xmlMalloc(XML_NODESET_DEFAULT * 3720 sizeof(xmlNodePtr)); 3721 if (cur->nodeTab == NULL) { 3722 xmlXPathErrMemory(NULL, "growing nodeset\n"); 3723 return(-1); 3724 } 3725 memset(cur->nodeTab, 0 , 3726 XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr)); 3727 cur->nodeMax = XML_NODESET_DEFAULT; 3728 } else if (cur->nodeNr == cur->nodeMax) { 3729 xmlNodePtr *temp; 3730 3731 if (cur->nodeMax >= XPATH_MAX_NODESET_LENGTH) { 3732 xmlXPathErrMemory(NULL, "growing nodeset hit limit\n"); 3733 return(-1); 3734 } 3735 temp = (xmlNodePtr *) xmlRealloc(cur->nodeTab, cur->nodeMax * 2 * 3736 sizeof(xmlNodePtr)); 3737 if (temp == NULL) { 3738 xmlXPathErrMemory(NULL, "growing nodeset\n"); 3739 return(-1); 3740 } 3741 cur->nodeMax *= 2; 3742 cur->nodeTab = temp; 3743 } 3744 if (val->type == XML_NAMESPACE_DECL) { 3745 xmlNsPtr ns = (xmlNsPtr) val; 3746 3747 cur->nodeTab[cur->nodeNr++] = 3748 xmlXPathNodeSetDupNs((xmlNodePtr) ns->next, ns); 3749 } else 3750 cur->nodeTab[cur->nodeNr++] = val; 3751 return(0); 3752 } 3753 3754 /** 3755 * xmlXPathNodeSetAddUnique: 3756 * @cur: the initial node set 3757 * @val: a new xmlNodePtr 3758 * 3759 * add a new xmlNodePtr to an existing NodeSet, optimized version 3760 * when we are sure the node is not already in the set. 3761 * 3762 * Returns 0 in case of success and -1 in case of failure 3763 */ 3764 int 3765 xmlXPathNodeSetAddUnique(xmlNodeSetPtr cur, xmlNodePtr val) { 3766 if ((cur == NULL) || (val == NULL)) return(-1); 3767 3768 /* @@ with_ns to check whether namespace nodes should be looked at @@ */ 3769 /* 3770 * grow the nodeTab if needed 3771 */ 3772 if (cur->nodeMax == 0) { 3773 cur->nodeTab = (xmlNodePtr *) xmlMalloc(XML_NODESET_DEFAULT * 3774 sizeof(xmlNodePtr)); 3775 if (cur->nodeTab == NULL) { 3776 xmlXPathErrMemory(NULL, "growing nodeset\n"); 3777 return(-1); 3778 } 3779 memset(cur->nodeTab, 0 , 3780 XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr)); 3781 cur->nodeMax = XML_NODESET_DEFAULT; 3782 } else if (cur->nodeNr == cur->nodeMax) { 3783 xmlNodePtr *temp; 3784 3785 if (cur->nodeMax >= XPATH_MAX_NODESET_LENGTH) { 3786 xmlXPathErrMemory(NULL, "growing nodeset hit limit\n"); 3787 return(-1); 3788 } 3789 temp = (xmlNodePtr *) xmlRealloc(cur->nodeTab, cur->nodeMax * 2 * 3790 sizeof(xmlNodePtr)); 3791 if (temp == NULL) { 3792 xmlXPathErrMemory(NULL, "growing nodeset\n"); 3793 return(-1); 3794 } 3795 cur->nodeTab = temp; 3796 cur->nodeMax *= 2; 3797 } 3798 if (val->type == XML_NAMESPACE_DECL) { 3799 xmlNsPtr ns = (xmlNsPtr) val; 3800 3801 cur->nodeTab[cur->nodeNr++] = 3802 xmlXPathNodeSetDupNs((xmlNodePtr) ns->next, ns); 3803 } else 3804 cur->nodeTab[cur->nodeNr++] = val; 3805 return(0); 3806 } 3807 3808 /** 3809 * xmlXPathNodeSetMerge: 3810 * @val1: the first NodeSet or NULL 3811 * @val2: the second NodeSet 3812 * 3813 * Merges two nodesets, all nodes from @val2 are added to @val1 3814 * if @val1 is NULL, a new set is created and copied from @val2 3815 * 3816 * Returns @val1 once extended or NULL in case of error. 3817 */ 3818 xmlNodeSetPtr 3819 xmlXPathNodeSetMerge(xmlNodeSetPtr val1, xmlNodeSetPtr val2) { 3820 int i, j, initNr, skip; 3821 xmlNodePtr n1, n2; 3822 3823 if (val2 == NULL) return(val1); 3824 if (val1 == NULL) { 3825 val1 = xmlXPathNodeSetCreate(NULL); 3826 if (val1 == NULL) 3827 return (NULL); 3828 #if 0 3829 /* 3830 * TODO: The optimization won't work in every case, since 3831 * those nasty namespace nodes need to be added with 3832 * xmlXPathNodeSetDupNs() to the set; thus a pure 3833 * memcpy is not possible. 3834 * If there was a flag on the nodesetval, indicating that 3835 * some temporary nodes are in, that would be helpfull. 3836 */ 3837 /* 3838 * Optimization: Create an equally sized node-set 3839 * and memcpy the content. 3840 */ 3841 val1 = xmlXPathNodeSetCreateSize(val2->nodeNr); 3842 if (val1 == NULL) 3843 return(NULL); 3844 if (val2->nodeNr != 0) { 3845 if (val2->nodeNr == 1) 3846 *(val1->nodeTab) = *(val2->nodeTab); 3847 else { 3848 memcpy(val1->nodeTab, val2->nodeTab, 3849 val2->nodeNr * sizeof(xmlNodePtr)); 3850 } 3851 val1->nodeNr = val2->nodeNr; 3852 } 3853 return(val1); 3854 #endif 3855 } 3856 3857 /* @@ with_ns to check whether namespace nodes should be looked at @@ */ 3858 initNr = val1->nodeNr; 3859 3860 for (i = 0;i < val2->nodeNr;i++) { 3861 n2 = val2->nodeTab[i]; 3862 /* 3863 * check against duplicates 3864 */ 3865 skip = 0; 3866 for (j = 0; j < initNr; j++) { 3867 n1 = val1->nodeTab[j]; 3868 if (n1 == n2) { 3869 skip = 1; 3870 break; 3871 } else if ((n1->type == XML_NAMESPACE_DECL) && 3872 (n2->type == XML_NAMESPACE_DECL)) { 3873 if ((((xmlNsPtr) n1)->next == ((xmlNsPtr) n2)->next) && 3874 (xmlStrEqual(((xmlNsPtr) n1)->prefix, 3875 ((xmlNsPtr) n2)->prefix))) 3876 { 3877 skip = 1; 3878 break; 3879 } 3880 } 3881 } 3882 if (skip) 3883 continue; 3884 3885 /* 3886 * grow the nodeTab if needed 3887 */ 3888 if (val1->nodeMax == 0) { 3889 val1->nodeTab = (xmlNodePtr *) xmlMalloc(XML_NODESET_DEFAULT * 3890 sizeof(xmlNodePtr)); 3891 if (val1->nodeTab == NULL) { 3892 xmlXPathErrMemory(NULL, "merging nodeset\n"); 3893 return(NULL); 3894 } 3895 memset(val1->nodeTab, 0 , 3896 XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr)); 3897 val1->nodeMax = XML_NODESET_DEFAULT; 3898 } else if (val1->nodeNr == val1->nodeMax) { 3899 xmlNodePtr *temp; 3900 3901 if (val1->nodeMax >= XPATH_MAX_NODESET_LENGTH) { 3902 xmlXPathErrMemory(NULL, "merging nodeset hit limit\n"); 3903 return(NULL); 3904 } 3905 temp = (xmlNodePtr *) xmlRealloc(val1->nodeTab, val1->nodeMax * 2 * 3906 sizeof(xmlNodePtr)); 3907 if (temp == NULL) { 3908 xmlXPathErrMemory(NULL, "merging nodeset\n"); 3909 return(NULL); 3910 } 3911 val1->nodeTab = temp; 3912 val1->nodeMax *= 2; 3913 } 3914 if (n2->type == XML_NAMESPACE_DECL) { 3915 xmlNsPtr ns = (xmlNsPtr) n2; 3916 3917 val1->nodeTab[val1->nodeNr++] = 3918 xmlXPathNodeSetDupNs((xmlNodePtr) ns->next, ns); 3919 } else 3920 val1->nodeTab[val1->nodeNr++] = n2; 3921 } 3922 3923 return(val1); 3924 } 3925 3926 3927 /** 3928 * xmlXPathNodeSetMergeAndClear: 3929 * @set1: the first NodeSet or NULL 3930 * @set2: the second NodeSet 3931 * @hasSet2NsNodes: 1 if set2 contains namespaces nodes 3932 * 3933 * Merges two nodesets, all nodes from @set2 are added to @set1 3934 * if @set1 is NULL, a new set is created and copied from @set2. 3935 * Checks for duplicate nodes. Clears set2. 3936 * 3937 * Returns @set1 once extended or NULL in case of error. 3938 */ 3939 static xmlNodeSetPtr 3940 xmlXPathNodeSetMergeAndClear(xmlNodeSetPtr set1, xmlNodeSetPtr set2, 3941 int hasNullEntries) 3942 { 3943 if ((set1 == NULL) && (hasNullEntries == 0)) { 3944 /* 3945 * Note that doing a memcpy of the list, namespace nodes are 3946 * just assigned to set1, since set2 is cleared anyway. 3947 */ 3948 set1 = xmlXPathNodeSetCreateSize(set2->nodeNr); 3949 if (set1 == NULL) 3950 return(NULL); 3951 if (set2->nodeNr != 0) { 3952 memcpy(set1->nodeTab, set2->nodeTab, 3953 set2->nodeNr * sizeof(xmlNodePtr)); 3954 set1->nodeNr = set2->nodeNr; 3955 } 3956 } else { 3957 int i, j, initNbSet1; 3958 xmlNodePtr n1, n2; 3959 3960 if (set1 == NULL) 3961 set1 = xmlXPathNodeSetCreate(NULL); 3962 if (set1 == NULL) 3963 return (NULL); 3964 3965 initNbSet1 = set1->nodeNr; 3966 for (i = 0;i < set2->nodeNr;i++) { 3967 n2 = set2->nodeTab[i]; 3968 /* 3969 * Skip NULLed entries. 3970 */ 3971 if (n2 == NULL) 3972 continue; 3973 /* 3974 * Skip duplicates. 3975 */ 3976 for (j = 0; j < initNbSet1; j++) { 3977 n1 = set1->nodeTab[j]; 3978 if (n1 == n2) { 3979 goto skip_node; 3980 } else if ((n1->type == XML_NAMESPACE_DECL) && 3981 (n2->type == XML_NAMESPACE_DECL)) 3982 { 3983 if ((((xmlNsPtr) n1)->next == ((xmlNsPtr) n2)->next) && 3984 (xmlStrEqual(((xmlNsPtr) n1)->prefix, 3985 ((xmlNsPtr) n2)->prefix))) 3986 { 3987 /* 3988 * Free the namespace node. 3989 */ 3990 set2->nodeTab[i] = NULL; 3991 xmlXPathNodeSetFreeNs((xmlNsPtr) n2); 3992 goto skip_node; 3993 } 3994 } 3995 } 3996 /* 3997 * grow the nodeTab if needed 3998 */ 3999 if (set1->nodeMax == 0) { 4000 set1->nodeTab = (xmlNodePtr *) xmlMalloc( 4001 XML_NODESET_DEFAULT * sizeof(xmlNodePtr)); 4002 if (set1->nodeTab == NULL) { 4003 xmlXPathErrMemory(NULL, "merging nodeset\n"); 4004 return(NULL); 4005 } 4006 memset(set1->nodeTab, 0, 4007 XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr)); 4008 set1->nodeMax = XML_NODESET_DEFAULT; 4009 } else if (set1->nodeNr >= set1->nodeMax) { 4010 xmlNodePtr *temp; 4011 4012 if (set1->nodeMax >= XPATH_MAX_NODESET_LENGTH) { 4013 xmlXPathErrMemory(NULL, "merging nodeset hit limit\n"); 4014 return(NULL); 4015 } 4016 temp = (xmlNodePtr *) xmlRealloc( 4017 set1->nodeTab, set1->nodeMax * 2 * sizeof(xmlNodePtr)); 4018 if (temp == NULL) { 4019 xmlXPathErrMemory(NULL, "merging nodeset\n"); 4020 return(NULL); 4021 } 4022 set1->nodeTab = temp; 4023 set1->nodeMax *= 2; 4024 } 4025 set1->nodeTab[set1->nodeNr++] = n2; 4026 skip_node: 4027 {} 4028 } 4029 } 4030 set2->nodeNr = 0; 4031 return(set1); 4032 } 4033 4034 /** 4035 * xmlXPathNodeSetMergeAndClearNoDupls: 4036 * @set1: the first NodeSet or NULL 4037 * @set2: the second NodeSet 4038 * @hasSet2NsNodes: 1 if set2 contains namespaces nodes 4039 * 4040 * Merges two nodesets, all nodes from @set2 are added to @set1 4041 * if @set1 is NULL, a new set is created and copied from @set2. 4042 * Doesn't chack for duplicate nodes. Clears set2. 4043 * 4044 * Returns @set1 once extended or NULL in case of error. 4045 */ 4046 static xmlNodeSetPtr 4047 xmlXPathNodeSetMergeAndClearNoDupls(xmlNodeSetPtr set1, xmlNodeSetPtr set2, 4048 int hasNullEntries) 4049 { 4050 if (set2 == NULL) 4051 return(set1); 4052 if ((set1 == NULL) && (hasNullEntries == 0)) { 4053 /* 4054 * Note that doing a memcpy of the list, namespace nodes are 4055 * just assigned to set1, since set2 is cleared anyway. 4056 */ 4057 set1 = xmlXPathNodeSetCreateSize(set2->nodeNr); 4058 if (set1 == NULL) 4059 return(NULL); 4060 if (set2->nodeNr != 0) { 4061 memcpy(set1->nodeTab, set2->nodeTab, 4062 set2->nodeNr * sizeof(xmlNodePtr)); 4063 set1->nodeNr = set2->nodeNr; 4064 } 4065 } else { 4066 int i; 4067 xmlNodePtr n2; 4068 4069 if (set1 == NULL) 4070 set1 = xmlXPathNodeSetCreate(NULL); 4071 if (set1 == NULL) 4072 return (NULL); 4073 4074 for (i = 0;i < set2->nodeNr;i++) { 4075 n2 = set2->nodeTab[i]; 4076 /* 4077 * Skip NULLed entries. 4078 */ 4079 if (n2 == NULL) 4080 continue; 4081 if (set1->nodeMax == 0) { 4082 set1->nodeTab = (xmlNodePtr *) xmlMalloc( 4083 XML_NODESET_DEFAULT * sizeof(xmlNodePtr)); 4084 if (set1->nodeTab == NULL) { 4085 xmlXPathErrMemory(NULL, "merging nodeset\n"); 4086 return(NULL); 4087 } 4088 memset(set1->nodeTab, 0, 4089 XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr)); 4090 set1->nodeMax = XML_NODESET_DEFAULT; 4091 } else if (set1->nodeNr >= set1->nodeMax) { 4092 xmlNodePtr *temp; 4093 4094 if (set1->nodeMax >= XPATH_MAX_NODESET_LENGTH) { 4095 xmlXPathErrMemory(NULL, "merging nodeset hit limit\n"); 4096 return(NULL); 4097 } 4098 temp = (xmlNodePtr *) xmlRealloc( 4099 set1->nodeTab, set1->nodeMax * 2 * sizeof(xmlNodePtr)); 4100 if (temp == NULL) { 4101 xmlXPathErrMemory(NULL, "merging nodeset\n"); 4102 return(NULL); 4103 } 4104 set1->nodeTab = temp; 4105 set1->nodeMax *= 2; 4106 } 4107 set1->nodeTab[set1->nodeNr++] = n2; 4108 } 4109 } 4110 set2->nodeNr = 0; 4111 return(set1); 4112 } 4113 4114 /** 4115 * xmlXPathNodeSetDel: 4116 * @cur: the initial node set 4117 * @val: an xmlNodePtr 4118 * 4119 * Removes an xmlNodePtr from an existing NodeSet 4120 */ 4121 void 4122 xmlXPathNodeSetDel(xmlNodeSetPtr cur, xmlNodePtr val) { 4123 int i; 4124 4125 if (cur == NULL) return; 4126 if (val == NULL) return; 4127 4128 /* 4129 * find node in nodeTab 4130 */ 4131 for (i = 0;i < cur->nodeNr;i++) 4132 if (cur->nodeTab[i] == val) break; 4133 4134 if (i >= cur->nodeNr) { /* not found */ 4135 #ifdef DEBUG 4136 xmlGenericError(xmlGenericErrorContext, 4137 "xmlXPathNodeSetDel: Node %s wasn't found in NodeList\n", 4138 val->name); 4139 #endif 4140 return; 4141 } 4142 if ((cur->nodeTab[i] != NULL) && 4143 (cur->nodeTab[i]->type == XML_NAMESPACE_DECL)) 4144 xmlXPathNodeSetFreeNs((xmlNsPtr) cur->nodeTab[i]); 4145 cur->nodeNr--; 4146 for (;i < cur->nodeNr;i++) 4147 cur->nodeTab[i] = cur->nodeTab[i + 1]; 4148 cur->nodeTab[cur->nodeNr] = NULL; 4149 } 4150 4151 /** 4152 * xmlXPathNodeSetRemove: 4153 * @cur: the initial node set 4154 * @val: the index to remove 4155 * 4156 * Removes an entry from an existing NodeSet list. 4157 */ 4158 void 4159 xmlXPathNodeSetRemove(xmlNodeSetPtr cur, int val) { 4160 if (cur == NULL) return; 4161 if (val >= cur->nodeNr) return; 4162 if ((cur->nodeTab[val] != NULL) && 4163 (cur->nodeTab[val]->type == XML_NAMESPACE_DECL)) 4164 xmlXPathNodeSetFreeNs((xmlNsPtr) cur->nodeTab[val]); 4165 cur->nodeNr--; 4166 for (;val < cur->nodeNr;val++) 4167 cur->nodeTab[val] = cur->nodeTab[val + 1]; 4168 cur->nodeTab[cur->nodeNr] = NULL; 4169 } 4170 4171 /** 4172 * xmlXPathFreeNodeSet: 4173 * @obj: the xmlNodeSetPtr to free 4174 * 4175 * Free the NodeSet compound (not the actual nodes !). 4176 */ 4177 void 4178 xmlXPathFreeNodeSet(xmlNodeSetPtr obj) { 4179 if (obj == NULL) return; 4180 if (obj->nodeTab != NULL) { 4181 int i; 4182 4183 /* @@ with_ns to check whether namespace nodes should be looked at @@ */ 4184 for (i = 0;i < obj->nodeNr;i++) 4185 if ((obj->nodeTab[i] != NULL) && 4186 (obj->nodeTab[i]->type == XML_NAMESPACE_DECL)) 4187 xmlXPathNodeSetFreeNs((xmlNsPtr) obj->nodeTab[i]); 4188 xmlFree(obj->nodeTab); 4189 } 4190 xmlFree(obj); 4191 } 4192 4193 /** 4194 * xmlXPathNodeSetClearFromPos: 4195 * @set: the node set to be cleared 4196 * @pos: the start position to clear from 4197 * 4198 * Clears the list from temporary XPath objects (e.g. namespace nodes 4199 * are feed) starting with the entry at @pos, but does *not* free the list 4200 * itself. Sets the length of the list to @pos. 4201 */ 4202 static void 4203 xmlXPathNodeSetClearFromPos(xmlNodeSetPtr set, int pos, int hasNsNodes) 4204 { 4205 if ((set == NULL) || (pos >= set->nodeNr)) 4206 return; 4207 else if ((hasNsNodes)) { 4208 int i; 4209 xmlNodePtr node; 4210 4211 for (i = pos; i < set->nodeNr; i++) { 4212 node = set->nodeTab[i]; 4213 if ((node != NULL) && 4214 (node->type == XML_NAMESPACE_DECL)) 4215 xmlXPathNodeSetFreeNs((xmlNsPtr) node); 4216 } 4217 } 4218 set->nodeNr = pos; 4219 } 4220 4221 /** 4222 * xmlXPathNodeSetClear: 4223 * @set: the node set to clear 4224 * 4225 * Clears the list from all temporary XPath objects (e.g. namespace nodes 4226 * are feed), but does *not* free the list itself. Sets the length of the 4227 * list to 0. 4228 */ 4229 static void 4230 xmlXPathNodeSetClear(xmlNodeSetPtr set, int hasNsNodes) 4231 { 4232 xmlXPathNodeSetClearFromPos(set, 0, hasNsNodes); 4233 } 4234 4235 /** 4236 * xmlXPathNodeSetKeepLast: 4237 * @set: the node set to be cleared 4238 * 4239 * Move the last node to the first position and clear temporary XPath objects 4240 * (e.g. namespace nodes) from all other nodes. Sets the length of the list 4241 * to 1. 4242 */ 4243 static void 4244 xmlXPathNodeSetKeepLast(xmlNodeSetPtr set) 4245 { 4246 int i; 4247 xmlNodePtr node; 4248 4249 if ((set == NULL) || (set->nodeNr <= 1)) 4250 return; 4251 for (i = 0; i < set->nodeNr - 1; i++) { 4252 node = set->nodeTab[i]; 4253 if ((node != NULL) && 4254 (node->type == XML_NAMESPACE_DECL)) 4255 xmlXPathNodeSetFreeNs((xmlNsPtr) node); 4256 } 4257 set->nodeTab[0] = set->nodeTab[set->nodeNr-1]; 4258 set->nodeNr = 1; 4259 } 4260 4261 /** 4262 * xmlXPathFreeValueTree: 4263 * @obj: the xmlNodeSetPtr to free 4264 * 4265 * Free the NodeSet compound and the actual tree, this is different 4266 * from xmlXPathFreeNodeSet() 4267 */ 4268 static void 4269 xmlXPathFreeValueTree(xmlNodeSetPtr obj) { 4270 int i; 4271 4272 if (obj == NULL) return; 4273 4274 if (obj->nodeTab != NULL) { 4275 for (i = 0;i < obj->nodeNr;i++) { 4276 if (obj->nodeTab[i] != NULL) { 4277 if (obj->nodeTab[i]->type == XML_NAMESPACE_DECL) { 4278 xmlXPathNodeSetFreeNs((xmlNsPtr) obj->nodeTab[i]); 4279 } else { 4280 xmlFreeNodeList(obj->nodeTab[i]); 4281 } 4282 } 4283 } 4284 xmlFree(obj->nodeTab); 4285 } 4286 xmlFree(obj); 4287 } 4288 4289 #if defined(DEBUG) || defined(DEBUG_STEP) 4290 /** 4291 * xmlGenericErrorContextNodeSet: 4292 * @output: a FILE * for the output 4293 * @obj: the xmlNodeSetPtr to display 4294 * 4295 * Quick display of a NodeSet 4296 */ 4297 void 4298 xmlGenericErrorContextNodeSet(FILE *output, xmlNodeSetPtr obj) { 4299 int i; 4300 4301 if (output == NULL) output = xmlGenericErrorContext; 4302 if (obj == NULL) { 4303 fprintf(output, "NodeSet == NULL !\n"); 4304 return; 4305 } 4306 if (obj->nodeNr == 0) { 4307 fprintf(output, "NodeSet is empty\n"); 4308 return; 4309 } 4310 if (obj->nodeTab == NULL) { 4311 fprintf(output, " nodeTab == NULL !\n"); 4312 return; 4313 } 4314 for (i = 0; i < obj->nodeNr; i++) { 4315 if (obj->nodeTab[i] == NULL) { 4316 fprintf(output, " NULL !\n"); 4317 return; 4318 } 4319 if ((obj->nodeTab[i]->type == XML_DOCUMENT_NODE) || 4320 (obj->nodeTab[i]->type == XML_HTML_DOCUMENT_NODE)) 4321 fprintf(output, " /"); 4322 else if (obj->nodeTab[i]->name == NULL) 4323 fprintf(output, " noname!"); 4324 else fprintf(output, " %s", obj->nodeTab[i]->name); 4325 } 4326 fprintf(output, "\n"); 4327 } 4328 #endif 4329 4330 /** 4331 * xmlXPathNewNodeSet: 4332 * @val: the NodePtr value 4333 * 4334 * Create a new xmlXPathObjectPtr of type NodeSet and initialize 4335 * it with the single Node @val 4336 * 4337 * Returns the newly created object. 4338 */ 4339 xmlXPathObjectPtr 4340 xmlXPathNewNodeSet(xmlNodePtr val) { 4341 xmlXPathObjectPtr ret; 4342 4343 ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject)); 4344 if (ret == NULL) { 4345 xmlXPathErrMemory(NULL, "creating nodeset\n"); 4346 return(NULL); 4347 } 4348 memset(ret, 0 , (size_t) sizeof(xmlXPathObject)); 4349 ret->type = XPATH_NODESET; 4350 ret->boolval = 0; 4351 ret->nodesetval = xmlXPathNodeSetCreate(val); 4352 /* @@ with_ns to check whether namespace nodes should be looked at @@ */ 4353 #ifdef XP_DEBUG_OBJ_USAGE 4354 xmlXPathDebugObjUsageRequested(NULL, XPATH_NODESET); 4355 #endif 4356 return(ret); 4357 } 4358 4359 /** 4360 * xmlXPathNewValueTree: 4361 * @val: the NodePtr value 4362 * 4363 * Create a new xmlXPathObjectPtr of type Value Tree (XSLT) and initialize 4364 * it with the tree root @val 4365 * 4366 * Returns the newly created object. 4367 */ 4368 xmlXPathObjectPtr 4369 xmlXPathNewValueTree(xmlNodePtr val) { 4370 xmlXPathObjectPtr ret; 4371 4372 ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject)); 4373 if (ret == NULL) { 4374 xmlXPathErrMemory(NULL, "creating result value tree\n"); 4375 return(NULL); 4376 } 4377 memset(ret, 0 , (size_t) sizeof(xmlXPathObject)); 4378 ret->type = XPATH_XSLT_TREE; 4379 ret->boolval = 0; 4380 ret->user = (void *) val; 4381 ret->nodesetval = xmlXPathNodeSetCreate(val); 4382 #ifdef XP_DEBUG_OBJ_USAGE 4383 xmlXPathDebugObjUsageRequested(NULL, XPATH_XSLT_TREE); 4384 #endif 4385 return(ret); 4386 } 4387 4388 /** 4389 * xmlXPathNewNodeSetList: 4390 * @val: an existing NodeSet 4391 * 4392 * Create a new xmlXPathObjectPtr of type NodeSet and initialize 4393 * it with the Nodeset @val 4394 * 4395 * Returns the newly created object. 4396 */ 4397 xmlXPathObjectPtr 4398 xmlXPathNewNodeSetList(xmlNodeSetPtr val) 4399 { 4400 xmlXPathObjectPtr ret; 4401 int i; 4402 4403 if (val == NULL) 4404 ret = NULL; 4405 else if (val->nodeTab == NULL) 4406 ret = xmlXPathNewNodeSet(NULL); 4407 else { 4408 ret = xmlXPathNewNodeSet(val->nodeTab[0]); 4409 if (ret) { 4410 for (i = 1; i < val->nodeNr; ++i) { 4411 if (xmlXPathNodeSetAddUnique(ret->nodesetval, val->nodeTab[i]) 4412 < 0) break; 4413 } 4414 } 4415 } 4416 4417 return (ret); 4418 } 4419 4420 /** 4421 * xmlXPathWrapNodeSet: 4422 * @val: the NodePtr value 4423 * 4424 * Wrap the Nodeset @val in a new xmlXPathObjectPtr 4425 * 4426 * Returns the newly created object. 4427 */ 4428 xmlXPathObjectPtr 4429 xmlXPathWrapNodeSet(xmlNodeSetPtr val) { 4430 xmlXPathObjectPtr ret; 4431 4432 ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject)); 4433 if (ret == NULL) { 4434 xmlXPathErrMemory(NULL, "creating node set object\n"); 4435 return(NULL); 4436 } 4437 memset(ret, 0 , (size_t) sizeof(xmlXPathObject)); 4438 ret->type = XPATH_NODESET; 4439 ret->nodesetval = val; 4440 #ifdef XP_DEBUG_OBJ_USAGE 4441 xmlXPathDebugObjUsageRequested(NULL, XPATH_NODESET); 4442 #endif 4443 return(ret); 4444 } 4445 4446 /** 4447 * xmlXPathFreeNodeSetList: 4448 * @obj: an existing NodeSetList object 4449 * 4450 * Free up the xmlXPathObjectPtr @obj but don't deallocate the objects in 4451 * the list contrary to xmlXPathFreeObject(). 4452 */ 4453 void 4454 xmlXPathFreeNodeSetList(xmlXPathObjectPtr obj) { 4455 if (obj == NULL) return; 4456 #ifdef XP_DEBUG_OBJ_USAGE 4457 xmlXPathDebugObjUsageReleased(NULL, obj->type); 4458 #endif 4459 xmlFree(obj); 4460 } 4461 4462 /** 4463 * xmlXPathDifference: 4464 * @nodes1: a node-set 4465 * @nodes2: a node-set 4466 * 4467 * Implements the EXSLT - Sets difference() function: 4468 * node-set set:difference (node-set, node-set) 4469 * 4470 * Returns the difference between the two node sets, or nodes1 if 4471 * nodes2 is empty 4472 */ 4473 xmlNodeSetPtr 4474 xmlXPathDifference (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) { 4475 xmlNodeSetPtr ret; 4476 int i, l1; 4477 xmlNodePtr cur; 4478 4479 if (xmlXPathNodeSetIsEmpty(nodes2)) 4480 return(nodes1); 4481 4482 ret = xmlXPathNodeSetCreate(NULL); 4483 if (xmlXPathNodeSetIsEmpty(nodes1)) 4484 return(ret); 4485 4486 l1 = xmlXPathNodeSetGetLength(nodes1); 4487 4488 for (i = 0; i < l1; i++) { 4489 cur = xmlXPathNodeSetItem(nodes1, i); 4490 if (!xmlXPathNodeSetContains(nodes2, cur)) { 4491 if (xmlXPathNodeSetAddUnique(ret, cur) < 0) 4492 break; 4493 } 4494 } 4495 return(ret); 4496 } 4497 4498 /** 4499 * xmlXPathIntersection: 4500 * @nodes1: a node-set 4501 * @nodes2: a node-set 4502 * 4503 * Implements the EXSLT - Sets intersection() function: 4504 * node-set set:intersection (node-set, node-set) 4505 * 4506 * Returns a node set comprising the nodes that are within both the 4507 * node sets passed as arguments 4508 */ 4509 xmlNodeSetPtr 4510 xmlXPathIntersection (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) { 4511 xmlNodeSetPtr ret = xmlXPathNodeSetCreate(NULL); 4512 int i, l1; 4513 xmlNodePtr cur; 4514 4515 if (ret == NULL) 4516 return(ret); 4517 if (xmlXPathNodeSetIsEmpty(nodes1)) 4518 return(ret); 4519 if (xmlXPathNodeSetIsEmpty(nodes2)) 4520 return(ret); 4521 4522 l1 = xmlXPathNodeSetGetLength(nodes1); 4523 4524 for (i = 0; i < l1; i++) { 4525 cur = xmlXPathNodeSetItem(nodes1, i); 4526 if (xmlXPathNodeSetContains(nodes2, cur)) { 4527 if (xmlXPathNodeSetAddUnique(ret, cur) < 0) 4528 break; 4529 } 4530 } 4531 return(ret); 4532 } 4533 4534 /** 4535 * xmlXPathDistinctSorted: 4536 * @nodes: a node-set, sorted by document order 4537 * 4538 * Implements the EXSLT - Sets distinct() function: 4539 * node-set set:distinct (node-set) 4540 * 4541 * Returns a subset of the nodes contained in @nodes, or @nodes if 4542 * it is empty 4543 */ 4544 xmlNodeSetPtr 4545 xmlXPathDistinctSorted (xmlNodeSetPtr nodes) { 4546 xmlNodeSetPtr ret; 4547 xmlHashTablePtr hash; 4548 int i, l; 4549 xmlChar * strval; 4550 xmlNodePtr cur; 4551 4552 if (xmlXPathNodeSetIsEmpty(nodes)) 4553 return(nodes); 4554 4555 ret = xmlXPathNodeSetCreate(NULL); 4556 if (ret == NULL) 4557 return(ret); 4558 l = xmlXPathNodeSetGetLength(nodes); 4559 hash = xmlHashCreate (l); 4560 for (i = 0; i < l; i++) { 4561 cur = xmlXPathNodeSetItem(nodes, i); 4562 strval = xmlXPathCastNodeToString(cur); 4563 if (xmlHashLookup(hash, strval) == NULL) { 4564 xmlHashAddEntry(hash, strval, strval); 4565 if (xmlXPathNodeSetAddUnique(ret, cur) < 0) 4566 break; 4567 } else { 4568 xmlFree(strval); 4569 } 4570 } 4571 xmlHashFree(hash, xmlHashDefaultDeallocator); 4572 return(ret); 4573 } 4574 4575 /** 4576 * xmlXPathDistinct: 4577 * @nodes: a node-set 4578 * 4579 * Implements the EXSLT - Sets distinct() function: 4580 * node-set set:distinct (node-set) 4581 * @nodes is sorted by document order, then #exslSetsDistinctSorted 4582 * is called with the sorted node-set 4583 * 4584 * Returns a subset of the nodes contained in @nodes, or @nodes if 4585 * it is empty 4586 */ 4587 xmlNodeSetPtr 4588 xmlXPathDistinct (xmlNodeSetPtr nodes) { 4589 if (xmlXPathNodeSetIsEmpty(nodes)) 4590 return(nodes); 4591 4592 xmlXPathNodeSetSort(nodes); 4593 return(xmlXPathDistinctSorted(nodes)); 4594 } 4595 4596 /** 4597 * xmlXPathHasSameNodes: 4598 * @nodes1: a node-set 4599 * @nodes2: a node-set 4600 * 4601 * Implements the EXSLT - Sets has-same-nodes function: 4602 * boolean set:has-same-node(node-set, node-set) 4603 * 4604 * Returns true (1) if @nodes1 shares any node with @nodes2, false (0) 4605 * otherwise 4606 */ 4607 int 4608 xmlXPathHasSameNodes (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) { 4609 int i, l; 4610 xmlNodePtr cur; 4611 4612 if (xmlXPathNodeSetIsEmpty(nodes1) || 4613 xmlXPathNodeSetIsEmpty(nodes2)) 4614 return(0); 4615 4616 l = xmlXPathNodeSetGetLength(nodes1); 4617 for (i = 0; i < l; i++) { 4618 cur = xmlXPathNodeSetItem(nodes1, i); 4619 if (xmlXPathNodeSetContains(nodes2, cur)) 4620 return(1); 4621 } 4622 return(0); 4623 } 4624 4625 /** 4626 * xmlXPathNodeLeadingSorted: 4627 * @nodes: a node-set, sorted by document order 4628 * @node: a node 4629 * 4630 * Implements the EXSLT - Sets leading() function: 4631 * node-set set:leading (node-set, node-set) 4632 * 4633 * Returns the nodes in @nodes that precede @node in document order, 4634 * @nodes if @node is NULL or an empty node-set if @nodes 4635 * doesn't contain @node 4636 */ 4637 xmlNodeSetPtr 4638 xmlXPathNodeLeadingSorted (xmlNodeSetPtr nodes, xmlNodePtr node) { 4639 int i, l; 4640 xmlNodePtr cur; 4641 xmlNodeSetPtr ret; 4642 4643 if (node == NULL) 4644 return(nodes); 4645 4646 ret = xmlXPathNodeSetCreate(NULL); 4647 if (ret == NULL) 4648 return(ret); 4649 if (xmlXPathNodeSetIsEmpty(nodes) || 4650 (!xmlXPathNodeSetContains(nodes, node))) 4651 return(ret); 4652 4653 l = xmlXPathNodeSetGetLength(nodes); 4654 for (i = 0; i < l; i++) { 4655 cur = xmlXPathNodeSetItem(nodes, i); 4656 if (cur == node) 4657 break; 4658 if (xmlXPathNodeSetAddUnique(ret, cur) < 0) 4659 break; 4660 } 4661 return(ret); 4662 } 4663 4664 /** 4665 * xmlXPathNodeLeading: 4666 * @nodes: a node-set 4667 * @node: a node 4668 * 4669 * Implements the EXSLT - Sets leading() function: 4670 * node-set set:leading (node-set, node-set) 4671 * @nodes is sorted by document order, then #exslSetsNodeLeadingSorted 4672 * is called. 4673 * 4674 * Returns the nodes in @nodes that precede @node in document order, 4675 * @nodes if @node is NULL or an empty node-set if @nodes 4676 * doesn't contain @node 4677 */ 4678 xmlNodeSetPtr 4679 xmlXPathNodeLeading (xmlNodeSetPtr nodes, xmlNodePtr node) { 4680 xmlXPathNodeSetSort(nodes); 4681 return(xmlXPathNodeLeadingSorted(nodes, node)); 4682 } 4683 4684 /** 4685 * xmlXPathLeadingSorted: 4686 * @nodes1: a node-set, sorted by document order 4687 * @nodes2: a node-set, sorted by document order 4688 * 4689 * Implements the EXSLT - Sets leading() function: 4690 * node-set set:leading (node-set, node-set) 4691 * 4692 * Returns the nodes in @nodes1 that precede the first node in @nodes2 4693 * in document order, @nodes1 if @nodes2 is NULL or empty or 4694 * an empty node-set if @nodes1 doesn't contain @nodes2 4695 */ 4696 xmlNodeSetPtr 4697 xmlXPathLeadingSorted (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) { 4698 if (xmlXPathNodeSetIsEmpty(nodes2)) 4699 return(nodes1); 4700 return(xmlXPathNodeLeadingSorted(nodes1, 4701 xmlXPathNodeSetItem(nodes2, 1))); 4702 } 4703 4704 /** 4705 * xmlXPathLeading: 4706 * @nodes1: a node-set 4707 * @nodes2: a node-set 4708 * 4709 * Implements the EXSLT - Sets leading() function: 4710 * node-set set:leading (node-set, node-set) 4711 * @nodes1 and @nodes2 are sorted by document order, then 4712 * #exslSetsLeadingSorted is called. 4713 * 4714 * Returns the nodes in @nodes1 that precede the first node in @nodes2 4715 * in document order, @nodes1 if @nodes2 is NULL or empty or 4716 * an empty node-set if @nodes1 doesn't contain @nodes2 4717 */ 4718 xmlNodeSetPtr 4719 xmlXPathLeading (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) { 4720 if (xmlXPathNodeSetIsEmpty(nodes2)) 4721 return(nodes1); 4722 if (xmlXPathNodeSetIsEmpty(nodes1)) 4723 return(xmlXPathNodeSetCreate(NULL)); 4724 xmlXPathNodeSetSort(nodes1); 4725 xmlXPathNodeSetSort(nodes2); 4726 return(xmlXPathNodeLeadingSorted(nodes1, 4727 xmlXPathNodeSetItem(nodes2, 1))); 4728 } 4729 4730 /** 4731 * xmlXPathNodeTrailingSorted: 4732 * @nodes: a node-set, sorted by document order 4733 * @node: a node 4734 * 4735 * Implements the EXSLT - Sets trailing() function: 4736 * node-set set:trailing (node-set, node-set) 4737 * 4738 * Returns the nodes in @nodes that follow @node in document order, 4739 * @nodes if @node is NULL or an empty node-set if @nodes 4740 * doesn't contain @node 4741 */ 4742 xmlNodeSetPtr 4743 xmlXPathNodeTrailingSorted (xmlNodeSetPtr nodes, xmlNodePtr node) { 4744 int i, l; 4745 xmlNodePtr cur; 4746 xmlNodeSetPtr ret; 4747 4748 if (node == NULL) 4749 return(nodes); 4750 4751 ret = xmlXPathNodeSetCreate(NULL); 4752 if (ret == NULL) 4753 return(ret); 4754 if (xmlXPathNodeSetIsEmpty(nodes) || 4755 (!xmlXPathNodeSetContains(nodes, node))) 4756 return(ret); 4757 4758 l = xmlXPathNodeSetGetLength(nodes); 4759 for (i = l - 1; i >= 0; i--) { 4760 cur = xmlXPathNodeSetItem(nodes, i); 4761 if (cur == node) 4762 break; 4763 if (xmlXPathNodeSetAddUnique(ret, cur) < 0) 4764 break; 4765 } 4766 xmlXPathNodeSetSort(ret); /* bug 413451 */ 4767 return(ret); 4768 } 4769 4770 /** 4771 * xmlXPathNodeTrailing: 4772 * @nodes: a node-set 4773 * @node: a node 4774 * 4775 * Implements the EXSLT - Sets trailing() function: 4776 * node-set set:trailing (node-set, node-set) 4777 * @nodes is sorted by document order, then #xmlXPathNodeTrailingSorted 4778 * is called. 4779 * 4780 * Returns the nodes in @nodes that follow @node in document order, 4781 * @nodes if @node is NULL or an empty node-set if @nodes 4782 * doesn't contain @node 4783 */ 4784 xmlNodeSetPtr 4785 xmlXPathNodeTrailing (xmlNodeSetPtr nodes, xmlNodePtr node) { 4786 xmlXPathNodeSetSort(nodes); 4787 return(xmlXPathNodeTrailingSorted(nodes, node)); 4788 } 4789 4790 /** 4791 * xmlXPathTrailingSorted: 4792 * @nodes1: a node-set, sorted by document order 4793 * @nodes2: a node-set, sorted by document order 4794 * 4795 * Implements the EXSLT - Sets trailing() function: 4796 * node-set set:trailing (node-set, node-set) 4797 * 4798 * Returns the nodes in @nodes1 that follow the first node in @nodes2 4799 * in document order, @nodes1 if @nodes2 is NULL or empty or 4800 * an empty node-set if @nodes1 doesn't contain @nodes2 4801 */ 4802 xmlNodeSetPtr 4803 xmlXPathTrailingSorted (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) { 4804 if (xmlXPathNodeSetIsEmpty(nodes2)) 4805 return(nodes1); 4806 return(xmlXPathNodeTrailingSorted(nodes1, 4807 xmlXPathNodeSetItem(nodes2, 0))); 4808 } 4809 4810 /** 4811 * xmlXPathTrailing: 4812 * @nodes1: a node-set 4813 * @nodes2: a node-set 4814 * 4815 * Implements the EXSLT - Sets trailing() function: 4816 * node-set set:trailing (node-set, node-set) 4817 * @nodes1 and @nodes2 are sorted by document order, then 4818 * #xmlXPathTrailingSorted is called. 4819 * 4820 * Returns the nodes in @nodes1 that follow the first node in @nodes2 4821 * in document order, @nodes1 if @nodes2 is NULL or empty or 4822 * an empty node-set if @nodes1 doesn't contain @nodes2 4823 */ 4824 xmlNodeSetPtr 4825 xmlXPathTrailing (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) { 4826 if (xmlXPathNodeSetIsEmpty(nodes2)) 4827 return(nodes1); 4828 if (xmlXPathNodeSetIsEmpty(nodes1)) 4829 return(xmlXPathNodeSetCreate(NULL)); 4830 xmlXPathNodeSetSort(nodes1); 4831 xmlXPathNodeSetSort(nodes2); 4832 return(xmlXPathNodeTrailingSorted(nodes1, 4833 xmlXPathNodeSetItem(nodes2, 0))); 4834 } 4835 4836 /************************************************************************ 4837 * * 4838 * Routines to handle extra functions * 4839 * * 4840 ************************************************************************/ 4841 4842 /** 4843 * xmlXPathRegisterFunc: 4844 * @ctxt: the XPath context 4845 * @name: the function name 4846 * @f: the function implementation or NULL 4847 * 4848 * Register a new function. If @f is NULL it unregisters the function 4849 * 4850 * Returns 0 in case of success, -1 in case of error 4851 */ 4852 int 4853 xmlXPathRegisterFunc(xmlXPathContextPtr ctxt, const xmlChar *name, 4854 xmlXPathFunction f) { 4855 return(xmlXPathRegisterFuncNS(ctxt, name, NULL, f)); 4856 } 4857 4858 /** 4859 * xmlXPathRegisterFuncNS: 4860 * @ctxt: the XPath context 4861 * @name: the function name 4862 * @ns_uri: the function namespace URI 4863 * @f: the function implementation or NULL 4864 * 4865 * Register a new function. If @f is NULL it unregisters the function 4866 * 4867 * Returns 0 in case of success, -1 in case of error 4868 */ 4869 int 4870 xmlXPathRegisterFuncNS(xmlXPathContextPtr ctxt, const xmlChar *name, 4871 const xmlChar *ns_uri, xmlXPathFunction f) { 4872 if (ctxt == NULL) 4873 return(-1); 4874 if (name == NULL) 4875 return(-1); 4876 4877 if (ctxt->funcHash == NULL) 4878 ctxt->funcHash = xmlHashCreate(0); 4879 if (ctxt->funcHash == NULL) 4880 return(-1); 4881 if (f == NULL) 4882 return(xmlHashRemoveEntry2(ctxt->funcHash, name, ns_uri, NULL)); 4883 XML_IGNORE_PEDANTIC_WARNINGS 4884 return(xmlHashAddEntry2(ctxt->funcHash, name, ns_uri, (void *) f)); 4885 XML_POP_WARNINGS 4886 } 4887 4888 /** 4889 * xmlXPathRegisterFuncLookup: 4890 * @ctxt: the XPath context 4891 * @f: the lookup function 4892 * @funcCtxt: the lookup data 4893 * 4894 * Registers an external mechanism to do function lookup. 4895 */ 4896 void 4897 xmlXPathRegisterFuncLookup (xmlXPathContextPtr ctxt, 4898 xmlXPathFuncLookupFunc f, 4899 void *funcCtxt) { 4900 if (ctxt == NULL) 4901 return; 4902 ctxt->funcLookupFunc = f; 4903 ctxt->funcLookupData = funcCtxt; 4904 } 4905 4906 /** 4907 * xmlXPathFunctionLookup: 4908 * @ctxt: the XPath context 4909 * @name: the function name 4910 * 4911 * Search in the Function array of the context for the given 4912 * function. 4913 * 4914 * Returns the xmlXPathFunction or NULL if not found 4915 */ 4916 xmlXPathFunction 4917 xmlXPathFunctionLookup(xmlXPathContextPtr ctxt, const xmlChar *name) { 4918 if (ctxt == NULL) 4919 return (NULL); 4920 4921 if (ctxt->funcLookupFunc != NULL) { 4922 xmlXPathFunction ret; 4923 xmlXPathFuncLookupFunc f; 4924 4925 f = ctxt->funcLookupFunc; 4926 ret = f(ctxt->funcLookupData, name, NULL); 4927 if (ret != NULL) 4928 return(ret); 4929 } 4930 return(xmlXPathFunctionLookupNS(ctxt, name, NULL)); 4931 } 4932 4933 /** 4934 * xmlXPathFunctionLookupNS: 4935 * @ctxt: the XPath context 4936 * @name: the function name 4937 * @ns_uri: the function namespace URI 4938 * 4939 * Search in the Function array of the context for the given 4940 * function. 4941 * 4942 * Returns the xmlXPathFunction or NULL if not found 4943 */ 4944 xmlXPathFunction 4945 xmlXPathFunctionLookupNS(xmlXPathContextPtr ctxt, const xmlChar *name, 4946 const xmlChar *ns_uri) { 4947 xmlXPathFunction ret; 4948 4949 if (ctxt == NULL) 4950 return(NULL); 4951 if (name == NULL) 4952 return(NULL); 4953 4954 if (ctxt->funcLookupFunc != NULL) { 4955 xmlXPathFuncLookupFunc f; 4956 4957 f = ctxt->funcLookupFunc; 4958 ret = f(ctxt->funcLookupData, name, ns_uri); 4959 if (ret != NULL) 4960 return(ret); 4961 } 4962 4963 if (ctxt->funcHash == NULL) 4964 return(NULL); 4965 4966 XML_IGNORE_PEDANTIC_WARNINGS 4967 ret = (xmlXPathFunction) xmlHashLookup2(ctxt->funcHash, name, ns_uri); 4968 XML_POP_WARNINGS 4969 return(ret); 4970 } 4971 4972 /** 4973 * xmlXPathRegisteredFuncsCleanup: 4974 * @ctxt: the XPath context 4975 * 4976 * Cleanup the XPath context data associated to registered functions 4977 */ 4978 void 4979 xmlXPathRegisteredFuncsCleanup(xmlXPathContextPtr ctxt) { 4980 if (ctxt == NULL) 4981 return; 4982 4983 xmlHashFree(ctxt->funcHash, NULL); 4984 ctxt->funcHash = NULL; 4985 } 4986 4987 /************************************************************************ 4988 * * 4989 * Routines to handle Variables * 4990 * * 4991 ************************************************************************/ 4992 4993 /** 4994 * xmlXPathRegisterVariable: 4995 * @ctxt: the XPath context 4996 * @name: the variable name 4997 * @value: the variable value or NULL 4998 * 4999 * Register a new variable value. If @value is NULL it unregisters 5000 * the variable 5001 * 5002 * Returns 0 in case of success, -1 in case of error 5003 */ 5004 int 5005 xmlXPathRegisterVariable(xmlXPathContextPtr ctxt, const xmlChar *name, 5006 xmlXPathObjectPtr value) { 5007 return(xmlXPathRegisterVariableNS(ctxt, name, NULL, value)); 5008 } 5009 5010 /** 5011 * xmlXPathRegisterVariableNS: 5012 * @ctxt: the XPath context 5013 * @name: the variable name 5014 * @ns_uri: the variable namespace URI 5015 * @value: the variable value or NULL 5016 * 5017 * Register a new variable value. If @value is NULL it unregisters 5018 * the variable 5019 * 5020 * Returns 0 in case of success, -1 in case of error 5021 */ 5022 int 5023 xmlXPathRegisterVariableNS(xmlXPathContextPtr ctxt, const xmlChar *name, 5024 const xmlChar *ns_uri, 5025 xmlXPathObjectPtr value) { 5026 if (ctxt == NULL) 5027 return(-1); 5028 if (name == NULL) 5029 return(-1); 5030 5031 if (ctxt->varHash == NULL) 5032 ctxt->varHash = xmlHashCreate(0); 5033 if (ctxt->varHash == NULL) 5034 return(-1); 5035 if (value == NULL) 5036 return(xmlHashRemoveEntry2(ctxt->varHash, name, ns_uri, 5037 xmlXPathFreeObjectEntry)); 5038 return(xmlHashUpdateEntry2(ctxt->varHash, name, ns_uri, 5039 (void *) value, xmlXPathFreeObjectEntry)); 5040 } 5041 5042 /** 5043 * xmlXPathRegisterVariableLookup: 5044 * @ctxt: the XPath context 5045 * @f: the lookup function 5046 * @data: the lookup data 5047 * 5048 * register an external mechanism to do variable lookup 5049 */ 5050 void 5051 xmlXPathRegisterVariableLookup(xmlXPathContextPtr ctxt, 5052 xmlXPathVariableLookupFunc f, void *data) { 5053 if (ctxt == NULL) 5054 return; 5055 ctxt->varLookupFunc = f; 5056 ctxt->varLookupData = data; 5057 } 5058 5059 /** 5060 * xmlXPathVariableLookup: 5061 * @ctxt: the XPath context 5062 * @name: the variable name 5063 * 5064 * Search in the Variable array of the context for the given 5065 * variable value. 5066 * 5067 * Returns a copy of the value or NULL if not found 5068 */ 5069 xmlXPathObjectPtr 5070 xmlXPathVariableLookup(xmlXPathContextPtr ctxt, const xmlChar *name) { 5071 if (ctxt == NULL) 5072 return(NULL); 5073 5074 if (ctxt->varLookupFunc != NULL) { 5075 xmlXPathObjectPtr ret; 5076 5077 ret = ((xmlXPathVariableLookupFunc)ctxt->varLookupFunc) 5078 (ctxt->varLookupData, name, NULL); 5079 return(ret); 5080 } 5081 return(xmlXPathVariableLookupNS(ctxt, name, NULL)); 5082 } 5083 5084 /** 5085 * xmlXPathVariableLookupNS: 5086 * @ctxt: the XPath context 5087 * @name: the variable name 5088 * @ns_uri: the variable namespace URI 5089 * 5090 * Search in the Variable array of the context for the given 5091 * variable value. 5092 * 5093 * Returns the a copy of the value or NULL if not found 5094 */ 5095 xmlXPathObjectPtr 5096 xmlXPathVariableLookupNS(xmlXPathContextPtr ctxt, const xmlChar *name, 5097 const xmlChar *ns_uri) { 5098 if (ctxt == NULL) 5099 return(NULL); 5100 5101 if (ctxt->varLookupFunc != NULL) { 5102 xmlXPathObjectPtr ret; 5103 5104 ret = ((xmlXPathVariableLookupFunc)ctxt->varLookupFunc) 5105 (ctxt->varLookupData, name, ns_uri); 5106 if (ret != NULL) return(ret); 5107 } 5108 5109 if (ctxt->varHash == NULL) 5110 return(NULL); 5111 if (name == NULL) 5112 return(NULL); 5113 5114 return(xmlXPathCacheObjectCopy(ctxt, (xmlXPathObjectPtr) 5115 xmlHashLookup2(ctxt->varHash, name, ns_uri))); 5116 } 5117 5118 /** 5119 * xmlXPathRegisteredVariablesCleanup: 5120 * @ctxt: the XPath context 5121 * 5122 * Cleanup the XPath context data associated to registered variables 5123 */ 5124 void 5125 xmlXPathRegisteredVariablesCleanup(xmlXPathContextPtr ctxt) { 5126 if (ctxt == NULL) 5127 return; 5128 5129 xmlHashFree(ctxt->varHash, xmlXPathFreeObjectEntry); 5130 ctxt->varHash = NULL; 5131 } 5132 5133 /** 5134 * xmlXPathRegisterNs: 5135 * @ctxt: the XPath context 5136 * @prefix: the namespace prefix cannot be NULL or empty string 5137 * @ns_uri: the namespace name 5138 * 5139 * Register a new namespace. If @ns_uri is NULL it unregisters 5140 * the namespace 5141 * 5142 * Returns 0 in case of success, -1 in case of error 5143 */ 5144 int 5145 xmlXPathRegisterNs(xmlXPathContextPtr ctxt, const xmlChar *prefix, 5146 const xmlChar *ns_uri) { 5147 if (ctxt == NULL) 5148 return(-1); 5149 if (prefix == NULL) 5150 return(-1); 5151 if (prefix[0] == 0) 5152 return(-1); 5153 5154 if (ctxt->nsHash == NULL) 5155 ctxt->nsHash = xmlHashCreate(10); 5156 if (ctxt->nsHash == NULL) 5157 return(-1); 5158 if (ns_uri == NULL) 5159 return(xmlHashRemoveEntry(ctxt->nsHash, prefix, 5160 xmlHashDefaultDeallocator)); 5161 return(xmlHashUpdateEntry(ctxt->nsHash, prefix, (void *) xmlStrdup(ns_uri), 5162 xmlHashDefaultDeallocator)); 5163 } 5164 5165 /** 5166 * xmlXPathNsLookup: 5167 * @ctxt: the XPath context 5168 * @prefix: the namespace prefix value 5169 * 5170 * Search in the namespace declaration array of the context for the given 5171 * namespace name associated to the given prefix 5172 * 5173 * Returns the value or NULL if not found 5174 */ 5175 const xmlChar * 5176 xmlXPathNsLookup(xmlXPathContextPtr ctxt, const xmlChar *prefix) { 5177 if (ctxt == NULL) 5178 return(NULL); 5179 if (prefix == NULL) 5180 return(NULL); 5181 5182 #ifdef XML_XML_NAMESPACE 5183 if (xmlStrEqual(prefix, (const xmlChar *) "xml")) 5184 return(XML_XML_NAMESPACE); 5185 #endif 5186 5187 if (ctxt->namespaces != NULL) { 5188 int i; 5189 5190 for (i = 0;i < ctxt->nsNr;i++) { 5191 if ((ctxt->namespaces[i] != NULL) && 5192 (xmlStrEqual(ctxt->namespaces[i]->prefix, prefix))) 5193 return(ctxt->namespaces[i]->href); 5194 } 5195 } 5196 5197 return((const xmlChar *) xmlHashLookup(ctxt->nsHash, prefix)); 5198 } 5199 5200 /** 5201 * xmlXPathRegisteredNsCleanup: 5202 * @ctxt: the XPath context 5203 * 5204 * Cleanup the XPath context data associated to registered variables 5205 */ 5206 void 5207 xmlXPathRegisteredNsCleanup(xmlXPathContextPtr ctxt) { 5208 if (ctxt == NULL) 5209 return; 5210 5211 xmlHashFree(ctxt->nsHash, xmlHashDefaultDeallocator); 5212 ctxt->nsHash = NULL; 5213 } 5214 5215 /************************************************************************ 5216 * * 5217 * Routines to handle Values * 5218 * * 5219 ************************************************************************/ 5220 5221 /* Allocations are terrible, one needs to optimize all this !!! */ 5222 5223 /** 5224 * xmlXPathNewFloat: 5225 * @val: the double value 5226 * 5227 * Create a new xmlXPathObjectPtr of type double and of value @val 5228 * 5229 * Returns the newly created object. 5230 */ 5231 xmlXPathObjectPtr 5232 xmlXPathNewFloat(double val) { 5233 xmlXPathObjectPtr ret; 5234 5235 ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject)); 5236 if (ret == NULL) { 5237 xmlXPathErrMemory(NULL, "creating float object\n"); 5238 return(NULL); 5239 } 5240 memset(ret, 0 , (size_t) sizeof(xmlXPathObject)); 5241 ret->type = XPATH_NUMBER; 5242 ret->floatval = val; 5243 #ifdef XP_DEBUG_OBJ_USAGE 5244 xmlXPathDebugObjUsageRequested(NULL, XPATH_NUMBER); 5245 #endif 5246 return(ret); 5247 } 5248 5249 /** 5250 * xmlXPathNewBoolean: 5251 * @val: the boolean value 5252 * 5253 * Create a new xmlXPathObjectPtr of type boolean and of value @val 5254 * 5255 * Returns the newly created object. 5256 */ 5257 xmlXPathObjectPtr 5258 xmlXPathNewBoolean(int val) { 5259 xmlXPathObjectPtr ret; 5260 5261 ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject)); 5262 if (ret == NULL) { 5263 xmlXPathErrMemory(NULL, "creating boolean object\n"); 5264 return(NULL); 5265 } 5266 memset(ret, 0 , (size_t) sizeof(xmlXPathObject)); 5267 ret->type = XPATH_BOOLEAN; 5268 ret->boolval = (val != 0); 5269 #ifdef XP_DEBUG_OBJ_USAGE 5270 xmlXPathDebugObjUsageRequested(NULL, XPATH_BOOLEAN); 5271 #endif 5272 return(ret); 5273 } 5274 5275 /** 5276 * xmlXPathNewString: 5277 * @val: the xmlChar * value 5278 * 5279 * Create a new xmlXPathObjectPtr of type string and of value @val 5280 * 5281 * Returns the newly created object. 5282 */ 5283 xmlXPathObjectPtr 5284 xmlXPathNewString(const xmlChar *val) { 5285 xmlXPathObjectPtr ret; 5286 5287 ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject)); 5288 if (ret == NULL) { 5289 xmlXPathErrMemory(NULL, "creating string object\n"); 5290 return(NULL); 5291 } 5292 memset(ret, 0 , (size_t) sizeof(xmlXPathObject)); 5293 ret->type = XPATH_STRING; 5294 if (val != NULL) 5295 ret->stringval = xmlStrdup(val); 5296 else 5297 ret->stringval = xmlStrdup((const xmlChar *)""); 5298 #ifdef XP_DEBUG_OBJ_USAGE 5299 xmlXPathDebugObjUsageRequested(NULL, XPATH_STRING); 5300 #endif 5301 return(ret); 5302 } 5303 5304 /** 5305 * xmlXPathWrapString: 5306 * @val: the xmlChar * value 5307 * 5308 * Wraps the @val string into an XPath object. 5309 * 5310 * Returns the newly created object. 5311 */ 5312 xmlXPathObjectPtr 5313 xmlXPathWrapString (xmlChar *val) { 5314 xmlXPathObjectPtr ret; 5315 5316 ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject)); 5317 if (ret == NULL) { 5318 xmlXPathErrMemory(NULL, "creating string object\n"); 5319 return(NULL); 5320 } 5321 memset(ret, 0 , (size_t) sizeof(xmlXPathObject)); 5322 ret->type = XPATH_STRING; 5323 ret->stringval = val; 5324 #ifdef XP_DEBUG_OBJ_USAGE 5325 xmlXPathDebugObjUsageRequested(NULL, XPATH_STRING); 5326 #endif 5327 return(ret); 5328 } 5329 5330 /** 5331 * xmlXPathNewCString: 5332 * @val: the char * value 5333 * 5334 * Create a new xmlXPathObjectPtr of type string and of value @val 5335 * 5336 * Returns the newly created object. 5337 */ 5338 xmlXPathObjectPtr 5339 xmlXPathNewCString(const char *val) { 5340 xmlXPathObjectPtr ret; 5341 5342 ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject)); 5343 if (ret == NULL) { 5344 xmlXPathErrMemory(NULL, "creating string object\n"); 5345 return(NULL); 5346 } 5347 memset(ret, 0 , (size_t) sizeof(xmlXPathObject)); 5348 ret->type = XPATH_STRING; 5349 ret->stringval = xmlStrdup(BAD_CAST val); 5350 #ifdef XP_DEBUG_OBJ_USAGE 5351 xmlXPathDebugObjUsageRequested(NULL, XPATH_STRING); 5352 #endif 5353 return(ret); 5354 } 5355 5356 /** 5357 * xmlXPathWrapCString: 5358 * @val: the char * value 5359 * 5360 * Wraps a string into an XPath object. 5361 * 5362 * Returns the newly created object. 5363 */ 5364 xmlXPathObjectPtr 5365 xmlXPathWrapCString (char * val) { 5366 return(xmlXPathWrapString((xmlChar *)(val))); 5367 } 5368 5369 /** 5370 * xmlXPathWrapExternal: 5371 * @val: the user data 5372 * 5373 * Wraps the @val data into an XPath object. 5374 * 5375 * Returns the newly created object. 5376 */ 5377 xmlXPathObjectPtr 5378 xmlXPathWrapExternal (void *val) { 5379 xmlXPathObjectPtr ret; 5380 5381 ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject)); 5382 if (ret == NULL) { 5383 xmlXPathErrMemory(NULL, "creating user object\n"); 5384 return(NULL); 5385 } 5386 memset(ret, 0 , (size_t) sizeof(xmlXPathObject)); 5387 ret->type = XPATH_USERS; 5388 ret->user = val; 5389 #ifdef XP_DEBUG_OBJ_USAGE 5390 xmlXPathDebugObjUsageRequested(NULL, XPATH_USERS); 5391 #endif 5392 return(ret); 5393 } 5394 5395 /** 5396 * xmlXPathObjectCopy: 5397 * @val: the original object 5398 * 5399 * allocate a new copy of a given object 5400 * 5401 * Returns the newly created object. 5402 */ 5403 xmlXPathObjectPtr 5404 xmlXPathObjectCopy(xmlXPathObjectPtr val) { 5405 xmlXPathObjectPtr ret; 5406 5407 if (val == NULL) 5408 return(NULL); 5409 5410 ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject)); 5411 if (ret == NULL) { 5412 xmlXPathErrMemory(NULL, "copying object\n"); 5413 return(NULL); 5414 } 5415 memcpy(ret, val , (size_t) sizeof(xmlXPathObject)); 5416 #ifdef XP_DEBUG_OBJ_USAGE 5417 xmlXPathDebugObjUsageRequested(NULL, val->type); 5418 #endif 5419 switch (val->type) { 5420 case XPATH_BOOLEAN: 5421 case XPATH_NUMBER: 5422 case XPATH_POINT: 5423 case XPATH_RANGE: 5424 break; 5425 case XPATH_STRING: 5426 ret->stringval = xmlStrdup(val->stringval); 5427 break; 5428 case XPATH_XSLT_TREE: 5429 #if 0 5430 /* 5431 Removed 11 July 2004 - the current handling of xslt tmpRVT nodes means that 5432 this previous handling is no longer correct, and can cause some serious 5433 problems (ref. bug 145547) 5434 */ 5435 if ((val->nodesetval != NULL) && 5436 (val->nodesetval->nodeTab != NULL)) { 5437 xmlNodePtr cur, tmp; 5438 xmlDocPtr top; 5439 5440 ret->boolval = 1; 5441 top = xmlNewDoc(NULL); 5442 top->name = (char *) 5443 xmlStrdup(val->nodesetval->nodeTab[0]->name); 5444 ret->user = top; 5445 if (top != NULL) { 5446 top->doc = top; 5447 cur = val->nodesetval->nodeTab[0]->children; 5448 while (cur != NULL) { 5449 tmp = xmlDocCopyNode(cur, top, 1); 5450 xmlAddChild((xmlNodePtr) top, tmp); 5451 cur = cur->next; 5452 } 5453 } 5454 5455 ret->nodesetval = xmlXPathNodeSetCreate((xmlNodePtr) top); 5456 } else 5457 ret->nodesetval = xmlXPathNodeSetCreate(NULL); 5458 /* Deallocate the copied tree value */ 5459 break; 5460 #endif 5461 case XPATH_NODESET: 5462 ret->nodesetval = xmlXPathNodeSetMerge(NULL, val->nodesetval); 5463 /* Do not deallocate the copied tree value */ 5464 ret->boolval = 0; 5465 break; 5466 case XPATH_LOCATIONSET: 5467 #ifdef LIBXML_XPTR_ENABLED 5468 { 5469 xmlLocationSetPtr loc = val->user; 5470 ret->user = (void *) xmlXPtrLocationSetMerge(NULL, loc); 5471 break; 5472 } 5473 #endif 5474 case XPATH_USERS: 5475 ret->user = val->user; 5476 break; 5477 case XPATH_UNDEFINED: 5478 xmlGenericError(xmlGenericErrorContext, 5479 "xmlXPathObjectCopy: unsupported type %d\n", 5480 val->type); 5481 break; 5482 } 5483 return(ret); 5484 } 5485 5486 /** 5487 * xmlXPathFreeObject: 5488 * @obj: the object to free 5489 * 5490 * Free up an xmlXPathObjectPtr object. 5491 */ 5492 void 5493 xmlXPathFreeObject(xmlXPathObjectPtr obj) { 5494 if (obj == NULL) return; 5495 if ((obj->type == XPATH_NODESET) || (obj->type == XPATH_XSLT_TREE)) { 5496 if (obj->boolval) { 5497 #if 0 5498 if (obj->user != NULL) { 5499 xmlXPathFreeNodeSet(obj->nodesetval); 5500 xmlFreeNodeList((xmlNodePtr) obj->user); 5501 } else 5502 #endif 5503 obj->type = XPATH_XSLT_TREE; /* TODO: Just for debugging. */ 5504 if (obj->nodesetval != NULL) 5505 xmlXPathFreeValueTree(obj->nodesetval); 5506 } else { 5507 if (obj->nodesetval != NULL) 5508 xmlXPathFreeNodeSet(obj->nodesetval); 5509 } 5510 #ifdef LIBXML_XPTR_ENABLED 5511 } else if (obj->type == XPATH_LOCATIONSET) { 5512 if (obj->user != NULL) 5513 xmlXPtrFreeLocationSet(obj->user); 5514 #endif 5515 } else if (obj->type == XPATH_STRING) { 5516 if (obj->stringval != NULL) 5517 xmlFree(obj->stringval); 5518 } 5519 #ifdef XP_DEBUG_OBJ_USAGE 5520 xmlXPathDebugObjUsageReleased(NULL, obj->type); 5521 #endif 5522 xmlFree(obj); 5523 } 5524 5525 static void 5526 xmlXPathFreeObjectEntry(void *obj, const xmlChar *name ATTRIBUTE_UNUSED) { 5527 xmlXPathFreeObject((xmlXPathObjectPtr) obj); 5528 } 5529 5530 /** 5531 * xmlXPathReleaseObject: 5532 * @obj: the xmlXPathObjectPtr to free or to cache 5533 * 5534 * Depending on the state of the cache this frees the given 5535 * XPath object or stores it in the cache. 5536 */ 5537 static void 5538 xmlXPathReleaseObject(xmlXPathContextPtr ctxt, xmlXPathObjectPtr obj) 5539 { 5540 #define XP_CACHE_ADD(sl, o) if (sl == NULL) { \ 5541 sl = xmlPointerListCreate(10); if (sl == NULL) goto free_obj; } \ 5542 if (xmlPointerListAddSize(sl, obj, 0) == -1) goto free_obj; 5543 5544 #define XP_CACHE_WANTS(sl, n) ((sl == NULL) || ((sl)->number < n)) 5545 5546 if (obj == NULL) 5547 return; 5548 if ((ctxt == NULL) || (ctxt->cache == NULL)) { 5549 xmlXPathFreeObject(obj); 5550 } else { 5551 xmlXPathContextCachePtr cache = 5552 (xmlXPathContextCachePtr) ctxt->cache; 5553 5554 switch (obj->type) { 5555 case XPATH_NODESET: 5556 case XPATH_XSLT_TREE: 5557 if (obj->nodesetval != NULL) { 5558 if (obj->boolval) { 5559 /* 5560 * It looks like the @boolval is used for 5561 * evaluation if this an XSLT Result Tree Fragment. 5562 * TODO: Check if this assumption is correct. 5563 */ 5564 obj->type = XPATH_XSLT_TREE; /* just for debugging */ 5565 xmlXPathFreeValueTree(obj->nodesetval); 5566 obj->nodesetval = NULL; 5567 } else if ((obj->nodesetval->nodeMax <= 40) && 5568 (XP_CACHE_WANTS(cache->nodesetObjs, 5569 cache->maxNodeset))) 5570 { 5571 XP_CACHE_ADD(cache->nodesetObjs, obj); 5572 goto obj_cached; 5573 } else { 5574 xmlXPathFreeNodeSet(obj->nodesetval); 5575 obj->nodesetval = NULL; 5576 } 5577 } 5578 break; 5579 case XPATH_STRING: 5580 if (obj->stringval != NULL) 5581 xmlFree(obj->stringval); 5582 5583 if (XP_CACHE_WANTS(cache->stringObjs, cache->maxString)) { 5584 XP_CACHE_ADD(cache->stringObjs, obj); 5585 goto obj_cached; 5586 } 5587 break; 5588 case XPATH_BOOLEAN: 5589 if (XP_CACHE_WANTS(cache->booleanObjs, cache->maxBoolean)) { 5590 XP_CACHE_ADD(cache->booleanObjs, obj); 5591 goto obj_cached; 5592 } 5593 break; 5594 case XPATH_NUMBER: 5595 if (XP_CACHE_WANTS(cache->numberObjs, cache->maxNumber)) { 5596 XP_CACHE_ADD(cache->numberObjs, obj); 5597 goto obj_cached; 5598 } 5599 break; 5600 #ifdef LIBXML_XPTR_ENABLED 5601 case XPATH_LOCATIONSET: 5602 if (obj->user != NULL) { 5603 xmlXPtrFreeLocationSet(obj->user); 5604 } 5605 goto free_obj; 5606 #endif 5607 default: 5608 goto free_obj; 5609 } 5610 5611 /* 5612 * Fallback to adding to the misc-objects slot. 5613 */ 5614 if (XP_CACHE_WANTS(cache->miscObjs, cache->maxMisc)) { 5615 XP_CACHE_ADD(cache->miscObjs, obj); 5616 } else 5617 goto free_obj; 5618 5619 obj_cached: 5620 5621 #ifdef XP_DEBUG_OBJ_USAGE 5622 xmlXPathDebugObjUsageReleased(ctxt, obj->type); 5623 #endif 5624 5625 if (obj->nodesetval != NULL) { 5626 xmlNodeSetPtr tmpset = obj->nodesetval; 5627 5628 /* 5629 * TODO: Due to those nasty ns-nodes, we need to traverse 5630 * the list and free the ns-nodes. 5631 * URGENT TODO: Check if it's actually slowing things down. 5632 * Maybe we shouldn't try to preserve the list. 5633 */ 5634 if (tmpset->nodeNr > 1) { 5635 int i; 5636 xmlNodePtr node; 5637 5638 for (i = 0; i < tmpset->nodeNr; i++) { 5639 node = tmpset->nodeTab[i]; 5640 if ((node != NULL) && 5641 (node->type == XML_NAMESPACE_DECL)) 5642 { 5643 xmlXPathNodeSetFreeNs((xmlNsPtr) node); 5644 } 5645 } 5646 } else if (tmpset->nodeNr == 1) { 5647 if ((tmpset->nodeTab[0] != NULL) && 5648 (tmpset->nodeTab[0]->type == XML_NAMESPACE_DECL)) 5649 xmlXPathNodeSetFreeNs((xmlNsPtr) tmpset->nodeTab[0]); 5650 } 5651 tmpset->nodeNr = 0; 5652 memset(obj, 0, sizeof(xmlXPathObject)); 5653 obj->nodesetval = tmpset; 5654 } else 5655 memset(obj, 0, sizeof(xmlXPathObject)); 5656 5657 return; 5658 5659 free_obj: 5660 /* 5661 * Cache is full; free the object. 5662 */ 5663 if (obj->nodesetval != NULL) 5664 xmlXPathFreeNodeSet(obj->nodesetval); 5665 #ifdef XP_DEBUG_OBJ_USAGE 5666 xmlXPathDebugObjUsageReleased(NULL, obj->type); 5667 #endif 5668 xmlFree(obj); 5669 } 5670 return; 5671 } 5672 5673 5674 /************************************************************************ 5675 * * 5676 * Type Casting Routines * 5677 * * 5678 ************************************************************************/ 5679 5680 /** 5681 * xmlXPathCastBooleanToString: 5682 * @val: a boolean 5683 * 5684 * Converts a boolean to its string value. 5685 * 5686 * Returns a newly allocated string. 5687 */ 5688 xmlChar * 5689 xmlXPathCastBooleanToString (int val) { 5690 xmlChar *ret; 5691 if (val) 5692 ret = xmlStrdup((const xmlChar *) "true"); 5693 else 5694 ret = xmlStrdup((const xmlChar *) "false"); 5695 return(ret); 5696 } 5697 5698 /** 5699 * xmlXPathCastNumberToString: 5700 * @val: a number 5701 * 5702 * Converts a number to its string value. 5703 * 5704 * Returns a newly allocated string. 5705 */ 5706 xmlChar * 5707 xmlXPathCastNumberToString (double val) { 5708 xmlChar *ret; 5709 switch (xmlXPathIsInf(val)) { 5710 case 1: 5711 ret = xmlStrdup((const xmlChar *) "Infinity"); 5712 break; 5713 case -1: 5714 ret = xmlStrdup((const xmlChar *) "-Infinity"); 5715 break; 5716 default: 5717 if (xmlXPathIsNaN(val)) { 5718 ret = xmlStrdup((const xmlChar *) "NaN"); 5719 } else if (val == 0) { 5720 /* Omit sign for negative zero. */ 5721 ret = xmlStrdup((const xmlChar *) "0"); 5722 } else { 5723 /* could be improved */ 5724 char buf[100]; 5725 xmlXPathFormatNumber(val, buf, 99); 5726 buf[99] = 0; 5727 ret = xmlStrdup((const xmlChar *) buf); 5728 } 5729 } 5730 return(ret); 5731 } 5732 5733 /** 5734 * xmlXPathCastNodeToString: 5735 * @node: a node 5736 * 5737 * Converts a node to its string value. 5738 * 5739 * Returns a newly allocated string. 5740 */ 5741 xmlChar * 5742 xmlXPathCastNodeToString (xmlNodePtr node) { 5743 xmlChar *ret; 5744 if ((ret = xmlNodeGetContent(node)) == NULL) 5745 ret = xmlStrdup((const xmlChar *) ""); 5746 return(ret); 5747 } 5748 5749 /** 5750 * xmlXPathCastNodeSetToString: 5751 * @ns: a node-set 5752 * 5753 * Converts a node-set to its string value. 5754 * 5755 * Returns a newly allocated string. 5756 */ 5757 xmlChar * 5758 xmlXPathCastNodeSetToString (xmlNodeSetPtr ns) { 5759 if ((ns == NULL) || (ns->nodeNr == 0) || (ns->nodeTab == NULL)) 5760 return(xmlStrdup((const xmlChar *) "")); 5761 5762 if (ns->nodeNr > 1) 5763 xmlXPathNodeSetSort(ns); 5764 return(xmlXPathCastNodeToString(ns->nodeTab[0])); 5765 } 5766 5767 /** 5768 * xmlXPathCastToString: 5769 * @val: an XPath object 5770 * 5771 * Converts an existing object to its string() equivalent 5772 * 5773 * Returns the allocated string value of the object, NULL in case of error. 5774 * It's up to the caller to free the string memory with xmlFree(). 5775 */ 5776 xmlChar * 5777 xmlXPathCastToString(xmlXPathObjectPtr val) { 5778 xmlChar *ret = NULL; 5779 5780 if (val == NULL) 5781 return(xmlStrdup((const xmlChar *) "")); 5782 switch (val->type) { 5783 case XPATH_UNDEFINED: 5784 #ifdef DEBUG_EXPR 5785 xmlGenericError(xmlGenericErrorContext, "String: undefined\n"); 5786 #endif 5787 ret = xmlStrdup((const xmlChar *) ""); 5788 break; 5789 case XPATH_NODESET: 5790 case XPATH_XSLT_TREE: 5791 ret = xmlXPathCastNodeSetToString(val->nodesetval); 5792 break; 5793 case XPATH_STRING: 5794 return(xmlStrdup(val->stringval)); 5795 case XPATH_BOOLEAN: 5796 ret = xmlXPathCastBooleanToString(val->boolval); 5797 break; 5798 case XPATH_NUMBER: { 5799 ret = xmlXPathCastNumberToString(val->floatval); 5800 break; 5801 } 5802 case XPATH_USERS: 5803 case XPATH_POINT: 5804 case XPATH_RANGE: 5805 case XPATH_LOCATIONSET: 5806 TODO 5807 ret = xmlStrdup((const xmlChar *) ""); 5808 break; 5809 } 5810 return(ret); 5811 } 5812 5813 /** 5814 * xmlXPathConvertString: 5815 * @val: an XPath object 5816 * 5817 * Converts an existing object to its string() equivalent 5818 * 5819 * Returns the new object, the old one is freed (or the operation 5820 * is done directly on @val) 5821 */ 5822 xmlXPathObjectPtr 5823 xmlXPathConvertString(xmlXPathObjectPtr val) { 5824 xmlChar *res = NULL; 5825 5826 if (val == NULL) 5827 return(xmlXPathNewCString("")); 5828 5829 switch (val->type) { 5830 case XPATH_UNDEFINED: 5831 #ifdef DEBUG_EXPR 5832 xmlGenericError(xmlGenericErrorContext, "STRING: undefined\n"); 5833 #endif 5834 break; 5835 case XPATH_NODESET: 5836 case XPATH_XSLT_TREE: 5837 res = xmlXPathCastNodeSetToString(val->nodesetval); 5838 break; 5839 case XPATH_STRING: 5840 return(val); 5841 case XPATH_BOOLEAN: 5842 res = xmlXPathCastBooleanToString(val->boolval); 5843 break; 5844 case XPATH_NUMBER: 5845 res = xmlXPathCastNumberToString(val->floatval); 5846 break; 5847 case XPATH_USERS: 5848 case XPATH_POINT: 5849 case XPATH_RANGE: 5850 case XPATH_LOCATIONSET: 5851 TODO; 5852 break; 5853 } 5854 xmlXPathFreeObject(val); 5855 if (res == NULL) 5856 return(xmlXPathNewCString("")); 5857 return(xmlXPathWrapString(res)); 5858 } 5859 5860 /** 5861 * xmlXPathCastBooleanToNumber: 5862 * @val: a boolean 5863 * 5864 * Converts a boolean to its number value 5865 * 5866 * Returns the number value 5867 */ 5868 double 5869 xmlXPathCastBooleanToNumber(int val) { 5870 if (val) 5871 return(1.0); 5872 return(0.0); 5873 } 5874 5875 /** 5876 * xmlXPathCastStringToNumber: 5877 * @val: a string 5878 * 5879 * Converts a string to its number value 5880 * 5881 * Returns the number value 5882 */ 5883 double 5884 xmlXPathCastStringToNumber(const xmlChar * val) { 5885 return(xmlXPathStringEvalNumber(val)); 5886 } 5887 5888 /** 5889 * xmlXPathCastNodeToNumber: 5890 * @node: a node 5891 * 5892 * Converts a node to its number value 5893 * 5894 * Returns the number value 5895 */ 5896 double 5897 xmlXPathCastNodeToNumber (xmlNodePtr node) { 5898 xmlChar *strval; 5899 double ret; 5900 5901 if (node == NULL) 5902 return(NAN); 5903 strval = xmlXPathCastNodeToString(node); 5904 if (strval == NULL) 5905 return(NAN); 5906 ret = xmlXPathCastStringToNumber(strval); 5907 xmlFree(strval); 5908 5909 return(ret); 5910 } 5911 5912 /** 5913 * xmlXPathCastNodeSetToNumber: 5914 * @ns: a node-set 5915 * 5916 * Converts a node-set to its number value 5917 * 5918 * Returns the number value 5919 */ 5920 double 5921 xmlXPathCastNodeSetToNumber (xmlNodeSetPtr ns) { 5922 xmlChar *str; 5923 double ret; 5924 5925 if (ns == NULL) 5926 return(NAN); 5927 str = xmlXPathCastNodeSetToString(ns); 5928 ret = xmlXPathCastStringToNumber(str); 5929 xmlFree(str); 5930 return(ret); 5931 } 5932 5933 /** 5934 * xmlXPathCastToNumber: 5935 * @val: an XPath object 5936 * 5937 * Converts an XPath object to its number value 5938 * 5939 * Returns the number value 5940 */ 5941 double 5942 xmlXPathCastToNumber(xmlXPathObjectPtr val) { 5943 double ret = 0.0; 5944 5945 if (val == NULL) 5946 return(NAN); 5947 switch (val->type) { 5948 case XPATH_UNDEFINED: 5949 #ifdef DEGUB_EXPR 5950 xmlGenericError(xmlGenericErrorContext, "NUMBER: undefined\n"); 5951 #endif 5952 ret = NAN; 5953 break; 5954 case XPATH_NODESET: 5955 case XPATH_XSLT_TREE: 5956 ret = xmlXPathCastNodeSetToNumber(val->nodesetval); 5957 break; 5958 case XPATH_STRING: 5959 ret = xmlXPathCastStringToNumber(val->stringval); 5960 break; 5961 case XPATH_NUMBER: 5962 ret = val->floatval; 5963 break; 5964 case XPATH_BOOLEAN: 5965 ret = xmlXPathCastBooleanToNumber(val->boolval); 5966 break; 5967 case XPATH_USERS: 5968 case XPATH_POINT: 5969 case XPATH_RANGE: 5970 case XPATH_LOCATIONSET: 5971 TODO; 5972 ret = NAN; 5973 break; 5974 } 5975 return(ret); 5976 } 5977 5978 /** 5979 * xmlXPathConvertNumber: 5980 * @val: an XPath object 5981 * 5982 * Converts an existing object to its number() equivalent 5983 * 5984 * Returns the new object, the old one is freed (or the operation 5985 * is done directly on @val) 5986 */ 5987 xmlXPathObjectPtr 5988 xmlXPathConvertNumber(xmlXPathObjectPtr val) { 5989 xmlXPathObjectPtr ret; 5990 5991 if (val == NULL) 5992 return(xmlXPathNewFloat(0.0)); 5993 if (val->type == XPATH_NUMBER) 5994 return(val); 5995 ret = xmlXPathNewFloat(xmlXPathCastToNumber(val)); 5996 xmlXPathFreeObject(val); 5997 return(ret); 5998 } 5999 6000 /** 6001 * xmlXPathCastNumberToBoolean: 6002 * @val: a number 6003 * 6004 * Converts a number to its boolean value 6005 * 6006 * Returns the boolean value 6007 */ 6008 int 6009 xmlXPathCastNumberToBoolean (double val) { 6010 if (xmlXPathIsNaN(val) || (val == 0.0)) 6011 return(0); 6012 return(1); 6013 } 6014 6015 /** 6016 * xmlXPathCastStringToBoolean: 6017 * @val: a string 6018 * 6019 * Converts a string to its boolean value 6020 * 6021 * Returns the boolean value 6022 */ 6023 int 6024 xmlXPathCastStringToBoolean (const xmlChar *val) { 6025 if ((val == NULL) || (xmlStrlen(val) == 0)) 6026 return(0); 6027 return(1); 6028 } 6029 6030 /** 6031 * xmlXPathCastNodeSetToBoolean: 6032 * @ns: a node-set 6033 * 6034 * Converts a node-set to its boolean value 6035 * 6036 * Returns the boolean value 6037 */ 6038 int 6039 xmlXPathCastNodeSetToBoolean (xmlNodeSetPtr ns) { 6040 if ((ns == NULL) || (ns->nodeNr == 0)) 6041 return(0); 6042 return(1); 6043 } 6044 6045 /** 6046 * xmlXPathCastToBoolean: 6047 * @val: an XPath object 6048 * 6049 * Converts an XPath object to its boolean value 6050 * 6051 * Returns the boolean value 6052 */ 6053 int 6054 xmlXPathCastToBoolean (xmlXPathObjectPtr val) { 6055 int ret = 0; 6056 6057 if (val == NULL) 6058 return(0); 6059 switch (val->type) { 6060 case XPATH_UNDEFINED: 6061 #ifdef DEBUG_EXPR 6062 xmlGenericError(xmlGenericErrorContext, "BOOLEAN: undefined\n"); 6063 #endif 6064 ret = 0; 6065 break; 6066 case XPATH_NODESET: 6067 case XPATH_XSLT_TREE: 6068 ret = xmlXPathCastNodeSetToBoolean(val->nodesetval); 6069 break; 6070 case XPATH_STRING: 6071 ret = xmlXPathCastStringToBoolean(val->stringval); 6072 break; 6073 case XPATH_NUMBER: 6074 ret = xmlXPathCastNumberToBoolean(val->floatval); 6075 break; 6076 case XPATH_BOOLEAN: 6077 ret = val->boolval; 6078 break; 6079 case XPATH_USERS: 6080 case XPATH_POINT: 6081 case XPATH_RANGE: 6082 case XPATH_LOCATIONSET: 6083 TODO; 6084 ret = 0; 6085 break; 6086 } 6087 return(ret); 6088 } 6089 6090 6091 /** 6092 * xmlXPathConvertBoolean: 6093 * @val: an XPath object 6094 * 6095 * Converts an existing object to its boolean() equivalent 6096 * 6097 * Returns the new object, the old one is freed (or the operation 6098 * is done directly on @val) 6099 */ 6100 xmlXPathObjectPtr 6101 xmlXPathConvertBoolean(xmlXPathObjectPtr val) { 6102 xmlXPathObjectPtr ret; 6103 6104 if (val == NULL) 6105 return(xmlXPathNewBoolean(0)); 6106 if (val->type == XPATH_BOOLEAN) 6107 return(val); 6108 ret = xmlXPathNewBoolean(xmlXPathCastToBoolean(val)); 6109 xmlXPathFreeObject(val); 6110 return(ret); 6111 } 6112 6113 /************************************************************************ 6114 * * 6115 * Routines to handle XPath contexts * 6116 * * 6117 ************************************************************************/ 6118 6119 /** 6120 * xmlXPathNewContext: 6121 * @doc: the XML document 6122 * 6123 * Create a new xmlXPathContext 6124 * 6125 * Returns the xmlXPathContext just allocated. The caller will need to free it. 6126 */ 6127 xmlXPathContextPtr 6128 xmlXPathNewContext(xmlDocPtr doc) { 6129 xmlXPathContextPtr ret; 6130 6131 ret = (xmlXPathContextPtr) xmlMalloc(sizeof(xmlXPathContext)); 6132 if (ret == NULL) { 6133 xmlXPathErrMemory(NULL, "creating context\n"); 6134 return(NULL); 6135 } 6136 memset(ret, 0 , (size_t) sizeof(xmlXPathContext)); 6137 ret->doc = doc; 6138 ret->node = NULL; 6139 6140 ret->varHash = NULL; 6141 6142 ret->nb_types = 0; 6143 ret->max_types = 0; 6144 ret->types = NULL; 6145 6146 ret->funcHash = xmlHashCreate(0); 6147 6148 ret->nb_axis = 0; 6149 ret->max_axis = 0; 6150 ret->axis = NULL; 6151 6152 ret->nsHash = NULL; 6153 ret->user = NULL; 6154 6155 ret->contextSize = -1; 6156 ret->proximityPosition = -1; 6157 6158 #ifdef XP_DEFAULT_CACHE_ON 6159 if (xmlXPathContextSetCache(ret, 1, -1, 0) == -1) { 6160 xmlXPathFreeContext(ret); 6161 return(NULL); 6162 } 6163 #endif 6164 6165 xmlXPathRegisterAllFunctions(ret); 6166 6167 return(ret); 6168 } 6169 6170 /** 6171 * xmlXPathFreeContext: 6172 * @ctxt: the context to free 6173 * 6174 * Free up an xmlXPathContext 6175 */ 6176 void 6177 xmlXPathFreeContext(xmlXPathContextPtr ctxt) { 6178 if (ctxt == NULL) return; 6179 6180 if (ctxt->cache != NULL) 6181 xmlXPathFreeCache((xmlXPathContextCachePtr) ctxt->cache); 6182 xmlXPathRegisteredNsCleanup(ctxt); 6183 xmlXPathRegisteredFuncsCleanup(ctxt); 6184 xmlXPathRegisteredVariablesCleanup(ctxt); 6185 xmlResetError(&ctxt->lastError); 6186 xmlFree(ctxt); 6187 } 6188 6189 /************************************************************************ 6190 * * 6191 * Routines to handle XPath parser contexts * 6192 * * 6193 ************************************************************************/ 6194 6195 #define CHECK_CTXT(ctxt) \ 6196 if (ctxt == NULL) { \ 6197 __xmlRaiseError(NULL, NULL, NULL, \ 6198 NULL, NULL, XML_FROM_XPATH, \ 6199 XML_ERR_INTERNAL_ERROR, XML_ERR_FATAL, \ 6200 __FILE__, __LINE__, \ 6201 NULL, NULL, NULL, 0, 0, \ 6202 "NULL context pointer\n"); \ 6203 return(NULL); \ 6204 } \ 6205 6206 #define CHECK_CTXT_NEG(ctxt) \ 6207 if (ctxt == NULL) { \ 6208 __xmlRaiseError(NULL, NULL, NULL, \ 6209 NULL, NULL, XML_FROM_XPATH, \ 6210 XML_ERR_INTERNAL_ERROR, XML_ERR_FATAL, \ 6211 __FILE__, __LINE__, \ 6212 NULL, NULL, NULL, 0, 0, \ 6213 "NULL context pointer\n"); \ 6214 return(-1); \ 6215 } \ 6216 6217 6218 #define CHECK_CONTEXT(ctxt) \ 6219 if ((ctxt == NULL) || (ctxt->doc == NULL) || \ 6220 (ctxt->doc->children == NULL)) { \ 6221 xmlXPatherror(ctxt, __FILE__, __LINE__, XPATH_INVALID_CTXT); \ 6222 return(NULL); \ 6223 } 6224 6225 6226 /** 6227 * xmlXPathNewParserContext: 6228 * @str: the XPath expression 6229 * @ctxt: the XPath context 6230 * 6231 * Create a new xmlXPathParserContext 6232 * 6233 * Returns the xmlXPathParserContext just allocated. 6234 */ 6235 xmlXPathParserContextPtr 6236 xmlXPathNewParserContext(const xmlChar *str, xmlXPathContextPtr ctxt) { 6237 xmlXPathParserContextPtr ret; 6238 6239 ret = (xmlXPathParserContextPtr) xmlMalloc(sizeof(xmlXPathParserContext)); 6240 if (ret == NULL) { 6241 xmlXPathErrMemory(ctxt, "creating parser context\n"); 6242 return(NULL); 6243 } 6244 memset(ret, 0 , (size_t) sizeof(xmlXPathParserContext)); 6245 ret->cur = ret->base = str; 6246 ret->context = ctxt; 6247 6248 ret->comp = xmlXPathNewCompExpr(); 6249 if (ret->comp == NULL) { 6250 xmlFree(ret->valueTab); 6251 xmlFree(ret); 6252 return(NULL); 6253 } 6254 if ((ctxt != NULL) && (ctxt->dict != NULL)) { 6255 ret->comp->dict = ctxt->dict; 6256 xmlDictReference(ret->comp->dict); 6257 } 6258 6259 return(ret); 6260 } 6261 6262 /** 6263 * xmlXPathCompParserContext: 6264 * @comp: the XPath compiled expression 6265 * @ctxt: the XPath context 6266 * 6267 * Create a new xmlXPathParserContext when processing a compiled expression 6268 * 6269 * Returns the xmlXPathParserContext just allocated. 6270 */ 6271 static xmlXPathParserContextPtr 6272 xmlXPathCompParserContext(xmlXPathCompExprPtr comp, xmlXPathContextPtr ctxt) { 6273 xmlXPathParserContextPtr ret; 6274 6275 ret = (xmlXPathParserContextPtr) xmlMalloc(sizeof(xmlXPathParserContext)); 6276 if (ret == NULL) { 6277 xmlXPathErrMemory(ctxt, "creating evaluation context\n"); 6278 return(NULL); 6279 } 6280 memset(ret, 0 , (size_t) sizeof(xmlXPathParserContext)); 6281 6282 /* Allocate the value stack */ 6283 ret->valueTab = (xmlXPathObjectPtr *) 6284 xmlMalloc(10 * sizeof(xmlXPathObjectPtr)); 6285 if (ret->valueTab == NULL) { 6286 xmlFree(ret); 6287 xmlXPathErrMemory(ctxt, "creating evaluation context\n"); 6288 return(NULL); 6289 } 6290 ret->valueNr = 0; 6291 ret->valueMax = 10; 6292 ret->value = NULL; 6293 ret->valueFrame = 0; 6294 6295 ret->context = ctxt; 6296 ret->comp = comp; 6297 6298 return(ret); 6299 } 6300 6301 /** 6302 * xmlXPathFreeParserContext: 6303 * @ctxt: the context to free 6304 * 6305 * Free up an xmlXPathParserContext 6306 */ 6307 void 6308 xmlXPathFreeParserContext(xmlXPathParserContextPtr ctxt) { 6309 int i; 6310 6311 if (ctxt->valueTab != NULL) { 6312 for (i = 0; i < ctxt->valueNr; i++) { 6313 if (ctxt->context) 6314 xmlXPathReleaseObject(ctxt->context, ctxt->valueTab[i]); 6315 else 6316 xmlXPathFreeObject(ctxt->valueTab[i]); 6317 } 6318 xmlFree(ctxt->valueTab); 6319 } 6320 if (ctxt->comp != NULL) { 6321 #ifdef XPATH_STREAMING 6322 if (ctxt->comp->stream != NULL) { 6323 xmlFreePatternList(ctxt->comp->stream); 6324 ctxt->comp->stream = NULL; 6325 } 6326 #endif 6327 xmlXPathFreeCompExpr(ctxt->comp); 6328 } 6329 xmlFree(ctxt); 6330 } 6331 6332 /************************************************************************ 6333 * * 6334 * The implicit core function library * 6335 * * 6336 ************************************************************************/ 6337 6338 /** 6339 * xmlXPathNodeValHash: 6340 * @node: a node pointer 6341 * 6342 * Function computing the beginning of the string value of the node, 6343 * used to speed up comparisons 6344 * 6345 * Returns an int usable as a hash 6346 */ 6347 static unsigned int 6348 xmlXPathNodeValHash(xmlNodePtr node) { 6349 int len = 2; 6350 const xmlChar * string = NULL; 6351 xmlNodePtr tmp = NULL; 6352 unsigned int ret = 0; 6353 6354 if (node == NULL) 6355 return(0); 6356 6357 if (node->type == XML_DOCUMENT_NODE) { 6358 tmp = xmlDocGetRootElement((xmlDocPtr) node); 6359 if (tmp == NULL) 6360 node = node->children; 6361 else 6362 node = tmp; 6363 6364 if (node == NULL) 6365 return(0); 6366 } 6367 6368 switch (node->type) { 6369 case XML_COMMENT_NODE: 6370 case XML_PI_NODE: 6371 case XML_CDATA_SECTION_NODE: 6372 case XML_TEXT_NODE: 6373 string = node->content; 6374 if (string == NULL) 6375 return(0); 6376 if (string[0] == 0) 6377 return(0); 6378 return(((unsigned int) string[0]) + 6379 (((unsigned int) string[1]) << 8)); 6380 case XML_NAMESPACE_DECL: 6381 string = ((xmlNsPtr)node)->href; 6382 if (string == NULL) 6383 return(0); 6384 if (string[0] == 0) 6385 return(0); 6386 return(((unsigned int) string[0]) + 6387 (((unsigned int) string[1]) << 8)); 6388 case XML_ATTRIBUTE_NODE: 6389 tmp = ((xmlAttrPtr) node)->children; 6390 break; 6391 case XML_ELEMENT_NODE: 6392 tmp = node->children; 6393 break; 6394 default: 6395 return(0); 6396 } 6397 while (tmp != NULL) { 6398 switch (tmp->type) { 6399 case XML_CDATA_SECTION_NODE: 6400 case XML_TEXT_NODE: 6401 string = tmp->content; 6402 break; 6403 default: 6404 string = NULL; 6405 break; 6406 } 6407 if ((string != NULL) && (string[0] != 0)) { 6408 if (len == 1) { 6409 return(ret + (((unsigned int) string[0]) << 8)); 6410 } 6411 if (string[1] == 0) { 6412 len = 1; 6413 ret = (unsigned int) string[0]; 6414 } else { 6415 return(((unsigned int) string[0]) + 6416 (((unsigned int) string[1]) << 8)); 6417 } 6418 } 6419 /* 6420 * Skip to next node 6421 */ 6422 if ((tmp->children != NULL) && (tmp->type != XML_DTD_NODE)) { 6423 if (tmp->children->type != XML_ENTITY_DECL) { 6424 tmp = tmp->children; 6425 continue; 6426 } 6427 } 6428 if (tmp == node) 6429 break; 6430 6431 if (tmp->next != NULL) { 6432 tmp = tmp->next; 6433 continue; 6434 } 6435 6436 do { 6437 tmp = tmp->parent; 6438 if (tmp == NULL) 6439 break; 6440 if (tmp == node) { 6441 tmp = NULL; 6442 break; 6443 } 6444 if (tmp->next != NULL) { 6445 tmp = tmp->next; 6446 break; 6447 } 6448 } while (tmp != NULL); 6449 } 6450 return(ret); 6451 } 6452 6453 /** 6454 * xmlXPathStringHash: 6455 * @string: a string 6456 * 6457 * Function computing the beginning of the string value of the node, 6458 * used to speed up comparisons 6459 * 6460 * Returns an int usable as a hash 6461 */ 6462 static unsigned int 6463 xmlXPathStringHash(const xmlChar * string) { 6464 if (string == NULL) 6465 return((unsigned int) 0); 6466 if (string[0] == 0) 6467 return(0); 6468 return(((unsigned int) string[0]) + 6469 (((unsigned int) string[1]) << 8)); 6470 } 6471 6472 /** 6473 * xmlXPathCompareNodeSetFloat: 6474 * @ctxt: the XPath Parser context 6475 * @inf: less than (1) or greater than (0) 6476 * @strict: is the comparison strict 6477 * @arg: the node set 6478 * @f: the value 6479 * 6480 * Implement the compare operation between a nodeset and a number 6481 * @ns < @val (1, 1, ... 6482 * @ns <= @val (1, 0, ... 6483 * @ns > @val (0, 1, ... 6484 * @ns >= @val (0, 0, ... 6485 * 6486 * If one object to be compared is a node-set and the other is a number, 6487 * then the comparison will be true if and only if there is a node in the 6488 * node-set such that the result of performing the comparison on the number 6489 * to be compared and on the result of converting the string-value of that 6490 * node to a number using the number function is true. 6491 * 6492 * Returns 0 or 1 depending on the results of the test. 6493 */ 6494 static int 6495 xmlXPathCompareNodeSetFloat(xmlXPathParserContextPtr ctxt, int inf, int strict, 6496 xmlXPathObjectPtr arg, xmlXPathObjectPtr f) { 6497 int i, ret = 0; 6498 xmlNodeSetPtr ns; 6499 xmlChar *str2; 6500 6501 if ((f == NULL) || (arg == NULL) || 6502 ((arg->type != XPATH_NODESET) && (arg->type != XPATH_XSLT_TREE))) { 6503 xmlXPathReleaseObject(ctxt->context, arg); 6504 xmlXPathReleaseObject(ctxt->context, f); 6505 return(0); 6506 } 6507 ns = arg->nodesetval; 6508 if (ns != NULL) { 6509 for (i = 0;i < ns->nodeNr;i++) { 6510 str2 = xmlXPathCastNodeToString(ns->nodeTab[i]); 6511 if (str2 != NULL) { 6512 valuePush(ctxt, 6513 xmlXPathCacheNewString(ctxt->context, str2)); 6514 xmlFree(str2); 6515 xmlXPathNumberFunction(ctxt, 1); 6516 valuePush(ctxt, xmlXPathCacheObjectCopy(ctxt->context, f)); 6517 ret = xmlXPathCompareValues(ctxt, inf, strict); 6518 if (ret) 6519 break; 6520 } 6521 } 6522 } 6523 xmlXPathReleaseObject(ctxt->context, arg); 6524 xmlXPathReleaseObject(ctxt->context, f); 6525 return(ret); 6526 } 6527 6528 /** 6529 * xmlXPathCompareNodeSetString: 6530 * @ctxt: the XPath Parser context 6531 * @inf: less than (1) or greater than (0) 6532 * @strict: is the comparison strict 6533 * @arg: the node set 6534 * @s: the value 6535 * 6536 * Implement the compare operation between a nodeset and a string 6537 * @ns < @val (1, 1, ... 6538 * @ns <= @val (1, 0, ... 6539 * @ns > @val (0, 1, ... 6540 * @ns >= @val (0, 0, ... 6541 * 6542 * If one object to be compared is a node-set and the other is a string, 6543 * then the comparison will be true if and only if there is a node in 6544 * the node-set such that the result of performing the comparison on the 6545 * string-value of the node and the other string is true. 6546 * 6547 * Returns 0 or 1 depending on the results of the test. 6548 */ 6549 static int 6550 xmlXPathCompareNodeSetString(xmlXPathParserContextPtr ctxt, int inf, int strict, 6551 xmlXPathObjectPtr arg, xmlXPathObjectPtr s) { 6552 int i, ret = 0; 6553 xmlNodeSetPtr ns; 6554 xmlChar *str2; 6555 6556 if ((s == NULL) || (arg == NULL) || 6557 ((arg->type != XPATH_NODESET) && (arg->type != XPATH_XSLT_TREE))) { 6558 xmlXPathReleaseObject(ctxt->context, arg); 6559 xmlXPathReleaseObject(ctxt->context, s); 6560 return(0); 6561 } 6562 ns = arg->nodesetval; 6563 if (ns != NULL) { 6564 for (i = 0;i < ns->nodeNr;i++) { 6565 str2 = xmlXPathCastNodeToString(ns->nodeTab[i]); 6566 if (str2 != NULL) { 6567 valuePush(ctxt, 6568 xmlXPathCacheNewString(ctxt->context, str2)); 6569 xmlFree(str2); 6570 valuePush(ctxt, xmlXPathCacheObjectCopy(ctxt->context, s)); 6571 ret = xmlXPathCompareValues(ctxt, inf, strict); 6572 if (ret) 6573 break; 6574 } 6575 } 6576 } 6577 xmlXPathReleaseObject(ctxt->context, arg); 6578 xmlXPathReleaseObject(ctxt->context, s); 6579 return(ret); 6580 } 6581 6582 /** 6583 * xmlXPathCompareNodeSets: 6584 * @inf: less than (1) or greater than (0) 6585 * @strict: is the comparison strict 6586 * @arg1: the first node set object 6587 * @arg2: the second node set object 6588 * 6589 * Implement the compare operation on nodesets: 6590 * 6591 * If both objects to be compared are node-sets, then the comparison 6592 * will be true if and only if there is a node in the first node-set 6593 * and a node in the second node-set such that the result of performing 6594 * the comparison on the string-values of the two nodes is true. 6595 * .... 6596 * When neither object to be compared is a node-set and the operator 6597 * is <=, <, >= or >, then the objects are compared by converting both 6598 * objects to numbers and comparing the numbers according to IEEE 754. 6599 * .... 6600 * The number function converts its argument to a number as follows: 6601 * - a string that consists of optional whitespace followed by an 6602 * optional minus sign followed by a Number followed by whitespace 6603 * is converted to the IEEE 754 number that is nearest (according 6604 * to the IEEE 754 round-to-nearest rule) to the mathematical value 6605 * represented by the string; any other string is converted to NaN 6606 * 6607 * Conclusion all nodes need to be converted first to their string value 6608 * and then the comparison must be done when possible 6609 */ 6610 static int 6611 xmlXPathCompareNodeSets(int inf, int strict, 6612 xmlXPathObjectPtr arg1, xmlXPathObjectPtr arg2) { 6613 int i, j, init = 0; 6614 double val1; 6615 double *values2; 6616 int ret = 0; 6617 xmlNodeSetPtr ns1; 6618 xmlNodeSetPtr ns2; 6619 6620 if ((arg1 == NULL) || 6621 ((arg1->type != XPATH_NODESET) && (arg1->type != XPATH_XSLT_TREE))) { 6622 xmlXPathFreeObject(arg2); 6623 return(0); 6624 } 6625 if ((arg2 == NULL) || 6626 ((arg2->type != XPATH_NODESET) && (arg2->type != XPATH_XSLT_TREE))) { 6627 xmlXPathFreeObject(arg1); 6628 xmlXPathFreeObject(arg2); 6629 return(0); 6630 } 6631 6632 ns1 = arg1->nodesetval; 6633 ns2 = arg2->nodesetval; 6634 6635 if ((ns1 == NULL) || (ns1->nodeNr <= 0)) { 6636 xmlXPathFreeObject(arg1); 6637 xmlXPathFreeObject(arg2); 6638 return(0); 6639 } 6640 if ((ns2 == NULL) || (ns2->nodeNr <= 0)) { 6641 xmlXPathFreeObject(arg1); 6642 xmlXPathFreeObject(arg2); 6643 return(0); 6644 } 6645 6646 values2 = (double *) xmlMalloc(ns2->nodeNr * sizeof(double)); 6647 if (values2 == NULL) { 6648 xmlXPathErrMemory(NULL, "comparing nodesets\n"); 6649 xmlXPathFreeObject(arg1); 6650 xmlXPathFreeObject(arg2); 6651 return(0); 6652 } 6653 for (i = 0;i < ns1->nodeNr;i++) { 6654 val1 = xmlXPathCastNodeToNumber(ns1->nodeTab[i]); 6655 if (xmlXPathIsNaN(val1)) 6656 continue; 6657 for (j = 0;j < ns2->nodeNr;j++) { 6658 if (init == 0) { 6659 values2[j] = xmlXPathCastNodeToNumber(ns2->nodeTab[j]); 6660 } 6661 if (xmlXPathIsNaN(values2[j])) 6662 continue; 6663 if (inf && strict) 6664 ret = (val1 < values2[j]); 6665 else if (inf && !strict) 6666 ret = (val1 <= values2[j]); 6667 else if (!inf && strict) 6668 ret = (val1 > values2[j]); 6669 else if (!inf && !strict) 6670 ret = (val1 >= values2[j]); 6671 if (ret) 6672 break; 6673 } 6674 if (ret) 6675 break; 6676 init = 1; 6677 } 6678 xmlFree(values2); 6679 xmlXPathFreeObject(arg1); 6680 xmlXPathFreeObject(arg2); 6681 return(ret); 6682 } 6683 6684 /** 6685 * xmlXPathCompareNodeSetValue: 6686 * @ctxt: the XPath Parser context 6687 * @inf: less than (1) or greater than (0) 6688 * @strict: is the comparison strict 6689 * @arg: the node set 6690 * @val: the value 6691 * 6692 * Implement the compare operation between a nodeset and a value 6693 * @ns < @val (1, 1, ... 6694 * @ns <= @val (1, 0, ... 6695 * @ns > @val (0, 1, ... 6696 * @ns >= @val (0, 0, ... 6697 * 6698 * If one object to be compared is a node-set and the other is a boolean, 6699 * then the comparison will be true if and only if the result of performing 6700 * the comparison on the boolean and on the result of converting 6701 * the node-set to a boolean using the boolean function is true. 6702 * 6703 * Returns 0 or 1 depending on the results of the test. 6704 */ 6705 static int 6706 xmlXPathCompareNodeSetValue(xmlXPathParserContextPtr ctxt, int inf, int strict, 6707 xmlXPathObjectPtr arg, xmlXPathObjectPtr val) { 6708 if ((val == NULL) || (arg == NULL) || 6709 ((arg->type != XPATH_NODESET) && (arg->type != XPATH_XSLT_TREE))) 6710 return(0); 6711 6712 switch(val->type) { 6713 case XPATH_NUMBER: 6714 return(xmlXPathCompareNodeSetFloat(ctxt, inf, strict, arg, val)); 6715 case XPATH_NODESET: 6716 case XPATH_XSLT_TREE: 6717 return(xmlXPathCompareNodeSets(inf, strict, arg, val)); 6718 case XPATH_STRING: 6719 return(xmlXPathCompareNodeSetString(ctxt, inf, strict, arg, val)); 6720 case XPATH_BOOLEAN: 6721 valuePush(ctxt, arg); 6722 xmlXPathBooleanFunction(ctxt, 1); 6723 valuePush(ctxt, val); 6724 return(xmlXPathCompareValues(ctxt, inf, strict)); 6725 default: 6726 xmlGenericError(xmlGenericErrorContext, 6727 "xmlXPathCompareNodeSetValue: Can't compare node set " 6728 "and object of type %d\n", 6729 val->type); 6730 xmlXPathReleaseObject(ctxt->context, arg); 6731 xmlXPathReleaseObject(ctxt->context, val); 6732 XP_ERROR0(XPATH_INVALID_TYPE); 6733 } 6734 return(0); 6735 } 6736 6737 /** 6738 * xmlXPathEqualNodeSetString: 6739 * @arg: the nodeset object argument 6740 * @str: the string to compare to. 6741 * @neq: flag to show whether for '=' (0) or '!=' (1) 6742 * 6743 * Implement the equal operation on XPath objects content: @arg1 == @arg2 6744 * If one object to be compared is a node-set and the other is a string, 6745 * then the comparison will be true if and only if there is a node in 6746 * the node-set such that the result of performing the comparison on the 6747 * string-value of the node and the other string is true. 6748 * 6749 * Returns 0 or 1 depending on the results of the test. 6750 */ 6751 static int 6752 xmlXPathEqualNodeSetString(xmlXPathObjectPtr arg, const xmlChar * str, int neq) 6753 { 6754 int i; 6755 xmlNodeSetPtr ns; 6756 xmlChar *str2; 6757 unsigned int hash; 6758 6759 if ((str == NULL) || (arg == NULL) || 6760 ((arg->type != XPATH_NODESET) && (arg->type != XPATH_XSLT_TREE))) 6761 return (0); 6762 ns = arg->nodesetval; 6763 /* 6764 * A NULL nodeset compared with a string is always false 6765 * (since there is no node equal, and no node not equal) 6766 */ 6767 if ((ns == NULL) || (ns->nodeNr <= 0) ) 6768 return (0); 6769 hash = xmlXPathStringHash(str); 6770 for (i = 0; i < ns->nodeNr; i++) { 6771 if (xmlXPathNodeValHash(ns->nodeTab[i]) == hash) { 6772 str2 = xmlNodeGetContent(ns->nodeTab[i]); 6773 if ((str2 != NULL) && (xmlStrEqual(str, str2))) { 6774 xmlFree(str2); 6775 if (neq) 6776 continue; 6777 return (1); 6778 } else if ((str2 == NULL) && (xmlStrEqual(str, BAD_CAST ""))) { 6779 if (neq) 6780 continue; 6781 return (1); 6782 } else if (neq) { 6783 if (str2 != NULL) 6784 xmlFree(str2); 6785 return (1); 6786 } 6787 if (str2 != NULL) 6788 xmlFree(str2); 6789 } else if (neq) 6790 return (1); 6791 } 6792 return (0); 6793 } 6794 6795 /** 6796 * xmlXPathEqualNodeSetFloat: 6797 * @arg: the nodeset object argument 6798 * @f: the float to compare to 6799 * @neq: flag to show whether to compare '=' (0) or '!=' (1) 6800 * 6801 * Implement the equal operation on XPath objects content: @arg1 == @arg2 6802 * If one object to be compared is a node-set and the other is a number, 6803 * then the comparison will be true if and only if there is a node in 6804 * the node-set such that the result of performing the comparison on the 6805 * number to be compared and on the result of converting the string-value 6806 * of that node to a number using the number function is true. 6807 * 6808 * Returns 0 or 1 depending on the results of the test. 6809 */ 6810 static int 6811 xmlXPathEqualNodeSetFloat(xmlXPathParserContextPtr ctxt, 6812 xmlXPathObjectPtr arg, double f, int neq) { 6813 int i, ret=0; 6814 xmlNodeSetPtr ns; 6815 xmlChar *str2; 6816 xmlXPathObjectPtr val; 6817 double v; 6818 6819 if ((arg == NULL) || 6820 ((arg->type != XPATH_NODESET) && (arg->type != XPATH_XSLT_TREE))) 6821 return(0); 6822 6823 ns = arg->nodesetval; 6824 if (ns != NULL) { 6825 for (i=0;i<ns->nodeNr;i++) { 6826 str2 = xmlXPathCastNodeToString(ns->nodeTab[i]); 6827 if (str2 != NULL) { 6828 valuePush(ctxt, xmlXPathCacheNewString(ctxt->context, str2)); 6829 xmlFree(str2); 6830 xmlXPathNumberFunction(ctxt, 1); 6831 val = valuePop(ctxt); 6832 v = val->floatval; 6833 xmlXPathReleaseObject(ctxt->context, val); 6834 if (!xmlXPathIsNaN(v)) { 6835 if ((!neq) && (v==f)) { 6836 ret = 1; 6837 break; 6838 } else if ((neq) && (v!=f)) { 6839 ret = 1; 6840 break; 6841 } 6842 } else { /* NaN is unequal to any value */ 6843 if (neq) 6844 ret = 1; 6845 } 6846 } 6847 } 6848 } 6849 6850 return(ret); 6851 } 6852 6853 6854 /** 6855 * xmlXPathEqualNodeSets: 6856 * @arg1: first nodeset object argument 6857 * @arg2: second nodeset object argument 6858 * @neq: flag to show whether to test '=' (0) or '!=' (1) 6859 * 6860 * Implement the equal / not equal operation on XPath nodesets: 6861 * @arg1 == @arg2 or @arg1 != @arg2 6862 * If both objects to be compared are node-sets, then the comparison 6863 * will be true if and only if there is a node in the first node-set and 6864 * a node in the second node-set such that the result of performing the 6865 * comparison on the string-values of the two nodes is true. 6866 * 6867 * (needless to say, this is a costly operation) 6868 * 6869 * Returns 0 or 1 depending on the results of the test. 6870 */ 6871 static int 6872 xmlXPathEqualNodeSets(xmlXPathObjectPtr arg1, xmlXPathObjectPtr arg2, int neq) { 6873 int i, j; 6874 unsigned int *hashs1; 6875 unsigned int *hashs2; 6876 xmlChar **values1; 6877 xmlChar **values2; 6878 int ret = 0; 6879 xmlNodeSetPtr ns1; 6880 xmlNodeSetPtr ns2; 6881 6882 if ((arg1 == NULL) || 6883 ((arg1->type != XPATH_NODESET) && (arg1->type != XPATH_XSLT_TREE))) 6884 return(0); 6885 if ((arg2 == NULL) || 6886 ((arg2->type != XPATH_NODESET) && (arg2->type != XPATH_XSLT_TREE))) 6887 return(0); 6888 6889 ns1 = arg1->nodesetval; 6890 ns2 = arg2->nodesetval; 6891 6892 if ((ns1 == NULL) || (ns1->nodeNr <= 0)) 6893 return(0); 6894 if ((ns2 == NULL) || (ns2->nodeNr <= 0)) 6895 return(0); 6896 6897 /* 6898 * for equal, check if there is a node pertaining to both sets 6899 */ 6900 if (neq == 0) 6901 for (i = 0;i < ns1->nodeNr;i++) 6902 for (j = 0;j < ns2->nodeNr;j++) 6903 if (ns1->nodeTab[i] == ns2->nodeTab[j]) 6904 return(1); 6905 6906 values1 = (xmlChar **) xmlMalloc(ns1->nodeNr * sizeof(xmlChar *)); 6907 if (values1 == NULL) { 6908 xmlXPathErrMemory(NULL, "comparing nodesets\n"); 6909 return(0); 6910 } 6911 hashs1 = (unsigned int *) xmlMalloc(ns1->nodeNr * sizeof(unsigned int)); 6912 if (hashs1 == NULL) { 6913 xmlXPathErrMemory(NULL, "comparing nodesets\n"); 6914 xmlFree(values1); 6915 return(0); 6916 } 6917 memset(values1, 0, ns1->nodeNr * sizeof(xmlChar *)); 6918 values2 = (xmlChar **) xmlMalloc(ns2->nodeNr * sizeof(xmlChar *)); 6919 if (values2 == NULL) { 6920 xmlXPathErrMemory(NULL, "comparing nodesets\n"); 6921 xmlFree(hashs1); 6922 xmlFree(values1); 6923 return(0); 6924 } 6925 hashs2 = (unsigned int *) xmlMalloc(ns2->nodeNr * sizeof(unsigned int)); 6926 if (hashs2 == NULL) { 6927 xmlXPathErrMemory(NULL, "comparing nodesets\n"); 6928 xmlFree(hashs1); 6929 xmlFree(values1); 6930 xmlFree(values2); 6931 return(0); 6932 } 6933 memset(values2, 0, ns2->nodeNr * sizeof(xmlChar *)); 6934 for (i = 0;i < ns1->nodeNr;i++) { 6935 hashs1[i] = xmlXPathNodeValHash(ns1->nodeTab[i]); 6936 for (j = 0;j < ns2->nodeNr;j++) { 6937 if (i == 0) 6938 hashs2[j] = xmlXPathNodeValHash(ns2->nodeTab[j]); 6939 if (hashs1[i] != hashs2[j]) { 6940 if (neq) { 6941 ret = 1; 6942 break; 6943 } 6944 } 6945 else { 6946 if (values1[i] == NULL) 6947 values1[i] = xmlNodeGetContent(ns1->nodeTab[i]); 6948 if (values2[j] == NULL) 6949 values2[j] = xmlNodeGetContent(ns2->nodeTab[j]); 6950 ret = xmlStrEqual(values1[i], values2[j]) ^ neq; 6951 if (ret) 6952 break; 6953 } 6954 } 6955 if (ret) 6956 break; 6957 } 6958 for (i = 0;i < ns1->nodeNr;i++) 6959 if (values1[i] != NULL) 6960 xmlFree(values1[i]); 6961 for (j = 0;j < ns2->nodeNr;j++) 6962 if (values2[j] != NULL) 6963 xmlFree(values2[j]); 6964 xmlFree(values1); 6965 xmlFree(values2); 6966 xmlFree(hashs1); 6967 xmlFree(hashs2); 6968 return(ret); 6969 } 6970 6971 static int 6972 xmlXPathEqualValuesCommon(xmlXPathParserContextPtr ctxt, 6973 xmlXPathObjectPtr arg1, xmlXPathObjectPtr arg2) { 6974 int ret = 0; 6975 /* 6976 *At this point we are assured neither arg1 nor arg2 6977 *is a nodeset, so we can just pick the appropriate routine. 6978 */ 6979 switch (arg1->type) { 6980 case XPATH_UNDEFINED: 6981 #ifdef DEBUG_EXPR 6982 xmlGenericError(xmlGenericErrorContext, 6983 "Equal: undefined\n"); 6984 #endif 6985 break; 6986 case XPATH_BOOLEAN: 6987 switch (arg2->type) { 6988 case XPATH_UNDEFINED: 6989 #ifdef DEBUG_EXPR 6990 xmlGenericError(xmlGenericErrorContext, 6991 "Equal: undefined\n"); 6992 #endif 6993 break; 6994 case XPATH_BOOLEAN: 6995 #ifdef DEBUG_EXPR 6996 xmlGenericError(xmlGenericErrorContext, 6997 "Equal: %d boolean %d \n", 6998 arg1->boolval, arg2->boolval); 6999 #endif 7000 ret = (arg1->boolval == arg2->boolval); 7001 break; 7002 case XPATH_NUMBER: 7003 ret = (arg1->boolval == 7004 xmlXPathCastNumberToBoolean(arg2->floatval)); 7005 break; 7006 case XPATH_STRING: 7007 if ((arg2->stringval == NULL) || 7008 (arg2->stringval[0] == 0)) ret = 0; 7009 else 7010 ret = 1; 7011 ret = (arg1->boolval == ret); 7012 break; 7013 case XPATH_USERS: 7014 case XPATH_POINT: 7015 case XPATH_RANGE: 7016 case XPATH_LOCATIONSET: 7017 TODO 7018 break; 7019 case XPATH_NODESET: 7020 case XPATH_XSLT_TREE: 7021 break; 7022 } 7023 break; 7024 case XPATH_NUMBER: 7025 switch (arg2->type) { 7026 case XPATH_UNDEFINED: 7027 #ifdef DEBUG_EXPR 7028 xmlGenericError(xmlGenericErrorContext, 7029 "Equal: undefined\n"); 7030 #endif 7031 break; 7032 case XPATH_BOOLEAN: 7033 ret = (arg2->boolval== 7034 xmlXPathCastNumberToBoolean(arg1->floatval)); 7035 break; 7036 case XPATH_STRING: 7037 valuePush(ctxt, arg2); 7038 xmlXPathNumberFunction(ctxt, 1); 7039 arg2 = valuePop(ctxt); 7040 /* Falls through. */ 7041 case XPATH_NUMBER: 7042 /* Hand check NaN and Infinity equalities */ 7043 if (xmlXPathIsNaN(arg1->floatval) || 7044 xmlXPathIsNaN(arg2->floatval)) { 7045 ret = 0; 7046 } else if (xmlXPathIsInf(arg1->floatval) == 1) { 7047 if (xmlXPathIsInf(arg2->floatval) == 1) 7048 ret = 1; 7049 else 7050 ret = 0; 7051 } else if (xmlXPathIsInf(arg1->floatval) == -1) { 7052 if (xmlXPathIsInf(arg2->floatval) == -1) 7053 ret = 1; 7054 else 7055 ret = 0; 7056 } else if (xmlXPathIsInf(arg2->floatval) == 1) { 7057 if (xmlXPathIsInf(arg1->floatval) == 1) 7058 ret = 1; 7059 else 7060 ret = 0; 7061 } else if (xmlXPathIsInf(arg2->floatval) == -1) { 7062 if (xmlXPathIsInf(arg1->floatval) == -1) 7063 ret = 1; 7064 else 7065 ret = 0; 7066 } else { 7067 ret = (arg1->floatval == arg2->floatval); 7068 } 7069 break; 7070 case XPATH_USERS: 7071 case XPATH_POINT: 7072 case XPATH_RANGE: 7073 case XPATH_LOCATIONSET: 7074 TODO 7075 break; 7076 case XPATH_NODESET: 7077 case XPATH_XSLT_TREE: 7078 break; 7079 } 7080 break; 7081 case XPATH_STRING: 7082 switch (arg2->type) { 7083 case XPATH_UNDEFINED: 7084 #ifdef DEBUG_EXPR 7085 xmlGenericError(xmlGenericErrorContext, 7086 "Equal: undefined\n"); 7087 #endif 7088 break; 7089 case XPATH_BOOLEAN: 7090 if ((arg1->stringval == NULL) || 7091 (arg1->stringval[0] == 0)) ret = 0; 7092 else 7093 ret = 1; 7094 ret = (arg2->boolval == ret); 7095 break; 7096 case XPATH_STRING: 7097 ret = xmlStrEqual(arg1->stringval, arg2->stringval); 7098 break; 7099 case XPATH_NUMBER: 7100 valuePush(ctxt, arg1); 7101 xmlXPathNumberFunction(ctxt, 1); 7102 arg1 = valuePop(ctxt); 7103 /* Hand check NaN and Infinity equalities */ 7104 if (xmlXPathIsNaN(arg1->floatval) || 7105 xmlXPathIsNaN(arg2->floatval)) { 7106 ret = 0; 7107 } else if (xmlXPathIsInf(arg1->floatval) == 1) { 7108 if (xmlXPathIsInf(arg2->floatval) == 1) 7109 ret = 1; 7110 else 7111 ret = 0; 7112 } else if (xmlXPathIsInf(arg1->floatval) == -1) { 7113 if (xmlXPathIsInf(arg2->floatval) == -1) 7114 ret = 1; 7115 else 7116 ret = 0; 7117 } else if (xmlXPathIsInf(arg2->floatval) == 1) { 7118 if (xmlXPathIsInf(arg1->floatval) == 1) 7119 ret = 1; 7120 else 7121 ret = 0; 7122 } else if (xmlXPathIsInf(arg2->floatval) == -1) { 7123 if (xmlXPathIsInf(arg1->floatval) == -1) 7124 ret = 1; 7125 else 7126 ret = 0; 7127 } else { 7128 ret = (arg1->floatval == arg2->floatval); 7129 } 7130 break; 7131 case XPATH_USERS: 7132 case XPATH_POINT: 7133 case XPATH_RANGE: 7134 case XPATH_LOCATIONSET: 7135 TODO 7136 break; 7137 case XPATH_NODESET: 7138 case XPATH_XSLT_TREE: 7139 break; 7140 } 7141 break; 7142 case XPATH_USERS: 7143 case XPATH_POINT: 7144 case XPATH_RANGE: 7145 case XPATH_LOCATIONSET: 7146 TODO 7147 break; 7148 case XPATH_NODESET: 7149 case XPATH_XSLT_TREE: 7150 break; 7151 } 7152 xmlXPathReleaseObject(ctxt->context, arg1); 7153 xmlXPathReleaseObject(ctxt->context, arg2); 7154 return(ret); 7155 } 7156 7157 /** 7158 * xmlXPathEqualValues: 7159 * @ctxt: the XPath Parser context 7160 * 7161 * Implement the equal operation on XPath objects content: @arg1 == @arg2 7162 * 7163 * Returns 0 or 1 depending on the results of the test. 7164 */ 7165 int 7166 xmlXPathEqualValues(xmlXPathParserContextPtr ctxt) { 7167 xmlXPathObjectPtr arg1, arg2, argtmp; 7168 int ret = 0; 7169 7170 if ((ctxt == NULL) || (ctxt->context == NULL)) return(0); 7171 arg2 = valuePop(ctxt); 7172 arg1 = valuePop(ctxt); 7173 if ((arg1 == NULL) || (arg2 == NULL)) { 7174 if (arg1 != NULL) 7175 xmlXPathReleaseObject(ctxt->context, arg1); 7176 else 7177 xmlXPathReleaseObject(ctxt->context, arg2); 7178 XP_ERROR0(XPATH_INVALID_OPERAND); 7179 } 7180 7181 if (arg1 == arg2) { 7182 #ifdef DEBUG_EXPR 7183 xmlGenericError(xmlGenericErrorContext, 7184 "Equal: by pointer\n"); 7185 #endif 7186 xmlXPathFreeObject(arg1); 7187 return(1); 7188 } 7189 7190 /* 7191 *If either argument is a nodeset, it's a 'special case' 7192 */ 7193 if ((arg2->type == XPATH_NODESET) || (arg2->type == XPATH_XSLT_TREE) || 7194 (arg1->type == XPATH_NODESET) || (arg1->type == XPATH_XSLT_TREE)) { 7195 /* 7196 *Hack it to assure arg1 is the nodeset 7197 */ 7198 if ((arg1->type != XPATH_NODESET) && (arg1->type != XPATH_XSLT_TREE)) { 7199 argtmp = arg2; 7200 arg2 = arg1; 7201 arg1 = argtmp; 7202 } 7203 switch (arg2->type) { 7204 case XPATH_UNDEFINED: 7205 #ifdef DEBUG_EXPR 7206 xmlGenericError(xmlGenericErrorContext, 7207 "Equal: undefined\n"); 7208 #endif 7209 break; 7210 case XPATH_NODESET: 7211 case XPATH_XSLT_TREE: 7212 ret = xmlXPathEqualNodeSets(arg1, arg2, 0); 7213 break; 7214 case XPATH_BOOLEAN: 7215 if ((arg1->nodesetval == NULL) || 7216 (arg1->nodesetval->nodeNr == 0)) ret = 0; 7217 else 7218 ret = 1; 7219 ret = (ret == arg2->boolval); 7220 break; 7221 case XPATH_NUMBER: 7222 ret = xmlXPathEqualNodeSetFloat(ctxt, arg1, arg2->floatval, 0); 7223 break; 7224 case XPATH_STRING: 7225 ret = xmlXPathEqualNodeSetString(arg1, arg2->stringval, 0); 7226 break; 7227 case XPATH_USERS: 7228 case XPATH_POINT: 7229 case XPATH_RANGE: 7230 case XPATH_LOCATIONSET: 7231 TODO 7232 break; 7233 } 7234 xmlXPathReleaseObject(ctxt->context, arg1); 7235 xmlXPathReleaseObject(ctxt->context, arg2); 7236 return(ret); 7237 } 7238 7239 return (xmlXPathEqualValuesCommon(ctxt, arg1, arg2)); 7240 } 7241 7242 /** 7243 * xmlXPathNotEqualValues: 7244 * @ctxt: the XPath Parser context 7245 * 7246 * Implement the equal operation on XPath objects content: @arg1 == @arg2 7247 * 7248 * Returns 0 or 1 depending on the results of the test. 7249 */ 7250 int 7251 xmlXPathNotEqualValues(xmlXPathParserContextPtr ctxt) { 7252 xmlXPathObjectPtr arg1, arg2, argtmp; 7253 int ret = 0; 7254 7255 if ((ctxt == NULL) || (ctxt->context == NULL)) return(0); 7256 arg2 = valuePop(ctxt); 7257 arg1 = valuePop(ctxt); 7258 if ((arg1 == NULL) || (arg2 == NULL)) { 7259 if (arg1 != NULL) 7260 xmlXPathReleaseObject(ctxt->context, arg1); 7261 else 7262 xmlXPathReleaseObject(ctxt->context, arg2); 7263 XP_ERROR0(XPATH_INVALID_OPERAND); 7264 } 7265 7266 if (arg1 == arg2) { 7267 #ifdef DEBUG_EXPR 7268 xmlGenericError(xmlGenericErrorContext, 7269 "NotEqual: by pointer\n"); 7270 #endif 7271 xmlXPathReleaseObject(ctxt->context, arg1); 7272 return(0); 7273 } 7274 7275 /* 7276 *If either argument is a nodeset, it's a 'special case' 7277 */ 7278 if ((arg2->type == XPATH_NODESET) || (arg2->type == XPATH_XSLT_TREE) || 7279 (arg1->type == XPATH_NODESET) || (arg1->type == XPATH_XSLT_TREE)) { 7280 /* 7281 *Hack it to assure arg1 is the nodeset 7282 */ 7283 if ((arg1->type != XPATH_NODESET) && (arg1->type != XPATH_XSLT_TREE)) { 7284 argtmp = arg2; 7285 arg2 = arg1; 7286 arg1 = argtmp; 7287 } 7288 switch (arg2->type) { 7289 case XPATH_UNDEFINED: 7290 #ifdef DEBUG_EXPR 7291 xmlGenericError(xmlGenericErrorContext, 7292 "NotEqual: undefined\n"); 7293 #endif 7294 break; 7295 case XPATH_NODESET: 7296 case XPATH_XSLT_TREE: 7297 ret = xmlXPathEqualNodeSets(arg1, arg2, 1); 7298 break; 7299 case XPATH_BOOLEAN: 7300 if ((arg1->nodesetval == NULL) || 7301 (arg1->nodesetval->nodeNr == 0)) ret = 0; 7302 else 7303 ret = 1; 7304 ret = (ret != arg2->boolval); 7305 break; 7306 case XPATH_NUMBER: 7307 ret = xmlXPathEqualNodeSetFloat(ctxt, arg1, arg2->floatval, 1); 7308 break; 7309 case XPATH_STRING: 7310 ret = xmlXPathEqualNodeSetString(arg1, arg2->stringval,1); 7311 break; 7312 case XPATH_USERS: 7313 case XPATH_POINT: 7314 case XPATH_RANGE: 7315 case XPATH_LOCATIONSET: 7316 TODO 7317 break; 7318 } 7319 xmlXPathReleaseObject(ctxt->context, arg1); 7320 xmlXPathReleaseObject(ctxt->context, arg2); 7321 return(ret); 7322 } 7323 7324 return (!xmlXPathEqualValuesCommon(ctxt, arg1, arg2)); 7325 } 7326 7327 /** 7328 * xmlXPathCompareValues: 7329 * @ctxt: the XPath Parser context 7330 * @inf: less than (1) or greater than (0) 7331 * @strict: is the comparison strict 7332 * 7333 * Implement the compare operation on XPath objects: 7334 * @arg1 < @arg2 (1, 1, ... 7335 * @arg1 <= @arg2 (1, 0, ... 7336 * @arg1 > @arg2 (0, 1, ... 7337 * @arg1 >= @arg2 (0, 0, ... 7338 * 7339 * When neither object to be compared is a node-set and the operator is 7340 * <=, <, >=, >, then the objects are compared by converted both objects 7341 * to numbers and comparing the numbers according to IEEE 754. The < 7342 * comparison will be true if and only if the first number is less than the 7343 * second number. The <= comparison will be true if and only if the first 7344 * number is less than or equal to the second number. The > comparison 7345 * will be true if and only if the first number is greater than the second 7346 * number. The >= comparison will be true if and only if the first number 7347 * is greater than or equal to the second number. 7348 * 7349 * Returns 1 if the comparison succeeded, 0 if it failed 7350 */ 7351 int 7352 xmlXPathCompareValues(xmlXPathParserContextPtr ctxt, int inf, int strict) { 7353 int ret = 0, arg1i = 0, arg2i = 0; 7354 xmlXPathObjectPtr arg1, arg2; 7355 7356 if ((ctxt == NULL) || (ctxt->context == NULL)) return(0); 7357 arg2 = valuePop(ctxt); 7358 arg1 = valuePop(ctxt); 7359 if ((arg1 == NULL) || (arg2 == NULL)) { 7360 if (arg1 != NULL) 7361 xmlXPathReleaseObject(ctxt->context, arg1); 7362 else 7363 xmlXPathReleaseObject(ctxt->context, arg2); 7364 XP_ERROR0(XPATH_INVALID_OPERAND); 7365 } 7366 7367 if ((arg2->type == XPATH_NODESET) || (arg2->type == XPATH_XSLT_TREE) || 7368 (arg1->type == XPATH_NODESET) || (arg1->type == XPATH_XSLT_TREE)) { 7369 /* 7370 * If either argument is a XPATH_NODESET or XPATH_XSLT_TREE the two arguments 7371 * are not freed from within this routine; they will be freed from the 7372 * called routine, e.g. xmlXPathCompareNodeSets or xmlXPathCompareNodeSetValue 7373 */ 7374 if (((arg2->type == XPATH_NODESET) || (arg2->type == XPATH_XSLT_TREE)) && 7375 ((arg1->type == XPATH_NODESET) || (arg1->type == XPATH_XSLT_TREE))){ 7376 ret = xmlXPathCompareNodeSets(inf, strict, arg1, arg2); 7377 } else { 7378 if ((arg1->type == XPATH_NODESET) || (arg1->type == XPATH_XSLT_TREE)) { 7379 ret = xmlXPathCompareNodeSetValue(ctxt, inf, strict, 7380 arg1, arg2); 7381 } else { 7382 ret = xmlXPathCompareNodeSetValue(ctxt, !inf, strict, 7383 arg2, arg1); 7384 } 7385 } 7386 return(ret); 7387 } 7388 7389 if (arg1->type != XPATH_NUMBER) { 7390 valuePush(ctxt, arg1); 7391 xmlXPathNumberFunction(ctxt, 1); 7392 arg1 = valuePop(ctxt); 7393 } 7394 if (arg1->type != XPATH_NUMBER) { 7395 xmlXPathFreeObject(arg1); 7396 xmlXPathFreeObject(arg2); 7397 XP_ERROR0(XPATH_INVALID_OPERAND); 7398 } 7399 if (arg2->type != XPATH_NUMBER) { 7400 valuePush(ctxt, arg2); 7401 xmlXPathNumberFunction(ctxt, 1); 7402 arg2 = valuePop(ctxt); 7403 } 7404 if (arg2->type != XPATH_NUMBER) { 7405 xmlXPathReleaseObject(ctxt->context, arg1); 7406 xmlXPathReleaseObject(ctxt->context, arg2); 7407 XP_ERROR0(XPATH_INVALID_OPERAND); 7408 } 7409 /* 7410 * Add tests for infinity and nan 7411 * => feedback on 3.4 for Inf and NaN 7412 */ 7413 /* Hand check NaN and Infinity comparisons */ 7414 if (xmlXPathIsNaN(arg1->floatval) || xmlXPathIsNaN(arg2->floatval)) { 7415 ret=0; 7416 } else { 7417 arg1i=xmlXPathIsInf(arg1->floatval); 7418 arg2i=xmlXPathIsInf(arg2->floatval); 7419 if (inf && strict) { 7420 if ((arg1i == -1 && arg2i != -1) || 7421 (arg2i == 1 && arg1i != 1)) { 7422 ret = 1; 7423 } else if (arg1i == 0 && arg2i == 0) { 7424 ret = (arg1->floatval < arg2->floatval); 7425 } else { 7426 ret = 0; 7427 } 7428 } 7429 else if (inf && !strict) { 7430 if (arg1i == -1 || arg2i == 1) { 7431 ret = 1; 7432 } else if (arg1i == 0 && arg2i == 0) { 7433 ret = (arg1->floatval <= arg2->floatval); 7434 } else { 7435 ret = 0; 7436 } 7437 } 7438 else if (!inf && strict) { 7439 if ((arg1i == 1 && arg2i != 1) || 7440 (arg2i == -1 && arg1i != -1)) { 7441 ret = 1; 7442 } else if (arg1i == 0 && arg2i == 0) { 7443 ret = (arg1->floatval > arg2->floatval); 7444 } else { 7445 ret = 0; 7446 } 7447 } 7448 else if (!inf && !strict) { 7449 if (arg1i == 1 || arg2i == -1) { 7450 ret = 1; 7451 } else if (arg1i == 0 && arg2i == 0) { 7452 ret = (arg1->floatval >= arg2->floatval); 7453 } else { 7454 ret = 0; 7455 } 7456 } 7457 } 7458 xmlXPathReleaseObject(ctxt->context, arg1); 7459 xmlXPathReleaseObject(ctxt->context, arg2); 7460 return(ret); 7461 } 7462 7463 /** 7464 * xmlXPathValueFlipSign: 7465 * @ctxt: the XPath Parser context 7466 * 7467 * Implement the unary - operation on an XPath object 7468 * The numeric operators convert their operands to numbers as if 7469 * by calling the number function. 7470 */ 7471 void 7472 xmlXPathValueFlipSign(xmlXPathParserContextPtr ctxt) { 7473 if ((ctxt == NULL) || (ctxt->context == NULL)) return; 7474 CAST_TO_NUMBER; 7475 CHECK_TYPE(XPATH_NUMBER); 7476 ctxt->value->floatval = -ctxt->value->floatval; 7477 } 7478 7479 /** 7480 * xmlXPathAddValues: 7481 * @ctxt: the XPath Parser context 7482 * 7483 * Implement the add operation on XPath objects: 7484 * The numeric operators convert their operands to numbers as if 7485 * by calling the number function. 7486 */ 7487 void 7488 xmlXPathAddValues(xmlXPathParserContextPtr ctxt) { 7489 xmlXPathObjectPtr arg; 7490 double val; 7491 7492 arg = valuePop(ctxt); 7493 if (arg == NULL) 7494 XP_ERROR(XPATH_INVALID_OPERAND); 7495 val = xmlXPathCastToNumber(arg); 7496 xmlXPathReleaseObject(ctxt->context, arg); 7497 CAST_TO_NUMBER; 7498 CHECK_TYPE(XPATH_NUMBER); 7499 ctxt->value->floatval += val; 7500 } 7501 7502 /** 7503 * xmlXPathSubValues: 7504 * @ctxt: the XPath Parser context 7505 * 7506 * Implement the subtraction operation on XPath objects: 7507 * The numeric operators convert their operands to numbers as if 7508 * by calling the number function. 7509 */ 7510 void 7511 xmlXPathSubValues(xmlXPathParserContextPtr ctxt) { 7512 xmlXPathObjectPtr arg; 7513 double val; 7514 7515 arg = valuePop(ctxt); 7516 if (arg == NULL) 7517 XP_ERROR(XPATH_INVALID_OPERAND); 7518 val = xmlXPathCastToNumber(arg); 7519 xmlXPathReleaseObject(ctxt->context, arg); 7520 CAST_TO_NUMBER; 7521 CHECK_TYPE(XPATH_NUMBER); 7522 ctxt->value->floatval -= val; 7523 } 7524 7525 /** 7526 * xmlXPathMultValues: 7527 * @ctxt: the XPath Parser context 7528 * 7529 * Implement the multiply operation on XPath objects: 7530 * The numeric operators convert their operands to numbers as if 7531 * by calling the number function. 7532 */ 7533 void 7534 xmlXPathMultValues(xmlXPathParserContextPtr ctxt) { 7535 xmlXPathObjectPtr arg; 7536 double val; 7537 7538 arg = valuePop(ctxt); 7539 if (arg == NULL) 7540 XP_ERROR(XPATH_INVALID_OPERAND); 7541 val = xmlXPathCastToNumber(arg); 7542 xmlXPathReleaseObject(ctxt->context, arg); 7543 CAST_TO_NUMBER; 7544 CHECK_TYPE(XPATH_NUMBER); 7545 ctxt->value->floatval *= val; 7546 } 7547 7548 /** 7549 * xmlXPathDivValues: 7550 * @ctxt: the XPath Parser context 7551 * 7552 * Implement the div operation on XPath objects @arg1 / @arg2: 7553 * The numeric operators convert their operands to numbers as if 7554 * by calling the number function. 7555 */ 7556 void 7557 xmlXPathDivValues(xmlXPathParserContextPtr ctxt) { 7558 xmlXPathObjectPtr arg; 7559 double val; 7560 7561 arg = valuePop(ctxt); 7562 if (arg == NULL) 7563 XP_ERROR(XPATH_INVALID_OPERAND); 7564 val = xmlXPathCastToNumber(arg); 7565 xmlXPathReleaseObject(ctxt->context, arg); 7566 CAST_TO_NUMBER; 7567 CHECK_TYPE(XPATH_NUMBER); 7568 ctxt->value->floatval /= val; 7569 } 7570 7571 /** 7572 * xmlXPathModValues: 7573 * @ctxt: the XPath Parser context 7574 * 7575 * Implement the mod operation on XPath objects: @arg1 / @arg2 7576 * The numeric operators convert their operands to numbers as if 7577 * by calling the number function. 7578 */ 7579 void 7580 xmlXPathModValues(xmlXPathParserContextPtr ctxt) { 7581 xmlXPathObjectPtr arg; 7582 double arg1, arg2; 7583 7584 arg = valuePop(ctxt); 7585 if (arg == NULL) 7586 XP_ERROR(XPATH_INVALID_OPERAND); 7587 arg2 = xmlXPathCastToNumber(arg); 7588 xmlXPathReleaseObject(ctxt->context, arg); 7589 CAST_TO_NUMBER; 7590 CHECK_TYPE(XPATH_NUMBER); 7591 arg1 = ctxt->value->floatval; 7592 if (arg2 == 0) 7593 ctxt->value->floatval = NAN; 7594 else { 7595 ctxt->value->floatval = fmod(arg1, arg2); 7596 } 7597 } 7598 7599 /************************************************************************ 7600 * * 7601 * The traversal functions * 7602 * * 7603 ************************************************************************/ 7604 7605 /* 7606 * A traversal function enumerates nodes along an axis. 7607 * Initially it must be called with NULL, and it indicates 7608 * termination on the axis by returning NULL. 7609 */ 7610 typedef xmlNodePtr (*xmlXPathTraversalFunction) 7611 (xmlXPathParserContextPtr ctxt, xmlNodePtr cur); 7612 7613 /* 7614 * xmlXPathTraversalFunctionExt: 7615 * A traversal function enumerates nodes along an axis. 7616 * Initially it must be called with NULL, and it indicates 7617 * termination on the axis by returning NULL. 7618 * The context node of the traversal is specified via @contextNode. 7619 */ 7620 typedef xmlNodePtr (*xmlXPathTraversalFunctionExt) 7621 (xmlNodePtr cur, xmlNodePtr contextNode); 7622 7623 /* 7624 * xmlXPathNodeSetMergeFunction: 7625 * Used for merging node sets in xmlXPathCollectAndTest(). 7626 */ 7627 typedef xmlNodeSetPtr (*xmlXPathNodeSetMergeFunction) 7628 (xmlNodeSetPtr, xmlNodeSetPtr, int); 7629 7630 7631 /** 7632 * xmlXPathNextSelf: 7633 * @ctxt: the XPath Parser context 7634 * @cur: the current node in the traversal 7635 * 7636 * Traversal function for the "self" direction 7637 * The self axis contains just the context node itself 7638 * 7639 * Returns the next element following that axis 7640 */ 7641 xmlNodePtr 7642 xmlXPathNextSelf(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) { 7643 if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL); 7644 if (cur == NULL) 7645 return(ctxt->context->node); 7646 return(NULL); 7647 } 7648 7649 /** 7650 * xmlXPathNextChild: 7651 * @ctxt: the XPath Parser context 7652 * @cur: the current node in the traversal 7653 * 7654 * Traversal function for the "child" direction 7655 * The child axis contains the children of the context node in document order. 7656 * 7657 * Returns the next element following that axis 7658 */ 7659 xmlNodePtr 7660 xmlXPathNextChild(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) { 7661 if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL); 7662 if (cur == NULL) { 7663 if (ctxt->context->node == NULL) return(NULL); 7664 switch (ctxt->context->node->type) { 7665 case XML_ELEMENT_NODE: 7666 case XML_TEXT_NODE: 7667 case XML_CDATA_SECTION_NODE: 7668 case XML_ENTITY_REF_NODE: 7669 case XML_ENTITY_NODE: 7670 case XML_PI_NODE: 7671 case XML_COMMENT_NODE: 7672 case XML_NOTATION_NODE: 7673 case XML_DTD_NODE: 7674 return(ctxt->context->node->children); 7675 case XML_DOCUMENT_NODE: 7676 case XML_DOCUMENT_TYPE_NODE: 7677 case XML_DOCUMENT_FRAG_NODE: 7678 case XML_HTML_DOCUMENT_NODE: 7679 #ifdef LIBXML_DOCB_ENABLED 7680 case XML_DOCB_DOCUMENT_NODE: 7681 #endif 7682 return(((xmlDocPtr) ctxt->context->node)->children); 7683 case XML_ELEMENT_DECL: 7684 case XML_ATTRIBUTE_DECL: 7685 case XML_ENTITY_DECL: 7686 case XML_ATTRIBUTE_NODE: 7687 case XML_NAMESPACE_DECL: 7688 case XML_XINCLUDE_START: 7689 case XML_XINCLUDE_END: 7690 return(NULL); 7691 } 7692 return(NULL); 7693 } 7694 if ((cur->type == XML_DOCUMENT_NODE) || 7695 (cur->type == XML_HTML_DOCUMENT_NODE)) 7696 return(NULL); 7697 return(cur->next); 7698 } 7699 7700 /** 7701 * xmlXPathNextChildElement: 7702 * @ctxt: the XPath Parser context 7703 * @cur: the current node in the traversal 7704 * 7705 * Traversal function for the "child" direction and nodes of type element. 7706 * The child axis contains the children of the context node in document order. 7707 * 7708 * Returns the next element following that axis 7709 */ 7710 static xmlNodePtr 7711 xmlXPathNextChildElement(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) { 7712 if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL); 7713 if (cur == NULL) { 7714 cur = ctxt->context->node; 7715 if (cur == NULL) return(NULL); 7716 /* 7717 * Get the first element child. 7718 */ 7719 switch (cur->type) { 7720 case XML_ELEMENT_NODE: 7721 case XML_DOCUMENT_FRAG_NODE: 7722 case XML_ENTITY_REF_NODE: /* URGENT TODO: entify-refs as well? */ 7723 case XML_ENTITY_NODE: 7724 cur = cur->children; 7725 if (cur != NULL) { 7726 if (cur->type == XML_ELEMENT_NODE) 7727 return(cur); 7728 do { 7729 cur = cur->next; 7730 } while ((cur != NULL) && 7731 (cur->type != XML_ELEMENT_NODE)); 7732 return(cur); 7733 } 7734 return(NULL); 7735 case XML_DOCUMENT_NODE: 7736 case XML_HTML_DOCUMENT_NODE: 7737 #ifdef LIBXML_DOCB_ENABLED 7738 case XML_DOCB_DOCUMENT_NODE: 7739 #endif 7740 return(xmlDocGetRootElement((xmlDocPtr) cur)); 7741 default: 7742 return(NULL); 7743 } 7744 return(NULL); 7745 } 7746 /* 7747 * Get the next sibling element node. 7748 */ 7749 switch (cur->type) { 7750 case XML_ELEMENT_NODE: 7751 case XML_TEXT_NODE: 7752 case XML_ENTITY_REF_NODE: 7753 case XML_ENTITY_NODE: 7754 case XML_CDATA_SECTION_NODE: 7755 case XML_PI_NODE: 7756 case XML_COMMENT_NODE: 7757 case XML_XINCLUDE_END: 7758 break; 7759 /* case XML_DTD_NODE: */ /* URGENT TODO: DTD-node as well? */ 7760 default: 7761 return(NULL); 7762 } 7763 if (cur->next != NULL) { 7764 if (cur->next->type == XML_ELEMENT_NODE) 7765 return(cur->next); 7766 cur = cur->next; 7767 do { 7768 cur = cur->next; 7769 } while ((cur != NULL) && (cur->type != XML_ELEMENT_NODE)); 7770 return(cur); 7771 } 7772 return(NULL); 7773 } 7774 7775 #if 0 7776 /** 7777 * xmlXPathNextDescendantOrSelfElemParent: 7778 * @ctxt: the XPath Parser context 7779 * @cur: the current node in the traversal 7780 * 7781 * Traversal function for the "descendant-or-self" axis. 7782 * Additionally it returns only nodes which can be parents of 7783 * element nodes. 7784 * 7785 * 7786 * Returns the next element following that axis 7787 */ 7788 static xmlNodePtr 7789 xmlXPathNextDescendantOrSelfElemParent(xmlNodePtr cur, 7790 xmlNodePtr contextNode) 7791 { 7792 if (cur == NULL) { 7793 if (contextNode == NULL) 7794 return(NULL); 7795 switch (contextNode->type) { 7796 case XML_ELEMENT_NODE: 7797 case XML_XINCLUDE_START: 7798 case XML_DOCUMENT_FRAG_NODE: 7799 case XML_DOCUMENT_NODE: 7800 #ifdef LIBXML_DOCB_ENABLED 7801 case XML_DOCB_DOCUMENT_NODE: 7802 #endif 7803 case XML_HTML_DOCUMENT_NODE: 7804 return(contextNode); 7805 default: 7806 return(NULL); 7807 } 7808 return(NULL); 7809 } else { 7810 xmlNodePtr start = cur; 7811 7812 while (cur != NULL) { 7813 switch (cur->type) { 7814 case XML_ELEMENT_NODE: 7815 /* TODO: OK to have XInclude here? */ 7816 case XML_XINCLUDE_START: 7817 case XML_DOCUMENT_FRAG_NODE: 7818 if (cur != start) 7819 return(cur); 7820 if (cur->children != NULL) { 7821 cur = cur->children; 7822 continue; 7823 } 7824 break; 7825 /* Not sure if we need those here. */ 7826 case XML_DOCUMENT_NODE: 7827 #ifdef LIBXML_DOCB_ENABLED 7828 case XML_DOCB_DOCUMENT_NODE: 7829 #endif 7830 case XML_HTML_DOCUMENT_NODE: 7831 if (cur != start) 7832 return(cur); 7833 return(xmlDocGetRootElement((xmlDocPtr) cur)); 7834 default: 7835 break; 7836 } 7837 7838 next_sibling: 7839 if ((cur == NULL) || (cur == contextNode)) 7840 return(NULL); 7841 if (cur->next != NULL) { 7842 cur = cur->next; 7843 } else { 7844 cur = cur->parent; 7845 goto next_sibling; 7846 } 7847 } 7848 } 7849 return(NULL); 7850 } 7851 #endif 7852 7853 /** 7854 * xmlXPathNextDescendant: 7855 * @ctxt: the XPath Parser context 7856 * @cur: the current node in the traversal 7857 * 7858 * Traversal function for the "descendant" direction 7859 * the descendant axis contains the descendants of the context node in document 7860 * order; a descendant is a child or a child of a child and so on. 7861 * 7862 * Returns the next element following that axis 7863 */ 7864 xmlNodePtr 7865 xmlXPathNextDescendant(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) { 7866 if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL); 7867 if (cur == NULL) { 7868 if (ctxt->context->node == NULL) 7869 return(NULL); 7870 if ((ctxt->context->node->type == XML_ATTRIBUTE_NODE) || 7871 (ctxt->context->node->type == XML_NAMESPACE_DECL)) 7872 return(NULL); 7873 7874 if (ctxt->context->node == (xmlNodePtr) ctxt->context->doc) 7875 return(ctxt->context->doc->children); 7876 return(ctxt->context->node->children); 7877 } 7878 7879 if (cur->type == XML_NAMESPACE_DECL) 7880 return(NULL); 7881 if (cur->children != NULL) { 7882 /* 7883 * Do not descend on entities declarations 7884 */ 7885 if (cur->children->type != XML_ENTITY_DECL) { 7886 cur = cur->children; 7887 /* 7888 * Skip DTDs 7889 */ 7890 if (cur->type != XML_DTD_NODE) 7891 return(cur); 7892 } 7893 } 7894 7895 if (cur == ctxt->context->node) return(NULL); 7896 7897 while (cur->next != NULL) { 7898 cur = cur->next; 7899 if ((cur->type != XML_ENTITY_DECL) && 7900 (cur->type != XML_DTD_NODE)) 7901 return(cur); 7902 } 7903 7904 do { 7905 cur = cur->parent; 7906 if (cur == NULL) break; 7907 if (cur == ctxt->context->node) return(NULL); 7908 if (cur->next != NULL) { 7909 cur = cur->next; 7910 return(cur); 7911 } 7912 } while (cur != NULL); 7913 return(cur); 7914 } 7915 7916 /** 7917 * xmlXPathNextDescendantOrSelf: 7918 * @ctxt: the XPath Parser context 7919 * @cur: the current node in the traversal 7920 * 7921 * Traversal function for the "descendant-or-self" direction 7922 * the descendant-or-self axis contains the context node and the descendants 7923 * of the context node in document order; thus the context node is the first 7924 * node on the axis, and the first child of the context node is the second node 7925 * on the axis 7926 * 7927 * Returns the next element following that axis 7928 */ 7929 xmlNodePtr 7930 xmlXPathNextDescendantOrSelf(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) { 7931 if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL); 7932 if (cur == NULL) 7933 return(ctxt->context->node); 7934 7935 if (ctxt->context->node == NULL) 7936 return(NULL); 7937 if ((ctxt->context->node->type == XML_ATTRIBUTE_NODE) || 7938 (ctxt->context->node->type == XML_NAMESPACE_DECL)) 7939 return(NULL); 7940 7941 return(xmlXPathNextDescendant(ctxt, cur)); 7942 } 7943 7944 /** 7945 * xmlXPathNextParent: 7946 * @ctxt: the XPath Parser context 7947 * @cur: the current node in the traversal 7948 * 7949 * Traversal function for the "parent" direction 7950 * The parent axis contains the parent of the context node, if there is one. 7951 * 7952 * Returns the next element following that axis 7953 */ 7954 xmlNodePtr 7955 xmlXPathNextParent(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) { 7956 if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL); 7957 /* 7958 * the parent of an attribute or namespace node is the element 7959 * to which the attribute or namespace node is attached 7960 * Namespace handling !!! 7961 */ 7962 if (cur == NULL) { 7963 if (ctxt->context->node == NULL) return(NULL); 7964 switch (ctxt->context->node->type) { 7965 case XML_ELEMENT_NODE: 7966 case XML_TEXT_NODE: 7967 case XML_CDATA_SECTION_NODE: 7968 case XML_ENTITY_REF_NODE: 7969 case XML_ENTITY_NODE: 7970 case XML_PI_NODE: 7971 case XML_COMMENT_NODE: 7972 case XML_NOTATION_NODE: 7973 case XML_DTD_NODE: 7974 case XML_ELEMENT_DECL: 7975 case XML_ATTRIBUTE_DECL: 7976 case XML_XINCLUDE_START: 7977 case XML_XINCLUDE_END: 7978 case XML_ENTITY_DECL: 7979 if (ctxt->context->node->parent == NULL) 7980 return((xmlNodePtr) ctxt->context->doc); 7981 if ((ctxt->context->node->parent->type == XML_ELEMENT_NODE) && 7982 ((ctxt->context->node->parent->name[0] == ' ') || 7983 (xmlStrEqual(ctxt->context->node->parent->name, 7984 BAD_CAST "fake node libxslt")))) 7985 return(NULL); 7986 return(ctxt->context->node->parent); 7987 case XML_ATTRIBUTE_NODE: { 7988 xmlAttrPtr att = (xmlAttrPtr) ctxt->context->node; 7989 7990 return(att->parent); 7991 } 7992 case XML_DOCUMENT_NODE: 7993 case XML_DOCUMENT_TYPE_NODE: 7994 case XML_DOCUMENT_FRAG_NODE: 7995 case XML_HTML_DOCUMENT_NODE: 7996 #ifdef LIBXML_DOCB_ENABLED 7997 case XML_DOCB_DOCUMENT_NODE: 7998 #endif 7999 return(NULL); 8000 case XML_NAMESPACE_DECL: { 8001 xmlNsPtr ns = (xmlNsPtr) ctxt->context->node; 8002 8003 if ((ns->next != NULL) && 8004 (ns->next->type != XML_NAMESPACE_DECL)) 8005 return((xmlNodePtr) ns->next); 8006 return(NULL); 8007 } 8008 } 8009 } 8010 return(NULL); 8011 } 8012 8013 /** 8014 * xmlXPathNextAncestor: 8015 * @ctxt: the XPath Parser context 8016 * @cur: the current node in the traversal 8017 * 8018 * Traversal function for the "ancestor" direction 8019 * the ancestor axis contains the ancestors of the context node; the ancestors 8020 * of the context node consist of the parent of context node and the parent's 8021 * parent and so on; the nodes are ordered in reverse document order; thus the 8022 * parent is the first node on the axis, and the parent's parent is the second 8023 * node on the axis 8024 * 8025 * Returns the next element following that axis 8026 */ 8027 xmlNodePtr 8028 xmlXPathNextAncestor(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) { 8029 if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL); 8030 /* 8031 * the parent of an attribute or namespace node is the element 8032 * to which the attribute or namespace node is attached 8033 * !!!!!!!!!!!!! 8034 */ 8035 if (cur == NULL) { 8036 if (ctxt->context->node == NULL) return(NULL); 8037 switch (ctxt->context->node->type) { 8038 case XML_ELEMENT_NODE: 8039 case XML_TEXT_NODE: 8040 case XML_CDATA_SECTION_NODE: 8041 case XML_ENTITY_REF_NODE: 8042 case XML_ENTITY_NODE: 8043 case XML_PI_NODE: 8044 case XML_COMMENT_NODE: 8045 case XML_DTD_NODE: 8046 case XML_ELEMENT_DECL: 8047 case XML_ATTRIBUTE_DECL: 8048 case XML_ENTITY_DECL: 8049 case XML_NOTATION_NODE: 8050 case XML_XINCLUDE_START: 8051 case XML_XINCLUDE_END: 8052 if (ctxt->context->node->parent == NULL) 8053 return((xmlNodePtr) ctxt->context->doc); 8054 if ((ctxt->context->node->parent->type == XML_ELEMENT_NODE) && 8055 ((ctxt->context->node->parent->name[0] == ' ') || 8056 (xmlStrEqual(ctxt->context->node->parent->name, 8057 BAD_CAST "fake node libxslt")))) 8058 return(NULL); 8059 return(ctxt->context->node->parent); 8060 case XML_ATTRIBUTE_NODE: { 8061 xmlAttrPtr tmp = (xmlAttrPtr) ctxt->context->node; 8062 8063 return(tmp->parent); 8064 } 8065 case XML_DOCUMENT_NODE: 8066 case XML_DOCUMENT_TYPE_NODE: 8067 case XML_DOCUMENT_FRAG_NODE: 8068 case XML_HTML_DOCUMENT_NODE: 8069 #ifdef LIBXML_DOCB_ENABLED 8070 case XML_DOCB_DOCUMENT_NODE: 8071 #endif 8072 return(NULL); 8073 case XML_NAMESPACE_DECL: { 8074 xmlNsPtr ns = (xmlNsPtr) ctxt->context->node; 8075 8076 if ((ns->next != NULL) && 8077 (ns->next->type != XML_NAMESPACE_DECL)) 8078 return((xmlNodePtr) ns->next); 8079 /* Bad, how did that namespace end up here ? */ 8080 return(NULL); 8081 } 8082 } 8083 return(NULL); 8084 } 8085 if (cur == ctxt->context->doc->children) 8086 return((xmlNodePtr) ctxt->context->doc); 8087 if (cur == (xmlNodePtr) ctxt->context->doc) 8088 return(NULL); 8089 switch (cur->type) { 8090 case XML_ELEMENT_NODE: 8091 case XML_TEXT_NODE: 8092 case XML_CDATA_SECTION_NODE: 8093 case XML_ENTITY_REF_NODE: 8094 case XML_ENTITY_NODE: 8095 case XML_PI_NODE: 8096 case XML_COMMENT_NODE: 8097 case XML_NOTATION_NODE: 8098 case XML_DTD_NODE: 8099 case XML_ELEMENT_DECL: 8100 case XML_ATTRIBUTE_DECL: 8101 case XML_ENTITY_DECL: 8102 case XML_XINCLUDE_START: 8103 case XML_XINCLUDE_END: 8104 if (cur->parent == NULL) 8105 return(NULL); 8106 if ((cur->parent->type == XML_ELEMENT_NODE) && 8107 ((cur->parent->name[0] == ' ') || 8108 (xmlStrEqual(cur->parent->name, 8109 BAD_CAST "fake node libxslt")))) 8110 return(NULL); 8111 return(cur->parent); 8112 case XML_ATTRIBUTE_NODE: { 8113 xmlAttrPtr att = (xmlAttrPtr) cur; 8114 8115 return(att->parent); 8116 } 8117 case XML_NAMESPACE_DECL: { 8118 xmlNsPtr ns = (xmlNsPtr) cur; 8119 8120 if ((ns->next != NULL) && 8121 (ns->next->type != XML_NAMESPACE_DECL)) 8122 return((xmlNodePtr) ns->next); 8123 /* Bad, how did that namespace end up here ? */ 8124 return(NULL); 8125 } 8126 case XML_DOCUMENT_NODE: 8127 case XML_DOCUMENT_TYPE_NODE: 8128 case XML_DOCUMENT_FRAG_NODE: 8129 case XML_HTML_DOCUMENT_NODE: 8130 #ifdef LIBXML_DOCB_ENABLED 8131 case XML_DOCB_DOCUMENT_NODE: 8132 #endif 8133 return(NULL); 8134 } 8135 return(NULL); 8136 } 8137 8138 /** 8139 * xmlXPathNextAncestorOrSelf: 8140 * @ctxt: the XPath Parser context 8141 * @cur: the current node in the traversal 8142 * 8143 * Traversal function for the "ancestor-or-self" direction 8144 * he ancestor-or-self axis contains the context node and ancestors of 8145 * the context node in reverse document order; thus the context node is 8146 * the first node on the axis, and the context node's parent the second; 8147 * parent here is defined the same as with the parent axis. 8148 * 8149 * Returns the next element following that axis 8150 */ 8151 xmlNodePtr 8152 xmlXPathNextAncestorOrSelf(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) { 8153 if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL); 8154 if (cur == NULL) 8155 return(ctxt->context->node); 8156 return(xmlXPathNextAncestor(ctxt, cur)); 8157 } 8158 8159 /** 8160 * xmlXPathNextFollowingSibling: 8161 * @ctxt: the XPath Parser context 8162 * @cur: the current node in the traversal 8163 * 8164 * Traversal function for the "following-sibling" direction 8165 * The following-sibling axis contains the following siblings of the context 8166 * node in document order. 8167 * 8168 * Returns the next element following that axis 8169 */ 8170 xmlNodePtr 8171 xmlXPathNextFollowingSibling(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) { 8172 if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL); 8173 if ((ctxt->context->node->type == XML_ATTRIBUTE_NODE) || 8174 (ctxt->context->node->type == XML_NAMESPACE_DECL)) 8175 return(NULL); 8176 if (cur == (xmlNodePtr) ctxt->context->doc) 8177 return(NULL); 8178 if (cur == NULL) 8179 return(ctxt->context->node->next); 8180 return(cur->next); 8181 } 8182 8183 /** 8184 * xmlXPathNextPrecedingSibling: 8185 * @ctxt: the XPath Parser context 8186 * @cur: the current node in the traversal 8187 * 8188 * Traversal function for the "preceding-sibling" direction 8189 * The preceding-sibling axis contains the preceding siblings of the context 8190 * node in reverse document order; the first preceding sibling is first on the 8191 * axis; the sibling preceding that node is the second on the axis and so on. 8192 * 8193 * Returns the next element following that axis 8194 */ 8195 xmlNodePtr 8196 xmlXPathNextPrecedingSibling(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) { 8197 if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL); 8198 if ((ctxt->context->node->type == XML_ATTRIBUTE_NODE) || 8199 (ctxt->context->node->type == XML_NAMESPACE_DECL)) 8200 return(NULL); 8201 if (cur == (xmlNodePtr) ctxt->context->doc) 8202 return(NULL); 8203 if (cur == NULL) 8204 return(ctxt->context->node->prev); 8205 if ((cur->prev != NULL) && (cur->prev->type == XML_DTD_NODE)) { 8206 cur = cur->prev; 8207 if (cur == NULL) 8208 return(ctxt->context->node->prev); 8209 } 8210 return(cur->prev); 8211 } 8212 8213 /** 8214 * xmlXPathNextFollowing: 8215 * @ctxt: the XPath Parser context 8216 * @cur: the current node in the traversal 8217 * 8218 * Traversal function for the "following" direction 8219 * The following axis contains all nodes in the same document as the context 8220 * node that are after the context node in document order, excluding any 8221 * descendants and excluding attribute nodes and namespace nodes; the nodes 8222 * are ordered in document order 8223 * 8224 * Returns the next element following that axis 8225 */ 8226 xmlNodePtr 8227 xmlXPathNextFollowing(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) { 8228 if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL); 8229 if ((cur != NULL) && (cur->type != XML_ATTRIBUTE_NODE) && 8230 (cur->type != XML_NAMESPACE_DECL) && (cur->children != NULL)) 8231 return(cur->children); 8232 8233 if (cur == NULL) { 8234 cur = ctxt->context->node; 8235 if (cur->type == XML_ATTRIBUTE_NODE) { 8236 cur = cur->parent; 8237 } else if (cur->type == XML_NAMESPACE_DECL) { 8238 xmlNsPtr ns = (xmlNsPtr) cur; 8239 8240 if ((ns->next == NULL) || 8241 (ns->next->type == XML_NAMESPACE_DECL)) 8242 return (NULL); 8243 cur = (xmlNodePtr) ns->next; 8244 } 8245 } 8246 if (cur == NULL) return(NULL) ; /* ERROR */ 8247 if (cur->next != NULL) return(cur->next) ; 8248 do { 8249 cur = cur->parent; 8250 if (cur == NULL) break; 8251 if (cur == (xmlNodePtr) ctxt->context->doc) return(NULL); 8252 if (cur->next != NULL) return(cur->next); 8253 } while (cur != NULL); 8254 return(cur); 8255 } 8256 8257 /* 8258 * xmlXPathIsAncestor: 8259 * @ancestor: the ancestor node 8260 * @node: the current node 8261 * 8262 * Check that @ancestor is a @node's ancestor 8263 * 8264 * returns 1 if @ancestor is a @node's ancestor, 0 otherwise. 8265 */ 8266 static int 8267 xmlXPathIsAncestor(xmlNodePtr ancestor, xmlNodePtr node) { 8268 if ((ancestor == NULL) || (node == NULL)) return(0); 8269 if (node->type == XML_NAMESPACE_DECL) 8270 return(0); 8271 if (ancestor->type == XML_NAMESPACE_DECL) 8272 return(0); 8273 /* nodes need to be in the same document */ 8274 if (ancestor->doc != node->doc) return(0); 8275 /* avoid searching if ancestor or node is the root node */ 8276 if (ancestor == (xmlNodePtr) node->doc) return(1); 8277 if (node == (xmlNodePtr) ancestor->doc) return(0); 8278 while (node->parent != NULL) { 8279 if (node->parent == ancestor) 8280 return(1); 8281 node = node->parent; 8282 } 8283 return(0); 8284 } 8285 8286 /** 8287 * xmlXPathNextPreceding: 8288 * @ctxt: the XPath Parser context 8289 * @cur: the current node in the traversal 8290 * 8291 * Traversal function for the "preceding" direction 8292 * the preceding axis contains all nodes in the same document as the context 8293 * node that are before the context node in document order, excluding any 8294 * ancestors and excluding attribute nodes and namespace nodes; the nodes are 8295 * ordered in reverse document order 8296 * 8297 * Returns the next element following that axis 8298 */ 8299 xmlNodePtr 8300 xmlXPathNextPreceding(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) 8301 { 8302 if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL); 8303 if (cur == NULL) { 8304 cur = ctxt->context->node; 8305 if (cur->type == XML_ATTRIBUTE_NODE) { 8306 cur = cur->parent; 8307 } else if (cur->type == XML_NAMESPACE_DECL) { 8308 xmlNsPtr ns = (xmlNsPtr) cur; 8309 8310 if ((ns->next == NULL) || 8311 (ns->next->type == XML_NAMESPACE_DECL)) 8312 return (NULL); 8313 cur = (xmlNodePtr) ns->next; 8314 } 8315 } 8316 if ((cur == NULL) || (cur->type == XML_NAMESPACE_DECL)) 8317 return (NULL); 8318 if ((cur->prev != NULL) && (cur->prev->type == XML_DTD_NODE)) 8319 cur = cur->prev; 8320 do { 8321 if (cur->prev != NULL) { 8322 for (cur = cur->prev; cur->last != NULL; cur = cur->last) ; 8323 return (cur); 8324 } 8325 8326 cur = cur->parent; 8327 if (cur == NULL) 8328 return (NULL); 8329 if (cur == ctxt->context->doc->children) 8330 return (NULL); 8331 } while (xmlXPathIsAncestor(cur, ctxt->context->node)); 8332 return (cur); 8333 } 8334 8335 /** 8336 * xmlXPathNextPrecedingInternal: 8337 * @ctxt: the XPath Parser context 8338 * @cur: the current node in the traversal 8339 * 8340 * Traversal function for the "preceding" direction 8341 * the preceding axis contains all nodes in the same document as the context 8342 * node that are before the context node in document order, excluding any 8343 * ancestors and excluding attribute nodes and namespace nodes; the nodes are 8344 * ordered in reverse document order 8345 * This is a faster implementation but internal only since it requires a 8346 * state kept in the parser context: ctxt->ancestor. 8347 * 8348 * Returns the next element following that axis 8349 */ 8350 static xmlNodePtr 8351 xmlXPathNextPrecedingInternal(xmlXPathParserContextPtr ctxt, 8352 xmlNodePtr cur) 8353 { 8354 if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL); 8355 if (cur == NULL) { 8356 cur = ctxt->context->node; 8357 if (cur == NULL) 8358 return (NULL); 8359 if (cur->type == XML_ATTRIBUTE_NODE) { 8360 cur = cur->parent; 8361 } else if (cur->type == XML_NAMESPACE_DECL) { 8362 xmlNsPtr ns = (xmlNsPtr) cur; 8363 8364 if ((ns->next == NULL) || 8365 (ns->next->type == XML_NAMESPACE_DECL)) 8366 return (NULL); 8367 cur = (xmlNodePtr) ns->next; 8368 } 8369 ctxt->ancestor = cur->parent; 8370 } 8371 if (cur->type == XML_NAMESPACE_DECL) 8372 return(NULL); 8373 if ((cur->prev != NULL) && (cur->prev->type == XML_DTD_NODE)) 8374 cur = cur->prev; 8375 while (cur->prev == NULL) { 8376 cur = cur->parent; 8377 if (cur == NULL) 8378 return (NULL); 8379 if (cur == ctxt->context->doc->children) 8380 return (NULL); 8381 if (cur != ctxt->ancestor) 8382 return (cur); 8383 ctxt->ancestor = cur->parent; 8384 } 8385 cur = cur->prev; 8386 while (cur->last != NULL) 8387 cur = cur->last; 8388 return (cur); 8389 } 8390 8391 /** 8392 * xmlXPathNextNamespace: 8393 * @ctxt: the XPath Parser context 8394 * @cur: the current attribute in the traversal 8395 * 8396 * Traversal function for the "namespace" direction 8397 * the namespace axis contains the namespace nodes of the context node; 8398 * the order of nodes on this axis is implementation-defined; the axis will 8399 * be empty unless the context node is an element 8400 * 8401 * We keep the XML namespace node at the end of the list. 8402 * 8403 * Returns the next element following that axis 8404 */ 8405 xmlNodePtr 8406 xmlXPathNextNamespace(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) { 8407 if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL); 8408 if (ctxt->context->node->type != XML_ELEMENT_NODE) return(NULL); 8409 if (cur == NULL) { 8410 if (ctxt->context->tmpNsList != NULL) 8411 xmlFree(ctxt->context->tmpNsList); 8412 ctxt->context->tmpNsList = 8413 xmlGetNsList(ctxt->context->doc, ctxt->context->node); 8414 ctxt->context->tmpNsNr = 0; 8415 if (ctxt->context->tmpNsList != NULL) { 8416 while (ctxt->context->tmpNsList[ctxt->context->tmpNsNr] != NULL) { 8417 ctxt->context->tmpNsNr++; 8418 } 8419 } 8420 return((xmlNodePtr) xmlXPathXMLNamespace); 8421 } 8422 if (ctxt->context->tmpNsNr > 0) { 8423 return (xmlNodePtr)ctxt->context->tmpNsList[--ctxt->context->tmpNsNr]; 8424 } else { 8425 if (ctxt->context->tmpNsList != NULL) 8426 xmlFree(ctxt->context->tmpNsList); 8427 ctxt->context->tmpNsList = NULL; 8428 return(NULL); 8429 } 8430 } 8431 8432 /** 8433 * xmlXPathNextAttribute: 8434 * @ctxt: the XPath Parser context 8435 * @cur: the current attribute in the traversal 8436 * 8437 * Traversal function for the "attribute" direction 8438 * TODO: support DTD inherited default attributes 8439 * 8440 * Returns the next element following that axis 8441 */ 8442 xmlNodePtr 8443 xmlXPathNextAttribute(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) { 8444 if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL); 8445 if (ctxt->context->node == NULL) 8446 return(NULL); 8447 if (ctxt->context->node->type != XML_ELEMENT_NODE) 8448 return(NULL); 8449 if (cur == NULL) { 8450 if (ctxt->context->node == (xmlNodePtr) ctxt->context->doc) 8451 return(NULL); 8452 return((xmlNodePtr)ctxt->context->node->properties); 8453 } 8454 return((xmlNodePtr)cur->next); 8455 } 8456 8457 /************************************************************************ 8458 * * 8459 * NodeTest Functions * 8460 * * 8461 ************************************************************************/ 8462 8463 #define IS_FUNCTION 200 8464 8465 8466 /************************************************************************ 8467 * * 8468 * Implicit tree core function library * 8469 * * 8470 ************************************************************************/ 8471 8472 /** 8473 * xmlXPathRoot: 8474 * @ctxt: the XPath Parser context 8475 * 8476 * Initialize the context to the root of the document 8477 */ 8478 void 8479 xmlXPathRoot(xmlXPathParserContextPtr ctxt) { 8480 if ((ctxt == NULL) || (ctxt->context == NULL)) 8481 return; 8482 ctxt->context->node = (xmlNodePtr) ctxt->context->doc; 8483 valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context, 8484 ctxt->context->node)); 8485 } 8486 8487 /************************************************************************ 8488 * * 8489 * The explicit core function library * 8490 *http://www.w3.org/Style/XSL/Group/1999/07/xpath-19990705.html#corelib * 8491 * * 8492 ************************************************************************/ 8493 8494 8495 /** 8496 * xmlXPathLastFunction: 8497 * @ctxt: the XPath Parser context 8498 * @nargs: the number of arguments 8499 * 8500 * Implement the last() XPath function 8501 * number last() 8502 * The last function returns the number of nodes in the context node list. 8503 */ 8504 void 8505 xmlXPathLastFunction(xmlXPathParserContextPtr ctxt, int nargs) { 8506 CHECK_ARITY(0); 8507 if (ctxt->context->contextSize >= 0) { 8508 valuePush(ctxt, 8509 xmlXPathCacheNewFloat(ctxt->context, 8510 (double) ctxt->context->contextSize)); 8511 #ifdef DEBUG_EXPR 8512 xmlGenericError(xmlGenericErrorContext, 8513 "last() : %d\n", ctxt->context->contextSize); 8514 #endif 8515 } else { 8516 XP_ERROR(XPATH_INVALID_CTXT_SIZE); 8517 } 8518 } 8519 8520 /** 8521 * xmlXPathPositionFunction: 8522 * @ctxt: the XPath Parser context 8523 * @nargs: the number of arguments 8524 * 8525 * Implement the position() XPath function 8526 * number position() 8527 * The position function returns the position of the context node in the 8528 * context node list. The first position is 1, and so the last position 8529 * will be equal to last(). 8530 */ 8531 void 8532 xmlXPathPositionFunction(xmlXPathParserContextPtr ctxt, int nargs) { 8533 CHECK_ARITY(0); 8534 if (ctxt->context->proximityPosition >= 0) { 8535 valuePush(ctxt, 8536 xmlXPathCacheNewFloat(ctxt->context, 8537 (double) ctxt->context->proximityPosition)); 8538 #ifdef DEBUG_EXPR 8539 xmlGenericError(xmlGenericErrorContext, "position() : %d\n", 8540 ctxt->context->proximityPosition); 8541 #endif 8542 } else { 8543 XP_ERROR(XPATH_INVALID_CTXT_POSITION); 8544 } 8545 } 8546 8547 /** 8548 * xmlXPathCountFunction: 8549 * @ctxt: the XPath Parser context 8550 * @nargs: the number of arguments 8551 * 8552 * Implement the count() XPath function 8553 * number count(node-set) 8554 */ 8555 void 8556 xmlXPathCountFunction(xmlXPathParserContextPtr ctxt, int nargs) { 8557 xmlXPathObjectPtr cur; 8558 8559 CHECK_ARITY(1); 8560 if ((ctxt->value == NULL) || 8561 ((ctxt->value->type != XPATH_NODESET) && 8562 (ctxt->value->type != XPATH_XSLT_TREE))) 8563 XP_ERROR(XPATH_INVALID_TYPE); 8564 cur = valuePop(ctxt); 8565 8566 if ((cur == NULL) || (cur->nodesetval == NULL)) 8567 valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, (double) 0)); 8568 else if ((cur->type == XPATH_NODESET) || (cur->type == XPATH_XSLT_TREE)) { 8569 valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, 8570 (double) cur->nodesetval->nodeNr)); 8571 } else { 8572 if ((cur->nodesetval->nodeNr != 1) || 8573 (cur->nodesetval->nodeTab == NULL)) { 8574 valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, (double) 0)); 8575 } else { 8576 xmlNodePtr tmp; 8577 int i = 0; 8578 8579 tmp = cur->nodesetval->nodeTab[0]; 8580 if ((tmp != NULL) && (tmp->type != XML_NAMESPACE_DECL)) { 8581 tmp = tmp->children; 8582 while (tmp != NULL) { 8583 tmp = tmp->next; 8584 i++; 8585 } 8586 } 8587 valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, (double) i)); 8588 } 8589 } 8590 xmlXPathReleaseObject(ctxt->context, cur); 8591 } 8592 8593 /** 8594 * xmlXPathGetElementsByIds: 8595 * @doc: the document 8596 * @ids: a whitespace separated list of IDs 8597 * 8598 * Selects elements by their unique ID. 8599 * 8600 * Returns a node-set of selected elements. 8601 */ 8602 static xmlNodeSetPtr 8603 xmlXPathGetElementsByIds (xmlDocPtr doc, const xmlChar *ids) { 8604 xmlNodeSetPtr ret; 8605 const xmlChar *cur = ids; 8606 xmlChar *ID; 8607 xmlAttrPtr attr; 8608 xmlNodePtr elem = NULL; 8609 8610 if (ids == NULL) return(NULL); 8611 8612 ret = xmlXPathNodeSetCreate(NULL); 8613 if (ret == NULL) 8614 return(ret); 8615 8616 while (IS_BLANK_CH(*cur)) cur++; 8617 while (*cur != 0) { 8618 while ((!IS_BLANK_CH(*cur)) && (*cur != 0)) 8619 cur++; 8620 8621 ID = xmlStrndup(ids, cur - ids); 8622 if (ID != NULL) { 8623 /* 8624 * We used to check the fact that the value passed 8625 * was an NCName, but this generated much troubles for 8626 * me and Aleksey Sanin, people blatantly violated that 8627 * constaint, like Visa3D spec. 8628 * if (xmlValidateNCName(ID, 1) == 0) 8629 */ 8630 attr = xmlGetID(doc, ID); 8631 if (attr != NULL) { 8632 if (attr->type == XML_ATTRIBUTE_NODE) 8633 elem = attr->parent; 8634 else if (attr->type == XML_ELEMENT_NODE) 8635 elem = (xmlNodePtr) attr; 8636 else 8637 elem = NULL; 8638 if (elem != NULL) 8639 xmlXPathNodeSetAdd(ret, elem); 8640 } 8641 xmlFree(ID); 8642 } 8643 8644 while (IS_BLANK_CH(*cur)) cur++; 8645 ids = cur; 8646 } 8647 return(ret); 8648 } 8649 8650 /** 8651 * xmlXPathIdFunction: 8652 * @ctxt: the XPath Parser context 8653 * @nargs: the number of arguments 8654 * 8655 * Implement the id() XPath function 8656 * node-set id(object) 8657 * The id function selects elements by their unique ID 8658 * (see [5.2.1 Unique IDs]). When the argument to id is of type node-set, 8659 * then the result is the union of the result of applying id to the 8660 * string value of each of the nodes in the argument node-set. When the 8661 * argument to id is of any other type, the argument is converted to a 8662 * string as if by a call to the string function; the string is split 8663 * into a whitespace-separated list of tokens (whitespace is any sequence 8664 * of characters matching the production S); the result is a node-set 8665 * containing the elements in the same document as the context node that 8666 * have a unique ID equal to any of the tokens in the list. 8667 */ 8668 void 8669 xmlXPathIdFunction(xmlXPathParserContextPtr ctxt, int nargs) { 8670 xmlChar *tokens; 8671 xmlNodeSetPtr ret; 8672 xmlXPathObjectPtr obj; 8673 8674 CHECK_ARITY(1); 8675 obj = valuePop(ctxt); 8676 if (obj == NULL) XP_ERROR(XPATH_INVALID_OPERAND); 8677 if ((obj->type == XPATH_NODESET) || (obj->type == XPATH_XSLT_TREE)) { 8678 xmlNodeSetPtr ns; 8679 int i; 8680 8681 ret = xmlXPathNodeSetCreate(NULL); 8682 /* 8683 * FIXME -- in an out-of-memory condition this will behave badly. 8684 * The solution is not clear -- we already popped an item from 8685 * ctxt, so the object is in a corrupt state. 8686 */ 8687 8688 if (obj->nodesetval != NULL) { 8689 for (i = 0; i < obj->nodesetval->nodeNr; i++) { 8690 tokens = 8691 xmlXPathCastNodeToString(obj->nodesetval->nodeTab[i]); 8692 ns = xmlXPathGetElementsByIds(ctxt->context->doc, tokens); 8693 ret = xmlXPathNodeSetMerge(ret, ns); 8694 xmlXPathFreeNodeSet(ns); 8695 if (tokens != NULL) 8696 xmlFree(tokens); 8697 } 8698 } 8699 xmlXPathReleaseObject(ctxt->context, obj); 8700 valuePush(ctxt, xmlXPathCacheWrapNodeSet(ctxt->context, ret)); 8701 return; 8702 } 8703 obj = xmlXPathCacheConvertString(ctxt->context, obj); 8704 ret = xmlXPathGetElementsByIds(ctxt->context->doc, obj->stringval); 8705 valuePush(ctxt, xmlXPathCacheWrapNodeSet(ctxt->context, ret)); 8706 xmlXPathReleaseObject(ctxt->context, obj); 8707 return; 8708 } 8709 8710 /** 8711 * xmlXPathLocalNameFunction: 8712 * @ctxt: the XPath Parser context 8713 * @nargs: the number of arguments 8714 * 8715 * Implement the local-name() XPath function 8716 * string local-name(node-set?) 8717 * The local-name function returns a string containing the local part 8718 * of the name of the node in the argument node-set that is first in 8719 * document order. If the node-set is empty or the first node has no 8720 * name, an empty string is returned. If the argument is omitted it 8721 * defaults to the context node. 8722 */ 8723 void 8724 xmlXPathLocalNameFunction(xmlXPathParserContextPtr ctxt, int nargs) { 8725 xmlXPathObjectPtr cur; 8726 8727 if (ctxt == NULL) return; 8728 8729 if (nargs == 0) { 8730 valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context, 8731 ctxt->context->node)); 8732 nargs = 1; 8733 } 8734 8735 CHECK_ARITY(1); 8736 if ((ctxt->value == NULL) || 8737 ((ctxt->value->type != XPATH_NODESET) && 8738 (ctxt->value->type != XPATH_XSLT_TREE))) 8739 XP_ERROR(XPATH_INVALID_TYPE); 8740 cur = valuePop(ctxt); 8741 8742 if ((cur->nodesetval == NULL) || (cur->nodesetval->nodeNr == 0)) { 8743 valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, "")); 8744 } else { 8745 int i = 0; /* Should be first in document order !!!!! */ 8746 switch (cur->nodesetval->nodeTab[i]->type) { 8747 case XML_ELEMENT_NODE: 8748 case XML_ATTRIBUTE_NODE: 8749 case XML_PI_NODE: 8750 if (cur->nodesetval->nodeTab[i]->name[0] == ' ') 8751 valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, "")); 8752 else 8753 valuePush(ctxt, 8754 xmlXPathCacheNewString(ctxt->context, 8755 cur->nodesetval->nodeTab[i]->name)); 8756 break; 8757 case XML_NAMESPACE_DECL: 8758 valuePush(ctxt, xmlXPathCacheNewString(ctxt->context, 8759 ((xmlNsPtr)cur->nodesetval->nodeTab[i])->prefix)); 8760 break; 8761 default: 8762 valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, "")); 8763 } 8764 } 8765 xmlXPathReleaseObject(ctxt->context, cur); 8766 } 8767 8768 /** 8769 * xmlXPathNamespaceURIFunction: 8770 * @ctxt: the XPath Parser context 8771 * @nargs: the number of arguments 8772 * 8773 * Implement the namespace-uri() XPath function 8774 * string namespace-uri(node-set?) 8775 * The namespace-uri function returns a string containing the 8776 * namespace URI of the expanded name of the node in the argument 8777 * node-set that is first in document order. If the node-set is empty, 8778 * the first node has no name, or the expanded name has no namespace 8779 * URI, an empty string is returned. If the argument is omitted it 8780 * defaults to the context node. 8781 */ 8782 void 8783 xmlXPathNamespaceURIFunction(xmlXPathParserContextPtr ctxt, int nargs) { 8784 xmlXPathObjectPtr cur; 8785 8786 if (ctxt == NULL) return; 8787 8788 if (nargs == 0) { 8789 valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context, 8790 ctxt->context->node)); 8791 nargs = 1; 8792 } 8793 CHECK_ARITY(1); 8794 if ((ctxt->value == NULL) || 8795 ((ctxt->value->type != XPATH_NODESET) && 8796 (ctxt->value->type != XPATH_XSLT_TREE))) 8797 XP_ERROR(XPATH_INVALID_TYPE); 8798 cur = valuePop(ctxt); 8799 8800 if ((cur->nodesetval == NULL) || (cur->nodesetval->nodeNr == 0)) { 8801 valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, "")); 8802 } else { 8803 int i = 0; /* Should be first in document order !!!!! */ 8804 switch (cur->nodesetval->nodeTab[i]->type) { 8805 case XML_ELEMENT_NODE: 8806 case XML_ATTRIBUTE_NODE: 8807 if (cur->nodesetval->nodeTab[i]->ns == NULL) 8808 valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, "")); 8809 else 8810 valuePush(ctxt, xmlXPathCacheNewString(ctxt->context, 8811 cur->nodesetval->nodeTab[i]->ns->href)); 8812 break; 8813 default: 8814 valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, "")); 8815 } 8816 } 8817 xmlXPathReleaseObject(ctxt->context, cur); 8818 } 8819 8820 /** 8821 * xmlXPathNameFunction: 8822 * @ctxt: the XPath Parser context 8823 * @nargs: the number of arguments 8824 * 8825 * Implement the name() XPath function 8826 * string name(node-set?) 8827 * The name function returns a string containing a QName representing 8828 * the name of the node in the argument node-set that is first in document 8829 * order. The QName must represent the name with respect to the namespace 8830 * declarations in effect on the node whose name is being represented. 8831 * Typically, this will be the form in which the name occurred in the XML 8832 * source. This need not be the case if there are namespace declarations 8833 * in effect on the node that associate multiple prefixes with the same 8834 * namespace. However, an implementation may include information about 8835 * the original prefix in its representation of nodes; in this case, an 8836 * implementation can ensure that the returned string is always the same 8837 * as the QName used in the XML source. If the argument it omitted it 8838 * defaults to the context node. 8839 * Libxml keep the original prefix so the "real qualified name" used is 8840 * returned. 8841 */ 8842 static void 8843 xmlXPathNameFunction(xmlXPathParserContextPtr ctxt, int nargs) 8844 { 8845 xmlXPathObjectPtr cur; 8846 8847 if (nargs == 0) { 8848 valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context, 8849 ctxt->context->node)); 8850 nargs = 1; 8851 } 8852 8853 CHECK_ARITY(1); 8854 if ((ctxt->value == NULL) || 8855 ((ctxt->value->type != XPATH_NODESET) && 8856 (ctxt->value->type != XPATH_XSLT_TREE))) 8857 XP_ERROR(XPATH_INVALID_TYPE); 8858 cur = valuePop(ctxt); 8859 8860 if ((cur->nodesetval == NULL) || (cur->nodesetval->nodeNr == 0)) { 8861 valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, "")); 8862 } else { 8863 int i = 0; /* Should be first in document order !!!!! */ 8864 8865 switch (cur->nodesetval->nodeTab[i]->type) { 8866 case XML_ELEMENT_NODE: 8867 case XML_ATTRIBUTE_NODE: 8868 if (cur->nodesetval->nodeTab[i]->name[0] == ' ') 8869 valuePush(ctxt, 8870 xmlXPathCacheNewCString(ctxt->context, "")); 8871 else if ((cur->nodesetval->nodeTab[i]->ns == NULL) || 8872 (cur->nodesetval->nodeTab[i]->ns->prefix == NULL)) { 8873 valuePush(ctxt, 8874 xmlXPathCacheNewString(ctxt->context, 8875 cur->nodesetval->nodeTab[i]->name)); 8876 } else { 8877 xmlChar *fullname; 8878 8879 fullname = xmlBuildQName(cur->nodesetval->nodeTab[i]->name, 8880 cur->nodesetval->nodeTab[i]->ns->prefix, 8881 NULL, 0); 8882 if (fullname == cur->nodesetval->nodeTab[i]->name) 8883 fullname = xmlStrdup(cur->nodesetval->nodeTab[i]->name); 8884 if (fullname == NULL) { 8885 XP_ERROR(XPATH_MEMORY_ERROR); 8886 } 8887 valuePush(ctxt, xmlXPathCacheWrapString( 8888 ctxt->context, fullname)); 8889 } 8890 break; 8891 default: 8892 valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context, 8893 cur->nodesetval->nodeTab[i])); 8894 xmlXPathLocalNameFunction(ctxt, 1); 8895 } 8896 } 8897 xmlXPathReleaseObject(ctxt->context, cur); 8898 } 8899 8900 8901 /** 8902 * xmlXPathStringFunction: 8903 * @ctxt: the XPath Parser context 8904 * @nargs: the number of arguments 8905 * 8906 * Implement the string() XPath function 8907 * string string(object?) 8908 * The string function converts an object to a string as follows: 8909 * - A node-set is converted to a string by returning the value of 8910 * the node in the node-set that is first in document order. 8911 * If the node-set is empty, an empty string is returned. 8912 * - A number is converted to a string as follows 8913 * + NaN is converted to the string NaN 8914 * + positive zero is converted to the string 0 8915 * + negative zero is converted to the string 0 8916 * + positive infinity is converted to the string Infinity 8917 * + negative infinity is converted to the string -Infinity 8918 * + if the number is an integer, the number is represented in 8919 * decimal form as a Number with no decimal point and no leading 8920 * zeros, preceded by a minus sign (-) if the number is negative 8921 * + otherwise, the number is represented in decimal form as a 8922 * Number including a decimal point with at least one digit 8923 * before the decimal point and at least one digit after the 8924 * decimal point, preceded by a minus sign (-) if the number 8925 * is negative; there must be no leading zeros before the decimal 8926 * point apart possibly from the one required digit immediately 8927 * before the decimal point; beyond the one required digit 8928 * after the decimal point there must be as many, but only as 8929 * many, more digits as are needed to uniquely distinguish the 8930 * number from all other IEEE 754 numeric values. 8931 * - The boolean false value is converted to the string false. 8932 * The boolean true value is converted to the string true. 8933 * 8934 * If the argument is omitted, it defaults to a node-set with the 8935 * context node as its only member. 8936 */ 8937 void 8938 xmlXPathStringFunction(xmlXPathParserContextPtr ctxt, int nargs) { 8939 xmlXPathObjectPtr cur; 8940 8941 if (ctxt == NULL) return; 8942 if (nargs == 0) { 8943 valuePush(ctxt, 8944 xmlXPathCacheWrapString(ctxt->context, 8945 xmlXPathCastNodeToString(ctxt->context->node))); 8946 return; 8947 } 8948 8949 CHECK_ARITY(1); 8950 cur = valuePop(ctxt); 8951 if (cur == NULL) XP_ERROR(XPATH_INVALID_OPERAND); 8952 valuePush(ctxt, xmlXPathCacheConvertString(ctxt->context, cur)); 8953 } 8954 8955 /** 8956 * xmlXPathStringLengthFunction: 8957 * @ctxt: the XPath Parser context 8958 * @nargs: the number of arguments 8959 * 8960 * Implement the string-length() XPath function 8961 * number string-length(string?) 8962 * The string-length returns the number of characters in the string 8963 * (see [3.6 Strings]). If the argument is omitted, it defaults to 8964 * the context node converted to a string, in other words the value 8965 * of the context node. 8966 */ 8967 void 8968 xmlXPathStringLengthFunction(xmlXPathParserContextPtr ctxt, int nargs) { 8969 xmlXPathObjectPtr cur; 8970 8971 if (nargs == 0) { 8972 if ((ctxt == NULL) || (ctxt->context == NULL)) 8973 return; 8974 if (ctxt->context->node == NULL) { 8975 valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, 0)); 8976 } else { 8977 xmlChar *content; 8978 8979 content = xmlXPathCastNodeToString(ctxt->context->node); 8980 valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, 8981 xmlUTF8Strlen(content))); 8982 xmlFree(content); 8983 } 8984 return; 8985 } 8986 CHECK_ARITY(1); 8987 CAST_TO_STRING; 8988 CHECK_TYPE(XPATH_STRING); 8989 cur = valuePop(ctxt); 8990 valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, 8991 xmlUTF8Strlen(cur->stringval))); 8992 xmlXPathReleaseObject(ctxt->context, cur); 8993 } 8994 8995 /** 8996 * xmlXPathConcatFunction: 8997 * @ctxt: the XPath Parser context 8998 * @nargs: the number of arguments 8999 * 9000 * Implement the concat() XPath function 9001 * string concat(string, string, string*) 9002 * The concat function returns the concatenation of its arguments. 9003 */ 9004 void 9005 xmlXPathConcatFunction(xmlXPathParserContextPtr ctxt, int nargs) { 9006 xmlXPathObjectPtr cur, newobj; 9007 xmlChar *tmp; 9008 9009 if (ctxt == NULL) return; 9010 if (nargs < 2) { 9011 CHECK_ARITY(2); 9012 } 9013 9014 CAST_TO_STRING; 9015 cur = valuePop(ctxt); 9016 if ((cur == NULL) || (cur->type != XPATH_STRING)) { 9017 xmlXPathReleaseObject(ctxt->context, cur); 9018 return; 9019 } 9020 nargs--; 9021 9022 while (nargs > 0) { 9023 CAST_TO_STRING; 9024 newobj = valuePop(ctxt); 9025 if ((newobj == NULL) || (newobj->type != XPATH_STRING)) { 9026 xmlXPathReleaseObject(ctxt->context, newobj); 9027 xmlXPathReleaseObject(ctxt->context, cur); 9028 XP_ERROR(XPATH_INVALID_TYPE); 9029 } 9030 tmp = xmlStrcat(newobj->stringval, cur->stringval); 9031 newobj->stringval = cur->stringval; 9032 cur->stringval = tmp; 9033 xmlXPathReleaseObject(ctxt->context, newobj); 9034 nargs--; 9035 } 9036 valuePush(ctxt, cur); 9037 } 9038 9039 /** 9040 * xmlXPathContainsFunction: 9041 * @ctxt: the XPath Parser context 9042 * @nargs: the number of arguments 9043 * 9044 * Implement the contains() XPath function 9045 * boolean contains(string, string) 9046 * The contains function returns true if the first argument string 9047 * contains the second argument string, and otherwise returns false. 9048 */ 9049 void 9050 xmlXPathContainsFunction(xmlXPathParserContextPtr ctxt, int nargs) { 9051 xmlXPathObjectPtr hay, needle; 9052 9053 CHECK_ARITY(2); 9054 CAST_TO_STRING; 9055 CHECK_TYPE(XPATH_STRING); 9056 needle = valuePop(ctxt); 9057 CAST_TO_STRING; 9058 hay = valuePop(ctxt); 9059 9060 if ((hay == NULL) || (hay->type != XPATH_STRING)) { 9061 xmlXPathReleaseObject(ctxt->context, hay); 9062 xmlXPathReleaseObject(ctxt->context, needle); 9063 XP_ERROR(XPATH_INVALID_TYPE); 9064 } 9065 if (xmlStrstr(hay->stringval, needle->stringval)) 9066 valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, 1)); 9067 else 9068 valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, 0)); 9069 xmlXPathReleaseObject(ctxt->context, hay); 9070 xmlXPathReleaseObject(ctxt->context, needle); 9071 } 9072 9073 /** 9074 * xmlXPathStartsWithFunction: 9075 * @ctxt: the XPath Parser context 9076 * @nargs: the number of arguments 9077 * 9078 * Implement the starts-with() XPath function 9079 * boolean starts-with(string, string) 9080 * The starts-with function returns true if the first argument string 9081 * starts with the second argument string, and otherwise returns false. 9082 */ 9083 void 9084 xmlXPathStartsWithFunction(xmlXPathParserContextPtr ctxt, int nargs) { 9085 xmlXPathObjectPtr hay, needle; 9086 int n; 9087 9088 CHECK_ARITY(2); 9089 CAST_TO_STRING; 9090 CHECK_TYPE(XPATH_STRING); 9091 needle = valuePop(ctxt); 9092 CAST_TO_STRING; 9093 hay = valuePop(ctxt); 9094 9095 if ((hay == NULL) || (hay->type != XPATH_STRING)) { 9096 xmlXPathReleaseObject(ctxt->context, hay); 9097 xmlXPathReleaseObject(ctxt->context, needle); 9098 XP_ERROR(XPATH_INVALID_TYPE); 9099 } 9100 n = xmlStrlen(needle->stringval); 9101 if (xmlStrncmp(hay->stringval, needle->stringval, n)) 9102 valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, 0)); 9103 else 9104 valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, 1)); 9105 xmlXPathReleaseObject(ctxt->context, hay); 9106 xmlXPathReleaseObject(ctxt->context, needle); 9107 } 9108 9109 /** 9110 * xmlXPathSubstringFunction: 9111 * @ctxt: the XPath Parser context 9112 * @nargs: the number of arguments 9113 * 9114 * Implement the substring() XPath function 9115 * string substring(string, number, number?) 9116 * The substring function returns the substring of the first argument 9117 * starting at the position specified in the second argument with 9118 * length specified in the third argument. For example, 9119 * substring("12345",2,3) returns "234". If the third argument is not 9120 * specified, it returns the substring starting at the position specified 9121 * in the second argument and continuing to the end of the string. For 9122 * example, substring("12345",2) returns "2345". More precisely, each 9123 * character in the string (see [3.6 Strings]) is considered to have a 9124 * numeric position: the position of the first character is 1, the position 9125 * of the second character is 2 and so on. The returned substring contains 9126 * those characters for which the position of the character is greater than 9127 * or equal to the second argument and, if the third argument is specified, 9128 * less than the sum of the second and third arguments; the comparisons 9129 * and addition used for the above follow the standard IEEE 754 rules. Thus: 9130 * - substring("12345", 1.5, 2.6) returns "234" 9131 * - substring("12345", 0, 3) returns "12" 9132 * - substring("12345", 0 div 0, 3) returns "" 9133 * - substring("12345", 1, 0 div 0) returns "" 9134 * - substring("12345", -42, 1 div 0) returns "12345" 9135 * - substring("12345", -1 div 0, 1 div 0) returns "" 9136 */ 9137 void 9138 xmlXPathSubstringFunction(xmlXPathParserContextPtr ctxt, int nargs) { 9139 xmlXPathObjectPtr str, start, len; 9140 double le=0, in; 9141 int i, l, m; 9142 xmlChar *ret; 9143 9144 if (nargs < 2) { 9145 CHECK_ARITY(2); 9146 } 9147 if (nargs > 3) { 9148 CHECK_ARITY(3); 9149 } 9150 /* 9151 * take care of possible last (position) argument 9152 */ 9153 if (nargs == 3) { 9154 CAST_TO_NUMBER; 9155 CHECK_TYPE(XPATH_NUMBER); 9156 len = valuePop(ctxt); 9157 le = len->floatval; 9158 xmlXPathReleaseObject(ctxt->context, len); 9159 } 9160 9161 CAST_TO_NUMBER; 9162 CHECK_TYPE(XPATH_NUMBER); 9163 start = valuePop(ctxt); 9164 in = start->floatval; 9165 xmlXPathReleaseObject(ctxt->context, start); 9166 CAST_TO_STRING; 9167 CHECK_TYPE(XPATH_STRING); 9168 str = valuePop(ctxt); 9169 m = xmlUTF8Strlen((const unsigned char *)str->stringval); 9170 9171 /* 9172 * If last pos not present, calculate last position 9173 */ 9174 if (nargs != 3) { 9175 le = (double)m; 9176 if (in < 1.0) 9177 in = 1.0; 9178 } 9179 9180 /* Need to check for the special cases where either 9181 * the index is NaN, the length is NaN, or both 9182 * arguments are infinity (relying on Inf + -Inf = NaN) 9183 */ 9184 if (!xmlXPathIsInf(in) && !xmlXPathIsNaN(in + le)) { 9185 /* 9186 * To meet the requirements of the spec, the arguments 9187 * must be converted to integer format before 9188 * initial index calculations are done 9189 * 9190 * First we go to integer form, rounding up 9191 * and checking for special cases 9192 */ 9193 i = (int) in; 9194 if (((double)i)+0.5 <= in) i++; 9195 9196 if (xmlXPathIsInf(le) == 1) { 9197 l = m; 9198 if (i < 1) 9199 i = 1; 9200 } 9201 else if (xmlXPathIsInf(le) == -1 || le < 0.0) 9202 l = 0; 9203 else { 9204 l = (int) le; 9205 if (((double)l)+0.5 <= le) l++; 9206 } 9207 9208 /* Now we normalize inidices */ 9209 i -= 1; 9210 l += i; 9211 if (i < 0) 9212 i = 0; 9213 if (l > m) 9214 l = m; 9215 9216 /* number of chars to copy */ 9217 l -= i; 9218 9219 ret = xmlUTF8Strsub(str->stringval, i, l); 9220 } 9221 else { 9222 ret = NULL; 9223 } 9224 if (ret == NULL) 9225 valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, "")); 9226 else { 9227 valuePush(ctxt, xmlXPathCacheNewString(ctxt->context, ret)); 9228 xmlFree(ret); 9229 } 9230 xmlXPathReleaseObject(ctxt->context, str); 9231 } 9232 9233 /** 9234 * xmlXPathSubstringBeforeFunction: 9235 * @ctxt: the XPath Parser context 9236 * @nargs: the number of arguments 9237 * 9238 * Implement the substring-before() XPath function 9239 * string substring-before(string, string) 9240 * The substring-before function returns the substring of the first 9241 * argument string that precedes the first occurrence of the second 9242 * argument string in the first argument string, or the empty string 9243 * if the first argument string does not contain the second argument 9244 * string. For example, substring-before("1999/04/01","/") returns 1999. 9245 */ 9246 void 9247 xmlXPathSubstringBeforeFunction(xmlXPathParserContextPtr ctxt, int nargs) { 9248 xmlXPathObjectPtr str; 9249 xmlXPathObjectPtr find; 9250 xmlBufPtr target; 9251 const xmlChar *point; 9252 int offset; 9253 9254 CHECK_ARITY(2); 9255 CAST_TO_STRING; 9256 find = valuePop(ctxt); 9257 CAST_TO_STRING; 9258 str = valuePop(ctxt); 9259 9260 target = xmlBufCreate(); 9261 if (target) { 9262 point = xmlStrstr(str->stringval, find->stringval); 9263 if (point) { 9264 offset = (int)(point - str->stringval); 9265 xmlBufAdd(target, str->stringval, offset); 9266 } 9267 valuePush(ctxt, xmlXPathCacheNewString(ctxt->context, 9268 xmlBufContent(target))); 9269 xmlBufFree(target); 9270 } 9271 xmlXPathReleaseObject(ctxt->context, str); 9272 xmlXPathReleaseObject(ctxt->context, find); 9273 } 9274 9275 /** 9276 * xmlXPathSubstringAfterFunction: 9277 * @ctxt: the XPath Parser context 9278 * @nargs: the number of arguments 9279 * 9280 * Implement the substring-after() XPath function 9281 * string substring-after(string, string) 9282 * The substring-after function returns the substring of the first 9283 * argument string that follows the first occurrence of the second 9284 * argument string in the first argument string, or the empty stringi 9285 * if the first argument string does not contain the second argument 9286 * string. For example, substring-after("1999/04/01","/") returns 04/01, 9287 * and substring-after("1999/04/01","19") returns 99/04/01. 9288 */ 9289 void 9290 xmlXPathSubstringAfterFunction(xmlXPathParserContextPtr ctxt, int nargs) { 9291 xmlXPathObjectPtr str; 9292 xmlXPathObjectPtr find; 9293 xmlBufPtr target; 9294 const xmlChar *point; 9295 int offset; 9296 9297 CHECK_ARITY(2); 9298 CAST_TO_STRING; 9299 find = valuePop(ctxt); 9300 CAST_TO_STRING; 9301 str = valuePop(ctxt); 9302 9303 target = xmlBufCreate(); 9304 if (target) { 9305 point = xmlStrstr(str->stringval, find->stringval); 9306 if (point) { 9307 offset = (int)(point - str->stringval) + xmlStrlen(find->stringval); 9308 xmlBufAdd(target, &str->stringval[offset], 9309 xmlStrlen(str->stringval) - offset); 9310 } 9311 valuePush(ctxt, xmlXPathCacheNewString(ctxt->context, 9312 xmlBufContent(target))); 9313 xmlBufFree(target); 9314 } 9315 xmlXPathReleaseObject(ctxt->context, str); 9316 xmlXPathReleaseObject(ctxt->context, find); 9317 } 9318 9319 /** 9320 * xmlXPathNormalizeFunction: 9321 * @ctxt: the XPath Parser context 9322 * @nargs: the number of arguments 9323 * 9324 * Implement the normalize-space() XPath function 9325 * string normalize-space(string?) 9326 * The normalize-space function returns the argument string with white 9327 * space normalized by stripping leading and trailing whitespace 9328 * and replacing sequences of whitespace characters by a single 9329 * space. Whitespace characters are the same allowed by the S production 9330 * in XML. If the argument is omitted, it defaults to the context 9331 * node converted to a string, in other words the value of the context node. 9332 */ 9333 void 9334 xmlXPathNormalizeFunction(xmlXPathParserContextPtr ctxt, int nargs) { 9335 xmlXPathObjectPtr obj = NULL; 9336 xmlChar *source = NULL; 9337 xmlBufPtr target; 9338 xmlChar blank; 9339 9340 if (ctxt == NULL) return; 9341 if (nargs == 0) { 9342 /* Use current context node */ 9343 valuePush(ctxt, 9344 xmlXPathCacheWrapString(ctxt->context, 9345 xmlXPathCastNodeToString(ctxt->context->node))); 9346 nargs = 1; 9347 } 9348 9349 CHECK_ARITY(1); 9350 CAST_TO_STRING; 9351 CHECK_TYPE(XPATH_STRING); 9352 obj = valuePop(ctxt); 9353 source = obj->stringval; 9354 9355 target = xmlBufCreate(); 9356 if (target && source) { 9357 9358 /* Skip leading whitespaces */ 9359 while (IS_BLANK_CH(*source)) 9360 source++; 9361 9362 /* Collapse intermediate whitespaces, and skip trailing whitespaces */ 9363 blank = 0; 9364 while (*source) { 9365 if (IS_BLANK_CH(*source)) { 9366 blank = 0x20; 9367 } else { 9368 if (blank) { 9369 xmlBufAdd(target, &blank, 1); 9370 blank = 0; 9371 } 9372 xmlBufAdd(target, source, 1); 9373 } 9374 source++; 9375 } 9376 valuePush(ctxt, xmlXPathCacheNewString(ctxt->context, 9377 xmlBufContent(target))); 9378 xmlBufFree(target); 9379 } 9380 xmlXPathReleaseObject(ctxt->context, obj); 9381 } 9382 9383 /** 9384 * xmlXPathTranslateFunction: 9385 * @ctxt: the XPath Parser context 9386 * @nargs: the number of arguments 9387 * 9388 * Implement the translate() XPath function 9389 * string translate(string, string, string) 9390 * The translate function returns the first argument string with 9391 * occurrences of characters in the second argument string replaced 9392 * by the character at the corresponding position in the third argument 9393 * string. For example, translate("bar","abc","ABC") returns the string 9394 * BAr. If there is a character in the second argument string with no 9395 * character at a corresponding position in the third argument string 9396 * (because the second argument string is longer than the third argument 9397 * string), then occurrences of that character in the first argument 9398 * string are removed. For example, translate("--aaa--","abc-","ABC") 9399 * returns "AAA". If a character occurs more than once in second 9400 * argument string, then the first occurrence determines the replacement 9401 * character. If the third argument string is longer than the second 9402 * argument string, then excess characters are ignored. 9403 */ 9404 void 9405 xmlXPathTranslateFunction(xmlXPathParserContextPtr ctxt, int nargs) { 9406 xmlXPathObjectPtr str; 9407 xmlXPathObjectPtr from; 9408 xmlXPathObjectPtr to; 9409 xmlBufPtr target; 9410 int offset, max; 9411 xmlChar ch; 9412 const xmlChar *point; 9413 xmlChar *cptr; 9414 9415 CHECK_ARITY(3); 9416 9417 CAST_TO_STRING; 9418 to = valuePop(ctxt); 9419 CAST_TO_STRING; 9420 from = valuePop(ctxt); 9421 CAST_TO_STRING; 9422 str = valuePop(ctxt); 9423 9424 target = xmlBufCreate(); 9425 if (target) { 9426 max = xmlUTF8Strlen(to->stringval); 9427 for (cptr = str->stringval; (ch=*cptr); ) { 9428 offset = xmlUTF8Strloc(from->stringval, cptr); 9429 if (offset >= 0) { 9430 if (offset < max) { 9431 point = xmlUTF8Strpos(to->stringval, offset); 9432 if (point) 9433 xmlBufAdd(target, point, xmlUTF8Strsize(point, 1)); 9434 } 9435 } else 9436 xmlBufAdd(target, cptr, xmlUTF8Strsize(cptr, 1)); 9437 9438 /* Step to next character in input */ 9439 cptr++; 9440 if ( ch & 0x80 ) { 9441 /* if not simple ascii, verify proper format */ 9442 if ( (ch & 0xc0) != 0xc0 ) { 9443 xmlGenericError(xmlGenericErrorContext, 9444 "xmlXPathTranslateFunction: Invalid UTF8 string\n"); 9445 /* not asserting an XPath error is probably better */ 9446 break; 9447 } 9448 /* then skip over remaining bytes for this char */ 9449 while ( (ch <<= 1) & 0x80 ) 9450 if ( (*cptr++ & 0xc0) != 0x80 ) { 9451 xmlGenericError(xmlGenericErrorContext, 9452 "xmlXPathTranslateFunction: Invalid UTF8 string\n"); 9453 /* not asserting an XPath error is probably better */ 9454 break; 9455 } 9456 if (ch & 0x80) /* must have had error encountered */ 9457 break; 9458 } 9459 } 9460 } 9461 valuePush(ctxt, xmlXPathCacheNewString(ctxt->context, 9462 xmlBufContent(target))); 9463 xmlBufFree(target); 9464 xmlXPathReleaseObject(ctxt->context, str); 9465 xmlXPathReleaseObject(ctxt->context, from); 9466 xmlXPathReleaseObject(ctxt->context, to); 9467 } 9468 9469 /** 9470 * xmlXPathBooleanFunction: 9471 * @ctxt: the XPath Parser context 9472 * @nargs: the number of arguments 9473 * 9474 * Implement the boolean() XPath function 9475 * boolean boolean(object) 9476 * The boolean function converts its argument to a boolean as follows: 9477 * - a number is true if and only if it is neither positive or 9478 * negative zero nor NaN 9479 * - a node-set is true if and only if it is non-empty 9480 * - a string is true if and only if its length is non-zero 9481 */ 9482 void 9483 xmlXPathBooleanFunction(xmlXPathParserContextPtr ctxt, int nargs) { 9484 xmlXPathObjectPtr cur; 9485 9486 CHECK_ARITY(1); 9487 cur = valuePop(ctxt); 9488 if (cur == NULL) XP_ERROR(XPATH_INVALID_OPERAND); 9489 cur = xmlXPathCacheConvertBoolean(ctxt->context, cur); 9490 valuePush(ctxt, cur); 9491 } 9492 9493 /** 9494 * xmlXPathNotFunction: 9495 * @ctxt: the XPath Parser context 9496 * @nargs: the number of arguments 9497 * 9498 * Implement the not() XPath function 9499 * boolean not(boolean) 9500 * The not function returns true if its argument is false, 9501 * and false otherwise. 9502 */ 9503 void 9504 xmlXPathNotFunction(xmlXPathParserContextPtr ctxt, int nargs) { 9505 CHECK_ARITY(1); 9506 CAST_TO_BOOLEAN; 9507 CHECK_TYPE(XPATH_BOOLEAN); 9508 ctxt->value->boolval = ! ctxt->value->boolval; 9509 } 9510 9511 /** 9512 * xmlXPathTrueFunction: 9513 * @ctxt: the XPath Parser context 9514 * @nargs: the number of arguments 9515 * 9516 * Implement the true() XPath function 9517 * boolean true() 9518 */ 9519 void 9520 xmlXPathTrueFunction(xmlXPathParserContextPtr ctxt, int nargs) { 9521 CHECK_ARITY(0); 9522 valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, 1)); 9523 } 9524 9525 /** 9526 * xmlXPathFalseFunction: 9527 * @ctxt: the XPath Parser context 9528 * @nargs: the number of arguments 9529 * 9530 * Implement the false() XPath function 9531 * boolean false() 9532 */ 9533 void 9534 xmlXPathFalseFunction(xmlXPathParserContextPtr ctxt, int nargs) { 9535 CHECK_ARITY(0); 9536 valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, 0)); 9537 } 9538 9539 /** 9540 * xmlXPathLangFunction: 9541 * @ctxt: the XPath Parser context 9542 * @nargs: the number of arguments 9543 * 9544 * Implement the lang() XPath function 9545 * boolean lang(string) 9546 * The lang function returns true or false depending on whether the 9547 * language of the context node as specified by xml:lang attributes 9548 * is the same as or is a sublanguage of the language specified by 9549 * the argument string. The language of the context node is determined 9550 * by the value of the xml:lang attribute on the context node, or, if 9551 * the context node has no xml:lang attribute, by the value of the 9552 * xml:lang attribute on the nearest ancestor of the context node that 9553 * has an xml:lang attribute. If there is no such attribute, then lang 9554 * returns false. If there is such an attribute, then lang returns 9555 * true if the attribute value is equal to the argument ignoring case, 9556 * or if there is some suffix starting with - such that the attribute 9557 * value is equal to the argument ignoring that suffix of the attribute 9558 * value and ignoring case. 9559 */ 9560 void 9561 xmlXPathLangFunction(xmlXPathParserContextPtr ctxt, int nargs) { 9562 xmlXPathObjectPtr val = NULL; 9563 const xmlChar *theLang = NULL; 9564 const xmlChar *lang; 9565 int ret = 0; 9566 int i; 9567 9568 CHECK_ARITY(1); 9569 CAST_TO_STRING; 9570 CHECK_TYPE(XPATH_STRING); 9571 val = valuePop(ctxt); 9572 lang = val->stringval; 9573 theLang = xmlNodeGetLang(ctxt->context->node); 9574 if ((theLang != NULL) && (lang != NULL)) { 9575 for (i = 0;lang[i] != 0;i++) 9576 if (toupper(lang[i]) != toupper(theLang[i])) 9577 goto not_equal; 9578 if ((theLang[i] == 0) || (theLang[i] == '-')) 9579 ret = 1; 9580 } 9581 not_equal: 9582 if (theLang != NULL) 9583 xmlFree((void *)theLang); 9584 9585 xmlXPathReleaseObject(ctxt->context, val); 9586 valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, ret)); 9587 } 9588 9589 /** 9590 * xmlXPathNumberFunction: 9591 * @ctxt: the XPath Parser context 9592 * @nargs: the number of arguments 9593 * 9594 * Implement the number() XPath function 9595 * number number(object?) 9596 */ 9597 void 9598 xmlXPathNumberFunction(xmlXPathParserContextPtr ctxt, int nargs) { 9599 xmlXPathObjectPtr cur; 9600 double res; 9601 9602 if (ctxt == NULL) return; 9603 if (nargs == 0) { 9604 if (ctxt->context->node == NULL) { 9605 valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, 0.0)); 9606 } else { 9607 xmlChar* content = xmlNodeGetContent(ctxt->context->node); 9608 9609 res = xmlXPathStringEvalNumber(content); 9610 valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, res)); 9611 xmlFree(content); 9612 } 9613 return; 9614 } 9615 9616 CHECK_ARITY(1); 9617 cur = valuePop(ctxt); 9618 valuePush(ctxt, xmlXPathCacheConvertNumber(ctxt->context, cur)); 9619 } 9620 9621 /** 9622 * xmlXPathSumFunction: 9623 * @ctxt: the XPath Parser context 9624 * @nargs: the number of arguments 9625 * 9626 * Implement the sum() XPath function 9627 * number sum(node-set) 9628 * The sum function returns the sum of the values of the nodes in 9629 * the argument node-set. 9630 */ 9631 void 9632 xmlXPathSumFunction(xmlXPathParserContextPtr ctxt, int nargs) { 9633 xmlXPathObjectPtr cur; 9634 int i; 9635 double res = 0.0; 9636 9637 CHECK_ARITY(1); 9638 if ((ctxt->value == NULL) || 9639 ((ctxt->value->type != XPATH_NODESET) && 9640 (ctxt->value->type != XPATH_XSLT_TREE))) 9641 XP_ERROR(XPATH_INVALID_TYPE); 9642 cur = valuePop(ctxt); 9643 9644 if ((cur->nodesetval != NULL) && (cur->nodesetval->nodeNr != 0)) { 9645 for (i = 0; i < cur->nodesetval->nodeNr; i++) { 9646 res += xmlXPathCastNodeToNumber(cur->nodesetval->nodeTab[i]); 9647 } 9648 } 9649 valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, res)); 9650 xmlXPathReleaseObject(ctxt->context, cur); 9651 } 9652 9653 /** 9654 * xmlXPathFloorFunction: 9655 * @ctxt: the XPath Parser context 9656 * @nargs: the number of arguments 9657 * 9658 * Implement the floor() XPath function 9659 * number floor(number) 9660 * The floor function returns the largest (closest to positive infinity) 9661 * number that is not greater than the argument and that is an integer. 9662 */ 9663 void 9664 xmlXPathFloorFunction(xmlXPathParserContextPtr ctxt, int nargs) { 9665 CHECK_ARITY(1); 9666 CAST_TO_NUMBER; 9667 CHECK_TYPE(XPATH_NUMBER); 9668 9669 ctxt->value->floatval = floor(ctxt->value->floatval); 9670 } 9671 9672 /** 9673 * xmlXPathCeilingFunction: 9674 * @ctxt: the XPath Parser context 9675 * @nargs: the number of arguments 9676 * 9677 * Implement the ceiling() XPath function 9678 * number ceiling(number) 9679 * The ceiling function returns the smallest (closest to negative infinity) 9680 * number that is not less than the argument and that is an integer. 9681 */ 9682 void 9683 xmlXPathCeilingFunction(xmlXPathParserContextPtr ctxt, int nargs) { 9684 CHECK_ARITY(1); 9685 CAST_TO_NUMBER; 9686 CHECK_TYPE(XPATH_NUMBER); 9687 9688 ctxt->value->floatval = ceil(ctxt->value->floatval); 9689 } 9690 9691 /** 9692 * xmlXPathRoundFunction: 9693 * @ctxt: the XPath Parser context 9694 * @nargs: the number of arguments 9695 * 9696 * Implement the round() XPath function 9697 * number round(number) 9698 * The round function returns the number that is closest to the 9699 * argument and that is an integer. If there are two such numbers, 9700 * then the one that is closest to positive infinity is returned. 9701 */ 9702 void 9703 xmlXPathRoundFunction(xmlXPathParserContextPtr ctxt, int nargs) { 9704 double f; 9705 9706 CHECK_ARITY(1); 9707 CAST_TO_NUMBER; 9708 CHECK_TYPE(XPATH_NUMBER); 9709 9710 f = ctxt->value->floatval; 9711 9712 if ((f >= -0.5) && (f < 0.5)) { 9713 /* Handles negative zero. */ 9714 ctxt->value->floatval *= 0.0; 9715 } 9716 else { 9717 double rounded = floor(f); 9718 if (f - rounded >= 0.5) 9719 rounded += 1.0; 9720 ctxt->value->floatval = rounded; 9721 } 9722 } 9723 9724 /************************************************************************ 9725 * * 9726 * The Parser * 9727 * * 9728 ************************************************************************/ 9729 9730 /* 9731 * a few forward declarations since we use a recursive call based 9732 * implementation. 9733 */ 9734 static void xmlXPathCompileExpr(xmlXPathParserContextPtr ctxt, int sort); 9735 static void xmlXPathCompPredicate(xmlXPathParserContextPtr ctxt, int filter); 9736 static void xmlXPathCompLocationPath(xmlXPathParserContextPtr ctxt); 9737 static void xmlXPathCompRelativeLocationPath(xmlXPathParserContextPtr ctxt); 9738 static xmlChar * xmlXPathParseNameComplex(xmlXPathParserContextPtr ctxt, 9739 int qualified); 9740 9741 /** 9742 * xmlXPathCurrentChar: 9743 * @ctxt: the XPath parser context 9744 * @cur: pointer to the beginning of the char 9745 * @len: pointer to the length of the char read 9746 * 9747 * The current char value, if using UTF-8 this may actually span multiple 9748 * bytes in the input buffer. 9749 * 9750 * Returns the current char value and its length 9751 */ 9752 9753 static int 9754 xmlXPathCurrentChar(xmlXPathParserContextPtr ctxt, int *len) { 9755 unsigned char c; 9756 unsigned int val; 9757 const xmlChar *cur; 9758 9759 if (ctxt == NULL) 9760 return(0); 9761 cur = ctxt->cur; 9762 9763 /* 9764 * We are supposed to handle UTF8, check it's valid 9765 * From rfc2044: encoding of the Unicode values on UTF-8: 9766 * 9767 * UCS-4 range (hex.) UTF-8 octet sequence (binary) 9768 * 0000 0000-0000 007F 0xxxxxxx 9769 * 0000 0080-0000 07FF 110xxxxx 10xxxxxx 9770 * 0000 0800-0000 FFFF 1110xxxx 10xxxxxx 10xxxxxx 9771 * 9772 * Check for the 0x110000 limit too 9773 */ 9774 c = *cur; 9775 if (c & 0x80) { 9776 if ((cur[1] & 0xc0) != 0x80) 9777 goto encoding_error; 9778 if ((c & 0xe0) == 0xe0) { 9779 9780 if ((cur[2] & 0xc0) != 0x80) 9781 goto encoding_error; 9782 if ((c & 0xf0) == 0xf0) { 9783 if (((c & 0xf8) != 0xf0) || 9784 ((cur[3] & 0xc0) != 0x80)) 9785 goto encoding_error; 9786 /* 4-byte code */ 9787 *len = 4; 9788 val = (cur[0] & 0x7) << 18; 9789 val |= (cur[1] & 0x3f) << 12; 9790 val |= (cur[2] & 0x3f) << 6; 9791 val |= cur[3] & 0x3f; 9792 } else { 9793 /* 3-byte code */ 9794 *len = 3; 9795 val = (cur[0] & 0xf) << 12; 9796 val |= (cur[1] & 0x3f) << 6; 9797 val |= cur[2] & 0x3f; 9798 } 9799 } else { 9800 /* 2-byte code */ 9801 *len = 2; 9802 val = (cur[0] & 0x1f) << 6; 9803 val |= cur[1] & 0x3f; 9804 } 9805 if (!IS_CHAR(val)) { 9806 XP_ERROR0(XPATH_INVALID_CHAR_ERROR); 9807 } 9808 return(val); 9809 } else { 9810 /* 1-byte code */ 9811 *len = 1; 9812 return((int) *cur); 9813 } 9814 encoding_error: 9815 /* 9816 * If we detect an UTF8 error that probably means that the 9817 * input encoding didn't get properly advertised in the 9818 * declaration header. Report the error and switch the encoding 9819 * to ISO-Latin-1 (if you don't like this policy, just declare the 9820 * encoding !) 9821 */ 9822 *len = 0; 9823 XP_ERROR0(XPATH_ENCODING_ERROR); 9824 } 9825 9826 /** 9827 * xmlXPathParseNCName: 9828 * @ctxt: the XPath Parser context 9829 * 9830 * parse an XML namespace non qualified name. 9831 * 9832 * [NS 3] NCName ::= (Letter | '_') (NCNameChar)* 9833 * 9834 * [NS 4] NCNameChar ::= Letter | Digit | '.' | '-' | '_' | 9835 * CombiningChar | Extender 9836 * 9837 * Returns the namespace name or NULL 9838 */ 9839 9840 xmlChar * 9841 xmlXPathParseNCName(xmlXPathParserContextPtr ctxt) { 9842 const xmlChar *in; 9843 xmlChar *ret; 9844 int count = 0; 9845 9846 if ((ctxt == NULL) || (ctxt->cur == NULL)) return(NULL); 9847 /* 9848 * Accelerator for simple ASCII names 9849 */ 9850 in = ctxt->cur; 9851 if (((*in >= 0x61) && (*in <= 0x7A)) || 9852 ((*in >= 0x41) && (*in <= 0x5A)) || 9853 (*in == '_')) { 9854 in++; 9855 while (((*in >= 0x61) && (*in <= 0x7A)) || 9856 ((*in >= 0x41) && (*in <= 0x5A)) || 9857 ((*in >= 0x30) && (*in <= 0x39)) || 9858 (*in == '_') || (*in == '.') || 9859 (*in == '-')) 9860 in++; 9861 if ((*in == ' ') || (*in == '>') || (*in == '/') || 9862 (*in == '[') || (*in == ']') || (*in == ':') || 9863 (*in == '@') || (*in == '*')) { 9864 count = in - ctxt->cur; 9865 if (count == 0) 9866 return(NULL); 9867 ret = xmlStrndup(ctxt->cur, count); 9868 ctxt->cur = in; 9869 return(ret); 9870 } 9871 } 9872 return(xmlXPathParseNameComplex(ctxt, 0)); 9873 } 9874 9875 9876 /** 9877 * xmlXPathParseQName: 9878 * @ctxt: the XPath Parser context 9879 * @prefix: a xmlChar ** 9880 * 9881 * parse an XML qualified name 9882 * 9883 * [NS 5] QName ::= (Prefix ':')? LocalPart 9884 * 9885 * [NS 6] Prefix ::= NCName 9886 * 9887 * [NS 7] LocalPart ::= NCName 9888 * 9889 * Returns the function returns the local part, and prefix is updated 9890 * to get the Prefix if any. 9891 */ 9892 9893 static xmlChar * 9894 xmlXPathParseQName(xmlXPathParserContextPtr ctxt, xmlChar **prefix) { 9895 xmlChar *ret = NULL; 9896 9897 *prefix = NULL; 9898 ret = xmlXPathParseNCName(ctxt); 9899 if (ret && CUR == ':') { 9900 *prefix = ret; 9901 NEXT; 9902 ret = xmlXPathParseNCName(ctxt); 9903 } 9904 return(ret); 9905 } 9906 9907 /** 9908 * xmlXPathParseName: 9909 * @ctxt: the XPath Parser context 9910 * 9911 * parse an XML name 9912 * 9913 * [4] NameChar ::= Letter | Digit | '.' | '-' | '_' | ':' | 9914 * CombiningChar | Extender 9915 * 9916 * [5] Name ::= (Letter | '_' | ':') (NameChar)* 9917 * 9918 * Returns the namespace name or NULL 9919 */ 9920 9921 xmlChar * 9922 xmlXPathParseName(xmlXPathParserContextPtr ctxt) { 9923 const xmlChar *in; 9924 xmlChar *ret; 9925 size_t count = 0; 9926 9927 if ((ctxt == NULL) || (ctxt->cur == NULL)) return(NULL); 9928 /* 9929 * Accelerator for simple ASCII names 9930 */ 9931 in = ctxt->cur; 9932 if (((*in >= 0x61) && (*in <= 0x7A)) || 9933 ((*in >= 0x41) && (*in <= 0x5A)) || 9934 (*in == '_') || (*in == ':')) { 9935 in++; 9936 while (((*in >= 0x61) && (*in <= 0x7A)) || 9937 ((*in >= 0x41) && (*in <= 0x5A)) || 9938 ((*in >= 0x30) && (*in <= 0x39)) || 9939 (*in == '_') || (*in == '-') || 9940 (*in == ':') || (*in == '.')) 9941 in++; 9942 if ((*in > 0) && (*in < 0x80)) { 9943 count = in - ctxt->cur; 9944 if (count > XML_MAX_NAME_LENGTH) { 9945 ctxt->cur = in; 9946 XP_ERRORNULL(XPATH_EXPR_ERROR); 9947 } 9948 ret = xmlStrndup(ctxt->cur, count); 9949 ctxt->cur = in; 9950 return(ret); 9951 } 9952 } 9953 return(xmlXPathParseNameComplex(ctxt, 1)); 9954 } 9955 9956 static xmlChar * 9957 xmlXPathParseNameComplex(xmlXPathParserContextPtr ctxt, int qualified) { 9958 xmlChar buf[XML_MAX_NAMELEN + 5]; 9959 int len = 0, l; 9960 int c; 9961 9962 /* 9963 * Handler for more complex cases 9964 */ 9965 c = CUR_CHAR(l); 9966 if ((c == ' ') || (c == '>') || (c == '/') || /* accelerators */ 9967 (c == '[') || (c == ']') || (c == '@') || /* accelerators */ 9968 (c == '*') || /* accelerators */ 9969 (!IS_LETTER(c) && (c != '_') && 9970 ((!qualified) || (c != ':')))) { 9971 return(NULL); 9972 } 9973 9974 while ((c != ' ') && (c != '>') && (c != '/') && /* test bigname.xml */ 9975 ((IS_LETTER(c)) || (IS_DIGIT(c)) || 9976 (c == '.') || (c == '-') || 9977 (c == '_') || ((qualified) && (c == ':')) || 9978 (IS_COMBINING(c)) || 9979 (IS_EXTENDER(c)))) { 9980 COPY_BUF(l,buf,len,c); 9981 NEXTL(l); 9982 c = CUR_CHAR(l); 9983 if (len >= XML_MAX_NAMELEN) { 9984 /* 9985 * Okay someone managed to make a huge name, so he's ready to pay 9986 * for the processing speed. 9987 */ 9988 xmlChar *buffer; 9989 int max = len * 2; 9990 9991 if (len > XML_MAX_NAME_LENGTH) { 9992 XP_ERRORNULL(XPATH_EXPR_ERROR); 9993 } 9994 buffer = (xmlChar *) xmlMallocAtomic(max * sizeof(xmlChar)); 9995 if (buffer == NULL) { 9996 XP_ERRORNULL(XPATH_MEMORY_ERROR); 9997 } 9998 memcpy(buffer, buf, len); 9999 while ((IS_LETTER(c)) || (IS_DIGIT(c)) || /* test bigname.xml */ 10000 (c == '.') || (c == '-') || 10001 (c == '_') || ((qualified) && (c == ':')) || 10002 (IS_COMBINING(c)) || 10003 (IS_EXTENDER(c))) { 10004 if (len + 10 > max) { 10005 if (max > XML_MAX_NAME_LENGTH) { 10006 XP_ERRORNULL(XPATH_EXPR_ERROR); 10007 } 10008 max *= 2; 10009 buffer = (xmlChar *) xmlRealloc(buffer, 10010 max * sizeof(xmlChar)); 10011 if (buffer == NULL) { 10012 XP_ERRORNULL(XPATH_MEMORY_ERROR); 10013 } 10014 } 10015 COPY_BUF(l,buffer,len,c); 10016 NEXTL(l); 10017 c = CUR_CHAR(l); 10018 } 10019 buffer[len] = 0; 10020 return(buffer); 10021 } 10022 } 10023 if (len == 0) 10024 return(NULL); 10025 return(xmlStrndup(buf, len)); 10026 } 10027 10028 #define MAX_FRAC 20 10029 10030 /** 10031 * xmlXPathStringEvalNumber: 10032 * @str: A string to scan 10033 * 10034 * [30a] Float ::= Number ('e' Digits?)? 10035 * 10036 * [30] Number ::= Digits ('.' Digits?)? 10037 * | '.' Digits 10038 * [31] Digits ::= [0-9]+ 10039 * 10040 * Compile a Number in the string 10041 * In complement of the Number expression, this function also handles 10042 * negative values : '-' Number. 10043 * 10044 * Returns the double value. 10045 */ 10046 double 10047 xmlXPathStringEvalNumber(const xmlChar *str) { 10048 const xmlChar *cur = str; 10049 double ret; 10050 int ok = 0; 10051 int isneg = 0; 10052 int exponent = 0; 10053 int is_exponent_negative = 0; 10054 #ifdef __GNUC__ 10055 unsigned long tmp = 0; 10056 double temp; 10057 #endif 10058 if (cur == NULL) return(0); 10059 while (IS_BLANK_CH(*cur)) cur++; 10060 if ((*cur != '.') && ((*cur < '0') || (*cur > '9')) && (*cur != '-')) { 10061 return(NAN); 10062 } 10063 if (*cur == '-') { 10064 isneg = 1; 10065 cur++; 10066 } 10067 10068 #ifdef __GNUC__ 10069 /* 10070 * tmp/temp is a workaround against a gcc compiler bug 10071 * http://veillard.com/gcc.bug 10072 */ 10073 ret = 0; 10074 while ((*cur >= '0') && (*cur <= '9')) { 10075 ret = ret * 10; 10076 tmp = (*cur - '0'); 10077 ok = 1; 10078 cur++; 10079 temp = (double) tmp; 10080 ret = ret + temp; 10081 } 10082 #else 10083 ret = 0; 10084 while ((*cur >= '0') && (*cur <= '9')) { 10085 ret = ret * 10 + (*cur - '0'); 10086 ok = 1; 10087 cur++; 10088 } 10089 #endif 10090 10091 if (*cur == '.') { 10092 int v, frac = 0, max; 10093 double fraction = 0; 10094 10095 cur++; 10096 if (((*cur < '0') || (*cur > '9')) && (!ok)) { 10097 return(NAN); 10098 } 10099 while (*cur == '0') { 10100 frac = frac + 1; 10101 cur++; 10102 } 10103 max = frac + MAX_FRAC; 10104 while (((*cur >= '0') && (*cur <= '9')) && (frac < max)) { 10105 v = (*cur - '0'); 10106 fraction = fraction * 10 + v; 10107 frac = frac + 1; 10108 cur++; 10109 } 10110 fraction /= pow(10.0, frac); 10111 ret = ret + fraction; 10112 while ((*cur >= '0') && (*cur <= '9')) 10113 cur++; 10114 } 10115 if ((*cur == 'e') || (*cur == 'E')) { 10116 cur++; 10117 if (*cur == '-') { 10118 is_exponent_negative = 1; 10119 cur++; 10120 } else if (*cur == '+') { 10121 cur++; 10122 } 10123 while ((*cur >= '0') && (*cur <= '9')) { 10124 if (exponent < 1000000) 10125 exponent = exponent * 10 + (*cur - '0'); 10126 cur++; 10127 } 10128 } 10129 while (IS_BLANK_CH(*cur)) cur++; 10130 if (*cur != 0) return(NAN); 10131 if (isneg) ret = -ret; 10132 if (is_exponent_negative) exponent = -exponent; 10133 ret *= pow(10.0, (double)exponent); 10134 return(ret); 10135 } 10136 10137 /** 10138 * xmlXPathCompNumber: 10139 * @ctxt: the XPath Parser context 10140 * 10141 * [30] Number ::= Digits ('.' Digits?)? 10142 * | '.' Digits 10143 * [31] Digits ::= [0-9]+ 10144 * 10145 * Compile a Number, then push it on the stack 10146 * 10147 */ 10148 static void 10149 xmlXPathCompNumber(xmlXPathParserContextPtr ctxt) 10150 { 10151 double ret = 0.0; 10152 int ok = 0; 10153 int exponent = 0; 10154 int is_exponent_negative = 0; 10155 #ifdef __GNUC__ 10156 unsigned long tmp = 0; 10157 double temp; 10158 #endif 10159 10160 CHECK_ERROR; 10161 if ((CUR != '.') && ((CUR < '0') || (CUR > '9'))) { 10162 XP_ERROR(XPATH_NUMBER_ERROR); 10163 } 10164 #ifdef __GNUC__ 10165 /* 10166 * tmp/temp is a workaround against a gcc compiler bug 10167 * http://veillard.com/gcc.bug 10168 */ 10169 ret = 0; 10170 while ((CUR >= '0') && (CUR <= '9')) { 10171 ret = ret * 10; 10172 tmp = (CUR - '0'); 10173 ok = 1; 10174 NEXT; 10175 temp = (double) tmp; 10176 ret = ret + temp; 10177 } 10178 #else 10179 ret = 0; 10180 while ((CUR >= '0') && (CUR <= '9')) { 10181 ret = ret * 10 + (CUR - '0'); 10182 ok = 1; 10183 NEXT; 10184 } 10185 #endif 10186 if (CUR == '.') { 10187 int v, frac = 0, max; 10188 double fraction = 0; 10189 10190 NEXT; 10191 if (((CUR < '0') || (CUR > '9')) && (!ok)) { 10192 XP_ERROR(XPATH_NUMBER_ERROR); 10193 } 10194 while (CUR == '0') { 10195 frac = frac + 1; 10196 NEXT; 10197 } 10198 max = frac + MAX_FRAC; 10199 while ((CUR >= '0') && (CUR <= '9') && (frac < max)) { 10200 v = (CUR - '0'); 10201 fraction = fraction * 10 + v; 10202 frac = frac + 1; 10203 NEXT; 10204 } 10205 fraction /= pow(10.0, frac); 10206 ret = ret + fraction; 10207 while ((CUR >= '0') && (CUR <= '9')) 10208 NEXT; 10209 } 10210 if ((CUR == 'e') || (CUR == 'E')) { 10211 NEXT; 10212 if (CUR == '-') { 10213 is_exponent_negative = 1; 10214 NEXT; 10215 } else if (CUR == '+') { 10216 NEXT; 10217 } 10218 while ((CUR >= '0') && (CUR <= '9')) { 10219 if (exponent < 1000000) 10220 exponent = exponent * 10 + (CUR - '0'); 10221 NEXT; 10222 } 10223 if (is_exponent_negative) 10224 exponent = -exponent; 10225 ret *= pow(10.0, (double) exponent); 10226 } 10227 PUSH_LONG_EXPR(XPATH_OP_VALUE, XPATH_NUMBER, 0, 0, 10228 xmlXPathCacheNewFloat(ctxt->context, ret), NULL); 10229 } 10230 10231 /** 10232 * xmlXPathParseLiteral: 10233 * @ctxt: the XPath Parser context 10234 * 10235 * Parse a Literal 10236 * 10237 * [29] Literal ::= '"' [^"]* '"' 10238 * | "'" [^']* "'" 10239 * 10240 * Returns the value found or NULL in case of error 10241 */ 10242 static xmlChar * 10243 xmlXPathParseLiteral(xmlXPathParserContextPtr ctxt) { 10244 const xmlChar *q; 10245 xmlChar *ret = NULL; 10246 10247 if (CUR == '"') { 10248 NEXT; 10249 q = CUR_PTR; 10250 while ((IS_CHAR_CH(CUR)) && (CUR != '"')) 10251 NEXT; 10252 if (!IS_CHAR_CH(CUR)) { 10253 XP_ERRORNULL(XPATH_UNFINISHED_LITERAL_ERROR); 10254 } else { 10255 ret = xmlStrndup(q, CUR_PTR - q); 10256 NEXT; 10257 } 10258 } else if (CUR == '\'') { 10259 NEXT; 10260 q = CUR_PTR; 10261 while ((IS_CHAR_CH(CUR)) && (CUR != '\'')) 10262 NEXT; 10263 if (!IS_CHAR_CH(CUR)) { 10264 XP_ERRORNULL(XPATH_UNFINISHED_LITERAL_ERROR); 10265 } else { 10266 ret = xmlStrndup(q, CUR_PTR - q); 10267 NEXT; 10268 } 10269 } else { 10270 XP_ERRORNULL(XPATH_START_LITERAL_ERROR); 10271 } 10272 return(ret); 10273 } 10274 10275 /** 10276 * xmlXPathCompLiteral: 10277 * @ctxt: the XPath Parser context 10278 * 10279 * Parse a Literal and push it on the stack. 10280 * 10281 * [29] Literal ::= '"' [^"]* '"' 10282 * | "'" [^']* "'" 10283 * 10284 * TODO: xmlXPathCompLiteral memory allocation could be improved. 10285 */ 10286 static void 10287 xmlXPathCompLiteral(xmlXPathParserContextPtr ctxt) { 10288 const xmlChar *q; 10289 xmlChar *ret = NULL; 10290 10291 if (CUR == '"') { 10292 NEXT; 10293 q = CUR_PTR; 10294 while ((IS_CHAR_CH(CUR)) && (CUR != '"')) 10295 NEXT; 10296 if (!IS_CHAR_CH(CUR)) { 10297 XP_ERROR(XPATH_UNFINISHED_LITERAL_ERROR); 10298 } else { 10299 ret = xmlStrndup(q, CUR_PTR - q); 10300 NEXT; 10301 } 10302 } else if (CUR == '\'') { 10303 NEXT; 10304 q = CUR_PTR; 10305 while ((IS_CHAR_CH(CUR)) && (CUR != '\'')) 10306 NEXT; 10307 if (!IS_CHAR_CH(CUR)) { 10308 XP_ERROR(XPATH_UNFINISHED_LITERAL_ERROR); 10309 } else { 10310 ret = xmlStrndup(q, CUR_PTR - q); 10311 NEXT; 10312 } 10313 } else { 10314 XP_ERROR(XPATH_START_LITERAL_ERROR); 10315 } 10316 if (ret == NULL) return; 10317 PUSH_LONG_EXPR(XPATH_OP_VALUE, XPATH_STRING, 0, 0, 10318 xmlXPathCacheNewString(ctxt->context, ret), NULL); 10319 xmlFree(ret); 10320 } 10321 10322 /** 10323 * xmlXPathCompVariableReference: 10324 * @ctxt: the XPath Parser context 10325 * 10326 * Parse a VariableReference, evaluate it and push it on the stack. 10327 * 10328 * The variable bindings consist of a mapping from variable names 10329 * to variable values. The value of a variable is an object, which can be 10330 * of any of the types that are possible for the value of an expression, 10331 * and may also be of additional types not specified here. 10332 * 10333 * Early evaluation is possible since: 10334 * The variable bindings [...] used to evaluate a subexpression are 10335 * always the same as those used to evaluate the containing expression. 10336 * 10337 * [36] VariableReference ::= '$' QName 10338 */ 10339 static void 10340 xmlXPathCompVariableReference(xmlXPathParserContextPtr ctxt) { 10341 xmlChar *name; 10342 xmlChar *prefix; 10343 10344 SKIP_BLANKS; 10345 if (CUR != '$') { 10346 XP_ERROR(XPATH_VARIABLE_REF_ERROR); 10347 } 10348 NEXT; 10349 name = xmlXPathParseQName(ctxt, &prefix); 10350 if (name == NULL) { 10351 xmlFree(prefix); 10352 XP_ERROR(XPATH_VARIABLE_REF_ERROR); 10353 } 10354 ctxt->comp->last = -1; 10355 PUSH_LONG_EXPR(XPATH_OP_VARIABLE, 0, 0, 0, 10356 name, prefix); 10357 SKIP_BLANKS; 10358 if ((ctxt->context != NULL) && (ctxt->context->flags & XML_XPATH_NOVAR)) { 10359 XP_ERROR(XPATH_FORBID_VARIABLE_ERROR); 10360 } 10361 } 10362 10363 /** 10364 * xmlXPathIsNodeType: 10365 * @name: a name string 10366 * 10367 * Is the name given a NodeType one. 10368 * 10369 * [38] NodeType ::= 'comment' 10370 * | 'text' 10371 * | 'processing-instruction' 10372 * | 'node' 10373 * 10374 * Returns 1 if true 0 otherwise 10375 */ 10376 int 10377 xmlXPathIsNodeType(const xmlChar *name) { 10378 if (name == NULL) 10379 return(0); 10380 10381 if (xmlStrEqual(name, BAD_CAST "node")) 10382 return(1); 10383 if (xmlStrEqual(name, BAD_CAST "text")) 10384 return(1); 10385 if (xmlStrEqual(name, BAD_CAST "comment")) 10386 return(1); 10387 if (xmlStrEqual(name, BAD_CAST "processing-instruction")) 10388 return(1); 10389 return(0); 10390 } 10391 10392 /** 10393 * xmlXPathCompFunctionCall: 10394 * @ctxt: the XPath Parser context 10395 * 10396 * [16] FunctionCall ::= FunctionName '(' ( Argument ( ',' Argument)*)? ')' 10397 * [17] Argument ::= Expr 10398 * 10399 * Compile a function call, the evaluation of all arguments are 10400 * pushed on the stack 10401 */ 10402 static void 10403 xmlXPathCompFunctionCall(xmlXPathParserContextPtr ctxt) { 10404 xmlChar *name; 10405 xmlChar *prefix; 10406 int nbargs = 0; 10407 int sort = 1; 10408 10409 name = xmlXPathParseQName(ctxt, &prefix); 10410 if (name == NULL) { 10411 xmlFree(prefix); 10412 XP_ERROR(XPATH_EXPR_ERROR); 10413 } 10414 SKIP_BLANKS; 10415 #ifdef DEBUG_EXPR 10416 if (prefix == NULL) 10417 xmlGenericError(xmlGenericErrorContext, "Calling function %s\n", 10418 name); 10419 else 10420 xmlGenericError(xmlGenericErrorContext, "Calling function %s:%s\n", 10421 prefix, name); 10422 #endif 10423 10424 if (CUR != '(') { 10425 xmlFree(name); 10426 xmlFree(prefix); 10427 XP_ERROR(XPATH_EXPR_ERROR); 10428 } 10429 NEXT; 10430 SKIP_BLANKS; 10431 10432 /* 10433 * Optimization for count(): we don't need the node-set to be sorted. 10434 */ 10435 if ((prefix == NULL) && (name[0] == 'c') && 10436 xmlStrEqual(name, BAD_CAST "count")) 10437 { 10438 sort = 0; 10439 } 10440 ctxt->comp->last = -1; 10441 if (CUR != ')') { 10442 while (CUR != 0) { 10443 int op1 = ctxt->comp->last; 10444 ctxt->comp->last = -1; 10445 xmlXPathCompileExpr(ctxt, sort); 10446 if (ctxt->error != XPATH_EXPRESSION_OK) { 10447 xmlFree(name); 10448 xmlFree(prefix); 10449 return; 10450 } 10451 PUSH_BINARY_EXPR(XPATH_OP_ARG, op1, ctxt->comp->last, 0, 0); 10452 nbargs++; 10453 if (CUR == ')') break; 10454 if (CUR != ',') { 10455 xmlFree(name); 10456 xmlFree(prefix); 10457 XP_ERROR(XPATH_EXPR_ERROR); 10458 } 10459 NEXT; 10460 SKIP_BLANKS; 10461 } 10462 } 10463 PUSH_LONG_EXPR(XPATH_OP_FUNCTION, nbargs, 0, 0, 10464 name, prefix); 10465 NEXT; 10466 SKIP_BLANKS; 10467 } 10468 10469 /** 10470 * xmlXPathCompPrimaryExpr: 10471 * @ctxt: the XPath Parser context 10472 * 10473 * [15] PrimaryExpr ::= VariableReference 10474 * | '(' Expr ')' 10475 * | Literal 10476 * | Number 10477 * | FunctionCall 10478 * 10479 * Compile a primary expression. 10480 */ 10481 static void 10482 xmlXPathCompPrimaryExpr(xmlXPathParserContextPtr ctxt) { 10483 SKIP_BLANKS; 10484 if (CUR == '$') xmlXPathCompVariableReference(ctxt); 10485 else if (CUR == '(') { 10486 NEXT; 10487 SKIP_BLANKS; 10488 xmlXPathCompileExpr(ctxt, 1); 10489 CHECK_ERROR; 10490 if (CUR != ')') { 10491 XP_ERROR(XPATH_EXPR_ERROR); 10492 } 10493 NEXT; 10494 SKIP_BLANKS; 10495 } else if (IS_ASCII_DIGIT(CUR) || (CUR == '.' && IS_ASCII_DIGIT(NXT(1)))) { 10496 xmlXPathCompNumber(ctxt); 10497 } else if ((CUR == '\'') || (CUR == '"')) { 10498 xmlXPathCompLiteral(ctxt); 10499 } else { 10500 xmlXPathCompFunctionCall(ctxt); 10501 } 10502 SKIP_BLANKS; 10503 } 10504 10505 /** 10506 * xmlXPathCompFilterExpr: 10507 * @ctxt: the XPath Parser context 10508 * 10509 * [20] FilterExpr ::= PrimaryExpr 10510 * | FilterExpr Predicate 10511 * 10512 * Compile a filter expression. 10513 * Square brackets are used to filter expressions in the same way that 10514 * they are used in location paths. It is an error if the expression to 10515 * be filtered does not evaluate to a node-set. The context node list 10516 * used for evaluating the expression in square brackets is the node-set 10517 * to be filtered listed in document order. 10518 */ 10519 10520 static void 10521 xmlXPathCompFilterExpr(xmlXPathParserContextPtr ctxt) { 10522 xmlXPathCompPrimaryExpr(ctxt); 10523 CHECK_ERROR; 10524 SKIP_BLANKS; 10525 10526 while (CUR == '[') { 10527 xmlXPathCompPredicate(ctxt, 1); 10528 SKIP_BLANKS; 10529 } 10530 10531 10532 } 10533 10534 /** 10535 * xmlXPathScanName: 10536 * @ctxt: the XPath Parser context 10537 * 10538 * Trickery: parse an XML name but without consuming the input flow 10539 * Needed to avoid insanity in the parser state. 10540 * 10541 * [4] NameChar ::= Letter | Digit | '.' | '-' | '_' | ':' | 10542 * CombiningChar | Extender 10543 * 10544 * [5] Name ::= (Letter | '_' | ':') (NameChar)* 10545 * 10546 * [6] Names ::= Name (S Name)* 10547 * 10548 * Returns the Name parsed or NULL 10549 */ 10550 10551 static xmlChar * 10552 xmlXPathScanName(xmlXPathParserContextPtr ctxt) { 10553 int len = 0, l; 10554 int c; 10555 const xmlChar *cur; 10556 xmlChar *ret; 10557 10558 cur = ctxt->cur; 10559 10560 c = CUR_CHAR(l); 10561 if ((c == ' ') || (c == '>') || (c == '/') || /* accelerators */ 10562 (!IS_LETTER(c) && (c != '_') && 10563 (c != ':'))) { 10564 return(NULL); 10565 } 10566 10567 while ((c != ' ') && (c != '>') && (c != '/') && /* test bigname.xml */ 10568 ((IS_LETTER(c)) || (IS_DIGIT(c)) || 10569 (c == '.') || (c == '-') || 10570 (c == '_') || (c == ':') || 10571 (IS_COMBINING(c)) || 10572 (IS_EXTENDER(c)))) { 10573 len += l; 10574 NEXTL(l); 10575 c = CUR_CHAR(l); 10576 } 10577 ret = xmlStrndup(cur, ctxt->cur - cur); 10578 ctxt->cur = cur; 10579 return(ret); 10580 } 10581 10582 /** 10583 * xmlXPathCompPathExpr: 10584 * @ctxt: the XPath Parser context 10585 * 10586 * [19] PathExpr ::= LocationPath 10587 * | FilterExpr 10588 * | FilterExpr '/' RelativeLocationPath 10589 * | FilterExpr '//' RelativeLocationPath 10590 * 10591 * Compile a path expression. 10592 * The / operator and // operators combine an arbitrary expression 10593 * and a relative location path. It is an error if the expression 10594 * does not evaluate to a node-set. 10595 * The / operator does composition in the same way as when / is 10596 * used in a location path. As in location paths, // is short for 10597 * /descendant-or-self::node()/. 10598 */ 10599 10600 static void 10601 xmlXPathCompPathExpr(xmlXPathParserContextPtr ctxt) { 10602 int lc = 1; /* Should we branch to LocationPath ? */ 10603 xmlChar *name = NULL; /* we may have to preparse a name to find out */ 10604 10605 SKIP_BLANKS; 10606 if ((CUR == '$') || (CUR == '(') || 10607 (IS_ASCII_DIGIT(CUR)) || 10608 (CUR == '\'') || (CUR == '"') || 10609 (CUR == '.' && IS_ASCII_DIGIT(NXT(1)))) { 10610 lc = 0; 10611 } else if (CUR == '*') { 10612 /* relative or absolute location path */ 10613 lc = 1; 10614 } else if (CUR == '/') { 10615 /* relative or absolute location path */ 10616 lc = 1; 10617 } else if (CUR == '@') { 10618 /* relative abbreviated attribute location path */ 10619 lc = 1; 10620 } else if (CUR == '.') { 10621 /* relative abbreviated attribute location path */ 10622 lc = 1; 10623 } else { 10624 /* 10625 * Problem is finding if we have a name here whether it's: 10626 * - a nodetype 10627 * - a function call in which case it's followed by '(' 10628 * - an axis in which case it's followed by ':' 10629 * - a element name 10630 * We do an a priori analysis here rather than having to 10631 * maintain parsed token content through the recursive function 10632 * calls. This looks uglier but makes the code easier to 10633 * read/write/debug. 10634 */ 10635 SKIP_BLANKS; 10636 name = xmlXPathScanName(ctxt); 10637 if ((name != NULL) && (xmlStrstr(name, (xmlChar *) "::") != NULL)) { 10638 #ifdef DEBUG_STEP 10639 xmlGenericError(xmlGenericErrorContext, 10640 "PathExpr: Axis\n"); 10641 #endif 10642 lc = 1; 10643 xmlFree(name); 10644 } else if (name != NULL) { 10645 int len =xmlStrlen(name); 10646 10647 10648 while (NXT(len) != 0) { 10649 if (NXT(len) == '/') { 10650 /* element name */ 10651 #ifdef DEBUG_STEP 10652 xmlGenericError(xmlGenericErrorContext, 10653 "PathExpr: AbbrRelLocation\n"); 10654 #endif 10655 lc = 1; 10656 break; 10657 } else if (IS_BLANK_CH(NXT(len))) { 10658 /* ignore blanks */ 10659 ; 10660 } else if (NXT(len) == ':') { 10661 #ifdef DEBUG_STEP 10662 xmlGenericError(xmlGenericErrorContext, 10663 "PathExpr: AbbrRelLocation\n"); 10664 #endif 10665 lc = 1; 10666 break; 10667 } else if ((NXT(len) == '(')) { 10668 /* Node Type or Function */ 10669 if (xmlXPathIsNodeType(name)) { 10670 #ifdef DEBUG_STEP 10671 xmlGenericError(xmlGenericErrorContext, 10672 "PathExpr: Type search\n"); 10673 #endif 10674 lc = 1; 10675 #ifdef LIBXML_XPTR_ENABLED 10676 } else if (ctxt->xptr && 10677 xmlStrEqual(name, BAD_CAST "range-to")) { 10678 lc = 1; 10679 #endif 10680 } else { 10681 #ifdef DEBUG_STEP 10682 xmlGenericError(xmlGenericErrorContext, 10683 "PathExpr: function call\n"); 10684 #endif 10685 lc = 0; 10686 } 10687 break; 10688 } else if ((NXT(len) == '[')) { 10689 /* element name */ 10690 #ifdef DEBUG_STEP 10691 xmlGenericError(xmlGenericErrorContext, 10692 "PathExpr: AbbrRelLocation\n"); 10693 #endif 10694 lc = 1; 10695 break; 10696 } else if ((NXT(len) == '<') || (NXT(len) == '>') || 10697 (NXT(len) == '=')) { 10698 lc = 1; 10699 break; 10700 } else { 10701 lc = 1; 10702 break; 10703 } 10704 len++; 10705 } 10706 if (NXT(len) == 0) { 10707 #ifdef DEBUG_STEP 10708 xmlGenericError(xmlGenericErrorContext, 10709 "PathExpr: AbbrRelLocation\n"); 10710 #endif 10711 /* element name */ 10712 lc = 1; 10713 } 10714 xmlFree(name); 10715 } else { 10716 /* make sure all cases are covered explicitly */ 10717 XP_ERROR(XPATH_EXPR_ERROR); 10718 } 10719 } 10720 10721 if (lc) { 10722 if (CUR == '/') { 10723 PUSH_LEAVE_EXPR(XPATH_OP_ROOT, 0, 0); 10724 } else { 10725 PUSH_LEAVE_EXPR(XPATH_OP_NODE, 0, 0); 10726 } 10727 xmlXPathCompLocationPath(ctxt); 10728 } else { 10729 xmlXPathCompFilterExpr(ctxt); 10730 CHECK_ERROR; 10731 if ((CUR == '/') && (NXT(1) == '/')) { 10732 SKIP(2); 10733 SKIP_BLANKS; 10734 10735 PUSH_LONG_EXPR(XPATH_OP_COLLECT, AXIS_DESCENDANT_OR_SELF, 10736 NODE_TEST_TYPE, NODE_TYPE_NODE, NULL, NULL); 10737 PUSH_UNARY_EXPR(XPATH_OP_RESET, ctxt->comp->last, 1, 0); 10738 10739 xmlXPathCompRelativeLocationPath(ctxt); 10740 } else if (CUR == '/') { 10741 xmlXPathCompRelativeLocationPath(ctxt); 10742 } 10743 } 10744 SKIP_BLANKS; 10745 } 10746 10747 /** 10748 * xmlXPathCompUnionExpr: 10749 * @ctxt: the XPath Parser context 10750 * 10751 * [18] UnionExpr ::= PathExpr 10752 * | UnionExpr '|' PathExpr 10753 * 10754 * Compile an union expression. 10755 */ 10756 10757 static void 10758 xmlXPathCompUnionExpr(xmlXPathParserContextPtr ctxt) { 10759 xmlXPathCompPathExpr(ctxt); 10760 CHECK_ERROR; 10761 SKIP_BLANKS; 10762 while (CUR == '|') { 10763 int op1 = ctxt->comp->last; 10764 PUSH_LEAVE_EXPR(XPATH_OP_NODE, 0, 0); 10765 10766 NEXT; 10767 SKIP_BLANKS; 10768 xmlXPathCompPathExpr(ctxt); 10769 10770 PUSH_BINARY_EXPR(XPATH_OP_UNION, op1, ctxt->comp->last, 0, 0); 10771 10772 SKIP_BLANKS; 10773 } 10774 } 10775 10776 /** 10777 * xmlXPathCompUnaryExpr: 10778 * @ctxt: the XPath Parser context 10779 * 10780 * [27] UnaryExpr ::= UnionExpr 10781 * | '-' UnaryExpr 10782 * 10783 * Compile an unary expression. 10784 */ 10785 10786 static void 10787 xmlXPathCompUnaryExpr(xmlXPathParserContextPtr ctxt) { 10788 int minus = 0; 10789 int found = 0; 10790 10791 SKIP_BLANKS; 10792 while (CUR == '-') { 10793 minus = 1 - minus; 10794 found = 1; 10795 NEXT; 10796 SKIP_BLANKS; 10797 } 10798 10799 xmlXPathCompUnionExpr(ctxt); 10800 CHECK_ERROR; 10801 if (found) { 10802 if (minus) 10803 PUSH_UNARY_EXPR(XPATH_OP_PLUS, ctxt->comp->last, 2, 0); 10804 else 10805 PUSH_UNARY_EXPR(XPATH_OP_PLUS, ctxt->comp->last, 3, 0); 10806 } 10807 } 10808 10809 /** 10810 * xmlXPathCompMultiplicativeExpr: 10811 * @ctxt: the XPath Parser context 10812 * 10813 * [26] MultiplicativeExpr ::= UnaryExpr 10814 * | MultiplicativeExpr MultiplyOperator UnaryExpr 10815 * | MultiplicativeExpr 'div' UnaryExpr 10816 * | MultiplicativeExpr 'mod' UnaryExpr 10817 * [34] MultiplyOperator ::= '*' 10818 * 10819 * Compile an Additive expression. 10820 */ 10821 10822 static void 10823 xmlXPathCompMultiplicativeExpr(xmlXPathParserContextPtr ctxt) { 10824 xmlXPathCompUnaryExpr(ctxt); 10825 CHECK_ERROR; 10826 SKIP_BLANKS; 10827 while ((CUR == '*') || 10828 ((CUR == 'd') && (NXT(1) == 'i') && (NXT(2) == 'v')) || 10829 ((CUR == 'm') && (NXT(1) == 'o') && (NXT(2) == 'd'))) { 10830 int op = -1; 10831 int op1 = ctxt->comp->last; 10832 10833 if (CUR == '*') { 10834 op = 0; 10835 NEXT; 10836 } else if (CUR == 'd') { 10837 op = 1; 10838 SKIP(3); 10839 } else if (CUR == 'm') { 10840 op = 2; 10841 SKIP(3); 10842 } 10843 SKIP_BLANKS; 10844 xmlXPathCompUnaryExpr(ctxt); 10845 CHECK_ERROR; 10846 PUSH_BINARY_EXPR(XPATH_OP_MULT, op1, ctxt->comp->last, op, 0); 10847 SKIP_BLANKS; 10848 } 10849 } 10850 10851 /** 10852 * xmlXPathCompAdditiveExpr: 10853 * @ctxt: the XPath Parser context 10854 * 10855 * [25] AdditiveExpr ::= MultiplicativeExpr 10856 * | AdditiveExpr '+' MultiplicativeExpr 10857 * | AdditiveExpr '-' MultiplicativeExpr 10858 * 10859 * Compile an Additive expression. 10860 */ 10861 10862 static void 10863 xmlXPathCompAdditiveExpr(xmlXPathParserContextPtr ctxt) { 10864 10865 xmlXPathCompMultiplicativeExpr(ctxt); 10866 CHECK_ERROR; 10867 SKIP_BLANKS; 10868 while ((CUR == '+') || (CUR == '-')) { 10869 int plus; 10870 int op1 = ctxt->comp->last; 10871 10872 if (CUR == '+') plus = 1; 10873 else plus = 0; 10874 NEXT; 10875 SKIP_BLANKS; 10876 xmlXPathCompMultiplicativeExpr(ctxt); 10877 CHECK_ERROR; 10878 PUSH_BINARY_EXPR(XPATH_OP_PLUS, op1, ctxt->comp->last, plus, 0); 10879 SKIP_BLANKS; 10880 } 10881 } 10882 10883 /** 10884 * xmlXPathCompRelationalExpr: 10885 * @ctxt: the XPath Parser context 10886 * 10887 * [24] RelationalExpr ::= AdditiveExpr 10888 * | RelationalExpr '<' AdditiveExpr 10889 * | RelationalExpr '>' AdditiveExpr 10890 * | RelationalExpr '<=' AdditiveExpr 10891 * | RelationalExpr '>=' AdditiveExpr 10892 * 10893 * A <= B > C is allowed ? Answer from James, yes with 10894 * (AdditiveExpr <= AdditiveExpr) > AdditiveExpr 10895 * which is basically what got implemented. 10896 * 10897 * Compile a Relational expression, then push the result 10898 * on the stack 10899 */ 10900 10901 static void 10902 xmlXPathCompRelationalExpr(xmlXPathParserContextPtr ctxt) { 10903 xmlXPathCompAdditiveExpr(ctxt); 10904 CHECK_ERROR; 10905 SKIP_BLANKS; 10906 while ((CUR == '<') || 10907 (CUR == '>') || 10908 ((CUR == '<') && (NXT(1) == '=')) || 10909 ((CUR == '>') && (NXT(1) == '='))) { 10910 int inf, strict; 10911 int op1 = ctxt->comp->last; 10912 10913 if (CUR == '<') inf = 1; 10914 else inf = 0; 10915 if (NXT(1) == '=') strict = 0; 10916 else strict = 1; 10917 NEXT; 10918 if (!strict) NEXT; 10919 SKIP_BLANKS; 10920 xmlXPathCompAdditiveExpr(ctxt); 10921 CHECK_ERROR; 10922 PUSH_BINARY_EXPR(XPATH_OP_CMP, op1, ctxt->comp->last, inf, strict); 10923 SKIP_BLANKS; 10924 } 10925 } 10926 10927 /** 10928 * xmlXPathCompEqualityExpr: 10929 * @ctxt: the XPath Parser context 10930 * 10931 * [23] EqualityExpr ::= RelationalExpr 10932 * | EqualityExpr '=' RelationalExpr 10933 * | EqualityExpr '!=' RelationalExpr 10934 * 10935 * A != B != C is allowed ? Answer from James, yes with 10936 * (RelationalExpr = RelationalExpr) = RelationalExpr 10937 * (RelationalExpr != RelationalExpr) != RelationalExpr 10938 * which is basically what got implemented. 10939 * 10940 * Compile an Equality expression. 10941 * 10942 */ 10943 static void 10944 xmlXPathCompEqualityExpr(xmlXPathParserContextPtr ctxt) { 10945 xmlXPathCompRelationalExpr(ctxt); 10946 CHECK_ERROR; 10947 SKIP_BLANKS; 10948 while ((CUR == '=') || ((CUR == '!') && (NXT(1) == '='))) { 10949 int eq; 10950 int op1 = ctxt->comp->last; 10951 10952 if (CUR == '=') eq = 1; 10953 else eq = 0; 10954 NEXT; 10955 if (!eq) NEXT; 10956 SKIP_BLANKS; 10957 xmlXPathCompRelationalExpr(ctxt); 10958 CHECK_ERROR; 10959 PUSH_BINARY_EXPR(XPATH_OP_EQUAL, op1, ctxt->comp->last, eq, 0); 10960 SKIP_BLANKS; 10961 } 10962 } 10963 10964 /** 10965 * xmlXPathCompAndExpr: 10966 * @ctxt: the XPath Parser context 10967 * 10968 * [22] AndExpr ::= EqualityExpr 10969 * | AndExpr 'and' EqualityExpr 10970 * 10971 * Compile an AND expression. 10972 * 10973 */ 10974 static void 10975 xmlXPathCompAndExpr(xmlXPathParserContextPtr ctxt) { 10976 xmlXPathCompEqualityExpr(ctxt); 10977 CHECK_ERROR; 10978 SKIP_BLANKS; 10979 while ((CUR == 'a') && (NXT(1) == 'n') && (NXT(2) == 'd')) { 10980 int op1 = ctxt->comp->last; 10981 SKIP(3); 10982 SKIP_BLANKS; 10983 xmlXPathCompEqualityExpr(ctxt); 10984 CHECK_ERROR; 10985 PUSH_BINARY_EXPR(XPATH_OP_AND, op1, ctxt->comp->last, 0, 0); 10986 SKIP_BLANKS; 10987 } 10988 } 10989 10990 /** 10991 * xmlXPathCompileExpr: 10992 * @ctxt: the XPath Parser context 10993 * 10994 * [14] Expr ::= OrExpr 10995 * [21] OrExpr ::= AndExpr 10996 * | OrExpr 'or' AndExpr 10997 * 10998 * Parse and compile an expression 10999 */ 11000 static void 11001 xmlXPathCompileExpr(xmlXPathParserContextPtr ctxt, int sort) { 11002 xmlXPathCompAndExpr(ctxt); 11003 CHECK_ERROR; 11004 SKIP_BLANKS; 11005 while ((CUR == 'o') && (NXT(1) == 'r')) { 11006 int op1 = ctxt->comp->last; 11007 SKIP(2); 11008 SKIP_BLANKS; 11009 xmlXPathCompAndExpr(ctxt); 11010 CHECK_ERROR; 11011 PUSH_BINARY_EXPR(XPATH_OP_OR, op1, ctxt->comp->last, 0, 0); 11012 SKIP_BLANKS; 11013 } 11014 if ((sort) && (ctxt->comp->steps[ctxt->comp->last].op != XPATH_OP_VALUE)) { 11015 /* more ops could be optimized too */ 11016 /* 11017 * This is the main place to eliminate sorting for 11018 * operations which don't require a sorted node-set. 11019 * E.g. count(). 11020 */ 11021 PUSH_UNARY_EXPR(XPATH_OP_SORT, ctxt->comp->last , 0, 0); 11022 } 11023 } 11024 11025 /** 11026 * xmlXPathCompPredicate: 11027 * @ctxt: the XPath Parser context 11028 * @filter: act as a filter 11029 * 11030 * [8] Predicate ::= '[' PredicateExpr ']' 11031 * [9] PredicateExpr ::= Expr 11032 * 11033 * Compile a predicate expression 11034 */ 11035 static void 11036 xmlXPathCompPredicate(xmlXPathParserContextPtr ctxt, int filter) { 11037 int op1 = ctxt->comp->last; 11038 11039 SKIP_BLANKS; 11040 if (CUR != '[') { 11041 XP_ERROR(XPATH_INVALID_PREDICATE_ERROR); 11042 } 11043 NEXT; 11044 SKIP_BLANKS; 11045 11046 ctxt->comp->last = -1; 11047 /* 11048 * This call to xmlXPathCompileExpr() will deactivate sorting 11049 * of the predicate result. 11050 * TODO: Sorting is still activated for filters, since I'm not 11051 * sure if needed. Normally sorting should not be needed, since 11052 * a filter can only diminish the number of items in a sequence, 11053 * but won't change its order; so if the initial sequence is sorted, 11054 * subsequent sorting is not needed. 11055 */ 11056 if (! filter) 11057 xmlXPathCompileExpr(ctxt, 0); 11058 else 11059 xmlXPathCompileExpr(ctxt, 1); 11060 CHECK_ERROR; 11061 11062 if (CUR != ']') { 11063 XP_ERROR(XPATH_INVALID_PREDICATE_ERROR); 11064 } 11065 11066 if (filter) 11067 PUSH_BINARY_EXPR(XPATH_OP_FILTER, op1, ctxt->comp->last, 0, 0); 11068 else 11069 PUSH_BINARY_EXPR(XPATH_OP_PREDICATE, op1, ctxt->comp->last, 0, 0); 11070 11071 NEXT; 11072 SKIP_BLANKS; 11073 } 11074 11075 /** 11076 * xmlXPathCompNodeTest: 11077 * @ctxt: the XPath Parser context 11078 * @test: pointer to a xmlXPathTestVal 11079 * @type: pointer to a xmlXPathTypeVal 11080 * @prefix: placeholder for a possible name prefix 11081 * 11082 * [7] NodeTest ::= NameTest 11083 * | NodeType '(' ')' 11084 * | 'processing-instruction' '(' Literal ')' 11085 * 11086 * [37] NameTest ::= '*' 11087 * | NCName ':' '*' 11088 * | QName 11089 * [38] NodeType ::= 'comment' 11090 * | 'text' 11091 * | 'processing-instruction' 11092 * | 'node' 11093 * 11094 * Returns the name found and updates @test, @type and @prefix appropriately 11095 */ 11096 static xmlChar * 11097 xmlXPathCompNodeTest(xmlXPathParserContextPtr ctxt, xmlXPathTestVal *test, 11098 xmlXPathTypeVal *type, const xmlChar **prefix, 11099 xmlChar *name) { 11100 int blanks; 11101 11102 if ((test == NULL) || (type == NULL) || (prefix == NULL)) { 11103 STRANGE; 11104 return(NULL); 11105 } 11106 *type = (xmlXPathTypeVal) 0; 11107 *test = (xmlXPathTestVal) 0; 11108 *prefix = NULL; 11109 SKIP_BLANKS; 11110 11111 if ((name == NULL) && (CUR == '*')) { 11112 /* 11113 * All elements 11114 */ 11115 NEXT; 11116 *test = NODE_TEST_ALL; 11117 return(NULL); 11118 } 11119 11120 if (name == NULL) 11121 name = xmlXPathParseNCName(ctxt); 11122 if (name == NULL) { 11123 XP_ERRORNULL(XPATH_EXPR_ERROR); 11124 } 11125 11126 blanks = IS_BLANK_CH(CUR); 11127 SKIP_BLANKS; 11128 if (CUR == '(') { 11129 NEXT; 11130 /* 11131 * NodeType or PI search 11132 */ 11133 if (xmlStrEqual(name, BAD_CAST "comment")) 11134 *type = NODE_TYPE_COMMENT; 11135 else if (xmlStrEqual(name, BAD_CAST "node")) 11136 *type = NODE_TYPE_NODE; 11137 else if (xmlStrEqual(name, BAD_CAST "processing-instruction")) 11138 *type = NODE_TYPE_PI; 11139 else if (xmlStrEqual(name, BAD_CAST "text")) 11140 *type = NODE_TYPE_TEXT; 11141 else { 11142 if (name != NULL) 11143 xmlFree(name); 11144 XP_ERRORNULL(XPATH_EXPR_ERROR); 11145 } 11146 11147 *test = NODE_TEST_TYPE; 11148 11149 SKIP_BLANKS; 11150 if (*type == NODE_TYPE_PI) { 11151 /* 11152 * Specific case: search a PI by name. 11153 */ 11154 if (name != NULL) 11155 xmlFree(name); 11156 name = NULL; 11157 if (CUR != ')') { 11158 name = xmlXPathParseLiteral(ctxt); 11159 CHECK_ERROR NULL; 11160 *test = NODE_TEST_PI; 11161 SKIP_BLANKS; 11162 } 11163 } 11164 if (CUR != ')') { 11165 if (name != NULL) 11166 xmlFree(name); 11167 XP_ERRORNULL(XPATH_UNCLOSED_ERROR); 11168 } 11169 NEXT; 11170 return(name); 11171 } 11172 *test = NODE_TEST_NAME; 11173 if ((!blanks) && (CUR == ':')) { 11174 NEXT; 11175 11176 /* 11177 * Since currently the parser context don't have a 11178 * namespace list associated: 11179 * The namespace name for this prefix can be computed 11180 * only at evaluation time. The compilation is done 11181 * outside of any context. 11182 */ 11183 #if 0 11184 *prefix = xmlXPathNsLookup(ctxt->context, name); 11185 if (name != NULL) 11186 xmlFree(name); 11187 if (*prefix == NULL) { 11188 XP_ERROR0(XPATH_UNDEF_PREFIX_ERROR); 11189 } 11190 #else 11191 *prefix = name; 11192 #endif 11193 11194 if (CUR == '*') { 11195 /* 11196 * All elements 11197 */ 11198 NEXT; 11199 *test = NODE_TEST_ALL; 11200 return(NULL); 11201 } 11202 11203 name = xmlXPathParseNCName(ctxt); 11204 if (name == NULL) { 11205 XP_ERRORNULL(XPATH_EXPR_ERROR); 11206 } 11207 } 11208 return(name); 11209 } 11210 11211 /** 11212 * xmlXPathIsAxisName: 11213 * @name: a preparsed name token 11214 * 11215 * [6] AxisName ::= 'ancestor' 11216 * | 'ancestor-or-self' 11217 * | 'attribute' 11218 * | 'child' 11219 * | 'descendant' 11220 * | 'descendant-or-self' 11221 * | 'following' 11222 * | 'following-sibling' 11223 * | 'namespace' 11224 * | 'parent' 11225 * | 'preceding' 11226 * | 'preceding-sibling' 11227 * | 'self' 11228 * 11229 * Returns the axis or 0 11230 */ 11231 static xmlXPathAxisVal 11232 xmlXPathIsAxisName(const xmlChar *name) { 11233 xmlXPathAxisVal ret = (xmlXPathAxisVal) 0; 11234 switch (name[0]) { 11235 case 'a': 11236 if (xmlStrEqual(name, BAD_CAST "ancestor")) 11237 ret = AXIS_ANCESTOR; 11238 if (xmlStrEqual(name, BAD_CAST "ancestor-or-self")) 11239 ret = AXIS_ANCESTOR_OR_SELF; 11240 if (xmlStrEqual(name, BAD_CAST "attribute")) 11241 ret = AXIS_ATTRIBUTE; 11242 break; 11243 case 'c': 11244 if (xmlStrEqual(name, BAD_CAST "child")) 11245 ret = AXIS_CHILD; 11246 break; 11247 case 'd': 11248 if (xmlStrEqual(name, BAD_CAST "descendant")) 11249 ret = AXIS_DESCENDANT; 11250 if (xmlStrEqual(name, BAD_CAST "descendant-or-self")) 11251 ret = AXIS_DESCENDANT_OR_SELF; 11252 break; 11253 case 'f': 11254 if (xmlStrEqual(name, BAD_CAST "following")) 11255 ret = AXIS_FOLLOWING; 11256 if (xmlStrEqual(name, BAD_CAST "following-sibling")) 11257 ret = AXIS_FOLLOWING_SIBLING; 11258 break; 11259 case 'n': 11260 if (xmlStrEqual(name, BAD_CAST "namespace")) 11261 ret = AXIS_NAMESPACE; 11262 break; 11263 case 'p': 11264 if (xmlStrEqual(name, BAD_CAST "parent")) 11265 ret = AXIS_PARENT; 11266 if (xmlStrEqual(name, BAD_CAST "preceding")) 11267 ret = AXIS_PRECEDING; 11268 if (xmlStrEqual(name, BAD_CAST "preceding-sibling")) 11269 ret = AXIS_PRECEDING_SIBLING; 11270 break; 11271 case 's': 11272 if (xmlStrEqual(name, BAD_CAST "self")) 11273 ret = AXIS_SELF; 11274 break; 11275 } 11276 return(ret); 11277 } 11278 11279 /** 11280 * xmlXPathCompStep: 11281 * @ctxt: the XPath Parser context 11282 * 11283 * [4] Step ::= AxisSpecifier NodeTest Predicate* 11284 * | AbbreviatedStep 11285 * 11286 * [12] AbbreviatedStep ::= '.' | '..' 11287 * 11288 * [5] AxisSpecifier ::= AxisName '::' 11289 * | AbbreviatedAxisSpecifier 11290 * 11291 * [13] AbbreviatedAxisSpecifier ::= '@'? 11292 * 11293 * Modified for XPtr range support as: 11294 * 11295 * [4xptr] Step ::= AxisSpecifier NodeTest Predicate* 11296 * | AbbreviatedStep 11297 * | 'range-to' '(' Expr ')' Predicate* 11298 * 11299 * Compile one step in a Location Path 11300 * A location step of . is short for self::node(). This is 11301 * particularly useful in conjunction with //. For example, the 11302 * location path .//para is short for 11303 * self::node()/descendant-or-self::node()/child::para 11304 * and so will select all para descendant elements of the context 11305 * node. 11306 * Similarly, a location step of .. is short for parent::node(). 11307 * For example, ../title is short for parent::node()/child::title 11308 * and so will select the title children of the parent of the context 11309 * node. 11310 */ 11311 static void 11312 xmlXPathCompStep(xmlXPathParserContextPtr ctxt) { 11313 #ifdef LIBXML_XPTR_ENABLED 11314 int rangeto = 0; 11315 int op2 = -1; 11316 #endif 11317 11318 SKIP_BLANKS; 11319 if ((CUR == '.') && (NXT(1) == '.')) { 11320 SKIP(2); 11321 SKIP_BLANKS; 11322 PUSH_LONG_EXPR(XPATH_OP_COLLECT, AXIS_PARENT, 11323 NODE_TEST_TYPE, NODE_TYPE_NODE, NULL, NULL); 11324 } else if (CUR == '.') { 11325 NEXT; 11326 SKIP_BLANKS; 11327 } else { 11328 xmlChar *name = NULL; 11329 const xmlChar *prefix = NULL; 11330 xmlXPathTestVal test = (xmlXPathTestVal) 0; 11331 xmlXPathAxisVal axis = (xmlXPathAxisVal) 0; 11332 xmlXPathTypeVal type = (xmlXPathTypeVal) 0; 11333 int op1; 11334 11335 /* 11336 * The modification needed for XPointer change to the production 11337 */ 11338 #ifdef LIBXML_XPTR_ENABLED 11339 if (ctxt->xptr) { 11340 name = xmlXPathParseNCName(ctxt); 11341 if ((name != NULL) && (xmlStrEqual(name, BAD_CAST "range-to"))) { 11342 op2 = ctxt->comp->last; 11343 xmlFree(name); 11344 SKIP_BLANKS; 11345 if (CUR != '(') { 11346 XP_ERROR(XPATH_EXPR_ERROR); 11347 } 11348 NEXT; 11349 SKIP_BLANKS; 11350 11351 xmlXPathCompileExpr(ctxt, 1); 11352 /* PUSH_BINARY_EXPR(XPATH_OP_RANGETO, op2, ctxt->comp->last, 0, 0); */ 11353 CHECK_ERROR; 11354 11355 SKIP_BLANKS; 11356 if (CUR != ')') { 11357 XP_ERROR(XPATH_EXPR_ERROR); 11358 } 11359 NEXT; 11360 rangeto = 1; 11361 goto eval_predicates; 11362 } 11363 } 11364 #endif 11365 if (CUR == '*') { 11366 axis = AXIS_CHILD; 11367 } else { 11368 if (name == NULL) 11369 name = xmlXPathParseNCName(ctxt); 11370 if (name != NULL) { 11371 axis = xmlXPathIsAxisName(name); 11372 if (axis != 0) { 11373 SKIP_BLANKS; 11374 if ((CUR == ':') && (NXT(1) == ':')) { 11375 SKIP(2); 11376 xmlFree(name); 11377 name = NULL; 11378 } else { 11379 /* an element name can conflict with an axis one :-\ */ 11380 axis = AXIS_CHILD; 11381 } 11382 } else { 11383 axis = AXIS_CHILD; 11384 } 11385 } else if (CUR == '@') { 11386 NEXT; 11387 axis = AXIS_ATTRIBUTE; 11388 } else { 11389 axis = AXIS_CHILD; 11390 } 11391 } 11392 11393 if (ctxt->error != XPATH_EXPRESSION_OK) { 11394 xmlFree(name); 11395 return; 11396 } 11397 11398 name = xmlXPathCompNodeTest(ctxt, &test, &type, &prefix, name); 11399 if (test == 0) 11400 return; 11401 11402 if ((prefix != NULL) && (ctxt->context != NULL) && 11403 (ctxt->context->flags & XML_XPATH_CHECKNS)) { 11404 if (xmlXPathNsLookup(ctxt->context, prefix) == NULL) { 11405 xmlXPathErr(ctxt, XPATH_UNDEF_PREFIX_ERROR); 11406 } 11407 } 11408 #ifdef DEBUG_STEP 11409 xmlGenericError(xmlGenericErrorContext, 11410 "Basis : computing new set\n"); 11411 #endif 11412 11413 #ifdef DEBUG_STEP 11414 xmlGenericError(xmlGenericErrorContext, "Basis : "); 11415 if (ctxt->value == NULL) 11416 xmlGenericError(xmlGenericErrorContext, "no value\n"); 11417 else if (ctxt->value->nodesetval == NULL) 11418 xmlGenericError(xmlGenericErrorContext, "Empty\n"); 11419 else 11420 xmlGenericErrorContextNodeSet(stdout, ctxt->value->nodesetval); 11421 #endif 11422 11423 #ifdef LIBXML_XPTR_ENABLED 11424 eval_predicates: 11425 #endif 11426 op1 = ctxt->comp->last; 11427 ctxt->comp->last = -1; 11428 11429 SKIP_BLANKS; 11430 while (CUR == '[') { 11431 xmlXPathCompPredicate(ctxt, 0); 11432 } 11433 11434 #ifdef LIBXML_XPTR_ENABLED 11435 if (rangeto) { 11436 PUSH_BINARY_EXPR(XPATH_OP_RANGETO, op2, op1, 0, 0); 11437 } else 11438 #endif 11439 PUSH_FULL_EXPR(XPATH_OP_COLLECT, op1, ctxt->comp->last, axis, 11440 test, type, (void *)prefix, (void *)name); 11441 11442 } 11443 #ifdef DEBUG_STEP 11444 xmlGenericError(xmlGenericErrorContext, "Step : "); 11445 if (ctxt->value == NULL) 11446 xmlGenericError(xmlGenericErrorContext, "no value\n"); 11447 else if (ctxt->value->nodesetval == NULL) 11448 xmlGenericError(xmlGenericErrorContext, "Empty\n"); 11449 else 11450 xmlGenericErrorContextNodeSet(xmlGenericErrorContext, 11451 ctxt->value->nodesetval); 11452 #endif 11453 } 11454 11455 /** 11456 * xmlXPathCompRelativeLocationPath: 11457 * @ctxt: the XPath Parser context 11458 * 11459 * [3] RelativeLocationPath ::= Step 11460 * | RelativeLocationPath '/' Step 11461 * | AbbreviatedRelativeLocationPath 11462 * [11] AbbreviatedRelativeLocationPath ::= RelativeLocationPath '//' Step 11463 * 11464 * Compile a relative location path. 11465 */ 11466 static void 11467 xmlXPathCompRelativeLocationPath 11468 (xmlXPathParserContextPtr ctxt) { 11469 SKIP_BLANKS; 11470 if ((CUR == '/') && (NXT(1) == '/')) { 11471 SKIP(2); 11472 SKIP_BLANKS; 11473 PUSH_LONG_EXPR(XPATH_OP_COLLECT, AXIS_DESCENDANT_OR_SELF, 11474 NODE_TEST_TYPE, NODE_TYPE_NODE, NULL, NULL); 11475 } else if (CUR == '/') { 11476 NEXT; 11477 SKIP_BLANKS; 11478 } 11479 xmlXPathCompStep(ctxt); 11480 CHECK_ERROR; 11481 SKIP_BLANKS; 11482 while (CUR == '/') { 11483 if ((CUR == '/') && (NXT(1) == '/')) { 11484 SKIP(2); 11485 SKIP_BLANKS; 11486 PUSH_LONG_EXPR(XPATH_OP_COLLECT, AXIS_DESCENDANT_OR_SELF, 11487 NODE_TEST_TYPE, NODE_TYPE_NODE, NULL, NULL); 11488 xmlXPathCompStep(ctxt); 11489 } else if (CUR == '/') { 11490 NEXT; 11491 SKIP_BLANKS; 11492 xmlXPathCompStep(ctxt); 11493 } 11494 SKIP_BLANKS; 11495 } 11496 } 11497 11498 /** 11499 * xmlXPathCompLocationPath: 11500 * @ctxt: the XPath Parser context 11501 * 11502 * [1] LocationPath ::= RelativeLocationPath 11503 * | AbsoluteLocationPath 11504 * [2] AbsoluteLocationPath ::= '/' RelativeLocationPath? 11505 * | AbbreviatedAbsoluteLocationPath 11506 * [10] AbbreviatedAbsoluteLocationPath ::= 11507 * '//' RelativeLocationPath 11508 * 11509 * Compile a location path 11510 * 11511 * // is short for /descendant-or-self::node()/. For example, 11512 * //para is short for /descendant-or-self::node()/child::para and 11513 * so will select any para element in the document (even a para element 11514 * that is a document element will be selected by //para since the 11515 * document element node is a child of the root node); div//para is 11516 * short for div/descendant-or-self::node()/child::para and so will 11517 * select all para descendants of div children. 11518 */ 11519 static void 11520 xmlXPathCompLocationPath(xmlXPathParserContextPtr ctxt) { 11521 SKIP_BLANKS; 11522 if (CUR != '/') { 11523 xmlXPathCompRelativeLocationPath(ctxt); 11524 } else { 11525 while (CUR == '/') { 11526 if ((CUR == '/') && (NXT(1) == '/')) { 11527 SKIP(2); 11528 SKIP_BLANKS; 11529 PUSH_LONG_EXPR(XPATH_OP_COLLECT, AXIS_DESCENDANT_OR_SELF, 11530 NODE_TEST_TYPE, NODE_TYPE_NODE, NULL, NULL); 11531 xmlXPathCompRelativeLocationPath(ctxt); 11532 } else if (CUR == '/') { 11533 NEXT; 11534 SKIP_BLANKS; 11535 if ((CUR != 0 ) && 11536 ((IS_ASCII_LETTER(CUR)) || (CUR == '_') || (CUR == '.') || 11537 (CUR == '@') || (CUR == '*'))) 11538 xmlXPathCompRelativeLocationPath(ctxt); 11539 } 11540 CHECK_ERROR; 11541 } 11542 } 11543 } 11544 11545 /************************************************************************ 11546 * * 11547 * XPath precompiled expression evaluation * 11548 * * 11549 ************************************************************************/ 11550 11551 static int 11552 xmlXPathCompOpEval(xmlXPathParserContextPtr ctxt, xmlXPathStepOpPtr op); 11553 11554 #ifdef DEBUG_STEP 11555 static void 11556 xmlXPathDebugDumpStepAxis(xmlXPathStepOpPtr op, 11557 int nbNodes) 11558 { 11559 xmlGenericError(xmlGenericErrorContext, "new step : "); 11560 switch (op->value) { 11561 case AXIS_ANCESTOR: 11562 xmlGenericError(xmlGenericErrorContext, "axis 'ancestors' "); 11563 break; 11564 case AXIS_ANCESTOR_OR_SELF: 11565 xmlGenericError(xmlGenericErrorContext, 11566 "axis 'ancestors-or-self' "); 11567 break; 11568 case AXIS_ATTRIBUTE: 11569 xmlGenericError(xmlGenericErrorContext, "axis 'attributes' "); 11570 break; 11571 case AXIS_CHILD: 11572 xmlGenericError(xmlGenericErrorContext, "axis 'child' "); 11573 break; 11574 case AXIS_DESCENDANT: 11575 xmlGenericError(xmlGenericErrorContext, "axis 'descendant' "); 11576 break; 11577 case AXIS_DESCENDANT_OR_SELF: 11578 xmlGenericError(xmlGenericErrorContext, 11579 "axis 'descendant-or-self' "); 11580 break; 11581 case AXIS_FOLLOWING: 11582 xmlGenericError(xmlGenericErrorContext, "axis 'following' "); 11583 break; 11584 case AXIS_FOLLOWING_SIBLING: 11585 xmlGenericError(xmlGenericErrorContext, 11586 "axis 'following-siblings' "); 11587 break; 11588 case AXIS_NAMESPACE: 11589 xmlGenericError(xmlGenericErrorContext, "axis 'namespace' "); 11590 break; 11591 case AXIS_PARENT: 11592 xmlGenericError(xmlGenericErrorContext, "axis 'parent' "); 11593 break; 11594 case AXIS_PRECEDING: 11595 xmlGenericError(xmlGenericErrorContext, "axis 'preceding' "); 11596 break; 11597 case AXIS_PRECEDING_SIBLING: 11598 xmlGenericError(xmlGenericErrorContext, 11599 "axis 'preceding-sibling' "); 11600 break; 11601 case AXIS_SELF: 11602 xmlGenericError(xmlGenericErrorContext, "axis 'self' "); 11603 break; 11604 } 11605 xmlGenericError(xmlGenericErrorContext, 11606 " context contains %d nodes\n", nbNodes); 11607 switch (op->value2) { 11608 case NODE_TEST_NONE: 11609 xmlGenericError(xmlGenericErrorContext, 11610 " searching for none !!!\n"); 11611 break; 11612 case NODE_TEST_TYPE: 11613 xmlGenericError(xmlGenericErrorContext, 11614 " searching for type %d\n", op->value3); 11615 break; 11616 case NODE_TEST_PI: 11617 xmlGenericError(xmlGenericErrorContext, 11618 " searching for PI !!!\n"); 11619 break; 11620 case NODE_TEST_ALL: 11621 xmlGenericError(xmlGenericErrorContext, 11622 " searching for *\n"); 11623 break; 11624 case NODE_TEST_NS: 11625 xmlGenericError(xmlGenericErrorContext, 11626 " searching for namespace %s\n", 11627 op->value5); 11628 break; 11629 case NODE_TEST_NAME: 11630 xmlGenericError(xmlGenericErrorContext, 11631 " searching for name %s\n", op->value5); 11632 if (op->value4) 11633 xmlGenericError(xmlGenericErrorContext, 11634 " with namespace %s\n", op->value4); 11635 break; 11636 } 11637 xmlGenericError(xmlGenericErrorContext, "Testing : "); 11638 } 11639 #endif /* DEBUG_STEP */ 11640 11641 static int 11642 xmlXPathCompOpEvalPredicate(xmlXPathParserContextPtr ctxt, 11643 xmlXPathStepOpPtr op, 11644 xmlNodeSetPtr set, 11645 int contextSize, 11646 int hasNsNodes) 11647 { 11648 if (op->ch1 != -1) { 11649 xmlXPathCompExprPtr comp = ctxt->comp; 11650 /* 11651 * Process inner predicates first. 11652 */ 11653 if (comp->steps[op->ch1].op != XPATH_OP_PREDICATE) { 11654 /* 11655 * TODO: raise an internal error. 11656 */ 11657 } 11658 contextSize = xmlXPathCompOpEvalPredicate(ctxt, 11659 &comp->steps[op->ch1], set, contextSize, hasNsNodes); 11660 CHECK_ERROR0; 11661 if (contextSize <= 0) 11662 return(0); 11663 } 11664 if (op->ch2 != -1) { 11665 xmlXPathContextPtr xpctxt = ctxt->context; 11666 xmlNodePtr contextNode, oldContextNode; 11667 xmlDocPtr oldContextDoc; 11668 int i, res, contextPos = 0, newContextSize; 11669 xmlXPathStepOpPtr exprOp; 11670 xmlXPathObjectPtr contextObj = NULL, exprRes = NULL; 11671 11672 #ifdef LIBXML_XPTR_ENABLED 11673 /* 11674 * URGENT TODO: Check the following: 11675 * We don't expect location sets if evaluating prediates, right? 11676 * Only filters should expect location sets, right? 11677 */ 11678 #endif 11679 /* 11680 * SPEC XPath 1.0: 11681 * "For each node in the node-set to be filtered, the 11682 * PredicateExpr is evaluated with that node as the 11683 * context node, with the number of nodes in the 11684 * node-set as the context size, and with the proximity 11685 * position of the node in the node-set with respect to 11686 * the axis as the context position;" 11687 * @oldset is the node-set" to be filtered. 11688 * 11689 * SPEC XPath 1.0: 11690 * "only predicates change the context position and 11691 * context size (see [2.4 Predicates])." 11692 * Example: 11693 * node-set context pos 11694 * nA 1 11695 * nB 2 11696 * nC 3 11697 * After applying predicate [position() > 1] : 11698 * node-set context pos 11699 * nB 1 11700 * nC 2 11701 */ 11702 oldContextNode = xpctxt->node; 11703 oldContextDoc = xpctxt->doc; 11704 /* 11705 * Get the expression of this predicate. 11706 */ 11707 exprOp = &ctxt->comp->steps[op->ch2]; 11708 newContextSize = 0; 11709 for (i = 0; i < set->nodeNr; i++) { 11710 if (set->nodeTab[i] == NULL) 11711 continue; 11712 11713 contextNode = set->nodeTab[i]; 11714 xpctxt->node = contextNode; 11715 xpctxt->contextSize = contextSize; 11716 xpctxt->proximityPosition = ++contextPos; 11717 11718 /* 11719 * Also set the xpath document in case things like 11720 * key() are evaluated in the predicate. 11721 */ 11722 if ((contextNode->type != XML_NAMESPACE_DECL) && 11723 (contextNode->doc != NULL)) 11724 xpctxt->doc = contextNode->doc; 11725 /* 11726 * Evaluate the predicate expression with 1 context node 11727 * at a time; this node is packaged into a node set; this 11728 * node set is handed over to the evaluation mechanism. 11729 */ 11730 if (contextObj == NULL) 11731 contextObj = xmlXPathCacheNewNodeSet(xpctxt, contextNode); 11732 else { 11733 if (xmlXPathNodeSetAddUnique(contextObj->nodesetval, 11734 contextNode) < 0) { 11735 ctxt->error = XPATH_MEMORY_ERROR; 11736 goto evaluation_exit; 11737 } 11738 } 11739 11740 valuePush(ctxt, contextObj); 11741 11742 res = xmlXPathCompOpEvalToBoolean(ctxt, exprOp, 1); 11743 11744 if ((ctxt->error != XPATH_EXPRESSION_OK) || (res == -1)) { 11745 xmlXPathNodeSetClear(set, hasNsNodes); 11746 newContextSize = 0; 11747 goto evaluation_exit; 11748 } 11749 11750 if (res != 0) { 11751 newContextSize++; 11752 } else { 11753 /* 11754 * Remove the entry from the initial node set. 11755 */ 11756 set->nodeTab[i] = NULL; 11757 if (contextNode->type == XML_NAMESPACE_DECL) 11758 xmlXPathNodeSetFreeNs((xmlNsPtr) contextNode); 11759 } 11760 if (ctxt->value == contextObj) { 11761 /* 11762 * Don't free the temporary XPath object holding the 11763 * context node, in order to avoid massive recreation 11764 * inside this loop. 11765 */ 11766 valuePop(ctxt); 11767 xmlXPathNodeSetClear(contextObj->nodesetval, hasNsNodes); 11768 } else { 11769 /* 11770 * TODO: The object was lost in the evaluation machinery. 11771 * Can this happen? Maybe in internal-error cases. 11772 */ 11773 contextObj = NULL; 11774 } 11775 } 11776 11777 if (contextObj != NULL) { 11778 if (ctxt->value == contextObj) 11779 valuePop(ctxt); 11780 xmlXPathReleaseObject(xpctxt, contextObj); 11781 } 11782 evaluation_exit: 11783 if (exprRes != NULL) 11784 xmlXPathReleaseObject(ctxt->context, exprRes); 11785 /* 11786 * Reset/invalidate the context. 11787 */ 11788 xpctxt->node = oldContextNode; 11789 xpctxt->doc = oldContextDoc; 11790 xpctxt->contextSize = -1; 11791 xpctxt->proximityPosition = -1; 11792 return(newContextSize); 11793 } 11794 return(contextSize); 11795 } 11796 11797 static int 11798 xmlXPathCompOpEvalPositionalPredicate(xmlXPathParserContextPtr ctxt, 11799 xmlXPathStepOpPtr op, 11800 xmlNodeSetPtr set, 11801 int contextSize, 11802 int minPos, 11803 int maxPos, 11804 int hasNsNodes) 11805 { 11806 if (op->ch1 != -1) { 11807 xmlXPathCompExprPtr comp = ctxt->comp; 11808 if (comp->steps[op->ch1].op != XPATH_OP_PREDICATE) { 11809 /* 11810 * TODO: raise an internal error. 11811 */ 11812 } 11813 contextSize = xmlXPathCompOpEvalPredicate(ctxt, 11814 &comp->steps[op->ch1], set, contextSize, hasNsNodes); 11815 CHECK_ERROR0; 11816 if (contextSize <= 0) 11817 return(0); 11818 } 11819 /* 11820 * Check if the node set contains a sufficient number of nodes for 11821 * the requested range. 11822 */ 11823 if (contextSize < minPos) { 11824 xmlXPathNodeSetClear(set, hasNsNodes); 11825 return(0); 11826 } 11827 if (op->ch2 == -1) { 11828 /* 11829 * TODO: Can this ever happen? 11830 */ 11831 return (contextSize); 11832 } else { 11833 xmlDocPtr oldContextDoc; 11834 int i, pos = 0, newContextSize = 0, contextPos = 0, res; 11835 xmlXPathStepOpPtr exprOp; 11836 xmlXPathObjectPtr contextObj = NULL, exprRes = NULL; 11837 xmlNodePtr oldContextNode, contextNode = NULL; 11838 xmlXPathContextPtr xpctxt = ctxt->context; 11839 int frame; 11840 11841 #ifdef LIBXML_XPTR_ENABLED 11842 /* 11843 * URGENT TODO: Check the following: 11844 * We don't expect location sets if evaluating prediates, right? 11845 * Only filters should expect location sets, right? 11846 */ 11847 #endif /* LIBXML_XPTR_ENABLED */ 11848 11849 /* 11850 * Save old context. 11851 */ 11852 oldContextNode = xpctxt->node; 11853 oldContextDoc = xpctxt->doc; 11854 /* 11855 * Get the expression of this predicate. 11856 */ 11857 exprOp = &ctxt->comp->steps[op->ch2]; 11858 for (i = 0; i < set->nodeNr; i++) { 11859 xmlXPathObjectPtr tmp; 11860 11861 if (set->nodeTab[i] == NULL) 11862 continue; 11863 11864 contextNode = set->nodeTab[i]; 11865 xpctxt->node = contextNode; 11866 xpctxt->contextSize = contextSize; 11867 xpctxt->proximityPosition = ++contextPos; 11868 11869 /* 11870 * Initialize the new set. 11871 * Also set the xpath document in case things like 11872 * key() evaluation are attempted on the predicate 11873 */ 11874 if ((contextNode->type != XML_NAMESPACE_DECL) && 11875 (contextNode->doc != NULL)) 11876 xpctxt->doc = contextNode->doc; 11877 /* 11878 * Evaluate the predicate expression with 1 context node 11879 * at a time; this node is packaged into a node set; this 11880 * node set is handed over to the evaluation mechanism. 11881 */ 11882 if (contextObj == NULL) 11883 contextObj = xmlXPathCacheNewNodeSet(xpctxt, contextNode); 11884 else { 11885 if (xmlXPathNodeSetAddUnique(contextObj->nodesetval, 11886 contextNode) < 0) { 11887 ctxt->error = XPATH_MEMORY_ERROR; 11888 goto evaluation_exit; 11889 } 11890 } 11891 11892 valuePush(ctxt, contextObj); 11893 frame = xmlXPathSetFrame(ctxt); 11894 res = xmlXPathCompOpEvalToBoolean(ctxt, exprOp, 1); 11895 xmlXPathPopFrame(ctxt, frame); 11896 tmp = valuePop(ctxt); 11897 11898 if ((ctxt->error != XPATH_EXPRESSION_OK) || (res == -1)) { 11899 while (tmp != contextObj) { 11900 /* 11901 * Free up the result 11902 * then pop off contextObj, which will be freed later 11903 */ 11904 xmlXPathReleaseObject(xpctxt, tmp); 11905 tmp = valuePop(ctxt); 11906 } 11907 goto evaluation_error; 11908 } 11909 /* push the result back onto the stack */ 11910 valuePush(ctxt, tmp); 11911 11912 if (res) 11913 pos++; 11914 11915 if (res && (pos >= minPos) && (pos <= maxPos)) { 11916 /* 11917 * Fits in the requested range. 11918 */ 11919 newContextSize++; 11920 if (minPos == maxPos) { 11921 /* 11922 * Only 1 node was requested. 11923 */ 11924 if (contextNode->type == XML_NAMESPACE_DECL) { 11925 /* 11926 * As always: take care of those nasty 11927 * namespace nodes. 11928 */ 11929 set->nodeTab[i] = NULL; 11930 } 11931 xmlXPathNodeSetClear(set, hasNsNodes); 11932 set->nodeNr = 1; 11933 set->nodeTab[0] = contextNode; 11934 goto evaluation_exit; 11935 } 11936 if (pos == maxPos) { 11937 /* 11938 * We are done. 11939 */ 11940 xmlXPathNodeSetClearFromPos(set, i +1, hasNsNodes); 11941 goto evaluation_exit; 11942 } 11943 } else { 11944 /* 11945 * Remove the entry from the initial node set. 11946 */ 11947 set->nodeTab[i] = NULL; 11948 if (contextNode->type == XML_NAMESPACE_DECL) 11949 xmlXPathNodeSetFreeNs((xmlNsPtr) contextNode); 11950 } 11951 if (exprRes != NULL) { 11952 xmlXPathReleaseObject(ctxt->context, exprRes); 11953 exprRes = NULL; 11954 } 11955 if (ctxt->value == contextObj) { 11956 /* 11957 * Don't free the temporary XPath object holding the 11958 * context node, in order to avoid massive recreation 11959 * inside this loop. 11960 */ 11961 valuePop(ctxt); 11962 xmlXPathNodeSetClear(contextObj->nodesetval, hasNsNodes); 11963 } else { 11964 /* 11965 * The object was lost in the evaluation machinery. 11966 * Can this happen? Maybe in case of internal-errors. 11967 */ 11968 contextObj = NULL; 11969 } 11970 } 11971 goto evaluation_exit; 11972 11973 evaluation_error: 11974 xmlXPathNodeSetClear(set, hasNsNodes); 11975 newContextSize = 0; 11976 11977 evaluation_exit: 11978 if (contextObj != NULL) { 11979 if (ctxt->value == contextObj) 11980 valuePop(ctxt); 11981 xmlXPathReleaseObject(xpctxt, contextObj); 11982 } 11983 if (exprRes != NULL) 11984 xmlXPathReleaseObject(ctxt->context, exprRes); 11985 /* 11986 * Reset/invalidate the context. 11987 */ 11988 xpctxt->node = oldContextNode; 11989 xpctxt->doc = oldContextDoc; 11990 xpctxt->contextSize = -1; 11991 xpctxt->proximityPosition = -1; 11992 return(newContextSize); 11993 } 11994 return(contextSize); 11995 } 11996 11997 static int 11998 xmlXPathIsPositionalPredicate(xmlXPathParserContextPtr ctxt, 11999 xmlXPathStepOpPtr op, 12000 int *maxPos) 12001 { 12002 12003 xmlXPathStepOpPtr exprOp; 12004 12005 /* 12006 * BIG NOTE: This is not intended for XPATH_OP_FILTER yet! 12007 */ 12008 12009 /* 12010 * If not -1, then ch1 will point to: 12011 * 1) For predicates (XPATH_OP_PREDICATE): 12012 * - an inner predicate operator 12013 * 2) For filters (XPATH_OP_FILTER): 12014 * - an inner filter operater OR 12015 * - an expression selecting the node set. 12016 * E.g. "key('a', 'b')" or "(//foo | //bar)". 12017 */ 12018 if ((op->op != XPATH_OP_PREDICATE) && (op->op != XPATH_OP_FILTER)) 12019 return(0); 12020 12021 if (op->ch2 != -1) { 12022 exprOp = &ctxt->comp->steps[op->ch2]; 12023 } else 12024 return(0); 12025 12026 if ((exprOp != NULL) && 12027 (exprOp->op == XPATH_OP_VALUE) && 12028 (exprOp->value4 != NULL) && 12029 (((xmlXPathObjectPtr) exprOp->value4)->type == XPATH_NUMBER)) 12030 { 12031 double floatval = ((xmlXPathObjectPtr) exprOp->value4)->floatval; 12032 12033 /* 12034 * We have a "[n]" predicate here. 12035 * TODO: Unfortunately this simplistic test here is not 12036 * able to detect a position() predicate in compound 12037 * expressions like "[@attr = 'a" and position() = 1], 12038 * and even not the usage of position() in 12039 * "[position() = 1]"; thus - obviously - a position-range, 12040 * like it "[position() < 5]", is also not detected. 12041 * Maybe we could rewrite the AST to ease the optimization. 12042 */ 12043 12044 if ((floatval > INT_MIN) && (floatval < INT_MAX)) { 12045 *maxPos = (int) floatval; 12046 if (floatval == (double) *maxPos) 12047 return(1); 12048 } 12049 } 12050 return(0); 12051 } 12052 12053 static int 12054 xmlXPathNodeCollectAndTest(xmlXPathParserContextPtr ctxt, 12055 xmlXPathStepOpPtr op, 12056 xmlNodePtr * first, xmlNodePtr * last, 12057 int toBool) 12058 { 12059 12060 #define XP_TEST_HIT \ 12061 if (hasAxisRange != 0) { \ 12062 if (++pos == maxPos) { \ 12063 if (addNode(seq, cur) < 0) \ 12064 ctxt->error = XPATH_MEMORY_ERROR; \ 12065 goto axis_range_end; } \ 12066 } else { \ 12067 if (addNode(seq, cur) < 0) \ 12068 ctxt->error = XPATH_MEMORY_ERROR; \ 12069 if (breakOnFirstHit) goto first_hit; } 12070 12071 #define XP_TEST_HIT_NS \ 12072 if (hasAxisRange != 0) { \ 12073 if (++pos == maxPos) { \ 12074 hasNsNodes = 1; \ 12075 if (xmlXPathNodeSetAddNs(seq, xpctxt->node, (xmlNsPtr) cur) < 0) \ 12076 ctxt->error = XPATH_MEMORY_ERROR; \ 12077 goto axis_range_end; } \ 12078 } else { \ 12079 hasNsNodes = 1; \ 12080 if (xmlXPathNodeSetAddNs(seq, xpctxt->node, (xmlNsPtr) cur) < 0) \ 12081 ctxt->error = XPATH_MEMORY_ERROR; \ 12082 if (breakOnFirstHit) goto first_hit; } 12083 12084 xmlXPathAxisVal axis = (xmlXPathAxisVal) op->value; 12085 xmlXPathTestVal test = (xmlXPathTestVal) op->value2; 12086 xmlXPathTypeVal type = (xmlXPathTypeVal) op->value3; 12087 const xmlChar *prefix = op->value4; 12088 const xmlChar *name = op->value5; 12089 const xmlChar *URI = NULL; 12090 12091 #ifdef DEBUG_STEP 12092 int nbMatches = 0, prevMatches = 0; 12093 #endif 12094 int total = 0, hasNsNodes = 0; 12095 /* The popped object holding the context nodes */ 12096 xmlXPathObjectPtr obj; 12097 /* The set of context nodes for the node tests */ 12098 xmlNodeSetPtr contextSeq; 12099 int contextIdx; 12100 xmlNodePtr contextNode; 12101 /* The final resulting node set wrt to all context nodes */ 12102 xmlNodeSetPtr outSeq; 12103 /* 12104 * The temporary resulting node set wrt 1 context node. 12105 * Used to feed predicate evaluation. 12106 */ 12107 xmlNodeSetPtr seq; 12108 xmlNodePtr cur; 12109 /* First predicate operator */ 12110 xmlXPathStepOpPtr predOp; 12111 int maxPos; /* The requested position() (when a "[n]" predicate) */ 12112 int hasPredicateRange, hasAxisRange, pos, size, newSize; 12113 int breakOnFirstHit; 12114 12115 xmlXPathTraversalFunction next = NULL; 12116 int (*addNode) (xmlNodeSetPtr, xmlNodePtr); 12117 xmlXPathNodeSetMergeFunction mergeAndClear; 12118 xmlNodePtr oldContextNode; 12119 xmlXPathContextPtr xpctxt = ctxt->context; 12120 12121 12122 CHECK_TYPE0(XPATH_NODESET); 12123 obj = valuePop(ctxt); 12124 /* 12125 * Setup namespaces. 12126 */ 12127 if (prefix != NULL) { 12128 URI = xmlXPathNsLookup(xpctxt, prefix); 12129 if (URI == NULL) { 12130 xmlXPathReleaseObject(xpctxt, obj); 12131 XP_ERROR0(XPATH_UNDEF_PREFIX_ERROR); 12132 } 12133 } 12134 /* 12135 * Setup axis. 12136 * 12137 * MAYBE FUTURE TODO: merging optimizations: 12138 * - If the nodes to be traversed wrt to the initial nodes and 12139 * the current axis cannot overlap, then we could avoid searching 12140 * for duplicates during the merge. 12141 * But the question is how/when to evaluate if they cannot overlap. 12142 * Example: if we know that for two initial nodes, the one is 12143 * not in the ancestor-or-self axis of the other, then we could safely 12144 * avoid a duplicate-aware merge, if the axis to be traversed is e.g. 12145 * the descendant-or-self axis. 12146 */ 12147 mergeAndClear = xmlXPathNodeSetMergeAndClear; 12148 switch (axis) { 12149 case AXIS_ANCESTOR: 12150 first = NULL; 12151 next = xmlXPathNextAncestor; 12152 break; 12153 case AXIS_ANCESTOR_OR_SELF: 12154 first = NULL; 12155 next = xmlXPathNextAncestorOrSelf; 12156 break; 12157 case AXIS_ATTRIBUTE: 12158 first = NULL; 12159 last = NULL; 12160 next = xmlXPathNextAttribute; 12161 mergeAndClear = xmlXPathNodeSetMergeAndClearNoDupls; 12162 break; 12163 case AXIS_CHILD: 12164 last = NULL; 12165 if (((test == NODE_TEST_NAME) || (test == NODE_TEST_ALL)) && 12166 (type == NODE_TYPE_NODE)) 12167 { 12168 /* 12169 * Optimization if an element node type is 'element'. 12170 */ 12171 next = xmlXPathNextChildElement; 12172 } else 12173 next = xmlXPathNextChild; 12174 mergeAndClear = xmlXPathNodeSetMergeAndClearNoDupls; 12175 break; 12176 case AXIS_DESCENDANT: 12177 last = NULL; 12178 next = xmlXPathNextDescendant; 12179 break; 12180 case AXIS_DESCENDANT_OR_SELF: 12181 last = NULL; 12182 next = xmlXPathNextDescendantOrSelf; 12183 break; 12184 case AXIS_FOLLOWING: 12185 last = NULL; 12186 next = xmlXPathNextFollowing; 12187 break; 12188 case AXIS_FOLLOWING_SIBLING: 12189 last = NULL; 12190 next = xmlXPathNextFollowingSibling; 12191 break; 12192 case AXIS_NAMESPACE: 12193 first = NULL; 12194 last = NULL; 12195 next = (xmlXPathTraversalFunction) xmlXPathNextNamespace; 12196 mergeAndClear = xmlXPathNodeSetMergeAndClearNoDupls; 12197 break; 12198 case AXIS_PARENT: 12199 first = NULL; 12200 next = xmlXPathNextParent; 12201 break; 12202 case AXIS_PRECEDING: 12203 first = NULL; 12204 next = xmlXPathNextPrecedingInternal; 12205 break; 12206 case AXIS_PRECEDING_SIBLING: 12207 first = NULL; 12208 next = xmlXPathNextPrecedingSibling; 12209 break; 12210 case AXIS_SELF: 12211 first = NULL; 12212 last = NULL; 12213 next = xmlXPathNextSelf; 12214 mergeAndClear = xmlXPathNodeSetMergeAndClearNoDupls; 12215 break; 12216 } 12217 12218 #ifdef DEBUG_STEP 12219 xmlXPathDebugDumpStepAxis(op, 12220 (obj->nodesetval != NULL) ? obj->nodesetval->nodeNr : 0); 12221 #endif 12222 12223 if (next == NULL) { 12224 xmlXPathReleaseObject(xpctxt, obj); 12225 return(0); 12226 } 12227 contextSeq = obj->nodesetval; 12228 if ((contextSeq == NULL) || (contextSeq->nodeNr <= 0)) { 12229 xmlXPathReleaseObject(xpctxt, obj); 12230 valuePush(ctxt, xmlXPathCacheWrapNodeSet(xpctxt, NULL)); 12231 return(0); 12232 } 12233 /* 12234 * Predicate optimization --------------------------------------------- 12235 * If this step has a last predicate, which contains a position(), 12236 * then we'll optimize (although not exactly "position()", but only 12237 * the short-hand form, i.e., "[n]". 12238 * 12239 * Example - expression "/foo[parent::bar][1]": 12240 * 12241 * COLLECT 'child' 'name' 'node' foo -- op (we are here) 12242 * ROOT -- op->ch1 12243 * PREDICATE -- op->ch2 (predOp) 12244 * PREDICATE -- predOp->ch1 = [parent::bar] 12245 * SORT 12246 * COLLECT 'parent' 'name' 'node' bar 12247 * NODE 12248 * ELEM Object is a number : 1 -- predOp->ch2 = [1] 12249 * 12250 */ 12251 maxPos = 0; 12252 predOp = NULL; 12253 hasPredicateRange = 0; 12254 hasAxisRange = 0; 12255 if (op->ch2 != -1) { 12256 /* 12257 * There's at least one predicate. 16 == XPATH_OP_PREDICATE 12258 */ 12259 predOp = &ctxt->comp->steps[op->ch2]; 12260 if (xmlXPathIsPositionalPredicate(ctxt, predOp, &maxPos)) { 12261 if (predOp->ch1 != -1) { 12262 /* 12263 * Use the next inner predicate operator. 12264 */ 12265 predOp = &ctxt->comp->steps[predOp->ch1]; 12266 hasPredicateRange = 1; 12267 } else { 12268 /* 12269 * There's no other predicate than the [n] predicate. 12270 */ 12271 predOp = NULL; 12272 hasAxisRange = 1; 12273 } 12274 } 12275 } 12276 breakOnFirstHit = ((toBool) && (predOp == NULL)) ? 1 : 0; 12277 /* 12278 * Axis traversal ----------------------------------------------------- 12279 */ 12280 /* 12281 * 2.3 Node Tests 12282 * - For the attribute axis, the principal node type is attribute. 12283 * - For the namespace axis, the principal node type is namespace. 12284 * - For other axes, the principal node type is element. 12285 * 12286 * A node test * is true for any node of the 12287 * principal node type. For example, child::* will 12288 * select all element children of the context node 12289 */ 12290 oldContextNode = xpctxt->node; 12291 addNode = xmlXPathNodeSetAddUnique; 12292 outSeq = NULL; 12293 seq = NULL; 12294 contextNode = NULL; 12295 contextIdx = 0; 12296 12297 12298 while (((contextIdx < contextSeq->nodeNr) || (contextNode != NULL)) && 12299 (ctxt->error == XPATH_EXPRESSION_OK)) { 12300 xpctxt->node = contextSeq->nodeTab[contextIdx++]; 12301 12302 if (seq == NULL) { 12303 seq = xmlXPathNodeSetCreate(NULL); 12304 if (seq == NULL) { 12305 total = 0; 12306 goto error; 12307 } 12308 } 12309 /* 12310 * Traverse the axis and test the nodes. 12311 */ 12312 pos = 0; 12313 cur = NULL; 12314 hasNsNodes = 0; 12315 do { 12316 cur = next(ctxt, cur); 12317 if (cur == NULL) 12318 break; 12319 12320 /* 12321 * QUESTION TODO: What does the "first" and "last" stuff do? 12322 */ 12323 if ((first != NULL) && (*first != NULL)) { 12324 if (*first == cur) 12325 break; 12326 if (((total % 256) == 0) && 12327 #ifdef XP_OPTIMIZED_NON_ELEM_COMPARISON 12328 (xmlXPathCmpNodesExt(*first, cur) >= 0)) 12329 #else 12330 (xmlXPathCmpNodes(*first, cur) >= 0)) 12331 #endif 12332 { 12333 break; 12334 } 12335 } 12336 if ((last != NULL) && (*last != NULL)) { 12337 if (*last == cur) 12338 break; 12339 if (((total % 256) == 0) && 12340 #ifdef XP_OPTIMIZED_NON_ELEM_COMPARISON 12341 (xmlXPathCmpNodesExt(cur, *last) >= 0)) 12342 #else 12343 (xmlXPathCmpNodes(cur, *last) >= 0)) 12344 #endif 12345 { 12346 break; 12347 } 12348 } 12349 12350 total++; 12351 12352 #ifdef DEBUG_STEP 12353 xmlGenericError(xmlGenericErrorContext, " %s", cur->name); 12354 #endif 12355 12356 switch (test) { 12357 case NODE_TEST_NONE: 12358 total = 0; 12359 STRANGE 12360 goto error; 12361 case NODE_TEST_TYPE: 12362 if (type == NODE_TYPE_NODE) { 12363 switch (cur->type) { 12364 case XML_DOCUMENT_NODE: 12365 case XML_HTML_DOCUMENT_NODE: 12366 #ifdef LIBXML_DOCB_ENABLED 12367 case XML_DOCB_DOCUMENT_NODE: 12368 #endif 12369 case XML_ELEMENT_NODE: 12370 case XML_ATTRIBUTE_NODE: 12371 case XML_PI_NODE: 12372 case XML_COMMENT_NODE: 12373 case XML_CDATA_SECTION_NODE: 12374 case XML_TEXT_NODE: 12375 XP_TEST_HIT 12376 break; 12377 case XML_NAMESPACE_DECL: { 12378 if (axis == AXIS_NAMESPACE) { 12379 XP_TEST_HIT_NS 12380 } else { 12381 hasNsNodes = 1; 12382 XP_TEST_HIT 12383 } 12384 break; 12385 } 12386 default: 12387 break; 12388 } 12389 } else if (cur->type == (xmlElementType) type) { 12390 if (cur->type == XML_NAMESPACE_DECL) 12391 XP_TEST_HIT_NS 12392 else 12393 XP_TEST_HIT 12394 } else if ((type == NODE_TYPE_TEXT) && 12395 (cur->type == XML_CDATA_SECTION_NODE)) 12396 { 12397 XP_TEST_HIT 12398 } 12399 break; 12400 case NODE_TEST_PI: 12401 if ((cur->type == XML_PI_NODE) && 12402 ((name == NULL) || xmlStrEqual(name, cur->name))) 12403 { 12404 XP_TEST_HIT 12405 } 12406 break; 12407 case NODE_TEST_ALL: 12408 if (axis == AXIS_ATTRIBUTE) { 12409 if (cur->type == XML_ATTRIBUTE_NODE) 12410 { 12411 if (prefix == NULL) 12412 { 12413 XP_TEST_HIT 12414 } else if ((cur->ns != NULL) && 12415 (xmlStrEqual(URI, cur->ns->href))) 12416 { 12417 XP_TEST_HIT 12418 } 12419 } 12420 } else if (axis == AXIS_NAMESPACE) { 12421 if (cur->type == XML_NAMESPACE_DECL) 12422 { 12423 XP_TEST_HIT_NS 12424 } 12425 } else { 12426 if (cur->type == XML_ELEMENT_NODE) { 12427 if (prefix == NULL) 12428 { 12429 XP_TEST_HIT 12430 12431 } else if ((cur->ns != NULL) && 12432 (xmlStrEqual(URI, cur->ns->href))) 12433 { 12434 XP_TEST_HIT 12435 } 12436 } 12437 } 12438 break; 12439 case NODE_TEST_NS:{ 12440 TODO; 12441 break; 12442 } 12443 case NODE_TEST_NAME: 12444 if (axis == AXIS_ATTRIBUTE) { 12445 if (cur->type != XML_ATTRIBUTE_NODE) 12446 break; 12447 } else if (axis == AXIS_NAMESPACE) { 12448 if (cur->type != XML_NAMESPACE_DECL) 12449 break; 12450 } else { 12451 if (cur->type != XML_ELEMENT_NODE) 12452 break; 12453 } 12454 switch (cur->type) { 12455 case XML_ELEMENT_NODE: 12456 if (xmlStrEqual(name, cur->name)) { 12457 if (prefix == NULL) { 12458 if (cur->ns == NULL) 12459 { 12460 XP_TEST_HIT 12461 } 12462 } else { 12463 if ((cur->ns != NULL) && 12464 (xmlStrEqual(URI, cur->ns->href))) 12465 { 12466 XP_TEST_HIT 12467 } 12468 } 12469 } 12470 break; 12471 case XML_ATTRIBUTE_NODE:{ 12472 xmlAttrPtr attr = (xmlAttrPtr) cur; 12473 12474 if (xmlStrEqual(name, attr->name)) { 12475 if (prefix == NULL) { 12476 if ((attr->ns == NULL) || 12477 (attr->ns->prefix == NULL)) 12478 { 12479 XP_TEST_HIT 12480 } 12481 } else { 12482 if ((attr->ns != NULL) && 12483 (xmlStrEqual(URI, 12484 attr->ns->href))) 12485 { 12486 XP_TEST_HIT 12487 } 12488 } 12489 } 12490 break; 12491 } 12492 case XML_NAMESPACE_DECL: 12493 if (cur->type == XML_NAMESPACE_DECL) { 12494 xmlNsPtr ns = (xmlNsPtr) cur; 12495 12496 if ((ns->prefix != NULL) && (name != NULL) 12497 && (xmlStrEqual(ns->prefix, name))) 12498 { 12499 XP_TEST_HIT_NS 12500 } 12501 } 12502 break; 12503 default: 12504 break; 12505 } 12506 break; 12507 } /* switch(test) */ 12508 } while ((cur != NULL) && (ctxt->error == XPATH_EXPRESSION_OK)); 12509 12510 goto apply_predicates; 12511 12512 axis_range_end: /* ----------------------------------------------------- */ 12513 /* 12514 * We have a "/foo[n]", and position() = n was reached. 12515 * Note that we can have as well "/foo/::parent::foo[1]", so 12516 * a duplicate-aware merge is still needed. 12517 * Merge with the result. 12518 */ 12519 if (outSeq == NULL) { 12520 outSeq = seq; 12521 seq = NULL; 12522 } else 12523 outSeq = mergeAndClear(outSeq, seq, 0); 12524 /* 12525 * Break if only a true/false result was requested. 12526 */ 12527 if (toBool) 12528 break; 12529 continue; 12530 12531 first_hit: /* ---------------------------------------------------------- */ 12532 /* 12533 * Break if only a true/false result was requested and 12534 * no predicates existed and a node test succeeded. 12535 */ 12536 if (outSeq == NULL) { 12537 outSeq = seq; 12538 seq = NULL; 12539 } else 12540 outSeq = mergeAndClear(outSeq, seq, 0); 12541 break; 12542 12543 #ifdef DEBUG_STEP 12544 if (seq != NULL) 12545 nbMatches += seq->nodeNr; 12546 #endif 12547 12548 apply_predicates: /* --------------------------------------------------- */ 12549 if (ctxt->error != XPATH_EXPRESSION_OK) 12550 goto error; 12551 12552 /* 12553 * Apply predicates. 12554 */ 12555 if ((predOp != NULL) && (seq->nodeNr > 0)) { 12556 /* 12557 * E.g. when we have a "/foo[some expression][n]". 12558 */ 12559 /* 12560 * QUESTION TODO: The old predicate evaluation took into 12561 * account location-sets. 12562 * (E.g. ctxt->value->type == XPATH_LOCATIONSET) 12563 * Do we expect such a set here? 12564 * All what I learned now from the evaluation semantics 12565 * does not indicate that a location-set will be processed 12566 * here, so this looks OK. 12567 */ 12568 /* 12569 * Iterate over all predicates, starting with the outermost 12570 * predicate. 12571 * TODO: Problem: we cannot execute the inner predicates first 12572 * since we cannot go back *up* the operator tree! 12573 * Options we have: 12574 * 1) Use of recursive functions (like is it currently done 12575 * via xmlXPathCompOpEval()) 12576 * 2) Add a predicate evaluation information stack to the 12577 * context struct 12578 * 3) Change the way the operators are linked; we need a 12579 * "parent" field on xmlXPathStepOp 12580 * 12581 * For the moment, I'll try to solve this with a recursive 12582 * function: xmlXPathCompOpEvalPredicate(). 12583 */ 12584 size = seq->nodeNr; 12585 if (hasPredicateRange != 0) 12586 newSize = xmlXPathCompOpEvalPositionalPredicate(ctxt, 12587 predOp, seq, size, maxPos, maxPos, hasNsNodes); 12588 else 12589 newSize = xmlXPathCompOpEvalPredicate(ctxt, 12590 predOp, seq, size, hasNsNodes); 12591 12592 if (ctxt->error != XPATH_EXPRESSION_OK) { 12593 total = 0; 12594 goto error; 12595 } 12596 /* 12597 * Add the filtered set of nodes to the result node set. 12598 */ 12599 if (newSize == 0) { 12600 /* 12601 * The predicates filtered all nodes out. 12602 */ 12603 xmlXPathNodeSetClear(seq, hasNsNodes); 12604 } else if (seq->nodeNr > 0) { 12605 /* 12606 * Add to result set. 12607 */ 12608 if (outSeq == NULL) { 12609 if (size != newSize) { 12610 /* 12611 * We need to merge and clear here, since 12612 * the sequence will contained NULLed entries. 12613 */ 12614 outSeq = mergeAndClear(NULL, seq, 1); 12615 } else { 12616 outSeq = seq; 12617 seq = NULL; 12618 } 12619 } else 12620 outSeq = mergeAndClear(outSeq, seq, 12621 (size != newSize) ? 1: 0); 12622 /* 12623 * Break if only a true/false result was requested. 12624 */ 12625 if (toBool) 12626 break; 12627 } 12628 } else if (seq->nodeNr > 0) { 12629 /* 12630 * Add to result set. 12631 */ 12632 if (outSeq == NULL) { 12633 outSeq = seq; 12634 seq = NULL; 12635 } else { 12636 outSeq = mergeAndClear(outSeq, seq, 0); 12637 } 12638 } 12639 } 12640 12641 error: 12642 if ((obj->boolval) && (obj->user != NULL)) { 12643 /* 12644 * QUESTION TODO: What does this do and why? 12645 * TODO: Do we have to do this also for the "error" 12646 * cleanup further down? 12647 */ 12648 ctxt->value->boolval = 1; 12649 ctxt->value->user = obj->user; 12650 obj->user = NULL; 12651 obj->boolval = 0; 12652 } 12653 xmlXPathReleaseObject(xpctxt, obj); 12654 12655 /* 12656 * Ensure we return at least an emtpy set. 12657 */ 12658 if (outSeq == NULL) { 12659 if ((seq != NULL) && (seq->nodeNr == 0)) 12660 outSeq = seq; 12661 else 12662 outSeq = xmlXPathNodeSetCreate(NULL); 12663 /* XXX what if xmlXPathNodeSetCreate returned NULL here? */ 12664 } 12665 if ((seq != NULL) && (seq != outSeq)) { 12666 xmlXPathFreeNodeSet(seq); 12667 } 12668 /* 12669 * Hand over the result. Better to push the set also in 12670 * case of errors. 12671 */ 12672 valuePush(ctxt, xmlXPathCacheWrapNodeSet(xpctxt, outSeq)); 12673 /* 12674 * Reset the context node. 12675 */ 12676 xpctxt->node = oldContextNode; 12677 /* 12678 * When traversing the namespace axis in "toBool" mode, it's 12679 * possible that tmpNsList wasn't freed. 12680 */ 12681 if (xpctxt->tmpNsList != NULL) { 12682 xmlFree(xpctxt->tmpNsList); 12683 xpctxt->tmpNsList = NULL; 12684 } 12685 12686 #ifdef DEBUG_STEP 12687 xmlGenericError(xmlGenericErrorContext, 12688 "\nExamined %d nodes, found %d nodes at that step\n", 12689 total, nbMatches); 12690 #endif 12691 12692 return(total); 12693 } 12694 12695 static int 12696 xmlXPathCompOpEvalFilterFirst(xmlXPathParserContextPtr ctxt, 12697 xmlXPathStepOpPtr op, xmlNodePtr * first); 12698 12699 /** 12700 * xmlXPathCompOpEvalFirst: 12701 * @ctxt: the XPath parser context with the compiled expression 12702 * @op: an XPath compiled operation 12703 * @first: the first elem found so far 12704 * 12705 * Evaluate the Precompiled XPath operation searching only the first 12706 * element in document order 12707 * 12708 * Returns the number of examined objects. 12709 */ 12710 static int 12711 xmlXPathCompOpEvalFirst(xmlXPathParserContextPtr ctxt, 12712 xmlXPathStepOpPtr op, xmlNodePtr * first) 12713 { 12714 int total = 0, cur; 12715 xmlXPathCompExprPtr comp; 12716 xmlXPathObjectPtr arg1, arg2; 12717 12718 CHECK_ERROR0; 12719 comp = ctxt->comp; 12720 switch (op->op) { 12721 case XPATH_OP_END: 12722 return (0); 12723 case XPATH_OP_UNION: 12724 total = 12725 xmlXPathCompOpEvalFirst(ctxt, &comp->steps[op->ch1], 12726 first); 12727 CHECK_ERROR0; 12728 if ((ctxt->value != NULL) 12729 && (ctxt->value->type == XPATH_NODESET) 12730 && (ctxt->value->nodesetval != NULL) 12731 && (ctxt->value->nodesetval->nodeNr >= 1)) { 12732 /* 12733 * limit tree traversing to first node in the result 12734 */ 12735 /* 12736 * OPTIMIZE TODO: This implicitely sorts 12737 * the result, even if not needed. E.g. if the argument 12738 * of the count() function, no sorting is needed. 12739 * OPTIMIZE TODO: How do we know if the node-list wasn't 12740 * aready sorted? 12741 */ 12742 if (ctxt->value->nodesetval->nodeNr > 1) 12743 xmlXPathNodeSetSort(ctxt->value->nodesetval); 12744 *first = ctxt->value->nodesetval->nodeTab[0]; 12745 } 12746 cur = 12747 xmlXPathCompOpEvalFirst(ctxt, &comp->steps[op->ch2], 12748 first); 12749 CHECK_ERROR0; 12750 12751 arg2 = valuePop(ctxt); 12752 arg1 = valuePop(ctxt); 12753 if ((arg1 == NULL) || (arg1->type != XPATH_NODESET) || 12754 (arg2 == NULL) || (arg2->type != XPATH_NODESET)) { 12755 xmlXPathReleaseObject(ctxt->context, arg1); 12756 xmlXPathReleaseObject(ctxt->context, arg2); 12757 XP_ERROR0(XPATH_INVALID_TYPE); 12758 } 12759 12760 arg1->nodesetval = xmlXPathNodeSetMerge(arg1->nodesetval, 12761 arg2->nodesetval); 12762 valuePush(ctxt, arg1); 12763 xmlXPathReleaseObject(ctxt->context, arg2); 12764 /* optimizer */ 12765 if (total > cur) 12766 xmlXPathCompSwap(op); 12767 return (total + cur); 12768 case XPATH_OP_ROOT: 12769 xmlXPathRoot(ctxt); 12770 return (0); 12771 case XPATH_OP_NODE: 12772 if (op->ch1 != -1) 12773 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]); 12774 CHECK_ERROR0; 12775 if (op->ch2 != -1) 12776 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]); 12777 CHECK_ERROR0; 12778 valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context, 12779 ctxt->context->node)); 12780 return (total); 12781 case XPATH_OP_RESET: 12782 if (op->ch1 != -1) 12783 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]); 12784 CHECK_ERROR0; 12785 if (op->ch2 != -1) 12786 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]); 12787 CHECK_ERROR0; 12788 ctxt->context->node = NULL; 12789 return (total); 12790 case XPATH_OP_COLLECT:{ 12791 if (op->ch1 == -1) 12792 return (total); 12793 12794 total = xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]); 12795 CHECK_ERROR0; 12796 12797 total += xmlXPathNodeCollectAndTest(ctxt, op, first, NULL, 0); 12798 return (total); 12799 } 12800 case XPATH_OP_VALUE: 12801 valuePush(ctxt, 12802 xmlXPathCacheObjectCopy(ctxt->context, 12803 (xmlXPathObjectPtr) op->value4)); 12804 return (0); 12805 case XPATH_OP_SORT: 12806 if (op->ch1 != -1) 12807 total += 12808 xmlXPathCompOpEvalFirst(ctxt, &comp->steps[op->ch1], 12809 first); 12810 CHECK_ERROR0; 12811 if ((ctxt->value != NULL) 12812 && (ctxt->value->type == XPATH_NODESET) 12813 && (ctxt->value->nodesetval != NULL) 12814 && (ctxt->value->nodesetval->nodeNr > 1)) 12815 xmlXPathNodeSetSort(ctxt->value->nodesetval); 12816 return (total); 12817 #ifdef XP_OPTIMIZED_FILTER_FIRST 12818 case XPATH_OP_FILTER: 12819 total += xmlXPathCompOpEvalFilterFirst(ctxt, op, first); 12820 return (total); 12821 #endif 12822 default: 12823 return (xmlXPathCompOpEval(ctxt, op)); 12824 } 12825 } 12826 12827 /** 12828 * xmlXPathCompOpEvalLast: 12829 * @ctxt: the XPath parser context with the compiled expression 12830 * @op: an XPath compiled operation 12831 * @last: the last elem found so far 12832 * 12833 * Evaluate the Precompiled XPath operation searching only the last 12834 * element in document order 12835 * 12836 * Returns the number of nodes traversed 12837 */ 12838 static int 12839 xmlXPathCompOpEvalLast(xmlXPathParserContextPtr ctxt, xmlXPathStepOpPtr op, 12840 xmlNodePtr * last) 12841 { 12842 int total = 0, cur; 12843 xmlXPathCompExprPtr comp; 12844 xmlXPathObjectPtr arg1, arg2; 12845 xmlNodePtr bak; 12846 xmlDocPtr bakd; 12847 int pp; 12848 int cs; 12849 12850 CHECK_ERROR0; 12851 comp = ctxt->comp; 12852 switch (op->op) { 12853 case XPATH_OP_END: 12854 return (0); 12855 case XPATH_OP_UNION: 12856 bakd = ctxt->context->doc; 12857 bak = ctxt->context->node; 12858 pp = ctxt->context->proximityPosition; 12859 cs = ctxt->context->contextSize; 12860 total = 12861 xmlXPathCompOpEvalLast(ctxt, &comp->steps[op->ch1], last); 12862 CHECK_ERROR0; 12863 if ((ctxt->value != NULL) 12864 && (ctxt->value->type == XPATH_NODESET) 12865 && (ctxt->value->nodesetval != NULL) 12866 && (ctxt->value->nodesetval->nodeNr >= 1)) { 12867 /* 12868 * limit tree traversing to first node in the result 12869 */ 12870 if (ctxt->value->nodesetval->nodeNr > 1) 12871 xmlXPathNodeSetSort(ctxt->value->nodesetval); 12872 *last = 12873 ctxt->value->nodesetval->nodeTab[ctxt->value-> 12874 nodesetval->nodeNr - 12875 1]; 12876 } 12877 ctxt->context->doc = bakd; 12878 ctxt->context->node = bak; 12879 ctxt->context->proximityPosition = pp; 12880 ctxt->context->contextSize = cs; 12881 cur = 12882 xmlXPathCompOpEvalLast(ctxt, &comp->steps[op->ch2], last); 12883 CHECK_ERROR0; 12884 if ((ctxt->value != NULL) 12885 && (ctxt->value->type == XPATH_NODESET) 12886 && (ctxt->value->nodesetval != NULL) 12887 && (ctxt->value->nodesetval->nodeNr >= 1)) { /* TODO: NOP ? */ 12888 } 12889 12890 arg2 = valuePop(ctxt); 12891 arg1 = valuePop(ctxt); 12892 if ((arg1 == NULL) || (arg1->type != XPATH_NODESET) || 12893 (arg2 == NULL) || (arg2->type != XPATH_NODESET)) { 12894 xmlXPathReleaseObject(ctxt->context, arg1); 12895 xmlXPathReleaseObject(ctxt->context, arg2); 12896 XP_ERROR0(XPATH_INVALID_TYPE); 12897 } 12898 12899 arg1->nodesetval = xmlXPathNodeSetMerge(arg1->nodesetval, 12900 arg2->nodesetval); 12901 valuePush(ctxt, arg1); 12902 xmlXPathReleaseObject(ctxt->context, arg2); 12903 /* optimizer */ 12904 if (total > cur) 12905 xmlXPathCompSwap(op); 12906 return (total + cur); 12907 case XPATH_OP_ROOT: 12908 xmlXPathRoot(ctxt); 12909 return (0); 12910 case XPATH_OP_NODE: 12911 if (op->ch1 != -1) 12912 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]); 12913 CHECK_ERROR0; 12914 if (op->ch2 != -1) 12915 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]); 12916 CHECK_ERROR0; 12917 valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context, 12918 ctxt->context->node)); 12919 return (total); 12920 case XPATH_OP_RESET: 12921 if (op->ch1 != -1) 12922 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]); 12923 CHECK_ERROR0; 12924 if (op->ch2 != -1) 12925 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]); 12926 CHECK_ERROR0; 12927 ctxt->context->node = NULL; 12928 return (total); 12929 case XPATH_OP_COLLECT:{ 12930 if (op->ch1 == -1) 12931 return (0); 12932 12933 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]); 12934 CHECK_ERROR0; 12935 12936 total += xmlXPathNodeCollectAndTest(ctxt, op, NULL, last, 0); 12937 return (total); 12938 } 12939 case XPATH_OP_VALUE: 12940 valuePush(ctxt, 12941 xmlXPathCacheObjectCopy(ctxt->context, 12942 (xmlXPathObjectPtr) op->value4)); 12943 return (0); 12944 case XPATH_OP_SORT: 12945 if (op->ch1 != -1) 12946 total += 12947 xmlXPathCompOpEvalLast(ctxt, &comp->steps[op->ch1], 12948 last); 12949 CHECK_ERROR0; 12950 if ((ctxt->value != NULL) 12951 && (ctxt->value->type == XPATH_NODESET) 12952 && (ctxt->value->nodesetval != NULL) 12953 && (ctxt->value->nodesetval->nodeNr > 1)) 12954 xmlXPathNodeSetSort(ctxt->value->nodesetval); 12955 return (total); 12956 default: 12957 return (xmlXPathCompOpEval(ctxt, op)); 12958 } 12959 } 12960 12961 #ifdef XP_OPTIMIZED_FILTER_FIRST 12962 static int 12963 xmlXPathCompOpEvalFilterFirst(xmlXPathParserContextPtr ctxt, 12964 xmlXPathStepOpPtr op, xmlNodePtr * first) 12965 { 12966 int total = 0; 12967 xmlXPathCompExprPtr comp; 12968 xmlXPathObjectPtr res; 12969 xmlXPathObjectPtr obj; 12970 xmlNodeSetPtr oldset; 12971 xmlNodePtr oldnode; 12972 xmlDocPtr oldDoc; 12973 int i; 12974 12975 CHECK_ERROR0; 12976 comp = ctxt->comp; 12977 /* 12978 * Optimization for ()[last()] selection i.e. the last elem 12979 */ 12980 if ((op->ch1 != -1) && (op->ch2 != -1) && 12981 (comp->steps[op->ch1].op == XPATH_OP_SORT) && 12982 (comp->steps[op->ch2].op == XPATH_OP_SORT)) { 12983 int f = comp->steps[op->ch2].ch1; 12984 12985 if ((f != -1) && 12986 (comp->steps[f].op == XPATH_OP_FUNCTION) && 12987 (comp->steps[f].value5 == NULL) && 12988 (comp->steps[f].value == 0) && 12989 (comp->steps[f].value4 != NULL) && 12990 (xmlStrEqual 12991 (comp->steps[f].value4, BAD_CAST "last"))) { 12992 xmlNodePtr last = NULL; 12993 12994 total += 12995 xmlXPathCompOpEvalLast(ctxt, 12996 &comp->steps[op->ch1], 12997 &last); 12998 CHECK_ERROR0; 12999 /* 13000 * The nodeset should be in document order, 13001 * Keep only the last value 13002 */ 13003 if ((ctxt->value != NULL) && 13004 (ctxt->value->type == XPATH_NODESET) && 13005 (ctxt->value->nodesetval != NULL) && 13006 (ctxt->value->nodesetval->nodeTab != NULL) && 13007 (ctxt->value->nodesetval->nodeNr > 1)) { 13008 xmlXPathNodeSetKeepLast(ctxt->value->nodesetval); 13009 *first = *(ctxt->value->nodesetval->nodeTab); 13010 } 13011 return (total); 13012 } 13013 } 13014 13015 if (op->ch1 != -1) 13016 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]); 13017 CHECK_ERROR0; 13018 if (op->ch2 == -1) 13019 return (total); 13020 if (ctxt->value == NULL) 13021 return (total); 13022 13023 #ifdef LIBXML_XPTR_ENABLED 13024 oldnode = ctxt->context->node; 13025 /* 13026 * Hum are we filtering the result of an XPointer expression 13027 */ 13028 if (ctxt->value->type == XPATH_LOCATIONSET) { 13029 xmlXPathObjectPtr tmp = NULL; 13030 xmlLocationSetPtr newlocset = NULL; 13031 xmlLocationSetPtr oldlocset; 13032 13033 /* 13034 * Extract the old locset, and then evaluate the result of the 13035 * expression for all the element in the locset. use it to grow 13036 * up a new locset. 13037 */ 13038 CHECK_TYPE0(XPATH_LOCATIONSET); 13039 obj = valuePop(ctxt); 13040 oldlocset = obj->user; 13041 ctxt->context->node = NULL; 13042 13043 if ((oldlocset == NULL) || (oldlocset->locNr == 0)) { 13044 ctxt->context->contextSize = 0; 13045 ctxt->context->proximityPosition = 0; 13046 if (op->ch2 != -1) 13047 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]); 13048 res = valuePop(ctxt); 13049 if (res != NULL) { 13050 xmlXPathReleaseObject(ctxt->context, res); 13051 } 13052 valuePush(ctxt, obj); 13053 CHECK_ERROR0; 13054 return (total); 13055 } 13056 newlocset = xmlXPtrLocationSetCreate(NULL); 13057 13058 for (i = 0; i < oldlocset->locNr; i++) { 13059 /* 13060 * Run the evaluation with a node list made of a 13061 * single item in the nodelocset. 13062 */ 13063 ctxt->context->node = oldlocset->locTab[i]->user; 13064 ctxt->context->contextSize = oldlocset->locNr; 13065 ctxt->context->proximityPosition = i + 1; 13066 if (tmp == NULL) { 13067 tmp = xmlXPathCacheNewNodeSet(ctxt->context, 13068 ctxt->context->node); 13069 } else { 13070 if (xmlXPathNodeSetAddUnique(tmp->nodesetval, 13071 ctxt->context->node) < 0) { 13072 ctxt->error = XPATH_MEMORY_ERROR; 13073 } 13074 } 13075 valuePush(ctxt, tmp); 13076 if (op->ch2 != -1) 13077 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]); 13078 if (ctxt->error != XPATH_EXPRESSION_OK) { 13079 xmlXPathFreeObject(obj); 13080 return(0); 13081 } 13082 /* 13083 * The result of the evaluation need to be tested to 13084 * decided whether the filter succeeded or not 13085 */ 13086 res = valuePop(ctxt); 13087 if (xmlXPathEvaluatePredicateResult(ctxt, res)) { 13088 xmlXPtrLocationSetAdd(newlocset, 13089 xmlXPathCacheObjectCopy(ctxt->context, 13090 oldlocset->locTab[i])); 13091 } 13092 /* 13093 * Cleanup 13094 */ 13095 if (res != NULL) { 13096 xmlXPathReleaseObject(ctxt->context, res); 13097 } 13098 if (ctxt->value == tmp) { 13099 valuePop(ctxt); 13100 xmlXPathNodeSetClear(tmp->nodesetval, 1); 13101 /* 13102 * REVISIT TODO: Don't create a temporary nodeset 13103 * for everly iteration. 13104 */ 13105 /* OLD: xmlXPathFreeObject(res); */ 13106 } else 13107 tmp = NULL; 13108 ctxt->context->node = NULL; 13109 /* 13110 * Only put the first node in the result, then leave. 13111 */ 13112 if (newlocset->locNr > 0) { 13113 *first = (xmlNodePtr) oldlocset->locTab[i]->user; 13114 break; 13115 } 13116 } 13117 if (tmp != NULL) { 13118 xmlXPathReleaseObject(ctxt->context, tmp); 13119 } 13120 /* 13121 * The result is used as the new evaluation locset. 13122 */ 13123 xmlXPathReleaseObject(ctxt->context, obj); 13124 ctxt->context->node = NULL; 13125 ctxt->context->contextSize = -1; 13126 ctxt->context->proximityPosition = -1; 13127 valuePush(ctxt, xmlXPtrWrapLocationSet(newlocset)); 13128 ctxt->context->node = oldnode; 13129 return (total); 13130 } 13131 #endif /* LIBXML_XPTR_ENABLED */ 13132 13133 /* 13134 * Extract the old set, and then evaluate the result of the 13135 * expression for all the element in the set. use it to grow 13136 * up a new set. 13137 */ 13138 CHECK_TYPE0(XPATH_NODESET); 13139 obj = valuePop(ctxt); 13140 oldset = obj->nodesetval; 13141 13142 oldnode = ctxt->context->node; 13143 oldDoc = ctxt->context->doc; 13144 ctxt->context->node = NULL; 13145 13146 if ((oldset == NULL) || (oldset->nodeNr == 0)) { 13147 ctxt->context->contextSize = 0; 13148 ctxt->context->proximityPosition = 0; 13149 /* QUESTION TODO: Why was this code commented out? 13150 if (op->ch2 != -1) 13151 total += 13152 xmlXPathCompOpEval(ctxt, 13153 &comp->steps[op->ch2]); 13154 CHECK_ERROR0; 13155 res = valuePop(ctxt); 13156 if (res != NULL) 13157 xmlXPathFreeObject(res); 13158 */ 13159 valuePush(ctxt, obj); 13160 ctxt->context->node = oldnode; 13161 CHECK_ERROR0; 13162 } else { 13163 xmlNodeSetPtr newset; 13164 xmlXPathObjectPtr tmp = NULL; 13165 /* 13166 * Initialize the new set. 13167 * Also set the xpath document in case things like 13168 * key() evaluation are attempted on the predicate 13169 */ 13170 newset = xmlXPathNodeSetCreate(NULL); 13171 /* XXX what if xmlXPathNodeSetCreate returned NULL? */ 13172 13173 for (i = 0; i < oldset->nodeNr; i++) { 13174 /* 13175 * Run the evaluation with a node list made of 13176 * a single item in the nodeset. 13177 */ 13178 ctxt->context->node = oldset->nodeTab[i]; 13179 if ((oldset->nodeTab[i]->type != XML_NAMESPACE_DECL) && 13180 (oldset->nodeTab[i]->doc != NULL)) 13181 ctxt->context->doc = oldset->nodeTab[i]->doc; 13182 if (tmp == NULL) { 13183 tmp = xmlXPathCacheNewNodeSet(ctxt->context, 13184 ctxt->context->node); 13185 } else { 13186 if (xmlXPathNodeSetAddUnique(tmp->nodesetval, 13187 ctxt->context->node) < 0) { 13188 ctxt->error = XPATH_MEMORY_ERROR; 13189 } 13190 } 13191 valuePush(ctxt, tmp); 13192 ctxt->context->contextSize = oldset->nodeNr; 13193 ctxt->context->proximityPosition = i + 1; 13194 if (op->ch2 != -1) 13195 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]); 13196 if (ctxt->error != XPATH_EXPRESSION_OK) { 13197 xmlXPathFreeNodeSet(newset); 13198 xmlXPathFreeObject(obj); 13199 return(0); 13200 } 13201 /* 13202 * The result of the evaluation needs to be tested to 13203 * decide whether the filter succeeded or not 13204 */ 13205 res = valuePop(ctxt); 13206 if (xmlXPathEvaluatePredicateResult(ctxt, res)) { 13207 if (xmlXPathNodeSetAdd(newset, oldset->nodeTab[i]) < 0) 13208 ctxt->error = XPATH_MEMORY_ERROR; 13209 } 13210 /* 13211 * Cleanup 13212 */ 13213 if (res != NULL) { 13214 xmlXPathReleaseObject(ctxt->context, res); 13215 } 13216 if (ctxt->value == tmp) { 13217 valuePop(ctxt); 13218 /* 13219 * Don't free the temporary nodeset 13220 * in order to avoid massive recreation inside this 13221 * loop. 13222 */ 13223 xmlXPathNodeSetClear(tmp->nodesetval, 1); 13224 } else 13225 tmp = NULL; 13226 ctxt->context->node = NULL; 13227 /* 13228 * Only put the first node in the result, then leave. 13229 */ 13230 if (newset->nodeNr > 0) { 13231 *first = *(newset->nodeTab); 13232 break; 13233 } 13234 } 13235 if (tmp != NULL) { 13236 xmlXPathReleaseObject(ctxt->context, tmp); 13237 } 13238 /* 13239 * The result is used as the new evaluation set. 13240 */ 13241 xmlXPathReleaseObject(ctxt->context, obj); 13242 ctxt->context->node = NULL; 13243 ctxt->context->contextSize = -1; 13244 ctxt->context->proximityPosition = -1; 13245 /* may want to move this past the '}' later */ 13246 ctxt->context->doc = oldDoc; 13247 valuePush(ctxt, xmlXPathCacheWrapNodeSet(ctxt->context, newset)); 13248 } 13249 ctxt->context->node = oldnode; 13250 return(total); 13251 } 13252 #endif /* XP_OPTIMIZED_FILTER_FIRST */ 13253 13254 /** 13255 * xmlXPathCompOpEval: 13256 * @ctxt: the XPath parser context with the compiled expression 13257 * @op: an XPath compiled operation 13258 * 13259 * Evaluate the Precompiled XPath operation 13260 * Returns the number of nodes traversed 13261 */ 13262 static int 13263 xmlXPathCompOpEval(xmlXPathParserContextPtr ctxt, xmlXPathStepOpPtr op) 13264 { 13265 int total = 0; 13266 int equal, ret; 13267 xmlXPathCompExprPtr comp; 13268 xmlXPathObjectPtr arg1, arg2; 13269 xmlNodePtr bak; 13270 xmlDocPtr bakd; 13271 int pp; 13272 int cs; 13273 13274 CHECK_ERROR0; 13275 comp = ctxt->comp; 13276 switch (op->op) { 13277 case XPATH_OP_END: 13278 return (0); 13279 case XPATH_OP_AND: 13280 bakd = ctxt->context->doc; 13281 bak = ctxt->context->node; 13282 pp = ctxt->context->proximityPosition; 13283 cs = ctxt->context->contextSize; 13284 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]); 13285 CHECK_ERROR0; 13286 xmlXPathBooleanFunction(ctxt, 1); 13287 if ((ctxt->value == NULL) || (ctxt->value->boolval == 0)) 13288 return (total); 13289 arg2 = valuePop(ctxt); 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 if (ctxt->error) { 13296 xmlXPathFreeObject(arg2); 13297 return(0); 13298 } 13299 xmlXPathBooleanFunction(ctxt, 1); 13300 arg1 = valuePop(ctxt); 13301 arg1->boolval &= arg2->boolval; 13302 valuePush(ctxt, arg1); 13303 xmlXPathReleaseObject(ctxt->context, arg2); 13304 return (total); 13305 case XPATH_OP_OR: 13306 bakd = ctxt->context->doc; 13307 bak = ctxt->context->node; 13308 pp = ctxt->context->proximityPosition; 13309 cs = ctxt->context->contextSize; 13310 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]); 13311 CHECK_ERROR0; 13312 xmlXPathBooleanFunction(ctxt, 1); 13313 if ((ctxt->value == NULL) || (ctxt->value->boolval == 1)) 13314 return (total); 13315 arg2 = valuePop(ctxt); 13316 ctxt->context->doc = bakd; 13317 ctxt->context->node = bak; 13318 ctxt->context->proximityPosition = pp; 13319 ctxt->context->contextSize = cs; 13320 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]); 13321 if (ctxt->error) { 13322 xmlXPathFreeObject(arg2); 13323 return(0); 13324 } 13325 xmlXPathBooleanFunction(ctxt, 1); 13326 arg1 = valuePop(ctxt); 13327 arg1->boolval |= arg2->boolval; 13328 valuePush(ctxt, arg1); 13329 xmlXPathReleaseObject(ctxt->context, arg2); 13330 return (total); 13331 case XPATH_OP_EQUAL: 13332 bakd = ctxt->context->doc; 13333 bak = ctxt->context->node; 13334 pp = ctxt->context->proximityPosition; 13335 cs = ctxt->context->contextSize; 13336 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]); 13337 CHECK_ERROR0; 13338 ctxt->context->doc = bakd; 13339 ctxt->context->node = bak; 13340 ctxt->context->proximityPosition = pp; 13341 ctxt->context->contextSize = cs; 13342 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]); 13343 CHECK_ERROR0; 13344 if (op->value) 13345 equal = xmlXPathEqualValues(ctxt); 13346 else 13347 equal = xmlXPathNotEqualValues(ctxt); 13348 valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, equal)); 13349 return (total); 13350 case XPATH_OP_CMP: 13351 bakd = ctxt->context->doc; 13352 bak = ctxt->context->node; 13353 pp = ctxt->context->proximityPosition; 13354 cs = ctxt->context->contextSize; 13355 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]); 13356 CHECK_ERROR0; 13357 ctxt->context->doc = bakd; 13358 ctxt->context->node = bak; 13359 ctxt->context->proximityPosition = pp; 13360 ctxt->context->contextSize = cs; 13361 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]); 13362 CHECK_ERROR0; 13363 ret = xmlXPathCompareValues(ctxt, op->value, op->value2); 13364 valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, ret)); 13365 return (total); 13366 case XPATH_OP_PLUS: 13367 bakd = ctxt->context->doc; 13368 bak = ctxt->context->node; 13369 pp = ctxt->context->proximityPosition; 13370 cs = ctxt->context->contextSize; 13371 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]); 13372 CHECK_ERROR0; 13373 if (op->ch2 != -1) { 13374 ctxt->context->doc = bakd; 13375 ctxt->context->node = bak; 13376 ctxt->context->proximityPosition = pp; 13377 ctxt->context->contextSize = cs; 13378 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]); 13379 } 13380 CHECK_ERROR0; 13381 if (op->value == 0) 13382 xmlXPathSubValues(ctxt); 13383 else if (op->value == 1) 13384 xmlXPathAddValues(ctxt); 13385 else if (op->value == 2) 13386 xmlXPathValueFlipSign(ctxt); 13387 else if (op->value == 3) { 13388 CAST_TO_NUMBER; 13389 CHECK_TYPE0(XPATH_NUMBER); 13390 } 13391 return (total); 13392 case XPATH_OP_MULT: 13393 bakd = ctxt->context->doc; 13394 bak = ctxt->context->node; 13395 pp = ctxt->context->proximityPosition; 13396 cs = ctxt->context->contextSize; 13397 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]); 13398 CHECK_ERROR0; 13399 ctxt->context->doc = bakd; 13400 ctxt->context->node = bak; 13401 ctxt->context->proximityPosition = pp; 13402 ctxt->context->contextSize = cs; 13403 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]); 13404 CHECK_ERROR0; 13405 if (op->value == 0) 13406 xmlXPathMultValues(ctxt); 13407 else if (op->value == 1) 13408 xmlXPathDivValues(ctxt); 13409 else if (op->value == 2) 13410 xmlXPathModValues(ctxt); 13411 return (total); 13412 case XPATH_OP_UNION: 13413 bakd = ctxt->context->doc; 13414 bak = ctxt->context->node; 13415 pp = ctxt->context->proximityPosition; 13416 cs = ctxt->context->contextSize; 13417 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]); 13418 CHECK_ERROR0; 13419 ctxt->context->doc = bakd; 13420 ctxt->context->node = bak; 13421 ctxt->context->proximityPosition = pp; 13422 ctxt->context->contextSize = cs; 13423 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]); 13424 CHECK_ERROR0; 13425 13426 arg2 = valuePop(ctxt); 13427 arg1 = valuePop(ctxt); 13428 if ((arg1 == NULL) || (arg1->type != XPATH_NODESET) || 13429 (arg2 == NULL) || (arg2->type != XPATH_NODESET)) { 13430 xmlXPathReleaseObject(ctxt->context, arg1); 13431 xmlXPathReleaseObject(ctxt->context, arg2); 13432 XP_ERROR0(XPATH_INVALID_TYPE); 13433 } 13434 13435 if ((arg1->nodesetval == NULL) || 13436 ((arg2->nodesetval != NULL) && 13437 (arg2->nodesetval->nodeNr != 0))) 13438 { 13439 arg1->nodesetval = xmlXPathNodeSetMerge(arg1->nodesetval, 13440 arg2->nodesetval); 13441 } 13442 13443 valuePush(ctxt, arg1); 13444 xmlXPathReleaseObject(ctxt->context, arg2); 13445 return (total); 13446 case XPATH_OP_ROOT: 13447 xmlXPathRoot(ctxt); 13448 return (total); 13449 case XPATH_OP_NODE: 13450 if (op->ch1 != -1) 13451 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]); 13452 CHECK_ERROR0; 13453 if (op->ch2 != -1) 13454 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]); 13455 CHECK_ERROR0; 13456 valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context, 13457 ctxt->context->node)); 13458 return (total); 13459 case XPATH_OP_RESET: 13460 if (op->ch1 != -1) 13461 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]); 13462 CHECK_ERROR0; 13463 if (op->ch2 != -1) 13464 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]); 13465 CHECK_ERROR0; 13466 ctxt->context->node = NULL; 13467 return (total); 13468 case XPATH_OP_COLLECT:{ 13469 if (op->ch1 == -1) 13470 return (total); 13471 13472 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]); 13473 CHECK_ERROR0; 13474 13475 total += xmlXPathNodeCollectAndTest(ctxt, op, NULL, NULL, 0); 13476 return (total); 13477 } 13478 case XPATH_OP_VALUE: 13479 valuePush(ctxt, 13480 xmlXPathCacheObjectCopy(ctxt->context, 13481 (xmlXPathObjectPtr) op->value4)); 13482 return (total); 13483 case XPATH_OP_VARIABLE:{ 13484 xmlXPathObjectPtr val; 13485 13486 if (op->ch1 != -1) 13487 total += 13488 xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]); 13489 if (op->value5 == NULL) { 13490 val = xmlXPathVariableLookup(ctxt->context, op->value4); 13491 if (val == NULL) 13492 XP_ERROR0(XPATH_UNDEF_VARIABLE_ERROR); 13493 valuePush(ctxt, val); 13494 } else { 13495 const xmlChar *URI; 13496 13497 URI = xmlXPathNsLookup(ctxt->context, op->value5); 13498 if (URI == NULL) { 13499 xmlGenericError(xmlGenericErrorContext, 13500 "xmlXPathCompOpEval: variable %s bound to undefined prefix %s\n", 13501 (char *) op->value4, (char *)op->value5); 13502 ctxt->error = XPATH_UNDEF_PREFIX_ERROR; 13503 return (total); 13504 } 13505 val = xmlXPathVariableLookupNS(ctxt->context, 13506 op->value4, URI); 13507 if (val == NULL) 13508 XP_ERROR0(XPATH_UNDEF_VARIABLE_ERROR); 13509 valuePush(ctxt, val); 13510 } 13511 return (total); 13512 } 13513 case XPATH_OP_FUNCTION:{ 13514 xmlXPathFunction func; 13515 const xmlChar *oldFunc, *oldFuncURI; 13516 int i; 13517 int frame; 13518 13519 frame = xmlXPathSetFrame(ctxt); 13520 if (op->ch1 != -1) { 13521 total += 13522 xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]); 13523 if (ctxt->error != XPATH_EXPRESSION_OK) { 13524 xmlXPathPopFrame(ctxt, frame); 13525 return (total); 13526 } 13527 } 13528 if (ctxt->valueNr < ctxt->valueFrame + op->value) { 13529 xmlGenericError(xmlGenericErrorContext, 13530 "xmlXPathCompOpEval: parameter error\n"); 13531 ctxt->error = XPATH_INVALID_OPERAND; 13532 xmlXPathPopFrame(ctxt, frame); 13533 return (total); 13534 } 13535 for (i = 0; i < op->value; i++) { 13536 if (ctxt->valueTab[(ctxt->valueNr - 1) - i] == NULL) { 13537 xmlGenericError(xmlGenericErrorContext, 13538 "xmlXPathCompOpEval: parameter error\n"); 13539 ctxt->error = XPATH_INVALID_OPERAND; 13540 xmlXPathPopFrame(ctxt, frame); 13541 return (total); 13542 } 13543 } 13544 if (op->cache != NULL) 13545 func = op->cache; 13546 else { 13547 const xmlChar *URI = NULL; 13548 13549 if (op->value5 == NULL) 13550 func = 13551 xmlXPathFunctionLookup(ctxt->context, 13552 op->value4); 13553 else { 13554 URI = xmlXPathNsLookup(ctxt->context, op->value5); 13555 if (URI == NULL) { 13556 xmlGenericError(xmlGenericErrorContext, 13557 "xmlXPathCompOpEval: function %s bound to undefined prefix %s\n", 13558 (char *)op->value4, (char *)op->value5); 13559 xmlXPathPopFrame(ctxt, frame); 13560 ctxt->error = XPATH_UNDEF_PREFIX_ERROR; 13561 return (total); 13562 } 13563 func = xmlXPathFunctionLookupNS(ctxt->context, 13564 op->value4, URI); 13565 } 13566 if (func == NULL) { 13567 xmlGenericError(xmlGenericErrorContext, 13568 "xmlXPathCompOpEval: function %s not found\n", 13569 (char *)op->value4); 13570 XP_ERROR0(XPATH_UNKNOWN_FUNC_ERROR); 13571 } 13572 op->cache = func; 13573 op->cacheURI = (void *) URI; 13574 } 13575 oldFunc = ctxt->context->function; 13576 oldFuncURI = ctxt->context->functionURI; 13577 ctxt->context->function = op->value4; 13578 ctxt->context->functionURI = op->cacheURI; 13579 func(ctxt, op->value); 13580 ctxt->context->function = oldFunc; 13581 ctxt->context->functionURI = oldFuncURI; 13582 xmlXPathPopFrame(ctxt, frame); 13583 return (total); 13584 } 13585 case XPATH_OP_ARG: 13586 bakd = ctxt->context->doc; 13587 bak = ctxt->context->node; 13588 pp = ctxt->context->proximityPosition; 13589 cs = ctxt->context->contextSize; 13590 if (op->ch1 != -1) { 13591 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]); 13592 ctxt->context->contextSize = cs; 13593 ctxt->context->proximityPosition = pp; 13594 ctxt->context->node = bak; 13595 ctxt->context->doc = bakd; 13596 CHECK_ERROR0; 13597 } 13598 if (op->ch2 != -1) { 13599 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]); 13600 ctxt->context->contextSize = cs; 13601 ctxt->context->proximityPosition = pp; 13602 ctxt->context->node = bak; 13603 ctxt->context->doc = bakd; 13604 CHECK_ERROR0; 13605 } 13606 return (total); 13607 case XPATH_OP_PREDICATE: 13608 case XPATH_OP_FILTER:{ 13609 xmlXPathObjectPtr res; 13610 xmlXPathObjectPtr obj, tmp; 13611 xmlNodeSetPtr newset = NULL; 13612 xmlNodeSetPtr oldset; 13613 xmlNodePtr oldnode; 13614 xmlDocPtr oldDoc; 13615 int i; 13616 13617 /* 13618 * Optimization for ()[1] selection i.e. the first elem 13619 */ 13620 if ((op->ch1 != -1) && (op->ch2 != -1) && 13621 #ifdef XP_OPTIMIZED_FILTER_FIRST 13622 /* 13623 * FILTER TODO: Can we assume that the inner processing 13624 * will result in an ordered list if we have an 13625 * XPATH_OP_FILTER? 13626 * What about an additional field or flag on 13627 * xmlXPathObject like @sorted ? This way we wouln'd need 13628 * to assume anything, so it would be more robust and 13629 * easier to optimize. 13630 */ 13631 ((comp->steps[op->ch1].op == XPATH_OP_SORT) || /* 18 */ 13632 (comp->steps[op->ch1].op == XPATH_OP_FILTER)) && /* 17 */ 13633 #else 13634 (comp->steps[op->ch1].op == XPATH_OP_SORT) && 13635 #endif 13636 (comp->steps[op->ch2].op == XPATH_OP_VALUE)) { /* 12 */ 13637 xmlXPathObjectPtr val; 13638 13639 val = comp->steps[op->ch2].value4; 13640 if ((val != NULL) && (val->type == XPATH_NUMBER) && 13641 (val->floatval == 1.0)) { 13642 xmlNodePtr first = NULL; 13643 13644 total += 13645 xmlXPathCompOpEvalFirst(ctxt, 13646 &comp->steps[op->ch1], 13647 &first); 13648 CHECK_ERROR0; 13649 /* 13650 * The nodeset should be in document order, 13651 * Keep only the first value 13652 */ 13653 if ((ctxt->value != NULL) && 13654 (ctxt->value->type == XPATH_NODESET) && 13655 (ctxt->value->nodesetval != NULL) && 13656 (ctxt->value->nodesetval->nodeNr > 1)) 13657 xmlXPathNodeSetClearFromPos(ctxt->value->nodesetval, 13658 1, 1); 13659 return (total); 13660 } 13661 } 13662 /* 13663 * Optimization for ()[last()] selection i.e. the last elem 13664 */ 13665 if ((op->ch1 != -1) && (op->ch2 != -1) && 13666 (comp->steps[op->ch1].op == XPATH_OP_SORT) && 13667 (comp->steps[op->ch2].op == XPATH_OP_SORT)) { 13668 int f = comp->steps[op->ch2].ch1; 13669 13670 if ((f != -1) && 13671 (comp->steps[f].op == XPATH_OP_FUNCTION) && 13672 (comp->steps[f].value5 == NULL) && 13673 (comp->steps[f].value == 0) && 13674 (comp->steps[f].value4 != NULL) && 13675 (xmlStrEqual 13676 (comp->steps[f].value4, BAD_CAST "last"))) { 13677 xmlNodePtr last = NULL; 13678 13679 total += 13680 xmlXPathCompOpEvalLast(ctxt, 13681 &comp->steps[op->ch1], 13682 &last); 13683 CHECK_ERROR0; 13684 /* 13685 * The nodeset should be in document order, 13686 * Keep only the last value 13687 */ 13688 if ((ctxt->value != NULL) && 13689 (ctxt->value->type == XPATH_NODESET) && 13690 (ctxt->value->nodesetval != NULL) && 13691 (ctxt->value->nodesetval->nodeTab != NULL) && 13692 (ctxt->value->nodesetval->nodeNr > 1)) 13693 xmlXPathNodeSetKeepLast(ctxt->value->nodesetval); 13694 return (total); 13695 } 13696 } 13697 /* 13698 * Process inner predicates first. 13699 * Example "index[parent::book][1]": 13700 * ... 13701 * PREDICATE <-- we are here "[1]" 13702 * PREDICATE <-- process "[parent::book]" first 13703 * SORT 13704 * COLLECT 'parent' 'name' 'node' book 13705 * NODE 13706 * ELEM Object is a number : 1 13707 */ 13708 if (op->ch1 != -1) 13709 total += 13710 xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]); 13711 CHECK_ERROR0; 13712 if (op->ch2 == -1) 13713 return (total); 13714 if (ctxt->value == NULL) 13715 return (total); 13716 13717 oldnode = ctxt->context->node; 13718 13719 #ifdef LIBXML_XPTR_ENABLED 13720 /* 13721 * Hum are we filtering the result of an XPointer expression 13722 */ 13723 if (ctxt->value->type == XPATH_LOCATIONSET) { 13724 xmlLocationSetPtr newlocset = NULL; 13725 xmlLocationSetPtr oldlocset; 13726 13727 /* 13728 * Extract the old locset, and then evaluate the result of the 13729 * expression for all the element in the locset. use it to grow 13730 * up a new locset. 13731 */ 13732 CHECK_TYPE0(XPATH_LOCATIONSET); 13733 obj = valuePop(ctxt); 13734 oldlocset = obj->user; 13735 ctxt->context->node = NULL; 13736 13737 if ((oldlocset == NULL) || (oldlocset->locNr == 0)) { 13738 ctxt->context->contextSize = 0; 13739 ctxt->context->proximityPosition = 0; 13740 if (op->ch2 != -1) 13741 total += 13742 xmlXPathCompOpEval(ctxt, 13743 &comp->steps[op->ch2]); 13744 res = valuePop(ctxt); 13745 if (res != NULL) { 13746 xmlXPathReleaseObject(ctxt->context, res); 13747 } 13748 valuePush(ctxt, obj); 13749 CHECK_ERROR0; 13750 return (total); 13751 } 13752 newlocset = xmlXPtrLocationSetCreate(NULL); 13753 13754 for (i = 0; i < oldlocset->locNr; i++) { 13755 /* 13756 * Run the evaluation with a node list made of a 13757 * single item in the nodelocset. 13758 */ 13759 ctxt->context->node = oldlocset->locTab[i]->user; 13760 ctxt->context->contextSize = oldlocset->locNr; 13761 ctxt->context->proximityPosition = i + 1; 13762 tmp = xmlXPathCacheNewNodeSet(ctxt->context, 13763 ctxt->context->node); 13764 valuePush(ctxt, tmp); 13765 13766 if (op->ch2 != -1) 13767 total += 13768 xmlXPathCompOpEval(ctxt, 13769 &comp->steps[op->ch2]); 13770 if (ctxt->error != XPATH_EXPRESSION_OK) { 13771 xmlXPathFreeObject(obj); 13772 return(0); 13773 } 13774 13775 /* 13776 * The result of the evaluation need to be tested to 13777 * decided whether the filter succeeded or not 13778 */ 13779 res = valuePop(ctxt); 13780 if (xmlXPathEvaluatePredicateResult(ctxt, res)) { 13781 xmlXPtrLocationSetAdd(newlocset, 13782 xmlXPathObjectCopy 13783 (oldlocset->locTab[i])); 13784 } 13785 13786 /* 13787 * Cleanup 13788 */ 13789 if (res != NULL) { 13790 xmlXPathReleaseObject(ctxt->context, res); 13791 } 13792 if (ctxt->value == tmp) { 13793 res = valuePop(ctxt); 13794 xmlXPathReleaseObject(ctxt->context, res); 13795 } 13796 13797 ctxt->context->node = NULL; 13798 } 13799 13800 /* 13801 * The result is used as the new evaluation locset. 13802 */ 13803 xmlXPathReleaseObject(ctxt->context, obj); 13804 ctxt->context->node = NULL; 13805 ctxt->context->contextSize = -1; 13806 ctxt->context->proximityPosition = -1; 13807 valuePush(ctxt, xmlXPtrWrapLocationSet(newlocset)); 13808 ctxt->context->node = oldnode; 13809 return (total); 13810 } 13811 #endif /* LIBXML_XPTR_ENABLED */ 13812 13813 /* 13814 * Extract the old set, and then evaluate the result of the 13815 * expression for all the element in the set. use it to grow 13816 * up a new set. 13817 */ 13818 CHECK_TYPE0(XPATH_NODESET); 13819 obj = valuePop(ctxt); 13820 oldset = obj->nodesetval; 13821 13822 oldnode = ctxt->context->node; 13823 oldDoc = ctxt->context->doc; 13824 ctxt->context->node = NULL; 13825 13826 if ((oldset == NULL) || (oldset->nodeNr == 0)) { 13827 ctxt->context->contextSize = 0; 13828 ctxt->context->proximityPosition = 0; 13829 /* 13830 if (op->ch2 != -1) 13831 total += 13832 xmlXPathCompOpEval(ctxt, 13833 &comp->steps[op->ch2]); 13834 CHECK_ERROR0; 13835 res = valuePop(ctxt); 13836 if (res != NULL) 13837 xmlXPathFreeObject(res); 13838 */ 13839 valuePush(ctxt, obj); 13840 ctxt->context->node = oldnode; 13841 CHECK_ERROR0; 13842 } else { 13843 tmp = NULL; 13844 /* 13845 * Initialize the new set. 13846 * Also set the xpath document in case things like 13847 * key() evaluation are attempted on the predicate 13848 */ 13849 newset = xmlXPathNodeSetCreate(NULL); 13850 /* 13851 * SPEC XPath 1.0: 13852 * "For each node in the node-set to be filtered, the 13853 * PredicateExpr is evaluated with that node as the 13854 * context node, with the number of nodes in the 13855 * node-set as the context size, and with the proximity 13856 * position of the node in the node-set with respect to 13857 * the axis as the context position;" 13858 * @oldset is the node-set" to be filtered. 13859 * 13860 * SPEC XPath 1.0: 13861 * "only predicates change the context position and 13862 * context size (see [2.4 Predicates])." 13863 * Example: 13864 * node-set context pos 13865 * nA 1 13866 * nB 2 13867 * nC 3 13868 * After applying predicate [position() > 1] : 13869 * node-set context pos 13870 * nB 1 13871 * nC 2 13872 * 13873 * removed the first node in the node-set, then 13874 * the context position of the 13875 */ 13876 for (i = 0; i < oldset->nodeNr; i++) { 13877 /* 13878 * Run the evaluation with a node list made of 13879 * a single item in the nodeset. 13880 */ 13881 ctxt->context->node = oldset->nodeTab[i]; 13882 if ((oldset->nodeTab[i]->type != XML_NAMESPACE_DECL) && 13883 (oldset->nodeTab[i]->doc != NULL)) 13884 ctxt->context->doc = oldset->nodeTab[i]->doc; 13885 if (tmp == NULL) { 13886 tmp = xmlXPathCacheNewNodeSet(ctxt->context, 13887 ctxt->context->node); 13888 } else { 13889 if (xmlXPathNodeSetAddUnique(tmp->nodesetval, 13890 ctxt->context->node) < 0) { 13891 ctxt->error = XPATH_MEMORY_ERROR; 13892 } 13893 } 13894 valuePush(ctxt, tmp); 13895 ctxt->context->contextSize = oldset->nodeNr; 13896 ctxt->context->proximityPosition = i + 1; 13897 /* 13898 * Evaluate the predicate against the context node. 13899 * Can/should we optimize position() predicates 13900 * here (e.g. "[1]")? 13901 */ 13902 if (op->ch2 != -1) 13903 total += 13904 xmlXPathCompOpEval(ctxt, 13905 &comp->steps[op->ch2]); 13906 if (ctxt->error != XPATH_EXPRESSION_OK) { 13907 xmlXPathFreeNodeSet(newset); 13908 xmlXPathFreeObject(obj); 13909 return(0); 13910 } 13911 13912 /* 13913 * The result of the evaluation needs to be tested to 13914 * decide whether the filter succeeded or not 13915 */ 13916 /* 13917 * OPTIMIZE TODO: Can we use 13918 * xmlXPathNodeSetAdd*Unique()* instead? 13919 */ 13920 res = valuePop(ctxt); 13921 if (xmlXPathEvaluatePredicateResult(ctxt, res)) { 13922 if (xmlXPathNodeSetAdd(newset, oldset->nodeTab[i]) 13923 < 0) 13924 ctxt->error = XPATH_MEMORY_ERROR; 13925 } 13926 13927 /* 13928 * Cleanup 13929 */ 13930 if (res != NULL) { 13931 xmlXPathReleaseObject(ctxt->context, res); 13932 } 13933 if (ctxt->value == tmp) { 13934 valuePop(ctxt); 13935 xmlXPathNodeSetClear(tmp->nodesetval, 1); 13936 /* 13937 * Don't free the temporary nodeset 13938 * in order to avoid massive recreation inside this 13939 * loop. 13940 */ 13941 } else 13942 tmp = NULL; 13943 ctxt->context->node = NULL; 13944 } 13945 if (tmp != NULL) 13946 xmlXPathReleaseObject(ctxt->context, tmp); 13947 /* 13948 * The result is used as the new evaluation set. 13949 */ 13950 xmlXPathReleaseObject(ctxt->context, obj); 13951 ctxt->context->node = NULL; 13952 ctxt->context->contextSize = -1; 13953 ctxt->context->proximityPosition = -1; 13954 /* may want to move this past the '}' later */ 13955 ctxt->context->doc = oldDoc; 13956 valuePush(ctxt, 13957 xmlXPathCacheWrapNodeSet(ctxt->context, newset)); 13958 } 13959 ctxt->context->node = oldnode; 13960 return (total); 13961 } 13962 case XPATH_OP_SORT: 13963 if (op->ch1 != -1) 13964 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]); 13965 CHECK_ERROR0; 13966 if ((ctxt->value != NULL) && 13967 (ctxt->value->type == XPATH_NODESET) && 13968 (ctxt->value->nodesetval != NULL) && 13969 (ctxt->value->nodesetval->nodeNr > 1)) 13970 { 13971 xmlXPathNodeSetSort(ctxt->value->nodesetval); 13972 } 13973 return (total); 13974 #ifdef LIBXML_XPTR_ENABLED 13975 case XPATH_OP_RANGETO:{ 13976 xmlXPathObjectPtr range; 13977 xmlXPathObjectPtr res, obj; 13978 xmlXPathObjectPtr tmp; 13979 xmlLocationSetPtr newlocset = NULL; 13980 xmlLocationSetPtr oldlocset; 13981 xmlNodeSetPtr oldset; 13982 int i, j; 13983 13984 if (op->ch1 != -1) { 13985 total += 13986 xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]); 13987 CHECK_ERROR0; 13988 } 13989 if (ctxt->value == NULL) { 13990 XP_ERROR0(XPATH_INVALID_OPERAND); 13991 } 13992 if (op->ch2 == -1) 13993 return (total); 13994 13995 if (ctxt->value->type == XPATH_LOCATIONSET) { 13996 /* 13997 * Extract the old locset, and then evaluate the result of the 13998 * expression for all the element in the locset. use it to grow 13999 * up a new locset. 14000 */ 14001 CHECK_TYPE0(XPATH_LOCATIONSET); 14002 obj = valuePop(ctxt); 14003 oldlocset = obj->user; 14004 14005 if ((oldlocset == NULL) || (oldlocset->locNr == 0)) { 14006 ctxt->context->node = NULL; 14007 ctxt->context->contextSize = 0; 14008 ctxt->context->proximityPosition = 0; 14009 total += xmlXPathCompOpEval(ctxt,&comp->steps[op->ch2]); 14010 res = valuePop(ctxt); 14011 if (res != NULL) { 14012 xmlXPathReleaseObject(ctxt->context, res); 14013 } 14014 valuePush(ctxt, obj); 14015 CHECK_ERROR0; 14016 return (total); 14017 } 14018 newlocset = xmlXPtrLocationSetCreate(NULL); 14019 14020 for (i = 0; i < oldlocset->locNr; i++) { 14021 /* 14022 * Run the evaluation with a node list made of a 14023 * single item in the nodelocset. 14024 */ 14025 ctxt->context->node = oldlocset->locTab[i]->user; 14026 ctxt->context->contextSize = oldlocset->locNr; 14027 ctxt->context->proximityPosition = i + 1; 14028 tmp = xmlXPathCacheNewNodeSet(ctxt->context, 14029 ctxt->context->node); 14030 valuePush(ctxt, tmp); 14031 14032 if (op->ch2 != -1) 14033 total += 14034 xmlXPathCompOpEval(ctxt, 14035 &comp->steps[op->ch2]); 14036 if (ctxt->error != XPATH_EXPRESSION_OK) { 14037 xmlXPathFreeObject(obj); 14038 return(0); 14039 } 14040 14041 res = valuePop(ctxt); 14042 if (res->type == XPATH_LOCATIONSET) { 14043 xmlLocationSetPtr rloc = 14044 (xmlLocationSetPtr)res->user; 14045 for (j=0; j<rloc->locNr; j++) { 14046 range = xmlXPtrNewRange( 14047 oldlocset->locTab[i]->user, 14048 oldlocset->locTab[i]->index, 14049 rloc->locTab[j]->user2, 14050 rloc->locTab[j]->index2); 14051 if (range != NULL) { 14052 xmlXPtrLocationSetAdd(newlocset, range); 14053 } 14054 } 14055 } else { 14056 range = xmlXPtrNewRangeNodeObject( 14057 (xmlNodePtr)oldlocset->locTab[i]->user, res); 14058 if (range != NULL) { 14059 xmlXPtrLocationSetAdd(newlocset,range); 14060 } 14061 } 14062 14063 /* 14064 * Cleanup 14065 */ 14066 if (res != NULL) { 14067 xmlXPathReleaseObject(ctxt->context, res); 14068 } 14069 if (ctxt->value == tmp) { 14070 res = valuePop(ctxt); 14071 xmlXPathReleaseObject(ctxt->context, res); 14072 } 14073 14074 ctxt->context->node = NULL; 14075 } 14076 } else { /* Not a location set */ 14077 CHECK_TYPE0(XPATH_NODESET); 14078 obj = valuePop(ctxt); 14079 oldset = obj->nodesetval; 14080 ctxt->context->node = NULL; 14081 14082 newlocset = xmlXPtrLocationSetCreate(NULL); 14083 14084 if (oldset != NULL) { 14085 for (i = 0; i < oldset->nodeNr; i++) { 14086 /* 14087 * Run the evaluation with a node list made of a single item 14088 * in the nodeset. 14089 */ 14090 ctxt->context->node = oldset->nodeTab[i]; 14091 /* 14092 * OPTIMIZE TODO: Avoid recreation for every iteration. 14093 */ 14094 tmp = xmlXPathCacheNewNodeSet(ctxt->context, 14095 ctxt->context->node); 14096 valuePush(ctxt, tmp); 14097 14098 if (op->ch2 != -1) 14099 total += 14100 xmlXPathCompOpEval(ctxt, 14101 &comp->steps[op->ch2]); 14102 if (ctxt->error != XPATH_EXPRESSION_OK) { 14103 xmlXPathFreeObject(obj); 14104 return(0); 14105 } 14106 14107 res = valuePop(ctxt); 14108 range = 14109 xmlXPtrNewRangeNodeObject(oldset->nodeTab[i], 14110 res); 14111 if (range != NULL) { 14112 xmlXPtrLocationSetAdd(newlocset, range); 14113 } 14114 14115 /* 14116 * Cleanup 14117 */ 14118 if (res != NULL) { 14119 xmlXPathReleaseObject(ctxt->context, res); 14120 } 14121 if (ctxt->value == tmp) { 14122 res = valuePop(ctxt); 14123 xmlXPathReleaseObject(ctxt->context, res); 14124 } 14125 14126 ctxt->context->node = NULL; 14127 } 14128 } 14129 } 14130 14131 /* 14132 * The result is used as the new evaluation set. 14133 */ 14134 xmlXPathReleaseObject(ctxt->context, obj); 14135 ctxt->context->node = NULL; 14136 ctxt->context->contextSize = -1; 14137 ctxt->context->proximityPosition = -1; 14138 valuePush(ctxt, xmlXPtrWrapLocationSet(newlocset)); 14139 return (total); 14140 } 14141 #endif /* LIBXML_XPTR_ENABLED */ 14142 } 14143 xmlGenericError(xmlGenericErrorContext, 14144 "XPath: unknown precompiled operation %d\n", op->op); 14145 ctxt->error = XPATH_INVALID_OPERAND; 14146 return (total); 14147 } 14148 14149 /** 14150 * xmlXPathCompOpEvalToBoolean: 14151 * @ctxt: the XPath parser context 14152 * 14153 * Evaluates if the expression evaluates to true. 14154 * 14155 * Returns 1 if true, 0 if false and -1 on API or internal errors. 14156 */ 14157 static int 14158 xmlXPathCompOpEvalToBoolean(xmlXPathParserContextPtr ctxt, 14159 xmlXPathStepOpPtr op, 14160 int isPredicate) 14161 { 14162 xmlXPathObjectPtr resObj = NULL; 14163 14164 start: 14165 /* comp = ctxt->comp; */ 14166 switch (op->op) { 14167 case XPATH_OP_END: 14168 return (0); 14169 case XPATH_OP_VALUE: 14170 resObj = (xmlXPathObjectPtr) op->value4; 14171 if (isPredicate) 14172 return(xmlXPathEvaluatePredicateResult(ctxt, resObj)); 14173 return(xmlXPathCastToBoolean(resObj)); 14174 case XPATH_OP_SORT: 14175 /* 14176 * We don't need sorting for boolean results. Skip this one. 14177 */ 14178 if (op->ch1 != -1) { 14179 op = &ctxt->comp->steps[op->ch1]; 14180 goto start; 14181 } 14182 return(0); 14183 case XPATH_OP_COLLECT: 14184 if (op->ch1 == -1) 14185 return(0); 14186 14187 xmlXPathCompOpEval(ctxt, &ctxt->comp->steps[op->ch1]); 14188 if (ctxt->error != XPATH_EXPRESSION_OK) 14189 return(-1); 14190 14191 xmlXPathNodeCollectAndTest(ctxt, op, NULL, NULL, 1); 14192 if (ctxt->error != XPATH_EXPRESSION_OK) 14193 return(-1); 14194 14195 resObj = valuePop(ctxt); 14196 if (resObj == NULL) 14197 return(-1); 14198 break; 14199 default: 14200 /* 14201 * Fallback to call xmlXPathCompOpEval(). 14202 */ 14203 xmlXPathCompOpEval(ctxt, op); 14204 if (ctxt->error != XPATH_EXPRESSION_OK) 14205 return(-1); 14206 14207 resObj = valuePop(ctxt); 14208 if (resObj == NULL) 14209 return(-1); 14210 break; 14211 } 14212 14213 if (resObj) { 14214 int res; 14215 14216 if (resObj->type == XPATH_BOOLEAN) { 14217 res = resObj->boolval; 14218 } else if (isPredicate) { 14219 /* 14220 * For predicates a result of type "number" is handled 14221 * differently: 14222 * SPEC XPath 1.0: 14223 * "If the result is a number, the result will be converted 14224 * to true if the number is equal to the context position 14225 * and will be converted to false otherwise;" 14226 */ 14227 res = xmlXPathEvaluatePredicateResult(ctxt, resObj); 14228 } else { 14229 res = xmlXPathCastToBoolean(resObj); 14230 } 14231 xmlXPathReleaseObject(ctxt->context, resObj); 14232 return(res); 14233 } 14234 14235 return(0); 14236 } 14237 14238 #ifdef XPATH_STREAMING 14239 /** 14240 * xmlXPathRunStreamEval: 14241 * @ctxt: the XPath parser context with the compiled expression 14242 * 14243 * Evaluate the Precompiled Streamable XPath expression in the given context. 14244 */ 14245 static int 14246 xmlXPathRunStreamEval(xmlXPathContextPtr ctxt, xmlPatternPtr comp, 14247 xmlXPathObjectPtr *resultSeq, int toBool) 14248 { 14249 int max_depth, min_depth; 14250 int from_root; 14251 int ret, depth; 14252 int eval_all_nodes; 14253 xmlNodePtr cur = NULL, limit = NULL; 14254 xmlStreamCtxtPtr patstream = NULL; 14255 14256 int nb_nodes = 0; 14257 14258 if ((ctxt == NULL) || (comp == NULL)) 14259 return(-1); 14260 max_depth = xmlPatternMaxDepth(comp); 14261 if (max_depth == -1) 14262 return(-1); 14263 if (max_depth == -2) 14264 max_depth = 10000; 14265 min_depth = xmlPatternMinDepth(comp); 14266 if (min_depth == -1) 14267 return(-1); 14268 from_root = xmlPatternFromRoot(comp); 14269 if (from_root < 0) 14270 return(-1); 14271 #if 0 14272 printf("stream eval: depth %d from root %d\n", max_depth, from_root); 14273 #endif 14274 14275 if (! toBool) { 14276 if (resultSeq == NULL) 14277 return(-1); 14278 *resultSeq = xmlXPathCacheNewNodeSet(ctxt, NULL); 14279 if (*resultSeq == NULL) 14280 return(-1); 14281 } 14282 14283 /* 14284 * handle the special cases of "/" amd "." being matched 14285 */ 14286 if (min_depth == 0) { 14287 if (from_root) { 14288 /* Select "/" */ 14289 if (toBool) 14290 return(1); 14291 xmlXPathNodeSetAddUnique((*resultSeq)->nodesetval, 14292 (xmlNodePtr) ctxt->doc); 14293 } else { 14294 /* Select "self::node()" */ 14295 if (toBool) 14296 return(1); 14297 xmlXPathNodeSetAddUnique((*resultSeq)->nodesetval, ctxt->node); 14298 } 14299 } 14300 if (max_depth == 0) { 14301 return(0); 14302 } 14303 14304 if (from_root) { 14305 cur = (xmlNodePtr)ctxt->doc; 14306 } else if (ctxt->node != NULL) { 14307 switch (ctxt->node->type) { 14308 case XML_ELEMENT_NODE: 14309 case XML_DOCUMENT_NODE: 14310 case XML_DOCUMENT_FRAG_NODE: 14311 case XML_HTML_DOCUMENT_NODE: 14312 #ifdef LIBXML_DOCB_ENABLED 14313 case XML_DOCB_DOCUMENT_NODE: 14314 #endif 14315 cur = ctxt->node; 14316 break; 14317 case XML_ATTRIBUTE_NODE: 14318 case XML_TEXT_NODE: 14319 case XML_CDATA_SECTION_NODE: 14320 case XML_ENTITY_REF_NODE: 14321 case XML_ENTITY_NODE: 14322 case XML_PI_NODE: 14323 case XML_COMMENT_NODE: 14324 case XML_NOTATION_NODE: 14325 case XML_DTD_NODE: 14326 case XML_DOCUMENT_TYPE_NODE: 14327 case XML_ELEMENT_DECL: 14328 case XML_ATTRIBUTE_DECL: 14329 case XML_ENTITY_DECL: 14330 case XML_NAMESPACE_DECL: 14331 case XML_XINCLUDE_START: 14332 case XML_XINCLUDE_END: 14333 break; 14334 } 14335 limit = cur; 14336 } 14337 if (cur == NULL) { 14338 return(0); 14339 } 14340 14341 patstream = xmlPatternGetStreamCtxt(comp); 14342 if (patstream == NULL) { 14343 /* 14344 * QUESTION TODO: Is this an error? 14345 */ 14346 return(0); 14347 } 14348 14349 eval_all_nodes = xmlStreamWantsAnyNode(patstream); 14350 14351 if (from_root) { 14352 ret = xmlStreamPush(patstream, NULL, NULL); 14353 if (ret < 0) { 14354 } else if (ret == 1) { 14355 if (toBool) 14356 goto return_1; 14357 xmlXPathNodeSetAddUnique((*resultSeq)->nodesetval, cur); 14358 } 14359 } 14360 depth = 0; 14361 goto scan_children; 14362 next_node: 14363 do { 14364 nb_nodes++; 14365 14366 switch (cur->type) { 14367 case XML_ELEMENT_NODE: 14368 case XML_TEXT_NODE: 14369 case XML_CDATA_SECTION_NODE: 14370 case XML_COMMENT_NODE: 14371 case XML_PI_NODE: 14372 if (cur->type == XML_ELEMENT_NODE) { 14373 ret = xmlStreamPush(patstream, cur->name, 14374 (cur->ns ? cur->ns->href : NULL)); 14375 } else if (eval_all_nodes) 14376 ret = xmlStreamPushNode(patstream, NULL, NULL, cur->type); 14377 else 14378 break; 14379 14380 if (ret < 0) { 14381 /* NOP. */ 14382 } else if (ret == 1) { 14383 if (toBool) 14384 goto return_1; 14385 if (xmlXPathNodeSetAddUnique((*resultSeq)->nodesetval, cur) 14386 < 0) { 14387 ctxt->lastError.domain = XML_FROM_XPATH; 14388 ctxt->lastError.code = XML_ERR_NO_MEMORY; 14389 } 14390 } 14391 if ((cur->children == NULL) || (depth >= max_depth)) { 14392 ret = xmlStreamPop(patstream); 14393 while (cur->next != NULL) { 14394 cur = cur->next; 14395 if ((cur->type != XML_ENTITY_DECL) && 14396 (cur->type != XML_DTD_NODE)) 14397 goto next_node; 14398 } 14399 } 14400 default: 14401 break; 14402 } 14403 14404 scan_children: 14405 if (cur->type == XML_NAMESPACE_DECL) break; 14406 if ((cur->children != NULL) && (depth < max_depth)) { 14407 /* 14408 * Do not descend on entities declarations 14409 */ 14410 if (cur->children->type != XML_ENTITY_DECL) { 14411 cur = cur->children; 14412 depth++; 14413 /* 14414 * Skip DTDs 14415 */ 14416 if (cur->type != XML_DTD_NODE) 14417 continue; 14418 } 14419 } 14420 14421 if (cur == limit) 14422 break; 14423 14424 while (cur->next != NULL) { 14425 cur = cur->next; 14426 if ((cur->type != XML_ENTITY_DECL) && 14427 (cur->type != XML_DTD_NODE)) 14428 goto next_node; 14429 } 14430 14431 do { 14432 cur = cur->parent; 14433 depth--; 14434 if ((cur == NULL) || (cur == limit)) 14435 goto done; 14436 if (cur->type == XML_ELEMENT_NODE) { 14437 ret = xmlStreamPop(patstream); 14438 } else if ((eval_all_nodes) && 14439 ((cur->type == XML_TEXT_NODE) || 14440 (cur->type == XML_CDATA_SECTION_NODE) || 14441 (cur->type == XML_COMMENT_NODE) || 14442 (cur->type == XML_PI_NODE))) 14443 { 14444 ret = xmlStreamPop(patstream); 14445 } 14446 if (cur->next != NULL) { 14447 cur = cur->next; 14448 break; 14449 } 14450 } while (cur != NULL); 14451 14452 } while ((cur != NULL) && (depth >= 0)); 14453 14454 done: 14455 14456 #if 0 14457 printf("stream eval: checked %d nodes selected %d\n", 14458 nb_nodes, retObj->nodesetval->nodeNr); 14459 #endif 14460 14461 if (patstream) 14462 xmlFreeStreamCtxt(patstream); 14463 return(0); 14464 14465 return_1: 14466 if (patstream) 14467 xmlFreeStreamCtxt(patstream); 14468 return(1); 14469 } 14470 #endif /* XPATH_STREAMING */ 14471 14472 /** 14473 * xmlXPathRunEval: 14474 * @ctxt: the XPath parser context with the compiled expression 14475 * @toBool: evaluate to a boolean result 14476 * 14477 * Evaluate the Precompiled XPath expression in the given context. 14478 */ 14479 static int 14480 xmlXPathRunEval(xmlXPathParserContextPtr ctxt, int toBool) 14481 { 14482 xmlXPathCompExprPtr comp; 14483 14484 if ((ctxt == NULL) || (ctxt->comp == NULL)) 14485 return(-1); 14486 14487 if (ctxt->valueTab == NULL) { 14488 /* Allocate the value stack */ 14489 ctxt->valueTab = (xmlXPathObjectPtr *) 14490 xmlMalloc(10 * sizeof(xmlXPathObjectPtr)); 14491 if (ctxt->valueTab == NULL) { 14492 xmlXPathPErrMemory(ctxt, "creating evaluation context\n"); 14493 xmlFree(ctxt); 14494 } 14495 ctxt->valueNr = 0; 14496 ctxt->valueMax = 10; 14497 ctxt->value = NULL; 14498 ctxt->valueFrame = 0; 14499 } 14500 #ifdef XPATH_STREAMING 14501 if (ctxt->comp->stream) { 14502 int res; 14503 14504 if (toBool) { 14505 /* 14506 * Evaluation to boolean result. 14507 */ 14508 res = xmlXPathRunStreamEval(ctxt->context, 14509 ctxt->comp->stream, NULL, 1); 14510 if (res != -1) 14511 return(res); 14512 } else { 14513 xmlXPathObjectPtr resObj = NULL; 14514 14515 /* 14516 * Evaluation to a sequence. 14517 */ 14518 res = xmlXPathRunStreamEval(ctxt->context, 14519 ctxt->comp->stream, &resObj, 0); 14520 14521 if ((res != -1) && (resObj != NULL)) { 14522 valuePush(ctxt, resObj); 14523 return(0); 14524 } 14525 if (resObj != NULL) 14526 xmlXPathReleaseObject(ctxt->context, resObj); 14527 } 14528 /* 14529 * QUESTION TODO: This falls back to normal XPath evaluation 14530 * if res == -1. Is this intended? 14531 */ 14532 } 14533 #endif 14534 comp = ctxt->comp; 14535 if (comp->last < 0) { 14536 xmlGenericError(xmlGenericErrorContext, 14537 "xmlXPathRunEval: last is less than zero\n"); 14538 return(-1); 14539 } 14540 if (toBool) 14541 return(xmlXPathCompOpEvalToBoolean(ctxt, 14542 &comp->steps[comp->last], 0)); 14543 else 14544 xmlXPathCompOpEval(ctxt, &comp->steps[comp->last]); 14545 14546 return(0); 14547 } 14548 14549 /************************************************************************ 14550 * * 14551 * Public interfaces * 14552 * * 14553 ************************************************************************/ 14554 14555 /** 14556 * xmlXPathEvalPredicate: 14557 * @ctxt: the XPath context 14558 * @res: the Predicate Expression evaluation result 14559 * 14560 * Evaluate a predicate result for the current node. 14561 * A PredicateExpr is evaluated by evaluating the Expr and converting 14562 * the result to a boolean. If the result is a number, the result will 14563 * be converted to true if the number is equal to the position of the 14564 * context node in the context node list (as returned by the position 14565 * function) and will be converted to false otherwise; if the result 14566 * is not a number, then the result will be converted as if by a call 14567 * to the boolean function. 14568 * 14569 * Returns 1 if predicate is true, 0 otherwise 14570 */ 14571 int 14572 xmlXPathEvalPredicate(xmlXPathContextPtr ctxt, xmlXPathObjectPtr res) { 14573 if ((ctxt == NULL) || (res == NULL)) return(0); 14574 switch (res->type) { 14575 case XPATH_BOOLEAN: 14576 return(res->boolval); 14577 case XPATH_NUMBER: 14578 return(res->floatval == ctxt->proximityPosition); 14579 case XPATH_NODESET: 14580 case XPATH_XSLT_TREE: 14581 if (res->nodesetval == NULL) 14582 return(0); 14583 return(res->nodesetval->nodeNr != 0); 14584 case XPATH_STRING: 14585 return((res->stringval != NULL) && 14586 (xmlStrlen(res->stringval) != 0)); 14587 default: 14588 STRANGE 14589 } 14590 return(0); 14591 } 14592 14593 /** 14594 * xmlXPathEvaluatePredicateResult: 14595 * @ctxt: the XPath Parser context 14596 * @res: the Predicate Expression evaluation result 14597 * 14598 * Evaluate a predicate result for the current node. 14599 * A PredicateExpr is evaluated by evaluating the Expr and converting 14600 * the result to a boolean. If the result is a number, the result will 14601 * be converted to true if the number is equal to the position of the 14602 * context node in the context node list (as returned by the position 14603 * function) and will be converted to false otherwise; if the result 14604 * is not a number, then the result will be converted as if by a call 14605 * to the boolean function. 14606 * 14607 * Returns 1 if predicate is true, 0 otherwise 14608 */ 14609 int 14610 xmlXPathEvaluatePredicateResult(xmlXPathParserContextPtr ctxt, 14611 xmlXPathObjectPtr res) { 14612 if ((ctxt == NULL) || (res == NULL)) return(0); 14613 switch (res->type) { 14614 case XPATH_BOOLEAN: 14615 return(res->boolval); 14616 case XPATH_NUMBER: 14617 #if defined(__BORLANDC__) || (defined(_MSC_VER) && (_MSC_VER == 1200)) 14618 return((res->floatval == ctxt->context->proximityPosition) && 14619 (!xmlXPathIsNaN(res->floatval))); /* MSC pbm Mark Vakoc !*/ 14620 #else 14621 return(res->floatval == ctxt->context->proximityPosition); 14622 #endif 14623 case XPATH_NODESET: 14624 case XPATH_XSLT_TREE: 14625 if (res->nodesetval == NULL) 14626 return(0); 14627 return(res->nodesetval->nodeNr != 0); 14628 case XPATH_STRING: 14629 return((res->stringval != NULL) && (res->stringval[0] != 0)); 14630 #ifdef LIBXML_XPTR_ENABLED 14631 case XPATH_LOCATIONSET:{ 14632 xmlLocationSetPtr ptr = res->user; 14633 if (ptr == NULL) 14634 return(0); 14635 return (ptr->locNr != 0); 14636 } 14637 #endif 14638 default: 14639 STRANGE 14640 } 14641 return(0); 14642 } 14643 14644 #ifdef XPATH_STREAMING 14645 /** 14646 * xmlXPathTryStreamCompile: 14647 * @ctxt: an XPath context 14648 * @str: the XPath expression 14649 * 14650 * Try to compile the XPath expression as a streamable subset. 14651 * 14652 * Returns the compiled expression or NULL if failed to compile. 14653 */ 14654 static xmlXPathCompExprPtr 14655 xmlXPathTryStreamCompile(xmlXPathContextPtr ctxt, const xmlChar *str) { 14656 /* 14657 * Optimization: use streaming patterns when the XPath expression can 14658 * be compiled to a stream lookup 14659 */ 14660 xmlPatternPtr stream; 14661 xmlXPathCompExprPtr comp; 14662 xmlDictPtr dict = NULL; 14663 const xmlChar **namespaces = NULL; 14664 xmlNsPtr ns; 14665 int i, j; 14666 14667 if ((!xmlStrchr(str, '[')) && (!xmlStrchr(str, '(')) && 14668 (!xmlStrchr(str, '@'))) { 14669 const xmlChar *tmp; 14670 14671 /* 14672 * We don't try to handle expressions using the verbose axis 14673 * specifiers ("::"), just the simplied form at this point. 14674 * Additionally, if there is no list of namespaces available and 14675 * there's a ":" in the expression, indicating a prefixed QName, 14676 * then we won't try to compile either. xmlPatterncompile() needs 14677 * to have a list of namespaces at compilation time in order to 14678 * compile prefixed name tests. 14679 */ 14680 tmp = xmlStrchr(str, ':'); 14681 if ((tmp != NULL) && 14682 ((ctxt == NULL) || (ctxt->nsNr == 0) || (tmp[1] == ':'))) 14683 return(NULL); 14684 14685 if (ctxt != NULL) { 14686 dict = ctxt->dict; 14687 if (ctxt->nsNr > 0) { 14688 namespaces = xmlMalloc(2 * (ctxt->nsNr + 1) * sizeof(xmlChar*)); 14689 if (namespaces == NULL) { 14690 xmlXPathErrMemory(ctxt, "allocating namespaces array\n"); 14691 return(NULL); 14692 } 14693 for (i = 0, j = 0; (j < ctxt->nsNr); j++) { 14694 ns = ctxt->namespaces[j]; 14695 namespaces[i++] = ns->href; 14696 namespaces[i++] = ns->prefix; 14697 } 14698 namespaces[i++] = NULL; 14699 namespaces[i] = NULL; 14700 } 14701 } 14702 14703 stream = xmlPatterncompile(str, dict, XML_PATTERN_XPATH, 14704 &namespaces[0]); 14705 if (namespaces != NULL) { 14706 xmlFree((xmlChar **)namespaces); 14707 } 14708 if ((stream != NULL) && (xmlPatternStreamable(stream) == 1)) { 14709 comp = xmlXPathNewCompExpr(); 14710 if (comp == NULL) { 14711 xmlXPathErrMemory(ctxt, "allocating streamable expression\n"); 14712 return(NULL); 14713 } 14714 comp->stream = stream; 14715 comp->dict = dict; 14716 if (comp->dict) 14717 xmlDictReference(comp->dict); 14718 return(comp); 14719 } 14720 xmlFreePattern(stream); 14721 } 14722 return(NULL); 14723 } 14724 #endif /* XPATH_STREAMING */ 14725 14726 static void 14727 xmlXPathOptimizeExpression(xmlXPathCompExprPtr comp, xmlXPathStepOpPtr op) 14728 { 14729 /* 14730 * Try to rewrite "descendant-or-self::node()/foo" to an optimized 14731 * internal representation. 14732 */ 14733 14734 if ((op->op == XPATH_OP_COLLECT /* 11 */) && 14735 (op->ch1 != -1) && 14736 (op->ch2 == -1 /* no predicate */)) 14737 { 14738 xmlXPathStepOpPtr prevop = &comp->steps[op->ch1]; 14739 14740 if ((prevop->op == XPATH_OP_COLLECT /* 11 */) && 14741 ((xmlXPathAxisVal) prevop->value == 14742 AXIS_DESCENDANT_OR_SELF) && 14743 (prevop->ch2 == -1) && 14744 ((xmlXPathTestVal) prevop->value2 == NODE_TEST_TYPE) && 14745 ((xmlXPathTypeVal) prevop->value3 == NODE_TYPE_NODE)) 14746 { 14747 /* 14748 * This is a "descendant-or-self::node()" without predicates. 14749 * Try to eliminate it. 14750 */ 14751 14752 switch ((xmlXPathAxisVal) op->value) { 14753 case AXIS_CHILD: 14754 case AXIS_DESCENDANT: 14755 /* 14756 * Convert "descendant-or-self::node()/child::" or 14757 * "descendant-or-self::node()/descendant::" to 14758 * "descendant::" 14759 */ 14760 op->ch1 = prevop->ch1; 14761 op->value = AXIS_DESCENDANT; 14762 break; 14763 case AXIS_SELF: 14764 case AXIS_DESCENDANT_OR_SELF: 14765 /* 14766 * Convert "descendant-or-self::node()/self::" or 14767 * "descendant-or-self::node()/descendant-or-self::" to 14768 * to "descendant-or-self::" 14769 */ 14770 op->ch1 = prevop->ch1; 14771 op->value = AXIS_DESCENDANT_OR_SELF; 14772 break; 14773 default: 14774 break; 14775 } 14776 } 14777 } 14778 14779 /* OP_VALUE has invalid ch1. */ 14780 if (op->op == XPATH_OP_VALUE) 14781 return; 14782 14783 /* Recurse */ 14784 if (op->ch1 != -1) 14785 xmlXPathOptimizeExpression(comp, &comp->steps[op->ch1]); 14786 if (op->ch2 != -1) 14787 xmlXPathOptimizeExpression(comp, &comp->steps[op->ch2]); 14788 } 14789 14790 /** 14791 * xmlXPathCtxtCompile: 14792 * @ctxt: an XPath context 14793 * @str: the XPath expression 14794 * 14795 * Compile an XPath expression 14796 * 14797 * Returns the xmlXPathCompExprPtr resulting from the compilation or NULL. 14798 * the caller has to free the object. 14799 */ 14800 xmlXPathCompExprPtr 14801 xmlXPathCtxtCompile(xmlXPathContextPtr ctxt, const xmlChar *str) { 14802 xmlXPathParserContextPtr pctxt; 14803 xmlXPathCompExprPtr comp; 14804 14805 #ifdef XPATH_STREAMING 14806 comp = xmlXPathTryStreamCompile(ctxt, str); 14807 if (comp != NULL) 14808 return(comp); 14809 #endif 14810 14811 xmlXPathInit(); 14812 14813 pctxt = xmlXPathNewParserContext(str, ctxt); 14814 if (pctxt == NULL) 14815 return NULL; 14816 xmlXPathCompileExpr(pctxt, 1); 14817 14818 if( pctxt->error != XPATH_EXPRESSION_OK ) 14819 { 14820 xmlXPathFreeParserContext(pctxt); 14821 return(NULL); 14822 } 14823 14824 if (*pctxt->cur != 0) { 14825 /* 14826 * aleksey: in some cases this line prints *second* error message 14827 * (see bug #78858) and probably this should be fixed. 14828 * However, we are not sure that all error messages are printed 14829 * out in other places. It's not critical so we leave it as-is for now 14830 */ 14831 xmlXPatherror(pctxt, __FILE__, __LINE__, XPATH_EXPR_ERROR); 14832 comp = NULL; 14833 } else { 14834 comp = pctxt->comp; 14835 pctxt->comp = NULL; 14836 } 14837 xmlXPathFreeParserContext(pctxt); 14838 14839 if (comp != NULL) { 14840 comp->expr = xmlStrdup(str); 14841 #ifdef DEBUG_EVAL_COUNTS 14842 comp->string = xmlStrdup(str); 14843 comp->nb = 0; 14844 #endif 14845 if ((comp->nbStep > 1) && (comp->last >= 0)) { 14846 xmlXPathOptimizeExpression(comp, &comp->steps[comp->last]); 14847 } 14848 } 14849 return(comp); 14850 } 14851 14852 /** 14853 * xmlXPathCompile: 14854 * @str: the XPath expression 14855 * 14856 * Compile an XPath expression 14857 * 14858 * Returns the xmlXPathCompExprPtr resulting from the compilation or NULL. 14859 * the caller has to free the object. 14860 */ 14861 xmlXPathCompExprPtr 14862 xmlXPathCompile(const xmlChar *str) { 14863 return(xmlXPathCtxtCompile(NULL, str)); 14864 } 14865 14866 /** 14867 * xmlXPathCompiledEvalInternal: 14868 * @comp: the compiled XPath expression 14869 * @ctxt: the XPath context 14870 * @resObj: the resulting XPath object or NULL 14871 * @toBool: 1 if only a boolean result is requested 14872 * 14873 * Evaluate the Precompiled XPath expression in the given context. 14874 * The caller has to free @resObj. 14875 * 14876 * Returns the xmlXPathObjectPtr resulting from the evaluation or NULL. 14877 * the caller has to free the object. 14878 */ 14879 static int 14880 xmlXPathCompiledEvalInternal(xmlXPathCompExprPtr comp, 14881 xmlXPathContextPtr ctxt, 14882 xmlXPathObjectPtr *resObjPtr, 14883 int toBool) 14884 { 14885 xmlXPathParserContextPtr pctxt; 14886 xmlXPathObjectPtr resObj; 14887 #ifndef LIBXML_THREAD_ENABLED 14888 static int reentance = 0; 14889 #endif 14890 int res; 14891 14892 CHECK_CTXT_NEG(ctxt) 14893 14894 if (comp == NULL) 14895 return(-1); 14896 xmlXPathInit(); 14897 14898 #ifndef LIBXML_THREAD_ENABLED 14899 reentance++; 14900 if (reentance > 1) 14901 xmlXPathDisableOptimizer = 1; 14902 #endif 14903 14904 #ifdef DEBUG_EVAL_COUNTS 14905 comp->nb++; 14906 if ((comp->string != NULL) && (comp->nb > 100)) { 14907 fprintf(stderr, "100 x %s\n", comp->string); 14908 comp->nb = 0; 14909 } 14910 #endif 14911 pctxt = xmlXPathCompParserContext(comp, ctxt); 14912 res = xmlXPathRunEval(pctxt, toBool); 14913 14914 if (pctxt->error != XPATH_EXPRESSION_OK) { 14915 resObj = NULL; 14916 } else { 14917 resObj = valuePop(pctxt); 14918 if (resObj == NULL) { 14919 if (!toBool) 14920 xmlGenericError(xmlGenericErrorContext, 14921 "xmlXPathCompiledEval: No result on the stack.\n"); 14922 } else if (pctxt->valueNr > 0) { 14923 xmlGenericError(xmlGenericErrorContext, 14924 "xmlXPathCompiledEval: %d object(s) left on the stack.\n", 14925 pctxt->valueNr); 14926 } 14927 } 14928 14929 if (resObjPtr) 14930 *resObjPtr = resObj; 14931 else 14932 xmlXPathReleaseObject(ctxt, resObj); 14933 14934 pctxt->comp = NULL; 14935 xmlXPathFreeParserContext(pctxt); 14936 #ifndef LIBXML_THREAD_ENABLED 14937 reentance--; 14938 #endif 14939 14940 return(res); 14941 } 14942 14943 /** 14944 * xmlXPathCompiledEval: 14945 * @comp: the compiled XPath expression 14946 * @ctx: the XPath context 14947 * 14948 * Evaluate the Precompiled XPath expression in the given context. 14949 * 14950 * Returns the xmlXPathObjectPtr resulting from the evaluation or NULL. 14951 * the caller has to free the object. 14952 */ 14953 xmlXPathObjectPtr 14954 xmlXPathCompiledEval(xmlXPathCompExprPtr comp, xmlXPathContextPtr ctx) 14955 { 14956 xmlXPathObjectPtr res = NULL; 14957 14958 xmlXPathCompiledEvalInternal(comp, ctx, &res, 0); 14959 return(res); 14960 } 14961 14962 /** 14963 * xmlXPathCompiledEvalToBoolean: 14964 * @comp: the compiled XPath expression 14965 * @ctxt: the XPath context 14966 * 14967 * Applies the XPath boolean() function on the result of the given 14968 * compiled expression. 14969 * 14970 * Returns 1 if the expression evaluated to true, 0 if to false and 14971 * -1 in API and internal errors. 14972 */ 14973 int 14974 xmlXPathCompiledEvalToBoolean(xmlXPathCompExprPtr comp, 14975 xmlXPathContextPtr ctxt) 14976 { 14977 return(xmlXPathCompiledEvalInternal(comp, ctxt, NULL, 1)); 14978 } 14979 14980 /** 14981 * xmlXPathEvalExpr: 14982 * @ctxt: the XPath Parser context 14983 * 14984 * Parse and evaluate an XPath expression in the given context, 14985 * then push the result on the context stack 14986 */ 14987 void 14988 xmlXPathEvalExpr(xmlXPathParserContextPtr ctxt) { 14989 #ifdef XPATH_STREAMING 14990 xmlXPathCompExprPtr comp; 14991 #endif 14992 14993 if (ctxt == NULL) return; 14994 14995 #ifdef XPATH_STREAMING 14996 comp = xmlXPathTryStreamCompile(ctxt->context, ctxt->base); 14997 if (comp != NULL) { 14998 if (ctxt->comp != NULL) 14999 xmlXPathFreeCompExpr(ctxt->comp); 15000 ctxt->comp = comp; 15001 } else 15002 #endif 15003 { 15004 xmlXPathCompileExpr(ctxt, 1); 15005 CHECK_ERROR; 15006 15007 /* Check for trailing characters. */ 15008 if (*ctxt->cur != 0) 15009 XP_ERROR(XPATH_EXPR_ERROR); 15010 15011 if ((ctxt->comp->nbStep > 1) && (ctxt->comp->last >= 0)) 15012 xmlXPathOptimizeExpression(ctxt->comp, 15013 &ctxt->comp->steps[ctxt->comp->last]); 15014 } 15015 15016 xmlXPathRunEval(ctxt, 0); 15017 } 15018 15019 /** 15020 * xmlXPathEval: 15021 * @str: the XPath expression 15022 * @ctx: the XPath context 15023 * 15024 * Evaluate the XPath Location Path in the given context. 15025 * 15026 * Returns the xmlXPathObjectPtr resulting from the evaluation or NULL. 15027 * the caller has to free the object. 15028 */ 15029 xmlXPathObjectPtr 15030 xmlXPathEval(const xmlChar *str, xmlXPathContextPtr ctx) { 15031 xmlXPathParserContextPtr ctxt; 15032 xmlXPathObjectPtr res; 15033 15034 CHECK_CTXT(ctx) 15035 15036 xmlXPathInit(); 15037 15038 ctxt = xmlXPathNewParserContext(str, ctx); 15039 if (ctxt == NULL) 15040 return NULL; 15041 xmlXPathEvalExpr(ctxt); 15042 15043 if (ctxt->error != XPATH_EXPRESSION_OK) { 15044 res = NULL; 15045 } else { 15046 res = valuePop(ctxt); 15047 if (res == NULL) { 15048 xmlGenericError(xmlGenericErrorContext, 15049 "xmlXPathCompiledEval: No result on the stack.\n"); 15050 } else if (ctxt->valueNr > 0) { 15051 xmlGenericError(xmlGenericErrorContext, 15052 "xmlXPathCompiledEval: %d object(s) left on the stack.\n", 15053 ctxt->valueNr); 15054 } 15055 } 15056 15057 xmlXPathFreeParserContext(ctxt); 15058 return(res); 15059 } 15060 15061 /** 15062 * xmlXPathSetContextNode: 15063 * @node: the node to to use as the context node 15064 * @ctx: the XPath context 15065 * 15066 * Sets 'node' as the context node. The node must be in the same 15067 * document as that associated with the context. 15068 * 15069 * Returns -1 in case of error or 0 if successful 15070 */ 15071 int 15072 xmlXPathSetContextNode(xmlNodePtr node, xmlXPathContextPtr ctx) { 15073 if ((node == NULL) || (ctx == NULL)) 15074 return(-1); 15075 15076 if (node->doc == ctx->doc) { 15077 ctx->node = node; 15078 return(0); 15079 } 15080 return(-1); 15081 } 15082 15083 /** 15084 * xmlXPathNodeEval: 15085 * @node: the node to to use as the context node 15086 * @str: the XPath expression 15087 * @ctx: the XPath context 15088 * 15089 * Evaluate the XPath Location Path in the given context. The node 'node' 15090 * is set as the context node. The context node is not restored. 15091 * 15092 * Returns the xmlXPathObjectPtr resulting from the evaluation or NULL. 15093 * the caller has to free the object. 15094 */ 15095 xmlXPathObjectPtr 15096 xmlXPathNodeEval(xmlNodePtr node, const xmlChar *str, xmlXPathContextPtr ctx) { 15097 if (str == NULL) 15098 return(NULL); 15099 if (xmlXPathSetContextNode(node, ctx) < 0) 15100 return(NULL); 15101 return(xmlXPathEval(str, ctx)); 15102 } 15103 15104 /** 15105 * xmlXPathEvalExpression: 15106 * @str: the XPath expression 15107 * @ctxt: the XPath context 15108 * 15109 * Alias for xmlXPathEval(). 15110 * 15111 * Returns the xmlXPathObjectPtr resulting from the evaluation or NULL. 15112 * the caller has to free the object. 15113 */ 15114 xmlXPathObjectPtr 15115 xmlXPathEvalExpression(const xmlChar *str, xmlXPathContextPtr ctxt) { 15116 return(xmlXPathEval(str, ctxt)); 15117 } 15118 15119 /************************************************************************ 15120 * * 15121 * Extra functions not pertaining to the XPath spec * 15122 * * 15123 ************************************************************************/ 15124 /** 15125 * xmlXPathEscapeUriFunction: 15126 * @ctxt: the XPath Parser context 15127 * @nargs: the number of arguments 15128 * 15129 * Implement the escape-uri() XPath function 15130 * string escape-uri(string $str, bool $escape-reserved) 15131 * 15132 * This function applies the URI escaping rules defined in section 2 of [RFC 15133 * 2396] to the string supplied as $uri-part, which typically represents all 15134 * or part of a URI. The effect of the function is to replace any special 15135 * character in the string by an escape sequence of the form %xx%yy..., 15136 * where xxyy... is the hexadecimal representation of the octets used to 15137 * represent the character in UTF-8. 15138 * 15139 * The set of characters that are escaped depends on the setting of the 15140 * boolean argument $escape-reserved. 15141 * 15142 * If $escape-reserved is true, all characters are escaped other than lower 15143 * case letters a-z, upper case letters A-Z, digits 0-9, and the characters 15144 * referred to in [RFC 2396] as "marks": specifically, "-" | "_" | "." | "!" 15145 * | "~" | "*" | "'" | "(" | ")". The "%" character itself is escaped only 15146 * if it is not followed by two hexadecimal digits (that is, 0-9, a-f, and 15147 * A-F). 15148 * 15149 * If $escape-reserved is false, the behavior differs in that characters 15150 * referred to in [RFC 2396] as reserved characters are not escaped. These 15151 * characters are ";" | "/" | "?" | ":" | "@" | "&" | "=" | "+" | "$" | ",". 15152 * 15153 * [RFC 2396] does not define whether escaped URIs should use lower case or 15154 * upper case for hexadecimal digits. To ensure that escaped URIs can be 15155 * compared using string comparison functions, this function must always use 15156 * the upper-case letters A-F. 15157 * 15158 * Generally, $escape-reserved should be set to true when escaping a string 15159 * that is to form a single part of a URI, and to false when escaping an 15160 * entire URI or URI reference. 15161 * 15162 * In the case of non-ascii characters, the string is encoded according to 15163 * utf-8 and then converted according to RFC 2396. 15164 * 15165 * Examples 15166 * xf:escape-uri ("gopher://spinaltap.micro.umn.edu/00/Weather/California/Los%20Angeles#ocean"), true()) 15167 * returns "gopher%3A%2F%2Fspinaltap.micro.umn.edu%2F00%2FWeather%2FCalifornia%2FLos%20Angeles%23ocean" 15168 * xf:escape-uri ("gopher://spinaltap.micro.umn.edu/00/Weather/California/Los%20Angeles#ocean"), false()) 15169 * returns "gopher://spinaltap.micro.umn.edu/00/Weather/California/Los%20Angeles%23ocean" 15170 * 15171 */ 15172 static void 15173 xmlXPathEscapeUriFunction(xmlXPathParserContextPtr ctxt, int nargs) { 15174 xmlXPathObjectPtr str; 15175 int escape_reserved; 15176 xmlBufPtr target; 15177 xmlChar *cptr; 15178 xmlChar escape[4]; 15179 15180 CHECK_ARITY(2); 15181 15182 escape_reserved = xmlXPathPopBoolean(ctxt); 15183 15184 CAST_TO_STRING; 15185 str = valuePop(ctxt); 15186 15187 target = xmlBufCreate(); 15188 15189 escape[0] = '%'; 15190 escape[3] = 0; 15191 15192 if (target) { 15193 for (cptr = str->stringval; *cptr; cptr++) { 15194 if ((*cptr >= 'A' && *cptr <= 'Z') || 15195 (*cptr >= 'a' && *cptr <= 'z') || 15196 (*cptr >= '0' && *cptr <= '9') || 15197 *cptr == '-' || *cptr == '_' || *cptr == '.' || 15198 *cptr == '!' || *cptr == '~' || *cptr == '*' || 15199 *cptr == '\''|| *cptr == '(' || *cptr == ')' || 15200 (*cptr == '%' && 15201 ((cptr[1] >= 'A' && cptr[1] <= 'F') || 15202 (cptr[1] >= 'a' && cptr[1] <= 'f') || 15203 (cptr[1] >= '0' && cptr[1] <= '9')) && 15204 ((cptr[2] >= 'A' && cptr[2] <= 'F') || 15205 (cptr[2] >= 'a' && cptr[2] <= 'f') || 15206 (cptr[2] >= '0' && cptr[2] <= '9'))) || 15207 (!escape_reserved && 15208 (*cptr == ';' || *cptr == '/' || *cptr == '?' || 15209 *cptr == ':' || *cptr == '@' || *cptr == '&' || 15210 *cptr == '=' || *cptr == '+' || *cptr == '$' || 15211 *cptr == ','))) { 15212 xmlBufAdd(target, cptr, 1); 15213 } else { 15214 if ((*cptr >> 4) < 10) 15215 escape[1] = '0' + (*cptr >> 4); 15216 else 15217 escape[1] = 'A' - 10 + (*cptr >> 4); 15218 if ((*cptr & 0xF) < 10) 15219 escape[2] = '0' + (*cptr & 0xF); 15220 else 15221 escape[2] = 'A' - 10 + (*cptr & 0xF); 15222 15223 xmlBufAdd(target, &escape[0], 3); 15224 } 15225 } 15226 } 15227 valuePush(ctxt, xmlXPathCacheNewString(ctxt->context, 15228 xmlBufContent(target))); 15229 xmlBufFree(target); 15230 xmlXPathReleaseObject(ctxt->context, str); 15231 } 15232 15233 /** 15234 * xmlXPathRegisterAllFunctions: 15235 * @ctxt: the XPath context 15236 * 15237 * Registers all default XPath functions in this context 15238 */ 15239 void 15240 xmlXPathRegisterAllFunctions(xmlXPathContextPtr ctxt) 15241 { 15242 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"boolean", 15243 xmlXPathBooleanFunction); 15244 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"ceiling", 15245 xmlXPathCeilingFunction); 15246 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"count", 15247 xmlXPathCountFunction); 15248 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"concat", 15249 xmlXPathConcatFunction); 15250 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"contains", 15251 xmlXPathContainsFunction); 15252 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"id", 15253 xmlXPathIdFunction); 15254 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"false", 15255 xmlXPathFalseFunction); 15256 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"floor", 15257 xmlXPathFloorFunction); 15258 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"last", 15259 xmlXPathLastFunction); 15260 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"lang", 15261 xmlXPathLangFunction); 15262 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"local-name", 15263 xmlXPathLocalNameFunction); 15264 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"not", 15265 xmlXPathNotFunction); 15266 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"name", 15267 xmlXPathNameFunction); 15268 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"namespace-uri", 15269 xmlXPathNamespaceURIFunction); 15270 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"normalize-space", 15271 xmlXPathNormalizeFunction); 15272 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"number", 15273 xmlXPathNumberFunction); 15274 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"position", 15275 xmlXPathPositionFunction); 15276 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"round", 15277 xmlXPathRoundFunction); 15278 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"string", 15279 xmlXPathStringFunction); 15280 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"string-length", 15281 xmlXPathStringLengthFunction); 15282 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"starts-with", 15283 xmlXPathStartsWithFunction); 15284 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"substring", 15285 xmlXPathSubstringFunction); 15286 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"substring-before", 15287 xmlXPathSubstringBeforeFunction); 15288 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"substring-after", 15289 xmlXPathSubstringAfterFunction); 15290 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"sum", 15291 xmlXPathSumFunction); 15292 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"true", 15293 xmlXPathTrueFunction); 15294 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"translate", 15295 xmlXPathTranslateFunction); 15296 15297 xmlXPathRegisterFuncNS(ctxt, (const xmlChar *)"escape-uri", 15298 (const xmlChar *)"http://www.w3.org/2002/08/xquery-functions", 15299 xmlXPathEscapeUriFunction); 15300 } 15301 15302 #endif /* LIBXML_XPATH_ENABLED */ 15303 #define bottom_xpath 15304 #include "elfgcchack.h" 15305
