1: /*
2: * xpath.c: XML Path Language implementation
3: * XPath is a language for addressing parts of an XML document,
4: * designed to be used by both XSLT and XPointer
5: *f
6: * Reference: W3C Recommendation 16 November 1999
7: * http://www.w3.org/TR/1999/REC-xpath-19991116
8: * Public reference:
9: * http://www.w3.org/TR/xpath
10: *
11: * See Copyright for the status of this software
12: *
13: * Author: daniel@veillard.com
14: *
15: */
16:
17: #define IN_LIBXML
18: #include "libxml.h"
19:
20: #include <string.h>
21:
22: #ifdef HAVE_SYS_TYPES_H
23: #include <sys/types.h>
24: #endif
25: #ifdef HAVE_MATH_H
26: #include <math.h>
27: #endif
28: #ifdef HAVE_FLOAT_H
29: #include <float.h>
30: #endif
31: #ifdef HAVE_CTYPE_H
32: #include <ctype.h>
33: #endif
34: #ifdef HAVE_SIGNAL_H
35: #include <signal.h>
36: #endif
37:
38: #include <libxml/xmlmemory.h>
39: #include <libxml/tree.h>
40: #include <libxml/valid.h>
41: #include <libxml/xpath.h>
42: #include <libxml/xpathInternals.h>
43: #include <libxml/parserInternals.h>
44: #include <libxml/hash.h>
45: #ifdef LIBXML_XPTR_ENABLED
46: #include <libxml/xpointer.h>
47: #endif
48: #ifdef LIBXML_DEBUG_ENABLED
49: #include <libxml/debugXML.h>
50: #endif
51: #include <libxml/xmlerror.h>
52: #include <libxml/threads.h>
53: #include <libxml/globals.h>
54: #ifdef LIBXML_PATTERN_ENABLED
55: #include <libxml/pattern.h>
56: #endif
57:
58: #ifdef LIBXML_PATTERN_ENABLED
59: #define XPATH_STREAMING
60: #endif
61:
62: #define TODO \
63: xmlGenericError(xmlGenericErrorContext, \
64: "Unimplemented block at %s:%d\n", \
65: __FILE__, __LINE__);
66:
67: /*
68: * XP_OPTIMIZED_NON_ELEM_COMPARISON:
69: * If defined, this will use xmlXPathCmpNodesExt() instead of
70: * xmlXPathCmpNodes(). The new function is optimized comparison of
71: * non-element nodes; actually it will speed up comparison only if
72: * xmlXPathOrderDocElems() was called in order to index the elements of
73: * a tree in document order; Libxslt does such an indexing, thus it will
74: * benefit from this optimization.
75: */
76: #define XP_OPTIMIZED_NON_ELEM_COMPARISON
77:
78: /*
79: * XP_OPTIMIZED_FILTER_FIRST:
80: * If defined, this will optimize expressions like "key('foo', 'val')[b][1]"
81: * in a way, that it stop evaluation at the first node.
82: */
83: #define XP_OPTIMIZED_FILTER_FIRST
84:
85: /*
86: * XP_DEBUG_OBJ_USAGE:
87: * Internal flag to enable tracking of how much XPath objects have been
88: * created.
89: */
90: /* #define XP_DEBUG_OBJ_USAGE */
91:
92: /*
93: * TODO:
94: * There are a few spots where some tests are done which depend upon ascii
95: * data. These should be enhanced for full UTF8 support (see particularly
96: * any use of the macros IS_ASCII_CHARACTER and IS_ASCII_DIGIT)
97: */
98:
99: #if defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
100:
101: /************************************************************************
102: * *
103: * Floating point stuff *
104: * *
105: ************************************************************************/
106:
107: #ifndef TRIO_REPLACE_STDIO
108: #define TRIO_PUBLIC static
109: #endif
110: #include "trionan.c"
111:
112: /*
113: * The lack of portability of this section of the libc is annoying !
114: */
115: double xmlXPathNAN = 0;
116: double xmlXPathPINF = 1;
117: double xmlXPathNINF = -1;
118: static double xmlXPathNZERO = 0; /* not exported from headers */
119: static int xmlXPathInitialized = 0;
120:
121: /**
122: * xmlXPathInit:
123: *
124: * Initialize the XPath environment
125: */
126: void
127: xmlXPathInit(void) {
128: if (xmlXPathInitialized) return;
129:
130: xmlXPathPINF = trio_pinf();
131: xmlXPathNINF = trio_ninf();
132: xmlXPathNAN = trio_nan();
133: xmlXPathNZERO = trio_nzero();
134:
135: xmlXPathInitialized = 1;
136: }
137:
138: /**
139: * xmlXPathIsNaN:
140: * @val: a double value
141: *
142: * Provides a portable isnan() function to detect whether a double
143: * is a NotaNumber. Based on trio code
144: * http://sourceforge.net/projects/ctrio/
145: *
146: * Returns 1 if the value is a NaN, 0 otherwise
147: */
148: int
149: xmlXPathIsNaN(double val) {
150: return(trio_isnan(val));
151: }
152:
153: /**
154: * xmlXPathIsInf:
155: * @val: a double value
156: *
157: * Provides a portable isinf() function to detect whether a double
158: * is a +Infinite or -Infinite. Based on trio code
159: * http://sourceforge.net/projects/ctrio/
160: *
161: * Returns 1 vi the value is +Infinite, -1 if -Infinite, 0 otherwise
162: */
163: int
164: xmlXPathIsInf(double val) {
165: return(trio_isinf(val));
166: }
167:
168: #endif /* SCHEMAS or XPATH */
169: #ifdef LIBXML_XPATH_ENABLED
170: /**
171: * xmlXPathGetSign:
172: * @val: a double value
173: *
174: * Provides a portable function to detect the sign of a double
175: * Modified from trio code
176: * http://sourceforge.net/projects/ctrio/
177: *
178: * Returns 1 if the value is Negative, 0 if positive
179: */
180: static int
181: xmlXPathGetSign(double val) {
182: return(trio_signbit(val));
183: }
184:
185:
186: /*
187: * TODO: when compatibility allows remove all "fake node libxslt" strings
188: * the test should just be name[0] = ' '
189: */
190: #ifdef DEBUG_XPATH_EXPRESSION
191: #define DEBUG_STEP
192: #define DEBUG_EXPR
193: #define DEBUG_EVAL_COUNTS
194: #endif
195:
196: static xmlNs xmlXPathXMLNamespaceStruct = {
197: NULL,
198: XML_NAMESPACE_DECL,
199: XML_XML_NAMESPACE,
200: BAD_CAST "xml",
201: NULL,
202: NULL
203: };
204: static xmlNsPtr xmlXPathXMLNamespace = &xmlXPathXMLNamespaceStruct;
205: #ifndef LIBXML_THREAD_ENABLED
206: /*
207: * Optimizer is disabled only when threaded apps are detected while
208: * the library ain't compiled for thread safety.
209: */
210: static int xmlXPathDisableOptimizer = 0;
211: #endif
212:
213: /************************************************************************
214: * *
215: * Error handling routines *
216: * *
217: ************************************************************************/
218:
219: /**
220: * XP_ERRORNULL:
221: * @X: the error code
222: *
223: * Macro to raise an XPath error and return NULL.
224: */
225: #define XP_ERRORNULL(X) \
226: { xmlXPathErr(ctxt, X); return(NULL); }
227:
228: /*
229: * The array xmlXPathErrorMessages corresponds to the enum xmlXPathError
230: */
231: static const char *xmlXPathErrorMessages[] = {
232: "Ok\n",
233: "Number encoding\n",
234: "Unfinished literal\n",
235: "Start of literal\n",
236: "Expected $ for variable reference\n",
237: "Undefined variable\n",
238: "Invalid predicate\n",
239: "Invalid expression\n",
240: "Missing closing curly brace\n",
241: "Unregistered function\n",
242: "Invalid operand\n",
243: "Invalid type\n",
244: "Invalid number of arguments\n",
245: "Invalid context size\n",
246: "Invalid context position\n",
247: "Memory allocation error\n",
248: "Syntax error\n",
249: "Resource error\n",
250: "Sub resource error\n",
251: "Undefined namespace prefix\n",
252: "Encoding error\n",
253: "Char out of XML range\n",
254: "Invalid or incomplete context\n",
255: "Stack usage errror\n",
256: "?? Unknown error ??\n" /* Must be last in the list! */
257: };
258: #define MAXERRNO ((int)(sizeof(xmlXPathErrorMessages) / \
259: sizeof(xmlXPathErrorMessages[0])) - 1)
260: /**
261: * xmlXPathErrMemory:
262: * @ctxt: an XPath context
263: * @extra: extra informations
264: *
265: * Handle a redefinition of attribute error
266: */
267: static void
268: xmlXPathErrMemory(xmlXPathContextPtr ctxt, const char *extra)
269: {
270: if (ctxt != NULL) {
271: if (extra) {
272: xmlChar buf[200];
273:
274: xmlStrPrintf(buf, 200,
275: BAD_CAST "Memory allocation failed : %s\n",
276: extra);
277: ctxt->lastError.message = (char *) xmlStrdup(buf);
278: } else {
279: ctxt->lastError.message = (char *)
280: xmlStrdup(BAD_CAST "Memory allocation failed\n");
281: }
282: ctxt->lastError.domain = XML_FROM_XPATH;
283: ctxt->lastError.code = XML_ERR_NO_MEMORY;
284: if (ctxt->error != NULL)
285: ctxt->error(ctxt->userData, &ctxt->lastError);
286: } else {
287: if (extra)
288: __xmlRaiseError(NULL, NULL, NULL,
289: NULL, NULL, XML_FROM_XPATH,
290: XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0,
291: extra, NULL, NULL, 0, 0,
292: "Memory allocation failed : %s\n", extra);
293: else
294: __xmlRaiseError(NULL, NULL, NULL,
295: NULL, NULL, XML_FROM_XPATH,
296: XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0,
297: NULL, NULL, NULL, 0, 0,
298: "Memory allocation failed\n");
299: }
300: }
301:
302: /**
303: * xmlXPathPErrMemory:
304: * @ctxt: an XPath parser context
305: * @extra: extra informations
306: *
307: * Handle a redefinition of attribute error
308: */
309: static void
310: xmlXPathPErrMemory(xmlXPathParserContextPtr ctxt, const char *extra)
311: {
312: if (ctxt == NULL)
313: xmlXPathErrMemory(NULL, extra);
314: else {
315: ctxt->error = XPATH_MEMORY_ERROR;
316: xmlXPathErrMemory(ctxt->context, extra);
317: }
318: }
319:
320: /**
321: * xmlXPathErr:
322: * @ctxt: a XPath parser context
323: * @error: the error code
324: *
325: * Handle an XPath error
326: */
327: void
328: xmlXPathErr(xmlXPathParserContextPtr ctxt, int error)
329: {
330: if ((error < 0) || (error > MAXERRNO))
331: error = MAXERRNO;
332: if (ctxt == NULL) {
333: __xmlRaiseError(NULL, NULL, NULL,
334: NULL, NULL, XML_FROM_XPATH,
335: error + XML_XPATH_EXPRESSION_OK - XPATH_EXPRESSION_OK,
336: XML_ERR_ERROR, NULL, 0,
337: NULL, NULL, NULL, 0, 0,
338: "%s", xmlXPathErrorMessages[error]);
339: return;
340: }
341: ctxt->error = error;
342: if (ctxt->context == NULL) {
343: __xmlRaiseError(NULL, NULL, NULL,
344: NULL, NULL, XML_FROM_XPATH,
345: error + XML_XPATH_EXPRESSION_OK - XPATH_EXPRESSION_OK,
346: XML_ERR_ERROR, NULL, 0,
347: (const char *) ctxt->base, NULL, NULL,
348: ctxt->cur - ctxt->base, 0,
349: "%s", xmlXPathErrorMessages[error]);
350: return;
351: }
352:
353: /* cleanup current last error */
354: xmlResetError(&ctxt->context->lastError);
355:
356: ctxt->context->lastError.domain = XML_FROM_XPATH;
357: ctxt->context->lastError.code = error + XML_XPATH_EXPRESSION_OK -
358: XPATH_EXPRESSION_OK;
359: ctxt->context->lastError.level = XML_ERR_ERROR;
360: ctxt->context->lastError.str1 = (char *) xmlStrdup(ctxt->base);
361: ctxt->context->lastError.int1 = ctxt->cur - ctxt->base;
362: ctxt->context->lastError.node = ctxt->context->debugNode;
363: if (ctxt->context->error != NULL) {
364: ctxt->context->error(ctxt->context->userData,
365: &ctxt->context->lastError);
366: } else {
367: __xmlRaiseError(NULL, NULL, NULL,
368: NULL, ctxt->context->debugNode, XML_FROM_XPATH,
369: error + XML_XPATH_EXPRESSION_OK - XPATH_EXPRESSION_OK,
370: XML_ERR_ERROR, NULL, 0,
371: (const char *) ctxt->base, NULL, NULL,
372: ctxt->cur - ctxt->base, 0,
373: "%s", xmlXPathErrorMessages[error]);
374: }
375:
376: }
377:
378: /**
379: * xmlXPatherror:
380: * @ctxt: the XPath Parser context
381: * @file: the file name
382: * @line: the line number
383: * @no: the error number
384: *
385: * Formats an error message.
386: */
387: void
388: xmlXPatherror(xmlXPathParserContextPtr ctxt, const char *file ATTRIBUTE_UNUSED,
389: int line ATTRIBUTE_UNUSED, int no) {
390: xmlXPathErr(ctxt, no);
391: }
392:
393: /************************************************************************
394: * *
395: * Utilities *
396: * *
397: ************************************************************************/
398:
399: /**
400: * xsltPointerList:
401: *
402: * Pointer-list for various purposes.
403: */
404: typedef struct _xmlPointerList xmlPointerList;
405: typedef xmlPointerList *xmlPointerListPtr;
406: struct _xmlPointerList {
407: void **items;
408: int number;
409: int size;
410: };
411: /*
412: * TODO: Since such a list-handling is used in xmlschemas.c and libxslt
413: * and here, we should make the functions public.
414: */
415: static int
416: xmlPointerListAddSize(xmlPointerListPtr list,
417: void *item,
418: int initialSize)
419: {
420: if (list->items == NULL) {
421: if (initialSize <= 0)
422: initialSize = 1;
423: list->items = (void **) xmlMalloc(
424: initialSize * sizeof(void *));
425: if (list->items == NULL) {
426: xmlXPathErrMemory(NULL,
427: "xmlPointerListCreate: allocating item\n");
428: return(-1);
429: }
430: list->number = 0;
431: list->size = initialSize;
432: } else if (list->size <= list->number) {
433: list->size *= 2;
434: list->items = (void **) xmlRealloc(list->items,
435: list->size * sizeof(void *));
436: if (list->items == NULL) {
437: xmlXPathErrMemory(NULL,
438: "xmlPointerListCreate: re-allocating item\n");
439: list->size = 0;
440: return(-1);
441: }
442: }
443: list->items[list->number++] = item;
444: return(0);
445: }
446:
447: /**
448: * xsltPointerListCreate:
449: *
450: * Creates an xsltPointerList structure.
451: *
452: * Returns a xsltPointerList structure or NULL in case of an error.
453: */
454: static xmlPointerListPtr
455: xmlPointerListCreate(int initialSize)
456: {
457: xmlPointerListPtr ret;
458:
459: ret = xmlMalloc(sizeof(xmlPointerList));
460: if (ret == NULL) {
461: xmlXPathErrMemory(NULL,
462: "xmlPointerListCreate: allocating item\n");
463: return (NULL);
464: }
465: memset(ret, 0, sizeof(xmlPointerList));
466: if (initialSize > 0) {
467: xmlPointerListAddSize(ret, NULL, initialSize);
468: ret->number = 0;
469: }
470: return (ret);
471: }
472:
473: /**
474: * xsltPointerListFree:
475: *
476: * Frees the xsltPointerList structure. This does not free
477: * the content of the list.
478: */
479: static void
480: xmlPointerListFree(xmlPointerListPtr list)
481: {
482: if (list == NULL)
483: return;
484: if (list->items != NULL)
485: xmlFree(list->items);
486: xmlFree(list);
487: }
488:
489: /************************************************************************
490: * *
491: * Parser Types *
492: * *
493: ************************************************************************/
494:
495: /*
496: * Types are private:
497: */
498:
499: typedef enum {
500: XPATH_OP_END=0,
501: XPATH_OP_AND,
502: XPATH_OP_OR,
503: XPATH_OP_EQUAL,
504: XPATH_OP_CMP,
505: XPATH_OP_PLUS,
506: XPATH_OP_MULT,
507: XPATH_OP_UNION,
508: XPATH_OP_ROOT,
509: XPATH_OP_NODE,
510: XPATH_OP_RESET, /* 10 */
511: XPATH_OP_COLLECT,
512: XPATH_OP_VALUE, /* 12 */
513: XPATH_OP_VARIABLE,
514: XPATH_OP_FUNCTION,
515: XPATH_OP_ARG,
516: XPATH_OP_PREDICATE,
517: XPATH_OP_FILTER, /* 17 */
518: XPATH_OP_SORT /* 18 */
519: #ifdef LIBXML_XPTR_ENABLED
520: ,XPATH_OP_RANGETO
521: #endif
522: } xmlXPathOp;
523:
524: typedef enum {
525: AXIS_ANCESTOR = 1,
526: AXIS_ANCESTOR_OR_SELF,
527: AXIS_ATTRIBUTE,
528: AXIS_CHILD,
529: AXIS_DESCENDANT,
530: AXIS_DESCENDANT_OR_SELF,
531: AXIS_FOLLOWING,
532: AXIS_FOLLOWING_SIBLING,
533: AXIS_NAMESPACE,
534: AXIS_PARENT,
535: AXIS_PRECEDING,
536: AXIS_PRECEDING_SIBLING,
537: AXIS_SELF
538: } xmlXPathAxisVal;
539:
540: typedef enum {
541: NODE_TEST_NONE = 0,
542: NODE_TEST_TYPE = 1,
543: NODE_TEST_PI = 2,
544: NODE_TEST_ALL = 3,
545: NODE_TEST_NS = 4,
546: NODE_TEST_NAME = 5
547: } xmlXPathTestVal;
548:
549: typedef enum {
550: NODE_TYPE_NODE = 0,
551: NODE_TYPE_COMMENT = XML_COMMENT_NODE,
552: NODE_TYPE_TEXT = XML_TEXT_NODE,
553: NODE_TYPE_PI = XML_PI_NODE
554: } xmlXPathTypeVal;
555:
556: #define XP_REWRITE_DOS_CHILD_ELEM 1
557:
558: typedef struct _xmlXPathStepOp xmlXPathStepOp;
559: typedef xmlXPathStepOp *xmlXPathStepOpPtr;
560: struct _xmlXPathStepOp {
561: xmlXPathOp op; /* The identifier of the operation */
562: int ch1; /* First child */
563: int ch2; /* Second child */
564: int value;
565: int value2;
566: int value3;
567: void *value4;
568: void *value5;
569: void *cache;
570: void *cacheURI;
571: int rewriteType;
572: };
573:
574: struct _xmlXPathCompExpr {
575: int nbStep; /* Number of steps in this expression */
576: int maxStep; /* Maximum number of steps allocated */
577: xmlXPathStepOp *steps; /* ops for computation of this expression */
578: int last; /* index of last step in expression */
579: xmlChar *expr; /* the expression being computed */
580: xmlDictPtr dict; /* the dictionnary to use if any */
581: #ifdef DEBUG_EVAL_COUNTS
582: int nb;
583: xmlChar *string;
584: #endif
585: #ifdef XPATH_STREAMING
586: xmlPatternPtr stream;
587: #endif
588: };
589:
590: /************************************************************************
591: * *
592: * Forward declarations *
593: * *
594: ************************************************************************/
595: static void
596: xmlXPathFreeValueTree(xmlNodeSetPtr obj);
597: static void
598: xmlXPathReleaseObject(xmlXPathContextPtr ctxt, xmlXPathObjectPtr obj);
599: static int
600: xmlXPathCompOpEvalFirst(xmlXPathParserContextPtr ctxt,
601: xmlXPathStepOpPtr op, xmlNodePtr *first);
602: static int
603: xmlXPathCompOpEvalToBoolean(xmlXPathParserContextPtr ctxt,
604: xmlXPathStepOpPtr op,
605: int isPredicate);
606:
607: /************************************************************************
608: * *
609: * Parser Type functions *
610: * *
611: ************************************************************************/
612:
613: /**
614: * xmlXPathNewCompExpr:
615: *
616: * Create a new Xpath component
617: *
618: * Returns the newly allocated xmlXPathCompExprPtr or NULL in case of error
619: */
620: static xmlXPathCompExprPtr
621: xmlXPathNewCompExpr(void) {
622: xmlXPathCompExprPtr cur;
623:
624: cur = (xmlXPathCompExprPtr) xmlMalloc(sizeof(xmlXPathCompExpr));
625: if (cur == NULL) {
626: xmlXPathErrMemory(NULL, "allocating component\n");
627: return(NULL);
628: }
629: memset(cur, 0, sizeof(xmlXPathCompExpr));
630: cur->maxStep = 10;
631: cur->nbStep = 0;
632: cur->steps = (xmlXPathStepOp *) xmlMalloc(cur->maxStep *
633: sizeof(xmlXPathStepOp));
634: if (cur->steps == NULL) {
635: xmlXPathErrMemory(NULL, "allocating steps\n");
636: xmlFree(cur);
637: return(NULL);
638: }
639: memset(cur->steps, 0, cur->maxStep * sizeof(xmlXPathStepOp));
640: cur->last = -1;
641: #ifdef DEBUG_EVAL_COUNTS
642: cur->nb = 0;
643: #endif
644: return(cur);
645: }
646:
647: /**
648: * xmlXPathFreeCompExpr:
649: * @comp: an XPATH comp
650: *
651: * Free up the memory allocated by @comp
652: */
653: void
654: xmlXPathFreeCompExpr(xmlXPathCompExprPtr comp)
655: {
656: xmlXPathStepOpPtr op;
657: int i;
658:
659: if (comp == NULL)
660: return;
661: if (comp->dict == NULL) {
662: for (i = 0; i < comp->nbStep; i++) {
663: op = &comp->steps[i];
664: if (op->value4 != NULL) {
665: if (op->op == XPATH_OP_VALUE)
666: xmlXPathFreeObject(op->value4);
667: else
668: xmlFree(op->value4);
669: }
670: if (op->value5 != NULL)
671: xmlFree(op->value5);
672: }
673: } else {
674: for (i = 0; i < comp->nbStep; i++) {
675: op = &comp->steps[i];
676: if (op->value4 != NULL) {
677: if (op->op == XPATH_OP_VALUE)
678: xmlXPathFreeObject(op->value4);
679: }
680: }
681: xmlDictFree(comp->dict);
682: }
683: if (comp->steps != NULL) {
684: xmlFree(comp->steps);
685: }
686: #ifdef DEBUG_EVAL_COUNTS
687: if (comp->string != NULL) {
688: xmlFree(comp->string);
689: }
690: #endif
691: #ifdef XPATH_STREAMING
692: if (comp->stream != NULL) {
693: xmlFreePatternList(comp->stream);
694: }
695: #endif
696: if (comp->expr != NULL) {
697: xmlFree(comp->expr);
698: }
699:
700: xmlFree(comp);
701: }
702:
703: /**
704: * xmlXPathCompExprAdd:
705: * @comp: the compiled expression
706: * @ch1: first child index
707: * @ch2: second child index
708: * @op: an op
709: * @value: the first int value
710: * @value2: the second int value
711: * @value3: the third int value
712: * @value4: the first string value
713: * @value5: the second string value
714: *
715: * Add a step to an XPath Compiled Expression
716: *
717: * Returns -1 in case of failure, the index otherwise
718: */
719: static int
720: xmlXPathCompExprAdd(xmlXPathCompExprPtr comp, int ch1, int ch2,
721: xmlXPathOp op, int value,
722: int value2, int value3, void *value4, void *value5) {
723: if (comp->nbStep >= comp->maxStep) {
724: xmlXPathStepOp *real;
725:
726: comp->maxStep *= 2;
727: real = (xmlXPathStepOp *) xmlRealloc(comp->steps,
728: comp->maxStep * sizeof(xmlXPathStepOp));
729: if (real == NULL) {
730: comp->maxStep /= 2;
731: xmlXPathErrMemory(NULL, "adding step\n");
732: return(-1);
733: }
734: comp->steps = real;
735: }
736: comp->last = comp->nbStep;
737: comp->steps[comp->nbStep].rewriteType = 0;
738: comp->steps[comp->nbStep].ch1 = ch1;
739: comp->steps[comp->nbStep].ch2 = ch2;
740: comp->steps[comp->nbStep].op = op;
741: comp->steps[comp->nbStep].value = value;
742: comp->steps[comp->nbStep].value2 = value2;
743: comp->steps[comp->nbStep].value3 = value3;
744: if ((comp->dict != NULL) &&
745: ((op == XPATH_OP_FUNCTION) || (op == XPATH_OP_VARIABLE) ||
746: (op == XPATH_OP_COLLECT))) {
747: if (value4 != NULL) {
748: comp->steps[comp->nbStep].value4 = (xmlChar *)
749: (void *)xmlDictLookup(comp->dict, value4, -1);
750: xmlFree(value4);
751: } else
752: comp->steps[comp->nbStep].value4 = NULL;
753: if (value5 != NULL) {
754: comp->steps[comp->nbStep].value5 = (xmlChar *)
755: (void *)xmlDictLookup(comp->dict, value5, -1);
756: xmlFree(value5);
757: } else
758: comp->steps[comp->nbStep].value5 = NULL;
759: } else {
760: comp->steps[comp->nbStep].value4 = value4;
761: comp->steps[comp->nbStep].value5 = value5;
762: }
763: comp->steps[comp->nbStep].cache = NULL;
764: return(comp->nbStep++);
765: }
766:
767: /**
768: * xmlXPathCompSwap:
769: * @comp: the compiled expression
770: * @op: operation index
771: *
772: * Swaps 2 operations in the compiled expression
773: */
774: static void
775: xmlXPathCompSwap(xmlXPathStepOpPtr op) {
776: int tmp;
777:
778: #ifndef LIBXML_THREAD_ENABLED
779: /*
780: * Since this manipulates possibly shared variables, this is
781: * disabled if one detects that the library is used in a multithreaded
782: * application
783: */
784: if (xmlXPathDisableOptimizer)
785: return;
786: #endif
787:
788: tmp = op->ch1;
789: op->ch1 = op->ch2;
790: op->ch2 = tmp;
791: }
792:
793: #define PUSH_FULL_EXPR(op, op1, op2, val, val2, val3, val4, val5) \
794: xmlXPathCompExprAdd(ctxt->comp, (op1), (op2), \
795: (op), (val), (val2), (val3), (val4), (val5))
796: #define PUSH_LONG_EXPR(op, val, val2, val3, val4, val5) \
797: xmlXPathCompExprAdd(ctxt->comp, ctxt->comp->last, -1, \
798: (op), (val), (val2), (val3), (val4), (val5))
799:
800: #define PUSH_LEAVE_EXPR(op, val, val2) \
801: xmlXPathCompExprAdd(ctxt->comp, -1, -1, (op), (val), (val2), 0 ,NULL ,NULL)
802:
803: #define PUSH_UNARY_EXPR(op, ch, val, val2) \
804: xmlXPathCompExprAdd(ctxt->comp, (ch), -1, (op), (val), (val2), 0 ,NULL ,NULL)
805:
806: #define PUSH_BINARY_EXPR(op, ch1, ch2, val, val2) \
807: xmlXPathCompExprAdd(ctxt->comp, (ch1), (ch2), (op), \
808: (val), (val2), 0 ,NULL ,NULL)
809:
810: /************************************************************************
811: * *
812: * XPath object cache structures *
813: * *
814: ************************************************************************/
815:
816: /* #define XP_DEFAULT_CACHE_ON */
817:
818: #define XP_HAS_CACHE(c) ((c != NULL) && ((c)->cache != NULL))
819:
820: typedef struct _xmlXPathContextCache xmlXPathContextCache;
821: typedef xmlXPathContextCache *xmlXPathContextCachePtr;
822: struct _xmlXPathContextCache {
823: xmlPointerListPtr nodesetObjs; /* contains xmlXPathObjectPtr */
824: xmlPointerListPtr stringObjs; /* contains xmlXPathObjectPtr */
825: xmlPointerListPtr booleanObjs; /* contains xmlXPathObjectPtr */
826: xmlPointerListPtr numberObjs; /* contains xmlXPathObjectPtr */
827: xmlPointerListPtr miscObjs; /* contains xmlXPathObjectPtr */
828: int maxNodeset;
829: int maxString;
830: int maxBoolean;
831: int maxNumber;
832: int maxMisc;
833: #ifdef XP_DEBUG_OBJ_USAGE
834: int dbgCachedAll;
835: int dbgCachedNodeset;
836: int dbgCachedString;
837: int dbgCachedBool;
838: int dbgCachedNumber;
839: int dbgCachedPoint;
840: int dbgCachedRange;
841: int dbgCachedLocset;
842: int dbgCachedUsers;
843: int dbgCachedXSLTTree;
844: int dbgCachedUndefined;
845:
846:
847: int dbgReusedAll;
848: int dbgReusedNodeset;
849: int dbgReusedString;
850: int dbgReusedBool;
851: int dbgReusedNumber;
852: int dbgReusedPoint;
853: int dbgReusedRange;
854: int dbgReusedLocset;
855: int dbgReusedUsers;
856: int dbgReusedXSLTTree;
857: int dbgReusedUndefined;
858:
859: #endif
860: };
861:
862: /************************************************************************
863: * *
864: * Debugging related functions *
865: * *
866: ************************************************************************/
867:
868: #define STRANGE \
869: xmlGenericError(xmlGenericErrorContext, \
870: "Internal error at %s:%d\n", \
871: __FILE__, __LINE__);
872:
873: #ifdef LIBXML_DEBUG_ENABLED
874: static void
875: xmlXPathDebugDumpNode(FILE *output, xmlNodePtr cur, int depth) {
876: int i;
877: char shift[100];
878:
879: for (i = 0;((i < depth) && (i < 25));i++)
880: shift[2 * i] = shift[2 * i + 1] = ' ';
881: shift[2 * i] = shift[2 * i + 1] = 0;
882: if (cur == NULL) {
883: fprintf(output, "%s", shift);
884: fprintf(output, "Node is NULL !\n");
885: return;
886:
887: }
888:
889: if ((cur->type == XML_DOCUMENT_NODE) ||
890: (cur->type == XML_HTML_DOCUMENT_NODE)) {
891: fprintf(output, "%s", shift);
892: fprintf(output, " /\n");
893: } else if (cur->type == XML_ATTRIBUTE_NODE)
894: xmlDebugDumpAttr(output, (xmlAttrPtr)cur, depth);
895: else
896: xmlDebugDumpOneNode(output, cur, depth);
897: }
898: static void
899: xmlXPathDebugDumpNodeList(FILE *output, xmlNodePtr cur, int depth) {
900: xmlNodePtr tmp;
901: int i;
902: char shift[100];
903:
904: for (i = 0;((i < depth) && (i < 25));i++)
905: shift[2 * i] = shift[2 * i + 1] = ' ';
906: shift[2 * i] = shift[2 * i + 1] = 0;
907: if (cur == NULL) {
908: fprintf(output, "%s", shift);
909: fprintf(output, "Node is NULL !\n");
910: return;
911:
912: }
913:
914: while (cur != NULL) {
915: tmp = cur;
916: cur = cur->next;
917: xmlDebugDumpOneNode(output, tmp, depth);
918: }
919: }
920:
921: static void
922: xmlXPathDebugDumpNodeSet(FILE *output, xmlNodeSetPtr cur, int depth) {
923: int i;
924: char shift[100];
925:
926: for (i = 0;((i < depth) && (i < 25));i++)
927: shift[2 * i] = shift[2 * i + 1] = ' ';
928: shift[2 * i] = shift[2 * i + 1] = 0;
929:
930: if (cur == NULL) {
931: fprintf(output, "%s", shift);
932: fprintf(output, "NodeSet is NULL !\n");
933: return;
934:
935: }
936:
937: if (cur != NULL) {
938: fprintf(output, "Set contains %d nodes:\n", cur->nodeNr);
939: for (i = 0;i < cur->nodeNr;i++) {
940: fprintf(output, "%s", shift);
941: fprintf(output, "%d", i + 1);
942: xmlXPathDebugDumpNode(output, cur->nodeTab[i], depth + 1);
943: }
944: }
945: }
946:
947: static void
948: xmlXPathDebugDumpValueTree(FILE *output, xmlNodeSetPtr cur, int depth) {
949: int i;
950: char shift[100];
951:
952: for (i = 0;((i < depth) && (i < 25));i++)
953: shift[2 * i] = shift[2 * i + 1] = ' ';
954: shift[2 * i] = shift[2 * i + 1] = 0;
955:
956: if ((cur == NULL) || (cur->nodeNr == 0) || (cur->nodeTab[0] == NULL)) {
957: fprintf(output, "%s", shift);
958: fprintf(output, "Value Tree is NULL !\n");
959: return;
960:
961: }
962:
963: fprintf(output, "%s", shift);
964: fprintf(output, "%d", i + 1);
965: xmlXPathDebugDumpNodeList(output, cur->nodeTab[0]->children, depth + 1);
966: }
967: #if defined(LIBXML_XPTR_ENABLED)
968: static void
969: xmlXPathDebugDumpLocationSet(FILE *output, xmlLocationSetPtr cur, int depth) {
970: int i;
971: char shift[100];
972:
973: for (i = 0;((i < depth) && (i < 25));i++)
974: shift[2 * i] = shift[2 * i + 1] = ' ';
975: shift[2 * i] = shift[2 * i + 1] = 0;
976:
977: if (cur == NULL) {
978: fprintf(output, "%s", shift);
979: fprintf(output, "LocationSet is NULL !\n");
980: return;
981:
982: }
983:
984: for (i = 0;i < cur->locNr;i++) {
985: fprintf(output, "%s", shift);
986: fprintf(output, "%d : ", i + 1);
987: xmlXPathDebugDumpObject(output, cur->locTab[i], depth + 1);
988: }
989: }
990: #endif /* LIBXML_XPTR_ENABLED */
991:
992: /**
993: * xmlXPathDebugDumpObject:
994: * @output: the FILE * to dump the output
995: * @cur: the object to inspect
996: * @depth: indentation level
997: *
998: * Dump the content of the object for debugging purposes
999: */
1000: void
1001: xmlXPathDebugDumpObject(FILE *output, xmlXPathObjectPtr cur, int depth) {
1002: int i;
1003: char shift[100];
1004:
1005: if (output == NULL) return;
1006:
1007: for (i = 0;((i < depth) && (i < 25));i++)
1008: shift[2 * i] = shift[2 * i + 1] = ' ';
1009: shift[2 * i] = shift[2 * i + 1] = 0;
1010:
1011:
1012: fprintf(output, "%s", shift);
1013:
1014: if (cur == NULL) {
1015: fprintf(output, "Object is empty (NULL)\n");
1016: return;
1017: }
1018: switch(cur->type) {
1019: case XPATH_UNDEFINED:
1020: fprintf(output, "Object is uninitialized\n");
1021: break;
1022: case XPATH_NODESET:
1023: fprintf(output, "Object is a Node Set :\n");
1024: xmlXPathDebugDumpNodeSet(output, cur->nodesetval, depth);
1025: break;
1026: case XPATH_XSLT_TREE:
1027: fprintf(output, "Object is an XSLT value tree :\n");
1028: xmlXPathDebugDumpValueTree(output, cur->nodesetval, depth);
1029: break;
1030: case XPATH_BOOLEAN:
1031: fprintf(output, "Object is a Boolean : ");
1032: if (cur->boolval) fprintf(output, "true\n");
1033: else fprintf(output, "false\n");
1034: break;
1035: case XPATH_NUMBER:
1036: switch (xmlXPathIsInf(cur->floatval)) {
1037: case 1:
1038: fprintf(output, "Object is a number : Infinity\n");
1039: break;
1040: case -1:
1041: fprintf(output, "Object is a number : -Infinity\n");
1042: break;
1043: default:
1044: if (xmlXPathIsNaN(cur->floatval)) {
1045: fprintf(output, "Object is a number : NaN\n");
1046: } else if (cur->floatval == 0 && xmlXPathGetSign(cur->floatval) != 0) {
1047: fprintf(output, "Object is a number : 0\n");
1048: } else {
1049: fprintf(output, "Object is a number : %0g\n", cur->floatval);
1050: }
1051: }
1052: break;
1053: case XPATH_STRING:
1054: fprintf(output, "Object is a string : ");
1055: xmlDebugDumpString(output, cur->stringval);
1056: fprintf(output, "\n");
1057: break;
1058: case XPATH_POINT:
1059: fprintf(output, "Object is a point : index %d in node", cur->index);
1060: xmlXPathDebugDumpNode(output, (xmlNodePtr) cur->user, depth + 1);
1061: fprintf(output, "\n");
1062: break;
1063: case XPATH_RANGE:
1064: if ((cur->user2 == NULL) ||
1065: ((cur->user2 == cur->user) && (cur->index == cur->index2))) {
1066: fprintf(output, "Object is a collapsed range :\n");
1067: fprintf(output, "%s", shift);
1068: if (cur->index >= 0)
1069: fprintf(output, "index %d in ", cur->index);
1070: fprintf(output, "node\n");
1071: xmlXPathDebugDumpNode(output, (xmlNodePtr) cur->user,
1072: depth + 1);
1073: } else {
1074: fprintf(output, "Object is a range :\n");
1075: fprintf(output, "%s", shift);
1076: fprintf(output, "From ");
1077: if (cur->index >= 0)
1078: fprintf(output, "index %d in ", cur->index);
1079: fprintf(output, "node\n");
1080: xmlXPathDebugDumpNode(output, (xmlNodePtr) cur->user,
1081: depth + 1);
1082: fprintf(output, "%s", shift);
1083: fprintf(output, "To ");
1084: if (cur->index2 >= 0)
1085: fprintf(output, "index %d in ", cur->index2);
1086: fprintf(output, "node\n");
1087: xmlXPathDebugDumpNode(output, (xmlNodePtr) cur->user2,
1088: depth + 1);
1089: fprintf(output, "\n");
1090: }
1091: break;
1092: case XPATH_LOCATIONSET:
1093: #if defined(LIBXML_XPTR_ENABLED)
1094: fprintf(output, "Object is a Location Set:\n");
1095: xmlXPathDebugDumpLocationSet(output,
1096: (xmlLocationSetPtr) cur->user, depth);
1097: #endif
1098: break;
1099: case XPATH_USERS:
1100: fprintf(output, "Object is user defined\n");
1101: break;
1102: }
1103: }
1104:
1105: static void
1106: xmlXPathDebugDumpStepOp(FILE *output, xmlXPathCompExprPtr comp,
1107: xmlXPathStepOpPtr op, int depth) {
1108: int i;
1109: char shift[100];
1110:
1111: for (i = 0;((i < depth) && (i < 25));i++)
1112: shift[2 * i] = shift[2 * i + 1] = ' ';
1113: shift[2 * i] = shift[2 * i + 1] = 0;
1114:
1115: fprintf(output, "%s", shift);
1116: if (op == NULL) {
1117: fprintf(output, "Step is NULL\n");
1118: return;
1119: }
1120: switch (op->op) {
1121: case XPATH_OP_END:
1122: fprintf(output, "END"); break;
1123: case XPATH_OP_AND:
1124: fprintf(output, "AND"); break;
1125: case XPATH_OP_OR:
1126: fprintf(output, "OR"); break;
1127: case XPATH_OP_EQUAL:
1128: if (op->value)
1129: fprintf(output, "EQUAL =");
1130: else
1131: fprintf(output, "EQUAL !=");
1132: break;
1133: case XPATH_OP_CMP:
1134: if (op->value)
1135: fprintf(output, "CMP <");
1136: else
1137: fprintf(output, "CMP >");
1138: if (!op->value2)
1139: fprintf(output, "=");
1140: break;
1141: case XPATH_OP_PLUS:
1142: if (op->value == 0)
1143: fprintf(output, "PLUS -");
1144: else if (op->value == 1)
1145: fprintf(output, "PLUS +");
1146: else if (op->value == 2)
1147: fprintf(output, "PLUS unary -");
1148: else if (op->value == 3)
1149: fprintf(output, "PLUS unary - -");
1150: break;
1151: case XPATH_OP_MULT:
1152: if (op->value == 0)
1153: fprintf(output, "MULT *");
1154: else if (op->value == 1)
1155: fprintf(output, "MULT div");
1156: else
1157: fprintf(output, "MULT mod");
1158: break;
1159: case XPATH_OP_UNION:
1160: fprintf(output, "UNION"); break;
1161: case XPATH_OP_ROOT:
1162: fprintf(output, "ROOT"); break;
1163: case XPATH_OP_NODE:
1164: fprintf(output, "NODE"); break;
1165: case XPATH_OP_RESET:
1166: fprintf(output, "RESET"); break;
1167: case XPATH_OP_SORT:
1168: fprintf(output, "SORT"); break;
1169: case XPATH_OP_COLLECT: {
1170: xmlXPathAxisVal axis = (xmlXPathAxisVal)op->value;
1171: xmlXPathTestVal test = (xmlXPathTestVal)op->value2;
1172: xmlXPathTypeVal type = (xmlXPathTypeVal)op->value3;
1173: const xmlChar *prefix = op->value4;
1174: const xmlChar *name = op->value5;
1175:
1176: fprintf(output, "COLLECT ");
1177: switch (axis) {
1178: case AXIS_ANCESTOR:
1179: fprintf(output, " 'ancestors' "); break;
1180: case AXIS_ANCESTOR_OR_SELF:
1181: fprintf(output, " 'ancestors-or-self' "); break;
1182: case AXIS_ATTRIBUTE:
1183: fprintf(output, " 'attributes' "); break;
1184: case AXIS_CHILD:
1185: fprintf(output, " 'child' "); break;
1186: case AXIS_DESCENDANT:
1187: fprintf(output, " 'descendant' "); break;
1188: case AXIS_DESCENDANT_OR_SELF:
1189: fprintf(output, " 'descendant-or-self' "); break;
1190: case AXIS_FOLLOWING:
1191: fprintf(output, " 'following' "); break;
1192: case AXIS_FOLLOWING_SIBLING:
1193: fprintf(output, " 'following-siblings' "); break;
1194: case AXIS_NAMESPACE:
1195: fprintf(output, " 'namespace' "); break;
1196: case AXIS_PARENT:
1197: fprintf(output, " 'parent' "); break;
1198: case AXIS_PRECEDING:
1199: fprintf(output, " 'preceding' "); break;
1200: case AXIS_PRECEDING_SIBLING:
1201: fprintf(output, " 'preceding-sibling' "); break;
1202: case AXIS_SELF:
1203: fprintf(output, " 'self' "); break;
1204: }
1205: switch (test) {
1206: case NODE_TEST_NONE:
1207: fprintf(output, "'none' "); break;
1208: case NODE_TEST_TYPE:
1209: fprintf(output, "'type' "); break;
1210: case NODE_TEST_PI:
1211: fprintf(output, "'PI' "); break;
1212: case NODE_TEST_ALL:
1213: fprintf(output, "'all' "); break;
1214: case NODE_TEST_NS:
1215: fprintf(output, "'namespace' "); break;
1216: case NODE_TEST_NAME:
1217: fprintf(output, "'name' "); break;
1218: }
1219: switch (type) {
1220: case NODE_TYPE_NODE:
1221: fprintf(output, "'node' "); break;
1222: case NODE_TYPE_COMMENT:
1223: fprintf(output, "'comment' "); break;
1224: case NODE_TYPE_TEXT:
1225: fprintf(output, "'text' "); break;
1226: case NODE_TYPE_PI:
1227: fprintf(output, "'PI' "); break;
1228: }
1229: if (prefix != NULL)
1230: fprintf(output, "%s:", prefix);
1231: if (name != NULL)
1232: fprintf(output, "%s", (const char *) name);
1233: break;
1234:
1235: }
1236: case XPATH_OP_VALUE: {
1237: xmlXPathObjectPtr object = (xmlXPathObjectPtr) op->value4;
1238:
1239: fprintf(output, "ELEM ");
1240: xmlXPathDebugDumpObject(output, object, 0);
1241: goto finish;
1242: }
1243: case XPATH_OP_VARIABLE: {
1244: const xmlChar *prefix = op->value5;
1245: const xmlChar *name = op->value4;
1246:
1247: if (prefix != NULL)
1248: fprintf(output, "VARIABLE %s:%s", prefix, name);
1249: else
1250: fprintf(output, "VARIABLE %s", name);
1251: break;
1252: }
1253: case XPATH_OP_FUNCTION: {
1254: int nbargs = op->value;
1255: const xmlChar *prefix = op->value5;
1256: const xmlChar *name = op->value4;
1257:
1258: if (prefix != NULL)
1259: fprintf(output, "FUNCTION %s:%s(%d args)",
1260: prefix, name, nbargs);
1261: else
1262: fprintf(output, "FUNCTION %s(%d args)", name, nbargs);
1263: break;
1264: }
1265: case XPATH_OP_ARG: fprintf(output, "ARG"); break;
1266: case XPATH_OP_PREDICATE: fprintf(output, "PREDICATE"); break;
1267: case XPATH_OP_FILTER: fprintf(output, "FILTER"); break;
1268: #ifdef LIBXML_XPTR_ENABLED
1269: case XPATH_OP_RANGETO: fprintf(output, "RANGETO"); break;
1270: #endif
1271: default:
1272: fprintf(output, "UNKNOWN %d\n", op->op); return;
1273: }
1274: fprintf(output, "\n");
1275: finish:
1276: if (op->ch1 >= 0)
1277: xmlXPathDebugDumpStepOp(output, comp, &comp->steps[op->ch1], depth + 1);
1278: if (op->ch2 >= 0)
1279: xmlXPathDebugDumpStepOp(output, comp, &comp->steps[op->ch2], depth + 1);
1280: }
1281:
1282: /**
1283: * xmlXPathDebugDumpCompExpr:
1284: * @output: the FILE * for the output
1285: * @comp: the precompiled XPath expression
1286: * @depth: the indentation level.
1287: *
1288: * Dumps the tree of the compiled XPath expression.
1289: */
1290: void
1291: xmlXPathDebugDumpCompExpr(FILE *output, xmlXPathCompExprPtr comp,
1292: int depth) {
1293: int i;
1294: char shift[100];
1295:
1296: if ((output == NULL) || (comp == NULL)) return;
1297:
1298: for (i = 0;((i < depth) && (i < 25));i++)
1299: shift[2 * i] = shift[2 * i + 1] = ' ';
1300: shift[2 * i] = shift[2 * i + 1] = 0;
1301:
1302: fprintf(output, "%s", shift);
1303:
1304: fprintf(output, "Compiled Expression : %d elements\n",
1305: comp->nbStep);
1306: i = comp->last;
1307: xmlXPathDebugDumpStepOp(output, comp, &comp->steps[i], depth + 1);
1308: }
1309:
1310: #ifdef XP_DEBUG_OBJ_USAGE
1311:
1312: /*
1313: * XPath object usage related debugging variables.
1314: */
1315: static int xmlXPathDebugObjCounterUndefined = 0;
1316: static int xmlXPathDebugObjCounterNodeset = 0;
1317: static int xmlXPathDebugObjCounterBool = 0;
1318: static int xmlXPathDebugObjCounterNumber = 0;
1319: static int xmlXPathDebugObjCounterString = 0;
1320: static int xmlXPathDebugObjCounterPoint = 0;
1321: static int xmlXPathDebugObjCounterRange = 0;
1322: static int xmlXPathDebugObjCounterLocset = 0;
1323: static int xmlXPathDebugObjCounterUsers = 0;
1324: static int xmlXPathDebugObjCounterXSLTTree = 0;
1325: static int xmlXPathDebugObjCounterAll = 0;
1326:
1327: static int xmlXPathDebugObjTotalUndefined = 0;
1328: static int xmlXPathDebugObjTotalNodeset = 0;
1329: static int xmlXPathDebugObjTotalBool = 0;
1330: static int xmlXPathDebugObjTotalNumber = 0;
1331: static int xmlXPathDebugObjTotalString = 0;
1332: static int xmlXPathDebugObjTotalPoint = 0;
1333: static int xmlXPathDebugObjTotalRange = 0;
1334: static int xmlXPathDebugObjTotalLocset = 0;
1335: static int xmlXPathDebugObjTotalUsers = 0;
1336: static int xmlXPathDebugObjTotalXSLTTree = 0;
1337: static int xmlXPathDebugObjTotalAll = 0;
1338:
1339: static int xmlXPathDebugObjMaxUndefined = 0;
1340: static int xmlXPathDebugObjMaxNodeset = 0;
1341: static int xmlXPathDebugObjMaxBool = 0;
1342: static int xmlXPathDebugObjMaxNumber = 0;
1343: static int xmlXPathDebugObjMaxString = 0;
1344: static int xmlXPathDebugObjMaxPoint = 0;
1345: static int xmlXPathDebugObjMaxRange = 0;
1346: static int xmlXPathDebugObjMaxLocset = 0;
1347: static int xmlXPathDebugObjMaxUsers = 0;
1348: static int xmlXPathDebugObjMaxXSLTTree = 0;
1349: static int xmlXPathDebugObjMaxAll = 0;
1350:
1351: /* REVISIT TODO: Make this static when committing */
1352: static void
1353: xmlXPathDebugObjUsageReset(xmlXPathContextPtr ctxt)
1354: {
1355: if (ctxt != NULL) {
1356: if (ctxt->cache != NULL) {
1357: xmlXPathContextCachePtr cache =
1358: (xmlXPathContextCachePtr) ctxt->cache;
1359:
1360: cache->dbgCachedAll = 0;
1361: cache->dbgCachedNodeset = 0;
1362: cache->dbgCachedString = 0;
1363: cache->dbgCachedBool = 0;
1364: cache->dbgCachedNumber = 0;
1365: cache->dbgCachedPoint = 0;
1366: cache->dbgCachedRange = 0;
1367: cache->dbgCachedLocset = 0;
1368: cache->dbgCachedUsers = 0;
1369: cache->dbgCachedXSLTTree = 0;
1370: cache->dbgCachedUndefined = 0;
1371:
1372: cache->dbgReusedAll = 0;
1373: cache->dbgReusedNodeset = 0;
1374: cache->dbgReusedString = 0;
1375: cache->dbgReusedBool = 0;
1376: cache->dbgReusedNumber = 0;
1377: cache->dbgReusedPoint = 0;
1378: cache->dbgReusedRange = 0;
1379: cache->dbgReusedLocset = 0;
1380: cache->dbgReusedUsers = 0;
1381: cache->dbgReusedXSLTTree = 0;
1382: cache->dbgReusedUndefined = 0;
1383: }
1384: }
1385:
1386: xmlXPathDebugObjCounterUndefined = 0;
1387: xmlXPathDebugObjCounterNodeset = 0;
1388: xmlXPathDebugObjCounterBool = 0;
1389: xmlXPathDebugObjCounterNumber = 0;
1390: xmlXPathDebugObjCounterString = 0;
1391: xmlXPathDebugObjCounterPoint = 0;
1392: xmlXPathDebugObjCounterRange = 0;
1393: xmlXPathDebugObjCounterLocset = 0;
1394: xmlXPathDebugObjCounterUsers = 0;
1395: xmlXPathDebugObjCounterXSLTTree = 0;
1396: xmlXPathDebugObjCounterAll = 0;
1397:
1398: xmlXPathDebugObjTotalUndefined = 0;
1399: xmlXPathDebugObjTotalNodeset = 0;
1400: xmlXPathDebugObjTotalBool = 0;
1401: xmlXPathDebugObjTotalNumber = 0;
1402: xmlXPathDebugObjTotalString = 0;
1403: xmlXPathDebugObjTotalPoint = 0;
1404: xmlXPathDebugObjTotalRange = 0;
1405: xmlXPathDebugObjTotalLocset = 0;
1406: xmlXPathDebugObjTotalUsers = 0;
1407: xmlXPathDebugObjTotalXSLTTree = 0;
1408: xmlXPathDebugObjTotalAll = 0;
1409:
1410: xmlXPathDebugObjMaxUndefined = 0;
1411: xmlXPathDebugObjMaxNodeset = 0;
1412: xmlXPathDebugObjMaxBool = 0;
1413: xmlXPathDebugObjMaxNumber = 0;
1414: xmlXPathDebugObjMaxString = 0;
1415: xmlXPathDebugObjMaxPoint = 0;
1416: xmlXPathDebugObjMaxRange = 0;
1417: xmlXPathDebugObjMaxLocset = 0;
1418: xmlXPathDebugObjMaxUsers = 0;
1419: xmlXPathDebugObjMaxXSLTTree = 0;
1420: xmlXPathDebugObjMaxAll = 0;
1421:
1422: }
1423:
1424: static void
1425: xmlXPathDebugObjUsageRequested(xmlXPathContextPtr ctxt,
1426: xmlXPathObjectType objType)
1427: {
1428: int isCached = 0;
1429:
1430: if (ctxt != NULL) {
1431: if (ctxt->cache != NULL) {
1432: xmlXPathContextCachePtr cache =
1433: (xmlXPathContextCachePtr) ctxt->cache;
1434:
1435: isCached = 1;
1436:
1437: cache->dbgReusedAll++;
1438: switch (objType) {
1439: case XPATH_UNDEFINED:
1440: cache->dbgReusedUndefined++;
1441: break;
1442: case XPATH_NODESET:
1443: cache->dbgReusedNodeset++;
1444: break;
1445: case XPATH_BOOLEAN:
1446: cache->dbgReusedBool++;
1447: break;
1448: case XPATH_NUMBER:
1449: cache->dbgReusedNumber++;
1450: break;
1451: case XPATH_STRING:
1452: cache->dbgReusedString++;
1453: break;
1454: case XPATH_POINT:
1455: cache->dbgReusedPoint++;
1456: break;
1457: case XPATH_RANGE:
1458: cache->dbgReusedRange++;
1459: break;
1460: case XPATH_LOCATIONSET:
1461: cache->dbgReusedLocset++;
1462: break;
1463: case XPATH_USERS:
1464: cache->dbgReusedUsers++;
1465: break;
1466: case XPATH_XSLT_TREE:
1467: cache->dbgReusedXSLTTree++;
1468: break;
1469: default:
1470: break;
1471: }
1472: }
1473: }
1474:
1475: switch (objType) {
1476: case XPATH_UNDEFINED:
1477: if (! isCached)
1478: xmlXPathDebugObjTotalUndefined++;
1479: xmlXPathDebugObjCounterUndefined++;
1480: if (xmlXPathDebugObjCounterUndefined >
1481: xmlXPathDebugObjMaxUndefined)
1482: xmlXPathDebugObjMaxUndefined =
1483: xmlXPathDebugObjCounterUndefined;
1484: break;
1485: case XPATH_NODESET:
1486: if (! isCached)
1487: xmlXPathDebugObjTotalNodeset++;
1488: xmlXPathDebugObjCounterNodeset++;
1489: if (xmlXPathDebugObjCounterNodeset >
1490: xmlXPathDebugObjMaxNodeset)
1491: xmlXPathDebugObjMaxNodeset =
1492: xmlXPathDebugObjCounterNodeset;
1493: break;
1494: case XPATH_BOOLEAN:
1495: if (! isCached)
1496: xmlXPathDebugObjTotalBool++;
1497: xmlXPathDebugObjCounterBool++;
1498: if (xmlXPathDebugObjCounterBool >
1499: xmlXPathDebugObjMaxBool)
1500: xmlXPathDebugObjMaxBool =
1501: xmlXPathDebugObjCounterBool;
1502: break;
1503: case XPATH_NUMBER:
1504: if (! isCached)
1505: xmlXPathDebugObjTotalNumber++;
1506: xmlXPathDebugObjCounterNumber++;
1507: if (xmlXPathDebugObjCounterNumber >
1508: xmlXPathDebugObjMaxNumber)
1509: xmlXPathDebugObjMaxNumber =
1510: xmlXPathDebugObjCounterNumber;
1511: break;
1512: case XPATH_STRING:
1513: if (! isCached)
1514: xmlXPathDebugObjTotalString++;
1515: xmlXPathDebugObjCounterString++;
1516: if (xmlXPathDebugObjCounterString >
1517: xmlXPathDebugObjMaxString)
1518: xmlXPathDebugObjMaxString =
1519: xmlXPathDebugObjCounterString;
1520: break;
1521: case XPATH_POINT:
1522: if (! isCached)
1523: xmlXPathDebugObjTotalPoint++;
1524: xmlXPathDebugObjCounterPoint++;
1525: if (xmlXPathDebugObjCounterPoint >
1526: xmlXPathDebugObjMaxPoint)
1527: xmlXPathDebugObjMaxPoint =
1528: xmlXPathDebugObjCounterPoint;
1529: break;
1530: case XPATH_RANGE:
1531: if (! isCached)
1532: xmlXPathDebugObjTotalRange++;
1533: xmlXPathDebugObjCounterRange++;
1534: if (xmlXPathDebugObjCounterRange >
1535: xmlXPathDebugObjMaxRange)
1536: xmlXPathDebugObjMaxRange =
1537: xmlXPathDebugObjCounterRange;
1538: break;
1539: case XPATH_LOCATIONSET:
1540: if (! isCached)
1541: xmlXPathDebugObjTotalLocset++;
1542: xmlXPathDebugObjCounterLocset++;
1543: if (xmlXPathDebugObjCounterLocset >
1544: xmlXPathDebugObjMaxLocset)
1545: xmlXPathDebugObjMaxLocset =
1546: xmlXPathDebugObjCounterLocset;
1547: break;
1548: case XPATH_USERS:
1549: if (! isCached)
1550: xmlXPathDebugObjTotalUsers++;
1551: xmlXPathDebugObjCounterUsers++;
1552: if (xmlXPathDebugObjCounterUsers >
1553: xmlXPathDebugObjMaxUsers)
1554: xmlXPathDebugObjMaxUsers =
1555: xmlXPathDebugObjCounterUsers;
1556: break;
1557: case XPATH_XSLT_TREE:
1558: if (! isCached)
1559: xmlXPathDebugObjTotalXSLTTree++;
1560: xmlXPathDebugObjCounterXSLTTree++;
1561: if (xmlXPathDebugObjCounterXSLTTree >
1562: xmlXPathDebugObjMaxXSLTTree)
1563: xmlXPathDebugObjMaxXSLTTree =
1564: xmlXPathDebugObjCounterXSLTTree;
1565: break;
1566: default:
1567: break;
1568: }
1569: if (! isCached)
1570: xmlXPathDebugObjTotalAll++;
1571: xmlXPathDebugObjCounterAll++;
1572: if (xmlXPathDebugObjCounterAll >
1573: xmlXPathDebugObjMaxAll)
1574: xmlXPathDebugObjMaxAll =
1575: xmlXPathDebugObjCounterAll;
1576: }
1577:
1578: static void
1579: xmlXPathDebugObjUsageReleased(xmlXPathContextPtr ctxt,
1580: xmlXPathObjectType objType)
1581: {
1582: int isCached = 0;
1583:
1584: if (ctxt != NULL) {
1585: if (ctxt->cache != NULL) {
1586: xmlXPathContextCachePtr cache =
1587: (xmlXPathContextCachePtr) ctxt->cache;
1588:
1589: isCached = 1;
1590:
1591: cache->dbgCachedAll++;
1592: switch (objType) {
1593: case XPATH_UNDEFINED:
1594: cache->dbgCachedUndefined++;
1595: break;
1596: case XPATH_NODESET:
1597: cache->dbgCachedNodeset++;
1598: break;
1599: case XPATH_BOOLEAN:
1600: cache->dbgCachedBool++;
1601: break;
1602: case XPATH_NUMBER:
1603: cache->dbgCachedNumber++;
1604: break;
1605: case XPATH_STRING:
1606: cache->dbgCachedString++;
1607: break;
1608: case XPATH_POINT:
1609: cache->dbgCachedPoint++;
1610: break;
1611: case XPATH_RANGE:
1612: cache->dbgCachedRange++;
1613: break;
1614: case XPATH_LOCATIONSET:
1615: cache->dbgCachedLocset++;
1616: break;
1617: case XPATH_USERS:
1618: cache->dbgCachedUsers++;
1619: break;
1620: case XPATH_XSLT_TREE:
1621: cache->dbgCachedXSLTTree++;
1622: break;
1623: default:
1624: break;
1625: }
1626:
1627: }
1628: }
1629: switch (objType) {
1630: case XPATH_UNDEFINED:
1631: xmlXPathDebugObjCounterUndefined--;
1632: break;
1633: case XPATH_NODESET:
1634: xmlXPathDebugObjCounterNodeset--;
1635: break;
1636: case XPATH_BOOLEAN:
1637: xmlXPathDebugObjCounterBool--;
1638: break;
1639: case XPATH_NUMBER:
1640: xmlXPathDebugObjCounterNumber--;
1641: break;
1642: case XPATH_STRING:
1643: xmlXPathDebugObjCounterString--;
1644: break;
1645: case XPATH_POINT:
1646: xmlXPathDebugObjCounterPoint--;
1647: break;
1648: case XPATH_RANGE:
1649: xmlXPathDebugObjCounterRange--;
1650: break;
1651: case XPATH_LOCATIONSET:
1652: xmlXPathDebugObjCounterLocset--;
1653: break;
1654: case XPATH_USERS:
1655: xmlXPathDebugObjCounterUsers--;
1656: break;
1657: case XPATH_XSLT_TREE:
1658: xmlXPathDebugObjCounterXSLTTree--;
1659: break;
1660: default:
1661: break;
1662: }
1663: xmlXPathDebugObjCounterAll--;
1664: }
1665:
1666: /* REVISIT TODO: Make this static when committing */
1667: static void
1668: xmlXPathDebugObjUsageDisplay(xmlXPathContextPtr ctxt)
1669: {
1670: int reqAll, reqNodeset, reqString, reqBool, reqNumber,
1671: reqXSLTTree, reqUndefined;
1672: int caAll = 0, caNodeset = 0, caString = 0, caBool = 0,
1673: caNumber = 0, caXSLTTree = 0, caUndefined = 0;
1674: int reAll = 0, reNodeset = 0, reString = 0, reBool = 0,
1675: reNumber = 0, reXSLTTree = 0, reUndefined = 0;
1676: int leftObjs = xmlXPathDebugObjCounterAll;
1677:
1678: reqAll = xmlXPathDebugObjTotalAll;
1679: reqNodeset = xmlXPathDebugObjTotalNodeset;
1680: reqString = xmlXPathDebugObjTotalString;
1681: reqBool = xmlXPathDebugObjTotalBool;
1682: reqNumber = xmlXPathDebugObjTotalNumber;
1683: reqXSLTTree = xmlXPathDebugObjTotalXSLTTree;
1684: reqUndefined = xmlXPathDebugObjTotalUndefined;
1685:
1686: printf("# XPath object usage:\n");
1687:
1688: if (ctxt != NULL) {
1689: if (ctxt->cache != NULL) {
1690: xmlXPathContextCachePtr cache =
1691: (xmlXPathContextCachePtr) ctxt->cache;
1692:
1693: reAll = cache->dbgReusedAll;
1694: reqAll += reAll;
1695: reNodeset = cache->dbgReusedNodeset;
1696: reqNodeset += reNodeset;
1697: reString = cache->dbgReusedString;
1698: reqString += reString;
1699: reBool = cache->dbgReusedBool;
1700: reqBool += reBool;
1701: reNumber = cache->dbgReusedNumber;
1702: reqNumber += reNumber;
1703: reXSLTTree = cache->dbgReusedXSLTTree;
1704: reqXSLTTree += reXSLTTree;
1705: reUndefined = cache->dbgReusedUndefined;
1706: reqUndefined += reUndefined;
1707:
1708: caAll = cache->dbgCachedAll;
1709: caBool = cache->dbgCachedBool;
1710: caNodeset = cache->dbgCachedNodeset;
1711: caString = cache->dbgCachedString;
1712: caNumber = cache->dbgCachedNumber;
1713: caXSLTTree = cache->dbgCachedXSLTTree;
1714: caUndefined = cache->dbgCachedUndefined;
1715:
1716: if (cache->nodesetObjs)
1717: leftObjs -= cache->nodesetObjs->number;
1718: if (cache->stringObjs)
1719: leftObjs -= cache->stringObjs->number;
1720: if (cache->booleanObjs)
1721: leftObjs -= cache->booleanObjs->number;
1722: if (cache->numberObjs)
1723: leftObjs -= cache->numberObjs->number;
1724: if (cache->miscObjs)
1725: leftObjs -= cache->miscObjs->number;
1726: }
1727: }
1728:
1729: printf("# all\n");
1730: printf("# total : %d\n", reqAll);
1731: printf("# left : %d\n", leftObjs);
1732: printf("# created: %d\n", xmlXPathDebugObjTotalAll);
1733: printf("# reused : %d\n", reAll);
1734: printf("# max : %d\n", xmlXPathDebugObjMaxAll);
1735:
1736: printf("# node-sets\n");
1737: printf("# total : %d\n", reqNodeset);
1738: printf("# created: %d\n", xmlXPathDebugObjTotalNodeset);
1739: printf("# reused : %d\n", reNodeset);
1740: printf("# max : %d\n", xmlXPathDebugObjMaxNodeset);
1741:
1742: printf("# strings\n");
1743: printf("# total : %d\n", reqString);
1744: printf("# created: %d\n", xmlXPathDebugObjTotalString);
1745: printf("# reused : %d\n", reString);
1746: printf("# max : %d\n", xmlXPathDebugObjMaxString);
1747:
1748: printf("# booleans\n");
1749: printf("# total : %d\n", reqBool);
1750: printf("# created: %d\n", xmlXPathDebugObjTotalBool);
1751: printf("# reused : %d\n", reBool);
1752: printf("# max : %d\n", xmlXPathDebugObjMaxBool);
1753:
1754: printf("# numbers\n");
1755: printf("# total : %d\n", reqNumber);
1756: printf("# created: %d\n", xmlXPathDebugObjTotalNumber);
1757: printf("# reused : %d\n", reNumber);
1758: printf("# max : %d\n", xmlXPathDebugObjMaxNumber);
1759:
1760: printf("# XSLT result tree fragments\n");
1761: printf("# total : %d\n", reqXSLTTree);
1762: printf("# created: %d\n", xmlXPathDebugObjTotalXSLTTree);
1763: printf("# reused : %d\n", reXSLTTree);
1764: printf("# max : %d\n", xmlXPathDebugObjMaxXSLTTree);
1765:
1766: printf("# undefined\n");
1767: printf("# total : %d\n", reqUndefined);
1768: printf("# created: %d\n", xmlXPathDebugObjTotalUndefined);
1769: printf("# reused : %d\n", reUndefined);
1770: printf("# max : %d\n", xmlXPathDebugObjMaxUndefined);
1771:
1772: }
1773:
1774: #endif /* XP_DEBUG_OBJ_USAGE */
1775:
1776: #endif /* LIBXML_DEBUG_ENABLED */
1777:
1778: /************************************************************************
1779: * *
1780: * XPath object caching *
1781: * *
1782: ************************************************************************/
1783:
1784: /**
1785: * xmlXPathNewCache:
1786: *
1787: * Create a new object cache
1788: *
1789: * Returns the xmlXPathCache just allocated.
1790: */
1791: static xmlXPathContextCachePtr
1792: xmlXPathNewCache(void)
1793: {
1794: xmlXPathContextCachePtr ret;
1795:
1796: ret = (xmlXPathContextCachePtr) xmlMalloc(sizeof(xmlXPathContextCache));
1797: if (ret == NULL) {
1798: xmlXPathErrMemory(NULL, "creating object cache\n");
1799: return(NULL);
1800: }
1801: memset(ret, 0 , (size_t) sizeof(xmlXPathContextCache));
1802: ret->maxNodeset = 100;
1803: ret->maxString = 100;
1804: ret->maxBoolean = 100;
1805: ret->maxNumber = 100;
1806: ret->maxMisc = 100;
1807: return(ret);
1808: }
1809:
1810: static void
1811: xmlXPathCacheFreeObjectList(xmlPointerListPtr list)
1812: {
1813: int i;
1814: xmlXPathObjectPtr obj;
1815:
1816: if (list == NULL)
1817: return;
1818:
1819: for (i = 0; i < list->number; i++) {
1820: obj = list->items[i];
1821: /*
1822: * Note that it is already assured that we don't need to
1823: * look out for namespace nodes in the node-set.
1824: */
1825: if (obj->nodesetval != NULL) {
1826: if (obj->nodesetval->nodeTab != NULL)
1827: xmlFree(obj->nodesetval->nodeTab);
1828: xmlFree(obj->nodesetval);
1829: }
1830: xmlFree(obj);
1831: #ifdef XP_DEBUG_OBJ_USAGE
1832: xmlXPathDebugObjCounterAll--;
1833: #endif
1834: }
1835: xmlPointerListFree(list);
1836: }
1837:
1838: static void
1839: xmlXPathFreeCache(xmlXPathContextCachePtr cache)
1840: {
1841: if (cache == NULL)
1842: return;
1843: if (cache->nodesetObjs)
1844: xmlXPathCacheFreeObjectList(cache->nodesetObjs);
1845: if (cache->stringObjs)
1846: xmlXPathCacheFreeObjectList(cache->stringObjs);
1847: if (cache->booleanObjs)
1848: xmlXPathCacheFreeObjectList(cache->booleanObjs);
1849: if (cache->numberObjs)
1850: xmlXPathCacheFreeObjectList(cache->numberObjs);
1851: if (cache->miscObjs)
1852: xmlXPathCacheFreeObjectList(cache->miscObjs);
1853: xmlFree(cache);
1854: }
1855:
1856: /**
1857: * xmlXPathContextSetCache:
1858: *
1859: * @ctxt: the XPath context
1860: * @active: enables/disables (creates/frees) the cache
1861: * @value: a value with semantics dependant on @options
1862: * @options: options (currently only the value 0 is used)
1863: *
1864: * Creates/frees an object cache on the XPath context.
1865: * If activates XPath objects (xmlXPathObject) will be cached internally
1866: * to be reused.
1867: * @options:
1868: * 0: This will set the XPath object caching:
1869: * @value:
1870: * This will set the maximum number of XPath objects
1871: * to be cached per slot
1872: * There are 5 slots for: node-set, string, number, boolean, and
1873: * misc objects. Use <0 for the default number (100).
1874: * Other values for @options have currently no effect.
1875: *
1876: * Returns 0 if the setting succeeded, and -1 on API or internal errors.
1877: */
1878: int
1879: xmlXPathContextSetCache(xmlXPathContextPtr ctxt,
1880: int active,
1881: int value,
1882: int options)
1883: {
1884: if (ctxt == NULL)
1885: return(-1);
1886: if (active) {
1887: xmlXPathContextCachePtr cache;
1888:
1889: if (ctxt->cache == NULL) {
1890: ctxt->cache = xmlXPathNewCache();
1891: if (ctxt->cache == NULL)
1892: return(-1);
1893: }
1894: cache = (xmlXPathContextCachePtr) ctxt->cache;
1895: if (options == 0) {
1896: if (value < 0)
1897: value = 100;
1898: cache->maxNodeset = value;
1899: cache->maxString = value;
1900: cache->maxNumber = value;
1901: cache->maxBoolean = value;
1902: cache->maxMisc = value;
1903: }
1904: } else if (ctxt->cache != NULL) {
1905: xmlXPathFreeCache((xmlXPathContextCachePtr) ctxt->cache);
1906: ctxt->cache = NULL;
1907: }
1908: return(0);
1909: }
1910:
1911: /**
1912: * xmlXPathCacheWrapNodeSet:
1913: * @ctxt: the XPath context
1914: * @val: the NodePtr value
1915: *
1916: * This is the cached version of xmlXPathWrapNodeSet().
1917: * Wrap the Nodeset @val in a new xmlXPathObjectPtr
1918: *
1919: * Returns the created or reused object.
1920: */
1921: static xmlXPathObjectPtr
1922: xmlXPathCacheWrapNodeSet(xmlXPathContextPtr ctxt, xmlNodeSetPtr val)
1923: {
1924: if ((ctxt != NULL) && (ctxt->cache != NULL)) {
1925: xmlXPathContextCachePtr cache =
1926: (xmlXPathContextCachePtr) ctxt->cache;
1927:
1928: if ((cache->miscObjs != NULL) &&
1929: (cache->miscObjs->number != 0))
1930: {
1931: xmlXPathObjectPtr ret;
1932:
1933: ret = (xmlXPathObjectPtr)
1934: cache->miscObjs->items[--cache->miscObjs->number];
1935: ret->type = XPATH_NODESET;
1936: ret->nodesetval = val;
1937: #ifdef XP_DEBUG_OBJ_USAGE
1938: xmlXPathDebugObjUsageRequested(ctxt, XPATH_NODESET);
1939: #endif
1940: return(ret);
1941: }
1942: }
1943:
1944: return(xmlXPathWrapNodeSet(val));
1945:
1946: }
1947:
1948: /**
1949: * xmlXPathCacheWrapString:
1950: * @ctxt: the XPath context
1951: * @val: the xmlChar * value
1952: *
1953: * This is the cached version of xmlXPathWrapString().
1954: * Wraps the @val string into an XPath object.
1955: *
1956: * Returns the created or reused object.
1957: */
1958: static xmlXPathObjectPtr
1959: xmlXPathCacheWrapString(xmlXPathContextPtr ctxt, xmlChar *val)
1960: {
1961: if ((ctxt != NULL) && (ctxt->cache != NULL)) {
1962: xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache;
1963:
1964: if ((cache->stringObjs != NULL) &&
1965: (cache->stringObjs->number != 0))
1966: {
1967:
1968: xmlXPathObjectPtr ret;
1969:
1970: ret = (xmlXPathObjectPtr)
1971: cache->stringObjs->items[--cache->stringObjs->number];
1972: ret->type = XPATH_STRING;
1973: ret->stringval = val;
1974: #ifdef XP_DEBUG_OBJ_USAGE
1975: xmlXPathDebugObjUsageRequested(ctxt, XPATH_STRING);
1976: #endif
1977: return(ret);
1978: } else if ((cache->miscObjs != NULL) &&
1979: (cache->miscObjs->number != 0))
1980: {
1981: xmlXPathObjectPtr ret;
1982: /*
1983: * Fallback to misc-cache.
1984: */
1985: ret = (xmlXPathObjectPtr)
1986: cache->miscObjs->items[--cache->miscObjs->number];
1987:
1988: ret->type = XPATH_STRING;
1989: ret->stringval = val;
1990: #ifdef XP_DEBUG_OBJ_USAGE
1991: xmlXPathDebugObjUsageRequested(ctxt, XPATH_STRING);
1992: #endif
1993: return(ret);
1994: }
1995: }
1996: return(xmlXPathWrapString(val));
1997: }
1998:
1999: /**
2000: * xmlXPathCacheNewNodeSet:
2001: * @ctxt: the XPath context
2002: * @val: the NodePtr value
2003: *
2004: * This is the cached version of xmlXPathNewNodeSet().
2005: * Acquire an xmlXPathObjectPtr of type NodeSet and initialize
2006: * it with the single Node @val
2007: *
2008: * Returns the created or reused object.
2009: */
2010: static xmlXPathObjectPtr
2011: xmlXPathCacheNewNodeSet(xmlXPathContextPtr ctxt, xmlNodePtr val)
2012: {
2013: if ((ctxt != NULL) && (ctxt->cache)) {
2014: xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache;
2015:
2016: if ((cache->nodesetObjs != NULL) &&
2017: (cache->nodesetObjs->number != 0))
2018: {
2019: xmlXPathObjectPtr ret;
2020: /*
2021: * Use the nodset-cache.
2022: */
2023: ret = (xmlXPathObjectPtr)
2024: cache->nodesetObjs->items[--cache->nodesetObjs->number];
2025: ret->type = XPATH_NODESET;
2026: ret->boolval = 0;
2027: if (val) {
2028: if ((ret->nodesetval->nodeMax == 0) ||
2029: (val->type == XML_NAMESPACE_DECL))
2030: {
2031: xmlXPathNodeSetAddUnique(ret->nodesetval, val);
2032: } else {
2033: ret->nodesetval->nodeTab[0] = val;
2034: ret->nodesetval->nodeNr = 1;
2035: }
2036: }
2037: #ifdef XP_DEBUG_OBJ_USAGE
2038: xmlXPathDebugObjUsageRequested(ctxt, XPATH_NODESET);
2039: #endif
2040: return(ret);
2041: } else if ((cache->miscObjs != NULL) &&
2042: (cache->miscObjs->number != 0))
2043: {
2044: xmlXPathObjectPtr ret;
2045: /*
2046: * Fallback to misc-cache.
2047: */
2048:
2049: ret = (xmlXPathObjectPtr)
2050: cache->miscObjs->items[--cache->miscObjs->number];
2051:
2052: ret->type = XPATH_NODESET;
2053: ret->boolval = 0;
2054: ret->nodesetval = xmlXPathNodeSetCreate(val);
2055: #ifdef XP_DEBUG_OBJ_USAGE
2056: xmlXPathDebugObjUsageRequested(ctxt, XPATH_NODESET);
2057: #endif
2058: return(ret);
2059: }
2060: }
2061: return(xmlXPathNewNodeSet(val));
2062: }
2063:
2064: /**
2065: * xmlXPathCacheNewCString:
2066: * @ctxt: the XPath context
2067: * @val: the char * value
2068: *
2069: * This is the cached version of xmlXPathNewCString().
2070: * Acquire an xmlXPathObjectPtr of type string and of value @val
2071: *
2072: * Returns the created or reused object.
2073: */
2074: static xmlXPathObjectPtr
2075: xmlXPathCacheNewCString(xmlXPathContextPtr ctxt, const char *val)
2076: {
2077: if ((ctxt != NULL) && (ctxt->cache)) {
2078: xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache;
2079:
2080: if ((cache->stringObjs != NULL) &&
2081: (cache->stringObjs->number != 0))
2082: {
2083: xmlXPathObjectPtr ret;
2084:
2085: ret = (xmlXPathObjectPtr)
2086: cache->stringObjs->items[--cache->stringObjs->number];
2087:
2088: ret->type = XPATH_STRING;
2089: ret->stringval = xmlStrdup(BAD_CAST val);
2090: #ifdef XP_DEBUG_OBJ_USAGE
2091: xmlXPathDebugObjUsageRequested(ctxt, XPATH_STRING);
2092: #endif
2093: return(ret);
2094: } else if ((cache->miscObjs != NULL) &&
2095: (cache->miscObjs->number != 0))
2096: {
2097: xmlXPathObjectPtr ret;
2098:
2099: ret = (xmlXPathObjectPtr)
2100: cache->miscObjs->items[--cache->miscObjs->number];
2101:
2102: ret->type = XPATH_STRING;
2103: ret->stringval = xmlStrdup(BAD_CAST val);
2104: #ifdef XP_DEBUG_OBJ_USAGE
2105: xmlXPathDebugObjUsageRequested(ctxt, XPATH_STRING);
2106: #endif
2107: return(ret);
2108: }
2109: }
2110: return(xmlXPathNewCString(val));
2111: }
2112:
2113: /**
2114: * xmlXPathCacheNewString:
2115: * @ctxt: the XPath context
2116: * @val: the xmlChar * value
2117: *
2118: * This is the cached version of xmlXPathNewString().
2119: * Acquire an xmlXPathObjectPtr of type string and of value @val
2120: *
2121: * Returns the created or reused object.
2122: */
2123: static xmlXPathObjectPtr
2124: xmlXPathCacheNewString(xmlXPathContextPtr ctxt, const xmlChar *val)
2125: {
2126: if ((ctxt != NULL) && (ctxt->cache)) {
2127: xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache;
2128:
2129: if ((cache->stringObjs != NULL) &&
2130: (cache->stringObjs->number != 0))
2131: {
2132: xmlXPathObjectPtr ret;
2133:
2134: ret = (xmlXPathObjectPtr)
2135: cache->stringObjs->items[--cache->stringObjs->number];
2136: ret->type = XPATH_STRING;
2137: if (val != NULL)
2138: ret->stringval = xmlStrdup(val);
2139: else
2140: ret->stringval = xmlStrdup((const xmlChar *)"");
2141: #ifdef XP_DEBUG_OBJ_USAGE
2142: xmlXPathDebugObjUsageRequested(ctxt, XPATH_STRING);
2143: #endif
2144: return(ret);
2145: } else if ((cache->miscObjs != NULL) &&
2146: (cache->miscObjs->number != 0))
2147: {
2148: xmlXPathObjectPtr ret;
2149:
2150: ret = (xmlXPathObjectPtr)
2151: cache->miscObjs->items[--cache->miscObjs->number];
2152:
2153: ret->type = XPATH_STRING;
2154: if (val != NULL)
2155: ret->stringval = xmlStrdup(val);
2156: else
2157: ret->stringval = xmlStrdup((const xmlChar *)"");
2158: #ifdef XP_DEBUG_OBJ_USAGE
2159: xmlXPathDebugObjUsageRequested(ctxt, XPATH_STRING);
2160: #endif
2161: return(ret);
2162: }
2163: }
2164: return(xmlXPathNewString(val));
2165: }
2166:
2167: /**
2168: * xmlXPathCacheNewBoolean:
2169: * @ctxt: the XPath context
2170: * @val: the boolean value
2171: *
2172: * This is the cached version of xmlXPathNewBoolean().
2173: * Acquires an xmlXPathObjectPtr of type boolean and of value @val
2174: *
2175: * Returns the created or reused object.
2176: */
2177: static xmlXPathObjectPtr
2178: xmlXPathCacheNewBoolean(xmlXPathContextPtr ctxt, int val)
2179: {
2180: if ((ctxt != NULL) && (ctxt->cache)) {
2181: xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache;
2182:
2183: if ((cache->booleanObjs != NULL) &&
2184: (cache->booleanObjs->number != 0))
2185: {
2186: xmlXPathObjectPtr ret;
2187:
2188: ret = (xmlXPathObjectPtr)
2189: cache->booleanObjs->items[--cache->booleanObjs->number];
2190: ret->type = XPATH_BOOLEAN;
2191: ret->boolval = (val != 0);
2192: #ifdef XP_DEBUG_OBJ_USAGE
2193: xmlXPathDebugObjUsageRequested(ctxt, XPATH_BOOLEAN);
2194: #endif
2195: return(ret);
2196: } else if ((cache->miscObjs != NULL) &&
2197: (cache->miscObjs->number != 0))
2198: {
2199: xmlXPathObjectPtr ret;
2200:
2201: ret = (xmlXPathObjectPtr)
2202: cache->miscObjs->items[--cache->miscObjs->number];
2203:
2204: ret->type = XPATH_BOOLEAN;
2205: ret->boolval = (val != 0);
2206: #ifdef XP_DEBUG_OBJ_USAGE
2207: xmlXPathDebugObjUsageRequested(ctxt, XPATH_BOOLEAN);
2208: #endif
2209: return(ret);
2210: }
2211: }
2212: return(xmlXPathNewBoolean(val));
2213: }
2214:
2215: /**
2216: * xmlXPathCacheNewFloat:
2217: * @ctxt: the XPath context
2218: * @val: the double value
2219: *
2220: * This is the cached version of xmlXPathNewFloat().
2221: * Acquires an xmlXPathObjectPtr of type double and of value @val
2222: *
2223: * Returns the created or reused object.
2224: */
2225: static xmlXPathObjectPtr
2226: xmlXPathCacheNewFloat(xmlXPathContextPtr ctxt, double val)
2227: {
2228: if ((ctxt != NULL) && (ctxt->cache)) {
2229: xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache;
2230:
2231: if ((cache->numberObjs != NULL) &&
2232: (cache->numberObjs->number != 0))
2233: {
2234: xmlXPathObjectPtr ret;
2235:
2236: ret = (xmlXPathObjectPtr)
2237: cache->numberObjs->items[--cache->numberObjs->number];
2238: ret->type = XPATH_NUMBER;
2239: ret->floatval = val;
2240: #ifdef XP_DEBUG_OBJ_USAGE
2241: xmlXPathDebugObjUsageRequested(ctxt, XPATH_NUMBER);
2242: #endif
2243: return(ret);
2244: } else if ((cache->miscObjs != NULL) &&
2245: (cache->miscObjs->number != 0))
2246: {
2247: xmlXPathObjectPtr ret;
2248:
2249: ret = (xmlXPathObjectPtr)
2250: cache->miscObjs->items[--cache->miscObjs->number];
2251:
2252: ret->type = XPATH_NUMBER;
2253: ret->floatval = val;
2254: #ifdef XP_DEBUG_OBJ_USAGE
2255: xmlXPathDebugObjUsageRequested(ctxt, XPATH_NUMBER);
2256: #endif
2257: return(ret);
2258: }
2259: }
2260: return(xmlXPathNewFloat(val));
2261: }
2262:
2263: /**
2264: * xmlXPathCacheConvertString:
2265: * @ctxt: the XPath context
2266: * @val: an XPath object
2267: *
2268: * This is the cached version of xmlXPathConvertString().
2269: * Converts an existing object to its string() equivalent
2270: *
2271: * Returns a created or reused object, the old one is freed (cached)
2272: * (or the operation is done directly on @val)
2273: */
2274:
2275: static xmlXPathObjectPtr
2276: xmlXPathCacheConvertString(xmlXPathContextPtr ctxt, xmlXPathObjectPtr val) {
2277: xmlChar *res = NULL;
2278:
2279: if (val == NULL)
2280: return(xmlXPathCacheNewCString(ctxt, ""));
2281:
2282: switch (val->type) {
2283: case XPATH_UNDEFINED:
2284: #ifdef DEBUG_EXPR
2285: xmlGenericError(xmlGenericErrorContext, "STRING: undefined\n");
2286: #endif
2287: break;
2288: case XPATH_NODESET:
2289: case XPATH_XSLT_TREE:
2290: res = xmlXPathCastNodeSetToString(val->nodesetval);
2291: break;
2292: case XPATH_STRING:
2293: return(val);
2294: case XPATH_BOOLEAN:
2295: res = xmlXPathCastBooleanToString(val->boolval);
2296: break;
2297: case XPATH_NUMBER:
2298: res = xmlXPathCastNumberToString(val->floatval);
2299: break;
2300: case XPATH_USERS:
2301: case XPATH_POINT:
2302: case XPATH_RANGE:
2303: case XPATH_LOCATIONSET:
2304: TODO;
2305: break;
2306: }
2307: xmlXPathReleaseObject(ctxt, val);
2308: if (res == NULL)
2309: return(xmlXPathCacheNewCString(ctxt, ""));
2310: return(xmlXPathCacheWrapString(ctxt, res));
2311: }
2312:
2313: /**
2314: * xmlXPathCacheObjectCopy:
2315: * @ctxt: the XPath context
2316: * @val: the original object
2317: *
2318: * This is the cached version of xmlXPathObjectCopy().
2319: * Acquire a copy of a given object
2320: *
2321: * Returns a created or reused created object.
2322: */
2323: static xmlXPathObjectPtr
2324: xmlXPathCacheObjectCopy(xmlXPathContextPtr ctxt, xmlXPathObjectPtr val)
2325: {
2326: if (val == NULL)
2327: return(NULL);
2328:
2329: if (XP_HAS_CACHE(ctxt)) {
2330: switch (val->type) {
2331: case XPATH_NODESET:
2332: return(xmlXPathCacheWrapNodeSet(ctxt,
2333: xmlXPathNodeSetMerge(NULL, val->nodesetval)));
2334: case XPATH_STRING:
2335: return(xmlXPathCacheNewString(ctxt, val->stringval));
2336: case XPATH_BOOLEAN:
2337: return(xmlXPathCacheNewBoolean(ctxt, val->boolval));
2338: case XPATH_NUMBER:
2339: return(xmlXPathCacheNewFloat(ctxt, val->floatval));
2340: default:
2341: break;
2342: }
2343: }
2344: return(xmlXPathObjectCopy(val));
2345: }
2346:
2347: /**
2348: * xmlXPathCacheConvertBoolean:
2349: * @ctxt: the XPath context
2350: * @val: an XPath object
2351: *
2352: * This is the cached version of xmlXPathConvertBoolean().
2353: * Converts an existing object to its boolean() equivalent
2354: *
2355: * Returns a created or reused object, the old one is freed (or the operation
2356: * is done directly on @val)
2357: */
2358: static xmlXPathObjectPtr
2359: xmlXPathCacheConvertBoolean(xmlXPathContextPtr ctxt, xmlXPathObjectPtr val) {
2360: xmlXPathObjectPtr ret;
2361:
2362: if (val == NULL)
2363: return(xmlXPathCacheNewBoolean(ctxt, 0));
2364: if (val->type == XPATH_BOOLEAN)
2365: return(val);
2366: ret = xmlXPathCacheNewBoolean(ctxt, xmlXPathCastToBoolean(val));
2367: xmlXPathReleaseObject(ctxt, val);
2368: return(ret);
2369: }
2370:
2371: /**
2372: * xmlXPathCacheConvertNumber:
2373: * @ctxt: the XPath context
2374: * @val: an XPath object
2375: *
2376: * This is the cached version of xmlXPathConvertNumber().
2377: * Converts an existing object to its number() equivalent
2378: *
2379: * Returns a created or reused object, the old one is freed (or the operation
2380: * is done directly on @val)
2381: */
2382: static xmlXPathObjectPtr
2383: xmlXPathCacheConvertNumber(xmlXPathContextPtr ctxt, xmlXPathObjectPtr val) {
2384: xmlXPathObjectPtr ret;
2385:
2386: if (val == NULL)
2387: return(xmlXPathCacheNewFloat(ctxt, 0.0));
2388: if (val->type == XPATH_NUMBER)
2389: return(val);
2390: ret = xmlXPathCacheNewFloat(ctxt, xmlXPathCastToNumber(val));
2391: xmlXPathReleaseObject(ctxt, val);
2392: return(ret);
2393: }
2394:
2395: /************************************************************************
2396: * *
2397: * Parser stacks related functions and macros *
2398: * *
2399: ************************************************************************/
2400:
2401: /**
2402: * xmlXPathSetFrame:
2403: * @ctxt: an XPath parser context
2404: *
2405: * Set the callee evaluation frame
2406: *
2407: * Returns the previous frame value to be restored once done
2408: */
2409: static int
2410: xmlXPathSetFrame(xmlXPathParserContextPtr ctxt) {
2411: int ret;
2412:
2413: if (ctxt == NULL)
2414: return(0);
2415: ret = ctxt->valueFrame;
2416: ctxt->valueFrame = ctxt->valueNr;
2417: return(ret);
2418: }
2419:
2420: /**
2421: * xmlXPathPopFrame:
2422: * @ctxt: an XPath parser context
2423: * @frame: the previous frame value
2424: *
2425: * Remove the callee evaluation frame
2426: */
2427: static void
2428: xmlXPathPopFrame(xmlXPathParserContextPtr ctxt, int frame) {
2429: if (ctxt == NULL)
2430: return;
2431: if (ctxt->valueNr < ctxt->valueFrame) {
2432: xmlXPatherror(ctxt, __FILE__, __LINE__, XPATH_STACK_ERROR);
2433: }
2434: ctxt->valueFrame = frame;
2435: }
2436:
2437: /**
2438: * valuePop:
2439: * @ctxt: an XPath evaluation context
2440: *
2441: * Pops the top XPath object from the value stack
2442: *
2443: * Returns the XPath object just removed
2444: */
2445: xmlXPathObjectPtr
2446: valuePop(xmlXPathParserContextPtr ctxt)
2447: {
2448: xmlXPathObjectPtr ret;
2449:
2450: if ((ctxt == NULL) || (ctxt->valueNr <= 0))
2451: return (NULL);
2452:
2453: if (ctxt->valueNr <= ctxt->valueFrame) {
2454: xmlXPatherror(ctxt, __FILE__, __LINE__, XPATH_STACK_ERROR);
2455: return (NULL);
2456: }
2457:
2458: ctxt->valueNr--;
2459: if (ctxt->valueNr > 0)
2460: ctxt->value = ctxt->valueTab[ctxt->valueNr - 1];
2461: else
2462: ctxt->value = NULL;
2463: ret = ctxt->valueTab[ctxt->valueNr];
2464: ctxt->valueTab[ctxt->valueNr] = NULL;
2465: return (ret);
2466: }
2467: /**
2468: * valuePush:
2469: * @ctxt: an XPath evaluation context
2470: * @value: the XPath object
2471: *
2472: * Pushes a new XPath object on top of the value stack
2473: *
2474: * returns the number of items on the value stack
2475: */
2476: int
2477: valuePush(xmlXPathParserContextPtr ctxt, xmlXPathObjectPtr value)
2478: {
2479: if ((ctxt == NULL) || (value == NULL)) return(-1);
2480: if (ctxt->valueNr >= ctxt->valueMax) {
2481: xmlXPathObjectPtr *tmp;
2482:
2483: tmp = (xmlXPathObjectPtr *) xmlRealloc(ctxt->valueTab,
2484: 2 * ctxt->valueMax *
2485: sizeof(ctxt->valueTab[0]));
2486: if (tmp == NULL) {
2487: xmlGenericError(xmlGenericErrorContext, "realloc failed !\n");
2488: ctxt->error = XPATH_MEMORY_ERROR;
2489: return (0);
2490: }
2491: ctxt->valueMax *= 2;
2492: ctxt->valueTab = tmp;
2493: }
2494: ctxt->valueTab[ctxt->valueNr] = value;
2495: ctxt->value = value;
2496: return (ctxt->valueNr++);
2497: }
2498:
2499: /**
2500: * xmlXPathPopBoolean:
2501: * @ctxt: an XPath parser context
2502: *
2503: * Pops a boolean from the stack, handling conversion if needed.
2504: * Check error with #xmlXPathCheckError.
2505: *
2506: * Returns the boolean
2507: */
2508: int
2509: xmlXPathPopBoolean (xmlXPathParserContextPtr ctxt) {
2510: xmlXPathObjectPtr obj;
2511: int ret;
2512:
2513: obj = valuePop(ctxt);
2514: if (obj == NULL) {
2515: xmlXPathSetError(ctxt, XPATH_INVALID_OPERAND);
2516: return(0);
2517: }
2518: if (obj->type != XPATH_BOOLEAN)
2519: ret = xmlXPathCastToBoolean(obj);
2520: else
2521: ret = obj->boolval;
2522: xmlXPathReleaseObject(ctxt->context, obj);
2523: return(ret);
2524: }
2525:
2526: /**
2527: * xmlXPathPopNumber:
2528: * @ctxt: an XPath parser context
2529: *
2530: * Pops a number from the stack, handling conversion if needed.
2531: * Check error with #xmlXPathCheckError.
2532: *
2533: * Returns the number
2534: */
2535: double
2536: xmlXPathPopNumber (xmlXPathParserContextPtr ctxt) {
2537: xmlXPathObjectPtr obj;
2538: double ret;
2539:
2540: obj = valuePop(ctxt);
2541: if (obj == NULL) {
2542: xmlXPathSetError(ctxt, XPATH_INVALID_OPERAND);
2543: return(0);
2544: }
2545: if (obj->type != XPATH_NUMBER)
2546: ret = xmlXPathCastToNumber(obj);
2547: else
2548: ret = obj->floatval;
2549: xmlXPathReleaseObject(ctxt->context, obj);
2550: return(ret);
2551: }
2552:
2553: /**
2554: * xmlXPathPopString:
2555: * @ctxt: an XPath parser context
2556: *
2557: * Pops a string from the stack, handling conversion if needed.
2558: * Check error with #xmlXPathCheckError.
2559: *
2560: * Returns the string
2561: */
2562: xmlChar *
2563: xmlXPathPopString (xmlXPathParserContextPtr ctxt) {
2564: xmlXPathObjectPtr obj;
2565: xmlChar * ret;
2566:
2567: obj = valuePop(ctxt);
2568: if (obj == NULL) {
2569: xmlXPathSetError(ctxt, XPATH_INVALID_OPERAND);
2570: return(NULL);
2571: }
2572: ret = xmlXPathCastToString(obj); /* this does required strdup */
2573: /* TODO: needs refactoring somewhere else */
2574: if (obj->stringval == ret)
2575: obj->stringval = NULL;
2576: xmlXPathReleaseObject(ctxt->context, obj);
2577: return(ret);
2578: }
2579:
2580: /**
2581: * xmlXPathPopNodeSet:
2582: * @ctxt: an XPath parser context
2583: *
2584: * Pops a node-set from the stack, handling conversion if needed.
2585: * Check error with #xmlXPathCheckError.
2586: *
2587: * Returns the node-set
2588: */
2589: xmlNodeSetPtr
2590: xmlXPathPopNodeSet (xmlXPathParserContextPtr ctxt) {
2591: xmlXPathObjectPtr obj;
2592: xmlNodeSetPtr ret;
2593:
2594: if (ctxt == NULL) return(NULL);
2595: if (ctxt->value == NULL) {
2596: xmlXPathSetError(ctxt, XPATH_INVALID_OPERAND);
2597: return(NULL);
2598: }
2599: if (!xmlXPathStackIsNodeSet(ctxt)) {
2600: xmlXPathSetTypeError(ctxt);
2601: return(NULL);
2602: }
2603: obj = valuePop(ctxt);
2604: ret = obj->nodesetval;
2605: #if 0
2606: /* to fix memory leak of not clearing obj->user */
2607: if (obj->boolval && obj->user != NULL)
2608: xmlFreeNodeList((xmlNodePtr) obj->user);
2609: #endif
2610: obj->nodesetval = NULL;
2611: xmlXPathReleaseObject(ctxt->context, obj);
2612: return(ret);
2613: }
2614:
2615: /**
2616: * xmlXPathPopExternal:
2617: * @ctxt: an XPath parser context
2618: *
2619: * Pops an external object from the stack, handling conversion if needed.
2620: * Check error with #xmlXPathCheckError.
2621: *
2622: * Returns the object
2623: */
2624: void *
2625: xmlXPathPopExternal (xmlXPathParserContextPtr ctxt) {
2626: xmlXPathObjectPtr obj;
2627: void * ret;
2628:
2629: if ((ctxt == NULL) || (ctxt->value == NULL)) {
2630: xmlXPathSetError(ctxt, XPATH_INVALID_OPERAND);
2631: return(NULL);
2632: }
2633: if (ctxt->value->type != XPATH_USERS) {
2634: xmlXPathSetTypeError(ctxt);
2635: return(NULL);
2636: }
2637: obj = valuePop(ctxt);
2638: ret = obj->user;
2639: obj->user = NULL;
2640: xmlXPathReleaseObject(ctxt->context, obj);
2641: return(ret);
2642: }
2643:
2644: /*
2645: * Macros for accessing the content. Those should be used only by the parser,
2646: * and not exported.
2647: *
2648: * Dirty macros, i.e. one need to make assumption on the context to use them
2649: *
2650: * CUR_PTR return the current pointer to the xmlChar to be parsed.
2651: * CUR returns the current xmlChar value, i.e. a 8 bit value
2652: * in ISO-Latin or UTF-8.
2653: * This should be used internally by the parser
2654: * only to compare to ASCII values otherwise it would break when
2655: * running with UTF-8 encoding.
2656: * NXT(n) returns the n'th next xmlChar. Same as CUR is should be used only
2657: * to compare on ASCII based substring.
2658: * SKIP(n) Skip n xmlChar, and must also be used only to skip ASCII defined
2659: * strings within the parser.
2660: * CURRENT Returns the current char value, with the full decoding of
2661: * UTF-8 if we are using this mode. It returns an int.
2662: * NEXT Skip to the next character, this does the proper decoding
2663: * in UTF-8 mode. It also pop-up unfinished entities on the fly.
2664: * It returns the pointer to the current xmlChar.
2665: */
2666:
2667: #define CUR (*ctxt->cur)
2668: #define SKIP(val) ctxt->cur += (val)
2669: #define NXT(val) ctxt->cur[(val)]
2670: #define CUR_PTR ctxt->cur
2671: #define CUR_CHAR(l) xmlXPathCurrentChar(ctxt, &l)
2672:
2673: #define COPY_BUF(l,b,i,v) \
2674: if (l == 1) b[i++] = (xmlChar) v; \
2675: else i += xmlCopyChar(l,&b[i],v)
2676:
2677: #define NEXTL(l) ctxt->cur += l
2678:
2679: #define SKIP_BLANKS \
2680: while (IS_BLANK_CH(*(ctxt->cur))) NEXT
2681:
2682: #define CURRENT (*ctxt->cur)
2683: #define NEXT ((*ctxt->cur) ? ctxt->cur++: ctxt->cur)
2684:
2685:
2686: #ifndef DBL_DIG
2687: #define DBL_DIG 16
2688: #endif
2689: #ifndef DBL_EPSILON
2690: #define DBL_EPSILON 1E-9
2691: #endif
2692:
2693: #define UPPER_DOUBLE 1E9
2694: #define LOWER_DOUBLE 1E-5
2695: #define LOWER_DOUBLE_EXP 5
2696:
2697: #define INTEGER_DIGITS DBL_DIG
2698: #define FRACTION_DIGITS (DBL_DIG + 1 + (LOWER_DOUBLE_EXP))
2699: #define EXPONENT_DIGITS (3 + 2)
2700:
2701: /**
2702: * xmlXPathFormatNumber:
2703: * @number: number to format
2704: * @buffer: output buffer
2705: * @buffersize: size of output buffer
2706: *
2707: * Convert the number into a string representation.
2708: */
2709: static void
2710: xmlXPathFormatNumber(double number, char buffer[], int buffersize)
2711: {
2712: switch (xmlXPathIsInf(number)) {
2713: case 1:
2714: if (buffersize > (int)sizeof("Infinity"))
2715: snprintf(buffer, buffersize, "Infinity");
2716: break;
2717: case -1:
2718: if (buffersize > (int)sizeof("-Infinity"))
2719: snprintf(buffer, buffersize, "-Infinity");
2720: break;
2721: default:
2722: if (xmlXPathIsNaN(number)) {
2723: if (buffersize > (int)sizeof("NaN"))
2724: snprintf(buffer, buffersize, "NaN");
2725: } else if (number == 0 && xmlXPathGetSign(number) != 0) {
2726: snprintf(buffer, buffersize, "0");
2727: } else if (number == ((int) number)) {
2728: char work[30];
2729: char *ptr, *cur;
2730: int value = (int) number;
2731:
2732: ptr = &buffer[0];
2733: if (value == 0) {
2734: *ptr++ = '0';
2735: } else {
2736: snprintf(work, 29, "%d", value);
2737: cur = &work[0];
2738: while ((*cur) && (ptr - buffer < buffersize)) {
2739: *ptr++ = *cur++;
2740: }
2741: }
2742: if (ptr - buffer < buffersize) {
2743: *ptr = 0;
2744: } else if (buffersize > 0) {
2745: ptr--;
2746: *ptr = 0;
2747: }
2748: } else {
2749: /*
2750: For the dimension of work,
2751: DBL_DIG is number of significant digits
2752: EXPONENT is only needed for "scientific notation"
2753: 3 is sign, decimal point, and terminating zero
2754: LOWER_DOUBLE_EXP is max number of leading zeroes in fraction
2755: Note that this dimension is slightly (a few characters)
2756: larger than actually necessary.
2757: */
2758: char work[DBL_DIG + EXPONENT_DIGITS + 3 + LOWER_DOUBLE_EXP];
2759: int integer_place, fraction_place;
2760: char *ptr;
2761: char *after_fraction;
2762: double absolute_value;
2763: int size;
2764:
2765: absolute_value = fabs(number);
2766:
2767: /*
2768: * First choose format - scientific or regular floating point.
2769: * In either case, result is in work, and after_fraction points
2770: * just past the fractional part.
2771: */
2772: if ( ((absolute_value > UPPER_DOUBLE) ||
2773: (absolute_value < LOWER_DOUBLE)) &&
2774: (absolute_value != 0.0) ) {
2775: /* Use scientific notation */
2776: integer_place = DBL_DIG + EXPONENT_DIGITS + 1;
2777: fraction_place = DBL_DIG - 1;
2778: size = snprintf(work, sizeof(work),"%*.*e",
2779: integer_place, fraction_place, number);
2780: while ((size > 0) && (work[size] != 'e')) size--;
2781:
2782: }
2783: else {
2784: /* Use regular notation */
2785: if (absolute_value > 0.0) {
2786: integer_place = (int)log10(absolute_value);
2787: if (integer_place > 0)
2788: fraction_place = DBL_DIG - integer_place - 1;
2789: else
2790: fraction_place = DBL_DIG - integer_place;
2791: } else {
2792: fraction_place = 1;
2793: }
2794: size = snprintf(work, sizeof(work), "%0.*f",
2795: fraction_place, number);
2796: }
2797:
2798: /* Remove fractional trailing zeroes */
2799: after_fraction = work + size;
2800: ptr = after_fraction;
2801: while (*(--ptr) == '0')
2802: ;
2803: if (*ptr != '.')
2804: ptr++;
2805: while ((*ptr++ = *after_fraction++) != 0);
2806:
2807: /* Finally copy result back to caller */
2808: size = strlen(work) + 1;
2809: if (size > buffersize) {
2810: work[buffersize - 1] = 0;
2811: size = buffersize;
2812: }
2813: memmove(buffer, work, size);
2814: }
2815: break;
2816: }
2817: }
2818:
2819:
2820: /************************************************************************
2821: * *
2822: * Routines to handle NodeSets *
2823: * *
2824: ************************************************************************/
2825:
2826: /**
2827: * xmlXPathOrderDocElems:
2828: * @doc: an input document
2829: *
2830: * Call this routine to speed up XPath computation on static documents.
2831: * This stamps all the element nodes with the document order
2832: * Like for line information, the order is kept in the element->content
2833: * field, the value stored is actually - the node number (starting at -1)
2834: * to be able to differentiate from line numbers.
2835: *
2836: * Returns the number of elements found in the document or -1 in case
2837: * of error.
2838: */
2839: long
2840: xmlXPathOrderDocElems(xmlDocPtr doc) {
2841: long count = 0;
2842: xmlNodePtr cur;
2843:
2844: if (doc == NULL)
2845: return(-1);
2846: cur = doc->children;
2847: while (cur != NULL) {
2848: if (cur->type == XML_ELEMENT_NODE) {
2849: cur->content = (void *) (-(++count));
2850: if (cur->children != NULL) {
2851: cur = cur->children;
2852: continue;
2853: }
2854: }
2855: if (cur->next != NULL) {
2856: cur = cur->next;
2857: continue;
2858: }
2859: do {
2860: cur = cur->parent;
2861: if (cur == NULL)
2862: break;
2863: if (cur == (xmlNodePtr) doc) {
2864: cur = NULL;
2865: break;
2866: }
2867: if (cur->next != NULL) {
2868: cur = cur->next;
2869: break;
2870: }
2871: } while (cur != NULL);
2872: }
2873: return(count);
2874: }
2875:
2876: /**
2877: * xmlXPathCmpNodes:
2878: * @node1: the first node
2879: * @node2: the second node
2880: *
2881: * Compare two nodes w.r.t document order
2882: *
2883: * Returns -2 in case of error 1 if first point < second point, 0 if
2884: * it's the same node, -1 otherwise
2885: */
2886: int
2887: xmlXPathCmpNodes(xmlNodePtr node1, xmlNodePtr node2) {
2888: int depth1, depth2;
2889: int attr1 = 0, attr2 = 0;
2890: xmlNodePtr attrNode1 = NULL, attrNode2 = NULL;
2891: xmlNodePtr cur, root;
2892:
2893: if ((node1 == NULL) || (node2 == NULL))
2894: return(-2);
2895: /*
2896: * a couple of optimizations which will avoid computations in most cases
2897: */
2898: if (node1 == node2) /* trivial case */
2899: return(0);
2900: if (node1->type == XML_ATTRIBUTE_NODE) {
2901: attr1 = 1;
2902: attrNode1 = node1;
2903: node1 = node1->parent;
2904: }
2905: if (node2->type == XML_ATTRIBUTE_NODE) {
2906: attr2 = 1;
2907: attrNode2 = node2;
2908: node2 = node2->parent;
2909: }
2910: if (node1 == node2) {
2911: if (attr1 == attr2) {
2912: /* not required, but we keep attributes in order */
2913: if (attr1 != 0) {
2914: cur = attrNode2->prev;
2915: while (cur != NULL) {
2916: if (cur == attrNode1)
2917: return (1);
2918: cur = cur->prev;
2919: }
2920: return (-1);
2921: }
2922: return(0);
2923: }
2924: if (attr2 == 1)
2925: return(1);
2926: return(-1);
2927: }
2928: if ((node1->type == XML_NAMESPACE_DECL) ||
2929: (node2->type == XML_NAMESPACE_DECL))
2930: return(1);
2931: if (node1 == node2->prev)
2932: return(1);
2933: if (node1 == node2->next)
2934: return(-1);
2935:
2936: /*
2937: * Speedup using document order if availble.
2938: */
2939: if ((node1->type == XML_ELEMENT_NODE) &&
2940: (node2->type == XML_ELEMENT_NODE) &&
2941: (0 > (long) node1->content) &&
2942: (0 > (long) node2->content) &&
2943: (node1->doc == node2->doc)) {
2944: long l1, l2;
2945:
2946: l1 = -((long) node1->content);
2947: l2 = -((long) node2->content);
2948: if (l1 < l2)
2949: return(1);
2950: if (l1 > l2)
2951: return(-1);
2952: }
2953:
2954: /*
2955: * compute depth to root
2956: */
2957: for (depth2 = 0, cur = node2;cur->parent != NULL;cur = cur->parent) {
2958: if (cur == node1)
2959: return(1);
2960: depth2++;
2961: }
2962: root = cur;
2963: for (depth1 = 0, cur = node1;cur->parent != NULL;cur = cur->parent) {
2964: if (cur == node2)
2965: return(-1);
2966: depth1++;
2967: }
2968: /*
2969: * Distinct document (or distinct entities :-( ) case.
2970: */
2971: if (root != cur) {
2972: return(-2);
2973: }
2974: /*
2975: * get the nearest common ancestor.
2976: */
2977: while (depth1 > depth2) {
2978: depth1--;
2979: node1 = node1->parent;
2980: }
2981: while (depth2 > depth1) {
2982: depth2--;
2983: node2 = node2->parent;
2984: }
2985: while (node1->parent != node2->parent) {
2986: node1 = node1->parent;
2987: node2 = node2->parent;
2988: /* should not happen but just in case ... */
2989: if ((node1 == NULL) || (node2 == NULL))
2990: return(-2);
2991: }
2992: /*
2993: * Find who's first.
2994: */
2995: if (node1 == node2->prev)
2996: return(1);
2997: if (node1 == node2->next)
2998: return(-1);
2999: /*
3000: * Speedup using document order if availble.
3001: */
3002: if ((node1->type == XML_ELEMENT_NODE) &&
3003: (node2->type == XML_ELEMENT_NODE) &&
3004: (0 > (long) node1->content) &&
3005: (0 > (long) node2->content) &&
3006: (node1->doc == node2->doc)) {
3007: long l1, l2;
3008:
3009: l1 = -((long) node1->content);
3010: l2 = -((long) node2->content);
3011: if (l1 < l2)
3012: return(1);
3013: if (l1 > l2)
3014: return(-1);
3015: }
3016:
3017: for (cur = node1->next;cur != NULL;cur = cur->next)
3018: if (cur == node2)
3019: return(1);
3020: return(-1); /* assume there is no sibling list corruption */
3021: }
3022:
3023: #ifdef XP_OPTIMIZED_NON_ELEM_COMPARISON
3024: /**
3025: * xmlXPathCmpNodesExt:
3026: * @node1: the first node
3027: * @node2: the second node
3028: *
3029: * Compare two nodes w.r.t document order.
3030: * This one is optimized for handling of non-element nodes.
3031: *
3032: * Returns -2 in case of error 1 if first point < second point, 0 if
3033: * it's the same node, -1 otherwise
3034: */
3035: static int
3036: xmlXPathCmpNodesExt(xmlNodePtr node1, xmlNodePtr node2) {
3037: int depth1, depth2;
3038: int misc = 0, precedence1 = 0, precedence2 = 0;
3039: xmlNodePtr miscNode1 = NULL, miscNode2 = NULL;
3040: xmlNodePtr cur, root;
3041: long l1, l2;
3042:
3043: if ((node1 == NULL) || (node2 == NULL))
3044: return(-2);
3045:
3046: if (node1 == node2)
3047: return(0);
3048:
3049: /*
3050: * a couple of optimizations which will avoid computations in most cases
3051: */
3052: switch (node1->type) {
3053: case XML_ELEMENT_NODE:
3054: if (node2->type == XML_ELEMENT_NODE) {
3055: if ((0 > (long) node1->content) && /* TODO: Would a != 0 suffice here? */
3056: (0 > (long) node2->content) &&
3057: (node1->doc == node2->doc))
3058: {
3059: l1 = -((long) node1->content);
3060: l2 = -((long) node2->content);
3061: if (l1 < l2)
3062: return(1);
3063: if (l1 > l2)
3064: return(-1);
3065: } else
3066: goto turtle_comparison;
3067: }
3068: break;
3069: case XML_ATTRIBUTE_NODE:
3070: precedence1 = 1; /* element is owner */
3071: miscNode1 = node1;
3072: node1 = node1->parent;
3073: misc = 1;
3074: break;
3075: case XML_TEXT_NODE:
3076: case XML_CDATA_SECTION_NODE:
3077: case XML_COMMENT_NODE:
3078: case XML_PI_NODE: {
3079: miscNode1 = node1;
3080: /*
3081: * Find nearest element node.
3082: */
3083: if (node1->prev != NULL) {
3084: do {
3085: node1 = node1->prev;
3086: if (node1->type == XML_ELEMENT_NODE) {
3087: precedence1 = 3; /* element in prev-sibl axis */
3088: break;
3089: }
3090: if (node1->prev == NULL) {
3091: precedence1 = 2; /* element is parent */
3092: /*
3093: * URGENT TODO: Are there any cases, where the
3094: * parent of such a node is not an element node?
3095: */
3096: node1 = node1->parent;
3097: break;
3098: }
3099: } while (1);
3100: } else {
3101: precedence1 = 2; /* element is parent */
3102: node1 = node1->parent;
3103: }
3104: if ((node1 == NULL) || (node1->type != XML_ELEMENT_NODE) ||
3105: (0 <= (long) node1->content)) {
3106: /*
3107: * Fallback for whatever case.
3108: */
3109: node1 = miscNode1;
3110: precedence1 = 0;
3111: } else
3112: misc = 1;
3113: }
3114: break;
3115: case XML_NAMESPACE_DECL:
3116: /*
3117: * TODO: why do we return 1 for namespace nodes?
3118: */
3119: return(1);
3120: default:
3121: break;
3122: }
3123: switch (node2->type) {
3124: case XML_ELEMENT_NODE:
3125: break;
3126: case XML_ATTRIBUTE_NODE:
3127: precedence2 = 1; /* element is owner */
3128: miscNode2 = node2;
3129: node2 = node2->parent;
3130: misc = 1;
3131: break;
3132: case XML_TEXT_NODE:
3133: case XML_CDATA_SECTION_NODE:
3134: case XML_COMMENT_NODE:
3135: case XML_PI_NODE: {
3136: miscNode2 = node2;
3137: if (node2->prev != NULL) {
3138: do {
3139: node2 = node2->prev;
3140: if (node2->type == XML_ELEMENT_NODE) {
3141: precedence2 = 3; /* element in prev-sibl axis */
3142: break;
3143: }
3144: if (node2->prev == NULL) {
3145: precedence2 = 2; /* element is parent */
3146: node2 = node2->parent;
3147: break;
3148: }
3149: } while (1);
3150: } else {
3151: precedence2 = 2; /* element is parent */
3152: node2 = node2->parent;
3153: }
3154: if ((node2 == NULL) || (node2->type != XML_ELEMENT_NODE) ||
3155: (0 <= (long) node1->content))
3156: {
3157: node2 = miscNode2;
3158: precedence2 = 0;
3159: } else
3160: misc = 1;
3161: }
3162: break;
3163: case XML_NAMESPACE_DECL:
3164: return(1);
3165: default:
3166: break;
3167: }
3168: if (misc) {
3169: if (node1 == node2) {
3170: if (precedence1 == precedence2) {
3171: /*
3172: * The ugly case; but normally there aren't many
3173: * adjacent non-element nodes around.
3174: */
3175: cur = miscNode2->prev;
3176: while (cur != NULL) {
3177: if (cur == miscNode1)
3178: return(1);
3179: if (cur->type == XML_ELEMENT_NODE)
3180: return(-1);
3181: cur = cur->prev;
3182: }
3183: return (-1);
3184: } else {
3185: /*
3186: * Evaluate based on higher precedence wrt to the element.
3187: * TODO: This assumes attributes are sorted before content.
3188: * Is this 100% correct?
3189: */
3190: if (precedence1 < precedence2)
3191: return(1);
3192: else
3193: return(-1);
3194: }
3195: }
3196: /*
3197: * Special case: One of the helper-elements is contained by the other.
3198: * <foo>
3199: * <node2>
3200: * <node1>Text-1(precedence1 == 2)</node1>
3201: * </node2>
3202: * Text-6(precedence2 == 3)
3203: * </foo>
3204: */
3205: if ((precedence2 == 3) && (precedence1 > 1)) {
3206: cur = node1->parent;
3207: while (cur) {
3208: if (cur == node2)
3209: return(1);
3210: cur = cur->parent;
3211: }
3212: }
3213: if ((precedence1 == 3) && (precedence2 > 1)) {
3214: cur = node2->parent;
3215: while (cur) {
3216: if (cur == node1)
3217: return(-1);
3218: cur = cur->parent;
3219: }
3220: }
3221: }
3222:
3223: /*
3224: * Speedup using document order if availble.
3225: */
3226: if ((node1->type == XML_ELEMENT_NODE) &&
3227: (node2->type == XML_ELEMENT_NODE) &&
3228: (0 > (long) node1->content) &&
3229: (0 > (long) node2->content) &&
3230: (node1->doc == node2->doc)) {
3231:
3232: l1 = -((long) node1->content);
3233: l2 = -((long) node2->content);
3234: if (l1 < l2)
3235: return(1);
3236: if (l1 > l2)
3237: return(-1);
3238: }
3239:
3240: turtle_comparison:
3241:
3242: if (node1 == node2->prev)
3243: return(1);
3244: if (node1 == node2->next)
3245: return(-1);
3246: /*
3247: * compute depth to root
3248: */
3249: for (depth2 = 0, cur = node2;cur->parent != NULL;cur = cur->parent) {
3250: if (cur == node1)
3251: return(1);
3252: depth2++;
3253: }
3254: root = cur;
3255: for (depth1 = 0, cur = node1;cur->parent != NULL;cur = cur->parent) {
3256: if (cur == node2)
3257: return(-1);
3258: depth1++;
3259: }
3260: /*
3261: * Distinct document (or distinct entities :-( ) case.
3262: */
3263: if (root != cur) {
3264: return(-2);
3265: }
3266: /*
3267: * get the nearest common ancestor.
3268: */
3269: while (depth1 > depth2) {
3270: depth1--;
3271: node1 = node1->parent;
3272: }
3273: while (depth2 > depth1) {
3274: depth2--;
3275: node2 = node2->parent;
3276: }
3277: while (node1->parent != node2->parent) {
3278: node1 = node1->parent;
3279: node2 = node2->parent;
3280: /* should not happen but just in case ... */
3281: if ((node1 == NULL) || (node2 == NULL))
3282: return(-2);
3283: }
3284: /*
3285: * Find who's first.
3286: */
3287: if (node1 == node2->prev)
3288: return(1);
3289: if (node1 == node2->next)
3290: return(-1);
3291: /*
3292: * Speedup using document order if availble.
3293: */
3294: if ((node1->type == XML_ELEMENT_NODE) &&
3295: (node2->type == XML_ELEMENT_NODE) &&
3296: (0 > (long) node1->content) &&
3297: (0 > (long) node2->content) &&
3298: (node1->doc == node2->doc)) {
3299:
3300: l1 = -((long) node1->content);
3301: l2 = -((long) node2->content);
3302: if (l1 < l2)
3303: return(1);
3304: if (l1 > l2)
3305: return(-1);
3306: }
3307:
3308: for (cur = node1->next;cur != NULL;cur = cur->next)
3309: if (cur == node2)
3310: return(1);
3311: return(-1); /* assume there is no sibling list corruption */
3312: }
3313: #endif /* XP_OPTIMIZED_NON_ELEM_COMPARISON */
3314:
3315: /**
3316: * xmlXPathNodeSetSort:
3317: * @set: the node set
3318: *
3319: * Sort the node set in document order
3320: */
3321: void
3322: xmlXPathNodeSetSort(xmlNodeSetPtr set) {
3323: int i, j, incr, len;
3324: xmlNodePtr tmp;
3325:
3326: if (set == NULL)
3327: return;
3328:
3329: /* Use Shell's sort to sort the node-set */
3330: len = set->nodeNr;
3331: for (incr = len / 2; incr > 0; incr /= 2) {
3332: for (i = incr; i < len; i++) {
3333: j = i - incr;
3334: while (j >= 0) {
3335: #ifdef XP_OPTIMIZED_NON_ELEM_COMPARISON
3336: if (xmlXPathCmpNodesExt(set->nodeTab[j],
3337: set->nodeTab[j + incr]) == -1)
3338: #else
3339: if (xmlXPathCmpNodes(set->nodeTab[j],
3340: set->nodeTab[j + incr]) == -1)
3341: #endif
3342: {
3343: tmp = set->nodeTab[j];
3344: set->nodeTab[j] = set->nodeTab[j + incr];
3345: set->nodeTab[j + incr] = tmp;
3346: j -= incr;
3347: } else
3348: break;
3349: }
3350: }
3351: }
3352: }
3353:
3354: #define XML_NODESET_DEFAULT 10
3355: /**
3356: * xmlXPathNodeSetDupNs:
3357: * @node: the parent node of the namespace XPath node
3358: * @ns: the libxml namespace declaration node.
3359: *
3360: * Namespace node in libxml don't match the XPath semantic. In a node set
3361: * the namespace nodes are duplicated and the next pointer is set to the
3362: * parent node in the XPath semantic.
3363: *
3364: * Returns the newly created object.
3365: */
3366: static xmlNodePtr
3367: xmlXPathNodeSetDupNs(xmlNodePtr node, xmlNsPtr ns) {
3368: xmlNsPtr cur;
3369:
3370: if ((ns == NULL) || (ns->type != XML_NAMESPACE_DECL))
3371: return(NULL);
3372: if ((node == NULL) || (node->type == XML_NAMESPACE_DECL))
3373: return((xmlNodePtr) ns);
3374:
3375: /*
3376: * Allocate a new Namespace and fill the fields.
3377: */
3378: cur = (xmlNsPtr) xmlMalloc(sizeof(xmlNs));
3379: if (cur == NULL) {
3380: xmlXPathErrMemory(NULL, "duplicating namespace\n");
3381: return(NULL);
3382: }
3383: memset(cur, 0, sizeof(xmlNs));
3384: cur->type = XML_NAMESPACE_DECL;
3385: if (ns->href != NULL)
3386: cur->href = xmlStrdup(ns->href);
3387: if (ns->prefix != NULL)
3388: cur->prefix = xmlStrdup(ns->prefix);
3389: cur->next = (xmlNsPtr) node;
3390: return((xmlNodePtr) cur);
3391: }
3392:
3393: /**
3394: * xmlXPathNodeSetFreeNs:
3395: * @ns: the XPath namespace node found in a nodeset.
3396: *
3397: * Namespace nodes in libxml don't match the XPath semantic. In a node set
3398: * the namespace nodes are duplicated and the next pointer is set to the
3399: * parent node in the XPath semantic. Check if such a node needs to be freed
3400: */
3401: void
3402: xmlXPathNodeSetFreeNs(xmlNsPtr ns) {
3403: if ((ns == NULL) || (ns->type != XML_NAMESPACE_DECL))
3404: return;
3405:
3406: if ((ns->next != NULL) && (ns->next->type != XML_NAMESPACE_DECL)) {
3407: if (ns->href != NULL)
3408: xmlFree((xmlChar *)ns->href);
3409: if (ns->prefix != NULL)
3410: xmlFree((xmlChar *)ns->prefix);
3411: xmlFree(ns);
3412: }
3413: }
3414:
3415: /**
3416: * xmlXPathNodeSetCreate:
3417: * @val: an initial xmlNodePtr, or NULL
3418: *
3419: * Create a new xmlNodeSetPtr of type double and of value @val
3420: *
3421: * Returns the newly created object.
3422: */
3423: xmlNodeSetPtr
3424: xmlXPathNodeSetCreate(xmlNodePtr val) {
3425: xmlNodeSetPtr ret;
3426:
3427: ret = (xmlNodeSetPtr) xmlMalloc(sizeof(xmlNodeSet));
3428: if (ret == NULL) {
3429: xmlXPathErrMemory(NULL, "creating nodeset\n");
3430: return(NULL);
3431: }
3432: memset(ret, 0 , (size_t) sizeof(xmlNodeSet));
3433: if (val != NULL) {
3434: ret->nodeTab = (xmlNodePtr *) xmlMalloc(XML_NODESET_DEFAULT *
3435: sizeof(xmlNodePtr));
3436: if (ret->nodeTab == NULL) {
3437: xmlXPathErrMemory(NULL, "creating nodeset\n");
3438: xmlFree(ret);
3439: return(NULL);
3440: }
3441: memset(ret->nodeTab, 0 ,
3442: XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
3443: ret->nodeMax = XML_NODESET_DEFAULT;
3444: if (val->type == XML_NAMESPACE_DECL) {
3445: xmlNsPtr ns = (xmlNsPtr) val;
3446:
3447: ret->nodeTab[ret->nodeNr++] =
3448: xmlXPathNodeSetDupNs((xmlNodePtr) ns->next, ns);
3449: } else
3450: ret->nodeTab[ret->nodeNr++] = val;
3451: }
3452: return(ret);
3453: }
3454:
3455: /**
3456: * xmlXPathNodeSetCreateSize:
3457: * @size: the initial size of the set
3458: *
3459: * Create a new xmlNodeSetPtr of type double and of value @val
3460: *
3461: * Returns the newly created object.
3462: */
3463: static xmlNodeSetPtr
3464: xmlXPathNodeSetCreateSize(int size) {
3465: xmlNodeSetPtr ret;
3466:
3467: ret = (xmlNodeSetPtr) xmlMalloc(sizeof(xmlNodeSet));
3468: if (ret == NULL) {
3469: xmlXPathErrMemory(NULL, "creating nodeset\n");
3470: return(NULL);
3471: }
3472: memset(ret, 0 , (size_t) sizeof(xmlNodeSet));
3473: if (size < XML_NODESET_DEFAULT)
3474: size = XML_NODESET_DEFAULT;
3475: ret->nodeTab = (xmlNodePtr *) xmlMalloc(size * sizeof(xmlNodePtr));
3476: if (ret->nodeTab == NULL) {
3477: xmlXPathErrMemory(NULL, "creating nodeset\n");
3478: xmlFree(ret);
3479: return(NULL);
3480: }
3481: memset(ret->nodeTab, 0 , size * (size_t) sizeof(xmlNodePtr));
3482: ret->nodeMax = size;
3483: return(ret);
3484: }
3485:
3486: /**
3487: * xmlXPathNodeSetContains:
3488: * @cur: the node-set
3489: * @val: the node
3490: *
3491: * checks whether @cur contains @val
3492: *
3493: * Returns true (1) if @cur contains @val, false (0) otherwise
3494: */
3495: int
3496: xmlXPathNodeSetContains (xmlNodeSetPtr cur, xmlNodePtr val) {
3497: int i;
3498:
3499: if ((cur == NULL) || (val == NULL)) return(0);
3500: if (val->type == XML_NAMESPACE_DECL) {
3501: for (i = 0; i < cur->nodeNr; i++) {
3502: if (cur->nodeTab[i]->type == XML_NAMESPACE_DECL) {
3503: xmlNsPtr ns1, ns2;
3504:
3505: ns1 = (xmlNsPtr) val;
3506: ns2 = (xmlNsPtr) cur->nodeTab[i];
3507: if (ns1 == ns2)
3508: return(1);
3509: if ((ns1->next != NULL) && (ns2->next == ns1->next) &&
3510: (xmlStrEqual(ns1->prefix, ns2->prefix)))
3511: return(1);
3512: }
3513: }
3514: } else {
3515: for (i = 0; i < cur->nodeNr; i++) {
3516: if (cur->nodeTab[i] == val)
3517: return(1);
3518: }
3519: }
3520: return(0);
3521: }
3522:
3523: /**
3524: * xmlXPathNodeSetAddNs:
3525: * @cur: the initial node set
3526: * @node: the hosting node
3527: * @ns: a the namespace node
3528: *
3529: * add a new namespace node to an existing NodeSet
3530: */
3531: void
3532: xmlXPathNodeSetAddNs(xmlNodeSetPtr cur, xmlNodePtr node, xmlNsPtr ns) {
3533: int i;
3534:
3535:
3536: if ((cur == NULL) || (ns == NULL) || (node == NULL) ||
3537: (ns->type != XML_NAMESPACE_DECL) ||
3538: (node->type != XML_ELEMENT_NODE))
3539: return;
3540:
3541: /* @@ with_ns to check whether namespace nodes should be looked at @@ */
3542: /*
3543: * prevent duplicates
3544: */
3545: for (i = 0;i < cur->nodeNr;i++) {
3546: if ((cur->nodeTab[i] != NULL) &&
3547: (cur->nodeTab[i]->type == XML_NAMESPACE_DECL) &&
3548: (((xmlNsPtr)cur->nodeTab[i])->next == (xmlNsPtr) node) &&
3549: (xmlStrEqual(ns->prefix, ((xmlNsPtr)cur->nodeTab[i])->prefix)))
3550: return;
3551: }
3552:
3553: /*
3554: * grow the nodeTab if needed
3555: */
3556: if (cur->nodeMax == 0) {
3557: cur->nodeTab = (xmlNodePtr *) xmlMalloc(XML_NODESET_DEFAULT *
3558: sizeof(xmlNodePtr));
3559: if (cur->nodeTab == NULL) {
3560: xmlXPathErrMemory(NULL, "growing nodeset\n");
3561: return;
3562: }
3563: memset(cur->nodeTab, 0 ,
3564: XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
3565: cur->nodeMax = XML_NODESET_DEFAULT;
3566: } else if (cur->nodeNr == cur->nodeMax) {
3567: xmlNodePtr *temp;
3568:
3569: temp = (xmlNodePtr *) xmlRealloc(cur->nodeTab, cur->nodeMax * 2 *
3570: sizeof(xmlNodePtr));
3571: if (temp == NULL) {
3572: xmlXPathErrMemory(NULL, "growing nodeset\n");
3573: return;
3574: }
3575: cur->nodeMax *= 2;
3576: cur->nodeTab = temp;
3577: }
3578: cur->nodeTab[cur->nodeNr++] = xmlXPathNodeSetDupNs(node, ns);
3579: }
3580:
3581: /**
3582: * xmlXPathNodeSetAdd:
3583: * @cur: the initial node set
3584: * @val: a new xmlNodePtr
3585: *
3586: * add a new xmlNodePtr to an existing NodeSet
3587: */
3588: void
3589: xmlXPathNodeSetAdd(xmlNodeSetPtr cur, xmlNodePtr val) {
3590: int i;
3591:
3592: if ((cur == NULL) || (val == NULL)) return;
3593:
3594: #if 0
3595: if ((val->type == XML_ELEMENT_NODE) && (val->name[0] == ' '))
3596: return; /* an XSLT fake node */
3597: #endif
3598:
3599: /* @@ with_ns to check whether namespace nodes should be looked at @@ */
3600: /*
3601: * prevent duplcates
3602: */
3603: for (i = 0;i < cur->nodeNr;i++)
3604: if (cur->nodeTab[i] == val) return;
3605:
3606: /*
3607: * grow the nodeTab if needed
3608: */
3609: if (cur->nodeMax == 0) {
3610: cur->nodeTab = (xmlNodePtr *) xmlMalloc(XML_NODESET_DEFAULT *
3611: sizeof(xmlNodePtr));
3612: if (cur->nodeTab == NULL) {
3613: xmlXPathErrMemory(NULL, "growing nodeset\n");
3614: return;
3615: }
3616: memset(cur->nodeTab, 0 ,
3617: XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
3618: cur->nodeMax = XML_NODESET_DEFAULT;
3619: } else if (cur->nodeNr == cur->nodeMax) {
3620: xmlNodePtr *temp;
3621:
3622: temp = (xmlNodePtr *) xmlRealloc(cur->nodeTab, cur->nodeMax * 2 *
3623: sizeof(xmlNodePtr));
3624: if (temp == NULL) {
3625: xmlXPathErrMemory(NULL, "growing nodeset\n");
3626: return;
3627: }
3628: cur->nodeMax *= 2;
3629: cur->nodeTab = temp;
3630: }
3631: if (val->type == XML_NAMESPACE_DECL) {
3632: xmlNsPtr ns = (xmlNsPtr) val;
3633:
3634: cur->nodeTab[cur->nodeNr++] =
3635: xmlXPathNodeSetDupNs((xmlNodePtr) ns->next, ns);
3636: } else
3637: cur->nodeTab[cur->nodeNr++] = val;
3638: }
3639:
3640: /**
3641: * xmlXPathNodeSetAddUnique:
3642: * @cur: the initial node set
3643: * @val: a new xmlNodePtr
3644: *
3645: * add a new xmlNodePtr to an existing NodeSet, optimized version
3646: * when we are sure the node is not already in the set.
3647: */
3648: void
3649: xmlXPathNodeSetAddUnique(xmlNodeSetPtr cur, xmlNodePtr val) {
3650: if ((cur == NULL) || (val == NULL)) return;
3651:
3652: #if 0
3653: if ((val->type == XML_ELEMENT_NODE) && (val->name[0] == ' '))
3654: return; /* an XSLT fake node */
3655: #endif
3656:
3657: /* @@ with_ns to check whether namespace nodes should be looked at @@ */
3658: /*
3659: * grow the nodeTab if needed
3660: */
3661: if (cur->nodeMax == 0) {
3662: cur->nodeTab = (xmlNodePtr *) xmlMalloc(XML_NODESET_DEFAULT *
3663: sizeof(xmlNodePtr));
3664: if (cur->nodeTab == NULL) {
3665: xmlXPathErrMemory(NULL, "growing nodeset\n");
3666: return;
3667: }
3668: memset(cur->nodeTab, 0 ,
3669: XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
3670: cur->nodeMax = XML_NODESET_DEFAULT;
3671: } else if (cur->nodeNr == cur->nodeMax) {
3672: xmlNodePtr *temp;
3673:
3674: temp = (xmlNodePtr *) xmlRealloc(cur->nodeTab, cur->nodeMax * 2 *
3675: sizeof(xmlNodePtr));
3676: if (temp == NULL) {
3677: xmlXPathErrMemory(NULL, "growing nodeset\n");
3678: return;
3679: }
3680: cur->nodeTab = temp;
3681: cur->nodeMax *= 2;
3682: }
3683: if (val->type == XML_NAMESPACE_DECL) {
3684: xmlNsPtr ns = (xmlNsPtr) val;
3685:
3686: cur->nodeTab[cur->nodeNr++] =
3687: xmlXPathNodeSetDupNs((xmlNodePtr) ns->next, ns);
3688: } else
3689: cur->nodeTab[cur->nodeNr++] = val;
3690: }
3691:
3692: /**
3693: * xmlXPathNodeSetMerge:
3694: * @val1: the first NodeSet or NULL
3695: * @val2: the second NodeSet
3696: *
3697: * Merges two nodesets, all nodes from @val2 are added to @val1
3698: * if @val1 is NULL, a new set is created and copied from @val2
3699: *
3700: * Returns @val1 once extended or NULL in case of error.
3701: */
3702: xmlNodeSetPtr
3703: xmlXPathNodeSetMerge(xmlNodeSetPtr val1, xmlNodeSetPtr val2) {
3704: int i, j, initNr, skip;
3705: xmlNodePtr n1, n2;
3706:
3707: if (val2 == NULL) return(val1);
3708: if (val1 == NULL) {
3709: val1 = xmlXPathNodeSetCreate(NULL);
3710: if (val1 == NULL)
3711: return (NULL);
3712: #if 0
3713: /*
3714: * TODO: The optimization won't work in every case, since
3715: * those nasty namespace nodes need to be added with
3716: * xmlXPathNodeSetDupNs() to the set; thus a pure
3717: * memcpy is not possible.
3718: * If there was a flag on the nodesetval, indicating that
3719: * some temporary nodes are in, that would be helpfull.
3720: */
3721: /*
3722: * Optimization: Create an equally sized node-set
3723: * and memcpy the content.
3724: */
3725: val1 = xmlXPathNodeSetCreateSize(val2->nodeNr);
3726: if (val1 == NULL)
3727: return(NULL);
3728: if (val2->nodeNr != 0) {
3729: if (val2->nodeNr == 1)
3730: *(val1->nodeTab) = *(val2->nodeTab);
3731: else {
3732: memcpy(val1->nodeTab, val2->nodeTab,
3733: val2->nodeNr * sizeof(xmlNodePtr));
3734: }
3735: val1->nodeNr = val2->nodeNr;
3736: }
3737: return(val1);
3738: #endif
3739: }
3740:
3741: /* @@ with_ns to check whether namespace nodes should be looked at @@ */
3742: initNr = val1->nodeNr;
3743:
3744: for (i = 0;i < val2->nodeNr;i++) {
3745: n2 = val2->nodeTab[i];
3746: /*
3747: * check against duplicates
3748: */
3749: skip = 0;
3750: for (j = 0; j < initNr; j++) {
3751: n1 = val1->nodeTab[j];
3752: if (n1 == n2) {
3753: skip = 1;
3754: break;
3755: } else if ((n1->type == XML_NAMESPACE_DECL) &&
3756: (n2->type == XML_NAMESPACE_DECL)) {
3757: if ((((xmlNsPtr) n1)->next == ((xmlNsPtr) n2)->next) &&
3758: (xmlStrEqual(((xmlNsPtr) n1)->prefix,
3759: ((xmlNsPtr) n2)->prefix)))
3760: {
3761: skip = 1;
3762: break;
3763: }
3764: }
3765: }
3766: if (skip)
3767: continue;
3768:
3769: /*
3770: * grow the nodeTab if needed
3771: */
3772: if (val1->nodeMax == 0) {
3773: val1->nodeTab = (xmlNodePtr *) xmlMalloc(XML_NODESET_DEFAULT *
3774: sizeof(xmlNodePtr));
3775: if (val1->nodeTab == NULL) {
3776: xmlXPathErrMemory(NULL, "merging nodeset\n");
3777: return(NULL);
3778: }
3779: memset(val1->nodeTab, 0 ,
3780: XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
3781: val1->nodeMax = XML_NODESET_DEFAULT;
3782: } else if (val1->nodeNr == val1->nodeMax) {
3783: xmlNodePtr *temp;
3784:
3785: temp = (xmlNodePtr *) xmlRealloc(val1->nodeTab, val1->nodeMax * 2 *
3786: sizeof(xmlNodePtr));
3787: if (temp == NULL) {
3788: xmlXPathErrMemory(NULL, "merging nodeset\n");
3789: return(NULL);
3790: }
3791: val1->nodeTab = temp;
3792: val1->nodeMax *= 2;
3793: }
3794: if (n2->type == XML_NAMESPACE_DECL) {
3795: xmlNsPtr ns = (xmlNsPtr) n2;
3796:
3797: val1->nodeTab[val1->nodeNr++] =
3798: xmlXPathNodeSetDupNs((xmlNodePtr) ns->next, ns);
3799: } else
3800: val1->nodeTab[val1->nodeNr++] = n2;
3801: }
3802:
3803: return(val1);
3804: }
3805:
3806: #if 0 /* xmlXPathNodeSetMergeUnique() is currently not used anymore */
3807: /**
3808: * xmlXPathNodeSetMergeUnique:
3809: * @val1: the first NodeSet or NULL
3810: * @val2: the second NodeSet
3811: *
3812: * Merges two nodesets, all nodes from @val2 are added to @val1
3813: * if @val1 is NULL, a new set is created and copied from @val2
3814: *
3815: * Returns @val1 once extended or NULL in case of error.
3816: */
3817: static xmlNodeSetPtr
3818: xmlXPathNodeSetMergeUnique(xmlNodeSetPtr val1, xmlNodeSetPtr val2) {
3819: int i;
3820:
3821: if (val2 == NULL) return(val1);
3822: if (val1 == NULL) {
3823: val1 = xmlXPathNodeSetCreate(NULL);
3824: }
3825: if (val1 == NULL)
3826: return (NULL);
3827:
3828: /* @@ with_ns to check whether namespace nodes should be looked at @@ */
3829:
3830: for (i = 0;i < val2->nodeNr;i++) {
3831: /*
3832: * grow the nodeTab if needed
3833: */
3834: if (val1->nodeMax == 0) {
3835: val1->nodeTab = (xmlNodePtr *) xmlMalloc(XML_NODESET_DEFAULT *
3836: sizeof(xmlNodePtr));
3837: if (val1->nodeTab == NULL) {
3838: xmlXPathErrMemory(NULL, "merging nodeset\n");
3839: return(NULL);
3840: }
3841: memset(val1->nodeTab, 0 ,
3842: XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
3843: val1->nodeMax = XML_NODESET_DEFAULT;
3844: } else if (val1->nodeNr == val1->nodeMax) {
3845: xmlNodePtr *temp;
3846:
3847: val1->nodeMax *= 2;
3848: temp = (xmlNodePtr *) xmlRealloc(val1->nodeTab, val1->nodeMax *
3849: sizeof(xmlNodePtr));
3850: if (temp == NULL) {
3851: xmlXPathErrMemory(NULL, "merging nodeset\n");
3852: return(NULL);
3853: }
3854: val1->nodeTab = temp;
3855: }
3856: if (val2->nodeTab[i]->type == XML_NAMESPACE_DECL) {
3857: xmlNsPtr ns = (xmlNsPtr) val2->nodeTab[i];
3858:
3859: val1->nodeTab[val1->nodeNr++] =
3860: xmlXPathNodeSetDupNs((xmlNodePtr) ns->next, ns);
3861: } else
3862: val1->nodeTab[val1->nodeNr++] = val2->nodeTab[i];
3863: }
3864:
3865: return(val1);
3866: }
3867: #endif /* xmlXPathNodeSetMergeUnique() is currently not used anymore */
3868:
3869: /**
3870: * xmlXPathNodeSetMergeAndClear:
3871: * @set1: the first NodeSet or NULL
3872: * @set2: the second NodeSet
3873: * @hasSet2NsNodes: 1 if set2 contains namespaces nodes
3874: *
3875: * Merges two nodesets, all nodes from @set2 are added to @set1
3876: * if @set1 is NULL, a new set is created and copied from @set2.
3877: * Checks for duplicate nodes. Clears set2.
3878: *
3879: * Returns @set1 once extended or NULL in case of error.
3880: */
3881: static xmlNodeSetPtr
3882: xmlXPathNodeSetMergeAndClear(xmlNodeSetPtr set1, xmlNodeSetPtr set2,
3883: int hasNullEntries)
3884: {
3885: if ((set1 == NULL) && (hasNullEntries == 0)) {
3886: /*
3887: * Note that doing a memcpy of the list, namespace nodes are
3888: * just assigned to set1, since set2 is cleared anyway.
3889: */
3890: set1 = xmlXPathNodeSetCreateSize(set2->nodeNr);
3891: if (set1 == NULL)
3892: return(NULL);
3893: if (set2->nodeNr != 0) {
3894: memcpy(set1->nodeTab, set2->nodeTab,
3895: set2->nodeNr * sizeof(xmlNodePtr));
3896: set1->nodeNr = set2->nodeNr;
3897: }
3898: } else {
3899: int i, j, initNbSet1;
3900: xmlNodePtr n1, n2;
3901:
3902: if (set1 == NULL)
3903: set1 = xmlXPathNodeSetCreate(NULL);
3904: if (set1 == NULL)
3905: return (NULL);
3906:
3907: initNbSet1 = set1->nodeNr;
3908: for (i = 0;i < set2->nodeNr;i++) {
3909: n2 = set2->nodeTab[i];
3910: /*
3911: * Skip NULLed entries.
3912: */
3913: if (n2 == NULL)
3914: continue;
3915: /*
3916: * Skip duplicates.
3917: */
3918: for (j = 0; j < initNbSet1; j++) {
3919: n1 = set1->nodeTab[j];
3920: if (n1 == n2) {
3921: goto skip_node;
3922: } else if ((n1->type == XML_NAMESPACE_DECL) &&
3923: (n2->type == XML_NAMESPACE_DECL))
3924: {
3925: if ((((xmlNsPtr) n1)->next == ((xmlNsPtr) n2)->next) &&
3926: (xmlStrEqual(((xmlNsPtr) n1)->prefix,
3927: ((xmlNsPtr) n2)->prefix)))
3928: {
3929: /*
3930: * Free the namespace node.
3931: */
3932: set2->nodeTab[i] = NULL;
3933: xmlXPathNodeSetFreeNs((xmlNsPtr) n2);
3934: goto skip_node;
3935: }
3936: }
3937: }
3938: /*
3939: * grow the nodeTab if needed
3940: */
3941: if (set1->nodeMax == 0) {
3942: set1->nodeTab = (xmlNodePtr *) xmlMalloc(
3943: XML_NODESET_DEFAULT * sizeof(xmlNodePtr));
3944: if (set1->nodeTab == NULL) {
3945: xmlXPathErrMemory(NULL, "merging nodeset\n");
3946: return(NULL);
3947: }
3948: memset(set1->nodeTab, 0,
3949: XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
3950: set1->nodeMax = XML_NODESET_DEFAULT;
3951: } else if (set1->nodeNr >= set1->nodeMax) {
3952: xmlNodePtr *temp;
3953:
3954: temp = (xmlNodePtr *) xmlRealloc(
3955: set1->nodeTab, set1->nodeMax * 2 * sizeof(xmlNodePtr));
3956: if (temp == NULL) {
3957: xmlXPathErrMemory(NULL, "merging nodeset\n");
3958: return(NULL);
3959: }
3960: set1->nodeTab = temp;
3961: set1->nodeMax *= 2;
3962: }
3963: if (n2->type == XML_NAMESPACE_DECL) {
3964: xmlNsPtr ns = (xmlNsPtr) n2;
3965:
3966: set1->nodeTab[set1->nodeNr++] =
3967: xmlXPathNodeSetDupNs((xmlNodePtr) ns->next, ns);
3968: } else
3969: set1->nodeTab[set1->nodeNr++] = n2;
3970: skip_node:
3971: {}
3972: }
3973: }
3974: set2->nodeNr = 0;
3975: return(set1);
3976: }
3977:
3978: /**
3979: * xmlXPathNodeSetMergeAndClearNoDupls:
3980: * @set1: the first NodeSet or NULL
3981: * @set2: the second NodeSet
3982: * @hasSet2NsNodes: 1 if set2 contains namespaces nodes
3983: *
3984: * Merges two nodesets, all nodes from @set2 are added to @set1
3985: * if @set1 is NULL, a new set is created and copied from @set2.
3986: * Doesn't chack for duplicate nodes. Clears set2.
3987: *
3988: * Returns @set1 once extended or NULL in case of error.
3989: */
3990: static xmlNodeSetPtr
3991: xmlXPathNodeSetMergeAndClearNoDupls(xmlNodeSetPtr set1, xmlNodeSetPtr set2,
3992: int hasNullEntries)
3993: {
3994: if (set2 == NULL)
3995: return(set1);
3996: if ((set1 == NULL) && (hasNullEntries == 0)) {
3997: /*
3998: * Note that doing a memcpy of the list, namespace nodes are
3999: * just assigned to set1, since set2 is cleared anyway.
4000: */
4001: set1 = xmlXPathNodeSetCreateSize(set2->nodeNr);
4002: if (set1 == NULL)
4003: return(NULL);
4004: if (set2->nodeNr != 0) {
4005: memcpy(set1->nodeTab, set2->nodeTab,
4006: set2->nodeNr * sizeof(xmlNodePtr));
4007: set1->nodeNr = set2->nodeNr;
4008: }
4009: } else {
4010: int i;
4011: xmlNodePtr n2;
4012:
4013: if (set1 == NULL)
4014: set1 = xmlXPathNodeSetCreate(NULL);
4015: if (set1 == NULL)
4016: return (NULL);
4017:
4018: for (i = 0;i < set2->nodeNr;i++) {
4019: n2 = set2->nodeTab[i];
4020: /*
4021: * Skip NULLed entries.
4022: */
4023: if (n2 == NULL)
4024: continue;
4025: if (set1->nodeMax == 0) {
4026: set1->nodeTab = (xmlNodePtr *) xmlMalloc(
4027: XML_NODESET_DEFAULT * sizeof(xmlNodePtr));
4028: if (set1->nodeTab == NULL) {
4029: xmlXPathErrMemory(NULL, "merging nodeset\n");
4030: return(NULL);
4031: }
4032: memset(set1->nodeTab, 0,
4033: XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
4034: set1->nodeMax = XML_NODESET_DEFAULT;
4035: } else if (set1->nodeNr >= set1->nodeMax) {
4036: xmlNodePtr *temp;
4037:
4038: temp = (xmlNodePtr *) xmlRealloc(
4039: set1->nodeTab, set1->nodeMax * 2 * sizeof(xmlNodePtr));
4040: if (temp == NULL) {
4041: xmlXPathErrMemory(NULL, "merging nodeset\n");
4042: return(NULL);
4043: }
4044: set1->nodeTab = temp;
4045: set1->nodeMax *= 2;
4046: }
4047: set1->nodeTab[set1->nodeNr++] = n2;
4048: }
4049: }
4050: set2->nodeNr = 0;
4051: return(set1);
4052: }
4053:
4054: /**
4055: * xmlXPathNodeSetDel:
4056: * @cur: the initial node set
4057: * @val: an xmlNodePtr
4058: *
4059: * Removes an xmlNodePtr from an existing NodeSet
4060: */
4061: void
4062: xmlXPathNodeSetDel(xmlNodeSetPtr cur, xmlNodePtr val) {
4063: int i;
4064:
4065: if (cur == NULL) return;
4066: if (val == NULL) return;
4067:
4068: /*
4069: * find node in nodeTab
4070: */
4071: for (i = 0;i < cur->nodeNr;i++)
4072: if (cur->nodeTab[i] == val) break;
4073:
4074: if (i >= cur->nodeNr) { /* not found */
4075: #ifdef DEBUG
4076: xmlGenericError(xmlGenericErrorContext,
4077: "xmlXPathNodeSetDel: Node %s wasn't found in NodeList\n",
4078: val->name);
4079: #endif
4080: return;
4081: }
4082: if ((cur->nodeTab[i] != NULL) &&
4083: (cur->nodeTab[i]->type == XML_NAMESPACE_DECL))
4084: xmlXPathNodeSetFreeNs((xmlNsPtr) cur->nodeTab[i]);
4085: cur->nodeNr--;
4086: for (;i < cur->nodeNr;i++)
4087: cur->nodeTab[i] = cur->nodeTab[i + 1];
4088: cur->nodeTab[cur->nodeNr] = NULL;
4089: }
4090:
4091: /**
4092: * xmlXPathNodeSetRemove:
4093: * @cur: the initial node set
4094: * @val: the index to remove
4095: *
4096: * Removes an entry from an existing NodeSet list.
4097: */
4098: void
4099: xmlXPathNodeSetRemove(xmlNodeSetPtr cur, int val) {
4100: if (cur == NULL) return;
4101: if (val >= cur->nodeNr) return;
4102: if ((cur->nodeTab[val] != NULL) &&
4103: (cur->nodeTab[val]->type == XML_NAMESPACE_DECL))
4104: xmlXPathNodeSetFreeNs((xmlNsPtr) cur->nodeTab[val]);
4105: cur->nodeNr--;
4106: for (;val < cur->nodeNr;val++)
4107: cur->nodeTab[val] = cur->nodeTab[val + 1];
4108: cur->nodeTab[cur->nodeNr] = NULL;
4109: }
4110:
4111: /**
4112: * xmlXPathFreeNodeSet:
4113: * @obj: the xmlNodeSetPtr to free
4114: *
4115: * Free the NodeSet compound (not the actual nodes !).
4116: */
4117: void
4118: xmlXPathFreeNodeSet(xmlNodeSetPtr obj) {
4119: if (obj == NULL) return;
4120: if (obj->nodeTab != NULL) {
4121: int i;
4122:
4123: /* @@ with_ns to check whether namespace nodes should be looked at @@ */
4124: for (i = 0;i < obj->nodeNr;i++)
4125: if ((obj->nodeTab[i] != NULL) &&
4126: (obj->nodeTab[i]->type == XML_NAMESPACE_DECL))
4127: xmlXPathNodeSetFreeNs((xmlNsPtr) obj->nodeTab[i]);
4128: xmlFree(obj->nodeTab);
4129: }
4130: xmlFree(obj);
4131: }
4132:
4133: /**
4134: * xmlXPathNodeSetClear:
4135: * @set: the node set to clear
4136: *
4137: * Clears the list from all temporary XPath objects (e.g. namespace nodes
4138: * are feed), but does *not* free the list itself. Sets the length of the
4139: * list to 0.
4140: */
4141: static void
4142: xmlXPathNodeSetClear(xmlNodeSetPtr set, int hasNsNodes)
4143: {
4144: if ((set == NULL) || (set->nodeNr <= 0))
4145: return;
4146: else if (hasNsNodes) {
4147: int i;
4148: xmlNodePtr node;
4149:
4150: for (i = 0; i < set->nodeNr; i++) {
4151: node = set->nodeTab[i];
4152: if ((node != NULL) &&
4153: (node->type == XML_NAMESPACE_DECL))
4154: xmlXPathNodeSetFreeNs((xmlNsPtr) node);
4155: }
4156: }
4157: set->nodeNr = 0;
4158: }
4159:
4160: /**
4161: * xmlXPathNodeSetClearFromPos:
4162: * @set: the node set to be cleared
4163: * @pos: the start position to clear from
4164: *
4165: * Clears the list from temporary XPath objects (e.g. namespace nodes
4166: * are feed) starting with the entry at @pos, but does *not* free the list
4167: * itself. Sets the length of the list to @pos.
4168: */
4169: static void
4170: xmlXPathNodeSetClearFromPos(xmlNodeSetPtr set, int pos, int hasNsNodes)
4171: {
4172: if ((set == NULL) || (set->nodeNr <= 0) || (pos >= set->nodeNr))
4173: return;
4174: else if ((hasNsNodes)) {
4175: int i;
4176: xmlNodePtr node;
4177:
4178: for (i = pos; i < set->nodeNr; i++) {
4179: node = set->nodeTab[i];
4180: if ((node != NULL) &&
4181: (node->type == XML_NAMESPACE_DECL))
4182: xmlXPathNodeSetFreeNs((xmlNsPtr) node);
4183: }
4184: }
4185: set->nodeNr = pos;
4186: }
4187:
4188: /**
4189: * xmlXPathFreeValueTree:
4190: * @obj: the xmlNodeSetPtr to free
4191: *
4192: * Free the NodeSet compound and the actual tree, this is different
4193: * from xmlXPathFreeNodeSet()
4194: */
4195: static void
4196: xmlXPathFreeValueTree(xmlNodeSetPtr obj) {
4197: int i;
4198:
4199: if (obj == NULL) return;
4200:
4201: if (obj->nodeTab != NULL) {
4202: for (i = 0;i < obj->nodeNr;i++) {
4203: if (obj->nodeTab[i] != NULL) {
4204: if (obj->nodeTab[i]->type == XML_NAMESPACE_DECL) {
4205: xmlXPathNodeSetFreeNs((xmlNsPtr) obj->nodeTab[i]);
4206: } else {
4207: xmlFreeNodeList(obj->nodeTab[i]);
4208: }
4209: }
4210: }
4211: xmlFree(obj->nodeTab);
4212: }
4213: xmlFree(obj);
4214: }
4215:
4216: #if defined(DEBUG) || defined(DEBUG_STEP)
4217: /**
4218: * xmlGenericErrorContextNodeSet:
4219: * @output: a FILE * for the output
4220: * @obj: the xmlNodeSetPtr to display
4221: *
4222: * Quick display of a NodeSet
4223: */
4224: void
4225: xmlGenericErrorContextNodeSet(FILE *output, xmlNodeSetPtr obj) {
4226: int i;
4227:
4228: if (output == NULL) output = xmlGenericErrorContext;
4229: if (obj == NULL) {
4230: fprintf(output, "NodeSet == NULL !\n");
4231: return;
4232: }
4233: if (obj->nodeNr == 0) {
4234: fprintf(output, "NodeSet is empty\n");
4235: return;
4236: }
4237: if (obj->nodeTab == NULL) {
4238: fprintf(output, " nodeTab == NULL !\n");
4239: return;
4240: }
4241: for (i = 0; i < obj->nodeNr; i++) {
4242: if (obj->nodeTab[i] == NULL) {
4243: fprintf(output, " NULL !\n");
4244: return;
4245: }
4246: if ((obj->nodeTab[i]->type == XML_DOCUMENT_NODE) ||
4247: (obj->nodeTab[i]->type == XML_HTML_DOCUMENT_NODE))
4248: fprintf(output, " /");
4249: else if (obj->nodeTab[i]->name == NULL)
4250: fprintf(output, " noname!");
4251: else fprintf(output, " %s", obj->nodeTab[i]->name);
4252: }
4253: fprintf(output, "\n");
4254: }
4255: #endif
4256:
4257: /**
4258: * xmlXPathNewNodeSet:
4259: * @val: the NodePtr value
4260: *
4261: * Create a new xmlXPathObjectPtr of type NodeSet and initialize
4262: * it with the single Node @val
4263: *
4264: * Returns the newly created object.
4265: */
4266: xmlXPathObjectPtr
4267: xmlXPathNewNodeSet(xmlNodePtr val) {
4268: xmlXPathObjectPtr ret;
4269:
4270: ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
4271: if (ret == NULL) {
4272: xmlXPathErrMemory(NULL, "creating nodeset\n");
4273: return(NULL);
4274: }
4275: memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
4276: ret->type = XPATH_NODESET;
4277: ret->boolval = 0;
4278: ret->nodesetval = xmlXPathNodeSetCreate(val);
4279: /* @@ with_ns to check whether namespace nodes should be looked at @@ */
4280: #ifdef XP_DEBUG_OBJ_USAGE
4281: xmlXPathDebugObjUsageRequested(NULL, XPATH_NODESET);
4282: #endif
4283: return(ret);
4284: }
4285:
4286: /**
4287: * xmlXPathNewValueTree:
4288: * @val: the NodePtr value
4289: *
4290: * Create a new xmlXPathObjectPtr of type Value Tree (XSLT) and initialize
4291: * it with the tree root @val
4292: *
4293: * Returns the newly created object.
4294: */
4295: xmlXPathObjectPtr
4296: xmlXPathNewValueTree(xmlNodePtr val) {
4297: xmlXPathObjectPtr ret;
4298:
4299: ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
4300: if (ret == NULL) {
4301: xmlXPathErrMemory(NULL, "creating result value tree\n");
4302: return(NULL);
4303: }
4304: memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
4305: ret->type = XPATH_XSLT_TREE;
4306: ret->boolval = 1;
4307: ret->user = (void *) val;
4308: ret->nodesetval = xmlXPathNodeSetCreate(val);
4309: #ifdef XP_DEBUG_OBJ_USAGE
4310: xmlXPathDebugObjUsageRequested(NULL, XPATH_XSLT_TREE);
4311: #endif
4312: return(ret);
4313: }
4314:
4315: /**
4316: * xmlXPathNewNodeSetList:
4317: * @val: an existing NodeSet
4318: *
4319: * Create a new xmlXPathObjectPtr of type NodeSet and initialize
4320: * it with the Nodeset @val
4321: *
4322: * Returns the newly created object.
4323: */
4324: xmlXPathObjectPtr
4325: xmlXPathNewNodeSetList(xmlNodeSetPtr val)
4326: {
4327: xmlXPathObjectPtr ret;
4328: int i;
4329:
4330: if (val == NULL)
4331: ret = NULL;
4332: else if (val->nodeTab == NULL)
4333: ret = xmlXPathNewNodeSet(NULL);
4334: else {
4335: ret = xmlXPathNewNodeSet(val->nodeTab[0]);
4336: if (ret)
4337: for (i = 1; i < val->nodeNr; ++i)
4338: xmlXPathNodeSetAddUnique(ret->nodesetval, val->nodeTab[i]);
4339: }
4340:
4341: return (ret);
4342: }
4343:
4344: /**
4345: * xmlXPathWrapNodeSet:
4346: * @val: the NodePtr value
4347: *
4348: * Wrap the Nodeset @val in a new xmlXPathObjectPtr
4349: *
4350: * Returns the newly created object.
4351: */
4352: xmlXPathObjectPtr
4353: xmlXPathWrapNodeSet(xmlNodeSetPtr val) {
4354: xmlXPathObjectPtr ret;
4355:
4356: ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
4357: if (ret == NULL) {
4358: xmlXPathErrMemory(NULL, "creating node set object\n");
4359: return(NULL);
4360: }
4361: memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
4362: ret->type = XPATH_NODESET;
4363: ret->nodesetval = val;
4364: #ifdef XP_DEBUG_OBJ_USAGE
4365: xmlXPathDebugObjUsageRequested(NULL, XPATH_NODESET);
4366: #endif
4367: return(ret);
4368: }
4369:
4370: /**
4371: * xmlXPathFreeNodeSetList:
4372: * @obj: an existing NodeSetList object
4373: *
4374: * Free up the xmlXPathObjectPtr @obj but don't deallocate the objects in
4375: * the list contrary to xmlXPathFreeObject().
4376: */
4377: void
4378: xmlXPathFreeNodeSetList(xmlXPathObjectPtr obj) {
4379: if (obj == NULL) return;
4380: #ifdef XP_DEBUG_OBJ_USAGE
4381: xmlXPathDebugObjUsageReleased(NULL, obj->type);
4382: #endif
4383: xmlFree(obj);
4384: }
4385:
4386: /**
4387: * xmlXPathDifference:
4388: * @nodes1: a node-set
4389: * @nodes2: a node-set
4390: *
4391: * Implements the EXSLT - Sets difference() function:
4392: * node-set set:difference (node-set, node-set)
4393: *
4394: * Returns the difference between the two node sets, or nodes1 if
4395: * nodes2 is empty
4396: */
4397: xmlNodeSetPtr
4398: xmlXPathDifference (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
4399: xmlNodeSetPtr ret;
4400: int i, l1;
4401: xmlNodePtr cur;
4402:
4403: if (xmlXPathNodeSetIsEmpty(nodes2))
4404: return(nodes1);
4405:
4406: ret = xmlXPathNodeSetCreate(NULL);
4407: if (xmlXPathNodeSetIsEmpty(nodes1))
4408: return(ret);
4409:
4410: l1 = xmlXPathNodeSetGetLength(nodes1);
4411:
4412: for (i = 0; i < l1; i++) {
4413: cur = xmlXPathNodeSetItem(nodes1, i);
4414: if (!xmlXPathNodeSetContains(nodes2, cur))
4415: xmlXPathNodeSetAddUnique(ret, cur);
4416: }
4417: return(ret);
4418: }
4419:
4420: /**
4421: * xmlXPathIntersection:
4422: * @nodes1: a node-set
4423: * @nodes2: a node-set
4424: *
4425: * Implements the EXSLT - Sets intersection() function:
4426: * node-set set:intersection (node-set, node-set)
4427: *
4428: * Returns a node set comprising the nodes that are within both the
4429: * node sets passed as arguments
4430: */
4431: xmlNodeSetPtr
4432: xmlXPathIntersection (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
4433: xmlNodeSetPtr ret = xmlXPathNodeSetCreate(NULL);
4434: int i, l1;
4435: xmlNodePtr cur;
4436:
4437: if (ret == NULL)
4438: return(ret);
4439: if (xmlXPathNodeSetIsEmpty(nodes1))
4440: return(ret);
4441: if (xmlXPathNodeSetIsEmpty(nodes2))
4442: return(ret);
4443:
4444: l1 = xmlXPathNodeSetGetLength(nodes1);
4445:
4446: for (i = 0; i < l1; i++) {
4447: cur = xmlXPathNodeSetItem(nodes1, i);
4448: if (xmlXPathNodeSetContains(nodes2, cur))
4449: xmlXPathNodeSetAddUnique(ret, cur);
4450: }
4451: return(ret);
4452: }
4453:
4454: /**
4455: * xmlXPathDistinctSorted:
4456: * @nodes: a node-set, sorted by document order
4457: *
4458: * Implements the EXSLT - Sets distinct() function:
4459: * node-set set:distinct (node-set)
4460: *
4461: * Returns a subset of the nodes contained in @nodes, or @nodes if
4462: * it is empty
4463: */
4464: xmlNodeSetPtr
4465: xmlXPathDistinctSorted (xmlNodeSetPtr nodes) {
4466: xmlNodeSetPtr ret;
4467: xmlHashTablePtr hash;
4468: int i, l;
4469: xmlChar * strval;
4470: xmlNodePtr cur;
4471:
4472: if (xmlXPathNodeSetIsEmpty(nodes))
4473: return(nodes);
4474:
4475: ret = xmlXPathNodeSetCreate(NULL);
4476: if (ret == NULL)
4477: return(ret);
4478: l = xmlXPathNodeSetGetLength(nodes);
4479: hash = xmlHashCreate (l);
4480: for (i = 0; i < l; i++) {
4481: cur = xmlXPathNodeSetItem(nodes, i);
4482: strval = xmlXPathCastNodeToString(cur);
4483: if (xmlHashLookup(hash, strval) == NULL) {
4484: xmlHashAddEntry(hash, strval, strval);
4485: xmlXPathNodeSetAddUnique(ret, cur);
4486: } else {
4487: xmlFree(strval);
4488: }
4489: }
4490: xmlHashFree(hash, (xmlHashDeallocator) xmlFree);
4491: return(ret);
4492: }
4493:
4494: /**
4495: * xmlXPathDistinct:
4496: * @nodes: a node-set
4497: *
4498: * Implements the EXSLT - Sets distinct() function:
4499: * node-set set:distinct (node-set)
4500: * @nodes is sorted by document order, then #exslSetsDistinctSorted
4501: * is called with the sorted node-set
4502: *
4503: * Returns a subset of the nodes contained in @nodes, or @nodes if
4504: * it is empty
4505: */
4506: xmlNodeSetPtr
4507: xmlXPathDistinct (xmlNodeSetPtr nodes) {
4508: if (xmlXPathNodeSetIsEmpty(nodes))
4509: return(nodes);
4510:
4511: xmlXPathNodeSetSort(nodes);
4512: return(xmlXPathDistinctSorted(nodes));
4513: }
4514:
4515: /**
4516: * xmlXPathHasSameNodes:
4517: * @nodes1: a node-set
4518: * @nodes2: a node-set
4519: *
4520: * Implements the EXSLT - Sets has-same-nodes function:
4521: * boolean set:has-same-node(node-set, node-set)
4522: *
4523: * Returns true (1) if @nodes1 shares any node with @nodes2, false (0)
4524: * otherwise
4525: */
4526: int
4527: xmlXPathHasSameNodes (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
4528: int i, l;
4529: xmlNodePtr cur;
4530:
4531: if (xmlXPathNodeSetIsEmpty(nodes1) ||
4532: xmlXPathNodeSetIsEmpty(nodes2))
4533: return(0);
4534:
4535: l = xmlXPathNodeSetGetLength(nodes1);
4536: for (i = 0; i < l; i++) {
4537: cur = xmlXPathNodeSetItem(nodes1, i);
4538: if (xmlXPathNodeSetContains(nodes2, cur))
4539: return(1);
4540: }
4541: return(0);
4542: }
4543:
4544: /**
4545: * xmlXPathNodeLeadingSorted:
4546: * @nodes: a node-set, sorted by document order
4547: * @node: a node
4548: *
4549: * Implements the EXSLT - Sets leading() function:
4550: * node-set set:leading (node-set, node-set)
4551: *
4552: * Returns the nodes in @nodes that precede @node in document order,
4553: * @nodes if @node is NULL or an empty node-set if @nodes
4554: * doesn't contain @node
4555: */
4556: xmlNodeSetPtr
4557: xmlXPathNodeLeadingSorted (xmlNodeSetPtr nodes, xmlNodePtr node) {
4558: int i, l;
4559: xmlNodePtr cur;
4560: xmlNodeSetPtr ret;
4561:
4562: if (node == NULL)
4563: return(nodes);
4564:
4565: ret = xmlXPathNodeSetCreate(NULL);
4566: if (ret == NULL)
4567: return(ret);
4568: if (xmlXPathNodeSetIsEmpty(nodes) ||
4569: (!xmlXPathNodeSetContains(nodes, node)))
4570: return(ret);
4571:
4572: l = xmlXPathNodeSetGetLength(nodes);
4573: for (i = 0; i < l; i++) {
4574: cur = xmlXPathNodeSetItem(nodes, i);
4575: if (cur == node)
4576: break;
4577: xmlXPathNodeSetAddUnique(ret, cur);
4578: }
4579: return(ret);
4580: }
4581:
4582: /**
4583: * xmlXPathNodeLeading:
4584: * @nodes: a node-set
4585: * @node: a node
4586: *
4587: * Implements the EXSLT - Sets leading() function:
4588: * node-set set:leading (node-set, node-set)
4589: * @nodes is sorted by document order, then #exslSetsNodeLeadingSorted
4590: * is called.
4591: *
4592: * Returns the nodes in @nodes that precede @node in document order,
4593: * @nodes if @node is NULL or an empty node-set if @nodes
4594: * doesn't contain @node
4595: */
4596: xmlNodeSetPtr
4597: xmlXPathNodeLeading (xmlNodeSetPtr nodes, xmlNodePtr node) {
4598: xmlXPathNodeSetSort(nodes);
4599: return(xmlXPathNodeLeadingSorted(nodes, node));
4600: }
4601:
4602: /**
4603: * xmlXPathLeadingSorted:
4604: * @nodes1: a node-set, sorted by document order
4605: * @nodes2: a node-set, sorted by document order
4606: *
4607: * Implements the EXSLT - Sets leading() function:
4608: * node-set set:leading (node-set, node-set)
4609: *
4610: * Returns the nodes in @nodes1 that precede the first node in @nodes2
4611: * in document order, @nodes1 if @nodes2 is NULL or empty or
4612: * an empty node-set if @nodes1 doesn't contain @nodes2
4613: */
4614: xmlNodeSetPtr
4615: xmlXPathLeadingSorted (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
4616: if (xmlXPathNodeSetIsEmpty(nodes2))
4617: return(nodes1);
4618: return(xmlXPathNodeLeadingSorted(nodes1,
4619: xmlXPathNodeSetItem(nodes2, 1)));
4620: }
4621:
4622: /**
4623: * xmlXPathLeading:
4624: * @nodes1: a node-set
4625: * @nodes2: a node-set
4626: *
4627: * Implements the EXSLT - Sets leading() function:
4628: * node-set set:leading (node-set, node-set)
4629: * @nodes1 and @nodes2 are sorted by document order, then
4630: * #exslSetsLeadingSorted is called.
4631: *
4632: * Returns the nodes in @nodes1 that precede the first node in @nodes2
4633: * in document order, @nodes1 if @nodes2 is NULL or empty or
4634: * an empty node-set if @nodes1 doesn't contain @nodes2
4635: */
4636: xmlNodeSetPtr
4637: xmlXPathLeading (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
4638: if (xmlXPathNodeSetIsEmpty(nodes2))
4639: return(nodes1);
4640: if (xmlXPathNodeSetIsEmpty(nodes1))
4641: return(xmlXPathNodeSetCreate(NULL));
4642: xmlXPathNodeSetSort(nodes1);
4643: xmlXPathNodeSetSort(nodes2);
4644: return(xmlXPathNodeLeadingSorted(nodes1,
4645: xmlXPathNodeSetItem(nodes2, 1)));
4646: }
4647:
4648: /**
4649: * xmlXPathNodeTrailingSorted:
4650: * @nodes: a node-set, sorted by document order
4651: * @node: a node
4652: *
4653: * Implements the EXSLT - Sets trailing() function:
4654: * node-set set:trailing (node-set, node-set)
4655: *
4656: * Returns the nodes in @nodes that follow @node in document order,
4657: * @nodes if @node is NULL or an empty node-set if @nodes
4658: * doesn't contain @node
4659: */
4660: xmlNodeSetPtr
4661: xmlXPathNodeTrailingSorted (xmlNodeSetPtr nodes, xmlNodePtr node) {
4662: int i, l;
4663: xmlNodePtr cur;
4664: xmlNodeSetPtr ret;
4665:
4666: if (node == NULL)
4667: return(nodes);
4668:
4669: ret = xmlXPathNodeSetCreate(NULL);
4670: if (ret == NULL)
4671: return(ret);
4672: if (xmlXPathNodeSetIsEmpty(nodes) ||
4673: (!xmlXPathNodeSetContains(nodes, node)))
4674: return(ret);
4675:
4676: l = xmlXPathNodeSetGetLength(nodes);
4677: for (i = l - 1; i >= 0; i--) {
4678: cur = xmlXPathNodeSetItem(nodes, i);
4679: if (cur == node)
4680: break;
4681: xmlXPathNodeSetAddUnique(ret, cur);
4682: }
4683: xmlXPathNodeSetSort(ret); /* bug 413451 */
4684: return(ret);
4685: }
4686:
4687: /**
4688: * xmlXPathNodeTrailing:
4689: * @nodes: a node-set
4690: * @node: a node
4691: *
4692: * Implements the EXSLT - Sets trailing() function:
4693: * node-set set:trailing (node-set, node-set)
4694: * @nodes is sorted by document order, then #xmlXPathNodeTrailingSorted
4695: * is called.
4696: *
4697: * Returns the nodes in @nodes that follow @node in document order,
4698: * @nodes if @node is NULL or an empty node-set if @nodes
4699: * doesn't contain @node
4700: */
4701: xmlNodeSetPtr
4702: xmlXPathNodeTrailing (xmlNodeSetPtr nodes, xmlNodePtr node) {
4703: xmlXPathNodeSetSort(nodes);
4704: return(xmlXPathNodeTrailingSorted(nodes, node));
4705: }
4706:
4707: /**
4708: * xmlXPathTrailingSorted:
4709: * @nodes1: a node-set, sorted by document order
4710: * @nodes2: a node-set, sorted by document order
4711: *
4712: * Implements the EXSLT - Sets trailing() function:
4713: * node-set set:trailing (node-set, node-set)
4714: *
4715: * Returns the nodes in @nodes1 that follow the first node in @nodes2
4716: * in document order, @nodes1 if @nodes2 is NULL or empty or
4717: * an empty node-set if @nodes1 doesn't contain @nodes2
4718: */
4719: xmlNodeSetPtr
4720: xmlXPathTrailingSorted (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
4721: if (xmlXPathNodeSetIsEmpty(nodes2))
4722: return(nodes1);
4723: return(xmlXPathNodeTrailingSorted(nodes1,
4724: xmlXPathNodeSetItem(nodes2, 0)));
4725: }
4726:
4727: /**
4728: * xmlXPathTrailing:
4729: * @nodes1: a node-set
4730: * @nodes2: a node-set
4731: *
4732: * Implements the EXSLT - Sets trailing() function:
4733: * node-set set:trailing (node-set, node-set)
4734: * @nodes1 and @nodes2 are sorted by document order, then
4735: * #xmlXPathTrailingSorted is called.
4736: *
4737: * Returns the nodes in @nodes1 that follow the first node in @nodes2
4738: * in document order, @nodes1 if @nodes2 is NULL or empty or
4739: * an empty node-set if @nodes1 doesn't contain @nodes2
4740: */
4741: xmlNodeSetPtr
4742: xmlXPathTrailing (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
4743: if (xmlXPathNodeSetIsEmpty(nodes2))
4744: return(nodes1);
4745: if (xmlXPathNodeSetIsEmpty(nodes1))
4746: return(xmlXPathNodeSetCreate(NULL));
4747: xmlXPathNodeSetSort(nodes1);
4748: xmlXPathNodeSetSort(nodes2);
4749: return(xmlXPathNodeTrailingSorted(nodes1,
4750: xmlXPathNodeSetItem(nodes2, 0)));
4751: }
4752:
4753: /************************************************************************
4754: * *
4755: * Routines to handle extra functions *
4756: * *
4757: ************************************************************************/
4758:
4759: /**
4760: * xmlXPathRegisterFunc:
4761: * @ctxt: the XPath context
4762: * @name: the function name
4763: * @f: the function implementation or NULL
4764: *
4765: * Register a new function. If @f is NULL it unregisters the function
4766: *
4767: * Returns 0 in case of success, -1 in case of error
4768: */
4769: int
4770: xmlXPathRegisterFunc(xmlXPathContextPtr ctxt, const xmlChar *name,
4771: xmlXPathFunction f) {
4772: return(xmlXPathRegisterFuncNS(ctxt, name, NULL, f));
4773: }
4774:
4775: /**
4776: * xmlXPathRegisterFuncNS:
4777: * @ctxt: the XPath context
4778: * @name: the function name
4779: * @ns_uri: the function namespace URI
4780: * @f: the function implementation or NULL
4781: *
4782: * Register a new function. If @f is NULL it unregisters the function
4783: *
4784: * Returns 0 in case of success, -1 in case of error
4785: */
4786: int
4787: xmlXPathRegisterFuncNS(xmlXPathContextPtr ctxt, const xmlChar *name,
4788: const xmlChar *ns_uri, xmlXPathFunction f) {
4789: if (ctxt == NULL)
4790: return(-1);
4791: if (name == NULL)
4792: return(-1);
4793:
4794: if (ctxt->funcHash == NULL)
4795: ctxt->funcHash = xmlHashCreate(0);
4796: if (ctxt->funcHash == NULL)
4797: return(-1);
4798: if (f == NULL)
4799: return(xmlHashRemoveEntry2(ctxt->funcHash, name, ns_uri, NULL));
4800: return(xmlHashAddEntry2(ctxt->funcHash, name, ns_uri, XML_CAST_FPTR(f)));
4801: }
4802:
4803: /**
4804: * xmlXPathRegisterFuncLookup:
4805: * @ctxt: the XPath context
4806: * @f: the lookup function
4807: * @funcCtxt: the lookup data
4808: *
4809: * Registers an external mechanism to do function lookup.
4810: */
4811: void
4812: xmlXPathRegisterFuncLookup (xmlXPathContextPtr ctxt,
4813: xmlXPathFuncLookupFunc f,
4814: void *funcCtxt) {
4815: if (ctxt == NULL)
4816: return;
4817: ctxt->funcLookupFunc = f;
4818: ctxt->funcLookupData = funcCtxt;
4819: }
4820:
4821: /**
4822: * xmlXPathFunctionLookup:
4823: * @ctxt: the XPath context
4824: * @name: the function name
4825: *
4826: * Search in the Function array of the context for the given
4827: * function.
4828: *
4829: * Returns the xmlXPathFunction or NULL if not found
4830: */
4831: xmlXPathFunction
4832: xmlXPathFunctionLookup(xmlXPathContextPtr ctxt, const xmlChar *name) {
4833: if (ctxt == NULL)
4834: return (NULL);
4835:
4836: if (ctxt->funcLookupFunc != NULL) {
4837: xmlXPathFunction ret;
4838: xmlXPathFuncLookupFunc f;
4839:
4840: f = ctxt->funcLookupFunc;
4841: ret = f(ctxt->funcLookupData, name, NULL);
4842: if (ret != NULL)
4843: return(ret);
4844: }
4845: return(xmlXPathFunctionLookupNS(ctxt, name, NULL));
4846: }
4847:
4848: /**
4849: * xmlXPathFunctionLookupNS:
4850: * @ctxt: the XPath context
4851: * @name: the function name
4852: * @ns_uri: the function namespace URI
4853: *
4854: * Search in the Function array of the context for the given
4855: * function.
4856: *
4857: * Returns the xmlXPathFunction or NULL if not found
4858: */
4859: xmlXPathFunction
4860: xmlXPathFunctionLookupNS(xmlXPathContextPtr ctxt, const xmlChar *name,
4861: const xmlChar *ns_uri) {
4862: xmlXPathFunction ret;
4863:
4864: if (ctxt == NULL)
4865: return(NULL);
4866: if (name == NULL)
4867: return(NULL);
4868:
4869: if (ctxt->funcLookupFunc != NULL) {
4870: xmlXPathFuncLookupFunc f;
4871:
4872: f = ctxt->funcLookupFunc;
4873: ret = f(ctxt->funcLookupData, name, ns_uri);
4874: if (ret != NULL)
4875: return(ret);
4876: }
4877:
4878: if (ctxt->funcHash == NULL)
4879: return(NULL);
4880:
4881: XML_CAST_FPTR(ret) = xmlHashLookup2(ctxt->funcHash, name, ns_uri);
4882: return(ret);
4883: }
4884:
4885: /**
4886: * xmlXPathRegisteredFuncsCleanup:
4887: * @ctxt: the XPath context
4888: *
4889: * Cleanup the XPath context data associated to registered functions
4890: */
4891: void
4892: xmlXPathRegisteredFuncsCleanup(xmlXPathContextPtr ctxt) {
4893: if (ctxt == NULL)
4894: return;
4895:
4896: xmlHashFree(ctxt->funcHash, NULL);
4897: ctxt->funcHash = NULL;
4898: }
4899:
4900: /************************************************************************
4901: * *
4902: * Routines to handle Variables *
4903: * *
4904: ************************************************************************/
4905:
4906: /**
4907: * xmlXPathRegisterVariable:
4908: * @ctxt: the XPath context
4909: * @name: the variable name
4910: * @value: the variable value or NULL
4911: *
4912: * Register a new variable value. If @value is NULL it unregisters
4913: * the variable
4914: *
4915: * Returns 0 in case of success, -1 in case of error
4916: */
4917: int
4918: xmlXPathRegisterVariable(xmlXPathContextPtr ctxt, const xmlChar *name,
4919: xmlXPathObjectPtr value) {
4920: return(xmlXPathRegisterVariableNS(ctxt, name, NULL, value));
4921: }
4922:
4923: /**
4924: * xmlXPathRegisterVariableNS:
4925: * @ctxt: the XPath context
4926: * @name: the variable name
4927: * @ns_uri: the variable namespace URI
4928: * @value: the variable value or NULL
4929: *
4930: * Register a new variable value. If @value is NULL it unregisters
4931: * the variable
4932: *
4933: * Returns 0 in case of success, -1 in case of error
4934: */
4935: int
4936: xmlXPathRegisterVariableNS(xmlXPathContextPtr ctxt, const xmlChar *name,
4937: const xmlChar *ns_uri,
4938: xmlXPathObjectPtr value) {
4939: if (ctxt == NULL)
4940: return(-1);
4941: if (name == NULL)
4942: return(-1);
4943:
4944: if (ctxt->varHash == NULL)
4945: ctxt->varHash = xmlHashCreate(0);
4946: if (ctxt->varHash == NULL)
4947: return(-1);
4948: if (value == NULL)
4949: return(xmlHashRemoveEntry2(ctxt->varHash, name, ns_uri,
4950: (xmlHashDeallocator)xmlXPathFreeObject));
4951: return(xmlHashUpdateEntry2(ctxt->varHash, name, ns_uri,
4952: (void *) value,
4953: (xmlHashDeallocator)xmlXPathFreeObject));
4954: }
4955:
4956: /**
4957: * xmlXPathRegisterVariableLookup:
4958: * @ctxt: the XPath context
4959: * @f: the lookup function
4960: * @data: the lookup data
4961: *
4962: * register an external mechanism to do variable lookup
4963: */
4964: void
4965: xmlXPathRegisterVariableLookup(xmlXPathContextPtr ctxt,
4966: xmlXPathVariableLookupFunc f, void *data) {
4967: if (ctxt == NULL)
4968: return;
4969: ctxt->varLookupFunc = f;
4970: ctxt->varLookupData = data;
4971: }
4972:
4973: /**
4974: * xmlXPathVariableLookup:
4975: * @ctxt: the XPath context
4976: * @name: the variable name
4977: *
4978: * Search in the Variable array of the context for the given
4979: * variable value.
4980: *
4981: * Returns a copy of the value or NULL if not found
4982: */
4983: xmlXPathObjectPtr
4984: xmlXPathVariableLookup(xmlXPathContextPtr ctxt, const xmlChar *name) {
4985: if (ctxt == NULL)
4986: return(NULL);
4987:
4988: if (ctxt->varLookupFunc != NULL) {
4989: xmlXPathObjectPtr ret;
4990:
4991: ret = ((xmlXPathVariableLookupFunc)ctxt->varLookupFunc)
4992: (ctxt->varLookupData, name, NULL);
4993: return(ret);
4994: }
4995: return(xmlXPathVariableLookupNS(ctxt, name, NULL));
4996: }
4997:
4998: /**
4999: * xmlXPathVariableLookupNS:
5000: * @ctxt: the XPath context
5001: * @name: the variable name
5002: * @ns_uri: the variable namespace URI
5003: *
5004: * Search in the Variable array of the context for the given
5005: * variable value.
5006: *
5007: * Returns the a copy of the value or NULL if not found
5008: */
5009: xmlXPathObjectPtr
5010: xmlXPathVariableLookupNS(xmlXPathContextPtr ctxt, const xmlChar *name,
5011: const xmlChar *ns_uri) {
5012: if (ctxt == NULL)
5013: return(NULL);
5014:
5015: if (ctxt->varLookupFunc != NULL) {
5016: xmlXPathObjectPtr ret;
5017:
5018: ret = ((xmlXPathVariableLookupFunc)ctxt->varLookupFunc)
5019: (ctxt->varLookupData, name, ns_uri);
5020: if (ret != NULL) return(ret);
5021: }
5022:
5023: if (ctxt->varHash == NULL)
5024: return(NULL);
5025: if (name == NULL)
5026: return(NULL);
5027:
5028: return(xmlXPathCacheObjectCopy(ctxt, (xmlXPathObjectPtr)
5029: xmlHashLookup2(ctxt->varHash, name, ns_uri)));
5030: }
5031:
5032: /**
5033: * xmlXPathRegisteredVariablesCleanup:
5034: * @ctxt: the XPath context
5035: *
5036: * Cleanup the XPath context data associated to registered variables
5037: */
5038: void
5039: xmlXPathRegisteredVariablesCleanup(xmlXPathContextPtr ctxt) {
5040: if (ctxt == NULL)
5041: return;
5042:
5043: xmlHashFree(ctxt->varHash, (xmlHashDeallocator)xmlXPathFreeObject);
5044: ctxt->varHash = NULL;
5045: }
5046:
5047: /**
5048: * xmlXPathRegisterNs:
5049: * @ctxt: the XPath context
5050: * @prefix: the namespace prefix cannot be NULL or empty string
5051: * @ns_uri: the namespace name
5052: *
5053: * Register a new namespace. If @ns_uri is NULL it unregisters
5054: * the namespace
5055: *
5056: * Returns 0 in case of success, -1 in case of error
5057: */
5058: int
5059: xmlXPathRegisterNs(xmlXPathContextPtr ctxt, const xmlChar *prefix,
5060: const xmlChar *ns_uri) {
5061: if (ctxt == NULL)
5062: return(-1);
5063: if (prefix == NULL)
5064: return(-1);
5065: if (prefix[0] == 0)
5066: return(-1);
5067:
5068: if (ctxt->nsHash == NULL)
5069: ctxt->nsHash = xmlHashCreate(10);
5070: if (ctxt->nsHash == NULL)
5071: return(-1);
5072: if (ns_uri == NULL)
5073: return(xmlHashRemoveEntry(ctxt->nsHash, prefix,
5074: (xmlHashDeallocator)xmlFree));
5075: return(xmlHashUpdateEntry(ctxt->nsHash, prefix, (void *) xmlStrdup(ns_uri),
5076: (xmlHashDeallocator)xmlFree));
5077: }
5078:
5079: /**
5080: * xmlXPathNsLookup:
5081: * @ctxt: the XPath context
5082: * @prefix: the namespace prefix value
5083: *
5084: * Search in the namespace declaration array of the context for the given
5085: * namespace name associated to the given prefix
5086: *
5087: * Returns the value or NULL if not found
5088: */
5089: const xmlChar *
5090: xmlXPathNsLookup(xmlXPathContextPtr ctxt, const xmlChar *prefix) {
5091: if (ctxt == NULL)
5092: return(NULL);
5093: if (prefix == NULL)
5094: return(NULL);
5095:
5096: #ifdef XML_XML_NAMESPACE
5097: if (xmlStrEqual(prefix, (const xmlChar *) "xml"))
5098: return(XML_XML_NAMESPACE);
5099: #endif
5100:
5101: if (ctxt->namespaces != NULL) {
5102: int i;
5103:
5104: for (i = 0;i < ctxt->nsNr;i++) {
5105: if ((ctxt->namespaces[i] != NULL) &&
5106: (xmlStrEqual(ctxt->namespaces[i]->prefix, prefix)))
5107: return(ctxt->namespaces[i]->href);
5108: }
5109: }
5110:
5111: return((const xmlChar *) xmlHashLookup(ctxt->nsHash, prefix));
5112: }
5113:
5114: /**
5115: * xmlXPathRegisteredNsCleanup:
5116: * @ctxt: the XPath context
5117: *
5118: * Cleanup the XPath context data associated to registered variables
5119: */
5120: void
5121: xmlXPathRegisteredNsCleanup(xmlXPathContextPtr ctxt) {
5122: if (ctxt == NULL)
5123: return;
5124:
5125: xmlHashFree(ctxt->nsHash, (xmlHashDeallocator)xmlFree);
5126: ctxt->nsHash = NULL;
5127: }
5128:
5129: /************************************************************************
5130: * *
5131: * Routines to handle Values *
5132: * *
5133: ************************************************************************/
5134:
5135: /* Allocations are terrible, one needs to optimize all this !!! */
5136:
5137: /**
5138: * xmlXPathNewFloat:
5139: * @val: the double value
5140: *
5141: * Create a new xmlXPathObjectPtr of type double and of value @val
5142: *
5143: * Returns the newly created object.
5144: */
5145: xmlXPathObjectPtr
5146: xmlXPathNewFloat(double val) {
5147: xmlXPathObjectPtr ret;
5148:
5149: ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
5150: if (ret == NULL) {
5151: xmlXPathErrMemory(NULL, "creating float object\n");
5152: return(NULL);
5153: }
5154: memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
5155: ret->type = XPATH_NUMBER;
5156: ret->floatval = val;
5157: #ifdef XP_DEBUG_OBJ_USAGE
5158: xmlXPathDebugObjUsageRequested(NULL, XPATH_NUMBER);
5159: #endif
5160: return(ret);
5161: }
5162:
5163: /**
5164: * xmlXPathNewBoolean:
5165: * @val: the boolean value
5166: *
5167: * Create a new xmlXPathObjectPtr of type boolean and of value @val
5168: *
5169: * Returns the newly created object.
5170: */
5171: xmlXPathObjectPtr
5172: xmlXPathNewBoolean(int val) {
5173: xmlXPathObjectPtr ret;
5174:
5175: ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
5176: if (ret == NULL) {
5177: xmlXPathErrMemory(NULL, "creating boolean object\n");
5178: return(NULL);
5179: }
5180: memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
5181: ret->type = XPATH_BOOLEAN;
5182: ret->boolval = (val != 0);
5183: #ifdef XP_DEBUG_OBJ_USAGE
5184: xmlXPathDebugObjUsageRequested(NULL, XPATH_BOOLEAN);
5185: #endif
5186: return(ret);
5187: }
5188:
5189: /**
5190: * xmlXPathNewString:
5191: * @val: the xmlChar * value
5192: *
5193: * Create a new xmlXPathObjectPtr of type string and of value @val
5194: *
5195: * Returns the newly created object.
5196: */
5197: xmlXPathObjectPtr
5198: xmlXPathNewString(const xmlChar *val) {
5199: xmlXPathObjectPtr ret;
5200:
5201: ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
5202: if (ret == NULL) {
5203: xmlXPathErrMemory(NULL, "creating string object\n");
5204: return(NULL);
5205: }
5206: memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
5207: ret->type = XPATH_STRING;
5208: if (val != NULL)
5209: ret->stringval = xmlStrdup(val);
5210: else
5211: ret->stringval = xmlStrdup((const xmlChar *)"");
5212: #ifdef XP_DEBUG_OBJ_USAGE
5213: xmlXPathDebugObjUsageRequested(NULL, XPATH_STRING);
5214: #endif
5215: return(ret);
5216: }
5217:
5218: /**
5219: * xmlXPathWrapString:
5220: * @val: the xmlChar * value
5221: *
5222: * Wraps the @val string into an XPath object.
5223: *
5224: * Returns the newly created object.
5225: */
5226: xmlXPathObjectPtr
5227: xmlXPathWrapString (xmlChar *val) {
5228: xmlXPathObjectPtr ret;
5229:
5230: ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
5231: if (ret == NULL) {
5232: xmlXPathErrMemory(NULL, "creating string object\n");
5233: return(NULL);
5234: }
5235: memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
5236: ret->type = XPATH_STRING;
5237: ret->stringval = val;
5238: #ifdef XP_DEBUG_OBJ_USAGE
5239: xmlXPathDebugObjUsageRequested(NULL, XPATH_STRING);
5240: #endif
5241: return(ret);
5242: }
5243:
5244: /**
5245: * xmlXPathNewCString:
5246: * @val: the char * value
5247: *
5248: * Create a new xmlXPathObjectPtr of type string and of value @val
5249: *
5250: * Returns the newly created object.
5251: */
5252: xmlXPathObjectPtr
5253: xmlXPathNewCString(const char *val) {
5254: xmlXPathObjectPtr ret;
5255:
5256: ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
5257: if (ret == NULL) {
5258: xmlXPathErrMemory(NULL, "creating string object\n");
5259: return(NULL);
5260: }
5261: memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
5262: ret->type = XPATH_STRING;
5263: ret->stringval = xmlStrdup(BAD_CAST val);
5264: #ifdef XP_DEBUG_OBJ_USAGE
5265: xmlXPathDebugObjUsageRequested(NULL, XPATH_STRING);
5266: #endif
5267: return(ret);
5268: }
5269:
5270: /**
5271: * xmlXPathWrapCString:
5272: * @val: the char * value
5273: *
5274: * Wraps a string into an XPath object.
5275: *
5276: * Returns the newly created object.
5277: */
5278: xmlXPathObjectPtr
5279: xmlXPathWrapCString (char * val) {
5280: return(xmlXPathWrapString((xmlChar *)(val)));
5281: }
5282:
5283: /**
5284: * xmlXPathWrapExternal:
5285: * @val: the user data
5286: *
5287: * Wraps the @val data into an XPath object.
5288: *
5289: * Returns the newly created object.
5290: */
5291: xmlXPathObjectPtr
5292: xmlXPathWrapExternal (void *val) {
5293: xmlXPathObjectPtr ret;
5294:
5295: ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
5296: if (ret == NULL) {
5297: xmlXPathErrMemory(NULL, "creating user object\n");
5298: return(NULL);
5299: }
5300: memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
5301: ret->type = XPATH_USERS;
5302: ret->user = val;
5303: #ifdef XP_DEBUG_OBJ_USAGE
5304: xmlXPathDebugObjUsageRequested(NULL, XPATH_USERS);
5305: #endif
5306: return(ret);
5307: }
5308:
5309: /**
5310: * xmlXPathObjectCopy:
5311: * @val: the original object
5312: *
5313: * allocate a new copy of a given object
5314: *
5315: * Returns the newly created object.
5316: */
5317: xmlXPathObjectPtr
5318: xmlXPathObjectCopy(xmlXPathObjectPtr val) {
5319: xmlXPathObjectPtr ret;
5320:
5321: if (val == NULL)
5322: return(NULL);
5323:
5324: ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
5325: if (ret == NULL) {
5326: xmlXPathErrMemory(NULL, "copying object\n");
5327: return(NULL);
5328: }
5329: memcpy(ret, val , (size_t) sizeof(xmlXPathObject));
5330: #ifdef XP_DEBUG_OBJ_USAGE
5331: xmlXPathDebugObjUsageRequested(NULL, val->type);
5332: #endif
5333: switch (val->type) {
5334: case XPATH_BOOLEAN:
5335: case XPATH_NUMBER:
5336: case XPATH_POINT:
5337: case XPATH_RANGE:
5338: break;
5339: case XPATH_STRING:
5340: ret->stringval = xmlStrdup(val->stringval);
5341: break;
5342: case XPATH_XSLT_TREE:
5343: #if 0
5344: /*
5345: Removed 11 July 2004 - the current handling of xslt tmpRVT nodes means that
5346: this previous handling is no longer correct, and can cause some serious
5347: problems (ref. bug 145547)
5348: */
5349: if ((val->nodesetval != NULL) &&
5350: (val->nodesetval->nodeTab != NULL)) {
5351: xmlNodePtr cur, tmp;
5352: xmlDocPtr top;
5353:
5354: ret->boolval = 1;
5355: top = xmlNewDoc(NULL);
5356: top->name = (char *)
5357: xmlStrdup(val->nodesetval->nodeTab[0]->name);
5358: ret->user = top;
5359: if (top != NULL) {
5360: top->doc = top;
5361: cur = val->nodesetval->nodeTab[0]->children;
5362: while (cur != NULL) {
5363: tmp = xmlDocCopyNode(cur, top, 1);
5364: xmlAddChild((xmlNodePtr) top, tmp);
5365: cur = cur->next;
5366: }
5367: }
5368:
5369: ret->nodesetval = xmlXPathNodeSetCreate((xmlNodePtr) top);
5370: } else
5371: ret->nodesetval = xmlXPathNodeSetCreate(NULL);
5372: /* Deallocate the copied tree value */
5373: break;
5374: #endif
5375: case XPATH_NODESET:
5376: ret->nodesetval = xmlXPathNodeSetMerge(NULL, val->nodesetval);
5377: /* Do not deallocate the copied tree value */
5378: ret->boolval = 0;
5379: break;
5380: case XPATH_LOCATIONSET:
5381: #ifdef LIBXML_XPTR_ENABLED
5382: {
5383: xmlLocationSetPtr loc = val->user;
5384: ret->user = (void *) xmlXPtrLocationSetMerge(NULL, loc);
5385: break;
5386: }
5387: #endif
5388: case XPATH_USERS:
5389: ret->user = val->user;
5390: break;
5391: case XPATH_UNDEFINED:
5392: xmlGenericError(xmlGenericErrorContext,
5393: "xmlXPathObjectCopy: unsupported type %d\n",
5394: val->type);
5395: break;
5396: }
5397: return(ret);
5398: }
5399:
5400: /**
5401: * xmlXPathFreeObject:
5402: * @obj: the object to free
5403: *
5404: * Free up an xmlXPathObjectPtr object.
5405: */
5406: void
5407: xmlXPathFreeObject(xmlXPathObjectPtr obj) {
5408: if (obj == NULL) return;
5409: if ((obj->type == XPATH_NODESET) || (obj->type == XPATH_XSLT_TREE)) {
5410: if (obj->boolval) {
5411: #if 0
5412: if (obj->user != NULL) {
5413: xmlXPathFreeNodeSet(obj->nodesetval);
5414: xmlFreeNodeList((xmlNodePtr) obj->user);
5415: } else
5416: #endif
5417: obj->type = XPATH_XSLT_TREE; /* TODO: Just for debugging. */
5418: if (obj->nodesetval != NULL)
5419: xmlXPathFreeValueTree(obj->nodesetval);
5420: } else {
5421: if (obj->nodesetval != NULL)
5422: xmlXPathFreeNodeSet(obj->nodesetval);
5423: }
5424: #ifdef LIBXML_XPTR_ENABLED
5425: } else if (obj->type == XPATH_LOCATIONSET) {
5426: if (obj->user != NULL)
5427: xmlXPtrFreeLocationSet(obj->user);
5428: #endif
5429: } else if (obj->type == XPATH_STRING) {
5430: if (obj->stringval != NULL)
5431: xmlFree(obj->stringval);
5432: }
5433: #ifdef XP_DEBUG_OBJ_USAGE
5434: xmlXPathDebugObjUsageReleased(NULL, obj->type);
5435: #endif
5436: xmlFree(obj);
5437: }
5438:
5439: /**
5440: * xmlXPathReleaseObject:
5441: * @obj: the xmlXPathObjectPtr to free or to cache
5442: *
5443: * Depending on the state of the cache this frees the given
5444: * XPath object or stores it in the cache.
5445: */
5446: static void
5447: xmlXPathReleaseObject(xmlXPathContextPtr ctxt, xmlXPathObjectPtr obj)
5448: {
5449: #define XP_CACHE_ADD(sl, o) if (sl == NULL) { \
5450: sl = xmlPointerListCreate(10); if (sl == NULL) goto free_obj; } \
5451: if (xmlPointerListAddSize(sl, obj, 0) == -1) goto free_obj;
5452:
5453: #define XP_CACHE_WANTS(sl, n) ((sl == NULL) || ((sl)->number < n))
5454:
5455: if (obj == NULL)
5456: return;
5457: if ((ctxt == NULL) || (ctxt->cache == NULL)) {
5458: xmlXPathFreeObject(obj);
5459: } else {
5460: xmlXPathContextCachePtr cache =
5461: (xmlXPathContextCachePtr) ctxt->cache;
5462:
5463: switch (obj->type) {
5464: case XPATH_NODESET:
5465: case XPATH_XSLT_TREE:
5466: if (obj->nodesetval != NULL) {
5467: if (obj->boolval) {
5468: /*
5469: * It looks like the @boolval is used for
5470: * evaluation if this an XSLT Result Tree Fragment.
5471: * TODO: Check if this assumption is correct.
5472: */
5473: obj->type = XPATH_XSLT_TREE; /* just for debugging */
5474: xmlXPathFreeValueTree(obj->nodesetval);
5475: obj->nodesetval = NULL;
5476: } else if ((obj->nodesetval->nodeMax <= 40) &&
5477: (XP_CACHE_WANTS(cache->nodesetObjs,
5478: cache->maxNodeset)))
5479: {
5480: XP_CACHE_ADD(cache->nodesetObjs, obj);
5481: goto obj_cached;
5482: } else {
5483: xmlXPathFreeNodeSet(obj->nodesetval);
5484: obj->nodesetval = NULL;
5485: }
5486: }
5487: break;
5488: case XPATH_STRING:
5489: if (obj->stringval != NULL)
5490: xmlFree(obj->stringval);
5491:
5492: if (XP_CACHE_WANTS(cache->stringObjs, cache->maxString)) {
5493: XP_CACHE_ADD(cache->stringObjs, obj);
5494: goto obj_cached;
5495: }
5496: break;
5497: case XPATH_BOOLEAN:
5498: if (XP_CACHE_WANTS(cache->booleanObjs, cache->maxBoolean)) {
5499: XP_CACHE_ADD(cache->booleanObjs, obj);
5500: goto obj_cached;
5501: }
5502: break;
5503: case XPATH_NUMBER:
5504: if (XP_CACHE_WANTS(cache->numberObjs, cache->maxNumber)) {
5505: XP_CACHE_ADD(cache->numberObjs, obj);
5506: goto obj_cached;
5507: }
5508: break;
5509: #ifdef LIBXML_XPTR_ENABLED
5510: case XPATH_LOCATIONSET:
5511: if (obj->user != NULL) {
5512: xmlXPtrFreeLocationSet(obj->user);
5513: }
5514: goto free_obj;
5515: #endif
5516: default:
5517: goto free_obj;
5518: }
5519:
5520: /*
5521: * Fallback to adding to the misc-objects slot.
5522: */
5523: if (XP_CACHE_WANTS(cache->miscObjs, cache->maxMisc)) {
5524: XP_CACHE_ADD(cache->miscObjs, obj);
5525: } else
5526: goto free_obj;
5527:
5528: obj_cached:
5529:
5530: #ifdef XP_DEBUG_OBJ_USAGE
5531: xmlXPathDebugObjUsageReleased(ctxt, obj->type);
5532: #endif
5533:
5534: if (obj->nodesetval != NULL) {
5535: xmlNodeSetPtr tmpset = obj->nodesetval;
5536:
5537: /*
5538: * TODO: Due to those nasty ns-nodes, we need to traverse
5539: * the list and free the ns-nodes.
5540: * URGENT TODO: Check if it's actually slowing things down.
5541: * Maybe we shouldn't try to preserve the list.
5542: */
5543: if (tmpset->nodeNr > 1) {
5544: int i;
5545: xmlNodePtr node;
5546:
5547: for (i = 0; i < tmpset->nodeNr; i++) {
5548: node = tmpset->nodeTab[i];
5549: if ((node != NULL) &&
5550: (node->type == XML_NAMESPACE_DECL))
5551: {
5552: xmlXPathNodeSetFreeNs((xmlNsPtr) node);
5553: }
5554: }
5555: } else if (tmpset->nodeNr == 1) {
5556: if ((tmpset->nodeTab[0] != NULL) &&
5557: (tmpset->nodeTab[0]->type == XML_NAMESPACE_DECL))
5558: xmlXPathNodeSetFreeNs((xmlNsPtr) tmpset->nodeTab[0]);
5559: }
5560: tmpset->nodeNr = 0;
5561: memset(obj, 0, sizeof(xmlXPathObject));
5562: obj->nodesetval = tmpset;
5563: } else
5564: memset(obj, 0, sizeof(xmlXPathObject));
5565:
5566: return;
5567:
5568: free_obj:
5569: /*
5570: * Cache is full; free the object.
5571: */
5572: if (obj->nodesetval != NULL)
5573: xmlXPathFreeNodeSet(obj->nodesetval);
5574: #ifdef XP_DEBUG_OBJ_USAGE
5575: xmlXPathDebugObjUsageReleased(NULL, obj->type);
5576: #endif
5577: xmlFree(obj);
5578: }
5579: return;
5580: }
5581:
5582:
5583: /************************************************************************
5584: * *
5585: * Type Casting Routines *
5586: * *
5587: ************************************************************************/
5588:
5589: /**
5590: * xmlXPathCastBooleanToString:
5591: * @val: a boolean
5592: *
5593: * Converts a boolean to its string value.
5594: *
5595: * Returns a newly allocated string.
5596: */
5597: xmlChar *
5598: xmlXPathCastBooleanToString (int val) {
5599: xmlChar *ret;
5600: if (val)
5601: ret = xmlStrdup((const xmlChar *) "true");
5602: else
5603: ret = xmlStrdup((const xmlChar *) "false");
5604: return(ret);
5605: }
5606:
5607: /**
5608: * xmlXPathCastNumberToString:
5609: * @val: a number
5610: *
5611: * Converts a number to its string value.
5612: *
5613: * Returns a newly allocated string.
5614: */
5615: xmlChar *
5616: xmlXPathCastNumberToString (double val) {
5617: xmlChar *ret;
5618: switch (xmlXPathIsInf(val)) {
5619: case 1:
5620: ret = xmlStrdup((const xmlChar *) "Infinity");
5621: break;
5622: case -1:
5623: ret = xmlStrdup((const xmlChar *) "-Infinity");
5624: break;
5625: default:
5626: if (xmlXPathIsNaN(val)) {
5627: ret = xmlStrdup((const xmlChar *) "NaN");
5628: } else if (val == 0 && xmlXPathGetSign(val) != 0) {
5629: ret = xmlStrdup((const xmlChar *) "0");
5630: } else {
5631: /* could be improved */
5632: char buf[100];
5633: xmlXPathFormatNumber(val, buf, 99);
5634: buf[99] = 0;
5635: ret = xmlStrdup((const xmlChar *) buf);
5636: }
5637: }
5638: return(ret);
5639: }
5640:
5641: /**
5642: * xmlXPathCastNodeToString:
5643: * @node: a node
5644: *
5645: * Converts a node to its string value.
5646: *
5647: * Returns a newly allocated string.
5648: */
5649: xmlChar *
5650: xmlXPathCastNodeToString (xmlNodePtr node) {
5651: xmlChar *ret;
5652: if ((ret = xmlNodeGetContent(node)) == NULL)
5653: ret = xmlStrdup((const xmlChar *) "");
5654: return(ret);
5655: }
5656:
5657: /**
5658: * xmlXPathCastNodeSetToString:
5659: * @ns: a node-set
5660: *
5661: * Converts a node-set to its string value.
5662: *
5663: * Returns a newly allocated string.
5664: */
5665: xmlChar *
5666: xmlXPathCastNodeSetToString (xmlNodeSetPtr ns) {
5667: if ((ns == NULL) || (ns->nodeNr == 0) || (ns->nodeTab == NULL))
5668: return(xmlStrdup((const xmlChar *) ""));
5669:
5670: if (ns->nodeNr > 1)
5671: xmlXPathNodeSetSort(ns);
5672: return(xmlXPathCastNodeToString(ns->nodeTab[0]));
5673: }
5674:
5675: /**
5676: * xmlXPathCastToString:
5677: * @val: an XPath object
5678: *
5679: * Converts an existing object to its string() equivalent
5680: *
5681: * Returns the allocated string value of the object, NULL in case of error.
5682: * It's up to the caller to free the string memory with xmlFree().
5683: */
5684: xmlChar *
5685: xmlXPathCastToString(xmlXPathObjectPtr val) {
5686: xmlChar *ret = NULL;
5687:
5688: if (val == NULL)
5689: return(xmlStrdup((const xmlChar *) ""));
5690: switch (val->type) {
5691: case XPATH_UNDEFINED:
5692: #ifdef DEBUG_EXPR
5693: xmlGenericError(xmlGenericErrorContext, "String: undefined\n");
5694: #endif
5695: ret = xmlStrdup((const xmlChar *) "");
5696: break;
5697: case XPATH_NODESET:
5698: case XPATH_XSLT_TREE:
5699: ret = xmlXPathCastNodeSetToString(val->nodesetval);
5700: break;
5701: case XPATH_STRING:
5702: return(xmlStrdup(val->stringval));
5703: case XPATH_BOOLEAN:
5704: ret = xmlXPathCastBooleanToString(val->boolval);
5705: break;
5706: case XPATH_NUMBER: {
5707: ret = xmlXPathCastNumberToString(val->floatval);
5708: break;
5709: }
5710: case XPATH_USERS:
5711: case XPATH_POINT:
5712: case XPATH_RANGE:
5713: case XPATH_LOCATIONSET:
5714: TODO
5715: ret = xmlStrdup((const xmlChar *) "");
5716: break;
5717: }
5718: return(ret);
5719: }
5720:
5721: /**
5722: * xmlXPathConvertString:
5723: * @val: an XPath object
5724: *
5725: * Converts an existing object to its string() equivalent
5726: *
5727: * Returns the new object, the old one is freed (or the operation
5728: * is done directly on @val)
5729: */
5730: xmlXPathObjectPtr
5731: xmlXPathConvertString(xmlXPathObjectPtr val) {
5732: xmlChar *res = NULL;
5733:
5734: if (val == NULL)
5735: return(xmlXPathNewCString(""));
5736:
5737: switch (val->type) {
5738: case XPATH_UNDEFINED:
5739: #ifdef DEBUG_EXPR
5740: xmlGenericError(xmlGenericErrorContext, "STRING: undefined\n");
5741: #endif
5742: break;
5743: case XPATH_NODESET:
5744: case XPATH_XSLT_TREE:
5745: res = xmlXPathCastNodeSetToString(val->nodesetval);
5746: break;
5747: case XPATH_STRING:
5748: return(val);
5749: case XPATH_BOOLEAN:
5750: res = xmlXPathCastBooleanToString(val->boolval);
5751: break;
5752: case XPATH_NUMBER:
5753: res = xmlXPathCastNumberToString(val->floatval);
5754: break;
5755: case XPATH_USERS:
5756: case XPATH_POINT:
5757: case XPATH_RANGE:
5758: case XPATH_LOCATIONSET:
5759: TODO;
5760: break;
5761: }
5762: xmlXPathFreeObject(val);
5763: if (res == NULL)
5764: return(xmlXPathNewCString(""));
5765: return(xmlXPathWrapString(res));
5766: }
5767:
5768: /**
5769: * xmlXPathCastBooleanToNumber:
5770: * @val: a boolean
5771: *
5772: * Converts a boolean to its number value
5773: *
5774: * Returns the number value
5775: */
5776: double
5777: xmlXPathCastBooleanToNumber(int val) {
5778: if (val)
5779: return(1.0);
5780: return(0.0);
5781: }
5782:
5783: /**
5784: * xmlXPathCastStringToNumber:
5785: * @val: a string
5786: *
5787: * Converts a string to its number value
5788: *
5789: * Returns the number value
5790: */
5791: double
5792: xmlXPathCastStringToNumber(const xmlChar * val) {
5793: return(xmlXPathStringEvalNumber(val));
5794: }
5795:
5796: /**
5797: * xmlXPathCastNodeToNumber:
5798: * @node: a node
5799: *
5800: * Converts a node to its number value
5801: *
5802: * Returns the number value
5803: */
5804: double
5805: xmlXPathCastNodeToNumber (xmlNodePtr node) {
5806: xmlChar *strval;
5807: double ret;
5808:
5809: if (node == NULL)
5810: return(xmlXPathNAN);
5811: strval = xmlXPathCastNodeToString(node);
5812: if (strval == NULL)
5813: return(xmlXPathNAN);
5814: ret = xmlXPathCastStringToNumber(strval);
5815: xmlFree(strval);
5816:
5817: return(ret);
5818: }
5819:
5820: /**
5821: * xmlXPathCastNodeSetToNumber:
5822: * @ns: a node-set
5823: *
5824: * Converts a node-set to its number value
5825: *
5826: * Returns the number value
5827: */
5828: double
5829: xmlXPathCastNodeSetToNumber (xmlNodeSetPtr ns) {
5830: xmlChar *str;
5831: double ret;
5832:
5833: if (ns == NULL)
5834: return(xmlXPathNAN);
5835: str = xmlXPathCastNodeSetToString(ns);
5836: ret = xmlXPathCastStringToNumber(str);
5837: xmlFree(str);
5838: return(ret);
5839: }
5840:
5841: /**
5842: * xmlXPathCastToNumber:
5843: * @val: an XPath object
5844: *
5845: * Converts an XPath object to its number value
5846: *
5847: * Returns the number value
5848: */
5849: double
5850: xmlXPathCastToNumber(xmlXPathObjectPtr val) {
5851: double ret = 0.0;
5852:
5853: if (val == NULL)
5854: return(xmlXPathNAN);
5855: switch (val->type) {
5856: case XPATH_UNDEFINED:
5857: #ifdef DEGUB_EXPR
5858: xmlGenericError(xmlGenericErrorContext, "NUMBER: undefined\n");
5859: #endif
5860: ret = xmlXPathNAN;
5861: break;
5862: case XPATH_NODESET:
5863: case XPATH_XSLT_TREE:
5864: ret = xmlXPathCastNodeSetToNumber(val->nodesetval);
5865: break;
5866: case XPATH_STRING:
5867: ret = xmlXPathCastStringToNumber(val->stringval);
5868: break;
5869: case XPATH_NUMBER:
5870: ret = val->floatval;
5871: break;
5872: case XPATH_BOOLEAN:
5873: ret = xmlXPathCastBooleanToNumber(val->boolval);
5874: break;
5875: case XPATH_USERS:
5876: case XPATH_POINT:
5877: case XPATH_RANGE:
5878: case XPATH_LOCATIONSET:
5879: TODO;
5880: ret = xmlXPathNAN;
5881: break;
5882: }
5883: return(ret);
5884: }
5885:
5886: /**
5887: * xmlXPathConvertNumber:
5888: * @val: an XPath object
5889: *
5890: * Converts an existing object to its number() equivalent
5891: *
5892: * Returns the new object, the old one is freed (or the operation
5893: * is done directly on @val)
5894: */
5895: xmlXPathObjectPtr
5896: xmlXPathConvertNumber(xmlXPathObjectPtr val) {
5897: xmlXPathObjectPtr ret;
5898:
5899: if (val == NULL)
5900: return(xmlXPathNewFloat(0.0));
5901: if (val->type == XPATH_NUMBER)
5902: return(val);
5903: ret = xmlXPathNewFloat(xmlXPathCastToNumber(val));
5904: xmlXPathFreeObject(val);
5905: return(ret);
5906: }
5907:
5908: /**
5909: * xmlXPathCastNumberToBoolean:
5910: * @val: a number
5911: *
5912: * Converts a number to its boolean value
5913: *
5914: * Returns the boolean value
5915: */
5916: int
5917: xmlXPathCastNumberToBoolean (double val) {
5918: if (xmlXPathIsNaN(val) || (val == 0.0))
5919: return(0);
5920: return(1);
5921: }
5922:
5923: /**
5924: * xmlXPathCastStringToBoolean:
5925: * @val: a string
5926: *
5927: * Converts a string to its boolean value
5928: *
5929: * Returns the boolean value
5930: */
5931: int
5932: xmlXPathCastStringToBoolean (const xmlChar *val) {
5933: if ((val == NULL) || (xmlStrlen(val) == 0))
5934: return(0);
5935: return(1);
5936: }
5937:
5938: /**
5939: * xmlXPathCastNodeSetToBoolean:
5940: * @ns: a node-set
5941: *
5942: * Converts a node-set to its boolean value
5943: *
5944: * Returns the boolean value
5945: */
5946: int
5947: xmlXPathCastNodeSetToBoolean (xmlNodeSetPtr ns) {
5948: if ((ns == NULL) || (ns->nodeNr == 0))
5949: return(0);
5950: return(1);
5951: }
5952:
5953: /**
5954: * xmlXPathCastToBoolean:
5955: * @val: an XPath object
5956: *
5957: * Converts an XPath object to its boolean value
5958: *
5959: * Returns the boolean value
5960: */
5961: int
5962: xmlXPathCastToBoolean (xmlXPathObjectPtr val) {
5963: int ret = 0;
5964:
5965: if (val == NULL)
5966: return(0);
5967: switch (val->type) {
5968: case XPATH_UNDEFINED:
5969: #ifdef DEBUG_EXPR
5970: xmlGenericError(xmlGenericErrorContext, "BOOLEAN: undefined\n");
5971: #endif
5972: ret = 0;
5973: break;
5974: case XPATH_NODESET:
5975: case XPATH_XSLT_TREE:
5976: ret = xmlXPathCastNodeSetToBoolean(val->nodesetval);
5977: break;
5978: case XPATH_STRING:
5979: ret = xmlXPathCastStringToBoolean(val->stringval);
5980: break;
5981: case XPATH_NUMBER:
5982: ret = xmlXPathCastNumberToBoolean(val->floatval);
5983: break;
5984: case XPATH_BOOLEAN:
5985: ret = val->boolval;
5986: break;
5987: case XPATH_USERS:
5988: case XPATH_POINT:
5989: case XPATH_RANGE:
5990: case XPATH_LOCATIONSET:
5991: TODO;
5992: ret = 0;
5993: break;
5994: }
5995: return(ret);
5996: }
5997:
5998:
5999: /**
6000: * xmlXPathConvertBoolean:
6001: * @val: an XPath object
6002: *
6003: * Converts an existing object to its boolean() equivalent
6004: *
6005: * Returns the new object, the old one is freed (or the operation
6006: * is done directly on @val)
6007: */
6008: xmlXPathObjectPtr
6009: xmlXPathConvertBoolean(xmlXPathObjectPtr val) {
6010: xmlXPathObjectPtr ret;
6011:
6012: if (val == NULL)
6013: return(xmlXPathNewBoolean(0));
6014: if (val->type == XPATH_BOOLEAN)
6015: return(val);
6016: ret = xmlXPathNewBoolean(xmlXPathCastToBoolean(val));
6017: xmlXPathFreeObject(val);
6018: return(ret);
6019: }
6020:
6021: /************************************************************************
6022: * *
6023: * Routines to handle XPath contexts *
6024: * *
6025: ************************************************************************/
6026:
6027: /**
6028: * xmlXPathNewContext:
6029: * @doc: the XML document
6030: *
6031: * Create a new xmlXPathContext
6032: *
6033: * Returns the xmlXPathContext just allocated. The caller will need to free it.
6034: */
6035: xmlXPathContextPtr
6036: xmlXPathNewContext(xmlDocPtr doc) {
6037: xmlXPathContextPtr ret;
6038:
6039: ret = (xmlXPathContextPtr) xmlMalloc(sizeof(xmlXPathContext));
6040: if (ret == NULL) {
6041: xmlXPathErrMemory(NULL, "creating context\n");
6042: return(NULL);
6043: }
6044: memset(ret, 0 , (size_t) sizeof(xmlXPathContext));
6045: ret->doc = doc;
6046: ret->node = NULL;
6047:
6048: ret->varHash = NULL;
6049:
6050: ret->nb_types = 0;
6051: ret->max_types = 0;
6052: ret->types = NULL;
6053:
6054: ret->funcHash = xmlHashCreate(0);
6055:
6056: ret->nb_axis = 0;
6057: ret->max_axis = 0;
6058: ret->axis = NULL;
6059:
6060: ret->nsHash = NULL;
6061: ret->user = NULL;
6062:
6063: ret->contextSize = -1;
6064: ret->proximityPosition = -1;
6065:
6066: #ifdef XP_DEFAULT_CACHE_ON
6067: if (xmlXPathContextSetCache(ret, 1, -1, 0) == -1) {
6068: xmlXPathFreeContext(ret);
6069: return(NULL);
6070: }
6071: #endif
6072:
6073: xmlXPathRegisterAllFunctions(ret);
6074:
6075: return(ret);
6076: }
6077:
6078: /**
6079: * xmlXPathFreeContext:
6080: * @ctxt: the context to free
6081: *
6082: * Free up an xmlXPathContext
6083: */
6084: void
6085: xmlXPathFreeContext(xmlXPathContextPtr ctxt) {
6086: if (ctxt == NULL) return;
6087:
6088: if (ctxt->cache != NULL)
6089: xmlXPathFreeCache((xmlXPathContextCachePtr) ctxt->cache);
6090: xmlXPathRegisteredNsCleanup(ctxt);
6091: xmlXPathRegisteredFuncsCleanup(ctxt);
6092: xmlXPathRegisteredVariablesCleanup(ctxt);
6093: xmlResetError(&ctxt->lastError);
6094: xmlFree(ctxt);
6095: }
6096:
6097: /************************************************************************
6098: * *
6099: * Routines to handle XPath parser contexts *
6100: * *
6101: ************************************************************************/
6102:
6103: #define CHECK_CTXT(ctxt) \
6104: if (ctxt == NULL) { \
6105: __xmlRaiseError(NULL, NULL, NULL, \
6106: NULL, NULL, XML_FROM_XPATH, \
6107: XML_ERR_INTERNAL_ERROR, XML_ERR_FATAL, \
6108: __FILE__, __LINE__, \
6109: NULL, NULL, NULL, 0, 0, \
6110: "NULL context pointer\n"); \
6111: return(NULL); \
6112: } \
6113:
6114: #define CHECK_CTXT_NEG(ctxt) \
6115: if (ctxt == NULL) { \
6116: __xmlRaiseError(NULL, NULL, NULL, \
6117: NULL, NULL, XML_FROM_XPATH, \
6118: XML_ERR_INTERNAL_ERROR, XML_ERR_FATAL, \
6119: __FILE__, __LINE__, \
6120: NULL, NULL, NULL, 0, 0, \
6121: "NULL context pointer\n"); \
6122: return(-1); \
6123: } \
6124:
6125:
6126: #define CHECK_CONTEXT(ctxt) \
6127: if ((ctxt == NULL) || (ctxt->doc == NULL) || \
6128: (ctxt->doc->children == NULL)) { \
6129: xmlXPatherror(ctxt, __FILE__, __LINE__, XPATH_INVALID_CTXT); \
6130: return(NULL); \
6131: }
6132:
6133:
6134: /**
6135: * xmlXPathNewParserContext:
6136: * @str: the XPath expression
6137: * @ctxt: the XPath context
6138: *
6139: * Create a new xmlXPathParserContext
6140: *
6141: * Returns the xmlXPathParserContext just allocated.
6142: */
6143: xmlXPathParserContextPtr
6144: xmlXPathNewParserContext(const xmlChar *str, xmlXPathContextPtr ctxt) {
6145: xmlXPathParserContextPtr ret;
6146:
6147: ret = (xmlXPathParserContextPtr) xmlMalloc(sizeof(xmlXPathParserContext));
6148: if (ret == NULL) {
6149: xmlXPathErrMemory(ctxt, "creating parser context\n");
6150: return(NULL);
6151: }
6152: memset(ret, 0 , (size_t) sizeof(xmlXPathParserContext));
6153: ret->cur = ret->base = str;
6154: ret->context = ctxt;
6155:
6156: ret->comp = xmlXPathNewCompExpr();
6157: if (ret->comp == NULL) {
6158: xmlFree(ret->valueTab);
6159: xmlFree(ret);
6160: return(NULL);
6161: }
6162: if ((ctxt != NULL) && (ctxt->dict != NULL)) {
6163: ret->comp->dict = ctxt->dict;
6164: xmlDictReference(ret->comp->dict);
6165: }
6166:
6167: return(ret);
6168: }
6169:
6170: /**
6171: * xmlXPathCompParserContext:
6172: * @comp: the XPath compiled expression
6173: * @ctxt: the XPath context
6174: *
6175: * Create a new xmlXPathParserContext when processing a compiled expression
6176: *
6177: * Returns the xmlXPathParserContext just allocated.
6178: */
6179: static xmlXPathParserContextPtr
6180: xmlXPathCompParserContext(xmlXPathCompExprPtr comp, xmlXPathContextPtr ctxt) {
6181: xmlXPathParserContextPtr ret;
6182:
6183: ret = (xmlXPathParserContextPtr) xmlMalloc(sizeof(xmlXPathParserContext));
6184: if (ret == NULL) {
6185: xmlXPathErrMemory(ctxt, "creating evaluation context\n");
6186: return(NULL);
6187: }
6188: memset(ret, 0 , (size_t) sizeof(xmlXPathParserContext));
6189:
6190: /* Allocate the value stack */
6191: ret->valueTab = (xmlXPathObjectPtr *)
6192: xmlMalloc(10 * sizeof(xmlXPathObjectPtr));
6193: if (ret->valueTab == NULL) {
6194: xmlFree(ret);
6195: xmlXPathErrMemory(ctxt, "creating evaluation context\n");
6196: return(NULL);
6197: }
6198: ret->valueNr = 0;
6199: ret->valueMax = 10;
6200: ret->value = NULL;
6201: ret->valueFrame = 0;
6202:
6203: ret->context = ctxt;
6204: ret->comp = comp;
6205:
6206: return(ret);
6207: }
6208:
6209: /**
6210: * xmlXPathFreeParserContext:
6211: * @ctxt: the context to free
6212: *
6213: * Free up an xmlXPathParserContext
6214: */
6215: void
6216: xmlXPathFreeParserContext(xmlXPathParserContextPtr ctxt) {
6217: if (ctxt->valueTab != NULL) {
6218: xmlFree(ctxt->valueTab);
6219: }
6220: if (ctxt->comp != NULL) {
6221: #ifdef XPATH_STREAMING
6222: if (ctxt->comp->stream != NULL) {
6223: xmlFreePatternList(ctxt->comp->stream);
6224: ctxt->comp->stream = NULL;
6225: }
6226: #endif
6227: xmlXPathFreeCompExpr(ctxt->comp);
6228: }
6229: xmlFree(ctxt);
6230: }
6231:
6232: /************************************************************************
6233: * *
6234: * The implicit core function library *
6235: * *
6236: ************************************************************************/
6237:
6238: /**
6239: * xmlXPathNodeValHash:
6240: * @node: a node pointer
6241: *
6242: * Function computing the beginning of the string value of the node,
6243: * used to speed up comparisons
6244: *
6245: * Returns an int usable as a hash
6246: */
6247: static unsigned int
6248: xmlXPathNodeValHash(xmlNodePtr node) {
6249: int len = 2;
6250: const xmlChar * string = NULL;
6251: xmlNodePtr tmp = NULL;
6252: unsigned int ret = 0;
6253:
6254: if (node == NULL)
6255: return(0);
6256:
6257: if (node->type == XML_DOCUMENT_NODE) {
6258: tmp = xmlDocGetRootElement((xmlDocPtr) node);
6259: if (tmp == NULL)
6260: node = node->children;
6261: else
6262: node = tmp;
6263:
6264: if (node == NULL)
6265: return(0);
6266: }
6267:
6268: switch (node->type) {
6269: case XML_COMMENT_NODE:
6270: case XML_PI_NODE:
6271: case XML_CDATA_SECTION_NODE:
6272: case XML_TEXT_NODE:
6273: string = node->content;
6274: if (string == NULL)
6275: return(0);
6276: if (string[0] == 0)
6277: return(0);
6278: return(((unsigned int) string[0]) +
6279: (((unsigned int) string[1]) << 8));
6280: case XML_NAMESPACE_DECL:
6281: string = ((xmlNsPtr)node)->href;
6282: if (string == NULL)
6283: return(0);
6284: if (string[0] == 0)
6285: return(0);
6286: return(((unsigned int) string[0]) +
6287: (((unsigned int) string[1]) << 8));
6288: case XML_ATTRIBUTE_NODE:
6289: tmp = ((xmlAttrPtr) node)->children;
6290: break;
6291: case XML_ELEMENT_NODE:
6292: tmp = node->children;
6293: break;
6294: default:
6295: return(0);
6296: }
6297: while (tmp != NULL) {
6298: switch (tmp->type) {
6299: case XML_COMMENT_NODE:
6300: case XML_PI_NODE:
6301: case XML_CDATA_SECTION_NODE:
6302: case XML_TEXT_NODE:
6303: string = tmp->content;
6304: break;
6305: case XML_NAMESPACE_DECL:
6306: string = ((xmlNsPtr)tmp)->href;
6307: break;
6308: default:
6309: break;
6310: }
6311: if ((string != NULL) && (string[0] != 0)) {
6312: if (len == 1) {
6313: return(ret + (((unsigned int) string[0]) << 8));
6314: }
6315: if (string[1] == 0) {
6316: len = 1;
6317: ret = (unsigned int) string[0];
6318: } else {
6319: return(((unsigned int) string[0]) +
6320: (((unsigned int) string[1]) << 8));
6321: }
6322: }
6323: /*
6324: * Skip to next node
6325: */
6326: if ((tmp->children != NULL) && (tmp->type != XML_DTD_NODE)) {
6327: if (tmp->children->type != XML_ENTITY_DECL) {
6328: tmp = tmp->children;
6329: continue;
6330: }
6331: }
6332: if (tmp == node)
6333: break;
6334:
6335: if (tmp->next != NULL) {
6336: tmp = tmp->next;
6337: continue;
6338: }
6339:
6340: do {
6341: tmp = tmp->parent;
6342: if (tmp == NULL)
6343: break;
6344: if (tmp == node) {
6345: tmp = NULL;
6346: break;
6347: }
6348: if (tmp->next != NULL) {
6349: tmp = tmp->next;
6350: break;
6351: }
6352: } while (tmp != NULL);
6353: }
6354: return(ret);
6355: }
6356:
6357: /**
6358: * xmlXPathStringHash:
6359: * @string: a string
6360: *
6361: * Function computing the beginning of the string value of the node,
6362: * used to speed up comparisons
6363: *
6364: * Returns an int usable as a hash
6365: */
6366: static unsigned int
6367: xmlXPathStringHash(const xmlChar * string) {
6368: if (string == NULL)
6369: return((unsigned int) 0);
6370: if (string[0] == 0)
6371: return(0);
6372: return(((unsigned int) string[0]) +
6373: (((unsigned int) string[1]) << 8));
6374: }
6375:
6376: /**
6377: * xmlXPathCompareNodeSetFloat:
6378: * @ctxt: the XPath Parser context
6379: * @inf: less than (1) or greater than (0)
6380: * @strict: is the comparison strict
6381: * @arg: the node set
6382: * @f: the value
6383: *
6384: * Implement the compare operation between a nodeset and a number
6385: * @ns < @val (1, 1, ...
6386: * @ns <= @val (1, 0, ...
6387: * @ns > @val (0, 1, ...
6388: * @ns >= @val (0, 0, ...
6389: *
6390: * If one object to be compared is a node-set and the other is a number,
6391: * then the comparison will be true if and only if there is a node in the
6392: * node-set such that the result of performing the comparison on the number
6393: * to be compared and on the result of converting the string-value of that
6394: * node to a number using the number function is true.
6395: *
6396: * Returns 0 or 1 depending on the results of the test.
6397: */
6398: static int
6399: xmlXPathCompareNodeSetFloat(xmlXPathParserContextPtr ctxt, int inf, int strict,
6400: xmlXPathObjectPtr arg, xmlXPathObjectPtr f) {
6401: int i, ret = 0;
6402: xmlNodeSetPtr ns;
6403: xmlChar *str2;
6404:
6405: if ((f == NULL) || (arg == NULL) ||
6406: ((arg->type != XPATH_NODESET) && (arg->type != XPATH_XSLT_TREE))) {
6407: xmlXPathReleaseObject(ctxt->context, arg);
6408: xmlXPathReleaseObject(ctxt->context, f);
6409: return(0);
6410: }
6411: ns = arg->nodesetval;
6412: if (ns != NULL) {
6413: for (i = 0;i < ns->nodeNr;i++) {
6414: str2 = xmlXPathCastNodeToString(ns->nodeTab[i]);
6415: if (str2 != NULL) {
6416: valuePush(ctxt,
6417: xmlXPathCacheNewString(ctxt->context, str2));
6418: xmlFree(str2);
6419: xmlXPathNumberFunction(ctxt, 1);
6420: valuePush(ctxt, xmlXPathCacheObjectCopy(ctxt->context, f));
6421: ret = xmlXPathCompareValues(ctxt, inf, strict);
6422: if (ret)
6423: break;
6424: }
6425: }
6426: }
6427: xmlXPathReleaseObject(ctxt->context, arg);
6428: xmlXPathReleaseObject(ctxt->context, f);
6429: return(ret);
6430: }
6431:
6432: /**
6433: * xmlXPathCompareNodeSetString:
6434: * @ctxt: the XPath Parser context
6435: * @inf: less than (1) or greater than (0)
6436: * @strict: is the comparison strict
6437: * @arg: the node set
6438: * @s: the value
6439: *
6440: * Implement the compare operation between a nodeset and a string
6441: * @ns < @val (1, 1, ...
6442: * @ns <= @val (1, 0, ...
6443: * @ns > @val (0, 1, ...
6444: * @ns >= @val (0, 0, ...
6445: *
6446: * If one object to be compared is a node-set and the other is a string,
6447: * then the comparison will be true if and only if there is a node in
6448: * the node-set such that the result of performing the comparison on the
6449: * string-value of the node and the other string is true.
6450: *
6451: * Returns 0 or 1 depending on the results of the test.
6452: */
6453: static int
6454: xmlXPathCompareNodeSetString(xmlXPathParserContextPtr ctxt, int inf, int strict,
6455: xmlXPathObjectPtr arg, xmlXPathObjectPtr s) {
6456: int i, ret = 0;
6457: xmlNodeSetPtr ns;
6458: xmlChar *str2;
6459:
6460: if ((s == NULL) || (arg == NULL) ||
6461: ((arg->type != XPATH_NODESET) && (arg->type != XPATH_XSLT_TREE))) {
6462: xmlXPathReleaseObject(ctxt->context, arg);
6463: xmlXPathReleaseObject(ctxt->context, s);
6464: return(0);
6465: }
6466: ns = arg->nodesetval;
6467: if (ns != NULL) {
6468: for (i = 0;i < ns->nodeNr;i++) {
6469: str2 = xmlXPathCastNodeToString(ns->nodeTab[i]);
6470: if (str2 != NULL) {
6471: valuePush(ctxt,
6472: xmlXPathCacheNewString(ctxt->context, str2));
6473: xmlFree(str2);
6474: valuePush(ctxt, xmlXPathCacheObjectCopy(ctxt->context, s));
6475: ret = xmlXPathCompareValues(ctxt, inf, strict);
6476: if (ret)
6477: break;
6478: }
6479: }
6480: }
6481: xmlXPathReleaseObject(ctxt->context, arg);
6482: xmlXPathReleaseObject(ctxt->context, s);
6483: return(ret);
6484: }
6485:
6486: /**
6487: * xmlXPathCompareNodeSets:
6488: * @inf: less than (1) or greater than (0)
6489: * @strict: is the comparison strict
6490: * @arg1: the first node set object
6491: * @arg2: the second node set object
6492: *
6493: * Implement the compare operation on nodesets:
6494: *
6495: * If both objects to be compared are node-sets, then the comparison
6496: * will be true if and only if there is a node in the first node-set
6497: * and a node in the second node-set such that the result of performing
6498: * the comparison on the string-values of the two nodes is true.
6499: * ....
6500: * When neither object to be compared is a node-set and the operator
6501: * is <=, <, >= or >, then the objects are compared by converting both
6502: * objects to numbers and comparing the numbers according to IEEE 754.
6503: * ....
6504: * The number function converts its argument to a number as follows:
6505: * - a string that consists of optional whitespace followed by an
6506: * optional minus sign followed by a Number followed by whitespace
6507: * is converted to the IEEE 754 number that is nearest (according
6508: * to the IEEE 754 round-to-nearest rule) to the mathematical value
6509: * represented by the string; any other string is converted to NaN
6510: *
6511: * Conclusion all nodes need to be converted first to their string value
6512: * and then the comparison must be done when possible
6513: */
6514: static int
6515: xmlXPathCompareNodeSets(int inf, int strict,
6516: xmlXPathObjectPtr arg1, xmlXPathObjectPtr arg2) {
6517: int i, j, init = 0;
6518: double val1;
6519: double *values2;
6520: int ret = 0;
6521: xmlNodeSetPtr ns1;
6522: xmlNodeSetPtr ns2;
6523:
6524: if ((arg1 == NULL) ||
6525: ((arg1->type != XPATH_NODESET) && (arg1->type != XPATH_XSLT_TREE))) {
6526: xmlXPathFreeObject(arg2);
6527: return(0);
6528: }
6529: if ((arg2 == NULL) ||
6530: ((arg2->type != XPATH_NODESET) && (arg2->type != XPATH_XSLT_TREE))) {
6531: xmlXPathFreeObject(arg1);
6532: xmlXPathFreeObject(arg2);
6533: return(0);
6534: }
6535:
6536: ns1 = arg1->nodesetval;
6537: ns2 = arg2->nodesetval;
6538:
6539: if ((ns1 == NULL) || (ns1->nodeNr <= 0)) {
6540: xmlXPathFreeObject(arg1);
6541: xmlXPathFreeObject(arg2);
6542: return(0);
6543: }
6544: if ((ns2 == NULL) || (ns2->nodeNr <= 0)) {
6545: xmlXPathFreeObject(arg1);
6546: xmlXPathFreeObject(arg2);
6547: return(0);
6548: }
6549:
6550: values2 = (double *) xmlMalloc(ns2->nodeNr * sizeof(double));
6551: if (values2 == NULL) {
6552: xmlXPathErrMemory(NULL, "comparing nodesets\n");
6553: xmlXPathFreeObject(arg1);
6554: xmlXPathFreeObject(arg2);
6555: return(0);
6556: }
6557: for (i = 0;i < ns1->nodeNr;i++) {
6558: val1 = xmlXPathCastNodeToNumber(ns1->nodeTab[i]);
6559: if (xmlXPathIsNaN(val1))
6560: continue;
6561: for (j = 0;j < ns2->nodeNr;j++) {
6562: if (init == 0) {
6563: values2[j] = xmlXPathCastNodeToNumber(ns2->nodeTab[j]);
6564: }
6565: if (xmlXPathIsNaN(values2[j]))
6566: continue;
6567: if (inf && strict)
6568: ret = (val1 < values2[j]);
6569: else if (inf && !strict)
6570: ret = (val1 <= values2[j]);
6571: else if (!inf && strict)
6572: ret = (val1 > values2[j]);
6573: else if (!inf && !strict)
6574: ret = (val1 >= values2[j]);
6575: if (ret)
6576: break;
6577: }
6578: if (ret)
6579: break;
6580: init = 1;
6581: }
6582: xmlFree(values2);
6583: xmlXPathFreeObject(arg1);
6584: xmlXPathFreeObject(arg2);
6585: return(ret);
6586: }
6587:
6588: /**
6589: * xmlXPathCompareNodeSetValue:
6590: * @ctxt: the XPath Parser context
6591: * @inf: less than (1) or greater than (0)
6592: * @strict: is the comparison strict
6593: * @arg: the node set
6594: * @val: the value
6595: *
6596: * Implement the compare operation between a nodeset and a value
6597: * @ns < @val (1, 1, ...
6598: * @ns <= @val (1, 0, ...
6599: * @ns > @val (0, 1, ...
6600: * @ns >= @val (0, 0, ...
6601: *
6602: * If one object to be compared is a node-set and the other is a boolean,
6603: * then the comparison will be true if and only if the result of performing
6604: * the comparison on the boolean and on the result of converting
6605: * the node-set to a boolean using the boolean function is true.
6606: *
6607: * Returns 0 or 1 depending on the results of the test.
6608: */
6609: static int
6610: xmlXPathCompareNodeSetValue(xmlXPathParserContextPtr ctxt, int inf, int strict,
6611: xmlXPathObjectPtr arg, xmlXPathObjectPtr val) {
6612: if ((val == NULL) || (arg == NULL) ||
6613: ((arg->type != XPATH_NODESET) && (arg->type != XPATH_XSLT_TREE)))
6614: return(0);
6615:
6616: switch(val->type) {
6617: case XPATH_NUMBER:
6618: return(xmlXPathCompareNodeSetFloat(ctxt, inf, strict, arg, val));
6619: case XPATH_NODESET:
6620: case XPATH_XSLT_TREE:
6621: return(xmlXPathCompareNodeSets(inf, strict, arg, val));
6622: case XPATH_STRING:
6623: return(xmlXPathCompareNodeSetString(ctxt, inf, strict, arg, val));
6624: case XPATH_BOOLEAN:
6625: valuePush(ctxt, arg);
6626: xmlXPathBooleanFunction(ctxt, 1);
6627: valuePush(ctxt, val);
6628: return(xmlXPathCompareValues(ctxt, inf, strict));
6629: default:
6630: TODO
6631: }
6632: return(0);
6633: }
6634:
6635: /**
6636: * xmlXPathEqualNodeSetString:
6637: * @arg: the nodeset object argument
6638: * @str: the string to compare to.
6639: * @neq: flag to show whether for '=' (0) or '!=' (1)
6640: *
6641: * Implement the equal operation on XPath objects content: @arg1 == @arg2
6642: * If one object to be compared is a node-set and the other is a string,
6643: * then the comparison will be true if and only if there is a node in
6644: * the node-set such that the result of performing the comparison on the
6645: * string-value of the node and the other string is true.
6646: *
6647: * Returns 0 or 1 depending on the results of the test.
6648: */
6649: static int
6650: xmlXPathEqualNodeSetString(xmlXPathObjectPtr arg, const xmlChar * str, int neq)
6651: {
6652: int i;
6653: xmlNodeSetPtr ns;
6654: xmlChar *str2;
6655: unsigned int hash;
6656:
6657: if ((str == NULL) || (arg == NULL) ||
6658: ((arg->type != XPATH_NODESET) && (arg->type != XPATH_XSLT_TREE)))
6659: return (0);
6660: ns = arg->nodesetval;
6661: /*
6662: * A NULL nodeset compared with a string is always false
6663: * (since there is no node equal, and no node not equal)
6664: */
6665: if ((ns == NULL) || (ns->nodeNr <= 0) )
6666: return (0);
6667: hash = xmlXPathStringHash(str);
6668: for (i = 0; i < ns->nodeNr; i++) {
6669: if (xmlXPathNodeValHash(ns->nodeTab[i]) == hash) {
6670: str2 = xmlNodeGetContent(ns->nodeTab[i]);
6671: if ((str2 != NULL) && (xmlStrEqual(str, str2))) {
6672: xmlFree(str2);
6673: if (neq)
6674: continue;
6675: return (1);
6676: } else if ((str2 == NULL) && (xmlStrEqual(str, BAD_CAST ""))) {
6677: if (neq)
6678: continue;
6679: return (1);
6680: } else if (neq) {
6681: if (str2 != NULL)
6682: xmlFree(str2);
6683: return (1);
6684: }
6685: if (str2 != NULL)
6686: xmlFree(str2);
6687: } else if (neq)
6688: return (1);
6689: }
6690: return (0);
6691: }
6692:
6693: /**
6694: * xmlXPathEqualNodeSetFloat:
6695: * @arg: the nodeset object argument
6696: * @f: the float to compare to
6697: * @neq: flag to show whether to compare '=' (0) or '!=' (1)
6698: *
6699: * Implement the equal operation on XPath objects content: @arg1 == @arg2
6700: * If one object to be compared is a node-set and the other is a number,
6701: * then the comparison will be true if and only if there is a node in
6702: * the node-set such that the result of performing the comparison on the
6703: * number to be compared and on the result of converting the string-value
6704: * of that node to a number using the number function is true.
6705: *
6706: * Returns 0 or 1 depending on the results of the test.
6707: */
6708: static int
6709: xmlXPathEqualNodeSetFloat(xmlXPathParserContextPtr ctxt,
6710: xmlXPathObjectPtr arg, double f, int neq) {
6711: int i, ret=0;
6712: xmlNodeSetPtr ns;
6713: xmlChar *str2;
6714: xmlXPathObjectPtr val;
6715: double v;
6716:
6717: if ((arg == NULL) ||
6718: ((arg->type != XPATH_NODESET) && (arg->type != XPATH_XSLT_TREE)))
6719: return(0);
6720:
6721: ns = arg->nodesetval;
6722: if (ns != NULL) {
6723: for (i=0;i<ns->nodeNr;i++) {
6724: str2 = xmlXPathCastNodeToString(ns->nodeTab[i]);
6725: if (str2 != NULL) {
6726: valuePush(ctxt, xmlXPathCacheNewString(ctxt->context, str2));
6727: xmlFree(str2);
6728: xmlXPathNumberFunction(ctxt, 1);
6729: val = valuePop(ctxt);
6730: v = val->floatval;
6731: xmlXPathReleaseObject(ctxt->context, val);
6732: if (!xmlXPathIsNaN(v)) {
6733: if ((!neq) && (v==f)) {
6734: ret = 1;
6735: break;
6736: } else if ((neq) && (v!=f)) {
6737: ret = 1;
6738: break;
6739: }
6740: } else { /* NaN is unequal to any value */
6741: if (neq)
6742: ret = 1;
6743: }
6744: }
6745: }
6746: }
6747:
6748: return(ret);
6749: }
6750:
6751:
6752: /**
6753: * xmlXPathEqualNodeSets:
6754: * @arg1: first nodeset object argument
6755: * @arg2: second nodeset object argument
6756: * @neq: flag to show whether to test '=' (0) or '!=' (1)
6757: *
6758: * Implement the equal / not equal operation on XPath nodesets:
6759: * @arg1 == @arg2 or @arg1 != @arg2
6760: * If both objects to be compared are node-sets, then the comparison
6761: * will be true if and only if there is a node in the first node-set and
6762: * a node in the second node-set such that the result of performing the
6763: * comparison on the string-values of the two nodes is true.
6764: *
6765: * (needless to say, this is a costly operation)
6766: *
6767: * Returns 0 or 1 depending on the results of the test.
6768: */
6769: static int
6770: xmlXPathEqualNodeSets(xmlXPathObjectPtr arg1, xmlXPathObjectPtr arg2, int neq) {
6771: int i, j;
6772: unsigned int *hashs1;
6773: unsigned int *hashs2;
6774: xmlChar **values1;
6775: xmlChar **values2;
6776: int ret = 0;
6777: xmlNodeSetPtr ns1;
6778: xmlNodeSetPtr ns2;
6779:
6780: if ((arg1 == NULL) ||
6781: ((arg1->type != XPATH_NODESET) && (arg1->type != XPATH_XSLT_TREE)))
6782: return(0);
6783: if ((arg2 == NULL) ||
6784: ((arg2->type != XPATH_NODESET) && (arg2->type != XPATH_XSLT_TREE)))
6785: return(0);
6786:
6787: ns1 = arg1->nodesetval;
6788: ns2 = arg2->nodesetval;
6789:
6790: if ((ns1 == NULL) || (ns1->nodeNr <= 0))
6791: return(0);
6792: if ((ns2 == NULL) || (ns2->nodeNr <= 0))
6793: return(0);
6794:
6795: /*
6796: * for equal, check if there is a node pertaining to both sets
6797: */
6798: if (neq == 0)
6799: for (i = 0;i < ns1->nodeNr;i++)
6800: for (j = 0;j < ns2->nodeNr;j++)
6801: if (ns1->nodeTab[i] == ns2->nodeTab[j])
6802: return(1);
6803:
6804: values1 = (xmlChar **) xmlMalloc(ns1->nodeNr * sizeof(xmlChar *));
6805: if (values1 == NULL) {
6806: xmlXPathErrMemory(NULL, "comparing nodesets\n");
6807: return(0);
6808: }
6809: hashs1 = (unsigned int *) xmlMalloc(ns1->nodeNr * sizeof(unsigned int));
6810: if (hashs1 == NULL) {
6811: xmlXPathErrMemory(NULL, "comparing nodesets\n");
6812: xmlFree(values1);
6813: return(0);
6814: }
6815: memset(values1, 0, ns1->nodeNr * sizeof(xmlChar *));
6816: values2 = (xmlChar **) xmlMalloc(ns2->nodeNr * sizeof(xmlChar *));
6817: if (values2 == NULL) {
6818: xmlXPathErrMemory(NULL, "comparing nodesets\n");
6819: xmlFree(hashs1);
6820: xmlFree(values1);
6821: return(0);
6822: }
6823: hashs2 = (unsigned int *) xmlMalloc(ns2->nodeNr * sizeof(unsigned int));
6824: if (hashs2 == NULL) {
6825: xmlXPathErrMemory(NULL, "comparing nodesets\n");
6826: xmlFree(hashs1);
6827: xmlFree(values1);
6828: xmlFree(values2);
6829: return(0);
6830: }
6831: memset(values2, 0, ns2->nodeNr * sizeof(xmlChar *));
6832: for (i = 0;i < ns1->nodeNr;i++) {
6833: hashs1[i] = xmlXPathNodeValHash(ns1->nodeTab[i]);
6834: for (j = 0;j < ns2->nodeNr;j++) {
6835: if (i == 0)
6836: hashs2[j] = xmlXPathNodeValHash(ns2->nodeTab[j]);
6837: if (hashs1[i] != hashs2[j]) {
6838: if (neq) {
6839: ret = 1;
6840: break;
6841: }
6842: }
6843: else {
6844: if (values1[i] == NULL)
6845: values1[i] = xmlNodeGetContent(ns1->nodeTab[i]);
6846: if (values2[j] == NULL)
6847: values2[j] = xmlNodeGetContent(ns2->nodeTab[j]);
6848: ret = xmlStrEqual(values1[i], values2[j]) ^ neq;
6849: if (ret)
6850: break;
6851: }
6852: }
6853: if (ret)
6854: break;
6855: }
6856: for (i = 0;i < ns1->nodeNr;i++)
6857: if (values1[i] != NULL)
6858: xmlFree(values1[i]);
6859: for (j = 0;j < ns2->nodeNr;j++)
6860: if (values2[j] != NULL)
6861: xmlFree(values2[j]);
6862: xmlFree(values1);
6863: xmlFree(values2);
6864: xmlFree(hashs1);
6865: xmlFree(hashs2);
6866: return(ret);
6867: }
6868:
6869: static int
6870: xmlXPathEqualValuesCommon(xmlXPathParserContextPtr ctxt,
6871: xmlXPathObjectPtr arg1, xmlXPathObjectPtr arg2) {
6872: int ret = 0;
6873: /*
6874: *At this point we are assured neither arg1 nor arg2
6875: *is a nodeset, so we can just pick the appropriate routine.
6876: */
6877: switch (arg1->type) {
6878: case XPATH_UNDEFINED:
6879: #ifdef DEBUG_EXPR
6880: xmlGenericError(xmlGenericErrorContext,
6881: "Equal: undefined\n");
6882: #endif
6883: break;
6884: case XPATH_BOOLEAN:
6885: switch (arg2->type) {
6886: case XPATH_UNDEFINED:
6887: #ifdef DEBUG_EXPR
6888: xmlGenericError(xmlGenericErrorContext,
6889: "Equal: undefined\n");
6890: #endif
6891: break;
6892: case XPATH_BOOLEAN:
6893: #ifdef DEBUG_EXPR
6894: xmlGenericError(xmlGenericErrorContext,
6895: "Equal: %d boolean %d \n",
6896: arg1->boolval, arg2->boolval);
6897: #endif
6898: ret = (arg1->boolval == arg2->boolval);
6899: break;
6900: case XPATH_NUMBER:
6901: ret = (arg1->boolval ==
6902: xmlXPathCastNumberToBoolean(arg2->floatval));
6903: break;
6904: case XPATH_STRING:
6905: if ((arg2->stringval == NULL) ||
6906: (arg2->stringval[0] == 0)) ret = 0;
6907: else
6908: ret = 1;
6909: ret = (arg1->boolval == ret);
6910: break;
6911: case XPATH_USERS:
6912: case XPATH_POINT:
6913: case XPATH_RANGE:
6914: case XPATH_LOCATIONSET:
6915: TODO
6916: break;
6917: case XPATH_NODESET:
6918: case XPATH_XSLT_TREE:
6919: break;
6920: }
6921: break;
6922: case XPATH_NUMBER:
6923: switch (arg2->type) {
6924: case XPATH_UNDEFINED:
6925: #ifdef DEBUG_EXPR
6926: xmlGenericError(xmlGenericErrorContext,
6927: "Equal: undefined\n");
6928: #endif
6929: break;
6930: case XPATH_BOOLEAN:
6931: ret = (arg2->boolval==
6932: xmlXPathCastNumberToBoolean(arg1->floatval));
6933: break;
6934: case XPATH_STRING:
6935: valuePush(ctxt, arg2);
6936: xmlXPathNumberFunction(ctxt, 1);
6937: arg2 = valuePop(ctxt);
6938: /* no break on purpose */
6939: case XPATH_NUMBER:
6940: /* Hand check NaN and Infinity equalities */
6941: if (xmlXPathIsNaN(arg1->floatval) ||
6942: xmlXPathIsNaN(arg2->floatval)) {
6943: ret = 0;
6944: } else if (xmlXPathIsInf(arg1->floatval) == 1) {
6945: if (xmlXPathIsInf(arg2->floatval) == 1)
6946: ret = 1;
6947: else
6948: ret = 0;
6949: } else if (xmlXPathIsInf(arg1->floatval) == -1) {
6950: if (xmlXPathIsInf(arg2->floatval) == -1)
6951: ret = 1;
6952: else
6953: ret = 0;
6954: } else if (xmlXPathIsInf(arg2->floatval) == 1) {
6955: if (xmlXPathIsInf(arg1->floatval) == 1)
6956: ret = 1;
6957: else
6958: ret = 0;
6959: } else if (xmlXPathIsInf(arg2->floatval) == -1) {
6960: if (xmlXPathIsInf(arg1->floatval) == -1)
6961: ret = 1;
6962: else
6963: ret = 0;
6964: } else {
6965: ret = (arg1->floatval == arg2->floatval);
6966: }
6967: break;
6968: case XPATH_USERS:
6969: case XPATH_POINT:
6970: case XPATH_RANGE:
6971: case XPATH_LOCATIONSET:
6972: TODO
6973: break;
6974: case XPATH_NODESET:
6975: case XPATH_XSLT_TREE:
6976: break;
6977: }
6978: break;
6979: case XPATH_STRING:
6980: switch (arg2->type) {
6981: case XPATH_UNDEFINED:
6982: #ifdef DEBUG_EXPR
6983: xmlGenericError(xmlGenericErrorContext,
6984: "Equal: undefined\n");
6985: #endif
6986: break;
6987: case XPATH_BOOLEAN:
6988: if ((arg1->stringval == NULL) ||
6989: (arg1->stringval[0] == 0)) ret = 0;
6990: else
6991: ret = 1;
6992: ret = (arg2->boolval == ret);
6993: break;
6994: case XPATH_STRING:
6995: ret = xmlStrEqual(arg1->stringval, arg2->stringval);
6996: break;
6997: case XPATH_NUMBER:
6998: valuePush(ctxt, arg1);
6999: xmlXPathNumberFunction(ctxt, 1);
7000: arg1 = valuePop(ctxt);
7001: /* Hand check NaN and Infinity equalities */
7002: if (xmlXPathIsNaN(arg1->floatval) ||
7003: xmlXPathIsNaN(arg2->floatval)) {
7004: ret = 0;
7005: } else if (xmlXPathIsInf(arg1->floatval) == 1) {
7006: if (xmlXPathIsInf(arg2->floatval) == 1)
7007: ret = 1;
7008: else
7009: ret = 0;
7010: } else if (xmlXPathIsInf(arg1->floatval) == -1) {
7011: if (xmlXPathIsInf(arg2->floatval) == -1)
7012: ret = 1;
7013: else
7014: ret = 0;
7015: } else if (xmlXPathIsInf(arg2->floatval) == 1) {
7016: if (xmlXPathIsInf(arg1->floatval) == 1)
7017: ret = 1;
7018: else
7019: ret = 0;
7020: } else if (xmlXPathIsInf(arg2->floatval) == -1) {
7021: if (xmlXPathIsInf(arg1->floatval) == -1)
7022: ret = 1;
7023: else
7024: ret = 0;
7025: } else {
7026: ret = (arg1->floatval == arg2->floatval);
7027: }
7028: break;
7029: case XPATH_USERS:
7030: case XPATH_POINT:
7031: case XPATH_RANGE:
7032: case XPATH_LOCATIONSET:
7033: TODO
7034: break;
7035: case XPATH_NODESET:
7036: case XPATH_XSLT_TREE:
7037: break;
7038: }
7039: break;
7040: case XPATH_USERS:
7041: case XPATH_POINT:
7042: case XPATH_RANGE:
7043: case XPATH_LOCATIONSET:
7044: TODO
7045: break;
7046: case XPATH_NODESET:
7047: case XPATH_XSLT_TREE:
7048: break;
7049: }
7050: xmlXPathReleaseObject(ctxt->context, arg1);
7051: xmlXPathReleaseObject(ctxt->context, arg2);
7052: return(ret);
7053: }
7054:
7055: /**
7056: * xmlXPathEqualValues:
7057: * @ctxt: the XPath Parser context
7058: *
7059: * Implement the equal operation on XPath objects content: @arg1 == @arg2
7060: *
7061: * Returns 0 or 1 depending on the results of the test.
7062: */
7063: int
7064: xmlXPathEqualValues(xmlXPathParserContextPtr ctxt) {
7065: xmlXPathObjectPtr arg1, arg2, argtmp;
7066: int ret = 0;
7067:
7068: if ((ctxt == NULL) || (ctxt->context == NULL)) return(0);
7069: arg2 = valuePop(ctxt);
7070: arg1 = valuePop(ctxt);
7071: if ((arg1 == NULL) || (arg2 == NULL)) {
7072: if (arg1 != NULL)
7073: xmlXPathReleaseObject(ctxt->context, arg1);
7074: else
7075: xmlXPathReleaseObject(ctxt->context, arg2);
7076: XP_ERROR0(XPATH_INVALID_OPERAND);
7077: }
7078:
7079: if (arg1 == arg2) {
7080: #ifdef DEBUG_EXPR
7081: xmlGenericError(xmlGenericErrorContext,
7082: "Equal: by pointer\n");
7083: #endif
7084: xmlXPathFreeObject(arg1);
7085: return(1);
7086: }
7087:
7088: /*
7089: *If either argument is a nodeset, it's a 'special case'
7090: */
7091: if ((arg2->type == XPATH_NODESET) || (arg2->type == XPATH_XSLT_TREE) ||
7092: (arg1->type == XPATH_NODESET) || (arg1->type == XPATH_XSLT_TREE)) {
7093: /*
7094: *Hack it to assure arg1 is the nodeset
7095: */
7096: if ((arg1->type != XPATH_NODESET) && (arg1->type != XPATH_XSLT_TREE)) {
7097: argtmp = arg2;
7098: arg2 = arg1;
7099: arg1 = argtmp;
7100: }
7101: switch (arg2->type) {
7102: case XPATH_UNDEFINED:
7103: #ifdef DEBUG_EXPR
7104: xmlGenericError(xmlGenericErrorContext,
7105: "Equal: undefined\n");
7106: #endif
7107: break;
7108: case XPATH_NODESET:
7109: case XPATH_XSLT_TREE:
7110: ret = xmlXPathEqualNodeSets(arg1, arg2, 0);
7111: break;
7112: case XPATH_BOOLEAN:
7113: if ((arg1->nodesetval == NULL) ||
7114: (arg1->nodesetval->nodeNr == 0)) ret = 0;
7115: else
7116: ret = 1;
7117: ret = (ret == arg2->boolval);
7118: break;
7119: case XPATH_NUMBER:
7120: ret = xmlXPathEqualNodeSetFloat(ctxt, arg1, arg2->floatval, 0);
7121: break;
7122: case XPATH_STRING:
7123: ret = xmlXPathEqualNodeSetString(arg1, arg2->stringval, 0);
7124: break;
7125: case XPATH_USERS:
7126: case XPATH_POINT:
7127: case XPATH_RANGE:
7128: case XPATH_LOCATIONSET:
7129: TODO
7130: break;
7131: }
7132: xmlXPathReleaseObject(ctxt->context, arg1);
7133: xmlXPathReleaseObject(ctxt->context, arg2);
7134: return(ret);
7135: }
7136:
7137: return (xmlXPathEqualValuesCommon(ctxt, arg1, arg2));
7138: }
7139:
7140: /**
7141: * xmlXPathNotEqualValues:
7142: * @ctxt: the XPath Parser context
7143: *
7144: * Implement the equal operation on XPath objects content: @arg1 == @arg2
7145: *
7146: * Returns 0 or 1 depending on the results of the test.
7147: */
7148: int
7149: xmlXPathNotEqualValues(xmlXPathParserContextPtr ctxt) {
7150: xmlXPathObjectPtr arg1, arg2, argtmp;
7151: int ret = 0;
7152:
7153: if ((ctxt == NULL) || (ctxt->context == NULL)) return(0);
7154: arg2 = valuePop(ctxt);
7155: arg1 = valuePop(ctxt);
7156: if ((arg1 == NULL) || (arg2 == NULL)) {
7157: if (arg1 != NULL)
7158: xmlXPathReleaseObject(ctxt->context, arg1);
7159: else
7160: xmlXPathReleaseObject(ctxt->context, arg2);
7161: XP_ERROR0(XPATH_INVALID_OPERAND);
7162: }
7163:
7164: if (arg1 == arg2) {
7165: #ifdef DEBUG_EXPR
7166: xmlGenericError(xmlGenericErrorContext,
7167: "NotEqual: by pointer\n");
7168: #endif
7169: xmlXPathReleaseObject(ctxt->context, arg1);
7170: return(0);
7171: }
7172:
7173: /*
7174: *If either argument is a nodeset, it's a 'special case'
7175: */
7176: if ((arg2->type == XPATH_NODESET) || (arg2->type == XPATH_XSLT_TREE) ||
7177: (arg1->type == XPATH_NODESET) || (arg1->type == XPATH_XSLT_TREE)) {
7178: /*
7179: *Hack it to assure arg1 is the nodeset
7180: */
7181: if ((arg1->type != XPATH_NODESET) && (arg1->type != XPATH_XSLT_TREE)) {
7182: argtmp = arg2;
7183: arg2 = arg1;
7184: arg1 = argtmp;
7185: }
7186: switch (arg2->type) {
7187: case XPATH_UNDEFINED:
7188: #ifdef DEBUG_EXPR
7189: xmlGenericError(xmlGenericErrorContext,
7190: "NotEqual: undefined\n");
7191: #endif
7192: break;
7193: case XPATH_NODESET:
7194: case XPATH_XSLT_TREE:
7195: ret = xmlXPathEqualNodeSets(arg1, arg2, 1);
7196: break;
7197: case XPATH_BOOLEAN:
7198: if ((arg1->nodesetval == NULL) ||
7199: (arg1->nodesetval->nodeNr == 0)) ret = 0;
7200: else
7201: ret = 1;
7202: ret = (ret != arg2->boolval);
7203: break;
7204: case XPATH_NUMBER:
7205: ret = xmlXPathEqualNodeSetFloat(ctxt, arg1, arg2->floatval, 1);
7206: break;
7207: case XPATH_STRING:
7208: ret = xmlXPathEqualNodeSetString(arg1, arg2->stringval,1);
7209: break;
7210: case XPATH_USERS:
7211: case XPATH_POINT:
7212: case XPATH_RANGE:
7213: case XPATH_LOCATIONSET:
7214: TODO
7215: break;
7216: }
7217: xmlXPathReleaseObject(ctxt->context, arg1);
7218: xmlXPathReleaseObject(ctxt->context, arg2);
7219: return(ret);
7220: }
7221:
7222: return (!xmlXPathEqualValuesCommon(ctxt, arg1, arg2));
7223: }
7224:
7225: /**
7226: * xmlXPathCompareValues:
7227: * @ctxt: the XPath Parser context
7228: * @inf: less than (1) or greater than (0)
7229: * @strict: is the comparison strict
7230: *
7231: * Implement the compare operation on XPath objects:
7232: * @arg1 < @arg2 (1, 1, ...
7233: * @arg1 <= @arg2 (1, 0, ...
7234: * @arg1 > @arg2 (0, 1, ...
7235: * @arg1 >= @arg2 (0, 0, ...
7236: *
7237: * When neither object to be compared is a node-set and the operator is
7238: * <=, <, >=, >, then the objects are compared by converted both objects
7239: * to numbers and comparing the numbers according to IEEE 754. The <
7240: * comparison will be true if and only if the first number is less than the
7241: * second number. The <= comparison will be true if and only if the first
7242: * number is less than or equal to the second number. The > comparison
7243: * will be true if and only if the first number is greater than the second
7244: * number. The >= comparison will be true if and only if the first number
7245: * is greater than or equal to the second number.
7246: *
7247: * Returns 1 if the comparison succeeded, 0 if it failed
7248: */
7249: int
7250: xmlXPathCompareValues(xmlXPathParserContextPtr ctxt, int inf, int strict) {
7251: int ret = 0, arg1i = 0, arg2i = 0;
7252: xmlXPathObjectPtr arg1, arg2;
7253:
7254: if ((ctxt == NULL) || (ctxt->context == NULL)) return(0);
7255: arg2 = valuePop(ctxt);
7256: arg1 = valuePop(ctxt);
7257: if ((arg1 == NULL) || (arg2 == NULL)) {
7258: if (arg1 != NULL)
7259: xmlXPathReleaseObject(ctxt->context, arg1);
7260: else
7261: xmlXPathReleaseObject(ctxt->context, arg2);
7262: XP_ERROR0(XPATH_INVALID_OPERAND);
7263: }
7264:
7265: if ((arg2->type == XPATH_NODESET) || (arg2->type == XPATH_XSLT_TREE) ||
7266: (arg1->type == XPATH_NODESET) || (arg1->type == XPATH_XSLT_TREE)) {
7267: /*
7268: * If either argument is a XPATH_NODESET or XPATH_XSLT_TREE the two arguments
7269: * are not freed from within this routine; they will be freed from the
7270: * called routine, e.g. xmlXPathCompareNodeSets or xmlXPathCompareNodeSetValue
7271: */
7272: if (((arg2->type == XPATH_NODESET) || (arg2->type == XPATH_XSLT_TREE)) &&
7273: ((arg1->type == XPATH_NODESET) || (arg1->type == XPATH_XSLT_TREE))){
7274: ret = xmlXPathCompareNodeSets(inf, strict, arg1, arg2);
7275: } else {
7276: if ((arg1->type == XPATH_NODESET) || (arg1->type == XPATH_XSLT_TREE)) {
7277: ret = xmlXPathCompareNodeSetValue(ctxt, inf, strict,
7278: arg1, arg2);
7279: } else {
7280: ret = xmlXPathCompareNodeSetValue(ctxt, !inf, strict,
7281: arg2, arg1);
7282: }
7283: }
7284: return(ret);
7285: }
7286:
7287: if (arg1->type != XPATH_NUMBER) {
7288: valuePush(ctxt, arg1);
7289: xmlXPathNumberFunction(ctxt, 1);
7290: arg1 = valuePop(ctxt);
7291: }
7292: if (arg1->type != XPATH_NUMBER) {
7293: xmlXPathFreeObject(arg1);
7294: xmlXPathFreeObject(arg2);
7295: XP_ERROR0(XPATH_INVALID_OPERAND);
7296: }
7297: if (arg2->type != XPATH_NUMBER) {
7298: valuePush(ctxt, arg2);
7299: xmlXPathNumberFunction(ctxt, 1);
7300: arg2 = valuePop(ctxt);
7301: }
7302: if (arg2->type != XPATH_NUMBER) {
7303: xmlXPathReleaseObject(ctxt->context, arg1);
7304: xmlXPathReleaseObject(ctxt->context, arg2);
7305: XP_ERROR0(XPATH_INVALID_OPERAND);
7306: }
7307: /*
7308: * Add tests for infinity and nan
7309: * => feedback on 3.4 for Inf and NaN
7310: */
7311: /* Hand check NaN and Infinity comparisons */
7312: if (xmlXPathIsNaN(arg1->floatval) || xmlXPathIsNaN(arg2->floatval)) {
7313: ret=0;
7314: } else {
7315: arg1i=xmlXPathIsInf(arg1->floatval);
7316: arg2i=xmlXPathIsInf(arg2->floatval);
7317: if (inf && strict) {
7318: if ((arg1i == -1 && arg2i != -1) ||
7319: (arg2i == 1 && arg1i != 1)) {
7320: ret = 1;
7321: } else if (arg1i == 0 && arg2i == 0) {
7322: ret = (arg1->floatval < arg2->floatval);
7323: } else {
7324: ret = 0;
7325: }
7326: }
7327: else if (inf && !strict) {
7328: if (arg1i == -1 || arg2i == 1) {
7329: ret = 1;
7330: } else if (arg1i == 0 && arg2i == 0) {
7331: ret = (arg1->floatval <= arg2->floatval);
7332: } else {
7333: ret = 0;
7334: }
7335: }
7336: else if (!inf && strict) {
7337: if ((arg1i == 1 && arg2i != 1) ||
7338: (arg2i == -1 && arg1i != -1)) {
7339: ret = 1;
7340: } else if (arg1i == 0 && arg2i == 0) {
7341: ret = (arg1->floatval > arg2->floatval);
7342: } else {
7343: ret = 0;
7344: }
7345: }
7346: else if (!inf && !strict) {
7347: if (arg1i == 1 || arg2i == -1) {
7348: ret = 1;
7349: } else if (arg1i == 0 && arg2i == 0) {
7350: ret = (arg1->floatval >= arg2->floatval);
7351: } else {
7352: ret = 0;
7353: }
7354: }
7355: }
7356: xmlXPathReleaseObject(ctxt->context, arg1);
7357: xmlXPathReleaseObject(ctxt->context, arg2);
7358: return(ret);
7359: }
7360:
7361: /**
7362: * xmlXPathValueFlipSign:
7363: * @ctxt: the XPath Parser context
7364: *
7365: * Implement the unary - operation on an XPath object
7366: * The numeric operators convert their operands to numbers as if
7367: * by calling the number function.
7368: */
7369: void
7370: xmlXPathValueFlipSign(xmlXPathParserContextPtr ctxt) {
7371: if ((ctxt == NULL) || (ctxt->context == NULL)) return;
7372: CAST_TO_NUMBER;
7373: CHECK_TYPE(XPATH_NUMBER);
7374: if (xmlXPathIsNaN(ctxt->value->floatval))
7375: ctxt->value->floatval=xmlXPathNAN;
7376: else if (xmlXPathIsInf(ctxt->value->floatval) == 1)
7377: ctxt->value->floatval=xmlXPathNINF;
7378: else if (xmlXPathIsInf(ctxt->value->floatval) == -1)
7379: ctxt->value->floatval=xmlXPathPINF;
7380: else if (ctxt->value->floatval == 0) {
7381: if (xmlXPathGetSign(ctxt->value->floatval) == 0)
7382: ctxt->value->floatval = xmlXPathNZERO;
7383: else
7384: ctxt->value->floatval = 0;
7385: }
7386: else
7387: ctxt->value->floatval = - ctxt->value->floatval;
7388: }
7389:
7390: /**
7391: * xmlXPathAddValues:
7392: * @ctxt: the XPath Parser context
7393: *
7394: * Implement the add operation on XPath objects:
7395: * The numeric operators convert their operands to numbers as if
7396: * by calling the number function.
7397: */
7398: void
7399: xmlXPathAddValues(xmlXPathParserContextPtr ctxt) {
7400: xmlXPathObjectPtr arg;
7401: double val;
7402:
7403: arg = valuePop(ctxt);
7404: if (arg == NULL)
7405: XP_ERROR(XPATH_INVALID_OPERAND);
7406: val = xmlXPathCastToNumber(arg);
7407: xmlXPathReleaseObject(ctxt->context, arg);
7408: CAST_TO_NUMBER;
7409: CHECK_TYPE(XPATH_NUMBER);
7410: ctxt->value->floatval += val;
7411: }
7412:
7413: /**
7414: * xmlXPathSubValues:
7415: * @ctxt: the XPath Parser context
7416: *
7417: * Implement the subtraction operation on XPath objects:
7418: * The numeric operators convert their operands to numbers as if
7419: * by calling the number function.
7420: */
7421: void
7422: xmlXPathSubValues(xmlXPathParserContextPtr ctxt) {
7423: xmlXPathObjectPtr arg;
7424: double val;
7425:
7426: arg = valuePop(ctxt);
7427: if (arg == NULL)
7428: XP_ERROR(XPATH_INVALID_OPERAND);
7429: val = xmlXPathCastToNumber(arg);
7430: xmlXPathReleaseObject(ctxt->context, arg);
7431: CAST_TO_NUMBER;
7432: CHECK_TYPE(XPATH_NUMBER);
7433: ctxt->value->floatval -= val;
7434: }
7435:
7436: /**
7437: * xmlXPathMultValues:
7438: * @ctxt: the XPath Parser context
7439: *
7440: * Implement the multiply operation on XPath objects:
7441: * The numeric operators convert their operands to numbers as if
7442: * by calling the number function.
7443: */
7444: void
7445: xmlXPathMultValues(xmlXPathParserContextPtr ctxt) {
7446: xmlXPathObjectPtr arg;
7447: double val;
7448:
7449: arg = valuePop(ctxt);
7450: if (arg == NULL)
7451: XP_ERROR(XPATH_INVALID_OPERAND);
7452: val = xmlXPathCastToNumber(arg);
7453: xmlXPathReleaseObject(ctxt->context, arg);
7454: CAST_TO_NUMBER;
7455: CHECK_TYPE(XPATH_NUMBER);
7456: ctxt->value->floatval *= val;
7457: }
7458:
7459: /**
7460: * xmlXPathDivValues:
7461: * @ctxt: the XPath Parser context
7462: *
7463: * Implement the div operation on XPath objects @arg1 / @arg2:
7464: * The numeric operators convert their operands to numbers as if
7465: * by calling the number function.
7466: */
7467: void
7468: xmlXPathDivValues(xmlXPathParserContextPtr ctxt) {
7469: xmlXPathObjectPtr arg;
7470: double val;
7471:
7472: arg = valuePop(ctxt);
7473: if (arg == NULL)
7474: XP_ERROR(XPATH_INVALID_OPERAND);
7475: val = xmlXPathCastToNumber(arg);
7476: xmlXPathReleaseObject(ctxt->context, arg);
7477: CAST_TO_NUMBER;
7478: CHECK_TYPE(XPATH_NUMBER);
7479: if (xmlXPathIsNaN(val) || xmlXPathIsNaN(ctxt->value->floatval))
7480: ctxt->value->floatval = xmlXPathNAN;
7481: else if (val == 0 && xmlXPathGetSign(val) != 0) {
7482: if (ctxt->value->floatval == 0)
7483: ctxt->value->floatval = xmlXPathNAN;
7484: else if (ctxt->value->floatval > 0)
7485: ctxt->value->floatval = xmlXPathNINF;
7486: else if (ctxt->value->floatval < 0)
7487: ctxt->value->floatval = xmlXPathPINF;
7488: }
7489: else if (val == 0) {
7490: if (ctxt->value->floatval == 0)
7491: ctxt->value->floatval = xmlXPathNAN;
7492: else if (ctxt->value->floatval > 0)
7493: ctxt->value->floatval = xmlXPathPINF;
7494: else if (ctxt->value->floatval < 0)
7495: ctxt->value->floatval = xmlXPathNINF;
7496: } else
7497: ctxt->value->floatval /= val;
7498: }
7499:
7500: /**
7501: * xmlXPathModValues:
7502: * @ctxt: the XPath Parser context
7503: *
7504: * Implement the mod operation on XPath objects: @arg1 / @arg2
7505: * The numeric operators convert their operands to numbers as if
7506: * by calling the number function.
7507: */
7508: void
7509: xmlXPathModValues(xmlXPathParserContextPtr ctxt) {
7510: xmlXPathObjectPtr arg;
7511: double arg1, arg2;
7512:
7513: arg = valuePop(ctxt);
7514: if (arg == NULL)
7515: XP_ERROR(XPATH_INVALID_OPERAND);
7516: arg2 = xmlXPathCastToNumber(arg);
7517: xmlXPathReleaseObject(ctxt->context, arg);
7518: CAST_TO_NUMBER;
7519: CHECK_TYPE(XPATH_NUMBER);
7520: arg1 = ctxt->value->floatval;
7521: if (arg2 == 0)
7522: ctxt->value->floatval = xmlXPathNAN;
7523: else {
7524: ctxt->value->floatval = fmod(arg1, arg2);
7525: }
7526: }
7527:
7528: /************************************************************************
7529: * *
7530: * The traversal functions *
7531: * *
7532: ************************************************************************/
7533:
7534: /*
7535: * A traversal function enumerates nodes along an axis.
7536: * Initially it must be called with NULL, and it indicates
7537: * termination on the axis by returning NULL.
7538: */
7539: typedef xmlNodePtr (*xmlXPathTraversalFunction)
7540: (xmlXPathParserContextPtr ctxt, xmlNodePtr cur);
7541:
7542: /*
7543: * xmlXPathTraversalFunctionExt:
7544: * A traversal function enumerates nodes along an axis.
7545: * Initially it must be called with NULL, and it indicates
7546: * termination on the axis by returning NULL.
7547: * The context node of the traversal is specified via @contextNode.
7548: */
7549: typedef xmlNodePtr (*xmlXPathTraversalFunctionExt)
7550: (xmlNodePtr cur, xmlNodePtr contextNode);
7551:
7552: /*
7553: * xmlXPathNodeSetMergeFunction:
7554: * Used for merging node sets in xmlXPathCollectAndTest().
7555: */
7556: typedef xmlNodeSetPtr (*xmlXPathNodeSetMergeFunction)
7557: (xmlNodeSetPtr, xmlNodeSetPtr, int);
7558:
7559:
7560: /**
7561: * xmlXPathNextSelf:
7562: * @ctxt: the XPath Parser context
7563: * @cur: the current node in the traversal
7564: *
7565: * Traversal function for the "self" direction
7566: * The self axis contains just the context node itself
7567: *
7568: * Returns the next element following that axis
7569: */
7570: xmlNodePtr
7571: xmlXPathNextSelf(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
7572: if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
7573: if (cur == NULL)
7574: return(ctxt->context->node);
7575: return(NULL);
7576: }
7577:
7578: /**
7579: * xmlXPathNextChild:
7580: * @ctxt: the XPath Parser context
7581: * @cur: the current node in the traversal
7582: *
7583: * Traversal function for the "child" direction
7584: * The child axis contains the children of the context node in document order.
7585: *
7586: * Returns the next element following that axis
7587: */
7588: xmlNodePtr
7589: xmlXPathNextChild(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
7590: if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
7591: if (cur == NULL) {
7592: if (ctxt->context->node == NULL) return(NULL);
7593: switch (ctxt->context->node->type) {
7594: case XML_ELEMENT_NODE:
7595: case XML_TEXT_NODE:
7596: case XML_CDATA_SECTION_NODE:
7597: case XML_ENTITY_REF_NODE:
7598: case XML_ENTITY_NODE:
7599: case XML_PI_NODE:
7600: case XML_COMMENT_NODE:
7601: case XML_NOTATION_NODE:
7602: case XML_DTD_NODE:
7603: return(ctxt->context->node->children);
7604: case XML_DOCUMENT_NODE:
7605: case XML_DOCUMENT_TYPE_NODE:
7606: case XML_DOCUMENT_FRAG_NODE:
7607: case XML_HTML_DOCUMENT_NODE:
7608: #ifdef LIBXML_DOCB_ENABLED
7609: case XML_DOCB_DOCUMENT_NODE:
7610: #endif
7611: return(((xmlDocPtr) ctxt->context->node)->children);
7612: case XML_ELEMENT_DECL:
7613: case XML_ATTRIBUTE_DECL:
7614: case XML_ENTITY_DECL:
7615: case XML_ATTRIBUTE_NODE:
7616: case XML_NAMESPACE_DECL:
7617: case XML_XINCLUDE_START:
7618: case XML_XINCLUDE_END:
7619: return(NULL);
7620: }
7621: return(NULL);
7622: }
7623: if ((cur->type == XML_DOCUMENT_NODE) ||
7624: (cur->type == XML_HTML_DOCUMENT_NODE))
7625: return(NULL);
7626: return(cur->next);
7627: }
7628:
7629: /**
7630: * xmlXPathNextChildElement:
7631: * @ctxt: the XPath Parser context
7632: * @cur: the current node in the traversal
7633: *
7634: * Traversal function for the "child" direction and nodes of type element.
7635: * The child axis contains the children of the context node in document order.
7636: *
7637: * Returns the next element following that axis
7638: */
7639: static xmlNodePtr
7640: xmlXPathNextChildElement(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
7641: if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
7642: if (cur == NULL) {
7643: cur = ctxt->context->node;
7644: if (cur == NULL) return(NULL);
7645: /*
7646: * Get the first element child.
7647: */
7648: switch (cur->type) {
7649: case XML_ELEMENT_NODE:
7650: case XML_DOCUMENT_FRAG_NODE:
7651: case XML_ENTITY_REF_NODE: /* URGENT TODO: entify-refs as well? */
7652: case XML_ENTITY_NODE:
7653: cur = cur->children;
7654: if (cur != NULL) {
7655: if (cur->type == XML_ELEMENT_NODE)
7656: return(cur);
7657: do {
7658: cur = cur->next;
7659: } while ((cur != NULL) &&
7660: (cur->type != XML_ELEMENT_NODE));
7661: return(cur);
7662: }
7663: return(NULL);
7664: case XML_DOCUMENT_NODE:
7665: case XML_HTML_DOCUMENT_NODE:
7666: #ifdef LIBXML_DOCB_ENABLED
7667: case XML_DOCB_DOCUMENT_NODE:
7668: #endif
7669: return(xmlDocGetRootElement((xmlDocPtr) cur));
7670: default:
7671: return(NULL);
7672: }
7673: return(NULL);
7674: }
7675: /*
7676: * Get the next sibling element node.
7677: */
7678: switch (cur->type) {
7679: case XML_ELEMENT_NODE:
7680: case XML_TEXT_NODE:
7681: case XML_ENTITY_REF_NODE:
7682: case XML_ENTITY_NODE:
7683: case XML_CDATA_SECTION_NODE:
7684: case XML_PI_NODE:
7685: case XML_COMMENT_NODE:
7686: case XML_XINCLUDE_END:
7687: break;
7688: /* case XML_DTD_NODE: */ /* URGENT TODO: DTD-node as well? */
7689: default:
7690: return(NULL);
7691: }
7692: if (cur->next != NULL) {
7693: if (cur->next->type == XML_ELEMENT_NODE)
7694: return(cur->next);
7695: cur = cur->next;
7696: do {
7697: cur = cur->next;
7698: } while ((cur != NULL) && (cur->type != XML_ELEMENT_NODE));
7699: return(cur);
7700: }
7701: return(NULL);
7702: }
7703:
7704: /**
7705: * xmlXPathNextDescendantOrSelfElemParent:
7706: * @ctxt: the XPath Parser context
7707: * @cur: the current node in the traversal
7708: *
7709: * Traversal function for the "descendant-or-self" axis.
7710: * Additionally it returns only nodes which can be parents of
7711: * element nodes.
7712: *
7713: *
7714: * Returns the next element following that axis
7715: */
7716: static xmlNodePtr
7717: xmlXPathNextDescendantOrSelfElemParent(xmlNodePtr cur,
7718: xmlNodePtr contextNode)
7719: {
7720: if (cur == NULL) {
7721: if (contextNode == NULL)
7722: return(NULL);
7723: switch (contextNode->type) {
7724: case XML_ELEMENT_NODE:
7725: case XML_XINCLUDE_START:
7726: case XML_DOCUMENT_FRAG_NODE:
7727: case XML_DOCUMENT_NODE:
7728: #ifdef LIBXML_DOCB_ENABLED
7729: case XML_DOCB_DOCUMENT_NODE:
7730: #endif
7731: case XML_HTML_DOCUMENT_NODE:
7732: return(contextNode);
7733: default:
7734: return(NULL);
7735: }
7736: return(NULL);
7737: } else {
7738: xmlNodePtr start = cur;
7739:
7740: while (cur != NULL) {
7741: switch (cur->type) {
7742: case XML_ELEMENT_NODE:
7743: /* TODO: OK to have XInclude here? */
7744: case XML_XINCLUDE_START:
7745: case XML_DOCUMENT_FRAG_NODE:
7746: if (cur != start)
7747: return(cur);
7748: if (cur->children != NULL) {
7749: cur = cur->children;
7750: continue;
7751: }
7752: break;
7753: /* Not sure if we need those here. */
7754: case XML_DOCUMENT_NODE:
7755: #ifdef LIBXML_DOCB_ENABLED
7756: case XML_DOCB_DOCUMENT_NODE:
7757: #endif
7758: case XML_HTML_DOCUMENT_NODE:
7759: if (cur != start)
7760: return(cur);
7761: return(xmlDocGetRootElement((xmlDocPtr) cur));
7762: default:
7763: break;
7764: }
7765:
7766: next_sibling:
7767: if ((cur == NULL) || (cur == contextNode))
7768: return(NULL);
7769: if (cur->next != NULL) {
7770: cur = cur->next;
7771: } else {
7772: cur = cur->parent;
7773: goto next_sibling;
7774: }
7775: }
7776: }
7777: return(NULL);
7778: }
7779:
7780: /**
7781: * xmlXPathNextDescendant:
7782: * @ctxt: the XPath Parser context
7783: * @cur: the current node in the traversal
7784: *
7785: * Traversal function for the "descendant" direction
7786: * the descendant axis contains the descendants of the context node in document
7787: * order; a descendant is a child or a child of a child and so on.
7788: *
7789: * Returns the next element following that axis
7790: */
7791: xmlNodePtr
7792: xmlXPathNextDescendant(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
7793: if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
7794: if (cur == NULL) {
7795: if (ctxt->context->node == NULL)
7796: return(NULL);
7797: if ((ctxt->context->node->type == XML_ATTRIBUTE_NODE) ||
7798: (ctxt->context->node->type == XML_NAMESPACE_DECL))
7799: return(NULL);
7800:
7801: if (ctxt->context->node == (xmlNodePtr) ctxt->context->doc)
7802: return(ctxt->context->doc->children);
7803: return(ctxt->context->node->children);
7804: }
7805:
7806: if (cur->children != NULL) {
7807: /*
7808: * Do not descend on entities declarations
7809: */
7810: if (cur->children->type != XML_ENTITY_DECL) {
7811: cur = cur->children;
7812: /*
7813: * Skip DTDs
7814: */
7815: if (cur->type != XML_DTD_NODE)
7816: return(cur);
7817: }
7818: }
7819:
7820: if (cur == ctxt->context->node) return(NULL);
7821:
7822: while (cur->next != NULL) {
7823: cur = cur->next;
7824: if ((cur->type != XML_ENTITY_DECL) &&
7825: (cur->type != XML_DTD_NODE))
7826: return(cur);
7827: }
7828:
7829: do {
7830: cur = cur->parent;
7831: if (cur == NULL) break;
7832: if (cur == ctxt->context->node) return(NULL);
7833: if (cur->next != NULL) {
7834: cur = cur->next;
7835: return(cur);
7836: }
7837: } while (cur != NULL);
7838: return(cur);
7839: }
7840:
7841: /**
7842: * xmlXPathNextDescendantOrSelf:
7843: * @ctxt: the XPath Parser context
7844: * @cur: the current node in the traversal
7845: *
7846: * Traversal function for the "descendant-or-self" direction
7847: * the descendant-or-self axis contains the context node and the descendants
7848: * of the context node in document order; thus the context node is the first
7849: * node on the axis, and the first child of the context node is the second node
7850: * on the axis
7851: *
7852: * Returns the next element following that axis
7853: */
7854: xmlNodePtr
7855: xmlXPathNextDescendantOrSelf(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
7856: if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
7857: if (cur == NULL) {
7858: if (ctxt->context->node == NULL)
7859: return(NULL);
7860: if ((ctxt->context->node->type == XML_ATTRIBUTE_NODE) ||
7861: (ctxt->context->node->type == XML_NAMESPACE_DECL))
7862: return(NULL);
7863: return(ctxt->context->node);
7864: }
7865:
7866: return(xmlXPathNextDescendant(ctxt, cur));
7867: }
7868:
7869: /**
7870: * xmlXPathNextParent:
7871: * @ctxt: the XPath Parser context
7872: * @cur: the current node in the traversal
7873: *
7874: * Traversal function for the "parent" direction
7875: * The parent axis contains the parent of the context node, if there is one.
7876: *
7877: * Returns the next element following that axis
7878: */
7879: xmlNodePtr
7880: xmlXPathNextParent(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
7881: if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
7882: /*
7883: * the parent of an attribute or namespace node is the element
7884: * to which the attribute or namespace node is attached
7885: * Namespace handling !!!
7886: */
7887: if (cur == NULL) {
7888: if (ctxt->context->node == NULL) return(NULL);
7889: switch (ctxt->context->node->type) {
7890: case XML_ELEMENT_NODE:
7891: case XML_TEXT_NODE:
7892: case XML_CDATA_SECTION_NODE:
7893: case XML_ENTITY_REF_NODE:
7894: case XML_ENTITY_NODE:
7895: case XML_PI_NODE:
7896: case XML_COMMENT_NODE:
7897: case XML_NOTATION_NODE:
7898: case XML_DTD_NODE:
7899: case XML_ELEMENT_DECL:
7900: case XML_ATTRIBUTE_DECL:
7901: case XML_XINCLUDE_START:
7902: case XML_XINCLUDE_END:
7903: case XML_ENTITY_DECL:
7904: if (ctxt->context->node->parent == NULL)
7905: return((xmlNodePtr) ctxt->context->doc);
7906: if ((ctxt->context->node->parent->type == XML_ELEMENT_NODE) &&
7907: ((ctxt->context->node->parent->name[0] == ' ') ||
7908: (xmlStrEqual(ctxt->context->node->parent->name,
7909: BAD_CAST "fake node libxslt"))))
7910: return(NULL);
7911: return(ctxt->context->node->parent);
7912: case XML_ATTRIBUTE_NODE: {
7913: xmlAttrPtr att = (xmlAttrPtr) ctxt->context->node;
7914:
7915: return(att->parent);
7916: }
7917: case XML_DOCUMENT_NODE:
7918: case XML_DOCUMENT_TYPE_NODE:
7919: case XML_DOCUMENT_FRAG_NODE:
7920: case XML_HTML_DOCUMENT_NODE:
7921: #ifdef LIBXML_DOCB_ENABLED
7922: case XML_DOCB_DOCUMENT_NODE:
7923: #endif
7924: return(NULL);
7925: case XML_NAMESPACE_DECL: {
7926: xmlNsPtr ns = (xmlNsPtr) ctxt->context->node;
7927:
7928: if ((ns->next != NULL) &&
7929: (ns->next->type != XML_NAMESPACE_DECL))
7930: return((xmlNodePtr) ns->next);
7931: return(NULL);
7932: }
7933: }
7934: }
7935: return(NULL);
7936: }
7937:
7938: /**
7939: * xmlXPathNextAncestor:
7940: * @ctxt: the XPath Parser context
7941: * @cur: the current node in the traversal
7942: *
7943: * Traversal function for the "ancestor" direction
7944: * the ancestor axis contains the ancestors of the context node; the ancestors
7945: * of the context node consist of the parent of context node and the parent's
7946: * parent and so on; the nodes are ordered in reverse document order; thus the
7947: * parent is the first node on the axis, and the parent's parent is the second
7948: * node on the axis
7949: *
7950: * Returns the next element following that axis
7951: */
7952: xmlNodePtr
7953: xmlXPathNextAncestor(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
7954: if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
7955: /*
7956: * the parent of an attribute or namespace node is the element
7957: * to which the attribute or namespace node is attached
7958: * !!!!!!!!!!!!!
7959: */
7960: if (cur == NULL) {
7961: if (ctxt->context->node == NULL) return(NULL);
7962: switch (ctxt->context->node->type) {
7963: case XML_ELEMENT_NODE:
7964: case XML_TEXT_NODE:
7965: case XML_CDATA_SECTION_NODE:
7966: case XML_ENTITY_REF_NODE:
7967: case XML_ENTITY_NODE:
7968: case XML_PI_NODE:
7969: case XML_COMMENT_NODE:
7970: case XML_DTD_NODE:
7971: case XML_ELEMENT_DECL:
7972: case XML_ATTRIBUTE_DECL:
7973: case XML_ENTITY_DECL:
7974: case XML_NOTATION_NODE:
7975: case XML_XINCLUDE_START:
7976: case XML_XINCLUDE_END:
7977: if (ctxt->context->node->parent == NULL)
7978: return((xmlNodePtr) ctxt->context->doc);
7979: if ((ctxt->context->node->parent->type == XML_ELEMENT_NODE) &&
7980: ((ctxt->context->node->parent->name[0] == ' ') ||
7981: (xmlStrEqual(ctxt->context->node->parent->name,
7982: BAD_CAST "fake node libxslt"))))
7983: return(NULL);
7984: return(ctxt->context->node->parent);
7985: case XML_ATTRIBUTE_NODE: {
7986: xmlAttrPtr tmp = (xmlAttrPtr) ctxt->context->node;
7987:
7988: return(tmp->parent);
7989: }
7990: case XML_DOCUMENT_NODE:
7991: case XML_DOCUMENT_TYPE_NODE:
7992: case XML_DOCUMENT_FRAG_NODE:
7993: case XML_HTML_DOCUMENT_NODE:
7994: #ifdef LIBXML_DOCB_ENABLED
7995: case XML_DOCB_DOCUMENT_NODE:
7996: #endif
7997: return(NULL);
7998: case XML_NAMESPACE_DECL: {
7999: xmlNsPtr ns = (xmlNsPtr) ctxt->context->node;
8000:
8001: if ((ns->next != NULL) &&
8002: (ns->next->type != XML_NAMESPACE_DECL))
8003: return((xmlNodePtr) ns->next);
8004: /* Bad, how did that namespace end up here ? */
8005: return(NULL);
8006: }
8007: }
8008: return(NULL);
8009: }
8010: if (cur == ctxt->context->doc->children)
8011: return((xmlNodePtr) ctxt->context->doc);
8012: if (cur == (xmlNodePtr) ctxt->context->doc)
8013: return(NULL);
8014: switch (cur->type) {
8015: case XML_ELEMENT_NODE:
8016: case XML_TEXT_NODE:
8017: case XML_CDATA_SECTION_NODE:
8018: case XML_ENTITY_REF_NODE:
8019: case XML_ENTITY_NODE:
8020: case XML_PI_NODE:
8021: case XML_COMMENT_NODE:
8022: case XML_NOTATION_NODE:
8023: case XML_DTD_NODE:
8024: case XML_ELEMENT_DECL:
8025: case XML_ATTRIBUTE_DECL:
8026: case XML_ENTITY_DECL:
8027: case XML_XINCLUDE_START:
8028: case XML_XINCLUDE_END:
8029: if (cur->parent == NULL)
8030: return(NULL);
8031: if ((cur->parent->type == XML_ELEMENT_NODE) &&
8032: ((cur->parent->name[0] == ' ') ||
8033: (xmlStrEqual(cur->parent->name,
8034: BAD_CAST "fake node libxslt"))))
8035: return(NULL);
8036: return(cur->parent);
8037: case XML_ATTRIBUTE_NODE: {
8038: xmlAttrPtr att = (xmlAttrPtr) ctxt->context->node;
8039:
8040: return(att->parent);
8041: }
8042: case XML_NAMESPACE_DECL: {
8043: xmlNsPtr ns = (xmlNsPtr) ctxt->context->node;
8044:
8045: if ((ns->next != NULL) &&
8046: (ns->next->type != XML_NAMESPACE_DECL))
8047: return((xmlNodePtr) ns->next);
8048: /* Bad, how did that namespace end up here ? */
8049: return(NULL);
8050: }
8051: case XML_DOCUMENT_NODE:
8052: case XML_DOCUMENT_TYPE_NODE:
8053: case XML_DOCUMENT_FRAG_NODE:
8054: case XML_HTML_DOCUMENT_NODE:
8055: #ifdef LIBXML_DOCB_ENABLED
8056: case XML_DOCB_DOCUMENT_NODE:
8057: #endif
8058: return(NULL);
8059: }
8060: return(NULL);
8061: }
8062:
8063: /**
8064: * xmlXPathNextAncestorOrSelf:
8065: * @ctxt: the XPath Parser context
8066: * @cur: the current node in the traversal
8067: *
8068: * Traversal function for the "ancestor-or-self" direction
8069: * he ancestor-or-self axis contains the context node and ancestors of
8070: * the context node in reverse document order; thus the context node is
8071: * the first node on the axis, and the context node's parent the second;
8072: * parent here is defined the same as with the parent axis.
8073: *
8074: * Returns the next element following that axis
8075: */
8076: xmlNodePtr
8077: xmlXPathNextAncestorOrSelf(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
8078: if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
8079: if (cur == NULL)
8080: return(ctxt->context->node);
8081: return(xmlXPathNextAncestor(ctxt, cur));
8082: }
8083:
8084: /**
8085: * xmlXPathNextFollowingSibling:
8086: * @ctxt: the XPath Parser context
8087: * @cur: the current node in the traversal
8088: *
8089: * Traversal function for the "following-sibling" direction
8090: * The following-sibling axis contains the following siblings of the context
8091: * node in document order.
8092: *
8093: * Returns the next element following that axis
8094: */
8095: xmlNodePtr
8096: xmlXPathNextFollowingSibling(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
8097: if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
8098: if ((ctxt->context->node->type == XML_ATTRIBUTE_NODE) ||
8099: (ctxt->context->node->type == XML_NAMESPACE_DECL))
8100: return(NULL);
8101: if (cur == (xmlNodePtr) ctxt->context->doc)
8102: return(NULL);
8103: if (cur == NULL)
8104: return(ctxt->context->node->next);
8105: return(cur->next);
8106: }
8107:
8108: /**
8109: * xmlXPathNextPrecedingSibling:
8110: * @ctxt: the XPath Parser context
8111: * @cur: the current node in the traversal
8112: *
8113: * Traversal function for the "preceding-sibling" direction
8114: * The preceding-sibling axis contains the preceding siblings of the context
8115: * node in reverse document order; the first preceding sibling is first on the
8116: * axis; the sibling preceding that node is the second on the axis and so on.
8117: *
8118: * Returns the next element following that axis
8119: */
8120: xmlNodePtr
8121: xmlXPathNextPrecedingSibling(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
8122: if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
8123: if ((ctxt->context->node->type == XML_ATTRIBUTE_NODE) ||
8124: (ctxt->context->node->type == XML_NAMESPACE_DECL))
8125: return(NULL);
8126: if (cur == (xmlNodePtr) ctxt->context->doc)
8127: return(NULL);
8128: if (cur == NULL)
8129: return(ctxt->context->node->prev);
8130: if ((cur->prev != NULL) && (cur->prev->type == XML_DTD_NODE)) {
8131: cur = cur->prev;
8132: if (cur == NULL)
8133: return(ctxt->context->node->prev);
8134: }
8135: return(cur->prev);
8136: }
8137:
8138: /**
8139: * xmlXPathNextFollowing:
8140: * @ctxt: the XPath Parser context
8141: * @cur: the current node in the traversal
8142: *
8143: * Traversal function for the "following" direction
8144: * The following axis contains all nodes in the same document as the context
8145: * node that are after the context node in document order, excluding any
8146: * descendants and excluding attribute nodes and namespace nodes; the nodes
8147: * are ordered in document order
8148: *
8149: * Returns the next element following that axis
8150: */
8151: xmlNodePtr
8152: xmlXPathNextFollowing(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
8153: if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
8154: if ((cur != NULL) && (cur->type != XML_ATTRIBUTE_NODE) &&
8155: (cur->type != XML_NAMESPACE_DECL) && (cur->children != NULL))
8156: return(cur->children);
8157:
8158: if (cur == NULL) {
8159: cur = ctxt->context->node;
8160: if (cur->type == XML_NAMESPACE_DECL)
8161: return(NULL);
8162: if (cur->type == XML_ATTRIBUTE_NODE)
8163: cur = cur->parent;
8164: }
8165: if (cur == NULL) return(NULL) ; /* ERROR */
8166: if (cur->next != NULL) return(cur->next) ;
8167: do {
8168: cur = cur->parent;
8169: if (cur == NULL) break;
8170: if (cur == (xmlNodePtr) ctxt->context->doc) return(NULL);
8171: if (cur->next != NULL) return(cur->next);
8172: } while (cur != NULL);
8173: return(cur);
8174: }
8175:
8176: /*
8177: * xmlXPathIsAncestor:
8178: * @ancestor: the ancestor node
8179: * @node: the current node
8180: *
8181: * Check that @ancestor is a @node's ancestor
8182: *
8183: * returns 1 if @ancestor is a @node's ancestor, 0 otherwise.
8184: */
8185: static int
8186: xmlXPathIsAncestor(xmlNodePtr ancestor, xmlNodePtr node) {
8187: if ((ancestor == NULL) || (node == NULL)) return(0);
8188: /* nodes need to be in the same document */
8189: if (ancestor->doc != node->doc) return(0);
8190: /* avoid searching if ancestor or node is the root node */
8191: if (ancestor == (xmlNodePtr) node->doc) return(1);
8192: if (node == (xmlNodePtr) ancestor->doc) return(0);
8193: while (node->parent != NULL) {
8194: if (node->parent == ancestor)
8195: return(1);
8196: node = node->parent;
8197: }
8198: return(0);
8199: }
8200:
8201: /**
8202: * xmlXPathNextPreceding:
8203: * @ctxt: the XPath Parser context
8204: * @cur: the current node in the traversal
8205: *
8206: * Traversal function for the "preceding" direction
8207: * the preceding axis contains all nodes in the same document as the context
8208: * node that are before the context node in document order, excluding any
8209: * ancestors and excluding attribute nodes and namespace nodes; the nodes are
8210: * ordered in reverse document order
8211: *
8212: * Returns the next element following that axis
8213: */
8214: xmlNodePtr
8215: xmlXPathNextPreceding(xmlXPathParserContextPtr ctxt, xmlNodePtr cur)
8216: {
8217: if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
8218: if (cur == NULL) {
8219: cur = ctxt->context->node;
8220: if (cur->type == XML_NAMESPACE_DECL)
8221: return(NULL);
8222: if (cur->type == XML_ATTRIBUTE_NODE)
8223: return(cur->parent);
8224: }
8225: if (cur == NULL)
8226: return (NULL);
8227: if ((cur->prev != NULL) && (cur->prev->type == XML_DTD_NODE))
8228: cur = cur->prev;
8229: do {
8230: if (cur->prev != NULL) {
8231: for (cur = cur->prev; cur->last != NULL; cur = cur->last) ;
8232: return (cur);
8233: }
8234:
8235: cur = cur->parent;
8236: if (cur == NULL)
8237: return (NULL);
8238: if (cur == ctxt->context->doc->children)
8239: return (NULL);
8240: } while (xmlXPathIsAncestor(cur, ctxt->context->node));
8241: return (cur);
8242: }
8243:
8244: /**
8245: * xmlXPathNextPrecedingInternal:
8246: * @ctxt: the XPath Parser context
8247: * @cur: the current node in the traversal
8248: *
8249: * Traversal function for the "preceding" direction
8250: * the preceding axis contains all nodes in the same document as the context
8251: * node that are before the context node in document order, excluding any
8252: * ancestors and excluding attribute nodes and namespace nodes; the nodes are
8253: * ordered in reverse document order
8254: * This is a faster implementation but internal only since it requires a
8255: * state kept in the parser context: ctxt->ancestor.
8256: *
8257: * Returns the next element following that axis
8258: */
8259: static xmlNodePtr
8260: xmlXPathNextPrecedingInternal(xmlXPathParserContextPtr ctxt,
8261: xmlNodePtr cur)
8262: {
8263: if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
8264: if (cur == NULL) {
8265: cur = ctxt->context->node;
8266: if (cur == NULL)
8267: return (NULL);
8268: if (cur->type == XML_NAMESPACE_DECL)
8269: return (NULL);
8270: ctxt->ancestor = cur->parent;
8271: }
8272: if ((cur->prev != NULL) && (cur->prev->type == XML_DTD_NODE))
8273: cur = cur->prev;
8274: while (cur->prev == NULL) {
8275: cur = cur->parent;
8276: if (cur == NULL)
8277: return (NULL);
8278: if (cur == ctxt->context->doc->children)
8279: return (NULL);
8280: if (cur != ctxt->ancestor)
8281: return (cur);
8282: ctxt->ancestor = cur->parent;
8283: }
8284: cur = cur->prev;
8285: while (cur->last != NULL)
8286: cur = cur->last;
8287: return (cur);
8288: }
8289:
8290: /**
8291: * xmlXPathNextNamespace:
8292: * @ctxt: the XPath Parser context
8293: * @cur: the current attribute in the traversal
8294: *
8295: * Traversal function for the "namespace" direction
8296: * the namespace axis contains the namespace nodes of the context node;
8297: * the order of nodes on this axis is implementation-defined; the axis will
8298: * be empty unless the context node is an element
8299: *
8300: * We keep the XML namespace node at the end of the list.
8301: *
8302: * Returns the next element following that axis
8303: */
8304: xmlNodePtr
8305: xmlXPathNextNamespace(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
8306: if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
8307: if (ctxt->context->node->type != XML_ELEMENT_NODE) return(NULL);
8308: if (ctxt->context->tmpNsList == NULL && cur != (xmlNodePtr) xmlXPathXMLNamespace) {
8309: if (ctxt->context->tmpNsList != NULL)
8310: xmlFree(ctxt->context->tmpNsList);
8311: ctxt->context->tmpNsList =
8312: xmlGetNsList(ctxt->context->doc, ctxt->context->node);
8313: ctxt->context->tmpNsNr = 0;
8314: if (ctxt->context->tmpNsList != NULL) {
8315: while (ctxt->context->tmpNsList[ctxt->context->tmpNsNr] != NULL) {
8316: ctxt->context->tmpNsNr++;
8317: }
8318: }
8319: return((xmlNodePtr) xmlXPathXMLNamespace);
8320: }
8321: if (ctxt->context->tmpNsNr > 0) {
8322: return (xmlNodePtr)ctxt->context->tmpNsList[--ctxt->context->tmpNsNr];
8323: } else {
8324: if (ctxt->context->tmpNsList != NULL)
8325: xmlFree(ctxt->context->tmpNsList);
8326: ctxt->context->tmpNsList = NULL;
8327: return(NULL);
8328: }
8329: }
8330:
8331: /**
8332: * xmlXPathNextAttribute:
8333: * @ctxt: the XPath Parser context
8334: * @cur: the current attribute in the traversal
8335: *
8336: * Traversal function for the "attribute" direction
8337: * TODO: support DTD inherited default attributes
8338: *
8339: * Returns the next element following that axis
8340: */
8341: xmlNodePtr
8342: xmlXPathNextAttribute(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
8343: if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
8344: if (ctxt->context->node == NULL)
8345: return(NULL);
8346: if (ctxt->context->node->type != XML_ELEMENT_NODE)
8347: return(NULL);
8348: if (cur == NULL) {
8349: if (ctxt->context->node == (xmlNodePtr) ctxt->context->doc)
8350: return(NULL);
8351: return((xmlNodePtr)ctxt->context->node->properties);
8352: }
8353: return((xmlNodePtr)cur->next);
8354: }
8355:
8356: /************************************************************************
8357: * *
8358: * NodeTest Functions *
8359: * *
8360: ************************************************************************/
8361:
8362: #define IS_FUNCTION 200
8363:
8364:
8365: /************************************************************************
8366: * *
8367: * Implicit tree core function library *
8368: * *
8369: ************************************************************************/
8370:
8371: /**
8372: * xmlXPathRoot:
8373: * @ctxt: the XPath Parser context
8374: *
8375: * Initialize the context to the root of the document
8376: */
8377: void
8378: xmlXPathRoot(xmlXPathParserContextPtr ctxt) {
8379: if ((ctxt == NULL) || (ctxt->context == NULL))
8380: return;
8381: ctxt->context->node = (xmlNodePtr) ctxt->context->doc;
8382: valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context,
8383: ctxt->context->node));
8384: }
8385:
8386: /************************************************************************
8387: * *
8388: * The explicit core function library *
8389: *http://www.w3.org/Style/XSL/Group/1999/07/xpath-19990705.html#corelib *
8390: * *
8391: ************************************************************************/
8392:
8393:
8394: /**
8395: * xmlXPathLastFunction:
8396: * @ctxt: the XPath Parser context
8397: * @nargs: the number of arguments
8398: *
8399: * Implement the last() XPath function
8400: * number last()
8401: * The last function returns the number of nodes in the context node list.
8402: */
8403: void
8404: xmlXPathLastFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8405: CHECK_ARITY(0);
8406: if (ctxt->context->contextSize >= 0) {
8407: valuePush(ctxt,
8408: xmlXPathCacheNewFloat(ctxt->context,
8409: (double) ctxt->context->contextSize));
8410: #ifdef DEBUG_EXPR
8411: xmlGenericError(xmlGenericErrorContext,
8412: "last() : %d\n", ctxt->context->contextSize);
8413: #endif
8414: } else {
8415: XP_ERROR(XPATH_INVALID_CTXT_SIZE);
8416: }
8417: }
8418:
8419: /**
8420: * xmlXPathPositionFunction:
8421: * @ctxt: the XPath Parser context
8422: * @nargs: the number of arguments
8423: *
8424: * Implement the position() XPath function
8425: * number position()
8426: * The position function returns the position of the context node in the
8427: * context node list. The first position is 1, and so the last position
8428: * will be equal to last().
8429: */
8430: void
8431: xmlXPathPositionFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8432: CHECK_ARITY(0);
8433: if (ctxt->context->proximityPosition >= 0) {
8434: valuePush(ctxt,
8435: xmlXPathCacheNewFloat(ctxt->context,
8436: (double) ctxt->context->proximityPosition));
8437: #ifdef DEBUG_EXPR
8438: xmlGenericError(xmlGenericErrorContext, "position() : %d\n",
8439: ctxt->context->proximityPosition);
8440: #endif
8441: } else {
8442: XP_ERROR(XPATH_INVALID_CTXT_POSITION);
8443: }
8444: }
8445:
8446: /**
8447: * xmlXPathCountFunction:
8448: * @ctxt: the XPath Parser context
8449: * @nargs: the number of arguments
8450: *
8451: * Implement the count() XPath function
8452: * number count(node-set)
8453: */
8454: void
8455: xmlXPathCountFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8456: xmlXPathObjectPtr cur;
8457:
8458: CHECK_ARITY(1);
8459: if ((ctxt->value == NULL) ||
8460: ((ctxt->value->type != XPATH_NODESET) &&
8461: (ctxt->value->type != XPATH_XSLT_TREE)))
8462: XP_ERROR(XPATH_INVALID_TYPE);
8463: cur = valuePop(ctxt);
8464:
8465: if ((cur == NULL) || (cur->nodesetval == NULL))
8466: valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, (double) 0));
8467: else if ((cur->type == XPATH_NODESET) || (cur->type == XPATH_XSLT_TREE)) {
8468: valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context,
8469: (double) cur->nodesetval->nodeNr));
8470: } else {
8471: if ((cur->nodesetval->nodeNr != 1) ||
8472: (cur->nodesetval->nodeTab == NULL)) {
8473: valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, (double) 0));
8474: } else {
8475: xmlNodePtr tmp;
8476: int i = 0;
8477:
8478: tmp = cur->nodesetval->nodeTab[0];
8479: if (tmp != NULL) {
8480: tmp = tmp->children;
8481: while (tmp != NULL) {
8482: tmp = tmp->next;
8483: i++;
8484: }
8485: }
8486: valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, (double) i));
8487: }
8488: }
8489: xmlXPathReleaseObject(ctxt->context, cur);
8490: }
8491:
8492: /**
8493: * xmlXPathGetElementsByIds:
8494: * @doc: the document
8495: * @ids: a whitespace separated list of IDs
8496: *
8497: * Selects elements by their unique ID.
8498: *
8499: * Returns a node-set of selected elements.
8500: */
8501: static xmlNodeSetPtr
8502: xmlXPathGetElementsByIds (xmlDocPtr doc, const xmlChar *ids) {
8503: xmlNodeSetPtr ret;
8504: const xmlChar *cur = ids;
8505: xmlChar *ID;
8506: xmlAttrPtr attr;
8507: xmlNodePtr elem = NULL;
8508:
8509: if (ids == NULL) return(NULL);
8510:
8511: ret = xmlXPathNodeSetCreate(NULL);
8512: if (ret == NULL)
8513: return(ret);
8514:
8515: while (IS_BLANK_CH(*cur)) cur++;
8516: while (*cur != 0) {
8517: while ((!IS_BLANK_CH(*cur)) && (*cur != 0))
8518: cur++;
8519:
8520: ID = xmlStrndup(ids, cur - ids);
8521: if (ID != NULL) {
8522: /*
8523: * We used to check the fact that the value passed
8524: * was an NCName, but this generated much troubles for
8525: * me and Aleksey Sanin, people blatantly violated that
8526: * constaint, like Visa3D spec.
8527: * if (xmlValidateNCName(ID, 1) == 0)
8528: */
8529: attr = xmlGetID(doc, ID);
8530: if (attr != NULL) {
8531: if (attr->type == XML_ATTRIBUTE_NODE)
8532: elem = attr->parent;
8533: else if (attr->type == XML_ELEMENT_NODE)
8534: elem = (xmlNodePtr) attr;
8535: else
8536: elem = NULL;
8537: if (elem != NULL)
8538: xmlXPathNodeSetAdd(ret, elem);
8539: }
8540: xmlFree(ID);
8541: }
8542:
8543: while (IS_BLANK_CH(*cur)) cur++;
8544: ids = cur;
8545: }
8546: return(ret);
8547: }
8548:
8549: /**
8550: * xmlXPathIdFunction:
8551: * @ctxt: the XPath Parser context
8552: * @nargs: the number of arguments
8553: *
8554: * Implement the id() XPath function
8555: * node-set id(object)
8556: * The id function selects elements by their unique ID
8557: * (see [5.2.1 Unique IDs]). When the argument to id is of type node-set,
8558: * then the result is the union of the result of applying id to the
8559: * string value of each of the nodes in the argument node-set. When the
8560: * argument to id is of any other type, the argument is converted to a
8561: * string as if by a call to the string function; the string is split
8562: * into a whitespace-separated list of tokens (whitespace is any sequence
8563: * of characters matching the production S); the result is a node-set
8564: * containing the elements in the same document as the context node that
8565: * have a unique ID equal to any of the tokens in the list.
8566: */
8567: void
8568: xmlXPathIdFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8569: xmlChar *tokens;
8570: xmlNodeSetPtr ret;
8571: xmlXPathObjectPtr obj;
8572:
8573: CHECK_ARITY(1);
8574: obj = valuePop(ctxt);
8575: if (obj == NULL) XP_ERROR(XPATH_INVALID_OPERAND);
8576: if ((obj->type == XPATH_NODESET) || (obj->type == XPATH_XSLT_TREE)) {
8577: xmlNodeSetPtr ns;
8578: int i;
8579:
8580: ret = xmlXPathNodeSetCreate(NULL);
8581: /*
8582: * FIXME -- in an out-of-memory condition this will behave badly.
8583: * The solution is not clear -- we already popped an item from
8584: * ctxt, so the object is in a corrupt state.
8585: */
8586:
8587: if (obj->nodesetval != NULL) {
8588: for (i = 0; i < obj->nodesetval->nodeNr; i++) {
8589: tokens =
8590: xmlXPathCastNodeToString(obj->nodesetval->nodeTab[i]);
8591: ns = xmlXPathGetElementsByIds(ctxt->context->doc, tokens);
8592: ret = xmlXPathNodeSetMerge(ret, ns);
8593: xmlXPathFreeNodeSet(ns);
8594: if (tokens != NULL)
8595: xmlFree(tokens);
8596: }
8597: }
8598: xmlXPathReleaseObject(ctxt->context, obj);
8599: valuePush(ctxt, xmlXPathCacheWrapNodeSet(ctxt->context, ret));
8600: return;
8601: }
8602: obj = xmlXPathCacheConvertString(ctxt->context, obj);
8603: ret = xmlXPathGetElementsByIds(ctxt->context->doc, obj->stringval);
8604: valuePush(ctxt, xmlXPathCacheWrapNodeSet(ctxt->context, ret));
8605: xmlXPathReleaseObject(ctxt->context, obj);
8606: return;
8607: }
8608:
8609: /**
8610: * xmlXPathLocalNameFunction:
8611: * @ctxt: the XPath Parser context
8612: * @nargs: the number of arguments
8613: *
8614: * Implement the local-name() XPath function
8615: * string local-name(node-set?)
8616: * The local-name function returns a string containing the local part
8617: * of the name of the node in the argument node-set that is first in
8618: * document order. If the node-set is empty or the first node has no
8619: * name, an empty string is returned. If the argument is omitted it
8620: * defaults to the context node.
8621: */
8622: void
8623: xmlXPathLocalNameFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8624: xmlXPathObjectPtr cur;
8625:
8626: if (ctxt == NULL) return;
8627:
8628: if (nargs == 0) {
8629: valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context,
8630: ctxt->context->node));
8631: nargs = 1;
8632: }
8633:
8634: CHECK_ARITY(1);
8635: if ((ctxt->value == NULL) ||
8636: ((ctxt->value->type != XPATH_NODESET) &&
8637: (ctxt->value->type != XPATH_XSLT_TREE)))
8638: XP_ERROR(XPATH_INVALID_TYPE);
8639: cur = valuePop(ctxt);
8640:
8641: if ((cur->nodesetval == NULL) || (cur->nodesetval->nodeNr == 0)) {
8642: valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, ""));
8643: } else {
8644: int i = 0; /* Should be first in document order !!!!! */
8645: switch (cur->nodesetval->nodeTab[i]->type) {
8646: case XML_ELEMENT_NODE:
8647: case XML_ATTRIBUTE_NODE:
8648: case XML_PI_NODE:
8649: if (cur->nodesetval->nodeTab[i]->name[0] == ' ')
8650: valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, ""));
8651: else
8652: valuePush(ctxt,
8653: xmlXPathCacheNewString(ctxt->context,
8654: cur->nodesetval->nodeTab[i]->name));
8655: break;
8656: case XML_NAMESPACE_DECL:
8657: valuePush(ctxt, xmlXPathCacheNewString(ctxt->context,
8658: ((xmlNsPtr)cur->nodesetval->nodeTab[i])->prefix));
8659: break;
8660: default:
8661: valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, ""));
8662: }
8663: }
8664: xmlXPathReleaseObject(ctxt->context, cur);
8665: }
8666:
8667: /**
8668: * xmlXPathNamespaceURIFunction:
8669: * @ctxt: the XPath Parser context
8670: * @nargs: the number of arguments
8671: *
8672: * Implement the namespace-uri() XPath function
8673: * string namespace-uri(node-set?)
8674: * The namespace-uri function returns a string containing the
8675: * namespace URI of the expanded name of the node in the argument
8676: * node-set that is first in document order. If the node-set is empty,
8677: * the first node has no name, or the expanded name has no namespace
8678: * URI, an empty string is returned. If the argument is omitted it
8679: * defaults to the context node.
8680: */
8681: void
8682: xmlXPathNamespaceURIFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8683: xmlXPathObjectPtr cur;
8684:
8685: if (ctxt == NULL) return;
8686:
8687: if (nargs == 0) {
8688: valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context,
8689: ctxt->context->node));
8690: nargs = 1;
8691: }
8692: CHECK_ARITY(1);
8693: if ((ctxt->value == NULL) ||
8694: ((ctxt->value->type != XPATH_NODESET) &&
8695: (ctxt->value->type != XPATH_XSLT_TREE)))
8696: XP_ERROR(XPATH_INVALID_TYPE);
8697: cur = valuePop(ctxt);
8698:
8699: if ((cur->nodesetval == NULL) || (cur->nodesetval->nodeNr == 0)) {
8700: valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, ""));
8701: } else {
8702: int i = 0; /* Should be first in document order !!!!! */
8703: switch (cur->nodesetval->nodeTab[i]->type) {
8704: case XML_ELEMENT_NODE:
8705: case XML_ATTRIBUTE_NODE:
8706: if (cur->nodesetval->nodeTab[i]->ns == NULL)
8707: valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, ""));
8708: else
8709: valuePush(ctxt, xmlXPathCacheNewString(ctxt->context,
8710: cur->nodesetval->nodeTab[i]->ns->href));
8711: break;
8712: default:
8713: valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, ""));
8714: }
8715: }
8716: xmlXPathReleaseObject(ctxt->context, cur);
8717: }
8718:
8719: /**
8720: * xmlXPathNameFunction:
8721: * @ctxt: the XPath Parser context
8722: * @nargs: the number of arguments
8723: *
8724: * Implement the name() XPath function
8725: * string name(node-set?)
8726: * The name function returns a string containing a QName representing
8727: * the name of the node in the argument node-set that is first in document
8728: * order. The QName must represent the name with respect to the namespace
8729: * declarations in effect on the node whose name is being represented.
8730: * Typically, this will be the form in which the name occurred in the XML
8731: * source. This need not be the case if there are namespace declarations
8732: * in effect on the node that associate multiple prefixes with the same
8733: * namespace. However, an implementation may include information about
8734: * the original prefix in its representation of nodes; in this case, an
8735: * implementation can ensure that the returned string is always the same
8736: * as the QName used in the XML source. If the argument it omitted it
8737: * defaults to the context node.
8738: * Libxml keep the original prefix so the "real qualified name" used is
8739: * returned.
8740: */
8741: static void
8742: xmlXPathNameFunction(xmlXPathParserContextPtr ctxt, int nargs)
8743: {
8744: xmlXPathObjectPtr cur;
8745:
8746: if (nargs == 0) {
8747: valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context,
8748: ctxt->context->node));
8749: nargs = 1;
8750: }
8751:
8752: CHECK_ARITY(1);
8753: if ((ctxt->value == NULL) ||
8754: ((ctxt->value->type != XPATH_NODESET) &&
8755: (ctxt->value->type != XPATH_XSLT_TREE)))
8756: XP_ERROR(XPATH_INVALID_TYPE);
8757: cur = valuePop(ctxt);
8758:
8759: if ((cur->nodesetval == NULL) || (cur->nodesetval->nodeNr == 0)) {
8760: valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, ""));
8761: } else {
8762: int i = 0; /* Should be first in document order !!!!! */
8763:
8764: switch (cur->nodesetval->nodeTab[i]->type) {
8765: case XML_ELEMENT_NODE:
8766: case XML_ATTRIBUTE_NODE:
8767: if (cur->nodesetval->nodeTab[i]->name[0] == ' ')
8768: valuePush(ctxt,
8769: xmlXPathCacheNewCString(ctxt->context, ""));
8770: else if ((cur->nodesetval->nodeTab[i]->ns == NULL) ||
8771: (cur->nodesetval->nodeTab[i]->ns->prefix == NULL)) {
8772: valuePush(ctxt,
8773: xmlXPathCacheNewString(ctxt->context,
8774: cur->nodesetval->nodeTab[i]->name));
8775: } else {
8776: xmlChar *fullname;
8777:
8778: fullname = xmlBuildQName(cur->nodesetval->nodeTab[i]->name,
8779: cur->nodesetval->nodeTab[i]->ns->prefix,
8780: NULL, 0);
8781: if (fullname == cur->nodesetval->nodeTab[i]->name)
8782: fullname = xmlStrdup(cur->nodesetval->nodeTab[i]->name);
8783: if (fullname == NULL) {
8784: XP_ERROR(XPATH_MEMORY_ERROR);
8785: }
8786: valuePush(ctxt, xmlXPathCacheWrapString(
8787: ctxt->context, fullname));
8788: }
8789: break;
8790: default:
8791: valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context,
8792: cur->nodesetval->nodeTab[i]));
8793: xmlXPathLocalNameFunction(ctxt, 1);
8794: }
8795: }
8796: xmlXPathReleaseObject(ctxt->context, cur);
8797: }
8798:
8799:
8800: /**
8801: * xmlXPathStringFunction:
8802: * @ctxt: the XPath Parser context
8803: * @nargs: the number of arguments
8804: *
8805: * Implement the string() XPath function
8806: * string string(object?)
8807: * The string function converts an object to a string as follows:
8808: * - A node-set is converted to a string by returning the value of
8809: * the node in the node-set that is first in document order.
8810: * If the node-set is empty, an empty string is returned.
8811: * - A number is converted to a string as follows
8812: * + NaN is converted to the string NaN
8813: * + positive zero is converted to the string 0
8814: * + negative zero is converted to the string 0
8815: * + positive infinity is converted to the string Infinity
8816: * + negative infinity is converted to the string -Infinity
8817: * + if the number is an integer, the number is represented in
8818: * decimal form as a Number with no decimal point and no leading
8819: * zeros, preceded by a minus sign (-) if the number is negative
8820: * + otherwise, the number is represented in decimal form as a
8821: * Number including a decimal point with at least one digit
8822: * before the decimal point and at least one digit after the
8823: * decimal point, preceded by a minus sign (-) if the number
8824: * is negative; there must be no leading zeros before the decimal
8825: * point apart possibly from the one required digit immediately
8826: * before the decimal point; beyond the one required digit
8827: * after the decimal point there must be as many, but only as
8828: * many, more digits as are needed to uniquely distinguish the
8829: * number from all other IEEE 754 numeric values.
8830: * - The boolean false value is converted to the string false.
8831: * The boolean true value is converted to the string true.
8832: *
8833: * If the argument is omitted, it defaults to a node-set with the
8834: * context node as its only member.
8835: */
8836: void
8837: xmlXPathStringFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8838: xmlXPathObjectPtr cur;
8839:
8840: if (ctxt == NULL) return;
8841: if (nargs == 0) {
8842: valuePush(ctxt,
8843: xmlXPathCacheWrapString(ctxt->context,
8844: xmlXPathCastNodeToString(ctxt->context->node)));
8845: return;
8846: }
8847:
8848: CHECK_ARITY(1);
8849: cur = valuePop(ctxt);
8850: if (cur == NULL) XP_ERROR(XPATH_INVALID_OPERAND);
8851: valuePush(ctxt, xmlXPathCacheConvertString(ctxt->context, cur));
8852: }
8853:
8854: /**
8855: * xmlXPathStringLengthFunction:
8856: * @ctxt: the XPath Parser context
8857: * @nargs: the number of arguments
8858: *
8859: * Implement the string-length() XPath function
8860: * number string-length(string?)
8861: * The string-length returns the number of characters in the string
8862: * (see [3.6 Strings]). If the argument is omitted, it defaults to
8863: * the context node converted to a string, in other words the value
8864: * of the context node.
8865: */
8866: void
8867: xmlXPathStringLengthFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8868: xmlXPathObjectPtr cur;
8869:
8870: if (nargs == 0) {
8871: if ((ctxt == NULL) || (ctxt->context == NULL))
8872: return;
8873: if (ctxt->context->node == NULL) {
8874: valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, 0));
8875: } else {
8876: xmlChar *content;
8877:
8878: content = xmlXPathCastNodeToString(ctxt->context->node);
8879: valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context,
8880: xmlUTF8Strlen(content)));
8881: xmlFree(content);
8882: }
8883: return;
8884: }
8885: CHECK_ARITY(1);
8886: CAST_TO_STRING;
8887: CHECK_TYPE(XPATH_STRING);
8888: cur = valuePop(ctxt);
8889: valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context,
8890: xmlUTF8Strlen(cur->stringval)));
8891: xmlXPathReleaseObject(ctxt->context, cur);
8892: }
8893:
8894: /**
8895: * xmlXPathConcatFunction:
8896: * @ctxt: the XPath Parser context
8897: * @nargs: the number of arguments
8898: *
8899: * Implement the concat() XPath function
8900: * string concat(string, string, string*)
8901: * The concat function returns the concatenation of its arguments.
8902: */
8903: void
8904: xmlXPathConcatFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8905: xmlXPathObjectPtr cur, newobj;
8906: xmlChar *tmp;
8907:
8908: if (ctxt == NULL) return;
8909: if (nargs < 2) {
8910: CHECK_ARITY(2);
8911: }
8912:
8913: CAST_TO_STRING;
8914: cur = valuePop(ctxt);
8915: if ((cur == NULL) || (cur->type != XPATH_STRING)) {
8916: xmlXPathReleaseObject(ctxt->context, cur);
8917: return;
8918: }
8919: nargs--;
8920:
8921: while (nargs > 0) {
8922: CAST_TO_STRING;
8923: newobj = valuePop(ctxt);
8924: if ((newobj == NULL) || (newobj->type != XPATH_STRING)) {
8925: xmlXPathReleaseObject(ctxt->context, newobj);
8926: xmlXPathReleaseObject(ctxt->context, cur);
8927: XP_ERROR(XPATH_INVALID_TYPE);
8928: }
8929: tmp = xmlStrcat(newobj->stringval, cur->stringval);
8930: newobj->stringval = cur->stringval;
8931: cur->stringval = tmp;
8932: xmlXPathReleaseObject(ctxt->context, newobj);
8933: nargs--;
8934: }
8935: valuePush(ctxt, cur);
8936: }
8937:
8938: /**
8939: * xmlXPathContainsFunction:
8940: * @ctxt: the XPath Parser context
8941: * @nargs: the number of arguments
8942: *
8943: * Implement the contains() XPath function
8944: * boolean contains(string, string)
8945: * The contains function returns true if the first argument string
8946: * contains the second argument string, and otherwise returns false.
8947: */
8948: void
8949: xmlXPathContainsFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8950: xmlXPathObjectPtr hay, needle;
8951:
8952: CHECK_ARITY(2);
8953: CAST_TO_STRING;
8954: CHECK_TYPE(XPATH_STRING);
8955: needle = valuePop(ctxt);
8956: CAST_TO_STRING;
8957: hay = valuePop(ctxt);
8958:
8959: if ((hay == NULL) || (hay->type != XPATH_STRING)) {
8960: xmlXPathReleaseObject(ctxt->context, hay);
8961: xmlXPathReleaseObject(ctxt->context, needle);
8962: XP_ERROR(XPATH_INVALID_TYPE);
8963: }
8964: if (xmlStrstr(hay->stringval, needle->stringval))
8965: valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, 1));
8966: else
8967: valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, 0));
8968: xmlXPathReleaseObject(ctxt->context, hay);
8969: xmlXPathReleaseObject(ctxt->context, needle);
8970: }
8971:
8972: /**
8973: * xmlXPathStartsWithFunction:
8974: * @ctxt: the XPath Parser context
8975: * @nargs: the number of arguments
8976: *
8977: * Implement the starts-with() XPath function
8978: * boolean starts-with(string, string)
8979: * The starts-with function returns true if the first argument string
8980: * starts with the second argument string, and otherwise returns false.
8981: */
8982: void
8983: xmlXPathStartsWithFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8984: xmlXPathObjectPtr hay, needle;
8985: int n;
8986:
8987: CHECK_ARITY(2);
8988: CAST_TO_STRING;
8989: CHECK_TYPE(XPATH_STRING);
8990: needle = valuePop(ctxt);
8991: CAST_TO_STRING;
8992: hay = valuePop(ctxt);
8993:
8994: if ((hay == NULL) || (hay->type != XPATH_STRING)) {
8995: xmlXPathReleaseObject(ctxt->context, hay);
8996: xmlXPathReleaseObject(ctxt->context, needle);
8997: XP_ERROR(XPATH_INVALID_TYPE);
8998: }
8999: n = xmlStrlen(needle->stringval);
9000: if (xmlStrncmp(hay->stringval, needle->stringval, n))
9001: valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, 0));
9002: else
9003: valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, 1));
9004: xmlXPathReleaseObject(ctxt->context, hay);
9005: xmlXPathReleaseObject(ctxt->context, needle);
9006: }
9007:
9008: /**
9009: * xmlXPathSubstringFunction:
9010: * @ctxt: the XPath Parser context
9011: * @nargs: the number of arguments
9012: *
9013: * Implement the substring() XPath function
9014: * string substring(string, number, number?)
9015: * The substring function returns the substring of the first argument
9016: * starting at the position specified in the second argument with
9017: * length specified in the third argument. For example,
9018: * substring("12345",2,3) returns "234". If the third argument is not
9019: * specified, it returns the substring starting at the position specified
9020: * in the second argument and continuing to the end of the string. For
9021: * example, substring("12345",2) returns "2345". More precisely, each
9022: * character in the string (see [3.6 Strings]) is considered to have a
9023: * numeric position: the position of the first character is 1, the position
9024: * of the second character is 2 and so on. The returned substring contains
9025: * those characters for which the position of the character is greater than
9026: * or equal to the second argument and, if the third argument is specified,
9027: * less than the sum of the second and third arguments; the comparisons
9028: * and addition used for the above follow the standard IEEE 754 rules. Thus:
9029: * - substring("12345", 1.5, 2.6) returns "234"
9030: * - substring("12345", 0, 3) returns "12"
9031: * - substring("12345", 0 div 0, 3) returns ""
9032: * - substring("12345", 1, 0 div 0) returns ""
9033: * - substring("12345", -42, 1 div 0) returns "12345"
9034: * - substring("12345", -1 div 0, 1 div 0) returns ""
9035: */
9036: void
9037: xmlXPathSubstringFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9038: xmlXPathObjectPtr str, start, len;
9039: double le=0, in;
9040: int i, l, m;
9041: xmlChar *ret;
9042:
9043: if (nargs < 2) {
9044: CHECK_ARITY(2);
9045: }
9046: if (nargs > 3) {
9047: CHECK_ARITY(3);
9048: }
9049: /*
9050: * take care of possible last (position) argument
9051: */
9052: if (nargs == 3) {
9053: CAST_TO_NUMBER;
9054: CHECK_TYPE(XPATH_NUMBER);
9055: len = valuePop(ctxt);
9056: le = len->floatval;
9057: xmlXPathReleaseObject(ctxt->context, len);
9058: }
9059:
9060: CAST_TO_NUMBER;
9061: CHECK_TYPE(XPATH_NUMBER);
9062: start = valuePop(ctxt);
9063: in = start->floatval;
9064: xmlXPathReleaseObject(ctxt->context, start);
9065: CAST_TO_STRING;
9066: CHECK_TYPE(XPATH_STRING);
9067: str = valuePop(ctxt);
9068: m = xmlUTF8Strlen((const unsigned char *)str->stringval);
9069:
9070: /*
9071: * If last pos not present, calculate last position
9072: */
9073: if (nargs != 3) {
9074: le = (double)m;
9075: if (in < 1.0)
9076: in = 1.0;
9077: }
9078:
9079: /* Need to check for the special cases where either
9080: * the index is NaN, the length is NaN, or both
9081: * arguments are infinity (relying on Inf + -Inf = NaN)
9082: */
9083: if (!xmlXPathIsInf(in) && !xmlXPathIsNaN(in + le)) {
9084: /*
9085: * To meet the requirements of the spec, the arguments
9086: * must be converted to integer format before
9087: * initial index calculations are done
9088: *
9089: * First we go to integer form, rounding up
9090: * and checking for special cases
9091: */
9092: i = (int) in;
9093: if (((double)i)+0.5 <= in) i++;
9094:
9095: if (xmlXPathIsInf(le) == 1) {
9096: l = m;
9097: if (i < 1)
9098: i = 1;
9099: }
9100: else if (xmlXPathIsInf(le) == -1 || le < 0.0)
9101: l = 0;
9102: else {
9103: l = (int) le;
9104: if (((double)l)+0.5 <= le) l++;
9105: }
9106:
9107: /* Now we normalize inidices */
9108: i -= 1;
9109: l += i;
9110: if (i < 0)
9111: i = 0;
9112: if (l > m)
9113: l = m;
9114:
9115: /* number of chars to copy */
9116: l -= i;
9117:
9118: ret = xmlUTF8Strsub(str->stringval, i, l);
9119: }
9120: else {
9121: ret = NULL;
9122: }
9123: if (ret == NULL)
9124: valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, ""));
9125: else {
9126: valuePush(ctxt, xmlXPathCacheNewString(ctxt->context, ret));
9127: xmlFree(ret);
9128: }
9129: xmlXPathReleaseObject(ctxt->context, str);
9130: }
9131:
9132: /**
9133: * xmlXPathSubstringBeforeFunction:
9134: * @ctxt: the XPath Parser context
9135: * @nargs: the number of arguments
9136: *
9137: * Implement the substring-before() XPath function
9138: * string substring-before(string, string)
9139: * The substring-before function returns the substring of the first
9140: * argument string that precedes the first occurrence of the second
9141: * argument string in the first argument string, or the empty string
9142: * if the first argument string does not contain the second argument
9143: * string. For example, substring-before("1999/04/01","/") returns 1999.
9144: */
9145: void
9146: xmlXPathSubstringBeforeFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9147: xmlXPathObjectPtr str;
9148: xmlXPathObjectPtr find;
9149: xmlBufferPtr target;
9150: const xmlChar *point;
9151: int offset;
9152:
9153: CHECK_ARITY(2);
9154: CAST_TO_STRING;
9155: find = valuePop(ctxt);
9156: CAST_TO_STRING;
9157: str = valuePop(ctxt);
9158:
9159: target = xmlBufferCreate();
9160: if (target) {
9161: point = xmlStrstr(str->stringval, find->stringval);
9162: if (point) {
9163: offset = (int)(point - str->stringval);
9164: xmlBufferAdd(target, str->stringval, offset);
9165: }
9166: valuePush(ctxt, xmlXPathCacheNewString(ctxt->context,
9167: xmlBufferContent(target)));
9168: xmlBufferFree(target);
9169: }
9170: xmlXPathReleaseObject(ctxt->context, str);
9171: xmlXPathReleaseObject(ctxt->context, find);
9172: }
9173:
9174: /**
9175: * xmlXPathSubstringAfterFunction:
9176: * @ctxt: the XPath Parser context
9177: * @nargs: the number of arguments
9178: *
9179: * Implement the substring-after() XPath function
9180: * string substring-after(string, string)
9181: * The substring-after function returns the substring of the first
9182: * argument string that follows the first occurrence of the second
9183: * argument string in the first argument string, or the empty stringi
9184: * if the first argument string does not contain the second argument
9185: * string. For example, substring-after("1999/04/01","/") returns 04/01,
9186: * and substring-after("1999/04/01","19") returns 99/04/01.
9187: */
9188: void
9189: xmlXPathSubstringAfterFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9190: xmlXPathObjectPtr str;
9191: xmlXPathObjectPtr find;
9192: xmlBufferPtr target;
9193: const xmlChar *point;
9194: int offset;
9195:
9196: CHECK_ARITY(2);
9197: CAST_TO_STRING;
9198: find = valuePop(ctxt);
9199: CAST_TO_STRING;
9200: str = valuePop(ctxt);
9201:
9202: target = xmlBufferCreate();
9203: if (target) {
9204: point = xmlStrstr(str->stringval, find->stringval);
9205: if (point) {
9206: offset = (int)(point - str->stringval) + xmlStrlen(find->stringval);
9207: xmlBufferAdd(target, &str->stringval[offset],
9208: xmlStrlen(str->stringval) - offset);
9209: }
9210: valuePush(ctxt, xmlXPathCacheNewString(ctxt->context,
9211: xmlBufferContent(target)));
9212: xmlBufferFree(target);
9213: }
9214: xmlXPathReleaseObject(ctxt->context, str);
9215: xmlXPathReleaseObject(ctxt->context, find);
9216: }
9217:
9218: /**
9219: * xmlXPathNormalizeFunction:
9220: * @ctxt: the XPath Parser context
9221: * @nargs: the number of arguments
9222: *
9223: * Implement the normalize-space() XPath function
9224: * string normalize-space(string?)
9225: * The normalize-space function returns the argument string with white
9226: * space normalized by stripping leading and trailing whitespace
9227: * and replacing sequences of whitespace characters by a single
9228: * space. Whitespace characters are the same allowed by the S production
9229: * in XML. If the argument is omitted, it defaults to the context
9230: * node converted to a string, in other words the value of the context node.
9231: */
9232: void
9233: xmlXPathNormalizeFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9234: xmlXPathObjectPtr obj = NULL;
9235: xmlChar *source = NULL;
9236: xmlBufferPtr target;
9237: xmlChar blank;
9238:
9239: if (ctxt == NULL) return;
9240: if (nargs == 0) {
9241: /* Use current context node */
9242: valuePush(ctxt,
9243: xmlXPathCacheWrapString(ctxt->context,
9244: xmlXPathCastNodeToString(ctxt->context->node)));
9245: nargs = 1;
9246: }
9247:
9248: CHECK_ARITY(1);
9249: CAST_TO_STRING;
9250: CHECK_TYPE(XPATH_STRING);
9251: obj = valuePop(ctxt);
9252: source = obj->stringval;
9253:
9254: target = xmlBufferCreate();
9255: if (target && source) {
9256:
9257: /* Skip leading whitespaces */
9258: while (IS_BLANK_CH(*source))
9259: source++;
9260:
9261: /* Collapse intermediate whitespaces, and skip trailing whitespaces */
9262: blank = 0;
9263: while (*source) {
9264: if (IS_BLANK_CH(*source)) {
9265: blank = 0x20;
9266: } else {
9267: if (blank) {
9268: xmlBufferAdd(target, &blank, 1);
9269: blank = 0;
9270: }
9271: xmlBufferAdd(target, source, 1);
9272: }
9273: source++;
9274: }
9275: valuePush(ctxt, xmlXPathCacheNewString(ctxt->context,
9276: xmlBufferContent(target)));
9277: xmlBufferFree(target);
9278: }
9279: xmlXPathReleaseObject(ctxt->context, obj);
9280: }
9281:
9282: /**
9283: * xmlXPathTranslateFunction:
9284: * @ctxt: the XPath Parser context
9285: * @nargs: the number of arguments
9286: *
9287: * Implement the translate() XPath function
9288: * string translate(string, string, string)
9289: * The translate function returns the first argument string with
9290: * occurrences of characters in the second argument string replaced
9291: * by the character at the corresponding position in the third argument
9292: * string. For example, translate("bar","abc","ABC") returns the string
9293: * BAr. If there is a character in the second argument string with no
9294: * character at a corresponding position in the third argument string
9295: * (because the second argument string is longer than the third argument
9296: * string), then occurrences of that character in the first argument
9297: * string are removed. For example, translate("--aaa--","abc-","ABC")
9298: * returns "AAA". If a character occurs more than once in second
9299: * argument string, then the first occurrence determines the replacement
9300: * character. If the third argument string is longer than the second
9301: * argument string, then excess characters are ignored.
9302: */
9303: void
9304: xmlXPathTranslateFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9305: xmlXPathObjectPtr str;
9306: xmlXPathObjectPtr from;
9307: xmlXPathObjectPtr to;
9308: xmlBufferPtr target;
9309: int offset, max;
9310: xmlChar ch;
9311: const xmlChar *point;
9312: xmlChar *cptr;
9313:
9314: CHECK_ARITY(3);
9315:
9316: CAST_TO_STRING;
9317: to = valuePop(ctxt);
9318: CAST_TO_STRING;
9319: from = valuePop(ctxt);
9320: CAST_TO_STRING;
9321: str = valuePop(ctxt);
9322:
9323: target = xmlBufferCreate();
9324: if (target) {
9325: max = xmlUTF8Strlen(to->stringval);
9326: for (cptr = str->stringval; (ch=*cptr); ) {
9327: offset = xmlUTF8Strloc(from->stringval, cptr);
9328: if (offset >= 0) {
9329: if (offset < max) {
9330: point = xmlUTF8Strpos(to->stringval, offset);
9331: if (point)
9332: xmlBufferAdd(target, point, xmlUTF8Strsize(point, 1));
9333: }
9334: } else
9335: xmlBufferAdd(target, cptr, xmlUTF8Strsize(cptr, 1));
9336:
9337: /* Step to next character in input */
9338: cptr++;
9339: if ( ch & 0x80 ) {
9340: /* if not simple ascii, verify proper format */
9341: if ( (ch & 0xc0) != 0xc0 ) {
9342: xmlGenericError(xmlGenericErrorContext,
9343: "xmlXPathTranslateFunction: Invalid UTF8 string\n");
9344: /* not asserting an XPath error is probably better */
9345: break;
9346: }
9347: /* then skip over remaining bytes for this char */
9348: while ( (ch <<= 1) & 0x80 )
9349: if ( (*cptr++ & 0xc0) != 0x80 ) {
9350: xmlGenericError(xmlGenericErrorContext,
9351: "xmlXPathTranslateFunction: Invalid UTF8 string\n");
9352: /* not asserting an XPath error is probably better */
9353: break;
9354: }
9355: if (ch & 0x80) /* must have had error encountered */
9356: break;
9357: }
9358: }
9359: }
9360: valuePush(ctxt, xmlXPathCacheNewString(ctxt->context,
9361: xmlBufferContent(target)));
9362: xmlBufferFree(target);
9363: xmlXPathReleaseObject(ctxt->context, str);
9364: xmlXPathReleaseObject(ctxt->context, from);
9365: xmlXPathReleaseObject(ctxt->context, to);
9366: }
9367:
9368: /**
9369: * xmlXPathBooleanFunction:
9370: * @ctxt: the XPath Parser context
9371: * @nargs: the number of arguments
9372: *
9373: * Implement the boolean() XPath function
9374: * boolean boolean(object)
9375: * The boolean function converts its argument to a boolean as follows:
9376: * - a number is true if and only if it is neither positive or
9377: * negative zero nor NaN
9378: * - a node-set is true if and only if it is non-empty
9379: * - a string is true if and only if its length is non-zero
9380: */
9381: void
9382: xmlXPathBooleanFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9383: xmlXPathObjectPtr cur;
9384:
9385: CHECK_ARITY(1);
9386: cur = valuePop(ctxt);
9387: if (cur == NULL) XP_ERROR(XPATH_INVALID_OPERAND);
9388: cur = xmlXPathCacheConvertBoolean(ctxt->context, cur);
9389: valuePush(ctxt, cur);
9390: }
9391:
9392: /**
9393: * xmlXPathNotFunction:
9394: * @ctxt: the XPath Parser context
9395: * @nargs: the number of arguments
9396: *
9397: * Implement the not() XPath function
9398: * boolean not(boolean)
9399: * The not function returns true if its argument is false,
9400: * and false otherwise.
9401: */
9402: void
9403: xmlXPathNotFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9404: CHECK_ARITY(1);
9405: CAST_TO_BOOLEAN;
9406: CHECK_TYPE(XPATH_BOOLEAN);
9407: ctxt->value->boolval = ! ctxt->value->boolval;
9408: }
9409:
9410: /**
9411: * xmlXPathTrueFunction:
9412: * @ctxt: the XPath Parser context
9413: * @nargs: the number of arguments
9414: *
9415: * Implement the true() XPath function
9416: * boolean true()
9417: */
9418: void
9419: xmlXPathTrueFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9420: CHECK_ARITY(0);
9421: valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, 1));
9422: }
9423:
9424: /**
9425: * xmlXPathFalseFunction:
9426: * @ctxt: the XPath Parser context
9427: * @nargs: the number of arguments
9428: *
9429: * Implement the false() XPath function
9430: * boolean false()
9431: */
9432: void
9433: xmlXPathFalseFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9434: CHECK_ARITY(0);
9435: valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, 0));
9436: }
9437:
9438: /**
9439: * xmlXPathLangFunction:
9440: * @ctxt: the XPath Parser context
9441: * @nargs: the number of arguments
9442: *
9443: * Implement the lang() XPath function
9444: * boolean lang(string)
9445: * The lang function returns true or false depending on whether the
9446: * language of the context node as specified by xml:lang attributes
9447: * is the same as or is a sublanguage of the language specified by
9448: * the argument string. The language of the context node is determined
9449: * by the value of the xml:lang attribute on the context node, or, if
9450: * the context node has no xml:lang attribute, by the value of the
9451: * xml:lang attribute on the nearest ancestor of the context node that
9452: * has an xml:lang attribute. If there is no such attribute, then lang
9453: * returns false. If there is such an attribute, then lang returns
9454: * true if the attribute value is equal to the argument ignoring case,
9455: * or if there is some suffix starting with - such that the attribute
9456: * value is equal to the argument ignoring that suffix of the attribute
9457: * value and ignoring case.
9458: */
9459: void
9460: xmlXPathLangFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9461: xmlXPathObjectPtr val = NULL;
9462: const xmlChar *theLang = NULL;
9463: const xmlChar *lang;
9464: int ret = 0;
9465: int i;
9466:
9467: CHECK_ARITY(1);
9468: CAST_TO_STRING;
9469: CHECK_TYPE(XPATH_STRING);
9470: val = valuePop(ctxt);
9471: lang = val->stringval;
9472: theLang = xmlNodeGetLang(ctxt->context->node);
9473: if ((theLang != NULL) && (lang != NULL)) {
9474: for (i = 0;lang[i] != 0;i++)
9475: if (toupper(lang[i]) != toupper(theLang[i]))
9476: goto not_equal;
9477: if ((theLang[i] == 0) || (theLang[i] == '-'))
9478: ret = 1;
9479: }
9480: not_equal:
9481: if (theLang != NULL)
9482: xmlFree((void *)theLang);
9483:
9484: xmlXPathReleaseObject(ctxt->context, val);
9485: valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, ret));
9486: }
9487:
9488: /**
9489: * xmlXPathNumberFunction:
9490: * @ctxt: the XPath Parser context
9491: * @nargs: the number of arguments
9492: *
9493: * Implement the number() XPath function
9494: * number number(object?)
9495: */
9496: void
9497: xmlXPathNumberFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9498: xmlXPathObjectPtr cur;
9499: double res;
9500:
9501: if (ctxt == NULL) return;
9502: if (nargs == 0) {
9503: if (ctxt->context->node == NULL) {
9504: valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, 0.0));
9505: } else {
9506: xmlChar* content = xmlNodeGetContent(ctxt->context->node);
9507:
9508: res = xmlXPathStringEvalNumber(content);
9509: valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, res));
9510: xmlFree(content);
9511: }
9512: return;
9513: }
9514:
9515: CHECK_ARITY(1);
9516: cur = valuePop(ctxt);
9517: valuePush(ctxt, xmlXPathCacheConvertNumber(ctxt->context, cur));
9518: }
9519:
9520: /**
9521: * xmlXPathSumFunction:
9522: * @ctxt: the XPath Parser context
9523: * @nargs: the number of arguments
9524: *
9525: * Implement the sum() XPath function
9526: * number sum(node-set)
9527: * The sum function returns the sum of the values of the nodes in
9528: * the argument node-set.
9529: */
9530: void
9531: xmlXPathSumFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9532: xmlXPathObjectPtr cur;
9533: int i;
9534: double res = 0.0;
9535:
9536: CHECK_ARITY(1);
9537: if ((ctxt->value == NULL) ||
9538: ((ctxt->value->type != XPATH_NODESET) &&
9539: (ctxt->value->type != XPATH_XSLT_TREE)))
9540: XP_ERROR(XPATH_INVALID_TYPE);
9541: cur = valuePop(ctxt);
9542:
9543: if ((cur->nodesetval != NULL) && (cur->nodesetval->nodeNr != 0)) {
9544: for (i = 0; i < cur->nodesetval->nodeNr; i++) {
9545: res += xmlXPathCastNodeToNumber(cur->nodesetval->nodeTab[i]);
9546: }
9547: }
9548: valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, res));
9549: xmlXPathReleaseObject(ctxt->context, cur);
9550: }
9551:
9552: /*
9553: * To assure working code on multiple platforms, we want to only depend
9554: * upon the characteristic truncation of converting a floating point value
9555: * to an integer. Unfortunately, because of the different storage sizes
9556: * of our internal floating point value (double) and integer (int), we
9557: * can't directly convert (see bug 301162). This macro is a messy
9558: * 'workaround'
9559: */
9560: #define XTRUNC(f, v) \
9561: f = fmod((v), INT_MAX); \
9562: f = (v) - (f) + (double)((int)(f));
9563:
9564: /**
9565: * xmlXPathFloorFunction:
9566: * @ctxt: the XPath Parser context
9567: * @nargs: the number of arguments
9568: *
9569: * Implement the floor() XPath function
9570: * number floor(number)
9571: * The floor function returns the largest (closest to positive infinity)
9572: * number that is not greater than the argument and that is an integer.
9573: */
9574: void
9575: xmlXPathFloorFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9576: double f;
9577:
9578: CHECK_ARITY(1);
9579: CAST_TO_NUMBER;
9580: CHECK_TYPE(XPATH_NUMBER);
9581:
9582: XTRUNC(f, ctxt->value->floatval);
9583: if (f != ctxt->value->floatval) {
9584: if (ctxt->value->floatval > 0)
9585: ctxt->value->floatval = f;
9586: else
9587: ctxt->value->floatval = f - 1;
9588: }
9589: }
9590:
9591: /**
9592: * xmlXPathCeilingFunction:
9593: * @ctxt: the XPath Parser context
9594: * @nargs: the number of arguments
9595: *
9596: * Implement the ceiling() XPath function
9597: * number ceiling(number)
9598: * The ceiling function returns the smallest (closest to negative infinity)
9599: * number that is not less than the argument and that is an integer.
9600: */
9601: void
9602: xmlXPathCeilingFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9603: double f;
9604:
9605: CHECK_ARITY(1);
9606: CAST_TO_NUMBER;
9607: CHECK_TYPE(XPATH_NUMBER);
9608:
9609: #if 0
9610: ctxt->value->floatval = ceil(ctxt->value->floatval);
9611: #else
9612: XTRUNC(f, ctxt->value->floatval);
9613: if (f != ctxt->value->floatval) {
9614: if (ctxt->value->floatval > 0)
9615: ctxt->value->floatval = f + 1;
9616: else {
9617: if (ctxt->value->floatval < 0 && f == 0)
9618: ctxt->value->floatval = xmlXPathNZERO;
9619: else
9620: ctxt->value->floatval = f;
9621: }
9622:
9623: }
9624: #endif
9625: }
9626:
9627: /**
9628: * xmlXPathRoundFunction:
9629: * @ctxt: the XPath Parser context
9630: * @nargs: the number of arguments
9631: *
9632: * Implement the round() XPath function
9633: * number round(number)
9634: * The round function returns the number that is closest to the
9635: * argument and that is an integer. If there are two such numbers,
9636: * then the one that is even is returned.
9637: */
9638: void
9639: xmlXPathRoundFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9640: double f;
9641:
9642: CHECK_ARITY(1);
9643: CAST_TO_NUMBER;
9644: CHECK_TYPE(XPATH_NUMBER);
9645:
9646: if ((xmlXPathIsNaN(ctxt->value->floatval)) ||
9647: (xmlXPathIsInf(ctxt->value->floatval) == 1) ||
9648: (xmlXPathIsInf(ctxt->value->floatval) == -1) ||
9649: (ctxt->value->floatval == 0.0))
9650: return;
9651:
9652: XTRUNC(f, ctxt->value->floatval);
9653: if (ctxt->value->floatval < 0) {
9654: if (ctxt->value->floatval < f - 0.5)
9655: ctxt->value->floatval = f - 1;
9656: else
9657: ctxt->value->floatval = f;
9658: if (ctxt->value->floatval == 0)
9659: ctxt->value->floatval = xmlXPathNZERO;
9660: } else {
9661: if (ctxt->value->floatval < f + 0.5)
9662: ctxt->value->floatval = f;
9663: else
9664: ctxt->value->floatval = f + 1;
9665: }
9666: }
9667:
9668: /************************************************************************
9669: * *
9670: * The Parser *
9671: * *
9672: ************************************************************************/
9673:
9674: /*
9675: * a few forward declarations since we use a recursive call based
9676: * implementation.
9677: */
9678: static void xmlXPathCompileExpr(xmlXPathParserContextPtr ctxt, int sort);
9679: static void xmlXPathCompPredicate(xmlXPathParserContextPtr ctxt, int filter);
9680: static void xmlXPathCompLocationPath(xmlXPathParserContextPtr ctxt);
9681: static void xmlXPathCompRelativeLocationPath(xmlXPathParserContextPtr ctxt);
9682: static xmlChar * xmlXPathParseNameComplex(xmlXPathParserContextPtr ctxt,
9683: int qualified);
9684:
9685: /**
9686: * xmlXPathCurrentChar:
9687: * @ctxt: the XPath parser context
9688: * @cur: pointer to the beginning of the char
9689: * @len: pointer to the length of the char read
9690: *
9691: * The current char value, if using UTF-8 this may actually span multiple
9692: * bytes in the input buffer.
9693: *
9694: * Returns the current char value and its length
9695: */
9696:
9697: static int
9698: xmlXPathCurrentChar(xmlXPathParserContextPtr ctxt, int *len) {
9699: unsigned char c;
9700: unsigned int val;
9701: const xmlChar *cur;
9702:
9703: if (ctxt == NULL)
9704: return(0);
9705: cur = ctxt->cur;
9706:
9707: /*
9708: * We are supposed to handle UTF8, check it's valid
9709: * From rfc2044: encoding of the Unicode values on UTF-8:
9710: *
9711: * UCS-4 range (hex.) UTF-8 octet sequence (binary)
9712: * 0000 0000-0000 007F 0xxxxxxx
9713: * 0000 0080-0000 07FF 110xxxxx 10xxxxxx
9714: * 0000 0800-0000 FFFF 1110xxxx 10xxxxxx 10xxxxxx
9715: *
9716: * Check for the 0x110000 limit too
9717: */
9718: c = *cur;
9719: if (c & 0x80) {
9720: if ((cur[1] & 0xc0) != 0x80)
9721: goto encoding_error;
9722: if ((c & 0xe0) == 0xe0) {
9723:
9724: if ((cur[2] & 0xc0) != 0x80)
9725: goto encoding_error;
9726: if ((c & 0xf0) == 0xf0) {
9727: if (((c & 0xf8) != 0xf0) ||
9728: ((cur[3] & 0xc0) != 0x80))
9729: goto encoding_error;
9730: /* 4-byte code */
9731: *len = 4;
9732: val = (cur[0] & 0x7) << 18;
9733: val |= (cur[1] & 0x3f) << 12;
9734: val |= (cur[2] & 0x3f) << 6;
9735: val |= cur[3] & 0x3f;
9736: } else {
9737: /* 3-byte code */
9738: *len = 3;
9739: val = (cur[0] & 0xf) << 12;
9740: val |= (cur[1] & 0x3f) << 6;
9741: val |= cur[2] & 0x3f;
9742: }
9743: } else {
9744: /* 2-byte code */
9745: *len = 2;
9746: val = (cur[0] & 0x1f) << 6;
9747: val |= cur[1] & 0x3f;
9748: }
9749: if (!IS_CHAR(val)) {
9750: XP_ERROR0(XPATH_INVALID_CHAR_ERROR);
9751: }
9752: return(val);
9753: } else {
9754: /* 1-byte code */
9755: *len = 1;
9756: return((int) *cur);
9757: }
9758: encoding_error:
9759: /*
9760: * If we detect an UTF8 error that probably means that the
9761: * input encoding didn't get properly advertised in the
9762: * declaration header. Report the error and switch the encoding
9763: * to ISO-Latin-1 (if you don't like this policy, just declare the
9764: * encoding !)
9765: */
9766: *len = 0;
9767: XP_ERROR0(XPATH_ENCODING_ERROR);
9768: }
9769:
9770: /**
9771: * xmlXPathParseNCName:
9772: * @ctxt: the XPath Parser context
9773: *
9774: * parse an XML namespace non qualified name.
9775: *
9776: * [NS 3] NCName ::= (Letter | '_') (NCNameChar)*
9777: *
9778: * [NS 4] NCNameChar ::= Letter | Digit | '.' | '-' | '_' |
9779: * CombiningChar | Extender
9780: *
9781: * Returns the namespace name or NULL
9782: */
9783:
9784: xmlChar *
9785: xmlXPathParseNCName(xmlXPathParserContextPtr ctxt) {
9786: const xmlChar *in;
9787: xmlChar *ret;
9788: int count = 0;
9789:
9790: if ((ctxt == NULL) || (ctxt->cur == NULL)) return(NULL);
9791: /*
9792: * Accelerator for simple ASCII names
9793: */
9794: in = ctxt->cur;
9795: if (((*in >= 0x61) && (*in <= 0x7A)) ||
9796: ((*in >= 0x41) && (*in <= 0x5A)) ||
9797: (*in == '_')) {
9798: in++;
9799: while (((*in >= 0x61) && (*in <= 0x7A)) ||
9800: ((*in >= 0x41) && (*in <= 0x5A)) ||
9801: ((*in >= 0x30) && (*in <= 0x39)) ||
9802: (*in == '_') || (*in == '.') ||
9803: (*in == '-'))
9804: in++;
9805: if ((*in == ' ') || (*in == '>') || (*in == '/') ||
9806: (*in == '[') || (*in == ']') || (*in == ':') ||
9807: (*in == '@') || (*in == '*')) {
9808: count = in - ctxt->cur;
9809: if (count == 0)
9810: return(NULL);
9811: ret = xmlStrndup(ctxt->cur, count);
9812: ctxt->cur = in;
9813: return(ret);
9814: }
9815: }
9816: return(xmlXPathParseNameComplex(ctxt, 0));
9817: }
9818:
9819:
9820: /**
9821: * xmlXPathParseQName:
9822: * @ctxt: the XPath Parser context
9823: * @prefix: a xmlChar **
9824: *
9825: * parse an XML qualified name
9826: *
9827: * [NS 5] QName ::= (Prefix ':')? LocalPart
9828: *
9829: * [NS 6] Prefix ::= NCName
9830: *
9831: * [NS 7] LocalPart ::= NCName
9832: *
9833: * Returns the function returns the local part, and prefix is updated
9834: * to get the Prefix if any.
9835: */
9836:
9837: static xmlChar *
9838: xmlXPathParseQName(xmlXPathParserContextPtr ctxt, xmlChar **prefix) {
9839: xmlChar *ret = NULL;
9840:
9841: *prefix = NULL;
9842: ret = xmlXPathParseNCName(ctxt);
9843: if (ret && CUR == ':') {
9844: *prefix = ret;
9845: NEXT;
9846: ret = xmlXPathParseNCName(ctxt);
9847: }
9848: return(ret);
9849: }
9850:
9851: /**
9852: * xmlXPathParseName:
9853: * @ctxt: the XPath Parser context
9854: *
9855: * parse an XML name
9856: *
9857: * [4] NameChar ::= Letter | Digit | '.' | '-' | '_' | ':' |
9858: * CombiningChar | Extender
9859: *
9860: * [5] Name ::= (Letter | '_' | ':') (NameChar)*
9861: *
9862: * Returns the namespace name or NULL
9863: */
9864:
9865: xmlChar *
9866: xmlXPathParseName(xmlXPathParserContextPtr ctxt) {
9867: const xmlChar *in;
9868: xmlChar *ret;
9869: int count = 0;
9870:
9871: if ((ctxt == NULL) || (ctxt->cur == NULL)) return(NULL);
9872: /*
9873: * Accelerator for simple ASCII names
9874: */
9875: in = ctxt->cur;
9876: if (((*in >= 0x61) && (*in <= 0x7A)) ||
9877: ((*in >= 0x41) && (*in <= 0x5A)) ||
9878: (*in == '_') || (*in == ':')) {
9879: in++;
9880: while (((*in >= 0x61) && (*in <= 0x7A)) ||
9881: ((*in >= 0x41) && (*in <= 0x5A)) ||
9882: ((*in >= 0x30) && (*in <= 0x39)) ||
9883: (*in == '_') || (*in == '-') ||
9884: (*in == ':') || (*in == '.'))
9885: in++;
9886: if ((*in > 0) && (*in < 0x80)) {
9887: count = in - ctxt->cur;
9888: ret = xmlStrndup(ctxt->cur, count);
9889: ctxt->cur = in;
9890: return(ret);
9891: }
9892: }
9893: return(xmlXPathParseNameComplex(ctxt, 1));
9894: }
9895:
9896: static xmlChar *
9897: xmlXPathParseNameComplex(xmlXPathParserContextPtr ctxt, int qualified) {
9898: xmlChar buf[XML_MAX_NAMELEN + 5];
9899: int len = 0, l;
9900: int c;
9901:
9902: /*
9903: * Handler for more complex cases
9904: */
9905: c = CUR_CHAR(l);
9906: if ((c == ' ') || (c == '>') || (c == '/') || /* accelerators */
9907: (c == '[') || (c == ']') || (c == '@') || /* accelerators */
9908: (c == '*') || /* accelerators */
9909: (!IS_LETTER(c) && (c != '_') &&
9910: ((qualified) && (c != ':')))) {
9911: return(NULL);
9912: }
9913:
9914: while ((c != ' ') && (c != '>') && (c != '/') && /* test bigname.xml */
9915: ((IS_LETTER(c)) || (IS_DIGIT(c)) ||
9916: (c == '.') || (c == '-') ||
9917: (c == '_') || ((qualified) && (c == ':')) ||
9918: (IS_COMBINING(c)) ||
9919: (IS_EXTENDER(c)))) {
9920: COPY_BUF(l,buf,len,c);
9921: NEXTL(l);
9922: c = CUR_CHAR(l);
9923: if (len >= XML_MAX_NAMELEN) {
9924: /*
9925: * Okay someone managed to make a huge name, so he's ready to pay
9926: * for the processing speed.
9927: */
9928: xmlChar *buffer;
9929: int max = len * 2;
9930:
9931: buffer = (xmlChar *) xmlMallocAtomic(max * sizeof(xmlChar));
9932: if (buffer == NULL) {
9933: XP_ERRORNULL(XPATH_MEMORY_ERROR);
9934: }
9935: memcpy(buffer, buf, len);
9936: while ((IS_LETTER(c)) || (IS_DIGIT(c)) || /* test bigname.xml */
9937: (c == '.') || (c == '-') ||
9938: (c == '_') || ((qualified) && (c == ':')) ||
9939: (IS_COMBINING(c)) ||
9940: (IS_EXTENDER(c))) {
9941: if (len + 10 > max) {
9942: max *= 2;
9943: buffer = (xmlChar *) xmlRealloc(buffer,
9944: max * sizeof(xmlChar));
9945: if (buffer == NULL) {
9946: XP_ERRORNULL(XPATH_MEMORY_ERROR);
9947: }
9948: }
9949: COPY_BUF(l,buffer,len,c);
9950: NEXTL(l);
9951: c = CUR_CHAR(l);
9952: }
9953: buffer[len] = 0;
9954: return(buffer);
9955: }
9956: }
9957: if (len == 0)
9958: return(NULL);
9959: return(xmlStrndup(buf, len));
9960: }
9961:
9962: #define MAX_FRAC 20
9963:
9964: /*
9965: * These are used as divisors for the fractional part of a number.
9966: * Since the table includes 1.0 (representing '0' fractional digits),
9967: * it must be dimensioned at MAX_FRAC+1 (bug 133921)
9968: */
9969: static double my_pow10[MAX_FRAC+1] = {
9970: 1.0, 10.0, 100.0, 1000.0, 10000.0,
9971: 100000.0, 1000000.0, 10000000.0, 100000000.0, 1000000000.0,
9972: 10000000000.0, 100000000000.0, 1000000000000.0, 10000000000000.0,
9973: 100000000000000.0,
9974: 1000000000000000.0, 10000000000000000.0, 100000000000000000.0,
9975: 1000000000000000000.0, 10000000000000000000.0, 100000000000000000000.0
9976: };
9977:
9978: /**
9979: * xmlXPathStringEvalNumber:
9980: * @str: A string to scan
9981: *
9982: * [30a] Float ::= Number ('e' Digits?)?
9983: *
9984: * [30] Number ::= Digits ('.' Digits?)?
9985: * | '.' Digits
9986: * [31] Digits ::= [0-9]+
9987: *
9988: * Compile a Number in the string
9989: * In complement of the Number expression, this function also handles
9990: * negative values : '-' Number.
9991: *
9992: * Returns the double value.
9993: */
9994: double
9995: xmlXPathStringEvalNumber(const xmlChar *str) {
9996: const xmlChar *cur = str;
9997: double ret;
9998: int ok = 0;
9999: int isneg = 0;
10000: int exponent = 0;
10001: int is_exponent_negative = 0;
10002: #ifdef __GNUC__
10003: unsigned long tmp = 0;
10004: double temp;
10005: #endif
10006: if (cur == NULL) return(0);
10007: while (IS_BLANK_CH(*cur)) cur++;
10008: if ((*cur != '.') && ((*cur < '0') || (*cur > '9')) && (*cur != '-')) {
10009: return(xmlXPathNAN);
10010: }
10011: if (*cur == '-') {
10012: isneg = 1;
10013: cur++;
10014: }
10015:
10016: #ifdef __GNUC__
10017: /*
10018: * tmp/temp is a workaround against a gcc compiler bug
10019: * http://veillard.com/gcc.bug
10020: */
10021: ret = 0;
10022: while ((*cur >= '0') && (*cur <= '9')) {
10023: ret = ret * 10;
10024: tmp = (*cur - '0');
10025: ok = 1;
10026: cur++;
10027: temp = (double) tmp;
10028: ret = ret + temp;
10029: }
10030: #else
10031: ret = 0;
10032: while ((*cur >= '0') && (*cur <= '9')) {
10033: ret = ret * 10 + (*cur - '0');
10034: ok = 1;
10035: cur++;
10036: }
10037: #endif
10038:
10039: if (*cur == '.') {
10040: int v, frac = 0;
10041: double fraction = 0;
10042:
10043: cur++;
10044: if (((*cur < '0') || (*cur > '9')) && (!ok)) {
10045: return(xmlXPathNAN);
10046: }
10047: while (((*cur >= '0') && (*cur <= '9')) && (frac < MAX_FRAC)) {
10048: v = (*cur - '0');
10049: fraction = fraction * 10 + v;
10050: frac = frac + 1;
10051: cur++;
10052: }
10053: fraction /= my_pow10[frac];
10054: ret = ret + fraction;
10055: while ((*cur >= '0') && (*cur <= '9'))
10056: cur++;
10057: }
10058: if ((*cur == 'e') || (*cur == 'E')) {
10059: cur++;
10060: if (*cur == '-') {
10061: is_exponent_negative = 1;
10062: cur++;
10063: } else if (*cur == '+') {
10064: cur++;
10065: }
10066: while ((*cur >= '0') && (*cur <= '9')) {
10067: exponent = exponent * 10 + (*cur - '0');
10068: cur++;
10069: }
10070: }
10071: while (IS_BLANK_CH(*cur)) cur++;
10072: if (*cur != 0) return(xmlXPathNAN);
10073: if (isneg) ret = -ret;
10074: if (is_exponent_negative) exponent = -exponent;
10075: ret *= pow(10.0, (double)exponent);
10076: return(ret);
10077: }
10078:
10079: /**
10080: * xmlXPathCompNumber:
10081: * @ctxt: the XPath Parser context
10082: *
10083: * [30] Number ::= Digits ('.' Digits?)?
10084: * | '.' Digits
10085: * [31] Digits ::= [0-9]+
10086: *
10087: * Compile a Number, then push it on the stack
10088: *
10089: */
10090: static void
10091: xmlXPathCompNumber(xmlXPathParserContextPtr ctxt)
10092: {
10093: double ret = 0.0;
10094: int ok = 0;
10095: int exponent = 0;
10096: int is_exponent_negative = 0;
10097: #ifdef __GNUC__
10098: unsigned long tmp = 0;
10099: double temp;
10100: #endif
10101:
10102: CHECK_ERROR;
10103: if ((CUR != '.') && ((CUR < '0') || (CUR > '9'))) {
10104: XP_ERROR(XPATH_NUMBER_ERROR);
10105: }
10106: #ifdef __GNUC__
10107: /*
10108: * tmp/temp is a workaround against a gcc compiler bug
10109: * http://veillard.com/gcc.bug
10110: */
10111: ret = 0;
10112: while ((CUR >= '0') && (CUR <= '9')) {
10113: ret = ret * 10;
10114: tmp = (CUR - '0');
10115: ok = 1;
10116: NEXT;
10117: temp = (double) tmp;
10118: ret = ret + temp;
10119: }
10120: #else
10121: ret = 0;
10122: while ((CUR >= '0') && (CUR <= '9')) {
10123: ret = ret * 10 + (CUR - '0');
10124: ok = 1;
10125: NEXT;
10126: }
10127: #endif
10128: if (CUR == '.') {
10129: int v, frac = 0;
10130: double fraction = 0;
10131:
10132: NEXT;
10133: if (((CUR < '0') || (CUR > '9')) && (!ok)) {
10134: XP_ERROR(XPATH_NUMBER_ERROR);
10135: }
10136: while ((CUR >= '0') && (CUR <= '9') && (frac < MAX_FRAC)) {
10137: v = (CUR - '0');
10138: fraction = fraction * 10 + v;
10139: frac = frac + 1;
10140: NEXT;
10141: }
10142: fraction /= my_pow10[frac];
10143: ret = ret + fraction;
10144: while ((CUR >= '0') && (CUR <= '9'))
10145: NEXT;
10146: }
10147: if ((CUR == 'e') || (CUR == 'E')) {
10148: NEXT;
10149: if (CUR == '-') {
10150: is_exponent_negative = 1;
10151: NEXT;
10152: } else if (CUR == '+') {
10153: NEXT;
10154: }
10155: while ((CUR >= '0') && (CUR <= '9')) {
10156: exponent = exponent * 10 + (CUR - '0');
10157: NEXT;
10158: }
10159: if (is_exponent_negative)
10160: exponent = -exponent;
10161: ret *= pow(10.0, (double) exponent);
10162: }
10163: PUSH_LONG_EXPR(XPATH_OP_VALUE, XPATH_NUMBER, 0, 0,
10164: xmlXPathCacheNewFloat(ctxt->context, ret), NULL);
10165: }
10166:
10167: /**
10168: * xmlXPathParseLiteral:
10169: * @ctxt: the XPath Parser context
10170: *
10171: * Parse a Literal
10172: *
10173: * [29] Literal ::= '"' [^"]* '"'
10174: * | "'" [^']* "'"
10175: *
10176: * Returns the value found or NULL in case of error
10177: */
10178: static xmlChar *
10179: xmlXPathParseLiteral(xmlXPathParserContextPtr ctxt) {
10180: const xmlChar *q;
10181: xmlChar *ret = NULL;
10182:
10183: if (CUR == '"') {
10184: NEXT;
10185: q = CUR_PTR;
10186: while ((IS_CHAR_CH(CUR)) && (CUR != '"'))
10187: NEXT;
10188: if (!IS_CHAR_CH(CUR)) {
10189: XP_ERRORNULL(XPATH_UNFINISHED_LITERAL_ERROR);
10190: } else {
10191: ret = xmlStrndup(q, CUR_PTR - q);
10192: NEXT;
10193: }
10194: } else if (CUR == '\'') {
10195: NEXT;
10196: q = CUR_PTR;
10197: while ((IS_CHAR_CH(CUR)) && (CUR != '\''))
10198: NEXT;
10199: if (!IS_CHAR_CH(CUR)) {
10200: XP_ERRORNULL(XPATH_UNFINISHED_LITERAL_ERROR);
10201: } else {
10202: ret = xmlStrndup(q, CUR_PTR - q);
10203: NEXT;
10204: }
10205: } else {
10206: XP_ERRORNULL(XPATH_START_LITERAL_ERROR);
10207: }
10208: return(ret);
10209: }
10210:
10211: /**
10212: * xmlXPathCompLiteral:
10213: * @ctxt: the XPath Parser context
10214: *
10215: * Parse a Literal and push it on the stack.
10216: *
10217: * [29] Literal ::= '"' [^"]* '"'
10218: * | "'" [^']* "'"
10219: *
10220: * TODO: xmlXPathCompLiteral memory allocation could be improved.
10221: */
10222: static void
10223: xmlXPathCompLiteral(xmlXPathParserContextPtr ctxt) {
10224: const xmlChar *q;
10225: xmlChar *ret = NULL;
10226:
10227: if (CUR == '"') {
10228: NEXT;
10229: q = CUR_PTR;
10230: while ((IS_CHAR_CH(CUR)) && (CUR != '"'))
10231: NEXT;
10232: if (!IS_CHAR_CH(CUR)) {
10233: XP_ERROR(XPATH_UNFINISHED_LITERAL_ERROR);
10234: } else {
10235: ret = xmlStrndup(q, CUR_PTR - q);
10236: NEXT;
10237: }
10238: } else if (CUR == '\'') {
10239: NEXT;
10240: q = CUR_PTR;
10241: while ((IS_CHAR_CH(CUR)) && (CUR != '\''))
10242: NEXT;
10243: if (!IS_CHAR_CH(CUR)) {
10244: XP_ERROR(XPATH_UNFINISHED_LITERAL_ERROR);
10245: } else {
10246: ret = xmlStrndup(q, CUR_PTR - q);
10247: NEXT;
10248: }
10249: } else {
10250: XP_ERROR(XPATH_START_LITERAL_ERROR);
10251: }
10252: if (ret == NULL) return;
10253: PUSH_LONG_EXPR(XPATH_OP_VALUE, XPATH_STRING, 0, 0,
10254: xmlXPathCacheNewString(ctxt->context, ret), NULL);
10255: xmlFree(ret);
10256: }
10257:
10258: /**
10259: * xmlXPathCompVariableReference:
10260: * @ctxt: the XPath Parser context
10261: *
10262: * Parse a VariableReference, evaluate it and push it on the stack.
10263: *
10264: * The variable bindings consist of a mapping from variable names
10265: * to variable values. The value of a variable is an object, which can be
10266: * of any of the types that are possible for the value of an expression,
10267: * and may also be of additional types not specified here.
10268: *
10269: * Early evaluation is possible since:
10270: * The variable bindings [...] used to evaluate a subexpression are
10271: * always the same as those used to evaluate the containing expression.
10272: *
10273: * [36] VariableReference ::= '$' QName
10274: */
10275: static void
10276: xmlXPathCompVariableReference(xmlXPathParserContextPtr ctxt) {
10277: xmlChar *name;
10278: xmlChar *prefix;
10279:
10280: SKIP_BLANKS;
10281: if (CUR != '$') {
10282: XP_ERROR(XPATH_VARIABLE_REF_ERROR);
10283: }
10284: NEXT;
10285: name = xmlXPathParseQName(ctxt, &prefix);
10286: if (name == NULL) {
10287: XP_ERROR(XPATH_VARIABLE_REF_ERROR);
10288: }
10289: ctxt->comp->last = -1;
10290: PUSH_LONG_EXPR(XPATH_OP_VARIABLE, 0, 0, 0,
10291: name, prefix);
10292: SKIP_BLANKS;
10293: if ((ctxt->context != NULL) && (ctxt->context->flags & XML_XPATH_NOVAR)) {
10294: XP_ERROR(XPATH_UNDEF_VARIABLE_ERROR);
10295: }
10296: }
10297:
10298: /**
10299: * xmlXPathIsNodeType:
10300: * @name: a name string
10301: *
10302: * Is the name given a NodeType one.
10303: *
10304: * [38] NodeType ::= 'comment'
10305: * | 'text'
10306: * | 'processing-instruction'
10307: * | 'node'
10308: *
10309: * Returns 1 if true 0 otherwise
10310: */
10311: int
10312: xmlXPathIsNodeType(const xmlChar *name) {
10313: if (name == NULL)
10314: return(0);
10315:
10316: if (xmlStrEqual(name, BAD_CAST "node"))
10317: return(1);
10318: if (xmlStrEqual(name, BAD_CAST "text"))
10319: return(1);
10320: if (xmlStrEqual(name, BAD_CAST "comment"))
10321: return(1);
10322: if (xmlStrEqual(name, BAD_CAST "processing-instruction"))
10323: return(1);
10324: return(0);
10325: }
10326:
10327: /**
10328: * xmlXPathCompFunctionCall:
10329: * @ctxt: the XPath Parser context
10330: *
10331: * [16] FunctionCall ::= FunctionName '(' ( Argument ( ',' Argument)*)? ')'
10332: * [17] Argument ::= Expr
10333: *
10334: * Compile a function call, the evaluation of all arguments are
10335: * pushed on the stack
10336: */
10337: static void
10338: xmlXPathCompFunctionCall(xmlXPathParserContextPtr ctxt) {
10339: xmlChar *name;
10340: xmlChar *prefix;
10341: int nbargs = 0;
10342: int sort = 1;
10343:
10344: name = xmlXPathParseQName(ctxt, &prefix);
10345: if (name == NULL) {
10346: xmlFree(prefix);
10347: XP_ERROR(XPATH_EXPR_ERROR);
10348: }
10349: SKIP_BLANKS;
10350: #ifdef DEBUG_EXPR
10351: if (prefix == NULL)
10352: xmlGenericError(xmlGenericErrorContext, "Calling function %s\n",
10353: name);
10354: else
10355: xmlGenericError(xmlGenericErrorContext, "Calling function %s:%s\n",
10356: prefix, name);
10357: #endif
10358:
10359: if (CUR != '(') {
10360: XP_ERROR(XPATH_EXPR_ERROR);
10361: }
10362: NEXT;
10363: SKIP_BLANKS;
10364:
10365: /*
10366: * Optimization for count(): we don't need the node-set to be sorted.
10367: */
10368: if ((prefix == NULL) && (name[0] == 'c') &&
10369: xmlStrEqual(name, BAD_CAST "count"))
10370: {
10371: sort = 0;
10372: }
10373: ctxt->comp->last = -1;
10374: if (CUR != ')') {
10375: while (CUR != 0) {
10376: int op1 = ctxt->comp->last;
10377: ctxt->comp->last = -1;
10378: xmlXPathCompileExpr(ctxt, sort);
10379: if (ctxt->error != XPATH_EXPRESSION_OK) {
10380: xmlFree(name);
10381: xmlFree(prefix);
10382: return;
10383: }
10384: PUSH_BINARY_EXPR(XPATH_OP_ARG, op1, ctxt->comp->last, 0, 0);
10385: nbargs++;
10386: if (CUR == ')') break;
10387: if (CUR != ',') {
10388: XP_ERROR(XPATH_EXPR_ERROR);
10389: }
10390: NEXT;
10391: SKIP_BLANKS;
10392: }
10393: }
10394: PUSH_LONG_EXPR(XPATH_OP_FUNCTION, nbargs, 0, 0,
10395: name, prefix);
10396: NEXT;
10397: SKIP_BLANKS;
10398: }
10399:
10400: /**
10401: * xmlXPathCompPrimaryExpr:
10402: * @ctxt: the XPath Parser context
10403: *
10404: * [15] PrimaryExpr ::= VariableReference
10405: * | '(' Expr ')'
10406: * | Literal
10407: * | Number
10408: * | FunctionCall
10409: *
10410: * Compile a primary expression.
10411: */
10412: static void
10413: xmlXPathCompPrimaryExpr(xmlXPathParserContextPtr ctxt) {
10414: SKIP_BLANKS;
10415: if (CUR == '$') xmlXPathCompVariableReference(ctxt);
10416: else if (CUR == '(') {
10417: NEXT;
10418: SKIP_BLANKS;
10419: xmlXPathCompileExpr(ctxt, 1);
10420: CHECK_ERROR;
10421: if (CUR != ')') {
10422: XP_ERROR(XPATH_EXPR_ERROR);
10423: }
10424: NEXT;
10425: SKIP_BLANKS;
10426: } else if (IS_ASCII_DIGIT(CUR) || (CUR == '.' && IS_ASCII_DIGIT(NXT(1)))) {
10427: xmlXPathCompNumber(ctxt);
10428: } else if ((CUR == '\'') || (CUR == '"')) {
10429: xmlXPathCompLiteral(ctxt);
10430: } else {
10431: xmlXPathCompFunctionCall(ctxt);
10432: }
10433: SKIP_BLANKS;
10434: }
10435:
10436: /**
10437: * xmlXPathCompFilterExpr:
10438: * @ctxt: the XPath Parser context
10439: *
10440: * [20] FilterExpr ::= PrimaryExpr
10441: * | FilterExpr Predicate
10442: *
10443: * Compile a filter expression.
10444: * Square brackets are used to filter expressions in the same way that
10445: * they are used in location paths. It is an error if the expression to
10446: * be filtered does not evaluate to a node-set. The context node list
10447: * used for evaluating the expression in square brackets is the node-set
10448: * to be filtered listed in document order.
10449: */
10450:
10451: static void
10452: xmlXPathCompFilterExpr(xmlXPathParserContextPtr ctxt) {
10453: xmlXPathCompPrimaryExpr(ctxt);
10454: CHECK_ERROR;
10455: SKIP_BLANKS;
10456:
10457: while (CUR == '[') {
10458: xmlXPathCompPredicate(ctxt, 1);
10459: SKIP_BLANKS;
10460: }
10461:
10462:
10463: }
10464:
10465: /**
10466: * xmlXPathScanName:
10467: * @ctxt: the XPath Parser context
10468: *
10469: * Trickery: parse an XML name but without consuming the input flow
10470: * Needed to avoid insanity in the parser state.
10471: *
10472: * [4] NameChar ::= Letter | Digit | '.' | '-' | '_' | ':' |
10473: * CombiningChar | Extender
10474: *
10475: * [5] Name ::= (Letter | '_' | ':') (NameChar)*
10476: *
10477: * [6] Names ::= Name (S Name)*
10478: *
10479: * Returns the Name parsed or NULL
10480: */
10481:
10482: static xmlChar *
10483: xmlXPathScanName(xmlXPathParserContextPtr ctxt) {
10484: int len = 0, l;
10485: int c;
10486: const xmlChar *cur;
10487: xmlChar *ret;
10488:
10489: cur = ctxt->cur;
10490:
10491: c = CUR_CHAR(l);
10492: if ((c == ' ') || (c == '>') || (c == '/') || /* accelerators */
10493: (!IS_LETTER(c) && (c != '_') &&
10494: (c != ':'))) {
10495: return(NULL);
10496: }
10497:
10498: while ((c != ' ') && (c != '>') && (c != '/') && /* test bigname.xml */
10499: ((IS_LETTER(c)) || (IS_DIGIT(c)) ||
10500: (c == '.') || (c == '-') ||
10501: (c == '_') || (c == ':') ||
10502: (IS_COMBINING(c)) ||
10503: (IS_EXTENDER(c)))) {
10504: len += l;
10505: NEXTL(l);
10506: c = CUR_CHAR(l);
10507: }
10508: ret = xmlStrndup(cur, ctxt->cur - cur);
10509: ctxt->cur = cur;
10510: return(ret);
10511: }
10512:
10513: /**
10514: * xmlXPathCompPathExpr:
10515: * @ctxt: the XPath Parser context
10516: *
10517: * [19] PathExpr ::= LocationPath
10518: * | FilterExpr
10519: * | FilterExpr '/' RelativeLocationPath
10520: * | FilterExpr '//' RelativeLocationPath
10521: *
10522: * Compile a path expression.
10523: * The / operator and // operators combine an arbitrary expression
10524: * and a relative location path. It is an error if the expression
10525: * does not evaluate to a node-set.
10526: * The / operator does composition in the same way as when / is
10527: * used in a location path. As in location paths, // is short for
10528: * /descendant-or-self::node()/.
10529: */
10530:
10531: static void
10532: xmlXPathCompPathExpr(xmlXPathParserContextPtr ctxt) {
10533: int lc = 1; /* Should we branch to LocationPath ? */
10534: xmlChar *name = NULL; /* we may have to preparse a name to find out */
10535:
10536: SKIP_BLANKS;
10537: if ((CUR == '$') || (CUR == '(') ||
10538: (IS_ASCII_DIGIT(CUR)) ||
10539: (CUR == '\'') || (CUR == '"') ||
10540: (CUR == '.' && IS_ASCII_DIGIT(NXT(1)))) {
10541: lc = 0;
10542: } else if (CUR == '*') {
10543: /* relative or absolute location path */
10544: lc = 1;
10545: } else if (CUR == '/') {
10546: /* relative or absolute location path */
10547: lc = 1;
10548: } else if (CUR == '@') {
10549: /* relative abbreviated attribute location path */
10550: lc = 1;
10551: } else if (CUR == '.') {
10552: /* relative abbreviated attribute location path */
10553: lc = 1;
10554: } else {
10555: /*
10556: * Problem is finding if we have a name here whether it's:
10557: * - a nodetype
10558: * - a function call in which case it's followed by '('
10559: * - an axis in which case it's followed by ':'
10560: * - a element name
10561: * We do an a priori analysis here rather than having to
10562: * maintain parsed token content through the recursive function
10563: * calls. This looks uglier but makes the code easier to
10564: * read/write/debug.
10565: */
10566: SKIP_BLANKS;
10567: name = xmlXPathScanName(ctxt);
10568: if ((name != NULL) && (xmlStrstr(name, (xmlChar *) "::") != NULL)) {
10569: #ifdef DEBUG_STEP
10570: xmlGenericError(xmlGenericErrorContext,
10571: "PathExpr: Axis\n");
10572: #endif
10573: lc = 1;
10574: xmlFree(name);
10575: } else if (name != NULL) {
10576: int len =xmlStrlen(name);
10577:
10578:
10579: while (NXT(len) != 0) {
10580: if (NXT(len) == '/') {
10581: /* element name */
10582: #ifdef DEBUG_STEP
10583: xmlGenericError(xmlGenericErrorContext,
10584: "PathExpr: AbbrRelLocation\n");
10585: #endif
10586: lc = 1;
10587: break;
10588: } else if (IS_BLANK_CH(NXT(len))) {
10589: /* ignore blanks */
10590: ;
10591: } else if (NXT(len) == ':') {
10592: #ifdef DEBUG_STEP
10593: xmlGenericError(xmlGenericErrorContext,
10594: "PathExpr: AbbrRelLocation\n");
10595: #endif
10596: lc = 1;
10597: break;
10598: } else if ((NXT(len) == '(')) {
10599: /* Note Type or Function */
10600: if (xmlXPathIsNodeType(name)) {
10601: #ifdef DEBUG_STEP
10602: xmlGenericError(xmlGenericErrorContext,
10603: "PathExpr: Type search\n");
10604: #endif
10605: lc = 1;
10606: } else {
10607: #ifdef DEBUG_STEP
10608: xmlGenericError(xmlGenericErrorContext,
10609: "PathExpr: function call\n");
10610: #endif
10611: lc = 0;
10612: }
10613: break;
10614: } else if ((NXT(len) == '[')) {
10615: /* element name */
10616: #ifdef DEBUG_STEP
10617: xmlGenericError(xmlGenericErrorContext,
10618: "PathExpr: AbbrRelLocation\n");
10619: #endif
10620: lc = 1;
10621: break;
10622: } else if ((NXT(len) == '<') || (NXT(len) == '>') ||
10623: (NXT(len) == '=')) {
10624: lc = 1;
10625: break;
10626: } else {
10627: lc = 1;
10628: break;
10629: }
10630: len++;
10631: }
10632: if (NXT(len) == 0) {
10633: #ifdef DEBUG_STEP
10634: xmlGenericError(xmlGenericErrorContext,
10635: "PathExpr: AbbrRelLocation\n");
10636: #endif
10637: /* element name */
10638: lc = 1;
10639: }
10640: xmlFree(name);
10641: } else {
10642: /* make sure all cases are covered explicitly */
10643: XP_ERROR(XPATH_EXPR_ERROR);
10644: }
10645: }
10646:
10647: if (lc) {
10648: if (CUR == '/') {
10649: PUSH_LEAVE_EXPR(XPATH_OP_ROOT, 0, 0);
10650: } else {
10651: PUSH_LEAVE_EXPR(XPATH_OP_NODE, 0, 0);
10652: }
10653: xmlXPathCompLocationPath(ctxt);
10654: } else {
10655: xmlXPathCompFilterExpr(ctxt);
10656: CHECK_ERROR;
10657: if ((CUR == '/') && (NXT(1) == '/')) {
10658: SKIP(2);
10659: SKIP_BLANKS;
10660:
10661: PUSH_LONG_EXPR(XPATH_OP_COLLECT, AXIS_DESCENDANT_OR_SELF,
10662: NODE_TEST_TYPE, NODE_TYPE_NODE, NULL, NULL);
10663: PUSH_UNARY_EXPR(XPATH_OP_RESET, ctxt->comp->last, 1, 0);
10664:
10665: xmlXPathCompRelativeLocationPath(ctxt);
10666: } else if (CUR == '/') {
10667: xmlXPathCompRelativeLocationPath(ctxt);
10668: }
10669: }
10670: SKIP_BLANKS;
10671: }
10672:
10673: /**
10674: * xmlXPathCompUnionExpr:
10675: * @ctxt: the XPath Parser context
10676: *
10677: * [18] UnionExpr ::= PathExpr
10678: * | UnionExpr '|' PathExpr
10679: *
10680: * Compile an union expression.
10681: */
10682:
10683: static void
10684: xmlXPathCompUnionExpr(xmlXPathParserContextPtr ctxt) {
10685: xmlXPathCompPathExpr(ctxt);
10686: CHECK_ERROR;
10687: SKIP_BLANKS;
10688: while (CUR == '|') {
10689: int op1 = ctxt->comp->last;
10690: PUSH_LEAVE_EXPR(XPATH_OP_NODE, 0, 0);
10691:
10692: NEXT;
10693: SKIP_BLANKS;
10694: xmlXPathCompPathExpr(ctxt);
10695:
10696: PUSH_BINARY_EXPR(XPATH_OP_UNION, op1, ctxt->comp->last, 0, 0);
10697:
10698: SKIP_BLANKS;
10699: }
10700: }
10701:
10702: /**
10703: * xmlXPathCompUnaryExpr:
10704: * @ctxt: the XPath Parser context
10705: *
10706: * [27] UnaryExpr ::= UnionExpr
10707: * | '-' UnaryExpr
10708: *
10709: * Compile an unary expression.
10710: */
10711:
10712: static void
10713: xmlXPathCompUnaryExpr(xmlXPathParserContextPtr ctxt) {
10714: int minus = 0;
10715: int found = 0;
10716:
10717: SKIP_BLANKS;
10718: while (CUR == '-') {
10719: minus = 1 - minus;
10720: found = 1;
10721: NEXT;
10722: SKIP_BLANKS;
10723: }
10724:
10725: xmlXPathCompUnionExpr(ctxt);
10726: CHECK_ERROR;
10727: if (found) {
10728: if (minus)
10729: PUSH_UNARY_EXPR(XPATH_OP_PLUS, ctxt->comp->last, 2, 0);
10730: else
10731: PUSH_UNARY_EXPR(XPATH_OP_PLUS, ctxt->comp->last, 3, 0);
10732: }
10733: }
10734:
10735: /**
10736: * xmlXPathCompMultiplicativeExpr:
10737: * @ctxt: the XPath Parser context
10738: *
10739: * [26] MultiplicativeExpr ::= UnaryExpr
10740: * | MultiplicativeExpr MultiplyOperator UnaryExpr
10741: * | MultiplicativeExpr 'div' UnaryExpr
10742: * | MultiplicativeExpr 'mod' UnaryExpr
10743: * [34] MultiplyOperator ::= '*'
10744: *
10745: * Compile an Additive expression.
10746: */
10747:
10748: static void
10749: xmlXPathCompMultiplicativeExpr(xmlXPathParserContextPtr ctxt) {
10750: xmlXPathCompUnaryExpr(ctxt);
10751: CHECK_ERROR;
10752: SKIP_BLANKS;
10753: while ((CUR == '*') ||
10754: ((CUR == 'd') && (NXT(1) == 'i') && (NXT(2) == 'v')) ||
10755: ((CUR == 'm') && (NXT(1) == 'o') && (NXT(2) == 'd'))) {
10756: int op = -1;
10757: int op1 = ctxt->comp->last;
10758:
10759: if (CUR == '*') {
10760: op = 0;
10761: NEXT;
10762: } else if (CUR == 'd') {
10763: op = 1;
10764: SKIP(3);
10765: } else if (CUR == 'm') {
10766: op = 2;
10767: SKIP(3);
10768: }
10769: SKIP_BLANKS;
10770: xmlXPathCompUnaryExpr(ctxt);
10771: CHECK_ERROR;
10772: PUSH_BINARY_EXPR(XPATH_OP_MULT, op1, ctxt->comp->last, op, 0);
10773: SKIP_BLANKS;
10774: }
10775: }
10776:
10777: /**
10778: * xmlXPathCompAdditiveExpr:
10779: * @ctxt: the XPath Parser context
10780: *
10781: * [25] AdditiveExpr ::= MultiplicativeExpr
10782: * | AdditiveExpr '+' MultiplicativeExpr
10783: * | AdditiveExpr '-' MultiplicativeExpr
10784: *
10785: * Compile an Additive expression.
10786: */
10787:
10788: static void
10789: xmlXPathCompAdditiveExpr(xmlXPathParserContextPtr ctxt) {
10790:
10791: xmlXPathCompMultiplicativeExpr(ctxt);
10792: CHECK_ERROR;
10793: SKIP_BLANKS;
10794: while ((CUR == '+') || (CUR == '-')) {
10795: int plus;
10796: int op1 = ctxt->comp->last;
10797:
10798: if (CUR == '+') plus = 1;
10799: else plus = 0;
10800: NEXT;
10801: SKIP_BLANKS;
10802: xmlXPathCompMultiplicativeExpr(ctxt);
10803: CHECK_ERROR;
10804: PUSH_BINARY_EXPR(XPATH_OP_PLUS, op1, ctxt->comp->last, plus, 0);
10805: SKIP_BLANKS;
10806: }
10807: }
10808:
10809: /**
10810: * xmlXPathCompRelationalExpr:
10811: * @ctxt: the XPath Parser context
10812: *
10813: * [24] RelationalExpr ::= AdditiveExpr
10814: * | RelationalExpr '<' AdditiveExpr
10815: * | RelationalExpr '>' AdditiveExpr
10816: * | RelationalExpr '<=' AdditiveExpr
10817: * | RelationalExpr '>=' AdditiveExpr
10818: *
10819: * A <= B > C is allowed ? Answer from James, yes with
10820: * (AdditiveExpr <= AdditiveExpr) > AdditiveExpr
10821: * which is basically what got implemented.
10822: *
10823: * Compile a Relational expression, then push the result
10824: * on the stack
10825: */
10826:
10827: static void
10828: xmlXPathCompRelationalExpr(xmlXPathParserContextPtr ctxt) {
10829: xmlXPathCompAdditiveExpr(ctxt);
10830: CHECK_ERROR;
10831: SKIP_BLANKS;
10832: while ((CUR == '<') ||
10833: (CUR == '>') ||
10834: ((CUR == '<') && (NXT(1) == '=')) ||
10835: ((CUR == '>') && (NXT(1) == '='))) {
10836: int inf, strict;
10837: int op1 = ctxt->comp->last;
10838:
10839: if (CUR == '<') inf = 1;
10840: else inf = 0;
10841: if (NXT(1) == '=') strict = 0;
10842: else strict = 1;
10843: NEXT;
10844: if (!strict) NEXT;
10845: SKIP_BLANKS;
10846: xmlXPathCompAdditiveExpr(ctxt);
10847: CHECK_ERROR;
10848: PUSH_BINARY_EXPR(XPATH_OP_CMP, op1, ctxt->comp->last, inf, strict);
10849: SKIP_BLANKS;
10850: }
10851: }
10852:
10853: /**
10854: * xmlXPathCompEqualityExpr:
10855: * @ctxt: the XPath Parser context
10856: *
10857: * [23] EqualityExpr ::= RelationalExpr
10858: * | EqualityExpr '=' RelationalExpr
10859: * | EqualityExpr '!=' RelationalExpr
10860: *
10861: * A != B != C is allowed ? Answer from James, yes with
10862: * (RelationalExpr = RelationalExpr) = RelationalExpr
10863: * (RelationalExpr != RelationalExpr) != RelationalExpr
10864: * which is basically what got implemented.
10865: *
10866: * Compile an Equality expression.
10867: *
10868: */
10869: static void
10870: xmlXPathCompEqualityExpr(xmlXPathParserContextPtr ctxt) {
10871: xmlXPathCompRelationalExpr(ctxt);
10872: CHECK_ERROR;
10873: SKIP_BLANKS;
10874: while ((CUR == '=') || ((CUR == '!') && (NXT(1) == '='))) {
10875: int eq;
10876: int op1 = ctxt->comp->last;
10877:
10878: if (CUR == '=') eq = 1;
10879: else eq = 0;
10880: NEXT;
10881: if (!eq) NEXT;
10882: SKIP_BLANKS;
10883: xmlXPathCompRelationalExpr(ctxt);
10884: CHECK_ERROR;
10885: PUSH_BINARY_EXPR(XPATH_OP_EQUAL, op1, ctxt->comp->last, eq, 0);
10886: SKIP_BLANKS;
10887: }
10888: }
10889:
10890: /**
10891: * xmlXPathCompAndExpr:
10892: * @ctxt: the XPath Parser context
10893: *
10894: * [22] AndExpr ::= EqualityExpr
10895: * | AndExpr 'and' EqualityExpr
10896: *
10897: * Compile an AND expression.
10898: *
10899: */
10900: static void
10901: xmlXPathCompAndExpr(xmlXPathParserContextPtr ctxt) {
10902: xmlXPathCompEqualityExpr(ctxt);
10903: CHECK_ERROR;
10904: SKIP_BLANKS;
10905: while ((CUR == 'a') && (NXT(1) == 'n') && (NXT(2) == 'd')) {
10906: int op1 = ctxt->comp->last;
10907: SKIP(3);
10908: SKIP_BLANKS;
10909: xmlXPathCompEqualityExpr(ctxt);
10910: CHECK_ERROR;
10911: PUSH_BINARY_EXPR(XPATH_OP_AND, op1, ctxt->comp->last, 0, 0);
10912: SKIP_BLANKS;
10913: }
10914: }
10915:
10916: /**
10917: * xmlXPathCompileExpr:
10918: * @ctxt: the XPath Parser context
10919: *
10920: * [14] Expr ::= OrExpr
10921: * [21] OrExpr ::= AndExpr
10922: * | OrExpr 'or' AndExpr
10923: *
10924: * Parse and compile an expression
10925: */
10926: static void
10927: xmlXPathCompileExpr(xmlXPathParserContextPtr ctxt, int sort) {
10928: xmlXPathCompAndExpr(ctxt);
10929: CHECK_ERROR;
10930: SKIP_BLANKS;
10931: while ((CUR == 'o') && (NXT(1) == 'r')) {
10932: int op1 = ctxt->comp->last;
10933: SKIP(2);
10934: SKIP_BLANKS;
10935: xmlXPathCompAndExpr(ctxt);
10936: CHECK_ERROR;
10937: PUSH_BINARY_EXPR(XPATH_OP_OR, op1, ctxt->comp->last, 0, 0);
10938: SKIP_BLANKS;
10939: }
10940: if ((sort) && (ctxt->comp->steps[ctxt->comp->last].op != XPATH_OP_VALUE)) {
10941: /* more ops could be optimized too */
10942: /*
10943: * This is the main place to eliminate sorting for
10944: * operations which don't require a sorted node-set.
10945: * E.g. count().
10946: */
10947: PUSH_UNARY_EXPR(XPATH_OP_SORT, ctxt->comp->last , 0, 0);
10948: }
10949: }
10950:
10951: /**
10952: * xmlXPathCompPredicate:
10953: * @ctxt: the XPath Parser context
10954: * @filter: act as a filter
10955: *
10956: * [8] Predicate ::= '[' PredicateExpr ']'
10957: * [9] PredicateExpr ::= Expr
10958: *
10959: * Compile a predicate expression
10960: */
10961: static void
10962: xmlXPathCompPredicate(xmlXPathParserContextPtr ctxt, int filter) {
10963: int op1 = ctxt->comp->last;
10964:
10965: SKIP_BLANKS;
10966: if (CUR != '[') {
10967: XP_ERROR(XPATH_INVALID_PREDICATE_ERROR);
10968: }
10969: NEXT;
10970: SKIP_BLANKS;
10971:
10972: ctxt->comp->last = -1;
10973: /*
10974: * This call to xmlXPathCompileExpr() will deactivate sorting
10975: * of the predicate result.
10976: * TODO: Sorting is still activated for filters, since I'm not
10977: * sure if needed. Normally sorting should not be needed, since
10978: * a filter can only diminish the number of items in a sequence,
10979: * but won't change its order; so if the initial sequence is sorted,
10980: * subsequent sorting is not needed.
10981: */
10982: if (! filter)
10983: xmlXPathCompileExpr(ctxt, 0);
10984: else
10985: xmlXPathCompileExpr(ctxt, 1);
10986: CHECK_ERROR;
10987:
10988: if (CUR != ']') {
10989: XP_ERROR(XPATH_INVALID_PREDICATE_ERROR);
10990: }
10991:
10992: if (filter)
10993: PUSH_BINARY_EXPR(XPATH_OP_FILTER, op1, ctxt->comp->last, 0, 0);
10994: else
10995: PUSH_BINARY_EXPR(XPATH_OP_PREDICATE, op1, ctxt->comp->last, 0, 0);
10996:
10997: NEXT;
10998: SKIP_BLANKS;
10999: }
11000:
11001: /**
11002: * xmlXPathCompNodeTest:
11003: * @ctxt: the XPath Parser context
11004: * @test: pointer to a xmlXPathTestVal
11005: * @type: pointer to a xmlXPathTypeVal
11006: * @prefix: placeholder for a possible name prefix
11007: *
11008: * [7] NodeTest ::= NameTest
11009: * | NodeType '(' ')'
11010: * | 'processing-instruction' '(' Literal ')'
11011: *
11012: * [37] NameTest ::= '*'
11013: * | NCName ':' '*'
11014: * | QName
11015: * [38] NodeType ::= 'comment'
11016: * | 'text'
11017: * | 'processing-instruction'
11018: * | 'node'
11019: *
11020: * Returns the name found and updates @test, @type and @prefix appropriately
11021: */
11022: static xmlChar *
11023: xmlXPathCompNodeTest(xmlXPathParserContextPtr ctxt, xmlXPathTestVal *test,
11024: xmlXPathTypeVal *type, const xmlChar **prefix,
11025: xmlChar *name) {
11026: int blanks;
11027:
11028: if ((test == NULL) || (type == NULL) || (prefix == NULL)) {
11029: STRANGE;
11030: return(NULL);
11031: }
11032: *type = (xmlXPathTypeVal) 0;
11033: *test = (xmlXPathTestVal) 0;
11034: *prefix = NULL;
11035: SKIP_BLANKS;
11036:
11037: if ((name == NULL) && (CUR == '*')) {
11038: /*
11039: * All elements
11040: */
11041: NEXT;
11042: *test = NODE_TEST_ALL;
11043: return(NULL);
11044: }
11045:
11046: if (name == NULL)
11047: name = xmlXPathParseNCName(ctxt);
11048: if (name == NULL) {
11049: XP_ERRORNULL(XPATH_EXPR_ERROR);
11050: }
11051:
11052: blanks = IS_BLANK_CH(CUR);
11053: SKIP_BLANKS;
11054: if (CUR == '(') {
11055: NEXT;
11056: /*
11057: * NodeType or PI search
11058: */
11059: if (xmlStrEqual(name, BAD_CAST "comment"))
11060: *type = NODE_TYPE_COMMENT;
11061: else if (xmlStrEqual(name, BAD_CAST "node"))
11062: *type = NODE_TYPE_NODE;
11063: else if (xmlStrEqual(name, BAD_CAST "processing-instruction"))
11064: *type = NODE_TYPE_PI;
11065: else if (xmlStrEqual(name, BAD_CAST "text"))
11066: *type = NODE_TYPE_TEXT;
11067: else {
11068: if (name != NULL)
11069: xmlFree(name);
11070: XP_ERRORNULL(XPATH_EXPR_ERROR);
11071: }
11072:
11073: *test = NODE_TEST_TYPE;
11074:
11075: SKIP_BLANKS;
11076: if (*type == NODE_TYPE_PI) {
11077: /*
11078: * Specific case: search a PI by name.
11079: */
11080: if (name != NULL)
11081: xmlFree(name);
11082: name = NULL;
11083: if (CUR != ')') {
11084: name = xmlXPathParseLiteral(ctxt);
11085: CHECK_ERROR NULL;
11086: *test = NODE_TEST_PI;
11087: SKIP_BLANKS;
11088: }
11089: }
11090: if (CUR != ')') {
11091: if (name != NULL)
11092: xmlFree(name);
11093: XP_ERRORNULL(XPATH_UNCLOSED_ERROR);
11094: }
11095: NEXT;
11096: return(name);
11097: }
11098: *test = NODE_TEST_NAME;
11099: if ((!blanks) && (CUR == ':')) {
11100: NEXT;
11101:
11102: /*
11103: * Since currently the parser context don't have a
11104: * namespace list associated:
11105: * The namespace name for this prefix can be computed
11106: * only at evaluation time. The compilation is done
11107: * outside of any context.
11108: */
11109: #if 0
11110: *prefix = xmlXPathNsLookup(ctxt->context, name);
11111: if (name != NULL)
11112: xmlFree(name);
11113: if (*prefix == NULL) {
11114: XP_ERROR0(XPATH_UNDEF_PREFIX_ERROR);
11115: }
11116: #else
11117: *prefix = name;
11118: #endif
11119:
11120: if (CUR == '*') {
11121: /*
11122: * All elements
11123: */
11124: NEXT;
11125: *test = NODE_TEST_ALL;
11126: return(NULL);
11127: }
11128:
11129: name = xmlXPathParseNCName(ctxt);
11130: if (name == NULL) {
11131: XP_ERRORNULL(XPATH_EXPR_ERROR);
11132: }
11133: }
11134: return(name);
11135: }
11136:
11137: /**
11138: * xmlXPathIsAxisName:
11139: * @name: a preparsed name token
11140: *
11141: * [6] AxisName ::= 'ancestor'
11142: * | 'ancestor-or-self'
11143: * | 'attribute'
11144: * | 'child'
11145: * | 'descendant'
11146: * | 'descendant-or-self'
11147: * | 'following'
11148: * | 'following-sibling'
11149: * | 'namespace'
11150: * | 'parent'
11151: * | 'preceding'
11152: * | 'preceding-sibling'
11153: * | 'self'
11154: *
11155: * Returns the axis or 0
11156: */
11157: static xmlXPathAxisVal
11158: xmlXPathIsAxisName(const xmlChar *name) {
11159: xmlXPathAxisVal ret = (xmlXPathAxisVal) 0;
11160: switch (name[0]) {
11161: case 'a':
11162: if (xmlStrEqual(name, BAD_CAST "ancestor"))
11163: ret = AXIS_ANCESTOR;
11164: if (xmlStrEqual(name, BAD_CAST "ancestor-or-self"))
11165: ret = AXIS_ANCESTOR_OR_SELF;
11166: if (xmlStrEqual(name, BAD_CAST "attribute"))
11167: ret = AXIS_ATTRIBUTE;
11168: break;
11169: case 'c':
11170: if (xmlStrEqual(name, BAD_CAST "child"))
11171: ret = AXIS_CHILD;
11172: break;
11173: case 'd':
11174: if (xmlStrEqual(name, BAD_CAST "descendant"))
11175: ret = AXIS_DESCENDANT;
11176: if (xmlStrEqual(name, BAD_CAST "descendant-or-self"))
11177: ret = AXIS_DESCENDANT_OR_SELF;
11178: break;
11179: case 'f':
11180: if (xmlStrEqual(name, BAD_CAST "following"))
11181: ret = AXIS_FOLLOWING;
11182: if (xmlStrEqual(name, BAD_CAST "following-sibling"))
11183: ret = AXIS_FOLLOWING_SIBLING;
11184: break;
11185: case 'n':
11186: if (xmlStrEqual(name, BAD_CAST "namespace"))
11187: ret = AXIS_NAMESPACE;
11188: break;
11189: case 'p':
11190: if (xmlStrEqual(name, BAD_CAST "parent"))
11191: ret = AXIS_PARENT;
11192: if (xmlStrEqual(name, BAD_CAST "preceding"))
11193: ret = AXIS_PRECEDING;
11194: if (xmlStrEqual(name, BAD_CAST "preceding-sibling"))
11195: ret = AXIS_PRECEDING_SIBLING;
11196: break;
11197: case 's':
11198: if (xmlStrEqual(name, BAD_CAST "self"))
11199: ret = AXIS_SELF;
11200: break;
11201: }
11202: return(ret);
11203: }
11204:
11205: /**
11206: * xmlXPathCompStep:
11207: * @ctxt: the XPath Parser context
11208: *
11209: * [4] Step ::= AxisSpecifier NodeTest Predicate*
11210: * | AbbreviatedStep
11211: *
11212: * [12] AbbreviatedStep ::= '.' | '..'
11213: *
11214: * [5] AxisSpecifier ::= AxisName '::'
11215: * | AbbreviatedAxisSpecifier
11216: *
11217: * [13] AbbreviatedAxisSpecifier ::= '@'?
11218: *
11219: * Modified for XPtr range support as:
11220: *
11221: * [4xptr] Step ::= AxisSpecifier NodeTest Predicate*
11222: * | AbbreviatedStep
11223: * | 'range-to' '(' Expr ')' Predicate*
11224: *
11225: * Compile one step in a Location Path
11226: * A location step of . is short for self::node(). This is
11227: * particularly useful in conjunction with //. For example, the
11228: * location path .//para is short for
11229: * self::node()/descendant-or-self::node()/child::para
11230: * and so will select all para descendant elements of the context
11231: * node.
11232: * Similarly, a location step of .. is short for parent::node().
11233: * For example, ../title is short for parent::node()/child::title
11234: * and so will select the title children of the parent of the context
11235: * node.
11236: */
11237: static void
11238: xmlXPathCompStep(xmlXPathParserContextPtr ctxt) {
11239: #ifdef LIBXML_XPTR_ENABLED
11240: int rangeto = 0;
11241: int op2 = -1;
11242: #endif
11243:
11244: SKIP_BLANKS;
11245: if ((CUR == '.') && (NXT(1) == '.')) {
11246: SKIP(2);
11247: SKIP_BLANKS;
11248: PUSH_LONG_EXPR(XPATH_OP_COLLECT, AXIS_PARENT,
11249: NODE_TEST_TYPE, NODE_TYPE_NODE, NULL, NULL);
11250: } else if (CUR == '.') {
11251: NEXT;
11252: SKIP_BLANKS;
11253: } else {
11254: xmlChar *name = NULL;
11255: const xmlChar *prefix = NULL;
11256: xmlXPathTestVal test = (xmlXPathTestVal) 0;
11257: xmlXPathAxisVal axis = (xmlXPathAxisVal) 0;
11258: xmlXPathTypeVal type = (xmlXPathTypeVal) 0;
11259: int op1;
11260:
11261: /*
11262: * The modification needed for XPointer change to the production
11263: */
11264: #ifdef LIBXML_XPTR_ENABLED
11265: if (ctxt->xptr) {
11266: name = xmlXPathParseNCName(ctxt);
11267: if ((name != NULL) && (xmlStrEqual(name, BAD_CAST "range-to"))) {
11268: op2 = ctxt->comp->last;
11269: xmlFree(name);
11270: SKIP_BLANKS;
11271: if (CUR != '(') {
11272: XP_ERROR(XPATH_EXPR_ERROR);
11273: }
11274: NEXT;
11275: SKIP_BLANKS;
11276:
11277: xmlXPathCompileExpr(ctxt, 1);
11278: /* PUSH_BINARY_EXPR(XPATH_OP_RANGETO, op2, ctxt->comp->last, 0, 0); */
11279: CHECK_ERROR;
11280:
11281: SKIP_BLANKS;
11282: if (CUR != ')') {
11283: XP_ERROR(XPATH_EXPR_ERROR);
11284: }
11285: NEXT;
11286: rangeto = 1;
11287: goto eval_predicates;
11288: }
11289: }
11290: #endif
11291: if (CUR == '*') {
11292: axis = AXIS_CHILD;
11293: } else {
11294: if (name == NULL)
11295: name = xmlXPathParseNCName(ctxt);
11296: if (name != NULL) {
11297: axis = xmlXPathIsAxisName(name);
11298: if (axis != 0) {
11299: SKIP_BLANKS;
11300: if ((CUR == ':') && (NXT(1) == ':')) {
11301: SKIP(2);
11302: xmlFree(name);
11303: name = NULL;
11304: } else {
11305: /* an element name can conflict with an axis one :-\ */
11306: axis = AXIS_CHILD;
11307: }
11308: } else {
11309: axis = AXIS_CHILD;
11310: }
11311: } else if (CUR == '@') {
11312: NEXT;
11313: axis = AXIS_ATTRIBUTE;
11314: } else {
11315: axis = AXIS_CHILD;
11316: }
11317: }
11318:
11319: if (ctxt->error != XPATH_EXPRESSION_OK) {
11320: xmlFree(name);
11321: return;
11322: }
11323:
11324: name = xmlXPathCompNodeTest(ctxt, &test, &type, &prefix, name);
11325: if (test == 0)
11326: return;
11327:
11328: if ((prefix != NULL) && (ctxt->context != NULL) &&
11329: (ctxt->context->flags & XML_XPATH_CHECKNS)) {
11330: if (xmlXPathNsLookup(ctxt->context, prefix) == NULL) {
11331: xmlXPathErr(ctxt, XPATH_UNDEF_PREFIX_ERROR);
11332: }
11333: }
11334: #ifdef DEBUG_STEP
11335: xmlGenericError(xmlGenericErrorContext,
11336: "Basis : computing new set\n");
11337: #endif
11338:
11339: #ifdef DEBUG_STEP
11340: xmlGenericError(xmlGenericErrorContext, "Basis : ");
11341: if (ctxt->value == NULL)
11342: xmlGenericError(xmlGenericErrorContext, "no value\n");
11343: else if (ctxt->value->nodesetval == NULL)
11344: xmlGenericError(xmlGenericErrorContext, "Empty\n");
11345: else
11346: xmlGenericErrorContextNodeSet(stdout, ctxt->value->nodesetval);
11347: #endif
11348:
11349: #ifdef LIBXML_XPTR_ENABLED
11350: eval_predicates:
11351: #endif
11352: op1 = ctxt->comp->last;
11353: ctxt->comp->last = -1;
11354:
11355: SKIP_BLANKS;
11356: while (CUR == '[') {
11357: xmlXPathCompPredicate(ctxt, 0);
11358: }
11359:
11360: #ifdef LIBXML_XPTR_ENABLED
11361: if (rangeto) {
11362: PUSH_BINARY_EXPR(XPATH_OP_RANGETO, op2, op1, 0, 0);
11363: } else
11364: #endif
11365: PUSH_FULL_EXPR(XPATH_OP_COLLECT, op1, ctxt->comp->last, axis,
11366: test, type, (void *)prefix, (void *)name);
11367:
11368: }
11369: #ifdef DEBUG_STEP
11370: xmlGenericError(xmlGenericErrorContext, "Step : ");
11371: if (ctxt->value == NULL)
11372: xmlGenericError(xmlGenericErrorContext, "no value\n");
11373: else if (ctxt->value->nodesetval == NULL)
11374: xmlGenericError(xmlGenericErrorContext, "Empty\n");
11375: else
11376: xmlGenericErrorContextNodeSet(xmlGenericErrorContext,
11377: ctxt->value->nodesetval);
11378: #endif
11379: }
11380:
11381: /**
11382: * xmlXPathCompRelativeLocationPath:
11383: * @ctxt: the XPath Parser context
11384: *
11385: * [3] RelativeLocationPath ::= Step
11386: * | RelativeLocationPath '/' Step
11387: * | AbbreviatedRelativeLocationPath
11388: * [11] AbbreviatedRelativeLocationPath ::= RelativeLocationPath '//' Step
11389: *
11390: * Compile a relative location path.
11391: */
11392: static void
11393: xmlXPathCompRelativeLocationPath
11394: (xmlXPathParserContextPtr ctxt) {
11395: SKIP_BLANKS;
11396: if ((CUR == '/') && (NXT(1) == '/')) {
11397: SKIP(2);
11398: SKIP_BLANKS;
11399: PUSH_LONG_EXPR(XPATH_OP_COLLECT, AXIS_DESCENDANT_OR_SELF,
11400: NODE_TEST_TYPE, NODE_TYPE_NODE, NULL, NULL);
11401: } else if (CUR == '/') {
11402: NEXT;
11403: SKIP_BLANKS;
11404: }
11405: xmlXPathCompStep(ctxt);
11406: CHECK_ERROR;
11407: SKIP_BLANKS;
11408: while (CUR == '/') {
11409: if ((CUR == '/') && (NXT(1) == '/')) {
11410: SKIP(2);
11411: SKIP_BLANKS;
11412: PUSH_LONG_EXPR(XPATH_OP_COLLECT, AXIS_DESCENDANT_OR_SELF,
11413: NODE_TEST_TYPE, NODE_TYPE_NODE, NULL, NULL);
11414: xmlXPathCompStep(ctxt);
11415: } else if (CUR == '/') {
11416: NEXT;
11417: SKIP_BLANKS;
11418: xmlXPathCompStep(ctxt);
11419: }
11420: SKIP_BLANKS;
11421: }
11422: }
11423:
11424: /**
11425: * xmlXPathCompLocationPath:
11426: * @ctxt: the XPath Parser context
11427: *
11428: * [1] LocationPath ::= RelativeLocationPath
11429: * | AbsoluteLocationPath
11430: * [2] AbsoluteLocationPath ::= '/' RelativeLocationPath?
11431: * | AbbreviatedAbsoluteLocationPath
11432: * [10] AbbreviatedAbsoluteLocationPath ::=
11433: * '//' RelativeLocationPath
11434: *
11435: * Compile a location path
11436: *
11437: * // is short for /descendant-or-self::node()/. For example,
11438: * //para is short for /descendant-or-self::node()/child::para and
11439: * so will select any para element in the document (even a para element
11440: * that is a document element will be selected by //para since the
11441: * document element node is a child of the root node); div//para is
11442: * short for div/descendant-or-self::node()/child::para and so will
11443: * select all para descendants of div children.
11444: */
11445: static void
11446: xmlXPathCompLocationPath(xmlXPathParserContextPtr ctxt) {
11447: SKIP_BLANKS;
11448: if (CUR != '/') {
11449: xmlXPathCompRelativeLocationPath(ctxt);
11450: } else {
11451: while (CUR == '/') {
11452: if ((CUR == '/') && (NXT(1) == '/')) {
11453: SKIP(2);
11454: SKIP_BLANKS;
11455: PUSH_LONG_EXPR(XPATH_OP_COLLECT, AXIS_DESCENDANT_OR_SELF,
11456: NODE_TEST_TYPE, NODE_TYPE_NODE, NULL, NULL);
11457: xmlXPathCompRelativeLocationPath(ctxt);
11458: } else if (CUR == '/') {
11459: NEXT;
11460: SKIP_BLANKS;
11461: if ((CUR != 0 ) &&
11462: ((IS_ASCII_LETTER(CUR)) || (CUR == '_') || (CUR == '.') ||
11463: (CUR == '@') || (CUR == '*')))
11464: xmlXPathCompRelativeLocationPath(ctxt);
11465: }
11466: CHECK_ERROR;
11467: }
11468: }
11469: }
11470:
11471: /************************************************************************
11472: * *
11473: * XPath precompiled expression evaluation *
11474: * *
11475: ************************************************************************/
11476:
11477: static int
11478: xmlXPathCompOpEval(xmlXPathParserContextPtr ctxt, xmlXPathStepOpPtr op);
11479:
11480: #ifdef DEBUG_STEP
11481: static void
11482: xmlXPathDebugDumpStepAxis(xmlXPathStepOpPtr op,
11483: int nbNodes)
11484: {
11485: xmlGenericError(xmlGenericErrorContext, "new step : ");
11486: switch (op->value) {
11487: case AXIS_ANCESTOR:
11488: xmlGenericError(xmlGenericErrorContext, "axis 'ancestors' ");
11489: break;
11490: case AXIS_ANCESTOR_OR_SELF:
11491: xmlGenericError(xmlGenericErrorContext,
11492: "axis 'ancestors-or-self' ");
11493: break;
11494: case AXIS_ATTRIBUTE:
11495: xmlGenericError(xmlGenericErrorContext, "axis 'attributes' ");
11496: break;
11497: case AXIS_CHILD:
11498: xmlGenericError(xmlGenericErrorContext, "axis 'child' ");
11499: break;
11500: case AXIS_DESCENDANT:
11501: xmlGenericError(xmlGenericErrorContext, "axis 'descendant' ");
11502: break;
11503: case AXIS_DESCENDANT_OR_SELF:
11504: xmlGenericError(xmlGenericErrorContext,
11505: "axis 'descendant-or-self' ");
11506: break;
11507: case AXIS_FOLLOWING:
11508: xmlGenericError(xmlGenericErrorContext, "axis 'following' ");
11509: break;
11510: case AXIS_FOLLOWING_SIBLING:
11511: xmlGenericError(xmlGenericErrorContext,
11512: "axis 'following-siblings' ");
11513: break;
11514: case AXIS_NAMESPACE:
11515: xmlGenericError(xmlGenericErrorContext, "axis 'namespace' ");
11516: break;
11517: case AXIS_PARENT:
11518: xmlGenericError(xmlGenericErrorContext, "axis 'parent' ");
11519: break;
11520: case AXIS_PRECEDING:
11521: xmlGenericError(xmlGenericErrorContext, "axis 'preceding' ");
11522: break;
11523: case AXIS_PRECEDING_SIBLING:
11524: xmlGenericError(xmlGenericErrorContext,
11525: "axis 'preceding-sibling' ");
11526: break;
11527: case AXIS_SELF:
11528: xmlGenericError(xmlGenericErrorContext, "axis 'self' ");
11529: break;
11530: }
11531: xmlGenericError(xmlGenericErrorContext,
11532: " context contains %d nodes\n", nbNodes);
11533: switch (op->value2) {
11534: case NODE_TEST_NONE:
11535: xmlGenericError(xmlGenericErrorContext,
11536: " searching for none !!!\n");
11537: break;
11538: case NODE_TEST_TYPE:
11539: xmlGenericError(xmlGenericErrorContext,
11540: " searching for type %d\n", op->value3);
11541: break;
11542: case NODE_TEST_PI:
11543: xmlGenericError(xmlGenericErrorContext,
11544: " searching for PI !!!\n");
11545: break;
11546: case NODE_TEST_ALL:
11547: xmlGenericError(xmlGenericErrorContext,
11548: " searching for *\n");
11549: break;
11550: case NODE_TEST_NS:
11551: xmlGenericError(xmlGenericErrorContext,
11552: " searching for namespace %s\n",
11553: op->value5);
11554: break;
11555: case NODE_TEST_NAME:
11556: xmlGenericError(xmlGenericErrorContext,
11557: " searching for name %s\n", op->value5);
11558: if (op->value4)
11559: xmlGenericError(xmlGenericErrorContext,
11560: " with namespace %s\n", op->value4);
11561: break;
11562: }
11563: xmlGenericError(xmlGenericErrorContext, "Testing : ");
11564: }
11565: #endif /* DEBUG_STEP */
11566:
11567: static int
11568: xmlXPathCompOpEvalPredicate(xmlXPathParserContextPtr ctxt,
11569: xmlXPathStepOpPtr op,
11570: xmlNodeSetPtr set,
11571: int contextSize,
11572: int hasNsNodes)
11573: {
11574: if (op->ch1 != -1) {
11575: xmlXPathCompExprPtr comp = ctxt->comp;
11576: /*
11577: * Process inner predicates first.
11578: */
11579: if (comp->steps[op->ch1].op != XPATH_OP_PREDICATE) {
11580: /*
11581: * TODO: raise an internal error.
11582: */
11583: }
11584: contextSize = xmlXPathCompOpEvalPredicate(ctxt,
11585: &comp->steps[op->ch1], set, contextSize, hasNsNodes);
11586: CHECK_ERROR0;
11587: if (contextSize <= 0)
11588: return(0);
11589: }
11590: if (op->ch2 != -1) {
11591: xmlXPathContextPtr xpctxt = ctxt->context;
11592: xmlNodePtr contextNode, oldContextNode;
11593: xmlDocPtr oldContextDoc;
11594: int i, res, contextPos = 0, newContextSize;
11595: xmlXPathStepOpPtr exprOp;
11596: xmlXPathObjectPtr contextObj = NULL, exprRes = NULL;
11597:
11598: #ifdef LIBXML_XPTR_ENABLED
11599: /*
11600: * URGENT TODO: Check the following:
11601: * We don't expect location sets if evaluating prediates, right?
11602: * Only filters should expect location sets, right?
11603: */
11604: #endif
11605: /*
11606: * SPEC XPath 1.0:
11607: * "For each node in the node-set to be filtered, the
11608: * PredicateExpr is evaluated with that node as the
11609: * context node, with the number of nodes in the
11610: * node-set as the context size, and with the proximity
11611: * position of the node in the node-set with respect to
11612: * the axis as the context position;"
11613: * @oldset is the node-set" to be filtered.
11614: *
11615: * SPEC XPath 1.0:
11616: * "only predicates change the context position and
11617: * context size (see [2.4 Predicates])."
11618: * Example:
11619: * node-set context pos
11620: * nA 1
11621: * nB 2
11622: * nC 3
11623: * After applying predicate [position() > 1] :
11624: * node-set context pos
11625: * nB 1
11626: * nC 2
11627: */
11628: oldContextNode = xpctxt->node;
11629: oldContextDoc = xpctxt->doc;
11630: /*
11631: * Get the expression of this predicate.
11632: */
11633: exprOp = &ctxt->comp->steps[op->ch2];
11634: newContextSize = 0;
11635: for (i = 0; i < set->nodeNr; i++) {
11636: if (set->nodeTab[i] == NULL)
11637: continue;
11638:
11639: contextNode = set->nodeTab[i];
11640: xpctxt->node = contextNode;
11641: xpctxt->contextSize = contextSize;
11642: xpctxt->proximityPosition = ++contextPos;
11643:
11644: /*
11645: * Also set the xpath document in case things like
11646: * key() are evaluated in the predicate.
11647: */
11648: if ((contextNode->type != XML_NAMESPACE_DECL) &&
11649: (contextNode->doc != NULL))
11650: xpctxt->doc = contextNode->doc;
11651: /*
11652: * Evaluate the predicate expression with 1 context node
11653: * at a time; this node is packaged into a node set; this
11654: * node set is handed over to the evaluation mechanism.
11655: */
11656: if (contextObj == NULL)
11657: contextObj = xmlXPathCacheNewNodeSet(xpctxt, contextNode);
11658: else
11659: xmlXPathNodeSetAddUnique(contextObj->nodesetval,
11660: contextNode);
11661:
11662: valuePush(ctxt, contextObj);
11663:
11664: res = xmlXPathCompOpEvalToBoolean(ctxt, exprOp, 1);
11665:
11666: if ((ctxt->error != XPATH_EXPRESSION_OK) || (res == -1)) {
11667: xmlXPathNodeSetClear(set, hasNsNodes);
11668: newContextSize = 0;
11669: goto evaluation_exit;
11670: }
11671:
11672: if (res != 0) {
11673: newContextSize++;
11674: } else {
11675: /*
11676: * Remove the entry from the initial node set.
11677: */
11678: set->nodeTab[i] = NULL;
11679: if (contextNode->type == XML_NAMESPACE_DECL)
11680: xmlXPathNodeSetFreeNs((xmlNsPtr) contextNode);
11681: }
11682: if (ctxt->value == contextObj) {
11683: /*
11684: * Don't free the temporary XPath object holding the
11685: * context node, in order to avoid massive recreation
11686: * inside this loop.
11687: */
11688: valuePop(ctxt);
11689: xmlXPathNodeSetClear(contextObj->nodesetval, hasNsNodes);
11690: } else {
11691: /*
11692: * TODO: The object was lost in the evaluation machinery.
11693: * Can this happen? Maybe in internal-error cases.
11694: */
11695: contextObj = NULL;
11696: }
11697: }
11698:
11699: if (contextObj != NULL) {
11700: if (ctxt->value == contextObj)
11701: valuePop(ctxt);
11702: xmlXPathReleaseObject(xpctxt, contextObj);
11703: }
11704: evaluation_exit:
11705: if (exprRes != NULL)
11706: xmlXPathReleaseObject(ctxt->context, exprRes);
11707: /*
11708: * Reset/invalidate the context.
11709: */
11710: xpctxt->node = oldContextNode;
11711: xpctxt->doc = oldContextDoc;
11712: xpctxt->contextSize = -1;
11713: xpctxt->proximityPosition = -1;
11714: return(newContextSize);
11715: }
11716: return(contextSize);
11717: }
11718:
11719: static int
11720: xmlXPathCompOpEvalPositionalPredicate(xmlXPathParserContextPtr ctxt,
11721: xmlXPathStepOpPtr op,
11722: xmlNodeSetPtr set,
11723: int contextSize,
11724: int minPos,
11725: int maxPos,
11726: int hasNsNodes)
11727: {
11728: if (op->ch1 != -1) {
11729: xmlXPathCompExprPtr comp = ctxt->comp;
11730: if (comp->steps[op->ch1].op != XPATH_OP_PREDICATE) {
11731: /*
11732: * TODO: raise an internal error.
11733: */
11734: }
11735: contextSize = xmlXPathCompOpEvalPredicate(ctxt,
11736: &comp->steps[op->ch1], set, contextSize, hasNsNodes);
11737: CHECK_ERROR0;
11738: if (contextSize <= 0)
11739: return(0);
11740: }
11741: /*
11742: * Check if the node set contains a sufficient number of nodes for
11743: * the requested range.
11744: */
11745: if (contextSize < minPos) {
11746: xmlXPathNodeSetClear(set, hasNsNodes);
11747: return(0);
11748: }
11749: if (op->ch2 == -1) {
11750: /*
11751: * TODO: Can this ever happen?
11752: */
11753: return (contextSize);
11754: } else {
11755: xmlDocPtr oldContextDoc;
11756: int i, pos = 0, newContextSize = 0, contextPos = 0, res;
11757: xmlXPathStepOpPtr exprOp;
11758: xmlXPathObjectPtr contextObj = NULL, exprRes = NULL;
11759: xmlNodePtr oldContextNode, contextNode = NULL;
11760: xmlXPathContextPtr xpctxt = ctxt->context;
11761: int frame;
11762:
11763: #ifdef LIBXML_XPTR_ENABLED
11764: /*
11765: * URGENT TODO: Check the following:
11766: * We don't expect location sets if evaluating prediates, right?
11767: * Only filters should expect location sets, right?
11768: */
11769: #endif /* LIBXML_XPTR_ENABLED */
11770:
11771: /*
11772: * Save old context.
11773: */
11774: oldContextNode = xpctxt->node;
11775: oldContextDoc = xpctxt->doc;
11776: /*
11777: * Get the expression of this predicate.
11778: */
11779: exprOp = &ctxt->comp->steps[op->ch2];
11780: for (i = 0; i < set->nodeNr; i++) {
11781: xmlXPathObjectPtr tmp;
11782:
11783: if (set->nodeTab[i] == NULL)
11784: continue;
11785:
11786: contextNode = set->nodeTab[i];
11787: xpctxt->node = contextNode;
11788: xpctxt->contextSize = contextSize;
11789: xpctxt->proximityPosition = ++contextPos;
11790:
11791: /*
11792: * Initialize the new set.
11793: * Also set the xpath document in case things like
11794: * key() evaluation are attempted on the predicate
11795: */
11796: if ((contextNode->type != XML_NAMESPACE_DECL) &&
11797: (contextNode->doc != NULL))
11798: xpctxt->doc = contextNode->doc;
11799: /*
11800: * Evaluate the predicate expression with 1 context node
11801: * at a time; this node is packaged into a node set; this
11802: * node set is handed over to the evaluation mechanism.
11803: */
11804: if (contextObj == NULL)
11805: contextObj = xmlXPathCacheNewNodeSet(xpctxt, contextNode);
11806: else
11807: xmlXPathNodeSetAddUnique(contextObj->nodesetval,
11808: contextNode);
11809:
11810: frame = xmlXPathSetFrame(ctxt);
11811: valuePush(ctxt, contextObj);
11812: res = xmlXPathCompOpEvalToBoolean(ctxt, exprOp, 1);
11813: tmp = valuePop(ctxt);
11814: xmlXPathPopFrame(ctxt, frame);
11815:
11816: if ((ctxt->error != XPATH_EXPRESSION_OK) || (res == -1)) {
11817: while (tmp != contextObj) {
11818: /*
11819: * Free up the result
11820: * then pop off contextObj, which will be freed later
11821: */
11822: xmlXPathReleaseObject(xpctxt, tmp);
11823: tmp = valuePop(ctxt);
11824: }
11825: goto evaluation_error;
11826: }
11827: /* push the result back onto the stack */
11828: valuePush(ctxt, tmp);
11829:
11830: if (res)
11831: pos++;
11832:
11833: if (res && (pos >= minPos) && (pos <= maxPos)) {
11834: /*
11835: * Fits in the requested range.
11836: */
11837: newContextSize++;
11838: if (minPos == maxPos) {
11839: /*
11840: * Only 1 node was requested.
11841: */
11842: if (contextNode->type == XML_NAMESPACE_DECL) {
11843: /*
11844: * As always: take care of those nasty
11845: * namespace nodes.
11846: */
11847: set->nodeTab[i] = NULL;
11848: }
11849: xmlXPathNodeSetClear(set, hasNsNodes);
11850: set->nodeNr = 1;
11851: set->nodeTab[0] = contextNode;
11852: goto evaluation_exit;
11853: }
11854: if (pos == maxPos) {
11855: /*
11856: * We are done.
11857: */
11858: xmlXPathNodeSetClearFromPos(set, i +1, hasNsNodes);
11859: goto evaluation_exit;
11860: }
11861: } else {
11862: /*
11863: * Remove the entry from the initial node set.
11864: */
11865: set->nodeTab[i] = NULL;
11866: if (contextNode->type == XML_NAMESPACE_DECL)
11867: xmlXPathNodeSetFreeNs((xmlNsPtr) contextNode);
11868: }
11869: if (exprRes != NULL) {
11870: xmlXPathReleaseObject(ctxt->context, exprRes);
11871: exprRes = NULL;
11872: }
11873: if (ctxt->value == contextObj) {
11874: /*
11875: * Don't free the temporary XPath object holding the
11876: * context node, in order to avoid massive recreation
11877: * inside this loop.
11878: */
11879: valuePop(ctxt);
11880: xmlXPathNodeSetClear(contextObj->nodesetval, hasNsNodes);
11881: } else {
11882: /*
11883: * The object was lost in the evaluation machinery.
11884: * Can this happen? Maybe in case of internal-errors.
11885: */
11886: contextObj = NULL;
11887: }
11888: }
11889: goto evaluation_exit;
11890:
11891: evaluation_error:
11892: xmlXPathNodeSetClear(set, hasNsNodes);
11893: newContextSize = 0;
11894:
11895: evaluation_exit:
11896: if (contextObj != NULL) {
11897: if (ctxt->value == contextObj)
11898: valuePop(ctxt);
11899: xmlXPathReleaseObject(xpctxt, contextObj);
11900: }
11901: if (exprRes != NULL)
11902: xmlXPathReleaseObject(ctxt->context, exprRes);
11903: /*
11904: * Reset/invalidate the context.
11905: */
11906: xpctxt->node = oldContextNode;
11907: xpctxt->doc = oldContextDoc;
11908: xpctxt->contextSize = -1;
11909: xpctxt->proximityPosition = -1;
11910: return(newContextSize);
11911: }
11912: return(contextSize);
11913: }
11914:
11915: static int
11916: xmlXPathIsPositionalPredicate(xmlXPathParserContextPtr ctxt,
11917: xmlXPathStepOpPtr op,
11918: int *maxPos)
11919: {
11920:
11921: xmlXPathStepOpPtr exprOp;
11922:
11923: /*
11924: * BIG NOTE: This is not intended for XPATH_OP_FILTER yet!
11925: */
11926:
11927: /*
11928: * If not -1, then ch1 will point to:
11929: * 1) For predicates (XPATH_OP_PREDICATE):
11930: * - an inner predicate operator
11931: * 2) For filters (XPATH_OP_FILTER):
11932: * - an inner filter operater OR
11933: * - an expression selecting the node set.
11934: * E.g. "key('a', 'b')" or "(//foo | //bar)".
11935: */
11936: if ((op->op != XPATH_OP_PREDICATE) && (op->op != XPATH_OP_FILTER))
11937: return(0);
11938:
11939: if (op->ch2 != -1) {
11940: exprOp = &ctxt->comp->steps[op->ch2];
11941: } else
11942: return(0);
11943:
11944: if ((exprOp != NULL) &&
11945: (exprOp->op == XPATH_OP_VALUE) &&
11946: (exprOp->value4 != NULL) &&
11947: (((xmlXPathObjectPtr) exprOp->value4)->type == XPATH_NUMBER))
11948: {
11949: /*
11950: * We have a "[n]" predicate here.
11951: * TODO: Unfortunately this simplistic test here is not
11952: * able to detect a position() predicate in compound
11953: * expressions like "[@attr = 'a" and position() = 1],
11954: * and even not the usage of position() in
11955: * "[position() = 1]"; thus - obviously - a position-range,
11956: * like it "[position() < 5]", is also not detected.
11957: * Maybe we could rewrite the AST to ease the optimization.
11958: */
11959: *maxPos = (int) ((xmlXPathObjectPtr) exprOp->value4)->floatval;
11960:
11961: if (((xmlXPathObjectPtr) exprOp->value4)->floatval ==
11962: (float) *maxPos)
11963: {
11964: return(1);
11965: }
11966: }
11967: return(0);
11968: }
11969:
11970: static int
11971: xmlXPathNodeCollectAndTest(xmlXPathParserContextPtr ctxt,
11972: xmlXPathStepOpPtr op,
11973: xmlNodePtr * first, xmlNodePtr * last,
11974: int toBool)
11975: {
11976:
11977: #define XP_TEST_HIT \
11978: if (hasAxisRange != 0) { \
11979: if (++pos == maxPos) { \
11980: addNode(seq, cur); \
11981: goto axis_range_end; } \
11982: } else { \
11983: addNode(seq, cur); \
11984: if (breakOnFirstHit) goto first_hit; }
11985:
11986: #define XP_TEST_HIT_NS \
11987: if (hasAxisRange != 0) { \
11988: if (++pos == maxPos) { \
11989: hasNsNodes = 1; \
11990: xmlXPathNodeSetAddNs(seq, xpctxt->node, (xmlNsPtr) cur); \
11991: goto axis_range_end; } \
11992: } else { \
11993: hasNsNodes = 1; \
11994: xmlXPathNodeSetAddNs(seq, \
11995: xpctxt->node, (xmlNsPtr) cur); \
11996: if (breakOnFirstHit) goto first_hit; }
11997:
11998: xmlXPathAxisVal axis = (xmlXPathAxisVal) op->value;
11999: xmlXPathTestVal test = (xmlXPathTestVal) op->value2;
12000: xmlXPathTypeVal type = (xmlXPathTypeVal) op->value3;
12001: const xmlChar *prefix = op->value4;
12002: const xmlChar *name = op->value5;
12003: const xmlChar *URI = NULL;
12004:
12005: #ifdef DEBUG_STEP
12006: int nbMatches = 0, prevMatches = 0;
12007: #endif
12008: int total = 0, hasNsNodes = 0;
12009: /* The popped object holding the context nodes */
12010: xmlXPathObjectPtr obj;
12011: /* The set of context nodes for the node tests */
12012: xmlNodeSetPtr contextSeq;
12013: int contextIdx;
12014: xmlNodePtr contextNode;
12015: /* The context node for a compound traversal */
12016: xmlNodePtr outerContextNode;
12017: /* The final resulting node set wrt to all context nodes */
12018: xmlNodeSetPtr outSeq;
12019: /*
12020: * The temporary resulting node set wrt 1 context node.
12021: * Used to feed predicate evaluation.
12022: */
12023: xmlNodeSetPtr seq;
12024: xmlNodePtr cur;
12025: /* First predicate operator */
12026: xmlXPathStepOpPtr predOp;
12027: int maxPos; /* The requested position() (when a "[n]" predicate) */
12028: int hasPredicateRange, hasAxisRange, pos, size, newSize;
12029: int breakOnFirstHit;
12030:
12031: xmlXPathTraversalFunction next = NULL;
12032: /* compound axis traversal */
12033: xmlXPathTraversalFunctionExt outerNext = NULL;
12034: void (*addNode) (xmlNodeSetPtr, xmlNodePtr);
12035: xmlXPathNodeSetMergeFunction mergeAndClear;
12036: xmlNodePtr oldContextNode;
12037: xmlXPathContextPtr xpctxt = ctxt->context;
12038:
12039:
12040: CHECK_TYPE0(XPATH_NODESET);
12041: obj = valuePop(ctxt);
12042: /*
12043: * Setup namespaces.
12044: */
12045: if (prefix != NULL) {
12046: URI = xmlXPathNsLookup(xpctxt, prefix);
12047: if (URI == NULL) {
12048: xmlXPathReleaseObject(xpctxt, obj);
12049: XP_ERROR0(XPATH_UNDEF_PREFIX_ERROR);
12050: }
12051: }
12052: /*
12053: * Setup axis.
12054: *
12055: * MAYBE FUTURE TODO: merging optimizations:
12056: * - If the nodes to be traversed wrt to the initial nodes and
12057: * the current axis cannot overlap, then we could avoid searching
12058: * for duplicates during the merge.
12059: * But the question is how/when to evaluate if they cannot overlap.
12060: * Example: if we know that for two initial nodes, the one is
12061: * not in the ancestor-or-self axis of the other, then we could safely
12062: * avoid a duplicate-aware merge, if the axis to be traversed is e.g.
12063: * the descendant-or-self axis.
12064: */
12065: mergeAndClear = xmlXPathNodeSetMergeAndClear;
12066: switch (axis) {
12067: case AXIS_ANCESTOR:
12068: first = NULL;
12069: next = xmlXPathNextAncestor;
12070: break;
12071: case AXIS_ANCESTOR_OR_SELF:
12072: first = NULL;
12073: next = xmlXPathNextAncestorOrSelf;
12074: break;
12075: case AXIS_ATTRIBUTE:
12076: first = NULL;
12077: last = NULL;
12078: next = xmlXPathNextAttribute;
12079: mergeAndClear = xmlXPathNodeSetMergeAndClearNoDupls;
12080: break;
12081: case AXIS_CHILD:
12082: last = NULL;
12083: if (op->rewriteType == XP_REWRITE_DOS_CHILD_ELEM) {
12084: /*
12085: * This iterator will give us only nodes which can
12086: * hold element nodes.
12087: */
12088: outerNext = xmlXPathNextDescendantOrSelfElemParent;
12089: }
12090: if (((test == NODE_TEST_NAME) || (test == NODE_TEST_ALL)) &&
12091: (type == NODE_TYPE_NODE))
12092: {
12093: /*
12094: * Optimization if an element node type is 'element'.
12095: */
12096: next = xmlXPathNextChildElement;
12097: } else
12098: next = xmlXPathNextChild;
12099: mergeAndClear = xmlXPathNodeSetMergeAndClearNoDupls;
12100: break;
12101: case AXIS_DESCENDANT:
12102: last = NULL;
12103: next = xmlXPathNextDescendant;
12104: break;
12105: case AXIS_DESCENDANT_OR_SELF:
12106: last = NULL;
12107: next = xmlXPathNextDescendantOrSelf;
12108: break;
12109: case AXIS_FOLLOWING:
12110: last = NULL;
12111: next = xmlXPathNextFollowing;
12112: break;
12113: case AXIS_FOLLOWING_SIBLING:
12114: last = NULL;
12115: next = xmlXPathNextFollowingSibling;
12116: break;
12117: case AXIS_NAMESPACE:
12118: first = NULL;
12119: last = NULL;
12120: next = (xmlXPathTraversalFunction) xmlXPathNextNamespace;
12121: mergeAndClear = xmlXPathNodeSetMergeAndClearNoDupls;
12122: break;
12123: case AXIS_PARENT:
12124: first = NULL;
12125: next = xmlXPathNextParent;
12126: break;
12127: case AXIS_PRECEDING:
12128: first = NULL;
12129: next = xmlXPathNextPrecedingInternal;
12130: break;
12131: case AXIS_PRECEDING_SIBLING:
12132: first = NULL;
12133: next = xmlXPathNextPrecedingSibling;
12134: break;
12135: case AXIS_SELF:
12136: first = NULL;
12137: last = NULL;
12138: next = xmlXPathNextSelf;
12139: mergeAndClear = xmlXPathNodeSetMergeAndClearNoDupls;
12140: break;
12141: }
12142:
12143: #ifdef DEBUG_STEP
12144: xmlXPathDebugDumpStepAxis(op,
12145: (obj->nodesetval != NULL) ? obj->nodesetval->nodeNr : 0);
12146: #endif
12147:
12148: if (next == NULL) {
12149: xmlXPathReleaseObject(xpctxt, obj);
12150: return(0);
12151: }
12152: contextSeq = obj->nodesetval;
12153: if ((contextSeq == NULL) || (contextSeq->nodeNr <= 0)) {
12154: xmlXPathReleaseObject(xpctxt, obj);
12155: valuePush(ctxt, xmlXPathCacheWrapNodeSet(xpctxt, NULL));
12156: return(0);
12157: }
12158: /*
12159: * Predicate optimization ---------------------------------------------
12160: * If this step has a last predicate, which contains a position(),
12161: * then we'll optimize (although not exactly "position()", but only
12162: * the short-hand form, i.e., "[n]".
12163: *
12164: * Example - expression "/foo[parent::bar][1]":
12165: *
12166: * COLLECT 'child' 'name' 'node' foo -- op (we are here)
12167: * ROOT -- op->ch1
12168: * PREDICATE -- op->ch2 (predOp)
12169: * PREDICATE -- predOp->ch1 = [parent::bar]
12170: * SORT
12171: * COLLECT 'parent' 'name' 'node' bar
12172: * NODE
12173: * ELEM Object is a number : 1 -- predOp->ch2 = [1]
12174: *
12175: */
12176: maxPos = 0;
12177: predOp = NULL;
12178: hasPredicateRange = 0;
12179: hasAxisRange = 0;
12180: if (op->ch2 != -1) {
12181: /*
12182: * There's at least one predicate. 16 == XPATH_OP_PREDICATE
12183: */
12184: predOp = &ctxt->comp->steps[op->ch2];
12185: if (xmlXPathIsPositionalPredicate(ctxt, predOp, &maxPos)) {
12186: if (predOp->ch1 != -1) {
12187: /*
12188: * Use the next inner predicate operator.
12189: */
12190: predOp = &ctxt->comp->steps[predOp->ch1];
12191: hasPredicateRange = 1;
12192: } else {
12193: /*
12194: * There's no other predicate than the [n] predicate.
12195: */
12196: predOp = NULL;
12197: hasAxisRange = 1;
12198: }
12199: }
12200: }
12201: breakOnFirstHit = ((toBool) && (predOp == NULL)) ? 1 : 0;
12202: /*
12203: * Axis traversal -----------------------------------------------------
12204: */
12205: /*
12206: * 2.3 Node Tests
12207: * - For the attribute axis, the principal node type is attribute.
12208: * - For the namespace axis, the principal node type is namespace.
12209: * - For other axes, the principal node type is element.
12210: *
12211: * A node test * is true for any node of the
12212: * principal node type. For example, child::* will
12213: * select all element children of the context node
12214: */
12215: oldContextNode = xpctxt->node;
12216: addNode = xmlXPathNodeSetAddUnique;
12217: outSeq = NULL;
12218: seq = NULL;
12219: outerContextNode = NULL;
12220: contextNode = NULL;
12221: contextIdx = 0;
12222:
12223:
12224: while ((contextIdx < contextSeq->nodeNr) || (contextNode != NULL)) {
12225: if (outerNext != NULL) {
12226: /*
12227: * This is a compound traversal.
12228: */
12229: if (contextNode == NULL) {
12230: /*
12231: * Set the context for the outer traversal.
12232: */
12233: outerContextNode = contextSeq->nodeTab[contextIdx++];
12234: contextNode = outerNext(NULL, outerContextNode);
12235: } else
12236: contextNode = outerNext(contextNode, outerContextNode);
12237: if (contextNode == NULL)
12238: continue;
12239: /*
12240: * Set the context for the main traversal.
12241: */
12242: xpctxt->node = contextNode;
12243: } else
12244: xpctxt->node = contextSeq->nodeTab[contextIdx++];
12245:
12246: if (seq == NULL) {
12247: seq = xmlXPathNodeSetCreate(NULL);
12248: if (seq == NULL) {
12249: total = 0;
12250: goto error;
12251: }
12252: }
12253: /*
12254: * Traverse the axis and test the nodes.
12255: */
12256: pos = 0;
12257: cur = NULL;
12258: hasNsNodes = 0;
12259: do {
12260: cur = next(ctxt, cur);
12261: if (cur == NULL)
12262: break;
12263:
12264: /*
12265: * QUESTION TODO: What does the "first" and "last" stuff do?
12266: */
12267: if ((first != NULL) && (*first != NULL)) {
12268: if (*first == cur)
12269: break;
12270: if (((total % 256) == 0) &&
12271: #ifdef XP_OPTIMIZED_NON_ELEM_COMPARISON
12272: (xmlXPathCmpNodesExt(*first, cur) >= 0))
12273: #else
12274: (xmlXPathCmpNodes(*first, cur) >= 0))
12275: #endif
12276: {
12277: break;
12278: }
12279: }
12280: if ((last != NULL) && (*last != NULL)) {
12281: if (*last == cur)
12282: break;
12283: if (((total % 256) == 0) &&
12284: #ifdef XP_OPTIMIZED_NON_ELEM_COMPARISON
12285: (xmlXPathCmpNodesExt(cur, *last) >= 0))
12286: #else
12287: (xmlXPathCmpNodes(cur, *last) >= 0))
12288: #endif
12289: {
12290: break;
12291: }
12292: }
12293:
12294: total++;
12295:
12296: #ifdef DEBUG_STEP
12297: xmlGenericError(xmlGenericErrorContext, " %s", cur->name);
12298: #endif
12299:
12300: switch (test) {
12301: case NODE_TEST_NONE:
12302: total = 0;
12303: STRANGE
12304: goto error;
12305: case NODE_TEST_TYPE:
12306: /*
12307: * TODO: Don't we need to use
12308: * xmlXPathNodeSetAddNs() for namespace nodes here?
12309: * Surprisingly, some c14n tests fail, if we do this.
12310: */
12311: if (type == NODE_TYPE_NODE) {
12312: switch (cur->type) {
12313: case XML_DOCUMENT_NODE:
12314: case XML_HTML_DOCUMENT_NODE:
12315: #ifdef LIBXML_DOCB_ENABLED
12316: case XML_DOCB_DOCUMENT_NODE:
12317: #endif
12318: case XML_ELEMENT_NODE:
12319: case XML_ATTRIBUTE_NODE:
12320: case XML_PI_NODE:
12321: case XML_COMMENT_NODE:
12322: case XML_CDATA_SECTION_NODE:
12323: case XML_TEXT_NODE:
12324: case XML_NAMESPACE_DECL:
12325: XP_TEST_HIT
12326: break;
12327: default:
12328: break;
12329: }
12330: } else if (cur->type == type) {
12331: if (type == XML_NAMESPACE_DECL)
12332: XP_TEST_HIT_NS
12333: else
12334: XP_TEST_HIT
12335: } else if ((type == NODE_TYPE_TEXT) &&
12336: (cur->type == XML_CDATA_SECTION_NODE))
12337: {
12338: XP_TEST_HIT
12339: }
12340: break;
12341: case NODE_TEST_PI:
12342: if ((cur->type == XML_PI_NODE) &&
12343: ((name == NULL) || xmlStrEqual(name, cur->name)))
12344: {
12345: XP_TEST_HIT
12346: }
12347: break;
12348: case NODE_TEST_ALL:
12349: if (axis == AXIS_ATTRIBUTE) {
12350: if (cur->type == XML_ATTRIBUTE_NODE)
12351: {
12352: XP_TEST_HIT
12353: }
12354: } else if (axis == AXIS_NAMESPACE) {
12355: if (cur->type == XML_NAMESPACE_DECL)
12356: {
12357: XP_TEST_HIT_NS
12358: }
12359: } else {
12360: if (cur->type == XML_ELEMENT_NODE) {
12361: if (prefix == NULL)
12362: {
12363: XP_TEST_HIT
12364:
12365: } else if ((cur->ns != NULL) &&
12366: (xmlStrEqual(URI, cur->ns->href)))
12367: {
12368: XP_TEST_HIT
12369: }
12370: }
12371: }
12372: break;
12373: case NODE_TEST_NS:{
12374: TODO;
12375: break;
12376: }
12377: case NODE_TEST_NAME:
12378: if (axis == AXIS_ATTRIBUTE) {
12379: if (cur->type != XML_ATTRIBUTE_NODE)
12380: break;
12381: } else if (axis == AXIS_NAMESPACE) {
12382: if (cur->type != XML_NAMESPACE_DECL)
12383: break;
12384: } else {
12385: if (cur->type != XML_ELEMENT_NODE)
12386: break;
12387: }
12388: switch (cur->type) {
12389: case XML_ELEMENT_NODE:
12390: if (xmlStrEqual(name, cur->name)) {
12391: if (prefix == NULL) {
12392: if (cur->ns == NULL)
12393: {
12394: XP_TEST_HIT
12395: }
12396: } else {
12397: if ((cur->ns != NULL) &&
12398: (xmlStrEqual(URI, cur->ns->href)))
12399: {
12400: XP_TEST_HIT
12401: }
12402: }
12403: }
12404: break;
12405: case XML_ATTRIBUTE_NODE:{
12406: xmlAttrPtr attr = (xmlAttrPtr) cur;
12407:
12408: if (xmlStrEqual(name, attr->name)) {
12409: if (prefix == NULL) {
12410: if ((attr->ns == NULL) ||
12411: (attr->ns->prefix == NULL))
12412: {
12413: XP_TEST_HIT
12414: }
12415: } else {
12416: if ((attr->ns != NULL) &&
12417: (xmlStrEqual(URI,
12418: attr->ns->href)))
12419: {
12420: XP_TEST_HIT
12421: }
12422: }
12423: }
12424: break;
12425: }
12426: case XML_NAMESPACE_DECL:
12427: if (cur->type == XML_NAMESPACE_DECL) {
12428: xmlNsPtr ns = (xmlNsPtr) cur;
12429:
12430: if ((ns->prefix != NULL) && (name != NULL)
12431: && (xmlStrEqual(ns->prefix, name)))
12432: {
12433: XP_TEST_HIT_NS
12434: }
12435: }
12436: break;
12437: default:
12438: break;
12439: }
12440: break;
12441: } /* switch(test) */
12442: } while (cur != NULL);
12443:
12444: goto apply_predicates;
12445:
12446: axis_range_end: /* ----------------------------------------------------- */
12447: /*
12448: * We have a "/foo[n]", and position() = n was reached.
12449: * Note that we can have as well "/foo/::parent::foo[1]", so
12450: * a duplicate-aware merge is still needed.
12451: * Merge with the result.
12452: */
12453: if (outSeq == NULL) {
12454: outSeq = seq;
12455: seq = NULL;
12456: } else
12457: outSeq = mergeAndClear(outSeq, seq, 0);
12458: /*
12459: * Break if only a true/false result was requested.
12460: */
12461: if (toBool)
12462: break;
12463: continue;
12464:
12465: first_hit: /* ---------------------------------------------------------- */
12466: /*
12467: * Break if only a true/false result was requested and
12468: * no predicates existed and a node test succeeded.
12469: */
12470: if (outSeq == NULL) {
12471: outSeq = seq;
12472: seq = NULL;
12473: } else
12474: outSeq = mergeAndClear(outSeq, seq, 0);
12475: break;
12476:
12477: #ifdef DEBUG_STEP
12478: if (seq != NULL)
12479: nbMatches += seq->nodeNr;
12480: #endif
12481:
12482: apply_predicates: /* --------------------------------------------------- */
12483: /*
12484: * Apply predicates.
12485: */
12486: if ((predOp != NULL) && (seq->nodeNr > 0)) {
12487: /*
12488: * E.g. when we have a "/foo[some expression][n]".
12489: */
12490: /*
12491: * QUESTION TODO: The old predicate evaluation took into
12492: * account location-sets.
12493: * (E.g. ctxt->value->type == XPATH_LOCATIONSET)
12494: * Do we expect such a set here?
12495: * All what I learned now from the evaluation semantics
12496: * does not indicate that a location-set will be processed
12497: * here, so this looks OK.
12498: */
12499: /*
12500: * Iterate over all predicates, starting with the outermost
12501: * predicate.
12502: * TODO: Problem: we cannot execute the inner predicates first
12503: * since we cannot go back *up* the operator tree!
12504: * Options we have:
12505: * 1) Use of recursive functions (like is it currently done
12506: * via xmlXPathCompOpEval())
12507: * 2) Add a predicate evaluation information stack to the
12508: * context struct
12509: * 3) Change the way the operators are linked; we need a
12510: * "parent" field on xmlXPathStepOp
12511: *
12512: * For the moment, I'll try to solve this with a recursive
12513: * function: xmlXPathCompOpEvalPredicate().
12514: */
12515: size = seq->nodeNr;
12516: if (hasPredicateRange != 0)
12517: newSize = xmlXPathCompOpEvalPositionalPredicate(ctxt,
12518: predOp, seq, size, maxPos, maxPos, hasNsNodes);
12519: else
12520: newSize = xmlXPathCompOpEvalPredicate(ctxt,
12521: predOp, seq, size, hasNsNodes);
12522:
12523: if (ctxt->error != XPATH_EXPRESSION_OK) {
12524: total = 0;
12525: goto error;
12526: }
12527: /*
12528: * Add the filtered set of nodes to the result node set.
12529: */
12530: if (newSize == 0) {
12531: /*
12532: * The predicates filtered all nodes out.
12533: */
12534: xmlXPathNodeSetClear(seq, hasNsNodes);
12535: } else if (seq->nodeNr > 0) {
12536: /*
12537: * Add to result set.
12538: */
12539: if (outSeq == NULL) {
12540: if (size != newSize) {
12541: /*
12542: * We need to merge and clear here, since
12543: * the sequence will contained NULLed entries.
12544: */
12545: outSeq = mergeAndClear(NULL, seq, 1);
12546: } else {
12547: outSeq = seq;
12548: seq = NULL;
12549: }
12550: } else
12551: outSeq = mergeAndClear(outSeq, seq,
12552: (size != newSize) ? 1: 0);
12553: /*
12554: * Break if only a true/false result was requested.
12555: */
12556: if (toBool)
12557: break;
12558: }
12559: } else if (seq->nodeNr > 0) {
12560: /*
12561: * Add to result set.
12562: */
12563: if (outSeq == NULL) {
12564: outSeq = seq;
12565: seq = NULL;
12566: } else {
12567: outSeq = mergeAndClear(outSeq, seq, 0);
12568: }
12569: }
12570: }
12571:
12572: error:
12573: if ((obj->boolval) && (obj->user != NULL)) {
12574: /*
12575: * QUESTION TODO: What does this do and why?
12576: * TODO: Do we have to do this also for the "error"
12577: * cleanup further down?
12578: */
12579: ctxt->value->boolval = 1;
12580: ctxt->value->user = obj->user;
12581: obj->user = NULL;
12582: obj->boolval = 0;
12583: }
12584: xmlXPathReleaseObject(xpctxt, obj);
12585:
12586: /*
12587: * Ensure we return at least an emtpy set.
12588: */
12589: if (outSeq == NULL) {
12590: if ((seq != NULL) && (seq->nodeNr == 0))
12591: outSeq = seq;
12592: else
12593: outSeq = xmlXPathNodeSetCreate(NULL);
12594: /* XXX what if xmlXPathNodeSetCreate returned NULL here? */
12595: }
12596: if ((seq != NULL) && (seq != outSeq)) {
12597: xmlXPathFreeNodeSet(seq);
12598: }
12599: /*
12600: * Hand over the result. Better to push the set also in
12601: * case of errors.
12602: */
12603: valuePush(ctxt, xmlXPathCacheWrapNodeSet(xpctxt, outSeq));
12604: /*
12605: * Reset the context node.
12606: */
12607: xpctxt->node = oldContextNode;
12608:
12609: #ifdef DEBUG_STEP
12610: xmlGenericError(xmlGenericErrorContext,
12611: "\nExamined %d nodes, found %d nodes at that step\n",
12612: total, nbMatches);
12613: #endif
12614:
12615: return(total);
12616: }
12617:
12618: static int
12619: xmlXPathCompOpEvalFilterFirst(xmlXPathParserContextPtr ctxt,
12620: xmlXPathStepOpPtr op, xmlNodePtr * first);
12621:
12622: /**
12623: * xmlXPathCompOpEvalFirst:
12624: * @ctxt: the XPath parser context with the compiled expression
12625: * @op: an XPath compiled operation
12626: * @first: the first elem found so far
12627: *
12628: * Evaluate the Precompiled XPath operation searching only the first
12629: * element in document order
12630: *
12631: * Returns the number of examined objects.
12632: */
12633: static int
12634: xmlXPathCompOpEvalFirst(xmlXPathParserContextPtr ctxt,
12635: xmlXPathStepOpPtr op, xmlNodePtr * first)
12636: {
12637: int total = 0, cur;
12638: xmlXPathCompExprPtr comp;
12639: xmlXPathObjectPtr arg1, arg2;
12640:
12641: CHECK_ERROR0;
12642: comp = ctxt->comp;
12643: switch (op->op) {
12644: case XPATH_OP_END:
12645: return (0);
12646: case XPATH_OP_UNION:
12647: total =
12648: xmlXPathCompOpEvalFirst(ctxt, &comp->steps[op->ch1],
12649: first);
12650: CHECK_ERROR0;
12651: if ((ctxt->value != NULL)
12652: && (ctxt->value->type == XPATH_NODESET)
12653: && (ctxt->value->nodesetval != NULL)
12654: && (ctxt->value->nodesetval->nodeNr >= 1)) {
12655: /*
12656: * limit tree traversing to first node in the result
12657: */
12658: /*
12659: * OPTIMIZE TODO: This implicitely sorts
12660: * the result, even if not needed. E.g. if the argument
12661: * of the count() function, no sorting is needed.
12662: * OPTIMIZE TODO: How do we know if the node-list wasn't
12663: * aready sorted?
12664: */
12665: if (ctxt->value->nodesetval->nodeNr > 1)
12666: xmlXPathNodeSetSort(ctxt->value->nodesetval);
12667: *first = ctxt->value->nodesetval->nodeTab[0];
12668: }
12669: cur =
12670: xmlXPathCompOpEvalFirst(ctxt, &comp->steps[op->ch2],
12671: first);
12672: CHECK_ERROR0;
12673: CHECK_TYPE0(XPATH_NODESET);
12674: arg2 = valuePop(ctxt);
12675:
12676: CHECK_TYPE0(XPATH_NODESET);
12677: arg1 = valuePop(ctxt);
12678:
12679: arg1->nodesetval = xmlXPathNodeSetMerge(arg1->nodesetval,
12680: arg2->nodesetval);
12681: valuePush(ctxt, arg1);
12682: xmlXPathReleaseObject(ctxt->context, arg2);
12683: /* optimizer */
12684: if (total > cur)
12685: xmlXPathCompSwap(op);
12686: return (total + cur);
12687: case XPATH_OP_ROOT:
12688: xmlXPathRoot(ctxt);
12689: return (0);
12690: case XPATH_OP_NODE:
12691: if (op->ch1 != -1)
12692: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
12693: CHECK_ERROR0;
12694: if (op->ch2 != -1)
12695: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
12696: CHECK_ERROR0;
12697: valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context,
12698: ctxt->context->node));
12699: return (total);
12700: case XPATH_OP_RESET:
12701: if (op->ch1 != -1)
12702: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
12703: CHECK_ERROR0;
12704: if (op->ch2 != -1)
12705: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
12706: CHECK_ERROR0;
12707: ctxt->context->node = NULL;
12708: return (total);
12709: case XPATH_OP_COLLECT:{
12710: if (op->ch1 == -1)
12711: return (total);
12712:
12713: total = xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
12714: CHECK_ERROR0;
12715:
12716: total += xmlXPathNodeCollectAndTest(ctxt, op, first, NULL, 0);
12717: return (total);
12718: }
12719: case XPATH_OP_VALUE:
12720: valuePush(ctxt,
12721: xmlXPathCacheObjectCopy(ctxt->context,
12722: (xmlXPathObjectPtr) op->value4));
12723: return (0);
12724: case XPATH_OP_SORT:
12725: if (op->ch1 != -1)
12726: total +=
12727: xmlXPathCompOpEvalFirst(ctxt, &comp->steps[op->ch1],
12728: first);
12729: CHECK_ERROR0;
12730: if ((ctxt->value != NULL)
12731: && (ctxt->value->type == XPATH_NODESET)
12732: && (ctxt->value->nodesetval != NULL)
12733: && (ctxt->value->nodesetval->nodeNr > 1))
12734: xmlXPathNodeSetSort(ctxt->value->nodesetval);
12735: return (total);
12736: #ifdef XP_OPTIMIZED_FILTER_FIRST
12737: case XPATH_OP_FILTER:
12738: total += xmlXPathCompOpEvalFilterFirst(ctxt, op, first);
12739: return (total);
12740: #endif
12741: default:
12742: return (xmlXPathCompOpEval(ctxt, op));
12743: }
12744: }
12745:
12746: /**
12747: * xmlXPathCompOpEvalLast:
12748: * @ctxt: the XPath parser context with the compiled expression
12749: * @op: an XPath compiled operation
12750: * @last: the last elem found so far
12751: *
12752: * Evaluate the Precompiled XPath operation searching only the last
12753: * element in document order
12754: *
12755: * Returns the number of nodes traversed
12756: */
12757: static int
12758: xmlXPathCompOpEvalLast(xmlXPathParserContextPtr ctxt, xmlXPathStepOpPtr op,
12759: xmlNodePtr * last)
12760: {
12761: int total = 0, cur;
12762: xmlXPathCompExprPtr comp;
12763: xmlXPathObjectPtr arg1, arg2;
12764: xmlNodePtr bak;
12765: xmlDocPtr bakd;
12766: int pp;
12767: int cs;
12768:
12769: CHECK_ERROR0;
12770: comp = ctxt->comp;
12771: switch (op->op) {
12772: case XPATH_OP_END:
12773: return (0);
12774: case XPATH_OP_UNION:
12775: bakd = ctxt->context->doc;
12776: bak = ctxt->context->node;
12777: pp = ctxt->context->proximityPosition;
12778: cs = ctxt->context->contextSize;
12779: total =
12780: xmlXPathCompOpEvalLast(ctxt, &comp->steps[op->ch1], last);
12781: CHECK_ERROR0;
12782: if ((ctxt->value != NULL)
12783: && (ctxt->value->type == XPATH_NODESET)
12784: && (ctxt->value->nodesetval != NULL)
12785: && (ctxt->value->nodesetval->nodeNr >= 1)) {
12786: /*
12787: * limit tree traversing to first node in the result
12788: */
12789: if (ctxt->value->nodesetval->nodeNr > 1)
12790: xmlXPathNodeSetSort(ctxt->value->nodesetval);
12791: *last =
12792: ctxt->value->nodesetval->nodeTab[ctxt->value->
12793: nodesetval->nodeNr -
12794: 1];
12795: }
12796: ctxt->context->doc = bakd;
12797: ctxt->context->node = bak;
12798: ctxt->context->proximityPosition = pp;
12799: ctxt->context->contextSize = cs;
12800: cur =
12801: xmlXPathCompOpEvalLast(ctxt, &comp->steps[op->ch2], last);
12802: CHECK_ERROR0;
12803: if ((ctxt->value != NULL)
12804: && (ctxt->value->type == XPATH_NODESET)
12805: && (ctxt->value->nodesetval != NULL)
12806: && (ctxt->value->nodesetval->nodeNr >= 1)) { /* TODO: NOP ? */
12807: }
12808: CHECK_TYPE0(XPATH_NODESET);
12809: arg2 = valuePop(ctxt);
12810:
12811: CHECK_TYPE0(XPATH_NODESET);
12812: arg1 = valuePop(ctxt);
12813:
12814: arg1->nodesetval = xmlXPathNodeSetMerge(arg1->nodesetval,
12815: arg2->nodesetval);
12816: valuePush(ctxt, arg1);
12817: xmlXPathReleaseObject(ctxt->context, arg2);
12818: /* optimizer */
12819: if (total > cur)
12820: xmlXPathCompSwap(op);
12821: return (total + cur);
12822: case XPATH_OP_ROOT:
12823: xmlXPathRoot(ctxt);
12824: return (0);
12825: case XPATH_OP_NODE:
12826: if (op->ch1 != -1)
12827: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
12828: CHECK_ERROR0;
12829: if (op->ch2 != -1)
12830: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
12831: CHECK_ERROR0;
12832: valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context,
12833: ctxt->context->node));
12834: return (total);
12835: case XPATH_OP_RESET:
12836: if (op->ch1 != -1)
12837: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
12838: CHECK_ERROR0;
12839: if (op->ch2 != -1)
12840: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
12841: CHECK_ERROR0;
12842: ctxt->context->node = NULL;
12843: return (total);
12844: case XPATH_OP_COLLECT:{
12845: if (op->ch1 == -1)
12846: return (0);
12847:
12848: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
12849: CHECK_ERROR0;
12850:
12851: total += xmlXPathNodeCollectAndTest(ctxt, op, NULL, last, 0);
12852: return (total);
12853: }
12854: case XPATH_OP_VALUE:
12855: valuePush(ctxt,
12856: xmlXPathCacheObjectCopy(ctxt->context,
12857: (xmlXPathObjectPtr) op->value4));
12858: return (0);
12859: case XPATH_OP_SORT:
12860: if (op->ch1 != -1)
12861: total +=
12862: xmlXPathCompOpEvalLast(ctxt, &comp->steps[op->ch1],
12863: last);
12864: CHECK_ERROR0;
12865: if ((ctxt->value != NULL)
12866: && (ctxt->value->type == XPATH_NODESET)
12867: && (ctxt->value->nodesetval != NULL)
12868: && (ctxt->value->nodesetval->nodeNr > 1))
12869: xmlXPathNodeSetSort(ctxt->value->nodesetval);
12870: return (total);
12871: default:
12872: return (xmlXPathCompOpEval(ctxt, op));
12873: }
12874: }
12875:
12876: #ifdef XP_OPTIMIZED_FILTER_FIRST
12877: static int
12878: xmlXPathCompOpEvalFilterFirst(xmlXPathParserContextPtr ctxt,
12879: xmlXPathStepOpPtr op, xmlNodePtr * first)
12880: {
12881: int total = 0;
12882: xmlXPathCompExprPtr comp;
12883: xmlXPathObjectPtr res;
12884: xmlXPathObjectPtr obj;
12885: xmlNodeSetPtr oldset;
12886: xmlNodePtr oldnode;
12887: xmlDocPtr oldDoc;
12888: int i;
12889:
12890: CHECK_ERROR0;
12891: comp = ctxt->comp;
12892: /*
12893: * Optimization for ()[last()] selection i.e. the last elem
12894: */
12895: if ((op->ch1 != -1) && (op->ch2 != -1) &&
12896: (comp->steps[op->ch1].op == XPATH_OP_SORT) &&
12897: (comp->steps[op->ch2].op == XPATH_OP_SORT)) {
12898: int f = comp->steps[op->ch2].ch1;
12899:
12900: if ((f != -1) &&
12901: (comp->steps[f].op == XPATH_OP_FUNCTION) &&
12902: (comp->steps[f].value5 == NULL) &&
12903: (comp->steps[f].value == 0) &&
12904: (comp->steps[f].value4 != NULL) &&
12905: (xmlStrEqual
12906: (comp->steps[f].value4, BAD_CAST "last"))) {
12907: xmlNodePtr last = NULL;
12908:
12909: total +=
12910: xmlXPathCompOpEvalLast(ctxt,
12911: &comp->steps[op->ch1],
12912: &last);
12913: CHECK_ERROR0;
12914: /*
12915: * The nodeset should be in document order,
12916: * Keep only the last value
12917: */
12918: if ((ctxt->value != NULL) &&
12919: (ctxt->value->type == XPATH_NODESET) &&
12920: (ctxt->value->nodesetval != NULL) &&
12921: (ctxt->value->nodesetval->nodeTab != NULL) &&
12922: (ctxt->value->nodesetval->nodeNr > 1)) {
12923: ctxt->value->nodesetval->nodeTab[0] =
12924: ctxt->value->nodesetval->nodeTab[ctxt->
12925: value->
12926: nodesetval->
12927: nodeNr -
12928: 1];
12929: ctxt->value->nodesetval->nodeNr = 1;
12930: *first = *(ctxt->value->nodesetval->nodeTab);
12931: }
12932: return (total);
12933: }
12934: }
12935:
12936: if (op->ch1 != -1)
12937: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
12938: CHECK_ERROR0;
12939: if (op->ch2 == -1)
12940: return (total);
12941: if (ctxt->value == NULL)
12942: return (total);
12943:
12944: #ifdef LIBXML_XPTR_ENABLED
12945: oldnode = ctxt->context->node;
12946: /*
12947: * Hum are we filtering the result of an XPointer expression
12948: */
12949: if (ctxt->value->type == XPATH_LOCATIONSET) {
12950: xmlXPathObjectPtr tmp = NULL;
12951: xmlLocationSetPtr newlocset = NULL;
12952: xmlLocationSetPtr oldlocset;
12953:
12954: /*
12955: * Extract the old locset, and then evaluate the result of the
12956: * expression for all the element in the locset. use it to grow
12957: * up a new locset.
12958: */
12959: CHECK_TYPE0(XPATH_LOCATIONSET);
12960: obj = valuePop(ctxt);
12961: oldlocset = obj->user;
12962: ctxt->context->node = NULL;
12963:
12964: if ((oldlocset == NULL) || (oldlocset->locNr == 0)) {
12965: ctxt->context->contextSize = 0;
12966: ctxt->context->proximityPosition = 0;
12967: if (op->ch2 != -1)
12968: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
12969: res = valuePop(ctxt);
12970: if (res != NULL) {
12971: xmlXPathReleaseObject(ctxt->context, res);
12972: }
12973: valuePush(ctxt, obj);
12974: CHECK_ERROR0;
12975: return (total);
12976: }
12977: newlocset = xmlXPtrLocationSetCreate(NULL);
12978:
12979: for (i = 0; i < oldlocset->locNr; i++) {
12980: /*
12981: * Run the evaluation with a node list made of a
12982: * single item in the nodelocset.
12983: */
12984: ctxt->context->node = oldlocset->locTab[i]->user;
12985: ctxt->context->contextSize = oldlocset->locNr;
12986: ctxt->context->proximityPosition = i + 1;
12987: if (tmp == NULL) {
12988: tmp = xmlXPathCacheNewNodeSet(ctxt->context,
12989: ctxt->context->node);
12990: } else {
12991: xmlXPathNodeSetAddUnique(tmp->nodesetval,
12992: ctxt->context->node);
12993: }
12994: valuePush(ctxt, tmp);
12995: if (op->ch2 != -1)
12996: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
12997: if (ctxt->error != XPATH_EXPRESSION_OK) {
12998: xmlXPathFreeObject(obj);
12999: return(0);
13000: }
13001: /*
13002: * The result of the evaluation need to be tested to
13003: * decided whether the filter succeeded or not
13004: */
13005: res = valuePop(ctxt);
13006: if (xmlXPathEvaluatePredicateResult(ctxt, res)) {
13007: xmlXPtrLocationSetAdd(newlocset,
13008: xmlXPathCacheObjectCopy(ctxt->context,
13009: oldlocset->locTab[i]));
13010: }
13011: /*
13012: * Cleanup
13013: */
13014: if (res != NULL) {
13015: xmlXPathReleaseObject(ctxt->context, res);
13016: }
13017: if (ctxt->value == tmp) {
13018: valuePop(ctxt);
13019: xmlXPathNodeSetClear(tmp->nodesetval, 1);
13020: /*
13021: * REVISIT TODO: Don't create a temporary nodeset
13022: * for everly iteration.
13023: */
13024: /* OLD: xmlXPathFreeObject(res); */
13025: } else
13026: tmp = NULL;
13027: ctxt->context->node = NULL;
13028: /*
13029: * Only put the first node in the result, then leave.
13030: */
13031: if (newlocset->locNr > 0) {
13032: *first = (xmlNodePtr) oldlocset->locTab[i]->user;
13033: break;
13034: }
13035: }
13036: if (tmp != NULL) {
13037: xmlXPathReleaseObject(ctxt->context, tmp);
13038: }
13039: /*
13040: * The result is used as the new evaluation locset.
13041: */
13042: xmlXPathReleaseObject(ctxt->context, obj);
13043: ctxt->context->node = NULL;
13044: ctxt->context->contextSize = -1;
13045: ctxt->context->proximityPosition = -1;
13046: valuePush(ctxt, xmlXPtrWrapLocationSet(newlocset));
13047: ctxt->context->node = oldnode;
13048: return (total);
13049: }
13050: #endif /* LIBXML_XPTR_ENABLED */
13051:
13052: /*
13053: * Extract the old set, and then evaluate the result of the
13054: * expression for all the element in the set. use it to grow
13055: * up a new set.
13056: */
13057: CHECK_TYPE0(XPATH_NODESET);
13058: obj = valuePop(ctxt);
13059: oldset = obj->nodesetval;
13060:
13061: oldnode = ctxt->context->node;
13062: oldDoc = ctxt->context->doc;
13063: ctxt->context->node = NULL;
13064:
13065: if ((oldset == NULL) || (oldset->nodeNr == 0)) {
13066: ctxt->context->contextSize = 0;
13067: ctxt->context->proximityPosition = 0;
13068: /* QUESTION TODO: Why was this code commented out?
13069: if (op->ch2 != -1)
13070: total +=
13071: xmlXPathCompOpEval(ctxt,
13072: &comp->steps[op->ch2]);
13073: CHECK_ERROR0;
13074: res = valuePop(ctxt);
13075: if (res != NULL)
13076: xmlXPathFreeObject(res);
13077: */
13078: valuePush(ctxt, obj);
13079: ctxt->context->node = oldnode;
13080: CHECK_ERROR0;
13081: } else {
13082: xmlNodeSetPtr newset;
13083: xmlXPathObjectPtr tmp = NULL;
13084: /*
13085: * Initialize the new set.
13086: * Also set the xpath document in case things like
13087: * key() evaluation are attempted on the predicate
13088: */
13089: newset = xmlXPathNodeSetCreate(NULL);
13090: /* XXX what if xmlXPathNodeSetCreate returned NULL? */
13091:
13092: for (i = 0; i < oldset->nodeNr; i++) {
13093: /*
13094: * Run the evaluation with a node list made of
13095: * a single item in the nodeset.
13096: */
13097: ctxt->context->node = oldset->nodeTab[i];
13098: if ((oldset->nodeTab[i]->type != XML_NAMESPACE_DECL) &&
13099: (oldset->nodeTab[i]->doc != NULL))
13100: ctxt->context->doc = oldset->nodeTab[i]->doc;
13101: if (tmp == NULL) {
13102: tmp = xmlXPathCacheNewNodeSet(ctxt->context,
13103: ctxt->context->node);
13104: } else {
13105: xmlXPathNodeSetAddUnique(tmp->nodesetval,
13106: ctxt->context->node);
13107: }
13108: valuePush(ctxt, tmp);
13109: ctxt->context->contextSize = oldset->nodeNr;
13110: ctxt->context->proximityPosition = i + 1;
13111: if (op->ch2 != -1)
13112: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13113: if (ctxt->error != XPATH_EXPRESSION_OK) {
13114: xmlXPathFreeNodeSet(newset);
13115: xmlXPathFreeObject(obj);
13116: return(0);
13117: }
13118: /*
13119: * The result of the evaluation needs to be tested to
13120: * decide whether the filter succeeded or not
13121: */
13122: res = valuePop(ctxt);
13123: if (xmlXPathEvaluatePredicateResult(ctxt, res)) {
13124: xmlXPathNodeSetAdd(newset, oldset->nodeTab[i]);
13125: }
13126: /*
13127: * Cleanup
13128: */
13129: if (res != NULL) {
13130: xmlXPathReleaseObject(ctxt->context, res);
13131: }
13132: if (ctxt->value == tmp) {
13133: valuePop(ctxt);
13134: /*
13135: * Don't free the temporary nodeset
13136: * in order to avoid massive recreation inside this
13137: * loop.
13138: */
13139: xmlXPathNodeSetClear(tmp->nodesetval, 1);
13140: } else
13141: tmp = NULL;
13142: ctxt->context->node = NULL;
13143: /*
13144: * Only put the first node in the result, then leave.
13145: */
13146: if (newset->nodeNr > 0) {
13147: *first = *(newset->nodeTab);
13148: break;
13149: }
13150: }
13151: if (tmp != NULL) {
13152: xmlXPathReleaseObject(ctxt->context, tmp);
13153: }
13154: /*
13155: * The result is used as the new evaluation set.
13156: */
13157: xmlXPathReleaseObject(ctxt->context, obj);
13158: ctxt->context->node = NULL;
13159: ctxt->context->contextSize = -1;
13160: ctxt->context->proximityPosition = -1;
13161: /* may want to move this past the '}' later */
13162: ctxt->context->doc = oldDoc;
13163: valuePush(ctxt, xmlXPathCacheWrapNodeSet(ctxt->context, newset));
13164: }
13165: ctxt->context->node = oldnode;
13166: return(total);
13167: }
13168: #endif /* XP_OPTIMIZED_FILTER_FIRST */
13169:
13170: /**
13171: * xmlXPathCompOpEval:
13172: * @ctxt: the XPath parser context with the compiled expression
13173: * @op: an XPath compiled operation
13174: *
13175: * Evaluate the Precompiled XPath operation
13176: * Returns the number of nodes traversed
13177: */
13178: static int
13179: xmlXPathCompOpEval(xmlXPathParserContextPtr ctxt, xmlXPathStepOpPtr op)
13180: {
13181: int total = 0;
13182: int equal, ret;
13183: xmlXPathCompExprPtr comp;
13184: xmlXPathObjectPtr arg1, arg2;
13185: xmlNodePtr bak;
13186: xmlDocPtr bakd;
13187: int pp;
13188: int cs;
13189:
13190: CHECK_ERROR0;
13191: comp = ctxt->comp;
13192: switch (op->op) {
13193: case XPATH_OP_END:
13194: return (0);
13195: case XPATH_OP_AND:
13196: bakd = ctxt->context->doc;
13197: bak = ctxt->context->node;
13198: pp = ctxt->context->proximityPosition;
13199: cs = ctxt->context->contextSize;
13200: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13201: CHECK_ERROR0;
13202: xmlXPathBooleanFunction(ctxt, 1);
13203: if ((ctxt->value == NULL) || (ctxt->value->boolval == 0))
13204: return (total);
13205: arg2 = valuePop(ctxt);
13206: ctxt->context->doc = bakd;
13207: ctxt->context->node = bak;
13208: ctxt->context->proximityPosition = pp;
13209: ctxt->context->contextSize = cs;
13210: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13211: if (ctxt->error) {
13212: xmlXPathFreeObject(arg2);
13213: return(0);
13214: }
13215: xmlXPathBooleanFunction(ctxt, 1);
13216: arg1 = valuePop(ctxt);
13217: arg1->boolval &= arg2->boolval;
13218: valuePush(ctxt, arg1);
13219: xmlXPathReleaseObject(ctxt->context, arg2);
13220: return (total);
13221: case XPATH_OP_OR:
13222: bakd = ctxt->context->doc;
13223: bak = ctxt->context->node;
13224: pp = ctxt->context->proximityPosition;
13225: cs = ctxt->context->contextSize;
13226: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13227: CHECK_ERROR0;
13228: xmlXPathBooleanFunction(ctxt, 1);
13229: if ((ctxt->value == NULL) || (ctxt->value->boolval == 1))
13230: return (total);
13231: arg2 = valuePop(ctxt);
13232: ctxt->context->doc = bakd;
13233: ctxt->context->node = bak;
13234: ctxt->context->proximityPosition = pp;
13235: ctxt->context->contextSize = cs;
13236: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13237: if (ctxt->error) {
13238: xmlXPathFreeObject(arg2);
13239: return(0);
13240: }
13241: xmlXPathBooleanFunction(ctxt, 1);
13242: arg1 = valuePop(ctxt);
13243: arg1->boolval |= arg2->boolval;
13244: valuePush(ctxt, arg1);
13245: xmlXPathReleaseObject(ctxt->context, arg2);
13246: return (total);
13247: case XPATH_OP_EQUAL:
13248: bakd = ctxt->context->doc;
13249: bak = ctxt->context->node;
13250: pp = ctxt->context->proximityPosition;
13251: cs = ctxt->context->contextSize;
13252: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13253: CHECK_ERROR0;
13254: ctxt->context->doc = bakd;
13255: ctxt->context->node = bak;
13256: ctxt->context->proximityPosition = pp;
13257: ctxt->context->contextSize = cs;
13258: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13259: CHECK_ERROR0;
13260: if (op->value)
13261: equal = xmlXPathEqualValues(ctxt);
13262: else
13263: equal = xmlXPathNotEqualValues(ctxt);
13264: valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, equal));
13265: return (total);
13266: case XPATH_OP_CMP:
13267: bakd = ctxt->context->doc;
13268: bak = ctxt->context->node;
13269: pp = ctxt->context->proximityPosition;
13270: cs = ctxt->context->contextSize;
13271: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13272: CHECK_ERROR0;
13273: ctxt->context->doc = bakd;
13274: ctxt->context->node = bak;
13275: ctxt->context->proximityPosition = pp;
13276: ctxt->context->contextSize = cs;
13277: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13278: CHECK_ERROR0;
13279: ret = xmlXPathCompareValues(ctxt, op->value, op->value2);
13280: valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, ret));
13281: return (total);
13282: case XPATH_OP_PLUS:
13283: bakd = ctxt->context->doc;
13284: bak = ctxt->context->node;
13285: pp = ctxt->context->proximityPosition;
13286: cs = ctxt->context->contextSize;
13287: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13288: CHECK_ERROR0;
13289: if (op->ch2 != -1) {
13290: ctxt->context->doc = bakd;
13291: ctxt->context->node = bak;
13292: ctxt->context->proximityPosition = pp;
13293: ctxt->context->contextSize = cs;
13294: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13295: }
13296: CHECK_ERROR0;
13297: if (op->value == 0)
13298: xmlXPathSubValues(ctxt);
13299: else if (op->value == 1)
13300: xmlXPathAddValues(ctxt);
13301: else if (op->value == 2)
13302: xmlXPathValueFlipSign(ctxt);
13303: else if (op->value == 3) {
13304: CAST_TO_NUMBER;
13305: CHECK_TYPE0(XPATH_NUMBER);
13306: }
13307: return (total);
13308: case XPATH_OP_MULT:
13309: bakd = ctxt->context->doc;
13310: bak = ctxt->context->node;
13311: pp = ctxt->context->proximityPosition;
13312: cs = ctxt->context->contextSize;
13313: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13314: CHECK_ERROR0;
13315: ctxt->context->doc = bakd;
13316: ctxt->context->node = bak;
13317: ctxt->context->proximityPosition = pp;
13318: ctxt->context->contextSize = cs;
13319: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13320: CHECK_ERROR0;
13321: if (op->value == 0)
13322: xmlXPathMultValues(ctxt);
13323: else if (op->value == 1)
13324: xmlXPathDivValues(ctxt);
13325: else if (op->value == 2)
13326: xmlXPathModValues(ctxt);
13327: return (total);
13328: case XPATH_OP_UNION:
13329: bakd = ctxt->context->doc;
13330: bak = ctxt->context->node;
13331: pp = ctxt->context->proximityPosition;
13332: cs = ctxt->context->contextSize;
13333: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13334: CHECK_ERROR0;
13335: ctxt->context->doc = bakd;
13336: ctxt->context->node = bak;
13337: ctxt->context->proximityPosition = pp;
13338: ctxt->context->contextSize = cs;
13339: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13340: CHECK_ERROR0;
13341: CHECK_TYPE0(XPATH_NODESET);
13342: arg2 = valuePop(ctxt);
13343:
13344: CHECK_TYPE0(XPATH_NODESET);
13345: arg1 = valuePop(ctxt);
13346:
13347: if ((arg1->nodesetval == NULL) ||
13348: ((arg2->nodesetval != NULL) &&
13349: (arg2->nodesetval->nodeNr != 0)))
13350: {
13351: arg1->nodesetval = xmlXPathNodeSetMerge(arg1->nodesetval,
13352: arg2->nodesetval);
13353: }
13354:
13355: valuePush(ctxt, arg1);
13356: xmlXPathReleaseObject(ctxt->context, arg2);
13357: return (total);
13358: case XPATH_OP_ROOT:
13359: xmlXPathRoot(ctxt);
13360: return (total);
13361: case XPATH_OP_NODE:
13362: if (op->ch1 != -1)
13363: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13364: CHECK_ERROR0;
13365: if (op->ch2 != -1)
13366: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13367: CHECK_ERROR0;
13368: valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context,
13369: ctxt->context->node));
13370: return (total);
13371: case XPATH_OP_RESET:
13372: if (op->ch1 != -1)
13373: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13374: CHECK_ERROR0;
13375: if (op->ch2 != -1)
13376: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13377: CHECK_ERROR0;
13378: ctxt->context->node = NULL;
13379: return (total);
13380: case XPATH_OP_COLLECT:{
13381: if (op->ch1 == -1)
13382: return (total);
13383:
13384: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13385: CHECK_ERROR0;
13386:
13387: total += xmlXPathNodeCollectAndTest(ctxt, op, NULL, NULL, 0);
13388: return (total);
13389: }
13390: case XPATH_OP_VALUE:
13391: valuePush(ctxt,
13392: xmlXPathCacheObjectCopy(ctxt->context,
13393: (xmlXPathObjectPtr) op->value4));
13394: return (total);
13395: case XPATH_OP_VARIABLE:{
13396: xmlXPathObjectPtr val;
13397:
13398: if (op->ch1 != -1)
13399: total +=
13400: xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13401: if (op->value5 == NULL) {
13402: val = xmlXPathVariableLookup(ctxt->context, op->value4);
13403: if (val == NULL) {
13404: ctxt->error = XPATH_UNDEF_VARIABLE_ERROR;
13405: return(0);
13406: }
13407: valuePush(ctxt, val);
13408: } else {
13409: const xmlChar *URI;
13410:
13411: URI = xmlXPathNsLookup(ctxt->context, op->value5);
13412: if (URI == NULL) {
13413: xmlGenericError(xmlGenericErrorContext,
13414: "xmlXPathCompOpEval: variable %s bound to undefined prefix %s\n",
13415: (char *) op->value4, (char *)op->value5);
13416: ctxt->error = XPATH_UNDEF_PREFIX_ERROR;
13417: return (total);
13418: }
13419: val = xmlXPathVariableLookupNS(ctxt->context,
13420: op->value4, URI);
13421: if (val == NULL) {
13422: ctxt->error = XPATH_UNDEF_VARIABLE_ERROR;
13423: return(0);
13424: }
13425: valuePush(ctxt, val);
13426: }
13427: return (total);
13428: }
13429: case XPATH_OP_FUNCTION:{
13430: xmlXPathFunction func;
13431: const xmlChar *oldFunc, *oldFuncURI;
13432: int i;
13433: int frame;
13434:
13435: frame = xmlXPathSetFrame(ctxt);
13436: if (op->ch1 != -1)
13437: total +=
13438: xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13439: if (ctxt->valueNr < op->value) {
13440: xmlGenericError(xmlGenericErrorContext,
13441: "xmlXPathCompOpEval: parameter error\n");
13442: ctxt->error = XPATH_INVALID_OPERAND;
13443: xmlXPathPopFrame(ctxt, frame);
13444: return (total);
13445: }
13446: for (i = 0; i < op->value; i++) {
13447: if (ctxt->valueTab[(ctxt->valueNr - 1) - i] == NULL) {
13448: xmlGenericError(xmlGenericErrorContext,
13449: "xmlXPathCompOpEval: parameter error\n");
13450: ctxt->error = XPATH_INVALID_OPERAND;
13451: xmlXPathPopFrame(ctxt, frame);
13452: return (total);
13453: }
13454: }
13455: if (op->cache != NULL)
13456: XML_CAST_FPTR(func) = op->cache;
13457: else {
13458: const xmlChar *URI = NULL;
13459:
13460: if (op->value5 == NULL)
13461: func =
13462: xmlXPathFunctionLookup(ctxt->context,
13463: op->value4);
13464: else {
13465: URI = xmlXPathNsLookup(ctxt->context, op->value5);
13466: if (URI == NULL) {
13467: xmlGenericError(xmlGenericErrorContext,
13468: "xmlXPathCompOpEval: function %s bound to undefined prefix %s\n",
13469: (char *)op->value4, (char *)op->value5);
13470: xmlXPathPopFrame(ctxt, frame);
13471: ctxt->error = XPATH_UNDEF_PREFIX_ERROR;
13472: return (total);
13473: }
13474: func = xmlXPathFunctionLookupNS(ctxt->context,
13475: op->value4, URI);
13476: }
13477: if (func == NULL) {
13478: xmlGenericError(xmlGenericErrorContext,
13479: "xmlXPathCompOpEval: function %s not found\n",
13480: (char *)op->value4);
13481: XP_ERROR0(XPATH_UNKNOWN_FUNC_ERROR);
13482: }
13483: op->cache = XML_CAST_FPTR(func);
13484: op->cacheURI = (void *) URI;
13485: }
13486: oldFunc = ctxt->context->function;
13487: oldFuncURI = ctxt->context->functionURI;
13488: ctxt->context->function = op->value4;
13489: ctxt->context->functionURI = op->cacheURI;
13490: func(ctxt, op->value);
13491: ctxt->context->function = oldFunc;
13492: ctxt->context->functionURI = oldFuncURI;
13493: xmlXPathPopFrame(ctxt, frame);
13494: return (total);
13495: }
13496: case XPATH_OP_ARG:
13497: bakd = ctxt->context->doc;
13498: bak = ctxt->context->node;
13499: pp = ctxt->context->proximityPosition;
13500: cs = ctxt->context->contextSize;
13501: if (op->ch1 != -1)
13502: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13503: ctxt->context->contextSize = cs;
13504: ctxt->context->proximityPosition = pp;
13505: ctxt->context->node = bak;
13506: ctxt->context->doc = bakd;
13507: CHECK_ERROR0;
13508: if (op->ch2 != -1) {
13509: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13510: ctxt->context->doc = bakd;
13511: ctxt->context->node = bak;
13512: CHECK_ERROR0;
13513: }
13514: return (total);
13515: case XPATH_OP_PREDICATE:
13516: case XPATH_OP_FILTER:{
13517: xmlXPathObjectPtr res;
13518: xmlXPathObjectPtr obj, tmp;
13519: xmlNodeSetPtr newset = NULL;
13520: xmlNodeSetPtr oldset;
13521: xmlNodePtr oldnode;
13522: xmlDocPtr oldDoc;
13523: int i;
13524:
13525: /*
13526: * Optimization for ()[1] selection i.e. the first elem
13527: */
13528: if ((op->ch1 != -1) && (op->ch2 != -1) &&
13529: #ifdef XP_OPTIMIZED_FILTER_FIRST
13530: /*
13531: * FILTER TODO: Can we assume that the inner processing
13532: * will result in an ordered list if we have an
13533: * XPATH_OP_FILTER?
13534: * What about an additional field or flag on
13535: * xmlXPathObject like @sorted ? This way we wouln'd need
13536: * to assume anything, so it would be more robust and
13537: * easier to optimize.
13538: */
13539: ((comp->steps[op->ch1].op == XPATH_OP_SORT) || /* 18 */
13540: (comp->steps[op->ch1].op == XPATH_OP_FILTER)) && /* 17 */
13541: #else
13542: (comp->steps[op->ch1].op == XPATH_OP_SORT) &&
13543: #endif
13544: (comp->steps[op->ch2].op == XPATH_OP_VALUE)) { /* 12 */
13545: xmlXPathObjectPtr val;
13546:
13547: val = comp->steps[op->ch2].value4;
13548: if ((val != NULL) && (val->type == XPATH_NUMBER) &&
13549: (val->floatval == 1.0)) {
13550: xmlNodePtr first = NULL;
13551:
13552: total +=
13553: xmlXPathCompOpEvalFirst(ctxt,
13554: &comp->steps[op->ch1],
13555: &first);
13556: CHECK_ERROR0;
13557: /*
13558: * The nodeset should be in document order,
13559: * Keep only the first value
13560: */
13561: if ((ctxt->value != NULL) &&
13562: (ctxt->value->type == XPATH_NODESET) &&
13563: (ctxt->value->nodesetval != NULL) &&
13564: (ctxt->value->nodesetval->nodeNr > 1))
13565: ctxt->value->nodesetval->nodeNr = 1;
13566: return (total);
13567: }
13568: }
13569: /*
13570: * Optimization for ()[last()] selection i.e. the last elem
13571: */
13572: if ((op->ch1 != -1) && (op->ch2 != -1) &&
13573: (comp->steps[op->ch1].op == XPATH_OP_SORT) &&
13574: (comp->steps[op->ch2].op == XPATH_OP_SORT)) {
13575: int f = comp->steps[op->ch2].ch1;
13576:
13577: if ((f != -1) &&
13578: (comp->steps[f].op == XPATH_OP_FUNCTION) &&
13579: (comp->steps[f].value5 == NULL) &&
13580: (comp->steps[f].value == 0) &&
13581: (comp->steps[f].value4 != NULL) &&
13582: (xmlStrEqual
13583: (comp->steps[f].value4, BAD_CAST "last"))) {
13584: xmlNodePtr last = NULL;
13585:
13586: total +=
13587: xmlXPathCompOpEvalLast(ctxt,
13588: &comp->steps[op->ch1],
13589: &last);
13590: CHECK_ERROR0;
13591: /*
13592: * The nodeset should be in document order,
13593: * Keep only the last value
13594: */
13595: if ((ctxt->value != NULL) &&
13596: (ctxt->value->type == XPATH_NODESET) &&
13597: (ctxt->value->nodesetval != NULL) &&
13598: (ctxt->value->nodesetval->nodeTab != NULL) &&
13599: (ctxt->value->nodesetval->nodeNr > 1)) {
13600: ctxt->value->nodesetval->nodeTab[0] =
13601: ctxt->value->nodesetval->nodeTab[ctxt->
13602: value->
13603: nodesetval->
13604: nodeNr -
13605: 1];
13606: ctxt->value->nodesetval->nodeNr = 1;
13607: }
13608: return (total);
13609: }
13610: }
13611: /*
13612: * Process inner predicates first.
13613: * Example "index[parent::book][1]":
13614: * ...
13615: * PREDICATE <-- we are here "[1]"
13616: * PREDICATE <-- process "[parent::book]" first
13617: * SORT
13618: * COLLECT 'parent' 'name' 'node' book
13619: * NODE
13620: * ELEM Object is a number : 1
13621: */
13622: if (op->ch1 != -1)
13623: total +=
13624: xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13625: CHECK_ERROR0;
13626: if (op->ch2 == -1)
13627: return (total);
13628: if (ctxt->value == NULL)
13629: return (total);
13630:
13631: oldnode = ctxt->context->node;
13632:
13633: #ifdef LIBXML_XPTR_ENABLED
13634: /*
13635: * Hum are we filtering the result of an XPointer expression
13636: */
13637: if (ctxt->value->type == XPATH_LOCATIONSET) {
13638: xmlLocationSetPtr newlocset = NULL;
13639: xmlLocationSetPtr oldlocset;
13640:
13641: /*
13642: * Extract the old locset, and then evaluate the result of the
13643: * expression for all the element in the locset. use it to grow
13644: * up a new locset.
13645: */
13646: CHECK_TYPE0(XPATH_LOCATIONSET);
13647: obj = valuePop(ctxt);
13648: oldlocset = obj->user;
13649: ctxt->context->node = NULL;
13650:
13651: if ((oldlocset == NULL) || (oldlocset->locNr == 0)) {
13652: ctxt->context->contextSize = 0;
13653: ctxt->context->proximityPosition = 0;
13654: if (op->ch2 != -1)
13655: total +=
13656: xmlXPathCompOpEval(ctxt,
13657: &comp->steps[op->ch2]);
13658: res = valuePop(ctxt);
13659: if (res != NULL) {
13660: xmlXPathReleaseObject(ctxt->context, res);
13661: }
13662: valuePush(ctxt, obj);
13663: CHECK_ERROR0;
13664: return (total);
13665: }
13666: newlocset = xmlXPtrLocationSetCreate(NULL);
13667:
13668: for (i = 0; i < oldlocset->locNr; i++) {
13669: /*
13670: * Run the evaluation with a node list made of a
13671: * single item in the nodelocset.
13672: */
13673: ctxt->context->node = oldlocset->locTab[i]->user;
13674: ctxt->context->contextSize = oldlocset->locNr;
13675: ctxt->context->proximityPosition = i + 1;
13676: tmp = xmlXPathCacheNewNodeSet(ctxt->context,
13677: ctxt->context->node);
13678: valuePush(ctxt, tmp);
13679:
13680: if (op->ch2 != -1)
13681: total +=
13682: xmlXPathCompOpEval(ctxt,
13683: &comp->steps[op->ch2]);
13684: if (ctxt->error != XPATH_EXPRESSION_OK) {
13685: xmlXPathFreeObject(obj);
13686: return(0);
13687: }
13688:
13689: /*
13690: * The result of the evaluation need to be tested to
13691: * decided whether the filter succeeded or not
13692: */
13693: res = valuePop(ctxt);
13694: if (xmlXPathEvaluatePredicateResult(ctxt, res)) {
13695: xmlXPtrLocationSetAdd(newlocset,
13696: xmlXPathObjectCopy
13697: (oldlocset->locTab[i]));
13698: }
13699:
13700: /*
13701: * Cleanup
13702: */
13703: if (res != NULL) {
13704: xmlXPathReleaseObject(ctxt->context, res);
13705: }
13706: if (ctxt->value == tmp) {
13707: res = valuePop(ctxt);
13708: xmlXPathReleaseObject(ctxt->context, res);
13709: }
13710:
13711: ctxt->context->node = NULL;
13712: }
13713:
13714: /*
13715: * The result is used as the new evaluation locset.
13716: */
13717: xmlXPathReleaseObject(ctxt->context, obj);
13718: ctxt->context->node = NULL;
13719: ctxt->context->contextSize = -1;
13720: ctxt->context->proximityPosition = -1;
13721: valuePush(ctxt, xmlXPtrWrapLocationSet(newlocset));
13722: ctxt->context->node = oldnode;
13723: return (total);
13724: }
13725: #endif /* LIBXML_XPTR_ENABLED */
13726:
13727: /*
13728: * Extract the old set, and then evaluate the result of the
13729: * expression for all the element in the set. use it to grow
13730: * up a new set.
13731: */
13732: CHECK_TYPE0(XPATH_NODESET);
13733: obj = valuePop(ctxt);
13734: oldset = obj->nodesetval;
13735:
13736: oldnode = ctxt->context->node;
13737: oldDoc = ctxt->context->doc;
13738: ctxt->context->node = NULL;
13739:
13740: if ((oldset == NULL) || (oldset->nodeNr == 0)) {
13741: ctxt->context->contextSize = 0;
13742: ctxt->context->proximityPosition = 0;
13743: /*
13744: if (op->ch2 != -1)
13745: total +=
13746: xmlXPathCompOpEval(ctxt,
13747: &comp->steps[op->ch2]);
13748: CHECK_ERROR0;
13749: res = valuePop(ctxt);
13750: if (res != NULL)
13751: xmlXPathFreeObject(res);
13752: */
13753: valuePush(ctxt, obj);
13754: ctxt->context->node = oldnode;
13755: CHECK_ERROR0;
13756: } else {
13757: tmp = NULL;
13758: /*
13759: * Initialize the new set.
13760: * Also set the xpath document in case things like
13761: * key() evaluation are attempted on the predicate
13762: */
13763: newset = xmlXPathNodeSetCreate(NULL);
13764: /*
13765: * SPEC XPath 1.0:
13766: * "For each node in the node-set to be filtered, the
13767: * PredicateExpr is evaluated with that node as the
13768: * context node, with the number of nodes in the
13769: * node-set as the context size, and with the proximity
13770: * position of the node in the node-set with respect to
13771: * the axis as the context position;"
13772: * @oldset is the node-set" to be filtered.
13773: *
13774: * SPEC XPath 1.0:
13775: * "only predicates change the context position and
13776: * context size (see [2.4 Predicates])."
13777: * Example:
13778: * node-set context pos
13779: * nA 1
13780: * nB 2
13781: * nC 3
13782: * After applying predicate [position() > 1] :
13783: * node-set context pos
13784: * nB 1
13785: * nC 2
13786: *
13787: * removed the first node in the node-set, then
13788: * the context position of the
13789: */
13790: for (i = 0; i < oldset->nodeNr; i++) {
13791: /*
13792: * Run the evaluation with a node list made of
13793: * a single item in the nodeset.
13794: */
13795: ctxt->context->node = oldset->nodeTab[i];
13796: if ((oldset->nodeTab[i]->type != XML_NAMESPACE_DECL) &&
13797: (oldset->nodeTab[i]->doc != NULL))
13798: ctxt->context->doc = oldset->nodeTab[i]->doc;
13799: if (tmp == NULL) {
13800: tmp = xmlXPathCacheNewNodeSet(ctxt->context,
13801: ctxt->context->node);
13802: } else {
13803: xmlXPathNodeSetAddUnique(tmp->nodesetval,
13804: ctxt->context->node);
13805: }
13806: valuePush(ctxt, tmp);
13807: ctxt->context->contextSize = oldset->nodeNr;
13808: ctxt->context->proximityPosition = i + 1;
13809: /*
13810: * Evaluate the predicate against the context node.
13811: * Can/should we optimize position() predicates
13812: * here (e.g. "[1]")?
13813: */
13814: if (op->ch2 != -1)
13815: total +=
13816: xmlXPathCompOpEval(ctxt,
13817: &comp->steps[op->ch2]);
13818: if (ctxt->error != XPATH_EXPRESSION_OK) {
13819: xmlXPathFreeNodeSet(newset);
13820: xmlXPathFreeObject(obj);
13821: return(0);
13822: }
13823:
13824: /*
13825: * The result of the evaluation needs to be tested to
13826: * decide whether the filter succeeded or not
13827: */
13828: /*
13829: * OPTIMIZE TODO: Can we use
13830: * xmlXPathNodeSetAdd*Unique()* instead?
13831: */
13832: res = valuePop(ctxt);
13833: if (xmlXPathEvaluatePredicateResult(ctxt, res)) {
13834: xmlXPathNodeSetAdd(newset, oldset->nodeTab[i]);
13835: }
13836:
13837: /*
13838: * Cleanup
13839: */
13840: if (res != NULL) {
13841: xmlXPathReleaseObject(ctxt->context, res);
13842: }
13843: if (ctxt->value == tmp) {
13844: valuePop(ctxt);
13845: xmlXPathNodeSetClear(tmp->nodesetval, 1);
13846: /*
13847: * Don't free the temporary nodeset
13848: * in order to avoid massive recreation inside this
13849: * loop.
13850: */
13851: } else
13852: tmp = NULL;
13853: ctxt->context->node = NULL;
13854: }
13855: if (tmp != NULL)
13856: xmlXPathReleaseObject(ctxt->context, tmp);
13857: /*
13858: * The result is used as the new evaluation set.
13859: */
13860: xmlXPathReleaseObject(ctxt->context, obj);
13861: ctxt->context->node = NULL;
13862: ctxt->context->contextSize = -1;
13863: ctxt->context->proximityPosition = -1;
13864: /* may want to move this past the '}' later */
13865: ctxt->context->doc = oldDoc;
13866: valuePush(ctxt,
13867: xmlXPathCacheWrapNodeSet(ctxt->context, newset));
13868: }
13869: ctxt->context->node = oldnode;
13870: return (total);
13871: }
13872: case XPATH_OP_SORT:
13873: if (op->ch1 != -1)
13874: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13875: CHECK_ERROR0;
13876: if ((ctxt->value != NULL) &&
13877: (ctxt->value->type == XPATH_NODESET) &&
13878: (ctxt->value->nodesetval != NULL) &&
13879: (ctxt->value->nodesetval->nodeNr > 1))
13880: {
13881: xmlXPathNodeSetSort(ctxt->value->nodesetval);
13882: }
13883: return (total);
13884: #ifdef LIBXML_XPTR_ENABLED
13885: case XPATH_OP_RANGETO:{
13886: xmlXPathObjectPtr range;
13887: xmlXPathObjectPtr res, obj;
13888: xmlXPathObjectPtr tmp;
13889: xmlLocationSetPtr newlocset = NULL;
13890: xmlLocationSetPtr oldlocset;
13891: xmlNodeSetPtr oldset;
13892: int i, j;
13893:
13894: if (op->ch1 != -1)
13895: total +=
13896: xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13897: if (op->ch2 == -1)
13898: return (total);
13899:
13900: if (ctxt->value->type == XPATH_LOCATIONSET) {
13901: /*
13902: * Extract the old locset, and then evaluate the result of the
13903: * expression for all the element in the locset. use it to grow
13904: * up a new locset.
13905: */
13906: CHECK_TYPE0(XPATH_LOCATIONSET);
13907: obj = valuePop(ctxt);
13908: oldlocset = obj->user;
13909:
13910: if ((oldlocset == NULL) || (oldlocset->locNr == 0)) {
13911: ctxt->context->node = NULL;
13912: ctxt->context->contextSize = 0;
13913: ctxt->context->proximityPosition = 0;
13914: total += xmlXPathCompOpEval(ctxt,&comp->steps[op->ch2]);
13915: res = valuePop(ctxt);
13916: if (res != NULL) {
13917: xmlXPathReleaseObject(ctxt->context, res);
13918: }
13919: valuePush(ctxt, obj);
13920: CHECK_ERROR0;
13921: return (total);
13922: }
13923: newlocset = xmlXPtrLocationSetCreate(NULL);
13924:
13925: for (i = 0; i < oldlocset->locNr; i++) {
13926: /*
13927: * Run the evaluation with a node list made of a
13928: * single item in the nodelocset.
13929: */
13930: ctxt->context->node = oldlocset->locTab[i]->user;
13931: ctxt->context->contextSize = oldlocset->locNr;
13932: ctxt->context->proximityPosition = i + 1;
13933: tmp = xmlXPathCacheNewNodeSet(ctxt->context,
13934: ctxt->context->node);
13935: valuePush(ctxt, tmp);
13936:
13937: if (op->ch2 != -1)
13938: total +=
13939: xmlXPathCompOpEval(ctxt,
13940: &comp->steps[op->ch2]);
13941: if (ctxt->error != XPATH_EXPRESSION_OK) {
13942: xmlXPathFreeObject(obj);
13943: return(0);
13944: }
13945:
13946: res = valuePop(ctxt);
13947: if (res->type == XPATH_LOCATIONSET) {
13948: xmlLocationSetPtr rloc =
13949: (xmlLocationSetPtr)res->user;
13950: for (j=0; j<rloc->locNr; j++) {
13951: range = xmlXPtrNewRange(
13952: oldlocset->locTab[i]->user,
13953: oldlocset->locTab[i]->index,
13954: rloc->locTab[j]->user2,
13955: rloc->locTab[j]->index2);
13956: if (range != NULL) {
13957: xmlXPtrLocationSetAdd(newlocset, range);
13958: }
13959: }
13960: } else {
13961: range = xmlXPtrNewRangeNodeObject(
13962: (xmlNodePtr)oldlocset->locTab[i]->user, res);
13963: if (range != NULL) {
13964: xmlXPtrLocationSetAdd(newlocset,range);
13965: }
13966: }
13967:
13968: /*
13969: * Cleanup
13970: */
13971: if (res != NULL) {
13972: xmlXPathReleaseObject(ctxt->context, res);
13973: }
13974: if (ctxt->value == tmp) {
13975: res = valuePop(ctxt);
13976: xmlXPathReleaseObject(ctxt->context, res);
13977: }
13978:
13979: ctxt->context->node = NULL;
13980: }
13981: } else { /* Not a location set */
13982: CHECK_TYPE0(XPATH_NODESET);
13983: obj = valuePop(ctxt);
13984: oldset = obj->nodesetval;
13985: ctxt->context->node = NULL;
13986:
13987: newlocset = xmlXPtrLocationSetCreate(NULL);
13988:
13989: if (oldset != NULL) {
13990: for (i = 0; i < oldset->nodeNr; i++) {
13991: /*
13992: * Run the evaluation with a node list made of a single item
13993: * in the nodeset.
13994: */
13995: ctxt->context->node = oldset->nodeTab[i];
13996: /*
13997: * OPTIMIZE TODO: Avoid recreation for every iteration.
13998: */
13999: tmp = xmlXPathCacheNewNodeSet(ctxt->context,
14000: ctxt->context->node);
14001: valuePush(ctxt, tmp);
14002:
14003: if (op->ch2 != -1)
14004: total +=
14005: xmlXPathCompOpEval(ctxt,
14006: &comp->steps[op->ch2]);
14007: if (ctxt->error != XPATH_EXPRESSION_OK) {
14008: xmlXPathFreeObject(obj);
14009: return(0);
14010: }
14011:
14012: res = valuePop(ctxt);
14013: range =
14014: xmlXPtrNewRangeNodeObject(oldset->nodeTab[i],
14015: res);
14016: if (range != NULL) {
14017: xmlXPtrLocationSetAdd(newlocset, range);
14018: }
14019:
14020: /*
14021: * Cleanup
14022: */
14023: if (res != NULL) {
14024: xmlXPathReleaseObject(ctxt->context, res);
14025: }
14026: if (ctxt->value == tmp) {
14027: res = valuePop(ctxt);
14028: xmlXPathReleaseObject(ctxt->context, res);
14029: }
14030:
14031: ctxt->context->node = NULL;
14032: }
14033: }
14034: }
14035:
14036: /*
14037: * The result is used as the new evaluation set.
14038: */
14039: xmlXPathReleaseObject(ctxt->context, obj);
14040: ctxt->context->node = NULL;
14041: ctxt->context->contextSize = -1;
14042: ctxt->context->proximityPosition = -1;
14043: valuePush(ctxt, xmlXPtrWrapLocationSet(newlocset));
14044: return (total);
14045: }
14046: #endif /* LIBXML_XPTR_ENABLED */
14047: }
14048: xmlGenericError(xmlGenericErrorContext,
14049: "XPath: unknown precompiled operation %d\n", op->op);
14050: ctxt->error = XPATH_INVALID_OPERAND;
14051: return (total);
14052: }
14053:
14054: /**
14055: * xmlXPathCompOpEvalToBoolean:
14056: * @ctxt: the XPath parser context
14057: *
14058: * Evaluates if the expression evaluates to true.
14059: *
14060: * Returns 1 if true, 0 if false and -1 on API or internal errors.
14061: */
14062: static int
14063: xmlXPathCompOpEvalToBoolean(xmlXPathParserContextPtr ctxt,
14064: xmlXPathStepOpPtr op,
14065: int isPredicate)
14066: {
14067: xmlXPathObjectPtr resObj = NULL;
14068:
14069: start:
14070: /* comp = ctxt->comp; */
14071: switch (op->op) {
14072: case XPATH_OP_END:
14073: return (0);
14074: case XPATH_OP_VALUE:
14075: resObj = (xmlXPathObjectPtr) op->value4;
14076: if (isPredicate)
14077: return(xmlXPathEvaluatePredicateResult(ctxt, resObj));
14078: return(xmlXPathCastToBoolean(resObj));
14079: case XPATH_OP_SORT:
14080: /*
14081: * We don't need sorting for boolean results. Skip this one.
14082: */
14083: if (op->ch1 != -1) {
14084: op = &ctxt->comp->steps[op->ch1];
14085: goto start;
14086: }
14087: return(0);
14088: case XPATH_OP_COLLECT:
14089: if (op->ch1 == -1)
14090: return(0);
14091:
14092: xmlXPathCompOpEval(ctxt, &ctxt->comp->steps[op->ch1]);
14093: if (ctxt->error != XPATH_EXPRESSION_OK)
14094: return(-1);
14095:
14096: xmlXPathNodeCollectAndTest(ctxt, op, NULL, NULL, 1);
14097: if (ctxt->error != XPATH_EXPRESSION_OK)
14098: return(-1);
14099:
14100: resObj = valuePop(ctxt);
14101: if (resObj == NULL)
14102: return(-1);
14103: break;
14104: default:
14105: /*
14106: * Fallback to call xmlXPathCompOpEval().
14107: */
14108: xmlXPathCompOpEval(ctxt, op);
14109: if (ctxt->error != XPATH_EXPRESSION_OK)
14110: return(-1);
14111:
14112: resObj = valuePop(ctxt);
14113: if (resObj == NULL)
14114: return(-1);
14115: break;
14116: }
14117:
14118: if (resObj) {
14119: int res;
14120:
14121: if (resObj->type == XPATH_BOOLEAN) {
14122: res = resObj->boolval;
14123: } else if (isPredicate) {
14124: /*
14125: * For predicates a result of type "number" is handled
14126: * differently:
14127: * SPEC XPath 1.0:
14128: * "If the result is a number, the result will be converted
14129: * to true if the number is equal to the context position
14130: * and will be converted to false otherwise;"
14131: */
14132: res = xmlXPathEvaluatePredicateResult(ctxt, resObj);
14133: } else {
14134: res = xmlXPathCastToBoolean(resObj);
14135: }
14136: xmlXPathReleaseObject(ctxt->context, resObj);
14137: return(res);
14138: }
14139:
14140: return(0);
14141: }
14142:
14143: #ifdef XPATH_STREAMING
14144: /**
14145: * xmlXPathRunStreamEval:
14146: * @ctxt: the XPath parser context with the compiled expression
14147: *
14148: * Evaluate the Precompiled Streamable XPath expression in the given context.
14149: */
14150: static int
14151: xmlXPathRunStreamEval(xmlXPathContextPtr ctxt, xmlPatternPtr comp,
14152: xmlXPathObjectPtr *resultSeq, int toBool)
14153: {
14154: int max_depth, min_depth;
14155: int from_root;
14156: int ret, depth;
14157: int eval_all_nodes;
14158: xmlNodePtr cur = NULL, limit = NULL;
14159: xmlStreamCtxtPtr patstream = NULL;
14160:
14161: int nb_nodes = 0;
14162:
14163: if ((ctxt == NULL) || (comp == NULL))
14164: return(-1);
14165: max_depth = xmlPatternMaxDepth(comp);
14166: if (max_depth == -1)
14167: return(-1);
14168: if (max_depth == -2)
14169: max_depth = 10000;
14170: min_depth = xmlPatternMinDepth(comp);
14171: if (min_depth == -1)
14172: return(-1);
14173: from_root = xmlPatternFromRoot(comp);
14174: if (from_root < 0)
14175: return(-1);
14176: #if 0
14177: printf("stream eval: depth %d from root %d\n", max_depth, from_root);
14178: #endif
14179:
14180: if (! toBool) {
14181: if (resultSeq == NULL)
14182: return(-1);
14183: *resultSeq = xmlXPathCacheNewNodeSet(ctxt, NULL);
14184: if (*resultSeq == NULL)
14185: return(-1);
14186: }
14187:
14188: /*
14189: * handle the special cases of "/" amd "." being matched
14190: */
14191: if (min_depth == 0) {
14192: if (from_root) {
14193: /* Select "/" */
14194: if (toBool)
14195: return(1);
14196: xmlXPathNodeSetAddUnique((*resultSeq)->nodesetval,
14197: (xmlNodePtr) ctxt->doc);
14198: } else {
14199: /* Select "self::node()" */
14200: if (toBool)
14201: return(1);
14202: xmlXPathNodeSetAddUnique((*resultSeq)->nodesetval, ctxt->node);
14203: }
14204: }
14205: if (max_depth == 0) {
14206: return(0);
14207: }
14208:
14209: if (from_root) {
14210: cur = (xmlNodePtr)ctxt->doc;
14211: } else if (ctxt->node != NULL) {
14212: switch (ctxt->node->type) {
14213: case XML_ELEMENT_NODE:
14214: case XML_DOCUMENT_NODE:
14215: case XML_DOCUMENT_FRAG_NODE:
14216: case XML_HTML_DOCUMENT_NODE:
14217: #ifdef LIBXML_DOCB_ENABLED
14218: case XML_DOCB_DOCUMENT_NODE:
14219: #endif
14220: cur = ctxt->node;
14221: break;
14222: case XML_ATTRIBUTE_NODE:
14223: case XML_TEXT_NODE:
14224: case XML_CDATA_SECTION_NODE:
14225: case XML_ENTITY_REF_NODE:
14226: case XML_ENTITY_NODE:
14227: case XML_PI_NODE:
14228: case XML_COMMENT_NODE:
14229: case XML_NOTATION_NODE:
14230: case XML_DTD_NODE:
14231: case XML_DOCUMENT_TYPE_NODE:
14232: case XML_ELEMENT_DECL:
14233: case XML_ATTRIBUTE_DECL:
14234: case XML_ENTITY_DECL:
14235: case XML_NAMESPACE_DECL:
14236: case XML_XINCLUDE_START:
14237: case XML_XINCLUDE_END:
14238: break;
14239: }
14240: limit = cur;
14241: }
14242: if (cur == NULL) {
14243: return(0);
14244: }
14245:
14246: patstream = xmlPatternGetStreamCtxt(comp);
14247: if (patstream == NULL) {
14248: /*
14249: * QUESTION TODO: Is this an error?
14250: */
14251: return(0);
14252: }
14253:
14254: eval_all_nodes = xmlStreamWantsAnyNode(patstream);
14255:
14256: if (from_root) {
14257: ret = xmlStreamPush(patstream, NULL, NULL);
14258: if (ret < 0) {
14259: } else if (ret == 1) {
14260: if (toBool)
14261: goto return_1;
14262: xmlXPathNodeSetAddUnique((*resultSeq)->nodesetval, cur);
14263: }
14264: }
14265: depth = 0;
14266: goto scan_children;
14267: next_node:
14268: do {
14269: nb_nodes++;
14270:
14271: switch (cur->type) {
14272: case XML_ELEMENT_NODE:
14273: case XML_TEXT_NODE:
14274: case XML_CDATA_SECTION_NODE:
14275: case XML_COMMENT_NODE:
14276: case XML_PI_NODE:
14277: if (cur->type == XML_ELEMENT_NODE) {
14278: ret = xmlStreamPush(patstream, cur->name,
14279: (cur->ns ? cur->ns->href : NULL));
14280: } else if (eval_all_nodes)
14281: ret = xmlStreamPushNode(patstream, NULL, NULL, cur->type);
14282: else
14283: break;
14284:
14285: if (ret < 0) {
14286: /* NOP. */
14287: } else if (ret == 1) {
14288: if (toBool)
14289: goto return_1;
14290: xmlXPathNodeSetAddUnique((*resultSeq)->nodesetval, cur);
14291: }
14292: if ((cur->children == NULL) || (depth >= max_depth)) {
14293: ret = xmlStreamPop(patstream);
14294: while (cur->next != NULL) {
14295: cur = cur->next;
14296: if ((cur->type != XML_ENTITY_DECL) &&
14297: (cur->type != XML_DTD_NODE))
14298: goto next_node;
14299: }
14300: }
14301: default:
14302: break;
14303: }
14304:
14305: scan_children:
14306: if ((cur->children != NULL) && (depth < max_depth)) {
14307: /*
14308: * Do not descend on entities declarations
14309: */
14310: if (cur->children->type != XML_ENTITY_DECL) {
14311: cur = cur->children;
14312: depth++;
14313: /*
14314: * Skip DTDs
14315: */
14316: if (cur->type != XML_DTD_NODE)
14317: continue;
14318: }
14319: }
14320:
14321: if (cur == limit)
14322: break;
14323:
14324: while (cur->next != NULL) {
14325: cur = cur->next;
14326: if ((cur->type != XML_ENTITY_DECL) &&
14327: (cur->type != XML_DTD_NODE))
14328: goto next_node;
14329: }
14330:
14331: do {
14332: cur = cur->parent;
14333: depth--;
14334: if ((cur == NULL) || (cur == limit))
14335: goto done;
14336: if (cur->type == XML_ELEMENT_NODE) {
14337: ret = xmlStreamPop(patstream);
14338: } else if ((eval_all_nodes) &&
14339: ((cur->type == XML_TEXT_NODE) ||
14340: (cur->type == XML_CDATA_SECTION_NODE) ||
14341: (cur->type == XML_COMMENT_NODE) ||
14342: (cur->type == XML_PI_NODE)))
14343: {
14344: ret = xmlStreamPop(patstream);
14345: }
14346: if (cur->next != NULL) {
14347: cur = cur->next;
14348: break;
14349: }
14350: } while (cur != NULL);
14351:
14352: } while ((cur != NULL) && (depth >= 0));
14353:
14354: done:
14355:
14356: #if 0
14357: printf("stream eval: checked %d nodes selected %d\n",
14358: nb_nodes, retObj->nodesetval->nodeNr);
14359: #endif
14360:
14361: if (patstream)
14362: xmlFreeStreamCtxt(patstream);
14363: return(0);
14364:
14365: return_1:
14366: if (patstream)
14367: xmlFreeStreamCtxt(patstream);
14368: return(1);
14369: }
14370: #endif /* XPATH_STREAMING */
14371:
14372: /**
14373: * xmlXPathRunEval:
14374: * @ctxt: the XPath parser context with the compiled expression
14375: * @toBool: evaluate to a boolean result
14376: *
14377: * Evaluate the Precompiled XPath expression in the given context.
14378: */
14379: static int
14380: xmlXPathRunEval(xmlXPathParserContextPtr ctxt, int toBool)
14381: {
14382: xmlXPathCompExprPtr comp;
14383:
14384: if ((ctxt == NULL) || (ctxt->comp == NULL))
14385: return(-1);
14386:
14387: if (ctxt->valueTab == NULL) {
14388: /* Allocate the value stack */
14389: ctxt->valueTab = (xmlXPathObjectPtr *)
14390: xmlMalloc(10 * sizeof(xmlXPathObjectPtr));
14391: if (ctxt->valueTab == NULL) {
14392: xmlXPathPErrMemory(ctxt, "creating evaluation context\n");
14393: xmlFree(ctxt);
14394: }
14395: ctxt->valueNr = 0;
14396: ctxt->valueMax = 10;
14397: ctxt->value = NULL;
14398: ctxt->valueFrame = 0;
14399: }
14400: #ifdef XPATH_STREAMING
14401: if (ctxt->comp->stream) {
14402: int res;
14403:
14404: if (toBool) {
14405: /*
14406: * Evaluation to boolean result.
14407: */
14408: res = xmlXPathRunStreamEval(ctxt->context,
14409: ctxt->comp->stream, NULL, 1);
14410: if (res != -1)
14411: return(res);
14412: } else {
14413: xmlXPathObjectPtr resObj = NULL;
14414:
14415: /*
14416: * Evaluation to a sequence.
14417: */
14418: res = xmlXPathRunStreamEval(ctxt->context,
14419: ctxt->comp->stream, &resObj, 0);
14420:
14421: if ((res != -1) && (resObj != NULL)) {
14422: valuePush(ctxt, resObj);
14423: return(0);
14424: }
14425: if (resObj != NULL)
14426: xmlXPathReleaseObject(ctxt->context, resObj);
14427: }
14428: /*
14429: * QUESTION TODO: This falls back to normal XPath evaluation
14430: * if res == -1. Is this intended?
14431: */
14432: }
14433: #endif
14434: comp = ctxt->comp;
14435: if (comp->last < 0) {
14436: xmlGenericError(xmlGenericErrorContext,
14437: "xmlXPathRunEval: last is less than zero\n");
14438: return(-1);
14439: }
14440: if (toBool)
14441: return(xmlXPathCompOpEvalToBoolean(ctxt,
14442: &comp->steps[comp->last], 0));
14443: else
14444: xmlXPathCompOpEval(ctxt, &comp->steps[comp->last]);
14445:
14446: return(0);
14447: }
14448:
14449: /************************************************************************
14450: * *
14451: * Public interfaces *
14452: * *
14453: ************************************************************************/
14454:
14455: /**
14456: * xmlXPathEvalPredicate:
14457: * @ctxt: the XPath context
14458: * @res: the Predicate Expression evaluation result
14459: *
14460: * Evaluate a predicate result for the current node.
14461: * A PredicateExpr is evaluated by evaluating the Expr and converting
14462: * the result to a boolean. If the result is a number, the result will
14463: * be converted to true if the number is equal to the position of the
14464: * context node in the context node list (as returned by the position
14465: * function) and will be converted to false otherwise; if the result
14466: * is not a number, then the result will be converted as if by a call
14467: * to the boolean function.
14468: *
14469: * Returns 1 if predicate is true, 0 otherwise
14470: */
14471: int
14472: xmlXPathEvalPredicate(xmlXPathContextPtr ctxt, xmlXPathObjectPtr res) {
14473: if ((ctxt == NULL) || (res == NULL)) return(0);
14474: switch (res->type) {
14475: case XPATH_BOOLEAN:
14476: return(res->boolval);
14477: case XPATH_NUMBER:
14478: return(res->floatval == ctxt->proximityPosition);
14479: case XPATH_NODESET:
14480: case XPATH_XSLT_TREE:
14481: if (res->nodesetval == NULL)
14482: return(0);
14483: return(res->nodesetval->nodeNr != 0);
14484: case XPATH_STRING:
14485: return((res->stringval != NULL) &&
14486: (xmlStrlen(res->stringval) != 0));
14487: default:
14488: STRANGE
14489: }
14490: return(0);
14491: }
14492:
14493: /**
14494: * xmlXPathEvaluatePredicateResult:
14495: * @ctxt: the XPath Parser context
14496: * @res: the Predicate Expression evaluation result
14497: *
14498: * Evaluate a predicate result for the current node.
14499: * A PredicateExpr is evaluated by evaluating the Expr and converting
14500: * the result to a boolean. If the result is a number, the result will
14501: * be converted to true if the number is equal to the position of the
14502: * context node in the context node list (as returned by the position
14503: * function) and will be converted to false otherwise; if the result
14504: * is not a number, then the result will be converted as if by a call
14505: * to the boolean function.
14506: *
14507: * Returns 1 if predicate is true, 0 otherwise
14508: */
14509: int
14510: xmlXPathEvaluatePredicateResult(xmlXPathParserContextPtr ctxt,
14511: xmlXPathObjectPtr res) {
14512: if ((ctxt == NULL) || (res == NULL)) return(0);
14513: switch (res->type) {
14514: case XPATH_BOOLEAN:
14515: return(res->boolval);
14516: case XPATH_NUMBER:
14517: #if defined(__BORLANDC__) || (defined(_MSC_VER) && (_MSC_VER == 1200))
14518: return((res->floatval == ctxt->context->proximityPosition) &&
14519: (!xmlXPathIsNaN(res->floatval))); /* MSC pbm Mark Vakoc !*/
14520: #else
14521: return(res->floatval == ctxt->context->proximityPosition);
14522: #endif
14523: case XPATH_NODESET:
14524: case XPATH_XSLT_TREE:
14525: if (res->nodesetval == NULL)
14526: return(0);
14527: return(res->nodesetval->nodeNr != 0);
14528: case XPATH_STRING:
14529: return((res->stringval != NULL) && (res->stringval[0] != 0));
14530: #ifdef LIBXML_XPTR_ENABLED
14531: case XPATH_LOCATIONSET:{
14532: xmlLocationSetPtr ptr = res->user;
14533: if (ptr == NULL)
14534: return(0);
14535: return (ptr->locNr != 0);
14536: }
14537: #endif
14538: default:
14539: STRANGE
14540: }
14541: return(0);
14542: }
14543:
14544: #ifdef XPATH_STREAMING
14545: /**
14546: * xmlXPathTryStreamCompile:
14547: * @ctxt: an XPath context
14548: * @str: the XPath expression
14549: *
14550: * Try to compile the XPath expression as a streamable subset.
14551: *
14552: * Returns the compiled expression or NULL if failed to compile.
14553: */
14554: static xmlXPathCompExprPtr
14555: xmlXPathTryStreamCompile(xmlXPathContextPtr ctxt, const xmlChar *str) {
14556: /*
14557: * Optimization: use streaming patterns when the XPath expression can
14558: * be compiled to a stream lookup
14559: */
14560: xmlPatternPtr stream;
14561: xmlXPathCompExprPtr comp;
14562: xmlDictPtr dict = NULL;
14563: const xmlChar **namespaces = NULL;
14564: xmlNsPtr ns;
14565: int i, j;
14566:
14567: if ((!xmlStrchr(str, '[')) && (!xmlStrchr(str, '(')) &&
14568: (!xmlStrchr(str, '@'))) {
14569: const xmlChar *tmp;
14570:
14571: /*
14572: * We don't try to handle expressions using the verbose axis
14573: * specifiers ("::"), just the simplied form at this point.
14574: * Additionally, if there is no list of namespaces available and
14575: * there's a ":" in the expression, indicating a prefixed QName,
14576: * then we won't try to compile either. xmlPatterncompile() needs
14577: * to have a list of namespaces at compilation time in order to
14578: * compile prefixed name tests.
14579: */
14580: tmp = xmlStrchr(str, ':');
14581: if ((tmp != NULL) &&
14582: ((ctxt == NULL) || (ctxt->nsNr == 0) || (tmp[1] == ':')))
14583: return(NULL);
14584:
14585: if (ctxt != NULL) {
14586: dict = ctxt->dict;
14587: if (ctxt->nsNr > 0) {
14588: namespaces = xmlMalloc(2 * (ctxt->nsNr + 1) * sizeof(xmlChar*));
14589: if (namespaces == NULL) {
14590: xmlXPathErrMemory(ctxt, "allocating namespaces array\n");
14591: return(NULL);
14592: }
14593: for (i = 0, j = 0; (j < ctxt->nsNr); j++) {
14594: ns = ctxt->namespaces[j];
14595: namespaces[i++] = ns->href;
14596: namespaces[i++] = ns->prefix;
14597: }
14598: namespaces[i++] = NULL;
14599: namespaces[i] = NULL;
14600: }
14601: }
14602:
14603: stream = xmlPatterncompile(str, dict, XML_PATTERN_XPATH,
14604: &namespaces[0]);
14605: if (namespaces != NULL) {
14606: xmlFree((xmlChar **)namespaces);
14607: }
14608: if ((stream != NULL) && (xmlPatternStreamable(stream) == 1)) {
14609: comp = xmlXPathNewCompExpr();
14610: if (comp == NULL) {
14611: xmlXPathErrMemory(ctxt, "allocating streamable expression\n");
14612: return(NULL);
14613: }
14614: comp->stream = stream;
14615: comp->dict = dict;
14616: if (comp->dict)
14617: xmlDictReference(comp->dict);
14618: return(comp);
14619: }
14620: xmlFreePattern(stream);
14621: }
14622: return(NULL);
14623: }
14624: #endif /* XPATH_STREAMING */
14625:
14626: static int
14627: xmlXPathCanRewriteDosExpression(xmlChar *expr)
14628: {
14629: if (expr == NULL)
14630: return(0);
14631: do {
14632: if ((*expr == '/') && (*(++expr) == '/'))
14633: return(1);
14634: } while (*expr++);
14635: return(0);
14636: }
14637: static void
14638: xmlXPathRewriteDOSExpression(xmlXPathCompExprPtr comp, xmlXPathStepOpPtr op)
14639: {
14640: /*
14641: * Try to rewrite "descendant-or-self::node()/foo" to an optimized
14642: * internal representation.
14643: */
14644: if (op->ch1 != -1) {
14645: if ((op->op == XPATH_OP_COLLECT /* 11 */) &&
14646: ((xmlXPathAxisVal) op->value == AXIS_CHILD /* 4 */) &&
14647: ((xmlXPathTestVal) op->value2 == NODE_TEST_NAME /* 5 */) &&
14648: ((xmlXPathTypeVal) op->value3 == NODE_TYPE_NODE /* 0 */))
14649: {
14650: /*
14651: * This is a "child::foo"
14652: */
14653: xmlXPathStepOpPtr prevop = &comp->steps[op->ch1];
14654:
14655: if ((prevop->op == XPATH_OP_COLLECT /* 11 */) &&
14656: (prevop->ch1 != -1) &&
14657: ((xmlXPathAxisVal) prevop->value ==
14658: AXIS_DESCENDANT_OR_SELF) &&
14659: (prevop->ch2 == -1) &&
14660: ((xmlXPathTestVal) prevop->value2 == NODE_TEST_TYPE) &&
14661: ((xmlXPathTypeVal) prevop->value3 == NODE_TYPE_NODE) &&
14662: (comp->steps[prevop->ch1].op == XPATH_OP_ROOT))
14663: {
14664: /*
14665: * This is a "/descendant-or-self::node()" without predicates.
14666: * Eliminate it.
14667: */
14668: op->ch1 = prevop->ch1;
14669: op->rewriteType = XP_REWRITE_DOS_CHILD_ELEM;
14670: }
14671: }
14672: if (op->ch1 != -1)
14673: xmlXPathRewriteDOSExpression(comp, &comp->steps[op->ch1]);
14674: }
14675: if (op->ch2 != -1)
14676: xmlXPathRewriteDOSExpression(comp, &comp->steps[op->ch2]);
14677: }
14678:
14679: /**
14680: * xmlXPathCtxtCompile:
14681: * @ctxt: an XPath context
14682: * @str: the XPath expression
14683: *
14684: * Compile an XPath expression
14685: *
14686: * Returns the xmlXPathCompExprPtr resulting from the compilation or NULL.
14687: * the caller has to free the object.
14688: */
14689: xmlXPathCompExprPtr
14690: xmlXPathCtxtCompile(xmlXPathContextPtr ctxt, const xmlChar *str) {
14691: xmlXPathParserContextPtr pctxt;
14692: xmlXPathCompExprPtr comp;
14693:
14694: #ifdef XPATH_STREAMING
14695: comp = xmlXPathTryStreamCompile(ctxt, str);
14696: if (comp != NULL)
14697: return(comp);
14698: #endif
14699:
14700: xmlXPathInit();
14701:
14702: pctxt = xmlXPathNewParserContext(str, ctxt);
14703: if (pctxt == NULL)
14704: return NULL;
14705: xmlXPathCompileExpr(pctxt, 1);
14706:
14707: if( pctxt->error != XPATH_EXPRESSION_OK )
14708: {
14709: xmlXPathFreeParserContext(pctxt);
14710: return(NULL);
14711: }
14712:
14713: if (*pctxt->cur != 0) {
14714: /*
14715: * aleksey: in some cases this line prints *second* error message
14716: * (see bug #78858) and probably this should be fixed.
14717: * However, we are not sure that all error messages are printed
14718: * out in other places. It's not critical so we leave it as-is for now
14719: */
14720: xmlXPatherror(pctxt, __FILE__, __LINE__, XPATH_EXPR_ERROR);
14721: comp = NULL;
14722: } else {
14723: comp = pctxt->comp;
14724: pctxt->comp = NULL;
14725: }
14726: xmlXPathFreeParserContext(pctxt);
14727:
14728: if (comp != NULL) {
14729: comp->expr = xmlStrdup(str);
14730: #ifdef DEBUG_EVAL_COUNTS
14731: comp->string = xmlStrdup(str);
14732: comp->nb = 0;
14733: #endif
14734: if ((comp->expr != NULL) &&
14735: (comp->nbStep > 2) &&
14736: (comp->last >= 0) &&
14737: (xmlXPathCanRewriteDosExpression(comp->expr) == 1))
14738: {
14739: xmlXPathRewriteDOSExpression(comp, &comp->steps[comp->last]);
14740: }
14741: }
14742: return(comp);
14743: }
14744:
14745: /**
14746: * xmlXPathCompile:
14747: * @str: the XPath expression
14748: *
14749: * Compile an XPath expression
14750: *
14751: * Returns the xmlXPathCompExprPtr resulting from the compilation or NULL.
14752: * the caller has to free the object.
14753: */
14754: xmlXPathCompExprPtr
14755: xmlXPathCompile(const xmlChar *str) {
14756: return(xmlXPathCtxtCompile(NULL, str));
14757: }
14758:
14759: /**
14760: * xmlXPathCompiledEvalInternal:
14761: * @comp: the compiled XPath expression
14762: * @ctxt: the XPath context
14763: * @resObj: the resulting XPath object or NULL
14764: * @toBool: 1 if only a boolean result is requested
14765: *
14766: * Evaluate the Precompiled XPath expression in the given context.
14767: * The caller has to free @resObj.
14768: *
14769: * Returns the xmlXPathObjectPtr resulting from the evaluation or NULL.
14770: * the caller has to free the object.
14771: */
14772: static int
14773: xmlXPathCompiledEvalInternal(xmlXPathCompExprPtr comp,
14774: xmlXPathContextPtr ctxt,
14775: xmlXPathObjectPtr *resObj,
14776: int toBool)
14777: {
14778: xmlXPathParserContextPtr pctxt;
14779: #ifndef LIBXML_THREAD_ENABLED
14780: static int reentance = 0;
14781: #endif
14782: int res;
14783:
14784: CHECK_CTXT_NEG(ctxt)
14785:
14786: if (comp == NULL)
14787: return(-1);
14788: xmlXPathInit();
14789:
14790: #ifndef LIBXML_THREAD_ENABLED
14791: reentance++;
14792: if (reentance > 1)
14793: xmlXPathDisableOptimizer = 1;
14794: #endif
14795:
14796: #ifdef DEBUG_EVAL_COUNTS
14797: comp->nb++;
14798: if ((comp->string != NULL) && (comp->nb > 100)) {
14799: fprintf(stderr, "100 x %s\n", comp->string);
14800: comp->nb = 0;
14801: }
14802: #endif
14803: pctxt = xmlXPathCompParserContext(comp, ctxt);
14804: res = xmlXPathRunEval(pctxt, toBool);
14805:
14806: if (resObj) {
14807: if (pctxt->value == NULL) {
14808: xmlGenericError(xmlGenericErrorContext,
14809: "xmlXPathCompiledEval: evaluation failed\n");
14810: *resObj = NULL;
14811: } else {
14812: *resObj = valuePop(pctxt);
14813: }
14814: }
14815:
14816: /*
14817: * Pop all remaining objects from the stack.
14818: */
14819: if (pctxt->valueNr > 0) {
14820: xmlXPathObjectPtr tmp;
14821: int stack = 0;
14822:
14823: do {
14824: tmp = valuePop(pctxt);
14825: if (tmp != NULL) {
14826: stack++;
14827: xmlXPathReleaseObject(ctxt, tmp);
14828: }
14829: } while (tmp != NULL);
14830: if ((stack != 0) &&
14831: ((toBool) || ((resObj) && (*resObj))))
14832: {
14833: xmlGenericError(xmlGenericErrorContext,
14834: "xmlXPathCompiledEval: %d objects left on the stack.\n",
14835: stack);
14836: }
14837: }
14838:
14839: if ((pctxt->error != XPATH_EXPRESSION_OK) && (resObj) && (*resObj)) {
14840: xmlXPathFreeObject(*resObj);
14841: *resObj = NULL;
14842: }
14843: pctxt->comp = NULL;
14844: xmlXPathFreeParserContext(pctxt);
14845: #ifndef LIBXML_THREAD_ENABLED
14846: reentance--;
14847: #endif
14848:
14849: return(res);
14850: }
14851:
14852: /**
14853: * xmlXPathCompiledEval:
14854: * @comp: the compiled XPath expression
14855: * @ctx: the XPath context
14856: *
14857: * Evaluate the Precompiled XPath expression in the given context.
14858: *
14859: * Returns the xmlXPathObjectPtr resulting from the evaluation or NULL.
14860: * the caller has to free the object.
14861: */
14862: xmlXPathObjectPtr
14863: xmlXPathCompiledEval(xmlXPathCompExprPtr comp, xmlXPathContextPtr ctx)
14864: {
14865: xmlXPathObjectPtr res = NULL;
14866:
14867: xmlXPathCompiledEvalInternal(comp, ctx, &res, 0);
14868: return(res);
14869: }
14870:
14871: /**
14872: * xmlXPathCompiledEvalToBoolean:
14873: * @comp: the compiled XPath expression
14874: * @ctxt: the XPath context
14875: *
14876: * Applies the XPath boolean() function on the result of the given
14877: * compiled expression.
14878: *
14879: * Returns 1 if the expression evaluated to true, 0 if to false and
14880: * -1 in API and internal errors.
14881: */
14882: int
14883: xmlXPathCompiledEvalToBoolean(xmlXPathCompExprPtr comp,
14884: xmlXPathContextPtr ctxt)
14885: {
14886: return(xmlXPathCompiledEvalInternal(comp, ctxt, NULL, 1));
14887: }
14888:
14889: /**
14890: * xmlXPathEvalExpr:
14891: * @ctxt: the XPath Parser context
14892: *
14893: * Parse and evaluate an XPath expression in the given context,
14894: * then push the result on the context stack
14895: */
14896: void
14897: xmlXPathEvalExpr(xmlXPathParserContextPtr ctxt) {
14898: #ifdef XPATH_STREAMING
14899: xmlXPathCompExprPtr comp;
14900: #endif
14901:
14902: if (ctxt == NULL) return;
14903:
14904: #ifdef XPATH_STREAMING
14905: comp = xmlXPathTryStreamCompile(ctxt->context, ctxt->base);
14906: if (comp != NULL) {
14907: if (ctxt->comp != NULL)
14908: xmlXPathFreeCompExpr(ctxt->comp);
14909: ctxt->comp = comp;
14910: if (ctxt->cur != NULL)
14911: while (*ctxt->cur != 0) ctxt->cur++;
14912: } else
14913: #endif
14914: {
14915: xmlXPathCompileExpr(ctxt, 1);
14916: /*
14917: * In this scenario the expression string will sit in ctxt->base.
14918: */
14919: if ((ctxt->error == XPATH_EXPRESSION_OK) &&
14920: (ctxt->comp != NULL) &&
14921: (ctxt->base != NULL) &&
14922: (ctxt->comp->nbStep > 2) &&
14923: (ctxt->comp->last >= 0) &&
14924: (xmlXPathCanRewriteDosExpression((xmlChar *) ctxt->base) == 1))
14925: {
14926: xmlXPathRewriteDOSExpression(ctxt->comp,
14927: &ctxt->comp->steps[ctxt->comp->last]);
14928: }
14929: }
14930: CHECK_ERROR;
14931: xmlXPathRunEval(ctxt, 0);
14932: }
14933:
14934: /**
14935: * xmlXPathEval:
14936: * @str: the XPath expression
14937: * @ctx: the XPath context
14938: *
14939: * Evaluate the XPath Location Path in the given context.
14940: *
14941: * Returns the xmlXPathObjectPtr resulting from the evaluation or NULL.
14942: * the caller has to free the object.
14943: */
14944: xmlXPathObjectPtr
14945: xmlXPathEval(const xmlChar *str, xmlXPathContextPtr ctx) {
14946: xmlXPathParserContextPtr ctxt;
14947: xmlXPathObjectPtr res, tmp, init = NULL;
14948: int stack = 0;
14949:
14950: CHECK_CTXT(ctx)
14951:
14952: xmlXPathInit();
14953:
14954: ctxt = xmlXPathNewParserContext(str, ctx);
14955: if (ctxt == NULL)
14956: return NULL;
14957: xmlXPathEvalExpr(ctxt);
14958:
14959: if (ctxt->value == NULL) {
14960: xmlGenericError(xmlGenericErrorContext,
14961: "xmlXPathEval: evaluation failed\n");
14962: res = NULL;
14963: } else if ((*ctxt->cur != 0) && (ctxt->comp != NULL)
14964: #ifdef XPATH_STREAMING
14965: && (ctxt->comp->stream == NULL)
14966: #endif
14967: ) {
14968: xmlXPatherror(ctxt, __FILE__, __LINE__, XPATH_EXPR_ERROR);
14969: res = NULL;
14970: } else {
14971: res = valuePop(ctxt);
14972: }
14973:
14974: do {
14975: tmp = valuePop(ctxt);
14976: if (tmp != NULL) {
14977: if (tmp != init)
14978: stack++;
14979: xmlXPathReleaseObject(ctx, tmp);
14980: }
14981: } while (tmp != NULL);
14982: if ((stack != 0) && (res != NULL)) {
14983: xmlGenericError(xmlGenericErrorContext,
14984: "xmlXPathEval: %d object left on the stack\n",
14985: stack);
14986: }
14987: if (ctxt->error != XPATH_EXPRESSION_OK) {
14988: xmlXPathFreeObject(res);
14989: res = NULL;
14990: }
14991:
14992: xmlXPathFreeParserContext(ctxt);
14993: return(res);
14994: }
14995:
14996: /**
14997: * xmlXPathEvalExpression:
14998: * @str: the XPath expression
14999: * @ctxt: the XPath context
15000: *
15001: * Evaluate the XPath expression in the given context.
15002: *
15003: * Returns the xmlXPathObjectPtr resulting from the evaluation or NULL.
15004: * the caller has to free the object.
15005: */
15006: xmlXPathObjectPtr
15007: xmlXPathEvalExpression(const xmlChar *str, xmlXPathContextPtr ctxt) {
15008: xmlXPathParserContextPtr pctxt;
15009: xmlXPathObjectPtr res, tmp;
15010: int stack = 0;
15011:
15012: CHECK_CTXT(ctxt)
15013:
15014: xmlXPathInit();
15015:
15016: pctxt = xmlXPathNewParserContext(str, ctxt);
15017: if (pctxt == NULL)
15018: return NULL;
15019: xmlXPathEvalExpr(pctxt);
15020:
15021: if ((*pctxt->cur != 0) || (pctxt->error != XPATH_EXPRESSION_OK)) {
15022: xmlXPatherror(pctxt, __FILE__, __LINE__, XPATH_EXPR_ERROR);
15023: res = NULL;
15024: } else {
15025: res = valuePop(pctxt);
15026: }
15027: do {
15028: tmp = valuePop(pctxt);
15029: if (tmp != NULL) {
15030: xmlXPathReleaseObject(ctxt, tmp);
15031: stack++;
15032: }
15033: } while (tmp != NULL);
15034: if ((stack != 0) && (res != NULL)) {
15035: xmlGenericError(xmlGenericErrorContext,
15036: "xmlXPathEvalExpression: %d object left on the stack\n",
15037: stack);
15038: }
15039: xmlXPathFreeParserContext(pctxt);
15040: return(res);
15041: }
15042:
15043: /************************************************************************
15044: * *
15045: * Extra functions not pertaining to the XPath spec *
15046: * *
15047: ************************************************************************/
15048: /**
15049: * xmlXPathEscapeUriFunction:
15050: * @ctxt: the XPath Parser context
15051: * @nargs: the number of arguments
15052: *
15053: * Implement the escape-uri() XPath function
15054: * string escape-uri(string $str, bool $escape-reserved)
15055: *
15056: * This function applies the URI escaping rules defined in section 2 of [RFC
15057: * 2396] to the string supplied as $uri-part, which typically represents all
15058: * or part of a URI. The effect of the function is to replace any special
15059: * character in the string by an escape sequence of the form %xx%yy...,
15060: * where xxyy... is the hexadecimal representation of the octets used to
15061: * represent the character in UTF-8.
15062: *
15063: * The set of characters that are escaped depends on the setting of the
15064: * boolean argument $escape-reserved.
15065: *
15066: * If $escape-reserved is true, all characters are escaped other than lower
15067: * case letters a-z, upper case letters A-Z, digits 0-9, and the characters
15068: * referred to in [RFC 2396] as "marks": specifically, "-" | "_" | "." | "!"
15069: * | "~" | "*" | "'" | "(" | ")". The "%" character itself is escaped only
15070: * if it is not followed by two hexadecimal digits (that is, 0-9, a-f, and
15071: * A-F).
15072: *
15073: * If $escape-reserved is false, the behavior differs in that characters
15074: * referred to in [RFC 2396] as reserved characters are not escaped. These
15075: * characters are ";" | "/" | "?" | ":" | "@" | "&" | "=" | "+" | "$" | ",".
15076: *
15077: * [RFC 2396] does not define whether escaped URIs should use lower case or
15078: * upper case for hexadecimal digits. To ensure that escaped URIs can be
15079: * compared using string comparison functions, this function must always use
15080: * the upper-case letters A-F.
15081: *
15082: * Generally, $escape-reserved should be set to true when escaping a string
15083: * that is to form a single part of a URI, and to false when escaping an
15084: * entire URI or URI reference.
15085: *
15086: * In the case of non-ascii characters, the string is encoded according to
15087: * utf-8 and then converted according to RFC 2396.
15088: *
15089: * Examples
15090: * xf:escape-uri ("gopher://spinaltap.micro.umn.edu/00/Weather/California/Los%20Angeles#ocean"), true())
15091: * returns "gopher%3A%2F%2Fspinaltap.micro.umn.edu%2F00%2FWeather%2FCalifornia%2FLos%20Angeles%23ocean"
15092: * xf:escape-uri ("gopher://spinaltap.micro.umn.edu/00/Weather/California/Los%20Angeles#ocean"), false())
15093: * returns "gopher://spinaltap.micro.umn.edu/00/Weather/California/Los%20Angeles%23ocean"
15094: *
15095: */
15096: static void
15097: xmlXPathEscapeUriFunction(xmlXPathParserContextPtr ctxt, int nargs) {
15098: xmlXPathObjectPtr str;
15099: int escape_reserved;
15100: xmlBufferPtr target;
15101: xmlChar *cptr;
15102: xmlChar escape[4];
15103:
15104: CHECK_ARITY(2);
15105:
15106: escape_reserved = xmlXPathPopBoolean(ctxt);
15107:
15108: CAST_TO_STRING;
15109: str = valuePop(ctxt);
15110:
15111: target = xmlBufferCreate();
15112:
15113: escape[0] = '%';
15114: escape[3] = 0;
15115:
15116: if (target) {
15117: for (cptr = str->stringval; *cptr; cptr++) {
15118: if ((*cptr >= 'A' && *cptr <= 'Z') ||
15119: (*cptr >= 'a' && *cptr <= 'z') ||
15120: (*cptr >= '0' && *cptr <= '9') ||
15121: *cptr == '-' || *cptr == '_' || *cptr == '.' ||
15122: *cptr == '!' || *cptr == '~' || *cptr == '*' ||
15123: *cptr == '\''|| *cptr == '(' || *cptr == ')' ||
15124: (*cptr == '%' &&
15125: ((cptr[1] >= 'A' && cptr[1] <= 'F') ||
15126: (cptr[1] >= 'a' && cptr[1] <= 'f') ||
15127: (cptr[1] >= '0' && cptr[1] <= '9')) &&
15128: ((cptr[2] >= 'A' && cptr[2] <= 'F') ||
15129: (cptr[2] >= 'a' && cptr[2] <= 'f') ||
15130: (cptr[2] >= '0' && cptr[2] <= '9'))) ||
15131: (!escape_reserved &&
15132: (*cptr == ';' || *cptr == '/' || *cptr == '?' ||
15133: *cptr == ':' || *cptr == '@' || *cptr == '&' ||
15134: *cptr == '=' || *cptr == '+' || *cptr == '$' ||
15135: *cptr == ','))) {
15136: xmlBufferAdd(target, cptr, 1);
15137: } else {
15138: if ((*cptr >> 4) < 10)
15139: escape[1] = '0' + (*cptr >> 4);
15140: else
15141: escape[1] = 'A' - 10 + (*cptr >> 4);
15142: if ((*cptr & 0xF) < 10)
15143: escape[2] = '0' + (*cptr & 0xF);
15144: else
15145: escape[2] = 'A' - 10 + (*cptr & 0xF);
15146:
15147: xmlBufferAdd(target, &escape[0], 3);
15148: }
15149: }
15150: }
15151: valuePush(ctxt, xmlXPathCacheNewString(ctxt->context,
15152: xmlBufferContent(target)));
15153: xmlBufferFree(target);
15154: xmlXPathReleaseObject(ctxt->context, str);
15155: }
15156:
15157: /**
15158: * xmlXPathRegisterAllFunctions:
15159: * @ctxt: the XPath context
15160: *
15161: * Registers all default XPath functions in this context
15162: */
15163: void
15164: xmlXPathRegisterAllFunctions(xmlXPathContextPtr ctxt)
15165: {
15166: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"boolean",
15167: xmlXPathBooleanFunction);
15168: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"ceiling",
15169: xmlXPathCeilingFunction);
15170: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"count",
15171: xmlXPathCountFunction);
15172: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"concat",
15173: xmlXPathConcatFunction);
15174: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"contains",
15175: xmlXPathContainsFunction);
15176: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"id",
15177: xmlXPathIdFunction);
15178: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"false",
15179: xmlXPathFalseFunction);
15180: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"floor",
15181: xmlXPathFloorFunction);
15182: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"last",
15183: xmlXPathLastFunction);
15184: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"lang",
15185: xmlXPathLangFunction);
15186: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"local-name",
15187: xmlXPathLocalNameFunction);
15188: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"not",
15189: xmlXPathNotFunction);
15190: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"name",
15191: xmlXPathNameFunction);
15192: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"namespace-uri",
15193: xmlXPathNamespaceURIFunction);
15194: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"normalize-space",
15195: xmlXPathNormalizeFunction);
15196: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"number",
15197: xmlXPathNumberFunction);
15198: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"position",
15199: xmlXPathPositionFunction);
15200: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"round",
15201: xmlXPathRoundFunction);
15202: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"string",
15203: xmlXPathStringFunction);
15204: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"string-length",
15205: xmlXPathStringLengthFunction);
15206: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"starts-with",
15207: xmlXPathStartsWithFunction);
15208: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"substring",
15209: xmlXPathSubstringFunction);
15210: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"substring-before",
15211: xmlXPathSubstringBeforeFunction);
15212: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"substring-after",
15213: xmlXPathSubstringAfterFunction);
15214: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"sum",
15215: xmlXPathSumFunction);
15216: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"true",
15217: xmlXPathTrueFunction);
15218: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"translate",
15219: xmlXPathTranslateFunction);
15220:
15221: xmlXPathRegisterFuncNS(ctxt, (const xmlChar *)"escape-uri",
15222: (const xmlChar *)"http://www.w3.org/2002/08/xquery-functions",
15223: xmlXPathEscapeUriFunction);
15224: }
15225:
15226: #endif /* LIBXML_XPATH_ENABLED */
15227: #define bottom_xpath
15228: #include "elfgcchack.h"
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