projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
[LWIP] Fix src/core/init.c a bit (#1620)
[reactos.git] / sdk / lib / 3rdparty / libxml2 / xpath.c
1 /*
2 * xpath.c: XML Path Language implementation
3 * XPath is a language for addressing parts of an XML document,
4 * designed to be used by both XSLT and XPointer
5 *
6 * Reference: W3C Recommendation 16 November 1999
7 * http://www.w3.org/TR/1999/REC-xpath-19991116
8 * Public reference:
9 * http://www.w3.org/TR/xpath
10 *
11 * See Copyright for the status of this software
12 *
13 * Author: daniel@veillard.com
14 *
15 */
16
17 /* 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 INFINITY
481 #define INFINITY (DBL_MAX * DBL_MAX)
482 #endif
483
484 #ifndef NAN
485 #define NAN (INFINITY / INFINITY)
486 #endif
487
488 double xmlXPathNAN;
489 double xmlXPathPINF;
490 double xmlXPathNINF;
491
492 /**
493 * xmlXPathInit:
494 *
495 * Initialize the XPath environment
496 */
497 void
498 xmlXPathInit(void) {
499 xmlXPathNAN = NAN;
500 xmlXPathPINF = INFINITY;
501 xmlXPathNINF = -INFINITY;
502 }
503
504 /**
505 * xmlXPathIsNaN:
506 * @val: a double value
507 *
508 * Returns 1 if the value is a NaN, 0 otherwise
509 */
510 int
511 xmlXPathIsNaN(double val) {
512 #ifdef isnan
513 return isnan(val);
514 #else
515 return !(val == val);
516 #endif
517 }
518
519 /**
520 * xmlXPathIsInf:
521 * @val: a double value
522 *
523 * Returns 1 if the value is +Infinite, -1 if -Infinite, 0 otherwise
524 */
525 int
526 xmlXPathIsInf(double val) {
527 #ifdef isinf
528 return isinf(val) ? (val > 0 ? 1 : -1) : 0;
529 #else
530 if (val >= INFINITY)
531 return 1;
532 if (val <= -INFINITY)
533 return -1;
534 return 0;
535 #endif
536 }
537
538 #endif /* SCHEMAS or XPATH */
539
540 #ifdef LIBXML_XPATH_ENABLED
541
542 /*
543 * TODO: when compatibility allows remove all "fake node libxslt" strings
544 * the test should just be name[0] = ' '
545 */
546 #ifdef DEBUG_XPATH_EXPRESSION
547 #define DEBUG_STEP
548 #define DEBUG_EXPR
549 #define DEBUG_EVAL_COUNTS
550 #endif
551
552 static xmlNs xmlXPathXMLNamespaceStruct = {
553 NULL,
554 XML_NAMESPACE_DECL,
555 XML_XML_NAMESPACE,
556 BAD_CAST "xml",
557 NULL,
558 NULL
559 };
560 static xmlNsPtr xmlXPathXMLNamespace = &xmlXPathXMLNamespaceStruct;
561 #ifndef LIBXML_THREAD_ENABLED
562 /*
563 * Optimizer is disabled only when threaded apps are detected while
564 * the library ain't compiled for thread safety.
565 */
566 static int xmlXPathDisableOptimizer = 0;
567 #endif
568
569 /************************************************************************
570 * *
571 * Error handling routines *
572 * *
573 ************************************************************************/
574
575 /**
576 * XP_ERRORNULL:
577 * @X: the error code
578 *
579 * Macro to raise an XPath error and return NULL.
580 */
581 #define XP_ERRORNULL(X) \
582 { xmlXPathErr(ctxt, X); return(NULL); }
583
584 /*
585 * The array xmlXPathErrorMessages corresponds to the enum xmlXPathError
586 */
587 static const char *xmlXPathErrorMessages[] = {
588 "Ok\n",
589 "Number encoding\n",
590 "Unfinished literal\n",
591 "Start of literal\n",
592 "Expected $ for variable reference\n",
593 "Undefined variable\n",
594 "Invalid predicate\n",
595 "Invalid expression\n",
596 "Missing closing curly brace\n",
597 "Unregistered function\n",
598 "Invalid operand\n",
599 "Invalid type\n",
600 "Invalid number of arguments\n",
601 "Invalid context size\n",
602 "Invalid context position\n",
603 "Memory allocation error\n",
604 "Syntax error\n",
605 "Resource error\n",
606 "Sub resource error\n",
607 "Undefined namespace prefix\n",
608 "Encoding error\n",
609 "Char out of XML range\n",
610 "Invalid or incomplete context\n",
611 "Stack usage error\n",
612 "Forbidden variable\n",
613 "?? Unknown error ??\n" /* Must be last in the list! */
614 };
615 #define MAXERRNO ((int)(sizeof(xmlXPathErrorMessages) / \
616 sizeof(xmlXPathErrorMessages[0])) - 1)
617 /**
618 * xmlXPathErrMemory:
619 * @ctxt: an XPath context
620 * @extra: extra informations
621 *
622 * Handle a redefinition of attribute error
623 */
624 static void
625 xmlXPathErrMemory(xmlXPathContextPtr ctxt, const char *extra)
626 {
627 if (ctxt != NULL) {
628 if (extra) {
629 xmlChar buf[200];
630
631 xmlStrPrintf(buf, 200,
632 "Memory allocation failed : %s\n",
633 extra);
634 ctxt->lastError.message = (char *) xmlStrdup(buf);
635 } else {
636 ctxt->lastError.message = (char *)
637 xmlStrdup(BAD_CAST "Memory allocation failed\n");
638 }
639 ctxt->lastError.domain = XML_FROM_XPATH;
640 ctxt->lastError.code = XML_ERR_NO_MEMORY;
641 if (ctxt->error != NULL)
642 ctxt->error(ctxt->userData, &ctxt->lastError);
643 } else {
644 if (extra)
645 __xmlRaiseError(NULL, NULL, NULL,
646 NULL, NULL, XML_FROM_XPATH,
647 XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0,
648 extra, NULL, NULL, 0, 0,
649 "Memory allocation failed : %s\n", extra);
650 else
651 __xmlRaiseError(NULL, NULL, NULL,
652 NULL, NULL, XML_FROM_XPATH,
653 XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0,
654 NULL, NULL, NULL, 0, 0,
655 "Memory allocation failed\n");
656 }
657 }
658
659 /**
660 * xmlXPathPErrMemory:
661 * @ctxt: an XPath parser context
662 * @extra: extra informations
663 *
664 * Handle a redefinition of attribute error
665 */
666 static void
667 xmlXPathPErrMemory(xmlXPathParserContextPtr ctxt, const char *extra)
668 {
669 if (ctxt == NULL)
670 xmlXPathErrMemory(NULL, extra);
671 else {
672 ctxt->error = XPATH_MEMORY_ERROR;
673 xmlXPathErrMemory(ctxt->context, extra);
674 }
675 }
676
677 /**
678 * xmlXPathErr:
679 * @ctxt: a XPath parser context
680 * @error: the error code
681 *
682 * Handle an XPath error
683 */
684 void
685 xmlXPathErr(xmlXPathParserContextPtr ctxt, int error)
686 {
687 if ((error < 0) || (error > MAXERRNO))
688 error = MAXERRNO;
689 if (ctxt == NULL) {
690 __xmlRaiseError(NULL, NULL, NULL,
691 NULL, NULL, XML_FROM_XPATH,
692 error + XML_XPATH_EXPRESSION_OK - XPATH_EXPRESSION_OK,
693 XML_ERR_ERROR, NULL, 0,
694 NULL, NULL, NULL, 0, 0,
695 "%s", xmlXPathErrorMessages[error]);
696 return;
697 }
698 ctxt->error = error;
699 if (ctxt->context == NULL) {
700 __xmlRaiseError(NULL, NULL, NULL,
701 NULL, NULL, XML_FROM_XPATH,
702 error + XML_XPATH_EXPRESSION_OK - XPATH_EXPRESSION_OK,
703 XML_ERR_ERROR, NULL, 0,
704 (const char *) ctxt->base, NULL, NULL,
705 ctxt->cur - ctxt->base, 0,
706 "%s", xmlXPathErrorMessages[error]);
707 return;
708 }
709
710 /* cleanup current last error */
711 xmlResetError(&ctxt->context->lastError);
712
713 ctxt->context->lastError.domain = XML_FROM_XPATH;
714 ctxt->context->lastError.code = error + XML_XPATH_EXPRESSION_OK -
715 XPATH_EXPRESSION_OK;
716 ctxt->context->lastError.level = XML_ERR_ERROR;
717 ctxt->context->lastError.str1 = (char *) xmlStrdup(ctxt->base);
718 ctxt->context->lastError.int1 = ctxt->cur - ctxt->base;
719 ctxt->context->lastError.node = ctxt->context->debugNode;
720 if (ctxt->context->error != NULL) {
721 ctxt->context->error(ctxt->context->userData,
722 &ctxt->context->lastError);
723 } else {
724 __xmlRaiseError(NULL, NULL, NULL,
725 NULL, ctxt->context->debugNode, XML_FROM_XPATH,
726 error + XML_XPATH_EXPRESSION_OK - XPATH_EXPRESSION_OK,
727 XML_ERR_ERROR, NULL, 0,
728 (const char *) ctxt->base, NULL, NULL,
729 ctxt->cur - ctxt->base, 0,
730 "%s", xmlXPathErrorMessages[error]);
731 }
732
733 }
734
735 /**
736 * xmlXPatherror:
737 * @ctxt: the XPath Parser context
738 * @file: the file name
739 * @line: the line number
740 * @no: the error number
741 *
742 * Formats an error message.
743 */
744 void
745 xmlXPatherror(xmlXPathParserContextPtr ctxt, const char *file ATTRIBUTE_UNUSED,
746 int line ATTRIBUTE_UNUSED, int no) {
747 xmlXPathErr(ctxt, no);
748 }
749
750 /************************************************************************
751 * *
752 * Utilities *
753 * *
754 ************************************************************************/
755
756 /**
757 * xsltPointerList:
758 *
759 * Pointer-list for various purposes.
760 */
761 typedef struct _xmlPointerList xmlPointerList;
762 typedef xmlPointerList *xmlPointerListPtr;
763 struct _xmlPointerList {
764 void **items;
765 int number;
766 int size;
767 };
768 /*
769 * TODO: Since such a list-handling is used in xmlschemas.c and libxslt
770 * and here, we should make the functions public.
771 */
772 static int
773 xmlPointerListAddSize(xmlPointerListPtr list,
774 void *item,
775 int initialSize)
776 {
777 if (list->items == NULL) {
778 if (initialSize <= 0)
779 initialSize = 1;
780 list->items = (void **) xmlMalloc(initialSize * sizeof(void *));
781 if (list->items == NULL) {
782 xmlXPathErrMemory(NULL,
783 "xmlPointerListCreate: allocating item\n");
784 return(-1);
785 }
786 list->number = 0;
787 list->size = initialSize;
788 } else if (list->size <= list->number) {
789 if (list->size > 50000000) {
790 xmlXPathErrMemory(NULL,
791 "xmlPointerListAddSize: re-allocating item\n");
792 return(-1);
793 }
794 list->size *= 2;
795 list->items = (void **) xmlRealloc(list->items,
796 list->size * sizeof(void *));
797 if (list->items == NULL) {
798 xmlXPathErrMemory(NULL,
799 "xmlPointerListAddSize: re-allocating item\n");
800 list->size = 0;
801 return(-1);
802 }
803 }
804 list->items[list->number++] = item;
805 return(0);
806 }
807
808 /**
809 * xsltPointerListCreate:
810 *
811 * Creates an xsltPointerList structure.
812 *
813 * Returns a xsltPointerList structure or NULL in case of an error.
814 */
815 static xmlPointerListPtr
816 xmlPointerListCreate(int initialSize)
817 {
818 xmlPointerListPtr ret;
819
820 ret = xmlMalloc(sizeof(xmlPointerList));
821 if (ret == NULL) {
822 xmlXPathErrMemory(NULL,
823 "xmlPointerListCreate: allocating item\n");
824 return (NULL);
825 }
826 memset(ret, 0, sizeof(xmlPointerList));
827 if (initialSize > 0) {
828 xmlPointerListAddSize(ret, NULL, initialSize);
829 ret->number = 0;
830 }
831 return (ret);
832 }
833
834 /**
835 * xsltPointerListFree:
836 *
837 * Frees the xsltPointerList structure. This does not free
838 * the content of the list.
839 */
840 static void
841 xmlPointerListFree(xmlPointerListPtr list)
842 {
843 if (list == NULL)
844 return;
845 if (list->items != NULL)
846 xmlFree(list->items);
847 xmlFree(list);
848 }
849
850 /************************************************************************
851 * *
852 * Parser Types *
853 * *
854 ************************************************************************/
855
856 /*
857 * Types are private:
858 */
859
860 typedef enum {
861 XPATH_OP_END=0,
862 XPATH_OP_AND,
863 XPATH_OP_OR,
864 XPATH_OP_EQUAL,
865 XPATH_OP_CMP,
866 XPATH_OP_PLUS,
867 XPATH_OP_MULT,
868 XPATH_OP_UNION,
869 XPATH_OP_ROOT,
870 XPATH_OP_NODE,
871 XPATH_OP_COLLECT,
872 XPATH_OP_VALUE, /* 11 */
873 XPATH_OP_VARIABLE,
874 XPATH_OP_FUNCTION,
875 XPATH_OP_ARG,
876 XPATH_OP_PREDICATE,
877 XPATH_OP_FILTER, /* 16 */
878 XPATH_OP_SORT /* 17 */
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_SORT:
1529 fprintf(output, "SORT"); break;
1530 case XPATH_OP_COLLECT: {
1531 xmlXPathAxisVal axis = (xmlXPathAxisVal)op->value;
1532 xmlXPathTestVal test = (xmlXPathTestVal)op->value2;
1533 xmlXPathTypeVal type = (xmlXPathTypeVal)op->value3;
1534 const xmlChar *prefix = op->value4;
1535 const xmlChar *name = op->value5;
1536
1537 fprintf(output, "COLLECT ");
1538 switch (axis) {
1539 case AXIS_ANCESTOR:
1540 fprintf(output, " 'ancestors' "); break;
1541 case AXIS_ANCESTOR_OR_SELF:
1542 fprintf(output, " 'ancestors-or-self' "); break;
1543 case AXIS_ATTRIBUTE:
1544 fprintf(output, " 'attributes' "); break;
1545 case AXIS_CHILD:
1546 fprintf(output, " 'child' "); break;
1547 case AXIS_DESCENDANT:
1548 fprintf(output, " 'descendant' "); break;
1549 case AXIS_DESCENDANT_OR_SELF:
1550 fprintf(output, " 'descendant-or-self' "); break;
1551 case AXIS_FOLLOWING:
1552 fprintf(output, " 'following' "); break;
1553 case AXIS_FOLLOWING_SIBLING:
1554 fprintf(output, " 'following-siblings' "); break;
1555 case AXIS_NAMESPACE:
1556 fprintf(output, " 'namespace' "); break;
1557 case AXIS_PARENT:
1558 fprintf(output, " 'parent' "); break;
1559 case AXIS_PRECEDING:
1560 fprintf(output, " 'preceding' "); break;
1561 case AXIS_PRECEDING_SIBLING:
1562 fprintf(output, " 'preceding-sibling' "); break;
1563 case AXIS_SELF:
1564 fprintf(output, " 'self' "); break;
1565 }
1566 switch (test) {
1567 case NODE_TEST_NONE:
1568 fprintf(output, "'none' "); break;
1569 case NODE_TEST_TYPE:
1570 fprintf(output, "'type' "); break;
1571 case NODE_TEST_PI:
1572 fprintf(output, "'PI' "); break;
1573 case NODE_TEST_ALL:
1574 fprintf(output, "'all' "); break;
1575 case NODE_TEST_NS:
1576 fprintf(output, "'namespace' "); break;
1577 case NODE_TEST_NAME:
1578 fprintf(output, "'name' "); break;
1579 }
1580 switch (type) {
1581 case NODE_TYPE_NODE:
1582 fprintf(output, "'node' "); break;
1583 case NODE_TYPE_COMMENT:
1584 fprintf(output, "'comment' "); break;
1585 case NODE_TYPE_TEXT:
1586 fprintf(output, "'text' "); break;
1587 case NODE_TYPE_PI:
1588 fprintf(output, "'PI' "); break;
1589 }
1590 if (prefix != NULL)
1591 fprintf(output, "%s:", prefix);
1592 if (name != NULL)
1593 fprintf(output, "%s", (const char *) name);
1594 break;
1595
1596 }
1597 case XPATH_OP_VALUE: {
1598 xmlXPathObjectPtr object = (xmlXPathObjectPtr) op->value4;
1599
1600 fprintf(output, "ELEM ");
1601 xmlXPathDebugDumpObject(output, object, 0);
1602 goto finish;
1603 }
1604 case XPATH_OP_VARIABLE: {
1605 const xmlChar *prefix = op->value5;
1606 const xmlChar *name = op->value4;
1607
1608 if (prefix != NULL)
1609 fprintf(output, "VARIABLE %s:%s", prefix, name);
1610 else
1611 fprintf(output, "VARIABLE %s", name);
1612 break;
1613 }
1614 case XPATH_OP_FUNCTION: {
1615 int nbargs = op->value;
1616 const xmlChar *prefix = op->value5;
1617 const xmlChar *name = op->value4;
1618
1619 if (prefix != NULL)
1620 fprintf(output, "FUNCTION %s:%s(%d args)",
1621 prefix, name, nbargs);
1622 else
1623 fprintf(output, "FUNCTION %s(%d args)", name, nbargs);
1624 break;
1625 }
1626 case XPATH_OP_ARG: fprintf(output, "ARG"); break;
1627 case XPATH_OP_PREDICATE: fprintf(output, "PREDICATE"); break;
1628 case XPATH_OP_FILTER: fprintf(output, "FILTER"); break;
1629 #ifdef LIBXML_XPTR_ENABLED
1630 case XPATH_OP_RANGETO: fprintf(output, "RANGETO"); break;
1631 #endif
1632 default:
1633 fprintf(output, "UNKNOWN %d\n", op->op); return;
1634 }
1635 fprintf(output, "\n");
1636 finish:
1637 if (op->ch1 >= 0)
1638 xmlXPathDebugDumpStepOp(output, comp, &comp->steps[op->ch1], depth + 1);
1639 if (op->ch2 >= 0)
1640 xmlXPathDebugDumpStepOp(output, comp, &comp->steps[op->ch2], depth + 1);
1641 }
1642
1643 /**
1644 * xmlXPathDebugDumpCompExpr:
1645 * @output: the FILE * for the output
1646 * @comp: the precompiled XPath expression
1647 * @depth: the indentation level.
1648 *
1649 * Dumps the tree of the compiled XPath expression.
1650 */
1651 void
1652 xmlXPathDebugDumpCompExpr(FILE *output, xmlXPathCompExprPtr comp,
1653 int depth) {
1654 int i;
1655 char shift[100];
1656
1657 if ((output == NULL) || (comp == NULL)) return;
1658
1659 for (i = 0;((i < depth) && (i < 25));i++)
1660 shift[2 * i] = shift[2 * i + 1] = ' ';
1661 shift[2 * i] = shift[2 * i + 1] = 0;
1662
1663 fprintf(output, "%s", shift);
1664
1665 #ifdef XPATH_STREAMING
1666 if (comp->stream) {
1667 fprintf(output, "Streaming Expression\n");
1668 } else
1669 #endif
1670 {
1671 fprintf(output, "Compiled Expression : %d elements\n",
1672 comp->nbStep);
1673 i = comp->last;
1674 xmlXPathDebugDumpStepOp(output, comp, &comp->steps[i], depth + 1);
1675 }
1676 }
1677
1678 #ifdef XP_DEBUG_OBJ_USAGE
1679
1680 /*
1681 * XPath object usage related debugging variables.
1682 */
1683 static int xmlXPathDebugObjCounterUndefined = 0;
1684 static int xmlXPathDebugObjCounterNodeset = 0;
1685 static int xmlXPathDebugObjCounterBool = 0;
1686 static int xmlXPathDebugObjCounterNumber = 0;
1687 static int xmlXPathDebugObjCounterString = 0;
1688 static int xmlXPathDebugObjCounterPoint = 0;
1689 static int xmlXPathDebugObjCounterRange = 0;
1690 static int xmlXPathDebugObjCounterLocset = 0;
1691 static int xmlXPathDebugObjCounterUsers = 0;
1692 static int xmlXPathDebugObjCounterXSLTTree = 0;
1693 static int xmlXPathDebugObjCounterAll = 0;
1694
1695 static int xmlXPathDebugObjTotalUndefined = 0;
1696 static int xmlXPathDebugObjTotalNodeset = 0;
1697 static int xmlXPathDebugObjTotalBool = 0;
1698 static int xmlXPathDebugObjTotalNumber = 0;
1699 static int xmlXPathDebugObjTotalString = 0;
1700 static int xmlXPathDebugObjTotalPoint = 0;
1701 static int xmlXPathDebugObjTotalRange = 0;
1702 static int xmlXPathDebugObjTotalLocset = 0;
1703 static int xmlXPathDebugObjTotalUsers = 0;
1704 static int xmlXPathDebugObjTotalXSLTTree = 0;
1705 static int xmlXPathDebugObjTotalAll = 0;
1706
1707 static int xmlXPathDebugObjMaxUndefined = 0;
1708 static int xmlXPathDebugObjMaxNodeset = 0;
1709 static int xmlXPathDebugObjMaxBool = 0;
1710 static int xmlXPathDebugObjMaxNumber = 0;
1711 static int xmlXPathDebugObjMaxString = 0;
1712 static int xmlXPathDebugObjMaxPoint = 0;
1713 static int xmlXPathDebugObjMaxRange = 0;
1714 static int xmlXPathDebugObjMaxLocset = 0;
1715 static int xmlXPathDebugObjMaxUsers = 0;
1716 static int xmlXPathDebugObjMaxXSLTTree = 0;
1717 static int xmlXPathDebugObjMaxAll = 0;
1718
1719 /* REVISIT TODO: Make this static when committing */
1720 static void
1721 xmlXPathDebugObjUsageReset(xmlXPathContextPtr ctxt)
1722 {
1723 if (ctxt != NULL) {
1724 if (ctxt->cache != NULL) {
1725 xmlXPathContextCachePtr cache =
1726 (xmlXPathContextCachePtr) ctxt->cache;
1727
1728 cache->dbgCachedAll = 0;
1729 cache->dbgCachedNodeset = 0;
1730 cache->dbgCachedString = 0;
1731 cache->dbgCachedBool = 0;
1732 cache->dbgCachedNumber = 0;
1733 cache->dbgCachedPoint = 0;
1734 cache->dbgCachedRange = 0;
1735 cache->dbgCachedLocset = 0;
1736 cache->dbgCachedUsers = 0;
1737 cache->dbgCachedXSLTTree = 0;
1738 cache->dbgCachedUndefined = 0;
1739
1740 cache->dbgReusedAll = 0;
1741 cache->dbgReusedNodeset = 0;
1742 cache->dbgReusedString = 0;
1743 cache->dbgReusedBool = 0;
1744 cache->dbgReusedNumber = 0;
1745 cache->dbgReusedPoint = 0;
1746 cache->dbgReusedRange = 0;
1747 cache->dbgReusedLocset = 0;
1748 cache->dbgReusedUsers = 0;
1749 cache->dbgReusedXSLTTree = 0;
1750 cache->dbgReusedUndefined = 0;
1751 }
1752 }
1753
1754 xmlXPathDebugObjCounterUndefined = 0;
1755 xmlXPathDebugObjCounterNodeset = 0;
1756 xmlXPathDebugObjCounterBool = 0;
1757 xmlXPathDebugObjCounterNumber = 0;
1758 xmlXPathDebugObjCounterString = 0;
1759 xmlXPathDebugObjCounterPoint = 0;
1760 xmlXPathDebugObjCounterRange = 0;
1761 xmlXPathDebugObjCounterLocset = 0;
1762 xmlXPathDebugObjCounterUsers = 0;
1763 xmlXPathDebugObjCounterXSLTTree = 0;
1764 xmlXPathDebugObjCounterAll = 0;
1765
1766 xmlXPathDebugObjTotalUndefined = 0;
1767 xmlXPathDebugObjTotalNodeset = 0;
1768 xmlXPathDebugObjTotalBool = 0;
1769 xmlXPathDebugObjTotalNumber = 0;
1770 xmlXPathDebugObjTotalString = 0;
1771 xmlXPathDebugObjTotalPoint = 0;
1772 xmlXPathDebugObjTotalRange = 0;
1773 xmlXPathDebugObjTotalLocset = 0;
1774 xmlXPathDebugObjTotalUsers = 0;
1775 xmlXPathDebugObjTotalXSLTTree = 0;
1776 xmlXPathDebugObjTotalAll = 0;
1777
1778 xmlXPathDebugObjMaxUndefined = 0;
1779 xmlXPathDebugObjMaxNodeset = 0;
1780 xmlXPathDebugObjMaxBool = 0;
1781 xmlXPathDebugObjMaxNumber = 0;
1782 xmlXPathDebugObjMaxString = 0;
1783 xmlXPathDebugObjMaxPoint = 0;
1784 xmlXPathDebugObjMaxRange = 0;
1785 xmlXPathDebugObjMaxLocset = 0;
1786 xmlXPathDebugObjMaxUsers = 0;
1787 xmlXPathDebugObjMaxXSLTTree = 0;
1788 xmlXPathDebugObjMaxAll = 0;
1789
1790 }
1791
1792 static void
1793 xmlXPathDebugObjUsageRequested(xmlXPathContextPtr ctxt,
1794 xmlXPathObjectType objType)
1795 {
1796 int isCached = 0;
1797
1798 if (ctxt != NULL) {
1799 if (ctxt->cache != NULL) {
1800 xmlXPathContextCachePtr cache =
1801 (xmlXPathContextCachePtr) ctxt->cache;
1802
1803 isCached = 1;
1804
1805 cache->dbgReusedAll++;
1806 switch (objType) {
1807 case XPATH_UNDEFINED:
1808 cache->dbgReusedUndefined++;
1809 break;
1810 case XPATH_NODESET:
1811 cache->dbgReusedNodeset++;
1812 break;
1813 case XPATH_BOOLEAN:
1814 cache->dbgReusedBool++;
1815 break;
1816 case XPATH_NUMBER:
1817 cache->dbgReusedNumber++;
1818 break;
1819 case XPATH_STRING:
1820 cache->dbgReusedString++;
1821 break;
1822 case XPATH_POINT:
1823 cache->dbgReusedPoint++;
1824 break;
1825 case XPATH_RANGE:
1826 cache->dbgReusedRange++;
1827 break;
1828 case XPATH_LOCATIONSET:
1829 cache->dbgReusedLocset++;
1830 break;
1831 case XPATH_USERS:
1832 cache->dbgReusedUsers++;
1833 break;
1834 case XPATH_XSLT_TREE:
1835 cache->dbgReusedXSLTTree++;
1836 break;
1837 default:
1838 break;
1839 }
1840 }
1841 }
1842
1843 switch (objType) {
1844 case XPATH_UNDEFINED:
1845 if (! isCached)
1846 xmlXPathDebugObjTotalUndefined++;
1847 xmlXPathDebugObjCounterUndefined++;
1848 if (xmlXPathDebugObjCounterUndefined >
1849 xmlXPathDebugObjMaxUndefined)
1850 xmlXPathDebugObjMaxUndefined =
1851 xmlXPathDebugObjCounterUndefined;
1852 break;
1853 case XPATH_NODESET:
1854 if (! isCached)
1855 xmlXPathDebugObjTotalNodeset++;
1856 xmlXPathDebugObjCounterNodeset++;
1857 if (xmlXPathDebugObjCounterNodeset >
1858 xmlXPathDebugObjMaxNodeset)
1859 xmlXPathDebugObjMaxNodeset =
1860 xmlXPathDebugObjCounterNodeset;
1861 break;
1862 case XPATH_BOOLEAN:
1863 if (! isCached)
1864 xmlXPathDebugObjTotalBool++;
1865 xmlXPathDebugObjCounterBool++;
1866 if (xmlXPathDebugObjCounterBool >
1867 xmlXPathDebugObjMaxBool)
1868 xmlXPathDebugObjMaxBool =
1869 xmlXPathDebugObjCounterBool;
1870 break;
1871 case XPATH_NUMBER:
1872 if (! isCached)
1873 xmlXPathDebugObjTotalNumber++;
1874 xmlXPathDebugObjCounterNumber++;
1875 if (xmlXPathDebugObjCounterNumber >
1876 xmlXPathDebugObjMaxNumber)
1877 xmlXPathDebugObjMaxNumber =
1878 xmlXPathDebugObjCounterNumber;
1879 break;
1880 case XPATH_STRING:
1881 if (! isCached)
1882 xmlXPathDebugObjTotalString++;
1883 xmlXPathDebugObjCounterString++;
1884 if (xmlXPathDebugObjCounterString >
1885 xmlXPathDebugObjMaxString)
1886 xmlXPathDebugObjMaxString =
1887 xmlXPathDebugObjCounterString;
1888 break;
1889 case XPATH_POINT:
1890 if (! isCached)
1891 xmlXPathDebugObjTotalPoint++;
1892 xmlXPathDebugObjCounterPoint++;
1893 if (xmlXPathDebugObjCounterPoint >
1894 xmlXPathDebugObjMaxPoint)
1895 xmlXPathDebugObjMaxPoint =
1896 xmlXPathDebugObjCounterPoint;
1897 break;
1898 case XPATH_RANGE:
1899 if (! isCached)
1900 xmlXPathDebugObjTotalRange++;
1901 xmlXPathDebugObjCounterRange++;
1902 if (xmlXPathDebugObjCounterRange >
1903 xmlXPathDebugObjMaxRange)
1904 xmlXPathDebugObjMaxRange =
1905 xmlXPathDebugObjCounterRange;
1906 break;
1907 case XPATH_LOCATIONSET:
1908 if (! isCached)
1909 xmlXPathDebugObjTotalLocset++;
1910 xmlXPathDebugObjCounterLocset++;
1911 if (xmlXPathDebugObjCounterLocset >
1912 xmlXPathDebugObjMaxLocset)
1913 xmlXPathDebugObjMaxLocset =
1914 xmlXPathDebugObjCounterLocset;
1915 break;
1916 case XPATH_USERS:
1917 if (! isCached)
1918 xmlXPathDebugObjTotalUsers++;
1919 xmlXPathDebugObjCounterUsers++;
1920 if (xmlXPathDebugObjCounterUsers >
1921 xmlXPathDebugObjMaxUsers)
1922 xmlXPathDebugObjMaxUsers =
1923 xmlXPathDebugObjCounterUsers;
1924 break;
1925 case XPATH_XSLT_TREE:
1926 if (! isCached)
1927 xmlXPathDebugObjTotalXSLTTree++;
1928 xmlXPathDebugObjCounterXSLTTree++;
1929 if (xmlXPathDebugObjCounterXSLTTree >
1930 xmlXPathDebugObjMaxXSLTTree)
1931 xmlXPathDebugObjMaxXSLTTree =
1932 xmlXPathDebugObjCounterXSLTTree;
1933 break;
1934 default:
1935 break;
1936 }
1937 if (! isCached)
1938 xmlXPathDebugObjTotalAll++;
1939 xmlXPathDebugObjCounterAll++;
1940 if (xmlXPathDebugObjCounterAll >
1941 xmlXPathDebugObjMaxAll)
1942 xmlXPathDebugObjMaxAll =
1943 xmlXPathDebugObjCounterAll;
1944 }
1945
1946 static void
1947 xmlXPathDebugObjUsageReleased(xmlXPathContextPtr ctxt,
1948 xmlXPathObjectType objType)
1949 {
1950 int isCached = 0;
1951
1952 if (ctxt != NULL) {
1953 if (ctxt->cache != NULL) {
1954 xmlXPathContextCachePtr cache =
1955 (xmlXPathContextCachePtr) ctxt->cache;
1956
1957 isCached = 1;
1958
1959 cache->dbgCachedAll++;
1960 switch (objType) {
1961 case XPATH_UNDEFINED:
1962 cache->dbgCachedUndefined++;
1963 break;
1964 case XPATH_NODESET:
1965 cache->dbgCachedNodeset++;
1966 break;
1967 case XPATH_BOOLEAN:
1968 cache->dbgCachedBool++;
1969 break;
1970 case XPATH_NUMBER:
1971 cache->dbgCachedNumber++;
1972 break;
1973 case XPATH_STRING:
1974 cache->dbgCachedString++;
1975 break;
1976 case XPATH_POINT:
1977 cache->dbgCachedPoint++;
1978 break;
1979 case XPATH_RANGE:
1980 cache->dbgCachedRange++;
1981 break;
1982 case XPATH_LOCATIONSET:
1983 cache->dbgCachedLocset++;
1984 break;
1985 case XPATH_USERS:
1986 cache->dbgCachedUsers++;
1987 break;
1988 case XPATH_XSLT_TREE:
1989 cache->dbgCachedXSLTTree++;
1990 break;
1991 default:
1992 break;
1993 }
1994
1995 }
1996 }
1997 switch (objType) {
1998 case XPATH_UNDEFINED:
1999 xmlXPathDebugObjCounterUndefined--;
2000 break;
2001 case XPATH_NODESET:
2002 xmlXPathDebugObjCounterNodeset--;
2003 break;
2004 case XPATH_BOOLEAN:
2005 xmlXPathDebugObjCounterBool--;
2006 break;
2007 case XPATH_NUMBER:
2008 xmlXPathDebugObjCounterNumber--;
2009 break;
2010 case XPATH_STRING:
2011 xmlXPathDebugObjCounterString--;
2012 break;
2013 case XPATH_POINT:
2014 xmlXPathDebugObjCounterPoint--;
2015 break;
2016 case XPATH_RANGE:
2017 xmlXPathDebugObjCounterRange--;
2018 break;
2019 case XPATH_LOCATIONSET:
2020 xmlXPathDebugObjCounterLocset--;
2021 break;
2022 case XPATH_USERS:
2023 xmlXPathDebugObjCounterUsers--;
2024 break;
2025 case XPATH_XSLT_TREE:
2026 xmlXPathDebugObjCounterXSLTTree--;
2027 break;
2028 default:
2029 break;
2030 }
2031 xmlXPathDebugObjCounterAll--;
2032 }
2033
2034 /* REVISIT TODO: Make this static when committing */
2035 static void
2036 xmlXPathDebugObjUsageDisplay(xmlXPathContextPtr ctxt)
2037 {
2038 int reqAll, reqNodeset, reqString, reqBool, reqNumber,
2039 reqXSLTTree, reqUndefined;
2040 int caAll = 0, caNodeset = 0, caString = 0, caBool = 0,
2041 caNumber = 0, caXSLTTree = 0, caUndefined = 0;
2042 int reAll = 0, reNodeset = 0, reString = 0, reBool = 0,
2043 reNumber = 0, reXSLTTree = 0, reUndefined = 0;
2044 int leftObjs = xmlXPathDebugObjCounterAll;
2045
2046 reqAll = xmlXPathDebugObjTotalAll;
2047 reqNodeset = xmlXPathDebugObjTotalNodeset;
2048 reqString = xmlXPathDebugObjTotalString;
2049 reqBool = xmlXPathDebugObjTotalBool;
2050 reqNumber = xmlXPathDebugObjTotalNumber;
2051 reqXSLTTree = xmlXPathDebugObjTotalXSLTTree;
2052 reqUndefined = xmlXPathDebugObjTotalUndefined;
2053
2054 printf("# XPath object usage:\n");
2055
2056 if (ctxt != NULL) {
2057 if (ctxt->cache != NULL) {
2058 xmlXPathContextCachePtr cache =
2059 (xmlXPathContextCachePtr) ctxt->cache;
2060
2061 reAll = cache->dbgReusedAll;
2062 reqAll += reAll;
2063 reNodeset = cache->dbgReusedNodeset;
2064 reqNodeset += reNodeset;
2065 reString = cache->dbgReusedString;
2066 reqString += reString;
2067 reBool = cache->dbgReusedBool;
2068 reqBool += reBool;
2069 reNumber = cache->dbgReusedNumber;
2070 reqNumber += reNumber;
2071 reXSLTTree = cache->dbgReusedXSLTTree;
2072 reqXSLTTree += reXSLTTree;
2073 reUndefined = cache->dbgReusedUndefined;
2074 reqUndefined += reUndefined;
2075
2076 caAll = cache->dbgCachedAll;
2077 caBool = cache->dbgCachedBool;
2078 caNodeset = cache->dbgCachedNodeset;
2079 caString = cache->dbgCachedString;
2080 caNumber = cache->dbgCachedNumber;
2081 caXSLTTree = cache->dbgCachedXSLTTree;
2082 caUndefined = cache->dbgCachedUndefined;
2083
2084 if (cache->nodesetObjs)
2085 leftObjs -= cache->nodesetObjs->number;
2086 if (cache->stringObjs)
2087 leftObjs -= cache->stringObjs->number;
2088 if (cache->booleanObjs)
2089 leftObjs -= cache->booleanObjs->number;
2090 if (cache->numberObjs)
2091 leftObjs -= cache->numberObjs->number;
2092 if (cache->miscObjs)
2093 leftObjs -= cache->miscObjs->number;
2094 }
2095 }
2096
2097 printf("# all\n");
2098 printf("# total : %d\n", reqAll);
2099 printf("# left : %d\n", leftObjs);
2100 printf("# created: %d\n", xmlXPathDebugObjTotalAll);
2101 printf("# reused : %d\n", reAll);
2102 printf("# max : %d\n", xmlXPathDebugObjMaxAll);
2103
2104 printf("# node-sets\n");
2105 printf("# total : %d\n", reqNodeset);
2106 printf("# created: %d\n", xmlXPathDebugObjTotalNodeset);
2107 printf("# reused : %d\n", reNodeset);
2108 printf("# max : %d\n", xmlXPathDebugObjMaxNodeset);
2109
2110 printf("# strings\n");
2111 printf("# total : %d\n", reqString);
2112 printf("# created: %d\n", xmlXPathDebugObjTotalString);
2113 printf("# reused : %d\n", reString);
2114 printf("# max : %d\n", xmlXPathDebugObjMaxString);
2115
2116 printf("# booleans\n");
2117 printf("# total : %d\n", reqBool);
2118 printf("# created: %d\n", xmlXPathDebugObjTotalBool);
2119 printf("# reused : %d\n", reBool);
2120 printf("# max : %d\n", xmlXPathDebugObjMaxBool);
2121
2122 printf("# numbers\n");
2123 printf("# total : %d\n", reqNumber);
2124 printf("# created: %d\n", xmlXPathDebugObjTotalNumber);
2125 printf("# reused : %d\n", reNumber);
2126 printf("# max : %d\n", xmlXPathDebugObjMaxNumber);
2127
2128 printf("# XSLT result tree fragments\n");
2129 printf("# total : %d\n", reqXSLTTree);
2130 printf("# created: %d\n", xmlXPathDebugObjTotalXSLTTree);
2131 printf("# reused : %d\n", reXSLTTree);
2132 printf("# max : %d\n", xmlXPathDebugObjMaxXSLTTree);
2133
2134 printf("# undefined\n");
2135 printf("# total : %d\n", reqUndefined);
2136 printf("# created: %d\n", xmlXPathDebugObjTotalUndefined);
2137 printf("# reused : %d\n", reUndefined);
2138 printf("# max : %d\n", xmlXPathDebugObjMaxUndefined);
2139
2140 }
2141
2142 #endif /* XP_DEBUG_OBJ_USAGE */
2143
2144 #endif /* LIBXML_DEBUG_ENABLED */
2145
2146 /************************************************************************
2147 * *
2148 * XPath object caching *
2149 * *
2150 ************************************************************************/
2151
2152 /**
2153 * xmlXPathNewCache:
2154 *
2155 * Create a new object cache
2156 *
2157 * Returns the xmlXPathCache just allocated.
2158 */
2159 static xmlXPathContextCachePtr
2160 xmlXPathNewCache(void)
2161 {
2162 xmlXPathContextCachePtr ret;
2163
2164 ret = (xmlXPathContextCachePtr) xmlMalloc(sizeof(xmlXPathContextCache));
2165 if (ret == NULL) {
2166 xmlXPathErrMemory(NULL, "creating object cache\n");
2167 return(NULL);
2168 }
2169 memset(ret, 0 , (size_t) sizeof(xmlXPathContextCache));
2170 ret->maxNodeset = 100;
2171 ret->maxString = 100;
2172 ret->maxBoolean = 100;
2173 ret->maxNumber = 100;
2174 ret->maxMisc = 100;
2175 return(ret);
2176 }
2177
2178 static void
2179 xmlXPathCacheFreeObjectList(xmlPointerListPtr list)
2180 {
2181 int i;
2182 xmlXPathObjectPtr obj;
2183
2184 if (list == NULL)
2185 return;
2186
2187 for (i = 0; i < list->number; i++) {
2188 obj = list->items[i];
2189 /*
2190 * Note that it is already assured that we don't need to
2191 * look out for namespace nodes in the node-set.
2192 */
2193 if (obj->nodesetval != NULL) {
2194 if (obj->nodesetval->nodeTab != NULL)
2195 xmlFree(obj->nodesetval->nodeTab);
2196 xmlFree(obj->nodesetval);
2197 }
2198 xmlFree(obj);
2199 #ifdef XP_DEBUG_OBJ_USAGE
2200 xmlXPathDebugObjCounterAll--;
2201 #endif
2202 }
2203 xmlPointerListFree(list);
2204 }
2205
2206 static void
2207 xmlXPathFreeCache(xmlXPathContextCachePtr cache)
2208 {
2209 if (cache == NULL)
2210 return;
2211 if (cache->nodesetObjs)
2212 xmlXPathCacheFreeObjectList(cache->nodesetObjs);
2213 if (cache->stringObjs)
2214 xmlXPathCacheFreeObjectList(cache->stringObjs);
2215 if (cache->booleanObjs)
2216 xmlXPathCacheFreeObjectList(cache->booleanObjs);
2217 if (cache->numberObjs)
2218 xmlXPathCacheFreeObjectList(cache->numberObjs);
2219 if (cache->miscObjs)
2220 xmlXPathCacheFreeObjectList(cache->miscObjs);
2221 xmlFree(cache);
2222 }
2223
2224 /**
2225 * xmlXPathContextSetCache:
2226 *
2227 * @ctxt: the XPath context
2228 * @active: enables/disables (creates/frees) the cache
2229 * @value: a value with semantics dependant on @options
2230 * @options: options (currently only the value 0 is used)
2231 *
2232 * Creates/frees an object cache on the XPath context.
2233 * If activates XPath objects (xmlXPathObject) will be cached internally
2234 * to be reused.
2235 * @options:
2236 * 0: This will set the XPath object caching:
2237 * @value:
2238 * This will set the maximum number of XPath objects
2239 * to be cached per slot
2240 * There are 5 slots for: node-set, string, number, boolean, and
2241 * misc objects. Use <0 for the default number (100).
2242 * Other values for @options have currently no effect.
2243 *
2244 * Returns 0 if the setting succeeded, and -1 on API or internal errors.
2245 */
2246 int
2247 xmlXPathContextSetCache(xmlXPathContextPtr ctxt,
2248 int active,
2249 int value,
2250 int options)
2251 {
2252 if (ctxt == NULL)
2253 return(-1);
2254 if (active) {
2255 xmlXPathContextCachePtr cache;
2256
2257 if (ctxt->cache == NULL) {
2258 ctxt->cache = xmlXPathNewCache();
2259 if (ctxt->cache == NULL)
2260 return(-1);
2261 }
2262 cache = (xmlXPathContextCachePtr) ctxt->cache;
2263 if (options == 0) {
2264 if (value < 0)
2265 value = 100;
2266 cache->maxNodeset = value;
2267 cache->maxString = value;
2268 cache->maxNumber = value;
2269 cache->maxBoolean = value;
2270 cache->maxMisc = value;
2271 }
2272 } else if (ctxt->cache != NULL) {
2273 xmlXPathFreeCache((xmlXPathContextCachePtr) ctxt->cache);
2274 ctxt->cache = NULL;
2275 }
2276 return(0);
2277 }
2278
2279 /**
2280 * xmlXPathCacheWrapNodeSet:
2281 * @ctxt: the XPath context
2282 * @val: the NodePtr value
2283 *
2284 * This is the cached version of xmlXPathWrapNodeSet().
2285 * Wrap the Nodeset @val in a new xmlXPathObjectPtr
2286 *
2287 * Returns the created or reused object.
2288 */
2289 static xmlXPathObjectPtr
2290 xmlXPathCacheWrapNodeSet(xmlXPathContextPtr ctxt, xmlNodeSetPtr val)
2291 {
2292 if ((ctxt != NULL) && (ctxt->cache != NULL)) {
2293 xmlXPathContextCachePtr cache =
2294 (xmlXPathContextCachePtr) ctxt->cache;
2295
2296 if ((cache->miscObjs != NULL) &&
2297 (cache->miscObjs->number != 0))
2298 {
2299 xmlXPathObjectPtr ret;
2300
2301 ret = (xmlXPathObjectPtr)
2302 cache->miscObjs->items[--cache->miscObjs->number];
2303 ret->type = XPATH_NODESET;
2304 ret->nodesetval = val;
2305 #ifdef XP_DEBUG_OBJ_USAGE
2306 xmlXPathDebugObjUsageRequested(ctxt, XPATH_NODESET);
2307 #endif
2308 return(ret);
2309 }
2310 }
2311
2312 return(xmlXPathWrapNodeSet(val));
2313
2314 }
2315
2316 /**
2317 * xmlXPathCacheWrapString:
2318 * @ctxt: the XPath context
2319 * @val: the xmlChar * value
2320 *
2321 * This is the cached version of xmlXPathWrapString().
2322 * Wraps the @val string into an XPath object.
2323 *
2324 * Returns the created or reused object.
2325 */
2326 static xmlXPathObjectPtr
2327 xmlXPathCacheWrapString(xmlXPathContextPtr ctxt, xmlChar *val)
2328 {
2329 if ((ctxt != NULL) && (ctxt->cache != NULL)) {
2330 xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache;
2331
2332 if ((cache->stringObjs != NULL) &&
2333 (cache->stringObjs->number != 0))
2334 {
2335
2336 xmlXPathObjectPtr ret;
2337
2338 ret = (xmlXPathObjectPtr)
2339 cache->stringObjs->items[--cache->stringObjs->number];
2340 ret->type = XPATH_STRING;
2341 ret->stringval = val;
2342 #ifdef XP_DEBUG_OBJ_USAGE
2343 xmlXPathDebugObjUsageRequested(ctxt, XPATH_STRING);
2344 #endif
2345 return(ret);
2346 } else if ((cache->miscObjs != NULL) &&
2347 (cache->miscObjs->number != 0))
2348 {
2349 xmlXPathObjectPtr ret;
2350 /*
2351 * Fallback to misc-cache.
2352 */
2353 ret = (xmlXPathObjectPtr)
2354 cache->miscObjs->items[--cache->miscObjs->number];
2355
2356 ret->type = XPATH_STRING;
2357 ret->stringval = val;
2358 #ifdef XP_DEBUG_OBJ_USAGE
2359 xmlXPathDebugObjUsageRequested(ctxt, XPATH_STRING);
2360 #endif
2361 return(ret);
2362 }
2363 }
2364 return(xmlXPathWrapString(val));
2365 }
2366
2367 /**
2368 * xmlXPathCacheNewNodeSet:
2369 * @ctxt: the XPath context
2370 * @val: the NodePtr value
2371 *
2372 * This is the cached version of xmlXPathNewNodeSet().
2373 * Acquire an xmlXPathObjectPtr of type NodeSet and initialize
2374 * it with the single Node @val
2375 *
2376 * Returns the created or reused object.
2377 */
2378 static xmlXPathObjectPtr
2379 xmlXPathCacheNewNodeSet(xmlXPathContextPtr ctxt, xmlNodePtr val)
2380 {
2381 if ((ctxt != NULL) && (ctxt->cache)) {
2382 xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache;
2383
2384 if ((cache->nodesetObjs != NULL) &&
2385 (cache->nodesetObjs->number != 0))
2386 {
2387 xmlXPathObjectPtr ret;
2388 /*
2389 * Use the nodset-cache.
2390 */
2391 ret = (xmlXPathObjectPtr)
2392 cache->nodesetObjs->items[--cache->nodesetObjs->number];
2393 ret->type = XPATH_NODESET;
2394 ret->boolval = 0;
2395 if (val) {
2396 if ((ret->nodesetval->nodeMax == 0) ||
2397 (val->type == XML_NAMESPACE_DECL))
2398 {
2399 xmlXPathNodeSetAddUnique(ret->nodesetval, val);
2400 } else {
2401 ret->nodesetval->nodeTab[0] = val;
2402 ret->nodesetval->nodeNr = 1;
2403 }
2404 }
2405 #ifdef XP_DEBUG_OBJ_USAGE
2406 xmlXPathDebugObjUsageRequested(ctxt, XPATH_NODESET);
2407 #endif
2408 return(ret);
2409 } else if ((cache->miscObjs != NULL) &&
2410 (cache->miscObjs->number != 0))
2411 {
2412 xmlXPathObjectPtr ret;
2413 /*
2414 * Fallback to misc-cache.
2415 */
2416
2417 ret = (xmlXPathObjectPtr)
2418 cache->miscObjs->items[--cache->miscObjs->number];
2419
2420 ret->type = XPATH_NODESET;
2421 ret->boolval = 0;
2422 ret->nodesetval = xmlXPathNodeSetCreate(val);
2423 if (ret->nodesetval == NULL) {
2424 ctxt->lastError.domain = XML_FROM_XPATH;
2425 ctxt->lastError.code = XML_ERR_NO_MEMORY;
2426 return(NULL);
2427 }
2428 #ifdef XP_DEBUG_OBJ_USAGE
2429 xmlXPathDebugObjUsageRequested(ctxt, XPATH_NODESET);
2430 #endif
2431 return(ret);
2432 }
2433 }
2434 return(xmlXPathNewNodeSet(val));
2435 }
2436
2437 /**
2438 * xmlXPathCacheNewCString:
2439 * @ctxt: the XPath context
2440 * @val: the char * value
2441 *
2442 * This is the cached version of xmlXPathNewCString().
2443 * Acquire an xmlXPathObjectPtr of type string and of value @val
2444 *
2445 * Returns the created or reused object.
2446 */
2447 static xmlXPathObjectPtr
2448 xmlXPathCacheNewCString(xmlXPathContextPtr ctxt, const char *val)
2449 {
2450 if ((ctxt != NULL) && (ctxt->cache)) {
2451 xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache;
2452
2453 if ((cache->stringObjs != NULL) &&
2454 (cache->stringObjs->number != 0))
2455 {
2456 xmlXPathObjectPtr ret;
2457
2458 ret = (xmlXPathObjectPtr)
2459 cache->stringObjs->items[--cache->stringObjs->number];
2460
2461 ret->type = XPATH_STRING;
2462 ret->stringval = xmlStrdup(BAD_CAST val);
2463 #ifdef XP_DEBUG_OBJ_USAGE
2464 xmlXPathDebugObjUsageRequested(ctxt, XPATH_STRING);
2465 #endif
2466 return(ret);
2467 } else if ((cache->miscObjs != NULL) &&
2468 (cache->miscObjs->number != 0))
2469 {
2470 xmlXPathObjectPtr ret;
2471
2472 ret = (xmlXPathObjectPtr)
2473 cache->miscObjs->items[--cache->miscObjs->number];
2474
2475 ret->type = XPATH_STRING;
2476 ret->stringval = xmlStrdup(BAD_CAST val);
2477 #ifdef XP_DEBUG_OBJ_USAGE
2478 xmlXPathDebugObjUsageRequested(ctxt, XPATH_STRING);
2479 #endif
2480 return(ret);
2481 }
2482 }
2483 return(xmlXPathNewCString(val));
2484 }
2485
2486 /**
2487 * xmlXPathCacheNewString:
2488 * @ctxt: the XPath context
2489 * @val: the xmlChar * value
2490 *
2491 * This is the cached version of xmlXPathNewString().
2492 * Acquire an xmlXPathObjectPtr of type string and of value @val
2493 *
2494 * Returns the created or reused object.
2495 */
2496 static xmlXPathObjectPtr
2497 xmlXPathCacheNewString(xmlXPathContextPtr ctxt, const xmlChar *val)
2498 {
2499 if ((ctxt != NULL) && (ctxt->cache)) {
2500 xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache;
2501
2502 if ((cache->stringObjs != NULL) &&
2503 (cache->stringObjs->number != 0))
2504 {
2505 xmlXPathObjectPtr ret;
2506
2507 ret = (xmlXPathObjectPtr)
2508 cache->stringObjs->items[--cache->stringObjs->number];
2509 ret->type = XPATH_STRING;
2510 if (val != NULL)
2511 ret->stringval = xmlStrdup(val);
2512 else
2513 ret->stringval = xmlStrdup((const xmlChar *)"");
2514 #ifdef XP_DEBUG_OBJ_USAGE
2515 xmlXPathDebugObjUsageRequested(ctxt, XPATH_STRING);
2516 #endif
2517 return(ret);
2518 } else if ((cache->miscObjs != NULL) &&
2519 (cache->miscObjs->number != 0))
2520 {
2521 xmlXPathObjectPtr ret;
2522
2523 ret = (xmlXPathObjectPtr)
2524 cache->miscObjs->items[--cache->miscObjs->number];
2525
2526 ret->type = XPATH_STRING;
2527 if (val != NULL)
2528 ret->stringval = xmlStrdup(val);
2529 else
2530 ret->stringval = xmlStrdup((const xmlChar *)"");
2531 #ifdef XP_DEBUG_OBJ_USAGE
2532 xmlXPathDebugObjUsageRequested(ctxt, XPATH_STRING);
2533 #endif
2534 return(ret);
2535 }
2536 }
2537 return(xmlXPathNewString(val));
2538 }
2539
2540 /**
2541 * xmlXPathCacheNewBoolean:
2542 * @ctxt: the XPath context
2543 * @val: the boolean value
2544 *
2545 * This is the cached version of xmlXPathNewBoolean().
2546 * Acquires an xmlXPathObjectPtr of type boolean and of value @val
2547 *
2548 * Returns the created or reused object.
2549 */
2550 static xmlXPathObjectPtr
2551 xmlXPathCacheNewBoolean(xmlXPathContextPtr ctxt, int val)
2552 {
2553 if ((ctxt != NULL) && (ctxt->cache)) {
2554 xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache;
2555
2556 if ((cache->booleanObjs != NULL) &&
2557 (cache->booleanObjs->number != 0))
2558 {
2559 xmlXPathObjectPtr ret;
2560
2561 ret = (xmlXPathObjectPtr)
2562 cache->booleanObjs->items[--cache->booleanObjs->number];
2563 ret->type = XPATH_BOOLEAN;
2564 ret->boolval = (val != 0);
2565 #ifdef XP_DEBUG_OBJ_USAGE
2566 xmlXPathDebugObjUsageRequested(ctxt, XPATH_BOOLEAN);
2567 #endif
2568 return(ret);
2569 } else if ((cache->miscObjs != NULL) &&
2570 (cache->miscObjs->number != 0))
2571 {
2572 xmlXPathObjectPtr ret;
2573
2574 ret = (xmlXPathObjectPtr)
2575 cache->miscObjs->items[--cache->miscObjs->number];
2576
2577 ret->type = XPATH_BOOLEAN;
2578 ret->boolval = (val != 0);
2579 #ifdef XP_DEBUG_OBJ_USAGE
2580 xmlXPathDebugObjUsageRequested(ctxt, XPATH_BOOLEAN);
2581 #endif
2582 return(ret);
2583 }
2584 }
2585 return(xmlXPathNewBoolean(val));
2586 }
2587
2588 /**
2589 * xmlXPathCacheNewFloat:
2590 * @ctxt: the XPath context
2591 * @val: the double value
2592 *
2593 * This is the cached version of xmlXPathNewFloat().
2594 * Acquires an xmlXPathObjectPtr of type double and of value @val
2595 *
2596 * Returns the created or reused object.
2597 */
2598 static xmlXPathObjectPtr
2599 xmlXPathCacheNewFloat(xmlXPathContextPtr ctxt, double val)
2600 {
2601 if ((ctxt != NULL) && (ctxt->cache)) {
2602 xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache;
2603
2604 if ((cache->numberObjs != NULL) &&
2605 (cache->numberObjs->number != 0))
2606 {
2607 xmlXPathObjectPtr ret;
2608
2609 ret = (xmlXPathObjectPtr)
2610 cache->numberObjs->items[--cache->numberObjs->number];
2611 ret->type = XPATH_NUMBER;
2612 ret->floatval = val;
2613 #ifdef XP_DEBUG_OBJ_USAGE
2614 xmlXPathDebugObjUsageRequested(ctxt, XPATH_NUMBER);
2615 #endif
2616 return(ret);
2617 } else if ((cache->miscObjs != NULL) &&
2618 (cache->miscObjs->number != 0))
2619 {
2620 xmlXPathObjectPtr ret;
2621
2622 ret = (xmlXPathObjectPtr)
2623 cache->miscObjs->items[--cache->miscObjs->number];
2624
2625 ret->type = XPATH_NUMBER;
2626 ret->floatval = val;
2627 #ifdef XP_DEBUG_OBJ_USAGE
2628 xmlXPathDebugObjUsageRequested(ctxt, XPATH_NUMBER);
2629 #endif
2630 return(ret);
2631 }
2632 }
2633 return(xmlXPathNewFloat(val));
2634 }
2635
2636 /**
2637 * xmlXPathCacheConvertString:
2638 * @ctxt: the XPath context
2639 * @val: an XPath object
2640 *
2641 * This is the cached version of xmlXPathConvertString().
2642 * Converts an existing object to its string() equivalent
2643 *
2644 * Returns a created or reused object, the old one is freed (cached)
2645 * (or the operation is done directly on @val)
2646 */
2647
2648 static xmlXPathObjectPtr
2649 xmlXPathCacheConvertString(xmlXPathContextPtr ctxt, xmlXPathObjectPtr val) {
2650 xmlChar *res = NULL;
2651
2652 if (val == NULL)
2653 return(xmlXPathCacheNewCString(ctxt, ""));
2654
2655 switch (val->type) {
2656 case XPATH_UNDEFINED:
2657 #ifdef DEBUG_EXPR
2658 xmlGenericError(xmlGenericErrorContext, "STRING: undefined\n");
2659 #endif
2660 break;
2661 case XPATH_NODESET:
2662 case XPATH_XSLT_TREE:
2663 res = xmlXPathCastNodeSetToString(val->nodesetval);
2664 break;
2665 case XPATH_STRING:
2666 return(val);
2667 case XPATH_BOOLEAN:
2668 res = xmlXPathCastBooleanToString(val->boolval);
2669 break;
2670 case XPATH_NUMBER:
2671 res = xmlXPathCastNumberToString(val->floatval);
2672 break;
2673 case XPATH_USERS:
2674 case XPATH_POINT:
2675 case XPATH_RANGE:
2676 case XPATH_LOCATIONSET:
2677 TODO;
2678 break;
2679 }
2680 xmlXPathReleaseObject(ctxt, val);
2681 if (res == NULL)
2682 return(xmlXPathCacheNewCString(ctxt, ""));
2683 return(xmlXPathCacheWrapString(ctxt, res));
2684 }
2685
2686 /**
2687 * xmlXPathCacheObjectCopy:
2688 * @ctxt: the XPath context
2689 * @val: the original object
2690 *
2691 * This is the cached version of xmlXPathObjectCopy().
2692 * Acquire a copy of a given object
2693 *
2694 * Returns a created or reused created object.
2695 */
2696 static xmlXPathObjectPtr
2697 xmlXPathCacheObjectCopy(xmlXPathContextPtr ctxt, xmlXPathObjectPtr val)
2698 {
2699 if (val == NULL)
2700 return(NULL);
2701
2702 if (XP_HAS_CACHE(ctxt)) {
2703 switch (val->type) {
2704 case XPATH_NODESET:
2705 return(xmlXPathCacheWrapNodeSet(ctxt,
2706 xmlXPathNodeSetMerge(NULL, val->nodesetval)));
2707 case XPATH_STRING:
2708 return(xmlXPathCacheNewString(ctxt, val->stringval));
2709 case XPATH_BOOLEAN:
2710 return(xmlXPathCacheNewBoolean(ctxt, val->boolval));
2711 case XPATH_NUMBER:
2712 return(xmlXPathCacheNewFloat(ctxt, val->floatval));
2713 default:
2714 break;
2715 }
2716 }
2717 return(xmlXPathObjectCopy(val));
2718 }
2719
2720 /**
2721 * xmlXPathCacheConvertBoolean:
2722 * @ctxt: the XPath context
2723 * @val: an XPath object
2724 *
2725 * This is the cached version of xmlXPathConvertBoolean().
2726 * Converts an existing object to its boolean() equivalent
2727 *
2728 * Returns a created or reused object, the old one is freed (or the operation
2729 * is done directly on @val)
2730 */
2731 static xmlXPathObjectPtr
2732 xmlXPathCacheConvertBoolean(xmlXPathContextPtr ctxt, xmlXPathObjectPtr val) {
2733 xmlXPathObjectPtr ret;
2734
2735 if (val == NULL)
2736 return(xmlXPathCacheNewBoolean(ctxt, 0));
2737 if (val->type == XPATH_BOOLEAN)
2738 return(val);
2739 ret = xmlXPathCacheNewBoolean(ctxt, xmlXPathCastToBoolean(val));
2740 xmlXPathReleaseObject(ctxt, val);
2741 return(ret);
2742 }
2743
2744 /**
2745 * xmlXPathCacheConvertNumber:
2746 * @ctxt: the XPath context
2747 * @val: an XPath object
2748 *
2749 * This is the cached version of xmlXPathConvertNumber().
2750 * Converts an existing object to its number() equivalent
2751 *
2752 * Returns a created or reused object, the old one is freed (or the operation
2753 * is done directly on @val)
2754 */
2755 static xmlXPathObjectPtr
2756 xmlXPathCacheConvertNumber(xmlXPathContextPtr ctxt, xmlXPathObjectPtr val) {
2757 xmlXPathObjectPtr ret;
2758
2759 if (val == NULL)
2760 return(xmlXPathCacheNewFloat(ctxt, 0.0));
2761 if (val->type == XPATH_NUMBER)
2762 return(val);
2763 ret = xmlXPathCacheNewFloat(ctxt, xmlXPathCastToNumber(val));
2764 xmlXPathReleaseObject(ctxt, val);
2765 return(ret);
2766 }
2767
2768 /************************************************************************
2769 * *
2770 * Parser stacks related functions and macros *
2771 * *
2772 ************************************************************************/
2773
2774 /**
2775 * xmlXPathSetFrame:
2776 * @ctxt: an XPath parser context
2777 *
2778 * Set the callee evaluation frame
2779 *
2780 * Returns the previous frame value to be restored once done
2781 */
2782 static int
2783 xmlXPathSetFrame(xmlXPathParserContextPtr ctxt) {
2784 int ret;
2785
2786 if (ctxt == NULL)
2787 return(0);
2788 ret = ctxt->valueFrame;
2789 ctxt->valueFrame = ctxt->valueNr;
2790 return(ret);
2791 }
2792
2793 /**
2794 * xmlXPathPopFrame:
2795 * @ctxt: an XPath parser context
2796 * @frame: the previous frame value
2797 *
2798 * Remove the callee evaluation frame
2799 */
2800 static void
2801 xmlXPathPopFrame(xmlXPathParserContextPtr ctxt, int frame) {
2802 if (ctxt == NULL)
2803 return;
2804 if (ctxt->valueNr < ctxt->valueFrame) {
2805 xmlXPatherror(ctxt, __FILE__, __LINE__, XPATH_STACK_ERROR);
2806 }
2807 ctxt->valueFrame = frame;
2808 }
2809
2810 /**
2811 * valuePop:
2812 * @ctxt: an XPath evaluation context
2813 *
2814 * Pops the top XPath object from the value stack
2815 *
2816 * Returns the XPath object just removed
2817 */
2818 xmlXPathObjectPtr
2819 valuePop(xmlXPathParserContextPtr ctxt)
2820 {
2821 xmlXPathObjectPtr ret;
2822
2823 if ((ctxt == NULL) || (ctxt->valueNr <= 0))
2824 return (NULL);
2825
2826 if (ctxt->valueNr <= ctxt->valueFrame) {
2827 xmlXPatherror(ctxt, __FILE__, __LINE__, XPATH_STACK_ERROR);
2828 return (NULL);
2829 }
2830
2831 ctxt->valueNr--;
2832 if (ctxt->valueNr > 0)
2833 ctxt->value = ctxt->valueTab[ctxt->valueNr - 1];
2834 else
2835 ctxt->value = NULL;
2836 ret = ctxt->valueTab[ctxt->valueNr];
2837 ctxt->valueTab[ctxt->valueNr] = NULL;
2838 return (ret);
2839 }
2840 /**
2841 * valuePush:
2842 * @ctxt: an XPath evaluation context
2843 * @value: the XPath object
2844 *
2845 * Pushes a new XPath object on top of the value stack
2846 *
2847 * returns the number of items on the value stack
2848 */
2849 int
2850 valuePush(xmlXPathParserContextPtr ctxt, xmlXPathObjectPtr value)
2851 {
2852 if ((ctxt == NULL) || (value == NULL)) return(-1);
2853 if (ctxt->valueNr >= ctxt->valueMax) {
2854 xmlXPathObjectPtr *tmp;
2855
2856 if (ctxt->valueMax >= XPATH_MAX_STACK_DEPTH) {
2857 xmlXPathErrMemory(NULL, "XPath stack depth limit reached\n");
2858 ctxt->error = XPATH_MEMORY_ERROR;
2859 return (0);
2860 }
2861 tmp = (xmlXPathObjectPtr *) xmlRealloc(ctxt->valueTab,
2862 2 * ctxt->valueMax *
2863 sizeof(ctxt->valueTab[0]));
2864 if (tmp == NULL) {
2865 xmlXPathErrMemory(NULL, "pushing value\n");
2866 ctxt->error = XPATH_MEMORY_ERROR;
2867 return (0);
2868 }
2869 ctxt->valueMax *= 2;
2870 ctxt->valueTab = tmp;
2871 }
2872 ctxt->valueTab[ctxt->valueNr] = value;
2873 ctxt->value = value;
2874 return (ctxt->valueNr++);
2875 }
2876
2877 /**
2878 * xmlXPathPopBoolean:
2879 * @ctxt: an XPath parser context
2880 *
2881 * Pops a boolean from the stack, handling conversion if needed.
2882 * Check error with #xmlXPathCheckError.
2883 *
2884 * Returns the boolean
2885 */
2886 int
2887 xmlXPathPopBoolean (xmlXPathParserContextPtr ctxt) {
2888 xmlXPathObjectPtr obj;
2889 int ret;
2890
2891 obj = valuePop(ctxt);
2892 if (obj == NULL) {
2893 xmlXPathSetError(ctxt, XPATH_INVALID_OPERAND);
2894 return(0);
2895 }
2896 if (obj->type != XPATH_BOOLEAN)
2897 ret = xmlXPathCastToBoolean(obj);
2898 else
2899 ret = obj->boolval;
2900 xmlXPathReleaseObject(ctxt->context, obj);
2901 return(ret);
2902 }
2903
2904 /**
2905 * xmlXPathPopNumber:
2906 * @ctxt: an XPath parser context
2907 *
2908 * Pops a number from the stack, handling conversion if needed.
2909 * Check error with #xmlXPathCheckError.
2910 *
2911 * Returns the number
2912 */
2913 double
2914 xmlXPathPopNumber (xmlXPathParserContextPtr ctxt) {
2915 xmlXPathObjectPtr obj;
2916 double ret;
2917
2918 obj = valuePop(ctxt);
2919 if (obj == NULL) {
2920 xmlXPathSetError(ctxt, XPATH_INVALID_OPERAND);
2921 return(0);
2922 }
2923 if (obj->type != XPATH_NUMBER)
2924 ret = xmlXPathCastToNumber(obj);
2925 else
2926 ret = obj->floatval;
2927 xmlXPathReleaseObject(ctxt->context, obj);
2928 return(ret);
2929 }
2930
2931 /**
2932 * xmlXPathPopString:
2933 * @ctxt: an XPath parser context
2934 *
2935 * Pops a string from the stack, handling conversion if needed.
2936 * Check error with #xmlXPathCheckError.
2937 *
2938 * Returns the string
2939 */
2940 xmlChar *
2941 xmlXPathPopString (xmlXPathParserContextPtr ctxt) {
2942 xmlXPathObjectPtr obj;
2943 xmlChar * ret;
2944
2945 obj = valuePop(ctxt);
2946 if (obj == NULL) {
2947 xmlXPathSetError(ctxt, XPATH_INVALID_OPERAND);
2948 return(NULL);
2949 }
2950 ret = xmlXPathCastToString(obj); /* this does required strdup */
2951 /* TODO: needs refactoring somewhere else */
2952 if (obj->stringval == ret)
2953 obj->stringval = NULL;
2954 xmlXPathReleaseObject(ctxt->context, obj);
2955 return(ret);
2956 }
2957
2958 /**
2959 * xmlXPathPopNodeSet:
2960 * @ctxt: an XPath parser context
2961 *
2962 * Pops a node-set from the stack, handling conversion if needed.
2963 * Check error with #xmlXPathCheckError.
2964 *
2965 * Returns the node-set
2966 */
2967 xmlNodeSetPtr
2968 xmlXPathPopNodeSet (xmlXPathParserContextPtr ctxt) {
2969 xmlXPathObjectPtr obj;
2970 xmlNodeSetPtr ret;
2971
2972 if (ctxt == NULL) return(NULL);
2973 if (ctxt->value == NULL) {
2974 xmlXPathSetError(ctxt, XPATH_INVALID_OPERAND);
2975 return(NULL);
2976 }
2977 if (!xmlXPathStackIsNodeSet(ctxt)) {
2978 xmlXPathSetTypeError(ctxt);
2979 return(NULL);
2980 }
2981 obj = valuePop(ctxt);
2982 ret = obj->nodesetval;
2983 #if 0
2984 /* to fix memory leak of not clearing obj->user */
2985 if (obj->boolval && obj->user != NULL)
2986 xmlFreeNodeList((xmlNodePtr) obj->user);
2987 #endif
2988 obj->nodesetval = NULL;
2989 xmlXPathReleaseObject(ctxt->context, obj);
2990 return(ret);
2991 }
2992
2993 /**
2994 * xmlXPathPopExternal:
2995 * @ctxt: an XPath parser context
2996 *
2997 * Pops an external object from the stack, handling conversion if needed.
2998 * Check error with #xmlXPathCheckError.
2999 *
3000 * Returns the object
3001 */
3002 void *
3003 xmlXPathPopExternal (xmlXPathParserContextPtr ctxt) {
3004 xmlXPathObjectPtr obj;
3005 void * ret;
3006
3007 if ((ctxt == NULL) || (ctxt->value == NULL)) {
3008 xmlXPathSetError(ctxt, XPATH_INVALID_OPERAND);
3009 return(NULL);
3010 }
3011 if (ctxt->value->type != XPATH_USERS) {
3012 xmlXPathSetTypeError(ctxt);
3013 return(NULL);
3014 }
3015 obj = valuePop(ctxt);
3016 ret = obj->user;
3017 obj->user = NULL;
3018 xmlXPathReleaseObject(ctxt->context, obj);
3019 return(ret);
3020 }
3021
3022 /*
3023 * Macros for accessing the content. Those should be used only by the parser,
3024 * and not exported.
3025 *
3026 * Dirty macros, i.e. one need to make assumption on the context to use them
3027 *
3028 * CUR_PTR return the current pointer to the xmlChar to be parsed.
3029 * CUR returns the current xmlChar value, i.e. a 8 bit value
3030 * in ISO-Latin or UTF-8.
3031 * This should be used internally by the parser
3032 * only to compare to ASCII values otherwise it would break when
3033 * running with UTF-8 encoding.
3034 * NXT(n) returns the n'th next xmlChar. Same as CUR is should be used only
3035 * to compare on ASCII based substring.
3036 * SKIP(n) Skip n xmlChar, and must also be used only to skip ASCII defined
3037 * strings within the parser.
3038 * CURRENT Returns the current char value, with the full decoding of
3039 * UTF-8 if we are using this mode. It returns an int.
3040 * NEXT Skip to the next character, this does the proper decoding
3041 * in UTF-8 mode. It also pop-up unfinished entities on the fly.
3042 * It returns the pointer to the current xmlChar.
3043 */
3044
3045 #define CUR (*ctxt->cur)
3046 #define SKIP(val) ctxt->cur += (val)
3047 #define NXT(val) ctxt->cur[(val)]
3048 #define CUR_PTR ctxt->cur
3049 #define CUR_CHAR(l) xmlXPathCurrentChar(ctxt, &l)
3050
3051 #define COPY_BUF(l,b,i,v) \
3052 if (l == 1) b[i++] = (xmlChar) v; \
3053 else i += xmlCopyChar(l,&b[i],v)
3054
3055 #define NEXTL(l) ctxt->cur += l
3056
3057 #define SKIP_BLANKS \
3058 while (IS_BLANK_CH(*(ctxt->cur))) NEXT
3059
3060 #define CURRENT (*ctxt->cur)
3061 #define NEXT ((*ctxt->cur) ? ctxt->cur++: ctxt->cur)
3062
3063
3064 #ifndef DBL_DIG
3065 #define DBL_DIG 16
3066 #endif
3067 #ifndef DBL_EPSILON
3068 #define DBL_EPSILON 1E-9
3069 #endif
3070
3071 #define UPPER_DOUBLE 1E9
3072 #define LOWER_DOUBLE 1E-5
3073 #define LOWER_DOUBLE_EXP 5
3074
3075 #define INTEGER_DIGITS DBL_DIG
3076 #define FRACTION_DIGITS (DBL_DIG + 1 + (LOWER_DOUBLE_EXP))
3077 #define EXPONENT_DIGITS (3 + 2)
3078
3079 /**
3080 * xmlXPathFormatNumber:
3081 * @number: number to format
3082 * @buffer: output buffer
3083 * @buffersize: size of output buffer
3084 *
3085 * Convert the number into a string representation.
3086 */
3087 static void
3088 xmlXPathFormatNumber(double number, char buffer[], int buffersize)
3089 {
3090 switch (xmlXPathIsInf(number)) {
3091 case 1:
3092 if (buffersize > (int)sizeof("Infinity"))
3093 snprintf(buffer, buffersize, "Infinity");
3094 break;
3095 case -1:
3096 if (buffersize > (int)sizeof("-Infinity"))
3097 snprintf(buffer, buffersize, "-Infinity");
3098 break;
3099 default:
3100 if (xmlXPathIsNaN(number)) {
3101 if (buffersize > (int)sizeof("NaN"))
3102 snprintf(buffer, buffersize, "NaN");
3103 } else if (number == 0) {
3104 /* Omit sign for negative zero. */
3105 snprintf(buffer, buffersize, "0");
3106 } else if ((number > INT_MIN) && (number < INT_MAX) &&
3107 (number == (int) number)) {
3108 char work[30];
3109 char *ptr, *cur;
3110 int value = (int) number;
3111
3112 ptr = &buffer[0];
3113 if (value == 0) {
3114 *ptr++ = '0';
3115 } else {
3116 snprintf(work, 29, "%d", value);
3117 cur = &work[0];
3118 while ((*cur) && (ptr - buffer < buffersize)) {
3119 *ptr++ = *cur++;
3120 }
3121 }
3122 if (ptr - buffer < buffersize) {
3123 *ptr = 0;
3124 } else if (buffersize > 0) {
3125 ptr--;
3126 *ptr = 0;
3127 }
3128 } else {
3129 /*
3130 For the dimension of work,
3131 DBL_DIG is number of significant digits
3132 EXPONENT is only needed for "scientific notation"
3133 3 is sign, decimal point, and terminating zero
3134 LOWER_DOUBLE_EXP is max number of leading zeroes in fraction
3135 Note that this dimension is slightly (a few characters)
3136 larger than actually necessary.
3137 */
3138 char work[DBL_DIG + EXPONENT_DIGITS + 3 + LOWER_DOUBLE_EXP];
3139 int integer_place, fraction_place;
3140 char *ptr;
3141 char *after_fraction;
3142 double absolute_value;
3143 int size;
3144
3145 absolute_value = fabs(number);
3146
3147 /*
3148 * First choose format - scientific or regular floating point.
3149 * In either case, result is in work, and after_fraction points
3150 * just past the fractional part.
3151 */
3152 if ( ((absolute_value > UPPER_DOUBLE) ||
3153 (absolute_value < LOWER_DOUBLE)) &&
3154 (absolute_value != 0.0) ) {
3155 /* Use scientific notation */
3156 integer_place = DBL_DIG + EXPONENT_DIGITS + 1;
3157 fraction_place = DBL_DIG - 1;
3158 size = snprintf(work, sizeof(work),"%*.*e",
3159 integer_place, fraction_place, number);
3160 while ((size > 0) && (work[size] != 'e')) size--;
3161
3162 }
3163 else {
3164 /* Use regular notation */
3165 if (absolute_value > 0.0) {
3166 integer_place = (int)log10(absolute_value);
3167 if (integer_place > 0)
3168 fraction_place = DBL_DIG - integer_place - 1;
3169 else
3170 fraction_place = DBL_DIG - integer_place;
3171 } else {
3172 fraction_place = 1;
3173 }
3174 size = snprintf(work, sizeof(work), "%0.*f",
3175 fraction_place, number);
3176 }
3177
3178 /* Remove leading spaces sometimes inserted by snprintf */
3179 while (work[0] == ' ') {
3180 for (ptr = &work[0];(ptr[0] = ptr[1]);ptr++);
3181 size--;
3182 }
3183
3184 /* Remove fractional trailing zeroes */
3185 after_fraction = work + size;
3186 ptr = after_fraction;
3187 while (*(--ptr) == '0')
3188 ;
3189 if (*ptr != '.')
3190 ptr++;
3191 while ((*ptr++ = *after_fraction++) != 0);
3192
3193 /* Finally copy result back to caller */
3194 size = strlen(work) + 1;
3195 if (size > buffersize) {
3196 work[buffersize - 1] = 0;
3197 size = buffersize;
3198 }
3199 memmove(buffer, work, size);
3200 }
3201 break;
3202 }
3203 }
3204
3205
3206 /************************************************************************
3207 * *
3208 * Routines to handle NodeSets *
3209 * *
3210 ************************************************************************/
3211
3212 /**
3213 * xmlXPathOrderDocElems:
3214 * @doc: an input document
3215 *
3216 * Call this routine to speed up XPath computation on static documents.
3217 * This stamps all the element nodes with the document order
3218 * Like for line information, the order is kept in the element->content
3219 * field, the value stored is actually - the node number (starting at -1)
3220 * to be able to differentiate from line numbers.
3221 *
3222 * Returns the number of elements found in the document or -1 in case
3223 * of error.
3224 */
3225 long
3226 xmlXPathOrderDocElems(xmlDocPtr doc) {
3227 ptrdiff_t count = 0;
3228 xmlNodePtr cur;
3229
3230 if (doc == NULL)
3231 return(-1);
3232 cur = doc->children;
3233 while (cur != NULL) {
3234 if (cur->type == XML_ELEMENT_NODE) {
3235 cur->content = (void *) (-(++count));
3236 if (cur->children != NULL) {
3237 cur = cur->children;
3238 continue;
3239 }
3240 }
3241 if (cur->next != NULL) {
3242 cur = cur->next;
3243 continue;
3244 }
3245 do {
3246 cur = cur->parent;
3247 if (cur == NULL)
3248 break;
3249 if (cur == (xmlNodePtr) doc) {
3250 cur = NULL;
3251 break;
3252 }
3253 if (cur->next != NULL) {
3254 cur = cur->next;
3255 break;
3256 }
3257 } while (cur != NULL);
3258 }
3259 return((long) count);
3260 }
3261
3262 /**
3263 * xmlXPathCmpNodes:
3264 * @node1: the first node
3265 * @node2: the second node
3266 *
3267 * Compare two nodes w.r.t document order
3268 *
3269 * Returns -2 in case of error 1 if first point < second point, 0 if
3270 * it's the same node, -1 otherwise
3271 */
3272 int
3273 xmlXPathCmpNodes(xmlNodePtr node1, xmlNodePtr node2) {
3274 int depth1, depth2;
3275 int attr1 = 0, attr2 = 0;
3276 xmlNodePtr attrNode1 = NULL, attrNode2 = NULL;
3277 xmlNodePtr cur, root;
3278
3279 if ((node1 == NULL) || (node2 == NULL))
3280 return(-2);
3281 /*
3282 * a couple of optimizations which will avoid computations in most cases
3283 */
3284 if (node1 == node2) /* trivial case */
3285 return(0);
3286 if (node1->type == XML_ATTRIBUTE_NODE) {
3287 attr1 = 1;
3288 attrNode1 = node1;
3289 node1 = node1->parent;
3290 }
3291 if (node2->type == XML_ATTRIBUTE_NODE) {
3292 attr2 = 1;
3293 attrNode2 = node2;
3294 node2 = node2->parent;
3295 }
3296 if (node1 == node2) {
3297 if (attr1 == attr2) {
3298 /* not required, but we keep attributes in order */
3299 if (attr1 != 0) {
3300 cur = attrNode2->prev;
3301 while (cur != NULL) {
3302 if (cur == attrNode1)
3303 return (1);
3304 cur = cur->prev;
3305 }
3306 return (-1);
3307 }
3308 return(0);
3309 }
3310 if (attr2 == 1)
3311 return(1);
3312 return(-1);
3313 }
3314 if ((node1->type == XML_NAMESPACE_DECL) ||
3315 (node2->type == XML_NAMESPACE_DECL))
3316 return(1);
3317 if (node1 == node2->prev)
3318 return(1);
3319 if (node1 == node2->next)
3320 return(-1);
3321
3322 /*
3323 * Speedup using document order if availble.
3324 */
3325 if ((node1->type == XML_ELEMENT_NODE) &&
3326 (node2->type == XML_ELEMENT_NODE) &&
3327 (0 > (ptrdiff_t) node1->content) &&
3328 (0 > (ptrdiff_t) node2->content) &&
3329 (node1->doc == node2->doc)) {
3330 ptrdiff_t l1, l2;
3331
3332 l1 = -((ptrdiff_t) node1->content);
3333 l2 = -((ptrdiff_t) node2->content);
3334 if (l1 < l2)
3335 return(1);
3336 if (l1 > l2)
3337 return(-1);
3338 }
3339
3340 /*
3341 * compute depth to root
3342 */
3343 for (depth2 = 0, cur = node2;cur->parent != NULL;cur = cur->parent) {
3344 if (cur->parent == node1)
3345 return(1);
3346 depth2++;
3347 }
3348 root = cur;
3349 for (depth1 = 0, cur = node1;cur->parent != NULL;cur = cur->parent) {
3350 if (cur->parent == node2)
3351 return(-1);
3352 depth1++;
3353 }
3354 /*
3355 * Distinct document (or distinct entities :-( ) case.
3356 */
3357 if (root != cur) {
3358 return(-2);
3359 }
3360 /*
3361 * get the nearest common ancestor.
3362 */
3363 while (depth1 > depth2) {
3364 depth1--;
3365 node1 = node1->parent;
3366 }
3367 while (depth2 > depth1) {
3368 depth2--;
3369 node2 = node2->parent;
3370 }
3371 while (node1->parent != node2->parent) {
3372 node1 = node1->parent;
3373 node2 = node2->parent;
3374 /* should not happen but just in case ... */
3375 if ((node1 == NULL) || (node2 == NULL))
3376 return(-2);
3377 }
3378 /*
3379 * Find who's first.
3380 */
3381 if (node1 == node2->prev)
3382 return(1);
3383 if (node1 == node2->next)
3384 return(-1);
3385 /*
3386 * Speedup using document order if availble.
3387 */
3388 if ((node1->type == XML_ELEMENT_NODE) &&
3389 (node2->type == XML_ELEMENT_NODE) &&
3390 (0 > (ptrdiff_t) node1->content) &&
3391 (0 > (ptrdiff_t) node2->content) &&
3392 (node1->doc == node2->doc)) {
3393 ptrdiff_t l1, l2;
3394
3395 l1 = -((ptrdiff_t) node1->content);
3396 l2 = -((ptrdiff_t) node2->content);
3397 if (l1 < l2)
3398 return(1);
3399 if (l1 > l2)
3400 return(-1);
3401 }
3402
3403 for (cur = node1->next;cur != NULL;cur = cur->next)
3404 if (cur == node2)
3405 return(1);
3406 return(-1); /* assume there is no sibling list corruption */
3407 }
3408
3409 /**
3410 * xmlXPathNodeSetSort:
3411 * @set: the node set
3412 *
3413 * Sort the node set in document order
3414 */
3415 void
3416 xmlXPathNodeSetSort(xmlNodeSetPtr set) {
3417 #ifndef WITH_TIM_SORT
3418 int i, j, incr, len;
3419 xmlNodePtr tmp;
3420 #endif
3421
3422 if (set == NULL)
3423 return;
3424
3425 #ifndef WITH_TIM_SORT
3426 /*
3427 * Use the old Shell's sort implementation to sort the node-set
3428 * Timsort ought to be quite faster
3429 */
3430 len = set->nodeNr;
3431 for (incr = len / 2; incr > 0; incr /= 2) {
3432 for (i = incr; i < len; i++) {
3433 j = i - incr;
3434 while (j >= 0) {
3435 #ifdef XP_OPTIMIZED_NON_ELEM_COMPARISON
3436 if (xmlXPathCmpNodesExt(set->nodeTab[j],
3437 set->nodeTab[j + incr]) == -1)
3438 #else
3439 if (xmlXPathCmpNodes(set->nodeTab[j],
3440 set->nodeTab[j + incr]) == -1)
3441 #endif
3442 {
3443 tmp = set->nodeTab[j];
3444 set->nodeTab[j] = set->nodeTab[j + incr];
3445 set->nodeTab[j + incr] = tmp;
3446 j -= incr;
3447 } else
3448 break;
3449 }
3450 }
3451 }
3452 #else /* WITH_TIM_SORT */
3453 libxml_domnode_tim_sort(set->nodeTab, set->nodeNr);
3454 #endif /* WITH_TIM_SORT */
3455 }
3456
3457 #define XML_NODESET_DEFAULT 10
3458 /**
3459 * xmlXPathNodeSetDupNs:
3460 * @node: the parent node of the namespace XPath node
3461 * @ns: the libxml namespace declaration node.
3462 *
3463 * Namespace node in libxml don't match the XPath semantic. In a node set
3464 * the namespace nodes are duplicated and the next pointer is set to the
3465 * parent node in the XPath semantic.
3466 *
3467 * Returns the newly created object.
3468 */
3469 static xmlNodePtr
3470 xmlXPathNodeSetDupNs(xmlNodePtr node, xmlNsPtr ns) {
3471 xmlNsPtr cur;
3472
3473 if ((ns == NULL) || (ns->type != XML_NAMESPACE_DECL))
3474 return(NULL);
3475 if ((node == NULL) || (node->type == XML_NAMESPACE_DECL))
3476 return((xmlNodePtr) ns);
3477
3478 /*
3479 * Allocate a new Namespace and fill the fields.
3480 */
3481 cur = (xmlNsPtr) xmlMalloc(sizeof(xmlNs));
3482 if (cur == NULL) {
3483 xmlXPathErrMemory(NULL, "duplicating namespace\n");
3484 return(NULL);
3485 }
3486 memset(cur, 0, sizeof(xmlNs));
3487 cur->type = XML_NAMESPACE_DECL;
3488 if (ns->href != NULL)
3489 cur->href = xmlStrdup(ns->href);
3490 if (ns->prefix != NULL)
3491 cur->prefix = xmlStrdup(ns->prefix);
3492 cur->next = (xmlNsPtr) node;
3493 return((xmlNodePtr) cur);
3494 }
3495
3496 /**
3497 * xmlXPathNodeSetFreeNs:
3498 * @ns: the XPath namespace node found in a nodeset.
3499 *
3500 * Namespace nodes in libxml don't match the XPath semantic. In a node set
3501 * the namespace nodes are duplicated and the next pointer is set to the
3502 * parent node in the XPath semantic. Check if such a node needs to be freed
3503 */
3504 void
3505 xmlXPathNodeSetFreeNs(xmlNsPtr ns) {
3506 if ((ns == NULL) || (ns->type != XML_NAMESPACE_DECL))
3507 return;
3508
3509 if ((ns->next != NULL) && (ns->next->type != XML_NAMESPACE_DECL)) {
3510 if (ns->href != NULL)
3511 xmlFree((xmlChar *)ns->href);
3512 if (ns->prefix != NULL)
3513 xmlFree((xmlChar *)ns->prefix);
3514 xmlFree(ns);
3515 }
3516 }
3517
3518 /**
3519 * xmlXPathNodeSetCreate:
3520 * @val: an initial xmlNodePtr, or NULL
3521 *
3522 * Create a new xmlNodeSetPtr of type double and of value @val
3523 *
3524 * Returns the newly created object.
3525 */
3526 xmlNodeSetPtr
3527 xmlXPathNodeSetCreate(xmlNodePtr val) {
3528 xmlNodeSetPtr ret;
3529
3530 ret = (xmlNodeSetPtr) xmlMalloc(sizeof(xmlNodeSet));
3531 if (ret == NULL) {
3532 xmlXPathErrMemory(NULL, "creating nodeset\n");
3533 return(NULL);
3534 }
3535 memset(ret, 0 , (size_t) sizeof(xmlNodeSet));
3536 if (val != NULL) {
3537 ret->nodeTab = (xmlNodePtr *) xmlMalloc(XML_NODESET_DEFAULT *
3538 sizeof(xmlNodePtr));
3539 if (ret->nodeTab == NULL) {
3540 xmlXPathErrMemory(NULL, "creating nodeset\n");
3541 xmlFree(ret);
3542 return(NULL);
3543 }
3544 memset(ret->nodeTab, 0 ,
3545 XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
3546 ret->nodeMax = XML_NODESET_DEFAULT;
3547 if (val->type == XML_NAMESPACE_DECL) {
3548 xmlNsPtr ns = (xmlNsPtr) val;
3549
3550 ret->nodeTab[ret->nodeNr++] =
3551 xmlXPathNodeSetDupNs((xmlNodePtr) ns->next, ns);
3552 } else
3553 ret->nodeTab[ret->nodeNr++] = val;
3554 }
3555 return(ret);
3556 }
3557
3558 /**
3559 * xmlXPathNodeSetCreateSize:
3560 * @size: the initial size of the set
3561 *
3562 * Create a new xmlNodeSetPtr of type double and of value @val
3563 *
3564 * Returns the newly created object.
3565 */
3566 static xmlNodeSetPtr
3567 xmlXPathNodeSetCreateSize(int size) {
3568 xmlNodeSetPtr ret;
3569
3570 ret = (xmlNodeSetPtr) xmlMalloc(sizeof(xmlNodeSet));
3571 if (ret == NULL) {
3572 xmlXPathErrMemory(NULL, "creating nodeset\n");
3573 return(NULL);
3574 }
3575 memset(ret, 0 , (size_t) sizeof(xmlNodeSet));
3576 if (size < XML_NODESET_DEFAULT)
3577 size = XML_NODESET_DEFAULT;
3578 ret->nodeTab = (xmlNodePtr *) xmlMalloc(size * sizeof(xmlNodePtr));
3579 if (ret->nodeTab == NULL) {
3580 xmlXPathErrMemory(NULL, "creating nodeset\n");
3581 xmlFree(ret);
3582 return(NULL);
3583 }
3584 memset(ret->nodeTab, 0 , size * (size_t) sizeof(xmlNodePtr));
3585 ret->nodeMax = size;
3586 return(ret);
3587 }
3588
3589 /**
3590 * xmlXPathNodeSetContains:
3591 * @cur: the node-set
3592 * @val: the node
3593 *
3594 * checks whether @cur contains @val
3595 *
3596 * Returns true (1) if @cur contains @val, false (0) otherwise
3597 */
3598 int
3599 xmlXPathNodeSetContains (xmlNodeSetPtr cur, xmlNodePtr val) {
3600 int i;
3601
3602 if ((cur == NULL) || (val == NULL)) return(0);
3603 if (val->type == XML_NAMESPACE_DECL) {
3604 for (i = 0; i < cur->nodeNr; i++) {
3605 if (cur->nodeTab[i]->type == XML_NAMESPACE_DECL) {
3606 xmlNsPtr ns1, ns2;
3607
3608 ns1 = (xmlNsPtr) val;
3609 ns2 = (xmlNsPtr) cur->nodeTab[i];
3610 if (ns1 == ns2)
3611 return(1);
3612 if ((ns1->next != NULL) && (ns2->next == ns1->next) &&
3613 (xmlStrEqual(ns1->prefix, ns2->prefix)))
3614 return(1);
3615 }
3616 }
3617 } else {
3618 for (i = 0; i < cur->nodeNr; i++) {
3619 if (cur->nodeTab[i] == val)
3620 return(1);
3621 }
3622 }
3623 return(0);
3624 }
3625
3626 /**
3627 * xmlXPathNodeSetAddNs:
3628 * @cur: the initial node set
3629 * @node: the hosting node
3630 * @ns: a the namespace node
3631 *
3632 * add a new namespace node to an existing NodeSet
3633 *
3634 * Returns 0 in case of success and -1 in case of error
3635 */
3636 int
3637 xmlXPathNodeSetAddNs(xmlNodeSetPtr cur, xmlNodePtr node, xmlNsPtr ns) {
3638 int i;
3639
3640
3641 if ((cur == NULL) || (ns == NULL) || (node == NULL) ||
3642 (ns->type != XML_NAMESPACE_DECL) ||
3643 (node->type != XML_ELEMENT_NODE))
3644 return(-1);
3645
3646 /* @@ with_ns to check whether namespace nodes should be looked at @@ */
3647 /*
3648 * prevent duplicates
3649 */
3650 for (i = 0;i < cur->nodeNr;i++) {
3651 if ((cur->nodeTab[i] != NULL) &&
3652 (cur->nodeTab[i]->type == XML_NAMESPACE_DECL) &&
3653 (((xmlNsPtr)cur->nodeTab[i])->next == (xmlNsPtr) node) &&
3654 (xmlStrEqual(ns->prefix, ((xmlNsPtr)cur->nodeTab[i])->prefix)))
3655 return(0);
3656 }
3657
3658 /*
3659 * grow the nodeTab if needed
3660 */
3661 if (cur->nodeMax == 0) {
3662 cur->nodeTab = (xmlNodePtr *) xmlMalloc(XML_NODESET_DEFAULT *
3663 sizeof(xmlNodePtr));
3664 if (cur->nodeTab == NULL) {
3665 xmlXPathErrMemory(NULL, "growing nodeset\n");
3666 return(-1);
3667 }
3668 memset(cur->nodeTab, 0 ,
3669 XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
3670 cur->nodeMax = XML_NODESET_DEFAULT;
3671 } else if (cur->nodeNr == cur->nodeMax) {
3672 xmlNodePtr *temp;
3673
3674 if (cur->nodeMax >= XPATH_MAX_NODESET_LENGTH) {
3675 xmlXPathErrMemory(NULL, "growing nodeset hit limit\n");
3676 return(-1);
3677 }
3678 temp = (xmlNodePtr *) xmlRealloc(cur->nodeTab, cur->nodeMax * 2 *
3679 sizeof(xmlNodePtr));
3680 if (temp == NULL) {
3681 xmlXPathErrMemory(NULL, "growing nodeset\n");
3682 return(-1);
3683 }
3684 cur->nodeMax *= 2;
3685 cur->nodeTab = temp;
3686 }
3687 cur->nodeTab[cur->nodeNr++] = xmlXPathNodeSetDupNs(node, ns);
3688 return(0);
3689 }
3690
3691 /**
3692 * xmlXPathNodeSetAdd:
3693 * @cur: the initial node set
3694 * @val: a new xmlNodePtr
3695 *
3696 * add a new xmlNodePtr to an existing NodeSet
3697 *
3698 * Returns 0 in case of success, and -1 in case of error
3699 */
3700 int
3701 xmlXPathNodeSetAdd(xmlNodeSetPtr cur, xmlNodePtr val) {
3702 int i;
3703
3704 if ((cur == NULL) || (val == NULL)) return(-1);
3705
3706 /* @@ with_ns to check whether namespace nodes should be looked at @@ */
3707 /*
3708 * prevent duplicates
3709 */
3710 for (i = 0;i < cur->nodeNr;i++)
3711 if (cur->nodeTab[i] == val) return(0);
3712
3713 /*
3714 * grow the nodeTab if needed
3715 */
3716 if (cur->nodeMax == 0) {
3717 cur->nodeTab = (xmlNodePtr *) xmlMalloc(XML_NODESET_DEFAULT *
3718 sizeof(xmlNodePtr));
3719 if (cur->nodeTab == NULL) {
3720 xmlXPathErrMemory(NULL, "growing nodeset\n");
3721 return(-1);
3722 }
3723 memset(cur->nodeTab, 0 ,
3724 XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
3725 cur->nodeMax = XML_NODESET_DEFAULT;
3726 } else if (cur->nodeNr == cur->nodeMax) {
3727 xmlNodePtr *temp;
3728
3729 if (cur->nodeMax >= XPATH_MAX_NODESET_LENGTH) {
3730 xmlXPathErrMemory(NULL, "growing nodeset hit limit\n");
3731 return(-1);
3732 }
3733 temp = (xmlNodePtr *) xmlRealloc(cur->nodeTab, cur->nodeMax * 2 *
3734 sizeof(xmlNodePtr));
3735 if (temp == NULL) {
3736 xmlXPathErrMemory(NULL, "growing nodeset\n");
3737 return(-1);
3738 }
3739 cur->nodeMax *= 2;
3740 cur->nodeTab = temp;
3741 }
3742 if (val->type == XML_NAMESPACE_DECL) {
3743 xmlNsPtr ns = (xmlNsPtr) val;
3744
3745 cur->nodeTab[cur->nodeNr++] =
3746 xmlXPathNodeSetDupNs((xmlNodePtr) ns->next, ns);
3747 } else
3748 cur->nodeTab[cur->nodeNr++] = val;
3749 return(0);
3750 }
3751
3752 /**
3753 * xmlXPathNodeSetAddUnique:
3754 * @cur: the initial node set
3755 * @val: a new xmlNodePtr
3756 *
3757 * add a new xmlNodePtr to an existing NodeSet, optimized version
3758 * when we are sure the node is not already in the set.
3759 *
3760 * Returns 0 in case of success and -1 in case of failure
3761 */
3762 int
3763 xmlXPathNodeSetAddUnique(xmlNodeSetPtr cur, xmlNodePtr val) {
3764 if ((cur == NULL) || (val == NULL)) return(-1);
3765
3766 /* @@ with_ns to check whether namespace nodes should be looked at @@ */
3767 /*
3768 * grow the nodeTab if needed
3769 */
3770 if (cur->nodeMax == 0) {
3771 cur->nodeTab = (xmlNodePtr *) xmlMalloc(XML_NODESET_DEFAULT *
3772 sizeof(xmlNodePtr));
3773 if (cur->nodeTab == NULL) {
3774 xmlXPathErrMemory(NULL, "growing nodeset\n");
3775 return(-1);
3776 }
3777 memset(cur->nodeTab, 0 ,
3778 XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
3779 cur->nodeMax = XML_NODESET_DEFAULT;
3780 } else if (cur->nodeNr == cur->nodeMax) {
3781 xmlNodePtr *temp;
3782
3783 if (cur->nodeMax >= XPATH_MAX_NODESET_LENGTH) {
3784 xmlXPathErrMemory(NULL, "growing nodeset hit limit\n");
3785 return(-1);
3786 }
3787 temp = (xmlNodePtr *) xmlRealloc(cur->nodeTab, cur->nodeMax * 2 *
3788 sizeof(xmlNodePtr));
3789 if (temp == NULL) {
3790 xmlXPathErrMemory(NULL, "growing nodeset\n");
3791 return(-1);
3792 }
3793 cur->nodeTab = temp;
3794 cur->nodeMax *= 2;
3795 }
3796 if (val->type == XML_NAMESPACE_DECL) {
3797 xmlNsPtr ns = (xmlNsPtr) val;
3798
3799 cur->nodeTab[cur->nodeNr++] =
3800 xmlXPathNodeSetDupNs((xmlNodePtr) ns->next, ns);
3801 } else
3802 cur->nodeTab[cur->nodeNr++] = val;
3803 return(0);
3804 }
3805
3806 /**
3807 * xmlXPathNodeSetMerge:
3808 * @val1: the first NodeSet or NULL
3809 * @val2: the second NodeSet
3810 *
3811 * Merges two nodesets, all nodes from @val2 are added to @val1
3812 * if @val1 is NULL, a new set is created and copied from @val2
3813 *
3814 * Returns @val1 once extended or NULL in case of error.
3815 */
3816 xmlNodeSetPtr
3817 xmlXPathNodeSetMerge(xmlNodeSetPtr val1, xmlNodeSetPtr val2) {
3818 int i, j, initNr, skip;
3819 xmlNodePtr n1, n2;
3820
3821 if (val2 == NULL) return(val1);
3822 if (val1 == NULL) {
3823 val1 = xmlXPathNodeSetCreate(NULL);
3824 if (val1 == NULL)
3825 return (NULL);
3826 #if 0
3827 /*
3828 * TODO: The optimization won't work in every case, since
3829 * those nasty namespace nodes need to be added with
3830 * xmlXPathNodeSetDupNs() to the set; thus a pure
3831 * memcpy is not possible.
3832 * If there was a flag on the nodesetval, indicating that
3833 * some temporary nodes are in, that would be helpfull.
3834 */
3835 /*
3836 * Optimization: Create an equally sized node-set
3837 * and memcpy the content.
3838 */
3839 val1 = xmlXPathNodeSetCreateSize(val2->nodeNr);
3840 if (val1 == NULL)
3841 return(NULL);
3842 if (val2->nodeNr != 0) {
3843 if (val2->nodeNr == 1)
3844 *(val1->nodeTab) = *(val2->nodeTab);
3845 else {
3846 memcpy(val1->nodeTab, val2->nodeTab,
3847 val2->nodeNr * sizeof(xmlNodePtr));
3848 }
3849 val1->nodeNr = val2->nodeNr;
3850 }
3851 return(val1);
3852 #endif
3853 }
3854
3855 /* @@ with_ns to check whether namespace nodes should be looked at @@ */
3856 initNr = val1->nodeNr;
3857
3858 for (i = 0;i < val2->nodeNr;i++) {
3859 n2 = val2->nodeTab[i];
3860 /*
3861 * check against duplicates
3862 */
3863 skip = 0;
3864 for (j = 0; j < initNr; j++) {
3865 n1 = val1->nodeTab[j];
3866 if (n1 == n2) {
3867 skip = 1;
3868 break;
3869 } else if ((n1->type == XML_NAMESPACE_DECL) &&
3870 (n2->type == XML_NAMESPACE_DECL)) {
3871 if ((((xmlNsPtr) n1)->next == ((xmlNsPtr) n2)->next) &&
3872 (xmlStrEqual(((xmlNsPtr) n1)->prefix,
3873 ((xmlNsPtr) n2)->prefix)))
3874 {
3875 skip = 1;
3876 break;
3877 }
3878 }
3879 }
3880 if (skip)
3881 continue;
3882
3883 /*
3884 * grow the nodeTab if needed
3885 */
3886 if (val1->nodeMax == 0) {
3887 val1->nodeTab = (xmlNodePtr *) xmlMalloc(XML_NODESET_DEFAULT *
3888 sizeof(xmlNodePtr));
3889 if (val1->nodeTab == NULL) {
3890 xmlXPathErrMemory(NULL, "merging nodeset\n");
3891 return(NULL);
3892 }
3893 memset(val1->nodeTab, 0 ,
3894 XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
3895 val1->nodeMax = XML_NODESET_DEFAULT;
3896 } else if (val1->nodeNr == val1->nodeMax) {
3897 xmlNodePtr *temp;
3898
3899 if (val1->nodeMax >= XPATH_MAX_NODESET_LENGTH) {
3900 xmlXPathErrMemory(NULL, "merging nodeset hit limit\n");
3901 return(NULL);
3902 }
3903 temp = (xmlNodePtr *) xmlRealloc(val1->nodeTab, val1->nodeMax * 2 *
3904 sizeof(xmlNodePtr));
3905 if (temp == NULL) {
3906 xmlXPathErrMemory(NULL, "merging nodeset\n");
3907 return(NULL);
3908 }
3909 val1->nodeTab = temp;
3910 val1->nodeMax *= 2;
3911 }
3912 if (n2->type == XML_NAMESPACE_DECL) {
3913 xmlNsPtr ns = (xmlNsPtr) n2;
3914
3915 val1->nodeTab[val1->nodeNr++] =
3916 xmlXPathNodeSetDupNs((xmlNodePtr) ns->next, ns);
3917 } else
3918 val1->nodeTab[val1->nodeNr++] = n2;
3919 }
3920
3921 return(val1);
3922 }
3923
3924
3925 /**
3926 * xmlXPathNodeSetMergeAndClear:
3927 * @set1: the first NodeSet or NULL
3928 * @set2: the second NodeSet
3929 * @hasSet2NsNodes: 1 if set2 contains namespaces nodes
3930 *
3931 * Merges two nodesets, all nodes from @set2 are added to @set1
3932 * if @set1 is NULL, a new set is created and copied from @set2.
3933 * Checks for duplicate nodes. Clears set2.
3934 *
3935 * Returns @set1 once extended or NULL in case of error.
3936 */
3937 static xmlNodeSetPtr
3938 xmlXPathNodeSetMergeAndClear(xmlNodeSetPtr set1, xmlNodeSetPtr set2,
3939 int hasNullEntries)
3940 {
3941 if ((set1 == NULL) && (hasNullEntries == 0)) {
3942 /*
3943 * Note that doing a memcpy of the list, namespace nodes are
3944 * just assigned to set1, since set2 is cleared anyway.
3945 */
3946 set1 = xmlXPathNodeSetCreateSize(set2->nodeNr);
3947 if (set1 == NULL)
3948 return(NULL);
3949 if (set2->nodeNr != 0) {
3950 memcpy(set1->nodeTab, set2->nodeTab,
3951 set2->nodeNr * sizeof(xmlNodePtr));
3952 set1->nodeNr = set2->nodeNr;
3953 }
3954 } else {
3955 int i, j, initNbSet1;
3956 xmlNodePtr n1, n2;
3957
3958 if (set1 == NULL)
3959 set1 = xmlXPathNodeSetCreate(NULL);
3960 if (set1 == NULL)
3961 return (NULL);
3962
3963 initNbSet1 = set1->nodeNr;
3964 for (i = 0;i < set2->nodeNr;i++) {
3965 n2 = set2->nodeTab[i];
3966 /*
3967 * Skip NULLed entries.
3968 */
3969 if (n2 == NULL)
3970 continue;
3971 /*
3972 * Skip duplicates.
3973 */
3974 for (j = 0; j < initNbSet1; j++) {
3975 n1 = set1->nodeTab[j];
3976 if (n1 == n2) {
3977 goto skip_node;
3978 } else if ((n1->type == XML_NAMESPACE_DECL) &&
3979 (n2->type == XML_NAMESPACE_DECL))
3980 {
3981 if ((((xmlNsPtr) n1)->next == ((xmlNsPtr) n2)->next) &&
3982 (xmlStrEqual(((xmlNsPtr) n1)->prefix,
3983 ((xmlNsPtr) n2)->prefix)))
3984 {
3985 /*
3986 * Free the namespace node.
3987 */
3988 set2->nodeTab[i] = NULL;
3989 xmlXPathNodeSetFreeNs((xmlNsPtr) n2);
3990 goto skip_node;
3991 }
3992 }
3993 }
3994 /*
3995 * grow the nodeTab if needed
3996 */
3997 if (set1->nodeMax == 0) {
3998 set1->nodeTab = (xmlNodePtr *) xmlMalloc(
3999 XML_NODESET_DEFAULT * sizeof(xmlNodePtr));
4000 if (set1->nodeTab == NULL) {
4001 xmlXPathErrMemory(NULL, "merging nodeset\n");
4002 return(NULL);
4003 }
4004 memset(set1->nodeTab, 0,
4005 XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
4006 set1->nodeMax = XML_NODESET_DEFAULT;
4007 } else if (set1->nodeNr >= set1->nodeMax) {
4008 xmlNodePtr *temp;
4009
4010 if (set1->nodeMax >= XPATH_MAX_NODESET_LENGTH) {
4011 xmlXPathErrMemory(NULL, "merging nodeset hit limit\n");
4012 return(NULL);
4013 }
4014 temp = (xmlNodePtr *) xmlRealloc(
4015 set1->nodeTab, set1->nodeMax * 2 * sizeof(xmlNodePtr));
4016 if (temp == NULL) {
4017 xmlXPathErrMemory(NULL, "merging nodeset\n");
4018 return(NULL);
4019 }
4020 set1->nodeTab = temp;
4021 set1->nodeMax *= 2;
4022 }
4023 set1->nodeTab[set1->nodeNr++] = n2;
4024 skip_node:
4025 {}
4026 }
4027 }
4028 set2->nodeNr = 0;
4029 return(set1);
4030 }
4031
4032 /**
4033 * xmlXPathNodeSetMergeAndClearNoDupls:
4034 * @set1: the first NodeSet or NULL
4035 * @set2: the second NodeSet
4036 * @hasSet2NsNodes: 1 if set2 contains namespaces nodes
4037 *
4038 * Merges two nodesets, all nodes from @set2 are added to @set1
4039 * if @set1 is NULL, a new set is created and copied from @set2.
4040 * Doesn't chack for duplicate nodes. Clears set2.
4041 *
4042 * Returns @set1 once extended or NULL in case of error.
4043 */
4044 static xmlNodeSetPtr
4045 xmlXPathNodeSetMergeAndClearNoDupls(xmlNodeSetPtr set1, xmlNodeSetPtr set2,
4046 int hasNullEntries)
4047 {
4048 if (set2 == NULL)
4049 return(set1);
4050 if ((set1 == NULL) && (hasNullEntries == 0)) {
4051 /*
4052 * Note that doing a memcpy of the list, namespace nodes are
4053 * just assigned to set1, since set2 is cleared anyway.
4054 */
4055 set1 = xmlXPathNodeSetCreateSize(set2->nodeNr);
4056 if (set1 == NULL)
4057 return(NULL);
4058 if (set2->nodeNr != 0) {
4059 memcpy(set1->nodeTab, set2->nodeTab,
4060 set2->nodeNr * sizeof(xmlNodePtr));
4061 set1->nodeNr = set2->nodeNr;
4062 }
4063 } else {
4064 int i;
4065 xmlNodePtr n2;
4066
4067 if (set1 == NULL)
4068 set1 = xmlXPathNodeSetCreate(NULL);
4069 if (set1 == NULL)
4070 return (NULL);
4071
4072 for (i = 0;i < set2->nodeNr;i++) {
4073 n2 = set2->nodeTab[i];
4074 /*
4075 * Skip NULLed entries.
4076 */
4077 if (n2 == NULL)
4078 continue;
4079 if (set1->nodeMax == 0) {
4080 set1->nodeTab = (xmlNodePtr *) xmlMalloc(
4081 XML_NODESET_DEFAULT * sizeof(xmlNodePtr));
4082 if (set1->nodeTab == NULL) {
4083 xmlXPathErrMemory(NULL, "merging nodeset\n");
4084 return(NULL);
4085 }
4086 memset(set1->nodeTab, 0,
4087 XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
4088 set1->nodeMax = XML_NODESET_DEFAULT;
4089 } else if (set1->nodeNr >= set1->nodeMax) {
4090 xmlNodePtr *temp;
4091
4092 if (set1->nodeMax >= XPATH_MAX_NODESET_LENGTH) {
4093 xmlXPathErrMemory(NULL, "merging nodeset hit limit\n");
4094 return(NULL);
4095 }
4096 temp = (xmlNodePtr *) xmlRealloc(
4097 set1->nodeTab, set1->nodeMax * 2 * sizeof(xmlNodePtr));
4098 if (temp == NULL) {
4099 xmlXPathErrMemory(NULL, "merging nodeset\n");
4100 return(NULL);
4101 }
4102 set1->nodeTab = temp;
4103 set1->nodeMax *= 2;
4104 }
4105 set1->nodeTab[set1->nodeNr++] = n2;
4106 }
4107 }
4108 set2->nodeNr = 0;
4109 return(set1);
4110 }
4111
4112 /**
4113 * xmlXPathNodeSetDel:
4114 * @cur: the initial node set
4115 * @val: an xmlNodePtr
4116 *
4117 * Removes an xmlNodePtr from an existing NodeSet
4118 */
4119 void
4120 xmlXPathNodeSetDel(xmlNodeSetPtr cur, xmlNodePtr val) {
4121 int i;
4122
4123 if (cur == NULL) return;
4124 if (val == NULL) return;
4125
4126 /*
4127 * find node in nodeTab
4128 */
4129 for (i = 0;i < cur->nodeNr;i++)
4130 if (cur->nodeTab[i] == val) break;
4131
4132 if (i >= cur->nodeNr) { /* not found */
4133 #ifdef DEBUG
4134 xmlGenericError(xmlGenericErrorContext,
4135 "xmlXPathNodeSetDel: Node %s wasn't found in NodeList\n",
4136 val->name);
4137 #endif
4138 return;
4139 }
4140 if ((cur->nodeTab[i] != NULL) &&
4141 (cur->nodeTab[i]->type == XML_NAMESPACE_DECL))
4142 xmlXPathNodeSetFreeNs((xmlNsPtr) cur->nodeTab[i]);
4143 cur->nodeNr--;
4144 for (;i < cur->nodeNr;i++)
4145 cur->nodeTab[i] = cur->nodeTab[i + 1];
4146 cur->nodeTab[cur->nodeNr] = NULL;
4147 }
4148
4149 /**
4150 * xmlXPathNodeSetRemove:
4151 * @cur: the initial node set
4152 * @val: the index to remove
4153 *
4154 * Removes an entry from an existing NodeSet list.
4155 */
4156 void
4157 xmlXPathNodeSetRemove(xmlNodeSetPtr cur, int val) {
4158 if (cur == NULL) return;
4159 if (val >= cur->nodeNr) return;
4160 if ((cur->nodeTab[val] != NULL) &&
4161 (cur->nodeTab[val]->type == XML_NAMESPACE_DECL))
4162 xmlXPathNodeSetFreeNs((xmlNsPtr) cur->nodeTab[val]);
4163 cur->nodeNr--;
4164 for (;val < cur->nodeNr;val++)
4165 cur->nodeTab[val] = cur->nodeTab[val + 1];
4166 cur->nodeTab[cur->nodeNr] = NULL;
4167 }
4168
4169 /**
4170 * xmlXPathFreeNodeSet:
4171 * @obj: the xmlNodeSetPtr to free
4172 *
4173 * Free the NodeSet compound (not the actual nodes !).
4174 */
4175 void
4176 xmlXPathFreeNodeSet(xmlNodeSetPtr obj) {
4177 if (obj == NULL) return;
4178 if (obj->nodeTab != NULL) {
4179 int i;
4180
4181 /* @@ with_ns to check whether namespace nodes should be looked at @@ */
4182 for (i = 0;i < obj->nodeNr;i++)
4183 if ((obj->nodeTab[i] != NULL) &&
4184 (obj->nodeTab[i]->type == XML_NAMESPACE_DECL))
4185 xmlXPathNodeSetFreeNs((xmlNsPtr) obj->nodeTab[i]);
4186 xmlFree(obj->nodeTab);
4187 }
4188 xmlFree(obj);
4189 }
4190
4191 /**
4192 * xmlXPathNodeSetClearFromPos:
4193 * @set: the node set to be cleared
4194 * @pos: the start position to clear from
4195 *
4196 * Clears the list from temporary XPath objects (e.g. namespace nodes
4197 * are feed) starting with the entry at @pos, but does *not* free the list
4198 * itself. Sets the length of the list to @pos.
4199 */
4200 static void
4201 xmlXPathNodeSetClearFromPos(xmlNodeSetPtr set, int pos, int hasNsNodes)
4202 {
4203 if ((set == NULL) || (pos >= set->nodeNr))
4204 return;
4205 else if ((hasNsNodes)) {
4206 int i;
4207 xmlNodePtr node;
4208
4209 for (i = pos; i < set->nodeNr; i++) {
4210 node = set->nodeTab[i];
4211 if ((node != NULL) &&
4212 (node->type == XML_NAMESPACE_DECL))
4213 xmlXPathNodeSetFreeNs((xmlNsPtr) node);
4214 }
4215 }
4216 set->nodeNr = pos;
4217 }
4218
4219 /**
4220 * xmlXPathNodeSetClear:
4221 * @set: the node set to clear
4222 *
4223 * Clears the list from all temporary XPath objects (e.g. namespace nodes
4224 * are feed), but does *not* free the list itself. Sets the length of the
4225 * list to 0.
4226 */
4227 static void
4228 xmlXPathNodeSetClear(xmlNodeSetPtr set, int hasNsNodes)
4229 {
4230 xmlXPathNodeSetClearFromPos(set, 0, hasNsNodes);
4231 }
4232
4233 /**
4234 * xmlXPathNodeSetKeepLast:
4235 * @set: the node set to be cleared
4236 *
4237 * Move the last node to the first position and clear temporary XPath objects
4238 * (e.g. namespace nodes) from all other nodes. Sets the length of the list
4239 * to 1.
4240 */
4241 static void
4242 xmlXPathNodeSetKeepLast(xmlNodeSetPtr set)
4243 {
4244 int i;
4245 xmlNodePtr node;
4246
4247 if ((set == NULL) || (set->nodeNr <= 1))
4248 return;
4249 for (i = 0; i < set->nodeNr - 1; i++) {
4250 node = set->nodeTab[i];
4251 if ((node != NULL) &&
4252 (node->type == XML_NAMESPACE_DECL))
4253 xmlXPathNodeSetFreeNs((xmlNsPtr) node);
4254 }
4255 set->nodeTab[0] = set->nodeTab[set->nodeNr-1];
4256 set->nodeNr = 1;
4257 }
4258
4259 /**
4260 * xmlXPathFreeValueTree:
4261 * @obj: the xmlNodeSetPtr to free
4262 *
4263 * Free the NodeSet compound and the actual tree, this is different
4264 * from xmlXPathFreeNodeSet()
4265 */
4266 static void
4267 xmlXPathFreeValueTree(xmlNodeSetPtr obj) {
4268 int i;
4269
4270 if (obj == NULL) return;
4271
4272 if (obj->nodeTab != NULL) {
4273 for (i = 0;i < obj->nodeNr;i++) {
4274 if (obj->nodeTab[i] != NULL) {
4275 if (obj->nodeTab[i]->type == XML_NAMESPACE_DECL) {
4276 xmlXPathNodeSetFreeNs((xmlNsPtr) obj->nodeTab[i]);
4277 } else {
4278 xmlFreeNodeList(obj->nodeTab[i]);
4279 }
4280 }
4281 }
4282 xmlFree(obj->nodeTab);
4283 }
4284 xmlFree(obj);
4285 }
4286
4287 #if defined(DEBUG) || defined(DEBUG_STEP)
4288 /**
4289 * xmlGenericErrorContextNodeSet:
4290 * @output: a FILE * for the output
4291 * @obj: the xmlNodeSetPtr to display
4292 *
4293 * Quick display of a NodeSet
4294 */
4295 void
4296 xmlGenericErrorContextNodeSet(FILE *output, xmlNodeSetPtr obj) {
4297 int i;
4298
4299 if (output == NULL) output = xmlGenericErrorContext;
4300 if (obj == NULL) {
4301 fprintf(output, "NodeSet == NULL !\n");
4302 return;
4303 }
4304 if (obj->nodeNr == 0) {
4305 fprintf(output, "NodeSet is empty\n");
4306 return;
4307 }
4308 if (obj->nodeTab == NULL) {
4309 fprintf(output, " nodeTab == NULL !\n");
4310 return;
4311 }
4312 for (i = 0; i < obj->nodeNr; i++) {
4313 if (obj->nodeTab[i] == NULL) {
4314 fprintf(output, " NULL !\n");
4315 return;
4316 }
4317 if ((obj->nodeTab[i]->type == XML_DOCUMENT_NODE) ||
4318 (obj->nodeTab[i]->type == XML_HTML_DOCUMENT_NODE))
4319 fprintf(output, " /");
4320 else if (obj->nodeTab[i]->name == NULL)
4321 fprintf(output, " noname!");
4322 else fprintf(output, " %s", obj->nodeTab[i]->name);
4323 }
4324 fprintf(output, "\n");
4325 }
4326 #endif
4327
4328 /**
4329 * xmlXPathNewNodeSet:
4330 * @val: the NodePtr value
4331 *
4332 * Create a new xmlXPathObjectPtr of type NodeSet and initialize
4333 * it with the single Node @val
4334 *
4335 * Returns the newly created object.
4336 */
4337 xmlXPathObjectPtr
4338 xmlXPathNewNodeSet(xmlNodePtr val) {
4339 xmlXPathObjectPtr ret;
4340
4341 ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
4342 if (ret == NULL) {
4343 xmlXPathErrMemory(NULL, "creating nodeset\n");
4344 return(NULL);
4345 }
4346 memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
4347 ret->type = XPATH_NODESET;
4348 ret->boolval = 0;
4349 ret->nodesetval = xmlXPathNodeSetCreate(val);
4350 /* @@ with_ns to check whether namespace nodes should be looked at @@ */
4351 #ifdef XP_DEBUG_OBJ_USAGE
4352 xmlXPathDebugObjUsageRequested(NULL, XPATH_NODESET);
4353 #endif
4354 return(ret);
4355 }
4356
4357 /**
4358 * xmlXPathNewValueTree:
4359 * @val: the NodePtr value
4360 *
4361 * Create a new xmlXPathObjectPtr of type Value Tree (XSLT) and initialize
4362 * it with the tree root @val
4363 *
4364 * Returns the newly created object.
4365 */
4366 xmlXPathObjectPtr
4367 xmlXPathNewValueTree(xmlNodePtr val) {
4368 xmlXPathObjectPtr ret;
4369
4370 ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
4371 if (ret == NULL) {
4372 xmlXPathErrMemory(NULL, "creating result value tree\n");
4373 return(NULL);
4374 }
4375 memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
4376 ret->type = XPATH_XSLT_TREE;
4377 ret->boolval = 1;
4378 ret->user = (void *) val;
4379 ret->nodesetval = xmlXPathNodeSetCreate(val);
4380 #ifdef XP_DEBUG_OBJ_USAGE
4381 xmlXPathDebugObjUsageRequested(NULL, XPATH_XSLT_TREE);
4382 #endif
4383 return(ret);
4384 }
4385
4386 /**
4387 * xmlXPathNewNodeSetList:
4388 * @val: an existing NodeSet
4389 *
4390 * Create a new xmlXPathObjectPtr of type NodeSet and initialize
4391 * it with the Nodeset @val
4392 *
4393 * Returns the newly created object.
4394 */
4395 xmlXPathObjectPtr
4396 xmlXPathNewNodeSetList(xmlNodeSetPtr val)
4397 {
4398 xmlXPathObjectPtr ret;
4399 int i;
4400
4401 if (val == NULL)
4402 ret = NULL;
4403 else if (val->nodeTab == NULL)
4404 ret = xmlXPathNewNodeSet(NULL);
4405 else {
4406 ret = xmlXPathNewNodeSet(val->nodeTab[0]);
4407 if (ret) {
4408 for (i = 1; i < val->nodeNr; ++i) {
4409 if (xmlXPathNodeSetAddUnique(ret->nodesetval, val->nodeTab[i])
4410 < 0) break;
4411 }
4412 }
4413 }
4414
4415 return (ret);
4416 }
4417
4418 /**
4419 * xmlXPathWrapNodeSet:
4420 * @val: the NodePtr value
4421 *
4422 * Wrap the Nodeset @val in a new xmlXPathObjectPtr
4423 *
4424 * Returns the newly created object.
4425 */
4426 xmlXPathObjectPtr
4427 xmlXPathWrapNodeSet(xmlNodeSetPtr val) {
4428 xmlXPathObjectPtr ret;
4429
4430 ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
4431 if (ret == NULL) {
4432 xmlXPathErrMemory(NULL, "creating node set object\n");
4433 return(NULL);
4434 }
4435 memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
4436 ret->type = XPATH_NODESET;
4437 ret->nodesetval = val;
4438 #ifdef XP_DEBUG_OBJ_USAGE
4439 xmlXPathDebugObjUsageRequested(NULL, XPATH_NODESET);
4440 #endif
4441 return(ret);
4442 }
4443
4444 /**
4445 * xmlXPathFreeNodeSetList:
4446 * @obj: an existing NodeSetList object
4447 *
4448 * Free up the xmlXPathObjectPtr @obj but don't deallocate the objects in
4449 * the list contrary to xmlXPathFreeObject().
4450 */
4451 void
4452 xmlXPathFreeNodeSetList(xmlXPathObjectPtr obj) {
4453 if (obj == NULL) return;
4454 #ifdef XP_DEBUG_OBJ_USAGE
4455 xmlXPathDebugObjUsageReleased(NULL, obj->type);
4456 #endif
4457 xmlFree(obj);
4458 }
4459
4460 /**
4461 * xmlXPathDifference:
4462 * @nodes1: a node-set
4463 * @nodes2: a node-set
4464 *
4465 * Implements the EXSLT - Sets difference() function:
4466 * node-set set:difference (node-set, node-set)
4467 *
4468 * Returns the difference between the two node sets, or nodes1 if
4469 * nodes2 is empty
4470 */
4471 xmlNodeSetPtr
4472 xmlXPathDifference (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
4473 xmlNodeSetPtr ret;
4474 int i, l1;
4475 xmlNodePtr cur;
4476
4477 if (xmlXPathNodeSetIsEmpty(nodes2))
4478 return(nodes1);
4479
4480 ret = xmlXPathNodeSetCreate(NULL);
4481 if (xmlXPathNodeSetIsEmpty(nodes1))
4482 return(ret);
4483
4484 l1 = xmlXPathNodeSetGetLength(nodes1);
4485
4486 for (i = 0; i < l1; i++) {
4487 cur = xmlXPathNodeSetItem(nodes1, i);
4488 if (!xmlXPathNodeSetContains(nodes2, cur)) {
4489 if (xmlXPathNodeSetAddUnique(ret, cur) < 0)
4490 break;
4491 }
4492 }
4493 return(ret);
4494 }
4495
4496 /**
4497 * xmlXPathIntersection:
4498 * @nodes1: a node-set
4499 * @nodes2: a node-set
4500 *
4501 * Implements the EXSLT - Sets intersection() function:
4502 * node-set set:intersection (node-set, node-set)
4503 *
4504 * Returns a node set comprising the nodes that are within both the
4505 * node sets passed as arguments
4506 */
4507 xmlNodeSetPtr
4508 xmlXPathIntersection (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
4509 xmlNodeSetPtr ret = xmlXPathNodeSetCreate(NULL);
4510 int i, l1;
4511 xmlNodePtr cur;
4512
4513 if (ret == NULL)
4514 return(ret);
4515 if (xmlXPathNodeSetIsEmpty(nodes1))
4516 return(ret);
4517 if (xmlXPathNodeSetIsEmpty(nodes2))
4518 return(ret);
4519
4520 l1 = xmlXPathNodeSetGetLength(nodes1);
4521
4522 for (i = 0; i < l1; i++) {
4523 cur = xmlXPathNodeSetItem(nodes1, i);
4524 if (xmlXPathNodeSetContains(nodes2, cur)) {
4525 if (xmlXPathNodeSetAddUnique(ret, cur) < 0)
4526 break;
4527 }
4528 }
4529 return(ret);
4530 }
4531
4532 /**
4533 * xmlXPathDistinctSorted:
4534 * @nodes: a node-set, sorted by document order
4535 *
4536 * Implements the EXSLT - Sets distinct() function:
4537 * node-set set:distinct (node-set)
4538 *
4539 * Returns a subset of the nodes contained in @nodes, or @nodes if
4540 * it is empty
4541 */
4542 xmlNodeSetPtr
4543 xmlXPathDistinctSorted (xmlNodeSetPtr nodes) {
4544 xmlNodeSetPtr ret;
4545 xmlHashTablePtr hash;
4546 int i, l;
4547 xmlChar * strval;
4548 xmlNodePtr cur;
4549
4550 if (xmlXPathNodeSetIsEmpty(nodes))
4551 return(nodes);
4552
4553 ret = xmlXPathNodeSetCreate(NULL);
4554 if (ret == NULL)
4555 return(ret);
4556 l = xmlXPathNodeSetGetLength(nodes);
4557 hash = xmlHashCreate (l);
4558 for (i = 0; i < l; i++) {
4559 cur = xmlXPathNodeSetItem(nodes, i);
4560 strval = xmlXPathCastNodeToString(cur);
4561 if (xmlHashLookup(hash, strval) == NULL) {
4562 xmlHashAddEntry(hash, strval, strval);
4563 if (xmlXPathNodeSetAddUnique(ret, cur) < 0)
4564 break;
4565 } else {
4566 xmlFree(strval);
4567 }
4568 }
4569 xmlHashFree(hash, xmlHashDefaultDeallocator);
4570 return(ret);
4571 }
4572
4573 /**
4574 * xmlXPathDistinct:
4575 * @nodes: a node-set
4576 *
4577 * Implements the EXSLT - Sets distinct() function:
4578 * node-set set:distinct (node-set)
4579 * @nodes is sorted by document order, then #exslSetsDistinctSorted
4580 * is called with the sorted node-set
4581 *
4582 * Returns a subset of the nodes contained in @nodes, or @nodes if
4583 * it is empty
4584 */
4585 xmlNodeSetPtr
4586 xmlXPathDistinct (xmlNodeSetPtr nodes) {
4587 if (xmlXPathNodeSetIsEmpty(nodes))
4588 return(nodes);
4589
4590 xmlXPathNodeSetSort(nodes);
4591 return(xmlXPathDistinctSorted(nodes));
4592 }
4593
4594 /**
4595 * xmlXPathHasSameNodes:
4596 * @nodes1: a node-set
4597 * @nodes2: a node-set
4598 *
4599 * Implements the EXSLT - Sets has-same-nodes function:
4600 * boolean set:has-same-node(node-set, node-set)
4601 *
4602 * Returns true (1) if @nodes1 shares any node with @nodes2, false (0)
4603 * otherwise
4604 */
4605 int
4606 xmlXPathHasSameNodes (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
4607 int i, l;
4608 xmlNodePtr cur;
4609
4610 if (xmlXPathNodeSetIsEmpty(nodes1) ||
4611 xmlXPathNodeSetIsEmpty(nodes2))
4612 return(0);
4613
4614 l = xmlXPathNodeSetGetLength(nodes1);
4615 for (i = 0; i < l; i++) {
4616 cur = xmlXPathNodeSetItem(nodes1, i);
4617 if (xmlXPathNodeSetContains(nodes2, cur))
4618 return(1);
4619 }
4620 return(0);
4621 }
4622
4623 /**
4624 * xmlXPathNodeLeadingSorted:
4625 * @nodes: a node-set, sorted by document order
4626 * @node: a node
4627 *
4628 * Implements the EXSLT - Sets leading() function:
4629 * node-set set:leading (node-set, node-set)
4630 *
4631 * Returns the nodes in @nodes that precede @node in document order,
4632 * @nodes if @node is NULL or an empty node-set if @nodes
4633 * doesn't contain @node
4634 */
4635 xmlNodeSetPtr
4636 xmlXPathNodeLeadingSorted (xmlNodeSetPtr nodes, xmlNodePtr node) {
4637 int i, l;
4638 xmlNodePtr cur;
4639 xmlNodeSetPtr ret;
4640
4641 if (node == NULL)
4642 return(nodes);
4643
4644 ret = xmlXPathNodeSetCreate(NULL);
4645 if (ret == NULL)
4646 return(ret);
4647 if (xmlXPathNodeSetIsEmpty(nodes) ||
4648 (!xmlXPathNodeSetContains(nodes, node)))
4649 return(ret);
4650
4651 l = xmlXPathNodeSetGetLength(nodes);
4652 for (i = 0; i < l; i++) {
4653 cur = xmlXPathNodeSetItem(nodes, i);
4654 if (cur == node)
4655 break;
4656 if (xmlXPathNodeSetAddUnique(ret, cur) < 0)
4657 break;
4658 }
4659 return(ret);
4660 }
4661
4662 /**
4663 * xmlXPathNodeLeading:
4664 * @nodes: a node-set
4665 * @node: a node
4666 *
4667 * Implements the EXSLT - Sets leading() function:
4668 * node-set set:leading (node-set, node-set)
4669 * @nodes is sorted by document order, then #exslSetsNodeLeadingSorted
4670 * is called.
4671 *
4672 * Returns the nodes in @nodes that precede @node in document order,
4673 * @nodes if @node is NULL or an empty node-set if @nodes
4674 * doesn't contain @node
4675 */
4676 xmlNodeSetPtr
4677 xmlXPathNodeLeading (xmlNodeSetPtr nodes, xmlNodePtr node) {
4678 xmlXPathNodeSetSort(nodes);
4679 return(xmlXPathNodeLeadingSorted(nodes, node));
4680 }
4681
4682 /**
4683 * xmlXPathLeadingSorted:
4684 * @nodes1: a node-set, sorted by document order
4685 * @nodes2: a node-set, sorted by document order
4686 *
4687 * Implements the EXSLT - Sets leading() function:
4688 * node-set set:leading (node-set, node-set)
4689 *
4690 * Returns the nodes in @nodes1 that precede the first node in @nodes2
4691 * in document order, @nodes1 if @nodes2 is NULL or empty or
4692 * an empty node-set if @nodes1 doesn't contain @nodes2
4693 */
4694 xmlNodeSetPtr
4695 xmlXPathLeadingSorted (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
4696 if (xmlXPathNodeSetIsEmpty(nodes2))
4697 return(nodes1);
4698 return(xmlXPathNodeLeadingSorted(nodes1,
4699 xmlXPathNodeSetItem(nodes2, 1)));
4700 }
4701
4702 /**
4703 * xmlXPathLeading:
4704 * @nodes1: a node-set
4705 * @nodes2: a node-set
4706 *
4707 * Implements the EXSLT - Sets leading() function:
4708 * node-set set:leading (node-set, node-set)
4709 * @nodes1 and @nodes2 are sorted by document order, then
4710 * #exslSetsLeadingSorted is called.
4711 *
4712 * Returns the nodes in @nodes1 that precede the first node in @nodes2
4713 * in document order, @nodes1 if @nodes2 is NULL or empty or
4714 * an empty node-set if @nodes1 doesn't contain @nodes2
4715 */
4716 xmlNodeSetPtr
4717 xmlXPathLeading (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
4718 if (xmlXPathNodeSetIsEmpty(nodes2))
4719 return(nodes1);
4720 if (xmlXPathNodeSetIsEmpty(nodes1))
4721 return(xmlXPathNodeSetCreate(NULL));
4722 xmlXPathNodeSetSort(nodes1);
4723 xmlXPathNodeSetSort(nodes2);
4724 return(xmlXPathNodeLeadingSorted(nodes1,
4725 xmlXPathNodeSetItem(nodes2, 1)));
4726 }
4727
4728 /**
4729 * xmlXPathNodeTrailingSorted:
4730 * @nodes: a node-set, sorted by document order
4731 * @node: a node
4732 *
4733 * Implements the EXSLT - Sets trailing() function:
4734 * node-set set:trailing (node-set, node-set)
4735 *
4736 * Returns the nodes in @nodes that follow @node in document order,
4737 * @nodes if @node is NULL or an empty node-set if @nodes
4738 * doesn't contain @node
4739 */
4740 xmlNodeSetPtr
4741 xmlXPathNodeTrailingSorted (xmlNodeSetPtr nodes, xmlNodePtr node) {
4742 int i, l;
4743 xmlNodePtr cur;
4744 xmlNodeSetPtr ret;
4745
4746 if (node == NULL)
4747 return(nodes);
4748
4749 ret = xmlXPathNodeSetCreate(NULL);
4750 if (ret == NULL)
4751 return(ret);
4752 if (xmlXPathNodeSetIsEmpty(nodes) ||
4753 (!xmlXPathNodeSetContains(nodes, node)))
4754 return(ret);
4755
4756 l = xmlXPathNodeSetGetLength(nodes);
4757 for (i = l - 1; i >= 0; i--) {
4758 cur = xmlXPathNodeSetItem(nodes, i);
4759 if (cur == node)
4760 break;
4761 if (xmlXPathNodeSetAddUnique(ret, cur) < 0)
4762 break;
4763 }
4764 xmlXPathNodeSetSort(ret); /* bug 413451 */
4765 return(ret);
4766 }
4767
4768 /**
4769 * xmlXPathNodeTrailing:
4770 * @nodes: a node-set
4771 * @node: a node
4772 *
4773 * Implements the EXSLT - Sets trailing() function:
4774 * node-set set:trailing (node-set, node-set)
4775 * @nodes is sorted by document order, then #xmlXPathNodeTrailingSorted
4776 * is called.
4777 *
4778 * Returns the nodes in @nodes that follow @node in document order,
4779 * @nodes if @node is NULL or an empty node-set if @nodes
4780 * doesn't contain @node
4781 */
4782 xmlNodeSetPtr
4783 xmlXPathNodeTrailing (xmlNodeSetPtr nodes, xmlNodePtr node) {
4784 xmlXPathNodeSetSort(nodes);
4785 return(xmlXPathNodeTrailingSorted(nodes, node));
4786 }
4787
4788 /**
4789 * xmlXPathTrailingSorted:
4790 * @nodes1: a node-set, sorted by document order
4791 * @nodes2: a node-set, sorted by document order
4792 *
4793 * Implements the EXSLT - Sets trailing() function:
4794 * node-set set:trailing (node-set, node-set)
4795 *
4796 * Returns the nodes in @nodes1 that follow the first node in @nodes2
4797 * in document order, @nodes1 if @nodes2 is NULL or empty or
4798 * an empty node-set if @nodes1 doesn't contain @nodes2
4799 */
4800 xmlNodeSetPtr
4801 xmlXPathTrailingSorted (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
4802 if (xmlXPathNodeSetIsEmpty(nodes2))
4803 return(nodes1);
4804 return(xmlXPathNodeTrailingSorted(nodes1,
4805 xmlXPathNodeSetItem(nodes2, 0)));
4806 }
4807
4808 /**
4809 * xmlXPathTrailing:
4810 * @nodes1: a node-set
4811 * @nodes2: a node-set
4812 *
4813 * Implements the EXSLT - Sets trailing() function:
4814 * node-set set:trailing (node-set, node-set)
4815 * @nodes1 and @nodes2 are sorted by document order, then
4816 * #xmlXPathTrailingSorted is called.
4817 *
4818 * Returns the nodes in @nodes1 that follow the first node in @nodes2
4819 * in document order, @nodes1 if @nodes2 is NULL or empty or
4820 * an empty node-set if @nodes1 doesn't contain @nodes2
4821 */
4822 xmlNodeSetPtr
4823 xmlXPathTrailing (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
4824 if (xmlXPathNodeSetIsEmpty(nodes2))
4825 return(nodes1);
4826 if (xmlXPathNodeSetIsEmpty(nodes1))
4827 return(xmlXPathNodeSetCreate(NULL));
4828 xmlXPathNodeSetSort(nodes1);
4829 xmlXPathNodeSetSort(nodes2);
4830 return(xmlXPathNodeTrailingSorted(nodes1,
4831 xmlXPathNodeSetItem(nodes2, 0)));
4832 }
4833
4834 /************************************************************************
4835 * *
4836 * Routines to handle extra functions *
4837 * *
4838 ************************************************************************/
4839
4840 /**
4841 * xmlXPathRegisterFunc:
4842 * @ctxt: the XPath context
4843 * @name: the function name
4844 * @f: the function implementation or NULL
4845 *
4846 * Register a new function. If @f is NULL it unregisters the function
4847 *
4848 * Returns 0 in case of success, -1 in case of error
4849 */
4850 int
4851 xmlXPathRegisterFunc(xmlXPathContextPtr ctxt, const xmlChar *name,
4852 xmlXPathFunction f) {
4853 return(xmlXPathRegisterFuncNS(ctxt, name, NULL, f));
4854 }
4855
4856 /**
4857 * xmlXPathRegisterFuncNS:
4858 * @ctxt: the XPath context
4859 * @name: the function name
4860 * @ns_uri: the function namespace URI
4861 * @f: the function implementation or NULL
4862 *
4863 * Register a new function. If @f is NULL it unregisters the function
4864 *
4865 * Returns 0 in case of success, -1 in case of error
4866 */
4867 int
4868 xmlXPathRegisterFuncNS(xmlXPathContextPtr ctxt, const xmlChar *name,
4869 const xmlChar *ns_uri, xmlXPathFunction f) {
4870 if (ctxt == NULL)
4871 return(-1);
4872 if (name == NULL)
4873 return(-1);
4874
4875 if (ctxt->funcHash == NULL)
4876 ctxt->funcHash = xmlHashCreate(0);
4877 if (ctxt->funcHash == NULL)
4878 return(-1);
4879 if (f == NULL)
4880 return(xmlHashRemoveEntry2(ctxt->funcHash, name, ns_uri, NULL));
4881 XML_IGNORE_PEDANTIC_WARNINGS
4882 return(xmlHashAddEntry2(ctxt->funcHash, name, ns_uri, (void *) f));
4883 XML_POP_WARNINGS
4884 }
4885
4886 /**
4887 * xmlXPathRegisterFuncLookup:
4888 * @ctxt: the XPath context
4889 * @f: the lookup function
4890 * @funcCtxt: the lookup data
4891 *
4892 * Registers an external mechanism to do function lookup.
4893 */
4894 void
4895 xmlXPathRegisterFuncLookup (xmlXPathContextPtr ctxt,
4896 xmlXPathFuncLookupFunc f,
4897 void *funcCtxt) {
4898 if (ctxt == NULL)
4899 return;
4900 ctxt->funcLookupFunc = f;
4901 ctxt->funcLookupData = funcCtxt;
4902 }
4903
4904 /**
4905 * xmlXPathFunctionLookup:
4906 * @ctxt: the XPath context
4907 * @name: the function name
4908 *
4909 * Search in the Function array of the context for the given
4910 * function.
4911 *
4912 * Returns the xmlXPathFunction or NULL if not found
4913 */
4914 xmlXPathFunction
4915 xmlXPathFunctionLookup(xmlXPathContextPtr ctxt, const xmlChar *name) {
4916 if (ctxt == NULL)
4917 return (NULL);
4918
4919 if (ctxt->funcLookupFunc != NULL) {
4920 xmlXPathFunction ret;
4921 xmlXPathFuncLookupFunc f;
4922
4923 f = ctxt->funcLookupFunc;
4924 ret = f(ctxt->funcLookupData, name, NULL);
4925 if (ret != NULL)
4926 return(ret);
4927 }
4928 return(xmlXPathFunctionLookupNS(ctxt, name, NULL));
4929 }
4930
4931 /**
4932 * xmlXPathFunctionLookupNS:
4933 * @ctxt: the XPath context
4934 * @name: the function name
4935 * @ns_uri: the function namespace URI
4936 *
4937 * Search in the Function array of the context for the given
4938 * function.
4939 *
4940 * Returns the xmlXPathFunction or NULL if not found
4941 */
4942 xmlXPathFunction
4943 xmlXPathFunctionLookupNS(xmlXPathContextPtr ctxt, const xmlChar *name,
4944 const xmlChar *ns_uri) {
4945 xmlXPathFunction ret;
4946
4947 if (ctxt == NULL)
4948 return(NULL);
4949 if (name == NULL)
4950 return(NULL);
4951
4952 if (ctxt->funcLookupFunc != NULL) {
4953 xmlXPathFuncLookupFunc f;
4954
4955 f = ctxt->funcLookupFunc;
4956 ret = f(ctxt->funcLookupData, name, ns_uri);
4957 if (ret != NULL)
4958 return(ret);
4959 }
4960
4961 if (ctxt->funcHash == NULL)
4962 return(NULL);
4963
4964 XML_IGNORE_PEDANTIC_WARNINGS
4965 ret = (xmlXPathFunction) xmlHashLookup2(ctxt->funcHash, name, ns_uri);
4966 XML_POP_WARNINGS
4967 return(ret);
4968 }
4969
4970 /**
4971 * xmlXPathRegisteredFuncsCleanup:
4972 * @ctxt: the XPath context
4973 *
4974 * Cleanup the XPath context data associated to registered functions
4975 */
4976 void
4977 xmlXPathRegisteredFuncsCleanup(xmlXPathContextPtr ctxt) {
4978 if (ctxt == NULL)
4979 return;
4980
4981 xmlHashFree(ctxt->funcHash, NULL);
4982 ctxt->funcHash = NULL;
4983 }
4984
4985 /************************************************************************
4986 * *
4987 * Routines to handle Variables *
4988 * *
4989 ************************************************************************/
4990
4991 /**
4992 * xmlXPathRegisterVariable:
4993 * @ctxt: the XPath context
4994 * @name: the variable name
4995 * @value: the variable value or NULL
4996 *
4997 * Register a new variable value. If @value is NULL it unregisters
4998 * the variable
4999 *
5000 * Returns 0 in case of success, -1 in case of error
5001 */
5002 int
5003 xmlXPathRegisterVariable(xmlXPathContextPtr ctxt, const xmlChar *name,
5004 xmlXPathObjectPtr value) {
5005 return(xmlXPathRegisterVariableNS(ctxt, name, NULL, value));
5006 }
5007
5008 /**
5009 * xmlXPathRegisterVariableNS:
5010 * @ctxt: the XPath context
5011 * @name: the variable name
5012 * @ns_uri: the variable namespace URI
5013 * @value: the variable value or NULL
5014 *
5015 * Register a new variable value. If @value is NULL it unregisters
5016 * the variable
5017 *
5018 * Returns 0 in case of success, -1 in case of error
5019 */
5020 int
5021 xmlXPathRegisterVariableNS(xmlXPathContextPtr ctxt, const xmlChar *name,
5022 const xmlChar *ns_uri,
5023 xmlXPathObjectPtr value) {
5024 if (ctxt == NULL)
5025 return(-1);
5026 if (name == NULL)
5027 return(-1);
5028
5029 if (ctxt->varHash == NULL)
5030 ctxt->varHash = xmlHashCreate(0);
5031 if (ctxt->varHash == NULL)
5032 return(-1);
5033 if (value == NULL)
5034 return(xmlHashRemoveEntry2(ctxt->varHash, name, ns_uri,
5035 xmlXPathFreeObjectEntry));
5036 return(xmlHashUpdateEntry2(ctxt->varHash, name, ns_uri,
5037 (void *) value, xmlXPathFreeObjectEntry));
5038 }
5039
5040 /**
5041 * xmlXPathRegisterVariableLookup:
5042 * @ctxt: the XPath context
5043 * @f: the lookup function
5044 * @data: the lookup data
5045 *
5046 * register an external mechanism to do variable lookup
5047 */
5048 void
5049 xmlXPathRegisterVariableLookup(xmlXPathContextPtr ctxt,
5050 xmlXPathVariableLookupFunc f, void *data) {
5051 if (ctxt == NULL)
5052 return;
5053 ctxt->varLookupFunc = f;
5054 ctxt->varLookupData = data;
5055 }
5056
5057 /**
5058 * xmlXPathVariableLookup:
5059 * @ctxt: the XPath context
5060 * @name: the variable name
5061 *
5062 * Search in the Variable array of the context for the given
5063 * variable value.
5064 *
5065 * Returns a copy of the value or NULL if not found
5066 */
5067 xmlXPathObjectPtr
5068 xmlXPathVariableLookup(xmlXPathContextPtr ctxt, const xmlChar *name) {
5069 if (ctxt == NULL)
5070 return(NULL);
5071
5072 if (ctxt->varLookupFunc != NULL) {
5073 xmlXPathObjectPtr ret;
5074
5075 ret = ((xmlXPathVariableLookupFunc)ctxt->varLookupFunc)
5076 (ctxt->varLookupData, name, NULL);
5077 return(ret);
5078 }
5079 return(xmlXPathVariableLookupNS(ctxt, name, NULL));
5080 }
5081
5082 /**
5083 * xmlXPathVariableLookupNS:
5084 * @ctxt: the XPath context
5085 * @name: the variable name
5086 * @ns_uri: the variable namespace URI
5087 *
5088 * Search in the Variable array of the context for the given
5089 * variable value.
5090 *
5091 * Returns the a copy of the value or NULL if not found
5092 */
5093 xmlXPathObjectPtr
5094 xmlXPathVariableLookupNS(xmlXPathContextPtr ctxt, const xmlChar *name,
5095 const xmlChar *ns_uri) {
5096 if (ctxt == NULL)
5097 return(NULL);
5098
5099 if (ctxt->varLookupFunc != NULL) {
5100 xmlXPathObjectPtr ret;
5101
5102 ret = ((xmlXPathVariableLookupFunc)ctxt->varLookupFunc)
5103 (ctxt->varLookupData, name, ns_uri);
5104 if (ret != NULL) return(ret);
5105 }
5106
5107 if (ctxt->varHash == NULL)
5108 return(NULL);
5109 if (name == NULL)
5110 return(NULL);
5111
5112 return(xmlXPathCacheObjectCopy(ctxt, (xmlXPathObjectPtr)
5113 xmlHashLookup2(ctxt->varHash, name, ns_uri)));
5114 }
5115
5116 /**
5117 * xmlXPathRegisteredVariablesCleanup:
5118 * @ctxt: the XPath context
5119 *
5120 * Cleanup the XPath context data associated to registered variables
5121 */
5122 void
5123 xmlXPathRegisteredVariablesCleanup(xmlXPathContextPtr ctxt) {
5124 if (ctxt == NULL)
5125 return;
5126
5127 xmlHashFree(ctxt->varHash, xmlXPathFreeObjectEntry);
5128 ctxt->varHash = NULL;
5129 }
5130
5131 /**
5132 * xmlXPathRegisterNs:
5133 * @ctxt: the XPath context
5134 * @prefix: the namespace prefix cannot be NULL or empty string
5135 * @ns_uri: the namespace name
5136 *
5137 * Register a new namespace. If @ns_uri is NULL it unregisters
5138 * the namespace
5139 *
5140 * Returns 0 in case of success, -1 in case of error
5141 */
5142 int
5143 xmlXPathRegisterNs(xmlXPathContextPtr ctxt, const xmlChar *prefix,
5144 const xmlChar *ns_uri) {
5145 if (ctxt == NULL)
5146 return(-1);
5147 if (prefix == NULL)
5148 return(-1);
5149 if (prefix[0] == 0)
5150 return(-1);
5151
5152 if (ctxt->nsHash == NULL)
5153 ctxt->nsHash = xmlHashCreate(10);
5154 if (ctxt->nsHash == NULL)
5155 return(-1);
5156 if (ns_uri == NULL)
5157 return(xmlHashRemoveEntry(ctxt->nsHash, prefix,
5158 xmlHashDefaultDeallocator));
5159 return(xmlHashUpdateEntry(ctxt->nsHash, prefix, (void *) xmlStrdup(ns_uri),
5160 xmlHashDefaultDeallocator));
5161 }
5162
5163 /**
5164 * xmlXPathNsLookup:
5165 * @ctxt: the XPath context
5166 * @prefix: the namespace prefix value
5167 *
5168 * Search in the namespace declaration array of the context for the given
5169 * namespace name associated to the given prefix
5170 *
5171 * Returns the value or NULL if not found
5172 */
5173 const xmlChar *
5174 xmlXPathNsLookup(xmlXPathContextPtr ctxt, const xmlChar *prefix) {
5175 if (ctxt == NULL)
5176 return(NULL);
5177 if (prefix == NULL)
5178 return(NULL);
5179
5180 #ifdef XML_XML_NAMESPACE
5181 if (xmlStrEqual(prefix, (const xmlChar *) "xml"))
5182 return(XML_XML_NAMESPACE);
5183 #endif
5184
5185 if (ctxt->namespaces != NULL) {
5186 int i;
5187
5188 for (i = 0;i < ctxt->nsNr;i++) {
5189 if ((ctxt->namespaces[i] != NULL) &&
5190 (xmlStrEqual(ctxt->namespaces[i]->prefix, prefix)))
5191 return(ctxt->namespaces[i]->href);
5192 }
5193 }
5194
5195 return((const xmlChar *) xmlHashLookup(ctxt->nsHash, prefix));
5196 }
5197
5198 /**
5199 * xmlXPathRegisteredNsCleanup:
5200 * @ctxt: the XPath context
5201 *
5202 * Cleanup the XPath context data associated to registered variables
5203 */
5204 void
5205 xmlXPathRegisteredNsCleanup(xmlXPathContextPtr ctxt) {
5206 if (ctxt == NULL)
5207 return;
5208
5209 xmlHashFree(ctxt->nsHash, xmlHashDefaultDeallocator);
5210 ctxt->nsHash = NULL;
5211 }
5212
5213 /************************************************************************
5214 * *
5215 * Routines to handle Values *
5216 * *
5217 ************************************************************************/
5218
5219 /* Allocations are terrible, one needs to optimize all this !!! */
5220
5221 /**
5222 * xmlXPathNewFloat:
5223 * @val: the double value
5224 *
5225 * Create a new xmlXPathObjectPtr of type double and of value @val
5226 *
5227 * Returns the newly created object.
5228 */
5229 xmlXPathObjectPtr
5230 xmlXPathNewFloat(double val) {
5231 xmlXPathObjectPtr ret;
5232
5233 ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
5234 if (ret == NULL) {
5235 xmlXPathErrMemory(NULL, "creating float object\n");
5236 return(NULL);
5237 }
5238 memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
5239 ret->type = XPATH_NUMBER;
5240 ret->floatval = val;
5241 #ifdef XP_DEBUG_OBJ_USAGE
5242 xmlXPathDebugObjUsageRequested(NULL, XPATH_NUMBER);
5243 #endif
5244 return(ret);
5245 }
5246
5247 /**
5248 * xmlXPathNewBoolean:
5249 * @val: the boolean value
5250 *
5251 * Create a new xmlXPathObjectPtr of type boolean and of value @val
5252 *
5253 * Returns the newly created object.
5254 */
5255 xmlXPathObjectPtr
5256 xmlXPathNewBoolean(int val) {
5257 xmlXPathObjectPtr ret;
5258
5259 ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
5260 if (ret == NULL) {
5261 xmlXPathErrMemory(NULL, "creating boolean object\n");
5262 return(NULL);
5263 }
5264 memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
5265 ret->type = XPATH_BOOLEAN;
5266 ret->boolval = (val != 0);
5267 #ifdef XP_DEBUG_OBJ_USAGE
5268 xmlXPathDebugObjUsageRequested(NULL, XPATH_BOOLEAN);
5269 #endif
5270 return(ret);
5271 }
5272
5273 /**
5274 * xmlXPathNewString:
5275 * @val: the xmlChar * value
5276 *
5277 * Create a new xmlXPathObjectPtr of type string and of value @val
5278 *
5279 * Returns the newly created object.
5280 */
5281 xmlXPathObjectPtr
5282 xmlXPathNewString(const xmlChar *val) {
5283 xmlXPathObjectPtr ret;
5284
5285 ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
5286 if (ret == NULL) {
5287 xmlXPathErrMemory(NULL, "creating string object\n");
5288 return(NULL);
5289 }
5290 memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
5291 ret->type = XPATH_STRING;
5292 if (val != NULL)
5293 ret->stringval = xmlStrdup(val);
5294 else
5295 ret->stringval = xmlStrdup((const xmlChar *)"");
5296 #ifdef XP_DEBUG_OBJ_USAGE
5297 xmlXPathDebugObjUsageRequested(NULL, XPATH_STRING);
5298 #endif
5299 return(ret);
5300 }
5301
5302 /**
5303 * xmlXPathWrapString:
5304 * @val: the xmlChar * value
5305 *
5306 * Wraps the @val string into an XPath object.
5307 *
5308 * Returns the newly created object.
5309 */
5310 xmlXPathObjectPtr
5311 xmlXPathWrapString (xmlChar *val) {
5312 xmlXPathObjectPtr ret;
5313
5314 ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
5315 if (ret == NULL) {
5316 xmlXPathErrMemory(NULL, "creating string object\n");
5317 return(NULL);
5318 }
5319 memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
5320 ret->type = XPATH_STRING;
5321 ret->stringval = val;
5322 #ifdef XP_DEBUG_OBJ_USAGE
5323 xmlXPathDebugObjUsageRequested(NULL, XPATH_STRING);
5324 #endif
5325 return(ret);
5326 }
5327
5328 /**
5329 * xmlXPathNewCString:
5330 * @val: the char * value
5331 *
5332 * Create a new xmlXPathObjectPtr of type string and of value @val
5333 *
5334 * Returns the newly created object.
5335 */
5336 xmlXPathObjectPtr
5337 xmlXPathNewCString(const char *val) {
5338 xmlXPathObjectPtr ret;
5339
5340 ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
5341 if (ret == NULL) {
5342 xmlXPathErrMemory(NULL, "creating string object\n");
5343 return(NULL);
5344 }
5345 memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
5346 ret->type = XPATH_STRING;
5347 ret->stringval = xmlStrdup(BAD_CAST val);
5348 #ifdef XP_DEBUG_OBJ_USAGE
5349 xmlXPathDebugObjUsageRequested(NULL, XPATH_STRING);
5350 #endif
5351 return(ret);
5352 }
5353
5354 /**
5355 * xmlXPathWrapCString:
5356 * @val: the char * value
5357 *
5358 * Wraps a string into an XPath object.
5359 *
5360 * Returns the newly created object.
5361 */
5362 xmlXPathObjectPtr
5363 xmlXPathWrapCString (char * val) {
5364 return(xmlXPathWrapString((xmlChar *)(val)));
5365 }
5366
5367 /**
5368 * xmlXPathWrapExternal:
5369 * @val: the user data
5370 *
5371 * Wraps the @val data into an XPath object.
5372 *
5373 * Returns the newly created object.
5374 */
5375 xmlXPathObjectPtr
5376 xmlXPathWrapExternal (void *val) {
5377 xmlXPathObjectPtr ret;
5378
5379 ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
5380 if (ret == NULL) {
5381 xmlXPathErrMemory(NULL, "creating user object\n");
5382 return(NULL);
5383 }
5384 memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
5385 ret->type = XPATH_USERS;
5386 ret->user = val;
5387 #ifdef XP_DEBUG_OBJ_USAGE
5388 xmlXPathDebugObjUsageRequested(NULL, XPATH_USERS);
5389 #endif
5390 return(ret);
5391 }
5392
5393 /**
5394 * xmlXPathObjectCopy:
5395 * @val: the original object
5396 *
5397 * allocate a new copy of a given object
5398 *
5399 * Returns the newly created object.
5400 */
5401 xmlXPathObjectPtr
5402 xmlXPathObjectCopy(xmlXPathObjectPtr val) {
5403 xmlXPathObjectPtr ret;
5404
5405 if (val == NULL)
5406 return(NULL);
5407
5408 ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
5409 if (ret == NULL) {
5410 xmlXPathErrMemory(NULL, "copying object\n");
5411 return(NULL);
5412 }
5413 memcpy(ret, val , (size_t) sizeof(xmlXPathObject));
5414 #ifdef XP_DEBUG_OBJ_USAGE
5415 xmlXPathDebugObjUsageRequested(NULL, val->type);
5416 #endif
5417 switch (val->type) {
5418 case XPATH_BOOLEAN:
5419 case XPATH_NUMBER:
5420 case XPATH_POINT:
5421 case XPATH_RANGE:
5422 break;
5423 case XPATH_STRING:
5424 ret->stringval = xmlStrdup(val->stringval);
5425 break;
5426 case XPATH_XSLT_TREE:
5427 #if 0
5428 /*
5429 Removed 11 July 2004 - the current handling of xslt tmpRVT nodes means that
5430 this previous handling is no longer correct, and can cause some serious
5431 problems (ref. bug 145547)
5432 */
5433 if ((val->nodesetval != NULL) &&
5434 (val->nodesetval->nodeTab != NULL)) {
5435 xmlNodePtr cur, tmp;
5436 xmlDocPtr top;
5437
5438 ret->boolval = 1;
5439 top = xmlNewDoc(NULL);
5440 top->name = (char *)
5441 xmlStrdup(val->nodesetval->nodeTab[0]->name);
5442 ret->user = top;
5443 if (top != NULL) {
5444 top->doc = top;
5445 cur = val->nodesetval->nodeTab[0]->children;
5446 while (cur != NULL) {
5447 tmp = xmlDocCopyNode(cur, top, 1);
5448 xmlAddChild((xmlNodePtr) top, tmp);
5449 cur = cur->next;
5450 }
5451 }
5452
5453 ret->nodesetval = xmlXPathNodeSetCreate((xmlNodePtr) top);
5454 } else
5455 ret->nodesetval = xmlXPathNodeSetCreate(NULL);
5456 /* Deallocate the copied tree value */
5457 break;
5458 #endif
5459 case XPATH_NODESET:
5460 ret->nodesetval = xmlXPathNodeSetMerge(NULL, val->nodesetval);
5461 /* Do not deallocate the copied tree value */
5462 ret->boolval = 0;
5463 break;
5464 case XPATH_LOCATIONSET:
5465 #ifdef LIBXML_XPTR_ENABLED
5466 {
5467 xmlLocationSetPtr loc = val->user;
5468 ret->user = (void *) xmlXPtrLocationSetMerge(NULL, loc);
5469 break;
5470 }
5471 #endif
5472 case XPATH_USERS:
5473 ret->user = val->user;
5474 break;
5475 case XPATH_UNDEFINED:
5476 xmlGenericError(xmlGenericErrorContext,
5477 "xmlXPathObjectCopy: unsupported type %d\n",
5478 val->type);
5479 break;
5480 }
5481 return(ret);
5482 }
5483
5484 /**
5485 * xmlXPathFreeObject:
5486 * @obj: the object to free
5487 *
5488 * Free up an xmlXPathObjectPtr object.
5489 */
5490 void
5491 xmlXPathFreeObject(xmlXPathObjectPtr obj) {
5492 if (obj == NULL) return;
5493 if ((obj->type == XPATH_NODESET) || (obj->type == XPATH_XSLT_TREE)) {
5494 if (obj->boolval) {
5495 #if 0
5496 if (obj->user != NULL) {
5497 xmlXPathFreeNodeSet(obj->nodesetval);
5498 xmlFreeNodeList((xmlNodePtr) obj->user);
5499 } else
5500 #endif
5501 obj->type = XPATH_XSLT_TREE; /* TODO: Just for debugging. */
5502 if (obj->nodesetval != NULL)
5503 xmlXPathFreeValueTree(obj->nodesetval);
5504 } else {
5505 if (obj->nodesetval != NULL)
5506 xmlXPathFreeNodeSet(obj->nodesetval);
5507 }
5508 #ifdef LIBXML_XPTR_ENABLED
5509 } else if (obj->type == XPATH_LOCATIONSET) {
5510 if (obj->user != NULL)
5511 xmlXPtrFreeLocationSet(obj->user);
5512 #endif
5513 } else if (obj->type == XPATH_STRING) {
5514 if (obj->stringval != NULL)
5515 xmlFree(obj->stringval);
5516 }
5517 #ifdef XP_DEBUG_OBJ_USAGE
5518 xmlXPathDebugObjUsageReleased(NULL, obj->type);
5519 #endif
5520 xmlFree(obj);
5521 }
5522
5523 static void
5524 xmlXPathFreeObjectEntry(void *obj, const xmlChar *name ATTRIBUTE_UNUSED) {
5525 xmlXPathFreeObject((xmlXPathObjectPtr) obj);
5526 }
5527
5528 /**
5529 * xmlXPathReleaseObject:
5530 * @obj: the xmlXPathObjectPtr to free or to cache
5531 *
5532 * Depending on the state of the cache this frees the given
5533 * XPath object or stores it in the cache.
5534 */
5535 static void
5536 xmlXPathReleaseObject(xmlXPathContextPtr ctxt, xmlXPathObjectPtr obj)
5537 {
5538 #define XP_CACHE_ADD(sl, o) if (sl == NULL) { \
5539 sl = xmlPointerListCreate(10); if (sl == NULL) goto free_obj; } \
5540 if (xmlPointerListAddSize(sl, obj, 0) == -1) goto free_obj;
5541
5542 #define XP_CACHE_WANTS(sl, n) ((sl == NULL) || ((sl)->number < n))
5543
5544 if (obj == NULL)
5545 return;
5546 if ((ctxt == NULL) || (ctxt->cache == NULL)) {
5547 xmlXPathFreeObject(obj);
5548 } else {
5549 xmlXPathContextCachePtr cache =
5550 (xmlXPathContextCachePtr) ctxt->cache;
5551
5552 switch (obj->type) {
5553 case XPATH_NODESET:
5554 case XPATH_XSLT_TREE:
5555 if (obj->nodesetval != NULL) {
5556 if (obj->boolval) {
5557 /*
5558 * It looks like the @boolval is used for
5559 * evaluation if this an XSLT Result Tree Fragment.
5560 * TODO: Check if this assumption is correct.
5561 */
5562 obj->type = XPATH_XSLT_TREE; /* just for debugging */
5563 xmlXPathFreeValueTree(obj->nodesetval);
5564 obj->nodesetval = NULL;
5565 } else if ((obj->nodesetval->nodeMax <= 40) &&
5566 (XP_CACHE_WANTS(cache->nodesetObjs,
5567 cache->maxNodeset)))
5568 {
5569 XP_CACHE_ADD(cache->nodesetObjs, obj);
5570 goto obj_cached;
5571 } else {
5572 xmlXPathFreeNodeSet(obj->nodesetval);
5573 obj->nodesetval = NULL;
5574 }
5575 }
5576 break;
5577 case XPATH_STRING:
5578 if (obj->stringval != NULL)
5579 xmlFree(obj->stringval);
5580
5581 if (XP_CACHE_WANTS(cache->stringObjs, cache->maxString)) {
5582 XP_CACHE_ADD(cache->stringObjs, obj);
5583 goto obj_cached;
5584 }
5585 break;
5586 case XPATH_BOOLEAN:
5587 if (XP_CACHE_WANTS(cache->booleanObjs, cache->maxBoolean)) {
5588 XP_CACHE_ADD(cache->booleanObjs, obj);
5589 goto obj_cached;
5590 }
5591 break;
5592 case XPATH_NUMBER:
5593 if (XP_CACHE_WANTS(cache->numberObjs, cache->maxNumber)) {
5594 XP_CACHE_ADD(cache->numberObjs, obj);
5595 goto obj_cached;
5596 }
5597 break;
5598 #ifdef LIBXML_XPTR_ENABLED
5599 case XPATH_LOCATIONSET:
5600 if (obj->user != NULL) {
5601 xmlXPtrFreeLocationSet(obj->user);
5602 }
5603 goto free_obj;
5604 #endif
5605 default:
5606 goto free_obj;
5607 }
5608
5609 /*
5610 * Fallback to adding to the misc-objects slot.
5611 */
5612 if (XP_CACHE_WANTS(cache->miscObjs, cache->maxMisc)) {
5613 XP_CACHE_ADD(cache->miscObjs, obj);
5614 } else
5615 goto free_obj;
5616
5617 obj_cached:
5618
5619 #ifdef XP_DEBUG_OBJ_USAGE
5620 xmlXPathDebugObjUsageReleased(ctxt, obj->type);
5621 #endif
5622
5623 if (obj->nodesetval != NULL) {
5624 xmlNodeSetPtr tmpset = obj->nodesetval;
5625
5626 /*
5627 * TODO: Due to those nasty ns-nodes, we need to traverse
5628 * the list and free the ns-nodes.
5629 * URGENT TODO: Check if it's actually slowing things down.
5630 * Maybe we shouldn't try to preserve the list.
5631 */
5632 if (tmpset->nodeNr > 1) {
5633 int i;
5634 xmlNodePtr node;
5635
5636 for (i = 0; i < tmpset->nodeNr; i++) {
5637 node = tmpset->nodeTab[i];
5638 if ((node != NULL) &&
5639 (node->type == XML_NAMESPACE_DECL))
5640 {
5641 xmlXPathNodeSetFreeNs((xmlNsPtr) node);
5642 }
5643 }
5644 } else if (tmpset->nodeNr == 1) {
5645 if ((tmpset->nodeTab[0] != NULL) &&
5646 (tmpset->nodeTab[0]->type == XML_NAMESPACE_DECL))
5647 xmlXPathNodeSetFreeNs((xmlNsPtr) tmpset->nodeTab[0]);
5648 }
5649 tmpset->nodeNr = 0;
5650 memset(obj, 0, sizeof(xmlXPathObject));
5651 obj->nodesetval = tmpset;
5652 } else
5653 memset(obj, 0, sizeof(xmlXPathObject));
5654
5655 return;
5656
5657 free_obj:
5658 /*
5659 * Cache is full; free the object.
5660 */
5661 if (obj->nodesetval != NULL)
5662 xmlXPathFreeNodeSet(obj->nodesetval);
5663 #ifdef XP_DEBUG_OBJ_USAGE
5664 xmlXPathDebugObjUsageReleased(NULL, obj->type);
5665 #endif
5666 xmlFree(obj);
5667 }
5668 return;
5669 }
5670
5671
5672 /************************************************************************
5673 * *
5674 * Type Casting Routines *
5675 * *
5676 ************************************************************************/
5677
5678 /**
5679 * xmlXPathCastBooleanToString:
5680 * @val: a boolean
5681 *
5682 * Converts a boolean to its string value.
5683 *
5684 * Returns a newly allocated string.
5685 */
5686 xmlChar *
5687 xmlXPathCastBooleanToString (int val) {
5688 xmlChar *ret;
5689 if (val)
5690 ret = xmlStrdup((const xmlChar *) "true");
5691 else
5692 ret = xmlStrdup((const xmlChar *) "false");
5693 return(ret);
5694 }
5695
5696 /**
5697 * xmlXPathCastNumberToString:
5698 * @val: a number
5699 *
5700 * Converts a number to its string value.
5701 *
5702 * Returns a newly allocated string.
5703 */
5704 xmlChar *
5705 xmlXPathCastNumberToString (double val) {
5706 xmlChar *ret;
5707 switch (xmlXPathIsInf(val)) {
5708 case 1:
5709 ret = xmlStrdup((const xmlChar *) "Infinity");
5710 break;
5711 case -1:
5712 ret = xmlStrdup((const xmlChar *) "-Infinity");
5713 break;
5714 default:
5715 if (xmlXPathIsNaN(val)) {
5716 ret = xmlStrdup((const xmlChar *) "NaN");
5717 } else if (val == 0) {
5718 /* Omit sign for negative zero. */
5719 ret = xmlStrdup((const xmlChar *) "0");
5720 } else {
5721 /* could be improved */
5722 char buf[100];
5723 xmlXPathFormatNumber(val, buf, 99);
5724 buf[99] = 0;
5725 ret = xmlStrdup((const xmlChar *) buf);
5726 }
5727 }
5728 return(ret);
5729 }
5730
5731 /**
5732 * xmlXPathCastNodeToString:
5733 * @node: a node
5734 *
5735 * Converts a node to its string value.
5736 *
5737 * Returns a newly allocated string.
5738 */
5739 xmlChar *
5740 xmlXPathCastNodeToString (xmlNodePtr node) {
5741 xmlChar *ret;
5742 if ((ret = xmlNodeGetContent(node)) == NULL)
5743 ret = xmlStrdup((const xmlChar *) "");
5744 return(ret);
5745 }
5746
5747 /**
5748 * xmlXPathCastNodeSetToString:
5749 * @ns: a node-set
5750 *
5751 * Converts a node-set to its string value.
5752 *
5753 * Returns a newly allocated string.
5754 */
5755 xmlChar *
5756 xmlXPathCastNodeSetToString (xmlNodeSetPtr ns) {
5757 if ((ns == NULL) || (ns->nodeNr == 0) || (ns->nodeTab == NULL))
5758 return(xmlStrdup((const xmlChar *) ""));
5759
5760 if (ns->nodeNr > 1)
5761 xmlXPathNodeSetSort(ns);
5762 return(xmlXPathCastNodeToString(ns->nodeTab[0]));
5763 }
5764
5765 /**
5766 * xmlXPathCastToString:
5767 * @val: an XPath object
5768 *
5769 * Converts an existing object to its string() equivalent
5770 *
5771 * Returns the allocated string value of the object, NULL in case of error.
5772 * It's up to the caller to free the string memory with xmlFree().
5773 */
5774 xmlChar *
5775 xmlXPathCastToString(xmlXPathObjectPtr val) {
5776 xmlChar *ret = NULL;
5777
5778 if (val == NULL)
5779 return(xmlStrdup((const xmlChar *) ""));
5780 switch (val->type) {
5781 case XPATH_UNDEFINED:
5782 #ifdef DEBUG_EXPR
5783 xmlGenericError(xmlGenericErrorContext, "String: undefined\n");
5784 #endif
5785 ret = xmlStrdup((const xmlChar *) "");
5786 break;
5787 case XPATH_NODESET:
5788 case XPATH_XSLT_TREE:
5789 ret = xmlXPathCastNodeSetToString(val->nodesetval);
5790 break;
5791 case XPATH_STRING:
5792 return(xmlStrdup(val->stringval));
5793 case XPATH_BOOLEAN:
5794 ret = xmlXPathCastBooleanToString(val->boolval);
5795 break;
5796 case XPATH_NUMBER: {
5797 ret = xmlXPathCastNumberToString(val->floatval);
5798 break;
5799 }
5800 case XPATH_USERS:
5801 case XPATH_POINT:
5802 case XPATH_RANGE:
5803 case XPATH_LOCATIONSET:
5804 TODO
5805 ret = xmlStrdup((const xmlChar *) "");
5806 break;
5807 }
5808 return(ret);
5809 }
5810
5811 /**
5812 * xmlXPathConvertString:
5813 * @val: an XPath object
5814 *
5815 * Converts an existing object to its string() equivalent
5816 *
5817 * Returns the new object, the old one is freed (or the operation
5818 * is done directly on @val)
5819 */
5820 xmlXPathObjectPtr
5821 xmlXPathConvertString(xmlXPathObjectPtr val) {
5822 xmlChar *res = NULL;
5823
5824 if (val == NULL)
5825 return(xmlXPathNewCString(""));
5826
5827 switch (val->type) {
5828 case XPATH_UNDEFINED:
5829 #ifdef DEBUG_EXPR
5830 xmlGenericError(xmlGenericErrorContext, "STRING: undefined\n");
5831 #endif
5832 break;
5833 case XPATH_NODESET:
5834 case XPATH_XSLT_TREE:
5835 res = xmlXPathCastNodeSetToString(val->nodesetval);
5836 break;
5837 case XPATH_STRING:
5838 return(val);
5839 case XPATH_BOOLEAN:
5840 res = xmlXPathCastBooleanToString(val->boolval);
5841 break;
5842 case XPATH_NUMBER:
5843 res = xmlXPathCastNumberToString(val->floatval);
5844 break;
5845 case XPATH_USERS:
5846 case XPATH_POINT:
5847 case XPATH_RANGE:
5848 case XPATH_LOCATIONSET:
5849 TODO;
5850 break;
5851 }
5852 xmlXPathFreeObject(val);
5853 if (res == NULL)
5854 return(xmlXPathNewCString(""));
5855 return(xmlXPathWrapString(res));
5856 }
5857
5858 /**
5859 * xmlXPathCastBooleanToNumber:
5860 * @val: a boolean
5861 *
5862 * Converts a boolean to its number value
5863 *
5864 * Returns the number value
5865 */
5866 double
5867 xmlXPathCastBooleanToNumber(int val) {
5868 if (val)
5869 return(1.0);
5870 return(0.0);
5871 }
5872
5873 /**
5874 * xmlXPathCastStringToNumber:
5875 * @val: a string
5876 *
5877 * Converts a string to its number value
5878 *
5879 * Returns the number value
5880 */
5881 double
5882 xmlXPathCastStringToNumber(const xmlChar * val) {
5883 return(xmlXPathStringEvalNumber(val));
5884 }
5885
5886 /**
5887 * xmlXPathCastNodeToNumber:
5888 * @node: a node
5889 *
5890 * Converts a node to its number value
5891 *
5892 * Returns the number value
5893 */
5894 double
5895 xmlXPathCastNodeToNumber (xmlNodePtr node) {
5896 xmlChar *strval;
5897 double ret;
5898
5899 if (node == NULL)
5900 return(NAN);
5901 strval = xmlXPathCastNodeToString(node);
5902 if (strval == NULL)
5903 return(NAN);
5904 ret = xmlXPathCastStringToNumber(strval);
5905 xmlFree(strval);
5906
5907 return(ret);
5908 }
5909
5910 /**
5911 * xmlXPathCastNodeSetToNumber:
5912 * @ns: a node-set
5913 *
5914 * Converts a node-set to its number value
5915 *
5916 * Returns the number value
5917 */
5918 double
5919 xmlXPathCastNodeSetToNumber (xmlNodeSetPtr ns) {
5920 xmlChar *str;
5921 double ret;
5922
5923 if (ns == NULL)
5924 return(NAN);
5925 str = xmlXPathCastNodeSetToString(ns);
5926 ret = xmlXPathCastStringToNumber(str);
5927 xmlFree(str);
5928 return(ret);
5929 }
5930
5931 /**
5932 * xmlXPathCastToNumber:
5933 * @val: an XPath object
5934 *
5935 * Converts an XPath object to its number value
5936 *
5937 * Returns the number value
5938 */
5939 double
5940 xmlXPathCastToNumber(xmlXPathObjectPtr val) {
5941 double ret = 0.0;
5942
5943 if (val == NULL)
5944 return(NAN);
5945 switch (val->type) {
5946 case XPATH_UNDEFINED:
5947 #ifdef DEGUB_EXPR
5948 xmlGenericError(xmlGenericErrorContext, "NUMBER: undefined\n");
5949 #endif
5950 ret = NAN;
5951 break;
5952 case XPATH_NODESET:
5953 case XPATH_XSLT_TREE:
5954 ret = xmlXPathCastNodeSetToNumber(val->nodesetval);
5955 break;
5956 case XPATH_STRING:
5957 ret = xmlXPathCastStringToNumber(val->stringval);
5958 break;
5959 case XPATH_NUMBER:
5960 ret = val->floatval;
5961 break;
5962 case XPATH_BOOLEAN:
5963 ret = xmlXPathCastBooleanToNumber(val->boolval);
5964 break;
5965 case XPATH_USERS:
5966 case XPATH_POINT:
5967 case XPATH_RANGE:
5968 case XPATH_LOCATIONSET:
5969 TODO;
5970 ret = NAN;
5971 break;
5972 }
5973 return(ret);
5974 }
5975
5976 /**
5977 * xmlXPathConvertNumber:
5978 * @val: an XPath object
5979 *
5980 * Converts an existing object to its number() equivalent
5981 *
5982 * Returns the new object, the old one is freed (or the operation
5983 * is done directly on @val)
5984 */
5985 xmlXPathObjectPtr
5986 xmlXPathConvertNumber(xmlXPathObjectPtr val) {
5987 xmlXPathObjectPtr ret;
5988
5989 if (val == NULL)
5990 return(xmlXPathNewFloat(0.0));
5991 if (val->type == XPATH_NUMBER)
5992 return(val);
5993 ret = xmlXPathNewFloat(xmlXPathCastToNumber(val));
5994 xmlXPathFreeObject(val);
5995 return(ret);
5996 }
5997
5998 /**
5999 * xmlXPathCastNumberToBoolean:
6000 * @val: a number
6001 *
6002 * Converts a number to its boolean value
6003 *
6004 * Returns the boolean value
6005 */
6006 int
6007 xmlXPathCastNumberToBoolean (double val) {
6008 if (xmlXPathIsNaN(val) || (val == 0.0))
6009 return(0);
6010 return(1);
6011 }
6012
6013 /**
6014 * xmlXPathCastStringToBoolean:
6015 * @val: a string
6016 *
6017 * Converts a string to its boolean value
6018 *
6019 * Returns the boolean value
6020 */
6021 int
6022 xmlXPathCastStringToBoolean (const xmlChar *val) {
6023 if ((val == NULL) || (xmlStrlen(val) == 0))
6024 return(0);
6025 return(1);
6026 }
6027
6028 /**
6029 * xmlXPathCastNodeSetToBoolean:
6030 * @ns: a node-set
6031 *
6032 * Converts a node-set to its boolean value
6033 *
6034 * Returns the boolean value
6035 */
6036 int
6037 xmlXPathCastNodeSetToBoolean (xmlNodeSetPtr ns) {
6038 if ((ns == NULL) || (ns->nodeNr == 0))
6039 return(0);
6040 return(1);
6041 }
6042
6043 /**
6044 * xmlXPathCastToBoolean:
6045 * @val: an XPath object
6046 *
6047 * Converts an XPath object to its boolean value
6048 *
6049 * Returns the boolean value
6050 */
6051 int
6052 xmlXPathCastToBoolean (xmlXPathObjectPtr val) {
6053 int ret = 0;
6054
6055 if (val == NULL)
6056 return(0);
6057 switch (val->type) {
6058 case XPATH_UNDEFINED:
6059 #ifdef DEBUG_EXPR
6060 xmlGenericError(xmlGenericErrorContext, "BOOLEAN: undefined\n");
6061 #endif
6062 ret = 0;
6063 break;
6064 case XPATH_NODESET:
6065 case XPATH_XSLT_TREE:
6066 ret = xmlXPathCastNodeSetToBoolean(val->nodesetval);
6067 break;
6068 case XPATH_STRING:
6069 ret = xmlXPathCastStringToBoolean(val->stringval);
6070 break;
6071 case XPATH_NUMBER:
6072 ret = xmlXPathCastNumberToBoolean(val->floatval);
6073 break;
6074 case XPATH_BOOLEAN:
6075 ret = val->boolval;
6076 break;
6077 case XPATH_USERS:
6078 case XPATH_POINT:
6079 case XPATH_RANGE:
6080 case XPATH_LOCATIONSET:
6081 TODO;
6082 ret = 0;
6083 break;
6084 }
6085 return(ret);
6086 }
6087
6088
6089 /**
6090 * xmlXPathConvertBoolean:
6091 * @val: an XPath object
6092 *
6093 * Converts an existing object to its boolean() equivalent
6094 *
6095 * Returns the new object, the old one is freed (or the operation
6096 * is done directly on @val)
6097 */
6098 xmlXPathObjectPtr
6099 xmlXPathConvertBoolean(xmlXPathObjectPtr val) {
6100 xmlXPathObjectPtr ret;
6101
6102 if (val == NULL)
6103 return(xmlXPathNewBoolean(0));
6104 if (val->type == XPATH_BOOLEAN)
6105 return(val);
6106 ret = xmlXPathNewBoolean(xmlXPathCastToBoolean(val));
6107 xmlXPathFreeObject(val);
6108 return(ret);
6109 }
6110
6111 /************************************************************************
6112 * *
6113 * Routines to handle XPath contexts *
6114 * *
6115 ************************************************************************/
6116
6117 /**
6118 * xmlXPathNewContext:
6119 * @doc: the XML document
6120 *
6121 * Create a new xmlXPathContext
6122 *
6123 * Returns the xmlXPathContext just allocated. The caller will need to free it.
6124 */
6125 xmlXPathContextPtr
6126 xmlXPathNewContext(xmlDocPtr doc) {
6127 xmlXPathContextPtr ret;
6128
6129 ret = (xmlXPathContextPtr) xmlMalloc(sizeof(xmlXPathContext));
6130 if (ret == NULL) {
6131 xmlXPathErrMemory(NULL, "creating context\n");
6132 return(NULL);
6133 }
6134 memset(ret, 0 , (size_t) sizeof(xmlXPathContext));
6135 ret->doc = doc;
6136 ret->node = NULL;
6137
6138 ret->varHash = NULL;
6139
6140 ret->nb_types = 0;
6141 ret->max_types = 0;
6142 ret->types = NULL;
6143
6144 ret->funcHash = xmlHashCreate(0);
6145
6146 ret->nb_axis = 0;
6147 ret->max_axis = 0;
6148 ret->axis = NULL;
6149
6150 ret->nsHash = NULL;
6151 ret->user = NULL;
6152
6153 ret->contextSize = -1;
6154 ret->proximityPosition = -1;
6155
6156 #ifdef XP_DEFAULT_CACHE_ON
6157 if (xmlXPathContextSetCache(ret, 1, -1, 0) == -1) {
6158 xmlXPathFreeContext(ret);
6159 return(NULL);
6160 }
6161 #endif
6162
6163 xmlXPathRegisterAllFunctions(ret);
6164
6165 return(ret);
6166 }
6167
6168 /**
6169 * xmlXPathFreeContext:
6170 * @ctxt: the context to free
6171 *
6172 * Free up an xmlXPathContext
6173 */
6174 void
6175 xmlXPathFreeContext(xmlXPathContextPtr ctxt) {
6176 if (ctxt == NULL) return;
6177
6178 if (ctxt->cache != NULL)
6179 xmlXPathFreeCache((xmlXPathContextCachePtr) ctxt->cache);
6180 xmlXPathRegisteredNsCleanup(ctxt);
6181 xmlXPathRegisteredFuncsCleanup(ctxt);
6182 xmlXPathRegisteredVariablesCleanup(ctxt);
6183 xmlResetError(&ctxt->lastError);
6184 xmlFree(ctxt);
6185 }
6186
6187 /************************************************************************
6188 * *
6189 * Routines to handle XPath parser contexts *
6190 * *
6191 ************************************************************************/
6192
6193 #define CHECK_CTXT(ctxt) \
6194 if (ctxt == NULL) { \
6195 __xmlRaiseError(NULL, NULL, NULL, \
6196 NULL, NULL, XML_FROM_XPATH, \
6197 XML_ERR_INTERNAL_ERROR, XML_ERR_FATAL, \
6198 __FILE__, __LINE__, \
6199 NULL, NULL, NULL, 0, 0, \
6200 "NULL context pointer\n"); \
6201 return(NULL); \
6202 } \
6203
6204 #define CHECK_CTXT_NEG(ctxt) \
6205 if (ctxt == NULL) { \
6206 __xmlRaiseError(NULL, NULL, NULL, \
6207 NULL, NULL, XML_FROM_XPATH, \
6208 XML_ERR_INTERNAL_ERROR, XML_ERR_FATAL, \
6209 __FILE__, __LINE__, \
6210 NULL, NULL, NULL, 0, 0, \
6211 "NULL context pointer\n"); \
6212 return(-1); \
6213 } \
6214
6215
6216 #define CHECK_CONTEXT(ctxt) \
6217 if ((ctxt == NULL) || (ctxt->doc == NULL) || \
6218 (ctxt->doc->children == NULL)) { \
6219 xmlXPatherror(ctxt, __FILE__, __LINE__, XPATH_INVALID_CTXT); \
6220 return(NULL); \
6221 }
6222
6223
6224 /**
6225 * xmlXPathNewParserContext:
6226 * @str: the XPath expression
6227 * @ctxt: the XPath context
6228 *
6229 * Create a new xmlXPathParserContext
6230 *
6231 * Returns the xmlXPathParserContext just allocated.
6232 */
6233 xmlXPathParserContextPtr
6234 xmlXPathNewParserContext(const xmlChar *str, xmlXPathContextPtr ctxt) {
6235 xmlXPathParserContextPtr ret;
6236
6237 ret = (xmlXPathParserContextPtr) xmlMalloc(sizeof(xmlXPathParserContext));
6238 if (ret == NULL) {
6239 xmlXPathErrMemory(ctxt, "creating parser context\n");
6240 return(NULL);
6241 }
6242 memset(ret, 0 , (size_t) sizeof(xmlXPathParserContext));
6243 ret->cur = ret->base = str;
6244 ret->context = ctxt;
6245
6246 ret->comp = xmlXPathNewCompExpr();
6247 if (ret->comp == NULL) {
6248 xmlFree(ret->valueTab);
6249 xmlFree(ret);
6250 return(NULL);
6251 }
6252 if ((ctxt != NULL) && (ctxt->dict != NULL)) {
6253 ret->comp->dict = ctxt->dict;
6254 xmlDictReference(ret->comp->dict);
6255 }
6256
6257 return(ret);
6258 }
6259
6260 /**
6261 * xmlXPathCompParserContext:
6262 * @comp: the XPath compiled expression
6263 * @ctxt: the XPath context
6264 *
6265 * Create a new xmlXPathParserContext when processing a compiled expression
6266 *
6267 * Returns the xmlXPathParserContext just allocated.
6268 */
6269 static xmlXPathParserContextPtr
6270 xmlXPathCompParserContext(xmlXPathCompExprPtr comp, xmlXPathContextPtr ctxt) {
6271 xmlXPathParserContextPtr ret;
6272
6273 ret = (xmlXPathParserContextPtr) xmlMalloc(sizeof(xmlXPathParserContext));
6274 if (ret == NULL) {
6275 xmlXPathErrMemory(ctxt, "creating evaluation context\n");
6276 return(NULL);
6277 }
6278 memset(ret, 0 , (size_t) sizeof(xmlXPathParserContext));
6279
6280 /* Allocate the value stack */
6281 ret->valueTab = (xmlXPathObjectPtr *)
6282 xmlMalloc(10 * sizeof(xmlXPathObjectPtr));
6283 if (ret->valueTab == NULL) {
6284 xmlFree(ret);
6285 xmlXPathErrMemory(ctxt, "creating evaluation context\n");
6286 return(NULL);
6287 }
6288 ret->valueNr = 0;
6289 ret->valueMax = 10;
6290 ret->value = NULL;
6291 ret->valueFrame = 0;
6292
6293 ret->context = ctxt;
6294 ret->comp = comp;
6295
6296 return(ret);
6297 }
6298
6299 /**
6300 * xmlXPathFreeParserContext:
6301 * @ctxt: the context to free
6302 *
6303 * Free up an xmlXPathParserContext
6304 */
6305 void
6306 xmlXPathFreeParserContext(xmlXPathParserContextPtr ctxt) {
6307 int i;
6308
6309 if (ctxt->valueTab != NULL) {
6310 for (i = 0; i < ctxt->valueNr; i++) {
6311 if (ctxt->context)
6312 xmlXPathReleaseObject(ctxt->context, ctxt->valueTab[i]);
6313 else
6314 xmlXPathFreeObject(ctxt->valueTab[i]);
6315 }
6316 xmlFree(ctxt->valueTab);
6317 }
6318 if (ctxt->comp != NULL) {
6319 #ifdef XPATH_STREAMING
6320 if (ctxt->comp->stream != NULL) {
6321 xmlFreePatternList(ctxt->comp->stream);
6322 ctxt->comp->stream = NULL;
6323 }
6324 #endif
6325 xmlXPathFreeCompExpr(ctxt->comp);
6326 }
6327 xmlFree(ctxt);
6328 }
6329
6330 /************************************************************************
6331 * *
6332 * The implicit core function library *
6333 * *
6334 ************************************************************************/
6335
6336 /**
6337 * xmlXPathNodeValHash:
6338 * @node: a node pointer
6339 *
6340 * Function computing the beginning of the string value of the node,
6341 * used to speed up comparisons
6342 *
6343 * Returns an int usable as a hash
6344 */
6345 static unsigned int
6346 xmlXPathNodeValHash(xmlNodePtr node) {
6347 int len = 2;
6348 const xmlChar * string = NULL;
6349 xmlNodePtr tmp = NULL;
6350 unsigned int ret = 0;
6351
6352 if (node == NULL)
6353 return(0);
6354
6355 if (node->type == XML_DOCUMENT_NODE) {
6356 tmp = xmlDocGetRootElement((xmlDocPtr) node);
6357 if (tmp == NULL)
6358 node = node->children;
6359 else
6360 node = tmp;
6361
6362 if (node == NULL)
6363 return(0);
6364 }
6365
6366 switch (node->type) {
6367 case XML_COMMENT_NODE:
6368 case XML_PI_NODE:
6369 case XML_CDATA_SECTION_NODE:
6370 case XML_TEXT_NODE:
6371 string = node->content;
6372 if (string == NULL)
6373 return(0);
6374 if (string[0] == 0)
6375 return(0);
6376 return(((unsigned int) string[0]) +
6377 (((unsigned int) string[1]) << 8));
6378 case XML_NAMESPACE_DECL:
6379 string = ((xmlNsPtr)node)->href;
6380 if (string == NULL)
6381 return(0);
6382 if (string[0] == 0)
6383 return(0);
6384 return(((unsigned int) string[0]) +
6385 (((unsigned int) string[1]) << 8));
6386 case XML_ATTRIBUTE_NODE:
6387 tmp = ((xmlAttrPtr) node)->children;
6388 break;
6389 case XML_ELEMENT_NODE:
6390 tmp = node->children;
6391 break;
6392 default:
6393 return(0);
6394 }
6395 while (tmp != NULL) {
6396 switch (tmp->type) {
6397 case XML_CDATA_SECTION_NODE:
6398 case XML_TEXT_NODE:
6399 string = tmp->content;
6400 break;
6401 default:
6402 string = NULL;
6403 break;
6404 }
6405 if ((string != NULL) && (string[0] != 0)) {
6406 if (len == 1) {
6407 return(ret + (((unsigned int) string[0]) << 8));
6408 }
6409 if (string[1] == 0) {
6410 len = 1;
6411 ret = (unsigned int) string[0];
6412 } else {
6413 return(((unsigned int) string[0]) +
6414 (((unsigned int) string[1]) << 8));
6415 }
6416 }
6417 /*
6418 * Skip to next node
6419 */
6420 if ((tmp->children != NULL) && (tmp->type != XML_DTD_NODE)) {
6421 if (tmp->children->type != XML_ENTITY_DECL) {
6422 tmp = tmp->children;
6423 continue;
6424 }
6425 }
6426 if (tmp == node)
6427 break;
6428
6429 if (tmp->next != NULL) {
6430 tmp = tmp->next;
6431 continue;
6432 }
6433
6434 do {
6435 tmp = tmp->parent;
6436 if (tmp == NULL)
6437 break;
6438 if (tmp == node) {
6439 tmp = NULL;
6440 break;
6441 }
6442 if (tmp->next != NULL) {
6443 tmp = tmp->next;
6444 break;
6445 }
6446 } while (tmp != NULL);
6447 }
6448 return(ret);
6449 }
6450
6451 /**
6452 * xmlXPathStringHash:
6453 * @string: a string
6454 *
6455 * Function computing the beginning of the string value of the node,
6456 * used to speed up comparisons
6457 *
6458 * Returns an int usable as a hash
6459 */
6460 static unsigned int
6461 xmlXPathStringHash(const xmlChar * string) {
6462 if (string == NULL)
6463 return((unsigned int) 0);
6464 if (string[0] == 0)
6465 return(0);
6466 return(((unsigned int) string[0]) +
6467 (((unsigned int) string[1]) << 8));
6468 }
6469
6470 /**
6471 * xmlXPathCompareNodeSetFloat:
6472 * @ctxt: the XPath Parser context
6473 * @inf: less than (1) or greater than (0)
6474 * @strict: is the comparison strict
6475 * @arg: the node set
6476 * @f: the value
6477 *
6478 * Implement the compare operation between a nodeset and a number
6479 * @ns < @val (1, 1, ...
6480 * @ns <= @val (1, 0, ...
6481 * @ns > @val (0, 1, ...
6482 * @ns >= @val (0, 0, ...
6483 *
6484 * If one object to be compared is a node-set and the other is a number,
6485 * then the comparison will be true if and only if there is a node in the
6486 * node-set such that the result of performing the comparison on the number
6487 * to be compared and on the result of converting the string-value of that
6488 * node to a number using the number function is true.
6489 *
6490 * Returns 0 or 1 depending on the results of the test.
6491 */
6492 static int
6493 xmlXPathCompareNodeSetFloat(xmlXPathParserContextPtr ctxt, int inf, int strict,
6494 xmlXPathObjectPtr arg, xmlXPathObjectPtr f) {
6495 int i, ret = 0;
6496 xmlNodeSetPtr ns;
6497 xmlChar *str2;
6498
6499 if ((f == NULL) || (arg == NULL) ||
6500 ((arg->type != XPATH_NODESET) && (arg->type != XPATH_XSLT_TREE))) {
6501 xmlXPathReleaseObject(ctxt->context, arg);
6502 xmlXPathReleaseObject(ctxt->context, f);
6503 return(0);
6504 }
6505 ns = arg->nodesetval;
6506 if (ns != NULL) {
6507 for (i = 0;i < ns->nodeNr;i++) {
6508 str2 = xmlXPathCastNodeToString(ns->nodeTab[i]);
6509 if (str2 != NULL) {
6510 valuePush(ctxt,
6511 xmlXPathCacheNewString(ctxt->context, str2));
6512 xmlFree(str2);
6513 xmlXPathNumberFunction(ctxt, 1);
6514 valuePush(ctxt, xmlXPathCacheObjectCopy(ctxt->context, f));
6515 ret = xmlXPathCompareValues(ctxt, inf, strict);
6516 if (ret)
6517 break;
6518 }
6519 }
6520 }
6521 xmlXPathReleaseObject(ctxt->context, arg);
6522 xmlXPathReleaseObject(ctxt->context, f);
6523 return(ret);
6524 }
6525
6526 /**
6527 * xmlXPathCompareNodeSetString:
6528 * @ctxt: the XPath Parser context
6529 * @inf: less than (1) or greater than (0)
6530 * @strict: is the comparison strict
6531 * @arg: the node set
6532 * @s: the value
6533 *
6534 * Implement the compare operation between a nodeset and a string
6535 * @ns < @val (1, 1, ...
6536 * @ns <= @val (1, 0, ...
6537 * @ns > @val (0, 1, ...
6538 * @ns >= @val (0, 0, ...
6539 *
6540 * If one object to be compared is a node-set and the other is a string,
6541 * then the comparison will be true if and only if there is a node in
6542 * the node-set such that the result of performing the comparison on the
6543 * string-value of the node and the other string is true.
6544 *
6545 * Returns 0 or 1 depending on the results of the test.
6546 */
6547 static int
6548 xmlXPathCompareNodeSetString(xmlXPathParserContextPtr ctxt, int inf, int strict,
6549 xmlXPathObjectPtr arg, xmlXPathObjectPtr s) {
6550 int i, ret = 0;
6551 xmlNodeSetPtr ns;
6552 xmlChar *str2;
6553
6554 if ((s == NULL) || (arg == NULL) ||
6555 ((arg->type != XPATH_NODESET) && (arg->type != XPATH_XSLT_TREE))) {
6556 xmlXPathReleaseObject(ctxt->context, arg);
6557 xmlXPathReleaseObject(ctxt->context, s);
6558 return(0);
6559 }
6560 ns = arg->nodesetval;
6561 if (ns != NULL) {
6562 for (i = 0;i < ns->nodeNr;i++) {
6563 str2 = xmlXPathCastNodeToString(ns->nodeTab[i]);
6564 if (str2 != NULL) {
6565 valuePush(ctxt,
6566 xmlXPathCacheNewString(ctxt->context, str2));
6567 xmlFree(str2);
6568 valuePush(ctxt, xmlXPathCacheObjectCopy(ctxt->context, s));
6569 ret = xmlXPathCompareValues(ctxt, inf, strict);
6570 if (ret)
6571 break;
6572 }
6573 }
6574 }
6575 xmlXPathReleaseObject(ctxt->context, arg);
6576 xmlXPathReleaseObject(ctxt->context, s);
6577 return(ret);
6578 }
6579
6580 /**
6581 * xmlXPathCompareNodeSets:
6582 * @inf: less than (1) or greater than (0)
6583 * @strict: is the comparison strict
6584 * @arg1: the first node set object
6585 * @arg2: the second node set object
6586 *
6587 * Implement the compare operation on nodesets:
6588 *
6589 * If both objects to be compared are node-sets, then the comparison
6590 * will be true if and only if there is a node in the first node-set
6591 * and a node in the second node-set such that the result of performing
6592 * the comparison on the string-values of the two nodes is true.
6593 * ....
6594 * When neither object to be compared is a node-set and the operator
6595 * is <=, <, >= or >, then the objects are compared by converting both
6596 * objects to numbers and comparing the numbers according to IEEE 754.
6597 * ....
6598 * The number function converts its argument to a number as follows:
6599 * - a string that consists of optional whitespace followed by an
6600 * optional minus sign followed by a Number followed by whitespace
6601 * is converted to the IEEE 754 number that is nearest (according
6602 * to the IEEE 754 round-to-nearest rule) to the mathematical value
6603 * represented by the string; any other string is converted to NaN
6604 *
6605 * Conclusion all nodes need to be converted first to their string value
6606 * and then the comparison must be done when possible
6607 */
6608 static int
6609 xmlXPathCompareNodeSets(int inf, int strict,
6610 xmlXPathObjectPtr arg1, xmlXPathObjectPtr arg2) {
6611 int i, j, init = 0;
6612 double val1;
6613 double *values2;
6614 int ret = 0;
6615 xmlNodeSetPtr ns1;
6616 xmlNodeSetPtr ns2;
6617
6618 if ((arg1 == NULL) ||
6619 ((arg1->type != XPATH_NODESET) && (arg1->type != XPATH_XSLT_TREE))) {
6620 xmlXPathFreeObject(arg2);
6621 return(0);
6622 }
6623 if ((arg2 == NULL) ||
6624 ((arg2->type != XPATH_NODESET) && (arg2->type != XPATH_XSLT_TREE))) {
6625 xmlXPathFreeObject(arg1);
6626 xmlXPathFreeObject(arg2);
6627 return(0);
6628 }
6629
6630 ns1 = arg1->nodesetval;
6631 ns2 = arg2->nodesetval;
6632
6633 if ((ns1 == NULL) || (ns1->nodeNr <= 0)) {
6634 xmlXPathFreeObject(arg1);
6635 xmlXPathFreeObject(arg2);
6636 return(0);
6637 }
6638 if ((ns2 == NULL) || (ns2->nodeNr <= 0)) {
6639 xmlXPathFreeObject(arg1);
6640 xmlXPathFreeObject(arg2);
6641 return(0);
6642 }
6643
6644 values2 = (double *) xmlMalloc(ns2->nodeNr * sizeof(double));
6645 if (values2 == NULL) {
6646 xmlXPathErrMemory(NULL, "comparing nodesets\n");
6647 xmlXPathFreeObject(arg1);
6648 xmlXPathFreeObject(arg2);
6649 return(0);
6650 }
6651 for (i = 0;i < ns1->nodeNr;i++) {
6652 val1 = xmlXPathCastNodeToNumber(ns1->nodeTab[i]);
6653 if (xmlXPathIsNaN(val1))
6654 continue;
6655 for (j = 0;j < ns2->nodeNr;j++) {
6656 if (init == 0) {
6657 values2[j] = xmlXPathCastNodeToNumber(ns2->nodeTab[j]);
6658 }
6659 if (xmlXPathIsNaN(values2[j]))
6660 continue;
6661 if (inf && strict)
6662 ret = (val1 < values2[j]);
6663 else 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 if (ret)
6670 break;
6671 }
6672 if (ret)
6673 break;
6674 init = 1;
6675 }
6676 xmlFree(values2);
6677 xmlXPathFreeObject(arg1);
6678 xmlXPathFreeObject(arg2);
6679 return(ret);
6680 }
6681
6682 /**
6683 * xmlXPathCompareNodeSetValue:
6684 * @ctxt: the XPath Parser context
6685 * @inf: less than (1) or greater than (0)
6686 * @strict: is the comparison strict
6687 * @arg: the node set
6688 * @val: the value
6689 *
6690 * Implement the compare operation between a nodeset and a value
6691 * @ns < @val (1, 1, ...
6692 * @ns <= @val (1, 0, ...
6693 * @ns > @val (0, 1, ...
6694 * @ns >= @val (0, 0, ...
6695 *
6696 * If one object to be compared is a node-set and the other is a boolean,
6697 * then the comparison will be true if and only if the result of performing
6698 * the comparison on the boolean and on the result of converting
6699 * the node-set to a boolean using the boolean function is true.
6700 *
6701 * Returns 0 or 1 depending on the results of the test.
6702 */
6703 static int
6704 xmlXPathCompareNodeSetValue(xmlXPathParserContextPtr ctxt, int inf, int strict,
6705 xmlXPathObjectPtr arg, xmlXPathObjectPtr val) {
6706 if ((val == NULL) || (arg == NULL) ||
6707 ((arg->type != XPATH_NODESET) && (arg->type != XPATH_XSLT_TREE)))
6708 return(0);
6709
6710 switch(val->type) {
6711 case XPATH_NUMBER:
6712 return(xmlXPathCompareNodeSetFloat(ctxt, inf, strict, arg, val));
6713 case XPATH_NODESET:
6714 case XPATH_XSLT_TREE:
6715 return(xmlXPathCompareNodeSets(inf, strict, arg, val));
6716 case XPATH_STRING:
6717 return(xmlXPathCompareNodeSetString(ctxt, inf, strict, arg, val));
6718 case XPATH_BOOLEAN:
6719 valuePush(ctxt, arg);
6720 xmlXPathBooleanFunction(ctxt, 1);
6721 valuePush(ctxt, val);
6722 return(xmlXPathCompareValues(ctxt, inf, strict));
6723 default:
6724 xmlGenericError(xmlGenericErrorContext,
6725 "xmlXPathCompareNodeSetValue: Can't compare node set "
6726 "and object of type %d\n",
6727 val->type);
6728 xmlXPathReleaseObject(ctxt->context, arg);
6729 xmlXPathReleaseObject(ctxt->context, val);
6730 XP_ERROR0(XPATH_INVALID_TYPE);
6731 }
6732 return(0);
6733 }
6734
6735 /**
6736 * xmlXPathEqualNodeSetString:
6737 * @arg: the nodeset object argument
6738 * @str: the string to compare to.
6739 * @neq: flag to show whether for '=' (0) or '!=' (1)
6740 *
6741 * Implement the equal operation on XPath objects content: @arg1 == @arg2
6742 * If one object to be compared is a node-set and the other is a string,
6743 * then the comparison will be true if and only if there is a node in
6744 * the node-set such that the result of performing the comparison on the
6745 * string-value of the node and the other string is true.
6746 *
6747 * Returns 0 or 1 depending on the results of the test.
6748 */
6749 static int
6750 xmlXPathEqualNodeSetString(xmlXPathObjectPtr arg, const xmlChar * str, int neq)
6751 {
6752 int i;
6753 xmlNodeSetPtr ns;
6754 xmlChar *str2;
6755 unsigned int hash;
6756
6757 if ((str == NULL) || (arg == NULL) ||
6758 ((arg->type != XPATH_NODESET) && (arg->type != XPATH_XSLT_TREE)))
6759 return (0);
6760 ns = arg->nodesetval;
6761 /*
6762 * A NULL nodeset compared with a string is always false
6763 * (since there is no node equal, and no node not equal)
6764 */
6765 if ((ns == NULL) || (ns->nodeNr <= 0) )
6766 return (0);
6767 hash = xmlXPathStringHash(str);
6768 for (i = 0; i < ns->nodeNr; i++) {
6769 if (xmlXPathNodeValHash(ns->nodeTab[i]) == hash) {
6770 str2 = xmlNodeGetContent(ns->nodeTab[i]);
6771 if ((str2 != NULL) && (xmlStrEqual(str, str2))) {
6772 xmlFree(str2);
6773 if (neq)
6774 continue;
6775 return (1);
6776 } else if ((str2 == NULL) && (xmlStrEqual(str, BAD_CAST ""))) {
6777 if (neq)
6778 continue;
6779 return (1);
6780 } else if (neq) {
6781 if (str2 != NULL)
6782 xmlFree(str2);
6783 return (1);
6784 }
6785 if (str2 != NULL)
6786 xmlFree(str2);
6787 } else if (neq)
6788 return (1);
6789 }
6790 return (0);
6791 }
6792
6793 /**
6794 * xmlXPathEqualNodeSetFloat:
6795 * @arg: the nodeset object argument
6796 * @f: the float to compare to
6797 * @neq: flag to show whether to compare '=' (0) or '!=' (1)
6798 *
6799 * Implement the equal operation on XPath objects content: @arg1 == @arg2
6800 * If one object to be compared is a node-set and the other is a number,
6801 * then the comparison will be true if and only if there is a node in
6802 * the node-set such that the result of performing the comparison on the
6803 * number to be compared and on the result of converting the string-value
6804 * of that node to a number using the number function is true.
6805 *
6806 * Returns 0 or 1 depending on the results of the test.
6807 */
6808 static int
6809 xmlXPathEqualNodeSetFloat(xmlXPathParserContextPtr ctxt,
6810 xmlXPathObjectPtr arg, double f, int neq) {
6811 int i, ret=0;
6812 xmlNodeSetPtr ns;
6813 xmlChar *str2;
6814 xmlXPathObjectPtr val;
6815 double v;
6816
6817 if ((arg == NULL) ||
6818 ((arg->type != XPATH_NODESET) && (arg->type != XPATH_XSLT_TREE)))
6819 return(0);
6820
6821 ns = arg->nodesetval;
6822 if (ns != NULL) {
6823 for (i=0;i<ns->nodeNr;i++) {
6824 str2 = xmlXPathCastNodeToString(ns->nodeTab[i]);
6825 if (str2 != NULL) {
6826 valuePush(ctxt, xmlXPathCacheNewString(ctxt->context, str2));
6827 xmlFree(str2);
6828 xmlXPathNumberFunction(ctxt, 1);
6829 val = valuePop(ctxt);
6830 v = val->floatval;
6831 xmlXPathReleaseObject(ctxt->context, val);
6832 if (!xmlXPathIsNaN(v)) {
6833 if ((!neq) && (v==f)) {
6834 ret = 1;
6835 break;
6836 } else if ((neq) && (v!=f)) {
6837 ret = 1;
6838 break;
6839 }
6840 } else { /* NaN is unequal to any value */
6841 if (neq)
6842 ret = 1;
6843 }
6844 }
6845 }
6846 }
6847
6848 return(ret);
6849 }
6850
6851
6852 /**
6853 * xmlXPathEqualNodeSets:
6854 * @arg1: first nodeset object argument
6855 * @arg2: second nodeset object argument
6856 * @neq: flag to show whether to test '=' (0) or '!=' (1)
6857 *
6858 * Implement the equal / not equal operation on XPath nodesets:
6859 * @arg1 == @arg2 or @arg1 != @arg2
6860 * If both objects to be compared are node-sets, then the comparison
6861 * will be true if and only if there is a node in the first node-set and
6862 * a node in the second node-set such that the result of performing the
6863 * comparison on the string-values of the two nodes is true.
6864 *
6865 * (needless to say, this is a costly operation)
6866 *
6867 * Returns 0 or 1 depending on the results of the test.
6868 */
6869 static int
6870 xmlXPathEqualNodeSets(xmlXPathObjectPtr arg1, xmlXPathObjectPtr arg2, int neq) {
6871 int i, j;
6872 unsigned int *hashs1;
6873 unsigned int *hashs2;
6874 xmlChar **values1;
6875 xmlChar **values2;
6876 int ret = 0;
6877 xmlNodeSetPtr ns1;
6878 xmlNodeSetPtr ns2;
6879
6880 if ((arg1 == NULL) ||
6881 ((arg1->type != XPATH_NODESET) && (arg1->type != XPATH_XSLT_TREE)))
6882 return(0);
6883 if ((arg2 == NULL) ||
6884 ((arg2->type != XPATH_NODESET) && (arg2->type != XPATH_XSLT_TREE)))
6885 return(0);
6886
6887 ns1 = arg1->nodesetval;
6888 ns2 = arg2->nodesetval;
6889
6890 if ((ns1 == NULL) || (ns1->nodeNr <= 0))
6891 return(0);
6892 if ((ns2 == NULL) || (ns2->nodeNr <= 0))
6893 return(0);
6894
6895 /*
6896 * for equal, check if there is a node pertaining to both sets
6897 */
6898 if (neq == 0)
6899 for (i = 0;i < ns1->nodeNr;i++)
6900 for (j = 0;j < ns2->nodeNr;j++)
6901 if (ns1->nodeTab[i] == ns2->nodeTab[j])
6902 return(1);
6903
6904 values1 = (xmlChar **) xmlMalloc(ns1->nodeNr * sizeof(xmlChar *));
6905 if (values1 == NULL) {
6906 xmlXPathErrMemory(NULL, "comparing nodesets\n");
6907 return(0);
6908 }
6909 hashs1 = (unsigned int *) xmlMalloc(ns1->nodeNr * sizeof(unsigned int));
6910 if (hashs1 == NULL) {
6911 xmlXPathErrMemory(NULL, "comparing nodesets\n");
6912 xmlFree(values1);
6913 return(0);
6914 }
6915 memset(values1, 0, ns1->nodeNr * sizeof(xmlChar *));
6916 values2 = (xmlChar **) xmlMalloc(ns2->nodeNr * sizeof(xmlChar *));
6917 if (values2 == NULL) {
6918 xmlXPathErrMemory(NULL, "comparing nodesets\n");
6919 xmlFree(hashs1);
6920 xmlFree(values1);
6921 return(0);
6922 }
6923 hashs2 = (unsigned int *) xmlMalloc(ns2->nodeNr * sizeof(unsigned int));
6924 if (hashs2 == NULL) {
6925 xmlXPathErrMemory(NULL, "comparing nodesets\n");
6926 xmlFree(hashs1);
6927 xmlFree(values1);
6928 xmlFree(values2);
6929 return(0);
6930 }
6931 memset(values2, 0, ns2->nodeNr * sizeof(xmlChar *));
6932 for (i = 0;i < ns1->nodeNr;i++) {
6933 hashs1[i] = xmlXPathNodeValHash(ns1->nodeTab[i]);
6934 for (j = 0;j < ns2->nodeNr;j++) {
6935 if (i == 0)
6936 hashs2[j] = xmlXPathNodeValHash(ns2->nodeTab[j]);
6937 if (hashs1[i] != hashs2[j]) {
6938 if (neq) {
6939 ret = 1;
6940 break;
6941 }
6942 }
6943 else {
6944 if (values1[i] == NULL)
6945 values1[i] = xmlNodeGetContent(ns1->nodeTab[i]);
6946 if (values2[j] == NULL)
6947 values2[j] = xmlNodeGetContent(ns2->nodeTab[j]);
6948 ret = xmlStrEqual(values1[i], values2[j]) ^ neq;
6949 if (ret)
6950 break;
6951 }
6952 }
6953 if (ret)
6954 break;
6955 }
6956 for (i = 0;i < ns1->nodeNr;i++)
6957 if (values1[i] != NULL)
6958 xmlFree(values1[i]);
6959 for (j = 0;j < ns2->nodeNr;j++)
6960 if (values2[j] != NULL)
6961 xmlFree(values2[j]);
6962 xmlFree(values1);
6963 xmlFree(values2);
6964 xmlFree(hashs1);
6965 xmlFree(hashs2);
6966 return(ret);
6967 }
6968
6969 static int
6970 xmlXPathEqualValuesCommon(xmlXPathParserContextPtr ctxt,
6971 xmlXPathObjectPtr arg1, xmlXPathObjectPtr arg2) {
6972 int ret = 0;
6973 /*
6974 *At this point we are assured neither arg1 nor arg2
6975 *is a nodeset, so we can just pick the appropriate routine.
6976 */
6977 switch (arg1->type) {
6978 case XPATH_UNDEFINED:
6979 #ifdef DEBUG_EXPR
6980 xmlGenericError(xmlGenericErrorContext,
6981 "Equal: undefined\n");
6982 #endif
6983 break;
6984 case XPATH_BOOLEAN:
6985 switch (arg2->type) {
6986 case XPATH_UNDEFINED:
6987 #ifdef DEBUG_EXPR
6988 xmlGenericError(xmlGenericErrorContext,
6989 "Equal: undefined\n");
6990 #endif
6991 break;
6992 case XPATH_BOOLEAN:
6993 #ifdef DEBUG_EXPR
6994 xmlGenericError(xmlGenericErrorContext,
6995 "Equal: %d boolean %d \n",
6996 arg1->boolval, arg2->boolval);
6997 #endif
6998 ret = (arg1->boolval == arg2->boolval);
6999 break;
7000 case XPATH_NUMBER:
7001 ret = (arg1->boolval ==
7002 xmlXPathCastNumberToBoolean(arg2->floatval));
7003 break;
7004 case XPATH_STRING:
7005 if ((arg2->stringval == NULL) ||
7006 (arg2->stringval[0] == 0)) ret = 0;
7007 else
7008 ret = 1;
7009 ret = (arg1->boolval == ret);
7010 break;
7011 case XPATH_USERS:
7012 case XPATH_POINT:
7013 case XPATH_RANGE:
7014 case XPATH_LOCATIONSET:
7015 TODO
7016 break;
7017 case XPATH_NODESET:
7018 case XPATH_XSLT_TREE:
7019 break;
7020 }
7021 break;
7022 case XPATH_NUMBER:
7023 switch (arg2->type) {
7024 case XPATH_UNDEFINED:
7025 #ifdef DEBUG_EXPR
7026 xmlGenericError(xmlGenericErrorContext,
7027 "Equal: undefined\n");
7028 #endif
7029 break;
7030 case XPATH_BOOLEAN:
7031 ret = (arg2->boolval==
7032 xmlXPathCastNumberToBoolean(arg1->floatval));
7033 break;
7034 case XPATH_STRING:
7035 valuePush(ctxt, arg2);
7036 xmlXPathNumberFunction(ctxt, 1);
7037 arg2 = valuePop(ctxt);
7038 /* Falls through. */
7039 case XPATH_NUMBER:
7040 /* Hand check NaN and Infinity equalities */
7041 if (xmlXPathIsNaN(arg1->floatval) ||
7042 xmlXPathIsNaN(arg2->floatval)) {
7043 ret = 0;
7044 } else if (xmlXPathIsInf(arg1->floatval) == 1) {
7045 if (xmlXPathIsInf(arg2->floatval) == 1)
7046 ret = 1;
7047 else
7048 ret = 0;
7049 } else if (xmlXPathIsInf(arg1->floatval) == -1) {
7050 if (xmlXPathIsInf(arg2->floatval) == -1)
7051 ret = 1;
7052 else
7053 ret = 0;
7054 } else if (xmlXPathIsInf(arg2->floatval) == 1) {
7055 if (xmlXPathIsInf(arg1->floatval) == 1)
7056 ret = 1;
7057 else
7058 ret = 0;
7059 } else if (xmlXPathIsInf(arg2->floatval) == -1) {
7060 if (xmlXPathIsInf(arg1->floatval) == -1)
7061 ret = 1;
7062 else
7063 ret = 0;
7064 } else {
7065 ret = (arg1->floatval == arg2->floatval);
7066 }
7067 break;
7068 case XPATH_USERS:
7069 case XPATH_POINT:
7070 case XPATH_RANGE:
7071 case XPATH_LOCATIONSET:
7072 TODO
7073 break;
7074 case XPATH_NODESET:
7075 case XPATH_XSLT_TREE:
7076 break;
7077 }
7078 break;
7079 case XPATH_STRING:
7080 switch (arg2->type) {
7081 case XPATH_UNDEFINED:
7082 #ifdef DEBUG_EXPR
7083 xmlGenericError(xmlGenericErrorContext,
7084 "Equal: undefined\n");
7085 #endif
7086 break;
7087 case XPATH_BOOLEAN:
7088 if ((arg1->stringval == NULL) ||
7089 (arg1->stringval[0] == 0)) ret = 0;
7090 else
7091 ret = 1;
7092 ret = (arg2->boolval == ret);
7093 break;
7094 case XPATH_STRING:
7095 ret = xmlStrEqual(arg1->stringval, arg2->stringval);
7096 break;
7097 case XPATH_NUMBER:
7098 valuePush(ctxt, arg1);
7099 xmlXPathNumberFunction(ctxt, 1);
7100 arg1 = valuePop(ctxt);
7101 /* Hand check NaN and Infinity equalities */
7102 if (xmlXPathIsNaN(arg1->floatval) ||
7103 xmlXPathIsNaN(arg2->floatval)) {
7104 ret = 0;
7105 } else if (xmlXPathIsInf(arg1->floatval) == 1) {
7106 if (xmlXPathIsInf(arg2->floatval) == 1)
7107 ret = 1;
7108 else
7109 ret = 0;
7110 } else if (xmlXPathIsInf(arg1->floatval) == -1) {
7111 if (xmlXPathIsInf(arg2->floatval) == -1)
7112 ret = 1;
7113 else
7114 ret = 0;
7115 } else if (xmlXPathIsInf(arg2->floatval) == 1) {
7116 if (xmlXPathIsInf(arg1->floatval) == 1)
7117 ret = 1;
7118 else
7119 ret = 0;
7120 } else if (xmlXPathIsInf(arg2->floatval) == -1) {
7121 if (xmlXPathIsInf(arg1->floatval) == -1)
7122 ret = 1;
7123 else
7124 ret = 0;
7125 } else {
7126 ret = (arg1->floatval == arg2->floatval);
7127 }
7128 break;
7129 case XPATH_USERS:
7130 case XPATH_POINT:
7131 case XPATH_RANGE:
7132 case XPATH_LOCATIONSET:
7133 TODO
7134 break;
7135 case XPATH_NODESET:
7136 case XPATH_XSLT_TREE:
7137 break;
7138 }
7139 break;
7140 case XPATH_USERS:
7141 case XPATH_POINT:
7142 case XPATH_RANGE:
7143 case XPATH_LOCATIONSET:
7144 TODO
7145 break;
7146 case XPATH_NODESET:
7147 case XPATH_XSLT_TREE:
7148 break;
7149 }
7150 xmlXPathReleaseObject(ctxt->context, arg1);
7151 xmlXPathReleaseObject(ctxt->context, arg2);
7152 return(ret);
7153 }
7154
7155 /**
7156 * xmlXPathEqualValues:
7157 * @ctxt: the XPath Parser context
7158 *
7159 * Implement the equal operation on XPath objects content: @arg1 == @arg2
7160 *
7161 * Returns 0 or 1 depending on the results of the test.
7162 */
7163 int
7164 xmlXPathEqualValues(xmlXPathParserContextPtr ctxt) {
7165 xmlXPathObjectPtr arg1, arg2, argtmp;
7166 int ret = 0;
7167
7168 if ((ctxt == NULL) || (ctxt->context == NULL)) return(0);
7169 arg2 = valuePop(ctxt);
7170 arg1 = valuePop(ctxt);
7171 if ((arg1 == NULL) || (arg2 == NULL)) {
7172 if (arg1 != NULL)
7173 xmlXPathReleaseObject(ctxt->context, arg1);
7174 else
7175 xmlXPathReleaseObject(ctxt->context, arg2);
7176 XP_ERROR0(XPATH_INVALID_OPERAND);
7177 }
7178
7179 if (arg1 == arg2) {
7180 #ifdef DEBUG_EXPR
7181 xmlGenericError(xmlGenericErrorContext,
7182 "Equal: by pointer\n");
7183 #endif
7184 xmlXPathFreeObject(arg1);
7185 return(1);
7186 }
7187
7188 /*
7189 *If either argument is a nodeset, it's a 'special case'
7190 */
7191 if ((arg2->type == XPATH_NODESET) || (arg2->type == XPATH_XSLT_TREE) ||
7192 (arg1->type == XPATH_NODESET) || (arg1->type == XPATH_XSLT_TREE)) {
7193 /*
7194 *Hack it to assure arg1 is the nodeset
7195 */
7196 if ((arg1->type != XPATH_NODESET) && (arg1->type != XPATH_XSLT_TREE)) {
7197 argtmp = arg2;
7198 arg2 = arg1;
7199 arg1 = argtmp;
7200 }
7201 switch (arg2->type) {
7202 case XPATH_UNDEFINED:
7203 #ifdef DEBUG_EXPR
7204 xmlGenericError(xmlGenericErrorContext,
7205 "Equal: undefined\n");
7206 #endif
7207 break;
7208 case XPATH_NODESET:
7209 case XPATH_XSLT_TREE:
7210 ret = xmlXPathEqualNodeSets(arg1, arg2, 0);
7211 break;
7212 case XPATH_BOOLEAN:
7213 if ((arg1->nodesetval == NULL) ||
7214 (arg1->nodesetval->nodeNr == 0)) ret = 0;
7215 else
7216 ret = 1;
7217 ret = (ret == arg2->boolval);
7218 break;
7219 case XPATH_NUMBER:
7220 ret = xmlXPathEqualNodeSetFloat(ctxt, arg1, arg2->floatval, 0);
7221 break;
7222 case XPATH_STRING:
7223 ret = xmlXPathEqualNodeSetString(arg1, arg2->stringval, 0);
7224 break;
7225 case XPATH_USERS:
7226 case XPATH_POINT:
7227 case XPATH_RANGE:
7228 case XPATH_LOCATIONSET:
7229 TODO
7230 break;
7231 }
7232 xmlXPathReleaseObject(ctxt->context, arg1);
7233 xmlXPathReleaseObject(ctxt->context, arg2);
7234 return(ret);
7235 }
7236
7237 return (xmlXPathEqualValuesCommon(ctxt, arg1, arg2));
7238 }
7239
7240 /**
7241 * xmlXPathNotEqualValues:
7242 * @ctxt: the XPath Parser context
7243 *
7244 * Implement the equal operation on XPath objects content: @arg1 == @arg2
7245 *
7246 * Returns 0 or 1 depending on the results of the test.
7247 */
7248 int
7249 xmlXPathNotEqualValues(xmlXPathParserContextPtr ctxt) {
7250 xmlXPathObjectPtr arg1, arg2, argtmp;
7251 int ret = 0;
7252
7253 if ((ctxt == NULL) || (ctxt->context == NULL)) return(0);
7254 arg2 = valuePop(ctxt);
7255 arg1 = valuePop(ctxt);
7256 if ((arg1 == NULL) || (arg2 == NULL)) {
7257 if (arg1 != NULL)
7258 xmlXPathReleaseObject(ctxt->context, arg1);
7259 else
7260 xmlXPathReleaseObject(ctxt->context, arg2);
7261 XP_ERROR0(XPATH_INVALID_OPERAND);
7262 }
7263
7264 if (arg1 == arg2) {
7265 #ifdef DEBUG_EXPR
7266 xmlGenericError(xmlGenericErrorContext,
7267 "NotEqual: by pointer\n");
7268 #endif
7269 xmlXPathReleaseObject(ctxt->context, arg1);
7270 return(0);
7271 }
7272
7273 /*
7274 *If either argument is a nodeset, it's a 'special case'
7275 */
7276 if ((arg2->type == XPATH_NODESET) || (arg2->type == XPATH_XSLT_TREE) ||
7277 (arg1->type == XPATH_NODESET) || (arg1->type == XPATH_XSLT_TREE)) {
7278 /*
7279 *Hack it to assure arg1 is the nodeset
7280 */
7281 if ((arg1->type != XPATH_NODESET) && (arg1->type != XPATH_XSLT_TREE)) {
7282 argtmp = arg2;
7283 arg2 = arg1;
7284 arg1 = argtmp;
7285 }
7286 switch (arg2->type) {
7287 case XPATH_UNDEFINED:
7288 #ifdef DEBUG_EXPR
7289 xmlGenericError(xmlGenericErrorContext,
7290 "NotEqual: undefined\n");
7291 #endif
7292 break;
7293 case XPATH_NODESET:
7294 case XPATH_XSLT_TREE:
7295 ret = xmlXPathEqualNodeSets(arg1, arg2, 1);
7296 break;
7297 case XPATH_BOOLEAN:
7298 if ((arg1->nodesetval == NULL) ||
7299 (arg1->nodesetval->nodeNr == 0)) ret = 0;
7300 else
7301 ret = 1;
7302 ret = (ret != arg2->boolval);
7303 break;
7304 case XPATH_NUMBER:
7305 ret = xmlXPathEqualNodeSetFloat(ctxt, arg1, arg2->floatval, 1);
7306 break;
7307 case XPATH_STRING:
7308 ret = xmlXPathEqualNodeSetString(arg1, arg2->stringval,1);
7309 break;
7310 case XPATH_USERS:
7311 case XPATH_POINT:
7312 case XPATH_RANGE:
7313 case XPATH_LOCATIONSET:
7314 TODO
7315 break;
7316 }
7317 xmlXPathReleaseObject(ctxt->context, arg1);
7318 xmlXPathReleaseObject(ctxt->context, arg2);
7319 return(ret);
7320 }
7321
7322 return (!xmlXPathEqualValuesCommon(ctxt, arg1, arg2));
7323 }
7324
7325 /**
7326 * xmlXPathCompareValues:
7327 * @ctxt: the XPath Parser context
7328 * @inf: less than (1) or greater than (0)
7329 * @strict: is the comparison strict
7330 *
7331 * Implement the compare operation on XPath objects:
7332 * @arg1 < @arg2 (1, 1, ...
7333 * @arg1 <= @arg2 (1, 0, ...
7334 * @arg1 > @arg2 (0, 1, ...
7335 * @arg1 >= @arg2 (0, 0, ...
7336 *
7337 * When neither object to be compared is a node-set and the operator is
7338 * <=, <, >=, >, then the objects are compared by converted both objects
7339 * to numbers and comparing the numbers according to IEEE 754. The <
7340 * comparison will be true if and only if the first number is less than the
7341 * second number. The <= comparison will be true if and only if the first
7342 * number is less than or equal to the second number. The > comparison
7343 * will be true if and only if the first number is greater than the second
7344 * number. The >= comparison will be true if and only if the first number
7345 * is greater than or equal to the second number.
7346 *
7347 * Returns 1 if the comparison succeeded, 0 if it failed
7348 */
7349 int
7350 xmlXPathCompareValues(xmlXPathParserContextPtr ctxt, int inf, int strict) {
7351 int ret = 0, arg1i = 0, arg2i = 0;
7352 xmlXPathObjectPtr arg1, arg2;
7353
7354 if ((ctxt == NULL) || (ctxt->context == NULL)) return(0);
7355 arg2 = valuePop(ctxt);
7356 arg1 = valuePop(ctxt);
7357 if ((arg1 == NULL) || (arg2 == NULL)) {
7358 if (arg1 != NULL)
7359 xmlXPathReleaseObject(ctxt->context, arg1);
7360 else
7361 xmlXPathReleaseObject(ctxt->context, arg2);
7362 XP_ERROR0(XPATH_INVALID_OPERAND);
7363 }
7364
7365 if ((arg2->type == XPATH_NODESET) || (arg2->type == XPATH_XSLT_TREE) ||
7366 (arg1->type == XPATH_NODESET) || (arg1->type == XPATH_XSLT_TREE)) {
7367 /*
7368 * If either argument is a XPATH_NODESET or XPATH_XSLT_TREE the two arguments
7369 * are not freed from within this routine; they will be freed from the
7370 * called routine, e.g. xmlXPathCompareNodeSets or xmlXPathCompareNodeSetValue
7371 */
7372 if (((arg2->type == XPATH_NODESET) || (arg2->type == XPATH_XSLT_TREE)) &&
7373 ((arg1->type == XPATH_NODESET) || (arg1->type == XPATH_XSLT_TREE))){
7374 ret = xmlXPathCompareNodeSets(inf, strict, arg1, arg2);
7375 } else {
7376 if ((arg1->type == XPATH_NODESET) || (arg1->type == XPATH_XSLT_TREE)) {
7377 ret = xmlXPathCompareNodeSetValue(ctxt, inf, strict,
7378 arg1, arg2);
7379 } else {
7380 ret = xmlXPathCompareNodeSetValue(ctxt, !inf, strict,
7381 arg2, arg1);
7382 }
7383 }
7384 return(ret);
7385 }
7386
7387 if (arg1->type != XPATH_NUMBER) {
7388 valuePush(ctxt, arg1);
7389 xmlXPathNumberFunction(ctxt, 1);
7390 arg1 = valuePop(ctxt);
7391 }
7392 if (arg1->type != XPATH_NUMBER) {
7393 xmlXPathFreeObject(arg1);
7394 xmlXPathFreeObject(arg2);
7395 XP_ERROR0(XPATH_INVALID_OPERAND);
7396 }
7397 if (arg2->type != XPATH_NUMBER) {
7398 valuePush(ctxt, arg2);
7399 xmlXPathNumberFunction(ctxt, 1);
7400 arg2 = valuePop(ctxt);
7401 }
7402 if (arg2->type != XPATH_NUMBER) {
7403 xmlXPathReleaseObject(ctxt->context, arg1);
7404 xmlXPathReleaseObject(ctxt->context, arg2);
7405 XP_ERROR0(XPATH_INVALID_OPERAND);
7406 }
7407 /*
7408 * Add tests for infinity and nan
7409 * => feedback on 3.4 for Inf and NaN
7410 */
7411 /* Hand check NaN and Infinity comparisons */
7412 if (xmlXPathIsNaN(arg1->floatval) || xmlXPathIsNaN(arg2->floatval)) {
7413 ret=0;
7414 } else {
7415 arg1i=xmlXPathIsInf(arg1->floatval);
7416 arg2i=xmlXPathIsInf(arg2->floatval);
7417 if (inf && strict) {
7418 if ((arg1i == -1 && arg2i != -1) ||
7419 (arg2i == 1 && arg1i != 1)) {
7420 ret = 1;
7421 } else if (arg1i == 0 && arg2i == 0) {
7422 ret = (arg1->floatval < arg2->floatval);
7423 } else {
7424 ret = 0;
7425 }
7426 }
7427 else if (inf && !strict) {
7428 if (arg1i == -1 || arg2i == 1) {
7429 ret = 1;
7430 } else if (arg1i == 0 && arg2i == 0) {
7431 ret = (arg1->floatval <= arg2->floatval);
7432 } else {
7433 ret = 0;
7434 }
7435 }
7436 else if (!inf && strict) {
7437 if ((arg1i == 1 && arg2i != 1) ||
7438 (arg2i == -1 && arg1i != -1)) {
7439 ret = 1;
7440 } else if (arg1i == 0 && arg2i == 0) {
7441 ret = (arg1->floatval > arg2->floatval);
7442 } else {
7443 ret = 0;
7444 }
7445 }
7446 else if (!inf && !strict) {
7447 if (arg1i == 1 || arg2i == -1) {
7448 ret = 1;
7449 } else if (arg1i == 0 && arg2i == 0) {
7450 ret = (arg1->floatval >= arg2->floatval);
7451 } else {
7452 ret = 0;
7453 }
7454 }
7455 }
7456 xmlXPathReleaseObject(ctxt->context, arg1);
7457 xmlXPathReleaseObject(ctxt->context, arg2);
7458 return(ret);
7459 }
7460
7461 /**
7462 * xmlXPathValueFlipSign:
7463 * @ctxt: the XPath Parser context
7464 *
7465 * Implement the unary - operation on an XPath object
7466 * The numeric operators convert their operands to numbers as if
7467 * by calling the number function.
7468 */
7469 void
7470 xmlXPathValueFlipSign(xmlXPathParserContextPtr ctxt) {
7471 if ((ctxt == NULL) || (ctxt->context == NULL)) return;
7472 CAST_TO_NUMBER;
7473 CHECK_TYPE(XPATH_NUMBER);
7474 ctxt->value->floatval = -ctxt->value->floatval;
7475 }
7476
7477 /**
7478 * xmlXPathAddValues:
7479 * @ctxt: the XPath Parser context
7480 *
7481 * Implement the add operation on XPath objects:
7482 * The numeric operators convert their operands to numbers as if
7483 * by calling the number function.
7484 */
7485 void
7486 xmlXPathAddValues(xmlXPathParserContextPtr ctxt) {
7487 xmlXPathObjectPtr arg;
7488 double val;
7489
7490 arg = valuePop(ctxt);
7491 if (arg == NULL)
7492 XP_ERROR(XPATH_INVALID_OPERAND);
7493 val = xmlXPathCastToNumber(arg);
7494 xmlXPathReleaseObject(ctxt->context, arg);
7495 CAST_TO_NUMBER;
7496 CHECK_TYPE(XPATH_NUMBER);
7497 ctxt->value->floatval += val;
7498 }
7499
7500 /**
7501 * xmlXPathSubValues:
7502 * @ctxt: the XPath Parser context
7503 *
7504 * Implement the subtraction operation on XPath objects:
7505 * The numeric operators convert their operands to numbers as if
7506 * by calling the number function.
7507 */
7508 void
7509 xmlXPathSubValues(xmlXPathParserContextPtr ctxt) {
7510 xmlXPathObjectPtr arg;
7511 double val;
7512
7513 arg = valuePop(ctxt);
7514 if (arg == NULL)
7515 XP_ERROR(XPATH_INVALID_OPERAND);
7516 val = xmlXPathCastToNumber(arg);
7517 xmlXPathReleaseObject(ctxt->context, arg);
7518 CAST_TO_NUMBER;
7519 CHECK_TYPE(XPATH_NUMBER);
7520 ctxt->value->floatval -= val;
7521 }
7522
7523 /**
7524 * xmlXPathMultValues:
7525 * @ctxt: the XPath Parser context
7526 *
7527 * Implement the multiply operation on XPath objects:
7528 * The numeric operators convert their operands to numbers as if
7529 * by calling the number function.
7530 */
7531 void
7532 xmlXPathMultValues(xmlXPathParserContextPtr ctxt) {
7533 xmlXPathObjectPtr arg;
7534 double val;
7535
7536 arg = valuePop(ctxt);
7537 if (arg == NULL)
7538 XP_ERROR(XPATH_INVALID_OPERAND);
7539 val = xmlXPathCastToNumber(arg);
7540 xmlXPathReleaseObject(ctxt->context, arg);
7541 CAST_TO_NUMBER;
7542 CHECK_TYPE(XPATH_NUMBER);
7543 ctxt->value->floatval *= val;
7544 }
7545
7546 /**
7547 * xmlXPathDivValues:
7548 * @ctxt: the XPath Parser context
7549 *
7550 * Implement the div operation on XPath objects @arg1 / @arg2:
7551 * The numeric operators convert their operands to numbers as if
7552 * by calling the number function.
7553 */
7554 void
7555 xmlXPathDivValues(xmlXPathParserContextPtr ctxt) {
7556 xmlXPathObjectPtr arg;
7557 double val;
7558
7559 arg = valuePop(ctxt);
7560 if (arg == NULL)
7561 XP_ERROR(XPATH_INVALID_OPERAND);
7562 val = xmlXPathCastToNumber(arg);
7563 xmlXPathReleaseObject(ctxt->context, arg);
7564 CAST_TO_NUMBER;
7565 CHECK_TYPE(XPATH_NUMBER);
7566 ctxt->value->floatval /= val;
7567 }
7568
7569 /**
7570 * xmlXPathModValues:
7571 * @ctxt: the XPath Parser context
7572 *
7573 * Implement the mod operation on XPath objects: @arg1 / @arg2
7574 * The numeric operators convert their operands to numbers as if
7575 * by calling the number function.
7576 */
7577 void
7578 xmlXPathModValues(xmlXPathParserContextPtr ctxt) {
7579 xmlXPathObjectPtr arg;
7580 double arg1, arg2;
7581
7582 arg = valuePop(ctxt);
7583 if (arg == NULL)
7584 XP_ERROR(XPATH_INVALID_OPERAND);
7585 arg2 = xmlXPathCastToNumber(arg);
7586 xmlXPathReleaseObject(ctxt->context, arg);
7587 CAST_TO_NUMBER;
7588 CHECK_TYPE(XPATH_NUMBER);
7589 arg1 = ctxt->value->floatval;
7590 if (arg2 == 0)
7591 ctxt->value->floatval = NAN;
7592 else {
7593 ctxt->value->floatval = fmod(arg1, arg2);
7594 }
7595 }
7596
7597 /************************************************************************
7598 * *
7599 * The traversal functions *
7600 * *
7601 ************************************************************************/
7602
7603 /*
7604 * A traversal function enumerates nodes along an axis.
7605 * Initially it must be called with NULL, and it indicates
7606 * termination on the axis by returning NULL.
7607 */
7608 typedef xmlNodePtr (*xmlXPathTraversalFunction)
7609 (xmlXPathParserContextPtr ctxt, xmlNodePtr cur);
7610
7611 /*
7612 * xmlXPathTraversalFunctionExt:
7613 * A traversal function enumerates nodes along an axis.
7614 * Initially it must be called with NULL, and it indicates
7615 * termination on the axis by returning NULL.
7616 * The context node of the traversal is specified via @contextNode.
7617 */
7618 typedef xmlNodePtr (*xmlXPathTraversalFunctionExt)
7619 (xmlNodePtr cur, xmlNodePtr contextNode);
7620
7621 /*
7622 * xmlXPathNodeSetMergeFunction:
7623 * Used for merging node sets in xmlXPathCollectAndTest().
7624 */
7625 typedef xmlNodeSetPtr (*xmlXPathNodeSetMergeFunction)
7626 (xmlNodeSetPtr, xmlNodeSetPtr, int);
7627
7628
7629 /**
7630 * xmlXPathNextSelf:
7631 * @ctxt: the XPath Parser context
7632 * @cur: the current node in the traversal
7633 *
7634 * Traversal function for the "self" direction
7635 * The self axis contains just the context node itself
7636 *
7637 * Returns the next element following that axis
7638 */
7639 xmlNodePtr
7640 xmlXPathNextSelf(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
7641 if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
7642 if (cur == NULL)
7643 return(ctxt->context->node);
7644 return(NULL);
7645 }
7646
7647 /**
7648 * xmlXPathNextChild:
7649 * @ctxt: the XPath Parser context
7650 * @cur: the current node in the traversal
7651 *
7652 * Traversal function for the "child" direction
7653 * The child axis contains the children of the context node in document order.
7654 *
7655 * Returns the next element following that axis
7656 */
7657 xmlNodePtr
7658 xmlXPathNextChild(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
7659 if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
7660 if (cur == NULL) {
7661 if (ctxt->context->node == NULL) return(NULL);
7662 switch (ctxt->context->node->type) {
7663 case XML_ELEMENT_NODE:
7664 case XML_TEXT_NODE:
7665 case XML_CDATA_SECTION_NODE:
7666 case XML_ENTITY_REF_NODE:
7667 case XML_ENTITY_NODE:
7668 case XML_PI_NODE:
7669 case XML_COMMENT_NODE:
7670 case XML_NOTATION_NODE:
7671 case XML_DTD_NODE:
7672 return(ctxt->context->node->children);
7673 case XML_DOCUMENT_NODE:
7674 case XML_DOCUMENT_TYPE_NODE:
7675 case XML_DOCUMENT_FRAG_NODE:
7676 case XML_HTML_DOCUMENT_NODE:
7677 #ifdef LIBXML_DOCB_ENABLED
7678 case XML_DOCB_DOCUMENT_NODE:
7679 #endif
7680 return(((xmlDocPtr) ctxt->context->node)->children);
7681 case XML_ELEMENT_DECL:
7682 case XML_ATTRIBUTE_DECL:
7683 case XML_ENTITY_DECL:
7684 case XML_ATTRIBUTE_NODE:
7685 case XML_NAMESPACE_DECL:
7686 case XML_XINCLUDE_START:
7687 case XML_XINCLUDE_END:
7688 return(NULL);
7689 }
7690 return(NULL);
7691 }
7692 if ((cur->type == XML_DOCUMENT_NODE) ||
7693 (cur->type == XML_HTML_DOCUMENT_NODE))
7694 return(NULL);
7695 return(cur->next);
7696 }
7697
7698 /**
7699 * xmlXPathNextChildElement:
7700 * @ctxt: the XPath Parser context
7701 * @cur: the current node in the traversal
7702 *
7703 * Traversal function for the "child" direction and nodes of type element.
7704 * The child axis contains the children of the context node in document order.
7705 *
7706 * Returns the next element following that axis
7707 */
7708 static xmlNodePtr
7709 xmlXPathNextChildElement(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
7710 if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
7711 if (cur == NULL) {
7712 cur = ctxt->context->node;
7713 if (cur == NULL) return(NULL);
7714 /*
7715 * Get the first element child.
7716 */
7717 switch (cur->type) {
7718 case XML_ELEMENT_NODE:
7719 case XML_DOCUMENT_FRAG_NODE:
7720 case XML_ENTITY_REF_NODE: /* URGENT TODO: entify-refs as well? */
7721 case XML_ENTITY_NODE:
7722 cur = cur->children;
7723 if (cur != NULL) {
7724 if (cur->type == XML_ELEMENT_NODE)
7725 return(cur);
7726 do {
7727 cur = cur->next;
7728 } while ((cur != NULL) &&
7729 (cur->type != XML_ELEMENT_NODE));
7730 return(cur);
7731 }
7732 return(NULL);
7733 case XML_DOCUMENT_NODE:
7734 case XML_HTML_DOCUMENT_NODE:
7735 #ifdef LIBXML_DOCB_ENABLED
7736 case XML_DOCB_DOCUMENT_NODE:
7737 #endif
7738 return(xmlDocGetRootElement((xmlDocPtr) cur));
7739 default:
7740 return(NULL);
7741 }
7742 return(NULL);
7743 }
7744 /*
7745 * Get the next sibling element node.
7746 */
7747 switch (cur->type) {
7748 case XML_ELEMENT_NODE:
7749 case XML_TEXT_NODE:
7750 case XML_ENTITY_REF_NODE:
7751 case XML_ENTITY_NODE:
7752 case XML_CDATA_SECTION_NODE:
7753 case XML_PI_NODE:
7754 case XML_COMMENT_NODE:
7755 case XML_XINCLUDE_END:
7756 break;
7757 /* case XML_DTD_NODE: */ /* URGENT TODO: DTD-node as well? */
7758 default:
7759 return(NULL);
7760 }
7761 if (cur->next != NULL) {
7762 if (cur->next->type == XML_ELEMENT_NODE)
7763 return(cur->next);
7764 cur = cur->next;
7765 do {
7766 cur = cur->next;
7767 } while ((cur != NULL) && (cur->type != XML_ELEMENT_NODE));
7768 return(cur);
7769 }
7770 return(NULL);
7771 }
7772
7773 #if 0
7774 /**
7775 * xmlXPathNextDescendantOrSelfElemParent:
7776 * @ctxt: the XPath Parser context
7777 * @cur: the current node in the traversal
7778 *
7779 * Traversal function for the "descendant-or-self" axis.
7780 * Additionally it returns only nodes which can be parents of
7781 * element nodes.
7782 *
7783 *
7784 * Returns the next element following that axis
7785 */
7786 static xmlNodePtr
7787 xmlXPathNextDescendantOrSelfElemParent(xmlNodePtr cur,
7788 xmlNodePtr contextNode)
7789 {
7790 if (cur == NULL) {
7791 if (contextNode == NULL)
7792 return(NULL);
7793 switch (contextNode->type) {
7794 case XML_ELEMENT_NODE:
7795 case XML_XINCLUDE_START:
7796 case XML_DOCUMENT_FRAG_NODE:
7797 case XML_DOCUMENT_NODE:
7798 #ifdef LIBXML_DOCB_ENABLED
7799 case XML_DOCB_DOCUMENT_NODE:
7800 #endif
7801 case XML_HTML_DOCUMENT_NODE:
7802 return(contextNode);
7803 default:
7804 return(NULL);
7805 }
7806 return(NULL);
7807 } else {
7808 xmlNodePtr start = cur;
7809
7810 while (cur != NULL) {
7811 switch (cur->type) {
7812 case XML_ELEMENT_NODE:
7813 /* TODO: OK to have XInclude here? */
7814 case XML_XINCLUDE_START:
7815 case XML_DOCUMENT_FRAG_NODE:
7816 if (cur != start)
7817 return(cur);
7818 if (cur->children != NULL) {
7819 cur = cur->children;
7820 continue;
7821 }
7822 break;
7823 /* Not sure if we need those here. */
7824 case XML_DOCUMENT_NODE:
7825 #ifdef LIBXML_DOCB_ENABLED
7826 case XML_DOCB_DOCUMENT_NODE:
7827 #endif
7828 case XML_HTML_DOCUMENT_NODE:
7829 if (cur != start)
7830 return(cur);
7831 return(xmlDocGetRootElement((xmlDocPtr) cur));
7832 default:
7833 break;
7834 }
7835
7836 next_sibling:
7837 if ((cur == NULL) || (cur == contextNode))
7838 return(NULL);
7839 if (cur->next != NULL) {
7840 cur = cur->next;
7841 } else {
7842 cur = cur->parent;
7843 goto next_sibling;
7844 }
7845 }
7846 }
7847 return(NULL);
7848 }
7849 #endif
7850
7851 /**
7852 * xmlXPathNextDescendant:
7853 * @ctxt: the XPath Parser context
7854 * @cur: the current node in the traversal
7855 *
7856 * Traversal function for the "descendant" direction
7857 * the descendant axis contains the descendants of the context node in document
7858 * order; a descendant is a child or a child of a child and so on.
7859 *
7860 * Returns the next element following that axis
7861 */
7862 xmlNodePtr
7863 xmlXPathNextDescendant(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
7864 if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
7865 if (cur == NULL) {
7866 if (ctxt->context->node == NULL)
7867 return(NULL);
7868 if ((ctxt->context->node->type == XML_ATTRIBUTE_NODE) ||
7869 (ctxt->context->node->type == XML_NAMESPACE_DECL))
7870 return(NULL);
7871
7872 if (ctxt->context->node == (xmlNodePtr) ctxt->context->doc)
7873 return(ctxt->context->doc->children);
7874 return(ctxt->context->node->children);
7875 }
7876
7877 if (cur->type == XML_NAMESPACE_DECL)
7878 return(NULL);
7879 if (cur->children != NULL) {
7880 /*
7881 * Do not descend on entities declarations
7882 */
7883 if (cur->children->type != XML_ENTITY_DECL) {
7884 cur = cur->children;
7885 /*
7886 * Skip DTDs
7887 */
7888 if (cur->type != XML_DTD_NODE)
7889 return(cur);
7890 }
7891 }
7892
7893 if (cur == ctxt->context->node) return(NULL);
7894
7895 while (cur->next != NULL) {
7896 cur = cur->next;
7897 if ((cur->type != XML_ENTITY_DECL) &&
7898 (cur->type != XML_DTD_NODE))
7899 return(cur);
7900 }
7901
7902 do {
7903 cur = cur->parent;
7904 if (cur == NULL) break;
7905 if (cur == ctxt->context->node) return(NULL);
7906 if (cur->next != NULL) {
7907 cur = cur->next;
7908 return(cur);
7909 }
7910 } while (cur != NULL);
7911 return(cur);
7912 }
7913
7914 /**
7915 * xmlXPathNextDescendantOrSelf:
7916 * @ctxt: the XPath Parser context
7917 * @cur: the current node in the traversal
7918 *
7919 * Traversal function for the "descendant-or-self" direction
7920 * the descendant-or-self axis contains the context node and the descendants
7921 * of the context node in document order; thus the context node is the first
7922 * node on the axis, and the first child of the context node is the second node
7923 * on the axis
7924 *
7925 * Returns the next element following that axis
7926 */
7927 xmlNodePtr
7928 xmlXPathNextDescendantOrSelf(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
7929 if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
7930 if (cur == NULL)
7931 return(ctxt->context->node);
7932
7933 if (ctxt->context->node == NULL)
7934 return(NULL);
7935 if ((ctxt->context->node->type == XML_ATTRIBUTE_NODE) ||
7936 (ctxt->context->node->type == XML_NAMESPACE_DECL))
7937 return(NULL);
7938
7939 return(xmlXPathNextDescendant(ctxt, cur));
7940 }
7941
7942 /**
7943 * xmlXPathNextParent:
7944 * @ctxt: the XPath Parser context
7945 * @cur: the current node in the traversal
7946 *
7947 * Traversal function for the "parent" direction
7948 * The parent axis contains the parent of the context node, if there is one.
7949 *
7950 * Returns the next element following that axis
7951 */
7952 xmlNodePtr
7953 xmlXPathNextParent(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
7954 if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
7955 /*
7956 * the parent of an attribute or namespace node is the element
7957 * to which the attribute or namespace node is attached
7958 * Namespace handling !!!
7959 */
7960 if (cur == NULL) {
7961 if (ctxt->context->node == NULL) return(NULL);
7962 switch (ctxt->context->node->type) {
7963 case XML_ELEMENT_NODE:
7964 case XML_TEXT_NODE:
7965 case XML_CDATA_SECTION_NODE:
7966 case XML_ENTITY_REF_NODE:
7967 case XML_ENTITY_NODE:
7968 case XML_PI_NODE:
7969 case XML_COMMENT_NODE:
7970 case XML_NOTATION_NODE:
7971 case XML_DTD_NODE:
7972 case XML_ELEMENT_DECL:
7973 case XML_ATTRIBUTE_DECL:
7974 case XML_XINCLUDE_START:
7975 case XML_XINCLUDE_END:
7976 case XML_ENTITY_DECL:
7977 if (ctxt->context->node->parent == NULL)
7978 return((xmlNodePtr) ctxt->context->doc);
7979 if ((ctxt->context->node->parent->type == XML_ELEMENT_NODE) &&
7980 ((ctxt->context->node->parent->name[0] == ' ') ||
7981 (xmlStrEqual(ctxt->context->node->parent->name,
7982 BAD_CAST "fake node libxslt"))))
7983 return(NULL);
7984 return(ctxt->context->node->parent);
7985 case XML_ATTRIBUTE_NODE: {
7986 xmlAttrPtr att = (xmlAttrPtr) ctxt->context->node;
7987
7988 return(att->parent);
7989 }
7990 case XML_DOCUMENT_NODE:
7991 case XML_DOCUMENT_TYPE_NODE:
7992 case XML_DOCUMENT_FRAG_NODE:
7993 case XML_HTML_DOCUMENT_NODE:
7994 #ifdef LIBXML_DOCB_ENABLED
7995 case XML_DOCB_DOCUMENT_NODE:
7996 #endif
7997 return(NULL);
7998 case XML_NAMESPACE_DECL: {
7999 xmlNsPtr ns = (xmlNsPtr) ctxt->context->node;
8000
8001 if ((ns->next != NULL) &&
8002 (ns->next->type != XML_NAMESPACE_DECL))
8003 return((xmlNodePtr) ns->next);
8004 return(NULL);
8005 }
8006 }
8007 }
8008 return(NULL);
8009 }
8010
8011 /**
8012 * xmlXPathNextAncestor:
8013 * @ctxt: the XPath Parser context
8014 * @cur: the current node in the traversal
8015 *
8016 * Traversal function for the "ancestor" direction
8017 * the ancestor axis contains the ancestors of the context node; the ancestors
8018 * of the context node consist of the parent of context node and the parent's
8019 * parent and so on; the nodes are ordered in reverse document order; thus the
8020 * parent is the first node on the axis, and the parent's parent is the second
8021 * node on the axis
8022 *
8023 * Returns the next element following that axis
8024 */
8025 xmlNodePtr
8026 xmlXPathNextAncestor(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
8027 if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
8028 /*
8029 * the parent of an attribute or namespace node is the element
8030 * to which the attribute or namespace node is attached
8031 * !!!!!!!!!!!!!
8032 */
8033 if (cur == NULL) {
8034 if (ctxt->context->node == NULL) return(NULL);
8035 switch (ctxt->context->node->type) {
8036 case XML_ELEMENT_NODE:
8037 case XML_TEXT_NODE:
8038 case XML_CDATA_SECTION_NODE:
8039 case XML_ENTITY_REF_NODE:
8040 case XML_ENTITY_NODE:
8041 case XML_PI_NODE:
8042 case XML_COMMENT_NODE:
8043 case XML_DTD_NODE:
8044 case XML_ELEMENT_DECL:
8045 case XML_ATTRIBUTE_DECL:
8046 case XML_ENTITY_DECL:
8047 case XML_NOTATION_NODE:
8048 case XML_XINCLUDE_START:
8049 case XML_XINCLUDE_END:
8050 if (ctxt->context->node->parent == NULL)
8051 return((xmlNodePtr) ctxt->context->doc);
8052 if ((ctxt->context->node->parent->type == XML_ELEMENT_NODE) &&
8053 ((ctxt->context->node->parent->name[0] == ' ') ||
8054 (xmlStrEqual(ctxt->context->node->parent->name,
8055 BAD_CAST "fake node libxslt"))))
8056 return(NULL);
8057 return(ctxt->context->node->parent);
8058 case XML_ATTRIBUTE_NODE: {
8059 xmlAttrPtr tmp = (xmlAttrPtr) ctxt->context->node;
8060
8061 return(tmp->parent);
8062 }
8063 case XML_DOCUMENT_NODE:
8064 case XML_DOCUMENT_TYPE_NODE:
8065 case XML_DOCUMENT_FRAG_NODE:
8066 case XML_HTML_DOCUMENT_NODE:
8067 #ifdef LIBXML_DOCB_ENABLED
8068 case XML_DOCB_DOCUMENT_NODE:
8069 #endif
8070 return(NULL);
8071 case XML_NAMESPACE_DECL: {
8072 xmlNsPtr ns = (xmlNsPtr) ctxt->context->node;
8073
8074 if ((ns->next != NULL) &&
8075 (ns->next->type != XML_NAMESPACE_DECL))
8076 return((xmlNodePtr) ns->next);
8077 /* Bad, how did that namespace end up here ? */
8078 return(NULL);
8079 }
8080 }
8081 return(NULL);
8082 }
8083 if (cur == ctxt->context->doc->children)
8084 return((xmlNodePtr) ctxt->context->doc);
8085 if (cur == (xmlNodePtr) ctxt->context->doc)
8086 return(NULL);
8087 switch (cur->type) {
8088 case XML_ELEMENT_NODE:
8089 case XML_TEXT_NODE:
8090 case XML_CDATA_SECTION_NODE:
8091 case XML_ENTITY_REF_NODE:
8092 case XML_ENTITY_NODE:
8093 case XML_PI_NODE:
8094 case XML_COMMENT_NODE:
8095 case XML_NOTATION_NODE:
8096 case XML_DTD_NODE:
8097 case XML_ELEMENT_DECL:
8098 case XML_ATTRIBUTE_DECL:
8099 case XML_ENTITY_DECL:
8100 case XML_XINCLUDE_START:
8101 case XML_XINCLUDE_END:
8102 if (cur->parent == NULL)
8103 return(NULL);
8104 if ((cur->parent->type == XML_ELEMENT_NODE) &&
8105 ((cur->parent->name[0] == ' ') ||
8106 (xmlStrEqual(cur->parent->name,
8107 BAD_CAST "fake node libxslt"))))
8108 return(NULL);
8109 return(cur->parent);
8110 case XML_ATTRIBUTE_NODE: {
8111 xmlAttrPtr att = (xmlAttrPtr) cur;
8112
8113 return(att->parent);
8114 }
8115 case XML_NAMESPACE_DECL: {
8116 xmlNsPtr ns = (xmlNsPtr) cur;
8117
8118 if ((ns->next != NULL) &&
8119 (ns->next->type != XML_NAMESPACE_DECL))
8120 return((xmlNodePtr) ns->next);
8121 /* Bad, how did that namespace end up here ? */
8122 return(NULL);
8123 }
8124 case XML_DOCUMENT_NODE:
8125 case XML_DOCUMENT_TYPE_NODE:
8126 case XML_DOCUMENT_FRAG_NODE:
8127 case XML_HTML_DOCUMENT_NODE:
8128 #ifdef LIBXML_DOCB_ENABLED
8129 case XML_DOCB_DOCUMENT_NODE:
8130 #endif
8131 return(NULL);
8132 }
8133 return(NULL);
8134 }
8135
8136 /**
8137 * xmlXPathNextAncestorOrSelf:
8138 * @ctxt: the XPath Parser context
8139 * @cur: the current node in the traversal
8140 *
8141 * Traversal function for the "ancestor-or-self" direction
8142 * he ancestor-or-self axis contains the context node and ancestors of
8143 * the context node in reverse document order; thus the context node is
8144 * the first node on the axis, and the context node's parent the second;
8145 * parent here is defined the same as with the parent axis.
8146 *
8147 * Returns the next element following that axis
8148 */
8149 xmlNodePtr
8150 xmlXPathNextAncestorOrSelf(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
8151 if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
8152 if (cur == NULL)
8153 return(ctxt->context->node);
8154 return(xmlXPathNextAncestor(ctxt, cur));
8155 }
8156
8157 /**
8158 * xmlXPathNextFollowingSibling:
8159 * @ctxt: the XPath Parser context
8160 * @cur: the current node in the traversal
8161 *
8162 * Traversal function for the "following-sibling" direction
8163 * The following-sibling axis contains the following siblings of the context
8164 * node in document order.
8165 *
8166 * Returns the next element following that axis
8167 */
8168 xmlNodePtr
8169 xmlXPathNextFollowingSibling(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
8170 if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
8171 if ((ctxt->context->node->type == XML_ATTRIBUTE_NODE) ||
8172 (ctxt->context->node->type == XML_NAMESPACE_DECL))
8173 return(NULL);
8174 if (cur == (xmlNodePtr) ctxt->context->doc)
8175 return(NULL);
8176 if (cur == NULL)
8177 return(ctxt->context->node->next);
8178 return(cur->next);
8179 }
8180
8181 /**
8182 * xmlXPathNextPrecedingSibling:
8183 * @ctxt: the XPath Parser context
8184 * @cur: the current node in the traversal
8185 *
8186 * Traversal function for the "preceding-sibling" direction
8187 * The preceding-sibling axis contains the preceding siblings of the context
8188 * node in reverse document order; the first preceding sibling is first on the
8189 * axis; the sibling preceding that node is the second on the axis and so on.
8190 *
8191 * Returns the next element following that axis
8192 */
8193 xmlNodePtr
8194 xmlXPathNextPrecedingSibling(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
8195 if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
8196 if ((ctxt->context->node->type == XML_ATTRIBUTE_NODE) ||
8197 (ctxt->context->node->type == XML_NAMESPACE_DECL))
8198 return(NULL);
8199 if (cur == (xmlNodePtr) ctxt->context->doc)
8200 return(NULL);
8201 if (cur == NULL)
8202 return(ctxt->context->node->prev);
8203 if ((cur->prev != NULL) && (cur->prev->type == XML_DTD_NODE)) {
8204 cur = cur->prev;
8205 if (cur == NULL)
8206 return(ctxt->context->node->prev);
8207 }
8208 return(cur->prev);
8209 }
8210
8211 /**
8212 * xmlXPathNextFollowing:
8213 * @ctxt: the XPath Parser context
8214 * @cur: the current node in the traversal
8215 *
8216 * Traversal function for the "following" direction
8217 * The following axis contains all nodes in the same document as the context
8218 * node that are after the context node in document order, excluding any
8219 * descendants and excluding attribute nodes and namespace nodes; the nodes
8220 * are ordered in document order
8221 *
8222 * Returns the next element following that axis
8223 */
8224 xmlNodePtr
8225 xmlXPathNextFollowing(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
8226 if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
8227 if ((cur != NULL) && (cur->type != XML_ATTRIBUTE_NODE) &&
8228 (cur->type != XML_NAMESPACE_DECL) && (cur->children != NULL))
8229 return(cur->children);
8230
8231 if (cur == NULL) {
8232 cur = ctxt->context->node;
8233 if (cur->type == XML_ATTRIBUTE_NODE) {
8234 cur = cur->parent;
8235 } else if (cur->type == XML_NAMESPACE_DECL) {
8236 xmlNsPtr ns = (xmlNsPtr) cur;
8237
8238 if ((ns->next == NULL) ||
8239 (ns->next->type == XML_NAMESPACE_DECL))
8240 return (NULL);
8241 cur = (xmlNodePtr) ns->next;
8242 }
8243 }
8244 if (cur == NULL) return(NULL) ; /* ERROR */
8245 if (cur->next != NULL) return(cur->next) ;
8246 do {
8247 cur = cur->parent;
8248 if (cur == NULL) break;
8249 if (cur == (xmlNodePtr) ctxt->context->doc) return(NULL);
8250 if (cur->next != NULL) return(cur->next);
8251 } while (cur != NULL);
8252 return(cur);
8253 }
8254
8255 /*
8256 * xmlXPathIsAncestor:
8257 * @ancestor: the ancestor node
8258 * @node: the current node
8259 *
8260 * Check that @ancestor is a @node's ancestor
8261 *
8262 * returns 1 if @ancestor is a @node's ancestor, 0 otherwise.
8263 */
8264 static int
8265 xmlXPathIsAncestor(xmlNodePtr ancestor, xmlNodePtr node) {
8266 if ((ancestor == NULL) || (node == NULL)) return(0);
8267 if (node->type == XML_NAMESPACE_DECL)
8268 return(0);
8269 if (ancestor->type == XML_NAMESPACE_DECL)
8270 return(0);
8271 /* nodes need to be in the same document */
8272 if (ancestor->doc != node->doc) return(0);
8273 /* avoid searching if ancestor or node is the root node */
8274 if (ancestor == (xmlNodePtr) node->doc) return(1);
8275 if (node == (xmlNodePtr) ancestor->doc) return(0);
8276 while (node->parent != NULL) {
8277 if (node->parent == ancestor)
8278 return(1);
8279 node = node->parent;
8280 }
8281 return(0);
8282 }
8283
8284 /**
8285 * xmlXPathNextPreceding:
8286 * @ctxt: the XPath Parser context
8287 * @cur: the current node in the traversal
8288 *
8289 * Traversal function for the "preceding" direction
8290 * the preceding axis contains all nodes in the same document as the context
8291 * node that are before the context node in document order, excluding any
8292 * ancestors and excluding attribute nodes and namespace nodes; the nodes are
8293 * ordered in reverse document order
8294 *
8295 * Returns the next element following that axis
8296 */
8297 xmlNodePtr
8298 xmlXPathNextPreceding(xmlXPathParserContextPtr ctxt, xmlNodePtr cur)
8299 {
8300 if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
8301 if (cur == NULL) {
8302 cur = ctxt->context->node;
8303 if (cur->type == XML_ATTRIBUTE_NODE) {
8304 cur = cur->parent;
8305 } else if (cur->type == XML_NAMESPACE_DECL) {
8306 xmlNsPtr ns = (xmlNsPtr) cur;
8307
8308 if ((ns->next == NULL) ||
8309 (ns->next->type == XML_NAMESPACE_DECL))
8310 return (NULL);
8311 cur = (xmlNodePtr) ns->next;
8312 }
8313 }
8314 if ((cur == NULL) || (cur->type == XML_NAMESPACE_DECL))
8315 return (NULL);
8316 if ((cur->prev != NULL) && (cur->prev->type == XML_DTD_NODE))
8317 cur = cur->prev;
8318 do {
8319 if (cur->prev != NULL) {
8320 for (cur = cur->prev; cur->last != NULL; cur = cur->last) ;
8321 return (cur);
8322 }
8323
8324 cur = cur->parent;
8325 if (cur == NULL)
8326 return (NULL);
8327 if (cur == ctxt->context->doc->children)
8328 return (NULL);
8329 } while (xmlXPathIsAncestor(cur, ctxt->context->node));
8330 return (cur);
8331 }
8332
8333 /**
8334 * xmlXPathNextPrecedingInternal:
8335 * @ctxt: the XPath Parser context
8336 * @cur: the current node in the traversal
8337 *
8338 * Traversal function for the "preceding" direction
8339 * the preceding axis contains all nodes in the same document as the context
8340 * node that are before the context node in document order, excluding any
8341 * ancestors and excluding attribute nodes and namespace nodes; the nodes are
8342 * ordered in reverse document order
8343 * This is a faster implementation but internal only since it requires a
8344 * state kept in the parser context: ctxt->ancestor.
8345 *
8346 * Returns the next element following that axis
8347 */
8348 static xmlNodePtr
8349 xmlXPathNextPrecedingInternal(xmlXPathParserContextPtr ctxt,
8350 xmlNodePtr cur)
8351 {
8352 if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
8353 if (cur == NULL) {
8354 cur = ctxt->context->node;
8355 if (cur == NULL)
8356 return (NULL);
8357 if (cur->type == XML_ATTRIBUTE_NODE) {
8358 cur = cur->parent;
8359 } else if (cur->type == XML_NAMESPACE_DECL) {
8360 xmlNsPtr ns = (xmlNsPtr) cur;
8361
8362 if ((ns->next == NULL) ||
8363 (ns->next->type == XML_NAMESPACE_DECL))
8364 return (NULL);
8365 cur = (xmlNodePtr) ns->next;
8366 }
8367 ctxt->ancestor = cur->parent;
8368 }
8369 if (cur->type == XML_NAMESPACE_DECL)
8370 return(NULL);
8371 if ((cur->prev != NULL) && (cur->prev->type == XML_DTD_NODE))
8372 cur = cur->prev;
8373 while (cur->prev == NULL) {
8374 cur = cur->parent;
8375 if (cur == NULL)
8376 return (NULL);
8377 if (cur == ctxt->context->doc->children)
8378 return (NULL);
8379 if (cur != ctxt->ancestor)
8380 return (cur);
8381 ctxt->ancestor = cur->parent;
8382 }
8383 cur = cur->prev;
8384 while (cur->last != NULL)
8385 cur = cur->last;
8386 return (cur);
8387 }
8388
8389 /**
8390 * xmlXPathNextNamespace:
8391 * @ctxt: the XPath Parser context
8392 * @cur: the current attribute in the traversal
8393 *
8394 * Traversal function for the "namespace" direction
8395 * the namespace axis contains the namespace nodes of the context node;
8396 * the order of nodes on this axis is implementation-defined; the axis will
8397 * be empty unless the context node is an element
8398 *
8399 * We keep the XML namespace node at the end of the list.
8400 *
8401 * Returns the next element following that axis
8402 */
8403 xmlNodePtr
8404 xmlXPathNextNamespace(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
8405 if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
8406 if (ctxt->context->node->type != XML_ELEMENT_NODE) return(NULL);
8407 if (cur == NULL) {
8408 if (ctxt->context->tmpNsList != NULL)
8409 xmlFree(ctxt->context->tmpNsList);
8410 ctxt->context->tmpNsList =
8411 xmlGetNsList(ctxt->context->doc, ctxt->context->node);
8412 ctxt->context->tmpNsNr = 0;
8413 if (ctxt->context->tmpNsList != NULL) {
8414 while (ctxt->context->tmpNsList[ctxt->context->tmpNsNr] != NULL) {
8415 ctxt->context->tmpNsNr++;
8416 }
8417 }
8418 return((xmlNodePtr) xmlXPathXMLNamespace);
8419 }
8420 if (ctxt->context->tmpNsNr > 0) {
8421 return (xmlNodePtr)ctxt->context->tmpNsList[--ctxt->context->tmpNsNr];
8422 } else {
8423 if (ctxt->context->tmpNsList != NULL)
8424 xmlFree(ctxt->context->tmpNsList);
8425 ctxt->context->tmpNsList = NULL;
8426 return(NULL);
8427 }
8428 }
8429
8430 /**
8431 * xmlXPathNextAttribute:
8432 * @ctxt: the XPath Parser context
8433 * @cur: the current attribute in the traversal
8434 *
8435 * Traversal function for the "attribute" direction
8436 * TODO: support DTD inherited default attributes
8437 *
8438 * Returns the next element following that axis
8439 */
8440 xmlNodePtr
8441 xmlXPathNextAttribute(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
8442 if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
8443 if (ctxt->context->node == NULL)
8444 return(NULL);
8445 if (ctxt->context->node->type != XML_ELEMENT_NODE)
8446 return(NULL);
8447 if (cur == NULL) {
8448 if (ctxt->context->node == (xmlNodePtr) ctxt->context->doc)
8449 return(NULL);
8450 return((xmlNodePtr)ctxt->context->node->properties);
8451 }
8452 return((xmlNodePtr)cur->next);
8453 }
8454
8455 /************************************************************************
8456 * *
8457 * NodeTest Functions *
8458 * *
8459 ************************************************************************/
8460
8461 #define IS_FUNCTION 200
8462
8463
8464 /************************************************************************
8465 * *
8466 * Implicit tree core function library *
8467 * *
8468 ************************************************************************/
8469
8470 /**
8471 * xmlXPathRoot:
8472 * @ctxt: the XPath Parser context
8473 *
8474 * Initialize the context to the root of the document
8475 */
8476 void
8477 xmlXPathRoot(xmlXPathParserContextPtr ctxt) {
8478 if ((ctxt == NULL) || (ctxt->context == NULL))
8479 return;
8480 valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context,
8481 (xmlNodePtr) ctxt->context->doc));
8482 }
8483
8484 /************************************************************************
8485 * *
8486 * The explicit core function library *
8487 *http://www.w3.org/Style/XSL/Group/1999/07/xpath-19990705.html#corelib *
8488 * *
8489 ************************************************************************/
8490
8491
8492 /**
8493 * xmlXPathLastFunction:
8494 * @ctxt: the XPath Parser context
8495 * @nargs: the number of arguments
8496 *
8497 * Implement the last() XPath function
8498 * number last()
8499 * The last function returns the number of nodes in the context node list.
8500 */
8501 void
8502 xmlXPathLastFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8503 CHECK_ARITY(0);
8504 if (ctxt->context->contextSize >= 0) {
8505 valuePush(ctxt,
8506 xmlXPathCacheNewFloat(ctxt->context,
8507 (double) ctxt->context->contextSize));
8508 #ifdef DEBUG_EXPR
8509 xmlGenericError(xmlGenericErrorContext,
8510 "last() : %d\n", ctxt->context->contextSize);
8511 #endif
8512 } else {
8513 XP_ERROR(XPATH_INVALID_CTXT_SIZE);
8514 }
8515 }
8516
8517 /**
8518 * xmlXPathPositionFunction:
8519 * @ctxt: the XPath Parser context
8520 * @nargs: the number of arguments
8521 *
8522 * Implement the position() XPath function
8523 * number position()
8524 * The position function returns the position of the context node in the
8525 * context node list. The first position is 1, and so the last position
8526 * will be equal to last().
8527 */
8528 void
8529 xmlXPathPositionFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8530 CHECK_ARITY(0);
8531 if (ctxt->context->proximityPosition >= 0) {
8532 valuePush(ctxt,
8533 xmlXPathCacheNewFloat(ctxt->context,
8534 (double) ctxt->context->proximityPosition));
8535 #ifdef DEBUG_EXPR
8536 xmlGenericError(xmlGenericErrorContext, "position() : %d\n",
8537 ctxt->context->proximityPosition);
8538 #endif
8539 } else {
8540 XP_ERROR(XPATH_INVALID_CTXT_POSITION);
8541 }
8542 }
8543
8544 /**
8545 * xmlXPathCountFunction:
8546 * @ctxt: the XPath Parser context
8547 * @nargs: the number of arguments
8548 *
8549 * Implement the count() XPath function
8550 * number count(node-set)
8551 */
8552 void
8553 xmlXPathCountFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8554 xmlXPathObjectPtr cur;
8555
8556 CHECK_ARITY(1);
8557 if ((ctxt->value == NULL) ||
8558 ((ctxt->value->type != XPATH_NODESET) &&
8559 (ctxt->value->type != XPATH_XSLT_TREE)))
8560 XP_ERROR(XPATH_INVALID_TYPE);
8561 cur = valuePop(ctxt);
8562
8563 if ((cur == NULL) || (cur->nodesetval == NULL))
8564 valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, (double) 0));
8565 else if ((cur->type == XPATH_NODESET) || (cur->type == XPATH_XSLT_TREE)) {
8566 valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context,
8567 (double) cur->nodesetval->nodeNr));
8568 } else {
8569 if ((cur->nodesetval->nodeNr != 1) ||
8570 (cur->nodesetval->nodeTab == NULL)) {
8571 valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, (double) 0));
8572 } else {
8573 xmlNodePtr tmp;
8574 int i = 0;
8575
8576 tmp = cur->nodesetval->nodeTab[0];
8577 if ((tmp != NULL) && (tmp->type != XML_NAMESPACE_DECL)) {
8578 tmp = tmp->children;
8579 while (tmp != NULL) {
8580 tmp = tmp->next;
8581 i++;
8582 }
8583 }
8584 valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, (double) i));
8585 }
8586 }
8587 xmlXPathReleaseObject(ctxt->context, cur);
8588 }
8589
8590 /**
8591 * xmlXPathGetElementsByIds:
8592 * @doc: the document
8593 * @ids: a whitespace separated list of IDs
8594 *
8595 * Selects elements by their unique ID.
8596 *
8597 * Returns a node-set of selected elements.
8598 */
8599 static xmlNodeSetPtr
8600 xmlXPathGetElementsByIds (xmlDocPtr doc, const xmlChar *ids) {
8601 xmlNodeSetPtr ret;
8602 const xmlChar *cur = ids;
8603 xmlChar *ID;
8604 xmlAttrPtr attr;
8605 xmlNodePtr elem = NULL;
8606
8607 if (ids == NULL) return(NULL);
8608
8609 ret = xmlXPathNodeSetCreate(NULL);
8610 if (ret == NULL)
8611 return(ret);
8612
8613 while (IS_BLANK_CH(*cur)) cur++;
8614 while (*cur != 0) {
8615 while ((!IS_BLANK_CH(*cur)) && (*cur != 0))
8616 cur++;
8617
8618 ID = xmlStrndup(ids, cur - ids);
8619 if (ID != NULL) {
8620 /*
8621 * We used to check the fact that the value passed
8622 * was an NCName, but this generated much troubles for
8623 * me and Aleksey Sanin, people blatantly violated that
8624 * constaint, like Visa3D spec.
8625 * if (xmlValidateNCName(ID, 1) == 0)
8626 */
8627 attr = xmlGetID(doc, ID);
8628 if (attr != NULL) {
8629 if (attr->type == XML_ATTRIBUTE_NODE)
8630 elem = attr->parent;
8631 else if (attr->type == XML_ELEMENT_NODE)
8632 elem = (xmlNodePtr) attr;
8633 else
8634 elem = NULL;
8635 if (elem != NULL)
8636 xmlXPathNodeSetAdd(ret, elem);
8637 }
8638 xmlFree(ID);
8639 }
8640
8641 while (IS_BLANK_CH(*cur)) cur++;
8642 ids = cur;
8643 }
8644 return(ret);
8645 }
8646
8647 /**
8648 * xmlXPathIdFunction:
8649 * @ctxt: the XPath Parser context
8650 * @nargs: the number of arguments
8651 *
8652 * Implement the id() XPath function
8653 * node-set id(object)
8654 * The id function selects elements by their unique ID
8655 * (see [5.2.1 Unique IDs]). When the argument to id is of type node-set,
8656 * then the result is the union of the result of applying id to the
8657 * string value of each of the nodes in the argument node-set. When the
8658 * argument to id is of any other type, the argument is converted to a
8659 * string as if by a call to the string function; the string is split
8660 * into a whitespace-separated list of tokens (whitespace is any sequence
8661 * of characters matching the production S); the result is a node-set
8662 * containing the elements in the same document as the context node that
8663 * have a unique ID equal to any of the tokens in the list.
8664 */
8665 void
8666 xmlXPathIdFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8667 xmlChar *tokens;
8668 xmlNodeSetPtr ret;
8669 xmlXPathObjectPtr obj;
8670
8671 CHECK_ARITY(1);
8672 obj = valuePop(ctxt);
8673 if (obj == NULL) XP_ERROR(XPATH_INVALID_OPERAND);
8674 if ((obj->type == XPATH_NODESET) || (obj->type == XPATH_XSLT_TREE)) {
8675 xmlNodeSetPtr ns;
8676 int i;
8677
8678 ret = xmlXPathNodeSetCreate(NULL);
8679 /*
8680 * FIXME -- in an out-of-memory condition this will behave badly.
8681 * The solution is not clear -- we already popped an item from
8682 * ctxt, so the object is in a corrupt state.
8683 */
8684
8685 if (obj->nodesetval != NULL) {
8686 for (i = 0; i < obj->nodesetval->nodeNr; i++) {
8687 tokens =
8688 xmlXPathCastNodeToString(obj->nodesetval->nodeTab[i]);
8689 ns = xmlXPathGetElementsByIds(ctxt->context->doc, tokens);
8690 ret = xmlXPathNodeSetMerge(ret, ns);
8691 xmlXPathFreeNodeSet(ns);
8692 if (tokens != NULL)
8693 xmlFree(tokens);
8694 }
8695 }
8696 xmlXPathReleaseObject(ctxt->context, obj);
8697 valuePush(ctxt, xmlXPathCacheWrapNodeSet(ctxt->context, ret));
8698 return;
8699 }
8700 obj = xmlXPathCacheConvertString(ctxt->context, obj);
8701 ret = xmlXPathGetElementsByIds(ctxt->context->doc, obj->stringval);
8702 valuePush(ctxt, xmlXPathCacheWrapNodeSet(ctxt->context, ret));
8703 xmlXPathReleaseObject(ctxt->context, obj);
8704 return;
8705 }
8706
8707 /**
8708 * xmlXPathLocalNameFunction:
8709 * @ctxt: the XPath Parser context
8710 * @nargs: the number of arguments
8711 *
8712 * Implement the local-name() XPath function
8713 * string local-name(node-set?)
8714 * The local-name function returns a string containing the local part
8715 * of the name of the node in the argument node-set that is first in
8716 * document order. If the node-set is empty or the first node has no
8717 * name, an empty string is returned. If the argument is omitted it
8718 * defaults to the context node.
8719 */
8720 void
8721 xmlXPathLocalNameFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8722 xmlXPathObjectPtr cur;
8723
8724 if (ctxt == NULL) return;
8725
8726 if (nargs == 0) {
8727 valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context,
8728 ctxt->context->node));
8729 nargs = 1;
8730 }
8731
8732 CHECK_ARITY(1);
8733 if ((ctxt->value == NULL) ||
8734 ((ctxt->value->type != XPATH_NODESET) &&
8735 (ctxt->value->type != XPATH_XSLT_TREE)))
8736 XP_ERROR(XPATH_INVALID_TYPE);
8737 cur = valuePop(ctxt);
8738
8739 if ((cur->nodesetval == NULL) || (cur->nodesetval->nodeNr == 0)) {
8740 valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, ""));
8741 } else {
8742 int i = 0; /* Should be first in document order !!!!! */
8743 switch (cur->nodesetval->nodeTab[i]->type) {
8744 case XML_ELEMENT_NODE:
8745 case XML_ATTRIBUTE_NODE:
8746 case XML_PI_NODE:
8747 if (cur->nodesetval->nodeTab[i]->name[0] == ' ')
8748 valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, ""));
8749 else
8750 valuePush(ctxt,
8751 xmlXPathCacheNewString(ctxt->context,
8752 cur->nodesetval->nodeTab[i]->name));
8753 break;
8754 case XML_NAMESPACE_DECL:
8755 valuePush(ctxt, xmlXPathCacheNewString(ctxt->context,
8756 ((xmlNsPtr)cur->nodesetval->nodeTab[i])->prefix));
8757 break;
8758 default:
8759 valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, ""));
8760 }
8761 }
8762 xmlXPathReleaseObject(ctxt->context, cur);
8763 }
8764
8765 /**
8766 * xmlXPathNamespaceURIFunction:
8767 * @ctxt: the XPath Parser context
8768 * @nargs: the number of arguments
8769 *
8770 * Implement the namespace-uri() XPath function
8771 * string namespace-uri(node-set?)
8772 * The namespace-uri function returns a string containing the
8773 * namespace URI of the expanded name of the node in the argument
8774 * node-set that is first in document order. If the node-set is empty,
8775 * the first node has no name, or the expanded name has no namespace
8776 * URI, an empty string is returned. If the argument is omitted it
8777 * defaults to the context node.
8778 */
8779 void
8780 xmlXPathNamespaceURIFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8781 xmlXPathObjectPtr cur;
8782
8783 if (ctxt == NULL) return;
8784
8785 if (nargs == 0) {
8786 valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context,
8787 ctxt->context->node));
8788 nargs = 1;
8789 }
8790 CHECK_ARITY(1);
8791 if ((ctxt->value == NULL) ||
8792 ((ctxt->value->type != XPATH_NODESET) &&
8793 (ctxt->value->type != XPATH_XSLT_TREE)))
8794 XP_ERROR(XPATH_INVALID_TYPE);
8795 cur = valuePop(ctxt);
8796
8797 if ((cur->nodesetval == NULL) || (cur->nodesetval->nodeNr == 0)) {
8798 valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, ""));
8799 } else {
8800 int i = 0; /* Should be first in document order !!!!! */
8801 switch (cur->nodesetval->nodeTab[i]->type) {
8802 case XML_ELEMENT_NODE:
8803 case XML_ATTRIBUTE_NODE:
8804 if (cur->nodesetval->nodeTab[i]->ns == NULL)
8805 valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, ""));
8806 else
8807 valuePush(ctxt, xmlXPathCacheNewString(ctxt->context,
8808 cur->nodesetval->nodeTab[i]->ns->href));
8809 break;
8810 default:
8811 valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, ""));
8812 }
8813 }
8814 xmlXPathReleaseObject(ctxt->context, cur);
8815 }
8816
8817 /**
8818 * xmlXPathNameFunction:
8819 * @ctxt: the XPath Parser context
8820 * @nargs: the number of arguments
8821 *
8822 * Implement the name() XPath function
8823 * string name(node-set?)
8824 * The name function returns a string containing a QName representing
8825 * the name of the node in the argument node-set that is first in document
8826 * order. The QName must represent the name with respect to the namespace
8827 * declarations in effect on the node whose name is being represented.
8828 * Typically, this will be the form in which the name occurred in the XML
8829 * source. This need not be the case if there are namespace declarations
8830 * in effect on the node that associate multiple prefixes with the same
8831 * namespace. However, an implementation may include information about
8832 * the original prefix in its representation of nodes; in this case, an
8833 * implementation can ensure that the returned string is always the same
8834 * as the QName used in the XML source. If the argument it omitted it
8835 * defaults to the context node.
8836 * Libxml keep the original prefix so the "real qualified name" used is
8837 * returned.
8838 */
8839 static void
8840 xmlXPathNameFunction(xmlXPathParserContextPtr ctxt, int nargs)
8841 {
8842 xmlXPathObjectPtr cur;
8843
8844 if (nargs == 0) {
8845 valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context,
8846 ctxt->context->node));
8847 nargs = 1;
8848 }
8849
8850 CHECK_ARITY(1);
8851 if ((ctxt->value == NULL) ||
8852 ((ctxt->value->type != XPATH_NODESET) &&
8853 (ctxt->value->type != XPATH_XSLT_TREE)))
8854 XP_ERROR(XPATH_INVALID_TYPE);
8855 cur = valuePop(ctxt);
8856
8857 if ((cur->nodesetval == NULL) || (cur->nodesetval->nodeNr == 0)) {
8858 valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, ""));
8859 } else {
8860 int i = 0; /* Should be first in document order !!!!! */
8861
8862 switch (cur->nodesetval->nodeTab[i]->type) {
8863 case XML_ELEMENT_NODE:
8864 case XML_ATTRIBUTE_NODE:
8865 if (cur->nodesetval->nodeTab[i]->name[0] == ' ')
8866 valuePush(ctxt,
8867 xmlXPathCacheNewCString(ctxt->context, ""));
8868 else if ((cur->nodesetval->nodeTab[i]->ns == NULL) ||
8869 (cur->nodesetval->nodeTab[i]->ns->prefix == NULL)) {
8870 valuePush(ctxt,
8871 xmlXPathCacheNewString(ctxt->context,
8872 cur->nodesetval->nodeTab[i]->name));
8873 } else {
8874 xmlChar *fullname;
8875
8876 fullname = xmlBuildQName(cur->nodesetval->nodeTab[i]->name,
8877 cur->nodesetval->nodeTab[i]->ns->prefix,
8878 NULL, 0);
8879 if (fullname == cur->nodesetval->nodeTab[i]->name)
8880 fullname = xmlStrdup(cur->nodesetval->nodeTab[i]->name);
8881 if (fullname == NULL) {
8882 XP_ERROR(XPATH_MEMORY_ERROR);
8883 }
8884 valuePush(ctxt, xmlXPathCacheWrapString(
8885 ctxt->context, fullname));
8886 }
8887 break;
8888 default:
8889 valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context,
8890 cur->nodesetval->nodeTab[i]));
8891 xmlXPathLocalNameFunction(ctxt, 1);
8892 }
8893 }
8894 xmlXPathReleaseObject(ctxt->context, cur);
8895 }
8896
8897
8898 /**
8899 * xmlXPathStringFunction:
8900 * @ctxt: the XPath Parser context
8901 * @nargs: the number of arguments
8902 *
8903 * Implement the string() XPath function
8904 * string string(object?)
8905 * The string function converts an object to a string as follows:
8906 * - A node-set is converted to a string by returning the value of
8907 * the node in the node-set that is first in document order.
8908 * If the node-set is empty, an empty string is returned.
8909 * - A number is converted to a string as follows
8910 * + NaN is converted to the string NaN
8911 * + positive zero is converted to the string 0
8912 * + negative zero is converted to the string 0
8913 * + positive infinity is converted to the string Infinity
8914 * + negative infinity is converted to the string -Infinity
8915 * + if the number is an integer, the number is represented in
8916 * decimal form as a Number with no decimal point and no leading
8917 * zeros, preceded by a minus sign (-) if the number is negative
8918 * + otherwise, the number is represented in decimal form as a
8919 * Number including a decimal point with at least one digit
8920 * before the decimal point and at least one digit after the
8921 * decimal point, preceded by a minus sign (-) if the number
8922 * is negative; there must be no leading zeros before the decimal
8923 * point apart possibly from the one required digit immediately
8924 * before the decimal point; beyond the one required digit
8925 * after the decimal point there must be as many, but only as
8926 * many, more digits as are needed to uniquely distinguish the
8927 * number from all other IEEE 754 numeric values.
8928 * - The boolean false value is converted to the string false.
8929 * The boolean true value is converted to the string true.
8930 *
8931 * If the argument is omitted, it defaults to a node-set with the
8932 * context node as its only member.
8933 */
8934 void
8935 xmlXPathStringFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8936 xmlXPathObjectPtr cur;
8937
8938 if (ctxt == NULL) return;
8939 if (nargs == 0) {
8940 valuePush(ctxt,
8941 xmlXPathCacheWrapString(ctxt->context,
8942 xmlXPathCastNodeToString(ctxt->context->node)));
8943 return;
8944 }
8945
8946 CHECK_ARITY(1);
8947 cur = valuePop(ctxt);
8948 if (cur == NULL) XP_ERROR(XPATH_INVALID_OPERAND);
8949 valuePush(ctxt, xmlXPathCacheConvertString(ctxt->context, cur));
8950 }
8951
8952 /**
8953 * xmlXPathStringLengthFunction:
8954 * @ctxt: the XPath Parser context
8955 * @nargs: the number of arguments
8956 *
8957 * Implement the string-length() XPath function
8958 * number string-length(string?)
8959 * The string-length returns the number of characters in the string
8960 * (see [3.6 Strings]). If the argument is omitted, it defaults to
8961 * the context node converted to a string, in other words the value
8962 * of the context node.
8963 */
8964 void
8965 xmlXPathStringLengthFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8966 xmlXPathObjectPtr cur;
8967
8968 if (nargs == 0) {
8969 if ((ctxt == NULL) || (ctxt->context == NULL))
8970 return;
8971 if (ctxt->context->node == NULL) {
8972 valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, 0));
8973 } else {
8974 xmlChar *content;
8975
8976 content = xmlXPathCastNodeToString(ctxt->context->node);
8977 valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context,
8978 xmlUTF8Strlen(content)));
8979 xmlFree(content);
8980 }
8981 return;
8982 }
8983 CHECK_ARITY(1);
8984 CAST_TO_STRING;
8985 CHECK_TYPE(XPATH_STRING);
8986 cur = valuePop(ctxt);
8987 valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context,
8988 xmlUTF8Strlen(cur->stringval)));
8989 xmlXPathReleaseObject(ctxt->context, cur);
8990 }
8991
8992 /**
8993 * xmlXPathConcatFunction:
8994 * @ctxt: the XPath Parser context
8995 * @nargs: the number of arguments
8996 *
8997 * Implement the concat() XPath function
8998 * string concat(string, string, string*)
8999 * The concat function returns the concatenation of its arguments.
9000 */
9001 void
9002 xmlXPathConcatFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9003 xmlXPathObjectPtr cur, newobj;
9004 xmlChar *tmp;
9005
9006 if (ctxt == NULL) return;
9007 if (nargs < 2) {
9008 CHECK_ARITY(2);
9009 }
9010
9011 CAST_TO_STRING;
9012 cur = valuePop(ctxt);
9013 if ((cur == NULL) || (cur->type != XPATH_STRING)) {
9014 xmlXPathReleaseObject(ctxt->context, cur);
9015 return;
9016 }
9017 nargs--;
9018
9019 while (nargs > 0) {
9020 CAST_TO_STRING;
9021 newobj = valuePop(ctxt);
9022 if ((newobj == NULL) || (newobj->type != XPATH_STRING)) {
9023 xmlXPathReleaseObject(ctxt->context, newobj);
9024 xmlXPathReleaseObject(ctxt->context, cur);
9025 XP_ERROR(XPATH_INVALID_TYPE);
9026 }
9027 tmp = xmlStrcat(newobj->stringval, cur->stringval);
9028 newobj->stringval = cur->stringval;
9029 cur->stringval = tmp;
9030 xmlXPathReleaseObject(ctxt->context, newobj);
9031 nargs--;
9032 }
9033 valuePush(ctxt, cur);
9034 }
9035
9036 /**
9037 * xmlXPathContainsFunction:
9038 * @ctxt: the XPath Parser context
9039 * @nargs: the number of arguments
9040 *
9041 * Implement the contains() XPath function
9042 * boolean contains(string, string)
9043 * The contains function returns true if the first argument string
9044 * contains the second argument string, and otherwise returns false.
9045 */
9046 void
9047 xmlXPathContainsFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9048 xmlXPathObjectPtr hay, needle;
9049
9050 CHECK_ARITY(2);
9051 CAST_TO_STRING;
9052 CHECK_TYPE(XPATH_STRING);
9053 needle = valuePop(ctxt);
9054 CAST_TO_STRING;
9055 hay = valuePop(ctxt);
9056
9057 if ((hay == NULL) || (hay->type != XPATH_STRING)) {
9058 xmlXPathReleaseObject(ctxt->context, hay);
9059 xmlXPathReleaseObject(ctxt->context, needle);
9060 XP_ERROR(XPATH_INVALID_TYPE);
9061 }
9062 if (xmlStrstr(hay->stringval, needle->stringval))
9063 valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, 1));
9064 else
9065 valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, 0));
9066 xmlXPathReleaseObject(ctxt->context, hay);
9067 xmlXPathReleaseObject(ctxt->context, needle);
9068 }
9069
9070 /**
9071 * xmlXPathStartsWithFunction:
9072 * @ctxt: the XPath Parser context
9073 * @nargs: the number of arguments
9074 *
9075 * Implement the starts-with() XPath function
9076 * boolean starts-with(string, string)
9077 * The starts-with function returns true if the first argument string
9078 * starts with the second argument string, and otherwise returns false.
9079 */
9080 void
9081 xmlXPathStartsWithFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9082 xmlXPathObjectPtr hay, needle;
9083 int n;
9084
9085 CHECK_ARITY(2);
9086 CAST_TO_STRING;
9087 CHECK_TYPE(XPATH_STRING);
9088 needle = valuePop(ctxt);
9089 CAST_TO_STRING;
9090 hay = valuePop(ctxt);
9091
9092 if ((hay == NULL) || (hay->type != XPATH_STRING)) {
9093 xmlXPathReleaseObject(ctxt->context, hay);
9094 xmlXPathReleaseObject(ctxt->context, needle);
9095 XP_ERROR(XPATH_INVALID_TYPE);
9096 }
9097 n = xmlStrlen(needle->stringval);
9098 if (xmlStrncmp(hay->stringval, needle->stringval, n))
9099 valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, 0));
9100 else
9101 valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, 1));
9102 xmlXPathReleaseObject(ctxt->context, hay);
9103 xmlXPathReleaseObject(ctxt->context, needle);
9104 }
9105
9106 /**
9107 * xmlXPathSubstringFunction:
9108 * @ctxt: the XPath Parser context
9109 * @nargs: the number of arguments
9110 *
9111 * Implement the substring() XPath function
9112 * string substring(string, number, number?)
9113 * The substring function returns the substring of the first argument
9114 * starting at the position specified in the second argument with
9115 * length specified in the third argument. For example,
9116 * substring("12345",2,3) returns "234". If the third argument is not
9117 * specified, it returns the substring starting at the position specified
9118 * in the second argument and continuing to the end of the string. For
9119 * example, substring("12345",2) returns "2345". More precisely, each
9120 * character in the string (see [3.6 Strings]) is considered to have a
9121 * numeric position: the position of the first character is 1, the position
9122 * of the second character is 2 and so on. The returned substring contains
9123 * those characters for which the position of the character is greater than
9124 * or equal to the second argument and, if the third argument is specified,
9125 * less than the sum of the second and third arguments; the comparisons
9126 * and addition used for the above follow the standard IEEE 754 rules. Thus:
9127 * - substring("12345", 1.5, 2.6) returns "234"
9128 * - substring("12345", 0, 3) returns "12"
9129 * - substring("12345", 0 div 0, 3) returns ""
9130 * - substring("12345", 1, 0 div 0) returns ""
9131 * - substring("12345", -42, 1 div 0) returns "12345"
9132 * - substring("12345", -1 div 0, 1 div 0) returns ""
9133 */
9134 void
9135 xmlXPathSubstringFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9136 xmlXPathObjectPtr str, start, len;
9137 double le=0, in;
9138 int i, l, m;
9139 xmlChar *ret;
9140
9141 if (nargs < 2) {
9142 CHECK_ARITY(2);
9143 }
9144 if (nargs > 3) {
9145 CHECK_ARITY(3);
9146 }
9147 /*
9148 * take care of possible last (position) argument
9149 */
9150 if (nargs == 3) {
9151 CAST_TO_NUMBER;
9152 CHECK_TYPE(XPATH_NUMBER);
9153 len = valuePop(ctxt);
9154 le = len->floatval;
9155 xmlXPathReleaseObject(ctxt->context, len);
9156 }
9157
9158 CAST_TO_NUMBER;
9159 CHECK_TYPE(XPATH_NUMBER);
9160 start = valuePop(ctxt);
9161 in = start->floatval;
9162 xmlXPathReleaseObject(ctxt->context, start);
9163 CAST_TO_STRING;
9164 CHECK_TYPE(XPATH_STRING);
9165 str = valuePop(ctxt);
9166 m = xmlUTF8Strlen((const unsigned char *)str->stringval);
9167
9168 /*
9169 * If last pos not present, calculate last position
9170 */
9171 if (nargs != 3) {
9172 le = (double)m;
9173 if (in < 1.0)
9174 in = 1.0;
9175 }
9176
9177 /* Need to check for the special cases where either
9178 * the index is NaN, the length is NaN, or both
9179 * arguments are infinity (relying on Inf + -Inf = NaN)
9180 */
9181 if (!xmlXPathIsInf(in) && !xmlXPathIsNaN(in + le)) {
9182 /*
9183 * To meet the requirements of the spec, the arguments
9184 * must be converted to integer format before
9185 * initial index calculations are done
9186 *
9187 * First we go to integer form, rounding up
9188 * and checking for special cases
9189 */
9190 i = (int) in;
9191 if (((double)i)+0.5 <= in) i++;
9192
9193 if (xmlXPathIsInf(le) == 1) {
9194 l = m;
9195 if (i < 1)
9196 i = 1;
9197 }
9198 else if (xmlXPathIsInf(le) == -1 || le < 0.0)
9199 l = 0;
9200 else {
9201 l = (int) le;
9202 if (((double)l)+0.5 <= le) l++;
9203 }
9204
9205 /* Now we normalize inidices */
9206 i -= 1;
9207 l += i;
9208 if (i < 0)
9209 i = 0;
9210 if (l > m)
9211 l = m;
9212
9213 /* number of chars to copy */
9214 l -= i;
9215
9216 ret = xmlUTF8Strsub(str->stringval, i, l);
9217 }
9218 else {
9219 ret = NULL;
9220 }
9221 if (ret == NULL)
9222 valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, ""));
9223 else {
9224 valuePush(ctxt, xmlXPathCacheNewString(ctxt->context, ret));
9225 xmlFree(ret);
9226 }
9227 xmlXPathReleaseObject(ctxt->context, str);
9228 }
9229
9230 /**
9231 * xmlXPathSubstringBeforeFunction:
9232 * @ctxt: the XPath Parser context
9233 * @nargs: the number of arguments
9234 *
9235 * Implement the substring-before() XPath function
9236 * string substring-before(string, string)
9237 * The substring-before function returns the substring of the first
9238 * argument string that precedes the first occurrence of the second
9239 * argument string in the first argument string, or the empty string
9240 * if the first argument string does not contain the second argument
9241 * string. For example, substring-before("1999/04/01","/") returns 1999.
9242 */
9243 void
9244 xmlXPathSubstringBeforeFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9245 xmlXPathObjectPtr str;
9246 xmlXPathObjectPtr find;
9247 xmlBufPtr target;
9248 const xmlChar *point;
9249 int offset;
9250
9251 CHECK_ARITY(2);
9252 CAST_TO_STRING;
9253 find = valuePop(ctxt);
9254 CAST_TO_STRING;
9255 str = valuePop(ctxt);
9256
9257 target = xmlBufCreate();
9258 if (target) {
9259 point = xmlStrstr(str->stringval, find->stringval);
9260 if (point) {
9261 offset = (int)(point - str->stringval);
9262 xmlBufAdd(target, str->stringval, offset);
9263 }
9264 valuePush(ctxt, xmlXPathCacheNewString(ctxt->context,
9265 xmlBufContent(target)));
9266 xmlBufFree(target);
9267 }
9268 xmlXPathReleaseObject(ctxt->context, str);
9269 xmlXPathReleaseObject(ctxt->context, find);
9270 }
9271
9272 /**
9273 * xmlXPathSubstringAfterFunction:
9274 * @ctxt: the XPath Parser context
9275 * @nargs: the number of arguments
9276 *
9277 * Implement the substring-after() XPath function
9278 * string substring-after(string, string)
9279 * The substring-after function returns the substring of the first
9280 * argument string that follows the first occurrence of the second
9281 * argument string in the first argument string, or the empty stringi
9282 * if the first argument string does not contain the second argument
9283 * string. For example, substring-after("1999/04/01","/") returns 04/01,
9284 * and substring-after("1999/04/01","19") returns 99/04/01.
9285 */
9286 void
9287 xmlXPathSubstringAfterFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9288 xmlXPathObjectPtr str;
9289 xmlXPathObjectPtr find;
9290 xmlBufPtr target;
9291 const xmlChar *point;
9292 int offset;
9293
9294 CHECK_ARITY(2);
9295 CAST_TO_STRING;
9296 find = valuePop(ctxt);
9297 CAST_TO_STRING;
9298 str = valuePop(ctxt);
9299
9300 target = xmlBufCreate();
9301 if (target) {
9302 point = xmlStrstr(str->stringval, find->stringval);
9303 if (point) {
9304 offset = (int)(point - str->stringval) + xmlStrlen(find->stringval);
9305 xmlBufAdd(target, &str->stringval[offset],
9306 xmlStrlen(str->stringval) - offset);
9307 }
9308 valuePush(ctxt, xmlXPathCacheNewString(ctxt->context,
9309 xmlBufContent(target)));
9310 xmlBufFree(target);
9311 }
9312 xmlXPathReleaseObject(ctxt->context, str);
9313 xmlXPathReleaseObject(ctxt->context, find);
9314 }
9315
9316 /**
9317 * xmlXPathNormalizeFunction:
9318 * @ctxt: the XPath Parser context
9319 * @nargs: the number of arguments
9320 *
9321 * Implement the normalize-space() XPath function
9322 * string normalize-space(string?)
9323 * The normalize-space function returns the argument string with white
9324 * space normalized by stripping leading and trailing whitespace
9325 * and replacing sequences of whitespace characters by a single
9326 * space. Whitespace characters are the same allowed by the S production
9327 * in XML. If the argument is omitted, it defaults to the context
9328 * node converted to a string, in other words the value of the context node.
9329 */
9330 void
9331 xmlXPathNormalizeFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9332 xmlXPathObjectPtr obj = NULL;
9333 xmlChar *source = NULL;
9334 xmlBufPtr target;
9335 xmlChar blank;
9336
9337 if (ctxt == NULL) return;
9338 if (nargs == 0) {
9339 /* Use current context node */
9340 valuePush(ctxt,
9341 xmlXPathCacheWrapString(ctxt->context,
9342 xmlXPathCastNodeToString(ctxt->context->node)));
9343 nargs = 1;
9344 }
9345
9346 CHECK_ARITY(1);
9347 CAST_TO_STRING;
9348 CHECK_TYPE(XPATH_STRING);
9349 obj = valuePop(ctxt);
9350 source = obj->stringval;
9351
9352 target = xmlBufCreate();
9353 if (target && source) {
9354
9355 /* Skip leading whitespaces */
9356 while (IS_BLANK_CH(*source))
9357 source++;
9358
9359 /* Collapse intermediate whitespaces, and skip trailing whitespaces */
9360 blank = 0;
9361 while (*source) {
9362 if (IS_BLANK_CH(*source)) {
9363 blank = 0x20;
9364 } else {
9365 if (blank) {
9366 xmlBufAdd(target, &blank, 1);
9367 blank = 0;
9368 }
9369 xmlBufAdd(target, source, 1);
9370 }
9371 source++;
9372 }
9373 valuePush(ctxt, xmlXPathCacheNewString(ctxt->context,
9374 xmlBufContent(target)));
9375 xmlBufFree(target);
9376 }
9377 xmlXPathReleaseObject(ctxt->context, obj);
9378 }
9379
9380 /**
9381 * xmlXPathTranslateFunction:
9382 * @ctxt: the XPath Parser context
9383 * @nargs: the number of arguments
9384 *
9385 * Implement the translate() XPath function
9386 * string translate(string, string, string)
9387 * The translate function returns the first argument string with
9388 * occurrences of characters in the second argument string replaced
9389 * by the character at the corresponding position in the third argument
9390 * string. For example, translate("bar","abc","ABC") returns the string
9391 * BAr. If there is a character in the second argument string with no
9392 * character at a corresponding position in the third argument string
9393 * (because the second argument string is longer than the third argument
9394 * string), then occurrences of that character in the first argument
9395 * string are removed. For example, translate("--aaa--","abc-","ABC")
9396 * returns "AAA". If a character occurs more than once in second
9397 * argument string, then the first occurrence determines the replacement
9398 * character. If the third argument string is longer than the second
9399 * argument string, then excess characters are ignored.
9400 */
9401 void
9402 xmlXPathTranslateFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9403 xmlXPathObjectPtr str;
9404 xmlXPathObjectPtr from;
9405 xmlXPathObjectPtr to;
9406 xmlBufPtr target;
9407 int offset, max;
9408 xmlChar ch;
9409 const xmlChar *point;
9410 xmlChar *cptr;
9411
9412 CHECK_ARITY(3);
9413
9414 CAST_TO_STRING;
9415 to = valuePop(ctxt);
9416 CAST_TO_STRING;
9417 from = valuePop(ctxt);
9418 CAST_TO_STRING;
9419 str = valuePop(ctxt);
9420
9421 target = xmlBufCreate();
9422 if (target) {
9423 max = xmlUTF8Strlen(to->stringval);
9424 for (cptr = str->stringval; (ch=*cptr); ) {
9425 offset = xmlUTF8Strloc(from->stringval, cptr);
9426 if (offset >= 0) {
9427 if (offset < max) {
9428 point = xmlUTF8Strpos(to->stringval, offset);
9429 if (point)
9430 xmlBufAdd(target, point, xmlUTF8Strsize(point, 1));
9431 }
9432 } else
9433 xmlBufAdd(target, cptr, xmlUTF8Strsize(cptr, 1));
9434
9435 /* Step to next character in input */
9436 cptr++;
9437 if ( ch & 0x80 ) {
9438 /* if not simple ascii, verify proper format */
9439 if ( (ch & 0xc0) != 0xc0 ) {
9440 xmlGenericError(xmlGenericErrorContext,
9441 "xmlXPathTranslateFunction: Invalid UTF8 string\n");
9442 /* not asserting an XPath error is probably better */
9443 break;
9444 }
9445 /* then skip over remaining bytes for this char */
9446 while ( (ch <<= 1) & 0x80 )
9447 if ( (*cptr++ & 0xc0) != 0x80 ) {
9448 xmlGenericError(xmlGenericErrorContext,
9449 "xmlXPathTranslateFunction: Invalid UTF8 string\n");
9450 /* not asserting an XPath error is probably better */
9451 break;
9452 }
9453 if (ch & 0x80) /* must have had error encountered */
9454 break;
9455 }
9456 }
9457 }
9458 valuePush(ctxt, xmlXPathCacheNewString(ctxt->context,
9459 xmlBufContent(target)));
9460 xmlBufFree(target);
9461 xmlXPathReleaseObject(ctxt->context, str);
9462 xmlXPathReleaseObject(ctxt->context, from);
9463 xmlXPathReleaseObject(ctxt->context, to);
9464 }
9465
9466 /**
9467 * xmlXPathBooleanFunction:
9468 * @ctxt: the XPath Parser context
9469 * @nargs: the number of arguments
9470 *
9471 * Implement the boolean() XPath function
9472 * boolean boolean(object)
9473 * The boolean function converts its argument to a boolean as follows:
9474 * - a number is true if and only if it is neither positive or
9475 * negative zero nor NaN
9476 * - a node-set is true if and only if it is non-empty
9477 * - a string is true if and only if its length is non-zero
9478 */
9479 void
9480 xmlXPathBooleanFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9481 xmlXPathObjectPtr cur;
9482
9483 CHECK_ARITY(1);
9484 cur = valuePop(ctxt);
9485 if (cur == NULL) XP_ERROR(XPATH_INVALID_OPERAND);
9486 cur = xmlXPathCacheConvertBoolean(ctxt->context, cur);
9487 valuePush(ctxt, cur);
9488 }
9489
9490 /**
9491 * xmlXPathNotFunction:
9492 * @ctxt: the XPath Parser context
9493 * @nargs: the number of arguments
9494 *
9495 * Implement the not() XPath function
9496 * boolean not(boolean)
9497 * The not function returns true if its argument is false,
9498 * and false otherwise.
9499 */
9500 void
9501 xmlXPathNotFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9502 CHECK_ARITY(1);
9503 CAST_TO_BOOLEAN;
9504 CHECK_TYPE(XPATH_BOOLEAN);
9505 ctxt->value->boolval = ! ctxt->value->boolval;
9506 }
9507
9508 /**
9509 * xmlXPathTrueFunction:
9510 * @ctxt: the XPath Parser context
9511 * @nargs: the number of arguments
9512 *
9513 * Implement the true() XPath function
9514 * boolean true()
9515 */
9516 void
9517 xmlXPathTrueFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9518 CHECK_ARITY(0);
9519 valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, 1));
9520 }
9521
9522 /**
9523 * xmlXPathFalseFunction:
9524 * @ctxt: the XPath Parser context
9525 * @nargs: the number of arguments
9526 *
9527 * Implement the false() XPath function
9528 * boolean false()
9529 */
9530 void
9531 xmlXPathFalseFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9532 CHECK_ARITY(0);
9533 valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, 0));
9534 }
9535
9536 /**
9537 * xmlXPathLangFunction:
9538 * @ctxt: the XPath Parser context
9539 * @nargs: the number of arguments
9540 *
9541 * Implement the lang() XPath function
9542 * boolean lang(string)
9543 * The lang function returns true or false depending on whether the
9544 * language of the context node as specified by xml:lang attributes
9545 * is the same as or is a sublanguage of the language specified by
9546 * the argument string. The language of the context node is determined
9547 * by the value of the xml:lang attribute on the context node, or, if
9548 * the context node has no xml:lang attribute, by the value of the
9549 * xml:lang attribute on the nearest ancestor of the context node that
9550 * has an xml:lang attribute. If there is no such attribute, then lang
9551 * returns false. If there is such an attribute, then lang returns
9552 * true if the attribute value is equal to the argument ignoring case,
9553 * or if there is some suffix starting with - such that the attribute
9554 * value is equal to the argument ignoring that suffix of the attribute
9555 * value and ignoring case.
9556 */
9557 void
9558 xmlXPathLangFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9559 xmlXPathObjectPtr val = NULL;
9560 const xmlChar *theLang = NULL;
9561 const xmlChar *lang;
9562 int ret = 0;
9563 int i;
9564
9565 CHECK_ARITY(1);
9566 CAST_TO_STRING;
9567 CHECK_TYPE(XPATH_STRING);
9568 val = valuePop(ctxt);
9569 lang = val->stringval;
9570 theLang = xmlNodeGetLang(ctxt->context->node);
9571 if ((theLang != NULL) && (lang != NULL)) {
9572 for (i = 0;lang[i] != 0;i++)
9573 if (toupper(lang[i]) != toupper(theLang[i]))
9574 goto not_equal;
9575 if ((theLang[i] == 0) || (theLang[i] == '-'))
9576 ret = 1;
9577 }
9578 not_equal:
9579 if (theLang != NULL)
9580 xmlFree((void *)theLang);
9581
9582 xmlXPathReleaseObject(ctxt->context, val);
9583 valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, ret));
9584 }
9585
9586 /**
9587 * xmlXPathNumberFunction:
9588 * @ctxt: the XPath Parser context
9589 * @nargs: the number of arguments
9590 *
9591 * Implement the number() XPath function
9592 * number number(object?)
9593 */
9594 void
9595 xmlXPathNumberFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9596 xmlXPathObjectPtr cur;
9597 double res;
9598
9599 if (ctxt == NULL) return;
9600 if (nargs == 0) {
9601 if (ctxt->context->node == NULL) {
9602 valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, 0.0));
9603 } else {
9604 xmlChar* content = xmlNodeGetContent(ctxt->context->node);
9605
9606 res = xmlXPathStringEvalNumber(content);
9607 valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, res));
9608 xmlFree(content);
9609 }
9610 return;
9611 }
9612
9613 CHECK_ARITY(1);
9614 cur = valuePop(ctxt);
9615 valuePush(ctxt, xmlXPathCacheConvertNumber(ctxt->context, cur));
9616 }
9617
9618 /**
9619 * xmlXPathSumFunction:
9620 * @ctxt: the XPath Parser context
9621 * @nargs: the number of arguments
9622 *
9623 * Implement the sum() XPath function
9624 * number sum(node-set)
9625 * The sum function returns the sum of the values of the nodes in
9626 * the argument node-set.
9627 */
9628 void
9629 xmlXPathSumFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9630 xmlXPathObjectPtr cur;
9631 int i;
9632 double res = 0.0;
9633
9634 CHECK_ARITY(1);
9635 if ((ctxt->value == NULL) ||
9636 ((ctxt->value->type != XPATH_NODESET) &&
9637 (ctxt->value->type != XPATH_XSLT_TREE)))
9638 XP_ERROR(XPATH_INVALID_TYPE);
9639 cur = valuePop(ctxt);
9640
9641 if ((cur->nodesetval != NULL) && (cur->nodesetval->nodeNr != 0)) {
9642 for (i = 0; i < cur->nodesetval->nodeNr; i++) {
9643 res += xmlXPathCastNodeToNumber(cur->nodesetval->nodeTab[i]);
9644 }
9645 }
9646 valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, res));
9647 xmlXPathReleaseObject(ctxt->context, cur);
9648 }
9649
9650 /**
9651 * xmlXPathFloorFunction:
9652 * @ctxt: the XPath Parser context
9653 * @nargs: the number of arguments
9654 *
9655 * Implement the floor() XPath function
9656 * number floor(number)
9657 * The floor function returns the largest (closest to positive infinity)
9658 * number that is not greater than the argument and that is an integer.
9659 */
9660 void
9661 xmlXPathFloorFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9662 CHECK_ARITY(1);
9663 CAST_TO_NUMBER;
9664 CHECK_TYPE(XPATH_NUMBER);
9665
9666 ctxt->value->floatval = floor(ctxt->value->floatval);
9667 }
9668
9669 /**
9670 * xmlXPathCeilingFunction:
9671 * @ctxt: the XPath Parser context
9672 * @nargs: the number of arguments
9673 *
9674 * Implement the ceiling() XPath function
9675 * number ceiling(number)
9676 * The ceiling function returns the smallest (closest to negative infinity)
9677 * number that is not less than the argument and that is an integer.
9678 */
9679 void
9680 xmlXPathCeilingFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9681 CHECK_ARITY(1);
9682 CAST_TO_NUMBER;
9683 CHECK_TYPE(XPATH_NUMBER);
9684
9685 ctxt->value->floatval = ceil(ctxt->value->floatval);
9686 }
9687
9688 /**
9689 * xmlXPathRoundFunction:
9690 * @ctxt: the XPath Parser context
9691 * @nargs: the number of arguments
9692 *
9693 * Implement the round() XPath function
9694 * number round(number)
9695 * The round function returns the number that is closest to the
9696 * argument and that is an integer. If there are two such numbers,
9697 * then the one that is closest to positive infinity is returned.
9698 */
9699 void
9700 xmlXPathRoundFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9701 double f;
9702
9703 CHECK_ARITY(1);
9704 CAST_TO_NUMBER;
9705 CHECK_TYPE(XPATH_NUMBER);
9706
9707 f = ctxt->value->floatval;
9708
9709 if ((f >= -0.5) && (f < 0.5)) {
9710 /* Handles negative zero. */
9711 ctxt->value->floatval *= 0.0;
9712 }
9713 else {
9714 double rounded = floor(f);
9715 if (f - rounded >= 0.5)
9716 rounded += 1.0;
9717 ctxt->value->floatval = rounded;
9718 }
9719 }
9720
9721 /************************************************************************
9722 * *
9723 * The Parser *
9724 * *
9725 ************************************************************************/
9726
9727 /*
9728 * a few forward declarations since we use a recursive call based
9729 * implementation.
9730 */
9731 static void xmlXPathCompileExpr(xmlXPathParserContextPtr ctxt, int sort);
9732 static void xmlXPathCompPredicate(xmlXPathParserContextPtr ctxt, int filter);
9733 static void xmlXPathCompLocationPath(xmlXPathParserContextPtr ctxt);
9734 static void xmlXPathCompRelativeLocationPath(xmlXPathParserContextPtr ctxt);
9735 static xmlChar * xmlXPathParseNameComplex(xmlXPathParserContextPtr ctxt,
9736 int qualified);
9737
9738 /**
9739 * xmlXPathCurrentChar:
9740 * @ctxt: the XPath parser context
9741 * @cur: pointer to the beginning of the char
9742 * @len: pointer to the length of the char read
9743 *
9744 * The current char value, if using UTF-8 this may actually span multiple
9745 * bytes in the input buffer.
9746 *
9747 * Returns the current char value and its length
9748 */
9749
9750 static int
9751 xmlXPathCurrentChar(xmlXPathParserContextPtr ctxt, int *len) {
9752 unsigned char c;
9753 unsigned int val;
9754 const xmlChar *cur;
9755
9756 if (ctxt == NULL)
9757 return(0);
9758 cur = ctxt->cur;
9759
9760 /*
9761 * We are supposed to handle UTF8, check it's valid
9762 * From rfc2044: encoding of the Unicode values on UTF-8:
9763 *
9764 * UCS-4 range (hex.) UTF-8 octet sequence (binary)
9765 * 0000 0000-0000 007F 0xxxxxxx
9766 * 0000 0080-0000 07FF 110xxxxx 10xxxxxx
9767 * 0000 0800-0000 FFFF 1110xxxx 10xxxxxx 10xxxxxx
9768 *
9769 * Check for the 0x110000 limit too
9770 */
9771 c = *cur;
9772 if (c & 0x80) {
9773 if ((cur[1] & 0xc0) != 0x80)
9774 goto encoding_error;
9775 if ((c & 0xe0) == 0xe0) {
9776
9777 if ((cur[2] & 0xc0) != 0x80)
9778 goto encoding_error;
9779 if ((c & 0xf0) == 0xf0) {
9780 if (((c & 0xf8) != 0xf0) ||
9781 ((cur[3] & 0xc0) != 0x80))
9782 goto encoding_error;
9783 /* 4-byte code */
9784 *len = 4;
9785 val = (cur[0] & 0x7) << 18;
9786 val |= (cur[1] & 0x3f) << 12;
9787 val |= (cur[2] & 0x3f) << 6;
9788 val |= cur[3] & 0x3f;
9789 } else {
9790 /* 3-byte code */
9791 *len = 3;
9792 val = (cur[0] & 0xf) << 12;
9793 val |= (cur[1] & 0x3f) << 6;
9794 val |= cur[2] & 0x3f;
9795 }
9796 } else {
9797 /* 2-byte code */
9798 *len = 2;
9799 val = (cur[0] & 0x1f) << 6;
9800 val |= cur[1] & 0x3f;
9801 }
9802 if (!IS_CHAR(val)) {
9803 XP_ERROR0(XPATH_INVALID_CHAR_ERROR);
9804 }
9805 return(val);
9806 } else {
9807 /* 1-byte code */
9808 *len = 1;
9809 return((int) *cur);
9810 }
9811 encoding_error:
9812 /*
9813 * If we detect an UTF8 error that probably means that the
9814 * input encoding didn't get properly advertised in the
9815 * declaration header. Report the error and switch the encoding
9816 * to ISO-Latin-1 (if you don't like this policy, just declare the
9817 * encoding !)
9818 */
9819 *len = 0;
9820 XP_ERROR0(XPATH_ENCODING_ERROR);
9821 }
9822
9823 /**
9824 * xmlXPathParseNCName:
9825 * @ctxt: the XPath Parser context
9826 *
9827 * parse an XML namespace non qualified name.
9828 *
9829 * [NS 3] NCName ::= (Letter | '_') (NCNameChar)*
9830 *
9831 * [NS 4] NCNameChar ::= Letter | Digit | '.' | '-' | '_' |
9832 * CombiningChar | Extender
9833 *
9834 * Returns the namespace name or NULL
9835 */
9836
9837 xmlChar *
9838 xmlXPathParseNCName(xmlXPathParserContextPtr ctxt) {
9839 const xmlChar *in;
9840 xmlChar *ret;
9841 int count = 0;
9842
9843 if ((ctxt == NULL) || (ctxt->cur == NULL)) return(NULL);
9844 /*
9845 * Accelerator for simple ASCII names
9846 */
9847 in = ctxt->cur;
9848 if (((*in >= 0x61) && (*in <= 0x7A)) ||
9849 ((*in >= 0x41) && (*in <= 0x5A)) ||
9850 (*in == '_')) {
9851 in++;
9852 while (((*in >= 0x61) && (*in <= 0x7A)) ||
9853 ((*in >= 0x41) && (*in <= 0x5A)) ||
9854 ((*in >= 0x30) && (*in <= 0x39)) ||
9855 (*in == '_') || (*in == '.') ||
9856 (*in == '-'))
9857 in++;
9858 if ((*in == ' ') || (*in == '>') || (*in == '/') ||
9859 (*in == '[') || (*in == ']') || (*in == ':') ||
9860 (*in == '@') || (*in == '*')) {
9861 count = in - ctxt->cur;
9862 if (count == 0)
9863 return(NULL);
9864 ret = xmlStrndup(ctxt->cur, count);
9865 ctxt->cur = in;
9866 return(ret);
9867 }
9868 }
9869 return(xmlXPathParseNameComplex(ctxt, 0));
9870 }
9871
9872
9873 /**
9874 * xmlXPathParseQName:
9875 * @ctxt: the XPath Parser context
9876 * @prefix: a xmlChar **
9877 *
9878 * parse an XML qualified name
9879 *
9880 * [NS 5] QName ::= (Prefix ':')? LocalPart
9881 *
9882 * [NS 6] Prefix ::= NCName
9883 *
9884 * [NS 7] LocalPart ::= NCName
9885 *
9886 * Returns the function returns the local part, and prefix is updated
9887 * to get the Prefix if any.
9888 */
9889
9890 static xmlChar *
9891 xmlXPathParseQName(xmlXPathParserContextPtr ctxt, xmlChar **prefix) {
9892 xmlChar *ret = NULL;
9893
9894 *prefix = NULL;
9895 ret = xmlXPathParseNCName(ctxt);
9896 if (ret && CUR == ':') {
9897 *prefix = ret;
9898 NEXT;
9899 ret = xmlXPathParseNCName(ctxt);
9900 }
9901 return(ret);
9902 }
9903
9904 /**
9905 * xmlXPathParseName:
9906 * @ctxt: the XPath Parser context
9907 *
9908 * parse an XML name
9909 *
9910 * [4] NameChar ::= Letter | Digit | '.' | '-' | '_' | ':' |
9911 * CombiningChar | Extender
9912 *
9913 * [5] Name ::= (Letter | '_' | ':') (NameChar)*
9914 *
9915 * Returns the namespace name or NULL
9916 */
9917
9918 xmlChar *
9919 xmlXPathParseName(xmlXPathParserContextPtr ctxt) {
9920 const xmlChar *in;
9921 xmlChar *ret;
9922 size_t count = 0;
9923
9924 if ((ctxt == NULL) || (ctxt->cur == NULL)) return(NULL);
9925 /*
9926 * Accelerator for simple ASCII names
9927 */
9928 in = ctxt->cur;
9929 if (((*in >= 0x61) && (*in <= 0x7A)) ||
9930 ((*in >= 0x41) && (*in <= 0x5A)) ||
9931 (*in == '_') || (*in == ':')) {
9932 in++;
9933 while (((*in >= 0x61) && (*in <= 0x7A)) ||
9934 ((*in >= 0x41) && (*in <= 0x5A)) ||
9935 ((*in >= 0x30) && (*in <= 0x39)) ||
9936 (*in == '_') || (*in == '-') ||
9937 (*in == ':') || (*in == '.'))
9938 in++;
9939 if ((*in > 0) && (*in < 0x80)) {
9940 count = in - ctxt->cur;
9941 if (count > XML_MAX_NAME_LENGTH) {
9942 ctxt->cur = in;
9943 XP_ERRORNULL(XPATH_EXPR_ERROR);
9944 }
9945 ret = xmlStrndup(ctxt->cur, count);
9946 ctxt->cur = in;
9947 return(ret);
9948 }
9949 }
9950 return(xmlXPathParseNameComplex(ctxt, 1));
9951 }
9952
9953 static xmlChar *
9954 xmlXPathParseNameComplex(xmlXPathParserContextPtr ctxt, int qualified) {
9955 xmlChar buf[XML_MAX_NAMELEN + 5];
9956 int len = 0, l;
9957 int c;
9958
9959 /*
9960 * Handler for more complex cases
9961 */
9962 c = CUR_CHAR(l);
9963 if ((c == ' ') || (c == '>') || (c == '/') || /* accelerators */
9964 (c == '[') || (c == ']') || (c == '@') || /* accelerators */
9965 (c == '*') || /* accelerators */
9966 (!IS_LETTER(c) && (c != '_') &&
9967 ((!qualified) || (c != ':')))) {
9968 return(NULL);
9969 }
9970
9971 while ((c != ' ') && (c != '>') && (c != '/') && /* test bigname.xml */
9972 ((IS_LETTER(c)) || (IS_DIGIT(c)) ||
9973 (c == '.') || (c == '-') ||
9974 (c == '_') || ((qualified) && (c == ':')) ||
9975 (IS_COMBINING(c)) ||
9976 (IS_EXTENDER(c)))) {
9977 COPY_BUF(l,buf,len,c);
9978 NEXTL(l);
9979 c = CUR_CHAR(l);
9980 if (len >= XML_MAX_NAMELEN) {
9981 /*
9982 * Okay someone managed to make a huge name, so he's ready to pay
9983 * for the processing speed.
9984 */
9985 xmlChar *buffer;
9986 int max = len * 2;
9987
9988 if (len > XML_MAX_NAME_LENGTH) {
9989 XP_ERRORNULL(XPATH_EXPR_ERROR);
9990 }
9991 buffer = (xmlChar *) xmlMallocAtomic(max * sizeof(xmlChar));
9992 if (buffer == NULL) {
9993 XP_ERRORNULL(XPATH_MEMORY_ERROR);
9994 }
9995 memcpy(buffer, buf, len);
9996 while ((IS_LETTER(c)) || (IS_DIGIT(c)) || /* test bigname.xml */
9997 (c == '.') || (c == '-') ||
9998 (c == '_') || ((qualified) && (c == ':')) ||
9999 (IS_COMBINING(c)) ||
10000 (IS_EXTENDER(c))) {
10001 if (len + 10 > max) {
10002 if (max > XML_MAX_NAME_LENGTH) {
10003 XP_ERRORNULL(XPATH_EXPR_ERROR);
10004 }
10005 max *= 2;
10006 buffer = (xmlChar *) xmlRealloc(buffer,
10007 max * sizeof(xmlChar));
10008 if (buffer == NULL) {
10009 XP_ERRORNULL(XPATH_MEMORY_ERROR);
10010 }
10011 }
10012 COPY_BUF(l,buffer,len,c);
10013 NEXTL(l);
10014 c = CUR_CHAR(l);
10015 }
10016 buffer[len] = 0;
10017 return(buffer);
10018 }
10019 }
10020 if (len == 0)
10021 return(NULL);
10022 return(xmlStrndup(buf, len));
10023 }
10024
10025 #define MAX_FRAC 20
10026
10027 /**
10028 * xmlXPathStringEvalNumber:
10029 * @str: A string to scan
10030 *
10031 * [30a] Float ::= Number ('e' Digits?)?
10032 *
10033 * [30] Number ::= Digits ('.' Digits?)?
10034 * | '.' Digits
10035 * [31] Digits ::= [0-9]+
10036 *
10037 * Compile a Number in the string
10038 * In complement of the Number expression, this function also handles
10039 * negative values : '-' Number.
10040 *
10041 * Returns the double value.
10042 */
10043 double
10044 xmlXPathStringEvalNumber(const xmlChar *str) {
10045 const xmlChar *cur = str;
10046 double ret;
10047 int ok = 0;
10048 int isneg = 0;
10049 int exponent = 0;
10050 int is_exponent_negative = 0;
10051 #ifdef __GNUC__
10052 unsigned long tmp = 0;
10053 double temp;
10054 #endif
10055 if (cur == NULL) return(0);
10056 while (IS_BLANK_CH(*cur)) cur++;
10057 if ((*cur != '.') && ((*cur < '0') || (*cur > '9')) && (*cur != '-')) {
10058 return(NAN);
10059 }
10060 if (*cur == '-') {
10061 isneg = 1;
10062 cur++;
10063 }
10064
10065 #ifdef __GNUC__
10066 /*
10067 * tmp/temp is a workaround against a gcc compiler bug
10068 * http://veillard.com/gcc.bug
10069 */
10070 ret = 0;
10071 while ((*cur >= '0') && (*cur <= '9')) {
10072 ret = ret * 10;
10073 tmp = (*cur - '0');
10074 ok = 1;
10075 cur++;
10076 temp = (double) tmp;
10077 ret = ret + temp;
10078 }
10079 #else
10080 ret = 0;
10081 while ((*cur >= '0') && (*cur <= '9')) {
10082 ret = ret * 10 + (*cur - '0');
10083 ok = 1;
10084 cur++;
10085 }
10086 #endif
10087
10088 if (*cur == '.') {
10089 int v, frac = 0, max;
10090 double fraction = 0;
10091
10092 cur++;
10093 if (((*cur < '0') || (*cur > '9')) && (!ok)) {
10094 return(NAN);
10095 }
10096 while (*cur == '0') {
10097 frac = frac + 1;
10098 cur++;
10099 }
10100 max = frac + MAX_FRAC;
10101 while (((*cur >= '0') && (*cur <= '9')) && (frac < max)) {
10102 v = (*cur - '0');
10103 fraction = fraction * 10 + v;
10104 frac = frac + 1;
10105 cur++;
10106 }
10107 fraction /= pow(10.0, frac);
10108 ret = ret + fraction;
10109 while ((*cur >= '0') && (*cur <= '9'))
10110 cur++;
10111 }
10112 if ((*cur == 'e') || (*cur == 'E')) {
10113 cur++;
10114 if (*cur == '-') {
10115 is_exponent_negative = 1;
10116 cur++;
10117 } else if (*cur == '+') {
10118 cur++;
10119 }
10120 while ((*cur >= '0') && (*cur <= '9')) {
10121 if (exponent < 1000000)
10122 exponent = exponent * 10 + (*cur - '0');
10123 cur++;
10124 }
10125 }
10126 while (IS_BLANK_CH(*cur)) cur++;
10127 if (*cur != 0) return(NAN);
10128 if (isneg) ret = -ret;
10129 if (is_exponent_negative) exponent = -exponent;
10130 ret *= pow(10.0, (double)exponent);
10131 return(ret);
10132 }
10133
10134 /**
10135 * xmlXPathCompNumber:
10136 * @ctxt: the XPath Parser context
10137 *
10138 * [30] Number ::= Digits ('.' Digits?)?
10139 * | '.' Digits
10140 * [31] Digits ::= [0-9]+
10141 *
10142 * Compile a Number, then push it on the stack
10143 *
10144 */
10145 static void
10146 xmlXPathCompNumber(xmlXPathParserContextPtr ctxt)
10147 {
10148 double ret = 0.0;
10149 int ok = 0;
10150 int exponent = 0;
10151 int is_exponent_negative = 0;
10152 #ifdef __GNUC__
10153 unsigned long tmp = 0;
10154 double temp;
10155 #endif
10156
10157 CHECK_ERROR;
10158 if ((CUR != '.') && ((CUR < '0') || (CUR > '9'))) {
10159 XP_ERROR(XPATH_NUMBER_ERROR);
10160 }
10161 #ifdef __GNUC__
10162 /*
10163 * tmp/temp is a workaround against a gcc compiler bug
10164 * http://veillard.com/gcc.bug
10165 */
10166 ret = 0;
10167 while ((CUR >= '0') && (CUR <= '9')) {
10168 ret = ret * 10;
10169 tmp = (CUR - '0');
10170 ok = 1;
10171 NEXT;
10172 temp = (double) tmp;
10173 ret = ret + temp;
10174 }
10175 #else
10176 ret = 0;
10177 while ((CUR >= '0') && (CUR <= '9')) {
10178 ret = ret * 10 + (CUR - '0');
10179 ok = 1;
10180 NEXT;
10181 }
10182 #endif
10183 if (CUR == '.') {
10184 int v, frac = 0, max;
10185 double fraction = 0;
10186
10187 NEXT;
10188 if (((CUR < '0') || (CUR > '9')) && (!ok)) {
10189 XP_ERROR(XPATH_NUMBER_ERROR);
10190 }
10191 while (CUR == '0') {
10192 frac = frac + 1;
10193 NEXT;
10194 }
10195 max = frac + MAX_FRAC;
10196 while ((CUR >= '0') && (CUR <= '9') && (frac < max)) {
10197 v = (CUR - '0');
10198 fraction = fraction * 10 + v;
10199 frac = frac + 1;
10200 NEXT;
10201 }
10202 fraction /= pow(10.0, frac);
10203 ret = ret + fraction;
10204 while ((CUR >= '0') && (CUR <= '9'))
10205 NEXT;
10206 }
10207 if ((CUR == 'e') || (CUR == 'E')) {
10208 NEXT;
10209 if (CUR == '-') {
10210 is_exponent_negative = 1;
10211 NEXT;
10212 } else if (CUR == '+') {
10213 NEXT;
10214 }
10215 while ((CUR >= '0') && (CUR <= '9')) {
10216 if (exponent < 1000000)
10217 exponent = exponent * 10 + (CUR - '0');
10218 NEXT;
10219 }
10220 if (is_exponent_negative)
10221 exponent = -exponent;
10222 ret *= pow(10.0, (double) exponent);
10223 }
10224 PUSH_LONG_EXPR(XPATH_OP_VALUE, XPATH_NUMBER, 0, 0,
10225 xmlXPathCacheNewFloat(ctxt->context, ret), NULL);
10226 }
10227
10228 /**
10229 * xmlXPathParseLiteral:
10230 * @ctxt: the XPath Parser context
10231 *
10232 * Parse a Literal
10233 *
10234 * [29] Literal ::= '"' [^"]* '"'
10235 * | "'" [^']* "'"
10236 *
10237 * Returns the value found or NULL in case of error
10238 */
10239 static xmlChar *
10240 xmlXPathParseLiteral(xmlXPathParserContextPtr ctxt) {
10241 const xmlChar *q;
10242 xmlChar *ret = NULL;
10243
10244 if (CUR == '"') {
10245 NEXT;
10246 q = CUR_PTR;
10247 while ((IS_CHAR_CH(CUR)) && (CUR != '"'))
10248 NEXT;
10249 if (!IS_CHAR_CH(CUR)) {
10250 XP_ERRORNULL(XPATH_UNFINISHED_LITERAL_ERROR);
10251 } else {
10252 ret = xmlStrndup(q, CUR_PTR - q);
10253 NEXT;
10254 }
10255 } else if (CUR == '\'') {
10256 NEXT;
10257 q = CUR_PTR;
10258 while ((IS_CHAR_CH(CUR)) && (CUR != '\''))
10259 NEXT;
10260 if (!IS_CHAR_CH(CUR)) {
10261 XP_ERRORNULL(XPATH_UNFINISHED_LITERAL_ERROR);
10262 } else {
10263 ret = xmlStrndup(q, CUR_PTR - q);
10264 NEXT;
10265 }
10266 } else {
10267 XP_ERRORNULL(XPATH_START_LITERAL_ERROR);
10268 }
10269 return(ret);
10270 }
10271
10272 /**
10273 * xmlXPathCompLiteral:
10274 * @ctxt: the XPath Parser context
10275 *
10276 * Parse a Literal and push it on the stack.
10277 *
10278 * [29] Literal ::= '"' [^"]* '"'
10279 * | "'" [^']* "'"
10280 *
10281 * TODO: xmlXPathCompLiteral memory allocation could be improved.
10282 */
10283 static void
10284 xmlXPathCompLiteral(xmlXPathParserContextPtr ctxt) {
10285 const xmlChar *q;
10286 xmlChar *ret = NULL;
10287
10288 if (CUR == '"') {
10289 NEXT;
10290 q = CUR_PTR;
10291 while ((IS_CHAR_CH(CUR)) && (CUR != '"'))
10292 NEXT;
10293 if (!IS_CHAR_CH(CUR)) {
10294 XP_ERROR(XPATH_UNFINISHED_LITERAL_ERROR);
10295 } else {
10296 ret = xmlStrndup(q, CUR_PTR - q);
10297 NEXT;
10298 }
10299 } else if (CUR == '\'') {
10300 NEXT;
10301 q = CUR_PTR;
10302 while ((IS_CHAR_CH(CUR)) && (CUR != '\''))
10303 NEXT;
10304 if (!IS_CHAR_CH(CUR)) {
10305 XP_ERROR(XPATH_UNFINISHED_LITERAL_ERROR);
10306 } else {
10307 ret = xmlStrndup(q, CUR_PTR - q);
10308 NEXT;
10309 }
10310 } else {
10311 XP_ERROR(XPATH_START_LITERAL_ERROR);
10312 }
10313 if (ret == NULL) return;
10314 PUSH_LONG_EXPR(XPATH_OP_VALUE, XPATH_STRING, 0, 0,
10315 xmlXPathCacheNewString(ctxt->context, ret), NULL);
10316 xmlFree(ret);
10317 }
10318
10319 /**
10320 * xmlXPathCompVariableReference:
10321 * @ctxt: the XPath Parser context
10322 *
10323 * Parse a VariableReference, evaluate it and push it on the stack.
10324 *
10325 * The variable bindings consist of a mapping from variable names
10326 * to variable values. The value of a variable is an object, which can be
10327 * of any of the types that are possible for the value of an expression,
10328 * and may also be of additional types not specified here.
10329 *
10330 * Early evaluation is possible since:
10331 * The variable bindings [...] used to evaluate a subexpression are
10332 * always the same as those used to evaluate the containing expression.
10333 *
10334 * [36] VariableReference ::= '$' QName
10335 */
10336 static void
10337 xmlXPathCompVariableReference(xmlXPathParserContextPtr ctxt) {
10338 xmlChar *name;
10339 xmlChar *prefix;
10340
10341 SKIP_BLANKS;
10342 if (CUR != '$') {
10343 XP_ERROR(XPATH_VARIABLE_REF_ERROR);
10344 }
10345 NEXT;
10346 name = xmlXPathParseQName(ctxt, &prefix);
10347 if (name == NULL) {
10348 xmlFree(prefix);
10349 XP_ERROR(XPATH_VARIABLE_REF_ERROR);
10350 }
10351 ctxt->comp->last = -1;
10352 PUSH_LONG_EXPR(XPATH_OP_VARIABLE, 0, 0, 0,
10353 name, prefix);
10354 SKIP_BLANKS;
10355 if ((ctxt->context != NULL) && (ctxt->context->flags & XML_XPATH_NOVAR)) {
10356 XP_ERROR(XPATH_FORBID_VARIABLE_ERROR);
10357 }
10358 }
10359
10360 /**
10361 * xmlXPathIsNodeType:
10362 * @name: a name string
10363 *
10364 * Is the name given a NodeType one.
10365 *
10366 * [38] NodeType ::= 'comment'
10367 * | 'text'
10368 * | 'processing-instruction'
10369 * | 'node'
10370 *
10371 * Returns 1 if true 0 otherwise
10372 */
10373 int
10374 xmlXPathIsNodeType(const xmlChar *name) {
10375 if (name == NULL)
10376 return(0);
10377
10378 if (xmlStrEqual(name, BAD_CAST "node"))
10379 return(1);
10380 if (xmlStrEqual(name, BAD_CAST "text"))
10381 return(1);
10382 if (xmlStrEqual(name, BAD_CAST "comment"))
10383 return(1);
10384 if (xmlStrEqual(name, BAD_CAST "processing-instruction"))
10385 return(1);
10386 return(0);
10387 }
10388
10389 /**
10390 * xmlXPathCompFunctionCall:
10391 * @ctxt: the XPath Parser context
10392 *
10393 * [16] FunctionCall ::= FunctionName '(' ( Argument ( ',' Argument)*)? ')'
10394 * [17] Argument ::= Expr
10395 *
10396 * Compile a function call, the evaluation of all arguments are
10397 * pushed on the stack
10398 */
10399 static void
10400 xmlXPathCompFunctionCall(xmlXPathParserContextPtr ctxt) {
10401 xmlChar *name;
10402 xmlChar *prefix;
10403 int nbargs = 0;
10404 int sort = 1;
10405
10406 name = xmlXPathParseQName(ctxt, &prefix);
10407 if (name == NULL) {
10408 xmlFree(prefix);
10409 XP_ERROR(XPATH_EXPR_ERROR);
10410 }
10411 SKIP_BLANKS;
10412 #ifdef DEBUG_EXPR
10413 if (prefix == NULL)
10414 xmlGenericError(xmlGenericErrorContext, "Calling function %s\n",
10415 name);
10416 else
10417 xmlGenericError(xmlGenericErrorContext, "Calling function %s:%s\n",
10418 prefix, name);
10419 #endif
10420
10421 if (CUR != '(') {
10422 xmlFree(name);
10423 xmlFree(prefix);
10424 XP_ERROR(XPATH_EXPR_ERROR);
10425 }
10426 NEXT;
10427 SKIP_BLANKS;
10428
10429 /*
10430 * Optimization for count(): we don't need the node-set to be sorted.
10431 */
10432 if ((prefix == NULL) && (name[0] == 'c') &&
10433 xmlStrEqual(name, BAD_CAST "count"))
10434 {
10435 sort = 0;
10436 }
10437 ctxt->comp->last = -1;
10438 if (CUR != ')') {
10439 while (CUR != 0) {
10440 int op1 = ctxt->comp->last;
10441 ctxt->comp->last = -1;
10442 xmlXPathCompileExpr(ctxt, sort);
10443 if (ctxt->error != XPATH_EXPRESSION_OK) {
10444 xmlFree(name);
10445 xmlFree(prefix);
10446 return;
10447 }
10448 PUSH_BINARY_EXPR(XPATH_OP_ARG, op1, ctxt->comp->last, 0, 0);
10449 nbargs++;
10450 if (CUR == ')') break;
10451 if (CUR != ',') {
10452 xmlFree(name);
10453 xmlFree(prefix);
10454 XP_ERROR(XPATH_EXPR_ERROR);
10455 }
10456 NEXT;
10457 SKIP_BLANKS;
10458 }
10459 }
10460 PUSH_LONG_EXPR(XPATH_OP_FUNCTION, nbargs, 0, 0,
10461 name, prefix);
10462 NEXT;
10463 SKIP_BLANKS;
10464 }
10465
10466 /**
10467 * xmlXPathCompPrimaryExpr:
10468 * @ctxt: the XPath Parser context
10469 *
10470 * [15] PrimaryExpr ::= VariableReference
10471 * | '(' Expr ')'
10472 * | Literal
10473 * | Number
10474 * | FunctionCall
10475 *
10476 * Compile a primary expression.
10477 */
10478 static void
10479 xmlXPathCompPrimaryExpr(xmlXPathParserContextPtr ctxt) {
10480 SKIP_BLANKS;
10481 if (CUR == '$') xmlXPathCompVariableReference(ctxt);
10482 else if (CUR == '(') {
10483 NEXT;
10484 SKIP_BLANKS;
10485 xmlXPathCompileExpr(ctxt, 1);
10486 CHECK_ERROR;
10487 if (CUR != ')') {
10488 XP_ERROR(XPATH_EXPR_ERROR);
10489 }
10490 NEXT;
10491 SKIP_BLANKS;
10492 } else if (IS_ASCII_DIGIT(CUR) || (CUR == '.' && IS_ASCII_DIGIT(NXT(1)))) {
10493 xmlXPathCompNumber(ctxt);
10494 } else if ((CUR == '\'') || (CUR == '"')) {
10495 xmlXPathCompLiteral(ctxt);
10496 } else {
10497 xmlXPathCompFunctionCall(ctxt);
10498 }
10499 SKIP_BLANKS;
10500 }
10501
10502 /**
10503 * xmlXPathCompFilterExpr:
10504 * @ctxt: the XPath Parser context
10505 *
10506 * [20] FilterExpr ::= PrimaryExpr
10507 * | FilterExpr Predicate
10508 *
10509 * Compile a filter expression.
10510 * Square brackets are used to filter expressions in the same way that
10511 * they are used in location paths. It is an error if the expression to
10512 * be filtered does not evaluate to a node-set. The context node list
10513 * used for evaluating the expression in square brackets is the node-set
10514 * to be filtered listed in document order.
10515 */
10516
10517 static void
10518 xmlXPathCompFilterExpr(xmlXPathParserContextPtr ctxt) {
10519 xmlXPathCompPrimaryExpr(ctxt);
10520 CHECK_ERROR;
10521 SKIP_BLANKS;
10522
10523 while (CUR == '[') {
10524 xmlXPathCompPredicate(ctxt, 1);
10525 SKIP_BLANKS;
10526 }
10527
10528
10529 }
10530
10531 /**
10532 * xmlXPathScanName:
10533 * @ctxt: the XPath Parser context
10534 *
10535 * Trickery: parse an XML name but without consuming the input flow
10536 * Needed to avoid insanity in the parser state.
10537 *
10538 * [4] NameChar ::= Letter | Digit | '.' | '-' | '_' | ':' |
10539 * CombiningChar | Extender
10540 *
10541 * [5] Name ::= (Letter | '_' | ':') (NameChar)*
10542 *
10543 * [6] Names ::= Name (S Name)*
10544 *
10545 * Returns the Name parsed or NULL
10546 */
10547
10548 static xmlChar *
10549 xmlXPathScanName(xmlXPathParserContextPtr ctxt) {
10550 int len = 0, l;
10551 int c;
10552 const xmlChar *cur;
10553 xmlChar *ret;
10554
10555 cur = ctxt->cur;
10556
10557 c = CUR_CHAR(l);
10558 if ((c == ' ') || (c == '>') || (c == '/') || /* accelerators */
10559 (!IS_LETTER(c) && (c != '_') &&
10560 (c != ':'))) {
10561 return(NULL);
10562 }
10563
10564 while ((c != ' ') && (c != '>') && (c != '/') && /* test bigname.xml */
10565 ((IS_LETTER(c)) || (IS_DIGIT(c)) ||
10566 (c == '.') || (c == '-') ||
10567 (c == '_') || (c == ':') ||
10568 (IS_COMBINING(c)) ||
10569 (IS_EXTENDER(c)))) {
10570 len += l;
10571 NEXTL(l);
10572 c = CUR_CHAR(l);
10573 }
10574 ret = xmlStrndup(cur, ctxt->cur - cur);
10575 ctxt->cur = cur;
10576 return(ret);
10577 }
10578
10579 /**
10580 * xmlXPathCompPathExpr:
10581 * @ctxt: the XPath Parser context
10582 *
10583 * [19] PathExpr ::= LocationPath
10584 * | FilterExpr
10585 * | FilterExpr '/' RelativeLocationPath
10586 * | FilterExpr '//' RelativeLocationPath
10587 *
10588 * Compile a path expression.
10589 * The / operator and // operators combine an arbitrary expression
10590 * and a relative location path. It is an error if the expression
10591 * does not evaluate to a node-set.
10592 * The / operator does composition in the same way as when / is
10593 * used in a location path. As in location paths, // is short for
10594 * /descendant-or-self::node()/.
10595 */
10596
10597 static void
10598 xmlXPathCompPathExpr(xmlXPathParserContextPtr ctxt) {
10599 int lc = 1; /* Should we branch to LocationPath ? */
10600 xmlChar *name = NULL; /* we may have to preparse a name to find out */
10601
10602 SKIP_BLANKS;
10603 if ((CUR == '$') || (CUR == '(') ||
10604 (IS_ASCII_DIGIT(CUR)) ||
10605 (CUR == '\'') || (CUR == '"') ||
10606 (CUR == '.' && IS_ASCII_DIGIT(NXT(1)))) {
10607 lc = 0;
10608 } else if (CUR == '*') {
10609 /* relative or absolute location path */
10610 lc = 1;
10611 } else if (CUR == '/') {
10612 /* relative or absolute location path */
10613 lc = 1;
10614 } else if (CUR == '@') {
10615 /* relative abbreviated attribute location path */
10616 lc = 1;
10617 } else if (CUR == '.') {
10618 /* relative abbreviated attribute location path */
10619 lc = 1;
10620 } else {
10621 /*
10622 * Problem is finding if we have a name here whether it's:
10623 * - a nodetype
10624 * - a function call in which case it's followed by '('
10625 * - an axis in which case it's followed by ':'
10626 * - a element name
10627 * We do an a priori analysis here rather than having to
10628 * maintain parsed token content through the recursive function
10629 * calls. This looks uglier but makes the code easier to
10630 * read/write/debug.
10631 */
10632 SKIP_BLANKS;
10633 name = xmlXPathScanName(ctxt);
10634 if ((name != NULL) && (xmlStrstr(name, (xmlChar *) "::") != NULL)) {
10635 #ifdef DEBUG_STEP
10636 xmlGenericError(xmlGenericErrorContext,
10637 "PathExpr: Axis\n");
10638 #endif
10639 lc = 1;
10640 xmlFree(name);
10641 } else if (name != NULL) {
10642 int len =xmlStrlen(name);
10643
10644
10645 while (NXT(len) != 0) {
10646 if (NXT(len) == '/') {
10647 /* element name */
10648 #ifdef DEBUG_STEP
10649 xmlGenericError(xmlGenericErrorContext,
10650 "PathExpr: AbbrRelLocation\n");
10651 #endif
10652 lc = 1;
10653 break;
10654 } else if (IS_BLANK_CH(NXT(len))) {
10655 /* ignore blanks */
10656 ;
10657 } else if (NXT(len) == ':') {
10658 #ifdef DEBUG_STEP
10659 xmlGenericError(xmlGenericErrorContext,
10660 "PathExpr: AbbrRelLocation\n");
10661 #endif
10662 lc = 1;
10663 break;
10664 } else if ((NXT(len) == '(')) {
10665 /* Node Type or Function */
10666 if (xmlXPathIsNodeType(name)) {
10667 #ifdef DEBUG_STEP
10668 xmlGenericError(xmlGenericErrorContext,
10669 "PathExpr: Type search\n");
10670 #endif
10671 lc = 1;
10672 #ifdef LIBXML_XPTR_ENABLED
10673 } else if (ctxt->xptr &&
10674 xmlStrEqual(name, BAD_CAST "range-to")) {
10675 lc = 1;
10676 #endif
10677 } else {
10678 #ifdef DEBUG_STEP
10679 xmlGenericError(xmlGenericErrorContext,
10680 "PathExpr: function call\n");
10681 #endif
10682 lc = 0;
10683 }
10684 break;
10685 } else if ((NXT(len) == '[')) {
10686 /* element name */
10687 #ifdef DEBUG_STEP
10688 xmlGenericError(xmlGenericErrorContext,
10689 "PathExpr: AbbrRelLocation\n");
10690 #endif
10691 lc = 1;
10692 break;
10693 } else if ((NXT(len) == '<') || (NXT(len) == '>') ||
10694 (NXT(len) == '=')) {
10695 lc = 1;
10696 break;
10697 } else {
10698 lc = 1;
10699 break;
10700 }
10701 len++;
10702 }
10703 if (NXT(len) == 0) {
10704 #ifdef DEBUG_STEP
10705 xmlGenericError(xmlGenericErrorContext,
10706 "PathExpr: AbbrRelLocation\n");
10707 #endif
10708 /* element name */
10709 lc = 1;
10710 }
10711 xmlFree(name);
10712 } else {
10713 /* make sure all cases are covered explicitly */
10714 XP_ERROR(XPATH_EXPR_ERROR);
10715 }
10716 }
10717
10718 if (lc) {
10719 if (CUR == '/') {
10720 PUSH_LEAVE_EXPR(XPATH_OP_ROOT, 0, 0);
10721 } else {
10722 PUSH_LEAVE_EXPR(XPATH_OP_NODE, 0, 0);
10723 }
10724 xmlXPathCompLocationPath(ctxt);
10725 } else {
10726 xmlXPathCompFilterExpr(ctxt);
10727 CHECK_ERROR;
10728 if ((CUR == '/') && (NXT(1) == '/')) {
10729 SKIP(2);
10730 SKIP_BLANKS;
10731
10732 PUSH_LONG_EXPR(XPATH_OP_COLLECT, AXIS_DESCENDANT_OR_SELF,
10733 NODE_TEST_TYPE, NODE_TYPE_NODE, NULL, NULL);
10734
10735 xmlXPathCompRelativeLocationPath(ctxt);
10736 } else if (CUR == '/') {
10737 xmlXPathCompRelativeLocationPath(ctxt);
10738 }
10739 }
10740 SKIP_BLANKS;
10741 }
10742
10743 /**
10744 * xmlXPathCompUnionExpr:
10745 * @ctxt: the XPath Parser context
10746 *
10747 * [18] UnionExpr ::= PathExpr
10748 * | UnionExpr '|' PathExpr
10749 *
10750 * Compile an union expression.
10751 */
10752
10753 static void
10754 xmlXPathCompUnionExpr(xmlXPathParserContextPtr ctxt) {
10755 xmlXPathCompPathExpr(ctxt);
10756 CHECK_ERROR;
10757 SKIP_BLANKS;
10758 while (CUR == '|') {
10759 int op1 = ctxt->comp->last;
10760 PUSH_LEAVE_EXPR(XPATH_OP_NODE, 0, 0);
10761
10762 NEXT;
10763 SKIP_BLANKS;
10764 xmlXPathCompPathExpr(ctxt);
10765
10766 PUSH_BINARY_EXPR(XPATH_OP_UNION, op1, ctxt->comp->last, 0, 0);
10767
10768 SKIP_BLANKS;
10769 }
10770 }
10771
10772 /**
10773 * xmlXPathCompUnaryExpr:
10774 * @ctxt: the XPath Parser context
10775 *
10776 * [27] UnaryExpr ::= UnionExpr
10777 * | '-' UnaryExpr
10778 *
10779 * Compile an unary expression.
10780 */
10781
10782 static void
10783 xmlXPathCompUnaryExpr(xmlXPathParserContextPtr ctxt) {
10784 int minus = 0;
10785 int found = 0;
10786
10787 SKIP_BLANKS;
10788 while (CUR == '-') {
10789 minus = 1 - minus;
10790 found = 1;
10791 NEXT;
10792 SKIP_BLANKS;
10793 }
10794
10795 xmlXPathCompUnionExpr(ctxt);
10796 CHECK_ERROR;
10797 if (found) {
10798 if (minus)
10799 PUSH_UNARY_EXPR(XPATH_OP_PLUS, ctxt->comp->last, 2, 0);
10800 else
10801 PUSH_UNARY_EXPR(XPATH_OP_PLUS, ctxt->comp->last, 3, 0);
10802 }
10803 }
10804
10805 /**
10806 * xmlXPathCompMultiplicativeExpr:
10807 * @ctxt: the XPath Parser context
10808 *
10809 * [26] MultiplicativeExpr ::= UnaryExpr
10810 * | MultiplicativeExpr MultiplyOperator UnaryExpr
10811 * | MultiplicativeExpr 'div' UnaryExpr
10812 * | MultiplicativeExpr 'mod' UnaryExpr
10813 * [34] MultiplyOperator ::= '*'
10814 *
10815 * Compile an Additive expression.
10816 */
10817
10818 static void
10819 xmlXPathCompMultiplicativeExpr(xmlXPathParserContextPtr ctxt) {
10820 xmlXPathCompUnaryExpr(ctxt);
10821 CHECK_ERROR;
10822 SKIP_BLANKS;
10823 while ((CUR == '*') ||
10824 ((CUR == 'd') && (NXT(1) == 'i') && (NXT(2) == 'v')) ||
10825 ((CUR == 'm') && (NXT(1) == 'o') && (NXT(2) == 'd'))) {
10826 int op = -1;
10827 int op1 = ctxt->comp->last;
10828
10829 if (CUR == '*') {
10830 op = 0;
10831 NEXT;
10832 } else if (CUR == 'd') {
10833 op = 1;
10834 SKIP(3);
10835 } else if (CUR == 'm') {
10836 op = 2;
10837 SKIP(3);
10838 }
10839 SKIP_BLANKS;
10840 xmlXPathCompUnaryExpr(ctxt);
10841 CHECK_ERROR;
10842 PUSH_BINARY_EXPR(XPATH_OP_MULT, op1, ctxt->comp->last, op, 0);
10843 SKIP_BLANKS;
10844 }
10845 }
10846
10847 /**
10848 * xmlXPathCompAdditiveExpr:
10849 * @ctxt: the XPath Parser context
10850 *
10851 * [25] AdditiveExpr ::= MultiplicativeExpr
10852 * | AdditiveExpr '+' MultiplicativeExpr
10853 * | AdditiveExpr '-' MultiplicativeExpr
10854 *
10855 * Compile an Additive expression.
10856 */
10857
10858 static void
10859 xmlXPathCompAdditiveExpr(xmlXPathParserContextPtr ctxt) {
10860
10861 xmlXPathCompMultiplicativeExpr(ctxt);
10862 CHECK_ERROR;
10863 SKIP_BLANKS;
10864 while ((CUR == '+') || (CUR == '-')) {
10865 int plus;
10866 int op1 = ctxt->comp->last;
10867
10868 if (CUR == '+') plus = 1;
10869 else plus = 0;
10870 NEXT;
10871 SKIP_BLANKS;
10872 xmlXPathCompMultiplicativeExpr(ctxt);
10873 CHECK_ERROR;
10874 PUSH_BINARY_EXPR(XPATH_OP_PLUS, op1, ctxt->comp->last, plus, 0);
10875 SKIP_BLANKS;
10876 }
10877 }
10878
10879 /**
10880 * xmlXPathCompRelationalExpr:
10881 * @ctxt: the XPath Parser context
10882 *
10883 * [24] RelationalExpr ::= AdditiveExpr
10884 * | RelationalExpr '<' AdditiveExpr
10885 * | RelationalExpr '>' AdditiveExpr
10886 * | RelationalExpr '<=' AdditiveExpr
10887 * | RelationalExpr '>=' AdditiveExpr
10888 *
10889 * A <= B > C is allowed ? Answer from James, yes with
10890 * (AdditiveExpr <= AdditiveExpr) > AdditiveExpr
10891 * which is basically what got implemented.
10892 *
10893 * Compile a Relational expression, then push the result
10894 * on the stack
10895 */
10896
10897 static void
10898 xmlXPathCompRelationalExpr(xmlXPathParserContextPtr ctxt) {
10899 xmlXPathCompAdditiveExpr(ctxt);
10900 CHECK_ERROR;
10901 SKIP_BLANKS;
10902 while ((CUR == '<') ||
10903 (CUR == '>') ||
10904 ((CUR == '<') && (NXT(1) == '=')) ||
10905 ((CUR == '>') && (NXT(1) == '='))) {
10906 int inf, strict;
10907 int op1 = ctxt->comp->last;
10908
10909 if (CUR == '<') inf = 1;
10910 else inf = 0;
10911 if (NXT(1) == '=') strict = 0;
10912 else strict = 1;
10913 NEXT;
10914 if (!strict) NEXT;
10915 SKIP_BLANKS;
10916 xmlXPathCompAdditiveExpr(ctxt);
10917 CHECK_ERROR;
10918 PUSH_BINARY_EXPR(XPATH_OP_CMP, op1, ctxt->comp->last, inf, strict);
10919 SKIP_BLANKS;
10920 }
10921 }
10922
10923 /**
10924 * xmlXPathCompEqualityExpr:
10925 * @ctxt: the XPath Parser context
10926 *
10927 * [23] EqualityExpr ::= RelationalExpr
10928 * | EqualityExpr '=' RelationalExpr
10929 * | EqualityExpr '!=' RelationalExpr
10930 *
10931 * A != B != C is allowed ? Answer from James, yes with
10932 * (RelationalExpr = RelationalExpr) = RelationalExpr
10933 * (RelationalExpr != RelationalExpr) != RelationalExpr
10934 * which is basically what got implemented.
10935 *
10936 * Compile an Equality expression.
10937 *
10938 */
10939 static void
10940 xmlXPathCompEqualityExpr(xmlXPathParserContextPtr ctxt) {
10941 xmlXPathCompRelationalExpr(ctxt);
10942 CHECK_ERROR;
10943 SKIP_BLANKS;
10944 while ((CUR == '=') || ((CUR == '!') && (NXT(1) == '='))) {
10945 int eq;
10946 int op1 = ctxt->comp->last;
10947
10948 if (CUR == '=') eq = 1;
10949 else eq = 0;
10950 NEXT;
10951 if (!eq) NEXT;
10952 SKIP_BLANKS;
10953 xmlXPathCompRelationalExpr(ctxt);
10954 CHECK_ERROR;
10955 PUSH_BINARY_EXPR(XPATH_OP_EQUAL, op1, ctxt->comp->last, eq, 0);
10956 SKIP_BLANKS;
10957 }
10958 }
10959
10960 /**
10961 * xmlXPathCompAndExpr:
10962 * @ctxt: the XPath Parser context
10963 *
10964 * [22] AndExpr ::= EqualityExpr
10965 * | AndExpr 'and' EqualityExpr
10966 *
10967 * Compile an AND expression.
10968 *
10969 */
10970 static void
10971 xmlXPathCompAndExpr(xmlXPathParserContextPtr ctxt) {
10972 xmlXPathCompEqualityExpr(ctxt);
10973 CHECK_ERROR;
10974 SKIP_BLANKS;
10975 while ((CUR == 'a') && (NXT(1) == 'n') && (NXT(2) == 'd')) {
10976 int op1 = ctxt->comp->last;
10977 SKIP(3);
10978 SKIP_BLANKS;
10979 xmlXPathCompEqualityExpr(ctxt);
10980 CHECK_ERROR;
10981 PUSH_BINARY_EXPR(XPATH_OP_AND, op1, ctxt->comp->last, 0, 0);
10982 SKIP_BLANKS;
10983 }
10984 }
10985
10986 /**
10987 * xmlXPathCompileExpr:
10988 * @ctxt: the XPath Parser context
10989 *
10990 * [14] Expr ::= OrExpr
10991 * [21] OrExpr ::= AndExpr
10992 * | OrExpr 'or' AndExpr
10993 *
10994 * Parse and compile an expression
10995 */
10996 static void
10997 xmlXPathCompileExpr(xmlXPathParserContextPtr ctxt, int sort) {
10998 xmlXPathCompAndExpr(ctxt);
10999 CHECK_ERROR;
11000 SKIP_BLANKS;
11001 while ((CUR == 'o') && (NXT(1) == 'r')) {
11002 int op1 = ctxt->comp->last;
11003 SKIP(2);
11004 SKIP_BLANKS;
11005 xmlXPathCompAndExpr(ctxt);
11006 CHECK_ERROR;
11007 PUSH_BINARY_EXPR(XPATH_OP_OR, op1, ctxt->comp->last, 0, 0);
11008 SKIP_BLANKS;
11009 }
11010 if ((sort) && (ctxt->comp->steps[ctxt->comp->last].op != XPATH_OP_VALUE)) {
11011 /* more ops could be optimized too */
11012 /*
11013 * This is the main place to eliminate sorting for
11014 * operations which don't require a sorted node-set.
11015 * E.g. count().
11016 */
11017 PUSH_UNARY_EXPR(XPATH_OP_SORT, ctxt->comp->last , 0, 0);
11018 }
11019 }
11020
11021 /**
11022 * xmlXPathCompPredicate:
11023 * @ctxt: the XPath Parser context
11024 * @filter: act as a filter
11025 *
11026 * [8] Predicate ::= '[' PredicateExpr ']'
11027 * [9] PredicateExpr ::= Expr
11028 *
11029 * Compile a predicate expression
11030 */
11031 static void
11032 xmlXPathCompPredicate(xmlXPathParserContextPtr ctxt, int filter) {
11033 int op1 = ctxt->comp->last;
11034
11035 SKIP_BLANKS;
11036 if (CUR != '[') {
11037 XP_ERROR(XPATH_INVALID_PREDICATE_ERROR);
11038 }
11039 NEXT;
11040 SKIP_BLANKS;
11041
11042 ctxt->comp->last = -1;
11043 /*
11044 * This call to xmlXPathCompileExpr() will deactivate sorting
11045 * of the predicate result.
11046 * TODO: Sorting is still activated for filters, since I'm not
11047 * sure if needed. Normally sorting should not be needed, since
11048 * a filter can only diminish the number of items in a sequence,
11049 * but won't change its order; so if the initial sequence is sorted,
11050 * subsequent sorting is not needed.
11051 */
11052 if (! filter)
11053 xmlXPathCompileExpr(ctxt, 0);
11054 else
11055 xmlXPathCompileExpr(ctxt, 1);
11056 CHECK_ERROR;
11057
11058 if (CUR != ']') {
11059 XP_ERROR(XPATH_INVALID_PREDICATE_ERROR);
11060 }
11061
11062 if (filter)
11063 PUSH_BINARY_EXPR(XPATH_OP_FILTER, op1, ctxt->comp->last, 0, 0);
11064 else
11065 PUSH_BINARY_EXPR(XPATH_OP_PREDICATE, op1, ctxt->comp->last, 0, 0);
11066
11067 NEXT;
11068 SKIP_BLANKS;
11069 }
11070
11071 /**
11072 * xmlXPathCompNodeTest:
11073 * @ctxt: the XPath Parser context
11074 * @test: pointer to a xmlXPathTestVal
11075 * @type: pointer to a xmlXPathTypeVal
11076 * @prefix: placeholder for a possible name prefix
11077 *
11078 * [7] NodeTest ::= NameTest
11079 * | NodeType '(' ')'
11080 * | 'processing-instruction' '(' Literal ')'
11081 *
11082 * [37] NameTest ::= '*'
11083 * | NCName ':' '*'
11084 * | QName
11085 * [38] NodeType ::= 'comment'
11086 * | 'text'
11087 * | 'processing-instruction'
11088 * | 'node'
11089 *
11090 * Returns the name found and updates @test, @type and @prefix appropriately
11091 */
11092 static xmlChar *
11093 xmlXPathCompNodeTest(xmlXPathParserContextPtr ctxt, xmlXPathTestVal *test,
11094 xmlXPathTypeVal *type, const xmlChar **prefix,
11095 xmlChar *name) {
11096 int blanks;
11097
11098 if ((test == NULL) || (type == NULL) || (prefix == NULL)) {
11099 STRANGE;
11100 return(NULL);
11101 }
11102 *type = (xmlXPathTypeVal) 0;
11103 *test = (xmlXPathTestVal) 0;
11104 *prefix = NULL;
11105 SKIP_BLANKS;
11106
11107 if ((name == NULL) && (CUR == '*')) {
11108 /*
11109 * All elements
11110 */
11111 NEXT;
11112 *test = NODE_TEST_ALL;
11113 return(NULL);
11114 }
11115
11116 if (name == NULL)
11117 name = xmlXPathParseNCName(ctxt);
11118 if (name == NULL) {
11119 XP_ERRORNULL(XPATH_EXPR_ERROR);
11120 }
11121
11122 blanks = IS_BLANK_CH(CUR);
11123 SKIP_BLANKS;
11124 if (CUR == '(') {
11125 NEXT;
11126 /*
11127 * NodeType or PI search
11128 */
11129 if (xmlStrEqual(name, BAD_CAST "comment"))
11130 *type = NODE_TYPE_COMMENT;
11131 else if (xmlStrEqual(name, BAD_CAST "node"))
11132 *type = NODE_TYPE_NODE;
11133 else if (xmlStrEqual(name, BAD_CAST "processing-instruction"))
11134 *type = NODE_TYPE_PI;
11135 else if (xmlStrEqual(name, BAD_CAST "text"))
11136 *type = NODE_TYPE_TEXT;
11137 else {
11138 if (name != NULL)
11139 xmlFree(name);
11140 XP_ERRORNULL(XPATH_EXPR_ERROR);
11141 }
11142
11143 *test = NODE_TEST_TYPE;
11144
11145 SKIP_BLANKS;
11146 if (*type == NODE_TYPE_PI) {
11147 /*
11148 * Specific case: search a PI by name.
11149 */
11150 if (name != NULL)
11151 xmlFree(name);
11152 name = NULL;
11153 if (CUR != ')') {
11154 name = xmlXPathParseLiteral(ctxt);
11155 CHECK_ERROR NULL;
11156 *test = NODE_TEST_PI;
11157 SKIP_BLANKS;
11158 }
11159 }
11160 if (CUR != ')') {
11161 if (name != NULL)
11162 xmlFree(name);
11163 XP_ERRORNULL(XPATH_UNCLOSED_ERROR);
11164 }
11165 NEXT;
11166 return(name);
11167 }
11168 *test = NODE_TEST_NAME;
11169 if ((!blanks) && (CUR == ':')) {
11170 NEXT;
11171
11172 /*
11173 * Since currently the parser context don't have a
11174 * namespace list associated:
11175 * The namespace name for this prefix can be computed
11176 * only at evaluation time. The compilation is done
11177 * outside of any context.
11178 */
11179 #if 0
11180 *prefix = xmlXPathNsLookup(ctxt->context, name);
11181 if (name != NULL)
11182 xmlFree(name);
11183 if (*prefix == NULL) {
11184 XP_ERROR0(XPATH_UNDEF_PREFIX_ERROR);
11185 }
11186 #else
11187 *prefix = name;
11188 #endif
11189
11190 if (CUR == '*') {
11191 /*
11192 * All elements
11193 */
11194 NEXT;
11195 *test = NODE_TEST_ALL;
11196 return(NULL);
11197 }
11198
11199 name = xmlXPathParseNCName(ctxt);
11200 if (name == NULL) {
11201 XP_ERRORNULL(XPATH_EXPR_ERROR);
11202 }
11203 }
11204 return(name);
11205 }
11206
11207 /**
11208 * xmlXPathIsAxisName:
11209 * @name: a preparsed name token
11210 *
11211 * [6] AxisName ::= 'ancestor'
11212 * | 'ancestor-or-self'
11213 * | 'attribute'
11214 * | 'child'
11215 * | 'descendant'
11216 * | 'descendant-or-self'
11217 * | 'following'
11218 * | 'following-sibling'
11219 * | 'namespace'
11220 * | 'parent'
11221 * | 'preceding'
11222 * | 'preceding-sibling'
11223 * | 'self'
11224 *
11225 * Returns the axis or 0
11226 */
11227 static xmlXPathAxisVal
11228 xmlXPathIsAxisName(const xmlChar *name) {
11229 xmlXPathAxisVal ret = (xmlXPathAxisVal) 0;
11230 switch (name[0]) {
11231 case 'a':
11232 if (xmlStrEqual(name, BAD_CAST "ancestor"))
11233 ret = AXIS_ANCESTOR;
11234 if (xmlStrEqual(name, BAD_CAST "ancestor-or-self"))
11235 ret = AXIS_ANCESTOR_OR_SELF;
11236 if (xmlStrEqual(name, BAD_CAST "attribute"))
11237 ret = AXIS_ATTRIBUTE;
11238 break;
11239 case 'c':
11240 if (xmlStrEqual(name, BAD_CAST "child"))
11241 ret = AXIS_CHILD;
11242 break;
11243 case 'd':
11244 if (xmlStrEqual(name, BAD_CAST "descendant"))
11245 ret = AXIS_DESCENDANT;
11246 if (xmlStrEqual(name, BAD_CAST "descendant-or-self"))
11247 ret = AXIS_DESCENDANT_OR_SELF;
11248 break;
11249 case 'f':
11250 if (xmlStrEqual(name, BAD_CAST "following"))
11251 ret = AXIS_FOLLOWING;
11252 if (xmlStrEqual(name, BAD_CAST "following-sibling"))
11253 ret = AXIS_FOLLOWING_SIBLING;
11254 break;
11255 case 'n':
11256 if (xmlStrEqual(name, BAD_CAST "namespace"))
11257 ret = AXIS_NAMESPACE;
11258 break;
11259 case 'p':
11260 if (xmlStrEqual(name, BAD_CAST "parent"))
11261 ret = AXIS_PARENT;
11262 if (xmlStrEqual(name, BAD_CAST "preceding"))
11263 ret = AXIS_PRECEDING;
11264 if (xmlStrEqual(name, BAD_CAST "preceding-sibling"))
11265 ret = AXIS_PRECEDING_SIBLING;
11266 break;
11267 case 's':
11268 if (xmlStrEqual(name, BAD_CAST "self"))
11269 ret = AXIS_SELF;
11270 break;
11271 }
11272 return(ret);
11273 }
11274
11275 /**
11276 * xmlXPathCompStep:
11277 * @ctxt: the XPath Parser context
11278 *
11279 * [4] Step ::= AxisSpecifier NodeTest Predicate*
11280 * | AbbreviatedStep
11281 *
11282 * [12] AbbreviatedStep ::= '.' | '..'
11283 *
11284 * [5] AxisSpecifier ::= AxisName '::'
11285 * | AbbreviatedAxisSpecifier
11286 *
11287 * [13] AbbreviatedAxisSpecifier ::= '@'?
11288 *
11289 * Modified for XPtr range support as:
11290 *
11291 * [4xptr] Step ::= AxisSpecifier NodeTest Predicate*
11292 * | AbbreviatedStep
11293 * | 'range-to' '(' Expr ')' Predicate*
11294 *
11295 * Compile one step in a Location Path
11296 * A location step of . is short for self::node(). This is
11297 * particularly useful in conjunction with //. For example, the
11298 * location path .//para is short for
11299 * self::node()/descendant-or-self::node()/child::para
11300 * and so will select all para descendant elements of the context
11301 * node.
11302 * Similarly, a location step of .. is short for parent::node().
11303 * For example, ../title is short for parent::node()/child::title
11304 * and so will select the title children of the parent of the context
11305 * node.
11306 */
11307 static void
11308 xmlXPathCompStep(xmlXPathParserContextPtr ctxt) {
11309 #ifdef LIBXML_XPTR_ENABLED
11310 int rangeto = 0;
11311 int op2 = -1;
11312 #endif
11313
11314 SKIP_BLANKS;
11315 if ((CUR == '.') && (NXT(1) == '.')) {
11316 SKIP(2);
11317 SKIP_BLANKS;
11318 PUSH_LONG_EXPR(XPATH_OP_COLLECT, AXIS_PARENT,
11319 NODE_TEST_TYPE, NODE_TYPE_NODE, NULL, NULL);
11320 } else if (CUR == '.') {
11321 NEXT;
11322 SKIP_BLANKS;
11323 } else {
11324 xmlChar *name = NULL;
11325 const xmlChar *prefix = NULL;
11326 xmlXPathTestVal test = (xmlXPathTestVal) 0;
11327 xmlXPathAxisVal axis = (xmlXPathAxisVal) 0;
11328 xmlXPathTypeVal type = (xmlXPathTypeVal) 0;
11329 int op1;
11330
11331 /*
11332 * The modification needed for XPointer change to the production
11333 */
11334 #ifdef LIBXML_XPTR_ENABLED
11335 if (ctxt->xptr) {
11336 name = xmlXPathParseNCName(ctxt);
11337 if ((name != NULL) && (xmlStrEqual(name, BAD_CAST "range-to"))) {
11338 op2 = ctxt->comp->last;
11339 xmlFree(name);
11340 SKIP_BLANKS;
11341 if (CUR != '(') {
11342 XP_ERROR(XPATH_EXPR_ERROR);
11343 }
11344 NEXT;
11345 SKIP_BLANKS;
11346
11347 xmlXPathCompileExpr(ctxt, 1);
11348 /* PUSH_BINARY_EXPR(XPATH_OP_RANGETO, op2, ctxt->comp->last, 0, 0); */
11349 CHECK_ERROR;
11350
11351 SKIP_BLANKS;
11352 if (CUR != ')') {
11353 XP_ERROR(XPATH_EXPR_ERROR);
11354 }
11355 NEXT;
11356 rangeto = 1;
11357 goto eval_predicates;
11358 }
11359 }
11360 #endif
11361 if (CUR == '*') {
11362 axis = AXIS_CHILD;
11363 } else {
11364 if (name == NULL)
11365 name = xmlXPathParseNCName(ctxt);
11366 if (name != NULL) {
11367 axis = xmlXPathIsAxisName(name);
11368 if (axis != 0) {
11369 SKIP_BLANKS;
11370 if ((CUR == ':') && (NXT(1) == ':')) {
11371 SKIP(2);
11372 xmlFree(name);
11373 name = NULL;
11374 } else {
11375 /* an element name can conflict with an axis one :-\ */
11376 axis = AXIS_CHILD;
11377 }
11378 } else {
11379 axis = AXIS_CHILD;
11380 }
11381 } else if (CUR == '@') {
11382 NEXT;
11383 axis = AXIS_ATTRIBUTE;
11384 } else {
11385 axis = AXIS_CHILD;
11386 }
11387 }
11388
11389 if (ctxt->error != XPATH_EXPRESSION_OK) {
11390 xmlFree(name);
11391 return;
11392 }
11393
11394 name = xmlXPathCompNodeTest(ctxt, &test, &type, &prefix, name);
11395 if (test == 0)
11396 return;
11397
11398 if ((prefix != NULL) && (ctxt->context != NULL) &&
11399 (ctxt->context->flags & XML_XPATH_CHECKNS)) {
11400 if (xmlXPathNsLookup(ctxt->context, prefix) == NULL) {
11401 xmlXPathErr(ctxt, XPATH_UNDEF_PREFIX_ERROR);
11402 }
11403 }
11404 #ifdef DEBUG_STEP
11405 xmlGenericError(xmlGenericErrorContext,
11406 "Basis : computing new set\n");
11407 #endif
11408
11409 #ifdef DEBUG_STEP
11410 xmlGenericError(xmlGenericErrorContext, "Basis : ");
11411 if (ctxt->value == NULL)
11412 xmlGenericError(xmlGenericErrorContext, "no value\n");
11413 else if (ctxt->value->nodesetval == NULL)
11414 xmlGenericError(xmlGenericErrorContext, "Empty\n");
11415 else
11416 xmlGenericErrorContextNodeSet(stdout, ctxt->value->nodesetval);
11417 #endif
11418
11419 #ifdef LIBXML_XPTR_ENABLED
11420 eval_predicates:
11421 #endif
11422 op1 = ctxt->comp->last;
11423 ctxt->comp->last = -1;
11424
11425 SKIP_BLANKS;
11426 while (CUR == '[') {
11427 xmlXPathCompPredicate(ctxt, 0);
11428 }
11429
11430 #ifdef LIBXML_XPTR_ENABLED
11431 if (rangeto) {
11432 PUSH_BINARY_EXPR(XPATH_OP_RANGETO, op2, op1, 0, 0);
11433 } else
11434 #endif
11435 PUSH_FULL_EXPR(XPATH_OP_COLLECT, op1, ctxt->comp->last, axis,
11436 test, type, (void *)prefix, (void *)name);
11437
11438 }
11439 #ifdef DEBUG_STEP
11440 xmlGenericError(xmlGenericErrorContext, "Step : ");
11441 if (ctxt->value == NULL)
11442 xmlGenericError(xmlGenericErrorContext, "no value\n");
11443 else if (ctxt->value->nodesetval == NULL)
11444 xmlGenericError(xmlGenericErrorContext, "Empty\n");
11445 else
11446 xmlGenericErrorContextNodeSet(xmlGenericErrorContext,
11447 ctxt->value->nodesetval);
11448 #endif
11449 }
11450
11451 /**
11452 * xmlXPathCompRelativeLocationPath:
11453 * @ctxt: the XPath Parser context
11454 *
11455 * [3] RelativeLocationPath ::= Step
11456 * | RelativeLocationPath '/' Step
11457 * | AbbreviatedRelativeLocationPath
11458 * [11] AbbreviatedRelativeLocationPath ::= RelativeLocationPath '//' Step
11459 *
11460 * Compile a relative location path.
11461 */
11462 static void
11463 xmlXPathCompRelativeLocationPath
11464 (xmlXPathParserContextPtr ctxt) {
11465 SKIP_BLANKS;
11466 if ((CUR == '/') && (NXT(1) == '/')) {
11467 SKIP(2);
11468 SKIP_BLANKS;
11469 PUSH_LONG_EXPR(XPATH_OP_COLLECT, AXIS_DESCENDANT_OR_SELF,
11470 NODE_TEST_TYPE, NODE_TYPE_NODE, NULL, NULL);
11471 } else if (CUR == '/') {
11472 NEXT;
11473 SKIP_BLANKS;
11474 }
11475 xmlXPathCompStep(ctxt);
11476 CHECK_ERROR;
11477 SKIP_BLANKS;
11478 while (CUR == '/') {
11479 if ((CUR == '/') && (NXT(1) == '/')) {
11480 SKIP(2);
11481 SKIP_BLANKS;
11482 PUSH_LONG_EXPR(XPATH_OP_COLLECT, AXIS_DESCENDANT_OR_SELF,
11483 NODE_TEST_TYPE, NODE_TYPE_NODE, NULL, NULL);
11484 xmlXPathCompStep(ctxt);
11485 } else if (CUR == '/') {
11486 NEXT;
11487 SKIP_BLANKS;
11488 xmlXPathCompStep(ctxt);
11489 }
11490 SKIP_BLANKS;
11491 }
11492 }
11493
11494 /**
11495 * xmlXPathCompLocationPath:
11496 * @ctxt: the XPath Parser context
11497 *
11498 * [1] LocationPath ::= RelativeLocationPath
11499 * | AbsoluteLocationPath
11500 * [2] AbsoluteLocationPath ::= '/' RelativeLocationPath?
11501 * | AbbreviatedAbsoluteLocationPath
11502 * [10] AbbreviatedAbsoluteLocationPath ::=
11503 * '//' RelativeLocationPath
11504 *
11505 * Compile a location path
11506 *
11507 * // is short for /descendant-or-self::node()/. For example,
11508 * //para is short for /descendant-or-self::node()/child::para and
11509 * so will select any para element in the document (even a para element
11510 * that is a document element will be selected by //para since the
11511 * document element node is a child of the root node); div//para is
11512 * short for div/descendant-or-self::node()/child::para and so will
11513 * select all para descendants of div children.
11514 */
11515 static void
11516 xmlXPathCompLocationPath(xmlXPathParserContextPtr ctxt) {
11517 SKIP_BLANKS;
11518 if (CUR != '/') {
11519 xmlXPathCompRelativeLocationPath(ctxt);
11520 } else {
11521 while (CUR == '/') {
11522 if ((CUR == '/') && (NXT(1) == '/')) {
11523 SKIP(2);
11524 SKIP_BLANKS;
11525 PUSH_LONG_EXPR(XPATH_OP_COLLECT, AXIS_DESCENDANT_OR_SELF,
11526 NODE_TEST_TYPE, NODE_TYPE_NODE, NULL, NULL);
11527 xmlXPathCompRelativeLocationPath(ctxt);
11528 } else if (CUR == '/') {
11529 NEXT;
11530 SKIP_BLANKS;
11531 if ((CUR != 0 ) &&
11532 ((IS_ASCII_LETTER(CUR)) || (CUR == '_') || (CUR == '.') ||
11533 (CUR == '@') || (CUR == '*')))
11534 xmlXPathCompRelativeLocationPath(ctxt);
11535 }
11536 CHECK_ERROR;
11537 }
11538 }
11539 }
11540
11541 /************************************************************************
11542 * *
11543 * XPath precompiled expression evaluation *
11544 * *
11545 ************************************************************************/
11546
11547 static int
11548 xmlXPathCompOpEval(xmlXPathParserContextPtr ctxt, xmlXPathStepOpPtr op);
11549
11550 #ifdef DEBUG_STEP
11551 static void
11552 xmlXPathDebugDumpStepAxis(xmlXPathStepOpPtr op,
11553 int nbNodes)
11554 {
11555 xmlGenericError(xmlGenericErrorContext, "new step : ");
11556 switch (op->value) {
11557 case AXIS_ANCESTOR:
11558 xmlGenericError(xmlGenericErrorContext, "axis 'ancestors' ");
11559 break;
11560 case AXIS_ANCESTOR_OR_SELF:
11561 xmlGenericError(xmlGenericErrorContext,
11562 "axis 'ancestors-or-self' ");
11563 break;
11564 case AXIS_ATTRIBUTE:
11565 xmlGenericError(xmlGenericErrorContext, "axis 'attributes' ");
11566 break;
11567 case AXIS_CHILD:
11568 xmlGenericError(xmlGenericErrorContext, "axis 'child' ");
11569 break;
11570 case AXIS_DESCENDANT:
11571 xmlGenericError(xmlGenericErrorContext, "axis 'descendant' ");
11572 break;
11573 case AXIS_DESCENDANT_OR_SELF:
11574 xmlGenericError(xmlGenericErrorContext,
11575 "axis 'descendant-or-self' ");
11576 break;
11577 case AXIS_FOLLOWING:
11578 xmlGenericError(xmlGenericErrorContext, "axis 'following' ");
11579 break;
11580 case AXIS_FOLLOWING_SIBLING:
11581 xmlGenericError(xmlGenericErrorContext,
11582 "axis 'following-siblings' ");
11583 break;
11584 case AXIS_NAMESPACE:
11585 xmlGenericError(xmlGenericErrorContext, "axis 'namespace' ");
11586 break;
11587 case AXIS_PARENT:
11588 xmlGenericError(xmlGenericErrorContext, "axis 'parent' ");
11589 break;
11590 case AXIS_PRECEDING:
11591 xmlGenericError(xmlGenericErrorContext, "axis 'preceding' ");
11592 break;
11593 case AXIS_PRECEDING_SIBLING:
11594 xmlGenericError(xmlGenericErrorContext,
11595 "axis 'preceding-sibling' ");
11596 break;
11597 case AXIS_SELF:
11598 xmlGenericError(xmlGenericErrorContext, "axis 'self' ");
11599 break;
11600 }
11601 xmlGenericError(xmlGenericErrorContext,
11602 " context contains %d nodes\n", nbNodes);
11603 switch (op->value2) {
11604 case NODE_TEST_NONE:
11605 xmlGenericError(xmlGenericErrorContext,
11606 " searching for none !!!\n");
11607 break;
11608 case NODE_TEST_TYPE:
11609 xmlGenericError(xmlGenericErrorContext,
11610 " searching for type %d\n", op->value3);
11611 break;
11612 case NODE_TEST_PI:
11613 xmlGenericError(xmlGenericErrorContext,
11614 " searching for PI !!!\n");
11615 break;
11616 case NODE_TEST_ALL:
11617 xmlGenericError(xmlGenericErrorContext,
11618 " searching for *\n");
11619 break;
11620 case NODE_TEST_NS:
11621 xmlGenericError(xmlGenericErrorContext,
11622 " searching for namespace %s\n",
11623 op->value5);
11624 break;
11625 case NODE_TEST_NAME:
11626 xmlGenericError(xmlGenericErrorContext,
11627 " searching for name %s\n", op->value5);
11628 if (op->value4)
11629 xmlGenericError(xmlGenericErrorContext,
11630 " with namespace %s\n", op->value4);
11631 break;
11632 }
11633 xmlGenericError(xmlGenericErrorContext, "Testing : ");
11634 }
11635 #endif /* DEBUG_STEP */
11636
11637 static int
11638 xmlXPathCompOpEvalPredicate(xmlXPathParserContextPtr ctxt,
11639 xmlXPathStepOpPtr op,
11640 xmlNodeSetPtr set,
11641 int contextSize,
11642 int hasNsNodes)
11643 {
11644 if (op->ch1 != -1) {
11645 xmlXPathCompExprPtr comp = ctxt->comp;
11646 /*
11647 * Process inner predicates first.
11648 */
11649 if (comp->steps[op->ch1].op != XPATH_OP_PREDICATE) {
11650 /*
11651 * TODO: raise an internal error.
11652 */
11653 }
11654 contextSize = xmlXPathCompOpEvalPredicate(ctxt,
11655 &comp->steps[op->ch1], set, contextSize, hasNsNodes);
11656 CHECK_ERROR0;
11657 if (contextSize <= 0)
11658 return(0);
11659 }
11660 if (op->ch2 != -1) {
11661 xmlXPathContextPtr xpctxt = ctxt->context;
11662 xmlNodePtr contextNode, oldContextNode;
11663 xmlDocPtr oldContextDoc;
11664 int oldcs, oldpp;
11665 int i, res, contextPos = 0, newContextSize;
11666 xmlXPathStepOpPtr exprOp;
11667 xmlXPathObjectPtr contextObj = NULL, exprRes = NULL;
11668
11669 #ifdef LIBXML_XPTR_ENABLED
11670 /*
11671 * URGENT TODO: Check the following:
11672 * We don't expect location sets if evaluating prediates, right?
11673 * Only filters should expect location sets, right?
11674 */
11675 #endif
11676 /*
11677 * SPEC XPath 1.0:
11678 * "For each node in the node-set to be filtered, the
11679 * PredicateExpr is evaluated with that node as the
11680 * context node, with the number of nodes in the
11681 * node-set as the context size, and with the proximity
11682 * position of the node in the node-set with respect to
11683 * the axis as the context position;"
11684 * @oldset is the node-set" to be filtered.
11685 *
11686 * SPEC XPath 1.0:
11687 * "only predicates change the context position and
11688 * context size (see [2.4 Predicates])."
11689 * Example:
11690 * node-set context pos
11691 * nA 1
11692 * nB 2
11693 * nC 3
11694 * After applying predicate [position() > 1] :
11695 * node-set context pos
11696 * nB 1
11697 * nC 2
11698 */
11699 oldContextNode = xpctxt->node;
11700 oldContextDoc = xpctxt->doc;
11701 oldcs = xpctxt->contextSize;
11702 oldpp = xpctxt->proximityPosition;
11703 /*
11704 * Get the expression of this predicate.
11705 */
11706 exprOp = &ctxt->comp->steps[op->ch2];
11707 newContextSize = 0;
11708 for (i = 0; i < set->nodeNr; i++) {
11709 if (set->nodeTab[i] == NULL)
11710 continue;
11711
11712 contextNode = set->nodeTab[i];
11713 xpctxt->node = contextNode;
11714 xpctxt->contextSize = contextSize;
11715 xpctxt->proximityPosition = ++contextPos;
11716
11717 /*
11718 * Also set the xpath document in case things like
11719 * key() are evaluated in the predicate.
11720 */
11721 if ((contextNode->type != XML_NAMESPACE_DECL) &&
11722 (contextNode->doc != NULL))
11723 xpctxt->doc = contextNode->doc;
11724 /*
11725 * Evaluate the predicate expression with 1 context node
11726 * at a time; this node is packaged into a node set; this
11727 * node set is handed over to the evaluation mechanism.
11728 */
11729 if (contextObj == NULL)
11730 contextObj = xmlXPathCacheNewNodeSet(xpctxt, contextNode);
11731 else {
11732 if (xmlXPathNodeSetAddUnique(contextObj->nodesetval,
11733 contextNode) < 0) {
11734 ctxt->error = XPATH_MEMORY_ERROR;
11735 goto evaluation_exit;
11736 }
11737 }
11738
11739 valuePush(ctxt, contextObj);
11740
11741 res = xmlXPathCompOpEvalToBoolean(ctxt, exprOp, 1);
11742
11743 if ((ctxt->error != XPATH_EXPRESSION_OK) || (res == -1)) {
11744 xmlXPathNodeSetClear(set, hasNsNodes);
11745 newContextSize = 0;
11746 goto evaluation_exit;
11747 }
11748
11749 if (res != 0) {
11750 newContextSize++;
11751 } else {
11752 /*
11753 * Remove the entry from the initial node set.
11754 */
11755 set->nodeTab[i] = NULL;
11756 if (contextNode->type == XML_NAMESPACE_DECL)
11757 xmlXPathNodeSetFreeNs((xmlNsPtr) contextNode);
11758 }
11759 if (ctxt->value == contextObj) {
11760 /*
11761 * Don't free the temporary XPath object holding the
11762 * context node, in order to avoid massive recreation
11763 * inside this loop.
11764 */
11765 valuePop(ctxt);
11766 xmlXPathNodeSetClear(contextObj->nodesetval, hasNsNodes);
11767 } else {
11768 /*
11769 * TODO: The object was lost in the evaluation machinery.
11770 * Can this happen? Maybe in internal-error cases.
11771 */
11772 contextObj = NULL;
11773 }
11774 }
11775
11776 if (contextObj != NULL) {
11777 if (ctxt->value == contextObj)
11778 valuePop(ctxt);
11779 xmlXPathReleaseObject(xpctxt, contextObj);
11780 }
11781 evaluation_exit:
11782 if (exprRes != NULL)
11783 xmlXPathReleaseObject(ctxt->context, exprRes);
11784 /*
11785 * Reset/invalidate the context.
11786 */
11787 xpctxt->node = oldContextNode;
11788 xpctxt->doc = oldContextDoc;
11789 xpctxt->contextSize = oldcs;
11790 xpctxt->proximityPosition = oldpp;
11791 return(newContextSize);
11792 }
11793 return(contextSize);
11794 }
11795
11796 static int
11797 xmlXPathCompOpEvalPositionalPredicate(xmlXPathParserContextPtr ctxt,
11798 xmlXPathStepOpPtr op,
11799 xmlNodeSetPtr set,
11800 int contextSize,
11801 int minPos,
11802 int maxPos,
11803 int hasNsNodes)
11804 {
11805 if (op->ch1 != -1) {
11806 xmlXPathCompExprPtr comp = ctxt->comp;
11807 if (comp->steps[op->ch1].op != XPATH_OP_PREDICATE) {
11808 /*
11809 * TODO: raise an internal error.
11810 */
11811 }
11812 contextSize = xmlXPathCompOpEvalPredicate(ctxt,
11813 &comp->steps[op->ch1], set, contextSize, hasNsNodes);
11814 CHECK_ERROR0;
11815 if (contextSize <= 0)
11816 return(0);
11817 }
11818 /*
11819 * Check if the node set contains a sufficient number of nodes for
11820 * the requested range.
11821 */
11822 if (contextSize < minPos) {
11823 xmlXPathNodeSetClear(set, hasNsNodes);
11824 return(0);
11825 }
11826 if (op->ch2 == -1) {
11827 /*
11828 * TODO: Can this ever happen?
11829 */
11830 return (contextSize);
11831 } else {
11832 xmlDocPtr oldContextDoc;
11833 int oldcs, oldpp;
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 oldcs = xpctxt->contextSize;
11855 oldpp = xpctxt->proximityPosition;
11856 /*
11857 * Get the expression of this predicate.
11858 */
11859 exprOp = &ctxt->comp->steps[op->ch2];
11860 for (i = 0; i < set->nodeNr; i++) {
11861 xmlXPathObjectPtr tmp;
11862
11863 if (set->nodeTab[i] == NULL)
11864 continue;
11865
11866 contextNode = set->nodeTab[i];
11867 xpctxt->node = contextNode;
11868 xpctxt->contextSize = contextSize;
11869 xpctxt->proximityPosition = ++contextPos;
11870
11871 /*
11872 * Initialize the new set.
11873 * Also set the xpath document in case things like
11874 * key() evaluation are attempted on the predicate
11875 */
11876 if ((contextNode->type != XML_NAMESPACE_DECL) &&
11877 (contextNode->doc != NULL))
11878 xpctxt->doc = contextNode->doc;
11879 /*
11880 * Evaluate the predicate expression with 1 context node
11881 * at a time; this node is packaged into a node set; this
11882 * node set is handed over to the evaluation mechanism.
11883 */
11884 if (contextObj == NULL)
11885 contextObj = xmlXPathCacheNewNodeSet(xpctxt, contextNode);
11886 else {
11887 if (xmlXPathNodeSetAddUnique(contextObj->nodesetval,
11888 contextNode) < 0) {
11889 ctxt->error = XPATH_MEMORY_ERROR;
11890 goto evaluation_exit;
11891 }
11892 }
11893
11894 valuePush(ctxt, contextObj);
11895 frame = xmlXPathSetFrame(ctxt);
11896 res = xmlXPathCompOpEvalToBoolean(ctxt, exprOp, 1);
11897 xmlXPathPopFrame(ctxt, frame);
11898 tmp = valuePop(ctxt);
11899
11900 if ((ctxt->error != XPATH_EXPRESSION_OK) || (res == -1)) {
11901 while (tmp != contextObj) {
11902 /*
11903 * Free up the result
11904 * then pop off contextObj, which will be freed later
11905 */
11906 xmlXPathReleaseObject(xpctxt, tmp);
11907 tmp = valuePop(ctxt);
11908 }
11909 goto evaluation_error;
11910 }
11911 /* push the result back onto the stack */
11912 valuePush(ctxt, tmp);
11913
11914 if (res)
11915 pos++;
11916
11917 if (res && (pos >= minPos) && (pos <= maxPos)) {
11918 /*
11919 * Fits in the requested range.
11920 */
11921 newContextSize++;
11922 if (minPos == maxPos) {
11923 /*
11924 * Only 1 node was requested.
11925 */
11926 if (contextNode->type == XML_NAMESPACE_DECL) {
11927 /*
11928 * As always: take care of those nasty
11929 * namespace nodes.
11930 */
11931 set->nodeTab[i] = NULL;
11932 }
11933 xmlXPathNodeSetClear(set, hasNsNodes);
11934 set->nodeNr = 1;
11935 set->nodeTab[0] = contextNode;
11936 goto evaluation_exit;
11937 }
11938 if (pos == maxPos) {
11939 /*
11940 * We are done.
11941 */
11942 xmlXPathNodeSetClearFromPos(set, i +1, hasNsNodes);
11943 goto evaluation_exit;
11944 }
11945 } else {
11946 /*
11947 * Remove the entry from the initial node set.
11948 */
11949 set->nodeTab[i] = NULL;
11950 if (contextNode->type == XML_NAMESPACE_DECL)
11951 xmlXPathNodeSetFreeNs((xmlNsPtr) contextNode);
11952 }
11953 if (exprRes != NULL) {
11954 xmlXPathReleaseObject(ctxt->context, exprRes);
11955 exprRes = NULL;
11956 }
11957 if (ctxt->value == contextObj) {
11958 /*
11959 * Don't free the temporary XPath object holding the
11960 * context node, in order to avoid massive recreation
11961 * inside this loop.
11962 */
11963 valuePop(ctxt);
11964 xmlXPathNodeSetClear(contextObj->nodesetval, hasNsNodes);
11965 } else {
11966 /*
11967 * The object was lost in the evaluation machinery.
11968 * Can this happen? Maybe in case of internal-errors.
11969 */
11970 contextObj = NULL;
11971 }
11972 }
11973 goto evaluation_exit;
11974
11975 evaluation_error:
11976 xmlXPathNodeSetClear(set, hasNsNodes);
11977 newContextSize = 0;
11978
11979 evaluation_exit:
11980 if (contextObj != NULL) {
11981 if (ctxt->value == contextObj)
11982 valuePop(ctxt);
11983 xmlXPathReleaseObject(xpctxt, contextObj);
11984 }
11985 if (exprRes != NULL)
11986 xmlXPathReleaseObject(ctxt->context, exprRes);
11987 /*
11988 * Reset/invalidate the context.
11989 */
11990 xpctxt->node = oldContextNode;
11991 xpctxt->doc = oldContextDoc;
11992 xpctxt->contextSize = oldcs;
11993 xpctxt->proximityPosition = oldpp;
11994 return(newContextSize);
11995 }
11996 return(contextSize);
11997 }
11998
11999 static int
12000 xmlXPathIsPositionalPredicate(xmlXPathParserContextPtr ctxt,
12001 xmlXPathStepOpPtr op,
12002 int *maxPos)
12003 {
12004
12005 xmlXPathStepOpPtr exprOp;
12006
12007 /*
12008 * BIG NOTE: This is not intended for XPATH_OP_FILTER yet!
12009 */
12010
12011 /*
12012 * If not -1, then ch1 will point to:
12013 * 1) For predicates (XPATH_OP_PREDICATE):
12014 * - an inner predicate operator
12015 * 2) For filters (XPATH_OP_FILTER):
12016 * - an inner filter operater OR
12017 * - an expression selecting the node set.
12018 * E.g. "key('a', 'b')" or "(//foo | //bar)".
12019 */
12020 if ((op->op != XPATH_OP_PREDICATE) && (op->op != XPATH_OP_FILTER))
12021 return(0);
12022
12023 if (op->ch2 != -1) {
12024 exprOp = &ctxt->comp->steps[op->ch2];
12025 } else
12026 return(0);
12027
12028 if ((exprOp != NULL) &&
12029 (exprOp->op == XPATH_OP_VALUE) &&
12030 (exprOp->value4 != NULL) &&
12031 (((xmlXPathObjectPtr) exprOp->value4)->type == XPATH_NUMBER))
12032 {
12033 double floatval = ((xmlXPathObjectPtr) exprOp->value4)->floatval;
12034
12035 /*
12036 * We have a "[n]" predicate here.
12037 * TODO: Unfortunately this simplistic test here is not
12038 * able to detect a position() predicate in compound
12039 * expressions like "[@attr = 'a" and position() = 1],
12040 * and even not the usage of position() in
12041 * "[position() = 1]"; thus - obviously - a position-range,
12042 * like it "[position() < 5]", is also not detected.
12043 * Maybe we could rewrite the AST to ease the optimization.
12044 */
12045
12046 if ((floatval > INT_MIN) && (floatval < INT_MAX)) {
12047 *maxPos = (int) floatval;
12048 if (floatval == (double) *maxPos)
12049 return(1);
12050 }
12051 }
12052 return(0);
12053 }
12054
12055 static int
12056 xmlXPathNodeCollectAndTest(xmlXPathParserContextPtr ctxt,
12057 xmlXPathStepOpPtr op,
12058 xmlNodePtr * first, xmlNodePtr * last,
12059 int toBool)
12060 {
12061
12062 #define XP_TEST_HIT \
12063 if (hasAxisRange != 0) { \
12064 if (++pos == maxPos) { \
12065 if (addNode(seq, cur) < 0) \
12066 ctxt->error = XPATH_MEMORY_ERROR; \
12067 goto axis_range_end; } \
12068 } else { \
12069 if (addNode(seq, cur) < 0) \
12070 ctxt->error = XPATH_MEMORY_ERROR; \
12071 if (breakOnFirstHit) goto first_hit; }
12072
12073 #define XP_TEST_HIT_NS \
12074 if (hasAxisRange != 0) { \
12075 if (++pos == maxPos) { \
12076 hasNsNodes = 1; \
12077 if (xmlXPathNodeSetAddNs(seq, xpctxt->node, (xmlNsPtr) cur) < 0) \
12078 ctxt->error = XPATH_MEMORY_ERROR; \
12079 goto axis_range_end; } \
12080 } else { \
12081 hasNsNodes = 1; \
12082 if (xmlXPathNodeSetAddNs(seq, xpctxt->node, (xmlNsPtr) cur) < 0) \
12083 ctxt->error = XPATH_MEMORY_ERROR; \
12084 if (breakOnFirstHit) goto first_hit; }
12085
12086 xmlXPathAxisVal axis = (xmlXPathAxisVal) op->value;
12087 xmlXPathTestVal test = (xmlXPathTestVal) op->value2;
12088 xmlXPathTypeVal type = (xmlXPathTypeVal) op->value3;
12089 const xmlChar *prefix = op->value4;
12090 const xmlChar *name = op->value5;
12091 const xmlChar *URI = NULL;
12092
12093 #ifdef DEBUG_STEP
12094 int nbMatches = 0, prevMatches = 0;
12095 #endif
12096 int total = 0, hasNsNodes = 0;
12097 /* The popped object holding the context nodes */
12098 xmlXPathObjectPtr obj;
12099 /* The set of context nodes for the node tests */
12100 xmlNodeSetPtr contextSeq;
12101 int contextIdx;
12102 xmlNodePtr contextNode;
12103 /* The final resulting node set wrt to all context nodes */
12104 xmlNodeSetPtr outSeq;
12105 /*
12106 * The temporary resulting node set wrt 1 context node.
12107 * Used to feed predicate evaluation.
12108 */
12109 xmlNodeSetPtr seq;
12110 xmlNodePtr cur;
12111 /* First predicate operator */
12112 xmlXPathStepOpPtr predOp;
12113 int maxPos; /* The requested position() (when a "[n]" predicate) */
12114 int hasPredicateRange, hasAxisRange, pos, size, newSize;
12115 int breakOnFirstHit;
12116
12117 xmlXPathTraversalFunction next = NULL;
12118 int (*addNode) (xmlNodeSetPtr, xmlNodePtr);
12119 xmlXPathNodeSetMergeFunction mergeAndClear;
12120 xmlNodePtr oldContextNode;
12121 xmlXPathContextPtr xpctxt = ctxt->context;
12122
12123
12124 CHECK_TYPE0(XPATH_NODESET);
12125 obj = valuePop(ctxt);
12126 /*
12127 * Setup namespaces.
12128 */
12129 if (prefix != NULL) {
12130 URI = xmlXPathNsLookup(xpctxt, prefix);
12131 if (URI == NULL) {
12132 xmlXPathReleaseObject(xpctxt, obj);
12133 XP_ERROR0(XPATH_UNDEF_PREFIX_ERROR);
12134 }
12135 }
12136 /*
12137 * Setup axis.
12138 *
12139 * MAYBE FUTURE TODO: merging optimizations:
12140 * - If the nodes to be traversed wrt to the initial nodes and
12141 * the current axis cannot overlap, then we could avoid searching
12142 * for duplicates during the merge.
12143 * But the question is how/when to evaluate if they cannot overlap.
12144 * Example: if we know that for two initial nodes, the one is
12145 * not in the ancestor-or-self axis of the other, then we could safely
12146 * avoid a duplicate-aware merge, if the axis to be traversed is e.g.
12147 * the descendant-or-self axis.
12148 */
12149 mergeAndClear = xmlXPathNodeSetMergeAndClear;
12150 switch (axis) {
12151 case AXIS_ANCESTOR:
12152 first = NULL;
12153 next = xmlXPathNextAncestor;
12154 break;
12155 case AXIS_ANCESTOR_OR_SELF:
12156 first = NULL;
12157 next = xmlXPathNextAncestorOrSelf;
12158 break;
12159 case AXIS_ATTRIBUTE:
12160 first = NULL;
12161 last = NULL;
12162 next = xmlXPathNextAttribute;
12163 mergeAndClear = xmlXPathNodeSetMergeAndClearNoDupls;
12164 break;
12165 case AXIS_CHILD:
12166 last = NULL;
12167 if (((test == NODE_TEST_NAME) || (test == NODE_TEST_ALL)) &&
12168 (type == NODE_TYPE_NODE))
12169 {
12170 /*
12171 * Optimization if an element node type is 'element'.
12172 */
12173 next = xmlXPathNextChildElement;
12174 } else
12175 next = xmlXPathNextChild;
12176 mergeAndClear = xmlXPathNodeSetMergeAndClearNoDupls;
12177 break;
12178 case AXIS_DESCENDANT:
12179 last = NULL;
12180 next = xmlXPathNextDescendant;
12181 break;
12182 case AXIS_DESCENDANT_OR_SELF:
12183 last = NULL;
12184 next = xmlXPathNextDescendantOrSelf;
12185 break;
12186 case AXIS_FOLLOWING:
12187 last = NULL;
12188 next = xmlXPathNextFollowing;
12189 break;
12190 case AXIS_FOLLOWING_SIBLING:
12191 last = NULL;
12192 next = xmlXPathNextFollowingSibling;
12193 break;
12194 case AXIS_NAMESPACE:
12195 first = NULL;
12196 last = NULL;
12197 next = (xmlXPathTraversalFunction) xmlXPathNextNamespace;
12198 mergeAndClear = xmlXPathNodeSetMergeAndClearNoDupls;
12199 break;
12200 case AXIS_PARENT:
12201 first = NULL;
12202 next = xmlXPathNextParent;
12203 break;
12204 case AXIS_PRECEDING:
12205 first = NULL;
12206 next = xmlXPathNextPrecedingInternal;
12207 break;
12208 case AXIS_PRECEDING_SIBLING:
12209 first = NULL;
12210 next = xmlXPathNextPrecedingSibling;
12211 break;
12212 case AXIS_SELF:
12213 first = NULL;
12214 last = NULL;
12215 next = xmlXPathNextSelf;
12216 mergeAndClear = xmlXPathNodeSetMergeAndClearNoDupls;
12217 break;
12218 }
12219
12220 #ifdef DEBUG_STEP
12221 xmlXPathDebugDumpStepAxis(op,
12222 (obj->nodesetval != NULL) ? obj->nodesetval->nodeNr : 0);
12223 #endif
12224
12225 if (next == NULL) {
12226 xmlXPathReleaseObject(xpctxt, obj);
12227 return(0);
12228 }
12229 contextSeq = obj->nodesetval;
12230 if ((contextSeq == NULL) || (contextSeq->nodeNr <= 0)) {
12231 xmlXPathReleaseObject(xpctxt, obj);
12232 valuePush(ctxt, xmlXPathCacheWrapNodeSet(xpctxt, NULL));
12233 return(0);
12234 }
12235 /*
12236 * Predicate optimization ---------------------------------------------
12237 * If this step has a last predicate, which contains a position(),
12238 * then we'll optimize (although not exactly "position()", but only
12239 * the short-hand form, i.e., "[n]".
12240 *
12241 * Example - expression "/foo[parent::bar][1]":
12242 *
12243 * COLLECT 'child' 'name' 'node' foo -- op (we are here)
12244 * ROOT -- op->ch1
12245 * PREDICATE -- op->ch2 (predOp)
12246 * PREDICATE -- predOp->ch1 = [parent::bar]
12247 * SORT
12248 * COLLECT 'parent' 'name' 'node' bar
12249 * NODE
12250 * ELEM Object is a number : 1 -- predOp->ch2 = [1]
12251 *
12252 */
12253 maxPos = 0;
12254 predOp = NULL;
12255 hasPredicateRange = 0;
12256 hasAxisRange = 0;
12257 if (op->ch2 != -1) {
12258 /*
12259 * There's at least one predicate. 16 == XPATH_OP_PREDICATE
12260 */
12261 predOp = &ctxt->comp->steps[op->ch2];
12262 if (xmlXPathIsPositionalPredicate(ctxt, predOp, &maxPos)) {
12263 if (predOp->ch1 != -1) {
12264 /*
12265 * Use the next inner predicate operator.
12266 */
12267 predOp = &ctxt->comp->steps[predOp->ch1];
12268 hasPredicateRange = 1;
12269 } else {
12270 /*
12271 * There's no other predicate than the [n] predicate.
12272 */
12273 predOp = NULL;
12274 hasAxisRange = 1;
12275 }
12276 }
12277 }
12278 breakOnFirstHit = ((toBool) && (predOp == NULL)) ? 1 : 0;
12279 /*
12280 * Axis traversal -----------------------------------------------------
12281 */
12282 /*
12283 * 2.3 Node Tests
12284 * - For the attribute axis, the principal node type is attribute.
12285 * - For the namespace axis, the principal node type is namespace.
12286 * - For other axes, the principal node type is element.
12287 *
12288 * A node test * is true for any node of the
12289 * principal node type. For example, child::* will
12290 * select all element children of the context node
12291 */
12292 oldContextNode = xpctxt->node;
12293 addNode = xmlXPathNodeSetAddUnique;
12294 outSeq = NULL;
12295 seq = NULL;
12296 contextNode = NULL;
12297 contextIdx = 0;
12298
12299
12300 while (((contextIdx < contextSeq->nodeNr) || (contextNode != NULL)) &&
12301 (ctxt->error == XPATH_EXPRESSION_OK)) {
12302 xpctxt->node = contextSeq->nodeTab[contextIdx++];
12303
12304 if (seq == NULL) {
12305 seq = xmlXPathNodeSetCreate(NULL);
12306 if (seq == NULL) {
12307 total = 0;
12308 goto error;
12309 }
12310 }
12311 /*
12312 * Traverse the axis and test the nodes.
12313 */
12314 pos = 0;
12315 cur = NULL;
12316 hasNsNodes = 0;
12317 do {
12318 cur = next(ctxt, cur);
12319 if (cur == NULL)
12320 break;
12321
12322 /*
12323 * QUESTION TODO: What does the "first" and "last" stuff do?
12324 */
12325 if ((first != NULL) && (*first != NULL)) {
12326 if (*first == cur)
12327 break;
12328 if (((total % 256) == 0) &&
12329 #ifdef XP_OPTIMIZED_NON_ELEM_COMPARISON
12330 (xmlXPathCmpNodesExt(*first, cur) >= 0))
12331 #else
12332 (xmlXPathCmpNodes(*first, cur) >= 0))
12333 #endif
12334 {
12335 break;
12336 }
12337 }
12338 if ((last != NULL) && (*last != NULL)) {
12339 if (*last == cur)
12340 break;
12341 if (((total % 256) == 0) &&
12342 #ifdef XP_OPTIMIZED_NON_ELEM_COMPARISON
12343 (xmlXPathCmpNodesExt(cur, *last) >= 0))
12344 #else
12345 (xmlXPathCmpNodes(cur, *last) >= 0))
12346 #endif
12347 {
12348 break;
12349 }
12350 }
12351
12352 total++;
12353
12354 #ifdef DEBUG_STEP
12355 xmlGenericError(xmlGenericErrorContext, " %s", cur->name);
12356 #endif
12357
12358 switch (test) {
12359 case NODE_TEST_NONE:
12360 total = 0;
12361 STRANGE
12362 goto error;
12363 case NODE_TEST_TYPE:
12364 if (type == NODE_TYPE_NODE) {
12365 switch (cur->type) {
12366 case XML_DOCUMENT_NODE:
12367 case XML_HTML_DOCUMENT_NODE:
12368 #ifdef LIBXML_DOCB_ENABLED
12369 case XML_DOCB_DOCUMENT_NODE:
12370 #endif
12371 case XML_ELEMENT_NODE:
12372 case XML_ATTRIBUTE_NODE:
12373 case XML_PI_NODE:
12374 case XML_COMMENT_NODE:
12375 case XML_CDATA_SECTION_NODE:
12376 case XML_TEXT_NODE:
12377 XP_TEST_HIT
12378 break;
12379 case XML_NAMESPACE_DECL: {
12380 if (axis == AXIS_NAMESPACE) {
12381 XP_TEST_HIT_NS
12382 } else {
12383 hasNsNodes = 1;
12384 XP_TEST_HIT
12385 }
12386 break;
12387 }
12388 default:
12389 break;
12390 }
12391 } else if (cur->type == (xmlElementType) type) {
12392 if (cur->type == XML_NAMESPACE_DECL)
12393 XP_TEST_HIT_NS
12394 else
12395 XP_TEST_HIT
12396 } else if ((type == NODE_TYPE_TEXT) &&
12397 (cur->type == XML_CDATA_SECTION_NODE))
12398 {
12399 XP_TEST_HIT
12400 }
12401 break;
12402 case NODE_TEST_PI:
12403 if ((cur->type == XML_PI_NODE) &&
12404 ((name == NULL) || xmlStrEqual(name, cur->name)))
12405 {
12406 XP_TEST_HIT
12407 }
12408 break;
12409 case NODE_TEST_ALL:
12410 if (axis == AXIS_ATTRIBUTE) {
12411 if (cur->type == XML_ATTRIBUTE_NODE)
12412 {
12413 if (prefix == NULL)
12414 {
12415 XP_TEST_HIT
12416 } else if ((cur->ns != NULL) &&
12417 (xmlStrEqual(URI, cur->ns->href)))
12418 {
12419 XP_TEST_HIT
12420 }
12421 }
12422 } else if (axis == AXIS_NAMESPACE) {
12423 if (cur->type == XML_NAMESPACE_DECL)
12424 {
12425 XP_TEST_HIT_NS
12426 }
12427 } else {
12428 if (cur->type == XML_ELEMENT_NODE) {
12429 if (prefix == NULL)
12430 {
12431 XP_TEST_HIT
12432
12433 } else if ((cur->ns != NULL) &&
12434 (xmlStrEqual(URI, cur->ns->href)))
12435 {
12436 XP_TEST_HIT
12437 }
12438 }
12439 }
12440 break;
12441 case NODE_TEST_NS:{
12442 TODO;
12443 break;
12444 }
12445 case NODE_TEST_NAME:
12446 if (axis == AXIS_ATTRIBUTE) {
12447 if (cur->type != XML_ATTRIBUTE_NODE)
12448 break;
12449 } else if (axis == AXIS_NAMESPACE) {
12450 if (cur->type != XML_NAMESPACE_DECL)
12451 break;
12452 } else {
12453 if (cur->type != XML_ELEMENT_NODE)
12454 break;
12455 }
12456 switch (cur->type) {
12457 case XML_ELEMENT_NODE:
12458 if (xmlStrEqual(name, cur->name)) {
12459 if (prefix == NULL) {
12460 if (cur->ns == NULL)
12461 {
12462 XP_TEST_HIT
12463 }
12464 } else {
12465 if ((cur->ns != NULL) &&
12466 (xmlStrEqual(URI, cur->ns->href)))
12467 {
12468 XP_TEST_HIT
12469 }
12470 }
12471 }
12472 break;
12473 case XML_ATTRIBUTE_NODE:{
12474 xmlAttrPtr attr = (xmlAttrPtr) cur;
12475
12476 if (xmlStrEqual(name, attr->name)) {
12477 if (prefix == NULL) {
12478 if ((attr->ns == NULL) ||
12479 (attr->ns->prefix == NULL))
12480 {
12481 XP_TEST_HIT
12482 }
12483 } else {
12484 if ((attr->ns != NULL) &&
12485 (xmlStrEqual(URI,
12486 attr->ns->href)))
12487 {
12488 XP_TEST_HIT
12489 }
12490 }
12491 }
12492 break;
12493 }
12494 case XML_NAMESPACE_DECL:
12495 if (cur->type == XML_NAMESPACE_DECL) {
12496 xmlNsPtr ns = (xmlNsPtr) cur;
12497
12498 if ((ns->prefix != NULL) && (name != NULL)
12499 && (xmlStrEqual(ns->prefix, name)))
12500 {
12501 XP_TEST_HIT_NS
12502 }
12503 }
12504 break;
12505 default:
12506 break;
12507 }
12508 break;
12509 } /* switch(test) */
12510 } while ((cur != NULL) && (ctxt->error == XPATH_EXPRESSION_OK));
12511
12512 goto apply_predicates;
12513
12514 axis_range_end: /* ----------------------------------------------------- */
12515 /*
12516 * We have a "/foo[n]", and position() = n was reached.
12517 * Note that we can have as well "/foo/::parent::foo[1]", so
12518 * a duplicate-aware merge is still needed.
12519 * Merge with the result.
12520 */
12521 if (outSeq == NULL) {
12522 outSeq = seq;
12523 seq = NULL;
12524 } else
12525 outSeq = mergeAndClear(outSeq, seq, 0);
12526 /*
12527 * Break if only a true/false result was requested.
12528 */
12529 if (toBool)
12530 break;
12531 continue;
12532
12533 first_hit: /* ---------------------------------------------------------- */
12534 /*
12535 * Break if only a true/false result was requested and
12536 * no predicates existed and a node test succeeded.
12537 */
12538 if (outSeq == NULL) {
12539 outSeq = seq;
12540 seq = NULL;
12541 } else
12542 outSeq = mergeAndClear(outSeq, seq, 0);
12543 break;
12544
12545 #ifdef DEBUG_STEP
12546 if (seq != NULL)
12547 nbMatches += seq->nodeNr;
12548 #endif
12549
12550 apply_predicates: /* --------------------------------------------------- */
12551 if (ctxt->error != XPATH_EXPRESSION_OK)
12552 goto error;
12553
12554 /*
12555 * Apply predicates.
12556 */
12557 if ((predOp != NULL) && (seq->nodeNr > 0)) {
12558 /*
12559 * E.g. when we have a "/foo[some expression][n]".
12560 */
12561 /*
12562 * QUESTION TODO: The old predicate evaluation took into
12563 * account location-sets.
12564 * (E.g. ctxt->value->type == XPATH_LOCATIONSET)
12565 * Do we expect such a set here?
12566 * All what I learned now from the evaluation semantics
12567 * does not indicate that a location-set will be processed
12568 * here, so this looks OK.
12569 */
12570 /*
12571 * Iterate over all predicates, starting with the outermost
12572 * predicate.
12573 * TODO: Problem: we cannot execute the inner predicates first
12574 * since we cannot go back *up* the operator tree!
12575 * Options we have:
12576 * 1) Use of recursive functions (like is it currently done
12577 * via xmlXPathCompOpEval())
12578 * 2) Add a predicate evaluation information stack to the
12579 * context struct
12580 * 3) Change the way the operators are linked; we need a
12581 * "parent" field on xmlXPathStepOp
12582 *
12583 * For the moment, I'll try to solve this with a recursive
12584 * function: xmlXPathCompOpEvalPredicate().
12585 */
12586 size = seq->nodeNr;
12587 if (hasPredicateRange != 0)
12588 newSize = xmlXPathCompOpEvalPositionalPredicate(ctxt,
12589 predOp, seq, size, maxPos, maxPos, hasNsNodes);
12590 else
12591 newSize = xmlXPathCompOpEvalPredicate(ctxt,
12592 predOp, seq, size, hasNsNodes);
12593
12594 if (ctxt->error != XPATH_EXPRESSION_OK) {
12595 total = 0;
12596 goto error;
12597 }
12598 /*
12599 * Add the filtered set of nodes to the result node set.
12600 */
12601 if (newSize == 0) {
12602 /*
12603 * The predicates filtered all nodes out.
12604 */
12605 xmlXPathNodeSetClear(seq, hasNsNodes);
12606 } else if (seq->nodeNr > 0) {
12607 /*
12608 * Add to result set.
12609 */
12610 if (outSeq == NULL) {
12611 if (size != newSize) {
12612 /*
12613 * We need to merge and clear here, since
12614 * the sequence will contained NULLed entries.
12615 */
12616 outSeq = mergeAndClear(NULL, seq, 1);
12617 } else {
12618 outSeq = seq;
12619 seq = NULL;
12620 }
12621 } else
12622 outSeq = mergeAndClear(outSeq, seq,
12623 (size != newSize) ? 1: 0);
12624 /*
12625 * Break if only a true/false result was requested.
12626 */
12627 if (toBool)
12628 break;
12629 }
12630 } else if (seq->nodeNr > 0) {
12631 /*
12632 * Add to result set.
12633 */
12634 if (outSeq == NULL) {
12635 outSeq = seq;
12636 seq = NULL;
12637 } else {
12638 outSeq = mergeAndClear(outSeq, seq, 0);
12639 }
12640 }
12641 }
12642
12643 error:
12644 if ((obj->boolval) && (obj->user != NULL)) {
12645 /*
12646 * QUESTION TODO: What does this do and why?
12647 * TODO: Do we have to do this also for the "error"
12648 * cleanup further down?
12649 */
12650 ctxt->value->boolval = 1;
12651 ctxt->value->user = obj->user;
12652 obj->user = NULL;
12653 obj->boolval = 0;
12654 }
12655 xmlXPathReleaseObject(xpctxt, obj);
12656
12657 /*
12658 * Ensure we return at least an emtpy set.
12659 */
12660 if (outSeq == NULL) {
12661 if ((seq != NULL) && (seq->nodeNr == 0))
12662 outSeq = seq;
12663 else
12664 outSeq = xmlXPathNodeSetCreate(NULL);
12665 /* XXX what if xmlXPathNodeSetCreate returned NULL here? */
12666 }
12667 if ((seq != NULL) && (seq != outSeq)) {
12668 xmlXPathFreeNodeSet(seq);
12669 }
12670 /*
12671 * Hand over the result. Better to push the set also in
12672 * case of errors.
12673 */
12674 valuePush(ctxt, xmlXPathCacheWrapNodeSet(xpctxt, outSeq));
12675 /*
12676 * Reset the context node.
12677 */
12678 xpctxt->node = oldContextNode;
12679 /*
12680 * When traversing the namespace axis in "toBool" mode, it's
12681 * possible that tmpNsList wasn't freed.
12682 */
12683 if (xpctxt->tmpNsList != NULL) {
12684 xmlFree(xpctxt->tmpNsList);
12685 xpctxt->tmpNsList = NULL;
12686 }
12687
12688 #ifdef DEBUG_STEP
12689 xmlGenericError(xmlGenericErrorContext,
12690 "\nExamined %d nodes, found %d nodes at that step\n",
12691 total, nbMatches);
12692 #endif
12693
12694 return(total);
12695 }
12696
12697 static int
12698 xmlXPathCompOpEvalFilterFirst(xmlXPathParserContextPtr ctxt,
12699 xmlXPathStepOpPtr op, xmlNodePtr * first);
12700
12701 /**
12702 * xmlXPathCompOpEvalFirst:
12703 * @ctxt: the XPath parser context with the compiled expression
12704 * @op: an XPath compiled operation
12705 * @first: the first elem found so far
12706 *
12707 * Evaluate the Precompiled XPath operation searching only the first
12708 * element in document order
12709 *
12710 * Returns the number of examined objects.
12711 */
12712 static int
12713 xmlXPathCompOpEvalFirst(xmlXPathParserContextPtr ctxt,
12714 xmlXPathStepOpPtr op, xmlNodePtr * first)
12715 {
12716 int total = 0, cur;
12717 xmlXPathCompExprPtr comp;
12718 xmlXPathObjectPtr arg1, arg2;
12719
12720 CHECK_ERROR0;
12721 comp = ctxt->comp;
12722 switch (op->op) {
12723 case XPATH_OP_END:
12724 return (0);
12725 case XPATH_OP_UNION:
12726 total =
12727 xmlXPathCompOpEvalFirst(ctxt, &comp->steps[op->ch1],
12728 first);
12729 CHECK_ERROR0;
12730 if ((ctxt->value != NULL)
12731 && (ctxt->value->type == XPATH_NODESET)
12732 && (ctxt->value->nodesetval != NULL)
12733 && (ctxt->value->nodesetval->nodeNr >= 1)) {
12734 /*
12735 * limit tree traversing to first node in the result
12736 */
12737 /*
12738 * OPTIMIZE TODO: This implicitely sorts
12739 * the result, even if not needed. E.g. if the argument
12740 * of the count() function, no sorting is needed.
12741 * OPTIMIZE TODO: How do we know if the node-list wasn't
12742 * aready sorted?
12743 */
12744 if (ctxt->value->nodesetval->nodeNr > 1)
12745 xmlXPathNodeSetSort(ctxt->value->nodesetval);
12746 *first = ctxt->value->nodesetval->nodeTab[0];
12747 }
12748 cur =
12749 xmlXPathCompOpEvalFirst(ctxt, &comp->steps[op->ch2],
12750 first);
12751 CHECK_ERROR0;
12752
12753 arg2 = valuePop(ctxt);
12754 arg1 = valuePop(ctxt);
12755 if ((arg1 == NULL) || (arg1->type != XPATH_NODESET) ||
12756 (arg2 == NULL) || (arg2->type != XPATH_NODESET)) {
12757 xmlXPathReleaseObject(ctxt->context, arg1);
12758 xmlXPathReleaseObject(ctxt->context, arg2);
12759 XP_ERROR0(XPATH_INVALID_TYPE);
12760 }
12761
12762 arg1->nodesetval = xmlXPathNodeSetMerge(arg1->nodesetval,
12763 arg2->nodesetval);
12764 valuePush(ctxt, arg1);
12765 xmlXPathReleaseObject(ctxt->context, arg2);
12766 /* optimizer */
12767 if (total > cur)
12768 xmlXPathCompSwap(op);
12769 return (total + cur);
12770 case XPATH_OP_ROOT:
12771 xmlXPathRoot(ctxt);
12772 return (0);
12773 case XPATH_OP_NODE:
12774 if (op->ch1 != -1)
12775 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
12776 CHECK_ERROR0;
12777 if (op->ch2 != -1)
12778 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
12779 CHECK_ERROR0;
12780 valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context,
12781 ctxt->context->node));
12782 return (total);
12783 case XPATH_OP_COLLECT:{
12784 if (op->ch1 == -1)
12785 return (total);
12786
12787 total = xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
12788 CHECK_ERROR0;
12789
12790 total += xmlXPathNodeCollectAndTest(ctxt, op, first, NULL, 0);
12791 return (total);
12792 }
12793 case XPATH_OP_VALUE:
12794 valuePush(ctxt,
12795 xmlXPathCacheObjectCopy(ctxt->context,
12796 (xmlXPathObjectPtr) op->value4));
12797 return (0);
12798 case XPATH_OP_SORT:
12799 if (op->ch1 != -1)
12800 total +=
12801 xmlXPathCompOpEvalFirst(ctxt, &comp->steps[op->ch1],
12802 first);
12803 CHECK_ERROR0;
12804 if ((ctxt->value != NULL)
12805 && (ctxt->value->type == XPATH_NODESET)
12806 && (ctxt->value->nodesetval != NULL)
12807 && (ctxt->value->nodesetval->nodeNr > 1))
12808 xmlXPathNodeSetSort(ctxt->value->nodesetval);
12809 return (total);
12810 #ifdef XP_OPTIMIZED_FILTER_FIRST
12811 case XPATH_OP_FILTER:
12812 total += xmlXPathCompOpEvalFilterFirst(ctxt, op, first);
12813 return (total);
12814 #endif
12815 default:
12816 return (xmlXPathCompOpEval(ctxt, op));
12817 }
12818 }
12819
12820 /**
12821 * xmlXPathCompOpEvalLast:
12822 * @ctxt: the XPath parser context with the compiled expression
12823 * @op: an XPath compiled operation
12824 * @last: the last elem found so far
12825 *
12826 * Evaluate the Precompiled XPath operation searching only the last
12827 * element in document order
12828 *
12829 * Returns the number of nodes traversed
12830 */
12831 static int
12832 xmlXPathCompOpEvalLast(xmlXPathParserContextPtr ctxt, xmlXPathStepOpPtr op,
12833 xmlNodePtr * last)
12834 {
12835 int total = 0, cur;
12836 xmlXPathCompExprPtr comp;
12837 xmlXPathObjectPtr arg1, arg2;
12838
12839 CHECK_ERROR0;
12840 comp = ctxt->comp;
12841 switch (op->op) {
12842 case XPATH_OP_END:
12843 return (0);
12844 case XPATH_OP_UNION:
12845 total =
12846 xmlXPathCompOpEvalLast(ctxt, &comp->steps[op->ch1], last);
12847 CHECK_ERROR0;
12848 if ((ctxt->value != NULL)
12849 && (ctxt->value->type == XPATH_NODESET)
12850 && (ctxt->value->nodesetval != NULL)
12851 && (ctxt->value->nodesetval->nodeNr >= 1)) {
12852 /*
12853 * limit tree traversing to first node in the result
12854 */
12855 if (ctxt->value->nodesetval->nodeNr > 1)
12856 xmlXPathNodeSetSort(ctxt->value->nodesetval);
12857 *last =
12858 ctxt->value->nodesetval->nodeTab[ctxt->value->
12859 nodesetval->nodeNr -
12860 1];
12861 }
12862 cur =
12863 xmlXPathCompOpEvalLast(ctxt, &comp->steps[op->ch2], last);
12864 CHECK_ERROR0;
12865 if ((ctxt->value != NULL)
12866 && (ctxt->value->type == XPATH_NODESET)
12867 && (ctxt->value->nodesetval != NULL)
12868 && (ctxt->value->nodesetval->nodeNr >= 1)) { /* TODO: NOP ? */
12869 }
12870
12871 arg2 = valuePop(ctxt);
12872 arg1 = valuePop(ctxt);
12873 if ((arg1 == NULL) || (arg1->type != XPATH_NODESET) ||
12874 (arg2 == NULL) || (arg2->type != XPATH_NODESET)) {
12875 xmlXPathReleaseObject(ctxt->context, arg1);
12876 xmlXPathReleaseObject(ctxt->context, arg2);
12877 XP_ERROR0(XPATH_INVALID_TYPE);
12878 }
12879
12880 arg1->nodesetval = xmlXPathNodeSetMerge(arg1->nodesetval,
12881 arg2->nodesetval);
12882 valuePush(ctxt, arg1);
12883 xmlXPathReleaseObject(ctxt->context, arg2);
12884 /* optimizer */
12885 if (total > cur)
12886 xmlXPathCompSwap(op);
12887 return (total + cur);
12888 case XPATH_OP_ROOT:
12889 xmlXPathRoot(ctxt);
12890 return (0);
12891 case XPATH_OP_NODE:
12892 if (op->ch1 != -1)
12893 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
12894 CHECK_ERROR0;
12895 if (op->ch2 != -1)
12896 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
12897 CHECK_ERROR0;
12898 valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context,
12899 ctxt->context->node));
12900 return (total);
12901 case XPATH_OP_COLLECT:{
12902 if (op->ch1 == -1)
12903 return (0);
12904
12905 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
12906 CHECK_ERROR0;
12907
12908 total += xmlXPathNodeCollectAndTest(ctxt, op, NULL, last, 0);
12909 return (total);
12910 }
12911 case XPATH_OP_VALUE:
12912 valuePush(ctxt,
12913 xmlXPathCacheObjectCopy(ctxt->context,
12914 (xmlXPathObjectPtr) op->value4));
12915 return (0);
12916 case XPATH_OP_SORT:
12917 if (op->ch1 != -1)
12918 total +=
12919 xmlXPathCompOpEvalLast(ctxt, &comp->steps[op->ch1],
12920 last);
12921 CHECK_ERROR0;
12922 if ((ctxt->value != NULL)
12923 && (ctxt->value->type == XPATH_NODESET)
12924 && (ctxt->value->nodesetval != NULL)
12925 && (ctxt->value->nodesetval->nodeNr > 1))
12926 xmlXPathNodeSetSort(ctxt->value->nodesetval);
12927 return (total);
12928 default:
12929 return (xmlXPathCompOpEval(ctxt, op));
12930 }
12931 }
12932
12933 #ifdef XP_OPTIMIZED_FILTER_FIRST
12934 static int
12935 xmlXPathCompOpEvalFilterFirst(xmlXPathParserContextPtr ctxt,
12936 xmlXPathStepOpPtr op, xmlNodePtr * first)
12937 {
12938 int total = 0;
12939 xmlXPathCompExprPtr comp;
12940 xmlXPathObjectPtr res;
12941 xmlXPathObjectPtr obj;
12942 xmlNodeSetPtr oldset;
12943 xmlNodePtr oldnode;
12944 xmlDocPtr oldDoc;
12945 int oldcs, oldpp;
12946 int i;
12947
12948 CHECK_ERROR0;
12949 comp = ctxt->comp;
12950 /*
12951 * Optimization for ()[last()] selection i.e. the last elem
12952 */
12953 if ((op->ch1 != -1) && (op->ch2 != -1) &&
12954 (comp->steps[op->ch1].op == XPATH_OP_SORT) &&
12955 (comp->steps[op->ch2].op == XPATH_OP_SORT)) {
12956 int f = comp->steps[op->ch2].ch1;
12957
12958 if ((f != -1) &&
12959 (comp->steps[f].op == XPATH_OP_FUNCTION) &&
12960 (comp->steps[f].value5 == NULL) &&
12961 (comp->steps[f].value == 0) &&
12962 (comp->steps[f].value4 != NULL) &&
12963 (xmlStrEqual
12964 (comp->steps[f].value4, BAD_CAST "last"))) {
12965 xmlNodePtr last = NULL;
12966
12967 total +=
12968 xmlXPathCompOpEvalLast(ctxt,
12969 &comp->steps[op->ch1],
12970 &last);
12971 CHECK_ERROR0;
12972 /*
12973 * The nodeset should be in document order,
12974 * Keep only the last value
12975 */
12976 if ((ctxt->value != NULL) &&
12977 (ctxt->value->type == XPATH_NODESET) &&
12978 (ctxt->value->nodesetval != NULL) &&
12979 (ctxt->value->nodesetval->nodeTab != NULL) &&
12980 (ctxt->value->nodesetval->nodeNr > 1)) {
12981 xmlXPathNodeSetKeepLast(ctxt->value->nodesetval);
12982 *first = *(ctxt->value->nodesetval->nodeTab);
12983 }
12984 return (total);
12985 }
12986 }
12987
12988 if (op->ch1 != -1)
12989 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
12990 CHECK_ERROR0;
12991 if (op->ch2 == -1)
12992 return (total);
12993 if (ctxt->value == NULL)
12994 return (total);
12995
12996 #ifdef LIBXML_XPTR_ENABLED
12997 /*
12998 * Hum are we filtering the result of an XPointer expression
12999 */
13000 if (ctxt->value->type == XPATH_LOCATIONSET) {
13001 xmlXPathObjectPtr tmp = NULL;
13002 xmlLocationSetPtr newlocset = NULL;
13003 xmlLocationSetPtr oldlocset;
13004
13005 /*
13006 * Extract the old locset, and then evaluate the result of the
13007 * expression for all the element in the locset. use it to grow
13008 * up a new locset.
13009 */
13010 CHECK_TYPE0(XPATH_LOCATIONSET);
13011
13012 if ((ctxt->value->user == NULL) ||
13013 (((xmlLocationSetPtr) ctxt->value->user)->locNr == 0))
13014 return (total);
13015
13016 obj = valuePop(ctxt);
13017 oldlocset = obj->user;
13018 oldnode = ctxt->context->node;
13019 oldcs = ctxt->context->contextSize;
13020 oldpp = ctxt->context->proximityPosition;
13021
13022 newlocset = xmlXPtrLocationSetCreate(NULL);
13023
13024 for (i = 0; i < oldlocset->locNr; i++) {
13025 /*
13026 * Run the evaluation with a node list made of a
13027 * single item in the nodelocset.
13028 */
13029 ctxt->context->node = oldlocset->locTab[i]->user;
13030 ctxt->context->contextSize = oldlocset->locNr;
13031 ctxt->context->proximityPosition = i + 1;
13032 if (tmp == NULL) {
13033 tmp = xmlXPathCacheNewNodeSet(ctxt->context,
13034 ctxt->context->node);
13035 } else {
13036 if (xmlXPathNodeSetAddUnique(tmp->nodesetval,
13037 ctxt->context->node) < 0) {
13038 ctxt->error = XPATH_MEMORY_ERROR;
13039 }
13040 }
13041 valuePush(ctxt, tmp);
13042 if (op->ch2 != -1)
13043 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13044 if (ctxt->error != XPATH_EXPRESSION_OK) {
13045 xmlXPtrFreeLocationSet(newlocset);
13046 goto xptr_error;
13047 }
13048 /*
13049 * The result of the evaluation need to be tested to
13050 * decided whether the filter succeeded or not
13051 */
13052 res = valuePop(ctxt);
13053 if (xmlXPathEvaluatePredicateResult(ctxt, res)) {
13054 xmlXPtrLocationSetAdd(newlocset,
13055 xmlXPathCacheObjectCopy(ctxt->context,
13056 oldlocset->locTab[i]));
13057 }
13058 /*
13059 * Cleanup
13060 */
13061 if (res != NULL) {
13062 xmlXPathReleaseObject(ctxt->context, res);
13063 }
13064 if (ctxt->value == tmp) {
13065 valuePop(ctxt);
13066 xmlXPathNodeSetClear(tmp->nodesetval, 1);
13067 /*
13068 * REVISIT TODO: Don't create a temporary nodeset
13069 * for everly iteration.
13070 */
13071 /* OLD: xmlXPathFreeObject(res); */
13072 } else
13073 tmp = NULL;
13074 /*
13075 * Only put the first node in the result, then leave.
13076 */
13077 if (newlocset->locNr > 0) {
13078 *first = (xmlNodePtr) oldlocset->locTab[i]->user;
13079 break;
13080 }
13081 }
13082 if (tmp != NULL) {
13083 xmlXPathReleaseObject(ctxt->context, tmp);
13084 }
13085 /*
13086 * The result is used as the new evaluation locset.
13087 */
13088 valuePush(ctxt, xmlXPtrWrapLocationSet(newlocset));
13089 xptr_error:
13090 xmlXPathReleaseObject(ctxt->context, obj);
13091 ctxt->context->node = oldnode;
13092 ctxt->context->contextSize = oldcs;
13093 ctxt->context->proximityPosition = oldpp;
13094 return (total);
13095 }
13096 #endif /* LIBXML_XPTR_ENABLED */
13097
13098 /*
13099 * Extract the old set, and then evaluate the result of the
13100 * expression for all the element in the set. use it to grow
13101 * up a new set.
13102 */
13103 CHECK_TYPE0(XPATH_NODESET);
13104
13105 if ((ctxt->value->nodesetval != NULL) &&
13106 (ctxt->value->nodesetval->nodeNr != 0)) {
13107 xmlNodeSetPtr newset;
13108 xmlXPathObjectPtr tmp = NULL;
13109
13110 obj = valuePop(ctxt);
13111 oldset = obj->nodesetval;
13112 oldnode = ctxt->context->node;
13113 oldDoc = ctxt->context->doc;
13114 oldcs = ctxt->context->contextSize;
13115 oldpp = ctxt->context->proximityPosition;
13116
13117 /*
13118 * Initialize the new set.
13119 * Also set the xpath document in case things like
13120 * key() evaluation are attempted on the predicate
13121 */
13122 newset = xmlXPathNodeSetCreate(NULL);
13123 /* XXX what if xmlXPathNodeSetCreate returned NULL? */
13124
13125 for (i = 0; i < oldset->nodeNr; i++) {
13126 /*
13127 * Run the evaluation with a node list made of
13128 * a single item in the nodeset.
13129 */
13130 ctxt->context->node = oldset->nodeTab[i];
13131 if ((oldset->nodeTab[i]->type != XML_NAMESPACE_DECL) &&
13132 (oldset->nodeTab[i]->doc != NULL))
13133 ctxt->context->doc = oldset->nodeTab[i]->doc;
13134 if (tmp == NULL) {
13135 tmp = xmlXPathCacheNewNodeSet(ctxt->context,
13136 ctxt->context->node);
13137 } else {
13138 if (xmlXPathNodeSetAddUnique(tmp->nodesetval,
13139 ctxt->context->node) < 0) {
13140 ctxt->error = XPATH_MEMORY_ERROR;
13141 }
13142 }
13143 valuePush(ctxt, tmp);
13144 ctxt->context->contextSize = oldset->nodeNr;
13145 ctxt->context->proximityPosition = i + 1;
13146 if (op->ch2 != -1)
13147 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13148 if (ctxt->error != XPATH_EXPRESSION_OK) {
13149 xmlXPathFreeNodeSet(newset);
13150 goto error;
13151 }
13152 /*
13153 * The result of the evaluation needs to be tested to
13154 * decide whether the filter succeeded or not
13155 */
13156 res = valuePop(ctxt);
13157 if (xmlXPathEvaluatePredicateResult(ctxt, res)) {
13158 if (xmlXPathNodeSetAdd(newset, oldset->nodeTab[i]) < 0)
13159 ctxt->error = XPATH_MEMORY_ERROR;
13160 }
13161 /*
13162 * Cleanup
13163 */
13164 if (res != NULL) {
13165 xmlXPathReleaseObject(ctxt->context, res);
13166 }
13167 if (ctxt->value == tmp) {
13168 valuePop(ctxt);
13169 /*
13170 * Don't free the temporary nodeset
13171 * in order to avoid massive recreation inside this
13172 * loop.
13173 */
13174 xmlXPathNodeSetClear(tmp->nodesetval, 1);
13175 } else
13176 tmp = NULL;
13177 /*
13178 * Only put the first node in the result, then leave.
13179 */
13180 if (newset->nodeNr > 0) {
13181 *first = *(newset->nodeTab);
13182 break;
13183 }
13184 }
13185 if (tmp != NULL) {
13186 xmlXPathReleaseObject(ctxt->context, tmp);
13187 }
13188 /*
13189 * The result is used as the new evaluation set.
13190 */
13191 valuePush(ctxt, xmlXPathCacheWrapNodeSet(ctxt->context, newset));
13192 error:
13193 xmlXPathReleaseObject(ctxt->context, obj);
13194 ctxt->context->node = oldnode;
13195 ctxt->context->doc = oldDoc;
13196 ctxt->context->contextSize = oldcs;
13197 ctxt->context->proximityPosition = oldpp;
13198 }
13199 return(total);
13200 }
13201 #endif /* XP_OPTIMIZED_FILTER_FIRST */
13202
13203 /**
13204 * xmlXPathCompOpEval:
13205 * @ctxt: the XPath parser context with the compiled expression
13206 * @op: an XPath compiled operation
13207 *
13208 * Evaluate the Precompiled XPath operation
13209 * Returns the number of nodes traversed
13210 */
13211 static int
13212 xmlXPathCompOpEval(xmlXPathParserContextPtr ctxt, xmlXPathStepOpPtr op)
13213 {
13214 int total = 0;
13215 int equal, ret;
13216 xmlXPathCompExprPtr comp;
13217 xmlXPathObjectPtr arg1, arg2;
13218
13219 CHECK_ERROR0;
13220 comp = ctxt->comp;
13221 switch (op->op) {
13222 case XPATH_OP_END:
13223 return (0);
13224 case XPATH_OP_AND:
13225 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13226 CHECK_ERROR0;
13227 xmlXPathBooleanFunction(ctxt, 1);
13228 if ((ctxt->value == NULL) || (ctxt->value->boolval == 0))
13229 return (total);
13230 arg2 = valuePop(ctxt);
13231 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13232 if (ctxt->error) {
13233 xmlXPathFreeObject(arg2);
13234 return(0);
13235 }
13236 xmlXPathBooleanFunction(ctxt, 1);
13237 if (ctxt->value != NULL)
13238 ctxt->value->boolval &= arg2->boolval;
13239 xmlXPathReleaseObject(ctxt->context, arg2);
13240 return (total);
13241 case XPATH_OP_OR:
13242 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13243 CHECK_ERROR0;
13244 xmlXPathBooleanFunction(ctxt, 1);
13245 if ((ctxt->value == NULL) || (ctxt->value->boolval == 1))
13246 return (total);
13247 arg2 = valuePop(ctxt);
13248 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13249 if (ctxt->error) {
13250 xmlXPathFreeObject(arg2);
13251 return(0);
13252 }
13253 xmlXPathBooleanFunction(ctxt, 1);
13254 if (ctxt->value != NULL)
13255 ctxt->value->boolval |= arg2->boolval;
13256 xmlXPathReleaseObject(ctxt->context, arg2);
13257 return (total);
13258 case XPATH_OP_EQUAL:
13259 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13260 CHECK_ERROR0;
13261 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13262 CHECK_ERROR0;
13263 if (op->value)
13264 equal = xmlXPathEqualValues(ctxt);
13265 else
13266 equal = xmlXPathNotEqualValues(ctxt);
13267 valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, equal));
13268 return (total);
13269 case XPATH_OP_CMP:
13270 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13271 CHECK_ERROR0;
13272 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13273 CHECK_ERROR0;
13274 ret = xmlXPathCompareValues(ctxt, op->value, op->value2);
13275 valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, ret));
13276 return (total);
13277 case XPATH_OP_PLUS:
13278 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13279 CHECK_ERROR0;
13280 if (op->ch2 != -1) {
13281 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13282 }
13283 CHECK_ERROR0;
13284 if (op->value == 0)
13285 xmlXPathSubValues(ctxt);
13286 else if (op->value == 1)
13287 xmlXPathAddValues(ctxt);
13288 else if (op->value == 2)
13289 xmlXPathValueFlipSign(ctxt);
13290 else if (op->value == 3) {
13291 CAST_TO_NUMBER;
13292 CHECK_TYPE0(XPATH_NUMBER);
13293 }
13294 return (total);
13295 case XPATH_OP_MULT:
13296 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13297 CHECK_ERROR0;
13298 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13299 CHECK_ERROR0;
13300 if (op->value == 0)
13301 xmlXPathMultValues(ctxt);
13302 else if (op->value == 1)
13303 xmlXPathDivValues(ctxt);
13304 else if (op->value == 2)
13305 xmlXPathModValues(ctxt);
13306 return (total);
13307 case XPATH_OP_UNION:
13308 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13309 CHECK_ERROR0;
13310 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13311 CHECK_ERROR0;
13312
13313 arg2 = valuePop(ctxt);
13314 arg1 = valuePop(ctxt);
13315 if ((arg1 == NULL) || (arg1->type != XPATH_NODESET) ||
13316 (arg2 == NULL) || (arg2->type != XPATH_NODESET)) {
13317 xmlXPathReleaseObject(ctxt->context, arg1);
13318 xmlXPathReleaseObject(ctxt->context, arg2);
13319 XP_ERROR0(XPATH_INVALID_TYPE);
13320 }
13321
13322 if ((arg1->nodesetval == NULL) ||
13323 ((arg2->nodesetval != NULL) &&
13324 (arg2->nodesetval->nodeNr != 0)))
13325 {
13326 arg1->nodesetval = xmlXPathNodeSetMerge(arg1->nodesetval,
13327 arg2->nodesetval);
13328 }
13329
13330 valuePush(ctxt, arg1);
13331 xmlXPathReleaseObject(ctxt->context, arg2);
13332 return (total);
13333 case XPATH_OP_ROOT:
13334 xmlXPathRoot(ctxt);
13335 return (total);
13336 case XPATH_OP_NODE:
13337 if (op->ch1 != -1)
13338 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13339 CHECK_ERROR0;
13340 if (op->ch2 != -1)
13341 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13342 CHECK_ERROR0;
13343 valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context,
13344 ctxt->context->node));
13345 return (total);
13346 case XPATH_OP_COLLECT:{
13347 if (op->ch1 == -1)
13348 return (total);
13349
13350 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13351 CHECK_ERROR0;
13352
13353 total += xmlXPathNodeCollectAndTest(ctxt, op, NULL, NULL, 0);
13354 return (total);
13355 }
13356 case XPATH_OP_VALUE:
13357 valuePush(ctxt,
13358 xmlXPathCacheObjectCopy(ctxt->context,
13359 (xmlXPathObjectPtr) op->value4));
13360 return (total);
13361 case XPATH_OP_VARIABLE:{
13362 xmlXPathObjectPtr val;
13363
13364 if (op->ch1 != -1)
13365 total +=
13366 xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13367 if (op->value5 == NULL) {
13368 val = xmlXPathVariableLookup(ctxt->context, op->value4);
13369 if (val == NULL)
13370 XP_ERROR0(XPATH_UNDEF_VARIABLE_ERROR);
13371 valuePush(ctxt, val);
13372 } else {
13373 const xmlChar *URI;
13374
13375 URI = xmlXPathNsLookup(ctxt->context, op->value5);
13376 if (URI == NULL) {
13377 xmlGenericError(xmlGenericErrorContext,
13378 "xmlXPathCompOpEval: variable %s bound to undefined prefix %s\n",
13379 (char *) op->value4, (char *)op->value5);
13380 ctxt->error = XPATH_UNDEF_PREFIX_ERROR;
13381 return (total);
13382 }
13383 val = xmlXPathVariableLookupNS(ctxt->context,
13384 op->value4, URI);
13385 if (val == NULL)
13386 XP_ERROR0(XPATH_UNDEF_VARIABLE_ERROR);
13387 valuePush(ctxt, val);
13388 }
13389 return (total);
13390 }
13391 case XPATH_OP_FUNCTION:{
13392 xmlXPathFunction func;
13393 const xmlChar *oldFunc, *oldFuncURI;
13394 int i;
13395 int frame;
13396
13397 frame = xmlXPathSetFrame(ctxt);
13398 if (op->ch1 != -1) {
13399 total +=
13400 xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13401 if (ctxt->error != XPATH_EXPRESSION_OK) {
13402 xmlXPathPopFrame(ctxt, frame);
13403 return (total);
13404 }
13405 }
13406 if (ctxt->valueNr < ctxt->valueFrame + op->value) {
13407 xmlGenericError(xmlGenericErrorContext,
13408 "xmlXPathCompOpEval: parameter error\n");
13409 ctxt->error = XPATH_INVALID_OPERAND;
13410 xmlXPathPopFrame(ctxt, frame);
13411 return (total);
13412 }
13413 for (i = 0; i < op->value; i++) {
13414 if (ctxt->valueTab[(ctxt->valueNr - 1) - i] == NULL) {
13415 xmlGenericError(xmlGenericErrorContext,
13416 "xmlXPathCompOpEval: parameter error\n");
13417 ctxt->error = XPATH_INVALID_OPERAND;
13418 xmlXPathPopFrame(ctxt, frame);
13419 return (total);
13420 }
13421 }
13422 if (op->cache != NULL)
13423 func = op->cache;
13424 else {
13425 const xmlChar *URI = NULL;
13426
13427 if (op->value5 == NULL)
13428 func =
13429 xmlXPathFunctionLookup(ctxt->context,
13430 op->value4);
13431 else {
13432 URI = xmlXPathNsLookup(ctxt->context, op->value5);
13433 if (URI == NULL) {
13434 xmlGenericError(xmlGenericErrorContext,
13435 "xmlXPathCompOpEval: function %s bound to undefined prefix %s\n",
13436 (char *)op->value4, (char *)op->value5);
13437 xmlXPathPopFrame(ctxt, frame);
13438 ctxt->error = XPATH_UNDEF_PREFIX_ERROR;
13439 return (total);
13440 }
13441 func = xmlXPathFunctionLookupNS(ctxt->context,
13442 op->value4, URI);
13443 }
13444 if (func == NULL) {
13445 xmlGenericError(xmlGenericErrorContext,
13446 "xmlXPathCompOpEval: function %s not found\n",
13447 (char *)op->value4);
13448 XP_ERROR0(XPATH_UNKNOWN_FUNC_ERROR);
13449 }
13450 op->cache = func;
13451 op->cacheURI = (void *) URI;
13452 }
13453 oldFunc = ctxt->context->function;
13454 oldFuncURI = ctxt->context->functionURI;
13455 ctxt->context->function = op->value4;
13456 ctxt->context->functionURI = op->cacheURI;
13457 func(ctxt, op->value);
13458 ctxt->context->function = oldFunc;
13459 ctxt->context->functionURI = oldFuncURI;
13460 xmlXPathPopFrame(ctxt, frame);
13461 return (total);
13462 }
13463 case XPATH_OP_ARG:
13464 if (op->ch1 != -1) {
13465 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13466 CHECK_ERROR0;
13467 }
13468 if (op->ch2 != -1) {
13469 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13470 CHECK_ERROR0;
13471 }
13472 return (total);
13473 case XPATH_OP_PREDICATE:
13474 case XPATH_OP_FILTER:{
13475 xmlXPathObjectPtr res;
13476 xmlXPathObjectPtr obj, tmp;
13477 xmlNodeSetPtr newset = NULL;
13478 xmlNodeSetPtr oldset;
13479 xmlNodePtr oldnode;
13480 xmlDocPtr oldDoc;
13481 int oldcs, oldpp;
13482 int i;
13483
13484 /*
13485 * Optimization for ()[1] selection i.e. the first elem
13486 */
13487 if ((op->ch1 != -1) && (op->ch2 != -1) &&
13488 #ifdef XP_OPTIMIZED_FILTER_FIRST
13489 /*
13490 * FILTER TODO: Can we assume that the inner processing
13491 * will result in an ordered list if we have an
13492 * XPATH_OP_FILTER?
13493 * What about an additional field or flag on
13494 * xmlXPathObject like @sorted ? This way we wouln'd need
13495 * to assume anything, so it would be more robust and
13496 * easier to optimize.
13497 */
13498 ((comp->steps[op->ch1].op == XPATH_OP_SORT) || /* 18 */
13499 (comp->steps[op->ch1].op == XPATH_OP_FILTER)) && /* 17 */
13500 #else
13501 (comp->steps[op->ch1].op == XPATH_OP_SORT) &&
13502 #endif
13503 (comp->steps[op->ch2].op == XPATH_OP_VALUE)) { /* 12 */
13504 xmlXPathObjectPtr val;
13505
13506 val = comp->steps[op->ch2].value4;
13507 if ((val != NULL) && (val->type == XPATH_NUMBER) &&
13508 (val->floatval == 1.0)) {
13509 xmlNodePtr first = NULL;
13510
13511 total +=
13512 xmlXPathCompOpEvalFirst(ctxt,
13513 &comp->steps[op->ch1],
13514 &first);
13515 CHECK_ERROR0;
13516 /*
13517 * The nodeset should be in document order,
13518 * Keep only the first value
13519 */
13520 if ((ctxt->value != NULL) &&
13521 (ctxt->value->type == XPATH_NODESET) &&
13522 (ctxt->value->nodesetval != NULL) &&
13523 (ctxt->value->nodesetval->nodeNr > 1))
13524 xmlXPathNodeSetClearFromPos(ctxt->value->nodesetval,
13525 1, 1);
13526 return (total);
13527 }
13528 }
13529 /*
13530 * Optimization for ()[last()] selection i.e. the last elem
13531 */
13532 if ((op->ch1 != -1) && (op->ch2 != -1) &&
13533 (comp->steps[op->ch1].op == XPATH_OP_SORT) &&
13534 (comp->steps[op->ch2].op == XPATH_OP_SORT)) {
13535 int f = comp->steps[op->ch2].ch1;
13536
13537 if ((f != -1) &&
13538 (comp->steps[f].op == XPATH_OP_FUNCTION) &&
13539 (comp->steps[f].value5 == NULL) &&
13540 (comp->steps[f].value == 0) &&
13541 (comp->steps[f].value4 != NULL) &&
13542 (xmlStrEqual
13543 (comp->steps[f].value4, BAD_CAST "last"))) {
13544 xmlNodePtr last = NULL;
13545
13546 total +=
13547 xmlXPathCompOpEvalLast(ctxt,
13548 &comp->steps[op->ch1],
13549 &last);
13550 CHECK_ERROR0;
13551 /*
13552 * The nodeset should be in document order,
13553 * Keep only the last value
13554 */
13555 if ((ctxt->value != NULL) &&
13556 (ctxt->value->type == XPATH_NODESET) &&
13557 (ctxt->value->nodesetval != NULL) &&
13558 (ctxt->value->nodesetval->nodeTab != NULL) &&
13559 (ctxt->value->nodesetval->nodeNr > 1))
13560 xmlXPathNodeSetKeepLast(ctxt->value->nodesetval);
13561 return (total);
13562 }
13563 }
13564 /*
13565 * Process inner predicates first.
13566 * Example "index[parent::book][1]":
13567 * ...
13568 * PREDICATE <-- we are here "[1]"
13569 * PREDICATE <-- process "[parent::book]" first
13570 * SORT
13571 * COLLECT 'parent' 'name' 'node' book
13572 * NODE
13573 * ELEM Object is a number : 1
13574 */
13575 if (op->ch1 != -1)
13576 total +=
13577 xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13578 CHECK_ERROR0;
13579 if (op->ch2 == -1)
13580 return (total);
13581 if (ctxt->value == NULL)
13582 return (total);
13583
13584 #ifdef LIBXML_XPTR_ENABLED
13585 /*
13586 * Hum are we filtering the result of an XPointer expression
13587 */
13588 if (ctxt->value->type == XPATH_LOCATIONSET) {
13589 xmlLocationSetPtr newlocset = NULL;
13590 xmlLocationSetPtr oldlocset;
13591
13592 /*
13593 * Extract the old locset, and then evaluate the result of the
13594 * expression for all the element in the locset. use it to grow
13595 * up a new locset.
13596 */
13597 CHECK_TYPE0(XPATH_LOCATIONSET);
13598
13599 if ((ctxt->value->user == NULL) ||
13600 (((xmlLocationSetPtr) ctxt->value->user)->locNr == 0))
13601 return (total);
13602
13603 obj = valuePop(ctxt);
13604 oldlocset = obj->user;
13605 oldnode = ctxt->context->node;
13606 oldcs = ctxt->context->contextSize;
13607 oldpp = ctxt->context->proximityPosition;
13608
13609 newlocset = xmlXPtrLocationSetCreate(NULL);
13610
13611 for (i = 0; i < oldlocset->locNr; i++) {
13612 /*
13613 * Run the evaluation with a node list made of a
13614 * single item in the nodelocset.
13615 */
13616 ctxt->context->node = oldlocset->locTab[i]->user;
13617 ctxt->context->contextSize = oldlocset->locNr;
13618 ctxt->context->proximityPosition = i + 1;
13619 tmp = xmlXPathCacheNewNodeSet(ctxt->context,
13620 ctxt->context->node);
13621 valuePush(ctxt, tmp);
13622
13623 if (op->ch2 != -1)
13624 total +=
13625 xmlXPathCompOpEval(ctxt,
13626 &comp->steps[op->ch2]);
13627 if (ctxt->error != XPATH_EXPRESSION_OK) {
13628 xmlXPtrFreeLocationSet(newlocset);
13629 goto filter_xptr_error;
13630 }
13631
13632 /*
13633 * The result of the evaluation need to be tested to
13634 * decided whether the filter succeeded or not
13635 */
13636 res = valuePop(ctxt);
13637 if (xmlXPathEvaluatePredicateResult(ctxt, res)) {
13638 xmlXPtrLocationSetAdd(newlocset,
13639 xmlXPathObjectCopy
13640 (oldlocset->locTab[i]));
13641 }
13642
13643 /*
13644 * Cleanup
13645 */
13646 if (res != NULL) {
13647 xmlXPathReleaseObject(ctxt->context, res);
13648 }
13649 if (ctxt->value == tmp) {
13650 res = valuePop(ctxt);
13651 xmlXPathReleaseObject(ctxt->context, res);
13652 }
13653 }
13654
13655 /*
13656 * The result is used as the new evaluation locset.
13657 */
13658 valuePush(ctxt, xmlXPtrWrapLocationSet(newlocset));
13659 filter_xptr_error:
13660 xmlXPathReleaseObject(ctxt->context, obj);
13661 ctxt->context->node = oldnode;
13662 ctxt->context->contextSize = oldcs;
13663 ctxt->context->proximityPosition = oldpp;
13664 return (total);
13665 }
13666 #endif /* LIBXML_XPTR_ENABLED */
13667
13668 /*
13669 * Extract the old set, and then evaluate the result of the
13670 * expression for all the element in the set. use it to grow
13671 * up a new set.
13672 */
13673 CHECK_TYPE0(XPATH_NODESET);
13674
13675 if ((ctxt->value->nodesetval != NULL) &&
13676 (ctxt->value->nodesetval->nodeNr != 0)) {
13677 obj = valuePop(ctxt);
13678 oldset = obj->nodesetval;
13679 oldnode = ctxt->context->node;
13680 oldDoc = ctxt->context->doc;
13681 oldcs = ctxt->context->contextSize;
13682 oldpp = ctxt->context->proximityPosition;
13683 tmp = NULL;
13684 /*
13685 * Initialize the new set.
13686 * Also set the xpath document in case things like
13687 * key() evaluation are attempted on the predicate
13688 */
13689 newset = xmlXPathNodeSetCreate(NULL);
13690 /*
13691 * SPEC XPath 1.0:
13692 * "For each node in the node-set to be filtered, the
13693 * PredicateExpr is evaluated with that node as the
13694 * context node, with the number of nodes in the
13695 * node-set as the context size, and with the proximity
13696 * position of the node in the node-set with respect to
13697 * the axis as the context position;"
13698 * @oldset is the node-set" to be filtered.
13699 *
13700 * SPEC XPath 1.0:
13701 * "only predicates change the context position and
13702 * context size (see [2.4 Predicates])."
13703 * Example:
13704 * node-set context pos
13705 * nA 1
13706 * nB 2
13707 * nC 3
13708 * After applying predicate [position() > 1] :
13709 * node-set context pos
13710 * nB 1
13711 * nC 2
13712 *
13713 * removed the first node in the node-set, then
13714 * the context position of the
13715 */
13716 for (i = 0; i < oldset->nodeNr; i++) {
13717 /*
13718 * Run the evaluation with a node list made of
13719 * a single item in the nodeset.
13720 */
13721 ctxt->context->node = oldset->nodeTab[i];
13722 if ((oldset->nodeTab[i]->type != XML_NAMESPACE_DECL) &&
13723 (oldset->nodeTab[i]->doc != NULL))
13724 ctxt->context->doc = oldset->nodeTab[i]->doc;
13725 if (tmp == NULL) {
13726 tmp = xmlXPathCacheNewNodeSet(ctxt->context,
13727 ctxt->context->node);
13728 } else {
13729 if (xmlXPathNodeSetAddUnique(tmp->nodesetval,
13730 ctxt->context->node) < 0) {
13731 ctxt->error = XPATH_MEMORY_ERROR;
13732 }
13733 }
13734 valuePush(ctxt, tmp);
13735 ctxt->context->contextSize = oldset->nodeNr;
13736 ctxt->context->proximityPosition = i + 1;
13737 /*
13738 * Evaluate the predicate against the context node.
13739 * Can/should we optimize position() predicates
13740 * here (e.g. "[1]")?
13741 */
13742 if (op->ch2 != -1)
13743 total +=
13744 xmlXPathCompOpEval(ctxt,
13745 &comp->steps[op->ch2]);
13746 if (ctxt->error != XPATH_EXPRESSION_OK) {
13747 xmlXPathFreeNodeSet(newset);
13748 goto filter_error;
13749 }
13750
13751 /*
13752 * The result of the evaluation needs to be tested to
13753 * decide whether the filter succeeded or not
13754 */
13755 /*
13756 * OPTIMIZE TODO: Can we use
13757 * xmlXPathNodeSetAdd*Unique()* instead?
13758 */
13759 res = valuePop(ctxt);
13760 if (xmlXPathEvaluatePredicateResult(ctxt, res)) {
13761 if (xmlXPathNodeSetAdd(newset, oldset->nodeTab[i])
13762 < 0)
13763 ctxt->error = XPATH_MEMORY_ERROR;
13764 }
13765
13766 /*
13767 * Cleanup
13768 */
13769 if (res != NULL) {
13770 xmlXPathReleaseObject(ctxt->context, res);
13771 }
13772 if (ctxt->value == tmp) {
13773 valuePop(ctxt);
13774 xmlXPathNodeSetClear(tmp->nodesetval, 1);
13775 /*
13776 * Don't free the temporary nodeset
13777 * in order to avoid massive recreation inside this
13778 * loop.
13779 */
13780 } else
13781 tmp = NULL;
13782 }
13783 if (tmp != NULL)
13784 xmlXPathReleaseObject(ctxt->context, tmp);
13785 /*
13786 * The result is used as the new evaluation set.
13787 */
13788 valuePush(ctxt,
13789 xmlXPathCacheWrapNodeSet(ctxt->context, newset));
13790 filter_error:
13791 xmlXPathReleaseObject(ctxt->context, obj);
13792 ctxt->context->node = oldnode;
13793 ctxt->context->doc = oldDoc;
13794 ctxt->context->contextSize = oldcs;
13795 ctxt->context->proximityPosition = oldpp;
13796 }
13797 return (total);
13798 }
13799 case XPATH_OP_SORT:
13800 if (op->ch1 != -1)
13801 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13802 CHECK_ERROR0;
13803 if ((ctxt->value != NULL) &&
13804 (ctxt->value->type == XPATH_NODESET) &&
13805 (ctxt->value->nodesetval != NULL) &&
13806 (ctxt->value->nodesetval->nodeNr > 1))
13807 {
13808 xmlXPathNodeSetSort(ctxt->value->nodesetval);
13809 }
13810 return (total);
13811 #ifdef LIBXML_XPTR_ENABLED
13812 case XPATH_OP_RANGETO:{
13813 xmlXPathObjectPtr range;
13814 xmlXPathObjectPtr res, obj;
13815 xmlXPathObjectPtr tmp;
13816 xmlLocationSetPtr newlocset = NULL;
13817 xmlLocationSetPtr oldlocset;
13818 xmlNodeSetPtr oldset;
13819 xmlNodePtr oldnode = ctxt->context->node;
13820 int oldcs = ctxt->context->contextSize;
13821 int oldpp = ctxt->context->proximityPosition;
13822 int i, j;
13823
13824 if (op->ch1 != -1) {
13825 total +=
13826 xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13827 CHECK_ERROR0;
13828 }
13829 if (ctxt->value == NULL) {
13830 XP_ERROR0(XPATH_INVALID_OPERAND);
13831 }
13832 if (op->ch2 == -1)
13833 return (total);
13834
13835 if (ctxt->value->type == XPATH_LOCATIONSET) {
13836 /*
13837 * Extract the old locset, and then evaluate the result of the
13838 * expression for all the element in the locset. use it to grow
13839 * up a new locset.
13840 */
13841 CHECK_TYPE0(XPATH_LOCATIONSET);
13842
13843 if ((ctxt->value->user == NULL) ||
13844 (((xmlLocationSetPtr) ctxt->value->user)->locNr == 0))
13845 return (total);
13846
13847 obj = valuePop(ctxt);
13848 oldlocset = obj->user;
13849
13850 newlocset = xmlXPtrLocationSetCreate(NULL);
13851
13852 for (i = 0; i < oldlocset->locNr; i++) {
13853 /*
13854 * Run the evaluation with a node list made of a
13855 * single item in the nodelocset.
13856 */
13857 ctxt->context->node = oldlocset->locTab[i]->user;
13858 ctxt->context->contextSize = oldlocset->locNr;
13859 ctxt->context->proximityPosition = i + 1;
13860 tmp = xmlXPathCacheNewNodeSet(ctxt->context,
13861 ctxt->context->node);
13862 valuePush(ctxt, tmp);
13863
13864 if (op->ch2 != -1)
13865 total +=
13866 xmlXPathCompOpEval(ctxt,
13867 &comp->steps[op->ch2]);
13868 if (ctxt->error != XPATH_EXPRESSION_OK) {
13869 xmlXPtrFreeLocationSet(newlocset);
13870 goto rangeto_error;
13871 }
13872
13873 res = valuePop(ctxt);
13874 if (res->type == XPATH_LOCATIONSET) {
13875 xmlLocationSetPtr rloc =
13876 (xmlLocationSetPtr)res->user;
13877 for (j=0; j<rloc->locNr; j++) {
13878 range = xmlXPtrNewRange(
13879 oldlocset->locTab[i]->user,
13880 oldlocset->locTab[i]->index,
13881 rloc->locTab[j]->user2,
13882 rloc->locTab[j]->index2);
13883 if (range != NULL) {
13884 xmlXPtrLocationSetAdd(newlocset, range);
13885 }
13886 }
13887 } else {
13888 range = xmlXPtrNewRangeNodeObject(
13889 (xmlNodePtr)oldlocset->locTab[i]->user, res);
13890 if (range != NULL) {
13891 xmlXPtrLocationSetAdd(newlocset,range);
13892 }
13893 }
13894
13895 /*
13896 * Cleanup
13897 */
13898 if (res != NULL) {
13899 xmlXPathReleaseObject(ctxt->context, res);
13900 }
13901 if (ctxt->value == tmp) {
13902 res = valuePop(ctxt);
13903 xmlXPathReleaseObject(ctxt->context, res);
13904 }
13905 }
13906 } else { /* Not a location set */
13907 CHECK_TYPE0(XPATH_NODESET);
13908 obj = valuePop(ctxt);
13909 oldset = obj->nodesetval;
13910
13911 newlocset = xmlXPtrLocationSetCreate(NULL);
13912
13913 if (oldset != NULL) {
13914 for (i = 0; i < oldset->nodeNr; i++) {
13915 /*
13916 * Run the evaluation with a node list made of a single item
13917 * in the nodeset.
13918 */
13919 ctxt->context->node = oldset->nodeTab[i];
13920 /*
13921 * OPTIMIZE TODO: Avoid recreation for every iteration.
13922 */
13923 tmp = xmlXPathCacheNewNodeSet(ctxt->context,
13924 ctxt->context->node);
13925 valuePush(ctxt, tmp);
13926
13927 if (op->ch2 != -1)
13928 total +=
13929 xmlXPathCompOpEval(ctxt,
13930 &comp->steps[op->ch2]);
13931 if (ctxt->error != XPATH_EXPRESSION_OK) {
13932 xmlXPtrFreeLocationSet(newlocset);
13933 goto rangeto_error;
13934 }
13935
13936 res = valuePop(ctxt);
13937 range =
13938 xmlXPtrNewRangeNodeObject(oldset->nodeTab[i],
13939 res);
13940 if (range != NULL) {
13941 xmlXPtrLocationSetAdd(newlocset, range);
13942 }
13943
13944 /*
13945 * Cleanup
13946 */
13947 if (res != NULL) {
13948 xmlXPathReleaseObject(ctxt->context, res);
13949 }
13950 if (ctxt->value == tmp) {
13951 res = valuePop(ctxt);
13952 xmlXPathReleaseObject(ctxt->context, res);
13953 }
13954 }
13955 }
13956 }
13957
13958 /*
13959 * The result is used as the new evaluation set.
13960 */
13961 valuePush(ctxt, xmlXPtrWrapLocationSet(newlocset));
13962 rangeto_error:
13963 xmlXPathReleaseObject(ctxt->context, obj);
13964 ctxt->context->node = oldnode;
13965 ctxt->context->contextSize = oldcs;
13966 ctxt->context->proximityPosition = oldpp;
13967 return (total);
13968 }
13969 #endif /* LIBXML_XPTR_ENABLED */
13970 }
13971 xmlGenericError(xmlGenericErrorContext,
13972 "XPath: unknown precompiled operation %d\n", op->op);
13973 ctxt->error = XPATH_INVALID_OPERAND;
13974 return (total);
13975 }
13976
13977 /**
13978 * xmlXPathCompOpEvalToBoolean:
13979 * @ctxt: the XPath parser context
13980 *
13981 * Evaluates if the expression evaluates to true.
13982 *
13983 * Returns 1 if true, 0 if false and -1 on API or internal errors.
13984 */
13985 static int
13986 xmlXPathCompOpEvalToBoolean(xmlXPathParserContextPtr ctxt,
13987 xmlXPathStepOpPtr op,
13988 int isPredicate)
13989 {
13990 xmlXPathObjectPtr resObj = NULL;
13991
13992 start:
13993 /* comp = ctxt->comp; */
13994 switch (op->op) {
13995 case XPATH_OP_END:
13996 return (0);
13997 case XPATH_OP_VALUE:
13998 resObj = (xmlXPathObjectPtr) op->value4;
13999 if (isPredicate)
14000 return(xmlXPathEvaluatePredicateResult(ctxt, resObj));
14001 return(xmlXPathCastToBoolean(resObj));
14002 case XPATH_OP_SORT:
14003 /*
14004 * We don't need sorting for boolean results. Skip this one.
14005 */
14006 if (op->ch1 != -1) {
14007 op = &ctxt->comp->steps[op->ch1];
14008 goto start;
14009 }
14010 return(0);
14011 case XPATH_OP_COLLECT:
14012 if (op->ch1 == -1)
14013 return(0);
14014
14015 xmlXPathCompOpEval(ctxt, &ctxt->comp->steps[op->ch1]);
14016 if (ctxt->error != XPATH_EXPRESSION_OK)
14017 return(-1);
14018
14019 xmlXPathNodeCollectAndTest(ctxt, op, NULL, NULL, 1);
14020 if (ctxt->error != XPATH_EXPRESSION_OK)
14021 return(-1);
14022
14023 resObj = valuePop(ctxt);
14024 if (resObj == NULL)
14025 return(-1);
14026 break;
14027 default:
14028 /*
14029 * Fallback to call xmlXPathCompOpEval().
14030 */
14031 xmlXPathCompOpEval(ctxt, op);
14032 if (ctxt->error != XPATH_EXPRESSION_OK)
14033 return(-1);
14034
14035 resObj = valuePop(ctxt);
14036 if (resObj == NULL)
14037 return(-1);
14038 break;
14039 }
14040
14041 if (resObj) {
14042 int res;
14043
14044 if (resObj->type == XPATH_BOOLEAN) {
14045 res = resObj->boolval;
14046 } else if (isPredicate) {
14047 /*
14048 * For predicates a result of type "number" is handled
14049 * differently:
14050 * SPEC XPath 1.0:
14051 * "If the result is a number, the result will be converted
14052 * to true if the number is equal to the context position
14053 * and will be converted to false otherwise;"
14054 */
14055 res = xmlXPathEvaluatePredicateResult(ctxt, resObj);
14056 } else {
14057 res = xmlXPathCastToBoolean(resObj);
14058 }
14059 xmlXPathReleaseObject(ctxt->context, resObj);
14060 return(res);
14061 }
14062
14063 return(0);
14064 }
14065
14066 #ifdef XPATH_STREAMING
14067 /**
14068 * xmlXPathRunStreamEval:
14069 * @ctxt: the XPath parser context with the compiled expression
14070 *
14071 * Evaluate the Precompiled Streamable XPath expression in the given context.
14072 */
14073 static int
14074 xmlXPathRunStreamEval(xmlXPathContextPtr ctxt, xmlPatternPtr comp,
14075 xmlXPathObjectPtr *resultSeq, int toBool)
14076 {
14077 int max_depth, min_depth;
14078 int from_root;
14079 int ret, depth;
14080 int eval_all_nodes;
14081 xmlNodePtr cur = NULL, limit = NULL;
14082 xmlStreamCtxtPtr patstream = NULL;
14083
14084 int nb_nodes = 0;
14085
14086 if ((ctxt == NULL) || (comp == NULL))
14087 return(-1);
14088 max_depth = xmlPatternMaxDepth(comp);
14089 if (max_depth == -1)
14090 return(-1);
14091 if (max_depth == -2)
14092 max_depth = 10000;
14093 min_depth = xmlPatternMinDepth(comp);
14094 if (min_depth == -1)
14095 return(-1);
14096 from_root = xmlPatternFromRoot(comp);
14097 if (from_root < 0)
14098 return(-1);
14099 #if 0
14100 printf("stream eval: depth %d from root %d\n", max_depth, from_root);
14101 #endif
14102
14103 if (! toBool) {
14104 if (resultSeq == NULL)
14105 return(-1);
14106 *resultSeq = xmlXPathCacheNewNodeSet(ctxt, NULL);
14107 if (*resultSeq == NULL)
14108 return(-1);
14109 }
14110
14111 /*
14112 * handle the special cases of "/" amd "." being matched
14113 */
14114 if (min_depth == 0) {
14115 if (from_root) {
14116 /* Select "/" */
14117 if (toBool)
14118 return(1);
14119 xmlXPathNodeSetAddUnique((*resultSeq)->nodesetval,
14120 (xmlNodePtr) ctxt->doc);
14121 } else {
14122 /* Select "self::node()" */
14123 if (toBool)
14124 return(1);
14125 xmlXPathNodeSetAddUnique((*resultSeq)->nodesetval, ctxt->node);
14126 }
14127 }
14128 if (max_depth == 0) {
14129 return(0);
14130 }
14131
14132 if (from_root) {
14133 cur = (xmlNodePtr)ctxt->doc;
14134 } else if (ctxt->node != NULL) {
14135 switch (ctxt->node->type) {
14136 case XML_ELEMENT_NODE:
14137 case XML_DOCUMENT_NODE:
14138 case XML_DOCUMENT_FRAG_NODE:
14139 case XML_HTML_DOCUMENT_NODE:
14140 #ifdef LIBXML_DOCB_ENABLED
14141 case XML_DOCB_DOCUMENT_NODE:
14142 #endif
14143 cur = ctxt->node;
14144 break;
14145 case XML_ATTRIBUTE_NODE:
14146 case XML_TEXT_NODE:
14147 case XML_CDATA_SECTION_NODE:
14148 case XML_ENTITY_REF_NODE:
14149 case XML_ENTITY_NODE:
14150 case XML_PI_NODE:
14151 case XML_COMMENT_NODE:
14152 case XML_NOTATION_NODE:
14153 case XML_DTD_NODE:
14154 case XML_DOCUMENT_TYPE_NODE:
14155 case XML_ELEMENT_DECL:
14156 case XML_ATTRIBUTE_DECL:
14157 case XML_ENTITY_DECL:
14158 case XML_NAMESPACE_DECL:
14159 case XML_XINCLUDE_START:
14160 case XML_XINCLUDE_END:
14161 break;
14162 }
14163 limit = cur;
14164 }
14165 if (cur == NULL) {
14166 return(0);
14167 }
14168
14169 patstream = xmlPatternGetStreamCtxt(comp);
14170 if (patstream == NULL) {
14171 /*
14172 * QUESTION TODO: Is this an error?
14173 */
14174 return(0);
14175 }
14176
14177 eval_all_nodes = xmlStreamWantsAnyNode(patstream);
14178
14179 if (from_root) {
14180 ret = xmlStreamPush(patstream, NULL, NULL);
14181 if (ret < 0) {
14182 } else if (ret == 1) {
14183 if (toBool)
14184 goto return_1;
14185 xmlXPathNodeSetAddUnique((*resultSeq)->nodesetval, cur);
14186 }
14187 }
14188 depth = 0;
14189 goto scan_children;
14190 next_node:
14191 do {
14192 nb_nodes++;
14193
14194 switch (cur->type) {
14195 case XML_ELEMENT_NODE:
14196 case XML_TEXT_NODE:
14197 case XML_CDATA_SECTION_NODE:
14198 case XML_COMMENT_NODE:
14199 case XML_PI_NODE:
14200 if (cur->type == XML_ELEMENT_NODE) {
14201 ret = xmlStreamPush(patstream, cur->name,
14202 (cur->ns ? cur->ns->href : NULL));
14203 } else if (eval_all_nodes)
14204 ret = xmlStreamPushNode(patstream, NULL, NULL, cur->type);
14205 else
14206 break;
14207
14208 if (ret < 0) {
14209 /* NOP. */
14210 } else if (ret == 1) {
14211 if (toBool)
14212 goto return_1;
14213 if (xmlXPathNodeSetAddUnique((*resultSeq)->nodesetval, cur)
14214 < 0) {
14215 ctxt->lastError.domain = XML_FROM_XPATH;
14216 ctxt->lastError.code = XML_ERR_NO_MEMORY;
14217 }
14218 }
14219 if ((cur->children == NULL) || (depth >= max_depth)) {
14220 ret = xmlStreamPop(patstream);
14221 while (cur->next != NULL) {
14222 cur = cur->next;
14223 if ((cur->type != XML_ENTITY_DECL) &&
14224 (cur->type != XML_DTD_NODE))
14225 goto next_node;
14226 }
14227 }
14228 default:
14229 break;
14230 }
14231
14232 scan_children:
14233 if (cur->type == XML_NAMESPACE_DECL) break;
14234 if ((cur->children != NULL) && (depth < max_depth)) {
14235 /*
14236 * Do not descend on entities declarations
14237 */
14238 if (cur->children->type != XML_ENTITY_DECL) {
14239 cur = cur->children;
14240 depth++;
14241 /*
14242 * Skip DTDs
14243 */
14244 if (cur->type != XML_DTD_NODE)
14245 continue;
14246 }
14247 }
14248
14249 if (cur == limit)
14250 break;
14251
14252 while (cur->next != NULL) {
14253 cur = cur->next;
14254 if ((cur->type != XML_ENTITY_DECL) &&
14255 (cur->type != XML_DTD_NODE))
14256 goto next_node;
14257 }
14258
14259 do {
14260 cur = cur->parent;
14261 depth--;
14262 if ((cur == NULL) || (cur == limit))
14263 goto done;
14264 if (cur->type == XML_ELEMENT_NODE) {
14265 ret = xmlStreamPop(patstream);
14266 } else if ((eval_all_nodes) &&
14267 ((cur->type == XML_TEXT_NODE) ||
14268 (cur->type == XML_CDATA_SECTION_NODE) ||
14269 (cur->type == XML_COMMENT_NODE) ||
14270 (cur->type == XML_PI_NODE)))
14271 {
14272 ret = xmlStreamPop(patstream);
14273 }
14274 if (cur->next != NULL) {
14275 cur = cur->next;
14276 break;
14277 }
14278 } while (cur != NULL);
14279
14280 } while ((cur != NULL) && (depth >= 0));
14281
14282 done:
14283
14284 #if 0
14285 printf("stream eval: checked %d nodes selected %d\n",
14286 nb_nodes, retObj->nodesetval->nodeNr);
14287 #endif
14288
14289 if (patstream)
14290 xmlFreeStreamCtxt(patstream);
14291 return(0);
14292
14293 return_1:
14294 if (patstream)
14295 xmlFreeStreamCtxt(patstream);
14296 return(1);
14297 }
14298 #endif /* XPATH_STREAMING */
14299
14300 /**
14301 * xmlXPathRunEval:
14302 * @ctxt: the XPath parser context with the compiled expression
14303 * @toBool: evaluate to a boolean result
14304 *
14305 * Evaluate the Precompiled XPath expression in the given context.
14306 */
14307 static int
14308 xmlXPathRunEval(xmlXPathParserContextPtr ctxt, int toBool)
14309 {
14310 xmlXPathCompExprPtr comp;
14311
14312 if ((ctxt == NULL) || (ctxt->comp == NULL))
14313 return(-1);
14314
14315 if (ctxt->valueTab == NULL) {
14316 /* Allocate the value stack */
14317 ctxt->valueTab = (xmlXPathObjectPtr *)
14318 xmlMalloc(10 * sizeof(xmlXPathObjectPtr));
14319 if (ctxt->valueTab == NULL) {
14320 xmlXPathPErrMemory(ctxt, "creating evaluation context\n");
14321 xmlFree(ctxt);
14322 }
14323 ctxt->valueNr = 0;
14324 ctxt->valueMax = 10;
14325 ctxt->value = NULL;
14326 ctxt->valueFrame = 0;
14327 }
14328 #ifdef XPATH_STREAMING
14329 if (ctxt->comp->stream) {
14330 int res;
14331
14332 if (toBool) {
14333 /*
14334 * Evaluation to boolean result.
14335 */
14336 res = xmlXPathRunStreamEval(ctxt->context,
14337 ctxt->comp->stream, NULL, 1);
14338 if (res != -1)
14339 return(res);
14340 } else {
14341 xmlXPathObjectPtr resObj = NULL;
14342
14343 /*
14344 * Evaluation to a sequence.
14345 */
14346 res = xmlXPathRunStreamEval(ctxt->context,
14347 ctxt->comp->stream, &resObj, 0);
14348
14349 if ((res != -1) && (resObj != NULL)) {
14350 valuePush(ctxt, resObj);
14351 return(0);
14352 }
14353 if (resObj != NULL)
14354 xmlXPathReleaseObject(ctxt->context, resObj);
14355 }
14356 /*
14357 * QUESTION TODO: This falls back to normal XPath evaluation
14358 * if res == -1. Is this intended?
14359 */
14360 }
14361 #endif
14362 comp = ctxt->comp;
14363 if (comp->last < 0) {
14364 xmlGenericError(xmlGenericErrorContext,
14365 "xmlXPathRunEval: last is less than zero\n");
14366 return(-1);
14367 }
14368 if (toBool)
14369 return(xmlXPathCompOpEvalToBoolean(ctxt,
14370 &comp->steps[comp->last], 0));
14371 else
14372 xmlXPathCompOpEval(ctxt, &comp->steps[comp->last]);
14373
14374 return(0);
14375 }
14376
14377 /************************************************************************
14378 * *
14379 * Public interfaces *
14380 * *
14381 ************************************************************************/
14382
14383 /**
14384 * xmlXPathEvalPredicate:
14385 * @ctxt: the XPath context
14386 * @res: the Predicate Expression evaluation result
14387 *
14388 * Evaluate a predicate result for the current node.
14389 * A PredicateExpr is evaluated by evaluating the Expr and converting
14390 * the result to a boolean. If the result is a number, the result will
14391 * be converted to true if the number is equal to the position of the
14392 * context node in the context node list (as returned by the position
14393 * function) and will be converted to false otherwise; if the result
14394 * is not a number, then the result will be converted as if by a call
14395 * to the boolean function.
14396 *
14397 * Returns 1 if predicate is true, 0 otherwise
14398 */
14399 int
14400 xmlXPathEvalPredicate(xmlXPathContextPtr ctxt, xmlXPathObjectPtr res) {
14401 if ((ctxt == NULL) || (res == NULL)) return(0);
14402 switch (res->type) {
14403 case XPATH_BOOLEAN:
14404 return(res->boolval);
14405 case XPATH_NUMBER:
14406 return(res->floatval == ctxt->proximityPosition);
14407 case XPATH_NODESET:
14408 case XPATH_XSLT_TREE:
14409 if (res->nodesetval == NULL)
14410 return(0);
14411 return(res->nodesetval->nodeNr != 0);
14412 case XPATH_STRING:
14413 return((res->stringval != NULL) &&
14414 (xmlStrlen(res->stringval) != 0));
14415 default:
14416 STRANGE
14417 }
14418 return(0);
14419 }
14420
14421 /**
14422 * xmlXPathEvaluatePredicateResult:
14423 * @ctxt: the XPath Parser context
14424 * @res: the Predicate Expression evaluation result
14425 *
14426 * Evaluate a predicate result for the current node.
14427 * A PredicateExpr is evaluated by evaluating the Expr and converting
14428 * the result to a boolean. If the result is a number, the result will
14429 * be converted to true if the number is equal to the position of the
14430 * context node in the context node list (as returned by the position
14431 * function) and will be converted to false otherwise; if the result
14432 * is not a number, then the result will be converted as if by a call
14433 * to the boolean function.
14434 *
14435 * Returns 1 if predicate is true, 0 otherwise
14436 */
14437 int
14438 xmlXPathEvaluatePredicateResult(xmlXPathParserContextPtr ctxt,
14439 xmlXPathObjectPtr res) {
14440 if ((ctxt == NULL) || (res == NULL)) return(0);
14441 switch (res->type) {
14442 case XPATH_BOOLEAN:
14443 return(res->boolval);
14444 case XPATH_NUMBER:
14445 #if defined(__BORLANDC__) || (defined(_MSC_VER) && (_MSC_VER == 1200))
14446 return((res->floatval == ctxt->context->proximityPosition) &&
14447 (!xmlXPathIsNaN(res->floatval))); /* MSC pbm Mark Vakoc !*/
14448 #else
14449 return(res->floatval == ctxt->context->proximityPosition);
14450 #endif
14451 case XPATH_NODESET:
14452 case XPATH_XSLT_TREE:
14453 if (res->nodesetval == NULL)
14454 return(0);
14455 return(res->nodesetval->nodeNr != 0);
14456 case XPATH_STRING:
14457 return((res->stringval != NULL) && (res->stringval[0] != 0));
14458 #ifdef LIBXML_XPTR_ENABLED
14459 case XPATH_LOCATIONSET:{
14460 xmlLocationSetPtr ptr = res->user;
14461 if (ptr == NULL)
14462 return(0);
14463 return (ptr->locNr != 0);
14464 }
14465 #endif
14466 default:
14467 STRANGE
14468 }
14469 return(0);
14470 }
14471
14472 #ifdef XPATH_STREAMING
14473 /**
14474 * xmlXPathTryStreamCompile:
14475 * @ctxt: an XPath context
14476 * @str: the XPath expression
14477 *
14478 * Try to compile the XPath expression as a streamable subset.
14479 *
14480 * Returns the compiled expression or NULL if failed to compile.
14481 */
14482 static xmlXPathCompExprPtr
14483 xmlXPathTryStreamCompile(xmlXPathContextPtr ctxt, const xmlChar *str) {
14484 /*
14485 * Optimization: use streaming patterns when the XPath expression can
14486 * be compiled to a stream lookup
14487 */
14488 xmlPatternPtr stream;
14489 xmlXPathCompExprPtr comp;
14490 xmlDictPtr dict = NULL;
14491 const xmlChar **namespaces = NULL;
14492 xmlNsPtr ns;
14493 int i, j;
14494
14495 if ((!xmlStrchr(str, '[')) && (!xmlStrchr(str, '(')) &&
14496 (!xmlStrchr(str, '@'))) {
14497 const xmlChar *tmp;
14498
14499 /*
14500 * We don't try to handle expressions using the verbose axis
14501 * specifiers ("::"), just the simplied form at this point.
14502 * Additionally, if there is no list of namespaces available and
14503 * there's a ":" in the expression, indicating a prefixed QName,
14504 * then we won't try to compile either. xmlPatterncompile() needs
14505 * to have a list of namespaces at compilation time in order to
14506 * compile prefixed name tests.
14507 */
14508 tmp = xmlStrchr(str, ':');
14509 if ((tmp != NULL) &&
14510 ((ctxt == NULL) || (ctxt->nsNr == 0) || (tmp[1] == ':')))
14511 return(NULL);
14512
14513 if (ctxt != NULL) {
14514 dict = ctxt->dict;
14515 if (ctxt->nsNr > 0) {
14516 namespaces = xmlMalloc(2 * (ctxt->nsNr + 1) * sizeof(xmlChar*));
14517 if (namespaces == NULL) {
14518 xmlXPathErrMemory(ctxt, "allocating namespaces array\n");
14519 return(NULL);
14520 }
14521 for (i = 0, j = 0; (j < ctxt->nsNr); j++) {
14522 ns = ctxt->namespaces[j];
14523 namespaces[i++] = ns->href;
14524 namespaces[i++] = ns->prefix;
14525 }
14526 namespaces[i++] = NULL;
14527 namespaces[i] = NULL;
14528 }
14529 }
14530
14531 stream = xmlPatterncompile(str, dict, XML_PATTERN_XPATH,
14532 &namespaces[0]);
14533 if (namespaces != NULL) {
14534 xmlFree((xmlChar **)namespaces);
14535 }
14536 if ((stream != NULL) && (xmlPatternStreamable(stream) == 1)) {
14537 comp = xmlXPathNewCompExpr();
14538 if (comp == NULL) {
14539 xmlXPathErrMemory(ctxt, "allocating streamable expression\n");
14540 return(NULL);
14541 }
14542 comp->stream = stream;
14543 comp->dict = dict;
14544 if (comp->dict)
14545 xmlDictReference(comp->dict);
14546 return(comp);
14547 }
14548 xmlFreePattern(stream);
14549 }
14550 return(NULL);
14551 }
14552 #endif /* XPATH_STREAMING */
14553
14554 static void
14555 xmlXPathOptimizeExpression(xmlXPathCompExprPtr comp, xmlXPathStepOpPtr op)
14556 {
14557 /*
14558 * Try to rewrite "descendant-or-self::node()/foo" to an optimized
14559 * internal representation.
14560 */
14561
14562 if ((op->op == XPATH_OP_COLLECT /* 11 */) &&
14563 (op->ch1 != -1) &&
14564 (op->ch2 == -1 /* no predicate */))
14565 {
14566 xmlXPathStepOpPtr prevop = &comp->steps[op->ch1];
14567
14568 if ((prevop->op == XPATH_OP_COLLECT /* 11 */) &&
14569 ((xmlXPathAxisVal) prevop->value ==
14570 AXIS_DESCENDANT_OR_SELF) &&
14571 (prevop->ch2 == -1) &&
14572 ((xmlXPathTestVal) prevop->value2 == NODE_TEST_TYPE) &&
14573 ((xmlXPathTypeVal) prevop->value3 == NODE_TYPE_NODE))
14574 {
14575 /*
14576 * This is a "descendant-or-self::node()" without predicates.
14577 * Try to eliminate it.
14578 */
14579
14580 switch ((xmlXPathAxisVal) op->value) {
14581 case AXIS_CHILD:
14582 case AXIS_DESCENDANT:
14583 /*
14584 * Convert "descendant-or-self::node()/child::" or
14585 * "descendant-or-self::node()/descendant::" to
14586 * "descendant::"
14587 */
14588 op->ch1 = prevop->ch1;
14589 op->value = AXIS_DESCENDANT;
14590 break;
14591 case AXIS_SELF:
14592 case AXIS_DESCENDANT_OR_SELF:
14593 /*
14594 * Convert "descendant-or-self::node()/self::" or
14595 * "descendant-or-self::node()/descendant-or-self::" to
14596 * to "descendant-or-self::"
14597 */
14598 op->ch1 = prevop->ch1;
14599 op->value = AXIS_DESCENDANT_OR_SELF;
14600 break;
14601 default:
14602 break;
14603 }
14604 }
14605 }
14606
14607 /* OP_VALUE has invalid ch1. */
14608 if (op->op == XPATH_OP_VALUE)
14609 return;
14610
14611 /* Recurse */
14612 if (op->ch1 != -1)
14613 xmlXPathOptimizeExpression(comp, &comp->steps[op->ch1]);
14614 if (op->ch2 != -1)
14615 xmlXPathOptimizeExpression(comp, &comp->steps[op->ch2]);
14616 }
14617
14618 /**
14619 * xmlXPathCtxtCompile:
14620 * @ctxt: an XPath context
14621 * @str: the XPath expression
14622 *
14623 * Compile an XPath expression
14624 *
14625 * Returns the xmlXPathCompExprPtr resulting from the compilation or NULL.
14626 * the caller has to free the object.
14627 */
14628 xmlXPathCompExprPtr
14629 xmlXPathCtxtCompile(xmlXPathContextPtr ctxt, const xmlChar *str) {
14630 xmlXPathParserContextPtr pctxt;
14631 xmlXPathCompExprPtr comp;
14632
14633 #ifdef XPATH_STREAMING
14634 comp = xmlXPathTryStreamCompile(ctxt, str);
14635 if (comp != NULL)
14636 return(comp);
14637 #endif
14638
14639 xmlXPathInit();
14640
14641 pctxt = xmlXPathNewParserContext(str, ctxt);
14642 if (pctxt == NULL)
14643 return NULL;
14644 xmlXPathCompileExpr(pctxt, 1);
14645
14646 if( pctxt->error != XPATH_EXPRESSION_OK )
14647 {
14648 xmlXPathFreeParserContext(pctxt);
14649 return(NULL);
14650 }
14651
14652 if (*pctxt->cur != 0) {
14653 /*
14654 * aleksey: in some cases this line prints *second* error message
14655 * (see bug #78858) and probably this should be fixed.
14656 * However, we are not sure that all error messages are printed
14657 * out in other places. It's not critical so we leave it as-is for now
14658 */
14659 xmlXPatherror(pctxt, __FILE__, __LINE__, XPATH_EXPR_ERROR);
14660 comp = NULL;
14661 } else {
14662 comp = pctxt->comp;
14663 pctxt->comp = NULL;
14664 }
14665 xmlXPathFreeParserContext(pctxt);
14666
14667 if (comp != NULL) {
14668 comp->expr = xmlStrdup(str);
14669 #ifdef DEBUG_EVAL_COUNTS
14670 comp->string = xmlStrdup(str);
14671 comp->nb = 0;
14672 #endif
14673 if ((comp->nbStep > 1) && (comp->last >= 0)) {
14674 xmlXPathOptimizeExpression(comp, &comp->steps[comp->last]);
14675 }
14676 }
14677 return(comp);
14678 }
14679
14680 /**
14681 * xmlXPathCompile:
14682 * @str: the XPath expression
14683 *
14684 * Compile an XPath expression
14685 *
14686 * Returns the xmlXPathCompExprPtr resulting from the compilation or NULL.
14687 * the caller has to free the object.
14688 */
14689 xmlXPathCompExprPtr
14690 xmlXPathCompile(const xmlChar *str) {
14691 return(xmlXPathCtxtCompile(NULL, str));
14692 }
14693
14694 /**
14695 * xmlXPathCompiledEvalInternal:
14696 * @comp: the compiled XPath expression
14697 * @ctxt: the XPath context
14698 * @resObj: the resulting XPath object or NULL
14699 * @toBool: 1 if only a boolean result is requested
14700 *
14701 * Evaluate the Precompiled XPath expression in the given context.
14702 * The caller has to free @resObj.
14703 *
14704 * Returns the xmlXPathObjectPtr resulting from the evaluation or NULL.
14705 * the caller has to free the object.
14706 */
14707 static int
14708 xmlXPathCompiledEvalInternal(xmlXPathCompExprPtr comp,
14709 xmlXPathContextPtr ctxt,
14710 xmlXPathObjectPtr *resObjPtr,
14711 int toBool)
14712 {
14713 xmlXPathParserContextPtr pctxt;
14714 xmlXPathObjectPtr resObj;
14715 #ifndef LIBXML_THREAD_ENABLED
14716 static int reentance = 0;
14717 #endif
14718 int res;
14719
14720 CHECK_CTXT_NEG(ctxt)
14721
14722 if (comp == NULL)
14723 return(-1);
14724 xmlXPathInit();
14725
14726 #ifndef LIBXML_THREAD_ENABLED
14727 reentance++;
14728 if (reentance > 1)
14729 xmlXPathDisableOptimizer = 1;
14730 #endif
14731
14732 #ifdef DEBUG_EVAL_COUNTS
14733 comp->nb++;
14734 if ((comp->string != NULL) && (comp->nb > 100)) {
14735 fprintf(stderr, "100 x %s\n", comp->string);
14736 comp->nb = 0;
14737 }
14738 #endif
14739 pctxt = xmlXPathCompParserContext(comp, ctxt);
14740 res = xmlXPathRunEval(pctxt, toBool);
14741
14742 if (pctxt->error != XPATH_EXPRESSION_OK) {
14743 resObj = NULL;
14744 } else {
14745 resObj = valuePop(pctxt);
14746 if (resObj == NULL) {
14747 if (!toBool)
14748 xmlGenericError(xmlGenericErrorContext,
14749 "xmlXPathCompiledEval: No result on the stack.\n");
14750 } else if (pctxt->valueNr > 0) {
14751 xmlGenericError(xmlGenericErrorContext,
14752 "xmlXPathCompiledEval: %d object(s) left on the stack.\n",
14753 pctxt->valueNr);
14754 }
14755 }
14756
14757 if (resObjPtr)
14758 *resObjPtr = resObj;
14759 else
14760 xmlXPathReleaseObject(ctxt, resObj);
14761
14762 pctxt->comp = NULL;
14763 xmlXPathFreeParserContext(pctxt);
14764 #ifndef LIBXML_THREAD_ENABLED
14765 reentance--;
14766 #endif
14767
14768 return(res);
14769 }
14770
14771 /**
14772 * xmlXPathCompiledEval:
14773 * @comp: the compiled XPath expression
14774 * @ctx: the XPath context
14775 *
14776 * Evaluate the Precompiled XPath expression in the given context.
14777 *
14778 * Returns the xmlXPathObjectPtr resulting from the evaluation or NULL.
14779 * the caller has to free the object.
14780 */
14781 xmlXPathObjectPtr
14782 xmlXPathCompiledEval(xmlXPathCompExprPtr comp, xmlXPathContextPtr ctx)
14783 {
14784 xmlXPathObjectPtr res = NULL;
14785
14786 xmlXPathCompiledEvalInternal(comp, ctx, &res, 0);
14787 return(res);
14788 }
14789
14790 /**
14791 * xmlXPathCompiledEvalToBoolean:
14792 * @comp: the compiled XPath expression
14793 * @ctxt: the XPath context
14794 *
14795 * Applies the XPath boolean() function on the result of the given
14796 * compiled expression.
14797 *
14798 * Returns 1 if the expression evaluated to true, 0 if to false and
14799 * -1 in API and internal errors.
14800 */
14801 int
14802 xmlXPathCompiledEvalToBoolean(xmlXPathCompExprPtr comp,
14803 xmlXPathContextPtr ctxt)
14804 {
14805 return(xmlXPathCompiledEvalInternal(comp, ctxt, NULL, 1));
14806 }
14807
14808 /**
14809 * xmlXPathEvalExpr:
14810 * @ctxt: the XPath Parser context
14811 *
14812 * Parse and evaluate an XPath expression in the given context,
14813 * then push the result on the context stack
14814 */
14815 void
14816 xmlXPathEvalExpr(xmlXPathParserContextPtr ctxt) {
14817 #ifdef XPATH_STREAMING
14818 xmlXPathCompExprPtr comp;
14819 #endif
14820
14821 if (ctxt == NULL) return;
14822
14823 #ifdef XPATH_STREAMING
14824 comp = xmlXPathTryStreamCompile(ctxt->context, ctxt->base);
14825 if (comp != NULL) {
14826 if (ctxt->comp != NULL)
14827 xmlXPathFreeCompExpr(ctxt->comp);
14828 ctxt->comp = comp;
14829 } else
14830 #endif
14831 {
14832 xmlXPathCompileExpr(ctxt, 1);
14833 CHECK_ERROR;
14834
14835 /* Check for trailing characters. */
14836 if (*ctxt->cur != 0)
14837 XP_ERROR(XPATH_EXPR_ERROR);
14838
14839 if ((ctxt->comp->nbStep > 1) && (ctxt->comp->last >= 0))
14840 xmlXPathOptimizeExpression(ctxt->comp,
14841 &ctxt->comp->steps[ctxt->comp->last]);
14842 }
14843
14844 xmlXPathRunEval(ctxt, 0);
14845 }
14846
14847 /**
14848 * xmlXPathEval:
14849 * @str: the XPath expression
14850 * @ctx: the XPath context
14851 *
14852 * Evaluate the XPath Location Path in the given context.
14853 *
14854 * Returns the xmlXPathObjectPtr resulting from the evaluation or NULL.
14855 * the caller has to free the object.
14856 */
14857 xmlXPathObjectPtr
14858 xmlXPathEval(const xmlChar *str, xmlXPathContextPtr ctx) {
14859 xmlXPathParserContextPtr ctxt;
14860 xmlXPathObjectPtr res;
14861
14862 CHECK_CTXT(ctx)
14863
14864 xmlXPathInit();
14865
14866 ctxt = xmlXPathNewParserContext(str, ctx);
14867 if (ctxt == NULL)
14868 return NULL;
14869 xmlXPathEvalExpr(ctxt);
14870
14871 if (ctxt->error != XPATH_EXPRESSION_OK) {
14872 res = NULL;
14873 } else {
14874 res = valuePop(ctxt);
14875 if (res == NULL) {
14876 xmlGenericError(xmlGenericErrorContext,
14877 "xmlXPathCompiledEval: No result on the stack.\n");
14878 } else if (ctxt->valueNr > 0) {
14879 xmlGenericError(xmlGenericErrorContext,
14880 "xmlXPathCompiledEval: %d object(s) left on the stack.\n",
14881 ctxt->valueNr);
14882 }
14883 }
14884
14885 xmlXPathFreeParserContext(ctxt);
14886 return(res);
14887 }
14888
14889 /**
14890 * xmlXPathSetContextNode:
14891 * @node: the node to to use as the context node
14892 * @ctx: the XPath context
14893 *
14894 * Sets 'node' as the context node. The node must be in the same
14895 * document as that associated with the context.
14896 *
14897 * Returns -1 in case of error or 0 if successful
14898 */
14899 int
14900 xmlXPathSetContextNode(xmlNodePtr node, xmlXPathContextPtr ctx) {
14901 if ((node == NULL) || (ctx == NULL))
14902 return(-1);
14903
14904 if (node->doc == ctx->doc) {
14905 ctx->node = node;
14906 return(0);
14907 }
14908 return(-1);
14909 }
14910
14911 /**
14912 * xmlXPathNodeEval:
14913 * @node: the node to to use as the context node
14914 * @str: the XPath expression
14915 * @ctx: the XPath context
14916 *
14917 * Evaluate the XPath Location Path in the given context. The node 'node'
14918 * is set as the context node. The context node is not restored.
14919 *
14920 * Returns the xmlXPathObjectPtr resulting from the evaluation or NULL.
14921 * the caller has to free the object.
14922 */
14923 xmlXPathObjectPtr
14924 xmlXPathNodeEval(xmlNodePtr node, const xmlChar *str, xmlXPathContextPtr ctx) {
14925 if (str == NULL)
14926 return(NULL);
14927 if (xmlXPathSetContextNode(node, ctx) < 0)
14928 return(NULL);
14929 return(xmlXPathEval(str, ctx));
14930 }
14931
14932 /**
14933 * xmlXPathEvalExpression:
14934 * @str: the XPath expression
14935 * @ctxt: the XPath context
14936 *
14937 * Alias for xmlXPathEval().
14938 *
14939 * Returns the xmlXPathObjectPtr resulting from the evaluation or NULL.
14940 * the caller has to free the object.
14941 */
14942 xmlXPathObjectPtr
14943 xmlXPathEvalExpression(const xmlChar *str, xmlXPathContextPtr ctxt) {
14944 return(xmlXPathEval(str, ctxt));
14945 }
14946
14947 /************************************************************************
14948 * *
14949 * Extra functions not pertaining to the XPath spec *
14950 * *
14951 ************************************************************************/
14952 /**
14953 * xmlXPathEscapeUriFunction:
14954 * @ctxt: the XPath Parser context
14955 * @nargs: the number of arguments
14956 *
14957 * Implement the escape-uri() XPath function
14958 * string escape-uri(string $str, bool $escape-reserved)
14959 *
14960 * This function applies the URI escaping rules defined in section 2 of [RFC
14961 * 2396] to the string supplied as $uri-part, which typically represents all
14962 * or part of a URI. The effect of the function is to replace any special
14963 * character in the string by an escape sequence of the form %xx%yy...,
14964 * where xxyy... is the hexadecimal representation of the octets used to
14965 * represent the character in UTF-8.
14966 *
14967 * The set of characters that are escaped depends on the setting of the
14968 * boolean argument $escape-reserved.
14969 *
14970 * If $escape-reserved is true, all characters are escaped other than lower
14971 * case letters a-z, upper case letters A-Z, digits 0-9, and the characters
14972 * referred to in [RFC 2396] as "marks": specifically, "-" | "_" | "." | "!"
14973 * | "~" | "*" | "'" | "(" | ")". The "%" character itself is escaped only
14974 * if it is not followed by two hexadecimal digits (that is, 0-9, a-f, and
14975 * A-F).
14976 *
14977 * If $escape-reserved is false, the behavior differs in that characters
14978 * referred to in [RFC 2396] as reserved characters are not escaped. These
14979 * characters are ";" | "/" | "?" | ":" | "@" | "&" | "=" | "+" | "$" | ",".
14980 *
14981 * [RFC 2396] does not define whether escaped URIs should use lower case or
14982 * upper case for hexadecimal digits. To ensure that escaped URIs can be
14983 * compared using string comparison functions, this function must always use
14984 * the upper-case letters A-F.
14985 *
14986 * Generally, $escape-reserved should be set to true when escaping a string
14987 * that is to form a single part of a URI, and to false when escaping an
14988 * entire URI or URI reference.
14989 *
14990 * In the case of non-ascii characters, the string is encoded according to
14991 * utf-8 and then converted according to RFC 2396.
14992 *
14993 * Examples
14994 * xf:escape-uri ("gopher://spinaltap.micro.umn.edu/00/Weather/California/Los%20Angeles#ocean"), true())
14995 * returns "gopher%3A%2F%2Fspinaltap.micro.umn.edu%2F00%2FWeather%2FCalifornia%2FLos%20Angeles%23ocean"
14996 * xf:escape-uri ("gopher://spinaltap.micro.umn.edu/00/Weather/California/Los%20Angeles#ocean"), false())
14997 * returns "gopher://spinaltap.micro.umn.edu/00/Weather/California/Los%20Angeles%23ocean"
14998 *
14999 */
15000 static void
15001 xmlXPathEscapeUriFunction(xmlXPathParserContextPtr ctxt, int nargs) {
15002 xmlXPathObjectPtr str;
15003 int escape_reserved;
15004 xmlBufPtr target;
15005 xmlChar *cptr;
15006 xmlChar escape[4];
15007
15008 CHECK_ARITY(2);
15009
15010 escape_reserved = xmlXPathPopBoolean(ctxt);
15011
15012 CAST_TO_STRING;
15013 str = valuePop(ctxt);
15014
15015 target = xmlBufCreate();
15016
15017 escape[0] = '%';
15018 escape[3] = 0;
15019
15020 if (target) {
15021 for (cptr = str->stringval; *cptr; cptr++) {
15022 if ((*cptr >= 'A' && *cptr <= 'Z') ||
15023 (*cptr >= 'a' && *cptr <= 'z') ||
15024 (*cptr >= '0' && *cptr <= '9') ||
15025 *cptr == '-' || *cptr == '_' || *cptr == '.' ||
15026 *cptr == '!' || *cptr == '~' || *cptr == '*' ||
15027 *cptr == '\''|| *cptr == '(' || *cptr == ')' ||
15028 (*cptr == '%' &&
15029 ((cptr[1] >= 'A' && cptr[1] <= 'F') ||
15030 (cptr[1] >= 'a' && cptr[1] <= 'f') ||
15031 (cptr[1] >= '0' && cptr[1] <= '9')) &&
15032 ((cptr[2] >= 'A' && cptr[2] <= 'F') ||
15033 (cptr[2] >= 'a' && cptr[2] <= 'f') ||
15034 (cptr[2] >= '0' && cptr[2] <= '9'))) ||
15035 (!escape_reserved &&
15036 (*cptr == ';' || *cptr == '/' || *cptr == '?' ||
15037 *cptr == ':' || *cptr == '@' || *cptr == '&' ||
15038 *cptr == '=' || *cptr == '+' || *cptr == '$' ||
15039 *cptr == ','))) {
15040 xmlBufAdd(target, cptr, 1);
15041 } else {
15042 if ((*cptr >> 4) < 10)
15043 escape[1] = '0' + (*cptr >> 4);
15044 else
15045 escape[1] = 'A' - 10 + (*cptr >> 4);
15046 if ((*cptr & 0xF) < 10)
15047 escape[2] = '0' + (*cptr & 0xF);
15048 else
15049 escape[2] = 'A' - 10 + (*cptr & 0xF);
15050
15051 xmlBufAdd(target, &escape[0], 3);
15052 }
15053 }
15054 }
15055 valuePush(ctxt, xmlXPathCacheNewString(ctxt->context,
15056 xmlBufContent(target)));
15057 xmlBufFree(target);
15058 xmlXPathReleaseObject(ctxt->context, str);
15059 }
15060
15061 /**
15062 * xmlXPathRegisterAllFunctions:
15063 * @ctxt: the XPath context
15064 *
15065 * Registers all default XPath functions in this context
15066 */
15067 void
15068 xmlXPathRegisterAllFunctions(xmlXPathContextPtr ctxt)
15069 {
15070 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"boolean",
15071 xmlXPathBooleanFunction);
15072 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"ceiling",
15073 xmlXPathCeilingFunction);
15074 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"count",
15075 xmlXPathCountFunction);
15076 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"concat",
15077 xmlXPathConcatFunction);
15078 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"contains",
15079 xmlXPathContainsFunction);
15080 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"id",
15081 xmlXPathIdFunction);
15082 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"false",
15083 xmlXPathFalseFunction);
15084 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"floor",
15085 xmlXPathFloorFunction);
15086 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"last",
15087 xmlXPathLastFunction);
15088 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"lang",
15089 xmlXPathLangFunction);
15090 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"local-name",
15091 xmlXPathLocalNameFunction);
15092 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"not",
15093 xmlXPathNotFunction);
15094 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"name",
15095 xmlXPathNameFunction);
15096 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"namespace-uri",
15097 xmlXPathNamespaceURIFunction);
15098 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"normalize-space",
15099 xmlXPathNormalizeFunction);
15100 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"number",
15101 xmlXPathNumberFunction);
15102 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"position",
15103 xmlXPathPositionFunction);
15104 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"round",
15105 xmlXPathRoundFunction);
15106 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"string",
15107 xmlXPathStringFunction);
15108 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"string-length",
15109 xmlXPathStringLengthFunction);
15110 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"starts-with",
15111 xmlXPathStartsWithFunction);
15112 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"substring",
15113 xmlXPathSubstringFunction);
15114 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"substring-before",
15115 xmlXPathSubstringBeforeFunction);
15116 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"substring-after",
15117 xmlXPathSubstringAfterFunction);
15118 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"sum",
15119 xmlXPathSumFunction);
15120 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"true",
15121 xmlXPathTrueFunction);
15122 xmlXPathRegisterFunc(ctxt, (const xmlChar *)"translate",
15123 xmlXPathTranslateFunction);
15124
15125 xmlXPathRegisterFuncNS(ctxt, (const xmlChar *)"escape-uri",
15126 (const xmlChar *)"http://www.w3.org/2002/08/xquery-functions",
15127 xmlXPathEscapeUriFunction);
15128 }
15129
15130 #endif /* LIBXML_XPATH_ENABLED */
15131 #define bottom_xpath
15132 #include "elfgcchack.h"
A free Windows-compatible Operating System