1: /*
2: * xpath.c: XML Path Language implementation
3: * XPath is a language for addressing parts of an XML document,
4: * designed to be used by both XSLT and XPointer
5: *f
6: * Reference: W3C Recommendation 16 November 1999
7: * http://www.w3.org/TR/1999/REC-xpath-19991116
8: * Public reference:
9: * http://www.w3.org/TR/xpath
10: *
11: * See Copyright for the status of this software
12: *
13: * Author: daniel@veillard.com
14: *
15: */
16:
17: #define IN_LIBXML
18: #include "libxml.h"
19:
20: #include <string.h>
21:
22: #ifdef HAVE_SYS_TYPES_H
23: #include <sys/types.h>
24: #endif
25: #ifdef HAVE_MATH_H
26: #include <math.h>
27: #endif
28: #ifdef HAVE_FLOAT_H
29: #include <float.h>
30: #endif
31: #ifdef HAVE_CTYPE_H
32: #include <ctype.h>
33: #endif
34: #ifdef HAVE_SIGNAL_H
35: #include <signal.h>
36: #endif
37:
38: #include <libxml/xmlmemory.h>
39: #include <libxml/tree.h>
40: #include <libxml/valid.h>
41: #include <libxml/xpath.h>
42: #include <libxml/xpathInternals.h>
43: #include <libxml/parserInternals.h>
44: #include <libxml/hash.h>
45: #ifdef LIBXML_XPTR_ENABLED
46: #include <libxml/xpointer.h>
47: #endif
48: #ifdef LIBXML_DEBUG_ENABLED
49: #include <libxml/debugXML.h>
50: #endif
51: #include <libxml/xmlerror.h>
52: #include <libxml/threads.h>
53: #include <libxml/globals.h>
54: #ifdef LIBXML_PATTERN_ENABLED
55: #include <libxml/pattern.h>
56: #endif
57:
58: #include "buf.h"
59:
60: #ifdef LIBXML_PATTERN_ENABLED
61: #define XPATH_STREAMING
62: #endif
63:
64: #define TODO \
65: xmlGenericError(xmlGenericErrorContext, \
66: "Unimplemented block at %s:%d\n", \
67: __FILE__, __LINE__);
68:
69: /**
70: * WITH_TIM_SORT:
71: *
72: * Use the Timsort algorithm provided in timsort.h to sort
73: * nodeset as this is a great improvement over the old Shell sort
74: * used in xmlXPathNodeSetSort()
75: */
76: #define WITH_TIM_SORT
77:
78: /*
79: * XP_OPTIMIZED_NON_ELEM_COMPARISON:
80: * If defined, this will use xmlXPathCmpNodesExt() instead of
81: * xmlXPathCmpNodes(). The new function is optimized comparison of
82: * non-element nodes; actually it will speed up comparison only if
83: * xmlXPathOrderDocElems() was called in order to index the elements of
84: * a tree in document order; Libxslt does such an indexing, thus it will
85: * benefit from this optimization.
86: */
87: #define XP_OPTIMIZED_NON_ELEM_COMPARISON
88:
89: /*
90: * XP_OPTIMIZED_FILTER_FIRST:
91: * If defined, this will optimize expressions like "key('foo', 'val')[b][1]"
92: * in a way, that it stop evaluation at the first node.
93: */
94: #define XP_OPTIMIZED_FILTER_FIRST
95:
96: /*
97: * XP_DEBUG_OBJ_USAGE:
98: * Internal flag to enable tracking of how much XPath objects have been
99: * created.
100: */
101: /* #define XP_DEBUG_OBJ_USAGE */
102:
103: /*
104: * XPATH_MAX_STEPS:
105: * when compiling an XPath expression we arbitrary limit the maximum
106: * number of step operation in the compiled expression. 1000000 is
107: * an insanely large value which should never be reached under normal
108: * circumstances
109: */
110: #define XPATH_MAX_STEPS 1000000
111:
112: /*
113: * XPATH_MAX_STACK_DEPTH:
114: * when evaluating an XPath expression we arbitrary limit the maximum
115: * number of object allowed to be pushed on the stack. 1000000 is
116: * an insanely large value which should never be reached under normal
117: * circumstances
118: */
119: #define XPATH_MAX_STACK_DEPTH 1000000
120:
121: /*
122: * XPATH_MAX_NODESET_LENGTH:
123: * when evaluating an XPath expression nodesets are created and we
124: * arbitrary limit the maximum length of those node set. 10000000 is
125: * an insanely large value which should never be reached under normal
126: * circumstances, one would first need to construct an in memory tree
127: * with more than 10 millions nodes.
128: */
129: #define XPATH_MAX_NODESET_LENGTH 10000000
130:
131: /*
132: * TODO:
133: * There are a few spots where some tests are done which depend upon ascii
134: * data. These should be enhanced for full UTF8 support (see particularly
135: * any use of the macros IS_ASCII_CHARACTER and IS_ASCII_DIGIT)
136: */
137:
138: /*
139: * Wrapper for the Timsort argorithm from timsort.h
140: */
141: #ifdef WITH_TIM_SORT
142: #define SORT_NAME libxml_domnode
143: #define SORT_TYPE xmlNodePtr
144: /**
145: * wrap_cmp:
146: * @x: a node
147: * @y: another node
148: *
149: * Comparison function for the Timsort implementation
150: *
151: * Returns -2 in case of error -1 if first point < second point, 0 if
152: * it's the same node, +1 otherwise
153: */
154: static
155: int wrap_cmp( xmlNodePtr x, xmlNodePtr y );
156: #ifdef XP_OPTIMIZED_NON_ELEM_COMPARISON
157: static int xmlXPathCmpNodesExt(xmlNodePtr, xmlNodePtr);
158: static int wrap_cmp( xmlNodePtr x, xmlNodePtr y )
159: {
160: int res = xmlXPathCmpNodesExt(x, y);
161: return res == -2 ? res : -res;
162: }
163: #else
164: static int wrap_cmp( xmlNodePtr x, xmlNodePtr y )
165: {
166: int res = xmlXPathCmpNodes(x, y);
167: return res == -2 ? res : -res;
168: }
169: #endif
170: #define SORT_CMP(x, y) (wrap_cmp(x, y))
171: #include "timsort.h"
172: #endif /* WITH_TIM_SORT */
173:
174: #if defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
175:
176: /************************************************************************
177: * *
178: * Floating point stuff *
179: * *
180: ************************************************************************/
181:
182: #ifndef TRIO_REPLACE_STDIO
183: #define TRIO_PUBLIC static
184: #endif
185: #include "trionan.c"
186:
187: /*
188: * The lack of portability of this section of the libc is annoying !
189: */
190: double xmlXPathNAN = 0;
191: double xmlXPathPINF = 1;
192: double xmlXPathNINF = -1;
193: static double xmlXPathNZERO = 0; /* not exported from headers */
194: static int xmlXPathInitialized = 0;
195:
196: /**
197: * xmlXPathInit:
198: *
199: * Initialize the XPath environment
200: */
201: void
202: xmlXPathInit(void) {
203: if (xmlXPathInitialized) return;
204:
205: xmlXPathPINF = trio_pinf();
206: xmlXPathNINF = trio_ninf();
207: xmlXPathNAN = trio_nan();
208: xmlXPathNZERO = trio_nzero();
209:
210: xmlXPathInitialized = 1;
211: }
212:
213: /**
214: * xmlXPathIsNaN:
215: * @val: a double value
216: *
217: * Provides a portable isnan() function to detect whether a double
218: * is a NotaNumber. Based on trio code
219: * http://sourceforge.net/projects/ctrio/
220: *
221: * Returns 1 if the value is a NaN, 0 otherwise
222: */
223: int
224: xmlXPathIsNaN(double val) {
225: return(trio_isnan(val));
226: }
227:
228: /**
229: * xmlXPathIsInf:
230: * @val: a double value
231: *
232: * Provides a portable isinf() function to detect whether a double
233: * is a +Infinite or -Infinite. Based on trio code
234: * http://sourceforge.net/projects/ctrio/
235: *
236: * Returns 1 vi the value is +Infinite, -1 if -Infinite, 0 otherwise
237: */
238: int
239: xmlXPathIsInf(double val) {
240: return(trio_isinf(val));
241: }
242:
243: #endif /* SCHEMAS or XPATH */
244: #ifdef LIBXML_XPATH_ENABLED
245: /**
246: * xmlXPathGetSign:
247: * @val: a double value
248: *
249: * Provides a portable function to detect the sign of a double
250: * Modified from trio code
251: * http://sourceforge.net/projects/ctrio/
252: *
253: * Returns 1 if the value is Negative, 0 if positive
254: */
255: static int
256: xmlXPathGetSign(double val) {
257: return(trio_signbit(val));
258: }
259:
260:
261: /*
262: * TODO: when compatibility allows remove all "fake node libxslt" strings
263: * the test should just be name[0] = ' '
264: */
265: #ifdef DEBUG_XPATH_EXPRESSION
266: #define DEBUG_STEP
267: #define DEBUG_EXPR
268: #define DEBUG_EVAL_COUNTS
269: #endif
270:
271: static xmlNs xmlXPathXMLNamespaceStruct = {
272: NULL,
273: XML_NAMESPACE_DECL,
274: XML_XML_NAMESPACE,
275: BAD_CAST "xml",
276: NULL,
277: NULL
278: };
279: static xmlNsPtr xmlXPathXMLNamespace = &xmlXPathXMLNamespaceStruct;
280: #ifndef LIBXML_THREAD_ENABLED
281: /*
282: * Optimizer is disabled only when threaded apps are detected while
283: * the library ain't compiled for thread safety.
284: */
285: static int xmlXPathDisableOptimizer = 0;
286: #endif
287:
288: /************************************************************************
289: * *
290: * Error handling routines *
291: * *
292: ************************************************************************/
293:
294: /**
295: * XP_ERRORNULL:
296: * @X: the error code
297: *
298: * Macro to raise an XPath error and return NULL.
299: */
300: #define XP_ERRORNULL(X) \
301: { xmlXPathErr(ctxt, X); return(NULL); }
302:
303: /*
304: * The array xmlXPathErrorMessages corresponds to the enum xmlXPathError
305: */
306: static const char *xmlXPathErrorMessages[] = {
307: "Ok\n",
308: "Number encoding\n",
309: "Unfinished literal\n",
310: "Start of literal\n",
311: "Expected $ for variable reference\n",
312: "Undefined variable\n",
313: "Invalid predicate\n",
314: "Invalid expression\n",
315: "Missing closing curly brace\n",
316: "Unregistered function\n",
317: "Invalid operand\n",
318: "Invalid type\n",
319: "Invalid number of arguments\n",
320: "Invalid context size\n",
321: "Invalid context position\n",
322: "Memory allocation error\n",
323: "Syntax error\n",
324: "Resource error\n",
325: "Sub resource error\n",
326: "Undefined namespace prefix\n",
327: "Encoding error\n",
328: "Char out of XML range\n",
329: "Invalid or incomplete context\n",
330: "Stack usage errror\n",
331: "Forbidden variable\n",
332: "?? Unknown error ??\n" /* Must be last in the list! */
333: };
334: #define MAXERRNO ((int)(sizeof(xmlXPathErrorMessages) / \
335: sizeof(xmlXPathErrorMessages[0])) - 1)
336: /**
337: * xmlXPathErrMemory:
338: * @ctxt: an XPath context
339: * @extra: extra informations
340: *
341: * Handle a redefinition of attribute error
342: */
343: static void
344: xmlXPathErrMemory(xmlXPathContextPtr ctxt, const char *extra)
345: {
346: if (ctxt != NULL) {
347: if (extra) {
348: xmlChar buf[200];
349:
350: xmlStrPrintf(buf, 200,
351: BAD_CAST "Memory allocation failed : %s\n",
352: extra);
353: ctxt->lastError.message = (char *) xmlStrdup(buf);
354: } else {
355: ctxt->lastError.message = (char *)
356: xmlStrdup(BAD_CAST "Memory allocation failed\n");
357: }
358: ctxt->lastError.domain = XML_FROM_XPATH;
359: ctxt->lastError.code = XML_ERR_NO_MEMORY;
360: if (ctxt->error != NULL)
361: ctxt->error(ctxt->userData, &ctxt->lastError);
362: } else {
363: if (extra)
364: __xmlRaiseError(NULL, NULL, NULL,
365: NULL, NULL, XML_FROM_XPATH,
366: XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0,
367: extra, NULL, NULL, 0, 0,
368: "Memory allocation failed : %s\n", extra);
369: else
370: __xmlRaiseError(NULL, NULL, NULL,
371: NULL, NULL, XML_FROM_XPATH,
372: XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0,
373: NULL, NULL, NULL, 0, 0,
374: "Memory allocation failed\n");
375: }
376: }
377:
378: /**
379: * xmlXPathPErrMemory:
380: * @ctxt: an XPath parser context
381: * @extra: extra informations
382: *
383: * Handle a redefinition of attribute error
384: */
385: static void
386: xmlXPathPErrMemory(xmlXPathParserContextPtr ctxt, const char *extra)
387: {
388: if (ctxt == NULL)
389: xmlXPathErrMemory(NULL, extra);
390: else {
391: ctxt->error = XPATH_MEMORY_ERROR;
392: xmlXPathErrMemory(ctxt->context, extra);
393: }
394: }
395:
396: /**
397: * xmlXPathErr:
398: * @ctxt: a XPath parser context
399: * @error: the error code
400: *
401: * Handle an XPath error
402: */
403: void
404: xmlXPathErr(xmlXPathParserContextPtr ctxt, int error)
405: {
406: if ((error < 0) || (error > MAXERRNO))
407: error = MAXERRNO;
408: if (ctxt == NULL) {
409: __xmlRaiseError(NULL, NULL, NULL,
410: NULL, NULL, XML_FROM_XPATH,
411: error + XML_XPATH_EXPRESSION_OK - XPATH_EXPRESSION_OK,
412: XML_ERR_ERROR, NULL, 0,
413: NULL, NULL, NULL, 0, 0,
414: "%s", xmlXPathErrorMessages[error]);
415: return;
416: }
417: ctxt->error = error;
418: if (ctxt->context == NULL) {
419: __xmlRaiseError(NULL, NULL, NULL,
420: NULL, NULL, XML_FROM_XPATH,
421: error + XML_XPATH_EXPRESSION_OK - XPATH_EXPRESSION_OK,
422: XML_ERR_ERROR, NULL, 0,
423: (const char *) ctxt->base, NULL, NULL,
424: ctxt->cur - ctxt->base, 0,
425: "%s", xmlXPathErrorMessages[error]);
426: return;
427: }
428:
429: /* cleanup current last error */
430: xmlResetError(&ctxt->context->lastError);
431:
432: ctxt->context->lastError.domain = XML_FROM_XPATH;
433: ctxt->context->lastError.code = error + XML_XPATH_EXPRESSION_OK -
434: XPATH_EXPRESSION_OK;
435: ctxt->context->lastError.level = XML_ERR_ERROR;
436: ctxt->context->lastError.str1 = (char *) xmlStrdup(ctxt->base);
437: ctxt->context->lastError.int1 = ctxt->cur - ctxt->base;
438: ctxt->context->lastError.node = ctxt->context->debugNode;
439: if (ctxt->context->error != NULL) {
440: ctxt->context->error(ctxt->context->userData,
441: &ctxt->context->lastError);
442: } else {
443: __xmlRaiseError(NULL, NULL, NULL,
444: NULL, ctxt->context->debugNode, XML_FROM_XPATH,
445: error + XML_XPATH_EXPRESSION_OK - XPATH_EXPRESSION_OK,
446: XML_ERR_ERROR, NULL, 0,
447: (const char *) ctxt->base, NULL, NULL,
448: ctxt->cur - ctxt->base, 0,
449: "%s", xmlXPathErrorMessages[error]);
450: }
451:
452: }
453:
454: /**
455: * xmlXPatherror:
456: * @ctxt: the XPath Parser context
457: * @file: the file name
458: * @line: the line number
459: * @no: the error number
460: *
461: * Formats an error message.
462: */
463: void
464: xmlXPatherror(xmlXPathParserContextPtr ctxt, const char *file ATTRIBUTE_UNUSED,
465: int line ATTRIBUTE_UNUSED, int no) {
466: xmlXPathErr(ctxt, no);
467: }
468:
469: /************************************************************************
470: * *
471: * Utilities *
472: * *
473: ************************************************************************/
474:
475: /**
476: * xsltPointerList:
477: *
478: * Pointer-list for various purposes.
479: */
480: typedef struct _xmlPointerList xmlPointerList;
481: typedef xmlPointerList *xmlPointerListPtr;
482: struct _xmlPointerList {
483: void **items;
484: int number;
485: int size;
486: };
487: /*
488: * TODO: Since such a list-handling is used in xmlschemas.c and libxslt
489: * and here, we should make the functions public.
490: */
491: static int
492: xmlPointerListAddSize(xmlPointerListPtr list,
493: void *item,
494: int initialSize)
495: {
496: if (list->items == NULL) {
497: if (initialSize <= 0)
498: initialSize = 1;
499: list->items = (void **) xmlMalloc(initialSize * sizeof(void *));
500: if (list->items == NULL) {
501: xmlXPathErrMemory(NULL,
502: "xmlPointerListCreate: allocating item\n");
503: return(-1);
504: }
505: list->number = 0;
506: list->size = initialSize;
507: } else if (list->size <= list->number) {
508: if (list->size > 50000000) {
509: xmlXPathErrMemory(NULL,
510: "xmlPointerListAddSize: re-allocating item\n");
511: return(-1);
512: }
513: list->size *= 2;
514: list->items = (void **) xmlRealloc(list->items,
515: list->size * sizeof(void *));
516: if (list->items == NULL) {
517: xmlXPathErrMemory(NULL,
518: "xmlPointerListAddSize: re-allocating item\n");
519: list->size = 0;
520: return(-1);
521: }
522: }
523: list->items[list->number++] = item;
524: return(0);
525: }
526:
527: /**
528: * xsltPointerListCreate:
529: *
530: * Creates an xsltPointerList structure.
531: *
532: * Returns a xsltPointerList structure or NULL in case of an error.
533: */
534: static xmlPointerListPtr
535: xmlPointerListCreate(int initialSize)
536: {
537: xmlPointerListPtr ret;
538:
539: ret = xmlMalloc(sizeof(xmlPointerList));
540: if (ret == NULL) {
541: xmlXPathErrMemory(NULL,
542: "xmlPointerListCreate: allocating item\n");
543: return (NULL);
544: }
545: memset(ret, 0, sizeof(xmlPointerList));
546: if (initialSize > 0) {
547: xmlPointerListAddSize(ret, NULL, initialSize);
548: ret->number = 0;
549: }
550: return (ret);
551: }
552:
553: /**
554: * xsltPointerListFree:
555: *
556: * Frees the xsltPointerList structure. This does not free
557: * the content of the list.
558: */
559: static void
560: xmlPointerListFree(xmlPointerListPtr list)
561: {
562: if (list == NULL)
563: return;
564: if (list->items != NULL)
565: xmlFree(list->items);
566: xmlFree(list);
567: }
568:
569: /************************************************************************
570: * *
571: * Parser Types *
572: * *
573: ************************************************************************/
574:
575: /*
576: * Types are private:
577: */
578:
579: typedef enum {
580: XPATH_OP_END=0,
581: XPATH_OP_AND,
582: XPATH_OP_OR,
583: XPATH_OP_EQUAL,
584: XPATH_OP_CMP,
585: XPATH_OP_PLUS,
586: XPATH_OP_MULT,
587: XPATH_OP_UNION,
588: XPATH_OP_ROOT,
589: XPATH_OP_NODE,
590: XPATH_OP_RESET, /* 10 */
591: XPATH_OP_COLLECT,
592: XPATH_OP_VALUE, /* 12 */
593: XPATH_OP_VARIABLE,
594: XPATH_OP_FUNCTION,
595: XPATH_OP_ARG,
596: XPATH_OP_PREDICATE,
597: XPATH_OP_FILTER, /* 17 */
598: XPATH_OP_SORT /* 18 */
599: #ifdef LIBXML_XPTR_ENABLED
600: ,XPATH_OP_RANGETO
601: #endif
602: } xmlXPathOp;
603:
604: typedef enum {
605: AXIS_ANCESTOR = 1,
606: AXIS_ANCESTOR_OR_SELF,
607: AXIS_ATTRIBUTE,
608: AXIS_CHILD,
609: AXIS_DESCENDANT,
610: AXIS_DESCENDANT_OR_SELF,
611: AXIS_FOLLOWING,
612: AXIS_FOLLOWING_SIBLING,
613: AXIS_NAMESPACE,
614: AXIS_PARENT,
615: AXIS_PRECEDING,
616: AXIS_PRECEDING_SIBLING,
617: AXIS_SELF
618: } xmlXPathAxisVal;
619:
620: typedef enum {
621: NODE_TEST_NONE = 0,
622: NODE_TEST_TYPE = 1,
623: NODE_TEST_PI = 2,
624: NODE_TEST_ALL = 3,
625: NODE_TEST_NS = 4,
626: NODE_TEST_NAME = 5
627: } xmlXPathTestVal;
628:
629: typedef enum {
630: NODE_TYPE_NODE = 0,
631: NODE_TYPE_COMMENT = XML_COMMENT_NODE,
632: NODE_TYPE_TEXT = XML_TEXT_NODE,
633: NODE_TYPE_PI = XML_PI_NODE
634: } xmlXPathTypeVal;
635:
636: typedef struct _xmlXPathStepOp xmlXPathStepOp;
637: typedef xmlXPathStepOp *xmlXPathStepOpPtr;
638: struct _xmlXPathStepOp {
639: xmlXPathOp op; /* The identifier of the operation */
640: int ch1; /* First child */
641: int ch2; /* Second child */
642: int value;
643: int value2;
644: int value3;
645: void *value4;
646: void *value5;
647: void *cache;
648: void *cacheURI;
649: };
650:
651: struct _xmlXPathCompExpr {
652: int nbStep; /* Number of steps in this expression */
653: int maxStep; /* Maximum number of steps allocated */
654: xmlXPathStepOp *steps; /* ops for computation of this expression */
655: int last; /* index of last step in expression */
656: xmlChar *expr; /* the expression being computed */
657: xmlDictPtr dict; /* the dictionnary to use if any */
658: #ifdef DEBUG_EVAL_COUNTS
659: int nb;
660: xmlChar *string;
661: #endif
662: #ifdef XPATH_STREAMING
663: xmlPatternPtr stream;
664: #endif
665: };
666:
667: /************************************************************************
668: * *
669: * Forward declarations *
670: * *
671: ************************************************************************/
672: static void
673: xmlXPathFreeValueTree(xmlNodeSetPtr obj);
674: static void
675: xmlXPathReleaseObject(xmlXPathContextPtr ctxt, xmlXPathObjectPtr obj);
676: static int
677: xmlXPathCompOpEvalFirst(xmlXPathParserContextPtr ctxt,
678: xmlXPathStepOpPtr op, xmlNodePtr *first);
679: static int
680: xmlXPathCompOpEvalToBoolean(xmlXPathParserContextPtr ctxt,
681: xmlXPathStepOpPtr op,
682: int isPredicate);
683:
684: /************************************************************************
685: * *
686: * Parser Type functions *
687: * *
688: ************************************************************************/
689:
690: /**
691: * xmlXPathNewCompExpr:
692: *
693: * Create a new Xpath component
694: *
695: * Returns the newly allocated xmlXPathCompExprPtr or NULL in case of error
696: */
697: static xmlXPathCompExprPtr
698: xmlXPathNewCompExpr(void) {
699: xmlXPathCompExprPtr cur;
700:
701: cur = (xmlXPathCompExprPtr) xmlMalloc(sizeof(xmlXPathCompExpr));
702: if (cur == NULL) {
703: xmlXPathErrMemory(NULL, "allocating component\n");
704: return(NULL);
705: }
706: memset(cur, 0, sizeof(xmlXPathCompExpr));
707: cur->maxStep = 10;
708: cur->nbStep = 0;
709: cur->steps = (xmlXPathStepOp *) xmlMalloc(cur->maxStep *
710: sizeof(xmlXPathStepOp));
711: if (cur->steps == NULL) {
712: xmlXPathErrMemory(NULL, "allocating steps\n");
713: xmlFree(cur);
714: return(NULL);
715: }
716: memset(cur->steps, 0, cur->maxStep * sizeof(xmlXPathStepOp));
717: cur->last = -1;
718: #ifdef DEBUG_EVAL_COUNTS
719: cur->nb = 0;
720: #endif
721: return(cur);
722: }
723:
724: /**
725: * xmlXPathFreeCompExpr:
726: * @comp: an XPATH comp
727: *
728: * Free up the memory allocated by @comp
729: */
730: void
731: xmlXPathFreeCompExpr(xmlXPathCompExprPtr comp)
732: {
733: xmlXPathStepOpPtr op;
734: int i;
735:
736: if (comp == NULL)
737: return;
738: if (comp->dict == NULL) {
739: for (i = 0; i < comp->nbStep; i++) {
740: op = &comp->steps[i];
741: if (op->value4 != NULL) {
742: if (op->op == XPATH_OP_VALUE)
743: xmlXPathFreeObject(op->value4);
744: else
745: xmlFree(op->value4);
746: }
747: if (op->value5 != NULL)
748: xmlFree(op->value5);
749: }
750: } else {
751: for (i = 0; i < comp->nbStep; i++) {
752: op = &comp->steps[i];
753: if (op->value4 != NULL) {
754: if (op->op == XPATH_OP_VALUE)
755: xmlXPathFreeObject(op->value4);
756: }
757: }
758: xmlDictFree(comp->dict);
759: }
760: if (comp->steps != NULL) {
761: xmlFree(comp->steps);
762: }
763: #ifdef DEBUG_EVAL_COUNTS
764: if (comp->string != NULL) {
765: xmlFree(comp->string);
766: }
767: #endif
768: #ifdef XPATH_STREAMING
769: if (comp->stream != NULL) {
770: xmlFreePatternList(comp->stream);
771: }
772: #endif
773: if (comp->expr != NULL) {
774: xmlFree(comp->expr);
775: }
776:
777: xmlFree(comp);
778: }
779:
780: /**
781: * xmlXPathCompExprAdd:
782: * @comp: the compiled expression
783: * @ch1: first child index
784: * @ch2: second child index
785: * @op: an op
786: * @value: the first int value
787: * @value2: the second int value
788: * @value3: the third int value
789: * @value4: the first string value
790: * @value5: the second string value
791: *
792: * Add a step to an XPath Compiled Expression
793: *
794: * Returns -1 in case of failure, the index otherwise
795: */
796: static int
797: xmlXPathCompExprAdd(xmlXPathCompExprPtr comp, int ch1, int ch2,
798: xmlXPathOp op, int value,
799: int value2, int value3, void *value4, void *value5) {
800: if (comp->nbStep >= comp->maxStep) {
801: xmlXPathStepOp *real;
802:
803: if (comp->maxStep >= XPATH_MAX_STEPS) {
804: xmlXPathErrMemory(NULL, "adding step\n");
805: return(-1);
806: }
807: comp->maxStep *= 2;
808: real = (xmlXPathStepOp *) xmlRealloc(comp->steps,
809: comp->maxStep * sizeof(xmlXPathStepOp));
810: if (real == NULL) {
811: comp->maxStep /= 2;
812: xmlXPathErrMemory(NULL, "adding step\n");
813: return(-1);
814: }
815: comp->steps = real;
816: }
817: comp->last = comp->nbStep;
818: comp->steps[comp->nbStep].ch1 = ch1;
819: comp->steps[comp->nbStep].ch2 = ch2;
820: comp->steps[comp->nbStep].op = op;
821: comp->steps[comp->nbStep].value = value;
822: comp->steps[comp->nbStep].value2 = value2;
823: comp->steps[comp->nbStep].value3 = value3;
824: if ((comp->dict != NULL) &&
825: ((op == XPATH_OP_FUNCTION) || (op == XPATH_OP_VARIABLE) ||
826: (op == XPATH_OP_COLLECT))) {
827: if (value4 != NULL) {
828: comp->steps[comp->nbStep].value4 = (xmlChar *)
829: (void *)xmlDictLookup(comp->dict, value4, -1);
830: xmlFree(value4);
831: } else
832: comp->steps[comp->nbStep].value4 = NULL;
833: if (value5 != NULL) {
834: comp->steps[comp->nbStep].value5 = (xmlChar *)
835: (void *)xmlDictLookup(comp->dict, value5, -1);
836: xmlFree(value5);
837: } else
838: comp->steps[comp->nbStep].value5 = NULL;
839: } else {
840: comp->steps[comp->nbStep].value4 = value4;
841: comp->steps[comp->nbStep].value5 = value5;
842: }
843: comp->steps[comp->nbStep].cache = NULL;
844: return(comp->nbStep++);
845: }
846:
847: /**
848: * xmlXPathCompSwap:
849: * @comp: the compiled expression
850: * @op: operation index
851: *
852: * Swaps 2 operations in the compiled expression
853: */
854: static void
855: xmlXPathCompSwap(xmlXPathStepOpPtr op) {
856: int tmp;
857:
858: #ifndef LIBXML_THREAD_ENABLED
859: /*
860: * Since this manipulates possibly shared variables, this is
861: * disabled if one detects that the library is used in a multithreaded
862: * application
863: */
864: if (xmlXPathDisableOptimizer)
865: return;
866: #endif
867:
868: tmp = op->ch1;
869: op->ch1 = op->ch2;
870: op->ch2 = tmp;
871: }
872:
873: #define PUSH_FULL_EXPR(op, op1, op2, val, val2, val3, val4, val5) \
874: xmlXPathCompExprAdd(ctxt->comp, (op1), (op2), \
875: (op), (val), (val2), (val3), (val4), (val5))
876: #define PUSH_LONG_EXPR(op, val, val2, val3, val4, val5) \
877: xmlXPathCompExprAdd(ctxt->comp, ctxt->comp->last, -1, \
878: (op), (val), (val2), (val3), (val4), (val5))
879:
880: #define PUSH_LEAVE_EXPR(op, val, val2) \
881: xmlXPathCompExprAdd(ctxt->comp, -1, -1, (op), (val), (val2), 0 ,NULL ,NULL)
882:
883: #define PUSH_UNARY_EXPR(op, ch, val, val2) \
884: xmlXPathCompExprAdd(ctxt->comp, (ch), -1, (op), (val), (val2), 0 ,NULL ,NULL)
885:
886: #define PUSH_BINARY_EXPR(op, ch1, ch2, val, val2) \
887: xmlXPathCompExprAdd(ctxt->comp, (ch1), (ch2), (op), \
888: (val), (val2), 0 ,NULL ,NULL)
889:
890: /************************************************************************
891: * *
892: * XPath object cache structures *
893: * *
894: ************************************************************************/
895:
896: /* #define XP_DEFAULT_CACHE_ON */
897:
898: #define XP_HAS_CACHE(c) ((c != NULL) && ((c)->cache != NULL))
899:
900: typedef struct _xmlXPathContextCache xmlXPathContextCache;
901: typedef xmlXPathContextCache *xmlXPathContextCachePtr;
902: struct _xmlXPathContextCache {
903: xmlPointerListPtr nodesetObjs; /* contains xmlXPathObjectPtr */
904: xmlPointerListPtr stringObjs; /* contains xmlXPathObjectPtr */
905: xmlPointerListPtr booleanObjs; /* contains xmlXPathObjectPtr */
906: xmlPointerListPtr numberObjs; /* contains xmlXPathObjectPtr */
907: xmlPointerListPtr miscObjs; /* contains xmlXPathObjectPtr */
908: int maxNodeset;
909: int maxString;
910: int maxBoolean;
911: int maxNumber;
912: int maxMisc;
913: #ifdef XP_DEBUG_OBJ_USAGE
914: int dbgCachedAll;
915: int dbgCachedNodeset;
916: int dbgCachedString;
917: int dbgCachedBool;
918: int dbgCachedNumber;
919: int dbgCachedPoint;
920: int dbgCachedRange;
921: int dbgCachedLocset;
922: int dbgCachedUsers;
923: int dbgCachedXSLTTree;
924: int dbgCachedUndefined;
925:
926:
927: int dbgReusedAll;
928: int dbgReusedNodeset;
929: int dbgReusedString;
930: int dbgReusedBool;
931: int dbgReusedNumber;
932: int dbgReusedPoint;
933: int dbgReusedRange;
934: int dbgReusedLocset;
935: int dbgReusedUsers;
936: int dbgReusedXSLTTree;
937: int dbgReusedUndefined;
938:
939: #endif
940: };
941:
942: /************************************************************************
943: * *
944: * Debugging related functions *
945: * *
946: ************************************************************************/
947:
948: #define STRANGE \
949: xmlGenericError(xmlGenericErrorContext, \
950: "Internal error at %s:%d\n", \
951: __FILE__, __LINE__);
952:
953: #ifdef LIBXML_DEBUG_ENABLED
954: static void
955: xmlXPathDebugDumpNode(FILE *output, xmlNodePtr cur, int depth) {
956: int i;
957: char shift[100];
958:
959: for (i = 0;((i < depth) && (i < 25));i++)
960: shift[2 * i] = shift[2 * i + 1] = ' ';
961: shift[2 * i] = shift[2 * i + 1] = 0;
962: if (cur == NULL) {
963: fprintf(output, "%s", shift);
964: fprintf(output, "Node is NULL !\n");
965: return;
966:
967: }
968:
969: if ((cur->type == XML_DOCUMENT_NODE) ||
970: (cur->type == XML_HTML_DOCUMENT_NODE)) {
971: fprintf(output, "%s", shift);
972: fprintf(output, " /\n");
973: } else if (cur->type == XML_ATTRIBUTE_NODE)
974: xmlDebugDumpAttr(output, (xmlAttrPtr)cur, depth);
975: else
976: xmlDebugDumpOneNode(output, cur, depth);
977: }
978: static void
979: xmlXPathDebugDumpNodeList(FILE *output, xmlNodePtr cur, int depth) {
980: xmlNodePtr tmp;
981: int i;
982: char shift[100];
983:
984: for (i = 0;((i < depth) && (i < 25));i++)
985: shift[2 * i] = shift[2 * i + 1] = ' ';
986: shift[2 * i] = shift[2 * i + 1] = 0;
987: if (cur == NULL) {
988: fprintf(output, "%s", shift);
989: fprintf(output, "Node is NULL !\n");
990: return;
991:
992: }
993:
994: while (cur != NULL) {
995: tmp = cur;
996: cur = cur->next;
997: xmlDebugDumpOneNode(output, tmp, depth);
998: }
999: }
1000:
1001: static void
1002: xmlXPathDebugDumpNodeSet(FILE *output, xmlNodeSetPtr cur, int depth) {
1003: int i;
1004: char shift[100];
1005:
1006: for (i = 0;((i < depth) && (i < 25));i++)
1007: shift[2 * i] = shift[2 * i + 1] = ' ';
1008: shift[2 * i] = shift[2 * i + 1] = 0;
1009:
1010: if (cur == NULL) {
1011: fprintf(output, "%s", shift);
1012: fprintf(output, "NodeSet is NULL !\n");
1013: return;
1014:
1015: }
1016:
1017: if (cur != NULL) {
1018: fprintf(output, "Set contains %d nodes:\n", cur->nodeNr);
1019: for (i = 0;i < cur->nodeNr;i++) {
1020: fprintf(output, "%s", shift);
1021: fprintf(output, "%d", i + 1);
1022: xmlXPathDebugDumpNode(output, cur->nodeTab[i], depth + 1);
1023: }
1024: }
1025: }
1026:
1027: static void
1028: xmlXPathDebugDumpValueTree(FILE *output, xmlNodeSetPtr cur, int depth) {
1029: int i;
1030: char shift[100];
1031:
1032: for (i = 0;((i < depth) && (i < 25));i++)
1033: shift[2 * i] = shift[2 * i + 1] = ' ';
1034: shift[2 * i] = shift[2 * i + 1] = 0;
1035:
1036: if ((cur == NULL) || (cur->nodeNr == 0) || (cur->nodeTab[0] == NULL)) {
1037: fprintf(output, "%s", shift);
1038: fprintf(output, "Value Tree is NULL !\n");
1039: return;
1040:
1041: }
1042:
1043: fprintf(output, "%s", shift);
1044: fprintf(output, "%d", i + 1);
1045: xmlXPathDebugDumpNodeList(output, cur->nodeTab[0]->children, depth + 1);
1046: }
1047: #if defined(LIBXML_XPTR_ENABLED)
1048: static void
1049: xmlXPathDebugDumpLocationSet(FILE *output, xmlLocationSetPtr cur, int depth) {
1050: int i;
1051: char shift[100];
1052:
1053: for (i = 0;((i < depth) && (i < 25));i++)
1054: shift[2 * i] = shift[2 * i + 1] = ' ';
1055: shift[2 * i] = shift[2 * i + 1] = 0;
1056:
1057: if (cur == NULL) {
1058: fprintf(output, "%s", shift);
1059: fprintf(output, "LocationSet is NULL !\n");
1060: return;
1061:
1062: }
1063:
1064: for (i = 0;i < cur->locNr;i++) {
1065: fprintf(output, "%s", shift);
1066: fprintf(output, "%d : ", i + 1);
1067: xmlXPathDebugDumpObject(output, cur->locTab[i], depth + 1);
1068: }
1069: }
1070: #endif /* LIBXML_XPTR_ENABLED */
1071:
1072: /**
1073: * xmlXPathDebugDumpObject:
1074: * @output: the FILE * to dump the output
1075: * @cur: the object to inspect
1076: * @depth: indentation level
1077: *
1078: * Dump the content of the object for debugging purposes
1079: */
1080: void
1081: xmlXPathDebugDumpObject(FILE *output, xmlXPathObjectPtr cur, int depth) {
1082: int i;
1083: char shift[100];
1084:
1085: if (output == NULL) return;
1086:
1087: for (i = 0;((i < depth) && (i < 25));i++)
1088: shift[2 * i] = shift[2 * i + 1] = ' ';
1089: shift[2 * i] = shift[2 * i + 1] = 0;
1090:
1091:
1092: fprintf(output, "%s", shift);
1093:
1094: if (cur == NULL) {
1095: fprintf(output, "Object is empty (NULL)\n");
1096: return;
1097: }
1098: switch(cur->type) {
1099: case XPATH_UNDEFINED:
1100: fprintf(output, "Object is uninitialized\n");
1101: break;
1102: case XPATH_NODESET:
1103: fprintf(output, "Object is a Node Set :\n");
1104: xmlXPathDebugDumpNodeSet(output, cur->nodesetval, depth);
1105: break;
1106: case XPATH_XSLT_TREE:
1107: fprintf(output, "Object is an XSLT value tree :\n");
1108: xmlXPathDebugDumpValueTree(output, cur->nodesetval, depth);
1109: break;
1110: case XPATH_BOOLEAN:
1111: fprintf(output, "Object is a Boolean : ");
1112: if (cur->boolval) fprintf(output, "true\n");
1113: else fprintf(output, "false\n");
1114: break;
1115: case XPATH_NUMBER:
1116: switch (xmlXPathIsInf(cur->floatval)) {
1117: case 1:
1118: fprintf(output, "Object is a number : Infinity\n");
1119: break;
1120: case -1:
1121: fprintf(output, "Object is a number : -Infinity\n");
1122: break;
1123: default:
1124: if (xmlXPathIsNaN(cur->floatval)) {
1125: fprintf(output, "Object is a number : NaN\n");
1126: } else if (cur->floatval == 0 && xmlXPathGetSign(cur->floatval) != 0) {
1127: fprintf(output, "Object is a number : 0\n");
1128: } else {
1129: fprintf(output, "Object is a number : %0g\n", cur->floatval);
1130: }
1131: }
1132: break;
1133: case XPATH_STRING:
1134: fprintf(output, "Object is a string : ");
1135: xmlDebugDumpString(output, cur->stringval);
1136: fprintf(output, "\n");
1137: break;
1138: case XPATH_POINT:
1139: fprintf(output, "Object is a point : index %d in node", cur->index);
1140: xmlXPathDebugDumpNode(output, (xmlNodePtr) cur->user, depth + 1);
1141: fprintf(output, "\n");
1142: break;
1143: case XPATH_RANGE:
1144: if ((cur->user2 == NULL) ||
1145: ((cur->user2 == cur->user) && (cur->index == cur->index2))) {
1146: fprintf(output, "Object is a collapsed range :\n");
1147: fprintf(output, "%s", shift);
1148: if (cur->index >= 0)
1149: fprintf(output, "index %d in ", cur->index);
1150: fprintf(output, "node\n");
1151: xmlXPathDebugDumpNode(output, (xmlNodePtr) cur->user,
1152: depth + 1);
1153: } else {
1154: fprintf(output, "Object is a range :\n");
1155: fprintf(output, "%s", shift);
1156: fprintf(output, "From ");
1157: if (cur->index >= 0)
1158: fprintf(output, "index %d in ", cur->index);
1159: fprintf(output, "node\n");
1160: xmlXPathDebugDumpNode(output, (xmlNodePtr) cur->user,
1161: depth + 1);
1162: fprintf(output, "%s", shift);
1163: fprintf(output, "To ");
1164: if (cur->index2 >= 0)
1165: fprintf(output, "index %d in ", cur->index2);
1166: fprintf(output, "node\n");
1167: xmlXPathDebugDumpNode(output, (xmlNodePtr) cur->user2,
1168: depth + 1);
1169: fprintf(output, "\n");
1170: }
1171: break;
1172: case XPATH_LOCATIONSET:
1173: #if defined(LIBXML_XPTR_ENABLED)
1174: fprintf(output, "Object is a Location Set:\n");
1175: xmlXPathDebugDumpLocationSet(output,
1176: (xmlLocationSetPtr) cur->user, depth);
1177: #endif
1178: break;
1179: case XPATH_USERS:
1180: fprintf(output, "Object is user defined\n");
1181: break;
1182: }
1183: }
1184:
1185: static void
1186: xmlXPathDebugDumpStepOp(FILE *output, xmlXPathCompExprPtr comp,
1187: xmlXPathStepOpPtr op, int depth) {
1188: int i;
1189: char shift[100];
1190:
1191: for (i = 0;((i < depth) && (i < 25));i++)
1192: shift[2 * i] = shift[2 * i + 1] = ' ';
1193: shift[2 * i] = shift[2 * i + 1] = 0;
1194:
1195: fprintf(output, "%s", shift);
1196: if (op == NULL) {
1197: fprintf(output, "Step is NULL\n");
1198: return;
1199: }
1200: switch (op->op) {
1201: case XPATH_OP_END:
1202: fprintf(output, "END"); break;
1203: case XPATH_OP_AND:
1204: fprintf(output, "AND"); break;
1205: case XPATH_OP_OR:
1206: fprintf(output, "OR"); break;
1207: case XPATH_OP_EQUAL:
1208: if (op->value)
1209: fprintf(output, "EQUAL =");
1210: else
1211: fprintf(output, "EQUAL !=");
1212: break;
1213: case XPATH_OP_CMP:
1214: if (op->value)
1215: fprintf(output, "CMP <");
1216: else
1217: fprintf(output, "CMP >");
1218: if (!op->value2)
1219: fprintf(output, "=");
1220: break;
1221: case XPATH_OP_PLUS:
1222: if (op->value == 0)
1223: fprintf(output, "PLUS -");
1224: else if (op->value == 1)
1225: fprintf(output, "PLUS +");
1226: else if (op->value == 2)
1227: fprintf(output, "PLUS unary -");
1228: else if (op->value == 3)
1229: fprintf(output, "PLUS unary - -");
1230: break;
1231: case XPATH_OP_MULT:
1232: if (op->value == 0)
1233: fprintf(output, "MULT *");
1234: else if (op->value == 1)
1235: fprintf(output, "MULT div");
1236: else
1237: fprintf(output, "MULT mod");
1238: break;
1239: case XPATH_OP_UNION:
1240: fprintf(output, "UNION"); break;
1241: case XPATH_OP_ROOT:
1242: fprintf(output, "ROOT"); break;
1243: case XPATH_OP_NODE:
1244: fprintf(output, "NODE"); break;
1245: case XPATH_OP_RESET:
1246: fprintf(output, "RESET"); break;
1247: case XPATH_OP_SORT:
1248: fprintf(output, "SORT"); break;
1249: case XPATH_OP_COLLECT: {
1250: xmlXPathAxisVal axis = (xmlXPathAxisVal)op->value;
1251: xmlXPathTestVal test = (xmlXPathTestVal)op->value2;
1252: xmlXPathTypeVal type = (xmlXPathTypeVal)op->value3;
1253: const xmlChar *prefix = op->value4;
1254: const xmlChar *name = op->value5;
1255:
1256: fprintf(output, "COLLECT ");
1257: switch (axis) {
1258: case AXIS_ANCESTOR:
1259: fprintf(output, " 'ancestors' "); break;
1260: case AXIS_ANCESTOR_OR_SELF:
1261: fprintf(output, " 'ancestors-or-self' "); break;
1262: case AXIS_ATTRIBUTE:
1263: fprintf(output, " 'attributes' "); break;
1264: case AXIS_CHILD:
1265: fprintf(output, " 'child' "); break;
1266: case AXIS_DESCENDANT:
1267: fprintf(output, " 'descendant' "); break;
1268: case AXIS_DESCENDANT_OR_SELF:
1269: fprintf(output, " 'descendant-or-self' "); break;
1270: case AXIS_FOLLOWING:
1271: fprintf(output, " 'following' "); break;
1272: case AXIS_FOLLOWING_SIBLING:
1273: fprintf(output, " 'following-siblings' "); break;
1274: case AXIS_NAMESPACE:
1275: fprintf(output, " 'namespace' "); break;
1276: case AXIS_PARENT:
1277: fprintf(output, " 'parent' "); break;
1278: case AXIS_PRECEDING:
1279: fprintf(output, " 'preceding' "); break;
1280: case AXIS_PRECEDING_SIBLING:
1281: fprintf(output, " 'preceding-sibling' "); break;
1282: case AXIS_SELF:
1283: fprintf(output, " 'self' "); break;
1284: }
1285: switch (test) {
1286: case NODE_TEST_NONE:
1287: fprintf(output, "'none' "); break;
1288: case NODE_TEST_TYPE:
1289: fprintf(output, "'type' "); break;
1290: case NODE_TEST_PI:
1291: fprintf(output, "'PI' "); break;
1292: case NODE_TEST_ALL:
1293: fprintf(output, "'all' "); break;
1294: case NODE_TEST_NS:
1295: fprintf(output, "'namespace' "); break;
1296: case NODE_TEST_NAME:
1297: fprintf(output, "'name' "); break;
1298: }
1299: switch (type) {
1300: case NODE_TYPE_NODE:
1301: fprintf(output, "'node' "); break;
1302: case NODE_TYPE_COMMENT:
1303: fprintf(output, "'comment' "); break;
1304: case NODE_TYPE_TEXT:
1305: fprintf(output, "'text' "); break;
1306: case NODE_TYPE_PI:
1307: fprintf(output, "'PI' "); break;
1308: }
1309: if (prefix != NULL)
1310: fprintf(output, "%s:", prefix);
1311: if (name != NULL)
1312: fprintf(output, "%s", (const char *) name);
1313: break;
1314:
1315: }
1316: case XPATH_OP_VALUE: {
1317: xmlXPathObjectPtr object = (xmlXPathObjectPtr) op->value4;
1318:
1319: fprintf(output, "ELEM ");
1320: xmlXPathDebugDumpObject(output, object, 0);
1321: goto finish;
1322: }
1323: case XPATH_OP_VARIABLE: {
1324: const xmlChar *prefix = op->value5;
1325: const xmlChar *name = op->value4;
1326:
1327: if (prefix != NULL)
1328: fprintf(output, "VARIABLE %s:%s", prefix, name);
1329: else
1330: fprintf(output, "VARIABLE %s", name);
1331: break;
1332: }
1333: case XPATH_OP_FUNCTION: {
1334: int nbargs = op->value;
1335: const xmlChar *prefix = op->value5;
1336: const xmlChar *name = op->value4;
1337:
1338: if (prefix != NULL)
1339: fprintf(output, "FUNCTION %s:%s(%d args)",
1340: prefix, name, nbargs);
1341: else
1342: fprintf(output, "FUNCTION %s(%d args)", name, nbargs);
1343: break;
1344: }
1345: case XPATH_OP_ARG: fprintf(output, "ARG"); break;
1346: case XPATH_OP_PREDICATE: fprintf(output, "PREDICATE"); break;
1347: case XPATH_OP_FILTER: fprintf(output, "FILTER"); break;
1348: #ifdef LIBXML_XPTR_ENABLED
1349: case XPATH_OP_RANGETO: fprintf(output, "RANGETO"); break;
1350: #endif
1351: default:
1352: fprintf(output, "UNKNOWN %d\n", op->op); return;
1353: }
1354: fprintf(output, "\n");
1355: finish:
1356: if (op->ch1 >= 0)
1357: xmlXPathDebugDumpStepOp(output, comp, &comp->steps[op->ch1], depth + 1);
1358: if (op->ch2 >= 0)
1359: xmlXPathDebugDumpStepOp(output, comp, &comp->steps[op->ch2], depth + 1);
1360: }
1361:
1362: /**
1363: * xmlXPathDebugDumpCompExpr:
1364: * @output: the FILE * for the output
1365: * @comp: the precompiled XPath expression
1366: * @depth: the indentation level.
1367: *
1368: * Dumps the tree of the compiled XPath expression.
1369: */
1370: void
1371: xmlXPathDebugDumpCompExpr(FILE *output, xmlXPathCompExprPtr comp,
1372: int depth) {
1373: int i;
1374: char shift[100];
1375:
1376: if ((output == NULL) || (comp == NULL)) return;
1377:
1378: for (i = 0;((i < depth) && (i < 25));i++)
1379: shift[2 * i] = shift[2 * i + 1] = ' ';
1380: shift[2 * i] = shift[2 * i + 1] = 0;
1381:
1382: fprintf(output, "%s", shift);
1383:
1384: fprintf(output, "Compiled Expression : %d elements\n",
1385: comp->nbStep);
1386: i = comp->last;
1387: xmlXPathDebugDumpStepOp(output, comp, &comp->steps[i], depth + 1);
1388: }
1389:
1390: #ifdef XP_DEBUG_OBJ_USAGE
1391:
1392: /*
1393: * XPath object usage related debugging variables.
1394: */
1395: static int xmlXPathDebugObjCounterUndefined = 0;
1396: static int xmlXPathDebugObjCounterNodeset = 0;
1397: static int xmlXPathDebugObjCounterBool = 0;
1398: static int xmlXPathDebugObjCounterNumber = 0;
1399: static int xmlXPathDebugObjCounterString = 0;
1400: static int xmlXPathDebugObjCounterPoint = 0;
1401: static int xmlXPathDebugObjCounterRange = 0;
1402: static int xmlXPathDebugObjCounterLocset = 0;
1403: static int xmlXPathDebugObjCounterUsers = 0;
1404: static int xmlXPathDebugObjCounterXSLTTree = 0;
1405: static int xmlXPathDebugObjCounterAll = 0;
1406:
1407: static int xmlXPathDebugObjTotalUndefined = 0;
1408: static int xmlXPathDebugObjTotalNodeset = 0;
1409: static int xmlXPathDebugObjTotalBool = 0;
1410: static int xmlXPathDebugObjTotalNumber = 0;
1411: static int xmlXPathDebugObjTotalString = 0;
1412: static int xmlXPathDebugObjTotalPoint = 0;
1413: static int xmlXPathDebugObjTotalRange = 0;
1414: static int xmlXPathDebugObjTotalLocset = 0;
1415: static int xmlXPathDebugObjTotalUsers = 0;
1416: static int xmlXPathDebugObjTotalXSLTTree = 0;
1417: static int xmlXPathDebugObjTotalAll = 0;
1418:
1419: static int xmlXPathDebugObjMaxUndefined = 0;
1420: static int xmlXPathDebugObjMaxNodeset = 0;
1421: static int xmlXPathDebugObjMaxBool = 0;
1422: static int xmlXPathDebugObjMaxNumber = 0;
1423: static int xmlXPathDebugObjMaxString = 0;
1424: static int xmlXPathDebugObjMaxPoint = 0;
1425: static int xmlXPathDebugObjMaxRange = 0;
1426: static int xmlXPathDebugObjMaxLocset = 0;
1427: static int xmlXPathDebugObjMaxUsers = 0;
1428: static int xmlXPathDebugObjMaxXSLTTree = 0;
1429: static int xmlXPathDebugObjMaxAll = 0;
1430:
1431: /* REVISIT TODO: Make this static when committing */
1432: static void
1433: xmlXPathDebugObjUsageReset(xmlXPathContextPtr ctxt)
1434: {
1435: if (ctxt != NULL) {
1436: if (ctxt->cache != NULL) {
1437: xmlXPathContextCachePtr cache =
1438: (xmlXPathContextCachePtr) ctxt->cache;
1439:
1440: cache->dbgCachedAll = 0;
1441: cache->dbgCachedNodeset = 0;
1442: cache->dbgCachedString = 0;
1443: cache->dbgCachedBool = 0;
1444: cache->dbgCachedNumber = 0;
1445: cache->dbgCachedPoint = 0;
1446: cache->dbgCachedRange = 0;
1447: cache->dbgCachedLocset = 0;
1448: cache->dbgCachedUsers = 0;
1449: cache->dbgCachedXSLTTree = 0;
1450: cache->dbgCachedUndefined = 0;
1451:
1452: cache->dbgReusedAll = 0;
1453: cache->dbgReusedNodeset = 0;
1454: cache->dbgReusedString = 0;
1455: cache->dbgReusedBool = 0;
1456: cache->dbgReusedNumber = 0;
1457: cache->dbgReusedPoint = 0;
1458: cache->dbgReusedRange = 0;
1459: cache->dbgReusedLocset = 0;
1460: cache->dbgReusedUsers = 0;
1461: cache->dbgReusedXSLTTree = 0;
1462: cache->dbgReusedUndefined = 0;
1463: }
1464: }
1465:
1466: xmlXPathDebugObjCounterUndefined = 0;
1467: xmlXPathDebugObjCounterNodeset = 0;
1468: xmlXPathDebugObjCounterBool = 0;
1469: xmlXPathDebugObjCounterNumber = 0;
1470: xmlXPathDebugObjCounterString = 0;
1471: xmlXPathDebugObjCounterPoint = 0;
1472: xmlXPathDebugObjCounterRange = 0;
1473: xmlXPathDebugObjCounterLocset = 0;
1474: xmlXPathDebugObjCounterUsers = 0;
1475: xmlXPathDebugObjCounterXSLTTree = 0;
1476: xmlXPathDebugObjCounterAll = 0;
1477:
1478: xmlXPathDebugObjTotalUndefined = 0;
1479: xmlXPathDebugObjTotalNodeset = 0;
1480: xmlXPathDebugObjTotalBool = 0;
1481: xmlXPathDebugObjTotalNumber = 0;
1482: xmlXPathDebugObjTotalString = 0;
1483: xmlXPathDebugObjTotalPoint = 0;
1484: xmlXPathDebugObjTotalRange = 0;
1485: xmlXPathDebugObjTotalLocset = 0;
1486: xmlXPathDebugObjTotalUsers = 0;
1487: xmlXPathDebugObjTotalXSLTTree = 0;
1488: xmlXPathDebugObjTotalAll = 0;
1489:
1490: xmlXPathDebugObjMaxUndefined = 0;
1491: xmlXPathDebugObjMaxNodeset = 0;
1492: xmlXPathDebugObjMaxBool = 0;
1493: xmlXPathDebugObjMaxNumber = 0;
1494: xmlXPathDebugObjMaxString = 0;
1495: xmlXPathDebugObjMaxPoint = 0;
1496: xmlXPathDebugObjMaxRange = 0;
1497: xmlXPathDebugObjMaxLocset = 0;
1498: xmlXPathDebugObjMaxUsers = 0;
1499: xmlXPathDebugObjMaxXSLTTree = 0;
1500: xmlXPathDebugObjMaxAll = 0;
1501:
1502: }
1503:
1504: static void
1505: xmlXPathDebugObjUsageRequested(xmlXPathContextPtr ctxt,
1506: xmlXPathObjectType objType)
1507: {
1508: int isCached = 0;
1509:
1510: if (ctxt != NULL) {
1511: if (ctxt->cache != NULL) {
1512: xmlXPathContextCachePtr cache =
1513: (xmlXPathContextCachePtr) ctxt->cache;
1514:
1515: isCached = 1;
1516:
1517: cache->dbgReusedAll++;
1518: switch (objType) {
1519: case XPATH_UNDEFINED:
1520: cache->dbgReusedUndefined++;
1521: break;
1522: case XPATH_NODESET:
1523: cache->dbgReusedNodeset++;
1524: break;
1525: case XPATH_BOOLEAN:
1526: cache->dbgReusedBool++;
1527: break;
1528: case XPATH_NUMBER:
1529: cache->dbgReusedNumber++;
1530: break;
1531: case XPATH_STRING:
1532: cache->dbgReusedString++;
1533: break;
1534: case XPATH_POINT:
1535: cache->dbgReusedPoint++;
1536: break;
1537: case XPATH_RANGE:
1538: cache->dbgReusedRange++;
1539: break;
1540: case XPATH_LOCATIONSET:
1541: cache->dbgReusedLocset++;
1542: break;
1543: case XPATH_USERS:
1544: cache->dbgReusedUsers++;
1545: break;
1546: case XPATH_XSLT_TREE:
1547: cache->dbgReusedXSLTTree++;
1548: break;
1549: default:
1550: break;
1551: }
1552: }
1553: }
1554:
1555: switch (objType) {
1556: case XPATH_UNDEFINED:
1557: if (! isCached)
1558: xmlXPathDebugObjTotalUndefined++;
1559: xmlXPathDebugObjCounterUndefined++;
1560: if (xmlXPathDebugObjCounterUndefined >
1561: xmlXPathDebugObjMaxUndefined)
1562: xmlXPathDebugObjMaxUndefined =
1563: xmlXPathDebugObjCounterUndefined;
1564: break;
1565: case XPATH_NODESET:
1566: if (! isCached)
1567: xmlXPathDebugObjTotalNodeset++;
1568: xmlXPathDebugObjCounterNodeset++;
1569: if (xmlXPathDebugObjCounterNodeset >
1570: xmlXPathDebugObjMaxNodeset)
1571: xmlXPathDebugObjMaxNodeset =
1572: xmlXPathDebugObjCounterNodeset;
1573: break;
1574: case XPATH_BOOLEAN:
1575: if (! isCached)
1576: xmlXPathDebugObjTotalBool++;
1577: xmlXPathDebugObjCounterBool++;
1578: if (xmlXPathDebugObjCounterBool >
1579: xmlXPathDebugObjMaxBool)
1580: xmlXPathDebugObjMaxBool =
1581: xmlXPathDebugObjCounterBool;
1582: break;
1583: case XPATH_NUMBER:
1584: if (! isCached)
1585: xmlXPathDebugObjTotalNumber++;
1586: xmlXPathDebugObjCounterNumber++;
1587: if (xmlXPathDebugObjCounterNumber >
1588: xmlXPathDebugObjMaxNumber)
1589: xmlXPathDebugObjMaxNumber =
1590: xmlXPathDebugObjCounterNumber;
1591: break;
1592: case XPATH_STRING:
1593: if (! isCached)
1594: xmlXPathDebugObjTotalString++;
1595: xmlXPathDebugObjCounterString++;
1596: if (xmlXPathDebugObjCounterString >
1597: xmlXPathDebugObjMaxString)
1598: xmlXPathDebugObjMaxString =
1599: xmlXPathDebugObjCounterString;
1600: break;
1601: case XPATH_POINT:
1602: if (! isCached)
1603: xmlXPathDebugObjTotalPoint++;
1604: xmlXPathDebugObjCounterPoint++;
1605: if (xmlXPathDebugObjCounterPoint >
1606: xmlXPathDebugObjMaxPoint)
1607: xmlXPathDebugObjMaxPoint =
1608: xmlXPathDebugObjCounterPoint;
1609: break;
1610: case XPATH_RANGE:
1611: if (! isCached)
1612: xmlXPathDebugObjTotalRange++;
1613: xmlXPathDebugObjCounterRange++;
1614: if (xmlXPathDebugObjCounterRange >
1615: xmlXPathDebugObjMaxRange)
1616: xmlXPathDebugObjMaxRange =
1617: xmlXPathDebugObjCounterRange;
1618: break;
1619: case XPATH_LOCATIONSET:
1620: if (! isCached)
1621: xmlXPathDebugObjTotalLocset++;
1622: xmlXPathDebugObjCounterLocset++;
1623: if (xmlXPathDebugObjCounterLocset >
1624: xmlXPathDebugObjMaxLocset)
1625: xmlXPathDebugObjMaxLocset =
1626: xmlXPathDebugObjCounterLocset;
1627: break;
1628: case XPATH_USERS:
1629: if (! isCached)
1630: xmlXPathDebugObjTotalUsers++;
1631: xmlXPathDebugObjCounterUsers++;
1632: if (xmlXPathDebugObjCounterUsers >
1633: xmlXPathDebugObjMaxUsers)
1634: xmlXPathDebugObjMaxUsers =
1635: xmlXPathDebugObjCounterUsers;
1636: break;
1637: case XPATH_XSLT_TREE:
1638: if (! isCached)
1639: xmlXPathDebugObjTotalXSLTTree++;
1640: xmlXPathDebugObjCounterXSLTTree++;
1641: if (xmlXPathDebugObjCounterXSLTTree >
1642: xmlXPathDebugObjMaxXSLTTree)
1643: xmlXPathDebugObjMaxXSLTTree =
1644: xmlXPathDebugObjCounterXSLTTree;
1645: break;
1646: default:
1647: break;
1648: }
1649: if (! isCached)
1650: xmlXPathDebugObjTotalAll++;
1651: xmlXPathDebugObjCounterAll++;
1652: if (xmlXPathDebugObjCounterAll >
1653: xmlXPathDebugObjMaxAll)
1654: xmlXPathDebugObjMaxAll =
1655: xmlXPathDebugObjCounterAll;
1656: }
1657:
1658: static void
1659: xmlXPathDebugObjUsageReleased(xmlXPathContextPtr ctxt,
1660: xmlXPathObjectType objType)
1661: {
1662: int isCached = 0;
1663:
1664: if (ctxt != NULL) {
1665: if (ctxt->cache != NULL) {
1666: xmlXPathContextCachePtr cache =
1667: (xmlXPathContextCachePtr) ctxt->cache;
1668:
1669: isCached = 1;
1670:
1671: cache->dbgCachedAll++;
1672: switch (objType) {
1673: case XPATH_UNDEFINED:
1674: cache->dbgCachedUndefined++;
1675: break;
1676: case XPATH_NODESET:
1677: cache->dbgCachedNodeset++;
1678: break;
1679: case XPATH_BOOLEAN:
1680: cache->dbgCachedBool++;
1681: break;
1682: case XPATH_NUMBER:
1683: cache->dbgCachedNumber++;
1684: break;
1685: case XPATH_STRING:
1686: cache->dbgCachedString++;
1687: break;
1688: case XPATH_POINT:
1689: cache->dbgCachedPoint++;
1690: break;
1691: case XPATH_RANGE:
1692: cache->dbgCachedRange++;
1693: break;
1694: case XPATH_LOCATIONSET:
1695: cache->dbgCachedLocset++;
1696: break;
1697: case XPATH_USERS:
1698: cache->dbgCachedUsers++;
1699: break;
1700: case XPATH_XSLT_TREE:
1701: cache->dbgCachedXSLTTree++;
1702: break;
1703: default:
1704: break;
1705: }
1706:
1707: }
1708: }
1709: switch (objType) {
1710: case XPATH_UNDEFINED:
1711: xmlXPathDebugObjCounterUndefined--;
1712: break;
1713: case XPATH_NODESET:
1714: xmlXPathDebugObjCounterNodeset--;
1715: break;
1716: case XPATH_BOOLEAN:
1717: xmlXPathDebugObjCounterBool--;
1718: break;
1719: case XPATH_NUMBER:
1720: xmlXPathDebugObjCounterNumber--;
1721: break;
1722: case XPATH_STRING:
1723: xmlXPathDebugObjCounterString--;
1724: break;
1725: case XPATH_POINT:
1726: xmlXPathDebugObjCounterPoint--;
1727: break;
1728: case XPATH_RANGE:
1729: xmlXPathDebugObjCounterRange--;
1730: break;
1731: case XPATH_LOCATIONSET:
1732: xmlXPathDebugObjCounterLocset--;
1733: break;
1734: case XPATH_USERS:
1735: xmlXPathDebugObjCounterUsers--;
1736: break;
1737: case XPATH_XSLT_TREE:
1738: xmlXPathDebugObjCounterXSLTTree--;
1739: break;
1740: default:
1741: break;
1742: }
1743: xmlXPathDebugObjCounterAll--;
1744: }
1745:
1746: /* REVISIT TODO: Make this static when committing */
1747: static void
1748: xmlXPathDebugObjUsageDisplay(xmlXPathContextPtr ctxt)
1749: {
1750: int reqAll, reqNodeset, reqString, reqBool, reqNumber,
1751: reqXSLTTree, reqUndefined;
1752: int caAll = 0, caNodeset = 0, caString = 0, caBool = 0,
1753: caNumber = 0, caXSLTTree = 0, caUndefined = 0;
1754: int reAll = 0, reNodeset = 0, reString = 0, reBool = 0,
1755: reNumber = 0, reXSLTTree = 0, reUndefined = 0;
1756: int leftObjs = xmlXPathDebugObjCounterAll;
1757:
1758: reqAll = xmlXPathDebugObjTotalAll;
1759: reqNodeset = xmlXPathDebugObjTotalNodeset;
1760: reqString = xmlXPathDebugObjTotalString;
1761: reqBool = xmlXPathDebugObjTotalBool;
1762: reqNumber = xmlXPathDebugObjTotalNumber;
1763: reqXSLTTree = xmlXPathDebugObjTotalXSLTTree;
1764: reqUndefined = xmlXPathDebugObjTotalUndefined;
1765:
1766: printf("# XPath object usage:\n");
1767:
1768: if (ctxt != NULL) {
1769: if (ctxt->cache != NULL) {
1770: xmlXPathContextCachePtr cache =
1771: (xmlXPathContextCachePtr) ctxt->cache;
1772:
1773: reAll = cache->dbgReusedAll;
1774: reqAll += reAll;
1775: reNodeset = cache->dbgReusedNodeset;
1776: reqNodeset += reNodeset;
1777: reString = cache->dbgReusedString;
1778: reqString += reString;
1779: reBool = cache->dbgReusedBool;
1780: reqBool += reBool;
1781: reNumber = cache->dbgReusedNumber;
1782: reqNumber += reNumber;
1783: reXSLTTree = cache->dbgReusedXSLTTree;
1784: reqXSLTTree += reXSLTTree;
1785: reUndefined = cache->dbgReusedUndefined;
1786: reqUndefined += reUndefined;
1787:
1788: caAll = cache->dbgCachedAll;
1789: caBool = cache->dbgCachedBool;
1790: caNodeset = cache->dbgCachedNodeset;
1791: caString = cache->dbgCachedString;
1792: caNumber = cache->dbgCachedNumber;
1793: caXSLTTree = cache->dbgCachedXSLTTree;
1794: caUndefined = cache->dbgCachedUndefined;
1795:
1796: if (cache->nodesetObjs)
1797: leftObjs -= cache->nodesetObjs->number;
1798: if (cache->stringObjs)
1799: leftObjs -= cache->stringObjs->number;
1800: if (cache->booleanObjs)
1801: leftObjs -= cache->booleanObjs->number;
1802: if (cache->numberObjs)
1803: leftObjs -= cache->numberObjs->number;
1804: if (cache->miscObjs)
1805: leftObjs -= cache->miscObjs->number;
1806: }
1807: }
1808:
1809: printf("# all\n");
1810: printf("# total : %d\n", reqAll);
1811: printf("# left : %d\n", leftObjs);
1812: printf("# created: %d\n", xmlXPathDebugObjTotalAll);
1813: printf("# reused : %d\n", reAll);
1814: printf("# max : %d\n", xmlXPathDebugObjMaxAll);
1815:
1816: printf("# node-sets\n");
1817: printf("# total : %d\n", reqNodeset);
1818: printf("# created: %d\n", xmlXPathDebugObjTotalNodeset);
1819: printf("# reused : %d\n", reNodeset);
1820: printf("# max : %d\n", xmlXPathDebugObjMaxNodeset);
1821:
1822: printf("# strings\n");
1823: printf("# total : %d\n", reqString);
1824: printf("# created: %d\n", xmlXPathDebugObjTotalString);
1825: printf("# reused : %d\n", reString);
1826: printf("# max : %d\n", xmlXPathDebugObjMaxString);
1827:
1828: printf("# booleans\n");
1829: printf("# total : %d\n", reqBool);
1830: printf("# created: %d\n", xmlXPathDebugObjTotalBool);
1831: printf("# reused : %d\n", reBool);
1832: printf("# max : %d\n", xmlXPathDebugObjMaxBool);
1833:
1834: printf("# numbers\n");
1835: printf("# total : %d\n", reqNumber);
1836: printf("# created: %d\n", xmlXPathDebugObjTotalNumber);
1837: printf("# reused : %d\n", reNumber);
1838: printf("# max : %d\n", xmlXPathDebugObjMaxNumber);
1839:
1840: printf("# XSLT result tree fragments\n");
1841: printf("# total : %d\n", reqXSLTTree);
1842: printf("# created: %d\n", xmlXPathDebugObjTotalXSLTTree);
1843: printf("# reused : %d\n", reXSLTTree);
1844: printf("# max : %d\n", xmlXPathDebugObjMaxXSLTTree);
1845:
1846: printf("# undefined\n");
1847: printf("# total : %d\n", reqUndefined);
1848: printf("# created: %d\n", xmlXPathDebugObjTotalUndefined);
1849: printf("# reused : %d\n", reUndefined);
1850: printf("# max : %d\n", xmlXPathDebugObjMaxUndefined);
1851:
1852: }
1853:
1854: #endif /* XP_DEBUG_OBJ_USAGE */
1855:
1856: #endif /* LIBXML_DEBUG_ENABLED */
1857:
1858: /************************************************************************
1859: * *
1860: * XPath object caching *
1861: * *
1862: ************************************************************************/
1863:
1864: /**
1865: * xmlXPathNewCache:
1866: *
1867: * Create a new object cache
1868: *
1869: * Returns the xmlXPathCache just allocated.
1870: */
1871: static xmlXPathContextCachePtr
1872: xmlXPathNewCache(void)
1873: {
1874: xmlXPathContextCachePtr ret;
1875:
1876: ret = (xmlXPathContextCachePtr) xmlMalloc(sizeof(xmlXPathContextCache));
1877: if (ret == NULL) {
1878: xmlXPathErrMemory(NULL, "creating object cache\n");
1879: return(NULL);
1880: }
1881: memset(ret, 0 , (size_t) sizeof(xmlXPathContextCache));
1882: ret->maxNodeset = 100;
1883: ret->maxString = 100;
1884: ret->maxBoolean = 100;
1885: ret->maxNumber = 100;
1886: ret->maxMisc = 100;
1887: return(ret);
1888: }
1889:
1890: static void
1891: xmlXPathCacheFreeObjectList(xmlPointerListPtr list)
1892: {
1893: int i;
1894: xmlXPathObjectPtr obj;
1895:
1896: if (list == NULL)
1897: return;
1898:
1899: for (i = 0; i < list->number; i++) {
1900: obj = list->items[i];
1901: /*
1902: * Note that it is already assured that we don't need to
1903: * look out for namespace nodes in the node-set.
1904: */
1905: if (obj->nodesetval != NULL) {
1906: if (obj->nodesetval->nodeTab != NULL)
1907: xmlFree(obj->nodesetval->nodeTab);
1908: xmlFree(obj->nodesetval);
1909: }
1910: xmlFree(obj);
1911: #ifdef XP_DEBUG_OBJ_USAGE
1912: xmlXPathDebugObjCounterAll--;
1913: #endif
1914: }
1915: xmlPointerListFree(list);
1916: }
1917:
1918: static void
1919: xmlXPathFreeCache(xmlXPathContextCachePtr cache)
1920: {
1921: if (cache == NULL)
1922: return;
1923: if (cache->nodesetObjs)
1924: xmlXPathCacheFreeObjectList(cache->nodesetObjs);
1925: if (cache->stringObjs)
1926: xmlXPathCacheFreeObjectList(cache->stringObjs);
1927: if (cache->booleanObjs)
1928: xmlXPathCacheFreeObjectList(cache->booleanObjs);
1929: if (cache->numberObjs)
1930: xmlXPathCacheFreeObjectList(cache->numberObjs);
1931: if (cache->miscObjs)
1932: xmlXPathCacheFreeObjectList(cache->miscObjs);
1933: xmlFree(cache);
1934: }
1935:
1936: /**
1937: * xmlXPathContextSetCache:
1938: *
1939: * @ctxt: the XPath context
1940: * @active: enables/disables (creates/frees) the cache
1941: * @value: a value with semantics dependant on @options
1942: * @options: options (currently only the value 0 is used)
1943: *
1944: * Creates/frees an object cache on the XPath context.
1945: * If activates XPath objects (xmlXPathObject) will be cached internally
1946: * to be reused.
1947: * @options:
1948: * 0: This will set the XPath object caching:
1949: * @value:
1950: * This will set the maximum number of XPath objects
1951: * to be cached per slot
1952: * There are 5 slots for: node-set, string, number, boolean, and
1953: * misc objects. Use <0 for the default number (100).
1954: * Other values for @options have currently no effect.
1955: *
1956: * Returns 0 if the setting succeeded, and -1 on API or internal errors.
1957: */
1958: int
1959: xmlXPathContextSetCache(xmlXPathContextPtr ctxt,
1960: int active,
1961: int value,
1962: int options)
1963: {
1964: if (ctxt == NULL)
1965: return(-1);
1966: if (active) {
1967: xmlXPathContextCachePtr cache;
1968:
1969: if (ctxt->cache == NULL) {
1970: ctxt->cache = xmlXPathNewCache();
1971: if (ctxt->cache == NULL)
1972: return(-1);
1973: }
1974: cache = (xmlXPathContextCachePtr) ctxt->cache;
1975: if (options == 0) {
1976: if (value < 0)
1977: value = 100;
1978: cache->maxNodeset = value;
1979: cache->maxString = value;
1980: cache->maxNumber = value;
1981: cache->maxBoolean = value;
1982: cache->maxMisc = value;
1983: }
1984: } else if (ctxt->cache != NULL) {
1985: xmlXPathFreeCache((xmlXPathContextCachePtr) ctxt->cache);
1986: ctxt->cache = NULL;
1987: }
1988: return(0);
1989: }
1990:
1991: /**
1992: * xmlXPathCacheWrapNodeSet:
1993: * @ctxt: the XPath context
1994: * @val: the NodePtr value
1995: *
1996: * This is the cached version of xmlXPathWrapNodeSet().
1997: * Wrap the Nodeset @val in a new xmlXPathObjectPtr
1998: *
1999: * Returns the created or reused object.
2000: */
2001: static xmlXPathObjectPtr
2002: xmlXPathCacheWrapNodeSet(xmlXPathContextPtr ctxt, xmlNodeSetPtr val)
2003: {
2004: if ((ctxt != NULL) && (ctxt->cache != NULL)) {
2005: xmlXPathContextCachePtr cache =
2006: (xmlXPathContextCachePtr) ctxt->cache;
2007:
2008: if ((cache->miscObjs != NULL) &&
2009: (cache->miscObjs->number != 0))
2010: {
2011: xmlXPathObjectPtr ret;
2012:
2013: ret = (xmlXPathObjectPtr)
2014: cache->miscObjs->items[--cache->miscObjs->number];
2015: ret->type = XPATH_NODESET;
2016: ret->nodesetval = val;
2017: #ifdef XP_DEBUG_OBJ_USAGE
2018: xmlXPathDebugObjUsageRequested(ctxt, XPATH_NODESET);
2019: #endif
2020: return(ret);
2021: }
2022: }
2023:
2024: return(xmlXPathWrapNodeSet(val));
2025:
2026: }
2027:
2028: /**
2029: * xmlXPathCacheWrapString:
2030: * @ctxt: the XPath context
2031: * @val: the xmlChar * value
2032: *
2033: * This is the cached version of xmlXPathWrapString().
2034: * Wraps the @val string into an XPath object.
2035: *
2036: * Returns the created or reused object.
2037: */
2038: static xmlXPathObjectPtr
2039: xmlXPathCacheWrapString(xmlXPathContextPtr ctxt, xmlChar *val)
2040: {
2041: if ((ctxt != NULL) && (ctxt->cache != NULL)) {
2042: xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache;
2043:
2044: if ((cache->stringObjs != NULL) &&
2045: (cache->stringObjs->number != 0))
2046: {
2047:
2048: xmlXPathObjectPtr ret;
2049:
2050: ret = (xmlXPathObjectPtr)
2051: cache->stringObjs->items[--cache->stringObjs->number];
2052: ret->type = XPATH_STRING;
2053: ret->stringval = val;
2054: #ifdef XP_DEBUG_OBJ_USAGE
2055: xmlXPathDebugObjUsageRequested(ctxt, XPATH_STRING);
2056: #endif
2057: return(ret);
2058: } else if ((cache->miscObjs != NULL) &&
2059: (cache->miscObjs->number != 0))
2060: {
2061: xmlXPathObjectPtr ret;
2062: /*
2063: * Fallback to misc-cache.
2064: */
2065: ret = (xmlXPathObjectPtr)
2066: cache->miscObjs->items[--cache->miscObjs->number];
2067:
2068: ret->type = XPATH_STRING;
2069: ret->stringval = val;
2070: #ifdef XP_DEBUG_OBJ_USAGE
2071: xmlXPathDebugObjUsageRequested(ctxt, XPATH_STRING);
2072: #endif
2073: return(ret);
2074: }
2075: }
2076: return(xmlXPathWrapString(val));
2077: }
2078:
2079: /**
2080: * xmlXPathCacheNewNodeSet:
2081: * @ctxt: the XPath context
2082: * @val: the NodePtr value
2083: *
2084: * This is the cached version of xmlXPathNewNodeSet().
2085: * Acquire an xmlXPathObjectPtr of type NodeSet and initialize
2086: * it with the single Node @val
2087: *
2088: * Returns the created or reused object.
2089: */
2090: static xmlXPathObjectPtr
2091: xmlXPathCacheNewNodeSet(xmlXPathContextPtr ctxt, xmlNodePtr val)
2092: {
2093: if ((ctxt != NULL) && (ctxt->cache)) {
2094: xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache;
2095:
2096: if ((cache->nodesetObjs != NULL) &&
2097: (cache->nodesetObjs->number != 0))
2098: {
2099: xmlXPathObjectPtr ret;
2100: /*
2101: * Use the nodset-cache.
2102: */
2103: ret = (xmlXPathObjectPtr)
2104: cache->nodesetObjs->items[--cache->nodesetObjs->number];
2105: ret->type = XPATH_NODESET;
2106: ret->boolval = 0;
2107: if (val) {
2108: if ((ret->nodesetval->nodeMax == 0) ||
2109: (val->type == XML_NAMESPACE_DECL))
2110: {
2111: xmlXPathNodeSetAddUnique(ret->nodesetval, val);
2112: } else {
2113: ret->nodesetval->nodeTab[0] = val;
2114: ret->nodesetval->nodeNr = 1;
2115: }
2116: }
2117: #ifdef XP_DEBUG_OBJ_USAGE
2118: xmlXPathDebugObjUsageRequested(ctxt, XPATH_NODESET);
2119: #endif
2120: return(ret);
2121: } else if ((cache->miscObjs != NULL) &&
2122: (cache->miscObjs->number != 0))
2123: {
2124: xmlXPathObjectPtr ret;
2125: /*
2126: * Fallback to misc-cache.
2127: */
2128:
2129: ret = (xmlXPathObjectPtr)
2130: cache->miscObjs->items[--cache->miscObjs->number];
2131:
2132: ret->type = XPATH_NODESET;
2133: ret->boolval = 0;
2134: ret->nodesetval = xmlXPathNodeSetCreate(val);
2135: if (ret->nodesetval == NULL) {
2136: ctxt->lastError.domain = XML_FROM_XPATH;
2137: ctxt->lastError.code = XML_ERR_NO_MEMORY;
2138: return(NULL);
2139: }
2140: #ifdef XP_DEBUG_OBJ_USAGE
2141: xmlXPathDebugObjUsageRequested(ctxt, XPATH_NODESET);
2142: #endif
2143: return(ret);
2144: }
2145: }
2146: return(xmlXPathNewNodeSet(val));
2147: }
2148:
2149: /**
2150: * xmlXPathCacheNewCString:
2151: * @ctxt: the XPath context
2152: * @val: the char * value
2153: *
2154: * This is the cached version of xmlXPathNewCString().
2155: * Acquire an xmlXPathObjectPtr of type string and of value @val
2156: *
2157: * Returns the created or reused object.
2158: */
2159: static xmlXPathObjectPtr
2160: xmlXPathCacheNewCString(xmlXPathContextPtr ctxt, const char *val)
2161: {
2162: if ((ctxt != NULL) && (ctxt->cache)) {
2163: xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache;
2164:
2165: if ((cache->stringObjs != NULL) &&
2166: (cache->stringObjs->number != 0))
2167: {
2168: xmlXPathObjectPtr ret;
2169:
2170: ret = (xmlXPathObjectPtr)
2171: cache->stringObjs->items[--cache->stringObjs->number];
2172:
2173: ret->type = XPATH_STRING;
2174: ret->stringval = xmlStrdup(BAD_CAST val);
2175: #ifdef XP_DEBUG_OBJ_USAGE
2176: xmlXPathDebugObjUsageRequested(ctxt, XPATH_STRING);
2177: #endif
2178: return(ret);
2179: } else if ((cache->miscObjs != NULL) &&
2180: (cache->miscObjs->number != 0))
2181: {
2182: xmlXPathObjectPtr ret;
2183:
2184: ret = (xmlXPathObjectPtr)
2185: cache->miscObjs->items[--cache->miscObjs->number];
2186:
2187: ret->type = XPATH_STRING;
2188: ret->stringval = xmlStrdup(BAD_CAST val);
2189: #ifdef XP_DEBUG_OBJ_USAGE
2190: xmlXPathDebugObjUsageRequested(ctxt, XPATH_STRING);
2191: #endif
2192: return(ret);
2193: }
2194: }
2195: return(xmlXPathNewCString(val));
2196: }
2197:
2198: /**
2199: * xmlXPathCacheNewString:
2200: * @ctxt: the XPath context
2201: * @val: the xmlChar * value
2202: *
2203: * This is the cached version of xmlXPathNewString().
2204: * Acquire an xmlXPathObjectPtr of type string and of value @val
2205: *
2206: * Returns the created or reused object.
2207: */
2208: static xmlXPathObjectPtr
2209: xmlXPathCacheNewString(xmlXPathContextPtr ctxt, const xmlChar *val)
2210: {
2211: if ((ctxt != NULL) && (ctxt->cache)) {
2212: xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache;
2213:
2214: if ((cache->stringObjs != NULL) &&
2215: (cache->stringObjs->number != 0))
2216: {
2217: xmlXPathObjectPtr ret;
2218:
2219: ret = (xmlXPathObjectPtr)
2220: cache->stringObjs->items[--cache->stringObjs->number];
2221: ret->type = XPATH_STRING;
2222: if (val != NULL)
2223: ret->stringval = xmlStrdup(val);
2224: else
2225: ret->stringval = xmlStrdup((const xmlChar *)"");
2226: #ifdef XP_DEBUG_OBJ_USAGE
2227: xmlXPathDebugObjUsageRequested(ctxt, XPATH_STRING);
2228: #endif
2229: return(ret);
2230: } else if ((cache->miscObjs != NULL) &&
2231: (cache->miscObjs->number != 0))
2232: {
2233: xmlXPathObjectPtr ret;
2234:
2235: ret = (xmlXPathObjectPtr)
2236: cache->miscObjs->items[--cache->miscObjs->number];
2237:
2238: ret->type = XPATH_STRING;
2239: if (val != NULL)
2240: ret->stringval = xmlStrdup(val);
2241: else
2242: ret->stringval = xmlStrdup((const xmlChar *)"");
2243: #ifdef XP_DEBUG_OBJ_USAGE
2244: xmlXPathDebugObjUsageRequested(ctxt, XPATH_STRING);
2245: #endif
2246: return(ret);
2247: }
2248: }
2249: return(xmlXPathNewString(val));
2250: }
2251:
2252: /**
2253: * xmlXPathCacheNewBoolean:
2254: * @ctxt: the XPath context
2255: * @val: the boolean value
2256: *
2257: * This is the cached version of xmlXPathNewBoolean().
2258: * Acquires an xmlXPathObjectPtr of type boolean and of value @val
2259: *
2260: * Returns the created or reused object.
2261: */
2262: static xmlXPathObjectPtr
2263: xmlXPathCacheNewBoolean(xmlXPathContextPtr ctxt, int val)
2264: {
2265: if ((ctxt != NULL) && (ctxt->cache)) {
2266: xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache;
2267:
2268: if ((cache->booleanObjs != NULL) &&
2269: (cache->booleanObjs->number != 0))
2270: {
2271: xmlXPathObjectPtr ret;
2272:
2273: ret = (xmlXPathObjectPtr)
2274: cache->booleanObjs->items[--cache->booleanObjs->number];
2275: ret->type = XPATH_BOOLEAN;
2276: ret->boolval = (val != 0);
2277: #ifdef XP_DEBUG_OBJ_USAGE
2278: xmlXPathDebugObjUsageRequested(ctxt, XPATH_BOOLEAN);
2279: #endif
2280: return(ret);
2281: } else if ((cache->miscObjs != NULL) &&
2282: (cache->miscObjs->number != 0))
2283: {
2284: xmlXPathObjectPtr ret;
2285:
2286: ret = (xmlXPathObjectPtr)
2287: cache->miscObjs->items[--cache->miscObjs->number];
2288:
2289: ret->type = XPATH_BOOLEAN;
2290: ret->boolval = (val != 0);
2291: #ifdef XP_DEBUG_OBJ_USAGE
2292: xmlXPathDebugObjUsageRequested(ctxt, XPATH_BOOLEAN);
2293: #endif
2294: return(ret);
2295: }
2296: }
2297: return(xmlXPathNewBoolean(val));
2298: }
2299:
2300: /**
2301: * xmlXPathCacheNewFloat:
2302: * @ctxt: the XPath context
2303: * @val: the double value
2304: *
2305: * This is the cached version of xmlXPathNewFloat().
2306: * Acquires an xmlXPathObjectPtr of type double and of value @val
2307: *
2308: * Returns the created or reused object.
2309: */
2310: static xmlXPathObjectPtr
2311: xmlXPathCacheNewFloat(xmlXPathContextPtr ctxt, double val)
2312: {
2313: if ((ctxt != NULL) && (ctxt->cache)) {
2314: xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache;
2315:
2316: if ((cache->numberObjs != NULL) &&
2317: (cache->numberObjs->number != 0))
2318: {
2319: xmlXPathObjectPtr ret;
2320:
2321: ret = (xmlXPathObjectPtr)
2322: cache->numberObjs->items[--cache->numberObjs->number];
2323: ret->type = XPATH_NUMBER;
2324: ret->floatval = val;
2325: #ifdef XP_DEBUG_OBJ_USAGE
2326: xmlXPathDebugObjUsageRequested(ctxt, XPATH_NUMBER);
2327: #endif
2328: return(ret);
2329: } else if ((cache->miscObjs != NULL) &&
2330: (cache->miscObjs->number != 0))
2331: {
2332: xmlXPathObjectPtr ret;
2333:
2334: ret = (xmlXPathObjectPtr)
2335: cache->miscObjs->items[--cache->miscObjs->number];
2336:
2337: ret->type = XPATH_NUMBER;
2338: ret->floatval = val;
2339: #ifdef XP_DEBUG_OBJ_USAGE
2340: xmlXPathDebugObjUsageRequested(ctxt, XPATH_NUMBER);
2341: #endif
2342: return(ret);
2343: }
2344: }
2345: return(xmlXPathNewFloat(val));
2346: }
2347:
2348: /**
2349: * xmlXPathCacheConvertString:
2350: * @ctxt: the XPath context
2351: * @val: an XPath object
2352: *
2353: * This is the cached version of xmlXPathConvertString().
2354: * Converts an existing object to its string() equivalent
2355: *
2356: * Returns a created or reused object, the old one is freed (cached)
2357: * (or the operation is done directly on @val)
2358: */
2359:
2360: static xmlXPathObjectPtr
2361: xmlXPathCacheConvertString(xmlXPathContextPtr ctxt, xmlXPathObjectPtr val) {
2362: xmlChar *res = NULL;
2363:
2364: if (val == NULL)
2365: return(xmlXPathCacheNewCString(ctxt, ""));
2366:
2367: switch (val->type) {
2368: case XPATH_UNDEFINED:
2369: #ifdef DEBUG_EXPR
2370: xmlGenericError(xmlGenericErrorContext, "STRING: undefined\n");
2371: #endif
2372: break;
2373: case XPATH_NODESET:
2374: case XPATH_XSLT_TREE:
2375: res = xmlXPathCastNodeSetToString(val->nodesetval);
2376: break;
2377: case XPATH_STRING:
2378: return(val);
2379: case XPATH_BOOLEAN:
2380: res = xmlXPathCastBooleanToString(val->boolval);
2381: break;
2382: case XPATH_NUMBER:
2383: res = xmlXPathCastNumberToString(val->floatval);
2384: break;
2385: case XPATH_USERS:
2386: case XPATH_POINT:
2387: case XPATH_RANGE:
2388: case XPATH_LOCATIONSET:
2389: TODO;
2390: break;
2391: }
2392: xmlXPathReleaseObject(ctxt, val);
2393: if (res == NULL)
2394: return(xmlXPathCacheNewCString(ctxt, ""));
2395: return(xmlXPathCacheWrapString(ctxt, res));
2396: }
2397:
2398: /**
2399: * xmlXPathCacheObjectCopy:
2400: * @ctxt: the XPath context
2401: * @val: the original object
2402: *
2403: * This is the cached version of xmlXPathObjectCopy().
2404: * Acquire a copy of a given object
2405: *
2406: * Returns a created or reused created object.
2407: */
2408: static xmlXPathObjectPtr
2409: xmlXPathCacheObjectCopy(xmlXPathContextPtr ctxt, xmlXPathObjectPtr val)
2410: {
2411: if (val == NULL)
2412: return(NULL);
2413:
2414: if (XP_HAS_CACHE(ctxt)) {
2415: switch (val->type) {
2416: case XPATH_NODESET:
2417: return(xmlXPathCacheWrapNodeSet(ctxt,
2418: xmlXPathNodeSetMerge(NULL, val->nodesetval)));
2419: case XPATH_STRING:
2420: return(xmlXPathCacheNewString(ctxt, val->stringval));
2421: case XPATH_BOOLEAN:
2422: return(xmlXPathCacheNewBoolean(ctxt, val->boolval));
2423: case XPATH_NUMBER:
2424: return(xmlXPathCacheNewFloat(ctxt, val->floatval));
2425: default:
2426: break;
2427: }
2428: }
2429: return(xmlXPathObjectCopy(val));
2430: }
2431:
2432: /**
2433: * xmlXPathCacheConvertBoolean:
2434: * @ctxt: the XPath context
2435: * @val: an XPath object
2436: *
2437: * This is the cached version of xmlXPathConvertBoolean().
2438: * Converts an existing object to its boolean() equivalent
2439: *
2440: * Returns a created or reused object, the old one is freed (or the operation
2441: * is done directly on @val)
2442: */
2443: static xmlXPathObjectPtr
2444: xmlXPathCacheConvertBoolean(xmlXPathContextPtr ctxt, xmlXPathObjectPtr val) {
2445: xmlXPathObjectPtr ret;
2446:
2447: if (val == NULL)
2448: return(xmlXPathCacheNewBoolean(ctxt, 0));
2449: if (val->type == XPATH_BOOLEAN)
2450: return(val);
2451: ret = xmlXPathCacheNewBoolean(ctxt, xmlXPathCastToBoolean(val));
2452: xmlXPathReleaseObject(ctxt, val);
2453: return(ret);
2454: }
2455:
2456: /**
2457: * xmlXPathCacheConvertNumber:
2458: * @ctxt: the XPath context
2459: * @val: an XPath object
2460: *
2461: * This is the cached version of xmlXPathConvertNumber().
2462: * Converts an existing object to its number() equivalent
2463: *
2464: * Returns a created or reused object, the old one is freed (or the operation
2465: * is done directly on @val)
2466: */
2467: static xmlXPathObjectPtr
2468: xmlXPathCacheConvertNumber(xmlXPathContextPtr ctxt, xmlXPathObjectPtr val) {
2469: xmlXPathObjectPtr ret;
2470:
2471: if (val == NULL)
2472: return(xmlXPathCacheNewFloat(ctxt, 0.0));
2473: if (val->type == XPATH_NUMBER)
2474: return(val);
2475: ret = xmlXPathCacheNewFloat(ctxt, xmlXPathCastToNumber(val));
2476: xmlXPathReleaseObject(ctxt, val);
2477: return(ret);
2478: }
2479:
2480: /************************************************************************
2481: * *
2482: * Parser stacks related functions and macros *
2483: * *
2484: ************************************************************************/
2485:
2486: /**
2487: * xmlXPathSetFrame:
2488: * @ctxt: an XPath parser context
2489: *
2490: * Set the callee evaluation frame
2491: *
2492: * Returns the previous frame value to be restored once done
2493: */
2494: static int
2495: xmlXPathSetFrame(xmlXPathParserContextPtr ctxt) {
2496: int ret;
2497:
2498: if (ctxt == NULL)
2499: return(0);
2500: ret = ctxt->valueFrame;
2501: ctxt->valueFrame = ctxt->valueNr;
2502: return(ret);
2503: }
2504:
2505: /**
2506: * xmlXPathPopFrame:
2507: * @ctxt: an XPath parser context
2508: * @frame: the previous frame value
2509: *
2510: * Remove the callee evaluation frame
2511: */
2512: static void
2513: xmlXPathPopFrame(xmlXPathParserContextPtr ctxt, int frame) {
2514: if (ctxt == NULL)
2515: return;
2516: if (ctxt->valueNr < ctxt->valueFrame) {
2517: xmlXPatherror(ctxt, __FILE__, __LINE__, XPATH_STACK_ERROR);
2518: }
2519: ctxt->valueFrame = frame;
2520: }
2521:
2522: /**
2523: * valuePop:
2524: * @ctxt: an XPath evaluation context
2525: *
2526: * Pops the top XPath object from the value stack
2527: *
2528: * Returns the XPath object just removed
2529: */
2530: xmlXPathObjectPtr
2531: valuePop(xmlXPathParserContextPtr ctxt)
2532: {
2533: xmlXPathObjectPtr ret;
2534:
2535: if ((ctxt == NULL) || (ctxt->valueNr <= 0))
2536: return (NULL);
2537:
2538: if (ctxt->valueNr <= ctxt->valueFrame) {
2539: xmlXPatherror(ctxt, __FILE__, __LINE__, XPATH_STACK_ERROR);
2540: return (NULL);
2541: }
2542:
2543: ctxt->valueNr--;
2544: if (ctxt->valueNr > 0)
2545: ctxt->value = ctxt->valueTab[ctxt->valueNr - 1];
2546: else
2547: ctxt->value = NULL;
2548: ret = ctxt->valueTab[ctxt->valueNr];
2549: ctxt->valueTab[ctxt->valueNr] = NULL;
2550: return (ret);
2551: }
2552: /**
2553: * valuePush:
2554: * @ctxt: an XPath evaluation context
2555: * @value: the XPath object
2556: *
2557: * Pushes a new XPath object on top of the value stack
2558: *
2559: * returns the number of items on the value stack
2560: */
2561: int
2562: valuePush(xmlXPathParserContextPtr ctxt, xmlXPathObjectPtr value)
2563: {
2564: if ((ctxt == NULL) || (value == NULL)) return(-1);
2565: if (ctxt->valueNr >= ctxt->valueMax) {
2566: xmlXPathObjectPtr *tmp;
2567:
2568: if (ctxt->valueMax >= XPATH_MAX_STACK_DEPTH) {
2569: xmlXPathErrMemory(NULL, "XPath stack depth limit reached\n");
2570: ctxt->error = XPATH_MEMORY_ERROR;
2571: return (0);
2572: }
2573: tmp = (xmlXPathObjectPtr *) xmlRealloc(ctxt->valueTab,
2574: 2 * ctxt->valueMax *
2575: sizeof(ctxt->valueTab[0]));
2576: if (tmp == NULL) {
2577: xmlXPathErrMemory(NULL, "pushing value\n");
2578: ctxt->error = XPATH_MEMORY_ERROR;
2579: return (0);
2580: }
2581: ctxt->valueMax *= 2;
2582: ctxt->valueTab = tmp;
2583: }
2584: ctxt->valueTab[ctxt->valueNr] = value;
2585: ctxt->value = value;
2586: return (ctxt->valueNr++);
2587: }
2588:
2589: /**
2590: * xmlXPathPopBoolean:
2591: * @ctxt: an XPath parser context
2592: *
2593: * Pops a boolean from the stack, handling conversion if needed.
2594: * Check error with #xmlXPathCheckError.
2595: *
2596: * Returns the boolean
2597: */
2598: int
2599: xmlXPathPopBoolean (xmlXPathParserContextPtr ctxt) {
2600: xmlXPathObjectPtr obj;
2601: int ret;
2602:
2603: obj = valuePop(ctxt);
2604: if (obj == NULL) {
2605: xmlXPathSetError(ctxt, XPATH_INVALID_OPERAND);
2606: return(0);
2607: }
2608: if (obj->type != XPATH_BOOLEAN)
2609: ret = xmlXPathCastToBoolean(obj);
2610: else
2611: ret = obj->boolval;
2612: xmlXPathReleaseObject(ctxt->context, obj);
2613: return(ret);
2614: }
2615:
2616: /**
2617: * xmlXPathPopNumber:
2618: * @ctxt: an XPath parser context
2619: *
2620: * Pops a number from the stack, handling conversion if needed.
2621: * Check error with #xmlXPathCheckError.
2622: *
2623: * Returns the number
2624: */
2625: double
2626: xmlXPathPopNumber (xmlXPathParserContextPtr ctxt) {
2627: xmlXPathObjectPtr obj;
2628: double ret;
2629:
2630: obj = valuePop(ctxt);
2631: if (obj == NULL) {
2632: xmlXPathSetError(ctxt, XPATH_INVALID_OPERAND);
2633: return(0);
2634: }
2635: if (obj->type != XPATH_NUMBER)
2636: ret = xmlXPathCastToNumber(obj);
2637: else
2638: ret = obj->floatval;
2639: xmlXPathReleaseObject(ctxt->context, obj);
2640: return(ret);
2641: }
2642:
2643: /**
2644: * xmlXPathPopString:
2645: * @ctxt: an XPath parser context
2646: *
2647: * Pops a string from the stack, handling conversion if needed.
2648: * Check error with #xmlXPathCheckError.
2649: *
2650: * Returns the string
2651: */
2652: xmlChar *
2653: xmlXPathPopString (xmlXPathParserContextPtr ctxt) {
2654: xmlXPathObjectPtr obj;
2655: xmlChar * ret;
2656:
2657: obj = valuePop(ctxt);
2658: if (obj == NULL) {
2659: xmlXPathSetError(ctxt, XPATH_INVALID_OPERAND);
2660: return(NULL);
2661: }
2662: ret = xmlXPathCastToString(obj); /* this does required strdup */
2663: /* TODO: needs refactoring somewhere else */
2664: if (obj->stringval == ret)
2665: obj->stringval = NULL;
2666: xmlXPathReleaseObject(ctxt->context, obj);
2667: return(ret);
2668: }
2669:
2670: /**
2671: * xmlXPathPopNodeSet:
2672: * @ctxt: an XPath parser context
2673: *
2674: * Pops a node-set from the stack, handling conversion if needed.
2675: * Check error with #xmlXPathCheckError.
2676: *
2677: * Returns the node-set
2678: */
2679: xmlNodeSetPtr
2680: xmlXPathPopNodeSet (xmlXPathParserContextPtr ctxt) {
2681: xmlXPathObjectPtr obj;
2682: xmlNodeSetPtr ret;
2683:
2684: if (ctxt == NULL) return(NULL);
2685: if (ctxt->value == NULL) {
2686: xmlXPathSetError(ctxt, XPATH_INVALID_OPERAND);
2687: return(NULL);
2688: }
2689: if (!xmlXPathStackIsNodeSet(ctxt)) {
2690: xmlXPathSetTypeError(ctxt);
2691: return(NULL);
2692: }
2693: obj = valuePop(ctxt);
2694: ret = obj->nodesetval;
2695: #if 0
2696: /* to fix memory leak of not clearing obj->user */
2697: if (obj->boolval && obj->user != NULL)
2698: xmlFreeNodeList((xmlNodePtr) obj->user);
2699: #endif
2700: obj->nodesetval = NULL;
2701: xmlXPathReleaseObject(ctxt->context, obj);
2702: return(ret);
2703: }
2704:
2705: /**
2706: * xmlXPathPopExternal:
2707: * @ctxt: an XPath parser context
2708: *
2709: * Pops an external object from the stack, handling conversion if needed.
2710: * Check error with #xmlXPathCheckError.
2711: *
2712: * Returns the object
2713: */
2714: void *
2715: xmlXPathPopExternal (xmlXPathParserContextPtr ctxt) {
2716: xmlXPathObjectPtr obj;
2717: void * ret;
2718:
2719: if ((ctxt == NULL) || (ctxt->value == NULL)) {
2720: xmlXPathSetError(ctxt, XPATH_INVALID_OPERAND);
2721: return(NULL);
2722: }
2723: if (ctxt->value->type != XPATH_USERS) {
2724: xmlXPathSetTypeError(ctxt);
2725: return(NULL);
2726: }
2727: obj = valuePop(ctxt);
2728: ret = obj->user;
2729: obj->user = NULL;
2730: xmlXPathReleaseObject(ctxt->context, obj);
2731: return(ret);
2732: }
2733:
2734: /*
2735: * Macros for accessing the content. Those should be used only by the parser,
2736: * and not exported.
2737: *
2738: * Dirty macros, i.e. one need to make assumption on the context to use them
2739: *
2740: * CUR_PTR return the current pointer to the xmlChar to be parsed.
2741: * CUR returns the current xmlChar value, i.e. a 8 bit value
2742: * in ISO-Latin or UTF-8.
2743: * This should be used internally by the parser
2744: * only to compare to ASCII values otherwise it would break when
2745: * running with UTF-8 encoding.
2746: * NXT(n) returns the n'th next xmlChar. Same as CUR is should be used only
2747: * to compare on ASCII based substring.
2748: * SKIP(n) Skip n xmlChar, and must also be used only to skip ASCII defined
2749: * strings within the parser.
2750: * CURRENT Returns the current char value, with the full decoding of
2751: * UTF-8 if we are using this mode. It returns an int.
2752: * NEXT Skip to the next character, this does the proper decoding
2753: * in UTF-8 mode. It also pop-up unfinished entities on the fly.
2754: * It returns the pointer to the current xmlChar.
2755: */
2756:
2757: #define CUR (*ctxt->cur)
2758: #define SKIP(val) ctxt->cur += (val)
2759: #define NXT(val) ctxt->cur[(val)]
2760: #define CUR_PTR ctxt->cur
2761: #define CUR_CHAR(l) xmlXPathCurrentChar(ctxt, &l)
2762:
2763: #define COPY_BUF(l,b,i,v) \
2764: if (l == 1) b[i++] = (xmlChar) v; \
2765: else i += xmlCopyChar(l,&b[i],v)
2766:
2767: #define NEXTL(l) ctxt->cur += l
2768:
2769: #define SKIP_BLANKS \
2770: while (IS_BLANK_CH(*(ctxt->cur))) NEXT
2771:
2772: #define CURRENT (*ctxt->cur)
2773: #define NEXT ((*ctxt->cur) ? ctxt->cur++: ctxt->cur)
2774:
2775:
2776: #ifndef DBL_DIG
2777: #define DBL_DIG 16
2778: #endif
2779: #ifndef DBL_EPSILON
2780: #define DBL_EPSILON 1E-9
2781: #endif
2782:
2783: #define UPPER_DOUBLE 1E9
2784: #define LOWER_DOUBLE 1E-5
2785: #define LOWER_DOUBLE_EXP 5
2786:
2787: #define INTEGER_DIGITS DBL_DIG
2788: #define FRACTION_DIGITS (DBL_DIG + 1 + (LOWER_DOUBLE_EXP))
2789: #define EXPONENT_DIGITS (3 + 2)
2790:
2791: /**
2792: * xmlXPathFormatNumber:
2793: * @number: number to format
2794: * @buffer: output buffer
2795: * @buffersize: size of output buffer
2796: *
2797: * Convert the number into a string representation.
2798: */
2799: static void
2800: xmlXPathFormatNumber(double number, char buffer[], int buffersize)
2801: {
2802: switch (xmlXPathIsInf(number)) {
2803: case 1:
2804: if (buffersize > (int)sizeof("Infinity"))
2805: snprintf(buffer, buffersize, "Infinity");
2806: break;
2807: case -1:
2808: if (buffersize > (int)sizeof("-Infinity"))
2809: snprintf(buffer, buffersize, "-Infinity");
2810: break;
2811: default:
2812: if (xmlXPathIsNaN(number)) {
2813: if (buffersize > (int)sizeof("NaN"))
2814: snprintf(buffer, buffersize, "NaN");
2815: } else if (number == 0 && xmlXPathGetSign(number) != 0) {
2816: snprintf(buffer, buffersize, "0");
2817: } else if (number == ((int) number)) {
2818: char work[30];
2819: char *ptr, *cur;
2820: int value = (int) number;
2821:
2822: ptr = &buffer[0];
2823: if (value == 0) {
2824: *ptr++ = '0';
2825: } else {
2826: snprintf(work, 29, "%d", value);
2827: cur = &work[0];
2828: while ((*cur) && (ptr - buffer < buffersize)) {
2829: *ptr++ = *cur++;
2830: }
2831: }
2832: if (ptr - buffer < buffersize) {
2833: *ptr = 0;
2834: } else if (buffersize > 0) {
2835: ptr--;
2836: *ptr = 0;
2837: }
2838: } else {
2839: /*
2840: For the dimension of work,
2841: DBL_DIG is number of significant digits
2842: EXPONENT is only needed for "scientific notation"
2843: 3 is sign, decimal point, and terminating zero
2844: LOWER_DOUBLE_EXP is max number of leading zeroes in fraction
2845: Note that this dimension is slightly (a few characters)
2846: larger than actually necessary.
2847: */
2848: char work[DBL_DIG + EXPONENT_DIGITS + 3 + LOWER_DOUBLE_EXP];
2849: int integer_place, fraction_place;
2850: char *ptr;
2851: char *after_fraction;
2852: double absolute_value;
2853: int size;
2854:
2855: absolute_value = fabs(number);
2856:
2857: /*
2858: * First choose format - scientific or regular floating point.
2859: * In either case, result is in work, and after_fraction points
2860: * just past the fractional part.
2861: */
2862: if ( ((absolute_value > UPPER_DOUBLE) ||
2863: (absolute_value < LOWER_DOUBLE)) &&
2864: (absolute_value != 0.0) ) {
2865: /* Use scientific notation */
2866: integer_place = DBL_DIG + EXPONENT_DIGITS + 1;
2867: fraction_place = DBL_DIG - 1;
2868: size = snprintf(work, sizeof(work),"%*.*e",
2869: integer_place, fraction_place, number);
2870: while ((size > 0) && (work[size] != 'e')) size--;
2871:
2872: }
2873: else {
2874: /* Use regular notation */
2875: if (absolute_value > 0.0) {
2876: integer_place = (int)log10(absolute_value);
2877: if (integer_place > 0)
2878: fraction_place = DBL_DIG - integer_place - 1;
2879: else
2880: fraction_place = DBL_DIG - integer_place;
2881: } else {
2882: fraction_place = 1;
2883: }
2884: size = snprintf(work, sizeof(work), "%0.*f",
2885: fraction_place, number);
2886: }
2887:
2888: /* Remove fractional trailing zeroes */
2889: after_fraction = work + size;
2890: ptr = after_fraction;
2891: while (*(--ptr) == '0')
2892: ;
2893: if (*ptr != '.')
2894: ptr++;
2895: while ((*ptr++ = *after_fraction++) != 0);
2896:
2897: /* Finally copy result back to caller */
2898: size = strlen(work) + 1;
2899: if (size > buffersize) {
2900: work[buffersize - 1] = 0;
2901: size = buffersize;
2902: }
2903: memmove(buffer, work, size);
2904: }
2905: break;
2906: }
2907: }
2908:
2909:
2910: /************************************************************************
2911: * *
2912: * Routines to handle NodeSets *
2913: * *
2914: ************************************************************************/
2915:
2916: /**
2917: * xmlXPathOrderDocElems:
2918: * @doc: an input document
2919: *
2920: * Call this routine to speed up XPath computation on static documents.
2921: * This stamps all the element nodes with the document order
2922: * Like for line information, the order is kept in the element->content
2923: * field, the value stored is actually - the node number (starting at -1)
2924: * to be able to differentiate from line numbers.
2925: *
2926: * Returns the number of elements found in the document or -1 in case
2927: * of error.
2928: */
2929: long
2930: xmlXPathOrderDocElems(xmlDocPtr doc) {
2931: long count = 0;
2932: xmlNodePtr cur;
2933:
2934: if (doc == NULL)
2935: return(-1);
2936: cur = doc->children;
2937: while (cur != NULL) {
2938: if (cur->type == XML_ELEMENT_NODE) {
2939: cur->content = (void *) (-(++count));
2940: if (cur->children != NULL) {
2941: cur = cur->children;
2942: continue;
2943: }
2944: }
2945: if (cur->next != NULL) {
2946: cur = cur->next;
2947: continue;
2948: }
2949: do {
2950: cur = cur->parent;
2951: if (cur == NULL)
2952: break;
2953: if (cur == (xmlNodePtr) doc) {
2954: cur = NULL;
2955: break;
2956: }
2957: if (cur->next != NULL) {
2958: cur = cur->next;
2959: break;
2960: }
2961: } while (cur != NULL);
2962: }
2963: return(count);
2964: }
2965:
2966: /**
2967: * xmlXPathCmpNodes:
2968: * @node1: the first node
2969: * @node2: the second node
2970: *
2971: * Compare two nodes w.r.t document order
2972: *
2973: * Returns -2 in case of error 1 if first point < second point, 0 if
2974: * it's the same node, -1 otherwise
2975: */
2976: int
2977: xmlXPathCmpNodes(xmlNodePtr node1, xmlNodePtr node2) {
2978: int depth1, depth2;
2979: int attr1 = 0, attr2 = 0;
2980: xmlNodePtr attrNode1 = NULL, attrNode2 = NULL;
2981: xmlNodePtr cur, root;
2982:
2983: if ((node1 == NULL) || (node2 == NULL))
2984: return(-2);
2985: /*
2986: * a couple of optimizations which will avoid computations in most cases
2987: */
2988: if (node1 == node2) /* trivial case */
2989: return(0);
2990: if (node1->type == XML_ATTRIBUTE_NODE) {
2991: attr1 = 1;
2992: attrNode1 = node1;
2993: node1 = node1->parent;
2994: }
2995: if (node2->type == XML_ATTRIBUTE_NODE) {
2996: attr2 = 1;
2997: attrNode2 = node2;
2998: node2 = node2->parent;
2999: }
3000: if (node1 == node2) {
3001: if (attr1 == attr2) {
3002: /* not required, but we keep attributes in order */
3003: if (attr1 != 0) {
3004: cur = attrNode2->prev;
3005: while (cur != NULL) {
3006: if (cur == attrNode1)
3007: return (1);
3008: cur = cur->prev;
3009: }
3010: return (-1);
3011: }
3012: return(0);
3013: }
3014: if (attr2 == 1)
3015: return(1);
3016: return(-1);
3017: }
3018: if ((node1->type == XML_NAMESPACE_DECL) ||
3019: (node2->type == XML_NAMESPACE_DECL))
3020: return(1);
3021: if (node1 == node2->prev)
3022: return(1);
3023: if (node1 == node2->next)
3024: return(-1);
3025:
3026: /*
3027: * Speedup using document order if availble.
3028: */
3029: if ((node1->type == XML_ELEMENT_NODE) &&
3030: (node2->type == XML_ELEMENT_NODE) &&
3031: (0 > (long) node1->content) &&
3032: (0 > (long) node2->content) &&
3033: (node1->doc == node2->doc)) {
3034: long l1, l2;
3035:
3036: l1 = -((long) node1->content);
3037: l2 = -((long) node2->content);
3038: if (l1 < l2)
3039: return(1);
3040: if (l1 > l2)
3041: return(-1);
3042: }
3043:
3044: /*
3045: * compute depth to root
3046: */
3047: for (depth2 = 0, cur = node2;cur->parent != NULL;cur = cur->parent) {
3048: if (cur == node1)
3049: return(1);
3050: depth2++;
3051: }
3052: root = cur;
3053: for (depth1 = 0, cur = node1;cur->parent != NULL;cur = cur->parent) {
3054: if (cur == node2)
3055: return(-1);
3056: depth1++;
3057: }
3058: /*
3059: * Distinct document (or distinct entities :-( ) case.
3060: */
3061: if (root != cur) {
3062: return(-2);
3063: }
3064: /*
3065: * get the nearest common ancestor.
3066: */
3067: while (depth1 > depth2) {
3068: depth1--;
3069: node1 = node1->parent;
3070: }
3071: while (depth2 > depth1) {
3072: depth2--;
3073: node2 = node2->parent;
3074: }
3075: while (node1->parent != node2->parent) {
3076: node1 = node1->parent;
3077: node2 = node2->parent;
3078: /* should not happen but just in case ... */
3079: if ((node1 == NULL) || (node2 == NULL))
3080: return(-2);
3081: }
3082: /*
3083: * Find who's first.
3084: */
3085: if (node1 == node2->prev)
3086: return(1);
3087: if (node1 == node2->next)
3088: return(-1);
3089: /*
3090: * Speedup using document order if availble.
3091: */
3092: if ((node1->type == XML_ELEMENT_NODE) &&
3093: (node2->type == XML_ELEMENT_NODE) &&
3094: (0 > (long) node1->content) &&
3095: (0 > (long) node2->content) &&
3096: (node1->doc == node2->doc)) {
3097: long l1, l2;
3098:
3099: l1 = -((long) node1->content);
3100: l2 = -((long) node2->content);
3101: if (l1 < l2)
3102: return(1);
3103: if (l1 > l2)
3104: return(-1);
3105: }
3106:
3107: for (cur = node1->next;cur != NULL;cur = cur->next)
3108: if (cur == node2)
3109: return(1);
3110: return(-1); /* assume there is no sibling list corruption */
3111: }
3112:
3113: #ifdef XP_OPTIMIZED_NON_ELEM_COMPARISON
3114: /**
3115: * xmlXPathCmpNodesExt:
3116: * @node1: the first node
3117: * @node2: the second node
3118: *
3119: * Compare two nodes w.r.t document order.
3120: * This one is optimized for handling of non-element nodes.
3121: *
3122: * Returns -2 in case of error 1 if first point < second point, 0 if
3123: * it's the same node, -1 otherwise
3124: */
3125: static int
3126: xmlXPathCmpNodesExt(xmlNodePtr node1, xmlNodePtr node2) {
3127: int depth1, depth2;
3128: int misc = 0, precedence1 = 0, precedence2 = 0;
3129: xmlNodePtr miscNode1 = NULL, miscNode2 = NULL;
3130: xmlNodePtr cur, root;
3131: long l1, l2;
3132:
3133: if ((node1 == NULL) || (node2 == NULL))
3134: return(-2);
3135:
3136: if (node1 == node2)
3137: return(0);
3138:
3139: /*
3140: * a couple of optimizations which will avoid computations in most cases
3141: */
3142: switch (node1->type) {
3143: case XML_ELEMENT_NODE:
3144: if (node2->type == XML_ELEMENT_NODE) {
3145: if ((0 > (long) node1->content) && /* TODO: Would a != 0 suffice here? */
3146: (0 > (long) node2->content) &&
3147: (node1->doc == node2->doc))
3148: {
3149: l1 = -((long) node1->content);
3150: l2 = -((long) node2->content);
3151: if (l1 < l2)
3152: return(1);
3153: if (l1 > l2)
3154: return(-1);
3155: } else
3156: goto turtle_comparison;
3157: }
3158: break;
3159: case XML_ATTRIBUTE_NODE:
3160: precedence1 = 1; /* element is owner */
3161: miscNode1 = node1;
3162: node1 = node1->parent;
3163: misc = 1;
3164: break;
3165: case XML_TEXT_NODE:
3166: case XML_CDATA_SECTION_NODE:
3167: case XML_COMMENT_NODE:
3168: case XML_PI_NODE: {
3169: miscNode1 = node1;
3170: /*
3171: * Find nearest element node.
3172: */
3173: if (node1->prev != NULL) {
3174: do {
3175: node1 = node1->prev;
3176: if (node1->type == XML_ELEMENT_NODE) {
3177: precedence1 = 3; /* element in prev-sibl axis */
3178: break;
3179: }
3180: if (node1->prev == NULL) {
3181: precedence1 = 2; /* element is parent */
3182: /*
3183: * URGENT TODO: Are there any cases, where the
3184: * parent of such a node is not an element node?
3185: */
3186: node1 = node1->parent;
3187: break;
3188: }
3189: } while (1);
3190: } else {
3191: precedence1 = 2; /* element is parent */
3192: node1 = node1->parent;
3193: }
3194: if ((node1 == NULL) || (node1->type != XML_ELEMENT_NODE) ||
3195: (0 <= (long) node1->content)) {
3196: /*
3197: * Fallback for whatever case.
3198: */
3199: node1 = miscNode1;
3200: precedence1 = 0;
3201: } else
3202: misc = 1;
3203: }
3204: break;
3205: case XML_NAMESPACE_DECL:
3206: /*
3207: * TODO: why do we return 1 for namespace nodes?
3208: */
3209: return(1);
3210: default:
3211: break;
3212: }
3213: switch (node2->type) {
3214: case XML_ELEMENT_NODE:
3215: break;
3216: case XML_ATTRIBUTE_NODE:
3217: precedence2 = 1; /* element is owner */
3218: miscNode2 = node2;
3219: node2 = node2->parent;
3220: misc = 1;
3221: break;
3222: case XML_TEXT_NODE:
3223: case XML_CDATA_SECTION_NODE:
3224: case XML_COMMENT_NODE:
3225: case XML_PI_NODE: {
3226: miscNode2 = node2;
3227: if (node2->prev != NULL) {
3228: do {
3229: node2 = node2->prev;
3230: if (node2->type == XML_ELEMENT_NODE) {
3231: precedence2 = 3; /* element in prev-sibl axis */
3232: break;
3233: }
3234: if (node2->prev == NULL) {
3235: precedence2 = 2; /* element is parent */
3236: node2 = node2->parent;
3237: break;
3238: }
3239: } while (1);
3240: } else {
3241: precedence2 = 2; /* element is parent */
3242: node2 = node2->parent;
3243: }
3244: if ((node2 == NULL) || (node2->type != XML_ELEMENT_NODE) ||
3245: (0 <= (long) node1->content))
3246: {
3247: node2 = miscNode2;
3248: precedence2 = 0;
3249: } else
3250: misc = 1;
3251: }
3252: break;
3253: case XML_NAMESPACE_DECL:
3254: return(1);
3255: default:
3256: break;
3257: }
3258: if (misc) {
3259: if (node1 == node2) {
3260: if (precedence1 == precedence2) {
3261: /*
3262: * The ugly case; but normally there aren't many
3263: * adjacent non-element nodes around.
3264: */
3265: cur = miscNode2->prev;
3266: while (cur != NULL) {
3267: if (cur == miscNode1)
3268: return(1);
3269: if (cur->type == XML_ELEMENT_NODE)
3270: return(-1);
3271: cur = cur->prev;
3272: }
3273: return (-1);
3274: } else {
3275: /*
3276: * Evaluate based on higher precedence wrt to the element.
3277: * TODO: This assumes attributes are sorted before content.
3278: * Is this 100% correct?
3279: */
3280: if (precedence1 < precedence2)
3281: return(1);
3282: else
3283: return(-1);
3284: }
3285: }
3286: /*
3287: * Special case: One of the helper-elements is contained by the other.
3288: * <foo>
3289: * <node2>
3290: * <node1>Text-1(precedence1 == 2)</node1>
3291: * </node2>
3292: * Text-6(precedence2 == 3)
3293: * </foo>
3294: */
3295: if ((precedence2 == 3) && (precedence1 > 1)) {
3296: cur = node1->parent;
3297: while (cur) {
3298: if (cur == node2)
3299: return(1);
3300: cur = cur->parent;
3301: }
3302: }
3303: if ((precedence1 == 3) && (precedence2 > 1)) {
3304: cur = node2->parent;
3305: while (cur) {
3306: if (cur == node1)
3307: return(-1);
3308: cur = cur->parent;
3309: }
3310: }
3311: }
3312:
3313: /*
3314: * Speedup using document order if availble.
3315: */
3316: if ((node1->type == XML_ELEMENT_NODE) &&
3317: (node2->type == XML_ELEMENT_NODE) &&
3318: (0 > (long) node1->content) &&
3319: (0 > (long) node2->content) &&
3320: (node1->doc == node2->doc)) {
3321:
3322: l1 = -((long) node1->content);
3323: l2 = -((long) node2->content);
3324: if (l1 < l2)
3325: return(1);
3326: if (l1 > l2)
3327: return(-1);
3328: }
3329:
3330: turtle_comparison:
3331:
3332: if (node1 == node2->prev)
3333: return(1);
3334: if (node1 == node2->next)
3335: return(-1);
3336: /*
3337: * compute depth to root
3338: */
3339: for (depth2 = 0, cur = node2;cur->parent != NULL;cur = cur->parent) {
3340: if (cur == node1)
3341: return(1);
3342: depth2++;
3343: }
3344: root = cur;
3345: for (depth1 = 0, cur = node1;cur->parent != NULL;cur = cur->parent) {
3346: if (cur == node2)
3347: return(-1);
3348: depth1++;
3349: }
3350: /*
3351: * Distinct document (or distinct entities :-( ) case.
3352: */
3353: if (root != cur) {
3354: return(-2);
3355: }
3356: /*
3357: * get the nearest common ancestor.
3358: */
3359: while (depth1 > depth2) {
3360: depth1--;
3361: node1 = node1->parent;
3362: }
3363: while (depth2 > depth1) {
3364: depth2--;
3365: node2 = node2->parent;
3366: }
3367: while (node1->parent != node2->parent) {
3368: node1 = node1->parent;
3369: node2 = node2->parent;
3370: /* should not happen but just in case ... */
3371: if ((node1 == NULL) || (node2 == NULL))
3372: return(-2);
3373: }
3374: /*
3375: * Find who's first.
3376: */
3377: if (node1 == node2->prev)
3378: return(1);
3379: if (node1 == node2->next)
3380: return(-1);
3381: /*
3382: * Speedup using document order if availble.
3383: */
3384: if ((node1->type == XML_ELEMENT_NODE) &&
3385: (node2->type == XML_ELEMENT_NODE) &&
3386: (0 > (long) node1->content) &&
3387: (0 > (long) node2->content) &&
3388: (node1->doc == node2->doc)) {
3389:
3390: l1 = -((long) node1->content);
3391: l2 = -((long) node2->content);
3392: if (l1 < l2)
3393: return(1);
3394: if (l1 > l2)
3395: return(-1);
3396: }
3397:
3398: for (cur = node1->next;cur != NULL;cur = cur->next)
3399: if (cur == node2)
3400: return(1);
3401: return(-1); /* assume there is no sibling list corruption */
3402: }
3403: #endif /* XP_OPTIMIZED_NON_ELEM_COMPARISON */
3404:
3405: /**
3406: * xmlXPathNodeSetSort:
3407: * @set: the node set
3408: *
3409: * Sort the node set in document order
3410: */
3411: void
3412: xmlXPathNodeSetSort(xmlNodeSetPtr set) {
3413: #ifndef WITH_TIM_SORT
3414: int i, j, incr, len;
3415: xmlNodePtr tmp;
3416: #endif
3417:
3418: if (set == NULL)
3419: return;
3420:
3421: #ifndef WITH_TIM_SORT
3422: /*
3423: * Use the old Shell's sort implementation to sort the node-set
3424: * Timsort ought to be quite faster
3425: */
3426: len = set->nodeNr;
3427: for (incr = len / 2; incr > 0; incr /= 2) {
3428: for (i = incr; i < len; i++) {
3429: j = i - incr;
3430: while (j >= 0) {
3431: #ifdef XP_OPTIMIZED_NON_ELEM_COMPARISON
3432: if (xmlXPathCmpNodesExt(set->nodeTab[j],
3433: set->nodeTab[j + incr]) == -1)
3434: #else
3435: if (xmlXPathCmpNodes(set->nodeTab[j],
3436: set->nodeTab[j + incr]) == -1)
3437: #endif
3438: {
3439: tmp = set->nodeTab[j];
3440: set->nodeTab[j] = set->nodeTab[j + incr];
3441: set->nodeTab[j + incr] = tmp;
3442: j -= incr;
3443: } else
3444: break;
3445: }
3446: }
3447: }
3448: #else /* WITH_TIM_SORT */
3449: libxml_domnode_tim_sort(set->nodeTab, set->nodeNr);
3450: #endif /* WITH_TIM_SORT */
3451: }
3452:
3453: #define XML_NODESET_DEFAULT 10
3454: /**
3455: * xmlXPathNodeSetDupNs:
3456: * @node: the parent node of the namespace XPath node
3457: * @ns: the libxml namespace declaration node.
3458: *
3459: * Namespace node in libxml don't match the XPath semantic. In a node set
3460: * the namespace nodes are duplicated and the next pointer is set to the
3461: * parent node in the XPath semantic.
3462: *
3463: * Returns the newly created object.
3464: */
3465: static xmlNodePtr
3466: xmlXPathNodeSetDupNs(xmlNodePtr node, xmlNsPtr ns) {
3467: xmlNsPtr cur;
3468:
3469: if ((ns == NULL) || (ns->type != XML_NAMESPACE_DECL))
3470: return(NULL);
3471: if ((node == NULL) || (node->type == XML_NAMESPACE_DECL))
3472: return((xmlNodePtr) ns);
3473:
3474: /*
3475: * Allocate a new Namespace and fill the fields.
3476: */
3477: cur = (xmlNsPtr) xmlMalloc(sizeof(xmlNs));
3478: if (cur == NULL) {
3479: xmlXPathErrMemory(NULL, "duplicating namespace\n");
3480: return(NULL);
3481: }
3482: memset(cur, 0, sizeof(xmlNs));
3483: cur->type = XML_NAMESPACE_DECL;
3484: if (ns->href != NULL)
3485: cur->href = xmlStrdup(ns->href);
3486: if (ns->prefix != NULL)
3487: cur->prefix = xmlStrdup(ns->prefix);
3488: cur->next = (xmlNsPtr) node;
3489: return((xmlNodePtr) cur);
3490: }
3491:
3492: /**
3493: * xmlXPathNodeSetFreeNs:
3494: * @ns: the XPath namespace node found in a nodeset.
3495: *
3496: * Namespace nodes in libxml don't match the XPath semantic. In a node set
3497: * the namespace nodes are duplicated and the next pointer is set to the
3498: * parent node in the XPath semantic. Check if such a node needs to be freed
3499: */
3500: void
3501: xmlXPathNodeSetFreeNs(xmlNsPtr ns) {
3502: if ((ns == NULL) || (ns->type != XML_NAMESPACE_DECL))
3503: return;
3504:
3505: if ((ns->next != NULL) && (ns->next->type != XML_NAMESPACE_DECL)) {
3506: if (ns->href != NULL)
3507: xmlFree((xmlChar *)ns->href);
3508: if (ns->prefix != NULL)
3509: xmlFree((xmlChar *)ns->prefix);
3510: xmlFree(ns);
3511: }
3512: }
3513:
3514: /**
3515: * xmlXPathNodeSetCreate:
3516: * @val: an initial xmlNodePtr, or NULL
3517: *
3518: * Create a new xmlNodeSetPtr of type double and of value @val
3519: *
3520: * Returns the newly created object.
3521: */
3522: xmlNodeSetPtr
3523: xmlXPathNodeSetCreate(xmlNodePtr val) {
3524: xmlNodeSetPtr ret;
3525:
3526: ret = (xmlNodeSetPtr) xmlMalloc(sizeof(xmlNodeSet));
3527: if (ret == NULL) {
3528: xmlXPathErrMemory(NULL, "creating nodeset\n");
3529: return(NULL);
3530: }
3531: memset(ret, 0 , (size_t) sizeof(xmlNodeSet));
3532: if (val != NULL) {
3533: ret->nodeTab = (xmlNodePtr *) xmlMalloc(XML_NODESET_DEFAULT *
3534: sizeof(xmlNodePtr));
3535: if (ret->nodeTab == NULL) {
3536: xmlXPathErrMemory(NULL, "creating nodeset\n");
3537: xmlFree(ret);
3538: return(NULL);
3539: }
3540: memset(ret->nodeTab, 0 ,
3541: XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
3542: ret->nodeMax = XML_NODESET_DEFAULT;
3543: if (val->type == XML_NAMESPACE_DECL) {
3544: xmlNsPtr ns = (xmlNsPtr) val;
3545:
3546: ret->nodeTab[ret->nodeNr++] =
3547: xmlXPathNodeSetDupNs((xmlNodePtr) ns->next, ns);
3548: } else
3549: ret->nodeTab[ret->nodeNr++] = val;
3550: }
3551: return(ret);
3552: }
3553:
3554: /**
3555: * xmlXPathNodeSetCreateSize:
3556: * @size: the initial size of the set
3557: *
3558: * Create a new xmlNodeSetPtr of type double and of value @val
3559: *
3560: * Returns the newly created object.
3561: */
3562: static xmlNodeSetPtr
3563: xmlXPathNodeSetCreateSize(int size) {
3564: xmlNodeSetPtr ret;
3565:
3566: ret = (xmlNodeSetPtr) xmlMalloc(sizeof(xmlNodeSet));
3567: if (ret == NULL) {
3568: xmlXPathErrMemory(NULL, "creating nodeset\n");
3569: return(NULL);
3570: }
3571: memset(ret, 0 , (size_t) sizeof(xmlNodeSet));
3572: if (size < XML_NODESET_DEFAULT)
3573: size = XML_NODESET_DEFAULT;
3574: ret->nodeTab = (xmlNodePtr *) xmlMalloc(size * sizeof(xmlNodePtr));
3575: if (ret->nodeTab == NULL) {
3576: xmlXPathErrMemory(NULL, "creating nodeset\n");
3577: xmlFree(ret);
3578: return(NULL);
3579: }
3580: memset(ret->nodeTab, 0 , size * (size_t) sizeof(xmlNodePtr));
3581: ret->nodeMax = size;
3582: return(ret);
3583: }
3584:
3585: /**
3586: * xmlXPathNodeSetContains:
3587: * @cur: the node-set
3588: * @val: the node
3589: *
3590: * checks whether @cur contains @val
3591: *
3592: * Returns true (1) if @cur contains @val, false (0) otherwise
3593: */
3594: int
3595: xmlXPathNodeSetContains (xmlNodeSetPtr cur, xmlNodePtr val) {
3596: int i;
3597:
3598: if ((cur == NULL) || (val == NULL)) return(0);
3599: if (val->type == XML_NAMESPACE_DECL) {
3600: for (i = 0; i < cur->nodeNr; i++) {
3601: if (cur->nodeTab[i]->type == XML_NAMESPACE_DECL) {
3602: xmlNsPtr ns1, ns2;
3603:
3604: ns1 = (xmlNsPtr) val;
3605: ns2 = (xmlNsPtr) cur->nodeTab[i];
3606: if (ns1 == ns2)
3607: return(1);
3608: if ((ns1->next != NULL) && (ns2->next == ns1->next) &&
3609: (xmlStrEqual(ns1->prefix, ns2->prefix)))
3610: return(1);
3611: }
3612: }
3613: } else {
3614: for (i = 0; i < cur->nodeNr; i++) {
3615: if (cur->nodeTab[i] == val)
3616: return(1);
3617: }
3618: }
3619: return(0);
3620: }
3621:
3622: /**
3623: * xmlXPathNodeSetAddNs:
3624: * @cur: the initial node set
3625: * @node: the hosting node
3626: * @ns: a the namespace node
3627: *
3628: * add a new namespace node to an existing NodeSet
3629: *
3630: * Returns 0 in case of success and -1 in case of error
3631: */
3632: int
3633: xmlXPathNodeSetAddNs(xmlNodeSetPtr cur, xmlNodePtr node, xmlNsPtr ns) {
3634: int i;
3635:
3636:
3637: if ((cur == NULL) || (ns == NULL) || (node == NULL) ||
3638: (ns->type != XML_NAMESPACE_DECL) ||
3639: (node->type != XML_ELEMENT_NODE))
3640: return(-1);
3641:
3642: /* @@ with_ns to check whether namespace nodes should be looked at @@ */
3643: /*
3644: * prevent duplicates
3645: */
3646: for (i = 0;i < cur->nodeNr;i++) {
3647: if ((cur->nodeTab[i] != NULL) &&
3648: (cur->nodeTab[i]->type == XML_NAMESPACE_DECL) &&
3649: (((xmlNsPtr)cur->nodeTab[i])->next == (xmlNsPtr) node) &&
3650: (xmlStrEqual(ns->prefix, ((xmlNsPtr)cur->nodeTab[i])->prefix)))
3651: return(0);
3652: }
3653:
3654: /*
3655: * grow the nodeTab if needed
3656: */
3657: if (cur->nodeMax == 0) {
3658: cur->nodeTab = (xmlNodePtr *) xmlMalloc(XML_NODESET_DEFAULT *
3659: sizeof(xmlNodePtr));
3660: if (cur->nodeTab == NULL) {
3661: xmlXPathErrMemory(NULL, "growing nodeset\n");
3662: return(-1);
3663: }
3664: memset(cur->nodeTab, 0 ,
3665: XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
3666: cur->nodeMax = XML_NODESET_DEFAULT;
3667: } else if (cur->nodeNr == cur->nodeMax) {
3668: xmlNodePtr *temp;
3669:
3670: if (cur->nodeMax >= XPATH_MAX_NODESET_LENGTH) {
3671: xmlXPathErrMemory(NULL, "growing nodeset hit limit\n");
3672: return(-1);
3673: }
3674: temp = (xmlNodePtr *) xmlRealloc(cur->nodeTab, cur->nodeMax * 2 *
3675: sizeof(xmlNodePtr));
3676: if (temp == NULL) {
3677: xmlXPathErrMemory(NULL, "growing nodeset\n");
3678: return(-1);
3679: }
3680: cur->nodeMax *= 2;
3681: cur->nodeTab = temp;
3682: }
3683: cur->nodeTab[cur->nodeNr++] = xmlXPathNodeSetDupNs(node, ns);
3684: return(0);
3685: }
3686:
3687: /**
3688: * xmlXPathNodeSetAdd:
3689: * @cur: the initial node set
3690: * @val: a new xmlNodePtr
3691: *
3692: * add a new xmlNodePtr to an existing NodeSet
3693: *
3694: * Returns 0 in case of success, and -1 in case of error
3695: */
3696: int
3697: xmlXPathNodeSetAdd(xmlNodeSetPtr cur, xmlNodePtr val) {
3698: int i;
3699:
3700: if ((cur == NULL) || (val == NULL)) return(-1);
3701:
3702: /* @@ with_ns to check whether namespace nodes should be looked at @@ */
3703: /*
3704: * prevent duplcates
3705: */
3706: for (i = 0;i < cur->nodeNr;i++)
3707: if (cur->nodeTab[i] == val) return(0);
3708:
3709: /*
3710: * grow the nodeTab if needed
3711: */
3712: if (cur->nodeMax == 0) {
3713: cur->nodeTab = (xmlNodePtr *) xmlMalloc(XML_NODESET_DEFAULT *
3714: sizeof(xmlNodePtr));
3715: if (cur->nodeTab == NULL) {
3716: xmlXPathErrMemory(NULL, "growing nodeset\n");
3717: return(-1);
3718: }
3719: memset(cur->nodeTab, 0 ,
3720: XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
3721: cur->nodeMax = XML_NODESET_DEFAULT;
3722: } else if (cur->nodeNr == cur->nodeMax) {
3723: xmlNodePtr *temp;
3724:
3725: if (cur->nodeMax >= XPATH_MAX_NODESET_LENGTH) {
3726: xmlXPathErrMemory(NULL, "growing nodeset hit limit\n");
3727: return(-1);
3728: }
3729: temp = (xmlNodePtr *) xmlRealloc(cur->nodeTab, cur->nodeMax * 2 *
3730: sizeof(xmlNodePtr));
3731: if (temp == NULL) {
3732: xmlXPathErrMemory(NULL, "growing nodeset\n");
3733: return(-1);
3734: }
3735: cur->nodeMax *= 2;
3736: cur->nodeTab = temp;
3737: }
3738: if (val->type == XML_NAMESPACE_DECL) {
3739: xmlNsPtr ns = (xmlNsPtr) val;
3740:
3741: cur->nodeTab[cur->nodeNr++] =
3742: xmlXPathNodeSetDupNs((xmlNodePtr) ns->next, ns);
3743: } else
3744: cur->nodeTab[cur->nodeNr++] = val;
3745: return(0);
3746: }
3747:
3748: /**
3749: * xmlXPathNodeSetAddUnique:
3750: * @cur: the initial node set
3751: * @val: a new xmlNodePtr
3752: *
3753: * add a new xmlNodePtr to an existing NodeSet, optimized version
3754: * when we are sure the node is not already in the set.
3755: *
3756: * Returns 0 in case of success and -1 in case of failure
3757: */
3758: int
3759: xmlXPathNodeSetAddUnique(xmlNodeSetPtr cur, xmlNodePtr val) {
3760: if ((cur == NULL) || (val == NULL)) return(-1);
3761:
3762: /* @@ with_ns to check whether namespace nodes should be looked at @@ */
3763: /*
3764: * grow the nodeTab if needed
3765: */
3766: if (cur->nodeMax == 0) {
3767: cur->nodeTab = (xmlNodePtr *) xmlMalloc(XML_NODESET_DEFAULT *
3768: sizeof(xmlNodePtr));
3769: if (cur->nodeTab == NULL) {
3770: xmlXPathErrMemory(NULL, "growing nodeset\n");
3771: return(-1);
3772: }
3773: memset(cur->nodeTab, 0 ,
3774: XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
3775: cur->nodeMax = XML_NODESET_DEFAULT;
3776: } else if (cur->nodeNr == cur->nodeMax) {
3777: xmlNodePtr *temp;
3778:
3779: if (cur->nodeMax >= XPATH_MAX_NODESET_LENGTH) {
3780: xmlXPathErrMemory(NULL, "growing nodeset hit limit\n");
3781: return(-1);
3782: }
3783: temp = (xmlNodePtr *) xmlRealloc(cur->nodeTab, cur->nodeMax * 2 *
3784: sizeof(xmlNodePtr));
3785: if (temp == NULL) {
3786: xmlXPathErrMemory(NULL, "growing nodeset\n");
3787: return(-1);
3788: }
3789: cur->nodeTab = temp;
3790: cur->nodeMax *= 2;
3791: }
3792: if (val->type == XML_NAMESPACE_DECL) {
3793: xmlNsPtr ns = (xmlNsPtr) val;
3794:
3795: cur->nodeTab[cur->nodeNr++] =
3796: xmlXPathNodeSetDupNs((xmlNodePtr) ns->next, ns);
3797: } else
3798: cur->nodeTab[cur->nodeNr++] = val;
3799: return(0);
3800: }
3801:
3802: /**
3803: * xmlXPathNodeSetMerge:
3804: * @val1: the first NodeSet or NULL
3805: * @val2: the second NodeSet
3806: *
3807: * Merges two nodesets, all nodes from @val2 are added to @val1
3808: * if @val1 is NULL, a new set is created and copied from @val2
3809: *
3810: * Returns @val1 once extended or NULL in case of error.
3811: */
3812: xmlNodeSetPtr
3813: xmlXPathNodeSetMerge(xmlNodeSetPtr val1, xmlNodeSetPtr val2) {
3814: int i, j, initNr, skip;
3815: xmlNodePtr n1, n2;
3816:
3817: if (val2 == NULL) return(val1);
3818: if (val1 == NULL) {
3819: val1 = xmlXPathNodeSetCreate(NULL);
3820: if (val1 == NULL)
3821: return (NULL);
3822: #if 0
3823: /*
3824: * TODO: The optimization won't work in every case, since
3825: * those nasty namespace nodes need to be added with
3826: * xmlXPathNodeSetDupNs() to the set; thus a pure
3827: * memcpy is not possible.
3828: * If there was a flag on the nodesetval, indicating that
3829: * some temporary nodes are in, that would be helpfull.
3830: */
3831: /*
3832: * Optimization: Create an equally sized node-set
3833: * and memcpy the content.
3834: */
3835: val1 = xmlXPathNodeSetCreateSize(val2->nodeNr);
3836: if (val1 == NULL)
3837: return(NULL);
3838: if (val2->nodeNr != 0) {
3839: if (val2->nodeNr == 1)
3840: *(val1->nodeTab) = *(val2->nodeTab);
3841: else {
3842: memcpy(val1->nodeTab, val2->nodeTab,
3843: val2->nodeNr * sizeof(xmlNodePtr));
3844: }
3845: val1->nodeNr = val2->nodeNr;
3846: }
3847: return(val1);
3848: #endif
3849: }
3850:
3851: /* @@ with_ns to check whether namespace nodes should be looked at @@ */
3852: initNr = val1->nodeNr;
3853:
3854: for (i = 0;i < val2->nodeNr;i++) {
3855: n2 = val2->nodeTab[i];
3856: /*
3857: * check against duplicates
3858: */
3859: skip = 0;
3860: for (j = 0; j < initNr; j++) {
3861: n1 = val1->nodeTab[j];
3862: if (n1 == n2) {
3863: skip = 1;
3864: break;
3865: } else if ((n1->type == XML_NAMESPACE_DECL) &&
3866: (n2->type == XML_NAMESPACE_DECL)) {
3867: if ((((xmlNsPtr) n1)->next == ((xmlNsPtr) n2)->next) &&
3868: (xmlStrEqual(((xmlNsPtr) n1)->prefix,
3869: ((xmlNsPtr) n2)->prefix)))
3870: {
3871: skip = 1;
3872: break;
3873: }
3874: }
3875: }
3876: if (skip)
3877: continue;
3878:
3879: /*
3880: * grow the nodeTab if needed
3881: */
3882: if (val1->nodeMax == 0) {
3883: val1->nodeTab = (xmlNodePtr *) xmlMalloc(XML_NODESET_DEFAULT *
3884: sizeof(xmlNodePtr));
3885: if (val1->nodeTab == NULL) {
3886: xmlXPathErrMemory(NULL, "merging nodeset\n");
3887: return(NULL);
3888: }
3889: memset(val1->nodeTab, 0 ,
3890: XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
3891: val1->nodeMax = XML_NODESET_DEFAULT;
3892: } else if (val1->nodeNr == val1->nodeMax) {
3893: xmlNodePtr *temp;
3894:
3895: if (val1->nodeMax >= XPATH_MAX_NODESET_LENGTH) {
3896: xmlXPathErrMemory(NULL, "merging nodeset hit limit\n");
3897: return(NULL);
3898: }
3899: temp = (xmlNodePtr *) xmlRealloc(val1->nodeTab, val1->nodeMax * 2 *
3900: sizeof(xmlNodePtr));
3901: if (temp == NULL) {
3902: xmlXPathErrMemory(NULL, "merging nodeset\n");
3903: return(NULL);
3904: }
3905: val1->nodeTab = temp;
3906: val1->nodeMax *= 2;
3907: }
3908: if (n2->type == XML_NAMESPACE_DECL) {
3909: xmlNsPtr ns = (xmlNsPtr) n2;
3910:
3911: val1->nodeTab[val1->nodeNr++] =
3912: xmlXPathNodeSetDupNs((xmlNodePtr) ns->next, ns);
3913: } else
3914: val1->nodeTab[val1->nodeNr++] = n2;
3915: }
3916:
3917: return(val1);
3918: }
3919:
3920:
3921: /**
3922: * xmlXPathNodeSetMergeAndClear:
3923: * @set1: the first NodeSet or NULL
3924: * @set2: the second NodeSet
3925: * @hasSet2NsNodes: 1 if set2 contains namespaces nodes
3926: *
3927: * Merges two nodesets, all nodes from @set2 are added to @set1
3928: * if @set1 is NULL, a new set is created and copied from @set2.
3929: * Checks for duplicate nodes. Clears set2.
3930: *
3931: * Returns @set1 once extended or NULL in case of error.
3932: */
3933: static xmlNodeSetPtr
3934: xmlXPathNodeSetMergeAndClear(xmlNodeSetPtr set1, xmlNodeSetPtr set2,
3935: int hasNullEntries)
3936: {
3937: if ((set1 == NULL) && (hasNullEntries == 0)) {
3938: /*
3939: * Note that doing a memcpy of the list, namespace nodes are
3940: * just assigned to set1, since set2 is cleared anyway.
3941: */
3942: set1 = xmlXPathNodeSetCreateSize(set2->nodeNr);
3943: if (set1 == NULL)
3944: return(NULL);
3945: if (set2->nodeNr != 0) {
3946: memcpy(set1->nodeTab, set2->nodeTab,
3947: set2->nodeNr * sizeof(xmlNodePtr));
3948: set1->nodeNr = set2->nodeNr;
3949: }
3950: } else {
3951: int i, j, initNbSet1;
3952: xmlNodePtr n1, n2;
3953:
3954: if (set1 == NULL)
3955: set1 = xmlXPathNodeSetCreate(NULL);
3956: if (set1 == NULL)
3957: return (NULL);
3958:
3959: initNbSet1 = set1->nodeNr;
3960: for (i = 0;i < set2->nodeNr;i++) {
3961: n2 = set2->nodeTab[i];
3962: /*
3963: * Skip NULLed entries.
3964: */
3965: if (n2 == NULL)
3966: continue;
3967: /*
3968: * Skip duplicates.
3969: */
3970: for (j = 0; j < initNbSet1; j++) {
3971: n1 = set1->nodeTab[j];
3972: if (n1 == n2) {
3973: goto skip_node;
3974: } else if ((n1->type == XML_NAMESPACE_DECL) &&
3975: (n2->type == XML_NAMESPACE_DECL))
3976: {
3977: if ((((xmlNsPtr) n1)->next == ((xmlNsPtr) n2)->next) &&
3978: (xmlStrEqual(((xmlNsPtr) n1)->prefix,
3979: ((xmlNsPtr) n2)->prefix)))
3980: {
3981: /*
3982: * Free the namespace node.
3983: */
3984: set2->nodeTab[i] = NULL;
3985: xmlXPathNodeSetFreeNs((xmlNsPtr) n2);
3986: goto skip_node;
3987: }
3988: }
3989: }
3990: /*
3991: * grow the nodeTab if needed
3992: */
3993: if (set1->nodeMax == 0) {
3994: set1->nodeTab = (xmlNodePtr *) xmlMalloc(
3995: XML_NODESET_DEFAULT * sizeof(xmlNodePtr));
3996: if (set1->nodeTab == NULL) {
3997: xmlXPathErrMemory(NULL, "merging nodeset\n");
3998: return(NULL);
3999: }
4000: memset(set1->nodeTab, 0,
4001: XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
4002: set1->nodeMax = XML_NODESET_DEFAULT;
4003: } else if (set1->nodeNr >= set1->nodeMax) {
4004: xmlNodePtr *temp;
4005:
4006: if (set1->nodeMax >= XPATH_MAX_NODESET_LENGTH) {
4007: xmlXPathErrMemory(NULL, "merging nodeset hit limit\n");
4008: return(NULL);
4009: }
4010: temp = (xmlNodePtr *) xmlRealloc(
4011: set1->nodeTab, set1->nodeMax * 2 * sizeof(xmlNodePtr));
4012: if (temp == NULL) {
4013: xmlXPathErrMemory(NULL, "merging nodeset\n");
4014: return(NULL);
4015: }
4016: set1->nodeTab = temp;
4017: set1->nodeMax *= 2;
4018: }
4019: if (n2->type == XML_NAMESPACE_DECL) {
4020: xmlNsPtr ns = (xmlNsPtr) n2;
4021:
4022: set1->nodeTab[set1->nodeNr++] =
4023: xmlXPathNodeSetDupNs((xmlNodePtr) ns->next, ns);
4024: } else
4025: set1->nodeTab[set1->nodeNr++] = n2;
4026: skip_node:
4027: {}
4028: }
4029: }
4030: set2->nodeNr = 0;
4031: return(set1);
4032: }
4033:
4034: /**
4035: * xmlXPathNodeSetMergeAndClearNoDupls:
4036: * @set1: the first NodeSet or NULL
4037: * @set2: the second NodeSet
4038: * @hasSet2NsNodes: 1 if set2 contains namespaces nodes
4039: *
4040: * Merges two nodesets, all nodes from @set2 are added to @set1
4041: * if @set1 is NULL, a new set is created and copied from @set2.
4042: * Doesn't chack for duplicate nodes. Clears set2.
4043: *
4044: * Returns @set1 once extended or NULL in case of error.
4045: */
4046: static xmlNodeSetPtr
4047: xmlXPathNodeSetMergeAndClearNoDupls(xmlNodeSetPtr set1, xmlNodeSetPtr set2,
4048: int hasNullEntries)
4049: {
4050: if (set2 == NULL)
4051: return(set1);
4052: if ((set1 == NULL) && (hasNullEntries == 0)) {
4053: /*
4054: * Note that doing a memcpy of the list, namespace nodes are
4055: * just assigned to set1, since set2 is cleared anyway.
4056: */
4057: set1 = xmlXPathNodeSetCreateSize(set2->nodeNr);
4058: if (set1 == NULL)
4059: return(NULL);
4060: if (set2->nodeNr != 0) {
4061: memcpy(set1->nodeTab, set2->nodeTab,
4062: set2->nodeNr * sizeof(xmlNodePtr));
4063: set1->nodeNr = set2->nodeNr;
4064: }
4065: } else {
4066: int i;
4067: xmlNodePtr n2;
4068:
4069: if (set1 == NULL)
4070: set1 = xmlXPathNodeSetCreate(NULL);
4071: if (set1 == NULL)
4072: return (NULL);
4073:
4074: for (i = 0;i < set2->nodeNr;i++) {
4075: n2 = set2->nodeTab[i];
4076: /*
4077: * Skip NULLed entries.
4078: */
4079: if (n2 == NULL)
4080: continue;
4081: if (set1->nodeMax == 0) {
4082: set1->nodeTab = (xmlNodePtr *) xmlMalloc(
4083: XML_NODESET_DEFAULT * sizeof(xmlNodePtr));
4084: if (set1->nodeTab == NULL) {
4085: xmlXPathErrMemory(NULL, "merging nodeset\n");
4086: return(NULL);
4087: }
4088: memset(set1->nodeTab, 0,
4089: XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
4090: set1->nodeMax = XML_NODESET_DEFAULT;
4091: } else if (set1->nodeNr >= set1->nodeMax) {
4092: xmlNodePtr *temp;
4093:
4094: if (set1->nodeMax >= XPATH_MAX_NODESET_LENGTH) {
4095: xmlXPathErrMemory(NULL, "merging nodeset hit limit\n");
4096: return(NULL);
4097: }
4098: temp = (xmlNodePtr *) xmlRealloc(
4099: set1->nodeTab, set1->nodeMax * 2 * sizeof(xmlNodePtr));
4100: if (temp == NULL) {
4101: xmlXPathErrMemory(NULL, "merging nodeset\n");
4102: return(NULL);
4103: }
4104: set1->nodeTab = temp;
4105: set1->nodeMax *= 2;
4106: }
4107: set1->nodeTab[set1->nodeNr++] = n2;
4108: }
4109: }
4110: set2->nodeNr = 0;
4111: return(set1);
4112: }
4113:
4114: /**
4115: * xmlXPathNodeSetDel:
4116: * @cur: the initial node set
4117: * @val: an xmlNodePtr
4118: *
4119: * Removes an xmlNodePtr from an existing NodeSet
4120: */
4121: void
4122: xmlXPathNodeSetDel(xmlNodeSetPtr cur, xmlNodePtr val) {
4123: int i;
4124:
4125: if (cur == NULL) return;
4126: if (val == NULL) return;
4127:
4128: /*
4129: * find node in nodeTab
4130: */
4131: for (i = 0;i < cur->nodeNr;i++)
4132: if (cur->nodeTab[i] == val) break;
4133:
4134: if (i >= cur->nodeNr) { /* not found */
4135: #ifdef DEBUG
4136: xmlGenericError(xmlGenericErrorContext,
4137: "xmlXPathNodeSetDel: Node %s wasn't found in NodeList\n",
4138: val->name);
4139: #endif
4140: return;
4141: }
4142: if ((cur->nodeTab[i] != NULL) &&
4143: (cur->nodeTab[i]->type == XML_NAMESPACE_DECL))
4144: xmlXPathNodeSetFreeNs((xmlNsPtr) cur->nodeTab[i]);
4145: cur->nodeNr--;
4146: for (;i < cur->nodeNr;i++)
4147: cur->nodeTab[i] = cur->nodeTab[i + 1];
4148: cur->nodeTab[cur->nodeNr] = NULL;
4149: }
4150:
4151: /**
4152: * xmlXPathNodeSetRemove:
4153: * @cur: the initial node set
4154: * @val: the index to remove
4155: *
4156: * Removes an entry from an existing NodeSet list.
4157: */
4158: void
4159: xmlXPathNodeSetRemove(xmlNodeSetPtr cur, int val) {
4160: if (cur == NULL) return;
4161: if (val >= cur->nodeNr) return;
4162: if ((cur->nodeTab[val] != NULL) &&
4163: (cur->nodeTab[val]->type == XML_NAMESPACE_DECL))
4164: xmlXPathNodeSetFreeNs((xmlNsPtr) cur->nodeTab[val]);
4165: cur->nodeNr--;
4166: for (;val < cur->nodeNr;val++)
4167: cur->nodeTab[val] = cur->nodeTab[val + 1];
4168: cur->nodeTab[cur->nodeNr] = NULL;
4169: }
4170:
4171: /**
4172: * xmlXPathFreeNodeSet:
4173: * @obj: the xmlNodeSetPtr to free
4174: *
4175: * Free the NodeSet compound (not the actual nodes !).
4176: */
4177: void
4178: xmlXPathFreeNodeSet(xmlNodeSetPtr obj) {
4179: if (obj == NULL) return;
4180: if (obj->nodeTab != NULL) {
4181: int i;
4182:
4183: /* @@ with_ns to check whether namespace nodes should be looked at @@ */
4184: for (i = 0;i < obj->nodeNr;i++)
4185: if ((obj->nodeTab[i] != NULL) &&
4186: (obj->nodeTab[i]->type == XML_NAMESPACE_DECL))
4187: xmlXPathNodeSetFreeNs((xmlNsPtr) obj->nodeTab[i]);
4188: xmlFree(obj->nodeTab);
4189: }
4190: xmlFree(obj);
4191: }
4192:
4193: /**
4194: * xmlXPathNodeSetClear:
4195: * @set: the node set to clear
4196: *
4197: * Clears the list from all temporary XPath objects (e.g. namespace nodes
4198: * are feed), but does *not* free the list itself. Sets the length of the
4199: * list to 0.
4200: */
4201: static void
4202: xmlXPathNodeSetClear(xmlNodeSetPtr set, int hasNsNodes)
4203: {
4204: if ((set == NULL) || (set->nodeNr <= 0))
4205: return;
4206: else if (hasNsNodes) {
4207: int i;
4208: xmlNodePtr node;
4209:
4210: for (i = 0; i < set->nodeNr; i++) {
4211: node = set->nodeTab[i];
4212: if ((node != NULL) &&
4213: (node->type == XML_NAMESPACE_DECL))
4214: xmlXPathNodeSetFreeNs((xmlNsPtr) node);
4215: }
4216: }
4217: set->nodeNr = 0;
4218: }
4219:
4220: /**
4221: * xmlXPathNodeSetClearFromPos:
4222: * @set: the node set to be cleared
4223: * @pos: the start position to clear from
4224: *
4225: * Clears the list from temporary XPath objects (e.g. namespace nodes
4226: * are feed) starting with the entry at @pos, but does *not* free the list
4227: * itself. Sets the length of the list to @pos.
4228: */
4229: static void
4230: xmlXPathNodeSetClearFromPos(xmlNodeSetPtr set, int pos, int hasNsNodes)
4231: {
4232: if ((set == NULL) || (set->nodeNr <= 0) || (pos >= set->nodeNr))
4233: return;
4234: else if ((hasNsNodes)) {
4235: int i;
4236: xmlNodePtr node;
4237:
4238: for (i = pos; i < set->nodeNr; i++) {
4239: node = set->nodeTab[i];
4240: if ((node != NULL) &&
4241: (node->type == XML_NAMESPACE_DECL))
4242: xmlXPathNodeSetFreeNs((xmlNsPtr) node);
4243: }
4244: }
4245: set->nodeNr = pos;
4246: }
4247:
4248: /**
4249: * xmlXPathFreeValueTree:
4250: * @obj: the xmlNodeSetPtr to free
4251: *
4252: * Free the NodeSet compound and the actual tree, this is different
4253: * from xmlXPathFreeNodeSet()
4254: */
4255: static void
4256: xmlXPathFreeValueTree(xmlNodeSetPtr obj) {
4257: int i;
4258:
4259: if (obj == NULL) return;
4260:
4261: if (obj->nodeTab != NULL) {
4262: for (i = 0;i < obj->nodeNr;i++) {
4263: if (obj->nodeTab[i] != NULL) {
4264: if (obj->nodeTab[i]->type == XML_NAMESPACE_DECL) {
4265: xmlXPathNodeSetFreeNs((xmlNsPtr) obj->nodeTab[i]);
4266: } else {
4267: xmlFreeNodeList(obj->nodeTab[i]);
4268: }
4269: }
4270: }
4271: xmlFree(obj->nodeTab);
4272: }
4273: xmlFree(obj);
4274: }
4275:
4276: #if defined(DEBUG) || defined(DEBUG_STEP)
4277: /**
4278: * xmlGenericErrorContextNodeSet:
4279: * @output: a FILE * for the output
4280: * @obj: the xmlNodeSetPtr to display
4281: *
4282: * Quick display of a NodeSet
4283: */
4284: void
4285: xmlGenericErrorContextNodeSet(FILE *output, xmlNodeSetPtr obj) {
4286: int i;
4287:
4288: if (output == NULL) output = xmlGenericErrorContext;
4289: if (obj == NULL) {
4290: fprintf(output, "NodeSet == NULL !\n");
4291: return;
4292: }
4293: if (obj->nodeNr == 0) {
4294: fprintf(output, "NodeSet is empty\n");
4295: return;
4296: }
4297: if (obj->nodeTab == NULL) {
4298: fprintf(output, " nodeTab == NULL !\n");
4299: return;
4300: }
4301: for (i = 0; i < obj->nodeNr; i++) {
4302: if (obj->nodeTab[i] == NULL) {
4303: fprintf(output, " NULL !\n");
4304: return;
4305: }
4306: if ((obj->nodeTab[i]->type == XML_DOCUMENT_NODE) ||
4307: (obj->nodeTab[i]->type == XML_HTML_DOCUMENT_NODE))
4308: fprintf(output, " /");
4309: else if (obj->nodeTab[i]->name == NULL)
4310: fprintf(output, " noname!");
4311: else fprintf(output, " %s", obj->nodeTab[i]->name);
4312: }
4313: fprintf(output, "\n");
4314: }
4315: #endif
4316:
4317: /**
4318: * xmlXPathNewNodeSet:
4319: * @val: the NodePtr value
4320: *
4321: * Create a new xmlXPathObjectPtr of type NodeSet and initialize
4322: * it with the single Node @val
4323: *
4324: * Returns the newly created object.
4325: */
4326: xmlXPathObjectPtr
4327: xmlXPathNewNodeSet(xmlNodePtr val) {
4328: xmlXPathObjectPtr ret;
4329:
4330: ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
4331: if (ret == NULL) {
4332: xmlXPathErrMemory(NULL, "creating nodeset\n");
4333: return(NULL);
4334: }
4335: memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
4336: ret->type = XPATH_NODESET;
4337: ret->boolval = 0;
4338: ret->nodesetval = xmlXPathNodeSetCreate(val);
4339: /* @@ with_ns to check whether namespace nodes should be looked at @@ */
4340: #ifdef XP_DEBUG_OBJ_USAGE
4341: xmlXPathDebugObjUsageRequested(NULL, XPATH_NODESET);
4342: #endif
4343: return(ret);
4344: }
4345:
4346: /**
4347: * xmlXPathNewValueTree:
4348: * @val: the NodePtr value
4349: *
4350: * Create a new xmlXPathObjectPtr of type Value Tree (XSLT) and initialize
4351: * it with the tree root @val
4352: *
4353: * Returns the newly created object.
4354: */
4355: xmlXPathObjectPtr
4356: xmlXPathNewValueTree(xmlNodePtr val) {
4357: xmlXPathObjectPtr ret;
4358:
4359: ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
4360: if (ret == NULL) {
4361: xmlXPathErrMemory(NULL, "creating result value tree\n");
4362: return(NULL);
4363: }
4364: memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
4365: ret->type = XPATH_XSLT_TREE;
4366: ret->boolval = 1;
4367: ret->user = (void *) val;
4368: ret->nodesetval = xmlXPathNodeSetCreate(val);
4369: #ifdef XP_DEBUG_OBJ_USAGE
4370: xmlXPathDebugObjUsageRequested(NULL, XPATH_XSLT_TREE);
4371: #endif
4372: return(ret);
4373: }
4374:
4375: /**
4376: * xmlXPathNewNodeSetList:
4377: * @val: an existing NodeSet
4378: *
4379: * Create a new xmlXPathObjectPtr of type NodeSet and initialize
4380: * it with the Nodeset @val
4381: *
4382: * Returns the newly created object.
4383: */
4384: xmlXPathObjectPtr
4385: xmlXPathNewNodeSetList(xmlNodeSetPtr val)
4386: {
4387: xmlXPathObjectPtr ret;
4388: int i;
4389:
4390: if (val == NULL)
4391: ret = NULL;
4392: else if (val->nodeTab == NULL)
4393: ret = xmlXPathNewNodeSet(NULL);
4394: else {
4395: ret = xmlXPathNewNodeSet(val->nodeTab[0]);
4396: if (ret) {
4397: for (i = 1; i < val->nodeNr; ++i) {
4398: if (xmlXPathNodeSetAddUnique(ret->nodesetval, val->nodeTab[i])
4399: < 0) break;
4400: }
4401: }
4402: }
4403:
4404: return (ret);
4405: }
4406:
4407: /**
4408: * xmlXPathWrapNodeSet:
4409: * @val: the NodePtr value
4410: *
4411: * Wrap the Nodeset @val in a new xmlXPathObjectPtr
4412: *
4413: * Returns the newly created object.
4414: */
4415: xmlXPathObjectPtr
4416: xmlXPathWrapNodeSet(xmlNodeSetPtr val) {
4417: xmlXPathObjectPtr ret;
4418:
4419: ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
4420: if (ret == NULL) {
4421: xmlXPathErrMemory(NULL, "creating node set object\n");
4422: return(NULL);
4423: }
4424: memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
4425: ret->type = XPATH_NODESET;
4426: ret->nodesetval = val;
4427: #ifdef XP_DEBUG_OBJ_USAGE
4428: xmlXPathDebugObjUsageRequested(NULL, XPATH_NODESET);
4429: #endif
4430: return(ret);
4431: }
4432:
4433: /**
4434: * xmlXPathFreeNodeSetList:
4435: * @obj: an existing NodeSetList object
4436: *
4437: * Free up the xmlXPathObjectPtr @obj but don't deallocate the objects in
4438: * the list contrary to xmlXPathFreeObject().
4439: */
4440: void
4441: xmlXPathFreeNodeSetList(xmlXPathObjectPtr obj) {
4442: if (obj == NULL) return;
4443: #ifdef XP_DEBUG_OBJ_USAGE
4444: xmlXPathDebugObjUsageReleased(NULL, obj->type);
4445: #endif
4446: xmlFree(obj);
4447: }
4448:
4449: /**
4450: * xmlXPathDifference:
4451: * @nodes1: a node-set
4452: * @nodes2: a node-set
4453: *
4454: * Implements the EXSLT - Sets difference() function:
4455: * node-set set:difference (node-set, node-set)
4456: *
4457: * Returns the difference between the two node sets, or nodes1 if
4458: * nodes2 is empty
4459: */
4460: xmlNodeSetPtr
4461: xmlXPathDifference (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
4462: xmlNodeSetPtr ret;
4463: int i, l1;
4464: xmlNodePtr cur;
4465:
4466: if (xmlXPathNodeSetIsEmpty(nodes2))
4467: return(nodes1);
4468:
4469: ret = xmlXPathNodeSetCreate(NULL);
4470: if (xmlXPathNodeSetIsEmpty(nodes1))
4471: return(ret);
4472:
4473: l1 = xmlXPathNodeSetGetLength(nodes1);
4474:
4475: for (i = 0; i < l1; i++) {
4476: cur = xmlXPathNodeSetItem(nodes1, i);
4477: if (!xmlXPathNodeSetContains(nodes2, cur)) {
4478: if (xmlXPathNodeSetAddUnique(ret, cur) < 0)
4479: break;
4480: }
4481: }
4482: return(ret);
4483: }
4484:
4485: /**
4486: * xmlXPathIntersection:
4487: * @nodes1: a node-set
4488: * @nodes2: a node-set
4489: *
4490: * Implements the EXSLT - Sets intersection() function:
4491: * node-set set:intersection (node-set, node-set)
4492: *
4493: * Returns a node set comprising the nodes that are within both the
4494: * node sets passed as arguments
4495: */
4496: xmlNodeSetPtr
4497: xmlXPathIntersection (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
4498: xmlNodeSetPtr ret = xmlXPathNodeSetCreate(NULL);
4499: int i, l1;
4500: xmlNodePtr cur;
4501:
4502: if (ret == NULL)
4503: return(ret);
4504: if (xmlXPathNodeSetIsEmpty(nodes1))
4505: return(ret);
4506: if (xmlXPathNodeSetIsEmpty(nodes2))
4507: return(ret);
4508:
4509: l1 = xmlXPathNodeSetGetLength(nodes1);
4510:
4511: for (i = 0; i < l1; i++) {
4512: cur = xmlXPathNodeSetItem(nodes1, i);
4513: if (xmlXPathNodeSetContains(nodes2, cur)) {
4514: if (xmlXPathNodeSetAddUnique(ret, cur) < 0)
4515: break;
4516: }
4517: }
4518: return(ret);
4519: }
4520:
4521: /**
4522: * xmlXPathDistinctSorted:
4523: * @nodes: a node-set, sorted by document order
4524: *
4525: * Implements the EXSLT - Sets distinct() function:
4526: * node-set set:distinct (node-set)
4527: *
4528: * Returns a subset of the nodes contained in @nodes, or @nodes if
4529: * it is empty
4530: */
4531: xmlNodeSetPtr
4532: xmlXPathDistinctSorted (xmlNodeSetPtr nodes) {
4533: xmlNodeSetPtr ret;
4534: xmlHashTablePtr hash;
4535: int i, l;
4536: xmlChar * strval;
4537: xmlNodePtr cur;
4538:
4539: if (xmlXPathNodeSetIsEmpty(nodes))
4540: return(nodes);
4541:
4542: ret = xmlXPathNodeSetCreate(NULL);
4543: if (ret == NULL)
4544: return(ret);
4545: l = xmlXPathNodeSetGetLength(nodes);
4546: hash = xmlHashCreate (l);
4547: for (i = 0; i < l; i++) {
4548: cur = xmlXPathNodeSetItem(nodes, i);
4549: strval = xmlXPathCastNodeToString(cur);
4550: if (xmlHashLookup(hash, strval) == NULL) {
4551: xmlHashAddEntry(hash, strval, strval);
4552: if (xmlXPathNodeSetAddUnique(ret, cur) < 0)
4553: break;
4554: } else {
4555: xmlFree(strval);
4556: }
4557: }
4558: xmlHashFree(hash, (xmlHashDeallocator) xmlFree);
4559: return(ret);
4560: }
4561:
4562: /**
4563: * xmlXPathDistinct:
4564: * @nodes: a node-set
4565: *
4566: * Implements the EXSLT - Sets distinct() function:
4567: * node-set set:distinct (node-set)
4568: * @nodes is sorted by document order, then #exslSetsDistinctSorted
4569: * is called with the sorted node-set
4570: *
4571: * Returns a subset of the nodes contained in @nodes, or @nodes if
4572: * it is empty
4573: */
4574: xmlNodeSetPtr
4575: xmlXPathDistinct (xmlNodeSetPtr nodes) {
4576: if (xmlXPathNodeSetIsEmpty(nodes))
4577: return(nodes);
4578:
4579: xmlXPathNodeSetSort(nodes);
4580: return(xmlXPathDistinctSorted(nodes));
4581: }
4582:
4583: /**
4584: * xmlXPathHasSameNodes:
4585: * @nodes1: a node-set
4586: * @nodes2: a node-set
4587: *
4588: * Implements the EXSLT - Sets has-same-nodes function:
4589: * boolean set:has-same-node(node-set, node-set)
4590: *
4591: * Returns true (1) if @nodes1 shares any node with @nodes2, false (0)
4592: * otherwise
4593: */
4594: int
4595: xmlXPathHasSameNodes (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
4596: int i, l;
4597: xmlNodePtr cur;
4598:
4599: if (xmlXPathNodeSetIsEmpty(nodes1) ||
4600: xmlXPathNodeSetIsEmpty(nodes2))
4601: return(0);
4602:
4603: l = xmlXPathNodeSetGetLength(nodes1);
4604: for (i = 0; i < l; i++) {
4605: cur = xmlXPathNodeSetItem(nodes1, i);
4606: if (xmlXPathNodeSetContains(nodes2, cur))
4607: return(1);
4608: }
4609: return(0);
4610: }
4611:
4612: /**
4613: * xmlXPathNodeLeadingSorted:
4614: * @nodes: a node-set, sorted by document order
4615: * @node: a node
4616: *
4617: * Implements the EXSLT - Sets leading() function:
4618: * node-set set:leading (node-set, node-set)
4619: *
4620: * Returns the nodes in @nodes that precede @node in document order,
4621: * @nodes if @node is NULL or an empty node-set if @nodes
4622: * doesn't contain @node
4623: */
4624: xmlNodeSetPtr
4625: xmlXPathNodeLeadingSorted (xmlNodeSetPtr nodes, xmlNodePtr node) {
4626: int i, l;
4627: xmlNodePtr cur;
4628: xmlNodeSetPtr ret;
4629:
4630: if (node == NULL)
4631: return(nodes);
4632:
4633: ret = xmlXPathNodeSetCreate(NULL);
4634: if (ret == NULL)
4635: return(ret);
4636: if (xmlXPathNodeSetIsEmpty(nodes) ||
4637: (!xmlXPathNodeSetContains(nodes, node)))
4638: return(ret);
4639:
4640: l = xmlXPathNodeSetGetLength(nodes);
4641: for (i = 0; i < l; i++) {
4642: cur = xmlXPathNodeSetItem(nodes, i);
4643: if (cur == node)
4644: break;
4645: if (xmlXPathNodeSetAddUnique(ret, cur) < 0)
4646: break;
4647: }
4648: return(ret);
4649: }
4650:
4651: /**
4652: * xmlXPathNodeLeading:
4653: * @nodes: a node-set
4654: * @node: a node
4655: *
4656: * Implements the EXSLT - Sets leading() function:
4657: * node-set set:leading (node-set, node-set)
4658: * @nodes is sorted by document order, then #exslSetsNodeLeadingSorted
4659: * is called.
4660: *
4661: * Returns the nodes in @nodes that precede @node in document order,
4662: * @nodes if @node is NULL or an empty node-set if @nodes
4663: * doesn't contain @node
4664: */
4665: xmlNodeSetPtr
4666: xmlXPathNodeLeading (xmlNodeSetPtr nodes, xmlNodePtr node) {
4667: xmlXPathNodeSetSort(nodes);
4668: return(xmlXPathNodeLeadingSorted(nodes, node));
4669: }
4670:
4671: /**
4672: * xmlXPathLeadingSorted:
4673: * @nodes1: a node-set, sorted by document order
4674: * @nodes2: a node-set, sorted by document order
4675: *
4676: * Implements the EXSLT - Sets leading() function:
4677: * node-set set:leading (node-set, node-set)
4678: *
4679: * Returns the nodes in @nodes1 that precede the first node in @nodes2
4680: * in document order, @nodes1 if @nodes2 is NULL or empty or
4681: * an empty node-set if @nodes1 doesn't contain @nodes2
4682: */
4683: xmlNodeSetPtr
4684: xmlXPathLeadingSorted (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
4685: if (xmlXPathNodeSetIsEmpty(nodes2))
4686: return(nodes1);
4687: return(xmlXPathNodeLeadingSorted(nodes1,
4688: xmlXPathNodeSetItem(nodes2, 1)));
4689: }
4690:
4691: /**
4692: * xmlXPathLeading:
4693: * @nodes1: a node-set
4694: * @nodes2: a node-set
4695: *
4696: * Implements the EXSLT - Sets leading() function:
4697: * node-set set:leading (node-set, node-set)
4698: * @nodes1 and @nodes2 are sorted by document order, then
4699: * #exslSetsLeadingSorted is called.
4700: *
4701: * Returns the nodes in @nodes1 that precede the first node in @nodes2
4702: * in document order, @nodes1 if @nodes2 is NULL or empty or
4703: * an empty node-set if @nodes1 doesn't contain @nodes2
4704: */
4705: xmlNodeSetPtr
4706: xmlXPathLeading (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
4707: if (xmlXPathNodeSetIsEmpty(nodes2))
4708: return(nodes1);
4709: if (xmlXPathNodeSetIsEmpty(nodes1))
4710: return(xmlXPathNodeSetCreate(NULL));
4711: xmlXPathNodeSetSort(nodes1);
4712: xmlXPathNodeSetSort(nodes2);
4713: return(xmlXPathNodeLeadingSorted(nodes1,
4714: xmlXPathNodeSetItem(nodes2, 1)));
4715: }
4716:
4717: /**
4718: * xmlXPathNodeTrailingSorted:
4719: * @nodes: a node-set, sorted by document order
4720: * @node: a node
4721: *
4722: * Implements the EXSLT - Sets trailing() function:
4723: * node-set set:trailing (node-set, node-set)
4724: *
4725: * Returns the nodes in @nodes that follow @node in document order,
4726: * @nodes if @node is NULL or an empty node-set if @nodes
4727: * doesn't contain @node
4728: */
4729: xmlNodeSetPtr
4730: xmlXPathNodeTrailingSorted (xmlNodeSetPtr nodes, xmlNodePtr node) {
4731: int i, l;
4732: xmlNodePtr cur;
4733: xmlNodeSetPtr ret;
4734:
4735: if (node == NULL)
4736: return(nodes);
4737:
4738: ret = xmlXPathNodeSetCreate(NULL);
4739: if (ret == NULL)
4740: return(ret);
4741: if (xmlXPathNodeSetIsEmpty(nodes) ||
4742: (!xmlXPathNodeSetContains(nodes, node)))
4743: return(ret);
4744:
4745: l = xmlXPathNodeSetGetLength(nodes);
4746: for (i = l - 1; i >= 0; i--) {
4747: cur = xmlXPathNodeSetItem(nodes, i);
4748: if (cur == node)
4749: break;
4750: if (xmlXPathNodeSetAddUnique(ret, cur) < 0)
4751: break;
4752: }
4753: xmlXPathNodeSetSort(ret); /* bug 413451 */
4754: return(ret);
4755: }
4756:
4757: /**
4758: * xmlXPathNodeTrailing:
4759: * @nodes: a node-set
4760: * @node: a node
4761: *
4762: * Implements the EXSLT - Sets trailing() function:
4763: * node-set set:trailing (node-set, node-set)
4764: * @nodes is sorted by document order, then #xmlXPathNodeTrailingSorted
4765: * is called.
4766: *
4767: * Returns the nodes in @nodes that follow @node in document order,
4768: * @nodes if @node is NULL or an empty node-set if @nodes
4769: * doesn't contain @node
4770: */
4771: xmlNodeSetPtr
4772: xmlXPathNodeTrailing (xmlNodeSetPtr nodes, xmlNodePtr node) {
4773: xmlXPathNodeSetSort(nodes);
4774: return(xmlXPathNodeTrailingSorted(nodes, node));
4775: }
4776:
4777: /**
4778: * xmlXPathTrailingSorted:
4779: * @nodes1: a node-set, sorted by document order
4780: * @nodes2: a node-set, sorted by document order
4781: *
4782: * Implements the EXSLT - Sets trailing() function:
4783: * node-set set:trailing (node-set, node-set)
4784: *
4785: * Returns the nodes in @nodes1 that follow the first node in @nodes2
4786: * in document order, @nodes1 if @nodes2 is NULL or empty or
4787: * an empty node-set if @nodes1 doesn't contain @nodes2
4788: */
4789: xmlNodeSetPtr
4790: xmlXPathTrailingSorted (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
4791: if (xmlXPathNodeSetIsEmpty(nodes2))
4792: return(nodes1);
4793: return(xmlXPathNodeTrailingSorted(nodes1,
4794: xmlXPathNodeSetItem(nodes2, 0)));
4795: }
4796:
4797: /**
4798: * xmlXPathTrailing:
4799: * @nodes1: a node-set
4800: * @nodes2: a node-set
4801: *
4802: * Implements the EXSLT - Sets trailing() function:
4803: * node-set set:trailing (node-set, node-set)
4804: * @nodes1 and @nodes2 are sorted by document order, then
4805: * #xmlXPathTrailingSorted is called.
4806: *
4807: * Returns the nodes in @nodes1 that follow the first node in @nodes2
4808: * in document order, @nodes1 if @nodes2 is NULL or empty or
4809: * an empty node-set if @nodes1 doesn't contain @nodes2
4810: */
4811: xmlNodeSetPtr
4812: xmlXPathTrailing (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
4813: if (xmlXPathNodeSetIsEmpty(nodes2))
4814: return(nodes1);
4815: if (xmlXPathNodeSetIsEmpty(nodes1))
4816: return(xmlXPathNodeSetCreate(NULL));
4817: xmlXPathNodeSetSort(nodes1);
4818: xmlXPathNodeSetSort(nodes2);
4819: return(xmlXPathNodeTrailingSorted(nodes1,
4820: xmlXPathNodeSetItem(nodes2, 0)));
4821: }
4822:
4823: /************************************************************************
4824: * *
4825: * Routines to handle extra functions *
4826: * *
4827: ************************************************************************/
4828:
4829: /**
4830: * xmlXPathRegisterFunc:
4831: * @ctxt: the XPath context
4832: * @name: the function name
4833: * @f: the function implementation or NULL
4834: *
4835: * Register a new function. If @f is NULL it unregisters the function
4836: *
4837: * Returns 0 in case of success, -1 in case of error
4838: */
4839: int
4840: xmlXPathRegisterFunc(xmlXPathContextPtr ctxt, const xmlChar *name,
4841: xmlXPathFunction f) {
4842: return(xmlXPathRegisterFuncNS(ctxt, name, NULL, f));
4843: }
4844:
4845: /**
4846: * xmlXPathRegisterFuncNS:
4847: * @ctxt: the XPath context
4848: * @name: the function name
4849: * @ns_uri: the function namespace URI
4850: * @f: the function implementation or NULL
4851: *
4852: * Register a new function. If @f is NULL it unregisters the function
4853: *
4854: * Returns 0 in case of success, -1 in case of error
4855: */
4856: int
4857: xmlXPathRegisterFuncNS(xmlXPathContextPtr ctxt, const xmlChar *name,
4858: const xmlChar *ns_uri, xmlXPathFunction f) {
4859: if (ctxt == NULL)
4860: return(-1);
4861: if (name == NULL)
4862: return(-1);
4863:
4864: if (ctxt->funcHash == NULL)
4865: ctxt->funcHash = xmlHashCreate(0);
4866: if (ctxt->funcHash == NULL)
4867: return(-1);
4868: if (f == NULL)
4869: return(xmlHashRemoveEntry2(ctxt->funcHash, name, ns_uri, NULL));
4870: return(xmlHashAddEntry2(ctxt->funcHash, name, ns_uri, XML_CAST_FPTR(f)));
4871: }
4872:
4873: /**
4874: * xmlXPathRegisterFuncLookup:
4875: * @ctxt: the XPath context
4876: * @f: the lookup function
4877: * @funcCtxt: the lookup data
4878: *
4879: * Registers an external mechanism to do function lookup.
4880: */
4881: void
4882: xmlXPathRegisterFuncLookup (xmlXPathContextPtr ctxt,
4883: xmlXPathFuncLookupFunc f,
4884: void *funcCtxt) {
4885: if (ctxt == NULL)
4886: return;
4887: ctxt->funcLookupFunc = f;
4888: ctxt->funcLookupData = funcCtxt;
4889: }
4890:
4891: /**
4892: * xmlXPathFunctionLookup:
4893: * @ctxt: the XPath context
4894: * @name: the function name
4895: *
4896: * Search in the Function array of the context for the given
4897: * function.
4898: *
4899: * Returns the xmlXPathFunction or NULL if not found
4900: */
4901: xmlXPathFunction
4902: xmlXPathFunctionLookup(xmlXPathContextPtr ctxt, const xmlChar *name) {
4903: if (ctxt == NULL)
4904: return (NULL);
4905:
4906: if (ctxt->funcLookupFunc != NULL) {
4907: xmlXPathFunction ret;
4908: xmlXPathFuncLookupFunc f;
4909:
4910: f = ctxt->funcLookupFunc;
4911: ret = f(ctxt->funcLookupData, name, NULL);
4912: if (ret != NULL)
4913: return(ret);
4914: }
4915: return(xmlXPathFunctionLookupNS(ctxt, name, NULL));
4916: }
4917:
4918: /**
4919: * xmlXPathFunctionLookupNS:
4920: * @ctxt: the XPath context
4921: * @name: the function name
4922: * @ns_uri: the function namespace URI
4923: *
4924: * Search in the Function array of the context for the given
4925: * function.
4926: *
4927: * Returns the xmlXPathFunction or NULL if not found
4928: */
4929: xmlXPathFunction
4930: xmlXPathFunctionLookupNS(xmlXPathContextPtr ctxt, const xmlChar *name,
4931: const xmlChar *ns_uri) {
4932: xmlXPathFunction ret;
4933:
4934: if (ctxt == NULL)
4935: return(NULL);
4936: if (name == NULL)
4937: return(NULL);
4938:
4939: if (ctxt->funcLookupFunc != NULL) {
4940: xmlXPathFuncLookupFunc f;
4941:
4942: f = ctxt->funcLookupFunc;
4943: ret = f(ctxt->funcLookupData, name, ns_uri);
4944: if (ret != NULL)
4945: return(ret);
4946: }
4947:
4948: if (ctxt->funcHash == NULL)
4949: return(NULL);
4950:
4951: XML_CAST_FPTR(ret) = xmlHashLookup2(ctxt->funcHash, name, ns_uri);
4952: return(ret);
4953: }
4954:
4955: /**
4956: * xmlXPathRegisteredFuncsCleanup:
4957: * @ctxt: the XPath context
4958: *
4959: * Cleanup the XPath context data associated to registered functions
4960: */
4961: void
4962: xmlXPathRegisteredFuncsCleanup(xmlXPathContextPtr ctxt) {
4963: if (ctxt == NULL)
4964: return;
4965:
4966: xmlHashFree(ctxt->funcHash, NULL);
4967: ctxt->funcHash = NULL;
4968: }
4969:
4970: /************************************************************************
4971: * *
4972: * Routines to handle Variables *
4973: * *
4974: ************************************************************************/
4975:
4976: /**
4977: * xmlXPathRegisterVariable:
4978: * @ctxt: the XPath context
4979: * @name: the variable name
4980: * @value: the variable value or NULL
4981: *
4982: * Register a new variable value. If @value is NULL it unregisters
4983: * the variable
4984: *
4985: * Returns 0 in case of success, -1 in case of error
4986: */
4987: int
4988: xmlXPathRegisterVariable(xmlXPathContextPtr ctxt, const xmlChar *name,
4989: xmlXPathObjectPtr value) {
4990: return(xmlXPathRegisterVariableNS(ctxt, name, NULL, value));
4991: }
4992:
4993: /**
4994: * xmlXPathRegisterVariableNS:
4995: * @ctxt: the XPath context
4996: * @name: the variable name
4997: * @ns_uri: the variable namespace URI
4998: * @value: the variable value or NULL
4999: *
5000: * Register a new variable value. If @value is NULL it unregisters
5001: * the variable
5002: *
5003: * Returns 0 in case of success, -1 in case of error
5004: */
5005: int
5006: xmlXPathRegisterVariableNS(xmlXPathContextPtr ctxt, const xmlChar *name,
5007: const xmlChar *ns_uri,
5008: xmlXPathObjectPtr value) {
5009: if (ctxt == NULL)
5010: return(-1);
5011: if (name == NULL)
5012: return(-1);
5013:
5014: if (ctxt->varHash == NULL)
5015: ctxt->varHash = xmlHashCreate(0);
5016: if (ctxt->varHash == NULL)
5017: return(-1);
5018: if (value == NULL)
5019: return(xmlHashRemoveEntry2(ctxt->varHash, name, ns_uri,
5020: (xmlHashDeallocator)xmlXPathFreeObject));
5021: return(xmlHashUpdateEntry2(ctxt->varHash, name, ns_uri,
5022: (void *) value,
5023: (xmlHashDeallocator)xmlXPathFreeObject));
5024: }
5025:
5026: /**
5027: * xmlXPathRegisterVariableLookup:
5028: * @ctxt: the XPath context
5029: * @f: the lookup function
5030: * @data: the lookup data
5031: *
5032: * register an external mechanism to do variable lookup
5033: */
5034: void
5035: xmlXPathRegisterVariableLookup(xmlXPathContextPtr ctxt,
5036: xmlXPathVariableLookupFunc f, void *data) {
5037: if (ctxt == NULL)
5038: return;
5039: ctxt->varLookupFunc = f;
5040: ctxt->varLookupData = data;
5041: }
5042:
5043: /**
5044: * xmlXPathVariableLookup:
5045: * @ctxt: the XPath context
5046: * @name: the variable name
5047: *
5048: * Search in the Variable array of the context for the given
5049: * variable value.
5050: *
5051: * Returns a copy of the value or NULL if not found
5052: */
5053: xmlXPathObjectPtr
5054: xmlXPathVariableLookup(xmlXPathContextPtr ctxt, const xmlChar *name) {
5055: if (ctxt == NULL)
5056: return(NULL);
5057:
5058: if (ctxt->varLookupFunc != NULL) {
5059: xmlXPathObjectPtr ret;
5060:
5061: ret = ((xmlXPathVariableLookupFunc)ctxt->varLookupFunc)
5062: (ctxt->varLookupData, name, NULL);
5063: return(ret);
5064: }
5065: return(xmlXPathVariableLookupNS(ctxt, name, NULL));
5066: }
5067:
5068: /**
5069: * xmlXPathVariableLookupNS:
5070: * @ctxt: the XPath context
5071: * @name: the variable name
5072: * @ns_uri: the variable namespace URI
5073: *
5074: * Search in the Variable array of the context for the given
5075: * variable value.
5076: *
5077: * Returns the a copy of the value or NULL if not found
5078: */
5079: xmlXPathObjectPtr
5080: xmlXPathVariableLookupNS(xmlXPathContextPtr ctxt, const xmlChar *name,
5081: const xmlChar *ns_uri) {
5082: if (ctxt == NULL)
5083: return(NULL);
5084:
5085: if (ctxt->varLookupFunc != NULL) {
5086: xmlXPathObjectPtr ret;
5087:
5088: ret = ((xmlXPathVariableLookupFunc)ctxt->varLookupFunc)
5089: (ctxt->varLookupData, name, ns_uri);
5090: if (ret != NULL) return(ret);
5091: }
5092:
5093: if (ctxt->varHash == NULL)
5094: return(NULL);
5095: if (name == NULL)
5096: return(NULL);
5097:
5098: return(xmlXPathCacheObjectCopy(ctxt, (xmlXPathObjectPtr)
5099: xmlHashLookup2(ctxt->varHash, name, ns_uri)));
5100: }
5101:
5102: /**
5103: * xmlXPathRegisteredVariablesCleanup:
5104: * @ctxt: the XPath context
5105: *
5106: * Cleanup the XPath context data associated to registered variables
5107: */
5108: void
5109: xmlXPathRegisteredVariablesCleanup(xmlXPathContextPtr ctxt) {
5110: if (ctxt == NULL)
5111: return;
5112:
5113: xmlHashFree(ctxt->varHash, (xmlHashDeallocator)xmlXPathFreeObject);
5114: ctxt->varHash = NULL;
5115: }
5116:
5117: /**
5118: * xmlXPathRegisterNs:
5119: * @ctxt: the XPath context
5120: * @prefix: the namespace prefix cannot be NULL or empty string
5121: * @ns_uri: the namespace name
5122: *
5123: * Register a new namespace. If @ns_uri is NULL it unregisters
5124: * the namespace
5125: *
5126: * Returns 0 in case of success, -1 in case of error
5127: */
5128: int
5129: xmlXPathRegisterNs(xmlXPathContextPtr ctxt, const xmlChar *prefix,
5130: const xmlChar *ns_uri) {
5131: if (ctxt == NULL)
5132: return(-1);
5133: if (prefix == NULL)
5134: return(-1);
5135: if (prefix[0] == 0)
5136: return(-1);
5137:
5138: if (ctxt->nsHash == NULL)
5139: ctxt->nsHash = xmlHashCreate(10);
5140: if (ctxt->nsHash == NULL)
5141: return(-1);
5142: if (ns_uri == NULL)
5143: return(xmlHashRemoveEntry(ctxt->nsHash, prefix,
5144: (xmlHashDeallocator)xmlFree));
5145: return(xmlHashUpdateEntry(ctxt->nsHash, prefix, (void *) xmlStrdup(ns_uri),
5146: (xmlHashDeallocator)xmlFree));
5147: }
5148:
5149: /**
5150: * xmlXPathNsLookup:
5151: * @ctxt: the XPath context
5152: * @prefix: the namespace prefix value
5153: *
5154: * Search in the namespace declaration array of the context for the given
5155: * namespace name associated to the given prefix
5156: *
5157: * Returns the value or NULL if not found
5158: */
5159: const xmlChar *
5160: xmlXPathNsLookup(xmlXPathContextPtr ctxt, const xmlChar *prefix) {
5161: if (ctxt == NULL)
5162: return(NULL);
5163: if (prefix == NULL)
5164: return(NULL);
5165:
5166: #ifdef XML_XML_NAMESPACE
5167: if (xmlStrEqual(prefix, (const xmlChar *) "xml"))
5168: return(XML_XML_NAMESPACE);
5169: #endif
5170:
5171: if (ctxt->namespaces != NULL) {
5172: int i;
5173:
5174: for (i = 0;i < ctxt->nsNr;i++) {
5175: if ((ctxt->namespaces[i] != NULL) &&
5176: (xmlStrEqual(ctxt->namespaces[i]->prefix, prefix)))
5177: return(ctxt->namespaces[i]->href);
5178: }
5179: }
5180:
5181: return((const xmlChar *) xmlHashLookup(ctxt->nsHash, prefix));
5182: }
5183:
5184: /**
5185: * xmlXPathRegisteredNsCleanup:
5186: * @ctxt: the XPath context
5187: *
5188: * Cleanup the XPath context data associated to registered variables
5189: */
5190: void
5191: xmlXPathRegisteredNsCleanup(xmlXPathContextPtr ctxt) {
5192: if (ctxt == NULL)
5193: return;
5194:
5195: xmlHashFree(ctxt->nsHash, (xmlHashDeallocator)xmlFree);
5196: ctxt->nsHash = NULL;
5197: }
5198:
5199: /************************************************************************
5200: * *
5201: * Routines to handle Values *
5202: * *
5203: ************************************************************************/
5204:
5205: /* Allocations are terrible, one needs to optimize all this !!! */
5206:
5207: /**
5208: * xmlXPathNewFloat:
5209: * @val: the double value
5210: *
5211: * Create a new xmlXPathObjectPtr of type double and of value @val
5212: *
5213: * Returns the newly created object.
5214: */
5215: xmlXPathObjectPtr
5216: xmlXPathNewFloat(double val) {
5217: xmlXPathObjectPtr ret;
5218:
5219: ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
5220: if (ret == NULL) {
5221: xmlXPathErrMemory(NULL, "creating float object\n");
5222: return(NULL);
5223: }
5224: memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
5225: ret->type = XPATH_NUMBER;
5226: ret->floatval = val;
5227: #ifdef XP_DEBUG_OBJ_USAGE
5228: xmlXPathDebugObjUsageRequested(NULL, XPATH_NUMBER);
5229: #endif
5230: return(ret);
5231: }
5232:
5233: /**
5234: * xmlXPathNewBoolean:
5235: * @val: the boolean value
5236: *
5237: * Create a new xmlXPathObjectPtr of type boolean and of value @val
5238: *
5239: * Returns the newly created object.
5240: */
5241: xmlXPathObjectPtr
5242: xmlXPathNewBoolean(int val) {
5243: xmlXPathObjectPtr ret;
5244:
5245: ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
5246: if (ret == NULL) {
5247: xmlXPathErrMemory(NULL, "creating boolean object\n");
5248: return(NULL);
5249: }
5250: memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
5251: ret->type = XPATH_BOOLEAN;
5252: ret->boolval = (val != 0);
5253: #ifdef XP_DEBUG_OBJ_USAGE
5254: xmlXPathDebugObjUsageRequested(NULL, XPATH_BOOLEAN);
5255: #endif
5256: return(ret);
5257: }
5258:
5259: /**
5260: * xmlXPathNewString:
5261: * @val: the xmlChar * value
5262: *
5263: * Create a new xmlXPathObjectPtr of type string and of value @val
5264: *
5265: * Returns the newly created object.
5266: */
5267: xmlXPathObjectPtr
5268: xmlXPathNewString(const xmlChar *val) {
5269: xmlXPathObjectPtr ret;
5270:
5271: ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
5272: if (ret == NULL) {
5273: xmlXPathErrMemory(NULL, "creating string object\n");
5274: return(NULL);
5275: }
5276: memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
5277: ret->type = XPATH_STRING;
5278: if (val != NULL)
5279: ret->stringval = xmlStrdup(val);
5280: else
5281: ret->stringval = xmlStrdup((const xmlChar *)"");
5282: #ifdef XP_DEBUG_OBJ_USAGE
5283: xmlXPathDebugObjUsageRequested(NULL, XPATH_STRING);
5284: #endif
5285: return(ret);
5286: }
5287:
5288: /**
5289: * xmlXPathWrapString:
5290: * @val: the xmlChar * value
5291: *
5292: * Wraps the @val string into an XPath object.
5293: *
5294: * Returns the newly created object.
5295: */
5296: xmlXPathObjectPtr
5297: xmlXPathWrapString (xmlChar *val) {
5298: xmlXPathObjectPtr ret;
5299:
5300: ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
5301: if (ret == NULL) {
5302: xmlXPathErrMemory(NULL, "creating string object\n");
5303: return(NULL);
5304: }
5305: memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
5306: ret->type = XPATH_STRING;
5307: ret->stringval = val;
5308: #ifdef XP_DEBUG_OBJ_USAGE
5309: xmlXPathDebugObjUsageRequested(NULL, XPATH_STRING);
5310: #endif
5311: return(ret);
5312: }
5313:
5314: /**
5315: * xmlXPathNewCString:
5316: * @val: the char * value
5317: *
5318: * Create a new xmlXPathObjectPtr of type string and of value @val
5319: *
5320: * Returns the newly created object.
5321: */
5322: xmlXPathObjectPtr
5323: xmlXPathNewCString(const char *val) {
5324: xmlXPathObjectPtr ret;
5325:
5326: ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
5327: if (ret == NULL) {
5328: xmlXPathErrMemory(NULL, "creating string object\n");
5329: return(NULL);
5330: }
5331: memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
5332: ret->type = XPATH_STRING;
5333: ret->stringval = xmlStrdup(BAD_CAST val);
5334: #ifdef XP_DEBUG_OBJ_USAGE
5335: xmlXPathDebugObjUsageRequested(NULL, XPATH_STRING);
5336: #endif
5337: return(ret);
5338: }
5339:
5340: /**
5341: * xmlXPathWrapCString:
5342: * @val: the char * value
5343: *
5344: * Wraps a string into an XPath object.
5345: *
5346: * Returns the newly created object.
5347: */
5348: xmlXPathObjectPtr
5349: xmlXPathWrapCString (char * val) {
5350: return(xmlXPathWrapString((xmlChar *)(val)));
5351: }
5352:
5353: /**
5354: * xmlXPathWrapExternal:
5355: * @val: the user data
5356: *
5357: * Wraps the @val data into an XPath object.
5358: *
5359: * Returns the newly created object.
5360: */
5361: xmlXPathObjectPtr
5362: xmlXPathWrapExternal (void *val) {
5363: xmlXPathObjectPtr ret;
5364:
5365: ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
5366: if (ret == NULL) {
5367: xmlXPathErrMemory(NULL, "creating user object\n");
5368: return(NULL);
5369: }
5370: memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
5371: ret->type = XPATH_USERS;
5372: ret->user = val;
5373: #ifdef XP_DEBUG_OBJ_USAGE
5374: xmlXPathDebugObjUsageRequested(NULL, XPATH_USERS);
5375: #endif
5376: return(ret);
5377: }
5378:
5379: /**
5380: * xmlXPathObjectCopy:
5381: * @val: the original object
5382: *
5383: * allocate a new copy of a given object
5384: *
5385: * Returns the newly created object.
5386: */
5387: xmlXPathObjectPtr
5388: xmlXPathObjectCopy(xmlXPathObjectPtr val) {
5389: xmlXPathObjectPtr ret;
5390:
5391: if (val == NULL)
5392: return(NULL);
5393:
5394: ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
5395: if (ret == NULL) {
5396: xmlXPathErrMemory(NULL, "copying object\n");
5397: return(NULL);
5398: }
5399: memcpy(ret, val , (size_t) sizeof(xmlXPathObject));
5400: #ifdef XP_DEBUG_OBJ_USAGE
5401: xmlXPathDebugObjUsageRequested(NULL, val->type);
5402: #endif
5403: switch (val->type) {
5404: case XPATH_BOOLEAN:
5405: case XPATH_NUMBER:
5406: case XPATH_POINT:
5407: case XPATH_RANGE:
5408: break;
5409: case XPATH_STRING:
5410: ret->stringval = xmlStrdup(val->stringval);
5411: break;
5412: case XPATH_XSLT_TREE:
5413: #if 0
5414: /*
5415: Removed 11 July 2004 - the current handling of xslt tmpRVT nodes means that
5416: this previous handling is no longer correct, and can cause some serious
5417: problems (ref. bug 145547)
5418: */
5419: if ((val->nodesetval != NULL) &&
5420: (val->nodesetval->nodeTab != NULL)) {
5421: xmlNodePtr cur, tmp;
5422: xmlDocPtr top;
5423:
5424: ret->boolval = 1;
5425: top = xmlNewDoc(NULL);
5426: top->name = (char *)
5427: xmlStrdup(val->nodesetval->nodeTab[0]->name);
5428: ret->user = top;
5429: if (top != NULL) {
5430: top->doc = top;
5431: cur = val->nodesetval->nodeTab[0]->children;
5432: while (cur != NULL) {
5433: tmp = xmlDocCopyNode(cur, top, 1);
5434: xmlAddChild((xmlNodePtr) top, tmp);
5435: cur = cur->next;
5436: }
5437: }
5438:
5439: ret->nodesetval = xmlXPathNodeSetCreate((xmlNodePtr) top);
5440: } else
5441: ret->nodesetval = xmlXPathNodeSetCreate(NULL);
5442: /* Deallocate the copied tree value */
5443: break;
5444: #endif
5445: case XPATH_NODESET:
5446: ret->nodesetval = xmlXPathNodeSetMerge(NULL, val->nodesetval);
5447: /* Do not deallocate the copied tree value */
5448: ret->boolval = 0;
5449: break;
5450: case XPATH_LOCATIONSET:
5451: #ifdef LIBXML_XPTR_ENABLED
5452: {
5453: xmlLocationSetPtr loc = val->user;
5454: ret->user = (void *) xmlXPtrLocationSetMerge(NULL, loc);
5455: break;
5456: }
5457: #endif
5458: case XPATH_USERS:
5459: ret->user = val->user;
5460: break;
5461: case XPATH_UNDEFINED:
5462: xmlGenericError(xmlGenericErrorContext,
5463: "xmlXPathObjectCopy: unsupported type %d\n",
5464: val->type);
5465: break;
5466: }
5467: return(ret);
5468: }
5469:
5470: /**
5471: * xmlXPathFreeObject:
5472: * @obj: the object to free
5473: *
5474: * Free up an xmlXPathObjectPtr object.
5475: */
5476: void
5477: xmlXPathFreeObject(xmlXPathObjectPtr obj) {
5478: if (obj == NULL) return;
5479: if ((obj->type == XPATH_NODESET) || (obj->type == XPATH_XSLT_TREE)) {
5480: if (obj->boolval) {
5481: #if 0
5482: if (obj->user != NULL) {
5483: xmlXPathFreeNodeSet(obj->nodesetval);
5484: xmlFreeNodeList((xmlNodePtr) obj->user);
5485: } else
5486: #endif
5487: obj->type = XPATH_XSLT_TREE; /* TODO: Just for debugging. */
5488: if (obj->nodesetval != NULL)
5489: xmlXPathFreeValueTree(obj->nodesetval);
5490: } else {
5491: if (obj->nodesetval != NULL)
5492: xmlXPathFreeNodeSet(obj->nodesetval);
5493: }
5494: #ifdef LIBXML_XPTR_ENABLED
5495: } else if (obj->type == XPATH_LOCATIONSET) {
5496: if (obj->user != NULL)
5497: xmlXPtrFreeLocationSet(obj->user);
5498: #endif
5499: } else if (obj->type == XPATH_STRING) {
5500: if (obj->stringval != NULL)
5501: xmlFree(obj->stringval);
5502: }
5503: #ifdef XP_DEBUG_OBJ_USAGE
5504: xmlXPathDebugObjUsageReleased(NULL, obj->type);
5505: #endif
5506: xmlFree(obj);
5507: }
5508:
5509: /**
5510: * xmlXPathReleaseObject:
5511: * @obj: the xmlXPathObjectPtr to free or to cache
5512: *
5513: * Depending on the state of the cache this frees the given
5514: * XPath object or stores it in the cache.
5515: */
5516: static void
5517: xmlXPathReleaseObject(xmlXPathContextPtr ctxt, xmlXPathObjectPtr obj)
5518: {
5519: #define XP_CACHE_ADD(sl, o) if (sl == NULL) { \
5520: sl = xmlPointerListCreate(10); if (sl == NULL) goto free_obj; } \
5521: if (xmlPointerListAddSize(sl, obj, 0) == -1) goto free_obj;
5522:
5523: #define XP_CACHE_WANTS(sl, n) ((sl == NULL) || ((sl)->number < n))
5524:
5525: if (obj == NULL)
5526: return;
5527: if ((ctxt == NULL) || (ctxt->cache == NULL)) {
5528: xmlXPathFreeObject(obj);
5529: } else {
5530: xmlXPathContextCachePtr cache =
5531: (xmlXPathContextCachePtr) ctxt->cache;
5532:
5533: switch (obj->type) {
5534: case XPATH_NODESET:
5535: case XPATH_XSLT_TREE:
5536: if (obj->nodesetval != NULL) {
5537: if (obj->boolval) {
5538: /*
5539: * It looks like the @boolval is used for
5540: * evaluation if this an XSLT Result Tree Fragment.
5541: * TODO: Check if this assumption is correct.
5542: */
5543: obj->type = XPATH_XSLT_TREE; /* just for debugging */
5544: xmlXPathFreeValueTree(obj->nodesetval);
5545: obj->nodesetval = NULL;
5546: } else if ((obj->nodesetval->nodeMax <= 40) &&
5547: (XP_CACHE_WANTS(cache->nodesetObjs,
5548: cache->maxNodeset)))
5549: {
5550: XP_CACHE_ADD(cache->nodesetObjs, obj);
5551: goto obj_cached;
5552: } else {
5553: xmlXPathFreeNodeSet(obj->nodesetval);
5554: obj->nodesetval = NULL;
5555: }
5556: }
5557: break;
5558: case XPATH_STRING:
5559: if (obj->stringval != NULL)
5560: xmlFree(obj->stringval);
5561:
5562: if (XP_CACHE_WANTS(cache->stringObjs, cache->maxString)) {
5563: XP_CACHE_ADD(cache->stringObjs, obj);
5564: goto obj_cached;
5565: }
5566: break;
5567: case XPATH_BOOLEAN:
5568: if (XP_CACHE_WANTS(cache->booleanObjs, cache->maxBoolean)) {
5569: XP_CACHE_ADD(cache->booleanObjs, obj);
5570: goto obj_cached;
5571: }
5572: break;
5573: case XPATH_NUMBER:
5574: if (XP_CACHE_WANTS(cache->numberObjs, cache->maxNumber)) {
5575: XP_CACHE_ADD(cache->numberObjs, obj);
5576: goto obj_cached;
5577: }
5578: break;
5579: #ifdef LIBXML_XPTR_ENABLED
5580: case XPATH_LOCATIONSET:
5581: if (obj->user != NULL) {
5582: xmlXPtrFreeLocationSet(obj->user);
5583: }
5584: goto free_obj;
5585: #endif
5586: default:
5587: goto free_obj;
5588: }
5589:
5590: /*
5591: * Fallback to adding to the misc-objects slot.
5592: */
5593: if (XP_CACHE_WANTS(cache->miscObjs, cache->maxMisc)) {
5594: XP_CACHE_ADD(cache->miscObjs, obj);
5595: } else
5596: goto free_obj;
5597:
5598: obj_cached:
5599:
5600: #ifdef XP_DEBUG_OBJ_USAGE
5601: xmlXPathDebugObjUsageReleased(ctxt, obj->type);
5602: #endif
5603:
5604: if (obj->nodesetval != NULL) {
5605: xmlNodeSetPtr tmpset = obj->nodesetval;
5606:
5607: /*
5608: * TODO: Due to those nasty ns-nodes, we need to traverse
5609: * the list and free the ns-nodes.
5610: * URGENT TODO: Check if it's actually slowing things down.
5611: * Maybe we shouldn't try to preserve the list.
5612: */
5613: if (tmpset->nodeNr > 1) {
5614: int i;
5615: xmlNodePtr node;
5616:
5617: for (i = 0; i < tmpset->nodeNr; i++) {
5618: node = tmpset->nodeTab[i];
5619: if ((node != NULL) &&
5620: (node->type == XML_NAMESPACE_DECL))
5621: {
5622: xmlXPathNodeSetFreeNs((xmlNsPtr) node);
5623: }
5624: }
5625: } else if (tmpset->nodeNr == 1) {
5626: if ((tmpset->nodeTab[0] != NULL) &&
5627: (tmpset->nodeTab[0]->type == XML_NAMESPACE_DECL))
5628: xmlXPathNodeSetFreeNs((xmlNsPtr) tmpset->nodeTab[0]);
5629: }
5630: tmpset->nodeNr = 0;
5631: memset(obj, 0, sizeof(xmlXPathObject));
5632: obj->nodesetval = tmpset;
5633: } else
5634: memset(obj, 0, sizeof(xmlXPathObject));
5635:
5636: return;
5637:
5638: free_obj:
5639: /*
5640: * Cache is full; free the object.
5641: */
5642: if (obj->nodesetval != NULL)
5643: xmlXPathFreeNodeSet(obj->nodesetval);
5644: #ifdef XP_DEBUG_OBJ_USAGE
5645: xmlXPathDebugObjUsageReleased(NULL, obj->type);
5646: #endif
5647: xmlFree(obj);
5648: }
5649: return;
5650: }
5651:
5652:
5653: /************************************************************************
5654: * *
5655: * Type Casting Routines *
5656: * *
5657: ************************************************************************/
5658:
5659: /**
5660: * xmlXPathCastBooleanToString:
5661: * @val: a boolean
5662: *
5663: * Converts a boolean to its string value.
5664: *
5665: * Returns a newly allocated string.
5666: */
5667: xmlChar *
5668: xmlXPathCastBooleanToString (int val) {
5669: xmlChar *ret;
5670: if (val)
5671: ret = xmlStrdup((const xmlChar *) "true");
5672: else
5673: ret = xmlStrdup((const xmlChar *) "false");
5674: return(ret);
5675: }
5676:
5677: /**
5678: * xmlXPathCastNumberToString:
5679: * @val: a number
5680: *
5681: * Converts a number to its string value.
5682: *
5683: * Returns a newly allocated string.
5684: */
5685: xmlChar *
5686: xmlXPathCastNumberToString (double val) {
5687: xmlChar *ret;
5688: switch (xmlXPathIsInf(val)) {
5689: case 1:
5690: ret = xmlStrdup((const xmlChar *) "Infinity");
5691: break;
5692: case -1:
5693: ret = xmlStrdup((const xmlChar *) "-Infinity");
5694: break;
5695: default:
5696: if (xmlXPathIsNaN(val)) {
5697: ret = xmlStrdup((const xmlChar *) "NaN");
5698: } else if (val == 0 && xmlXPathGetSign(val) != 0) {
5699: ret = xmlStrdup((const xmlChar *) "0");
5700: } else {
5701: /* could be improved */
5702: char buf[100];
5703: xmlXPathFormatNumber(val, buf, 99);
5704: buf[99] = 0;
5705: ret = xmlStrdup((const xmlChar *) buf);
5706: }
5707: }
5708: return(ret);
5709: }
5710:
5711: /**
5712: * xmlXPathCastNodeToString:
5713: * @node: a node
5714: *
5715: * Converts a node to its string value.
5716: *
5717: * Returns a newly allocated string.
5718: */
5719: xmlChar *
5720: xmlXPathCastNodeToString (xmlNodePtr node) {
5721: xmlChar *ret;
5722: if ((ret = xmlNodeGetContent(node)) == NULL)
5723: ret = xmlStrdup((const xmlChar *) "");
5724: return(ret);
5725: }
5726:
5727: /**
5728: * xmlXPathCastNodeSetToString:
5729: * @ns: a node-set
5730: *
5731: * Converts a node-set to its string value.
5732: *
5733: * Returns a newly allocated string.
5734: */
5735: xmlChar *
5736: xmlXPathCastNodeSetToString (xmlNodeSetPtr ns) {
5737: if ((ns == NULL) || (ns->nodeNr == 0) || (ns->nodeTab == NULL))
5738: return(xmlStrdup((const xmlChar *) ""));
5739:
5740: if (ns->nodeNr > 1)
5741: xmlXPathNodeSetSort(ns);
5742: return(xmlXPathCastNodeToString(ns->nodeTab[0]));
5743: }
5744:
5745: /**
5746: * xmlXPathCastToString:
5747: * @val: an XPath object
5748: *
5749: * Converts an existing object to its string() equivalent
5750: *
5751: * Returns the allocated string value of the object, NULL in case of error.
5752: * It's up to the caller to free the string memory with xmlFree().
5753: */
5754: xmlChar *
5755: xmlXPathCastToString(xmlXPathObjectPtr val) {
5756: xmlChar *ret = NULL;
5757:
5758: if (val == NULL)
5759: return(xmlStrdup((const xmlChar *) ""));
5760: switch (val->type) {
5761: case XPATH_UNDEFINED:
5762: #ifdef DEBUG_EXPR
5763: xmlGenericError(xmlGenericErrorContext, "String: undefined\n");
5764: #endif
5765: ret = xmlStrdup((const xmlChar *) "");
5766: break;
5767: case XPATH_NODESET:
5768: case XPATH_XSLT_TREE:
5769: ret = xmlXPathCastNodeSetToString(val->nodesetval);
5770: break;
5771: case XPATH_STRING:
5772: return(xmlStrdup(val->stringval));
5773: case XPATH_BOOLEAN:
5774: ret = xmlXPathCastBooleanToString(val->boolval);
5775: break;
5776: case XPATH_NUMBER: {
5777: ret = xmlXPathCastNumberToString(val->floatval);
5778: break;
5779: }
5780: case XPATH_USERS:
5781: case XPATH_POINT:
5782: case XPATH_RANGE:
5783: case XPATH_LOCATIONSET:
5784: TODO
5785: ret = xmlStrdup((const xmlChar *) "");
5786: break;
5787: }
5788: return(ret);
5789: }
5790:
5791: /**
5792: * xmlXPathConvertString:
5793: * @val: an XPath object
5794: *
5795: * Converts an existing object to its string() equivalent
5796: *
5797: * Returns the new object, the old one is freed (or the operation
5798: * is done directly on @val)
5799: */
5800: xmlXPathObjectPtr
5801: xmlXPathConvertString(xmlXPathObjectPtr val) {
5802: xmlChar *res = NULL;
5803:
5804: if (val == NULL)
5805: return(xmlXPathNewCString(""));
5806:
5807: switch (val->type) {
5808: case XPATH_UNDEFINED:
5809: #ifdef DEBUG_EXPR
5810: xmlGenericError(xmlGenericErrorContext, "STRING: undefined\n");
5811: #endif
5812: break;
5813: case XPATH_NODESET:
5814: case XPATH_XSLT_TREE:
5815: res = xmlXPathCastNodeSetToString(val->nodesetval);
5816: break;
5817: case XPATH_STRING:
5818: return(val);
5819: case XPATH_BOOLEAN:
5820: res = xmlXPathCastBooleanToString(val->boolval);
5821: break;
5822: case XPATH_NUMBER:
5823: res = xmlXPathCastNumberToString(val->floatval);
5824: break;
5825: case XPATH_USERS:
5826: case XPATH_POINT:
5827: case XPATH_RANGE:
5828: case XPATH_LOCATIONSET:
5829: TODO;
5830: break;
5831: }
5832: xmlXPathFreeObject(val);
5833: if (res == NULL)
5834: return(xmlXPathNewCString(""));
5835: return(xmlXPathWrapString(res));
5836: }
5837:
5838: /**
5839: * xmlXPathCastBooleanToNumber:
5840: * @val: a boolean
5841: *
5842: * Converts a boolean to its number value
5843: *
5844: * Returns the number value
5845: */
5846: double
5847: xmlXPathCastBooleanToNumber(int val) {
5848: if (val)
5849: return(1.0);
5850: return(0.0);
5851: }
5852:
5853: /**
5854: * xmlXPathCastStringToNumber:
5855: * @val: a string
5856: *
5857: * Converts a string to its number value
5858: *
5859: * Returns the number value
5860: */
5861: double
5862: xmlXPathCastStringToNumber(const xmlChar * val) {
5863: return(xmlXPathStringEvalNumber(val));
5864: }
5865:
5866: /**
5867: * xmlXPathCastNodeToNumber:
5868: * @node: a node
5869: *
5870: * Converts a node to its number value
5871: *
5872: * Returns the number value
5873: */
5874: double
5875: xmlXPathCastNodeToNumber (xmlNodePtr node) {
5876: xmlChar *strval;
5877: double ret;
5878:
5879: if (node == NULL)
5880: return(xmlXPathNAN);
5881: strval = xmlXPathCastNodeToString(node);
5882: if (strval == NULL)
5883: return(xmlXPathNAN);
5884: ret = xmlXPathCastStringToNumber(strval);
5885: xmlFree(strval);
5886:
5887: return(ret);
5888: }
5889:
5890: /**
5891: * xmlXPathCastNodeSetToNumber:
5892: * @ns: a node-set
5893: *
5894: * Converts a node-set to its number value
5895: *
5896: * Returns the number value
5897: */
5898: double
5899: xmlXPathCastNodeSetToNumber (xmlNodeSetPtr ns) {
5900: xmlChar *str;
5901: double ret;
5902:
5903: if (ns == NULL)
5904: return(xmlXPathNAN);
5905: str = xmlXPathCastNodeSetToString(ns);
5906: ret = xmlXPathCastStringToNumber(str);
5907: xmlFree(str);
5908: return(ret);
5909: }
5910:
5911: /**
5912: * xmlXPathCastToNumber:
5913: * @val: an XPath object
5914: *
5915: * Converts an XPath object to its number value
5916: *
5917: * Returns the number value
5918: */
5919: double
5920: xmlXPathCastToNumber(xmlXPathObjectPtr val) {
5921: double ret = 0.0;
5922:
5923: if (val == NULL)
5924: return(xmlXPathNAN);
5925: switch (val->type) {
5926: case XPATH_UNDEFINED:
5927: #ifdef DEGUB_EXPR
5928: xmlGenericError(xmlGenericErrorContext, "NUMBER: undefined\n");
5929: #endif
5930: ret = xmlXPathNAN;
5931: break;
5932: case XPATH_NODESET:
5933: case XPATH_XSLT_TREE:
5934: ret = xmlXPathCastNodeSetToNumber(val->nodesetval);
5935: break;
5936: case XPATH_STRING:
5937: ret = xmlXPathCastStringToNumber(val->stringval);
5938: break;
5939: case XPATH_NUMBER:
5940: ret = val->floatval;
5941: break;
5942: case XPATH_BOOLEAN:
5943: ret = xmlXPathCastBooleanToNumber(val->boolval);
5944: break;
5945: case XPATH_USERS:
5946: case XPATH_POINT:
5947: case XPATH_RANGE:
5948: case XPATH_LOCATIONSET:
5949: TODO;
5950: ret = xmlXPathNAN;
5951: break;
5952: }
5953: return(ret);
5954: }
5955:
5956: /**
5957: * xmlXPathConvertNumber:
5958: * @val: an XPath object
5959: *
5960: * Converts an existing object to its number() equivalent
5961: *
5962: * Returns the new object, the old one is freed (or the operation
5963: * is done directly on @val)
5964: */
5965: xmlXPathObjectPtr
5966: xmlXPathConvertNumber(xmlXPathObjectPtr val) {
5967: xmlXPathObjectPtr ret;
5968:
5969: if (val == NULL)
5970: return(xmlXPathNewFloat(0.0));
5971: if (val->type == XPATH_NUMBER)
5972: return(val);
5973: ret = xmlXPathNewFloat(xmlXPathCastToNumber(val));
5974: xmlXPathFreeObject(val);
5975: return(ret);
5976: }
5977:
5978: /**
5979: * xmlXPathCastNumberToBoolean:
5980: * @val: a number
5981: *
5982: * Converts a number to its boolean value
5983: *
5984: * Returns the boolean value
5985: */
5986: int
5987: xmlXPathCastNumberToBoolean (double val) {
5988: if (xmlXPathIsNaN(val) || (val == 0.0))
5989: return(0);
5990: return(1);
5991: }
5992:
5993: /**
5994: * xmlXPathCastStringToBoolean:
5995: * @val: a string
5996: *
5997: * Converts a string to its boolean value
5998: *
5999: * Returns the boolean value
6000: */
6001: int
6002: xmlXPathCastStringToBoolean (const xmlChar *val) {
6003: if ((val == NULL) || (xmlStrlen(val) == 0))
6004: return(0);
6005: return(1);
6006: }
6007:
6008: /**
6009: * xmlXPathCastNodeSetToBoolean:
6010: * @ns: a node-set
6011: *
6012: * Converts a node-set to its boolean value
6013: *
6014: * Returns the boolean value
6015: */
6016: int
6017: xmlXPathCastNodeSetToBoolean (xmlNodeSetPtr ns) {
6018: if ((ns == NULL) || (ns->nodeNr == 0))
6019: return(0);
6020: return(1);
6021: }
6022:
6023: /**
6024: * xmlXPathCastToBoolean:
6025: * @val: an XPath object
6026: *
6027: * Converts an XPath object to its boolean value
6028: *
6029: * Returns the boolean value
6030: */
6031: int
6032: xmlXPathCastToBoolean (xmlXPathObjectPtr val) {
6033: int ret = 0;
6034:
6035: if (val == NULL)
6036: return(0);
6037: switch (val->type) {
6038: case XPATH_UNDEFINED:
6039: #ifdef DEBUG_EXPR
6040: xmlGenericError(xmlGenericErrorContext, "BOOLEAN: undefined\n");
6041: #endif
6042: ret = 0;
6043: break;
6044: case XPATH_NODESET:
6045: case XPATH_XSLT_TREE:
6046: ret = xmlXPathCastNodeSetToBoolean(val->nodesetval);
6047: break;
6048: case XPATH_STRING:
6049: ret = xmlXPathCastStringToBoolean(val->stringval);
6050: break;
6051: case XPATH_NUMBER:
6052: ret = xmlXPathCastNumberToBoolean(val->floatval);
6053: break;
6054: case XPATH_BOOLEAN:
6055: ret = val->boolval;
6056: break;
6057: case XPATH_USERS:
6058: case XPATH_POINT:
6059: case XPATH_RANGE:
6060: case XPATH_LOCATIONSET:
6061: TODO;
6062: ret = 0;
6063: break;
6064: }
6065: return(ret);
6066: }
6067:
6068:
6069: /**
6070: * xmlXPathConvertBoolean:
6071: * @val: an XPath object
6072: *
6073: * Converts an existing object to its boolean() equivalent
6074: *
6075: * Returns the new object, the old one is freed (or the operation
6076: * is done directly on @val)
6077: */
6078: xmlXPathObjectPtr
6079: xmlXPathConvertBoolean(xmlXPathObjectPtr val) {
6080: xmlXPathObjectPtr ret;
6081:
6082: if (val == NULL)
6083: return(xmlXPathNewBoolean(0));
6084: if (val->type == XPATH_BOOLEAN)
6085: return(val);
6086: ret = xmlXPathNewBoolean(xmlXPathCastToBoolean(val));
6087: xmlXPathFreeObject(val);
6088: return(ret);
6089: }
6090:
6091: /************************************************************************
6092: * *
6093: * Routines to handle XPath contexts *
6094: * *
6095: ************************************************************************/
6096:
6097: /**
6098: * xmlXPathNewContext:
6099: * @doc: the XML document
6100: *
6101: * Create a new xmlXPathContext
6102: *
6103: * Returns the xmlXPathContext just allocated. The caller will need to free it.
6104: */
6105: xmlXPathContextPtr
6106: xmlXPathNewContext(xmlDocPtr doc) {
6107: xmlXPathContextPtr ret;
6108:
6109: ret = (xmlXPathContextPtr) xmlMalloc(sizeof(xmlXPathContext));
6110: if (ret == NULL) {
6111: xmlXPathErrMemory(NULL, "creating context\n");
6112: return(NULL);
6113: }
6114: memset(ret, 0 , (size_t) sizeof(xmlXPathContext));
6115: ret->doc = doc;
6116: ret->node = NULL;
6117:
6118: ret->varHash = NULL;
6119:
6120: ret->nb_types = 0;
6121: ret->max_types = 0;
6122: ret->types = NULL;
6123:
6124: ret->funcHash = xmlHashCreate(0);
6125:
6126: ret->nb_axis = 0;
6127: ret->max_axis = 0;
6128: ret->axis = NULL;
6129:
6130: ret->nsHash = NULL;
6131: ret->user = NULL;
6132:
6133: ret->contextSize = -1;
6134: ret->proximityPosition = -1;
6135:
6136: #ifdef XP_DEFAULT_CACHE_ON
6137: if (xmlXPathContextSetCache(ret, 1, -1, 0) == -1) {
6138: xmlXPathFreeContext(ret);
6139: return(NULL);
6140: }
6141: #endif
6142:
6143: xmlXPathRegisterAllFunctions(ret);
6144:
6145: return(ret);
6146: }
6147:
6148: /**
6149: * xmlXPathFreeContext:
6150: * @ctxt: the context to free
6151: *
6152: * Free up an xmlXPathContext
6153: */
6154: void
6155: xmlXPathFreeContext(xmlXPathContextPtr ctxt) {
6156: if (ctxt == NULL) return;
6157:
6158: if (ctxt->cache != NULL)
6159: xmlXPathFreeCache((xmlXPathContextCachePtr) ctxt->cache);
6160: xmlXPathRegisteredNsCleanup(ctxt);
6161: xmlXPathRegisteredFuncsCleanup(ctxt);
6162: xmlXPathRegisteredVariablesCleanup(ctxt);
6163: xmlResetError(&ctxt->lastError);
6164: xmlFree(ctxt);
6165: }
6166:
6167: /************************************************************************
6168: * *
6169: * Routines to handle XPath parser contexts *
6170: * *
6171: ************************************************************************/
6172:
6173: #define CHECK_CTXT(ctxt) \
6174: if (ctxt == NULL) { \
6175: __xmlRaiseError(NULL, NULL, NULL, \
6176: NULL, NULL, XML_FROM_XPATH, \
6177: XML_ERR_INTERNAL_ERROR, XML_ERR_FATAL, \
6178: __FILE__, __LINE__, \
6179: NULL, NULL, NULL, 0, 0, \
6180: "NULL context pointer\n"); \
6181: return(NULL); \
6182: } \
6183:
6184: #define CHECK_CTXT_NEG(ctxt) \
6185: if (ctxt == NULL) { \
6186: __xmlRaiseError(NULL, NULL, NULL, \
6187: NULL, NULL, XML_FROM_XPATH, \
6188: XML_ERR_INTERNAL_ERROR, XML_ERR_FATAL, \
6189: __FILE__, __LINE__, \
6190: NULL, NULL, NULL, 0, 0, \
6191: "NULL context pointer\n"); \
6192: return(-1); \
6193: } \
6194:
6195:
6196: #define CHECK_CONTEXT(ctxt) \
6197: if ((ctxt == NULL) || (ctxt->doc == NULL) || \
6198: (ctxt->doc->children == NULL)) { \
6199: xmlXPatherror(ctxt, __FILE__, __LINE__, XPATH_INVALID_CTXT); \
6200: return(NULL); \
6201: }
6202:
6203:
6204: /**
6205: * xmlXPathNewParserContext:
6206: * @str: the XPath expression
6207: * @ctxt: the XPath context
6208: *
6209: * Create a new xmlXPathParserContext
6210: *
6211: * Returns the xmlXPathParserContext just allocated.
6212: */
6213: xmlXPathParserContextPtr
6214: xmlXPathNewParserContext(const xmlChar *str, xmlXPathContextPtr ctxt) {
6215: xmlXPathParserContextPtr ret;
6216:
6217: ret = (xmlXPathParserContextPtr) xmlMalloc(sizeof(xmlXPathParserContext));
6218: if (ret == NULL) {
6219: xmlXPathErrMemory(ctxt, "creating parser context\n");
6220: return(NULL);
6221: }
6222: memset(ret, 0 , (size_t) sizeof(xmlXPathParserContext));
6223: ret->cur = ret->base = str;
6224: ret->context = ctxt;
6225:
6226: ret->comp = xmlXPathNewCompExpr();
6227: if (ret->comp == NULL) {
6228: xmlFree(ret->valueTab);
6229: xmlFree(ret);
6230: return(NULL);
6231: }
6232: if ((ctxt != NULL) && (ctxt->dict != NULL)) {
6233: ret->comp->dict = ctxt->dict;
6234: xmlDictReference(ret->comp->dict);
6235: }
6236:
6237: return(ret);
6238: }
6239:
6240: /**
6241: * xmlXPathCompParserContext:
6242: * @comp: the XPath compiled expression
6243: * @ctxt: the XPath context
6244: *
6245: * Create a new xmlXPathParserContext when processing a compiled expression
6246: *
6247: * Returns the xmlXPathParserContext just allocated.
6248: */
6249: static xmlXPathParserContextPtr
6250: xmlXPathCompParserContext(xmlXPathCompExprPtr comp, xmlXPathContextPtr ctxt) {
6251: xmlXPathParserContextPtr ret;
6252:
6253: ret = (xmlXPathParserContextPtr) xmlMalloc(sizeof(xmlXPathParserContext));
6254: if (ret == NULL) {
6255: xmlXPathErrMemory(ctxt, "creating evaluation context\n");
6256: return(NULL);
6257: }
6258: memset(ret, 0 , (size_t) sizeof(xmlXPathParserContext));
6259:
6260: /* Allocate the value stack */
6261: ret->valueTab = (xmlXPathObjectPtr *)
6262: xmlMalloc(10 * sizeof(xmlXPathObjectPtr));
6263: if (ret->valueTab == NULL) {
6264: xmlFree(ret);
6265: xmlXPathErrMemory(ctxt, "creating evaluation context\n");
6266: return(NULL);
6267: }
6268: ret->valueNr = 0;
6269: ret->valueMax = 10;
6270: ret->value = NULL;
6271: ret->valueFrame = 0;
6272:
6273: ret->context = ctxt;
6274: ret->comp = comp;
6275:
6276: return(ret);
6277: }
6278:
6279: /**
6280: * xmlXPathFreeParserContext:
6281: * @ctxt: the context to free
6282: *
6283: * Free up an xmlXPathParserContext
6284: */
6285: void
6286: xmlXPathFreeParserContext(xmlXPathParserContextPtr ctxt) {
6287: if (ctxt->valueTab != NULL) {
6288: xmlFree(ctxt->valueTab);
6289: }
6290: if (ctxt->comp != NULL) {
6291: #ifdef XPATH_STREAMING
6292: if (ctxt->comp->stream != NULL) {
6293: xmlFreePatternList(ctxt->comp->stream);
6294: ctxt->comp->stream = NULL;
6295: }
6296: #endif
6297: xmlXPathFreeCompExpr(ctxt->comp);
6298: }
6299: xmlFree(ctxt);
6300: }
6301:
6302: /************************************************************************
6303: * *
6304: * The implicit core function library *
6305: * *
6306: ************************************************************************/
6307:
6308: /**
6309: * xmlXPathNodeValHash:
6310: * @node: a node pointer
6311: *
6312: * Function computing the beginning of the string value of the node,
6313: * used to speed up comparisons
6314: *
6315: * Returns an int usable as a hash
6316: */
6317: static unsigned int
6318: xmlXPathNodeValHash(xmlNodePtr node) {
6319: int len = 2;
6320: const xmlChar * string = NULL;
6321: xmlNodePtr tmp = NULL;
6322: unsigned int ret = 0;
6323:
6324: if (node == NULL)
6325: return(0);
6326:
6327: if (node->type == XML_DOCUMENT_NODE) {
6328: tmp = xmlDocGetRootElement((xmlDocPtr) node);
6329: if (tmp == NULL)
6330: node = node->children;
6331: else
6332: node = tmp;
6333:
6334: if (node == NULL)
6335: return(0);
6336: }
6337:
6338: switch (node->type) {
6339: case XML_COMMENT_NODE:
6340: case XML_PI_NODE:
6341: case XML_CDATA_SECTION_NODE:
6342: case XML_TEXT_NODE:
6343: string = node->content;
6344: if (string == NULL)
6345: return(0);
6346: if (string[0] == 0)
6347: return(0);
6348: return(((unsigned int) string[0]) +
6349: (((unsigned int) string[1]) << 8));
6350: case XML_NAMESPACE_DECL:
6351: string = ((xmlNsPtr)node)->href;
6352: if (string == NULL)
6353: return(0);
6354: if (string[0] == 0)
6355: return(0);
6356: return(((unsigned int) string[0]) +
6357: (((unsigned int) string[1]) << 8));
6358: case XML_ATTRIBUTE_NODE:
6359: tmp = ((xmlAttrPtr) node)->children;
6360: break;
6361: case XML_ELEMENT_NODE:
6362: tmp = node->children;
6363: break;
6364: default:
6365: return(0);
6366: }
6367: while (tmp != NULL) {
6368: switch (tmp->type) {
6369: case XML_COMMENT_NODE:
6370: case XML_PI_NODE:
6371: case XML_CDATA_SECTION_NODE:
6372: case XML_TEXT_NODE:
6373: string = tmp->content;
6374: break;
6375: case XML_NAMESPACE_DECL:
6376: string = ((xmlNsPtr)tmp)->href;
6377: break;
6378: default:
6379: break;
6380: }
6381: if ((string != NULL) && (string[0] != 0)) {
6382: if (len == 1) {
6383: return(ret + (((unsigned int) string[0]) << 8));
6384: }
6385: if (string[1] == 0) {
6386: len = 1;
6387: ret = (unsigned int) string[0];
6388: } else {
6389: return(((unsigned int) string[0]) +
6390: (((unsigned int) string[1]) << 8));
6391: }
6392: }
6393: /*
6394: * Skip to next node
6395: */
6396: if ((tmp->children != NULL) && (tmp->type != XML_DTD_NODE)) {
6397: if (tmp->children->type != XML_ENTITY_DECL) {
6398: tmp = tmp->children;
6399: continue;
6400: }
6401: }
6402: if (tmp == node)
6403: break;
6404:
6405: if (tmp->next != NULL) {
6406: tmp = tmp->next;
6407: continue;
6408: }
6409:
6410: do {
6411: tmp = tmp->parent;
6412: if (tmp == NULL)
6413: break;
6414: if (tmp == node) {
6415: tmp = NULL;
6416: break;
6417: }
6418: if (tmp->next != NULL) {
6419: tmp = tmp->next;
6420: break;
6421: }
6422: } while (tmp != NULL);
6423: }
6424: return(ret);
6425: }
6426:
6427: /**
6428: * xmlXPathStringHash:
6429: * @string: a string
6430: *
6431: * Function computing the beginning of the string value of the node,
6432: * used to speed up comparisons
6433: *
6434: * Returns an int usable as a hash
6435: */
6436: static unsigned int
6437: xmlXPathStringHash(const xmlChar * string) {
6438: if (string == NULL)
6439: return((unsigned int) 0);
6440: if (string[0] == 0)
6441: return(0);
6442: return(((unsigned int) string[0]) +
6443: (((unsigned int) string[1]) << 8));
6444: }
6445:
6446: /**
6447: * xmlXPathCompareNodeSetFloat:
6448: * @ctxt: the XPath Parser context
6449: * @inf: less than (1) or greater than (0)
6450: * @strict: is the comparison strict
6451: * @arg: the node set
6452: * @f: the value
6453: *
6454: * Implement the compare operation between a nodeset and a number
6455: * @ns < @val (1, 1, ...
6456: * @ns <= @val (1, 0, ...
6457: * @ns > @val (0, 1, ...
6458: * @ns >= @val (0, 0, ...
6459: *
6460: * If one object to be compared is a node-set and the other is a number,
6461: * then the comparison will be true if and only if there is a node in the
6462: * node-set such that the result of performing the comparison on the number
6463: * to be compared and on the result of converting the string-value of that
6464: * node to a number using the number function is true.
6465: *
6466: * Returns 0 or 1 depending on the results of the test.
6467: */
6468: static int
6469: xmlXPathCompareNodeSetFloat(xmlXPathParserContextPtr ctxt, int inf, int strict,
6470: xmlXPathObjectPtr arg, xmlXPathObjectPtr f) {
6471: int i, ret = 0;
6472: xmlNodeSetPtr ns;
6473: xmlChar *str2;
6474:
6475: if ((f == NULL) || (arg == NULL) ||
6476: ((arg->type != XPATH_NODESET) && (arg->type != XPATH_XSLT_TREE))) {
6477: xmlXPathReleaseObject(ctxt->context, arg);
6478: xmlXPathReleaseObject(ctxt->context, f);
6479: return(0);
6480: }
6481: ns = arg->nodesetval;
6482: if (ns != NULL) {
6483: for (i = 0;i < ns->nodeNr;i++) {
6484: str2 = xmlXPathCastNodeToString(ns->nodeTab[i]);
6485: if (str2 != NULL) {
6486: valuePush(ctxt,
6487: xmlXPathCacheNewString(ctxt->context, str2));
6488: xmlFree(str2);
6489: xmlXPathNumberFunction(ctxt, 1);
6490: valuePush(ctxt, xmlXPathCacheObjectCopy(ctxt->context, f));
6491: ret = xmlXPathCompareValues(ctxt, inf, strict);
6492: if (ret)
6493: break;
6494: }
6495: }
6496: }
6497: xmlXPathReleaseObject(ctxt->context, arg);
6498: xmlXPathReleaseObject(ctxt->context, f);
6499: return(ret);
6500: }
6501:
6502: /**
6503: * xmlXPathCompareNodeSetString:
6504: * @ctxt: the XPath Parser context
6505: * @inf: less than (1) or greater than (0)
6506: * @strict: is the comparison strict
6507: * @arg: the node set
6508: * @s: the value
6509: *
6510: * Implement the compare operation between a nodeset and a string
6511: * @ns < @val (1, 1, ...
6512: * @ns <= @val (1, 0, ...
6513: * @ns > @val (0, 1, ...
6514: * @ns >= @val (0, 0, ...
6515: *
6516: * If one object to be compared is a node-set and the other is a string,
6517: * then the comparison will be true if and only if there is a node in
6518: * the node-set such that the result of performing the comparison on the
6519: * string-value of the node and the other string is true.
6520: *
6521: * Returns 0 or 1 depending on the results of the test.
6522: */
6523: static int
6524: xmlXPathCompareNodeSetString(xmlXPathParserContextPtr ctxt, int inf, int strict,
6525: xmlXPathObjectPtr arg, xmlXPathObjectPtr s) {
6526: int i, ret = 0;
6527: xmlNodeSetPtr ns;
6528: xmlChar *str2;
6529:
6530: if ((s == NULL) || (arg == NULL) ||
6531: ((arg->type != XPATH_NODESET) && (arg->type != XPATH_XSLT_TREE))) {
6532: xmlXPathReleaseObject(ctxt->context, arg);
6533: xmlXPathReleaseObject(ctxt->context, s);
6534: return(0);
6535: }
6536: ns = arg->nodesetval;
6537: if (ns != NULL) {
6538: for (i = 0;i < ns->nodeNr;i++) {
6539: str2 = xmlXPathCastNodeToString(ns->nodeTab[i]);
6540: if (str2 != NULL) {
6541: valuePush(ctxt,
6542: xmlXPathCacheNewString(ctxt->context, str2));
6543: xmlFree(str2);
6544: valuePush(ctxt, xmlXPathCacheObjectCopy(ctxt->context, s));
6545: ret = xmlXPathCompareValues(ctxt, inf, strict);
6546: if (ret)
6547: break;
6548: }
6549: }
6550: }
6551: xmlXPathReleaseObject(ctxt->context, arg);
6552: xmlXPathReleaseObject(ctxt->context, s);
6553: return(ret);
6554: }
6555:
6556: /**
6557: * xmlXPathCompareNodeSets:
6558: * @inf: less than (1) or greater than (0)
6559: * @strict: is the comparison strict
6560: * @arg1: the first node set object
6561: * @arg2: the second node set object
6562: *
6563: * Implement the compare operation on nodesets:
6564: *
6565: * If both objects to be compared are node-sets, then the comparison
6566: * will be true if and only if there is a node in the first node-set
6567: * and a node in the second node-set such that the result of performing
6568: * the comparison on the string-values of the two nodes is true.
6569: * ....
6570: * When neither object to be compared is a node-set and the operator
6571: * is <=, <, >= or >, then the objects are compared by converting both
6572: * objects to numbers and comparing the numbers according to IEEE 754.
6573: * ....
6574: * The number function converts its argument to a number as follows:
6575: * - a string that consists of optional whitespace followed by an
6576: * optional minus sign followed by a Number followed by whitespace
6577: * is converted to the IEEE 754 number that is nearest (according
6578: * to the IEEE 754 round-to-nearest rule) to the mathematical value
6579: * represented by the string; any other string is converted to NaN
6580: *
6581: * Conclusion all nodes need to be converted first to their string value
6582: * and then the comparison must be done when possible
6583: */
6584: static int
6585: xmlXPathCompareNodeSets(int inf, int strict,
6586: xmlXPathObjectPtr arg1, xmlXPathObjectPtr arg2) {
6587: int i, j, init = 0;
6588: double val1;
6589: double *values2;
6590: int ret = 0;
6591: xmlNodeSetPtr ns1;
6592: xmlNodeSetPtr ns2;
6593:
6594: if ((arg1 == NULL) ||
6595: ((arg1->type != XPATH_NODESET) && (arg1->type != XPATH_XSLT_TREE))) {
6596: xmlXPathFreeObject(arg2);
6597: return(0);
6598: }
6599: if ((arg2 == NULL) ||
6600: ((arg2->type != XPATH_NODESET) && (arg2->type != XPATH_XSLT_TREE))) {
6601: xmlXPathFreeObject(arg1);
6602: xmlXPathFreeObject(arg2);
6603: return(0);
6604: }
6605:
6606: ns1 = arg1->nodesetval;
6607: ns2 = arg2->nodesetval;
6608:
6609: if ((ns1 == NULL) || (ns1->nodeNr <= 0)) {
6610: xmlXPathFreeObject(arg1);
6611: xmlXPathFreeObject(arg2);
6612: return(0);
6613: }
6614: if ((ns2 == NULL) || (ns2->nodeNr <= 0)) {
6615: xmlXPathFreeObject(arg1);
6616: xmlXPathFreeObject(arg2);
6617: return(0);
6618: }
6619:
6620: values2 = (double *) xmlMalloc(ns2->nodeNr * sizeof(double));
6621: if (values2 == NULL) {
6622: xmlXPathErrMemory(NULL, "comparing nodesets\n");
6623: xmlXPathFreeObject(arg1);
6624: xmlXPathFreeObject(arg2);
6625: return(0);
6626: }
6627: for (i = 0;i < ns1->nodeNr;i++) {
6628: val1 = xmlXPathCastNodeToNumber(ns1->nodeTab[i]);
6629: if (xmlXPathIsNaN(val1))
6630: continue;
6631: for (j = 0;j < ns2->nodeNr;j++) {
6632: if (init == 0) {
6633: values2[j] = xmlXPathCastNodeToNumber(ns2->nodeTab[j]);
6634: }
6635: if (xmlXPathIsNaN(values2[j]))
6636: continue;
6637: if (inf && strict)
6638: ret = (val1 < values2[j]);
6639: else if (inf && !strict)
6640: ret = (val1 <= values2[j]);
6641: else if (!inf && strict)
6642: ret = (val1 > values2[j]);
6643: else if (!inf && !strict)
6644: ret = (val1 >= values2[j]);
6645: if (ret)
6646: break;
6647: }
6648: if (ret)
6649: break;
6650: init = 1;
6651: }
6652: xmlFree(values2);
6653: xmlXPathFreeObject(arg1);
6654: xmlXPathFreeObject(arg2);
6655: return(ret);
6656: }
6657:
6658: /**
6659: * xmlXPathCompareNodeSetValue:
6660: * @ctxt: the XPath Parser context
6661: * @inf: less than (1) or greater than (0)
6662: * @strict: is the comparison strict
6663: * @arg: the node set
6664: * @val: the value
6665: *
6666: * Implement the compare operation between a nodeset and a value
6667: * @ns < @val (1, 1, ...
6668: * @ns <= @val (1, 0, ...
6669: * @ns > @val (0, 1, ...
6670: * @ns >= @val (0, 0, ...
6671: *
6672: * If one object to be compared is a node-set and the other is a boolean,
6673: * then the comparison will be true if and only if the result of performing
6674: * the comparison on the boolean and on the result of converting
6675: * the node-set to a boolean using the boolean function is true.
6676: *
6677: * Returns 0 or 1 depending on the results of the test.
6678: */
6679: static int
6680: xmlXPathCompareNodeSetValue(xmlXPathParserContextPtr ctxt, int inf, int strict,
6681: xmlXPathObjectPtr arg, xmlXPathObjectPtr val) {
6682: if ((val == NULL) || (arg == NULL) ||
6683: ((arg->type != XPATH_NODESET) && (arg->type != XPATH_XSLT_TREE)))
6684: return(0);
6685:
6686: switch(val->type) {
6687: case XPATH_NUMBER:
6688: return(xmlXPathCompareNodeSetFloat(ctxt, inf, strict, arg, val));
6689: case XPATH_NODESET:
6690: case XPATH_XSLT_TREE:
6691: return(xmlXPathCompareNodeSets(inf, strict, arg, val));
6692: case XPATH_STRING:
6693: return(xmlXPathCompareNodeSetString(ctxt, inf, strict, arg, val));
6694: case XPATH_BOOLEAN:
6695: valuePush(ctxt, arg);
6696: xmlXPathBooleanFunction(ctxt, 1);
6697: valuePush(ctxt, val);
6698: return(xmlXPathCompareValues(ctxt, inf, strict));
6699: default:
6700: TODO
6701: }
6702: return(0);
6703: }
6704:
6705: /**
6706: * xmlXPathEqualNodeSetString:
6707: * @arg: the nodeset object argument
6708: * @str: the string to compare to.
6709: * @neq: flag to show whether for '=' (0) or '!=' (1)
6710: *
6711: * Implement the equal operation on XPath objects content: @arg1 == @arg2
6712: * If one object to be compared is a node-set and the other is a string,
6713: * then the comparison will be true if and only if there is a node in
6714: * the node-set such that the result of performing the comparison on the
6715: * string-value of the node and the other string is true.
6716: *
6717: * Returns 0 or 1 depending on the results of the test.
6718: */
6719: static int
6720: xmlXPathEqualNodeSetString(xmlXPathObjectPtr arg, const xmlChar * str, int neq)
6721: {
6722: int i;
6723: xmlNodeSetPtr ns;
6724: xmlChar *str2;
6725: unsigned int hash;
6726:
6727: if ((str == NULL) || (arg == NULL) ||
6728: ((arg->type != XPATH_NODESET) && (arg->type != XPATH_XSLT_TREE)))
6729: return (0);
6730: ns = arg->nodesetval;
6731: /*
6732: * A NULL nodeset compared with a string is always false
6733: * (since there is no node equal, and no node not equal)
6734: */
6735: if ((ns == NULL) || (ns->nodeNr <= 0) )
6736: return (0);
6737: hash = xmlXPathStringHash(str);
6738: for (i = 0; i < ns->nodeNr; i++) {
6739: if (xmlXPathNodeValHash(ns->nodeTab[i]) == hash) {
6740: str2 = xmlNodeGetContent(ns->nodeTab[i]);
6741: if ((str2 != NULL) && (xmlStrEqual(str, str2))) {
6742: xmlFree(str2);
6743: if (neq)
6744: continue;
6745: return (1);
6746: } else if ((str2 == NULL) && (xmlStrEqual(str, BAD_CAST ""))) {
6747: if (neq)
6748: continue;
6749: return (1);
6750: } else if (neq) {
6751: if (str2 != NULL)
6752: xmlFree(str2);
6753: return (1);
6754: }
6755: if (str2 != NULL)
6756: xmlFree(str2);
6757: } else if (neq)
6758: return (1);
6759: }
6760: return (0);
6761: }
6762:
6763: /**
6764: * xmlXPathEqualNodeSetFloat:
6765: * @arg: the nodeset object argument
6766: * @f: the float to compare to
6767: * @neq: flag to show whether to compare '=' (0) or '!=' (1)
6768: *
6769: * Implement the equal operation on XPath objects content: @arg1 == @arg2
6770: * If one object to be compared is a node-set and the other is a number,
6771: * then the comparison will be true if and only if there is a node in
6772: * the node-set such that the result of performing the comparison on the
6773: * number to be compared and on the result of converting the string-value
6774: * of that node to a number using the number function is true.
6775: *
6776: * Returns 0 or 1 depending on the results of the test.
6777: */
6778: static int
6779: xmlXPathEqualNodeSetFloat(xmlXPathParserContextPtr ctxt,
6780: xmlXPathObjectPtr arg, double f, int neq) {
6781: int i, ret=0;
6782: xmlNodeSetPtr ns;
6783: xmlChar *str2;
6784: xmlXPathObjectPtr val;
6785: double v;
6786:
6787: if ((arg == NULL) ||
6788: ((arg->type != XPATH_NODESET) && (arg->type != XPATH_XSLT_TREE)))
6789: return(0);
6790:
6791: ns = arg->nodesetval;
6792: if (ns != NULL) {
6793: for (i=0;i<ns->nodeNr;i++) {
6794: str2 = xmlXPathCastNodeToString(ns->nodeTab[i]);
6795: if (str2 != NULL) {
6796: valuePush(ctxt, xmlXPathCacheNewString(ctxt->context, str2));
6797: xmlFree(str2);
6798: xmlXPathNumberFunction(ctxt, 1);
6799: val = valuePop(ctxt);
6800: v = val->floatval;
6801: xmlXPathReleaseObject(ctxt->context, val);
6802: if (!xmlXPathIsNaN(v)) {
6803: if ((!neq) && (v==f)) {
6804: ret = 1;
6805: break;
6806: } else if ((neq) && (v!=f)) {
6807: ret = 1;
6808: break;
6809: }
6810: } else { /* NaN is unequal to any value */
6811: if (neq)
6812: ret = 1;
6813: }
6814: }
6815: }
6816: }
6817:
6818: return(ret);
6819: }
6820:
6821:
6822: /**
6823: * xmlXPathEqualNodeSets:
6824: * @arg1: first nodeset object argument
6825: * @arg2: second nodeset object argument
6826: * @neq: flag to show whether to test '=' (0) or '!=' (1)
6827: *
6828: * Implement the equal / not equal operation on XPath nodesets:
6829: * @arg1 == @arg2 or @arg1 != @arg2
6830: * If both objects to be compared are node-sets, then the comparison
6831: * will be true if and only if there is a node in the first node-set and
6832: * a node in the second node-set such that the result of performing the
6833: * comparison on the string-values of the two nodes is true.
6834: *
6835: * (needless to say, this is a costly operation)
6836: *
6837: * Returns 0 or 1 depending on the results of the test.
6838: */
6839: static int
6840: xmlXPathEqualNodeSets(xmlXPathObjectPtr arg1, xmlXPathObjectPtr arg2, int neq) {
6841: int i, j;
6842: unsigned int *hashs1;
6843: unsigned int *hashs2;
6844: xmlChar **values1;
6845: xmlChar **values2;
6846: int ret = 0;
6847: xmlNodeSetPtr ns1;
6848: xmlNodeSetPtr ns2;
6849:
6850: if ((arg1 == NULL) ||
6851: ((arg1->type != XPATH_NODESET) && (arg1->type != XPATH_XSLT_TREE)))
6852: return(0);
6853: if ((arg2 == NULL) ||
6854: ((arg2->type != XPATH_NODESET) && (arg2->type != XPATH_XSLT_TREE)))
6855: return(0);
6856:
6857: ns1 = arg1->nodesetval;
6858: ns2 = arg2->nodesetval;
6859:
6860: if ((ns1 == NULL) || (ns1->nodeNr <= 0))
6861: return(0);
6862: if ((ns2 == NULL) || (ns2->nodeNr <= 0))
6863: return(0);
6864:
6865: /*
6866: * for equal, check if there is a node pertaining to both sets
6867: */
6868: if (neq == 0)
6869: for (i = 0;i < ns1->nodeNr;i++)
6870: for (j = 0;j < ns2->nodeNr;j++)
6871: if (ns1->nodeTab[i] == ns2->nodeTab[j])
6872: return(1);
6873:
6874: values1 = (xmlChar **) xmlMalloc(ns1->nodeNr * sizeof(xmlChar *));
6875: if (values1 == NULL) {
6876: xmlXPathErrMemory(NULL, "comparing nodesets\n");
6877: return(0);
6878: }
6879: hashs1 = (unsigned int *) xmlMalloc(ns1->nodeNr * sizeof(unsigned int));
6880: if (hashs1 == NULL) {
6881: xmlXPathErrMemory(NULL, "comparing nodesets\n");
6882: xmlFree(values1);
6883: return(0);
6884: }
6885: memset(values1, 0, ns1->nodeNr * sizeof(xmlChar *));
6886: values2 = (xmlChar **) xmlMalloc(ns2->nodeNr * sizeof(xmlChar *));
6887: if (values2 == NULL) {
6888: xmlXPathErrMemory(NULL, "comparing nodesets\n");
6889: xmlFree(hashs1);
6890: xmlFree(values1);
6891: return(0);
6892: }
6893: hashs2 = (unsigned int *) xmlMalloc(ns2->nodeNr * sizeof(unsigned int));
6894: if (hashs2 == NULL) {
6895: xmlXPathErrMemory(NULL, "comparing nodesets\n");
6896: xmlFree(hashs1);
6897: xmlFree(values1);
6898: xmlFree(values2);
6899: return(0);
6900: }
6901: memset(values2, 0, ns2->nodeNr * sizeof(xmlChar *));
6902: for (i = 0;i < ns1->nodeNr;i++) {
6903: hashs1[i] = xmlXPathNodeValHash(ns1->nodeTab[i]);
6904: for (j = 0;j < ns2->nodeNr;j++) {
6905: if (i == 0)
6906: hashs2[j] = xmlXPathNodeValHash(ns2->nodeTab[j]);
6907: if (hashs1[i] != hashs2[j]) {
6908: if (neq) {
6909: ret = 1;
6910: break;
6911: }
6912: }
6913: else {
6914: if (values1[i] == NULL)
6915: values1[i] = xmlNodeGetContent(ns1->nodeTab[i]);
6916: if (values2[j] == NULL)
6917: values2[j] = xmlNodeGetContent(ns2->nodeTab[j]);
6918: ret = xmlStrEqual(values1[i], values2[j]) ^ neq;
6919: if (ret)
6920: break;
6921: }
6922: }
6923: if (ret)
6924: break;
6925: }
6926: for (i = 0;i < ns1->nodeNr;i++)
6927: if (values1[i] != NULL)
6928: xmlFree(values1[i]);
6929: for (j = 0;j < ns2->nodeNr;j++)
6930: if (values2[j] != NULL)
6931: xmlFree(values2[j]);
6932: xmlFree(values1);
6933: xmlFree(values2);
6934: xmlFree(hashs1);
6935: xmlFree(hashs2);
6936: return(ret);
6937: }
6938:
6939: static int
6940: xmlXPathEqualValuesCommon(xmlXPathParserContextPtr ctxt,
6941: xmlXPathObjectPtr arg1, xmlXPathObjectPtr arg2) {
6942: int ret = 0;
6943: /*
6944: *At this point we are assured neither arg1 nor arg2
6945: *is a nodeset, so we can just pick the appropriate routine.
6946: */
6947: switch (arg1->type) {
6948: case XPATH_UNDEFINED:
6949: #ifdef DEBUG_EXPR
6950: xmlGenericError(xmlGenericErrorContext,
6951: "Equal: undefined\n");
6952: #endif
6953: break;
6954: case XPATH_BOOLEAN:
6955: switch (arg2->type) {
6956: case XPATH_UNDEFINED:
6957: #ifdef DEBUG_EXPR
6958: xmlGenericError(xmlGenericErrorContext,
6959: "Equal: undefined\n");
6960: #endif
6961: break;
6962: case XPATH_BOOLEAN:
6963: #ifdef DEBUG_EXPR
6964: xmlGenericError(xmlGenericErrorContext,
6965: "Equal: %d boolean %d \n",
6966: arg1->boolval, arg2->boolval);
6967: #endif
6968: ret = (arg1->boolval == arg2->boolval);
6969: break;
6970: case XPATH_NUMBER:
6971: ret = (arg1->boolval ==
6972: xmlXPathCastNumberToBoolean(arg2->floatval));
6973: break;
6974: case XPATH_STRING:
6975: if ((arg2->stringval == NULL) ||
6976: (arg2->stringval[0] == 0)) ret = 0;
6977: else
6978: ret = 1;
6979: ret = (arg1->boolval == ret);
6980: break;
6981: case XPATH_USERS:
6982: case XPATH_POINT:
6983: case XPATH_RANGE:
6984: case XPATH_LOCATIONSET:
6985: TODO
6986: break;
6987: case XPATH_NODESET:
6988: case XPATH_XSLT_TREE:
6989: break;
6990: }
6991: break;
6992: case XPATH_NUMBER:
6993: switch (arg2->type) {
6994: case XPATH_UNDEFINED:
6995: #ifdef DEBUG_EXPR
6996: xmlGenericError(xmlGenericErrorContext,
6997: "Equal: undefined\n");
6998: #endif
6999: break;
7000: case XPATH_BOOLEAN:
7001: ret = (arg2->boolval==
7002: xmlXPathCastNumberToBoolean(arg1->floatval));
7003: break;
7004: case XPATH_STRING:
7005: valuePush(ctxt, arg2);
7006: xmlXPathNumberFunction(ctxt, 1);
7007: arg2 = valuePop(ctxt);
7008: /* no break on purpose */
7009: case XPATH_NUMBER:
7010: /* Hand check NaN and Infinity equalities */
7011: if (xmlXPathIsNaN(arg1->floatval) ||
7012: xmlXPathIsNaN(arg2->floatval)) {
7013: ret = 0;
7014: } else if (xmlXPathIsInf(arg1->floatval) == 1) {
7015: if (xmlXPathIsInf(arg2->floatval) == 1)
7016: ret = 1;
7017: else
7018: ret = 0;
7019: } else if (xmlXPathIsInf(arg1->floatval) == -1) {
7020: if (xmlXPathIsInf(arg2->floatval) == -1)
7021: ret = 1;
7022: else
7023: ret = 0;
7024: } else if (xmlXPathIsInf(arg2->floatval) == 1) {
7025: if (xmlXPathIsInf(arg1->floatval) == 1)
7026: ret = 1;
7027: else
7028: ret = 0;
7029: } else if (xmlXPathIsInf(arg2->floatval) == -1) {
7030: if (xmlXPathIsInf(arg1->floatval) == -1)
7031: ret = 1;
7032: else
7033: ret = 0;
7034: } else {
7035: ret = (arg1->floatval == arg2->floatval);
7036: }
7037: break;
7038: case XPATH_USERS:
7039: case XPATH_POINT:
7040: case XPATH_RANGE:
7041: case XPATH_LOCATIONSET:
7042: TODO
7043: break;
7044: case XPATH_NODESET:
7045: case XPATH_XSLT_TREE:
7046: break;
7047: }
7048: break;
7049: case XPATH_STRING:
7050: switch (arg2->type) {
7051: case XPATH_UNDEFINED:
7052: #ifdef DEBUG_EXPR
7053: xmlGenericError(xmlGenericErrorContext,
7054: "Equal: undefined\n");
7055: #endif
7056: break;
7057: case XPATH_BOOLEAN:
7058: if ((arg1->stringval == NULL) ||
7059: (arg1->stringval[0] == 0)) ret = 0;
7060: else
7061: ret = 1;
7062: ret = (arg2->boolval == ret);
7063: break;
7064: case XPATH_STRING:
7065: ret = xmlStrEqual(arg1->stringval, arg2->stringval);
7066: break;
7067: case XPATH_NUMBER:
7068: valuePush(ctxt, arg1);
7069: xmlXPathNumberFunction(ctxt, 1);
7070: arg1 = valuePop(ctxt);
7071: /* Hand check NaN and Infinity equalities */
7072: if (xmlXPathIsNaN(arg1->floatval) ||
7073: xmlXPathIsNaN(arg2->floatval)) {
7074: ret = 0;
7075: } else if (xmlXPathIsInf(arg1->floatval) == 1) {
7076: if (xmlXPathIsInf(arg2->floatval) == 1)
7077: ret = 1;
7078: else
7079: ret = 0;
7080: } else if (xmlXPathIsInf(arg1->floatval) == -1) {
7081: if (xmlXPathIsInf(arg2->floatval) == -1)
7082: ret = 1;
7083: else
7084: ret = 0;
7085: } else if (xmlXPathIsInf(arg2->floatval) == 1) {
7086: if (xmlXPathIsInf(arg1->floatval) == 1)
7087: ret = 1;
7088: else
7089: ret = 0;
7090: } else if (xmlXPathIsInf(arg2->floatval) == -1) {
7091: if (xmlXPathIsInf(arg1->floatval) == -1)
7092: ret = 1;
7093: else
7094: ret = 0;
7095: } else {
7096: ret = (arg1->floatval == arg2->floatval);
7097: }
7098: break;
7099: case XPATH_USERS:
7100: case XPATH_POINT:
7101: case XPATH_RANGE:
7102: case XPATH_LOCATIONSET:
7103: TODO
7104: break;
7105: case XPATH_NODESET:
7106: case XPATH_XSLT_TREE:
7107: break;
7108: }
7109: break;
7110: case XPATH_USERS:
7111: case XPATH_POINT:
7112: case XPATH_RANGE:
7113: case XPATH_LOCATIONSET:
7114: TODO
7115: break;
7116: case XPATH_NODESET:
7117: case XPATH_XSLT_TREE:
7118: break;
7119: }
7120: xmlXPathReleaseObject(ctxt->context, arg1);
7121: xmlXPathReleaseObject(ctxt->context, arg2);
7122: return(ret);
7123: }
7124:
7125: /**
7126: * xmlXPathEqualValues:
7127: * @ctxt: the XPath Parser context
7128: *
7129: * Implement the equal operation on XPath objects content: @arg1 == @arg2
7130: *
7131: * Returns 0 or 1 depending on the results of the test.
7132: */
7133: int
7134: xmlXPathEqualValues(xmlXPathParserContextPtr ctxt) {
7135: xmlXPathObjectPtr arg1, arg2, argtmp;
7136: int ret = 0;
7137:
7138: if ((ctxt == NULL) || (ctxt->context == NULL)) return(0);
7139: arg2 = valuePop(ctxt);
7140: arg1 = valuePop(ctxt);
7141: if ((arg1 == NULL) || (arg2 == NULL)) {
7142: if (arg1 != NULL)
7143: xmlXPathReleaseObject(ctxt->context, arg1);
7144: else
7145: xmlXPathReleaseObject(ctxt->context, arg2);
7146: XP_ERROR0(XPATH_INVALID_OPERAND);
7147: }
7148:
7149: if (arg1 == arg2) {
7150: #ifdef DEBUG_EXPR
7151: xmlGenericError(xmlGenericErrorContext,
7152: "Equal: by pointer\n");
7153: #endif
7154: xmlXPathFreeObject(arg1);
7155: return(1);
7156: }
7157:
7158: /*
7159: *If either argument is a nodeset, it's a 'special case'
7160: */
7161: if ((arg2->type == XPATH_NODESET) || (arg2->type == XPATH_XSLT_TREE) ||
7162: (arg1->type == XPATH_NODESET) || (arg1->type == XPATH_XSLT_TREE)) {
7163: /*
7164: *Hack it to assure arg1 is the nodeset
7165: */
7166: if ((arg1->type != XPATH_NODESET) && (arg1->type != XPATH_XSLT_TREE)) {
7167: argtmp = arg2;
7168: arg2 = arg1;
7169: arg1 = argtmp;
7170: }
7171: switch (arg2->type) {
7172: case XPATH_UNDEFINED:
7173: #ifdef DEBUG_EXPR
7174: xmlGenericError(xmlGenericErrorContext,
7175: "Equal: undefined\n");
7176: #endif
7177: break;
7178: case XPATH_NODESET:
7179: case XPATH_XSLT_TREE:
7180: ret = xmlXPathEqualNodeSets(arg1, arg2, 0);
7181: break;
7182: case XPATH_BOOLEAN:
7183: if ((arg1->nodesetval == NULL) ||
7184: (arg1->nodesetval->nodeNr == 0)) ret = 0;
7185: else
7186: ret = 1;
7187: ret = (ret == arg2->boolval);
7188: break;
7189: case XPATH_NUMBER:
7190: ret = xmlXPathEqualNodeSetFloat(ctxt, arg1, arg2->floatval, 0);
7191: break;
7192: case XPATH_STRING:
7193: ret = xmlXPathEqualNodeSetString(arg1, arg2->stringval, 0);
7194: break;
7195: case XPATH_USERS:
7196: case XPATH_POINT:
7197: case XPATH_RANGE:
7198: case XPATH_LOCATIONSET:
7199: TODO
7200: break;
7201: }
7202: xmlXPathReleaseObject(ctxt->context, arg1);
7203: xmlXPathReleaseObject(ctxt->context, arg2);
7204: return(ret);
7205: }
7206:
7207: return (xmlXPathEqualValuesCommon(ctxt, arg1, arg2));
7208: }
7209:
7210: /**
7211: * xmlXPathNotEqualValues:
7212: * @ctxt: the XPath Parser context
7213: *
7214: * Implement the equal operation on XPath objects content: @arg1 == @arg2
7215: *
7216: * Returns 0 or 1 depending on the results of the test.
7217: */
7218: int
7219: xmlXPathNotEqualValues(xmlXPathParserContextPtr ctxt) {
7220: xmlXPathObjectPtr arg1, arg2, argtmp;
7221: int ret = 0;
7222:
7223: if ((ctxt == NULL) || (ctxt->context == NULL)) return(0);
7224: arg2 = valuePop(ctxt);
7225: arg1 = valuePop(ctxt);
7226: if ((arg1 == NULL) || (arg2 == NULL)) {
7227: if (arg1 != NULL)
7228: xmlXPathReleaseObject(ctxt->context, arg1);
7229: else
7230: xmlXPathReleaseObject(ctxt->context, arg2);
7231: XP_ERROR0(XPATH_INVALID_OPERAND);
7232: }
7233:
7234: if (arg1 == arg2) {
7235: #ifdef DEBUG_EXPR
7236: xmlGenericError(xmlGenericErrorContext,
7237: "NotEqual: by pointer\n");
7238: #endif
7239: xmlXPathReleaseObject(ctxt->context, arg1);
7240: return(0);
7241: }
7242:
7243: /*
7244: *If either argument is a nodeset, it's a 'special case'
7245: */
7246: if ((arg2->type == XPATH_NODESET) || (arg2->type == XPATH_XSLT_TREE) ||
7247: (arg1->type == XPATH_NODESET) || (arg1->type == XPATH_XSLT_TREE)) {
7248: /*
7249: *Hack it to assure arg1 is the nodeset
7250: */
7251: if ((arg1->type != XPATH_NODESET) && (arg1->type != XPATH_XSLT_TREE)) {
7252: argtmp = arg2;
7253: arg2 = arg1;
7254: arg1 = argtmp;
7255: }
7256: switch (arg2->type) {
7257: case XPATH_UNDEFINED:
7258: #ifdef DEBUG_EXPR
7259: xmlGenericError(xmlGenericErrorContext,
7260: "NotEqual: undefined\n");
7261: #endif
7262: break;
7263: case XPATH_NODESET:
7264: case XPATH_XSLT_TREE:
7265: ret = xmlXPathEqualNodeSets(arg1, arg2, 1);
7266: break;
7267: case XPATH_BOOLEAN:
7268: if ((arg1->nodesetval == NULL) ||
7269: (arg1->nodesetval->nodeNr == 0)) ret = 0;
7270: else
7271: ret = 1;
7272: ret = (ret != arg2->boolval);
7273: break;
7274: case XPATH_NUMBER:
7275: ret = xmlXPathEqualNodeSetFloat(ctxt, arg1, arg2->floatval, 1);
7276: break;
7277: case XPATH_STRING:
7278: ret = xmlXPathEqualNodeSetString(arg1, arg2->stringval,1);
7279: break;
7280: case XPATH_USERS:
7281: case XPATH_POINT:
7282: case XPATH_RANGE:
7283: case XPATH_LOCATIONSET:
7284: TODO
7285: break;
7286: }
7287: xmlXPathReleaseObject(ctxt->context, arg1);
7288: xmlXPathReleaseObject(ctxt->context, arg2);
7289: return(ret);
7290: }
7291:
7292: return (!xmlXPathEqualValuesCommon(ctxt, arg1, arg2));
7293: }
7294:
7295: /**
7296: * xmlXPathCompareValues:
7297: * @ctxt: the XPath Parser context
7298: * @inf: less than (1) or greater than (0)
7299: * @strict: is the comparison strict
7300: *
7301: * Implement the compare operation on XPath objects:
7302: * @arg1 < @arg2 (1, 1, ...
7303: * @arg1 <= @arg2 (1, 0, ...
7304: * @arg1 > @arg2 (0, 1, ...
7305: * @arg1 >= @arg2 (0, 0, ...
7306: *
7307: * When neither object to be compared is a node-set and the operator is
7308: * <=, <, >=, >, then the objects are compared by converted both objects
7309: * to numbers and comparing the numbers according to IEEE 754. The <
7310: * comparison will be true if and only if the first number is less than the
7311: * second number. The <= comparison will be true if and only if the first
7312: * number is less than or equal to the second number. The > comparison
7313: * will be true if and only if the first number is greater than the second
7314: * number. The >= comparison will be true if and only if the first number
7315: * is greater than or equal to the second number.
7316: *
7317: * Returns 1 if the comparison succeeded, 0 if it failed
7318: */
7319: int
7320: xmlXPathCompareValues(xmlXPathParserContextPtr ctxt, int inf, int strict) {
7321: int ret = 0, arg1i = 0, arg2i = 0;
7322: xmlXPathObjectPtr arg1, arg2;
7323:
7324: if ((ctxt == NULL) || (ctxt->context == NULL)) return(0);
7325: arg2 = valuePop(ctxt);
7326: arg1 = valuePop(ctxt);
7327: if ((arg1 == NULL) || (arg2 == NULL)) {
7328: if (arg1 != NULL)
7329: xmlXPathReleaseObject(ctxt->context, arg1);
7330: else
7331: xmlXPathReleaseObject(ctxt->context, arg2);
7332: XP_ERROR0(XPATH_INVALID_OPERAND);
7333: }
7334:
7335: if ((arg2->type == XPATH_NODESET) || (arg2->type == XPATH_XSLT_TREE) ||
7336: (arg1->type == XPATH_NODESET) || (arg1->type == XPATH_XSLT_TREE)) {
7337: /*
7338: * If either argument is a XPATH_NODESET or XPATH_XSLT_TREE the two arguments
7339: * are not freed from within this routine; they will be freed from the
7340: * called routine, e.g. xmlXPathCompareNodeSets or xmlXPathCompareNodeSetValue
7341: */
7342: if (((arg2->type == XPATH_NODESET) || (arg2->type == XPATH_XSLT_TREE)) &&
7343: ((arg1->type == XPATH_NODESET) || (arg1->type == XPATH_XSLT_TREE))){
7344: ret = xmlXPathCompareNodeSets(inf, strict, arg1, arg2);
7345: } else {
7346: if ((arg1->type == XPATH_NODESET) || (arg1->type == XPATH_XSLT_TREE)) {
7347: ret = xmlXPathCompareNodeSetValue(ctxt, inf, strict,
7348: arg1, arg2);
7349: } else {
7350: ret = xmlXPathCompareNodeSetValue(ctxt, !inf, strict,
7351: arg2, arg1);
7352: }
7353: }
7354: return(ret);
7355: }
7356:
7357: if (arg1->type != XPATH_NUMBER) {
7358: valuePush(ctxt, arg1);
7359: xmlXPathNumberFunction(ctxt, 1);
7360: arg1 = valuePop(ctxt);
7361: }
7362: if (arg1->type != XPATH_NUMBER) {
7363: xmlXPathFreeObject(arg1);
7364: xmlXPathFreeObject(arg2);
7365: XP_ERROR0(XPATH_INVALID_OPERAND);
7366: }
7367: if (arg2->type != XPATH_NUMBER) {
7368: valuePush(ctxt, arg2);
7369: xmlXPathNumberFunction(ctxt, 1);
7370: arg2 = valuePop(ctxt);
7371: }
7372: if (arg2->type != XPATH_NUMBER) {
7373: xmlXPathReleaseObject(ctxt->context, arg1);
7374: xmlXPathReleaseObject(ctxt->context, arg2);
7375: XP_ERROR0(XPATH_INVALID_OPERAND);
7376: }
7377: /*
7378: * Add tests for infinity and nan
7379: * => feedback on 3.4 for Inf and NaN
7380: */
7381: /* Hand check NaN and Infinity comparisons */
7382: if (xmlXPathIsNaN(arg1->floatval) || xmlXPathIsNaN(arg2->floatval)) {
7383: ret=0;
7384: } else {
7385: arg1i=xmlXPathIsInf(arg1->floatval);
7386: arg2i=xmlXPathIsInf(arg2->floatval);
7387: if (inf && strict) {
7388: if ((arg1i == -1 && arg2i != -1) ||
7389: (arg2i == 1 && arg1i != 1)) {
7390: ret = 1;
7391: } else if (arg1i == 0 && arg2i == 0) {
7392: ret = (arg1->floatval < arg2->floatval);
7393: } else {
7394: ret = 0;
7395: }
7396: }
7397: else if (inf && !strict) {
7398: if (arg1i == -1 || arg2i == 1) {
7399: ret = 1;
7400: } else if (arg1i == 0 && arg2i == 0) {
7401: ret = (arg1->floatval <= arg2->floatval);
7402: } else {
7403: ret = 0;
7404: }
7405: }
7406: else if (!inf && strict) {
7407: if ((arg1i == 1 && arg2i != 1) ||
7408: (arg2i == -1 && arg1i != -1)) {
7409: ret = 1;
7410: } else if (arg1i == 0 && arg2i == 0) {
7411: ret = (arg1->floatval > arg2->floatval);
7412: } else {
7413: ret = 0;
7414: }
7415: }
7416: else if (!inf && !strict) {
7417: if (arg1i == 1 || arg2i == -1) {
7418: ret = 1;
7419: } else if (arg1i == 0 && arg2i == 0) {
7420: ret = (arg1->floatval >= arg2->floatval);
7421: } else {
7422: ret = 0;
7423: }
7424: }
7425: }
7426: xmlXPathReleaseObject(ctxt->context, arg1);
7427: xmlXPathReleaseObject(ctxt->context, arg2);
7428: return(ret);
7429: }
7430:
7431: /**
7432: * xmlXPathValueFlipSign:
7433: * @ctxt: the XPath Parser context
7434: *
7435: * Implement the unary - operation on an XPath object
7436: * The numeric operators convert their operands to numbers as if
7437: * by calling the number function.
7438: */
7439: void
7440: xmlXPathValueFlipSign(xmlXPathParserContextPtr ctxt) {
7441: if ((ctxt == NULL) || (ctxt->context == NULL)) return;
7442: CAST_TO_NUMBER;
7443: CHECK_TYPE(XPATH_NUMBER);
7444: if (xmlXPathIsNaN(ctxt->value->floatval))
7445: ctxt->value->floatval=xmlXPathNAN;
7446: else if (xmlXPathIsInf(ctxt->value->floatval) == 1)
7447: ctxt->value->floatval=xmlXPathNINF;
7448: else if (xmlXPathIsInf(ctxt->value->floatval) == -1)
7449: ctxt->value->floatval=xmlXPathPINF;
7450: else if (ctxt->value->floatval == 0) {
7451: if (xmlXPathGetSign(ctxt->value->floatval) == 0)
7452: ctxt->value->floatval = xmlXPathNZERO;
7453: else
7454: ctxt->value->floatval = 0;
7455: }
7456: else
7457: ctxt->value->floatval = - ctxt->value->floatval;
7458: }
7459:
7460: /**
7461: * xmlXPathAddValues:
7462: * @ctxt: the XPath Parser context
7463: *
7464: * Implement the add operation on XPath objects:
7465: * The numeric operators convert their operands to numbers as if
7466: * by calling the number function.
7467: */
7468: void
7469: xmlXPathAddValues(xmlXPathParserContextPtr ctxt) {
7470: xmlXPathObjectPtr arg;
7471: double val;
7472:
7473: arg = valuePop(ctxt);
7474: if (arg == NULL)
7475: XP_ERROR(XPATH_INVALID_OPERAND);
7476: val = xmlXPathCastToNumber(arg);
7477: xmlXPathReleaseObject(ctxt->context, arg);
7478: CAST_TO_NUMBER;
7479: CHECK_TYPE(XPATH_NUMBER);
7480: ctxt->value->floatval += val;
7481: }
7482:
7483: /**
7484: * xmlXPathSubValues:
7485: * @ctxt: the XPath Parser context
7486: *
7487: * Implement the subtraction operation on XPath objects:
7488: * The numeric operators convert their operands to numbers as if
7489: * by calling the number function.
7490: */
7491: void
7492: xmlXPathSubValues(xmlXPathParserContextPtr ctxt) {
7493: xmlXPathObjectPtr arg;
7494: double val;
7495:
7496: arg = valuePop(ctxt);
7497: if (arg == NULL)
7498: XP_ERROR(XPATH_INVALID_OPERAND);
7499: val = xmlXPathCastToNumber(arg);
7500: xmlXPathReleaseObject(ctxt->context, arg);
7501: CAST_TO_NUMBER;
7502: CHECK_TYPE(XPATH_NUMBER);
7503: ctxt->value->floatval -= val;
7504: }
7505:
7506: /**
7507: * xmlXPathMultValues:
7508: * @ctxt: the XPath Parser context
7509: *
7510: * Implement the multiply operation on XPath objects:
7511: * The numeric operators convert their operands to numbers as if
7512: * by calling the number function.
7513: */
7514: void
7515: xmlXPathMultValues(xmlXPathParserContextPtr ctxt) {
7516: xmlXPathObjectPtr arg;
7517: double val;
7518:
7519: arg = valuePop(ctxt);
7520: if (arg == NULL)
7521: XP_ERROR(XPATH_INVALID_OPERAND);
7522: val = xmlXPathCastToNumber(arg);
7523: xmlXPathReleaseObject(ctxt->context, arg);
7524: CAST_TO_NUMBER;
7525: CHECK_TYPE(XPATH_NUMBER);
7526: ctxt->value->floatval *= val;
7527: }
7528:
7529: /**
7530: * xmlXPathDivValues:
7531: * @ctxt: the XPath Parser context
7532: *
7533: * Implement the div operation on XPath objects @arg1 / @arg2:
7534: * The numeric operators convert their operands to numbers as if
7535: * by calling the number function.
7536: */
7537: void
7538: xmlXPathDivValues(xmlXPathParserContextPtr ctxt) {
7539: xmlXPathObjectPtr arg;
7540: double val;
7541:
7542: arg = valuePop(ctxt);
7543: if (arg == NULL)
7544: XP_ERROR(XPATH_INVALID_OPERAND);
7545: val = xmlXPathCastToNumber(arg);
7546: xmlXPathReleaseObject(ctxt->context, arg);
7547: CAST_TO_NUMBER;
7548: CHECK_TYPE(XPATH_NUMBER);
7549: if (xmlXPathIsNaN(val) || xmlXPathIsNaN(ctxt->value->floatval))
7550: ctxt->value->floatval = xmlXPathNAN;
7551: else if (val == 0 && xmlXPathGetSign(val) != 0) {
7552: if (ctxt->value->floatval == 0)
7553: ctxt->value->floatval = xmlXPathNAN;
7554: else if (ctxt->value->floatval > 0)
7555: ctxt->value->floatval = xmlXPathNINF;
7556: else if (ctxt->value->floatval < 0)
7557: ctxt->value->floatval = xmlXPathPINF;
7558: }
7559: else if (val == 0) {
7560: if (ctxt->value->floatval == 0)
7561: ctxt->value->floatval = xmlXPathNAN;
7562: else if (ctxt->value->floatval > 0)
7563: ctxt->value->floatval = xmlXPathPINF;
7564: else if (ctxt->value->floatval < 0)
7565: ctxt->value->floatval = xmlXPathNINF;
7566: } else
7567: ctxt->value->floatval /= val;
7568: }
7569:
7570: /**
7571: * xmlXPathModValues:
7572: * @ctxt: the XPath Parser context
7573: *
7574: * Implement the mod operation on XPath objects: @arg1 / @arg2
7575: * The numeric operators convert their operands to numbers as if
7576: * by calling the number function.
7577: */
7578: void
7579: xmlXPathModValues(xmlXPathParserContextPtr ctxt) {
7580: xmlXPathObjectPtr arg;
7581: double arg1, arg2;
7582:
7583: arg = valuePop(ctxt);
7584: if (arg == NULL)
7585: XP_ERROR(XPATH_INVALID_OPERAND);
7586: arg2 = xmlXPathCastToNumber(arg);
7587: xmlXPathReleaseObject(ctxt->context, arg);
7588: CAST_TO_NUMBER;
7589: CHECK_TYPE(XPATH_NUMBER);
7590: arg1 = ctxt->value->floatval;
7591: if (arg2 == 0)
7592: ctxt->value->floatval = xmlXPathNAN;
7593: else {
7594: ctxt->value->floatval = fmod(arg1, arg2);
7595: }
7596: }
7597:
7598: /************************************************************************
7599: * *
7600: * The traversal functions *
7601: * *
7602: ************************************************************************/
7603:
7604: /*
7605: * A traversal function enumerates nodes along an axis.
7606: * Initially it must be called with NULL, and it indicates
7607: * termination on the axis by returning NULL.
7608: */
7609: typedef xmlNodePtr (*xmlXPathTraversalFunction)
7610: (xmlXPathParserContextPtr ctxt, xmlNodePtr cur);
7611:
7612: /*
7613: * xmlXPathTraversalFunctionExt:
7614: * A traversal function enumerates nodes along an axis.
7615: * Initially it must be called with NULL, and it indicates
7616: * termination on the axis by returning NULL.
7617: * The context node of the traversal is specified via @contextNode.
7618: */
7619: typedef xmlNodePtr (*xmlXPathTraversalFunctionExt)
7620: (xmlNodePtr cur, xmlNodePtr contextNode);
7621:
7622: /*
7623: * xmlXPathNodeSetMergeFunction:
7624: * Used for merging node sets in xmlXPathCollectAndTest().
7625: */
7626: typedef xmlNodeSetPtr (*xmlXPathNodeSetMergeFunction)
7627: (xmlNodeSetPtr, xmlNodeSetPtr, int);
7628:
7629:
7630: /**
7631: * xmlXPathNextSelf:
7632: * @ctxt: the XPath Parser context
7633: * @cur: the current node in the traversal
7634: *
7635: * Traversal function for the "self" direction
7636: * The self axis contains just the context node itself
7637: *
7638: * Returns the next element following that axis
7639: */
7640: xmlNodePtr
7641: xmlXPathNextSelf(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
7642: if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
7643: if (cur == NULL)
7644: return(ctxt->context->node);
7645: return(NULL);
7646: }
7647:
7648: /**
7649: * xmlXPathNextChild:
7650: * @ctxt: the XPath Parser context
7651: * @cur: the current node in the traversal
7652: *
7653: * Traversal function for the "child" direction
7654: * The child axis contains the children of the context node in document order.
7655: *
7656: * Returns the next element following that axis
7657: */
7658: xmlNodePtr
7659: xmlXPathNextChild(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
7660: if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
7661: if (cur == NULL) {
7662: if (ctxt->context->node == NULL) return(NULL);
7663: switch (ctxt->context->node->type) {
7664: case XML_ELEMENT_NODE:
7665: case XML_TEXT_NODE:
7666: case XML_CDATA_SECTION_NODE:
7667: case XML_ENTITY_REF_NODE:
7668: case XML_ENTITY_NODE:
7669: case XML_PI_NODE:
7670: case XML_COMMENT_NODE:
7671: case XML_NOTATION_NODE:
7672: case XML_DTD_NODE:
7673: return(ctxt->context->node->children);
7674: case XML_DOCUMENT_NODE:
7675: case XML_DOCUMENT_TYPE_NODE:
7676: case XML_DOCUMENT_FRAG_NODE:
7677: case XML_HTML_DOCUMENT_NODE:
7678: #ifdef LIBXML_DOCB_ENABLED
7679: case XML_DOCB_DOCUMENT_NODE:
7680: #endif
7681: return(((xmlDocPtr) ctxt->context->node)->children);
7682: case XML_ELEMENT_DECL:
7683: case XML_ATTRIBUTE_DECL:
7684: case XML_ENTITY_DECL:
7685: case XML_ATTRIBUTE_NODE:
7686: case XML_NAMESPACE_DECL:
7687: case XML_XINCLUDE_START:
7688: case XML_XINCLUDE_END:
7689: return(NULL);
7690: }
7691: return(NULL);
7692: }
7693: if ((cur->type == XML_DOCUMENT_NODE) ||
7694: (cur->type == XML_HTML_DOCUMENT_NODE))
7695: return(NULL);
7696: return(cur->next);
7697: }
7698:
7699: /**
7700: * xmlXPathNextChildElement:
7701: * @ctxt: the XPath Parser context
7702: * @cur: the current node in the traversal
7703: *
7704: * Traversal function for the "child" direction and nodes of type element.
7705: * The child axis contains the children of the context node in document order.
7706: *
7707: * Returns the next element following that axis
7708: */
7709: static xmlNodePtr
7710: xmlXPathNextChildElement(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
7711: if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
7712: if (cur == NULL) {
7713: cur = ctxt->context->node;
7714: if (cur == NULL) return(NULL);
7715: /*
7716: * Get the first element child.
7717: */
7718: switch (cur->type) {
7719: case XML_ELEMENT_NODE:
7720: case XML_DOCUMENT_FRAG_NODE:
7721: case XML_ENTITY_REF_NODE: /* URGENT TODO: entify-refs as well? */
7722: case XML_ENTITY_NODE:
7723: cur = cur->children;
7724: if (cur != NULL) {
7725: if (cur->type == XML_ELEMENT_NODE)
7726: return(cur);
7727: do {
7728: cur = cur->next;
7729: } while ((cur != NULL) &&
7730: (cur->type != XML_ELEMENT_NODE));
7731: return(cur);
7732: }
7733: return(NULL);
7734: case XML_DOCUMENT_NODE:
7735: case XML_HTML_DOCUMENT_NODE:
7736: #ifdef LIBXML_DOCB_ENABLED
7737: case XML_DOCB_DOCUMENT_NODE:
7738: #endif
7739: return(xmlDocGetRootElement((xmlDocPtr) cur));
7740: default:
7741: return(NULL);
7742: }
7743: return(NULL);
7744: }
7745: /*
7746: * Get the next sibling element node.
7747: */
7748: switch (cur->type) {
7749: case XML_ELEMENT_NODE:
7750: case XML_TEXT_NODE:
7751: case XML_ENTITY_REF_NODE:
7752: case XML_ENTITY_NODE:
7753: case XML_CDATA_SECTION_NODE:
7754: case XML_PI_NODE:
7755: case XML_COMMENT_NODE:
7756: case XML_XINCLUDE_END:
7757: break;
7758: /* case XML_DTD_NODE: */ /* URGENT TODO: DTD-node as well? */
7759: default:
7760: return(NULL);
7761: }
7762: if (cur->next != NULL) {
7763: if (cur->next->type == XML_ELEMENT_NODE)
7764: return(cur->next);
7765: cur = cur->next;
7766: do {
7767: cur = cur->next;
7768: } while ((cur != NULL) && (cur->type != XML_ELEMENT_NODE));
7769: return(cur);
7770: }
7771: return(NULL);
7772: }
7773:
7774: #if 0
7775: /**
7776: * xmlXPathNextDescendantOrSelfElemParent:
7777: * @ctxt: the XPath Parser context
7778: * @cur: the current node in the traversal
7779: *
7780: * Traversal function for the "descendant-or-self" axis.
7781: * Additionally it returns only nodes which can be parents of
7782: * element nodes.
7783: *
7784: *
7785: * Returns the next element following that axis
7786: */
7787: static xmlNodePtr
7788: xmlXPathNextDescendantOrSelfElemParent(xmlNodePtr cur,
7789: xmlNodePtr contextNode)
7790: {
7791: if (cur == NULL) {
7792: if (contextNode == NULL)
7793: return(NULL);
7794: switch (contextNode->type) {
7795: case XML_ELEMENT_NODE:
7796: case XML_XINCLUDE_START:
7797: case XML_DOCUMENT_FRAG_NODE:
7798: case XML_DOCUMENT_NODE:
7799: #ifdef LIBXML_DOCB_ENABLED
7800: case XML_DOCB_DOCUMENT_NODE:
7801: #endif
7802: case XML_HTML_DOCUMENT_NODE:
7803: return(contextNode);
7804: default:
7805: return(NULL);
7806: }
7807: return(NULL);
7808: } else {
7809: xmlNodePtr start = cur;
7810:
7811: while (cur != NULL) {
7812: switch (cur->type) {
7813: case XML_ELEMENT_NODE:
7814: /* TODO: OK to have XInclude here? */
7815: case XML_XINCLUDE_START:
7816: case XML_DOCUMENT_FRAG_NODE:
7817: if (cur != start)
7818: return(cur);
7819: if (cur->children != NULL) {
7820: cur = cur->children;
7821: continue;
7822: }
7823: break;
7824: /* Not sure if we need those here. */
7825: case XML_DOCUMENT_NODE:
7826: #ifdef LIBXML_DOCB_ENABLED
7827: case XML_DOCB_DOCUMENT_NODE:
7828: #endif
7829: case XML_HTML_DOCUMENT_NODE:
7830: if (cur != start)
7831: return(cur);
7832: return(xmlDocGetRootElement((xmlDocPtr) cur));
7833: default:
7834: break;
7835: }
7836:
7837: next_sibling:
7838: if ((cur == NULL) || (cur == contextNode))
7839: return(NULL);
7840: if (cur->next != NULL) {
7841: cur = cur->next;
7842: } else {
7843: cur = cur->parent;
7844: goto next_sibling;
7845: }
7846: }
7847: }
7848: return(NULL);
7849: }
7850: #endif
7851:
7852: /**
7853: * xmlXPathNextDescendant:
7854: * @ctxt: the XPath Parser context
7855: * @cur: the current node in the traversal
7856: *
7857: * Traversal function for the "descendant" direction
7858: * the descendant axis contains the descendants of the context node in document
7859: * order; a descendant is a child or a child of a child and so on.
7860: *
7861: * Returns the next element following that axis
7862: */
7863: xmlNodePtr
7864: xmlXPathNextDescendant(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
7865: if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
7866: if (cur == NULL) {
7867: if (ctxt->context->node == NULL)
7868: return(NULL);
7869: if ((ctxt->context->node->type == XML_ATTRIBUTE_NODE) ||
7870: (ctxt->context->node->type == XML_NAMESPACE_DECL))
7871: return(NULL);
7872:
7873: if (ctxt->context->node == (xmlNodePtr) ctxt->context->doc)
7874: return(ctxt->context->doc->children);
7875: return(ctxt->context->node->children);
7876: }
7877:
7878: if (cur->type == XML_NAMESPACE_DECL)
7879: return(NULL);
7880: if (cur->children != NULL) {
7881: /*
7882: * Do not descend on entities declarations
7883: */
7884: if (cur->children->type != XML_ENTITY_DECL) {
7885: cur = cur->children;
7886: /*
7887: * Skip DTDs
7888: */
7889: if (cur->type != XML_DTD_NODE)
7890: return(cur);
7891: }
7892: }
7893:
7894: if (cur == ctxt->context->node) return(NULL);
7895:
7896: while (cur->next != NULL) {
7897: cur = cur->next;
7898: if ((cur->type != XML_ENTITY_DECL) &&
7899: (cur->type != XML_DTD_NODE))
7900: return(cur);
7901: }
7902:
7903: do {
7904: cur = cur->parent;
7905: if (cur == NULL) break;
7906: if (cur == ctxt->context->node) return(NULL);
7907: if (cur->next != NULL) {
7908: cur = cur->next;
7909: return(cur);
7910: }
7911: } while (cur != NULL);
7912: return(cur);
7913: }
7914:
7915: /**
7916: * xmlXPathNextDescendantOrSelf:
7917: * @ctxt: the XPath Parser context
7918: * @cur: the current node in the traversal
7919: *
7920: * Traversal function for the "descendant-or-self" direction
7921: * the descendant-or-self axis contains the context node and the descendants
7922: * of the context node in document order; thus the context node is the first
7923: * node on the axis, and the first child of the context node is the second node
7924: * on the axis
7925: *
7926: * Returns the next element following that axis
7927: */
7928: xmlNodePtr
7929: xmlXPathNextDescendantOrSelf(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
7930: if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
7931: if (cur == NULL) {
7932: if (ctxt->context->node == NULL)
7933: return(NULL);
7934: if ((ctxt->context->node->type == XML_ATTRIBUTE_NODE) ||
7935: (ctxt->context->node->type == XML_NAMESPACE_DECL))
7936: return(NULL);
7937: return(ctxt->context->node);
7938: }
7939:
7940: return(xmlXPathNextDescendant(ctxt, cur));
7941: }
7942:
7943: /**
7944: * xmlXPathNextParent:
7945: * @ctxt: the XPath Parser context
7946: * @cur: the current node in the traversal
7947: *
7948: * Traversal function for the "parent" direction
7949: * The parent axis contains the parent of the context node, if there is one.
7950: *
7951: * Returns the next element following that axis
7952: */
7953: xmlNodePtr
7954: xmlXPathNextParent(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
7955: if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
7956: /*
7957: * the parent of an attribute or namespace node is the element
7958: * to which the attribute or namespace node is attached
7959: * Namespace handling !!!
7960: */
7961: if (cur == NULL) {
7962: if (ctxt->context->node == NULL) return(NULL);
7963: switch (ctxt->context->node->type) {
7964: case XML_ELEMENT_NODE:
7965: case XML_TEXT_NODE:
7966: case XML_CDATA_SECTION_NODE:
7967: case XML_ENTITY_REF_NODE:
7968: case XML_ENTITY_NODE:
7969: case XML_PI_NODE:
7970: case XML_COMMENT_NODE:
7971: case XML_NOTATION_NODE:
7972: case XML_DTD_NODE:
7973: case XML_ELEMENT_DECL:
7974: case XML_ATTRIBUTE_DECL:
7975: case XML_XINCLUDE_START:
7976: case XML_XINCLUDE_END:
7977: case XML_ENTITY_DECL:
7978: if (ctxt->context->node->parent == NULL)
7979: return((xmlNodePtr) ctxt->context->doc);
7980: if ((ctxt->context->node->parent->type == XML_ELEMENT_NODE) &&
7981: ((ctxt->context->node->parent->name[0] == ' ') ||
7982: (xmlStrEqual(ctxt->context->node->parent->name,
7983: BAD_CAST "fake node libxslt"))))
7984: return(NULL);
7985: return(ctxt->context->node->parent);
7986: case XML_ATTRIBUTE_NODE: {
7987: xmlAttrPtr att = (xmlAttrPtr) ctxt->context->node;
7988:
7989: return(att->parent);
7990: }
7991: case XML_DOCUMENT_NODE:
7992: case XML_DOCUMENT_TYPE_NODE:
7993: case XML_DOCUMENT_FRAG_NODE:
7994: case XML_HTML_DOCUMENT_NODE:
7995: #ifdef LIBXML_DOCB_ENABLED
7996: case XML_DOCB_DOCUMENT_NODE:
7997: #endif
7998: return(NULL);
7999: case XML_NAMESPACE_DECL: {
8000: xmlNsPtr ns = (xmlNsPtr) ctxt->context->node;
8001:
8002: if ((ns->next != NULL) &&
8003: (ns->next->type != XML_NAMESPACE_DECL))
8004: return((xmlNodePtr) ns->next);
8005: return(NULL);
8006: }
8007: }
8008: }
8009: return(NULL);
8010: }
8011:
8012: /**
8013: * xmlXPathNextAncestor:
8014: * @ctxt: the XPath Parser context
8015: * @cur: the current node in the traversal
8016: *
8017: * Traversal function for the "ancestor" direction
8018: * the ancestor axis contains the ancestors of the context node; the ancestors
8019: * of the context node consist of the parent of context node and the parent's
8020: * parent and so on; the nodes are ordered in reverse document order; thus the
8021: * parent is the first node on the axis, and the parent's parent is the second
8022: * node on the axis
8023: *
8024: * Returns the next element following that axis
8025: */
8026: xmlNodePtr
8027: xmlXPathNextAncestor(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
8028: if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
8029: /*
8030: * the parent of an attribute or namespace node is the element
8031: * to which the attribute or namespace node is attached
8032: * !!!!!!!!!!!!!
8033: */
8034: if (cur == NULL) {
8035: if (ctxt->context->node == NULL) return(NULL);
8036: switch (ctxt->context->node->type) {
8037: case XML_ELEMENT_NODE:
8038: case XML_TEXT_NODE:
8039: case XML_CDATA_SECTION_NODE:
8040: case XML_ENTITY_REF_NODE:
8041: case XML_ENTITY_NODE:
8042: case XML_PI_NODE:
8043: case XML_COMMENT_NODE:
8044: case XML_DTD_NODE:
8045: case XML_ELEMENT_DECL:
8046: case XML_ATTRIBUTE_DECL:
8047: case XML_ENTITY_DECL:
8048: case XML_NOTATION_NODE:
8049: case XML_XINCLUDE_START:
8050: case XML_XINCLUDE_END:
8051: if (ctxt->context->node->parent == NULL)
8052: return((xmlNodePtr) ctxt->context->doc);
8053: if ((ctxt->context->node->parent->type == XML_ELEMENT_NODE) &&
8054: ((ctxt->context->node->parent->name[0] == ' ') ||
8055: (xmlStrEqual(ctxt->context->node->parent->name,
8056: BAD_CAST "fake node libxslt"))))
8057: return(NULL);
8058: return(ctxt->context->node->parent);
8059: case XML_ATTRIBUTE_NODE: {
8060: xmlAttrPtr tmp = (xmlAttrPtr) ctxt->context->node;
8061:
8062: return(tmp->parent);
8063: }
8064: case XML_DOCUMENT_NODE:
8065: case XML_DOCUMENT_TYPE_NODE:
8066: case XML_DOCUMENT_FRAG_NODE:
8067: case XML_HTML_DOCUMENT_NODE:
8068: #ifdef LIBXML_DOCB_ENABLED
8069: case XML_DOCB_DOCUMENT_NODE:
8070: #endif
8071: return(NULL);
8072: case XML_NAMESPACE_DECL: {
8073: xmlNsPtr ns = (xmlNsPtr) ctxt->context->node;
8074:
8075: if ((ns->next != NULL) &&
8076: (ns->next->type != XML_NAMESPACE_DECL))
8077: return((xmlNodePtr) ns->next);
8078: /* Bad, how did that namespace end up here ? */
8079: return(NULL);
8080: }
8081: }
8082: return(NULL);
8083: }
8084: if (cur == ctxt->context->doc->children)
8085: return((xmlNodePtr) ctxt->context->doc);
8086: if (cur == (xmlNodePtr) ctxt->context->doc)
8087: return(NULL);
8088: switch (cur->type) {
8089: case XML_ELEMENT_NODE:
8090: case XML_TEXT_NODE:
8091: case XML_CDATA_SECTION_NODE:
8092: case XML_ENTITY_REF_NODE:
8093: case XML_ENTITY_NODE:
8094: case XML_PI_NODE:
8095: case XML_COMMENT_NODE:
8096: case XML_NOTATION_NODE:
8097: case XML_DTD_NODE:
8098: case XML_ELEMENT_DECL:
8099: case XML_ATTRIBUTE_DECL:
8100: case XML_ENTITY_DECL:
8101: case XML_XINCLUDE_START:
8102: case XML_XINCLUDE_END:
8103: if (cur->parent == NULL)
8104: return(NULL);
8105: if ((cur->parent->type == XML_ELEMENT_NODE) &&
8106: ((cur->parent->name[0] == ' ') ||
8107: (xmlStrEqual(cur->parent->name,
8108: BAD_CAST "fake node libxslt"))))
8109: return(NULL);
8110: return(cur->parent);
8111: case XML_ATTRIBUTE_NODE: {
8112: xmlAttrPtr att = (xmlAttrPtr) ctxt->context->node;
8113:
8114: return(att->parent);
8115: }
8116: case XML_NAMESPACE_DECL: {
8117: xmlNsPtr ns = (xmlNsPtr) ctxt->context->node;
8118:
8119: if ((ns->next != NULL) &&
8120: (ns->next->type != XML_NAMESPACE_DECL))
8121: return((xmlNodePtr) ns->next);
8122: /* Bad, how did that namespace end up here ? */
8123: return(NULL);
8124: }
8125: case XML_DOCUMENT_NODE:
8126: case XML_DOCUMENT_TYPE_NODE:
8127: case XML_DOCUMENT_FRAG_NODE:
8128: case XML_HTML_DOCUMENT_NODE:
8129: #ifdef LIBXML_DOCB_ENABLED
8130: case XML_DOCB_DOCUMENT_NODE:
8131: #endif
8132: return(NULL);
8133: }
8134: return(NULL);
8135: }
8136:
8137: /**
8138: * xmlXPathNextAncestorOrSelf:
8139: * @ctxt: the XPath Parser context
8140: * @cur: the current node in the traversal
8141: *
8142: * Traversal function for the "ancestor-or-self" direction
8143: * he ancestor-or-self axis contains the context node and ancestors of
8144: * the context node in reverse document order; thus the context node is
8145: * the first node on the axis, and the context node's parent the second;
8146: * parent here is defined the same as with the parent axis.
8147: *
8148: * Returns the next element following that axis
8149: */
8150: xmlNodePtr
8151: xmlXPathNextAncestorOrSelf(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
8152: if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
8153: if (cur == NULL)
8154: return(ctxt->context->node);
8155: return(xmlXPathNextAncestor(ctxt, cur));
8156: }
8157:
8158: /**
8159: * xmlXPathNextFollowingSibling:
8160: * @ctxt: the XPath Parser context
8161: * @cur: the current node in the traversal
8162: *
8163: * Traversal function for the "following-sibling" direction
8164: * The following-sibling axis contains the following siblings of the context
8165: * node in document order.
8166: *
8167: * Returns the next element following that axis
8168: */
8169: xmlNodePtr
8170: xmlXPathNextFollowingSibling(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
8171: if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
8172: if ((ctxt->context->node->type == XML_ATTRIBUTE_NODE) ||
8173: (ctxt->context->node->type == XML_NAMESPACE_DECL))
8174: return(NULL);
8175: if (cur == (xmlNodePtr) ctxt->context->doc)
8176: return(NULL);
8177: if (cur == NULL)
8178: return(ctxt->context->node->next);
8179: return(cur->next);
8180: }
8181:
8182: /**
8183: * xmlXPathNextPrecedingSibling:
8184: * @ctxt: the XPath Parser context
8185: * @cur: the current node in the traversal
8186: *
8187: * Traversal function for the "preceding-sibling" direction
8188: * The preceding-sibling axis contains the preceding siblings of the context
8189: * node in reverse document order; the first preceding sibling is first on the
8190: * axis; the sibling preceding that node is the second on the axis and so on.
8191: *
8192: * Returns the next element following that axis
8193: */
8194: xmlNodePtr
8195: xmlXPathNextPrecedingSibling(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
8196: if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
8197: if ((ctxt->context->node->type == XML_ATTRIBUTE_NODE) ||
8198: (ctxt->context->node->type == XML_NAMESPACE_DECL))
8199: return(NULL);
8200: if (cur == (xmlNodePtr) ctxt->context->doc)
8201: return(NULL);
8202: if (cur == NULL)
8203: return(ctxt->context->node->prev);
8204: if ((cur->prev != NULL) && (cur->prev->type == XML_DTD_NODE)) {
8205: cur = cur->prev;
8206: if (cur == NULL)
8207: return(ctxt->context->node->prev);
8208: }
8209: return(cur->prev);
8210: }
8211:
8212: /**
8213: * xmlXPathNextFollowing:
8214: * @ctxt: the XPath Parser context
8215: * @cur: the current node in the traversal
8216: *
8217: * Traversal function for the "following" direction
8218: * The following axis contains all nodes in the same document as the context
8219: * node that are after the context node in document order, excluding any
8220: * descendants and excluding attribute nodes and namespace nodes; the nodes
8221: * are ordered in document order
8222: *
8223: * Returns the next element following that axis
8224: */
8225: xmlNodePtr
8226: xmlXPathNextFollowing(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
8227: if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
8228: if ((cur != NULL) && (cur->type != XML_ATTRIBUTE_NODE) &&
8229: (cur->type != XML_NAMESPACE_DECL) && (cur->children != NULL))
8230: return(cur->children);
8231:
8232: if (cur == NULL) {
8233: cur = ctxt->context->node;
8234: if (cur->type == XML_NAMESPACE_DECL)
8235: return(NULL);
8236: if (cur->type == XML_ATTRIBUTE_NODE)
8237: cur = cur->parent;
8238: }
8239: if (cur == NULL) return(NULL) ; /* ERROR */
8240: if (cur->next != NULL) return(cur->next) ;
8241: do {
8242: cur = cur->parent;
8243: if (cur == NULL) break;
8244: if (cur == (xmlNodePtr) ctxt->context->doc) return(NULL);
8245: if (cur->next != NULL) return(cur->next);
8246: } while (cur != NULL);
8247: return(cur);
8248: }
8249:
8250: /*
8251: * xmlXPathIsAncestor:
8252: * @ancestor: the ancestor node
8253: * @node: the current node
8254: *
8255: * Check that @ancestor is a @node's ancestor
8256: *
8257: * returns 1 if @ancestor is a @node's ancestor, 0 otherwise.
8258: */
8259: static int
8260: xmlXPathIsAncestor(xmlNodePtr ancestor, xmlNodePtr node) {
8261: if ((ancestor == NULL) || (node == NULL)) return(0);
8262: if (node->type == XML_NAMESPACE_DECL)
8263: return(0);
8264: if (ancestor->type == XML_NAMESPACE_DECL)
8265: return(0);
8266: /* nodes need to be in the same document */
8267: if (ancestor->doc != node->doc) return(0);
8268: /* avoid searching if ancestor or node is the root node */
8269: if (ancestor == (xmlNodePtr) node->doc) return(1);
8270: if (node == (xmlNodePtr) ancestor->doc) return(0);
8271: while (node->parent != NULL) {
8272: if (node->parent == ancestor)
8273: return(1);
8274: node = node->parent;
8275: }
8276: return(0);
8277: }
8278:
8279: /**
8280: * xmlXPathNextPreceding:
8281: * @ctxt: the XPath Parser context
8282: * @cur: the current node in the traversal
8283: *
8284: * Traversal function for the "preceding" direction
8285: * the preceding axis contains all nodes in the same document as the context
8286: * node that are before the context node in document order, excluding any
8287: * ancestors and excluding attribute nodes and namespace nodes; the nodes are
8288: * ordered in reverse document order
8289: *
8290: * Returns the next element following that axis
8291: */
8292: xmlNodePtr
8293: xmlXPathNextPreceding(xmlXPathParserContextPtr ctxt, xmlNodePtr cur)
8294: {
8295: if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
8296: if (cur == NULL) {
8297: cur = ctxt->context->node;
8298: if (cur->type == XML_NAMESPACE_DECL)
8299: return(NULL);
8300: if (cur->type == XML_ATTRIBUTE_NODE)
8301: return(cur->parent);
8302: }
8303: if ((cur == NULL) || (cur->type == XML_NAMESPACE_DECL))
8304: return (NULL);
8305: if ((cur->prev != NULL) && (cur->prev->type == XML_DTD_NODE))
8306: cur = cur->prev;
8307: do {
8308: if (cur->prev != NULL) {
8309: for (cur = cur->prev; cur->last != NULL; cur = cur->last) ;
8310: return (cur);
8311: }
8312:
8313: cur = cur->parent;
8314: if (cur == NULL)
8315: return (NULL);
8316: if (cur == ctxt->context->doc->children)
8317: return (NULL);
8318: } while (xmlXPathIsAncestor(cur, ctxt->context->node));
8319: return (cur);
8320: }
8321:
8322: /**
8323: * xmlXPathNextPrecedingInternal:
8324: * @ctxt: the XPath Parser context
8325: * @cur: the current node in the traversal
8326: *
8327: * Traversal function for the "preceding" direction
8328: * the preceding axis contains all nodes in the same document as the context
8329: * node that are before the context node in document order, excluding any
8330: * ancestors and excluding attribute nodes and namespace nodes; the nodes are
8331: * ordered in reverse document order
8332: * This is a faster implementation but internal only since it requires a
8333: * state kept in the parser context: ctxt->ancestor.
8334: *
8335: * Returns the next element following that axis
8336: */
8337: static xmlNodePtr
8338: xmlXPathNextPrecedingInternal(xmlXPathParserContextPtr ctxt,
8339: xmlNodePtr cur)
8340: {
8341: if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
8342: if (cur == NULL) {
8343: cur = ctxt->context->node;
8344: if (cur == NULL)
8345: return (NULL);
8346: if (cur->type == XML_NAMESPACE_DECL)
8347: return (NULL);
8348: ctxt->ancestor = cur->parent;
8349: }
8350: if (cur->type == XML_NAMESPACE_DECL)
8351: return(NULL);
8352: if ((cur->prev != NULL) && (cur->prev->type == XML_DTD_NODE))
8353: cur = cur->prev;
8354: while (cur->prev == NULL) {
8355: cur = cur->parent;
8356: if (cur == NULL)
8357: return (NULL);
8358: if (cur == ctxt->context->doc->children)
8359: return (NULL);
8360: if (cur != ctxt->ancestor)
8361: return (cur);
8362: ctxt->ancestor = cur->parent;
8363: }
8364: cur = cur->prev;
8365: while (cur->last != NULL)
8366: cur = cur->last;
8367: return (cur);
8368: }
8369:
8370: /**
8371: * xmlXPathNextNamespace:
8372: * @ctxt: the XPath Parser context
8373: * @cur: the current attribute in the traversal
8374: *
8375: * Traversal function for the "namespace" direction
8376: * the namespace axis contains the namespace nodes of the context node;
8377: * the order of nodes on this axis is implementation-defined; the axis will
8378: * be empty unless the context node is an element
8379: *
8380: * We keep the XML namespace node at the end of the list.
8381: *
8382: * Returns the next element following that axis
8383: */
8384: xmlNodePtr
8385: xmlXPathNextNamespace(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
8386: if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
8387: if (ctxt->context->node->type != XML_ELEMENT_NODE) return(NULL);
8388: if (ctxt->context->tmpNsList == NULL && cur != (xmlNodePtr) xmlXPathXMLNamespace) {
8389: if (ctxt->context->tmpNsList != NULL)
8390: xmlFree(ctxt->context->tmpNsList);
8391: ctxt->context->tmpNsList =
8392: xmlGetNsList(ctxt->context->doc, ctxt->context->node);
8393: ctxt->context->tmpNsNr = 0;
8394: if (ctxt->context->tmpNsList != NULL) {
8395: while (ctxt->context->tmpNsList[ctxt->context->tmpNsNr] != NULL) {
8396: ctxt->context->tmpNsNr++;
8397: }
8398: }
8399: return((xmlNodePtr) xmlXPathXMLNamespace);
8400: }
8401: if (ctxt->context->tmpNsNr > 0) {
8402: return (xmlNodePtr)ctxt->context->tmpNsList[--ctxt->context->tmpNsNr];
8403: } else {
8404: if (ctxt->context->tmpNsList != NULL)
8405: xmlFree(ctxt->context->tmpNsList);
8406: ctxt->context->tmpNsList = NULL;
8407: return(NULL);
8408: }
8409: }
8410:
8411: /**
8412: * xmlXPathNextAttribute:
8413: * @ctxt: the XPath Parser context
8414: * @cur: the current attribute in the traversal
8415: *
8416: * Traversal function for the "attribute" direction
8417: * TODO: support DTD inherited default attributes
8418: *
8419: * Returns the next element following that axis
8420: */
8421: xmlNodePtr
8422: xmlXPathNextAttribute(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
8423: if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
8424: if (ctxt->context->node == NULL)
8425: return(NULL);
8426: if (ctxt->context->node->type != XML_ELEMENT_NODE)
8427: return(NULL);
8428: if (cur == NULL) {
8429: if (ctxt->context->node == (xmlNodePtr) ctxt->context->doc)
8430: return(NULL);
8431: return((xmlNodePtr)ctxt->context->node->properties);
8432: }
8433: return((xmlNodePtr)cur->next);
8434: }
8435:
8436: /************************************************************************
8437: * *
8438: * NodeTest Functions *
8439: * *
8440: ************************************************************************/
8441:
8442: #define IS_FUNCTION 200
8443:
8444:
8445: /************************************************************************
8446: * *
8447: * Implicit tree core function library *
8448: * *
8449: ************************************************************************/
8450:
8451: /**
8452: * xmlXPathRoot:
8453: * @ctxt: the XPath Parser context
8454: *
8455: * Initialize the context to the root of the document
8456: */
8457: void
8458: xmlXPathRoot(xmlXPathParserContextPtr ctxt) {
8459: if ((ctxt == NULL) || (ctxt->context == NULL))
8460: return;
8461: ctxt->context->node = (xmlNodePtr) ctxt->context->doc;
8462: valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context,
8463: ctxt->context->node));
8464: }
8465:
8466: /************************************************************************
8467: * *
8468: * The explicit core function library *
8469: *http://www.w3.org/Style/XSL/Group/1999/07/xpath-19990705.html#corelib *
8470: * *
8471: ************************************************************************/
8472:
8473:
8474: /**
8475: * xmlXPathLastFunction:
8476: * @ctxt: the XPath Parser context
8477: * @nargs: the number of arguments
8478: *
8479: * Implement the last() XPath function
8480: * number last()
8481: * The last function returns the number of nodes in the context node list.
8482: */
8483: void
8484: xmlXPathLastFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8485: CHECK_ARITY(0);
8486: if (ctxt->context->contextSize >= 0) {
8487: valuePush(ctxt,
8488: xmlXPathCacheNewFloat(ctxt->context,
8489: (double) ctxt->context->contextSize));
8490: #ifdef DEBUG_EXPR
8491: xmlGenericError(xmlGenericErrorContext,
8492: "last() : %d\n", ctxt->context->contextSize);
8493: #endif
8494: } else {
8495: XP_ERROR(XPATH_INVALID_CTXT_SIZE);
8496: }
8497: }
8498:
8499: /**
8500: * xmlXPathPositionFunction:
8501: * @ctxt: the XPath Parser context
8502: * @nargs: the number of arguments
8503: *
8504: * Implement the position() XPath function
8505: * number position()
8506: * The position function returns the position of the context node in the
8507: * context node list. The first position is 1, and so the last position
8508: * will be equal to last().
8509: */
8510: void
8511: xmlXPathPositionFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8512: CHECK_ARITY(0);
8513: if (ctxt->context->proximityPosition >= 0) {
8514: valuePush(ctxt,
8515: xmlXPathCacheNewFloat(ctxt->context,
8516: (double) ctxt->context->proximityPosition));
8517: #ifdef DEBUG_EXPR
8518: xmlGenericError(xmlGenericErrorContext, "position() : %d\n",
8519: ctxt->context->proximityPosition);
8520: #endif
8521: } else {
8522: XP_ERROR(XPATH_INVALID_CTXT_POSITION);
8523: }
8524: }
8525:
8526: /**
8527: * xmlXPathCountFunction:
8528: * @ctxt: the XPath Parser context
8529: * @nargs: the number of arguments
8530: *
8531: * Implement the count() XPath function
8532: * number count(node-set)
8533: */
8534: void
8535: xmlXPathCountFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8536: xmlXPathObjectPtr cur;
8537:
8538: CHECK_ARITY(1);
8539: if ((ctxt->value == NULL) ||
8540: ((ctxt->value->type != XPATH_NODESET) &&
8541: (ctxt->value->type != XPATH_XSLT_TREE)))
8542: XP_ERROR(XPATH_INVALID_TYPE);
8543: cur = valuePop(ctxt);
8544:
8545: if ((cur == NULL) || (cur->nodesetval == NULL))
8546: valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, (double) 0));
8547: else if ((cur->type == XPATH_NODESET) || (cur->type == XPATH_XSLT_TREE)) {
8548: valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context,
8549: (double) cur->nodesetval->nodeNr));
8550: } else {
8551: if ((cur->nodesetval->nodeNr != 1) ||
8552: (cur->nodesetval->nodeTab == NULL)) {
8553: valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, (double) 0));
8554: } else {
8555: xmlNodePtr tmp;
8556: int i = 0;
8557:
8558: tmp = cur->nodesetval->nodeTab[0];
8559: if ((tmp != NULL) && (tmp->type != XML_NAMESPACE_DECL)) {
8560: tmp = tmp->children;
8561: while (tmp != NULL) {
8562: tmp = tmp->next;
8563: i++;
8564: }
8565: }
8566: valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, (double) i));
8567: }
8568: }
8569: xmlXPathReleaseObject(ctxt->context, cur);
8570: }
8571:
8572: /**
8573: * xmlXPathGetElementsByIds:
8574: * @doc: the document
8575: * @ids: a whitespace separated list of IDs
8576: *
8577: * Selects elements by their unique ID.
8578: *
8579: * Returns a node-set of selected elements.
8580: */
8581: static xmlNodeSetPtr
8582: xmlXPathGetElementsByIds (xmlDocPtr doc, const xmlChar *ids) {
8583: xmlNodeSetPtr ret;
8584: const xmlChar *cur = ids;
8585: xmlChar *ID;
8586: xmlAttrPtr attr;
8587: xmlNodePtr elem = NULL;
8588:
8589: if (ids == NULL) return(NULL);
8590:
8591: ret = xmlXPathNodeSetCreate(NULL);
8592: if (ret == NULL)
8593: return(ret);
8594:
8595: while (IS_BLANK_CH(*cur)) cur++;
8596: while (*cur != 0) {
8597: while ((!IS_BLANK_CH(*cur)) && (*cur != 0))
8598: cur++;
8599:
8600: ID = xmlStrndup(ids, cur - ids);
8601: if (ID != NULL) {
8602: /*
8603: * We used to check the fact that the value passed
8604: * was an NCName, but this generated much troubles for
8605: * me and Aleksey Sanin, people blatantly violated that
8606: * constaint, like Visa3D spec.
8607: * if (xmlValidateNCName(ID, 1) == 0)
8608: */
8609: attr = xmlGetID(doc, ID);
8610: if (attr != NULL) {
8611: if (attr->type == XML_ATTRIBUTE_NODE)
8612: elem = attr->parent;
8613: else if (attr->type == XML_ELEMENT_NODE)
8614: elem = (xmlNodePtr) attr;
8615: else
8616: elem = NULL;
8617: if (elem != NULL)
8618: xmlXPathNodeSetAdd(ret, elem);
8619: }
8620: xmlFree(ID);
8621: }
8622:
8623: while (IS_BLANK_CH(*cur)) cur++;
8624: ids = cur;
8625: }
8626: return(ret);
8627: }
8628:
8629: /**
8630: * xmlXPathIdFunction:
8631: * @ctxt: the XPath Parser context
8632: * @nargs: the number of arguments
8633: *
8634: * Implement the id() XPath function
8635: * node-set id(object)
8636: * The id function selects elements by their unique ID
8637: * (see [5.2.1 Unique IDs]). When the argument to id is of type node-set,
8638: * then the result is the union of the result of applying id to the
8639: * string value of each of the nodes in the argument node-set. When the
8640: * argument to id is of any other type, the argument is converted to a
8641: * string as if by a call to the string function; the string is split
8642: * into a whitespace-separated list of tokens (whitespace is any sequence
8643: * of characters matching the production S); the result is a node-set
8644: * containing the elements in the same document as the context node that
8645: * have a unique ID equal to any of the tokens in the list.
8646: */
8647: void
8648: xmlXPathIdFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8649: xmlChar *tokens;
8650: xmlNodeSetPtr ret;
8651: xmlXPathObjectPtr obj;
8652:
8653: CHECK_ARITY(1);
8654: obj = valuePop(ctxt);
8655: if (obj == NULL) XP_ERROR(XPATH_INVALID_OPERAND);
8656: if ((obj->type == XPATH_NODESET) || (obj->type == XPATH_XSLT_TREE)) {
8657: xmlNodeSetPtr ns;
8658: int i;
8659:
8660: ret = xmlXPathNodeSetCreate(NULL);
8661: /*
8662: * FIXME -- in an out-of-memory condition this will behave badly.
8663: * The solution is not clear -- we already popped an item from
8664: * ctxt, so the object is in a corrupt state.
8665: */
8666:
8667: if (obj->nodesetval != NULL) {
8668: for (i = 0; i < obj->nodesetval->nodeNr; i++) {
8669: tokens =
8670: xmlXPathCastNodeToString(obj->nodesetval->nodeTab[i]);
8671: ns = xmlXPathGetElementsByIds(ctxt->context->doc, tokens);
8672: ret = xmlXPathNodeSetMerge(ret, ns);
8673: xmlXPathFreeNodeSet(ns);
8674: if (tokens != NULL)
8675: xmlFree(tokens);
8676: }
8677: }
8678: xmlXPathReleaseObject(ctxt->context, obj);
8679: valuePush(ctxt, xmlXPathCacheWrapNodeSet(ctxt->context, ret));
8680: return;
8681: }
8682: obj = xmlXPathCacheConvertString(ctxt->context, obj);
8683: ret = xmlXPathGetElementsByIds(ctxt->context->doc, obj->stringval);
8684: valuePush(ctxt, xmlXPathCacheWrapNodeSet(ctxt->context, ret));
8685: xmlXPathReleaseObject(ctxt->context, obj);
8686: return;
8687: }
8688:
8689: /**
8690: * xmlXPathLocalNameFunction:
8691: * @ctxt: the XPath Parser context
8692: * @nargs: the number of arguments
8693: *
8694: * Implement the local-name() XPath function
8695: * string local-name(node-set?)
8696: * The local-name function returns a string containing the local part
8697: * of the name of the node in the argument node-set that is first in
8698: * document order. If the node-set is empty or the first node has no
8699: * name, an empty string is returned. If the argument is omitted it
8700: * defaults to the context node.
8701: */
8702: void
8703: xmlXPathLocalNameFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8704: xmlXPathObjectPtr cur;
8705:
8706: if (ctxt == NULL) return;
8707:
8708: if (nargs == 0) {
8709: valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context,
8710: ctxt->context->node));
8711: nargs = 1;
8712: }
8713:
8714: CHECK_ARITY(1);
8715: if ((ctxt->value == NULL) ||
8716: ((ctxt->value->type != XPATH_NODESET) &&
8717: (ctxt->value->type != XPATH_XSLT_TREE)))
8718: XP_ERROR(XPATH_INVALID_TYPE);
8719: cur = valuePop(ctxt);
8720:
8721: if ((cur->nodesetval == NULL) || (cur->nodesetval->nodeNr == 0)) {
8722: valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, ""));
8723: } else {
8724: int i = 0; /* Should be first in document order !!!!! */
8725: switch (cur->nodesetval->nodeTab[i]->type) {
8726: case XML_ELEMENT_NODE:
8727: case XML_ATTRIBUTE_NODE:
8728: case XML_PI_NODE:
8729: if (cur->nodesetval->nodeTab[i]->name[0] == ' ')
8730: valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, ""));
8731: else
8732: valuePush(ctxt,
8733: xmlXPathCacheNewString(ctxt->context,
8734: cur->nodesetval->nodeTab[i]->name));
8735: break;
8736: case XML_NAMESPACE_DECL:
8737: valuePush(ctxt, xmlXPathCacheNewString(ctxt->context,
8738: ((xmlNsPtr)cur->nodesetval->nodeTab[i])->prefix));
8739: break;
8740: default:
8741: valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, ""));
8742: }
8743: }
8744: xmlXPathReleaseObject(ctxt->context, cur);
8745: }
8746:
8747: /**
8748: * xmlXPathNamespaceURIFunction:
8749: * @ctxt: the XPath Parser context
8750: * @nargs: the number of arguments
8751: *
8752: * Implement the namespace-uri() XPath function
8753: * string namespace-uri(node-set?)
8754: * The namespace-uri function returns a string containing the
8755: * namespace URI of the expanded name of the node in the argument
8756: * node-set that is first in document order. If the node-set is empty,
8757: * the first node has no name, or the expanded name has no namespace
8758: * URI, an empty string is returned. If the argument is omitted it
8759: * defaults to the context node.
8760: */
8761: void
8762: xmlXPathNamespaceURIFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8763: xmlXPathObjectPtr cur;
8764:
8765: if (ctxt == NULL) return;
8766:
8767: if (nargs == 0) {
8768: valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context,
8769: ctxt->context->node));
8770: nargs = 1;
8771: }
8772: CHECK_ARITY(1);
8773: if ((ctxt->value == NULL) ||
8774: ((ctxt->value->type != XPATH_NODESET) &&
8775: (ctxt->value->type != XPATH_XSLT_TREE)))
8776: XP_ERROR(XPATH_INVALID_TYPE);
8777: cur = valuePop(ctxt);
8778:
8779: if ((cur->nodesetval == NULL) || (cur->nodesetval->nodeNr == 0)) {
8780: valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, ""));
8781: } else {
8782: int i = 0; /* Should be first in document order !!!!! */
8783: switch (cur->nodesetval->nodeTab[i]->type) {
8784: case XML_ELEMENT_NODE:
8785: case XML_ATTRIBUTE_NODE:
8786: if (cur->nodesetval->nodeTab[i]->ns == NULL)
8787: valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, ""));
8788: else
8789: valuePush(ctxt, xmlXPathCacheNewString(ctxt->context,
8790: cur->nodesetval->nodeTab[i]->ns->href));
8791: break;
8792: default:
8793: valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, ""));
8794: }
8795: }
8796: xmlXPathReleaseObject(ctxt->context, cur);
8797: }
8798:
8799: /**
8800: * xmlXPathNameFunction:
8801: * @ctxt: the XPath Parser context
8802: * @nargs: the number of arguments
8803: *
8804: * Implement the name() XPath function
8805: * string name(node-set?)
8806: * The name function returns a string containing a QName representing
8807: * the name of the node in the argument node-set that is first in document
8808: * order. The QName must represent the name with respect to the namespace
8809: * declarations in effect on the node whose name is being represented.
8810: * Typically, this will be the form in which the name occurred in the XML
8811: * source. This need not be the case if there are namespace declarations
8812: * in effect on the node that associate multiple prefixes with the same
8813: * namespace. However, an implementation may include information about
8814: * the original prefix in its representation of nodes; in this case, an
8815: * implementation can ensure that the returned string is always the same
8816: * as the QName used in the XML source. If the argument it omitted it
8817: * defaults to the context node.
8818: * Libxml keep the original prefix so the "real qualified name" used is
8819: * returned.
8820: */
8821: static void
8822: xmlXPathNameFunction(xmlXPathParserContextPtr ctxt, int nargs)
8823: {
8824: xmlXPathObjectPtr cur;
8825:
8826: if (nargs == 0) {
8827: valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context,
8828: ctxt->context->node));
8829: nargs = 1;
8830: }
8831:
8832: CHECK_ARITY(1);
8833: if ((ctxt->value == NULL) ||
8834: ((ctxt->value->type != XPATH_NODESET) &&
8835: (ctxt->value->type != XPATH_XSLT_TREE)))
8836: XP_ERROR(XPATH_INVALID_TYPE);
8837: cur = valuePop(ctxt);
8838:
8839: if ((cur->nodesetval == NULL) || (cur->nodesetval->nodeNr == 0)) {
8840: valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, ""));
8841: } else {
8842: int i = 0; /* Should be first in document order !!!!! */
8843:
8844: switch (cur->nodesetval->nodeTab[i]->type) {
8845: case XML_ELEMENT_NODE:
8846: case XML_ATTRIBUTE_NODE:
8847: if (cur->nodesetval->nodeTab[i]->name[0] == ' ')
8848: valuePush(ctxt,
8849: xmlXPathCacheNewCString(ctxt->context, ""));
8850: else if ((cur->nodesetval->nodeTab[i]->ns == NULL) ||
8851: (cur->nodesetval->nodeTab[i]->ns->prefix == NULL)) {
8852: valuePush(ctxt,
8853: xmlXPathCacheNewString(ctxt->context,
8854: cur->nodesetval->nodeTab[i]->name));
8855: } else {
8856: xmlChar *fullname;
8857:
8858: fullname = xmlBuildQName(cur->nodesetval->nodeTab[i]->name,
8859: cur->nodesetval->nodeTab[i]->ns->prefix,
8860: NULL, 0);
8861: if (fullname == cur->nodesetval->nodeTab[i]->name)
8862: fullname = xmlStrdup(cur->nodesetval->nodeTab[i]->name);
8863: if (fullname == NULL) {
8864: XP_ERROR(XPATH_MEMORY_ERROR);
8865: }
8866: valuePush(ctxt, xmlXPathCacheWrapString(
8867: ctxt->context, fullname));
8868: }
8869: break;
8870: default:
8871: valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context,
8872: cur->nodesetval->nodeTab[i]));
8873: xmlXPathLocalNameFunction(ctxt, 1);
8874: }
8875: }
8876: xmlXPathReleaseObject(ctxt->context, cur);
8877: }
8878:
8879:
8880: /**
8881: * xmlXPathStringFunction:
8882: * @ctxt: the XPath Parser context
8883: * @nargs: the number of arguments
8884: *
8885: * Implement the string() XPath function
8886: * string string(object?)
8887: * The string function converts an object to a string as follows:
8888: * - A node-set is converted to a string by returning the value of
8889: * the node in the node-set that is first in document order.
8890: * If the node-set is empty, an empty string is returned.
8891: * - A number is converted to a string as follows
8892: * + NaN is converted to the string NaN
8893: * + positive zero is converted to the string 0
8894: * + negative zero is converted to the string 0
8895: * + positive infinity is converted to the string Infinity
8896: * + negative infinity is converted to the string -Infinity
8897: * + if the number is an integer, the number is represented in
8898: * decimal form as a Number with no decimal point and no leading
8899: * zeros, preceded by a minus sign (-) if the number is negative
8900: * + otherwise, the number is represented in decimal form as a
8901: * Number including a decimal point with at least one digit
8902: * before the decimal point and at least one digit after the
8903: * decimal point, preceded by a minus sign (-) if the number
8904: * is negative; there must be no leading zeros before the decimal
8905: * point apart possibly from the one required digit immediately
8906: * before the decimal point; beyond the one required digit
8907: * after the decimal point there must be as many, but only as
8908: * many, more digits as are needed to uniquely distinguish the
8909: * number from all other IEEE 754 numeric values.
8910: * - The boolean false value is converted to the string false.
8911: * The boolean true value is converted to the string true.
8912: *
8913: * If the argument is omitted, it defaults to a node-set with the
8914: * context node as its only member.
8915: */
8916: void
8917: xmlXPathStringFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8918: xmlXPathObjectPtr cur;
8919:
8920: if (ctxt == NULL) return;
8921: if (nargs == 0) {
8922: valuePush(ctxt,
8923: xmlXPathCacheWrapString(ctxt->context,
8924: xmlXPathCastNodeToString(ctxt->context->node)));
8925: return;
8926: }
8927:
8928: CHECK_ARITY(1);
8929: cur = valuePop(ctxt);
8930: if (cur == NULL) XP_ERROR(XPATH_INVALID_OPERAND);
8931: valuePush(ctxt, xmlXPathCacheConvertString(ctxt->context, cur));
8932: }
8933:
8934: /**
8935: * xmlXPathStringLengthFunction:
8936: * @ctxt: the XPath Parser context
8937: * @nargs: the number of arguments
8938: *
8939: * Implement the string-length() XPath function
8940: * number string-length(string?)
8941: * The string-length returns the number of characters in the string
8942: * (see [3.6 Strings]). If the argument is omitted, it defaults to
8943: * the context node converted to a string, in other words the value
8944: * of the context node.
8945: */
8946: void
8947: xmlXPathStringLengthFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8948: xmlXPathObjectPtr cur;
8949:
8950: if (nargs == 0) {
8951: if ((ctxt == NULL) || (ctxt->context == NULL))
8952: return;
8953: if (ctxt->context->node == NULL) {
8954: valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, 0));
8955: } else {
8956: xmlChar *content;
8957:
8958: content = xmlXPathCastNodeToString(ctxt->context->node);
8959: valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context,
8960: xmlUTF8Strlen(content)));
8961: xmlFree(content);
8962: }
8963: return;
8964: }
8965: CHECK_ARITY(1);
8966: CAST_TO_STRING;
8967: CHECK_TYPE(XPATH_STRING);
8968: cur = valuePop(ctxt);
8969: valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context,
8970: xmlUTF8Strlen(cur->stringval)));
8971: xmlXPathReleaseObject(ctxt->context, cur);
8972: }
8973:
8974: /**
8975: * xmlXPathConcatFunction:
8976: * @ctxt: the XPath Parser context
8977: * @nargs: the number of arguments
8978: *
8979: * Implement the concat() XPath function
8980: * string concat(string, string, string*)
8981: * The concat function returns the concatenation of its arguments.
8982: */
8983: void
8984: xmlXPathConcatFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8985: xmlXPathObjectPtr cur, newobj;
8986: xmlChar *tmp;
8987:
8988: if (ctxt == NULL) return;
8989: if (nargs < 2) {
8990: CHECK_ARITY(2);
8991: }
8992:
8993: CAST_TO_STRING;
8994: cur = valuePop(ctxt);
8995: if ((cur == NULL) || (cur->type != XPATH_STRING)) {
8996: xmlXPathReleaseObject(ctxt->context, cur);
8997: return;
8998: }
8999: nargs--;
9000:
9001: while (nargs > 0) {
9002: CAST_TO_STRING;
9003: newobj = valuePop(ctxt);
9004: if ((newobj == NULL) || (newobj->type != XPATH_STRING)) {
9005: xmlXPathReleaseObject(ctxt->context, newobj);
9006: xmlXPathReleaseObject(ctxt->context, cur);
9007: XP_ERROR(XPATH_INVALID_TYPE);
9008: }
9009: tmp = xmlStrcat(newobj->stringval, cur->stringval);
9010: newobj->stringval = cur->stringval;
9011: cur->stringval = tmp;
9012: xmlXPathReleaseObject(ctxt->context, newobj);
9013: nargs--;
9014: }
9015: valuePush(ctxt, cur);
9016: }
9017:
9018: /**
9019: * xmlXPathContainsFunction:
9020: * @ctxt: the XPath Parser context
9021: * @nargs: the number of arguments
9022: *
9023: * Implement the contains() XPath function
9024: * boolean contains(string, string)
9025: * The contains function returns true if the first argument string
9026: * contains the second argument string, and otherwise returns false.
9027: */
9028: void
9029: xmlXPathContainsFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9030: xmlXPathObjectPtr hay, needle;
9031:
9032: CHECK_ARITY(2);
9033: CAST_TO_STRING;
9034: CHECK_TYPE(XPATH_STRING);
9035: needle = valuePop(ctxt);
9036: CAST_TO_STRING;
9037: hay = valuePop(ctxt);
9038:
9039: if ((hay == NULL) || (hay->type != XPATH_STRING)) {
9040: xmlXPathReleaseObject(ctxt->context, hay);
9041: xmlXPathReleaseObject(ctxt->context, needle);
9042: XP_ERROR(XPATH_INVALID_TYPE);
9043: }
9044: if (xmlStrstr(hay->stringval, needle->stringval))
9045: valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, 1));
9046: else
9047: valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, 0));
9048: xmlXPathReleaseObject(ctxt->context, hay);
9049: xmlXPathReleaseObject(ctxt->context, needle);
9050: }
9051:
9052: /**
9053: * xmlXPathStartsWithFunction:
9054: * @ctxt: the XPath Parser context
9055: * @nargs: the number of arguments
9056: *
9057: * Implement the starts-with() XPath function
9058: * boolean starts-with(string, string)
9059: * The starts-with function returns true if the first argument string
9060: * starts with the second argument string, and otherwise returns false.
9061: */
9062: void
9063: xmlXPathStartsWithFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9064: xmlXPathObjectPtr hay, needle;
9065: int n;
9066:
9067: CHECK_ARITY(2);
9068: CAST_TO_STRING;
9069: CHECK_TYPE(XPATH_STRING);
9070: needle = valuePop(ctxt);
9071: CAST_TO_STRING;
9072: hay = valuePop(ctxt);
9073:
9074: if ((hay == NULL) || (hay->type != XPATH_STRING)) {
9075: xmlXPathReleaseObject(ctxt->context, hay);
9076: xmlXPathReleaseObject(ctxt->context, needle);
9077: XP_ERROR(XPATH_INVALID_TYPE);
9078: }
9079: n = xmlStrlen(needle->stringval);
9080: if (xmlStrncmp(hay->stringval, needle->stringval, n))
9081: valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, 0));
9082: else
9083: valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, 1));
9084: xmlXPathReleaseObject(ctxt->context, hay);
9085: xmlXPathReleaseObject(ctxt->context, needle);
9086: }
9087:
9088: /**
9089: * xmlXPathSubstringFunction:
9090: * @ctxt: the XPath Parser context
9091: * @nargs: the number of arguments
9092: *
9093: * Implement the substring() XPath function
9094: * string substring(string, number, number?)
9095: * The substring function returns the substring of the first argument
9096: * starting at the position specified in the second argument with
9097: * length specified in the third argument. For example,
9098: * substring("12345",2,3) returns "234". If the third argument is not
9099: * specified, it returns the substring starting at the position specified
9100: * in the second argument and continuing to the end of the string. For
9101: * example, substring("12345",2) returns "2345". More precisely, each
9102: * character in the string (see [3.6 Strings]) is considered to have a
9103: * numeric position: the position of the first character is 1, the position
9104: * of the second character is 2 and so on. The returned substring contains
9105: * those characters for which the position of the character is greater than
9106: * or equal to the second argument and, if the third argument is specified,
9107: * less than the sum of the second and third arguments; the comparisons
9108: * and addition used for the above follow the standard IEEE 754 rules. Thus:
9109: * - substring("12345", 1.5, 2.6) returns "234"
9110: * - substring("12345", 0, 3) returns "12"
9111: * - substring("12345", 0 div 0, 3) returns ""
9112: * - substring("12345", 1, 0 div 0) returns ""
9113: * - substring("12345", -42, 1 div 0) returns "12345"
9114: * - substring("12345", -1 div 0, 1 div 0) returns ""
9115: */
9116: void
9117: xmlXPathSubstringFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9118: xmlXPathObjectPtr str, start, len;
9119: double le=0, in;
9120: int i, l, m;
9121: xmlChar *ret;
9122:
9123: if (nargs < 2) {
9124: CHECK_ARITY(2);
9125: }
9126: if (nargs > 3) {
9127: CHECK_ARITY(3);
9128: }
9129: /*
9130: * take care of possible last (position) argument
9131: */
9132: if (nargs == 3) {
9133: CAST_TO_NUMBER;
9134: CHECK_TYPE(XPATH_NUMBER);
9135: len = valuePop(ctxt);
9136: le = len->floatval;
9137: xmlXPathReleaseObject(ctxt->context, len);
9138: }
9139:
9140: CAST_TO_NUMBER;
9141: CHECK_TYPE(XPATH_NUMBER);
9142: start = valuePop(ctxt);
9143: in = start->floatval;
9144: xmlXPathReleaseObject(ctxt->context, start);
9145: CAST_TO_STRING;
9146: CHECK_TYPE(XPATH_STRING);
9147: str = valuePop(ctxt);
9148: m = xmlUTF8Strlen((const unsigned char *)str->stringval);
9149:
9150: /*
9151: * If last pos not present, calculate last position
9152: */
9153: if (nargs != 3) {
9154: le = (double)m;
9155: if (in < 1.0)
9156: in = 1.0;
9157: }
9158:
9159: /* Need to check for the special cases where either
9160: * the index is NaN, the length is NaN, or both
9161: * arguments are infinity (relying on Inf + -Inf = NaN)
9162: */
9163: if (!xmlXPathIsInf(in) && !xmlXPathIsNaN(in + le)) {
9164: /*
9165: * To meet the requirements of the spec, the arguments
9166: * must be converted to integer format before
9167: * initial index calculations are done
9168: *
9169: * First we go to integer form, rounding up
9170: * and checking for special cases
9171: */
9172: i = (int) in;
9173: if (((double)i)+0.5 <= in) i++;
9174:
9175: if (xmlXPathIsInf(le) == 1) {
9176: l = m;
9177: if (i < 1)
9178: i = 1;
9179: }
9180: else if (xmlXPathIsInf(le) == -1 || le < 0.0)
9181: l = 0;
9182: else {
9183: l = (int) le;
9184: if (((double)l)+0.5 <= le) l++;
9185: }
9186:
9187: /* Now we normalize inidices */
9188: i -= 1;
9189: l += i;
9190: if (i < 0)
9191: i = 0;
9192: if (l > m)
9193: l = m;
9194:
9195: /* number of chars to copy */
9196: l -= i;
9197:
9198: ret = xmlUTF8Strsub(str->stringval, i, l);
9199: }
9200: else {
9201: ret = NULL;
9202: }
9203: if (ret == NULL)
9204: valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, ""));
9205: else {
9206: valuePush(ctxt, xmlXPathCacheNewString(ctxt->context, ret));
9207: xmlFree(ret);
9208: }
9209: xmlXPathReleaseObject(ctxt->context, str);
9210: }
9211:
9212: /**
9213: * xmlXPathSubstringBeforeFunction:
9214: * @ctxt: the XPath Parser context
9215: * @nargs: the number of arguments
9216: *
9217: * Implement the substring-before() XPath function
9218: * string substring-before(string, string)
9219: * The substring-before function returns the substring of the first
9220: * argument string that precedes the first occurrence of the second
9221: * argument string in the first argument string, or the empty string
9222: * if the first argument string does not contain the second argument
9223: * string. For example, substring-before("1999/04/01","/") returns 1999.
9224: */
9225: void
9226: xmlXPathSubstringBeforeFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9227: xmlXPathObjectPtr str;
9228: xmlXPathObjectPtr find;
9229: xmlBufPtr target;
9230: const xmlChar *point;
9231: int offset;
9232:
9233: CHECK_ARITY(2);
9234: CAST_TO_STRING;
9235: find = valuePop(ctxt);
9236: CAST_TO_STRING;
9237: str = valuePop(ctxt);
9238:
9239: target = xmlBufCreate();
9240: if (target) {
9241: point = xmlStrstr(str->stringval, find->stringval);
9242: if (point) {
9243: offset = (int)(point - str->stringval);
9244: xmlBufAdd(target, str->stringval, offset);
9245: }
9246: valuePush(ctxt, xmlXPathCacheNewString(ctxt->context,
9247: xmlBufContent(target)));
9248: xmlBufFree(target);
9249: }
9250: xmlXPathReleaseObject(ctxt->context, str);
9251: xmlXPathReleaseObject(ctxt->context, find);
9252: }
9253:
9254: /**
9255: * xmlXPathSubstringAfterFunction:
9256: * @ctxt: the XPath Parser context
9257: * @nargs: the number of arguments
9258: *
9259: * Implement the substring-after() XPath function
9260: * string substring-after(string, string)
9261: * The substring-after function returns the substring of the first
9262: * argument string that follows the first occurrence of the second
9263: * argument string in the first argument string, or the empty stringi
9264: * if the first argument string does not contain the second argument
9265: * string. For example, substring-after("1999/04/01","/") returns 04/01,
9266: * and substring-after("1999/04/01","19") returns 99/04/01.
9267: */
9268: void
9269: xmlXPathSubstringAfterFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9270: xmlXPathObjectPtr str;
9271: xmlXPathObjectPtr find;
9272: xmlBufPtr target;
9273: const xmlChar *point;
9274: int offset;
9275:
9276: CHECK_ARITY(2);
9277: CAST_TO_STRING;
9278: find = valuePop(ctxt);
9279: CAST_TO_STRING;
9280: str = valuePop(ctxt);
9281:
9282: target = xmlBufCreate();
9283: if (target) {
9284: point = xmlStrstr(str->stringval, find->stringval);
9285: if (point) {
9286: offset = (int)(point - str->stringval) + xmlStrlen(find->stringval);
9287: xmlBufAdd(target, &str->stringval[offset],
9288: xmlStrlen(str->stringval) - offset);
9289: }
9290: valuePush(ctxt, xmlXPathCacheNewString(ctxt->context,
9291: xmlBufContent(target)));
9292: xmlBufFree(target);
9293: }
9294: xmlXPathReleaseObject(ctxt->context, str);
9295: xmlXPathReleaseObject(ctxt->context, find);
9296: }
9297:
9298: /**
9299: * xmlXPathNormalizeFunction:
9300: * @ctxt: the XPath Parser context
9301: * @nargs: the number of arguments
9302: *
9303: * Implement the normalize-space() XPath function
9304: * string normalize-space(string?)
9305: * The normalize-space function returns the argument string with white
9306: * space normalized by stripping leading and trailing whitespace
9307: * and replacing sequences of whitespace characters by a single
9308: * space. Whitespace characters are the same allowed by the S production
9309: * in XML. If the argument is omitted, it defaults to the context
9310: * node converted to a string, in other words the value of the context node.
9311: */
9312: void
9313: xmlXPathNormalizeFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9314: xmlXPathObjectPtr obj = NULL;
9315: xmlChar *source = NULL;
9316: xmlBufPtr target;
9317: xmlChar blank;
9318:
9319: if (ctxt == NULL) return;
9320: if (nargs == 0) {
9321: /* Use current context node */
9322: valuePush(ctxt,
9323: xmlXPathCacheWrapString(ctxt->context,
9324: xmlXPathCastNodeToString(ctxt->context->node)));
9325: nargs = 1;
9326: }
9327:
9328: CHECK_ARITY(1);
9329: CAST_TO_STRING;
9330: CHECK_TYPE(XPATH_STRING);
9331: obj = valuePop(ctxt);
9332: source = obj->stringval;
9333:
9334: target = xmlBufCreate();
9335: if (target && source) {
9336:
9337: /* Skip leading whitespaces */
9338: while (IS_BLANK_CH(*source))
9339: source++;
9340:
9341: /* Collapse intermediate whitespaces, and skip trailing whitespaces */
9342: blank = 0;
9343: while (*source) {
9344: if (IS_BLANK_CH(*source)) {
9345: blank = 0x20;
9346: } else {
9347: if (blank) {
9348: xmlBufAdd(target, &blank, 1);
9349: blank = 0;
9350: }
9351: xmlBufAdd(target, source, 1);
9352: }
9353: source++;
9354: }
9355: valuePush(ctxt, xmlXPathCacheNewString(ctxt->context,
9356: xmlBufContent(target)));
9357: xmlBufFree(target);
9358: }
9359: xmlXPathReleaseObject(ctxt->context, obj);
9360: }
9361:
9362: /**
9363: * xmlXPathTranslateFunction:
9364: * @ctxt: the XPath Parser context
9365: * @nargs: the number of arguments
9366: *
9367: * Implement the translate() XPath function
9368: * string translate(string, string, string)
9369: * The translate function returns the first argument string with
9370: * occurrences of characters in the second argument string replaced
9371: * by the character at the corresponding position in the third argument
9372: * string. For example, translate("bar","abc","ABC") returns the string
9373: * BAr. If there is a character in the second argument string with no
9374: * character at a corresponding position in the third argument string
9375: * (because the second argument string is longer than the third argument
9376: * string), then occurrences of that character in the first argument
9377: * string are removed. For example, translate("--aaa--","abc-","ABC")
9378: * returns "AAA". If a character occurs more than once in second
9379: * argument string, then the first occurrence determines the replacement
9380: * character. If the third argument string is longer than the second
9381: * argument string, then excess characters are ignored.
9382: */
9383: void
9384: xmlXPathTranslateFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9385: xmlXPathObjectPtr str;
9386: xmlXPathObjectPtr from;
9387: xmlXPathObjectPtr to;
9388: xmlBufPtr target;
9389: int offset, max;
9390: xmlChar ch;
9391: const xmlChar *point;
9392: xmlChar *cptr;
9393:
9394: CHECK_ARITY(3);
9395:
9396: CAST_TO_STRING;
9397: to = valuePop(ctxt);
9398: CAST_TO_STRING;
9399: from = valuePop(ctxt);
9400: CAST_TO_STRING;
9401: str = valuePop(ctxt);
9402:
9403: target = xmlBufCreate();
9404: if (target) {
9405: max = xmlUTF8Strlen(to->stringval);
9406: for (cptr = str->stringval; (ch=*cptr); ) {
9407: offset = xmlUTF8Strloc(from->stringval, cptr);
9408: if (offset >= 0) {
9409: if (offset < max) {
9410: point = xmlUTF8Strpos(to->stringval, offset);
9411: if (point)
9412: xmlBufAdd(target, point, xmlUTF8Strsize(point, 1));
9413: }
9414: } else
9415: xmlBufAdd(target, cptr, xmlUTF8Strsize(cptr, 1));
9416:
9417: /* Step to next character in input */
9418: cptr++;
9419: if ( ch & 0x80 ) {
9420: /* if not simple ascii, verify proper format */
9421: if ( (ch & 0xc0) != 0xc0 ) {
9422: xmlGenericError(xmlGenericErrorContext,
9423: "xmlXPathTranslateFunction: Invalid UTF8 string\n");
9424: /* not asserting an XPath error is probably better */
9425: break;
9426: }
9427: /* then skip over remaining bytes for this char */
9428: while ( (ch <<= 1) & 0x80 )
9429: if ( (*cptr++ & 0xc0) != 0x80 ) {
9430: xmlGenericError(xmlGenericErrorContext,
9431: "xmlXPathTranslateFunction: Invalid UTF8 string\n");
9432: /* not asserting an XPath error is probably better */
9433: break;
9434: }
9435: if (ch & 0x80) /* must have had error encountered */
9436: break;
9437: }
9438: }
9439: }
9440: valuePush(ctxt, xmlXPathCacheNewString(ctxt->context,
9441: xmlBufContent(target)));
9442: xmlBufFree(target);
9443: xmlXPathReleaseObject(ctxt->context, str);
9444: xmlXPathReleaseObject(ctxt->context, from);
9445: xmlXPathReleaseObject(ctxt->context, to);
9446: }
9447:
9448: /**
9449: * xmlXPathBooleanFunction:
9450: * @ctxt: the XPath Parser context
9451: * @nargs: the number of arguments
9452: *
9453: * Implement the boolean() XPath function
9454: * boolean boolean(object)
9455: * The boolean function converts its argument to a boolean as follows:
9456: * - a number is true if and only if it is neither positive or
9457: * negative zero nor NaN
9458: * - a node-set is true if and only if it is non-empty
9459: * - a string is true if and only if its length is non-zero
9460: */
9461: void
9462: xmlXPathBooleanFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9463: xmlXPathObjectPtr cur;
9464:
9465: CHECK_ARITY(1);
9466: cur = valuePop(ctxt);
9467: if (cur == NULL) XP_ERROR(XPATH_INVALID_OPERAND);
9468: cur = xmlXPathCacheConvertBoolean(ctxt->context, cur);
9469: valuePush(ctxt, cur);
9470: }
9471:
9472: /**
9473: * xmlXPathNotFunction:
9474: * @ctxt: the XPath Parser context
9475: * @nargs: the number of arguments
9476: *
9477: * Implement the not() XPath function
9478: * boolean not(boolean)
9479: * The not function returns true if its argument is false,
9480: * and false otherwise.
9481: */
9482: void
9483: xmlXPathNotFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9484: CHECK_ARITY(1);
9485: CAST_TO_BOOLEAN;
9486: CHECK_TYPE(XPATH_BOOLEAN);
9487: ctxt->value->boolval = ! ctxt->value->boolval;
9488: }
9489:
9490: /**
9491: * xmlXPathTrueFunction:
9492: * @ctxt: the XPath Parser context
9493: * @nargs: the number of arguments
9494: *
9495: * Implement the true() XPath function
9496: * boolean true()
9497: */
9498: void
9499: xmlXPathTrueFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9500: CHECK_ARITY(0);
9501: valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, 1));
9502: }
9503:
9504: /**
9505: * xmlXPathFalseFunction:
9506: * @ctxt: the XPath Parser context
9507: * @nargs: the number of arguments
9508: *
9509: * Implement the false() XPath function
9510: * boolean false()
9511: */
9512: void
9513: xmlXPathFalseFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9514: CHECK_ARITY(0);
9515: valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, 0));
9516: }
9517:
9518: /**
9519: * xmlXPathLangFunction:
9520: * @ctxt: the XPath Parser context
9521: * @nargs: the number of arguments
9522: *
9523: * Implement the lang() XPath function
9524: * boolean lang(string)
9525: * The lang function returns true or false depending on whether the
9526: * language of the context node as specified by xml:lang attributes
9527: * is the same as or is a sublanguage of the language specified by
9528: * the argument string. The language of the context node is determined
9529: * by the value of the xml:lang attribute on the context node, or, if
9530: * the context node has no xml:lang attribute, by the value of the
9531: * xml:lang attribute on the nearest ancestor of the context node that
9532: * has an xml:lang attribute. If there is no such attribute, then lang
9533: * returns false. If there is such an attribute, then lang returns
9534: * true if the attribute value is equal to the argument ignoring case,
9535: * or if there is some suffix starting with - such that the attribute
9536: * value is equal to the argument ignoring that suffix of the attribute
9537: * value and ignoring case.
9538: */
9539: void
9540: xmlXPathLangFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9541: xmlXPathObjectPtr val = NULL;
9542: const xmlChar *theLang = NULL;
9543: const xmlChar *lang;
9544: int ret = 0;
9545: int i;
9546:
9547: CHECK_ARITY(1);
9548: CAST_TO_STRING;
9549: CHECK_TYPE(XPATH_STRING);
9550: val = valuePop(ctxt);
9551: lang = val->stringval;
9552: theLang = xmlNodeGetLang(ctxt->context->node);
9553: if ((theLang != NULL) && (lang != NULL)) {
9554: for (i = 0;lang[i] != 0;i++)
9555: if (toupper(lang[i]) != toupper(theLang[i]))
9556: goto not_equal;
9557: if ((theLang[i] == 0) || (theLang[i] == '-'))
9558: ret = 1;
9559: }
9560: not_equal:
9561: if (theLang != NULL)
9562: xmlFree((void *)theLang);
9563:
9564: xmlXPathReleaseObject(ctxt->context, val);
9565: valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, ret));
9566: }
9567:
9568: /**
9569: * xmlXPathNumberFunction:
9570: * @ctxt: the XPath Parser context
9571: * @nargs: the number of arguments
9572: *
9573: * Implement the number() XPath function
9574: * number number(object?)
9575: */
9576: void
9577: xmlXPathNumberFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9578: xmlXPathObjectPtr cur;
9579: double res;
9580:
9581: if (ctxt == NULL) return;
9582: if (nargs == 0) {
9583: if (ctxt->context->node == NULL) {
9584: valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, 0.0));
9585: } else {
9586: xmlChar* content = xmlNodeGetContent(ctxt->context->node);
9587:
9588: res = xmlXPathStringEvalNumber(content);
9589: valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, res));
9590: xmlFree(content);
9591: }
9592: return;
9593: }
9594:
9595: CHECK_ARITY(1);
9596: cur = valuePop(ctxt);
9597: valuePush(ctxt, xmlXPathCacheConvertNumber(ctxt->context, cur));
9598: }
9599:
9600: /**
9601: * xmlXPathSumFunction:
9602: * @ctxt: the XPath Parser context
9603: * @nargs: the number of arguments
9604: *
9605: * Implement the sum() XPath function
9606: * number sum(node-set)
9607: * The sum function returns the sum of the values of the nodes in
9608: * the argument node-set.
9609: */
9610: void
9611: xmlXPathSumFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9612: xmlXPathObjectPtr cur;
9613: int i;
9614: double res = 0.0;
9615:
9616: CHECK_ARITY(1);
9617: if ((ctxt->value == NULL) ||
9618: ((ctxt->value->type != XPATH_NODESET) &&
9619: (ctxt->value->type != XPATH_XSLT_TREE)))
9620: XP_ERROR(XPATH_INVALID_TYPE);
9621: cur = valuePop(ctxt);
9622:
9623: if ((cur->nodesetval != NULL) && (cur->nodesetval->nodeNr != 0)) {
9624: for (i = 0; i < cur->nodesetval->nodeNr; i++) {
9625: res += xmlXPathCastNodeToNumber(cur->nodesetval->nodeTab[i]);
9626: }
9627: }
9628: valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, res));
9629: xmlXPathReleaseObject(ctxt->context, cur);
9630: }
9631:
9632: /*
9633: * To assure working code on multiple platforms, we want to only depend
9634: * upon the characteristic truncation of converting a floating point value
9635: * to an integer. Unfortunately, because of the different storage sizes
9636: * of our internal floating point value (double) and integer (int), we
9637: * can't directly convert (see bug 301162). This macro is a messy
9638: * 'workaround'
9639: */
9640: #define XTRUNC(f, v) \
9641: f = fmod((v), INT_MAX); \
9642: f = (v) - (f) + (double)((int)(f));
9643:
9644: /**
9645: * xmlXPathFloorFunction:
9646: * @ctxt: the XPath Parser context
9647: * @nargs: the number of arguments
9648: *
9649: * Implement the floor() XPath function
9650: * number floor(number)
9651: * The floor function returns the largest (closest to positive infinity)
9652: * number that is not greater than the argument and that is an integer.
9653: */
9654: void
9655: xmlXPathFloorFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9656: double f;
9657:
9658: CHECK_ARITY(1);
9659: CAST_TO_NUMBER;
9660: CHECK_TYPE(XPATH_NUMBER);
9661:
9662: XTRUNC(f, ctxt->value->floatval);
9663: if (f != ctxt->value->floatval) {
9664: if (ctxt->value->floatval > 0)
9665: ctxt->value->floatval = f;
9666: else
9667: ctxt->value->floatval = f - 1;
9668: }
9669: }
9670:
9671: /**
9672: * xmlXPathCeilingFunction:
9673: * @ctxt: the XPath Parser context
9674: * @nargs: the number of arguments
9675: *
9676: * Implement the ceiling() XPath function
9677: * number ceiling(number)
9678: * The ceiling function returns the smallest (closest to negative infinity)
9679: * number that is not less than the argument and that is an integer.
9680: */
9681: void
9682: xmlXPathCeilingFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9683: double f;
9684:
9685: CHECK_ARITY(1);
9686: CAST_TO_NUMBER;
9687: CHECK_TYPE(XPATH_NUMBER);
9688:
9689: #if 0
9690: ctxt->value->floatval = ceil(ctxt->value->floatval);
9691: #else
9692: XTRUNC(f, ctxt->value->floatval);
9693: if (f != ctxt->value->floatval) {
9694: if (ctxt->value->floatval > 0)
9695: ctxt->value->floatval = f + 1;
9696: else {
9697: if (ctxt->value->floatval < 0 && f == 0)
9698: ctxt->value->floatval = xmlXPathNZERO;
9699: else
9700: ctxt->value->floatval = f;
9701: }
9702:
9703: }
9704: #endif
9705: }
9706:
9707: /**
9708: * xmlXPathRoundFunction:
9709: * @ctxt: the XPath Parser context
9710: * @nargs: the number of arguments
9711: *
9712: * Implement the round() XPath function
9713: * number round(number)
9714: * The round function returns the number that is closest to the
9715: * argument and that is an integer. If there are two such numbers,
9716: * then the one that is even is returned.
9717: */
9718: void
9719: xmlXPathRoundFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9720: double f;
9721:
9722: CHECK_ARITY(1);
9723: CAST_TO_NUMBER;
9724: CHECK_TYPE(XPATH_NUMBER);
9725:
9726: if ((xmlXPathIsNaN(ctxt->value->floatval)) ||
9727: (xmlXPathIsInf(ctxt->value->floatval) == 1) ||
9728: (xmlXPathIsInf(ctxt->value->floatval) == -1) ||
9729: (ctxt->value->floatval == 0.0))
9730: return;
9731:
9732: XTRUNC(f, ctxt->value->floatval);
9733: if (ctxt->value->floatval < 0) {
9734: if (ctxt->value->floatval < f - 0.5)
9735: ctxt->value->floatval = f - 1;
9736: else
9737: ctxt->value->floatval = f;
9738: if (ctxt->value->floatval == 0)
9739: ctxt->value->floatval = xmlXPathNZERO;
9740: } else {
9741: if (ctxt->value->floatval < f + 0.5)
9742: ctxt->value->floatval = f;
9743: else
9744: ctxt->value->floatval = f + 1;
9745: }
9746: }
9747:
9748: /************************************************************************
9749: * *
9750: * The Parser *
9751: * *
9752: ************************************************************************/
9753:
9754: /*
9755: * a few forward declarations since we use a recursive call based
9756: * implementation.
9757: */
9758: static void xmlXPathCompileExpr(xmlXPathParserContextPtr ctxt, int sort);
9759: static void xmlXPathCompPredicate(xmlXPathParserContextPtr ctxt, int filter);
9760: static void xmlXPathCompLocationPath(xmlXPathParserContextPtr ctxt);
9761: static void xmlXPathCompRelativeLocationPath(xmlXPathParserContextPtr ctxt);
9762: static xmlChar * xmlXPathParseNameComplex(xmlXPathParserContextPtr ctxt,
9763: int qualified);
9764:
9765: /**
9766: * xmlXPathCurrentChar:
9767: * @ctxt: the XPath parser context
9768: * @cur: pointer to the beginning of the char
9769: * @len: pointer to the length of the char read
9770: *
9771: * The current char value, if using UTF-8 this may actually span multiple
9772: * bytes in the input buffer.
9773: *
9774: * Returns the current char value and its length
9775: */
9776:
9777: static int
9778: xmlXPathCurrentChar(xmlXPathParserContextPtr ctxt, int *len) {
9779: unsigned char c;
9780: unsigned int val;
9781: const xmlChar *cur;
9782:
9783: if (ctxt == NULL)
9784: return(0);
9785: cur = ctxt->cur;
9786:
9787: /*
9788: * We are supposed to handle UTF8, check it's valid
9789: * From rfc2044: encoding of the Unicode values on UTF-8:
9790: *
9791: * UCS-4 range (hex.) UTF-8 octet sequence (binary)
9792: * 0000 0000-0000 007F 0xxxxxxx
9793: * 0000 0080-0000 07FF 110xxxxx 10xxxxxx
9794: * 0000 0800-0000 FFFF 1110xxxx 10xxxxxx 10xxxxxx
9795: *
9796: * Check for the 0x110000 limit too
9797: */
9798: c = *cur;
9799: if (c & 0x80) {
9800: if ((cur[1] & 0xc0) != 0x80)
9801: goto encoding_error;
9802: if ((c & 0xe0) == 0xe0) {
9803:
9804: if ((cur[2] & 0xc0) != 0x80)
9805: goto encoding_error;
9806: if ((c & 0xf0) == 0xf0) {
9807: if (((c & 0xf8) != 0xf0) ||
9808: ((cur[3] & 0xc0) != 0x80))
9809: goto encoding_error;
9810: /* 4-byte code */
9811: *len = 4;
9812: val = (cur[0] & 0x7) << 18;
9813: val |= (cur[1] & 0x3f) << 12;
9814: val |= (cur[2] & 0x3f) << 6;
9815: val |= cur[3] & 0x3f;
9816: } else {
9817: /* 3-byte code */
9818: *len = 3;
9819: val = (cur[0] & 0xf) << 12;
9820: val |= (cur[1] & 0x3f) << 6;
9821: val |= cur[2] & 0x3f;
9822: }
9823: } else {
9824: /* 2-byte code */
9825: *len = 2;
9826: val = (cur[0] & 0x1f) << 6;
9827: val |= cur[1] & 0x3f;
9828: }
9829: if (!IS_CHAR(val)) {
9830: XP_ERROR0(XPATH_INVALID_CHAR_ERROR);
9831: }
9832: return(val);
9833: } else {
9834: /* 1-byte code */
9835: *len = 1;
9836: return((int) *cur);
9837: }
9838: encoding_error:
9839: /*
9840: * If we detect an UTF8 error that probably means that the
9841: * input encoding didn't get properly advertised in the
9842: * declaration header. Report the error and switch the encoding
9843: * to ISO-Latin-1 (if you don't like this policy, just declare the
9844: * encoding !)
9845: */
9846: *len = 0;
9847: XP_ERROR0(XPATH_ENCODING_ERROR);
9848: }
9849:
9850: /**
9851: * xmlXPathParseNCName:
9852: * @ctxt: the XPath Parser context
9853: *
9854: * parse an XML namespace non qualified name.
9855: *
9856: * [NS 3] NCName ::= (Letter | '_') (NCNameChar)*
9857: *
9858: * [NS 4] NCNameChar ::= Letter | Digit | '.' | '-' | '_' |
9859: * CombiningChar | Extender
9860: *
9861: * Returns the namespace name or NULL
9862: */
9863:
9864: xmlChar *
9865: xmlXPathParseNCName(xmlXPathParserContextPtr ctxt) {
9866: const xmlChar *in;
9867: xmlChar *ret;
9868: int count = 0;
9869:
9870: if ((ctxt == NULL) || (ctxt->cur == NULL)) return(NULL);
9871: /*
9872: * Accelerator for simple ASCII names
9873: */
9874: in = ctxt->cur;
9875: if (((*in >= 0x61) && (*in <= 0x7A)) ||
9876: ((*in >= 0x41) && (*in <= 0x5A)) ||
9877: (*in == '_')) {
9878: in++;
9879: while (((*in >= 0x61) && (*in <= 0x7A)) ||
9880: ((*in >= 0x41) && (*in <= 0x5A)) ||
9881: ((*in >= 0x30) && (*in <= 0x39)) ||
9882: (*in == '_') || (*in == '.') ||
9883: (*in == '-'))
9884: in++;
9885: if ((*in == ' ') || (*in == '>') || (*in == '/') ||
9886: (*in == '[') || (*in == ']') || (*in == ':') ||
9887: (*in == '@') || (*in == '*')) {
9888: count = in - ctxt->cur;
9889: if (count == 0)
9890: return(NULL);
9891: ret = xmlStrndup(ctxt->cur, count);
9892: ctxt->cur = in;
9893: return(ret);
9894: }
9895: }
9896: return(xmlXPathParseNameComplex(ctxt, 0));
9897: }
9898:
9899:
9900: /**
9901: * xmlXPathParseQName:
9902: * @ctxt: the XPath Parser context
9903: * @prefix: a xmlChar **
9904: *
9905: * parse an XML qualified name
9906: *
9907: * [NS 5] QName ::= (Prefix ':')? LocalPart
9908: *
9909: * [NS 6] Prefix ::= NCName
9910: *
9911: * [NS 7] LocalPart ::= NCName
9912: *
9913: * Returns the function returns the local part, and prefix is updated
9914: * to get the Prefix if any.
9915: */
9916:
9917: static xmlChar *
9918: xmlXPathParseQName(xmlXPathParserContextPtr ctxt, xmlChar **prefix) {
9919: xmlChar *ret = NULL;
9920:
9921: *prefix = NULL;
9922: ret = xmlXPathParseNCName(ctxt);
9923: if (ret && CUR == ':') {
9924: *prefix = ret;
9925: NEXT;
9926: ret = xmlXPathParseNCName(ctxt);
9927: }
9928: return(ret);
9929: }
9930:
9931: /**
9932: * xmlXPathParseName:
9933: * @ctxt: the XPath Parser context
9934: *
9935: * parse an XML name
9936: *
9937: * [4] NameChar ::= Letter | Digit | '.' | '-' | '_' | ':' |
9938: * CombiningChar | Extender
9939: *
9940: * [5] Name ::= (Letter | '_' | ':') (NameChar)*
9941: *
9942: * Returns the namespace name or NULL
9943: */
9944:
9945: xmlChar *
9946: xmlXPathParseName(xmlXPathParserContextPtr ctxt) {
9947: const xmlChar *in;
9948: xmlChar *ret;
9949: size_t count = 0;
9950:
9951: if ((ctxt == NULL) || (ctxt->cur == NULL)) return(NULL);
9952: /*
9953: * Accelerator for simple ASCII names
9954: */
9955: in = ctxt->cur;
9956: if (((*in >= 0x61) && (*in <= 0x7A)) ||
9957: ((*in >= 0x41) && (*in <= 0x5A)) ||
9958: (*in == '_') || (*in == ':')) {
9959: in++;
9960: while (((*in >= 0x61) && (*in <= 0x7A)) ||
9961: ((*in >= 0x41) && (*in <= 0x5A)) ||
9962: ((*in >= 0x30) && (*in <= 0x39)) ||
9963: (*in == '_') || (*in == '-') ||
9964: (*in == ':') || (*in == '.'))
9965: in++;
9966: if ((*in > 0) && (*in < 0x80)) {
9967: count = in - ctxt->cur;
9968: if (count > XML_MAX_NAME_LENGTH) {
9969: ctxt->cur = in;
9970: XP_ERRORNULL(XPATH_EXPR_ERROR);
9971: }
9972: ret = xmlStrndup(ctxt->cur, count);
9973: ctxt->cur = in;
9974: return(ret);
9975: }
9976: }
9977: return(xmlXPathParseNameComplex(ctxt, 1));
9978: }
9979:
9980: static xmlChar *
9981: xmlXPathParseNameComplex(xmlXPathParserContextPtr ctxt, int qualified) {
9982: xmlChar buf[XML_MAX_NAMELEN + 5];
9983: int len = 0, l;
9984: int c;
9985:
9986: /*
9987: * Handler for more complex cases
9988: */
9989: c = CUR_CHAR(l);
9990: if ((c == ' ') || (c == '>') || (c == '/') || /* accelerators */
9991: (c == '[') || (c == ']') || (c == '@') || /* accelerators */
9992: (c == '*') || /* accelerators */
9993: (!IS_LETTER(c) && (c != '_') &&
9994: ((qualified) && (c != ':')))) {
9995: return(NULL);
9996: }
9997:
9998: while ((c != ' ') && (c != '>') && (c != '/') && /* test bigname.xml */
9999: ((IS_LETTER(c)) || (IS_DIGIT(c)) ||
10000: (c == '.') || (c == '-') ||
10001: (c == '_') || ((qualified) && (c == ':')) ||
10002: (IS_COMBINING(c)) ||
10003: (IS_EXTENDER(c)))) {
10004: COPY_BUF(l,buf,len,c);
10005: NEXTL(l);
10006: c = CUR_CHAR(l);
10007: if (len >= XML_MAX_NAMELEN) {
10008: /*
10009: * Okay someone managed to make a huge name, so he's ready to pay
10010: * for the processing speed.
10011: */
10012: xmlChar *buffer;
10013: int max = len * 2;
10014:
10015: if (len > XML_MAX_NAME_LENGTH) {
10016: XP_ERRORNULL(XPATH_EXPR_ERROR);
10017: }
10018: buffer = (xmlChar *) xmlMallocAtomic(max * sizeof(xmlChar));
10019: if (buffer == NULL) {
10020: XP_ERRORNULL(XPATH_MEMORY_ERROR);
10021: }
10022: memcpy(buffer, buf, len);
10023: while ((IS_LETTER(c)) || (IS_DIGIT(c)) || /* test bigname.xml */
10024: (c == '.') || (c == '-') ||
10025: (c == '_') || ((qualified) && (c == ':')) ||
10026: (IS_COMBINING(c)) ||
10027: (IS_EXTENDER(c))) {
10028: if (len + 10 > max) {
10029: if (max > XML_MAX_NAME_LENGTH) {
10030: XP_ERRORNULL(XPATH_EXPR_ERROR);
10031: }
10032: max *= 2;
10033: buffer = (xmlChar *) xmlRealloc(buffer,
10034: max * sizeof(xmlChar));
10035: if (buffer == NULL) {
10036: XP_ERRORNULL(XPATH_MEMORY_ERROR);
10037: }
10038: }
10039: COPY_BUF(l,buffer,len,c);
10040: NEXTL(l);
10041: c = CUR_CHAR(l);
10042: }
10043: buffer[len] = 0;
10044: return(buffer);
10045: }
10046: }
10047: if (len == 0)
10048: return(NULL);
10049: return(xmlStrndup(buf, len));
10050: }
10051:
10052: #define MAX_FRAC 20
10053:
10054: /*
10055: * These are used as divisors for the fractional part of a number.
10056: * Since the table includes 1.0 (representing '0' fractional digits),
10057: * it must be dimensioned at MAX_FRAC+1 (bug 133921)
10058: */
10059: static double my_pow10[MAX_FRAC+1] = {
10060: 1.0, 10.0, 100.0, 1000.0, 10000.0,
10061: 100000.0, 1000000.0, 10000000.0, 100000000.0, 1000000000.0,
10062: 10000000000.0, 100000000000.0, 1000000000000.0, 10000000000000.0,
10063: 100000000000000.0,
10064: 1000000000000000.0, 10000000000000000.0, 100000000000000000.0,
10065: 1000000000000000000.0, 10000000000000000000.0, 100000000000000000000.0
10066: };
10067:
10068: /**
10069: * xmlXPathStringEvalNumber:
10070: * @str: A string to scan
10071: *
10072: * [30a] Float ::= Number ('e' Digits?)?
10073: *
10074: * [30] Number ::= Digits ('.' Digits?)?
10075: * | '.' Digits
10076: * [31] Digits ::= [0-9]+
10077: *
10078: * Compile a Number in the string
10079: * In complement of the Number expression, this function also handles
10080: * negative values : '-' Number.
10081: *
10082: * Returns the double value.
10083: */
10084: double
10085: xmlXPathStringEvalNumber(const xmlChar *str) {
10086: const xmlChar *cur = str;
10087: double ret;
10088: int ok = 0;
10089: int isneg = 0;
10090: int exponent = 0;
10091: int is_exponent_negative = 0;
10092: #ifdef __GNUC__
10093: unsigned long tmp = 0;
10094: double temp;
10095: #endif
10096: if (cur == NULL) return(0);
10097: while (IS_BLANK_CH(*cur)) cur++;
10098: if ((*cur != '.') && ((*cur < '0') || (*cur > '9')) && (*cur != '-')) {
10099: return(xmlXPathNAN);
10100: }
10101: if (*cur == '-') {
10102: isneg = 1;
10103: cur++;
10104: }
10105:
10106: #ifdef __GNUC__
10107: /*
10108: * tmp/temp is a workaround against a gcc compiler bug
10109: * http://veillard.com/gcc.bug
10110: */
10111: ret = 0;
10112: while ((*cur >= '0') && (*cur <= '9')) {
10113: ret = ret * 10;
10114: tmp = (*cur - '0');
10115: ok = 1;
10116: cur++;
10117: temp = (double) tmp;
10118: ret = ret + temp;
10119: }
10120: #else
10121: ret = 0;
10122: while ((*cur >= '0') && (*cur <= '9')) {
10123: ret = ret * 10 + (*cur - '0');
10124: ok = 1;
10125: cur++;
10126: }
10127: #endif
10128:
10129: if (*cur == '.') {
10130: int v, frac = 0;
10131: double fraction = 0;
10132:
10133: cur++;
10134: if (((*cur < '0') || (*cur > '9')) && (!ok)) {
10135: return(xmlXPathNAN);
10136: }
10137: while (((*cur >= '0') && (*cur <= '9')) && (frac < MAX_FRAC)) {
10138: v = (*cur - '0');
10139: fraction = fraction * 10 + v;
10140: frac = frac + 1;
10141: cur++;
10142: }
10143: fraction /= my_pow10[frac];
10144: ret = ret + fraction;
10145: while ((*cur >= '0') && (*cur <= '9'))
10146: cur++;
10147: }
10148: if ((*cur == 'e') || (*cur == 'E')) {
10149: cur++;
10150: if (*cur == '-') {
10151: is_exponent_negative = 1;
10152: cur++;
10153: } else if (*cur == '+') {
10154: cur++;
10155: }
10156: while ((*cur >= '0') && (*cur <= '9')) {
10157: exponent = exponent * 10 + (*cur - '0');
10158: cur++;
10159: }
10160: }
10161: while (IS_BLANK_CH(*cur)) cur++;
10162: if (*cur != 0) return(xmlXPathNAN);
10163: if (isneg) ret = -ret;
10164: if (is_exponent_negative) exponent = -exponent;
10165: ret *= pow(10.0, (double)exponent);
10166: return(ret);
10167: }
10168:
10169: /**
10170: * xmlXPathCompNumber:
10171: * @ctxt: the XPath Parser context
10172: *
10173: * [30] Number ::= Digits ('.' Digits?)?
10174: * | '.' Digits
10175: * [31] Digits ::= [0-9]+
10176: *
10177: * Compile a Number, then push it on the stack
10178: *
10179: */
10180: static void
10181: xmlXPathCompNumber(xmlXPathParserContextPtr ctxt)
10182: {
10183: double ret = 0.0;
10184: int ok = 0;
10185: int exponent = 0;
10186: int is_exponent_negative = 0;
10187: #ifdef __GNUC__
10188: unsigned long tmp = 0;
10189: double temp;
10190: #endif
10191:
10192: CHECK_ERROR;
10193: if ((CUR != '.') && ((CUR < '0') || (CUR > '9'))) {
10194: XP_ERROR(XPATH_NUMBER_ERROR);
10195: }
10196: #ifdef __GNUC__
10197: /*
10198: * tmp/temp is a workaround against a gcc compiler bug
10199: * http://veillard.com/gcc.bug
10200: */
10201: ret = 0;
10202: while ((CUR >= '0') && (CUR <= '9')) {
10203: ret = ret * 10;
10204: tmp = (CUR - '0');
10205: ok = 1;
10206: NEXT;
10207: temp = (double) tmp;
10208: ret = ret + temp;
10209: }
10210: #else
10211: ret = 0;
10212: while ((CUR >= '0') && (CUR <= '9')) {
10213: ret = ret * 10 + (CUR - '0');
10214: ok = 1;
10215: NEXT;
10216: }
10217: #endif
10218: if (CUR == '.') {
10219: int v, frac = 0;
10220: double fraction = 0;
10221:
10222: NEXT;
10223: if (((CUR < '0') || (CUR > '9')) && (!ok)) {
10224: XP_ERROR(XPATH_NUMBER_ERROR);
10225: }
10226: while ((CUR >= '0') && (CUR <= '9') && (frac < MAX_FRAC)) {
10227: v = (CUR - '0');
10228: fraction = fraction * 10 + v;
10229: frac = frac + 1;
10230: NEXT;
10231: }
10232: fraction /= my_pow10[frac];
10233: ret = ret + fraction;
10234: while ((CUR >= '0') && (CUR <= '9'))
10235: NEXT;
10236: }
10237: if ((CUR == 'e') || (CUR == 'E')) {
10238: NEXT;
10239: if (CUR == '-') {
10240: is_exponent_negative = 1;
10241: NEXT;
10242: } else if (CUR == '+') {
10243: NEXT;
10244: }
10245: while ((CUR >= '0') && (CUR <= '9')) {
10246: exponent = exponent * 10 + (CUR - '0');
10247: NEXT;
10248: }
10249: if (is_exponent_negative)
10250: exponent = -exponent;
10251: ret *= pow(10.0, (double) exponent);
10252: }
10253: PUSH_LONG_EXPR(XPATH_OP_VALUE, XPATH_NUMBER, 0, 0,
10254: xmlXPathCacheNewFloat(ctxt->context, ret), NULL);
10255: }
10256:
10257: /**
10258: * xmlXPathParseLiteral:
10259: * @ctxt: the XPath Parser context
10260: *
10261: * Parse a Literal
10262: *
10263: * [29] Literal ::= '"' [^"]* '"'
10264: * | "'" [^']* "'"
10265: *
10266: * Returns the value found or NULL in case of error
10267: */
10268: static xmlChar *
10269: xmlXPathParseLiteral(xmlXPathParserContextPtr ctxt) {
10270: const xmlChar *q;
10271: xmlChar *ret = NULL;
10272:
10273: if (CUR == '"') {
10274: NEXT;
10275: q = CUR_PTR;
10276: while ((IS_CHAR_CH(CUR)) && (CUR != '"'))
10277: NEXT;
10278: if (!IS_CHAR_CH(CUR)) {
10279: XP_ERRORNULL(XPATH_UNFINISHED_LITERAL_ERROR);
10280: } else {
10281: ret = xmlStrndup(q, CUR_PTR - q);
10282: NEXT;
10283: }
10284: } else if (CUR == '\'') {
10285: NEXT;
10286: q = CUR_PTR;
10287: while ((IS_CHAR_CH(CUR)) && (CUR != '\''))
10288: NEXT;
10289: if (!IS_CHAR_CH(CUR)) {
10290: XP_ERRORNULL(XPATH_UNFINISHED_LITERAL_ERROR);
10291: } else {
10292: ret = xmlStrndup(q, CUR_PTR - q);
10293: NEXT;
10294: }
10295: } else {
10296: XP_ERRORNULL(XPATH_START_LITERAL_ERROR);
10297: }
10298: return(ret);
10299: }
10300:
10301: /**
10302: * xmlXPathCompLiteral:
10303: * @ctxt: the XPath Parser context
10304: *
10305: * Parse a Literal and push it on the stack.
10306: *
10307: * [29] Literal ::= '"' [^"]* '"'
10308: * | "'" [^']* "'"
10309: *
10310: * TODO: xmlXPathCompLiteral memory allocation could be improved.
10311: */
10312: static void
10313: xmlXPathCompLiteral(xmlXPathParserContextPtr ctxt) {
10314: const xmlChar *q;
10315: xmlChar *ret = NULL;
10316:
10317: if (CUR == '"') {
10318: NEXT;
10319: q = CUR_PTR;
10320: while ((IS_CHAR_CH(CUR)) && (CUR != '"'))
10321: NEXT;
10322: if (!IS_CHAR_CH(CUR)) {
10323: XP_ERROR(XPATH_UNFINISHED_LITERAL_ERROR);
10324: } else {
10325: ret = xmlStrndup(q, CUR_PTR - q);
10326: NEXT;
10327: }
10328: } else if (CUR == '\'') {
10329: NEXT;
10330: q = CUR_PTR;
10331: while ((IS_CHAR_CH(CUR)) && (CUR != '\''))
10332: NEXT;
10333: if (!IS_CHAR_CH(CUR)) {
10334: XP_ERROR(XPATH_UNFINISHED_LITERAL_ERROR);
10335: } else {
10336: ret = xmlStrndup(q, CUR_PTR - q);
10337: NEXT;
10338: }
10339: } else {
10340: XP_ERROR(XPATH_START_LITERAL_ERROR);
10341: }
10342: if (ret == NULL) return;
10343: PUSH_LONG_EXPR(XPATH_OP_VALUE, XPATH_STRING, 0, 0,
10344: xmlXPathCacheNewString(ctxt->context, ret), NULL);
10345: xmlFree(ret);
10346: }
10347:
10348: /**
10349: * xmlXPathCompVariableReference:
10350: * @ctxt: the XPath Parser context
10351: *
10352: * Parse a VariableReference, evaluate it and push it on the stack.
10353: *
10354: * The variable bindings consist of a mapping from variable names
10355: * to variable values. The value of a variable is an object, which can be
10356: * of any of the types that are possible for the value of an expression,
10357: * and may also be of additional types not specified here.
10358: *
10359: * Early evaluation is possible since:
10360: * The variable bindings [...] used to evaluate a subexpression are
10361: * always the same as those used to evaluate the containing expression.
10362: *
10363: * [36] VariableReference ::= '$' QName
10364: */
10365: static void
10366: xmlXPathCompVariableReference(xmlXPathParserContextPtr ctxt) {
10367: xmlChar *name;
10368: xmlChar *prefix;
10369:
10370: SKIP_BLANKS;
10371: if (CUR != '$') {
10372: XP_ERROR(XPATH_VARIABLE_REF_ERROR);
10373: }
10374: NEXT;
10375: name = xmlXPathParseQName(ctxt, &prefix);
10376: if (name == NULL) {
10377: XP_ERROR(XPATH_VARIABLE_REF_ERROR);
10378: }
10379: ctxt->comp->last = -1;
10380: PUSH_LONG_EXPR(XPATH_OP_VARIABLE, 0, 0, 0,
10381: name, prefix);
10382: SKIP_BLANKS;
10383: if ((ctxt->context != NULL) && (ctxt->context->flags & XML_XPATH_NOVAR)) {
10384: XP_ERROR(XPATH_FORBID_VARIABLE_ERROR);
10385: }
10386: }
10387:
10388: /**
10389: * xmlXPathIsNodeType:
10390: * @name: a name string
10391: *
10392: * Is the name given a NodeType one.
10393: *
10394: * [38] NodeType ::= 'comment'
10395: * | 'text'
10396: * | 'processing-instruction'
10397: * | 'node'
10398: *
10399: * Returns 1 if true 0 otherwise
10400: */
10401: int
10402: xmlXPathIsNodeType(const xmlChar *name) {
10403: if (name == NULL)
10404: return(0);
10405:
10406: if (xmlStrEqual(name, BAD_CAST "node"))
10407: return(1);
10408: if (xmlStrEqual(name, BAD_CAST "text"))
10409: return(1);
10410: if (xmlStrEqual(name, BAD_CAST "comment"))
10411: return(1);
10412: if (xmlStrEqual(name, BAD_CAST "processing-instruction"))
10413: return(1);
10414: return(0);
10415: }
10416:
10417: /**
10418: * xmlXPathCompFunctionCall:
10419: * @ctxt: the XPath Parser context
10420: *
10421: * [16] FunctionCall ::= FunctionName '(' ( Argument ( ',' Argument)*)? ')'
10422: * [17] Argument ::= Expr
10423: *
10424: * Compile a function call, the evaluation of all arguments are
10425: * pushed on the stack
10426: */
10427: static void
10428: xmlXPathCompFunctionCall(xmlXPathParserContextPtr ctxt) {
10429: xmlChar *name;
10430: xmlChar *prefix;
10431: int nbargs = 0;
10432: int sort = 1;
10433:
10434: name = xmlXPathParseQName(ctxt, &prefix);
10435: if (name == NULL) {
10436: xmlFree(prefix);
10437: XP_ERROR(XPATH_EXPR_ERROR);
10438: }
10439: SKIP_BLANKS;
10440: #ifdef DEBUG_EXPR
10441: if (prefix == NULL)
10442: xmlGenericError(xmlGenericErrorContext, "Calling function %s\n",
10443: name);
10444: else
10445: xmlGenericError(xmlGenericErrorContext, "Calling function %s:%s\n",
10446: prefix, name);
10447: #endif
10448:
10449: if (CUR != '(') {
10450: XP_ERROR(XPATH_EXPR_ERROR);
10451: }
10452: NEXT;
10453: SKIP_BLANKS;
10454:
10455: /*
10456: * Optimization for count(): we don't need the node-set to be sorted.
10457: */
10458: if ((prefix == NULL) && (name[0] == 'c') &&
10459: xmlStrEqual(name, BAD_CAST "count"))
10460: {
10461: sort = 0;
10462: }
10463: ctxt->comp->last = -1;
10464: if (CUR != ')') {
10465: while (CUR != 0) {
10466: int op1 = ctxt->comp->last;
10467: ctxt->comp->last = -1;
10468: xmlXPathCompileExpr(ctxt, sort);
10469: if (ctxt->error != XPATH_EXPRESSION_OK) {
10470: xmlFree(name);
10471: xmlFree(prefix);
10472: return;
10473: }
10474: PUSH_BINARY_EXPR(XPATH_OP_ARG, op1, ctxt->comp->last, 0, 0);
10475: nbargs++;
10476: if (CUR == ')') break;
10477: if (CUR != ',') {
10478: XP_ERROR(XPATH_EXPR_ERROR);
10479: }
10480: NEXT;
10481: SKIP_BLANKS;
10482: }
10483: }
10484: PUSH_LONG_EXPR(XPATH_OP_FUNCTION, nbargs, 0, 0,
10485: name, prefix);
10486: NEXT;
10487: SKIP_BLANKS;
10488: }
10489:
10490: /**
10491: * xmlXPathCompPrimaryExpr:
10492: * @ctxt: the XPath Parser context
10493: *
10494: * [15] PrimaryExpr ::= VariableReference
10495: * | '(' Expr ')'
10496: * | Literal
10497: * | Number
10498: * | FunctionCall
10499: *
10500: * Compile a primary expression.
10501: */
10502: static void
10503: xmlXPathCompPrimaryExpr(xmlXPathParserContextPtr ctxt) {
10504: SKIP_BLANKS;
10505: if (CUR == '$') xmlXPathCompVariableReference(ctxt);
10506: else if (CUR == '(') {
10507: NEXT;
10508: SKIP_BLANKS;
10509: xmlXPathCompileExpr(ctxt, 1);
10510: CHECK_ERROR;
10511: if (CUR != ')') {
10512: XP_ERROR(XPATH_EXPR_ERROR);
10513: }
10514: NEXT;
10515: SKIP_BLANKS;
10516: } else if (IS_ASCII_DIGIT(CUR) || (CUR == '.' && IS_ASCII_DIGIT(NXT(1)))) {
10517: xmlXPathCompNumber(ctxt);
10518: } else if ((CUR == '\'') || (CUR == '"')) {
10519: xmlXPathCompLiteral(ctxt);
10520: } else {
10521: xmlXPathCompFunctionCall(ctxt);
10522: }
10523: SKIP_BLANKS;
10524: }
10525:
10526: /**
10527: * xmlXPathCompFilterExpr:
10528: * @ctxt: the XPath Parser context
10529: *
10530: * [20] FilterExpr ::= PrimaryExpr
10531: * | FilterExpr Predicate
10532: *
10533: * Compile a filter expression.
10534: * Square brackets are used to filter expressions in the same way that
10535: * they are used in location paths. It is an error if the expression to
10536: * be filtered does not evaluate to a node-set. The context node list
10537: * used for evaluating the expression in square brackets is the node-set
10538: * to be filtered listed in document order.
10539: */
10540:
10541: static void
10542: xmlXPathCompFilterExpr(xmlXPathParserContextPtr ctxt) {
10543: xmlXPathCompPrimaryExpr(ctxt);
10544: CHECK_ERROR;
10545: SKIP_BLANKS;
10546:
10547: while (CUR == '[') {
10548: xmlXPathCompPredicate(ctxt, 1);
10549: SKIP_BLANKS;
10550: }
10551:
10552:
10553: }
10554:
10555: /**
10556: * xmlXPathScanName:
10557: * @ctxt: the XPath Parser context
10558: *
10559: * Trickery: parse an XML name but without consuming the input flow
10560: * Needed to avoid insanity in the parser state.
10561: *
10562: * [4] NameChar ::= Letter | Digit | '.' | '-' | '_' | ':' |
10563: * CombiningChar | Extender
10564: *
10565: * [5] Name ::= (Letter | '_' | ':') (NameChar)*
10566: *
10567: * [6] Names ::= Name (S Name)*
10568: *
10569: * Returns the Name parsed or NULL
10570: */
10571:
10572: static xmlChar *
10573: xmlXPathScanName(xmlXPathParserContextPtr ctxt) {
10574: int len = 0, l;
10575: int c;
10576: const xmlChar *cur;
10577: xmlChar *ret;
10578:
10579: cur = ctxt->cur;
10580:
10581: c = CUR_CHAR(l);
10582: if ((c == ' ') || (c == '>') || (c == '/') || /* accelerators */
10583: (!IS_LETTER(c) && (c != '_') &&
10584: (c != ':'))) {
10585: return(NULL);
10586: }
10587:
10588: while ((c != ' ') && (c != '>') && (c != '/') && /* test bigname.xml */
10589: ((IS_LETTER(c)) || (IS_DIGIT(c)) ||
10590: (c == '.') || (c == '-') ||
10591: (c == '_') || (c == ':') ||
10592: (IS_COMBINING(c)) ||
10593: (IS_EXTENDER(c)))) {
10594: len += l;
10595: NEXTL(l);
10596: c = CUR_CHAR(l);
10597: }
10598: ret = xmlStrndup(cur, ctxt->cur - cur);
10599: ctxt->cur = cur;
10600: return(ret);
10601: }
10602:
10603: /**
10604: * xmlXPathCompPathExpr:
10605: * @ctxt: the XPath Parser context
10606: *
10607: * [19] PathExpr ::= LocationPath
10608: * | FilterExpr
10609: * | FilterExpr '/' RelativeLocationPath
10610: * | FilterExpr '//' RelativeLocationPath
10611: *
10612: * Compile a path expression.
10613: * The / operator and // operators combine an arbitrary expression
10614: * and a relative location path. It is an error if the expression
10615: * does not evaluate to a node-set.
10616: * The / operator does composition in the same way as when / is
10617: * used in a location path. As in location paths, // is short for
10618: * /descendant-or-self::node()/.
10619: */
10620:
10621: static void
10622: xmlXPathCompPathExpr(xmlXPathParserContextPtr ctxt) {
10623: int lc = 1; /* Should we branch to LocationPath ? */
10624: xmlChar *name = NULL; /* we may have to preparse a name to find out */
10625:
10626: SKIP_BLANKS;
10627: if ((CUR == '$') || (CUR == '(') ||
10628: (IS_ASCII_DIGIT(CUR)) ||
10629: (CUR == '\'') || (CUR == '"') ||
10630: (CUR == '.' && IS_ASCII_DIGIT(NXT(1)))) {
10631: lc = 0;
10632: } else if (CUR == '*') {
10633: /* relative or absolute location path */
10634: lc = 1;
10635: } else if (CUR == '/') {
10636: /* relative or absolute location path */
10637: lc = 1;
10638: } else if (CUR == '@') {
10639: /* relative abbreviated attribute location path */
10640: lc = 1;
10641: } else if (CUR == '.') {
10642: /* relative abbreviated attribute location path */
10643: lc = 1;
10644: } else {
10645: /*
10646: * Problem is finding if we have a name here whether it's:
10647: * - a nodetype
10648: * - a function call in which case it's followed by '('
10649: * - an axis in which case it's followed by ':'
10650: * - a element name
10651: * We do an a priori analysis here rather than having to
10652: * maintain parsed token content through the recursive function
10653: * calls. This looks uglier but makes the code easier to
10654: * read/write/debug.
10655: */
10656: SKIP_BLANKS;
10657: name = xmlXPathScanName(ctxt);
10658: if ((name != NULL) && (xmlStrstr(name, (xmlChar *) "::") != NULL)) {
10659: #ifdef DEBUG_STEP
10660: xmlGenericError(xmlGenericErrorContext,
10661: "PathExpr: Axis\n");
10662: #endif
10663: lc = 1;
10664: xmlFree(name);
10665: } else if (name != NULL) {
10666: int len =xmlStrlen(name);
10667:
10668:
10669: while (NXT(len) != 0) {
10670: if (NXT(len) == '/') {
10671: /* element name */
10672: #ifdef DEBUG_STEP
10673: xmlGenericError(xmlGenericErrorContext,
10674: "PathExpr: AbbrRelLocation\n");
10675: #endif
10676: lc = 1;
10677: break;
10678: } else if (IS_BLANK_CH(NXT(len))) {
10679: /* ignore blanks */
10680: ;
10681: } else if (NXT(len) == ':') {
10682: #ifdef DEBUG_STEP
10683: xmlGenericError(xmlGenericErrorContext,
10684: "PathExpr: AbbrRelLocation\n");
10685: #endif
10686: lc = 1;
10687: break;
10688: } else if ((NXT(len) == '(')) {
10689: /* Note Type or Function */
10690: if (xmlXPathIsNodeType(name)) {
10691: #ifdef DEBUG_STEP
10692: xmlGenericError(xmlGenericErrorContext,
10693: "PathExpr: Type search\n");
10694: #endif
10695: lc = 1;
10696: } else {
10697: #ifdef DEBUG_STEP
10698: xmlGenericError(xmlGenericErrorContext,
10699: "PathExpr: function call\n");
10700: #endif
10701: lc = 0;
10702: }
10703: break;
10704: } else if ((NXT(len) == '[')) {
10705: /* element name */
10706: #ifdef DEBUG_STEP
10707: xmlGenericError(xmlGenericErrorContext,
10708: "PathExpr: AbbrRelLocation\n");
10709: #endif
10710: lc = 1;
10711: break;
10712: } else if ((NXT(len) == '<') || (NXT(len) == '>') ||
10713: (NXT(len) == '=')) {
10714: lc = 1;
10715: break;
10716: } else {
10717: lc = 1;
10718: break;
10719: }
10720: len++;
10721: }
10722: if (NXT(len) == 0) {
10723: #ifdef DEBUG_STEP
10724: xmlGenericError(xmlGenericErrorContext,
10725: "PathExpr: AbbrRelLocation\n");
10726: #endif
10727: /* element name */
10728: lc = 1;
10729: }
10730: xmlFree(name);
10731: } else {
10732: /* make sure all cases are covered explicitly */
10733: XP_ERROR(XPATH_EXPR_ERROR);
10734: }
10735: }
10736:
10737: if (lc) {
10738: if (CUR == '/') {
10739: PUSH_LEAVE_EXPR(XPATH_OP_ROOT, 0, 0);
10740: } else {
10741: PUSH_LEAVE_EXPR(XPATH_OP_NODE, 0, 0);
10742: }
10743: xmlXPathCompLocationPath(ctxt);
10744: } else {
10745: xmlXPathCompFilterExpr(ctxt);
10746: CHECK_ERROR;
10747: if ((CUR == '/') && (NXT(1) == '/')) {
10748: SKIP(2);
10749: SKIP_BLANKS;
10750:
10751: PUSH_LONG_EXPR(XPATH_OP_COLLECT, AXIS_DESCENDANT_OR_SELF,
10752: NODE_TEST_TYPE, NODE_TYPE_NODE, NULL, NULL);
10753: PUSH_UNARY_EXPR(XPATH_OP_RESET, ctxt->comp->last, 1, 0);
10754:
10755: xmlXPathCompRelativeLocationPath(ctxt);
10756: } else if (CUR == '/') {
10757: xmlXPathCompRelativeLocationPath(ctxt);
10758: }
10759: }
10760: SKIP_BLANKS;
10761: }
10762:
10763: /**
10764: * xmlXPathCompUnionExpr:
10765: * @ctxt: the XPath Parser context
10766: *
10767: * [18] UnionExpr ::= PathExpr
10768: * | UnionExpr '|' PathExpr
10769: *
10770: * Compile an union expression.
10771: */
10772:
10773: static void
10774: xmlXPathCompUnionExpr(xmlXPathParserContextPtr ctxt) {
10775: xmlXPathCompPathExpr(ctxt);
10776: CHECK_ERROR;
10777: SKIP_BLANKS;
10778: while (CUR == '|') {
10779: int op1 = ctxt->comp->last;
10780: PUSH_LEAVE_EXPR(XPATH_OP_NODE, 0, 0);
10781:
10782: NEXT;
10783: SKIP_BLANKS;
10784: xmlXPathCompPathExpr(ctxt);
10785:
10786: PUSH_BINARY_EXPR(XPATH_OP_UNION, op1, ctxt->comp->last, 0, 0);
10787:
10788: SKIP_BLANKS;
10789: }
10790: }
10791:
10792: /**
10793: * xmlXPathCompUnaryExpr:
10794: * @ctxt: the XPath Parser context
10795: *
10796: * [27] UnaryExpr ::= UnionExpr
10797: * | '-' UnaryExpr
10798: *
10799: * Compile an unary expression.
10800: */
10801:
10802: static void
10803: xmlXPathCompUnaryExpr(xmlXPathParserContextPtr ctxt) {
10804: int minus = 0;
10805: int found = 0;
10806:
10807: SKIP_BLANKS;
10808: while (CUR == '-') {
10809: minus = 1 - minus;
10810: found = 1;
10811: NEXT;
10812: SKIP_BLANKS;
10813: }
10814:
10815: xmlXPathCompUnionExpr(ctxt);
10816: CHECK_ERROR;
10817: if (found) {
10818: if (minus)
10819: PUSH_UNARY_EXPR(XPATH_OP_PLUS, ctxt->comp->last, 2, 0);
10820: else
10821: PUSH_UNARY_EXPR(XPATH_OP_PLUS, ctxt->comp->last, 3, 0);
10822: }
10823: }
10824:
10825: /**
10826: * xmlXPathCompMultiplicativeExpr:
10827: * @ctxt: the XPath Parser context
10828: *
10829: * [26] MultiplicativeExpr ::= UnaryExpr
10830: * | MultiplicativeExpr MultiplyOperator UnaryExpr
10831: * | MultiplicativeExpr 'div' UnaryExpr
10832: * | MultiplicativeExpr 'mod' UnaryExpr
10833: * [34] MultiplyOperator ::= '*'
10834: *
10835: * Compile an Additive expression.
10836: */
10837:
10838: static void
10839: xmlXPathCompMultiplicativeExpr(xmlXPathParserContextPtr ctxt) {
10840: xmlXPathCompUnaryExpr(ctxt);
10841: CHECK_ERROR;
10842: SKIP_BLANKS;
10843: while ((CUR == '*') ||
10844: ((CUR == 'd') && (NXT(1) == 'i') && (NXT(2) == 'v')) ||
10845: ((CUR == 'm') && (NXT(1) == 'o') && (NXT(2) == 'd'))) {
10846: int op = -1;
10847: int op1 = ctxt->comp->last;
10848:
10849: if (CUR == '*') {
10850: op = 0;
10851: NEXT;
10852: } else if (CUR == 'd') {
10853: op = 1;
10854: SKIP(3);
10855: } else if (CUR == 'm') {
10856: op = 2;
10857: SKIP(3);
10858: }
10859: SKIP_BLANKS;
10860: xmlXPathCompUnaryExpr(ctxt);
10861: CHECK_ERROR;
10862: PUSH_BINARY_EXPR(XPATH_OP_MULT, op1, ctxt->comp->last, op, 0);
10863: SKIP_BLANKS;
10864: }
10865: }
10866:
10867: /**
10868: * xmlXPathCompAdditiveExpr:
10869: * @ctxt: the XPath Parser context
10870: *
10871: * [25] AdditiveExpr ::= MultiplicativeExpr
10872: * | AdditiveExpr '+' MultiplicativeExpr
10873: * | AdditiveExpr '-' MultiplicativeExpr
10874: *
10875: * Compile an Additive expression.
10876: */
10877:
10878: static void
10879: xmlXPathCompAdditiveExpr(xmlXPathParserContextPtr ctxt) {
10880:
10881: xmlXPathCompMultiplicativeExpr(ctxt);
10882: CHECK_ERROR;
10883: SKIP_BLANKS;
10884: while ((CUR == '+') || (CUR == '-')) {
10885: int plus;
10886: int op1 = ctxt->comp->last;
10887:
10888: if (CUR == '+') plus = 1;
10889: else plus = 0;
10890: NEXT;
10891: SKIP_BLANKS;
10892: xmlXPathCompMultiplicativeExpr(ctxt);
10893: CHECK_ERROR;
10894: PUSH_BINARY_EXPR(XPATH_OP_PLUS, op1, ctxt->comp->last, plus, 0);
10895: SKIP_BLANKS;
10896: }
10897: }
10898:
10899: /**
10900: * xmlXPathCompRelationalExpr:
10901: * @ctxt: the XPath Parser context
10902: *
10903: * [24] RelationalExpr ::= AdditiveExpr
10904: * | RelationalExpr '<' AdditiveExpr
10905: * | RelationalExpr '>' AdditiveExpr
10906: * | RelationalExpr '<=' AdditiveExpr
10907: * | RelationalExpr '>=' AdditiveExpr
10908: *
10909: * A <= B > C is allowed ? Answer from James, yes with
10910: * (AdditiveExpr <= AdditiveExpr) > AdditiveExpr
10911: * which is basically what got implemented.
10912: *
10913: * Compile a Relational expression, then push the result
10914: * on the stack
10915: */
10916:
10917: static void
10918: xmlXPathCompRelationalExpr(xmlXPathParserContextPtr ctxt) {
10919: xmlXPathCompAdditiveExpr(ctxt);
10920: CHECK_ERROR;
10921: SKIP_BLANKS;
10922: while ((CUR == '<') ||
10923: (CUR == '>') ||
10924: ((CUR == '<') && (NXT(1) == '=')) ||
10925: ((CUR == '>') && (NXT(1) == '='))) {
10926: int inf, strict;
10927: int op1 = ctxt->comp->last;
10928:
10929: if (CUR == '<') inf = 1;
10930: else inf = 0;
10931: if (NXT(1) == '=') strict = 0;
10932: else strict = 1;
10933: NEXT;
10934: if (!strict) NEXT;
10935: SKIP_BLANKS;
10936: xmlXPathCompAdditiveExpr(ctxt);
10937: CHECK_ERROR;
10938: PUSH_BINARY_EXPR(XPATH_OP_CMP, op1, ctxt->comp->last, inf, strict);
10939: SKIP_BLANKS;
10940: }
10941: }
10942:
10943: /**
10944: * xmlXPathCompEqualityExpr:
10945: * @ctxt: the XPath Parser context
10946: *
10947: * [23] EqualityExpr ::= RelationalExpr
10948: * | EqualityExpr '=' RelationalExpr
10949: * | EqualityExpr '!=' RelationalExpr
10950: *
10951: * A != B != C is allowed ? Answer from James, yes with
10952: * (RelationalExpr = RelationalExpr) = RelationalExpr
10953: * (RelationalExpr != RelationalExpr) != RelationalExpr
10954: * which is basically what got implemented.
10955: *
10956: * Compile an Equality expression.
10957: *
10958: */
10959: static void
10960: xmlXPathCompEqualityExpr(xmlXPathParserContextPtr ctxt) {
10961: xmlXPathCompRelationalExpr(ctxt);
10962: CHECK_ERROR;
10963: SKIP_BLANKS;
10964: while ((CUR == '=') || ((CUR == '!') && (NXT(1) == '='))) {
10965: int eq;
10966: int op1 = ctxt->comp->last;
10967:
10968: if (CUR == '=') eq = 1;
10969: else eq = 0;
10970: NEXT;
10971: if (!eq) NEXT;
10972: SKIP_BLANKS;
10973: xmlXPathCompRelationalExpr(ctxt);
10974: CHECK_ERROR;
10975: PUSH_BINARY_EXPR(XPATH_OP_EQUAL, op1, ctxt->comp->last, eq, 0);
10976: SKIP_BLANKS;
10977: }
10978: }
10979:
10980: /**
10981: * xmlXPathCompAndExpr:
10982: * @ctxt: the XPath Parser context
10983: *
10984: * [22] AndExpr ::= EqualityExpr
10985: * | AndExpr 'and' EqualityExpr
10986: *
10987: * Compile an AND expression.
10988: *
10989: */
10990: static void
10991: xmlXPathCompAndExpr(xmlXPathParserContextPtr ctxt) {
10992: xmlXPathCompEqualityExpr(ctxt);
10993: CHECK_ERROR;
10994: SKIP_BLANKS;
10995: while ((CUR == 'a') && (NXT(1) == 'n') && (NXT(2) == 'd')) {
10996: int op1 = ctxt->comp->last;
10997: SKIP(3);
10998: SKIP_BLANKS;
10999: xmlXPathCompEqualityExpr(ctxt);
11000: CHECK_ERROR;
11001: PUSH_BINARY_EXPR(XPATH_OP_AND, op1, ctxt->comp->last, 0, 0);
11002: SKIP_BLANKS;
11003: }
11004: }
11005:
11006: /**
11007: * xmlXPathCompileExpr:
11008: * @ctxt: the XPath Parser context
11009: *
11010: * [14] Expr ::= OrExpr
11011: * [21] OrExpr ::= AndExpr
11012: * | OrExpr 'or' AndExpr
11013: *
11014: * Parse and compile an expression
11015: */
11016: static void
11017: xmlXPathCompileExpr(xmlXPathParserContextPtr ctxt, int sort) {
11018: xmlXPathCompAndExpr(ctxt);
11019: CHECK_ERROR;
11020: SKIP_BLANKS;
11021: while ((CUR == 'o') && (NXT(1) == 'r')) {
11022: int op1 = ctxt->comp->last;
11023: SKIP(2);
11024: SKIP_BLANKS;
11025: xmlXPathCompAndExpr(ctxt);
11026: CHECK_ERROR;
11027: PUSH_BINARY_EXPR(XPATH_OP_OR, op1, ctxt->comp->last, 0, 0);
11028: SKIP_BLANKS;
11029: }
11030: if ((sort) && (ctxt->comp->steps[ctxt->comp->last].op != XPATH_OP_VALUE)) {
11031: /* more ops could be optimized too */
11032: /*
11033: * This is the main place to eliminate sorting for
11034: * operations which don't require a sorted node-set.
11035: * E.g. count().
11036: */
11037: PUSH_UNARY_EXPR(XPATH_OP_SORT, ctxt->comp->last , 0, 0);
11038: }
11039: }
11040:
11041: /**
11042: * xmlXPathCompPredicate:
11043: * @ctxt: the XPath Parser context
11044: * @filter: act as a filter
11045: *
11046: * [8] Predicate ::= '[' PredicateExpr ']'
11047: * [9] PredicateExpr ::= Expr
11048: *
11049: * Compile a predicate expression
11050: */
11051: static void
11052: xmlXPathCompPredicate(xmlXPathParserContextPtr ctxt, int filter) {
11053: int op1 = ctxt->comp->last;
11054:
11055: SKIP_BLANKS;
11056: if (CUR != '[') {
11057: XP_ERROR(XPATH_INVALID_PREDICATE_ERROR);
11058: }
11059: NEXT;
11060: SKIP_BLANKS;
11061:
11062: ctxt->comp->last = -1;
11063: /*
11064: * This call to xmlXPathCompileExpr() will deactivate sorting
11065: * of the predicate result.
11066: * TODO: Sorting is still activated for filters, since I'm not
11067: * sure if needed. Normally sorting should not be needed, since
11068: * a filter can only diminish the number of items in a sequence,
11069: * but won't change its order; so if the initial sequence is sorted,
11070: * subsequent sorting is not needed.
11071: */
11072: if (! filter)
11073: xmlXPathCompileExpr(ctxt, 0);
11074: else
11075: xmlXPathCompileExpr(ctxt, 1);
11076: CHECK_ERROR;
11077:
11078: if (CUR != ']') {
11079: XP_ERROR(XPATH_INVALID_PREDICATE_ERROR);
11080: }
11081:
11082: if (filter)
11083: PUSH_BINARY_EXPR(XPATH_OP_FILTER, op1, ctxt->comp->last, 0, 0);
11084: else
11085: PUSH_BINARY_EXPR(XPATH_OP_PREDICATE, op1, ctxt->comp->last, 0, 0);
11086:
11087: NEXT;
11088: SKIP_BLANKS;
11089: }
11090:
11091: /**
11092: * xmlXPathCompNodeTest:
11093: * @ctxt: the XPath Parser context
11094: * @test: pointer to a xmlXPathTestVal
11095: * @type: pointer to a xmlXPathTypeVal
11096: * @prefix: placeholder for a possible name prefix
11097: *
11098: * [7] NodeTest ::= NameTest
11099: * | NodeType '(' ')'
11100: * | 'processing-instruction' '(' Literal ')'
11101: *
11102: * [37] NameTest ::= '*'
11103: * | NCName ':' '*'
11104: * | QName
11105: * [38] NodeType ::= 'comment'
11106: * | 'text'
11107: * | 'processing-instruction'
11108: * | 'node'
11109: *
11110: * Returns the name found and updates @test, @type and @prefix appropriately
11111: */
11112: static xmlChar *
11113: xmlXPathCompNodeTest(xmlXPathParserContextPtr ctxt, xmlXPathTestVal *test,
11114: xmlXPathTypeVal *type, const xmlChar **prefix,
11115: xmlChar *name) {
11116: int blanks;
11117:
11118: if ((test == NULL) || (type == NULL) || (prefix == NULL)) {
11119: STRANGE;
11120: return(NULL);
11121: }
11122: *type = (xmlXPathTypeVal) 0;
11123: *test = (xmlXPathTestVal) 0;
11124: *prefix = NULL;
11125: SKIP_BLANKS;
11126:
11127: if ((name == NULL) && (CUR == '*')) {
11128: /*
11129: * All elements
11130: */
11131: NEXT;
11132: *test = NODE_TEST_ALL;
11133: return(NULL);
11134: }
11135:
11136: if (name == NULL)
11137: name = xmlXPathParseNCName(ctxt);
11138: if (name == NULL) {
11139: XP_ERRORNULL(XPATH_EXPR_ERROR);
11140: }
11141:
11142: blanks = IS_BLANK_CH(CUR);
11143: SKIP_BLANKS;
11144: if (CUR == '(') {
11145: NEXT;
11146: /*
11147: * NodeType or PI search
11148: */
11149: if (xmlStrEqual(name, BAD_CAST "comment"))
11150: *type = NODE_TYPE_COMMENT;
11151: else if (xmlStrEqual(name, BAD_CAST "node"))
11152: *type = NODE_TYPE_NODE;
11153: else if (xmlStrEqual(name, BAD_CAST "processing-instruction"))
11154: *type = NODE_TYPE_PI;
11155: else if (xmlStrEqual(name, BAD_CAST "text"))
11156: *type = NODE_TYPE_TEXT;
11157: else {
11158: if (name != NULL)
11159: xmlFree(name);
11160: XP_ERRORNULL(XPATH_EXPR_ERROR);
11161: }
11162:
11163: *test = NODE_TEST_TYPE;
11164:
11165: SKIP_BLANKS;
11166: if (*type == NODE_TYPE_PI) {
11167: /*
11168: * Specific case: search a PI by name.
11169: */
11170: if (name != NULL)
11171: xmlFree(name);
11172: name = NULL;
11173: if (CUR != ')') {
11174: name = xmlXPathParseLiteral(ctxt);
11175: CHECK_ERROR NULL;
11176: *test = NODE_TEST_PI;
11177: SKIP_BLANKS;
11178: }
11179: }
11180: if (CUR != ')') {
11181: if (name != NULL)
11182: xmlFree(name);
11183: XP_ERRORNULL(XPATH_UNCLOSED_ERROR);
11184: }
11185: NEXT;
11186: return(name);
11187: }
11188: *test = NODE_TEST_NAME;
11189: if ((!blanks) && (CUR == ':')) {
11190: NEXT;
11191:
11192: /*
11193: * Since currently the parser context don't have a
11194: * namespace list associated:
11195: * The namespace name for this prefix can be computed
11196: * only at evaluation time. The compilation is done
11197: * outside of any context.
11198: */
11199: #if 0
11200: *prefix = xmlXPathNsLookup(ctxt->context, name);
11201: if (name != NULL)
11202: xmlFree(name);
11203: if (*prefix == NULL) {
11204: XP_ERROR0(XPATH_UNDEF_PREFIX_ERROR);
11205: }
11206: #else
11207: *prefix = name;
11208: #endif
11209:
11210: if (CUR == '*') {
11211: /*
11212: * All elements
11213: */
11214: NEXT;
11215: *test = NODE_TEST_ALL;
11216: return(NULL);
11217: }
11218:
11219: name = xmlXPathParseNCName(ctxt);
11220: if (name == NULL) {
11221: XP_ERRORNULL(XPATH_EXPR_ERROR);
11222: }
11223: }
11224: return(name);
11225: }
11226:
11227: /**
11228: * xmlXPathIsAxisName:
11229: * @name: a preparsed name token
11230: *
11231: * [6] AxisName ::= 'ancestor'
11232: * | 'ancestor-or-self'
11233: * | 'attribute'
11234: * | 'child'
11235: * | 'descendant'
11236: * | 'descendant-or-self'
11237: * | 'following'
11238: * | 'following-sibling'
11239: * | 'namespace'
11240: * | 'parent'
11241: * | 'preceding'
11242: * | 'preceding-sibling'
11243: * | 'self'
11244: *
11245: * Returns the axis or 0
11246: */
11247: static xmlXPathAxisVal
11248: xmlXPathIsAxisName(const xmlChar *name) {
11249: xmlXPathAxisVal ret = (xmlXPathAxisVal) 0;
11250: switch (name[0]) {
11251: case 'a':
11252: if (xmlStrEqual(name, BAD_CAST "ancestor"))
11253: ret = AXIS_ANCESTOR;
11254: if (xmlStrEqual(name, BAD_CAST "ancestor-or-self"))
11255: ret = AXIS_ANCESTOR_OR_SELF;
11256: if (xmlStrEqual(name, BAD_CAST "attribute"))
11257: ret = AXIS_ATTRIBUTE;
11258: break;
11259: case 'c':
11260: if (xmlStrEqual(name, BAD_CAST "child"))
11261: ret = AXIS_CHILD;
11262: break;
11263: case 'd':
11264: if (xmlStrEqual(name, BAD_CAST "descendant"))
11265: ret = AXIS_DESCENDANT;
11266: if (xmlStrEqual(name, BAD_CAST "descendant-or-self"))
11267: ret = AXIS_DESCENDANT_OR_SELF;
11268: break;
11269: case 'f':
11270: if (xmlStrEqual(name, BAD_CAST "following"))
11271: ret = AXIS_FOLLOWING;
11272: if (xmlStrEqual(name, BAD_CAST "following-sibling"))
11273: ret = AXIS_FOLLOWING_SIBLING;
11274: break;
11275: case 'n':
11276: if (xmlStrEqual(name, BAD_CAST "namespace"))
11277: ret = AXIS_NAMESPACE;
11278: break;
11279: case 'p':
11280: if (xmlStrEqual(name, BAD_CAST "parent"))
11281: ret = AXIS_PARENT;
11282: if (xmlStrEqual(name, BAD_CAST "preceding"))
11283: ret = AXIS_PRECEDING;
11284: if (xmlStrEqual(name, BAD_CAST "preceding-sibling"))
11285: ret = AXIS_PRECEDING_SIBLING;
11286: break;
11287: case 's':
11288: if (xmlStrEqual(name, BAD_CAST "self"))
11289: ret = AXIS_SELF;
11290: break;
11291: }
11292: return(ret);
11293: }
11294:
11295: /**
11296: * xmlXPathCompStep:
11297: * @ctxt: the XPath Parser context
11298: *
11299: * [4] Step ::= AxisSpecifier NodeTest Predicate*
11300: * | AbbreviatedStep
11301: *
11302: * [12] AbbreviatedStep ::= '.' | '..'
11303: *
11304: * [5] AxisSpecifier ::= AxisName '::'
11305: * | AbbreviatedAxisSpecifier
11306: *
11307: * [13] AbbreviatedAxisSpecifier ::= '@'?
11308: *
11309: * Modified for XPtr range support as:
11310: *
11311: * [4xptr] Step ::= AxisSpecifier NodeTest Predicate*
11312: * | AbbreviatedStep
11313: * | 'range-to' '(' Expr ')' Predicate*
11314: *
11315: * Compile one step in a Location Path
11316: * A location step of . is short for self::node(). This is
11317: * particularly useful in conjunction with //. For example, the
11318: * location path .//para is short for
11319: * self::node()/descendant-or-self::node()/child::para
11320: * and so will select all para descendant elements of the context
11321: * node.
11322: * Similarly, a location step of .. is short for parent::node().
11323: * For example, ../title is short for parent::node()/child::title
11324: * and so will select the title children of the parent of the context
11325: * node.
11326: */
11327: static void
11328: xmlXPathCompStep(xmlXPathParserContextPtr ctxt) {
11329: #ifdef LIBXML_XPTR_ENABLED
11330: int rangeto = 0;
11331: int op2 = -1;
11332: #endif
11333:
11334: SKIP_BLANKS;
11335: if ((CUR == '.') && (NXT(1) == '.')) {
11336: SKIP(2);
11337: SKIP_BLANKS;
11338: PUSH_LONG_EXPR(XPATH_OP_COLLECT, AXIS_PARENT,
11339: NODE_TEST_TYPE, NODE_TYPE_NODE, NULL, NULL);
11340: } else if (CUR == '.') {
11341: NEXT;
11342: SKIP_BLANKS;
11343: } else {
11344: xmlChar *name = NULL;
11345: const xmlChar *prefix = NULL;
11346: xmlXPathTestVal test = (xmlXPathTestVal) 0;
11347: xmlXPathAxisVal axis = (xmlXPathAxisVal) 0;
11348: xmlXPathTypeVal type = (xmlXPathTypeVal) 0;
11349: int op1;
11350:
11351: /*
11352: * The modification needed for XPointer change to the production
11353: */
11354: #ifdef LIBXML_XPTR_ENABLED
11355: if (ctxt->xptr) {
11356: name = xmlXPathParseNCName(ctxt);
11357: if ((name != NULL) && (xmlStrEqual(name, BAD_CAST "range-to"))) {
11358: op2 = ctxt->comp->last;
11359: xmlFree(name);
11360: SKIP_BLANKS;
11361: if (CUR != '(') {
11362: XP_ERROR(XPATH_EXPR_ERROR);
11363: }
11364: NEXT;
11365: SKIP_BLANKS;
11366:
11367: xmlXPathCompileExpr(ctxt, 1);
11368: /* PUSH_BINARY_EXPR(XPATH_OP_RANGETO, op2, ctxt->comp->last, 0, 0); */
11369: CHECK_ERROR;
11370:
11371: SKIP_BLANKS;
11372: if (CUR != ')') {
11373: XP_ERROR(XPATH_EXPR_ERROR);
11374: }
11375: NEXT;
11376: rangeto = 1;
11377: goto eval_predicates;
11378: }
11379: }
11380: #endif
11381: if (CUR == '*') {
11382: axis = AXIS_CHILD;
11383: } else {
11384: if (name == NULL)
11385: name = xmlXPathParseNCName(ctxt);
11386: if (name != NULL) {
11387: axis = xmlXPathIsAxisName(name);
11388: if (axis != 0) {
11389: SKIP_BLANKS;
11390: if ((CUR == ':') && (NXT(1) == ':')) {
11391: SKIP(2);
11392: xmlFree(name);
11393: name = NULL;
11394: } else {
11395: /* an element name can conflict with an axis one :-\ */
11396: axis = AXIS_CHILD;
11397: }
11398: } else {
11399: axis = AXIS_CHILD;
11400: }
11401: } else if (CUR == '@') {
11402: NEXT;
11403: axis = AXIS_ATTRIBUTE;
11404: } else {
11405: axis = AXIS_CHILD;
11406: }
11407: }
11408:
11409: if (ctxt->error != XPATH_EXPRESSION_OK) {
11410: xmlFree(name);
11411: return;
11412: }
11413:
11414: name = xmlXPathCompNodeTest(ctxt, &test, &type, &prefix, name);
11415: if (test == 0)
11416: return;
11417:
11418: if ((prefix != NULL) && (ctxt->context != NULL) &&
11419: (ctxt->context->flags & XML_XPATH_CHECKNS)) {
11420: if (xmlXPathNsLookup(ctxt->context, prefix) == NULL) {
11421: xmlXPathErr(ctxt, XPATH_UNDEF_PREFIX_ERROR);
11422: }
11423: }
11424: #ifdef DEBUG_STEP
11425: xmlGenericError(xmlGenericErrorContext,
11426: "Basis : computing new set\n");
11427: #endif
11428:
11429: #ifdef DEBUG_STEP
11430: xmlGenericError(xmlGenericErrorContext, "Basis : ");
11431: if (ctxt->value == NULL)
11432: xmlGenericError(xmlGenericErrorContext, "no value\n");
11433: else if (ctxt->value->nodesetval == NULL)
11434: xmlGenericError(xmlGenericErrorContext, "Empty\n");
11435: else
11436: xmlGenericErrorContextNodeSet(stdout, ctxt->value->nodesetval);
11437: #endif
11438:
11439: #ifdef LIBXML_XPTR_ENABLED
11440: eval_predicates:
11441: #endif
11442: op1 = ctxt->comp->last;
11443: ctxt->comp->last = -1;
11444:
11445: SKIP_BLANKS;
11446: while (CUR == '[') {
11447: xmlXPathCompPredicate(ctxt, 0);
11448: }
11449:
11450: #ifdef LIBXML_XPTR_ENABLED
11451: if (rangeto) {
11452: PUSH_BINARY_EXPR(XPATH_OP_RANGETO, op2, op1, 0, 0);
11453: } else
11454: #endif
11455: PUSH_FULL_EXPR(XPATH_OP_COLLECT, op1, ctxt->comp->last, axis,
11456: test, type, (void *)prefix, (void *)name);
11457:
11458: }
11459: #ifdef DEBUG_STEP
11460: xmlGenericError(xmlGenericErrorContext, "Step : ");
11461: if (ctxt->value == NULL)
11462: xmlGenericError(xmlGenericErrorContext, "no value\n");
11463: else if (ctxt->value->nodesetval == NULL)
11464: xmlGenericError(xmlGenericErrorContext, "Empty\n");
11465: else
11466: xmlGenericErrorContextNodeSet(xmlGenericErrorContext,
11467: ctxt->value->nodesetval);
11468: #endif
11469: }
11470:
11471: /**
11472: * xmlXPathCompRelativeLocationPath:
11473: * @ctxt: the XPath Parser context
11474: *
11475: * [3] RelativeLocationPath ::= Step
11476: * | RelativeLocationPath '/' Step
11477: * | AbbreviatedRelativeLocationPath
11478: * [11] AbbreviatedRelativeLocationPath ::= RelativeLocationPath '//' Step
11479: *
11480: * Compile a relative location path.
11481: */
11482: static void
11483: xmlXPathCompRelativeLocationPath
11484: (xmlXPathParserContextPtr ctxt) {
11485: SKIP_BLANKS;
11486: if ((CUR == '/') && (NXT(1) == '/')) {
11487: SKIP(2);
11488: SKIP_BLANKS;
11489: PUSH_LONG_EXPR(XPATH_OP_COLLECT, AXIS_DESCENDANT_OR_SELF,
11490: NODE_TEST_TYPE, NODE_TYPE_NODE, NULL, NULL);
11491: } else if (CUR == '/') {
11492: NEXT;
11493: SKIP_BLANKS;
11494: }
11495: xmlXPathCompStep(ctxt);
11496: CHECK_ERROR;
11497: SKIP_BLANKS;
11498: while (CUR == '/') {
11499: if ((CUR == '/') && (NXT(1) == '/')) {
11500: SKIP(2);
11501: SKIP_BLANKS;
11502: PUSH_LONG_EXPR(XPATH_OP_COLLECT, AXIS_DESCENDANT_OR_SELF,
11503: NODE_TEST_TYPE, NODE_TYPE_NODE, NULL, NULL);
11504: xmlXPathCompStep(ctxt);
11505: } else if (CUR == '/') {
11506: NEXT;
11507: SKIP_BLANKS;
11508: xmlXPathCompStep(ctxt);
11509: }
11510: SKIP_BLANKS;
11511: }
11512: }
11513:
11514: /**
11515: * xmlXPathCompLocationPath:
11516: * @ctxt: the XPath Parser context
11517: *
11518: * [1] LocationPath ::= RelativeLocationPath
11519: * | AbsoluteLocationPath
11520: * [2] AbsoluteLocationPath ::= '/' RelativeLocationPath?
11521: * | AbbreviatedAbsoluteLocationPath
11522: * [10] AbbreviatedAbsoluteLocationPath ::=
11523: * '//' RelativeLocationPath
11524: *
11525: * Compile a location path
11526: *
11527: * // is short for /descendant-or-self::node()/. For example,
11528: * //para is short for /descendant-or-self::node()/child::para and
11529: * so will select any para element in the document (even a para element
11530: * that is a document element will be selected by //para since the
11531: * document element node is a child of the root node); div//para is
11532: * short for div/descendant-or-self::node()/child::para and so will
11533: * select all para descendants of div children.
11534: */
11535: static void
11536: xmlXPathCompLocationPath(xmlXPathParserContextPtr ctxt) {
11537: SKIP_BLANKS;
11538: if (CUR != '/') {
11539: xmlXPathCompRelativeLocationPath(ctxt);
11540: } else {
11541: while (CUR == '/') {
11542: if ((CUR == '/') && (NXT(1) == '/')) {
11543: SKIP(2);
11544: SKIP_BLANKS;
11545: PUSH_LONG_EXPR(XPATH_OP_COLLECT, AXIS_DESCENDANT_OR_SELF,
11546: NODE_TEST_TYPE, NODE_TYPE_NODE, NULL, NULL);
11547: xmlXPathCompRelativeLocationPath(ctxt);
11548: } else if (CUR == '/') {
11549: NEXT;
11550: SKIP_BLANKS;
11551: if ((CUR != 0 ) &&
11552: ((IS_ASCII_LETTER(CUR)) || (CUR == '_') || (CUR == '.') ||
11553: (CUR == '@') || (CUR == '*')))
11554: xmlXPathCompRelativeLocationPath(ctxt);
11555: }
11556: CHECK_ERROR;
11557: }
11558: }
11559: }
11560:
11561: /************************************************************************
11562: * *
11563: * XPath precompiled expression evaluation *
11564: * *
11565: ************************************************************************/
11566:
11567: static int
11568: xmlXPathCompOpEval(xmlXPathParserContextPtr ctxt, xmlXPathStepOpPtr op);
11569:
11570: #ifdef DEBUG_STEP
11571: static void
11572: xmlXPathDebugDumpStepAxis(xmlXPathStepOpPtr op,
11573: int nbNodes)
11574: {
11575: xmlGenericError(xmlGenericErrorContext, "new step : ");
11576: switch (op->value) {
11577: case AXIS_ANCESTOR:
11578: xmlGenericError(xmlGenericErrorContext, "axis 'ancestors' ");
11579: break;
11580: case AXIS_ANCESTOR_OR_SELF:
11581: xmlGenericError(xmlGenericErrorContext,
11582: "axis 'ancestors-or-self' ");
11583: break;
11584: case AXIS_ATTRIBUTE:
11585: xmlGenericError(xmlGenericErrorContext, "axis 'attributes' ");
11586: break;
11587: case AXIS_CHILD:
11588: xmlGenericError(xmlGenericErrorContext, "axis 'child' ");
11589: break;
11590: case AXIS_DESCENDANT:
11591: xmlGenericError(xmlGenericErrorContext, "axis 'descendant' ");
11592: break;
11593: case AXIS_DESCENDANT_OR_SELF:
11594: xmlGenericError(xmlGenericErrorContext,
11595: "axis 'descendant-or-self' ");
11596: break;
11597: case AXIS_FOLLOWING:
11598: xmlGenericError(xmlGenericErrorContext, "axis 'following' ");
11599: break;
11600: case AXIS_FOLLOWING_SIBLING:
11601: xmlGenericError(xmlGenericErrorContext,
11602: "axis 'following-siblings' ");
11603: break;
11604: case AXIS_NAMESPACE:
11605: xmlGenericError(xmlGenericErrorContext, "axis 'namespace' ");
11606: break;
11607: case AXIS_PARENT:
11608: xmlGenericError(xmlGenericErrorContext, "axis 'parent' ");
11609: break;
11610: case AXIS_PRECEDING:
11611: xmlGenericError(xmlGenericErrorContext, "axis 'preceding' ");
11612: break;
11613: case AXIS_PRECEDING_SIBLING:
11614: xmlGenericError(xmlGenericErrorContext,
11615: "axis 'preceding-sibling' ");
11616: break;
11617: case AXIS_SELF:
11618: xmlGenericError(xmlGenericErrorContext, "axis 'self' ");
11619: break;
11620: }
11621: xmlGenericError(xmlGenericErrorContext,
11622: " context contains %d nodes\n", nbNodes);
11623: switch (op->value2) {
11624: case NODE_TEST_NONE:
11625: xmlGenericError(xmlGenericErrorContext,
11626: " searching for none !!!\n");
11627: break;
11628: case NODE_TEST_TYPE:
11629: xmlGenericError(xmlGenericErrorContext,
11630: " searching for type %d\n", op->value3);
11631: break;
11632: case NODE_TEST_PI:
11633: xmlGenericError(xmlGenericErrorContext,
11634: " searching for PI !!!\n");
11635: break;
11636: case NODE_TEST_ALL:
11637: xmlGenericError(xmlGenericErrorContext,
11638: " searching for *\n");
11639: break;
11640: case NODE_TEST_NS:
11641: xmlGenericError(xmlGenericErrorContext,
11642: " searching for namespace %s\n",
11643: op->value5);
11644: break;
11645: case NODE_TEST_NAME:
11646: xmlGenericError(xmlGenericErrorContext,
11647: " searching for name %s\n", op->value5);
11648: if (op->value4)
11649: xmlGenericError(xmlGenericErrorContext,
11650: " with namespace %s\n", op->value4);
11651: break;
11652: }
11653: xmlGenericError(xmlGenericErrorContext, "Testing : ");
11654: }
11655: #endif /* DEBUG_STEP */
11656:
11657: static int
11658: xmlXPathCompOpEvalPredicate(xmlXPathParserContextPtr ctxt,
11659: xmlXPathStepOpPtr op,
11660: xmlNodeSetPtr set,
11661: int contextSize,
11662: int hasNsNodes)
11663: {
11664: if (op->ch1 != -1) {
11665: xmlXPathCompExprPtr comp = ctxt->comp;
11666: /*
11667: * Process inner predicates first.
11668: */
11669: if (comp->steps[op->ch1].op != XPATH_OP_PREDICATE) {
11670: /*
11671: * TODO: raise an internal error.
11672: */
11673: }
11674: contextSize = xmlXPathCompOpEvalPredicate(ctxt,
11675: &comp->steps[op->ch1], set, contextSize, hasNsNodes);
11676: CHECK_ERROR0;
11677: if (contextSize <= 0)
11678: return(0);
11679: }
11680: if (op->ch2 != -1) {
11681: xmlXPathContextPtr xpctxt = ctxt->context;
11682: xmlNodePtr contextNode, oldContextNode;
11683: xmlDocPtr oldContextDoc;
11684: int i, res, contextPos = 0, newContextSize;
11685: xmlXPathStepOpPtr exprOp;
11686: xmlXPathObjectPtr contextObj = NULL, exprRes = NULL;
11687:
11688: #ifdef LIBXML_XPTR_ENABLED
11689: /*
11690: * URGENT TODO: Check the following:
11691: * We don't expect location sets if evaluating prediates, right?
11692: * Only filters should expect location sets, right?
11693: */
11694: #endif
11695: /*
11696: * SPEC XPath 1.0:
11697: * "For each node in the node-set to be filtered, the
11698: * PredicateExpr is evaluated with that node as the
11699: * context node, with the number of nodes in the
11700: * node-set as the context size, and with the proximity
11701: * position of the node in the node-set with respect to
11702: * the axis as the context position;"
11703: * @oldset is the node-set" to be filtered.
11704: *
11705: * SPEC XPath 1.0:
11706: * "only predicates change the context position and
11707: * context size (see [2.4 Predicates])."
11708: * Example:
11709: * node-set context pos
11710: * nA 1
11711: * nB 2
11712: * nC 3
11713: * After applying predicate [position() > 1] :
11714: * node-set context pos
11715: * nB 1
11716: * nC 2
11717: */
11718: oldContextNode = xpctxt->node;
11719: oldContextDoc = xpctxt->doc;
11720: /*
11721: * Get the expression of this predicate.
11722: */
11723: exprOp = &ctxt->comp->steps[op->ch2];
11724: newContextSize = 0;
11725: for (i = 0; i < set->nodeNr; i++) {
11726: if (set->nodeTab[i] == NULL)
11727: continue;
11728:
11729: contextNode = set->nodeTab[i];
11730: xpctxt->node = contextNode;
11731: xpctxt->contextSize = contextSize;
11732: xpctxt->proximityPosition = ++contextPos;
11733:
11734: /*
11735: * Also set the xpath document in case things like
11736: * key() are evaluated in the predicate.
11737: */
11738: if ((contextNode->type != XML_NAMESPACE_DECL) &&
11739: (contextNode->doc != NULL))
11740: xpctxt->doc = contextNode->doc;
11741: /*
11742: * Evaluate the predicate expression with 1 context node
11743: * at a time; this node is packaged into a node set; this
11744: * node set is handed over to the evaluation mechanism.
11745: */
11746: if (contextObj == NULL)
11747: contextObj = xmlXPathCacheNewNodeSet(xpctxt, contextNode);
11748: else {
11749: if (xmlXPathNodeSetAddUnique(contextObj->nodesetval,
11750: contextNode) < 0) {
11751: ctxt->error = XPATH_MEMORY_ERROR;
11752: goto evaluation_exit;
11753: }
11754: }
11755:
11756: valuePush(ctxt, contextObj);
11757:
11758: res = xmlXPathCompOpEvalToBoolean(ctxt, exprOp, 1);
11759:
11760: if ((ctxt->error != XPATH_EXPRESSION_OK) || (res == -1)) {
11761: xmlXPathNodeSetClear(set, hasNsNodes);
11762: newContextSize = 0;
11763: goto evaluation_exit;
11764: }
11765:
11766: if (res != 0) {
11767: newContextSize++;
11768: } else {
11769: /*
11770: * Remove the entry from the initial node set.
11771: */
11772: set->nodeTab[i] = NULL;
11773: if (contextNode->type == XML_NAMESPACE_DECL)
11774: xmlXPathNodeSetFreeNs((xmlNsPtr) contextNode);
11775: }
11776: if (ctxt->value == contextObj) {
11777: /*
11778: * Don't free the temporary XPath object holding the
11779: * context node, in order to avoid massive recreation
11780: * inside this loop.
11781: */
11782: valuePop(ctxt);
11783: xmlXPathNodeSetClear(contextObj->nodesetval, hasNsNodes);
11784: } else {
11785: /*
11786: * TODO: The object was lost in the evaluation machinery.
11787: * Can this happen? Maybe in internal-error cases.
11788: */
11789: contextObj = NULL;
11790: }
11791: }
11792:
11793: if (contextObj != NULL) {
11794: if (ctxt->value == contextObj)
11795: valuePop(ctxt);
11796: xmlXPathReleaseObject(xpctxt, contextObj);
11797: }
11798: evaluation_exit:
11799: if (exprRes != NULL)
11800: xmlXPathReleaseObject(ctxt->context, exprRes);
11801: /*
11802: * Reset/invalidate the context.
11803: */
11804: xpctxt->node = oldContextNode;
11805: xpctxt->doc = oldContextDoc;
11806: xpctxt->contextSize = -1;
11807: xpctxt->proximityPosition = -1;
11808: return(newContextSize);
11809: }
11810: return(contextSize);
11811: }
11812:
11813: static int
11814: xmlXPathCompOpEvalPositionalPredicate(xmlXPathParserContextPtr ctxt,
11815: xmlXPathStepOpPtr op,
11816: xmlNodeSetPtr set,
11817: int contextSize,
11818: int minPos,
11819: int maxPos,
11820: int hasNsNodes)
11821: {
11822: if (op->ch1 != -1) {
11823: xmlXPathCompExprPtr comp = ctxt->comp;
11824: if (comp->steps[op->ch1].op != XPATH_OP_PREDICATE) {
11825: /*
11826: * TODO: raise an internal error.
11827: */
11828: }
11829: contextSize = xmlXPathCompOpEvalPredicate(ctxt,
11830: &comp->steps[op->ch1], set, contextSize, hasNsNodes);
11831: CHECK_ERROR0;
11832: if (contextSize <= 0)
11833: return(0);
11834: }
11835: /*
11836: * Check if the node set contains a sufficient number of nodes for
11837: * the requested range.
11838: */
11839: if (contextSize < minPos) {
11840: xmlXPathNodeSetClear(set, hasNsNodes);
11841: return(0);
11842: }
11843: if (op->ch2 == -1) {
11844: /*
11845: * TODO: Can this ever happen?
11846: */
11847: return (contextSize);
11848: } else {
11849: xmlDocPtr oldContextDoc;
11850: int i, pos = 0, newContextSize = 0, contextPos = 0, res;
11851: xmlXPathStepOpPtr exprOp;
11852: xmlXPathObjectPtr contextObj = NULL, exprRes = NULL;
11853: xmlNodePtr oldContextNode, contextNode = NULL;
11854: xmlXPathContextPtr xpctxt = ctxt->context;
11855: int frame;
11856:
11857: #ifdef LIBXML_XPTR_ENABLED
11858: /*
11859: * URGENT TODO: Check the following:
11860: * We don't expect location sets if evaluating prediates, right?
11861: * Only filters should expect location sets, right?
11862: */
11863: #endif /* LIBXML_XPTR_ENABLED */
11864:
11865: /*
11866: * Save old context.
11867: */
11868: oldContextNode = xpctxt->node;
11869: oldContextDoc = xpctxt->doc;
11870: /*
11871: * Get the expression of this predicate.
11872: */
11873: exprOp = &ctxt->comp->steps[op->ch2];
11874: for (i = 0; i < set->nodeNr; i++) {
11875: xmlXPathObjectPtr tmp;
11876:
11877: if (set->nodeTab[i] == NULL)
11878: continue;
11879:
11880: contextNode = set->nodeTab[i];
11881: xpctxt->node = contextNode;
11882: xpctxt->contextSize = contextSize;
11883: xpctxt->proximityPosition = ++contextPos;
11884:
11885: /*
11886: * Initialize the new set.
11887: * Also set the xpath document in case things like
11888: * key() evaluation are attempted on the predicate
11889: */
11890: if ((contextNode->type != XML_NAMESPACE_DECL) &&
11891: (contextNode->doc != NULL))
11892: xpctxt->doc = contextNode->doc;
11893: /*
11894: * Evaluate the predicate expression with 1 context node
11895: * at a time; this node is packaged into a node set; this
11896: * node set is handed over to the evaluation mechanism.
11897: */
11898: if (contextObj == NULL)
11899: contextObj = xmlXPathCacheNewNodeSet(xpctxt, contextNode);
11900: else {
11901: if (xmlXPathNodeSetAddUnique(contextObj->nodesetval,
11902: contextNode) < 0) {
11903: ctxt->error = XPATH_MEMORY_ERROR;
11904: goto evaluation_exit;
11905: }
11906: }
11907:
11908: frame = xmlXPathSetFrame(ctxt);
11909: valuePush(ctxt, contextObj);
11910: res = xmlXPathCompOpEvalToBoolean(ctxt, exprOp, 1);
11911: tmp = valuePop(ctxt);
11912: xmlXPathPopFrame(ctxt, frame);
11913:
11914: if ((ctxt->error != XPATH_EXPRESSION_OK) || (res == -1)) {
11915: while (tmp != contextObj) {
11916: /*
11917: * Free up the result
11918: * then pop off contextObj, which will be freed later
11919: */
11920: xmlXPathReleaseObject(xpctxt, tmp);
11921: tmp = valuePop(ctxt);
11922: }
11923: goto evaluation_error;
11924: }
11925: /* push the result back onto the stack */
11926: valuePush(ctxt, tmp);
11927:
11928: if (res)
11929: pos++;
11930:
11931: if (res && (pos >= minPos) && (pos <= maxPos)) {
11932: /*
11933: * Fits in the requested range.
11934: */
11935: newContextSize++;
11936: if (minPos == maxPos) {
11937: /*
11938: * Only 1 node was requested.
11939: */
11940: if (contextNode->type == XML_NAMESPACE_DECL) {
11941: /*
11942: * As always: take care of those nasty
11943: * namespace nodes.
11944: */
11945: set->nodeTab[i] = NULL;
11946: }
11947: xmlXPathNodeSetClear(set, hasNsNodes);
11948: set->nodeNr = 1;
11949: set->nodeTab[0] = contextNode;
11950: goto evaluation_exit;
11951: }
11952: if (pos == maxPos) {
11953: /*
11954: * We are done.
11955: */
11956: xmlXPathNodeSetClearFromPos(set, i +1, hasNsNodes);
11957: goto evaluation_exit;
11958: }
11959: } else {
11960: /*
11961: * Remove the entry from the initial node set.
11962: */
11963: set->nodeTab[i] = NULL;
11964: if (contextNode->type == XML_NAMESPACE_DECL)
11965: xmlXPathNodeSetFreeNs((xmlNsPtr) contextNode);
11966: }
11967: if (exprRes != NULL) {
11968: xmlXPathReleaseObject(ctxt->context, exprRes);
11969: exprRes = NULL;
11970: }
11971: if (ctxt->value == contextObj) {
11972: /*
11973: * Don't free the temporary XPath object holding the
11974: * context node, in order to avoid massive recreation
11975: * inside this loop.
11976: */
11977: valuePop(ctxt);
11978: xmlXPathNodeSetClear(contextObj->nodesetval, hasNsNodes);
11979: } else {
11980: /*
11981: * The object was lost in the evaluation machinery.
11982: * Can this happen? Maybe in case of internal-errors.
11983: */
11984: contextObj = NULL;
11985: }
11986: }
11987: goto evaluation_exit;
11988:
11989: evaluation_error:
11990: xmlXPathNodeSetClear(set, hasNsNodes);
11991: newContextSize = 0;
11992:
11993: evaluation_exit:
11994: if (contextObj != NULL) {
11995: if (ctxt->value == contextObj)
11996: valuePop(ctxt);
11997: xmlXPathReleaseObject(xpctxt, contextObj);
11998: }
11999: if (exprRes != NULL)
12000: xmlXPathReleaseObject(ctxt->context, exprRes);
12001: /*
12002: * Reset/invalidate the context.
12003: */
12004: xpctxt->node = oldContextNode;
12005: xpctxt->doc = oldContextDoc;
12006: xpctxt->contextSize = -1;
12007: xpctxt->proximityPosition = -1;
12008: return(newContextSize);
12009: }
12010: return(contextSize);
12011: }
12012:
12013: static int
12014: xmlXPathIsPositionalPredicate(xmlXPathParserContextPtr ctxt,
12015: xmlXPathStepOpPtr op,
12016: int *maxPos)
12017: {
12018:
12019: xmlXPathStepOpPtr exprOp;
12020:
12021: /*
12022: * BIG NOTE: This is not intended for XPATH_OP_FILTER yet!
12023: */
12024:
12025: /*
12026: * If not -1, then ch1 will point to:
12027: * 1) For predicates (XPATH_OP_PREDICATE):
12028: * - an inner predicate operator
12029: * 2) For filters (XPATH_OP_FILTER):
12030: * - an inner filter operater OR
12031: * - an expression selecting the node set.
12032: * E.g. "key('a', 'b')" or "(//foo | //bar)".
12033: */
12034: if ((op->op != XPATH_OP_PREDICATE) && (op->op != XPATH_OP_FILTER))
12035: return(0);
12036:
12037: if (op->ch2 != -1) {
12038: exprOp = &ctxt->comp->steps[op->ch2];
12039: } else
12040: return(0);
12041:
12042: if ((exprOp != NULL) &&
12043: (exprOp->op == XPATH_OP_VALUE) &&
12044: (exprOp->value4 != NULL) &&
12045: (((xmlXPathObjectPtr) exprOp->value4)->type == XPATH_NUMBER))
12046: {
12047: /*
12048: * We have a "[n]" predicate here.
12049: * TODO: Unfortunately this simplistic test here is not
12050: * able to detect a position() predicate in compound
12051: * expressions like "[@attr = 'a" and position() = 1],
12052: * and even not the usage of position() in
12053: * "[position() = 1]"; thus - obviously - a position-range,
12054: * like it "[position() < 5]", is also not detected.
12055: * Maybe we could rewrite the AST to ease the optimization.
12056: */
12057: *maxPos = (int) ((xmlXPathObjectPtr) exprOp->value4)->floatval;
12058:
12059: if (((xmlXPathObjectPtr) exprOp->value4)->floatval ==
12060: (float) *maxPos)
12061: {
12062: return(1);
12063: }
12064: }
12065: return(0);
12066: }
12067:
12068: static int
12069: xmlXPathNodeCollectAndTest(xmlXPathParserContextPtr ctxt,
12070: xmlXPathStepOpPtr op,
12071: xmlNodePtr * first, xmlNodePtr * last,
12072: int toBool)
12073: {
12074:
12075: #define XP_TEST_HIT \
12076: if (hasAxisRange != 0) { \
12077: if (++pos == maxPos) { \
12078: if (addNode(seq, cur) < 0) \
12079: ctxt->error = XPATH_MEMORY_ERROR; \
12080: goto axis_range_end; } \
12081: } else { \
12082: if (addNode(seq, cur) < 0) \
12083: ctxt->error = XPATH_MEMORY_ERROR; \
12084: if (breakOnFirstHit) goto first_hit; }
12085:
12086: #define XP_TEST_HIT_NS \
12087: if (hasAxisRange != 0) { \
12088: if (++pos == maxPos) { \
12089: hasNsNodes = 1; \
12090: if (xmlXPathNodeSetAddNs(seq, xpctxt->node, (xmlNsPtr) cur) < 0) \
12091: ctxt->error = XPATH_MEMORY_ERROR; \
12092: goto axis_range_end; } \
12093: } else { \
12094: hasNsNodes = 1; \
12095: if (xmlXPathNodeSetAddNs(seq, xpctxt->node, (xmlNsPtr) cur) < 0) \
12096: ctxt->error = XPATH_MEMORY_ERROR; \
12097: if (breakOnFirstHit) goto first_hit; }
12098:
12099: xmlXPathAxisVal axis = (xmlXPathAxisVal) op->value;
12100: xmlXPathTestVal test = (xmlXPathTestVal) op->value2;
12101: xmlXPathTypeVal type = (xmlXPathTypeVal) op->value3;
12102: const xmlChar *prefix = op->value4;
12103: const xmlChar *name = op->value5;
12104: const xmlChar *URI = NULL;
12105:
12106: #ifdef DEBUG_STEP
12107: int nbMatches = 0, prevMatches = 0;
12108: #endif
12109: int total = 0, hasNsNodes = 0;
12110: /* The popped object holding the context nodes */
12111: xmlXPathObjectPtr obj;
12112: /* The set of context nodes for the node tests */
12113: xmlNodeSetPtr contextSeq;
12114: int contextIdx;
12115: xmlNodePtr contextNode;
12116: /* The final resulting node set wrt to all context nodes */
12117: xmlNodeSetPtr outSeq;
12118: /*
12119: * The temporary resulting node set wrt 1 context node.
12120: * Used to feed predicate evaluation.
12121: */
12122: xmlNodeSetPtr seq;
12123: xmlNodePtr cur;
12124: /* First predicate operator */
12125: xmlXPathStepOpPtr predOp;
12126: int maxPos; /* The requested position() (when a "[n]" predicate) */
12127: int hasPredicateRange, hasAxisRange, pos, size, newSize;
12128: int breakOnFirstHit;
12129:
12130: xmlXPathTraversalFunction next = NULL;
12131: int (*addNode) (xmlNodeSetPtr, xmlNodePtr);
12132: xmlXPathNodeSetMergeFunction mergeAndClear;
12133: xmlNodePtr oldContextNode;
12134: xmlXPathContextPtr xpctxt = ctxt->context;
12135:
12136:
12137: CHECK_TYPE0(XPATH_NODESET);
12138: obj = valuePop(ctxt);
12139: /*
12140: * Setup namespaces.
12141: */
12142: if (prefix != NULL) {
12143: URI = xmlXPathNsLookup(xpctxt, prefix);
12144: if (URI == NULL) {
12145: xmlXPathReleaseObject(xpctxt, obj);
12146: XP_ERROR0(XPATH_UNDEF_PREFIX_ERROR);
12147: }
12148: }
12149: /*
12150: * Setup axis.
12151: *
12152: * MAYBE FUTURE TODO: merging optimizations:
12153: * - If the nodes to be traversed wrt to the initial nodes and
12154: * the current axis cannot overlap, then we could avoid searching
12155: * for duplicates during the merge.
12156: * But the question is how/when to evaluate if they cannot overlap.
12157: * Example: if we know that for two initial nodes, the one is
12158: * not in the ancestor-or-self axis of the other, then we could safely
12159: * avoid a duplicate-aware merge, if the axis to be traversed is e.g.
12160: * the descendant-or-self axis.
12161: */
12162: mergeAndClear = xmlXPathNodeSetMergeAndClear;
12163: switch (axis) {
12164: case AXIS_ANCESTOR:
12165: first = NULL;
12166: next = xmlXPathNextAncestor;
12167: break;
12168: case AXIS_ANCESTOR_OR_SELF:
12169: first = NULL;
12170: next = xmlXPathNextAncestorOrSelf;
12171: break;
12172: case AXIS_ATTRIBUTE:
12173: first = NULL;
12174: last = NULL;
12175: next = xmlXPathNextAttribute;
12176: mergeAndClear = xmlXPathNodeSetMergeAndClearNoDupls;
12177: break;
12178: case AXIS_CHILD:
12179: last = NULL;
12180: if (((test == NODE_TEST_NAME) || (test == NODE_TEST_ALL)) &&
12181: (type == NODE_TYPE_NODE))
12182: {
12183: /*
12184: * Optimization if an element node type is 'element'.
12185: */
12186: next = xmlXPathNextChildElement;
12187: } else
12188: next = xmlXPathNextChild;
12189: mergeAndClear = xmlXPathNodeSetMergeAndClearNoDupls;
12190: break;
12191: case AXIS_DESCENDANT:
12192: last = NULL;
12193: next = xmlXPathNextDescendant;
12194: break;
12195: case AXIS_DESCENDANT_OR_SELF:
12196: last = NULL;
12197: next = xmlXPathNextDescendantOrSelf;
12198: break;
12199: case AXIS_FOLLOWING:
12200: last = NULL;
12201: next = xmlXPathNextFollowing;
12202: break;
12203: case AXIS_FOLLOWING_SIBLING:
12204: last = NULL;
12205: next = xmlXPathNextFollowingSibling;
12206: break;
12207: case AXIS_NAMESPACE:
12208: first = NULL;
12209: last = NULL;
12210: next = (xmlXPathTraversalFunction) xmlXPathNextNamespace;
12211: mergeAndClear = xmlXPathNodeSetMergeAndClearNoDupls;
12212: break;
12213: case AXIS_PARENT:
12214: first = NULL;
12215: next = xmlXPathNextParent;
12216: break;
12217: case AXIS_PRECEDING:
12218: first = NULL;
12219: next = xmlXPathNextPrecedingInternal;
12220: break;
12221: case AXIS_PRECEDING_SIBLING:
12222: first = NULL;
12223: next = xmlXPathNextPrecedingSibling;
12224: break;
12225: case AXIS_SELF:
12226: first = NULL;
12227: last = NULL;
12228: next = xmlXPathNextSelf;
12229: mergeAndClear = xmlXPathNodeSetMergeAndClearNoDupls;
12230: break;
12231: }
12232:
12233: #ifdef DEBUG_STEP
12234: xmlXPathDebugDumpStepAxis(op,
12235: (obj->nodesetval != NULL) ? obj->nodesetval->nodeNr : 0);
12236: #endif
12237:
12238: if (next == NULL) {
12239: xmlXPathReleaseObject(xpctxt, obj);
12240: return(0);
12241: }
12242: contextSeq = obj->nodesetval;
12243: if ((contextSeq == NULL) || (contextSeq->nodeNr <= 0)) {
12244: xmlXPathReleaseObject(xpctxt, obj);
12245: valuePush(ctxt, xmlXPathCacheWrapNodeSet(xpctxt, NULL));
12246: return(0);
12247: }
12248: /*
12249: * Predicate optimization ---------------------------------------------
12250: * If this step has a last predicate, which contains a position(),
12251: * then we'll optimize (although not exactly "position()", but only
12252: * the short-hand form, i.e., "[n]".
12253: *
12254: * Example - expression "/foo[parent::bar][1]":
12255: *
12256: * COLLECT 'child' 'name' 'node' foo -- op (we are here)
12257: * ROOT -- op->ch1
12258: * PREDICATE -- op->ch2 (predOp)
12259: * PREDICATE -- predOp->ch1 = [parent::bar]
12260: * SORT
12261: * COLLECT 'parent' 'name' 'node' bar
12262: * NODE
12263: * ELEM Object is a number : 1 -- predOp->ch2 = [1]
12264: *
12265: */
12266: maxPos = 0;
12267: predOp = NULL;
12268: hasPredicateRange = 0;
12269: hasAxisRange = 0;
12270: if (op->ch2 != -1) {
12271: /*
12272: * There's at least one predicate. 16 == XPATH_OP_PREDICATE
12273: */
12274: predOp = &ctxt->comp->steps[op->ch2];
12275: if (xmlXPathIsPositionalPredicate(ctxt, predOp, &maxPos)) {
12276: if (predOp->ch1 != -1) {
12277: /*
12278: * Use the next inner predicate operator.
12279: */
12280: predOp = &ctxt->comp->steps[predOp->ch1];
12281: hasPredicateRange = 1;
12282: } else {
12283: /*
12284: * There's no other predicate than the [n] predicate.
12285: */
12286: predOp = NULL;
12287: hasAxisRange = 1;
12288: }
12289: }
12290: }
12291: breakOnFirstHit = ((toBool) && (predOp == NULL)) ? 1 : 0;
12292: /*
12293: * Axis traversal -----------------------------------------------------
12294: */
12295: /*
12296: * 2.3 Node Tests
12297: * - For the attribute axis, the principal node type is attribute.
12298: * - For the namespace axis, the principal node type is namespace.
12299: * - For other axes, the principal node type is element.
12300: *
12301: * A node test * is true for any node of the
12302: * principal node type. For example, child::* will
12303: * select all element children of the context node
12304: */
12305: oldContextNode = xpctxt->node;
12306: addNode = xmlXPathNodeSetAddUnique;
12307: outSeq = NULL;
12308: seq = NULL;
12309: contextNode = NULL;
12310: contextIdx = 0;
12311:
12312:
12313: while (((contextIdx < contextSeq->nodeNr) || (contextNode != NULL)) &&
12314: (ctxt->error == XPATH_EXPRESSION_OK)) {
12315: xpctxt->node = contextSeq->nodeTab[contextIdx++];
12316:
12317: if (seq == NULL) {
12318: seq = xmlXPathNodeSetCreate(NULL);
12319: if (seq == NULL) {
12320: total = 0;
12321: goto error;
12322: }
12323: }
12324: /*
12325: * Traverse the axis and test the nodes.
12326: */
12327: pos = 0;
12328: cur = NULL;
12329: hasNsNodes = 0;
12330: do {
12331: cur = next(ctxt, cur);
12332: if (cur == NULL)
12333: break;
12334:
12335: /*
12336: * QUESTION TODO: What does the "first" and "last" stuff do?
12337: */
12338: if ((first != NULL) && (*first != NULL)) {
12339: if (*first == cur)
12340: break;
12341: if (((total % 256) == 0) &&
12342: #ifdef XP_OPTIMIZED_NON_ELEM_COMPARISON
12343: (xmlXPathCmpNodesExt(*first, cur) >= 0))
12344: #else
12345: (xmlXPathCmpNodes(*first, cur) >= 0))
12346: #endif
12347: {
12348: break;
12349: }
12350: }
12351: if ((last != NULL) && (*last != NULL)) {
12352: if (*last == cur)
12353: break;
12354: if (((total % 256) == 0) &&
12355: #ifdef XP_OPTIMIZED_NON_ELEM_COMPARISON
12356: (xmlXPathCmpNodesExt(cur, *last) >= 0))
12357: #else
12358: (xmlXPathCmpNodes(cur, *last) >= 0))
12359: #endif
12360: {
12361: break;
12362: }
12363: }
12364:
12365: total++;
12366:
12367: #ifdef DEBUG_STEP
12368: xmlGenericError(xmlGenericErrorContext, " %s", cur->name);
12369: #endif
12370:
12371: switch (test) {
12372: case NODE_TEST_NONE:
12373: total = 0;
12374: STRANGE
12375: goto error;
12376: case NODE_TEST_TYPE:
12377: /*
12378: * TODO: Don't we need to use
12379: * xmlXPathNodeSetAddNs() for namespace nodes here?
12380: * Surprisingly, some c14n tests fail, if we do this.
12381: */
12382: if (type == NODE_TYPE_NODE) {
12383: switch (cur->type) {
12384: case XML_DOCUMENT_NODE:
12385: case XML_HTML_DOCUMENT_NODE:
12386: #ifdef LIBXML_DOCB_ENABLED
12387: case XML_DOCB_DOCUMENT_NODE:
12388: #endif
12389: case XML_ELEMENT_NODE:
12390: case XML_ATTRIBUTE_NODE:
12391: case XML_PI_NODE:
12392: case XML_COMMENT_NODE:
12393: case XML_CDATA_SECTION_NODE:
12394: case XML_TEXT_NODE:
12395: case XML_NAMESPACE_DECL:
12396: XP_TEST_HIT
12397: break;
12398: default:
12399: break;
12400: }
12401: } else if (cur->type == type) {
12402: if (cur->type == XML_NAMESPACE_DECL)
12403: XP_TEST_HIT_NS
12404: else
12405: XP_TEST_HIT
12406: } else if ((type == NODE_TYPE_TEXT) &&
12407: (cur->type == XML_CDATA_SECTION_NODE))
12408: {
12409: XP_TEST_HIT
12410: }
12411: break;
12412: case NODE_TEST_PI:
12413: if ((cur->type == XML_PI_NODE) &&
12414: ((name == NULL) || xmlStrEqual(name, cur->name)))
12415: {
12416: XP_TEST_HIT
12417: }
12418: break;
12419: case NODE_TEST_ALL:
12420: if (axis == AXIS_ATTRIBUTE) {
12421: if (cur->type == XML_ATTRIBUTE_NODE)
12422: {
12423: XP_TEST_HIT
12424: }
12425: } else if (axis == AXIS_NAMESPACE) {
12426: if (cur->type == XML_NAMESPACE_DECL)
12427: {
12428: XP_TEST_HIT_NS
12429: }
12430: } else {
12431: if (cur->type == XML_ELEMENT_NODE) {
12432: if (prefix == NULL)
12433: {
12434: XP_TEST_HIT
12435:
12436: } else if ((cur->ns != NULL) &&
12437: (xmlStrEqual(URI, cur->ns->href)))
12438: {
12439: XP_TEST_HIT
12440: }
12441: }
12442: }
12443: break;
12444: case NODE_TEST_NS:{
12445: TODO;
12446: break;
12447: }
12448: case NODE_TEST_NAME:
12449: if (axis == AXIS_ATTRIBUTE) {
12450: if (cur->type != XML_ATTRIBUTE_NODE)
12451: break;
12452: } else if (axis == AXIS_NAMESPACE) {
12453: if (cur->type != XML_NAMESPACE_DECL)
12454: break;
12455: } else {
12456: if (cur->type != XML_ELEMENT_NODE)
12457: break;
12458: }
12459: switch (cur->type) {
12460: case XML_ELEMENT_NODE:
12461: if (xmlStrEqual(name, cur->name)) {
12462: if (prefix == NULL) {
12463: if (cur->ns == NULL)
12464: {
12465: XP_TEST_HIT
12466: }
12467: } else {
12468: if ((cur->ns != NULL) &&
12469: (xmlStrEqual(URI, cur->ns->href)))
12470: {
12471: XP_TEST_HIT
12472: }
12473: }
12474: }
12475: break;
12476: case XML_ATTRIBUTE_NODE:{
12477: xmlAttrPtr attr = (xmlAttrPtr) cur;
12478:
12479: if (xmlStrEqual(name, attr->name)) {
12480: if (prefix == NULL) {
12481: if ((attr->ns == NULL) ||
12482: (attr->ns->prefix == NULL))
12483: {
12484: XP_TEST_HIT
12485: }
12486: } else {
12487: if ((attr->ns != NULL) &&
12488: (xmlStrEqual(URI,
12489: attr->ns->href)))
12490: {
12491: XP_TEST_HIT
12492: }
12493: }
12494: }
12495: break;
12496: }
12497: case XML_NAMESPACE_DECL:
12498: if (cur->type == XML_NAMESPACE_DECL) {
12499: xmlNsPtr ns = (xmlNsPtr) cur;
12500:
12501: if ((ns->prefix != NULL) && (name != NULL)
12502: && (xmlStrEqual(ns->prefix, name)))
12503: {
12504: XP_TEST_HIT_NS
12505: }
12506: }
12507: break;
12508: default:
12509: break;
12510: }
12511: break;
12512: } /* switch(test) */
12513: } while ((cur != NULL) && (ctxt->error == XPATH_EXPRESSION_OK));
12514:
12515: goto apply_predicates;
12516:
12517: axis_range_end: /* ----------------------------------------------------- */
12518: /*
12519: * We have a "/foo[n]", and position() = n was reached.
12520: * Note that we can have as well "/foo/::parent::foo[1]", so
12521: * a duplicate-aware merge is still needed.
12522: * Merge with the result.
12523: */
12524: if (outSeq == NULL) {
12525: outSeq = seq;
12526: seq = NULL;
12527: } else
12528: outSeq = mergeAndClear(outSeq, seq, 0);
12529: /*
12530: * Break if only a true/false result was requested.
12531: */
12532: if (toBool)
12533: break;
12534: continue;
12535:
12536: first_hit: /* ---------------------------------------------------------- */
12537: /*
12538: * Break if only a true/false result was requested and
12539: * no predicates existed and a node test succeeded.
12540: */
12541: if (outSeq == NULL) {
12542: outSeq = seq;
12543: seq = NULL;
12544: } else
12545: outSeq = mergeAndClear(outSeq, seq, 0);
12546: break;
12547:
12548: #ifdef DEBUG_STEP
12549: if (seq != NULL)
12550: nbMatches += seq->nodeNr;
12551: #endif
12552:
12553: apply_predicates: /* --------------------------------------------------- */
12554: if (ctxt->error != XPATH_EXPRESSION_OK)
12555: goto error;
12556:
12557: /*
12558: * Apply predicates.
12559: */
12560: if ((predOp != NULL) && (seq->nodeNr > 0)) {
12561: /*
12562: * E.g. when we have a "/foo[some expression][n]".
12563: */
12564: /*
12565: * QUESTION TODO: The old predicate evaluation took into
12566: * account location-sets.
12567: * (E.g. ctxt->value->type == XPATH_LOCATIONSET)
12568: * Do we expect such a set here?
12569: * All what I learned now from the evaluation semantics
12570: * does not indicate that a location-set will be processed
12571: * here, so this looks OK.
12572: */
12573: /*
12574: * Iterate over all predicates, starting with the outermost
12575: * predicate.
12576: * TODO: Problem: we cannot execute the inner predicates first
12577: * since we cannot go back *up* the operator tree!
12578: * Options we have:
12579: * 1) Use of recursive functions (like is it currently done
12580: * via xmlXPathCompOpEval())
12581: * 2) Add a predicate evaluation information stack to the
12582: * context struct
12583: * 3) Change the way the operators are linked; we need a
12584: * "parent" field on xmlXPathStepOp
12585: *
12586: * For the moment, I'll try to solve this with a recursive
12587: * function: xmlXPathCompOpEvalPredicate().
12588: */
12589: size = seq->nodeNr;
12590: if (hasPredicateRange != 0)
12591: newSize = xmlXPathCompOpEvalPositionalPredicate(ctxt,
12592: predOp, seq, size, maxPos, maxPos, hasNsNodes);
12593: else
12594: newSize = xmlXPathCompOpEvalPredicate(ctxt,
12595: predOp, seq, size, hasNsNodes);
12596:
12597: if (ctxt->error != XPATH_EXPRESSION_OK) {
12598: total = 0;
12599: goto error;
12600: }
12601: /*
12602: * Add the filtered set of nodes to the result node set.
12603: */
12604: if (newSize == 0) {
12605: /*
12606: * The predicates filtered all nodes out.
12607: */
12608: xmlXPathNodeSetClear(seq, hasNsNodes);
12609: } else if (seq->nodeNr > 0) {
12610: /*
12611: * Add to result set.
12612: */
12613: if (outSeq == NULL) {
12614: if (size != newSize) {
12615: /*
12616: * We need to merge and clear here, since
12617: * the sequence will contained NULLed entries.
12618: */
12619: outSeq = mergeAndClear(NULL, seq, 1);
12620: } else {
12621: outSeq = seq;
12622: seq = NULL;
12623: }
12624: } else
12625: outSeq = mergeAndClear(outSeq, seq,
12626: (size != newSize) ? 1: 0);
12627: /*
12628: * Break if only a true/false result was requested.
12629: */
12630: if (toBool)
12631: break;
12632: }
12633: } else if (seq->nodeNr > 0) {
12634: /*
12635: * Add to result set.
12636: */
12637: if (outSeq == NULL) {
12638: outSeq = seq;
12639: seq = NULL;
12640: } else {
12641: outSeq = mergeAndClear(outSeq, seq, 0);
12642: }
12643: }
12644: }
12645:
12646: error:
12647: if ((obj->boolval) && (obj->user != NULL)) {
12648: /*
12649: * QUESTION TODO: What does this do and why?
12650: * TODO: Do we have to do this also for the "error"
12651: * cleanup further down?
12652: */
12653: ctxt->value->boolval = 1;
12654: ctxt->value->user = obj->user;
12655: obj->user = NULL;
12656: obj->boolval = 0;
12657: }
12658: xmlXPathReleaseObject(xpctxt, obj);
12659:
12660: /*
12661: * Ensure we return at least an emtpy set.
12662: */
12663: if (outSeq == NULL) {
12664: if ((seq != NULL) && (seq->nodeNr == 0))
12665: outSeq = seq;
12666: else
12667: outSeq = xmlXPathNodeSetCreate(NULL);
12668: /* XXX what if xmlXPathNodeSetCreate returned NULL here? */
12669: }
12670: if ((seq != NULL) && (seq != outSeq)) {
12671: xmlXPathFreeNodeSet(seq);
12672: }
12673: /*
12674: * Hand over the result. Better to push the set also in
12675: * case of errors.
12676: */
12677: valuePush(ctxt, xmlXPathCacheWrapNodeSet(xpctxt, outSeq));
12678: /*
12679: * Reset the context node.
12680: */
12681: xpctxt->node = oldContextNode;
12682:
12683: #ifdef DEBUG_STEP
12684: xmlGenericError(xmlGenericErrorContext,
12685: "\nExamined %d nodes, found %d nodes at that step\n",
12686: total, nbMatches);
12687: #endif
12688:
12689: return(total);
12690: }
12691:
12692: static int
12693: xmlXPathCompOpEvalFilterFirst(xmlXPathParserContextPtr ctxt,
12694: xmlXPathStepOpPtr op, xmlNodePtr * first);
12695:
12696: /**
12697: * xmlXPathCompOpEvalFirst:
12698: * @ctxt: the XPath parser context with the compiled expression
12699: * @op: an XPath compiled operation
12700: * @first: the first elem found so far
12701: *
12702: * Evaluate the Precompiled XPath operation searching only the first
12703: * element in document order
12704: *
12705: * Returns the number of examined objects.
12706: */
12707: static int
12708: xmlXPathCompOpEvalFirst(xmlXPathParserContextPtr ctxt,
12709: xmlXPathStepOpPtr op, xmlNodePtr * first)
12710: {
12711: int total = 0, cur;
12712: xmlXPathCompExprPtr comp;
12713: xmlXPathObjectPtr arg1, arg2;
12714:
12715: CHECK_ERROR0;
12716: comp = ctxt->comp;
12717: switch (op->op) {
12718: case XPATH_OP_END:
12719: return (0);
12720: case XPATH_OP_UNION:
12721: total =
12722: xmlXPathCompOpEvalFirst(ctxt, &comp->steps[op->ch1],
12723: first);
12724: CHECK_ERROR0;
12725: if ((ctxt->value != NULL)
12726: && (ctxt->value->type == XPATH_NODESET)
12727: && (ctxt->value->nodesetval != NULL)
12728: && (ctxt->value->nodesetval->nodeNr >= 1)) {
12729: /*
12730: * limit tree traversing to first node in the result
12731: */
12732: /*
12733: * OPTIMIZE TODO: This implicitely sorts
12734: * the result, even if not needed. E.g. if the argument
12735: * of the count() function, no sorting is needed.
12736: * OPTIMIZE TODO: How do we know if the node-list wasn't
12737: * aready sorted?
12738: */
12739: if (ctxt->value->nodesetval->nodeNr > 1)
12740: xmlXPathNodeSetSort(ctxt->value->nodesetval);
12741: *first = ctxt->value->nodesetval->nodeTab[0];
12742: }
12743: cur =
12744: xmlXPathCompOpEvalFirst(ctxt, &comp->steps[op->ch2],
12745: first);
12746: CHECK_ERROR0;
12747: CHECK_TYPE0(XPATH_NODESET);
12748: arg2 = valuePop(ctxt);
12749:
12750: CHECK_TYPE0(XPATH_NODESET);
12751: arg1 = valuePop(ctxt);
12752:
12753: arg1->nodesetval = xmlXPathNodeSetMerge(arg1->nodesetval,
12754: arg2->nodesetval);
12755: valuePush(ctxt, arg1);
12756: xmlXPathReleaseObject(ctxt->context, arg2);
12757: /* optimizer */
12758: if (total > cur)
12759: xmlXPathCompSwap(op);
12760: return (total + cur);
12761: case XPATH_OP_ROOT:
12762: xmlXPathRoot(ctxt);
12763: return (0);
12764: case XPATH_OP_NODE:
12765: if (op->ch1 != -1)
12766: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
12767: CHECK_ERROR0;
12768: if (op->ch2 != -1)
12769: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
12770: CHECK_ERROR0;
12771: valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context,
12772: ctxt->context->node));
12773: return (total);
12774: case XPATH_OP_RESET:
12775: if (op->ch1 != -1)
12776: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
12777: CHECK_ERROR0;
12778: if (op->ch2 != -1)
12779: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
12780: CHECK_ERROR0;
12781: ctxt->context->node = NULL;
12782: return (total);
12783: case XPATH_OP_COLLECT:{
12784: if (op->ch1 == -1)
12785: return (total);
12786:
12787: total = xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
12788: CHECK_ERROR0;
12789:
12790: total += xmlXPathNodeCollectAndTest(ctxt, op, first, NULL, 0);
12791: return (total);
12792: }
12793: case XPATH_OP_VALUE:
12794: valuePush(ctxt,
12795: xmlXPathCacheObjectCopy(ctxt->context,
12796: (xmlXPathObjectPtr) op->value4));
12797: return (0);
12798: case XPATH_OP_SORT:
12799: if (op->ch1 != -1)
12800: total +=
12801: xmlXPathCompOpEvalFirst(ctxt, &comp->steps[op->ch1],
12802: first);
12803: CHECK_ERROR0;
12804: if ((ctxt->value != NULL)
12805: && (ctxt->value->type == XPATH_NODESET)
12806: && (ctxt->value->nodesetval != NULL)
12807: && (ctxt->value->nodesetval->nodeNr > 1))
12808: xmlXPathNodeSetSort(ctxt->value->nodesetval);
12809: return (total);
12810: #ifdef XP_OPTIMIZED_FILTER_FIRST
12811: case XPATH_OP_FILTER:
12812: total += xmlXPathCompOpEvalFilterFirst(ctxt, op, first);
12813: return (total);
12814: #endif
12815: default:
12816: return (xmlXPathCompOpEval(ctxt, op));
12817: }
12818: }
12819:
12820: /**
12821: * xmlXPathCompOpEvalLast:
12822: * @ctxt: the XPath parser context with the compiled expression
12823: * @op: an XPath compiled operation
12824: * @last: the last elem found so far
12825: *
12826: * Evaluate the Precompiled XPath operation searching only the last
12827: * element in document order
12828: *
12829: * Returns the number of nodes traversed
12830: */
12831: static int
12832: xmlXPathCompOpEvalLast(xmlXPathParserContextPtr ctxt, xmlXPathStepOpPtr op,
12833: xmlNodePtr * last)
12834: {
12835: int total = 0, cur;
12836: xmlXPathCompExprPtr comp;
12837: xmlXPathObjectPtr arg1, arg2;
12838: xmlNodePtr bak;
12839: xmlDocPtr bakd;
12840: int pp;
12841: int cs;
12842:
12843: CHECK_ERROR0;
12844: comp = ctxt->comp;
12845: switch (op->op) {
12846: case XPATH_OP_END:
12847: return (0);
12848: case XPATH_OP_UNION:
12849: bakd = ctxt->context->doc;
12850: bak = ctxt->context->node;
12851: pp = ctxt->context->proximityPosition;
12852: cs = ctxt->context->contextSize;
12853: total =
12854: xmlXPathCompOpEvalLast(ctxt, &comp->steps[op->ch1], last);
12855: CHECK_ERROR0;
12856: if ((ctxt->value != NULL)
12857: && (ctxt->value->type == XPATH_NODESET)
12858: && (ctxt->value->nodesetval != NULL)
12859: && (ctxt->value->nodesetval->nodeNr >= 1)) {
12860: /*
12861: * limit tree traversing to first node in the result
12862: */
12863: if (ctxt->value->nodesetval->nodeNr > 1)
12864: xmlXPathNodeSetSort(ctxt->value->nodesetval);
12865: *last =
12866: ctxt->value->nodesetval->nodeTab[ctxt->value->
12867: nodesetval->nodeNr -
12868: 1];
12869: }
12870: ctxt->context->doc = bakd;
12871: ctxt->context->node = bak;
12872: ctxt->context->proximityPosition = pp;
12873: ctxt->context->contextSize = cs;
12874: cur =
12875: xmlXPathCompOpEvalLast(ctxt, &comp->steps[op->ch2], last);
12876: CHECK_ERROR0;
12877: if ((ctxt->value != NULL)
12878: && (ctxt->value->type == XPATH_NODESET)
12879: && (ctxt->value->nodesetval != NULL)
12880: && (ctxt->value->nodesetval->nodeNr >= 1)) { /* TODO: NOP ? */
12881: }
12882: CHECK_TYPE0(XPATH_NODESET);
12883: arg2 = valuePop(ctxt);
12884:
12885: CHECK_TYPE0(XPATH_NODESET);
12886: arg1 = valuePop(ctxt);
12887:
12888: arg1->nodesetval = xmlXPathNodeSetMerge(arg1->nodesetval,
12889: arg2->nodesetval);
12890: valuePush(ctxt, arg1);
12891: xmlXPathReleaseObject(ctxt->context, arg2);
12892: /* optimizer */
12893: if (total > cur)
12894: xmlXPathCompSwap(op);
12895: return (total + cur);
12896: case XPATH_OP_ROOT:
12897: xmlXPathRoot(ctxt);
12898: return (0);
12899: case XPATH_OP_NODE:
12900: if (op->ch1 != -1)
12901: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
12902: CHECK_ERROR0;
12903: if (op->ch2 != -1)
12904: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
12905: CHECK_ERROR0;
12906: valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context,
12907: ctxt->context->node));
12908: return (total);
12909: case XPATH_OP_RESET:
12910: if (op->ch1 != -1)
12911: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
12912: CHECK_ERROR0;
12913: if (op->ch2 != -1)
12914: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
12915: CHECK_ERROR0;
12916: ctxt->context->node = NULL;
12917: return (total);
12918: case XPATH_OP_COLLECT:{
12919: if (op->ch1 == -1)
12920: return (0);
12921:
12922: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
12923: CHECK_ERROR0;
12924:
12925: total += xmlXPathNodeCollectAndTest(ctxt, op, NULL, last, 0);
12926: return (total);
12927: }
12928: case XPATH_OP_VALUE:
12929: valuePush(ctxt,
12930: xmlXPathCacheObjectCopy(ctxt->context,
12931: (xmlXPathObjectPtr) op->value4));
12932: return (0);
12933: case XPATH_OP_SORT:
12934: if (op->ch1 != -1)
12935: total +=
12936: xmlXPathCompOpEvalLast(ctxt, &comp->steps[op->ch1],
12937: last);
12938: CHECK_ERROR0;
12939: if ((ctxt->value != NULL)
12940: && (ctxt->value->type == XPATH_NODESET)
12941: && (ctxt->value->nodesetval != NULL)
12942: && (ctxt->value->nodesetval->nodeNr > 1))
12943: xmlXPathNodeSetSort(ctxt->value->nodesetval);
12944: return (total);
12945: default:
12946: return (xmlXPathCompOpEval(ctxt, op));
12947: }
12948: }
12949:
12950: #ifdef XP_OPTIMIZED_FILTER_FIRST
12951: static int
12952: xmlXPathCompOpEvalFilterFirst(xmlXPathParserContextPtr ctxt,
12953: xmlXPathStepOpPtr op, xmlNodePtr * first)
12954: {
12955: int total = 0;
12956: xmlXPathCompExprPtr comp;
12957: xmlXPathObjectPtr res;
12958: xmlXPathObjectPtr obj;
12959: xmlNodeSetPtr oldset;
12960: xmlNodePtr oldnode;
12961: xmlDocPtr oldDoc;
12962: int i;
12963:
12964: CHECK_ERROR0;
12965: comp = ctxt->comp;
12966: /*
12967: * Optimization for ()[last()] selection i.e. the last elem
12968: */
12969: if ((op->ch1 != -1) && (op->ch2 != -1) &&
12970: (comp->steps[op->ch1].op == XPATH_OP_SORT) &&
12971: (comp->steps[op->ch2].op == XPATH_OP_SORT)) {
12972: int f = comp->steps[op->ch2].ch1;
12973:
12974: if ((f != -1) &&
12975: (comp->steps[f].op == XPATH_OP_FUNCTION) &&
12976: (comp->steps[f].value5 == NULL) &&
12977: (comp->steps[f].value == 0) &&
12978: (comp->steps[f].value4 != NULL) &&
12979: (xmlStrEqual
12980: (comp->steps[f].value4, BAD_CAST "last"))) {
12981: xmlNodePtr last = NULL;
12982:
12983: total +=
12984: xmlXPathCompOpEvalLast(ctxt,
12985: &comp->steps[op->ch1],
12986: &last);
12987: CHECK_ERROR0;
12988: /*
12989: * The nodeset should be in document order,
12990: * Keep only the last value
12991: */
12992: if ((ctxt->value != NULL) &&
12993: (ctxt->value->type == XPATH_NODESET) &&
12994: (ctxt->value->nodesetval != NULL) &&
12995: (ctxt->value->nodesetval->nodeTab != NULL) &&
12996: (ctxt->value->nodesetval->nodeNr > 1)) {
12997: ctxt->value->nodesetval->nodeTab[0] =
12998: ctxt->value->nodesetval->nodeTab[ctxt->
12999: value->
13000: nodesetval->
13001: nodeNr -
13002: 1];
13003: ctxt->value->nodesetval->nodeNr = 1;
13004: *first = *(ctxt->value->nodesetval->nodeTab);
13005: }
13006: return (total);
13007: }
13008: }
13009:
13010: if (op->ch1 != -1)
13011: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13012: CHECK_ERROR0;
13013: if (op->ch2 == -1)
13014: return (total);
13015: if (ctxt->value == NULL)
13016: return (total);
13017:
13018: #ifdef LIBXML_XPTR_ENABLED
13019: oldnode = ctxt->context->node;
13020: /*
13021: * Hum are we filtering the result of an XPointer expression
13022: */
13023: if (ctxt->value->type == XPATH_LOCATIONSET) {
13024: xmlXPathObjectPtr tmp = NULL;
13025: xmlLocationSetPtr newlocset = NULL;
13026: xmlLocationSetPtr oldlocset;
13027:
13028: /*
13029: * Extract the old locset, and then evaluate the result of the
13030: * expression for all the element in the locset. use it to grow
13031: * up a new locset.
13032: */
13033: CHECK_TYPE0(XPATH_LOCATIONSET);
13034: obj = valuePop(ctxt);
13035: oldlocset = obj->user;
13036: ctxt->context->node = NULL;
13037:
13038: if ((oldlocset == NULL) || (oldlocset->locNr == 0)) {
13039: ctxt->context->contextSize = 0;
13040: ctxt->context->proximityPosition = 0;
13041: if (op->ch2 != -1)
13042: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13043: res = valuePop(ctxt);
13044: if (res != NULL) {
13045: xmlXPathReleaseObject(ctxt->context, res);
13046: }
13047: valuePush(ctxt, obj);
13048: CHECK_ERROR0;
13049: return (total);
13050: }
13051: newlocset = xmlXPtrLocationSetCreate(NULL);
13052:
13053: for (i = 0; i < oldlocset->locNr; i++) {
13054: /*
13055: * Run the evaluation with a node list made of a
13056: * single item in the nodelocset.
13057: */
13058: ctxt->context->node = oldlocset->locTab[i]->user;
13059: ctxt->context->contextSize = oldlocset->locNr;
13060: ctxt->context->proximityPosition = i + 1;
13061: if (tmp == NULL) {
13062: tmp = xmlXPathCacheNewNodeSet(ctxt->context,
13063: ctxt->context->node);
13064: } else {
13065: if (xmlXPathNodeSetAddUnique(tmp->nodesetval,
13066: ctxt->context->node) < 0) {
13067: ctxt->error = XPATH_MEMORY_ERROR;
13068: }
13069: }
13070: valuePush(ctxt, tmp);
13071: if (op->ch2 != -1)
13072: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13073: if (ctxt->error != XPATH_EXPRESSION_OK) {
13074: xmlXPathFreeObject(obj);
13075: return(0);
13076: }
13077: /*
13078: * The result of the evaluation need to be tested to
13079: * decided whether the filter succeeded or not
13080: */
13081: res = valuePop(ctxt);
13082: if (xmlXPathEvaluatePredicateResult(ctxt, res)) {
13083: xmlXPtrLocationSetAdd(newlocset,
13084: xmlXPathCacheObjectCopy(ctxt->context,
13085: oldlocset->locTab[i]));
13086: }
13087: /*
13088: * Cleanup
13089: */
13090: if (res != NULL) {
13091: xmlXPathReleaseObject(ctxt->context, res);
13092: }
13093: if (ctxt->value == tmp) {
13094: valuePop(ctxt);
13095: xmlXPathNodeSetClear(tmp->nodesetval, 1);
13096: /*
13097: * REVISIT TODO: Don't create a temporary nodeset
13098: * for everly iteration.
13099: */
13100: /* OLD: xmlXPathFreeObject(res); */
13101: } else
13102: tmp = NULL;
13103: ctxt->context->node = NULL;
13104: /*
13105: * Only put the first node in the result, then leave.
13106: */
13107: if (newlocset->locNr > 0) {
13108: *first = (xmlNodePtr) oldlocset->locTab[i]->user;
13109: break;
13110: }
13111: }
13112: if (tmp != NULL) {
13113: xmlXPathReleaseObject(ctxt->context, tmp);
13114: }
13115: /*
13116: * The result is used as the new evaluation locset.
13117: */
13118: xmlXPathReleaseObject(ctxt->context, obj);
13119: ctxt->context->node = NULL;
13120: ctxt->context->contextSize = -1;
13121: ctxt->context->proximityPosition = -1;
13122: valuePush(ctxt, xmlXPtrWrapLocationSet(newlocset));
13123: ctxt->context->node = oldnode;
13124: return (total);
13125: }
13126: #endif /* LIBXML_XPTR_ENABLED */
13127:
13128: /*
13129: * Extract the old set, and then evaluate the result of the
13130: * expression for all the element in the set. use it to grow
13131: * up a new set.
13132: */
13133: CHECK_TYPE0(XPATH_NODESET);
13134: obj = valuePop(ctxt);
13135: oldset = obj->nodesetval;
13136:
13137: oldnode = ctxt->context->node;
13138: oldDoc = ctxt->context->doc;
13139: ctxt->context->node = NULL;
13140:
13141: if ((oldset == NULL) || (oldset->nodeNr == 0)) {
13142: ctxt->context->contextSize = 0;
13143: ctxt->context->proximityPosition = 0;
13144: /* QUESTION TODO: Why was this code commented out?
13145: if (op->ch2 != -1)
13146: total +=
13147: xmlXPathCompOpEval(ctxt,
13148: &comp->steps[op->ch2]);
13149: CHECK_ERROR0;
13150: res = valuePop(ctxt);
13151: if (res != NULL)
13152: xmlXPathFreeObject(res);
13153: */
13154: valuePush(ctxt, obj);
13155: ctxt->context->node = oldnode;
13156: CHECK_ERROR0;
13157: } else {
13158: xmlNodeSetPtr newset;
13159: xmlXPathObjectPtr tmp = NULL;
13160: /*
13161: * Initialize the new set.
13162: * Also set the xpath document in case things like
13163: * key() evaluation are attempted on the predicate
13164: */
13165: newset = xmlXPathNodeSetCreate(NULL);
13166: /* XXX what if xmlXPathNodeSetCreate returned NULL? */
13167:
13168: for (i = 0; i < oldset->nodeNr; i++) {
13169: /*
13170: * Run the evaluation with a node list made of
13171: * a single item in the nodeset.
13172: */
13173: ctxt->context->node = oldset->nodeTab[i];
13174: if ((oldset->nodeTab[i]->type != XML_NAMESPACE_DECL) &&
13175: (oldset->nodeTab[i]->doc != NULL))
13176: ctxt->context->doc = oldset->nodeTab[i]->doc;
13177: if (tmp == NULL) {
13178: tmp = xmlXPathCacheNewNodeSet(ctxt->context,
13179: ctxt->context->node);
13180: } else {
13181: if (xmlXPathNodeSetAddUnique(tmp->nodesetval,
13182: ctxt->context->node) < 0) {
13183: ctxt->error = XPATH_MEMORY_ERROR;
13184: }
13185: }
13186: valuePush(ctxt, tmp);
13187: ctxt->context->contextSize = oldset->nodeNr;
13188: ctxt->context->proximityPosition = i + 1;
13189: if (op->ch2 != -1)
13190: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13191: if (ctxt->error != XPATH_EXPRESSION_OK) {
13192: xmlXPathFreeNodeSet(newset);
13193: xmlXPathFreeObject(obj);
13194: return(0);
13195: }
13196: /*
13197: * The result of the evaluation needs to be tested to
13198: * decide whether the filter succeeded or not
13199: */
13200: res = valuePop(ctxt);
13201: if (xmlXPathEvaluatePredicateResult(ctxt, res)) {
13202: if (xmlXPathNodeSetAdd(newset, oldset->nodeTab[i]) < 0)
13203: ctxt->error = XPATH_MEMORY_ERROR;
13204: }
13205: /*
13206: * Cleanup
13207: */
13208: if (res != NULL) {
13209: xmlXPathReleaseObject(ctxt->context, res);
13210: }
13211: if (ctxt->value == tmp) {
13212: valuePop(ctxt);
13213: /*
13214: * Don't free the temporary nodeset
13215: * in order to avoid massive recreation inside this
13216: * loop.
13217: */
13218: xmlXPathNodeSetClear(tmp->nodesetval, 1);
13219: } else
13220: tmp = NULL;
13221: ctxt->context->node = NULL;
13222: /*
13223: * Only put the first node in the result, then leave.
13224: */
13225: if (newset->nodeNr > 0) {
13226: *first = *(newset->nodeTab);
13227: break;
13228: }
13229: }
13230: if (tmp != NULL) {
13231: xmlXPathReleaseObject(ctxt->context, tmp);
13232: }
13233: /*
13234: * The result is used as the new evaluation set.
13235: */
13236: xmlXPathReleaseObject(ctxt->context, obj);
13237: ctxt->context->node = NULL;
13238: ctxt->context->contextSize = -1;
13239: ctxt->context->proximityPosition = -1;
13240: /* may want to move this past the '}' later */
13241: ctxt->context->doc = oldDoc;
13242: valuePush(ctxt, xmlXPathCacheWrapNodeSet(ctxt->context, newset));
13243: }
13244: ctxt->context->node = oldnode;
13245: return(total);
13246: }
13247: #endif /* XP_OPTIMIZED_FILTER_FIRST */
13248:
13249: /**
13250: * xmlXPathCompOpEval:
13251: * @ctxt: the XPath parser context with the compiled expression
13252: * @op: an XPath compiled operation
13253: *
13254: * Evaluate the Precompiled XPath operation
13255: * Returns the number of nodes traversed
13256: */
13257: static int
13258: xmlXPathCompOpEval(xmlXPathParserContextPtr ctxt, xmlXPathStepOpPtr op)
13259: {
13260: int total = 0;
13261: int equal, ret;
13262: xmlXPathCompExprPtr comp;
13263: xmlXPathObjectPtr arg1, arg2;
13264: xmlNodePtr bak;
13265: xmlDocPtr bakd;
13266: int pp;
13267: int cs;
13268:
13269: CHECK_ERROR0;
13270: comp = ctxt->comp;
13271: switch (op->op) {
13272: case XPATH_OP_END:
13273: return (0);
13274: case XPATH_OP_AND:
13275: bakd = ctxt->context->doc;
13276: bak = ctxt->context->node;
13277: pp = ctxt->context->proximityPosition;
13278: cs = ctxt->context->contextSize;
13279: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13280: CHECK_ERROR0;
13281: xmlXPathBooleanFunction(ctxt, 1);
13282: if ((ctxt->value == NULL) || (ctxt->value->boolval == 0))
13283: return (total);
13284: arg2 = valuePop(ctxt);
13285: ctxt->context->doc = bakd;
13286: ctxt->context->node = bak;
13287: ctxt->context->proximityPosition = pp;
13288: ctxt->context->contextSize = cs;
13289: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13290: if (ctxt->error) {
13291: xmlXPathFreeObject(arg2);
13292: return(0);
13293: }
13294: xmlXPathBooleanFunction(ctxt, 1);
13295: arg1 = valuePop(ctxt);
13296: arg1->boolval &= arg2->boolval;
13297: valuePush(ctxt, arg1);
13298: xmlXPathReleaseObject(ctxt->context, arg2);
13299: return (total);
13300: case XPATH_OP_OR:
13301: bakd = ctxt->context->doc;
13302: bak = ctxt->context->node;
13303: pp = ctxt->context->proximityPosition;
13304: cs = ctxt->context->contextSize;
13305: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13306: CHECK_ERROR0;
13307: xmlXPathBooleanFunction(ctxt, 1);
13308: if ((ctxt->value == NULL) || (ctxt->value->boolval == 1))
13309: return (total);
13310: arg2 = valuePop(ctxt);
13311: ctxt->context->doc = bakd;
13312: ctxt->context->node = bak;
13313: ctxt->context->proximityPosition = pp;
13314: ctxt->context->contextSize = cs;
13315: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13316: if (ctxt->error) {
13317: xmlXPathFreeObject(arg2);
13318: return(0);
13319: }
13320: xmlXPathBooleanFunction(ctxt, 1);
13321: arg1 = valuePop(ctxt);
13322: arg1->boolval |= arg2->boolval;
13323: valuePush(ctxt, arg1);
13324: xmlXPathReleaseObject(ctxt->context, arg2);
13325: return (total);
13326: case XPATH_OP_EQUAL:
13327: bakd = ctxt->context->doc;
13328: bak = ctxt->context->node;
13329: pp = ctxt->context->proximityPosition;
13330: cs = ctxt->context->contextSize;
13331: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13332: CHECK_ERROR0;
13333: ctxt->context->doc = bakd;
13334: ctxt->context->node = bak;
13335: ctxt->context->proximityPosition = pp;
13336: ctxt->context->contextSize = cs;
13337: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13338: CHECK_ERROR0;
13339: if (op->value)
13340: equal = xmlXPathEqualValues(ctxt);
13341: else
13342: equal = xmlXPathNotEqualValues(ctxt);
13343: valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, equal));
13344: return (total);
13345: case XPATH_OP_CMP:
13346: bakd = ctxt->context->doc;
13347: bak = ctxt->context->node;
13348: pp = ctxt->context->proximityPosition;
13349: cs = ctxt->context->contextSize;
13350: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13351: CHECK_ERROR0;
13352: ctxt->context->doc = bakd;
13353: ctxt->context->node = bak;
13354: ctxt->context->proximityPosition = pp;
13355: ctxt->context->contextSize = cs;
13356: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13357: CHECK_ERROR0;
13358: ret = xmlXPathCompareValues(ctxt, op->value, op->value2);
13359: valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, ret));
13360: return (total);
13361: case XPATH_OP_PLUS:
13362: bakd = ctxt->context->doc;
13363: bak = ctxt->context->node;
13364: pp = ctxt->context->proximityPosition;
13365: cs = ctxt->context->contextSize;
13366: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13367: CHECK_ERROR0;
13368: if (op->ch2 != -1) {
13369: ctxt->context->doc = bakd;
13370: ctxt->context->node = bak;
13371: ctxt->context->proximityPosition = pp;
13372: ctxt->context->contextSize = cs;
13373: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13374: }
13375: CHECK_ERROR0;
13376: if (op->value == 0)
13377: xmlXPathSubValues(ctxt);
13378: else if (op->value == 1)
13379: xmlXPathAddValues(ctxt);
13380: else if (op->value == 2)
13381: xmlXPathValueFlipSign(ctxt);
13382: else if (op->value == 3) {
13383: CAST_TO_NUMBER;
13384: CHECK_TYPE0(XPATH_NUMBER);
13385: }
13386: return (total);
13387: case XPATH_OP_MULT:
13388: bakd = ctxt->context->doc;
13389: bak = ctxt->context->node;
13390: pp = ctxt->context->proximityPosition;
13391: cs = ctxt->context->contextSize;
13392: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13393: CHECK_ERROR0;
13394: ctxt->context->doc = bakd;
13395: ctxt->context->node = bak;
13396: ctxt->context->proximityPosition = pp;
13397: ctxt->context->contextSize = cs;
13398: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13399: CHECK_ERROR0;
13400: if (op->value == 0)
13401: xmlXPathMultValues(ctxt);
13402: else if (op->value == 1)
13403: xmlXPathDivValues(ctxt);
13404: else if (op->value == 2)
13405: xmlXPathModValues(ctxt);
13406: return (total);
13407: case XPATH_OP_UNION:
13408: bakd = ctxt->context->doc;
13409: bak = ctxt->context->node;
13410: pp = ctxt->context->proximityPosition;
13411: cs = ctxt->context->contextSize;
13412: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13413: CHECK_ERROR0;
13414: ctxt->context->doc = bakd;
13415: ctxt->context->node = bak;
13416: ctxt->context->proximityPosition = pp;
13417: ctxt->context->contextSize = cs;
13418: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13419: CHECK_ERROR0;
13420: CHECK_TYPE0(XPATH_NODESET);
13421: arg2 = valuePop(ctxt);
13422:
13423: CHECK_TYPE0(XPATH_NODESET);
13424: arg1 = valuePop(ctxt);
13425:
13426: if ((arg1->nodesetval == NULL) ||
13427: ((arg2->nodesetval != NULL) &&
13428: (arg2->nodesetval->nodeNr != 0)))
13429: {
13430: arg1->nodesetval = xmlXPathNodeSetMerge(arg1->nodesetval,
13431: arg2->nodesetval);
13432: }
13433:
13434: valuePush(ctxt, arg1);
13435: xmlXPathReleaseObject(ctxt->context, arg2);
13436: return (total);
13437: case XPATH_OP_ROOT:
13438: xmlXPathRoot(ctxt);
13439: return (total);
13440: case XPATH_OP_NODE:
13441: if (op->ch1 != -1)
13442: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13443: CHECK_ERROR0;
13444: if (op->ch2 != -1)
13445: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13446: CHECK_ERROR0;
13447: valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context,
13448: ctxt->context->node));
13449: return (total);
13450: case XPATH_OP_RESET:
13451: if (op->ch1 != -1)
13452: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13453: CHECK_ERROR0;
13454: if (op->ch2 != -1)
13455: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13456: CHECK_ERROR0;
13457: ctxt->context->node = NULL;
13458: return (total);
13459: case XPATH_OP_COLLECT:{
13460: if (op->ch1 == -1)
13461: return (total);
13462:
13463: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13464: CHECK_ERROR0;
13465:
13466: total += xmlXPathNodeCollectAndTest(ctxt, op, NULL, NULL, 0);
13467: return (total);
13468: }
13469: case XPATH_OP_VALUE:
13470: valuePush(ctxt,
13471: xmlXPathCacheObjectCopy(ctxt->context,
13472: (xmlXPathObjectPtr) op->value4));
13473: return (total);
13474: case XPATH_OP_VARIABLE:{
13475: xmlXPathObjectPtr val;
13476:
13477: if (op->ch1 != -1)
13478: total +=
13479: xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13480: if (op->value5 == NULL) {
13481: val = xmlXPathVariableLookup(ctxt->context, op->value4);
13482: if (val == NULL) {
13483: ctxt->error = XPATH_UNDEF_VARIABLE_ERROR;
13484: return(0);
13485: }
13486: valuePush(ctxt, val);
13487: } else {
13488: const xmlChar *URI;
13489:
13490: URI = xmlXPathNsLookup(ctxt->context, op->value5);
13491: if (URI == NULL) {
13492: xmlGenericError(xmlGenericErrorContext,
13493: "xmlXPathCompOpEval: variable %s bound to undefined prefix %s\n",
13494: (char *) op->value4, (char *)op->value5);
13495: ctxt->error = XPATH_UNDEF_PREFIX_ERROR;
13496: return (total);
13497: }
13498: val = xmlXPathVariableLookupNS(ctxt->context,
13499: op->value4, URI);
13500: if (val == NULL) {
13501: ctxt->error = XPATH_UNDEF_VARIABLE_ERROR;
13502: return(0);
13503: }
13504: valuePush(ctxt, val);
13505: }
13506: return (total);
13507: }
13508: case XPATH_OP_FUNCTION:{
13509: xmlXPathFunction func;
13510: const xmlChar *oldFunc, *oldFuncURI;
13511: int i;
13512: int frame;
13513:
13514: frame = xmlXPathSetFrame(ctxt);
13515: if (op->ch1 != -1)
13516: total +=
13517: xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13518: if (ctxt->valueNr < op->value) {
13519: xmlGenericError(xmlGenericErrorContext,
13520: "xmlXPathCompOpEval: parameter error\n");
13521: ctxt->error = XPATH_INVALID_OPERAND;
13522: xmlXPathPopFrame(ctxt, frame);
13523: return (total);
13524: }
13525: for (i = 0; i < op->value; i++) {
13526: if (ctxt->valueTab[(ctxt->valueNr - 1) - i] == NULL) {
13527: xmlGenericError(xmlGenericErrorContext,
13528: "xmlXPathCompOpEval: parameter error\n");
13529: ctxt->error = XPATH_INVALID_OPERAND;
13530: xmlXPathPopFrame(ctxt, frame);
13531: return (total);
13532: }
13533: }
13534: if (op->cache != NULL)
13535: XML_CAST_FPTR(func) = op->cache;
13536: else {
13537: const xmlChar *URI = NULL;
13538:
13539: if (op->value5 == NULL)
13540: func =
13541: xmlXPathFunctionLookup(ctxt->context,
13542: op->value4);
13543: else {
13544: URI = xmlXPathNsLookup(ctxt->context, op->value5);
13545: if (URI == NULL) {
13546: xmlGenericError(xmlGenericErrorContext,
13547: "xmlXPathCompOpEval: function %s bound to undefined prefix %s\n",
13548: (char *)op->value4, (char *)op->value5);
13549: xmlXPathPopFrame(ctxt, frame);
13550: ctxt->error = XPATH_UNDEF_PREFIX_ERROR;
13551: return (total);
13552: }
13553: func = xmlXPathFunctionLookupNS(ctxt->context,
13554: op->value4, URI);
13555: }
13556: if (func == NULL) {
13557: xmlGenericError(xmlGenericErrorContext,
13558: "xmlXPathCompOpEval: function %s not found\n",
13559: (char *)op->value4);
13560: XP_ERROR0(XPATH_UNKNOWN_FUNC_ERROR);
13561: }
13562: op->cache = XML_CAST_FPTR(func);
13563: op->cacheURI = (void *) URI;
13564: }
13565: oldFunc = ctxt->context->function;
13566: oldFuncURI = ctxt->context->functionURI;
13567: ctxt->context->function = op->value4;
13568: ctxt->context->functionURI = op->cacheURI;
13569: func(ctxt, op->value);
13570: ctxt->context->function = oldFunc;
13571: ctxt->context->functionURI = oldFuncURI;
13572: xmlXPathPopFrame(ctxt, frame);
13573: return (total);
13574: }
13575: case XPATH_OP_ARG:
13576: bakd = ctxt->context->doc;
13577: bak = ctxt->context->node;
13578: pp = ctxt->context->proximityPosition;
13579: cs = ctxt->context->contextSize;
13580: if (op->ch1 != -1)
13581: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13582: ctxt->context->contextSize = cs;
13583: ctxt->context->proximityPosition = pp;
13584: ctxt->context->node = bak;
13585: ctxt->context->doc = bakd;
13586: CHECK_ERROR0;
13587: if (op->ch2 != -1) {
13588: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13589: ctxt->context->doc = bakd;
13590: ctxt->context->node = bak;
13591: CHECK_ERROR0;
13592: }
13593: return (total);
13594: case XPATH_OP_PREDICATE:
13595: case XPATH_OP_FILTER:{
13596: xmlXPathObjectPtr res;
13597: xmlXPathObjectPtr obj, tmp;
13598: xmlNodeSetPtr newset = NULL;
13599: xmlNodeSetPtr oldset;
13600: xmlNodePtr oldnode;
13601: xmlDocPtr oldDoc;
13602: int i;
13603:
13604: /*
13605: * Optimization for ()[1] selection i.e. the first elem
13606: */
13607: if ((op->ch1 != -1) && (op->ch2 != -1) &&
13608: #ifdef XP_OPTIMIZED_FILTER_FIRST
13609: /*
13610: * FILTER TODO: Can we assume that the inner processing
13611: * will result in an ordered list if we have an
13612: * XPATH_OP_FILTER?
13613: * What about an additional field or flag on
13614: * xmlXPathObject like @sorted ? This way we wouln'd need
13615: * to assume anything, so it would be more robust and
13616: * easier to optimize.
13617: */
13618: ((comp->steps[op->ch1].op == XPATH_OP_SORT) || /* 18 */
13619: (comp->steps[op->ch1].op == XPATH_OP_FILTER)) && /* 17 */
13620: #else
13621: (comp->steps[op->ch1].op == XPATH_OP_SORT) &&
13622: #endif
13623: (comp->steps[op->ch2].op == XPATH_OP_VALUE)) { /* 12 */
13624: xmlXPathObjectPtr val;
13625:
13626: val = comp->steps[op->ch2].value4;
13627: if ((val != NULL) && (val->type == XPATH_NUMBER) &&
13628: (val->floatval == 1.0)) {
13629: xmlNodePtr first = NULL;
13630:
13631: total +=
13632: xmlXPathCompOpEvalFirst(ctxt,
13633: &comp->steps[op->ch1],
13634: &first);
13635: CHECK_ERROR0;
13636: /*
13637: * The nodeset should be in document order,
13638: * Keep only the first value
13639: */
13640: if ((ctxt->value != NULL) &&
13641: (ctxt->value->type == XPATH_NODESET) &&
13642: (ctxt->value->nodesetval != NULL) &&
13643: (ctxt->value->nodesetval->nodeNr > 1))
13644: ctxt->value->nodesetval->nodeNr = 1;
13645: return (total);
13646: }
13647: }
13648: /*
13649: * Optimization for ()[last()] selection i.e. the last elem
13650: */
13651: if ((op->ch1 != -1) && (op->ch2 != -1) &&
13652: (comp->steps[op->ch1].op == XPATH_OP_SORT) &&
13653: (comp->steps[op->ch2].op == XPATH_OP_SORT)) {
13654: int f = comp->steps[op->ch2].ch1;
13655:
13656: if ((f != -1) &&
13657: (comp->steps[f].op == XPATH_OP_FUNCTION) &&
13658: (comp->steps[f].value5 == NULL) &&
13659: (comp->steps[f].value == 0) &&
13660: (comp->steps[f].value4 != NULL) &&
13661: (xmlStrEqual
13662: (comp->steps[f].value4, BAD_CAST "last"))) {
13663: xmlNodePtr last = NULL;
13664:
13665: total +=
13666: xmlXPathCompOpEvalLast(ctxt,
13667: &comp->steps[op->ch1],
13668: &last);
13669: CHECK_ERROR0;
13670: /*
13671: * The nodeset should be in document order,
13672: * Keep only the last value
13673: */
13674: if ((ctxt->value != NULL) &&
13675: (ctxt->value->type == XPATH_NODESET) &&
13676: (ctxt->value->nodesetval != NULL) &&
13677: (ctxt->value->nodesetval->nodeTab != NULL) &&
13678: (ctxt->value->nodesetval->nodeNr > 1)) {
13679: ctxt->value->nodesetval->nodeTab[0] =
13680: ctxt->value->nodesetval->nodeTab[ctxt->
13681: value->
13682: nodesetval->
13683: nodeNr -
13684: 1];
13685: ctxt->value->nodesetval->nodeNr = 1;
13686: }
13687: return (total);
13688: }
13689: }
13690: /*
13691: * Process inner predicates first.
13692: * Example "index[parent::book][1]":
13693: * ...
13694: * PREDICATE <-- we are here "[1]"
13695: * PREDICATE <-- process "[parent::book]" first
13696: * SORT
13697: * COLLECT 'parent' 'name' 'node' book
13698: * NODE
13699: * ELEM Object is a number : 1
13700: */
13701: if (op->ch1 != -1)
13702: total +=
13703: xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13704: CHECK_ERROR0;
13705: if (op->ch2 == -1)
13706: return (total);
13707: if (ctxt->value == NULL)
13708: return (total);
13709:
13710: oldnode = ctxt->context->node;
13711:
13712: #ifdef LIBXML_XPTR_ENABLED
13713: /*
13714: * Hum are we filtering the result of an XPointer expression
13715: */
13716: if (ctxt->value->type == XPATH_LOCATIONSET) {
13717: xmlLocationSetPtr newlocset = NULL;
13718: xmlLocationSetPtr oldlocset;
13719:
13720: /*
13721: * Extract the old locset, and then evaluate the result of the
13722: * expression for all the element in the locset. use it to grow
13723: * up a new locset.
13724: */
13725: CHECK_TYPE0(XPATH_LOCATIONSET);
13726: obj = valuePop(ctxt);
13727: oldlocset = obj->user;
13728: ctxt->context->node = NULL;
13729:
13730: if ((oldlocset == NULL) || (oldlocset->locNr == 0)) {
13731: ctxt->context->contextSize = 0;
13732: ctxt->context->proximityPosition = 0;
13733: if (op->ch2 != -1)
13734: total +=
13735: xmlXPathCompOpEval(ctxt,
13736: &comp->steps[op->ch2]);
13737: res = valuePop(ctxt);
13738: if (res != NULL) {
13739: xmlXPathReleaseObject(ctxt->context, res);
13740: }
13741: valuePush(ctxt, obj);
13742: CHECK_ERROR0;
13743: return (total);
13744: }
13745: newlocset = xmlXPtrLocationSetCreate(NULL);
13746:
13747: for (i = 0; i < oldlocset->locNr; i++) {
13748: /*
13749: * Run the evaluation with a node list made of a
13750: * single item in the nodelocset.
13751: */
13752: ctxt->context->node = oldlocset->locTab[i]->user;
13753: ctxt->context->contextSize = oldlocset->locNr;
13754: ctxt->context->proximityPosition = i + 1;
13755: tmp = xmlXPathCacheNewNodeSet(ctxt->context,
13756: ctxt->context->node);
13757: valuePush(ctxt, tmp);
13758:
13759: if (op->ch2 != -1)
13760: total +=
13761: xmlXPathCompOpEval(ctxt,
13762: &comp->steps[op->ch2]);
13763: if (ctxt->error != XPATH_EXPRESSION_OK) {
13764: xmlXPathFreeObject(obj);
13765: return(0);
13766: }
13767:
13768: /*
13769: * The result of the evaluation need to be tested to
13770: * decided whether the filter succeeded or not
13771: */
13772: res = valuePop(ctxt);
13773: if (xmlXPathEvaluatePredicateResult(ctxt, res)) {
13774: xmlXPtrLocationSetAdd(newlocset,
13775: xmlXPathObjectCopy
13776: (oldlocset->locTab[i]));
13777: }
13778:
13779: /*
13780: * Cleanup
13781: */
13782: if (res != NULL) {
13783: xmlXPathReleaseObject(ctxt->context, res);
13784: }
13785: if (ctxt->value == tmp) {
13786: res = valuePop(ctxt);
13787: xmlXPathReleaseObject(ctxt->context, res);
13788: }
13789:
13790: ctxt->context->node = NULL;
13791: }
13792:
13793: /*
13794: * The result is used as the new evaluation locset.
13795: */
13796: xmlXPathReleaseObject(ctxt->context, obj);
13797: ctxt->context->node = NULL;
13798: ctxt->context->contextSize = -1;
13799: ctxt->context->proximityPosition = -1;
13800: valuePush(ctxt, xmlXPtrWrapLocationSet(newlocset));
13801: ctxt->context->node = oldnode;
13802: return (total);
13803: }
13804: #endif /* LIBXML_XPTR_ENABLED */
13805:
13806: /*
13807: * Extract the old set, and then evaluate the result of the
13808: * expression for all the element in the set. use it to grow
13809: * up a new set.
13810: */
13811: CHECK_TYPE0(XPATH_NODESET);
13812: obj = valuePop(ctxt);
13813: oldset = obj->nodesetval;
13814:
13815: oldnode = ctxt->context->node;
13816: oldDoc = ctxt->context->doc;
13817: ctxt->context->node = NULL;
13818:
13819: if ((oldset == NULL) || (oldset->nodeNr == 0)) {
13820: ctxt->context->contextSize = 0;
13821: ctxt->context->proximityPosition = 0;
13822: /*
13823: if (op->ch2 != -1)
13824: total +=
13825: xmlXPathCompOpEval(ctxt,
13826: &comp->steps[op->ch2]);
13827: CHECK_ERROR0;
13828: res = valuePop(ctxt);
13829: if (res != NULL)
13830: xmlXPathFreeObject(res);
13831: */
13832: valuePush(ctxt, obj);
13833: ctxt->context->node = oldnode;
13834: CHECK_ERROR0;
13835: } else {
13836: tmp = NULL;
13837: /*
13838: * Initialize the new set.
13839: * Also set the xpath document in case things like
13840: * key() evaluation are attempted on the predicate
13841: */
13842: newset = xmlXPathNodeSetCreate(NULL);
13843: /*
13844: * SPEC XPath 1.0:
13845: * "For each node in the node-set to be filtered, the
13846: * PredicateExpr is evaluated with that node as the
13847: * context node, with the number of nodes in the
13848: * node-set as the context size, and with the proximity
13849: * position of the node in the node-set with respect to
13850: * the axis as the context position;"
13851: * @oldset is the node-set" to be filtered.
13852: *
13853: * SPEC XPath 1.0:
13854: * "only predicates change the context position and
13855: * context size (see [2.4 Predicates])."
13856: * Example:
13857: * node-set context pos
13858: * nA 1
13859: * nB 2
13860: * nC 3
13861: * After applying predicate [position() > 1] :
13862: * node-set context pos
13863: * nB 1
13864: * nC 2
13865: *
13866: * removed the first node in the node-set, then
13867: * the context position of the
13868: */
13869: for (i = 0; i < oldset->nodeNr; i++) {
13870: /*
13871: * Run the evaluation with a node list made of
13872: * a single item in the nodeset.
13873: */
13874: ctxt->context->node = oldset->nodeTab[i];
13875: if ((oldset->nodeTab[i]->type != XML_NAMESPACE_DECL) &&
13876: (oldset->nodeTab[i]->doc != NULL))
13877: ctxt->context->doc = oldset->nodeTab[i]->doc;
13878: if (tmp == NULL) {
13879: tmp = xmlXPathCacheNewNodeSet(ctxt->context,
13880: ctxt->context->node);
13881: } else {
13882: if (xmlXPathNodeSetAddUnique(tmp->nodesetval,
13883: ctxt->context->node) < 0) {
13884: ctxt->error = XPATH_MEMORY_ERROR;
13885: }
13886: }
13887: valuePush(ctxt, tmp);
13888: ctxt->context->contextSize = oldset->nodeNr;
13889: ctxt->context->proximityPosition = i + 1;
13890: /*
13891: * Evaluate the predicate against the context node.
13892: * Can/should we optimize position() predicates
13893: * here (e.g. "[1]")?
13894: */
13895: if (op->ch2 != -1)
13896: total +=
13897: xmlXPathCompOpEval(ctxt,
13898: &comp->steps[op->ch2]);
13899: if (ctxt->error != XPATH_EXPRESSION_OK) {
13900: xmlXPathFreeNodeSet(newset);
13901: xmlXPathFreeObject(obj);
13902: return(0);
13903: }
13904:
13905: /*
13906: * The result of the evaluation needs to be tested to
13907: * decide whether the filter succeeded or not
13908: */
13909: /*
13910: * OPTIMIZE TODO: Can we use
13911: * xmlXPathNodeSetAdd*Unique()* instead?
13912: */
13913: res = valuePop(ctxt);
13914: if (xmlXPathEvaluatePredicateResult(ctxt, res)) {
13915: if (xmlXPathNodeSetAdd(newset, oldset->nodeTab[i])
13916: < 0)
13917: ctxt->error = XPATH_MEMORY_ERROR;
13918: }
13919:
13920: /*
13921: * Cleanup
13922: */
13923: if (res != NULL) {
13924: xmlXPathReleaseObject(ctxt->context, res);
13925: }
13926: if (ctxt->value == tmp) {
13927: valuePop(ctxt);
13928: xmlXPathNodeSetClear(tmp->nodesetval, 1);
13929: /*
13930: * Don't free the temporary nodeset
13931: * in order to avoid massive recreation inside this
13932: * loop.
13933: */
13934: } else
13935: tmp = NULL;
13936: ctxt->context->node = NULL;
13937: }
13938: if (tmp != NULL)
13939: xmlXPathReleaseObject(ctxt->context, tmp);
13940: /*
13941: * The result is used as the new evaluation set.
13942: */
13943: xmlXPathReleaseObject(ctxt->context, obj);
13944: ctxt->context->node = NULL;
13945: ctxt->context->contextSize = -1;
13946: ctxt->context->proximityPosition = -1;
13947: /* may want to move this past the '}' later */
13948: ctxt->context->doc = oldDoc;
13949: valuePush(ctxt,
13950: xmlXPathCacheWrapNodeSet(ctxt->context, newset));
13951: }
13952: ctxt->context->node = oldnode;
13953: return (total);
13954: }
13955: case XPATH_OP_SORT:
13956: if (op->ch1 != -1)
13957: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13958: CHECK_ERROR0;
13959: if ((ctxt->value != NULL) &&
13960: (ctxt->value->type == XPATH_NODESET) &&
13961: (ctxt->value->nodesetval != NULL) &&
13962: (ctxt->value->nodesetval->nodeNr > 1))
13963: {
13964: xmlXPathNodeSetSort(ctxt->value->nodesetval);
13965: }
13966: return (total);
13967: #ifdef LIBXML_XPTR_ENABLED
13968: case XPATH_OP_RANGETO:{
13969: xmlXPathObjectPtr range;
13970: xmlXPathObjectPtr res, obj;
13971: xmlXPathObjectPtr tmp;
13972: xmlLocationSetPtr newlocset = NULL;
13973: xmlLocationSetPtr oldlocset;
13974: xmlNodeSetPtr oldset;
13975: int i, j;
13976:
13977: if (op->ch1 != -1)
13978: total +=
13979: xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13980: if (op->ch2 == -1)
13981: return (total);
13982:
13983: if (ctxt->value->type == XPATH_LOCATIONSET) {
13984: /*
13985: * Extract the old locset, and then evaluate the result of the
13986: * expression for all the element in the locset. use it to grow
13987: * up a new locset.
13988: */
13989: CHECK_TYPE0(XPATH_LOCATIONSET);
13990: obj = valuePop(ctxt);
13991: oldlocset = obj->user;
13992:
13993: if ((oldlocset == NULL) || (oldlocset->locNr == 0)) {
13994: ctxt->context->node = NULL;
13995: ctxt->context->contextSize = 0;
13996: ctxt->context->proximityPosition = 0;
13997: total += xmlXPathCompOpEval(ctxt,&comp->steps[op->ch2]);
13998: res = valuePop(ctxt);
13999: if (res != NULL) {
14000: xmlXPathReleaseObject(ctxt->context, res);
14001: }
14002: valuePush(ctxt, obj);
14003: CHECK_ERROR0;
14004: return (total);
14005: }
14006: newlocset = xmlXPtrLocationSetCreate(NULL);
14007:
14008: for (i = 0; i < oldlocset->locNr; i++) {
14009: /*
14010: * Run the evaluation with a node list made of a
14011: * single item in the nodelocset.
14012: */
14013: ctxt->context->node = oldlocset->locTab[i]->user;
14014: ctxt->context->contextSize = oldlocset->locNr;
14015: ctxt->context->proximityPosition = i + 1;
14016: tmp = xmlXPathCacheNewNodeSet(ctxt->context,
14017: ctxt->context->node);
14018: valuePush(ctxt, tmp);
14019:
14020: if (op->ch2 != -1)
14021: total +=
14022: xmlXPathCompOpEval(ctxt,
14023: &comp->steps[op->ch2]);
14024: if (ctxt->error != XPATH_EXPRESSION_OK) {
14025: xmlXPathFreeObject(obj);
14026: return(0);
14027: }
14028:
14029: res = valuePop(ctxt);
14030: if (res->type == XPATH_LOCATIONSET) {
14031: xmlLocationSetPtr rloc =
14032: (xmlLocationSetPtr)res->user;
14033: for (j=0; j<rloc->locNr; j++) {
14034: range = xmlXPtrNewRange(
14035: oldlocset->locTab[i]->user,
14036: oldlocset->locTab[i]->index,
14037: rloc->locTab[j]->user2,
14038: rloc->locTab[j]->index2);
14039: if (range != NULL) {
14040: xmlXPtrLocationSetAdd(newlocset, range);
14041: }
14042: }
14043: } else {
14044: range = xmlXPtrNewRangeNodeObject(
14045: (xmlNodePtr)oldlocset->locTab[i]->user, res);
14046: if (range != NULL) {
14047: xmlXPtrLocationSetAdd(newlocset,range);
14048: }
14049: }
14050:
14051: /*
14052: * Cleanup
14053: */
14054: if (res != NULL) {
14055: xmlXPathReleaseObject(ctxt->context, res);
14056: }
14057: if (ctxt->value == tmp) {
14058: res = valuePop(ctxt);
14059: xmlXPathReleaseObject(ctxt->context, res);
14060: }
14061:
14062: ctxt->context->node = NULL;
14063: }
14064: } else { /* Not a location set */
14065: CHECK_TYPE0(XPATH_NODESET);
14066: obj = valuePop(ctxt);
14067: oldset = obj->nodesetval;
14068: ctxt->context->node = NULL;
14069:
14070: newlocset = xmlXPtrLocationSetCreate(NULL);
14071:
14072: if (oldset != NULL) {
14073: for (i = 0; i < oldset->nodeNr; i++) {
14074: /*
14075: * Run the evaluation with a node list made of a single item
14076: * in the nodeset.
14077: */
14078: ctxt->context->node = oldset->nodeTab[i];
14079: /*
14080: * OPTIMIZE TODO: Avoid recreation for every iteration.
14081: */
14082: tmp = xmlXPathCacheNewNodeSet(ctxt->context,
14083: ctxt->context->node);
14084: valuePush(ctxt, tmp);
14085:
14086: if (op->ch2 != -1)
14087: total +=
14088: xmlXPathCompOpEval(ctxt,
14089: &comp->steps[op->ch2]);
14090: if (ctxt->error != XPATH_EXPRESSION_OK) {
14091: xmlXPathFreeObject(obj);
14092: return(0);
14093: }
14094:
14095: res = valuePop(ctxt);
14096: range =
14097: xmlXPtrNewRangeNodeObject(oldset->nodeTab[i],
14098: res);
14099: if (range != NULL) {
14100: xmlXPtrLocationSetAdd(newlocset, range);
14101: }
14102:
14103: /*
14104: * Cleanup
14105: */
14106: if (res != NULL) {
14107: xmlXPathReleaseObject(ctxt->context, res);
14108: }
14109: if (ctxt->value == tmp) {
14110: res = valuePop(ctxt);
14111: xmlXPathReleaseObject(ctxt->context, res);
14112: }
14113:
14114: ctxt->context->node = NULL;
14115: }
14116: }
14117: }
14118:
14119: /*
14120: * The result is used as the new evaluation set.
14121: */
14122: xmlXPathReleaseObject(ctxt->context, obj);
14123: ctxt->context->node = NULL;
14124: ctxt->context->contextSize = -1;
14125: ctxt->context->proximityPosition = -1;
14126: valuePush(ctxt, xmlXPtrWrapLocationSet(newlocset));
14127: return (total);
14128: }
14129: #endif /* LIBXML_XPTR_ENABLED */
14130: }
14131: xmlGenericError(xmlGenericErrorContext,
14132: "XPath: unknown precompiled operation %d\n", op->op);
14133: ctxt->error = XPATH_INVALID_OPERAND;
14134: return (total);
14135: }
14136:
14137: /**
14138: * xmlXPathCompOpEvalToBoolean:
14139: * @ctxt: the XPath parser context
14140: *
14141: * Evaluates if the expression evaluates to true.
14142: *
14143: * Returns 1 if true, 0 if false and -1 on API or internal errors.
14144: */
14145: static int
14146: xmlXPathCompOpEvalToBoolean(xmlXPathParserContextPtr ctxt,
14147: xmlXPathStepOpPtr op,
14148: int isPredicate)
14149: {
14150: xmlXPathObjectPtr resObj = NULL;
14151:
14152: start:
14153: /* comp = ctxt->comp; */
14154: switch (op->op) {
14155: case XPATH_OP_END:
14156: return (0);
14157: case XPATH_OP_VALUE:
14158: resObj = (xmlXPathObjectPtr) op->value4;
14159: if (isPredicate)
14160: return(xmlXPathEvaluatePredicateResult(ctxt, resObj));
14161: return(xmlXPathCastToBoolean(resObj));
14162: case XPATH_OP_SORT:
14163: /*
14164: * We don't need sorting for boolean results. Skip this one.
14165: */
14166: if (op->ch1 != -1) {
14167: op = &ctxt->comp->steps[op->ch1];
14168: goto start;
14169: }
14170: return(0);
14171: case XPATH_OP_COLLECT:
14172: if (op->ch1 == -1)
14173: return(0);
14174:
14175: xmlXPathCompOpEval(ctxt, &ctxt->comp->steps[op->ch1]);
14176: if (ctxt->error != XPATH_EXPRESSION_OK)
14177: return(-1);
14178:
14179: xmlXPathNodeCollectAndTest(ctxt, op, NULL, NULL, 1);
14180: if (ctxt->error != XPATH_EXPRESSION_OK)
14181: return(-1);
14182:
14183: resObj = valuePop(ctxt);
14184: if (resObj == NULL)
14185: return(-1);
14186: break;
14187: default:
14188: /*
14189: * Fallback to call xmlXPathCompOpEval().
14190: */
14191: xmlXPathCompOpEval(ctxt, op);
14192: if (ctxt->error != XPATH_EXPRESSION_OK)
14193: return(-1);
14194:
14195: resObj = valuePop(ctxt);
14196: if (resObj == NULL)
14197: return(-1);
14198: break;
14199: }
14200:
14201: if (resObj) {
14202: int res;
14203:
14204: if (resObj->type == XPATH_BOOLEAN) {
14205: res = resObj->boolval;
14206: } else if (isPredicate) {
14207: /*
14208: * For predicates a result of type "number" is handled
14209: * differently:
14210: * SPEC XPath 1.0:
14211: * "If the result is a number, the result will be converted
14212: * to true if the number is equal to the context position
14213: * and will be converted to false otherwise;"
14214: */
14215: res = xmlXPathEvaluatePredicateResult(ctxt, resObj);
14216: } else {
14217: res = xmlXPathCastToBoolean(resObj);
14218: }
14219: xmlXPathReleaseObject(ctxt->context, resObj);
14220: return(res);
14221: }
14222:
14223: return(0);
14224: }
14225:
14226: #ifdef XPATH_STREAMING
14227: /**
14228: * xmlXPathRunStreamEval:
14229: * @ctxt: the XPath parser context with the compiled expression
14230: *
14231: * Evaluate the Precompiled Streamable XPath expression in the given context.
14232: */
14233: static int
14234: xmlXPathRunStreamEval(xmlXPathContextPtr ctxt, xmlPatternPtr comp,
14235: xmlXPathObjectPtr *resultSeq, int toBool)
14236: {
14237: int max_depth, min_depth;
14238: int from_root;
14239: int ret, depth;
14240: int eval_all_nodes;
14241: xmlNodePtr cur = NULL, limit = NULL;
14242: xmlStreamCtxtPtr patstream = NULL;
14243:
14244: int nb_nodes = 0;
14245:
14246: if ((ctxt == NULL) || (comp == NULL))
14247: return(-1);
14248: max_depth = xmlPatternMaxDepth(comp);
14249: if (max_depth == -1)
14250: return(-1);
14251: if (max_depth == -2)
14252: max_depth = 10000;
14253: min_depth = xmlPatternMinDepth(comp);
14254: if (min_depth == -1)
14255: return(-1);
14256: from_root = xmlPatternFromRoot(comp);
14257: if (from_root < 0)
14258: return(-1);
14259: #if 0
14260: printf("stream eval: depth %d from root %d\n", max_depth, from_root);
14261: #endif
14262:
14263: if (! toBool) {
14264: if (resultSeq == NULL)
14265: return(-1);
14266: *resultSeq = xmlXPathCacheNewNodeSet(ctxt, NULL);
14267: if (*resultSeq == NULL)
14268: return(-1);
14269: }
14270:
14271: /*
14272: * handle the special cases of "/" amd "." being matched
14273: */
14274: if (min_depth == 0) {
14275: if (from_root) {
14276: /* Select "/" */
14277: if (toBool)
14278: return(1);
14279: xmlXPathNodeSetAddUnique((*resultSeq)->nodesetval,
14280: (xmlNodePtr) ctxt->doc);
14281: } else {
14282: /* Select "self::node()" */
14283: if (toBool)
14284: return(1);
14285: xmlXPathNodeSetAddUnique((*resultSeq)->nodesetval, ctxt->node);
14286: }
14287: }
14288: if (max_depth == 0) {
14289: return(0);
14290: }
14291:
14292: if (from_root) {
14293: cur = (xmlNodePtr)ctxt->doc;
14294: } else if (ctxt->node != NULL) {
14295: switch (ctxt->node->type) {
14296: case XML_ELEMENT_NODE:
14297: case XML_DOCUMENT_NODE:
14298: case XML_DOCUMENT_FRAG_NODE:
14299: case XML_HTML_DOCUMENT_NODE:
14300: #ifdef LIBXML_DOCB_ENABLED
14301: case XML_DOCB_DOCUMENT_NODE:
14302: #endif
14303: cur = ctxt->node;
14304: break;
14305: case XML_ATTRIBUTE_NODE:
14306: case XML_TEXT_NODE:
14307: case XML_CDATA_SECTION_NODE:
14308: case XML_ENTITY_REF_NODE:
14309: case XML_ENTITY_NODE:
14310: case XML_PI_NODE:
14311: case XML_COMMENT_NODE:
14312: case XML_NOTATION_NODE:
14313: case XML_DTD_NODE:
14314: case XML_DOCUMENT_TYPE_NODE:
14315: case XML_ELEMENT_DECL:
14316: case XML_ATTRIBUTE_DECL:
14317: case XML_ENTITY_DECL:
14318: case XML_NAMESPACE_DECL:
14319: case XML_XINCLUDE_START:
14320: case XML_XINCLUDE_END:
14321: break;
14322: }
14323: limit = cur;
14324: }
14325: if (cur == NULL) {
14326: return(0);
14327: }
14328:
14329: patstream = xmlPatternGetStreamCtxt(comp);
14330: if (patstream == NULL) {
14331: /*
14332: * QUESTION TODO: Is this an error?
14333: */
14334: return(0);
14335: }
14336:
14337: eval_all_nodes = xmlStreamWantsAnyNode(patstream);
14338:
14339: if (from_root) {
14340: ret = xmlStreamPush(patstream, NULL, NULL);
14341: if (ret < 0) {
14342: } else if (ret == 1) {
14343: if (toBool)
14344: goto return_1;
14345: xmlXPathNodeSetAddUnique((*resultSeq)->nodesetval, cur);
14346: }
14347: }
14348: depth = 0;
14349: goto scan_children;
14350: next_node:
14351: do {
14352: nb_nodes++;
14353:
14354: switch (cur->type) {
14355: case XML_ELEMENT_NODE:
14356: case XML_TEXT_NODE:
14357: case XML_CDATA_SECTION_NODE:
14358: case XML_COMMENT_NODE:
14359: case XML_PI_NODE:
14360: if (cur->type == XML_ELEMENT_NODE) {
14361: ret = xmlStreamPush(patstream, cur->name,
14362: (cur->ns ? cur->ns->href : NULL));
14363: } else if (eval_all_nodes)
14364: ret = xmlStreamPushNode(patstream, NULL, NULL, cur->type);
14365: else
14366: break;
14367:
14368: if (ret < 0) {
14369: /* NOP. */
14370: } else if (ret == 1) {
14371: if (toBool)
14372: goto return_1;
14373: if (xmlXPathNodeSetAddUnique((*resultSeq)->nodesetval, cur)
14374: < 0) {
14375: ctxt->lastError.domain = XML_FROM_XPATH;
14376: ctxt->lastError.code = XML_ERR_NO_MEMORY;
14377: }
14378: }
14379: if ((cur->children == NULL) || (depth >= max_depth)) {
14380: ret = xmlStreamPop(patstream);
14381: while (cur->next != NULL) {
14382: cur = cur->next;
14383: if ((cur->type != XML_ENTITY_DECL) &&
14384: (cur->type != XML_DTD_NODE))
14385: goto next_node;
14386: }
14387: }
14388: default:
14389: break;
14390: }
14391:
14392: scan_children:
14393: if (cur->type == XML_NAMESPACE_DECL) break;
14394: if ((cur->children != NULL) && (depth < max_depth)) {
14395: /*
14396: * Do not descend on entities declarations
14397: */
14398: if (cur->children->type != XML_ENTITY_DECL) {
14399: cur = cur->children;
14400: depth++;
14401: /*
14402: * Skip DTDs
14403: */
14404: if (cur->type != XML_DTD_NODE)
14405: continue;
14406: }
14407: }
14408:
14409: if (cur == limit)
14410: break;
14411:
14412: while (cur->next != NULL) {
14413: cur = cur->next;
14414: if ((cur->type != XML_ENTITY_DECL) &&
14415: (cur->type != XML_DTD_NODE))
14416: goto next_node;
14417: }
14418:
14419: do {
14420: cur = cur->parent;
14421: depth--;
14422: if ((cur == NULL) || (cur == limit))
14423: goto done;
14424: if (cur->type == XML_ELEMENT_NODE) {
14425: ret = xmlStreamPop(patstream);
14426: } else if ((eval_all_nodes) &&
14427: ((cur->type == XML_TEXT_NODE) ||
14428: (cur->type == XML_CDATA_SECTION_NODE) ||
14429: (cur->type == XML_COMMENT_NODE) ||
14430: (cur->type == XML_PI_NODE)))
14431: {
14432: ret = xmlStreamPop(patstream);
14433: }
14434: if (cur->next != NULL) {
14435: cur = cur->next;
14436: break;
14437: }
14438: } while (cur != NULL);
14439:
14440: } while ((cur != NULL) && (depth >= 0));
14441:
14442: done:
14443:
14444: #if 0
14445: printf("stream eval: checked %d nodes selected %d\n",
14446: nb_nodes, retObj->nodesetval->nodeNr);
14447: #endif
14448:
14449: if (patstream)
14450: xmlFreeStreamCtxt(patstream);
14451: return(0);
14452:
14453: return_1:
14454: if (patstream)
14455: xmlFreeStreamCtxt(patstream);
14456: return(1);
14457: }
14458: #endif /* XPATH_STREAMING */
14459:
14460: /**
14461: * xmlXPathRunEval:
14462: * @ctxt: the XPath parser context with the compiled expression
14463: * @toBool: evaluate to a boolean result
14464: *
14465: * Evaluate the Precompiled XPath expression in the given context.
14466: */
14467: static int
14468: xmlXPathRunEval(xmlXPathParserContextPtr ctxt, int toBool)
14469: {
14470: xmlXPathCompExprPtr comp;
14471:
14472: if ((ctxt == NULL) || (ctxt->comp == NULL))
14473: return(-1);
14474:
14475: if (ctxt->valueTab == NULL) {
14476: /* Allocate the value stack */
14477: ctxt->valueTab = (xmlXPathObjectPtr *)
14478: xmlMalloc(10 * sizeof(xmlXPathObjectPtr));
14479: if (ctxt->valueTab == NULL) {
14480: xmlXPathPErrMemory(ctxt, "creating evaluation context\n");
14481: xmlFree(ctxt);
14482: }
14483: ctxt->valueNr = 0;
14484: ctxt->valueMax = 10;
14485: ctxt->value = NULL;
14486: ctxt->valueFrame = 0;
14487: }
14488: #ifdef XPATH_STREAMING
14489: if (ctxt->comp->stream) {
14490: int res;
14491:
14492: if (toBool) {
14493: /*
14494: * Evaluation to boolean result.
14495: */
14496: res = xmlXPathRunStreamEval(ctxt->context,
14497: ctxt->comp->stream, NULL, 1);
14498: if (res != -1)
14499: return(res);
14500: } else {
14501: xmlXPathObjectPtr resObj = NULL;
14502:
14503: /*
14504: * Evaluation to a sequence.
14505: */
14506: res = xmlXPathRunStreamEval(ctxt->context,
14507: ctxt->comp->stream, &resObj, 0);
14508:
14509: if ((res != -1) && (resObj != NULL)) {
14510: valuePush(ctxt, resObj);
14511: return(0);
14512: }
14513: if (resObj != NULL)
14514: xmlXPathReleaseObject(ctxt->context, resObj);
14515: }
14516: /*
14517: * QUESTION TODO: This falls back to normal XPath evaluation
14518: * if res == -1. Is this intended?
14519: */
14520: }
14521: #endif
14522: comp = ctxt->comp;
14523: if (comp->last < 0) {
14524: xmlGenericError(xmlGenericErrorContext,
14525: "xmlXPathRunEval: last is less than zero\n");
14526: return(-1);
14527: }
14528: if (toBool)
14529: return(xmlXPathCompOpEvalToBoolean(ctxt,
14530: &comp->steps[comp->last], 0));
14531: else
14532: xmlXPathCompOpEval(ctxt, &comp->steps[comp->last]);
14533:
14534: return(0);
14535: }
14536:
14537: /************************************************************************
14538: * *
14539: * Public interfaces *
14540: * *
14541: ************************************************************************/
14542:
14543: /**
14544: * xmlXPathEvalPredicate:
14545: * @ctxt: the XPath context
14546: * @res: the Predicate Expression evaluation result
14547: *
14548: * Evaluate a predicate result for the current node.
14549: * A PredicateExpr is evaluated by evaluating the Expr and converting
14550: * the result to a boolean. If the result is a number, the result will
14551: * be converted to true if the number is equal to the position of the
14552: * context node in the context node list (as returned by the position
14553: * function) and will be converted to false otherwise; if the result
14554: * is not a number, then the result will be converted as if by a call
14555: * to the boolean function.
14556: *
14557: * Returns 1 if predicate is true, 0 otherwise
14558: */
14559: int
14560: xmlXPathEvalPredicate(xmlXPathContextPtr ctxt, xmlXPathObjectPtr res) {
14561: if ((ctxt == NULL) || (res == NULL)) return(0);
14562: switch (res->type) {
14563: case XPATH_BOOLEAN:
14564: return(res->boolval);
14565: case XPATH_NUMBER:
14566: return(res->floatval == ctxt->proximityPosition);
14567: case XPATH_NODESET:
14568: case XPATH_XSLT_TREE:
14569: if (res->nodesetval == NULL)
14570: return(0);
14571: return(res->nodesetval->nodeNr != 0);
14572: case XPATH_STRING:
14573: return((res->stringval != NULL) &&
14574: (xmlStrlen(res->stringval) != 0));
14575: default:
14576: STRANGE
14577: }
14578: return(0);
14579: }
14580:
14581: /**
14582: * xmlXPathEvaluatePredicateResult:
14583: * @ctxt: the XPath Parser context
14584: * @res: the Predicate Expression evaluation result
14585: *
14586: * Evaluate a predicate result for the current node.
14587: * A PredicateExpr is evaluated by evaluating the Expr and converting
14588: * the result to a boolean. If the result is a number, the result will
14589: * be converted to true if the number is equal to the position of the
14590: * context node in the context node list (as returned by the position
14591: * function) and will be converted to false otherwise; if the result
14592: * is not a number, then the result will be converted as if by a call
14593: * to the boolean function.
14594: *
14595: * Returns 1 if predicate is true, 0 otherwise
14596: */
14597: int
14598: xmlXPathEvaluatePredicateResult(xmlXPathParserContextPtr ctxt,
14599: xmlXPathObjectPtr res) {
14600: if ((ctxt == NULL) || (res == NULL)) return(0);
14601: switch (res->type) {
14602: case XPATH_BOOLEAN:
14603: return(res->boolval);
14604: case XPATH_NUMBER:
14605: #if defined(__BORLANDC__) || (defined(_MSC_VER) && (_MSC_VER == 1200))
14606: return((res->floatval == ctxt->context->proximityPosition) &&
14607: (!xmlXPathIsNaN(res->floatval))); /* MSC pbm Mark Vakoc !*/
14608: #else
14609: return(res->floatval == ctxt->context->proximityPosition);
14610: #endif
14611: case XPATH_NODESET:
14612: case XPATH_XSLT_TREE:
14613: if (res->nodesetval == NULL)
14614: return(0);
14615: return(res->nodesetval->nodeNr != 0);
14616: case XPATH_STRING:
14617: return((res->stringval != NULL) && (res->stringval[0] != 0));
14618: #ifdef LIBXML_XPTR_ENABLED
14619: case XPATH_LOCATIONSET:{
14620: xmlLocationSetPtr ptr = res->user;
14621: if (ptr == NULL)
14622: return(0);
14623: return (ptr->locNr != 0);
14624: }
14625: #endif
14626: default:
14627: STRANGE
14628: }
14629: return(0);
14630: }
14631:
14632: #ifdef XPATH_STREAMING
14633: /**
14634: * xmlXPathTryStreamCompile:
14635: * @ctxt: an XPath context
14636: * @str: the XPath expression
14637: *
14638: * Try to compile the XPath expression as a streamable subset.
14639: *
14640: * Returns the compiled expression or NULL if failed to compile.
14641: */
14642: static xmlXPathCompExprPtr
14643: xmlXPathTryStreamCompile(xmlXPathContextPtr ctxt, const xmlChar *str) {
14644: /*
14645: * Optimization: use streaming patterns when the XPath expression can
14646: * be compiled to a stream lookup
14647: */
14648: xmlPatternPtr stream;
14649: xmlXPathCompExprPtr comp;
14650: xmlDictPtr dict = NULL;
14651: const xmlChar **namespaces = NULL;
14652: xmlNsPtr ns;
14653: int i, j;
14654:
14655: if ((!xmlStrchr(str, '[')) && (!xmlStrchr(str, '(')) &&
14656: (!xmlStrchr(str, '@'))) {
14657: const xmlChar *tmp;
14658:
14659: /*
14660: * We don't try to handle expressions using the verbose axis
14661: * specifiers ("::"), just the simplied form at this point.
14662: * Additionally, if there is no list of namespaces available and
14663: * there's a ":" in the expression, indicating a prefixed QName,
14664: * then we won't try to compile either. xmlPatterncompile() needs
14665: * to have a list of namespaces at compilation time in order to
14666: * compile prefixed name tests.
14667: */
14668: tmp = xmlStrchr(str, ':');
14669: if ((tmp != NULL) &&
14670: ((ctxt == NULL) || (ctxt->nsNr == 0) || (tmp[1] == ':')))
14671: return(NULL);
14672:
14673: if (ctxt != NULL) {
14674: dict = ctxt->dict;
14675: if (ctxt->nsNr > 0) {
14676: namespaces = xmlMalloc(2 * (ctxt->nsNr + 1) * sizeof(xmlChar*));
14677: if (namespaces == NULL) {
14678: xmlXPathErrMemory(ctxt, "allocating namespaces array\n");
14679: return(NULL);
14680: }
14681: for (i = 0, j = 0; (j < ctxt->nsNr); j++) {
14682: ns = ctxt->namespaces[j];
14683: namespaces[i++] = ns->href;
14684: namespaces[i++] = ns->prefix;
14685: }
14686: namespaces[i++] = NULL;
14687: namespaces[i] = NULL;
14688: }
14689: }
14690:
14691: stream = xmlPatterncompile(str, dict, XML_PATTERN_XPATH,
14692: &namespaces[0]);
14693: if (namespaces != NULL) {
14694: xmlFree((xmlChar **)namespaces);
14695: }
14696: if ((stream != NULL) && (xmlPatternStreamable(stream) == 1)) {
14697: comp = xmlXPathNewCompExpr();
14698: if (comp == NULL) {
14699: xmlXPathErrMemory(ctxt, "allocating streamable expression\n");
14700: return(NULL);
14701: }
14702: comp->stream = stream;
14703: comp->dict = dict;
14704: if (comp->dict)
14705: xmlDictReference(comp->dict);
14706: return(comp);
14707: }
14708: xmlFreePattern(stream);
14709: }
14710: return(NULL);
14711: }
14712: #endif /* XPATH_STREAMING */
14713:
14714: static void
14715: xmlXPathOptimizeExpression(xmlXPathCompExprPtr comp, xmlXPathStepOpPtr op)
14716: {
14717: /*
14718: * Try to rewrite "descendant-or-self::node()/foo" to an optimized
14719: * internal representation.
14720: */
14721:
14722: if ((op->ch1 != -1) &&
14723: (op->op == XPATH_OP_COLLECT /* 11 */))
14724: {
14725: xmlXPathStepOpPtr prevop = &comp->steps[op->ch1];
14726:
14727: if ((prevop->op == XPATH_OP_COLLECT /* 11 */) &&
14728: ((xmlXPathAxisVal) prevop->value ==
14729: AXIS_DESCENDANT_OR_SELF) &&
14730: (prevop->ch2 == -1) &&
14731: ((xmlXPathTestVal) prevop->value2 == NODE_TEST_TYPE) &&
14732: ((xmlXPathTypeVal) prevop->value3 == NODE_TYPE_NODE))
14733: {
14734: /*
14735: * This is a "descendant-or-self::node()" without predicates.
14736: * Try to eliminate it.
14737: */
14738:
14739: switch ((xmlXPathAxisVal) op->value) {
14740: case AXIS_CHILD:
14741: case AXIS_DESCENDANT:
14742: /*
14743: * Convert "descendant-or-self::node()/child::" or
14744: * "descendant-or-self::node()/descendant::" to
14745: * "descendant::"
14746: */
14747: op->ch1 = prevop->ch1;
14748: op->value = AXIS_DESCENDANT;
14749: break;
14750: case AXIS_SELF:
14751: case AXIS_DESCENDANT_OR_SELF:
14752: /*
14753: * Convert "descendant-or-self::node()/self::" or
14754: * "descendant-or-self::node()/descendant-or-self::" to
14755: * to "descendant-or-self::"
14756: */
14757: op->ch1 = prevop->ch1;
14758: op->value = AXIS_DESCENDANT_OR_SELF;
14759: break;
14760: default:
14761: break;
14762: }
14763: }
14764: }
14765:
14766: /* Recurse */
14767: if (op->ch1 != -1)
14768: xmlXPathOptimizeExpression(comp, &comp->steps[op->ch1]);
14769: if (op->ch2 != -1)
14770: xmlXPathOptimizeExpression(comp, &comp->steps[op->ch2]);
14771: }
14772:
14773: /**
14774: * xmlXPathCtxtCompile:
14775: * @ctxt: an XPath context
14776: * @str: the XPath expression
14777: *
14778: * Compile an XPath expression
14779: *
14780: * Returns the xmlXPathCompExprPtr resulting from the compilation or NULL.
14781: * the caller has to free the object.
14782: */
14783: xmlXPathCompExprPtr
14784: xmlXPathCtxtCompile(xmlXPathContextPtr ctxt, const xmlChar *str) {
14785: xmlXPathParserContextPtr pctxt;
14786: xmlXPathCompExprPtr comp;
14787:
14788: #ifdef XPATH_STREAMING
14789: comp = xmlXPathTryStreamCompile(ctxt, str);
14790: if (comp != NULL)
14791: return(comp);
14792: #endif
14793:
14794: xmlXPathInit();
14795:
14796: pctxt = xmlXPathNewParserContext(str, ctxt);
14797: if (pctxt == NULL)
14798: return NULL;
14799: xmlXPathCompileExpr(pctxt, 1);
14800:
14801: if( pctxt->error != XPATH_EXPRESSION_OK )
14802: {
14803: xmlXPathFreeParserContext(pctxt);
14804: return(NULL);
14805: }
14806:
14807: if (*pctxt->cur != 0) {
14808: /*
14809: * aleksey: in some cases this line prints *second* error message
14810: * (see bug #78858) and probably this should be fixed.
14811: * However, we are not sure that all error messages are printed
14812: * out in other places. It's not critical so we leave it as-is for now
14813: */
14814: xmlXPatherror(pctxt, __FILE__, __LINE__, XPATH_EXPR_ERROR);
14815: comp = NULL;
14816: } else {
14817: comp = pctxt->comp;
14818: pctxt->comp = NULL;
14819: }
14820: xmlXPathFreeParserContext(pctxt);
14821:
14822: if (comp != NULL) {
14823: comp->expr = xmlStrdup(str);
14824: #ifdef DEBUG_EVAL_COUNTS
14825: comp->string = xmlStrdup(str);
14826: comp->nb = 0;
14827: #endif
14828: if ((comp->nbStep > 1) && (comp->last >= 0)) {
14829: xmlXPathOptimizeExpression(comp, &comp->steps[comp->last]);
14830: }
14831: }
14832: return(comp);
14833: }
14834:
14835: /**
14836: * xmlXPathCompile:
14837: * @str: the XPath expression
14838: *
14839: * Compile an XPath expression
14840: *
14841: * Returns the xmlXPathCompExprPtr resulting from the compilation or NULL.
14842: * the caller has to free the object.
14843: */
14844: xmlXPathCompExprPtr
14845: xmlXPathCompile(const xmlChar *str) {
14846: return(xmlXPathCtxtCompile(NULL, str));
14847: }
14848:
14849: /**
14850: * xmlXPathCompiledEvalInternal:
14851: * @comp: the compiled XPath expression
14852: * @ctxt: the XPath context
14853: * @resObj: the resulting XPath object or NULL
14854: * @toBool: 1 if only a boolean result is requested
14855: *
14856: * Evaluate the Precompiled XPath expression in the given context.
14857: * The caller has to free @resObj.
14858: *
14859: * Returns the xmlXPathObjectPtr resulting from the evaluation or NULL.
14860: * the caller has to free the object.
14861: */
14862: static int
14863: xmlXPathCompiledEvalInternal(xmlXPathCompExprPtr comp,
14864: xmlXPathContextPtr ctxt,
14865: xmlXPathObjectPtr *resObj,
14866: int toBool)
14867: {
14868: xmlXPathParserContextPtr pctxt;
14869: #ifndef LIBXML_THREAD_ENABLED
14870: static int reentance = 0;
14871: #endif
14872: int res;
14873:
14874: CHECK_CTXT_NEG(ctxt)
14875:
14876: if (comp == NULL)
14877: return(-1);
14878: xmlXPathInit();
14879:
14880: #ifndef LIBXML_THREAD_ENABLED
14881: reentance++;
14882: if (reentance > 1)
14883: xmlXPathDisableOptimizer = 1;
14884: #endif
14885:
14886: #ifdef DEBUG_EVAL_COUNTS
14887: comp->nb++;
14888: if ((comp->string != NULL) && (comp->nb > 100)) {
14889: fprintf(stderr, "100 x %s\n", comp->string);
14890: comp->nb = 0;
14891: }
14892: #endif
14893: pctxt = xmlXPathCompParserContext(comp, ctxt);
14894: res = xmlXPathRunEval(pctxt, toBool);
14895:
14896: if (resObj) {
14897: if (pctxt->value == NULL) {
14898: xmlGenericError(xmlGenericErrorContext,
14899: "xmlXPathCompiledEval: evaluation failed\n");
14900: *resObj = NULL;
14901: } else {
14902: *resObj = valuePop(pctxt);
14903: }
14904: }
14905:
14906: /*
14907: * Pop all remaining objects from the stack.
14908: */
14909: if (pctxt->valueNr > 0) {
14910: xmlXPathObjectPtr tmp;
14911: int stack = 0;
14912:
14913: do {
14914: tmp = valuePop(pctxt);
14915: if (tmp != NULL) {
14916: stack++;
14917: xmlXPathReleaseObject(ctxt, tmp);
14918: }
14919: } while (tmp != NULL);
14920: if ((stack != 0) &&
14921: ((toBool) || ((resObj) && (*resObj))))
14922: {
14923: xmlGenericError(xmlGenericErrorContext,
14924: "xmlXPathCompiledEval: %d objects left on the stack.\n",
14925: stack);
14926: }
14927: }
14928:
14929: if ((pctxt->error != XPATH_EXPRESSION_OK) && (resObj) && (*resObj)) {
14930: xmlXPathFreeObject(*resObj);
14931: *resObj = NULL;
14932: }
14933: pctxt->comp = NULL;
14934: xmlXPathFreeParserContext(pctxt);
14935: #ifndef LIBXML_THREAD_ENABLED
14936: reentance--;
14937: #endif
14938:
14939: return(res);
14940: }
14941:
14942: /**
14943: * xmlXPathCompiledEval:
14944: * @comp: the compiled XPath expression
14945: * @ctx: the XPath context
14946: *
14947: * Evaluate the Precompiled XPath expression in the given context.
14948: *
14949: * Returns the xmlXPathObjectPtr resulting from the evaluation or NULL.
14950: * the caller has to free the object.
14951: */
14952: xmlXPathObjectPtr
14953: xmlXPathCompiledEval(xmlXPathCompExprPtr comp, xmlXPathContextPtr ctx)
14954: {
14955: xmlXPathObjectPtr res = NULL;
14956:
14957: xmlXPathCompiledEvalInternal(comp, ctx, &res, 0);
14958: return(res);
14959: }
14960:
14961: /**
14962: * xmlXPathCompiledEvalToBoolean:
14963: * @comp: the compiled XPath expression
14964: * @ctxt: the XPath context
14965: *
14966: * Applies the XPath boolean() function on the result of the given
14967: * compiled expression.
14968: *
14969: * Returns 1 if the expression evaluated to true, 0 if to false and
14970: * -1 in API and internal errors.
14971: */
14972: int
14973: xmlXPathCompiledEvalToBoolean(xmlXPathCompExprPtr comp,
14974: xmlXPathContextPtr ctxt)
14975: {
14976: return(xmlXPathCompiledEvalInternal(comp, ctxt, NULL, 1));
14977: }
14978:
14979: /**
14980: * xmlXPathEvalExpr:
14981: * @ctxt: the XPath Parser context
14982: *
14983: * Parse and evaluate an XPath expression in the given context,
14984: * then push the result on the context stack
14985: */
14986: void
14987: xmlXPathEvalExpr(xmlXPathParserContextPtr ctxt) {
14988: #ifdef XPATH_STREAMING
14989: xmlXPathCompExprPtr comp;
14990: #endif
14991:
14992: if (ctxt == NULL) return;
14993:
14994: #ifdef XPATH_STREAMING
14995: comp = xmlXPathTryStreamCompile(ctxt->context, ctxt->base);
14996: if (comp != NULL) {
14997: if (ctxt->comp != NULL)
14998: xmlXPathFreeCompExpr(ctxt->comp);
14999: ctxt->comp = comp;
15000: if (ctxt->cur != NULL)
15001: while (*ctxt->cur != 0) ctxt->cur++;
15002: } else
15003: #endif
15004: {
15005: xmlXPathCompileExpr(ctxt, 1);
15006: if ((ctxt->error == XPATH_EXPRESSION_OK) &&
15007: (ctxt->comp != NULL) &&
15008: (ctxt->comp->nbStep > 1) &&
15009: (ctxt->comp->last >= 0))
15010: {
15011: xmlXPathOptimizeExpression(ctxt->comp,
15012: &ctxt->comp->steps[ctxt->comp->last]);
15013: }
15014: }
15015: CHECK_ERROR;
15016: xmlXPathRunEval(ctxt, 0);
15017: }
15018:
15019: /**
15020: * xmlXPathEval:
15021: * @str: the XPath expression
15022: * @ctx: the XPath context
15023: *
15024: * Evaluate the XPath Location Path in the given context.
15025: *
15026: * Returns the xmlXPathObjectPtr resulting from the evaluation or NULL.
15027: * the caller has to free the object.
15028: */
15029: xmlXPathObjectPtr
15030: xmlXPathEval(const xmlChar *str, xmlXPathContextPtr ctx) {
15031: xmlXPathParserContextPtr ctxt;
15032: xmlXPathObjectPtr res, tmp, init = NULL;
15033: int stack = 0;
15034:
15035: CHECK_CTXT(ctx)
15036:
15037: xmlXPathInit();
15038:
15039: ctxt = xmlXPathNewParserContext(str, ctx);
15040: if (ctxt == NULL)
15041: return NULL;
15042: xmlXPathEvalExpr(ctxt);
15043:
15044: if (ctxt->value == NULL) {
15045: xmlGenericError(xmlGenericErrorContext,
15046: "xmlXPathEval: evaluation failed\n");
15047: res = NULL;
15048: } else if ((*ctxt->cur != 0) && (ctxt->comp != NULL)
15049: #ifdef XPATH_STREAMING
15050: && (ctxt->comp->stream == NULL)
15051: #endif
15052: ) {
15053: xmlXPatherror(ctxt, __FILE__, __LINE__, XPATH_EXPR_ERROR);
15054: res = NULL;
15055: } else {
15056: res = valuePop(ctxt);
15057: }
15058:
15059: do {
15060: tmp = valuePop(ctxt);
15061: if (tmp != NULL) {
15062: if (tmp != init)
15063: stack++;
15064: xmlXPathReleaseObject(ctx, tmp);
15065: }
15066: } while (tmp != NULL);
15067: if ((stack != 0) && (res != NULL)) {
15068: xmlGenericError(xmlGenericErrorContext,
15069: "xmlXPathEval: %d object left on the stack\n",
15070: stack);
15071: }
15072: if (ctxt->error != XPATH_EXPRESSION_OK) {
15073: xmlXPathFreeObject(res);
15074: res = NULL;
15075: }
15076:
15077: xmlXPathFreeParserContext(ctxt);
15078: return(res);
15079: }
15080:
15081: /**
15082: * xmlXPathSetContextNode:
15083: * @node: the node to to use as the context node
15084: * @ctx: the XPath context
15085: *
15086: * Sets 'node' as the context node. The node must be in the same
15087: * document as that associated with the context.
15088: *
15089: * Returns -1 in case of error or 0 if successful
15090: */
15091: int
15092: xmlXPathSetContextNode(xmlNodePtr node, xmlXPathContextPtr ctx) {
15093: if ((node == NULL) || (ctx == NULL))
15094: return(-1);
15095:
15096: if (node->doc == ctx->doc) {
15097: ctx->node = node;
15098: return(0);
15099: }
15100: return(-1);
15101: }
15102:
15103: /**
15104: * xmlXPathNodeEval:
15105: * @node: the node to to use as the context node
15106: * @str: the XPath expression
15107: * @ctx: the XPath context
15108: *
15109: * Evaluate the XPath Location Path in the given context. The node 'node'
15110: * is set as the context node. The context node is not restored.
15111: *
15112: * Returns the xmlXPathObjectPtr resulting from the evaluation or NULL.
15113: * the caller has to free the object.
15114: */
15115: xmlXPathObjectPtr
15116: xmlXPathNodeEval(xmlNodePtr node, const xmlChar *str, xmlXPathContextPtr ctx) {
15117: if (str == NULL)
15118: return(NULL);
15119: if (xmlXPathSetContextNode(node, ctx) < 0)
15120: return(NULL);
15121: return(xmlXPathEval(str, ctx));
15122: }
15123:
15124: /**
15125: * xmlXPathEvalExpression:
15126: * @str: the XPath expression
15127: * @ctxt: the XPath context
15128: *
15129: * Evaluate the XPath expression in the given context.
15130: *
15131: * Returns the xmlXPathObjectPtr resulting from the evaluation or NULL.
15132: * the caller has to free the object.
15133: */
15134: xmlXPathObjectPtr
15135: xmlXPathEvalExpression(const xmlChar *str, xmlXPathContextPtr ctxt) {
15136: xmlXPathParserContextPtr pctxt;
15137: xmlXPathObjectPtr res, tmp;
15138: int stack = 0;
15139:
15140: CHECK_CTXT(ctxt)
15141:
15142: xmlXPathInit();
15143:
15144: pctxt = xmlXPathNewParserContext(str, ctxt);
15145: if (pctxt == NULL)
15146: return NULL;
15147: xmlXPathEvalExpr(pctxt);
15148:
15149: if ((*pctxt->cur != 0) || (pctxt->error != XPATH_EXPRESSION_OK)) {
15150: xmlXPatherror(pctxt, __FILE__, __LINE__, XPATH_EXPR_ERROR);
15151: res = NULL;
15152: } else {
15153: res = valuePop(pctxt);
15154: }
15155: do {
15156: tmp = valuePop(pctxt);
15157: if (tmp != NULL) {
15158: xmlXPathReleaseObject(ctxt, tmp);
15159: stack++;
15160: }
15161: } while (tmp != NULL);
15162: if ((stack != 0) && (res != NULL)) {
15163: xmlGenericError(xmlGenericErrorContext,
15164: "xmlXPathEvalExpression: %d object left on the stack\n",
15165: stack);
15166: }
15167: xmlXPathFreeParserContext(pctxt);
15168: return(res);
15169: }
15170:
15171: /************************************************************************
15172: * *
15173: * Extra functions not pertaining to the XPath spec *
15174: * *
15175: ************************************************************************/
15176: /**
15177: * xmlXPathEscapeUriFunction:
15178: * @ctxt: the XPath Parser context
15179: * @nargs: the number of arguments
15180: *
15181: * Implement the escape-uri() XPath function
15182: * string escape-uri(string $str, bool $escape-reserved)
15183: *
15184: * This function applies the URI escaping rules defined in section 2 of [RFC
15185: * 2396] to the string supplied as $uri-part, which typically represents all
15186: * or part of a URI. The effect of the function is to replace any special
15187: * character in the string by an escape sequence of the form %xx%yy...,
15188: * where xxyy... is the hexadecimal representation of the octets used to
15189: * represent the character in UTF-8.
15190: *
15191: * The set of characters that are escaped depends on the setting of the
15192: * boolean argument $escape-reserved.
15193: *
15194: * If $escape-reserved is true, all characters are escaped other than lower
15195: * case letters a-z, upper case letters A-Z, digits 0-9, and the characters
15196: * referred to in [RFC 2396] as "marks": specifically, "-" | "_" | "." | "!"
15197: * | "~" | "*" | "'" | "(" | ")". The "%" character itself is escaped only
15198: * if it is not followed by two hexadecimal digits (that is, 0-9, a-f, and
15199: * A-F).
15200: *
15201: * If $escape-reserved is false, the behavior differs in that characters
15202: * referred to in [RFC 2396] as reserved characters are not escaped. These
15203: * characters are ";" | "/" | "?" | ":" | "@" | "&" | "=" | "+" | "$" | ",".
15204: *
15205: * [RFC 2396] does not define whether escaped URIs should use lower case or
15206: * upper case for hexadecimal digits. To ensure that escaped URIs can be
15207: * compared using string comparison functions, this function must always use
15208: * the upper-case letters A-F.
15209: *
15210: * Generally, $escape-reserved should be set to true when escaping a string
15211: * that is to form a single part of a URI, and to false when escaping an
15212: * entire URI or URI reference.
15213: *
15214: * In the case of non-ascii characters, the string is encoded according to
15215: * utf-8 and then converted according to RFC 2396.
15216: *
15217: * Examples
15218: * xf:escape-uri ("gopher://spinaltap.micro.umn.edu/00/Weather/California/Los%20Angeles#ocean"), true())
15219: * returns "gopher%3A%2F%2Fspinaltap.micro.umn.edu%2F00%2FWeather%2FCalifornia%2FLos%20Angeles%23ocean"
15220: * xf:escape-uri ("gopher://spinaltap.micro.umn.edu/00/Weather/California/Los%20Angeles#ocean"), false())
15221: * returns "gopher://spinaltap.micro.umn.edu/00/Weather/California/Los%20Angeles%23ocean"
15222: *
15223: */
15224: static void
15225: xmlXPathEscapeUriFunction(xmlXPathParserContextPtr ctxt, int nargs) {
15226: xmlXPathObjectPtr str;
15227: int escape_reserved;
15228: xmlBufPtr target;
15229: xmlChar *cptr;
15230: xmlChar escape[4];
15231:
15232: CHECK_ARITY(2);
15233:
15234: escape_reserved = xmlXPathPopBoolean(ctxt);
15235:
15236: CAST_TO_STRING;
15237: str = valuePop(ctxt);
15238:
15239: target = xmlBufCreate();
15240:
15241: escape[0] = '%';
15242: escape[3] = 0;
15243:
15244: if (target) {
15245: for (cptr = str->stringval; *cptr; cptr++) {
15246: if ((*cptr >= 'A' && *cptr <= 'Z') ||
15247: (*cptr >= 'a' && *cptr <= 'z') ||
15248: (*cptr >= '0' && *cptr <= '9') ||
15249: *cptr == '-' || *cptr == '_' || *cptr == '.' ||
15250: *cptr == '!' || *cptr == '~' || *cptr == '*' ||
15251: *cptr == '\''|| *cptr == '(' || *cptr == ')' ||
15252: (*cptr == '%' &&
15253: ((cptr[1] >= 'A' && cptr[1] <= 'F') ||
15254: (cptr[1] >= 'a' && cptr[1] <= 'f') ||
15255: (cptr[1] >= '0' && cptr[1] <= '9')) &&
15256: ((cptr[2] >= 'A' && cptr[2] <= 'F') ||
15257: (cptr[2] >= 'a' && cptr[2] <= 'f') ||
15258: (cptr[2] >= '0' && cptr[2] <= '9'))) ||
15259: (!escape_reserved &&
15260: (*cptr == ';' || *cptr == '/' || *cptr == '?' ||
15261: *cptr == ':' || *cptr == '@' || *cptr == '&' ||
15262: *cptr == '=' || *cptr == '+' || *cptr == '$' ||
15263: *cptr == ','))) {
15264: xmlBufAdd(target, cptr, 1);
15265: } else {
15266: if ((*cptr >> 4) < 10)
15267: escape[1] = '0' + (*cptr >> 4);
15268: else
15269: escape[1] = 'A' - 10 + (*cptr >> 4);
15270: if ((*cptr & 0xF) < 10)
15271: escape[2] = '0' + (*cptr & 0xF);
15272: else
15273: escape[2] = 'A' - 10 + (*cptr & 0xF);
15274:
15275: xmlBufAdd(target, &escape[0], 3);
15276: }
15277: }
15278: }
15279: valuePush(ctxt, xmlXPathCacheNewString(ctxt->context,
15280: xmlBufContent(target)));
15281: xmlBufFree(target);
15282: xmlXPathReleaseObject(ctxt->context, str);
15283: }
15284:
15285: /**
15286: * xmlXPathRegisterAllFunctions:
15287: * @ctxt: the XPath context
15288: *
15289: * Registers all default XPath functions in this context
15290: */
15291: void
15292: xmlXPathRegisterAllFunctions(xmlXPathContextPtr ctxt)
15293: {
15294: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"boolean",
15295: xmlXPathBooleanFunction);
15296: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"ceiling",
15297: xmlXPathCeilingFunction);
15298: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"count",
15299: xmlXPathCountFunction);
15300: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"concat",
15301: xmlXPathConcatFunction);
15302: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"contains",
15303: xmlXPathContainsFunction);
15304: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"id",
15305: xmlXPathIdFunction);
15306: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"false",
15307: xmlXPathFalseFunction);
15308: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"floor",
15309: xmlXPathFloorFunction);
15310: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"last",
15311: xmlXPathLastFunction);
15312: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"lang",
15313: xmlXPathLangFunction);
15314: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"local-name",
15315: xmlXPathLocalNameFunction);
15316: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"not",
15317: xmlXPathNotFunction);
15318: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"name",
15319: xmlXPathNameFunction);
15320: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"namespace-uri",
15321: xmlXPathNamespaceURIFunction);
15322: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"normalize-space",
15323: xmlXPathNormalizeFunction);
15324: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"number",
15325: xmlXPathNumberFunction);
15326: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"position",
15327: xmlXPathPositionFunction);
15328: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"round",
15329: xmlXPathRoundFunction);
15330: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"string",
15331: xmlXPathStringFunction);
15332: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"string-length",
15333: xmlXPathStringLengthFunction);
15334: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"starts-with",
15335: xmlXPathStartsWithFunction);
15336: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"substring",
15337: xmlXPathSubstringFunction);
15338: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"substring-before",
15339: xmlXPathSubstringBeforeFunction);
15340: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"substring-after",
15341: xmlXPathSubstringAfterFunction);
15342: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"sum",
15343: xmlXPathSumFunction);
15344: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"true",
15345: xmlXPathTrueFunction);
15346: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"translate",
15347: xmlXPathTranslateFunction);
15348:
15349: xmlXPathRegisterFuncNS(ctxt, (const xmlChar *)"escape-uri",
15350: (const xmlChar *)"http://www.w3.org/2002/08/xquery-functions",
15351: xmlXPathEscapeUriFunction);
15352: }
15353:
15354: #endif /* LIBXML_XPATH_ENABLED */
15355: #define bottom_xpath
15356: #include "elfgcchack.h"
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to xpath.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libxml2