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: "?? Unknown error ??\n" /* Must be last in the list! */
256: };
257: #define MAXERRNO ((int)(sizeof(xmlXPathErrorMessages) / \
258: sizeof(xmlXPathErrorMessages[0])) - 1)
259: /**
260: * xmlXPathErrMemory:
261: * @ctxt: an XPath context
262: * @extra: extra informations
263: *
264: * Handle a redefinition of attribute error
265: */
266: static void
267: xmlXPathErrMemory(xmlXPathContextPtr ctxt, const char *extra)
268: {
269: if (ctxt != NULL) {
270: if (extra) {
271: xmlChar buf[200];
272:
273: xmlStrPrintf(buf, 200,
274: BAD_CAST "Memory allocation failed : %s\n",
275: extra);
276: ctxt->lastError.message = (char *) xmlStrdup(buf);
277: } else {
278: ctxt->lastError.message = (char *)
279: xmlStrdup(BAD_CAST "Memory allocation failed\n");
280: }
281: ctxt->lastError.domain = XML_FROM_XPATH;
282: ctxt->lastError.code = XML_ERR_NO_MEMORY;
283: if (ctxt->error != NULL)
284: ctxt->error(ctxt->userData, &ctxt->lastError);
285: } else {
286: if (extra)
287: __xmlRaiseError(NULL, NULL, NULL,
288: NULL, NULL, XML_FROM_XPATH,
289: XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0,
290: extra, NULL, NULL, 0, 0,
291: "Memory allocation failed : %s\n", extra);
292: else
293: __xmlRaiseError(NULL, NULL, NULL,
294: NULL, NULL, XML_FROM_XPATH,
295: XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0,
296: NULL, NULL, NULL, 0, 0,
297: "Memory allocation failed\n");
298: }
299: }
300:
301: /**
302: * xmlXPathPErrMemory:
303: * @ctxt: an XPath parser context
304: * @extra: extra informations
305: *
306: * Handle a redefinition of attribute error
307: */
308: static void
309: xmlXPathPErrMemory(xmlXPathParserContextPtr ctxt, const char *extra)
310: {
311: if (ctxt == NULL)
312: xmlXPathErrMemory(NULL, extra);
313: else {
314: ctxt->error = XPATH_MEMORY_ERROR;
315: xmlXPathErrMemory(ctxt->context, extra);
316: }
317: }
318:
319: /**
320: * xmlXPathErr:
321: * @ctxt: a XPath parser context
322: * @error: the error code
323: *
324: * Handle an XPath error
325: */
326: void
327: xmlXPathErr(xmlXPathParserContextPtr ctxt, int error)
328: {
329: if ((error < 0) || (error > MAXERRNO))
330: error = MAXERRNO;
331: if (ctxt == NULL) {
332: __xmlRaiseError(NULL, NULL, NULL,
333: NULL, NULL, XML_FROM_XPATH,
334: error + XML_XPATH_EXPRESSION_OK - XPATH_EXPRESSION_OK,
335: XML_ERR_ERROR, NULL, 0,
336: NULL, NULL, NULL, 0, 0,
337: "%s", xmlXPathErrorMessages[error]);
338: return;
339: }
340: ctxt->error = error;
341: if (ctxt->context == NULL) {
342: __xmlRaiseError(NULL, NULL, NULL,
343: NULL, NULL, XML_FROM_XPATH,
344: error + XML_XPATH_EXPRESSION_OK - XPATH_EXPRESSION_OK,
345: XML_ERR_ERROR, NULL, 0,
346: (const char *) ctxt->base, NULL, NULL,
347: ctxt->cur - ctxt->base, 0,
348: "%s", xmlXPathErrorMessages[error]);
349: return;
350: }
351:
352: /* cleanup current last error */
353: xmlResetError(&ctxt->context->lastError);
354:
355: ctxt->context->lastError.domain = XML_FROM_XPATH;
356: ctxt->context->lastError.code = error + XML_XPATH_EXPRESSION_OK -
357: XPATH_EXPRESSION_OK;
358: ctxt->context->lastError.level = XML_ERR_ERROR;
359: ctxt->context->lastError.str1 = (char *) xmlStrdup(ctxt->base);
360: ctxt->context->lastError.int1 = ctxt->cur - ctxt->base;
361: ctxt->context->lastError.node = ctxt->context->debugNode;
362: if (ctxt->context->error != NULL) {
363: ctxt->context->error(ctxt->context->userData,
364: &ctxt->context->lastError);
365: } else {
366: __xmlRaiseError(NULL, NULL, NULL,
367: NULL, ctxt->context->debugNode, XML_FROM_XPATH,
368: error + XML_XPATH_EXPRESSION_OK - XPATH_EXPRESSION_OK,
369: XML_ERR_ERROR, NULL, 0,
370: (const char *) ctxt->base, NULL, NULL,
371: ctxt->cur - ctxt->base, 0,
372: "%s", xmlXPathErrorMessages[error]);
373: }
374:
375: }
376:
377: /**
378: * xmlXPatherror:
379: * @ctxt: the XPath Parser context
380: * @file: the file name
381: * @line: the line number
382: * @no: the error number
383: *
384: * Formats an error message.
385: */
386: void
387: xmlXPatherror(xmlXPathParserContextPtr ctxt, const char *file ATTRIBUTE_UNUSED,
388: int line ATTRIBUTE_UNUSED, int no) {
389: xmlXPathErr(ctxt, no);
390: }
391:
392: /************************************************************************
393: * *
394: * Utilities *
395: * *
396: ************************************************************************/
397:
398: /**
399: * xsltPointerList:
400: *
401: * Pointer-list for various purposes.
402: */
403: typedef struct _xmlPointerList xmlPointerList;
404: typedef xmlPointerList *xmlPointerListPtr;
405: struct _xmlPointerList {
406: void **items;
407: int number;
408: int size;
409: };
410: /*
411: * TODO: Since such a list-handling is used in xmlschemas.c and libxslt
412: * and here, we should make the functions public.
413: */
414: static int
415: xmlPointerListAddSize(xmlPointerListPtr list,
416: void *item,
417: int initialSize)
418: {
419: if (list->items == NULL) {
420: if (initialSize <= 0)
421: initialSize = 1;
422: list->items = (void **) xmlMalloc(
423: initialSize * sizeof(void *));
424: if (list->items == NULL) {
425: xmlXPathErrMemory(NULL,
426: "xmlPointerListCreate: allocating item\n");
427: return(-1);
428: }
429: list->number = 0;
430: list->size = initialSize;
431: } else if (list->size <= list->number) {
432: list->size *= 2;
433: list->items = (void **) xmlRealloc(list->items,
434: list->size * sizeof(void *));
435: if (list->items == NULL) {
436: xmlXPathErrMemory(NULL,
437: "xmlPointerListCreate: re-allocating item\n");
438: list->size = 0;
439: return(-1);
440: }
441: }
442: list->items[list->number++] = item;
443: return(0);
444: }
445:
446: /**
447: * xsltPointerListCreate:
448: *
449: * Creates an xsltPointerList structure.
450: *
451: * Returns a xsltPointerList structure or NULL in case of an error.
452: */
453: static xmlPointerListPtr
454: xmlPointerListCreate(int initialSize)
455: {
456: xmlPointerListPtr ret;
457:
458: ret = xmlMalloc(sizeof(xmlPointerList));
459: if (ret == NULL) {
460: xmlXPathErrMemory(NULL,
461: "xmlPointerListCreate: allocating item\n");
462: return (NULL);
463: }
464: memset(ret, 0, sizeof(xmlPointerList));
465: if (initialSize > 0) {
466: xmlPointerListAddSize(ret, NULL, initialSize);
467: ret->number = 0;
468: }
469: return (ret);
470: }
471:
472: /**
473: * xsltPointerListFree:
474: *
475: * Frees the xsltPointerList structure. This does not free
476: * the content of the list.
477: */
478: static void
479: xmlPointerListFree(xmlPointerListPtr list)
480: {
481: if (list == NULL)
482: return;
483: if (list->items != NULL)
484: xmlFree(list->items);
485: xmlFree(list);
486: }
487:
488: /************************************************************************
489: * *
490: * Parser Types *
491: * *
492: ************************************************************************/
493:
494: /*
495: * Types are private:
496: */
497:
498: typedef enum {
499: XPATH_OP_END=0,
500: XPATH_OP_AND,
501: XPATH_OP_OR,
502: XPATH_OP_EQUAL,
503: XPATH_OP_CMP,
504: XPATH_OP_PLUS,
505: XPATH_OP_MULT,
506: XPATH_OP_UNION,
507: XPATH_OP_ROOT,
508: XPATH_OP_NODE,
509: XPATH_OP_RESET, /* 10 */
510: XPATH_OP_COLLECT,
511: XPATH_OP_VALUE, /* 12 */
512: XPATH_OP_VARIABLE,
513: XPATH_OP_FUNCTION,
514: XPATH_OP_ARG,
515: XPATH_OP_PREDICATE,
516: XPATH_OP_FILTER, /* 17 */
517: XPATH_OP_SORT /* 18 */
518: #ifdef LIBXML_XPTR_ENABLED
519: ,XPATH_OP_RANGETO
520: #endif
521: } xmlXPathOp;
522:
523: typedef enum {
524: AXIS_ANCESTOR = 1,
525: AXIS_ANCESTOR_OR_SELF,
526: AXIS_ATTRIBUTE,
527: AXIS_CHILD,
528: AXIS_DESCENDANT,
529: AXIS_DESCENDANT_OR_SELF,
530: AXIS_FOLLOWING,
531: AXIS_FOLLOWING_SIBLING,
532: AXIS_NAMESPACE,
533: AXIS_PARENT,
534: AXIS_PRECEDING,
535: AXIS_PRECEDING_SIBLING,
536: AXIS_SELF
537: } xmlXPathAxisVal;
538:
539: typedef enum {
540: NODE_TEST_NONE = 0,
541: NODE_TEST_TYPE = 1,
542: NODE_TEST_PI = 2,
543: NODE_TEST_ALL = 3,
544: NODE_TEST_NS = 4,
545: NODE_TEST_NAME = 5
546: } xmlXPathTestVal;
547:
548: typedef enum {
549: NODE_TYPE_NODE = 0,
550: NODE_TYPE_COMMENT = XML_COMMENT_NODE,
551: NODE_TYPE_TEXT = XML_TEXT_NODE,
552: NODE_TYPE_PI = XML_PI_NODE
553: } xmlXPathTypeVal;
554:
555: #define XP_REWRITE_DOS_CHILD_ELEM 1
556:
557: typedef struct _xmlXPathStepOp xmlXPathStepOp;
558: typedef xmlXPathStepOp *xmlXPathStepOpPtr;
559: struct _xmlXPathStepOp {
560: xmlXPathOp op; /* The identifier of the operation */
561: int ch1; /* First child */
562: int ch2; /* Second child */
563: int value;
564: int value2;
565: int value3;
566: void *value4;
567: void *value5;
568: void *cache;
569: void *cacheURI;
570: int rewriteType;
571: };
572:
573: struct _xmlXPathCompExpr {
574: int nbStep; /* Number of steps in this expression */
575: int maxStep; /* Maximum number of steps allocated */
576: xmlXPathStepOp *steps; /* ops for computation of this expression */
577: int last; /* index of last step in expression */
578: xmlChar *expr; /* the expression being computed */
579: xmlDictPtr dict; /* the dictionnary to use if any */
580: #ifdef DEBUG_EVAL_COUNTS
581: int nb;
582: xmlChar *string;
583: #endif
584: #ifdef XPATH_STREAMING
585: xmlPatternPtr stream;
586: #endif
587: };
588:
589: /************************************************************************
590: * *
591: * Forward declarations *
592: * *
593: ************************************************************************/
594: static void
595: xmlXPathFreeValueTree(xmlNodeSetPtr obj);
596: static void
597: xmlXPathReleaseObject(xmlXPathContextPtr ctxt, xmlXPathObjectPtr obj);
598: static int
599: xmlXPathCompOpEvalFirst(xmlXPathParserContextPtr ctxt,
600: xmlXPathStepOpPtr op, xmlNodePtr *first);
601: static int
602: xmlXPathCompOpEvalToBoolean(xmlXPathParserContextPtr ctxt,
603: xmlXPathStepOpPtr op,
604: int isPredicate);
605:
606: /************************************************************************
607: * *
608: * Parser Type functions *
609: * *
610: ************************************************************************/
611:
612: /**
613: * xmlXPathNewCompExpr:
614: *
615: * Create a new Xpath component
616: *
617: * Returns the newly allocated xmlXPathCompExprPtr or NULL in case of error
618: */
619: static xmlXPathCompExprPtr
620: xmlXPathNewCompExpr(void) {
621: xmlXPathCompExprPtr cur;
622:
623: cur = (xmlXPathCompExprPtr) xmlMalloc(sizeof(xmlXPathCompExpr));
624: if (cur == NULL) {
625: xmlXPathErrMemory(NULL, "allocating component\n");
626: return(NULL);
627: }
628: memset(cur, 0, sizeof(xmlXPathCompExpr));
629: cur->maxStep = 10;
630: cur->nbStep = 0;
631: cur->steps = (xmlXPathStepOp *) xmlMalloc(cur->maxStep *
632: sizeof(xmlXPathStepOp));
633: if (cur->steps == NULL) {
634: xmlXPathErrMemory(NULL, "allocating steps\n");
635: xmlFree(cur);
636: return(NULL);
637: }
638: memset(cur->steps, 0, cur->maxStep * sizeof(xmlXPathStepOp));
639: cur->last = -1;
640: #ifdef DEBUG_EVAL_COUNTS
641: cur->nb = 0;
642: #endif
643: return(cur);
644: }
645:
646: /**
647: * xmlXPathFreeCompExpr:
648: * @comp: an XPATH comp
649: *
650: * Free up the memory allocated by @comp
651: */
652: void
653: xmlXPathFreeCompExpr(xmlXPathCompExprPtr comp)
654: {
655: xmlXPathStepOpPtr op;
656: int i;
657:
658: if (comp == NULL)
659: return;
660: if (comp->dict == NULL) {
661: for (i = 0; i < comp->nbStep; i++) {
662: op = &comp->steps[i];
663: if (op->value4 != NULL) {
664: if (op->op == XPATH_OP_VALUE)
665: xmlXPathFreeObject(op->value4);
666: else
667: xmlFree(op->value4);
668: }
669: if (op->value5 != NULL)
670: xmlFree(op->value5);
671: }
672: } else {
673: for (i = 0; i < comp->nbStep; i++) {
674: op = &comp->steps[i];
675: if (op->value4 != NULL) {
676: if (op->op == XPATH_OP_VALUE)
677: xmlXPathFreeObject(op->value4);
678: }
679: }
680: xmlDictFree(comp->dict);
681: }
682: if (comp->steps != NULL) {
683: xmlFree(comp->steps);
684: }
685: #ifdef DEBUG_EVAL_COUNTS
686: if (comp->string != NULL) {
687: xmlFree(comp->string);
688: }
689: #endif
690: #ifdef XPATH_STREAMING
691: if (comp->stream != NULL) {
692: xmlFreePatternList(comp->stream);
693: }
694: #endif
695: if (comp->expr != NULL) {
696: xmlFree(comp->expr);
697: }
698:
699: xmlFree(comp);
700: }
701:
702: /**
703: * xmlXPathCompExprAdd:
704: * @comp: the compiled expression
705: * @ch1: first child index
706: * @ch2: second child index
707: * @op: an op
708: * @value: the first int value
709: * @value2: the second int value
710: * @value3: the third int value
711: * @value4: the first string value
712: * @value5: the second string value
713: *
714: * Add a step to an XPath Compiled Expression
715: *
716: * Returns -1 in case of failure, the index otherwise
717: */
718: static int
719: xmlXPathCompExprAdd(xmlXPathCompExprPtr comp, int ch1, int ch2,
720: xmlXPathOp op, int value,
721: int value2, int value3, void *value4, void *value5) {
722: if (comp->nbStep >= comp->maxStep) {
723: xmlXPathStepOp *real;
724:
725: comp->maxStep *= 2;
726: real = (xmlXPathStepOp *) xmlRealloc(comp->steps,
727: comp->maxStep * sizeof(xmlXPathStepOp));
728: if (real == NULL) {
729: comp->maxStep /= 2;
730: xmlXPathErrMemory(NULL, "adding step\n");
731: return(-1);
732: }
733: comp->steps = real;
734: }
735: comp->last = comp->nbStep;
736: comp->steps[comp->nbStep].rewriteType = 0;
737: comp->steps[comp->nbStep].ch1 = ch1;
738: comp->steps[comp->nbStep].ch2 = ch2;
739: comp->steps[comp->nbStep].op = op;
740: comp->steps[comp->nbStep].value = value;
741: comp->steps[comp->nbStep].value2 = value2;
742: comp->steps[comp->nbStep].value3 = value3;
743: if ((comp->dict != NULL) &&
744: ((op == XPATH_OP_FUNCTION) || (op == XPATH_OP_VARIABLE) ||
745: (op == XPATH_OP_COLLECT))) {
746: if (value4 != NULL) {
747: comp->steps[comp->nbStep].value4 = (xmlChar *)
748: (void *)xmlDictLookup(comp->dict, value4, -1);
749: xmlFree(value4);
750: } else
751: comp->steps[comp->nbStep].value4 = NULL;
752: if (value5 != NULL) {
753: comp->steps[comp->nbStep].value5 = (xmlChar *)
754: (void *)xmlDictLookup(comp->dict, value5, -1);
755: xmlFree(value5);
756: } else
757: comp->steps[comp->nbStep].value5 = NULL;
758: } else {
759: comp->steps[comp->nbStep].value4 = value4;
760: comp->steps[comp->nbStep].value5 = value5;
761: }
762: comp->steps[comp->nbStep].cache = NULL;
763: return(comp->nbStep++);
764: }
765:
766: /**
767: * xmlXPathCompSwap:
768: * @comp: the compiled expression
769: * @op: operation index
770: *
771: * Swaps 2 operations in the compiled expression
772: */
773: static void
774: xmlXPathCompSwap(xmlXPathStepOpPtr op) {
775: int tmp;
776:
777: #ifndef LIBXML_THREAD_ENABLED
778: /*
779: * Since this manipulates possibly shared variables, this is
780: * disabled if one detects that the library is used in a multithreaded
781: * application
782: */
783: if (xmlXPathDisableOptimizer)
784: return;
785: #endif
786:
787: tmp = op->ch1;
788: op->ch1 = op->ch2;
789: op->ch2 = tmp;
790: }
791:
792: #define PUSH_FULL_EXPR(op, op1, op2, val, val2, val3, val4, val5) \
793: xmlXPathCompExprAdd(ctxt->comp, (op1), (op2), \
794: (op), (val), (val2), (val3), (val4), (val5))
795: #define PUSH_LONG_EXPR(op, val, val2, val3, val4, val5) \
796: xmlXPathCompExprAdd(ctxt->comp, ctxt->comp->last, -1, \
797: (op), (val), (val2), (val3), (val4), (val5))
798:
799: #define PUSH_LEAVE_EXPR(op, val, val2) \
800: xmlXPathCompExprAdd(ctxt->comp, -1, -1, (op), (val), (val2), 0 ,NULL ,NULL)
801:
802: #define PUSH_UNARY_EXPR(op, ch, val, val2) \
803: xmlXPathCompExprAdd(ctxt->comp, (ch), -1, (op), (val), (val2), 0 ,NULL ,NULL)
804:
805: #define PUSH_BINARY_EXPR(op, ch1, ch2, val, val2) \
806: xmlXPathCompExprAdd(ctxt->comp, (ch1), (ch2), (op), \
807: (val), (val2), 0 ,NULL ,NULL)
808:
809: /************************************************************************
810: * *
811: * XPath object cache structures *
812: * *
813: ************************************************************************/
814:
815: /* #define XP_DEFAULT_CACHE_ON */
816:
817: #define XP_HAS_CACHE(c) ((c != NULL) && ((c)->cache != NULL))
818:
819: typedef struct _xmlXPathContextCache xmlXPathContextCache;
820: typedef xmlXPathContextCache *xmlXPathContextCachePtr;
821: struct _xmlXPathContextCache {
822: xmlPointerListPtr nodesetObjs; /* contains xmlXPathObjectPtr */
823: xmlPointerListPtr stringObjs; /* contains xmlXPathObjectPtr */
824: xmlPointerListPtr booleanObjs; /* contains xmlXPathObjectPtr */
825: xmlPointerListPtr numberObjs; /* contains xmlXPathObjectPtr */
826: xmlPointerListPtr miscObjs; /* contains xmlXPathObjectPtr */
827: int maxNodeset;
828: int maxString;
829: int maxBoolean;
830: int maxNumber;
831: int maxMisc;
832: #ifdef XP_DEBUG_OBJ_USAGE
833: int dbgCachedAll;
834: int dbgCachedNodeset;
835: int dbgCachedString;
836: int dbgCachedBool;
837: int dbgCachedNumber;
838: int dbgCachedPoint;
839: int dbgCachedRange;
840: int dbgCachedLocset;
841: int dbgCachedUsers;
842: int dbgCachedXSLTTree;
843: int dbgCachedUndefined;
844:
845:
846: int dbgReusedAll;
847: int dbgReusedNodeset;
848: int dbgReusedString;
849: int dbgReusedBool;
850: int dbgReusedNumber;
851: int dbgReusedPoint;
852: int dbgReusedRange;
853: int dbgReusedLocset;
854: int dbgReusedUsers;
855: int dbgReusedXSLTTree;
856: int dbgReusedUndefined;
857:
858: #endif
859: };
860:
861: /************************************************************************
862: * *
863: * Debugging related functions *
864: * *
865: ************************************************************************/
866:
867: #define STRANGE \
868: xmlGenericError(xmlGenericErrorContext, \
869: "Internal error at %s:%d\n", \
870: __FILE__, __LINE__);
871:
872: #ifdef LIBXML_DEBUG_ENABLED
873: static void
874: xmlXPathDebugDumpNode(FILE *output, xmlNodePtr cur, int depth) {
875: int i;
876: char shift[100];
877:
878: for (i = 0;((i < depth) && (i < 25));i++)
879: shift[2 * i] = shift[2 * i + 1] = ' ';
880: shift[2 * i] = shift[2 * i + 1] = 0;
881: if (cur == NULL) {
882: fprintf(output, "%s", shift);
883: fprintf(output, "Node is NULL !\n");
884: return;
885:
886: }
887:
888: if ((cur->type == XML_DOCUMENT_NODE) ||
889: (cur->type == XML_HTML_DOCUMENT_NODE)) {
890: fprintf(output, "%s", shift);
891: fprintf(output, " /\n");
892: } else if (cur->type == XML_ATTRIBUTE_NODE)
893: xmlDebugDumpAttr(output, (xmlAttrPtr)cur, depth);
894: else
895: xmlDebugDumpOneNode(output, cur, depth);
896: }
897: static void
898: xmlXPathDebugDumpNodeList(FILE *output, xmlNodePtr cur, int depth) {
899: xmlNodePtr tmp;
900: int i;
901: char shift[100];
902:
903: for (i = 0;((i < depth) && (i < 25));i++)
904: shift[2 * i] = shift[2 * i + 1] = ' ';
905: shift[2 * i] = shift[2 * i + 1] = 0;
906: if (cur == NULL) {
907: fprintf(output, "%s", shift);
908: fprintf(output, "Node is NULL !\n");
909: return;
910:
911: }
912:
913: while (cur != NULL) {
914: tmp = cur;
915: cur = cur->next;
916: xmlDebugDumpOneNode(output, tmp, depth);
917: }
918: }
919:
920: static void
921: xmlXPathDebugDumpNodeSet(FILE *output, xmlNodeSetPtr cur, int depth) {
922: int i;
923: char shift[100];
924:
925: for (i = 0;((i < depth) && (i < 25));i++)
926: shift[2 * i] = shift[2 * i + 1] = ' ';
927: shift[2 * i] = shift[2 * i + 1] = 0;
928:
929: if (cur == NULL) {
930: fprintf(output, "%s", shift);
931: fprintf(output, "NodeSet is NULL !\n");
932: return;
933:
934: }
935:
936: if (cur != NULL) {
937: fprintf(output, "Set contains %d nodes:\n", cur->nodeNr);
938: for (i = 0;i < cur->nodeNr;i++) {
939: fprintf(output, "%s", shift);
940: fprintf(output, "%d", i + 1);
941: xmlXPathDebugDumpNode(output, cur->nodeTab[i], depth + 1);
942: }
943: }
944: }
945:
946: static void
947: xmlXPathDebugDumpValueTree(FILE *output, xmlNodeSetPtr cur, int depth) {
948: int i;
949: char shift[100];
950:
951: for (i = 0;((i < depth) && (i < 25));i++)
952: shift[2 * i] = shift[2 * i + 1] = ' ';
953: shift[2 * i] = shift[2 * i + 1] = 0;
954:
955: if ((cur == NULL) || (cur->nodeNr == 0) || (cur->nodeTab[0] == NULL)) {
956: fprintf(output, "%s", shift);
957: fprintf(output, "Value Tree is NULL !\n");
958: return;
959:
960: }
961:
962: fprintf(output, "%s", shift);
963: fprintf(output, "%d", i + 1);
964: xmlXPathDebugDumpNodeList(output, cur->nodeTab[0]->children, depth + 1);
965: }
966: #if defined(LIBXML_XPTR_ENABLED)
967: static void
968: xmlXPathDebugDumpLocationSet(FILE *output, xmlLocationSetPtr cur, int depth) {
969: int i;
970: char shift[100];
971:
972: for (i = 0;((i < depth) && (i < 25));i++)
973: shift[2 * i] = shift[2 * i + 1] = ' ';
974: shift[2 * i] = shift[2 * i + 1] = 0;
975:
976: if (cur == NULL) {
977: fprintf(output, "%s", shift);
978: fprintf(output, "LocationSet is NULL !\n");
979: return;
980:
981: }
982:
983: for (i = 0;i < cur->locNr;i++) {
984: fprintf(output, "%s", shift);
985: fprintf(output, "%d : ", i + 1);
986: xmlXPathDebugDumpObject(output, cur->locTab[i], depth + 1);
987: }
988: }
989: #endif /* LIBXML_XPTR_ENABLED */
990:
991: /**
992: * xmlXPathDebugDumpObject:
993: * @output: the FILE * to dump the output
994: * @cur: the object to inspect
995: * @depth: indentation level
996: *
997: * Dump the content of the object for debugging purposes
998: */
999: void
1000: xmlXPathDebugDumpObject(FILE *output, xmlXPathObjectPtr cur, int depth) {
1001: int i;
1002: char shift[100];
1003:
1004: if (output == NULL) return;
1005:
1006: for (i = 0;((i < depth) && (i < 25));i++)
1007: shift[2 * i] = shift[2 * i + 1] = ' ';
1008: shift[2 * i] = shift[2 * i + 1] = 0;
1009:
1010:
1011: fprintf(output, "%s", shift);
1012:
1013: if (cur == NULL) {
1014: fprintf(output, "Object is empty (NULL)\n");
1015: return;
1016: }
1017: switch(cur->type) {
1018: case XPATH_UNDEFINED:
1019: fprintf(output, "Object is uninitialized\n");
1020: break;
1021: case XPATH_NODESET:
1022: fprintf(output, "Object is a Node Set :\n");
1023: xmlXPathDebugDumpNodeSet(output, cur->nodesetval, depth);
1024: break;
1025: case XPATH_XSLT_TREE:
1026: fprintf(output, "Object is an XSLT value tree :\n");
1027: xmlXPathDebugDumpValueTree(output, cur->nodesetval, depth);
1028: break;
1029: case XPATH_BOOLEAN:
1030: fprintf(output, "Object is a Boolean : ");
1031: if (cur->boolval) fprintf(output, "true\n");
1032: else fprintf(output, "false\n");
1033: break;
1034: case XPATH_NUMBER:
1035: switch (xmlXPathIsInf(cur->floatval)) {
1036: case 1:
1037: fprintf(output, "Object is a number : Infinity\n");
1038: break;
1039: case -1:
1040: fprintf(output, "Object is a number : -Infinity\n");
1041: break;
1042: default:
1043: if (xmlXPathIsNaN(cur->floatval)) {
1044: fprintf(output, "Object is a number : NaN\n");
1045: } else if (cur->floatval == 0 && xmlXPathGetSign(cur->floatval) != 0) {
1046: fprintf(output, "Object is a number : 0\n");
1047: } else {
1048: fprintf(output, "Object is a number : %0g\n", cur->floatval);
1049: }
1050: }
1051: break;
1052: case XPATH_STRING:
1053: fprintf(output, "Object is a string : ");
1054: xmlDebugDumpString(output, cur->stringval);
1055: fprintf(output, "\n");
1056: break;
1057: case XPATH_POINT:
1058: fprintf(output, "Object is a point : index %d in node", cur->index);
1059: xmlXPathDebugDumpNode(output, (xmlNodePtr) cur->user, depth + 1);
1060: fprintf(output, "\n");
1061: break;
1062: case XPATH_RANGE:
1063: if ((cur->user2 == NULL) ||
1064: ((cur->user2 == cur->user) && (cur->index == cur->index2))) {
1065: fprintf(output, "Object is a collapsed range :\n");
1066: fprintf(output, "%s", shift);
1067: if (cur->index >= 0)
1068: fprintf(output, "index %d in ", cur->index);
1069: fprintf(output, "node\n");
1070: xmlXPathDebugDumpNode(output, (xmlNodePtr) cur->user,
1071: depth + 1);
1072: } else {
1073: fprintf(output, "Object is a range :\n");
1074: fprintf(output, "%s", shift);
1075: fprintf(output, "From ");
1076: if (cur->index >= 0)
1077: fprintf(output, "index %d in ", cur->index);
1078: fprintf(output, "node\n");
1079: xmlXPathDebugDumpNode(output, (xmlNodePtr) cur->user,
1080: depth + 1);
1081: fprintf(output, "%s", shift);
1082: fprintf(output, "To ");
1083: if (cur->index2 >= 0)
1084: fprintf(output, "index %d in ", cur->index2);
1085: fprintf(output, "node\n");
1086: xmlXPathDebugDumpNode(output, (xmlNodePtr) cur->user2,
1087: depth + 1);
1088: fprintf(output, "\n");
1089: }
1090: break;
1091: case XPATH_LOCATIONSET:
1092: #if defined(LIBXML_XPTR_ENABLED)
1093: fprintf(output, "Object is a Location Set:\n");
1094: xmlXPathDebugDumpLocationSet(output,
1095: (xmlLocationSetPtr) cur->user, depth);
1096: #endif
1097: break;
1098: case XPATH_USERS:
1099: fprintf(output, "Object is user defined\n");
1100: break;
1101: }
1102: }
1103:
1104: static void
1105: xmlXPathDebugDumpStepOp(FILE *output, xmlXPathCompExprPtr comp,
1106: xmlXPathStepOpPtr op, int depth) {
1107: int i;
1108: char shift[100];
1109:
1110: for (i = 0;((i < depth) && (i < 25));i++)
1111: shift[2 * i] = shift[2 * i + 1] = ' ';
1112: shift[2 * i] = shift[2 * i + 1] = 0;
1113:
1114: fprintf(output, "%s", shift);
1115: if (op == NULL) {
1116: fprintf(output, "Step is NULL\n");
1117: return;
1118: }
1119: switch (op->op) {
1120: case XPATH_OP_END:
1121: fprintf(output, "END"); break;
1122: case XPATH_OP_AND:
1123: fprintf(output, "AND"); break;
1124: case XPATH_OP_OR:
1125: fprintf(output, "OR"); break;
1126: case XPATH_OP_EQUAL:
1127: if (op->value)
1128: fprintf(output, "EQUAL =");
1129: else
1130: fprintf(output, "EQUAL !=");
1131: break;
1132: case XPATH_OP_CMP:
1133: if (op->value)
1134: fprintf(output, "CMP <");
1135: else
1136: fprintf(output, "CMP >");
1137: if (!op->value2)
1138: fprintf(output, "=");
1139: break;
1140: case XPATH_OP_PLUS:
1141: if (op->value == 0)
1142: fprintf(output, "PLUS -");
1143: else if (op->value == 1)
1144: fprintf(output, "PLUS +");
1145: else if (op->value == 2)
1146: fprintf(output, "PLUS unary -");
1147: else if (op->value == 3)
1148: fprintf(output, "PLUS unary - -");
1149: break;
1150: case XPATH_OP_MULT:
1151: if (op->value == 0)
1152: fprintf(output, "MULT *");
1153: else if (op->value == 1)
1154: fprintf(output, "MULT div");
1155: else
1156: fprintf(output, "MULT mod");
1157: break;
1158: case XPATH_OP_UNION:
1159: fprintf(output, "UNION"); break;
1160: case XPATH_OP_ROOT:
1161: fprintf(output, "ROOT"); break;
1162: case XPATH_OP_NODE:
1163: fprintf(output, "NODE"); break;
1164: case XPATH_OP_RESET:
1165: fprintf(output, "RESET"); break;
1166: case XPATH_OP_SORT:
1167: fprintf(output, "SORT"); break;
1168: case XPATH_OP_COLLECT: {
1169: xmlXPathAxisVal axis = (xmlXPathAxisVal)op->value;
1170: xmlXPathTestVal test = (xmlXPathTestVal)op->value2;
1171: xmlXPathTypeVal type = (xmlXPathTypeVal)op->value3;
1172: const xmlChar *prefix = op->value4;
1173: const xmlChar *name = op->value5;
1174:
1175: fprintf(output, "COLLECT ");
1176: switch (axis) {
1177: case AXIS_ANCESTOR:
1178: fprintf(output, " 'ancestors' "); break;
1179: case AXIS_ANCESTOR_OR_SELF:
1180: fprintf(output, " 'ancestors-or-self' "); break;
1181: case AXIS_ATTRIBUTE:
1182: fprintf(output, " 'attributes' "); break;
1183: case AXIS_CHILD:
1184: fprintf(output, " 'child' "); break;
1185: case AXIS_DESCENDANT:
1186: fprintf(output, " 'descendant' "); break;
1187: case AXIS_DESCENDANT_OR_SELF:
1188: fprintf(output, " 'descendant-or-self' "); break;
1189: case AXIS_FOLLOWING:
1190: fprintf(output, " 'following' "); break;
1191: case AXIS_FOLLOWING_SIBLING:
1192: fprintf(output, " 'following-siblings' "); break;
1193: case AXIS_NAMESPACE:
1194: fprintf(output, " 'namespace' "); break;
1195: case AXIS_PARENT:
1196: fprintf(output, " 'parent' "); break;
1197: case AXIS_PRECEDING:
1198: fprintf(output, " 'preceding' "); break;
1199: case AXIS_PRECEDING_SIBLING:
1200: fprintf(output, " 'preceding-sibling' "); break;
1201: case AXIS_SELF:
1202: fprintf(output, " 'self' "); break;
1203: }
1204: switch (test) {
1205: case NODE_TEST_NONE:
1206: fprintf(output, "'none' "); break;
1207: case NODE_TEST_TYPE:
1208: fprintf(output, "'type' "); break;
1209: case NODE_TEST_PI:
1210: fprintf(output, "'PI' "); break;
1211: case NODE_TEST_ALL:
1212: fprintf(output, "'all' "); break;
1213: case NODE_TEST_NS:
1214: fprintf(output, "'namespace' "); break;
1215: case NODE_TEST_NAME:
1216: fprintf(output, "'name' "); break;
1217: }
1218: switch (type) {
1219: case NODE_TYPE_NODE:
1220: fprintf(output, "'node' "); break;
1221: case NODE_TYPE_COMMENT:
1222: fprintf(output, "'comment' "); break;
1223: case NODE_TYPE_TEXT:
1224: fprintf(output, "'text' "); break;
1225: case NODE_TYPE_PI:
1226: fprintf(output, "'PI' "); break;
1227: }
1228: if (prefix != NULL)
1229: fprintf(output, "%s:", prefix);
1230: if (name != NULL)
1231: fprintf(output, "%s", (const char *) name);
1232: break;
1233:
1234: }
1235: case XPATH_OP_VALUE: {
1236: xmlXPathObjectPtr object = (xmlXPathObjectPtr) op->value4;
1237:
1238: fprintf(output, "ELEM ");
1239: xmlXPathDebugDumpObject(output, object, 0);
1240: goto finish;
1241: }
1242: case XPATH_OP_VARIABLE: {
1243: const xmlChar *prefix = op->value5;
1244: const xmlChar *name = op->value4;
1245:
1246: if (prefix != NULL)
1247: fprintf(output, "VARIABLE %s:%s", prefix, name);
1248: else
1249: fprintf(output, "VARIABLE %s", name);
1250: break;
1251: }
1252: case XPATH_OP_FUNCTION: {
1253: int nbargs = op->value;
1254: const xmlChar *prefix = op->value5;
1255: const xmlChar *name = op->value4;
1256:
1257: if (prefix != NULL)
1258: fprintf(output, "FUNCTION %s:%s(%d args)",
1259: prefix, name, nbargs);
1260: else
1261: fprintf(output, "FUNCTION %s(%d args)", name, nbargs);
1262: break;
1263: }
1264: case XPATH_OP_ARG: fprintf(output, "ARG"); break;
1265: case XPATH_OP_PREDICATE: fprintf(output, "PREDICATE"); break;
1266: case XPATH_OP_FILTER: fprintf(output, "FILTER"); break;
1267: #ifdef LIBXML_XPTR_ENABLED
1268: case XPATH_OP_RANGETO: fprintf(output, "RANGETO"); break;
1269: #endif
1270: default:
1271: fprintf(output, "UNKNOWN %d\n", op->op); return;
1272: }
1273: fprintf(output, "\n");
1274: finish:
1275: if (op->ch1 >= 0)
1276: xmlXPathDebugDumpStepOp(output, comp, &comp->steps[op->ch1], depth + 1);
1277: if (op->ch2 >= 0)
1278: xmlXPathDebugDumpStepOp(output, comp, &comp->steps[op->ch2], depth + 1);
1279: }
1280:
1281: /**
1282: * xmlXPathDebugDumpCompExpr:
1283: * @output: the FILE * for the output
1284: * @comp: the precompiled XPath expression
1285: * @depth: the indentation level.
1286: *
1287: * Dumps the tree of the compiled XPath expression.
1288: */
1289: void
1290: xmlXPathDebugDumpCompExpr(FILE *output, xmlXPathCompExprPtr comp,
1291: int depth) {
1292: int i;
1293: char shift[100];
1294:
1295: if ((output == NULL) || (comp == NULL)) return;
1296:
1297: for (i = 0;((i < depth) && (i < 25));i++)
1298: shift[2 * i] = shift[2 * i + 1] = ' ';
1299: shift[2 * i] = shift[2 * i + 1] = 0;
1300:
1301: fprintf(output, "%s", shift);
1302:
1303: fprintf(output, "Compiled Expression : %d elements\n",
1304: comp->nbStep);
1305: i = comp->last;
1306: xmlXPathDebugDumpStepOp(output, comp, &comp->steps[i], depth + 1);
1307: }
1308:
1309: #ifdef XP_DEBUG_OBJ_USAGE
1310:
1311: /*
1312: * XPath object usage related debugging variables.
1313: */
1314: static int xmlXPathDebugObjCounterUndefined = 0;
1315: static int xmlXPathDebugObjCounterNodeset = 0;
1316: static int xmlXPathDebugObjCounterBool = 0;
1317: static int xmlXPathDebugObjCounterNumber = 0;
1318: static int xmlXPathDebugObjCounterString = 0;
1319: static int xmlXPathDebugObjCounterPoint = 0;
1320: static int xmlXPathDebugObjCounterRange = 0;
1321: static int xmlXPathDebugObjCounterLocset = 0;
1322: static int xmlXPathDebugObjCounterUsers = 0;
1323: static int xmlXPathDebugObjCounterXSLTTree = 0;
1324: static int xmlXPathDebugObjCounterAll = 0;
1325:
1326: static int xmlXPathDebugObjTotalUndefined = 0;
1327: static int xmlXPathDebugObjTotalNodeset = 0;
1328: static int xmlXPathDebugObjTotalBool = 0;
1329: static int xmlXPathDebugObjTotalNumber = 0;
1330: static int xmlXPathDebugObjTotalString = 0;
1331: static int xmlXPathDebugObjTotalPoint = 0;
1332: static int xmlXPathDebugObjTotalRange = 0;
1333: static int xmlXPathDebugObjTotalLocset = 0;
1334: static int xmlXPathDebugObjTotalUsers = 0;
1335: static int xmlXPathDebugObjTotalXSLTTree = 0;
1336: static int xmlXPathDebugObjTotalAll = 0;
1337:
1338: static int xmlXPathDebugObjMaxUndefined = 0;
1339: static int xmlXPathDebugObjMaxNodeset = 0;
1340: static int xmlXPathDebugObjMaxBool = 0;
1341: static int xmlXPathDebugObjMaxNumber = 0;
1342: static int xmlXPathDebugObjMaxString = 0;
1343: static int xmlXPathDebugObjMaxPoint = 0;
1344: static int xmlXPathDebugObjMaxRange = 0;
1345: static int xmlXPathDebugObjMaxLocset = 0;
1346: static int xmlXPathDebugObjMaxUsers = 0;
1347: static int xmlXPathDebugObjMaxXSLTTree = 0;
1348: static int xmlXPathDebugObjMaxAll = 0;
1349:
1350: /* REVISIT TODO: Make this static when committing */
1351: static void
1352: xmlXPathDebugObjUsageReset(xmlXPathContextPtr ctxt)
1353: {
1354: if (ctxt != NULL) {
1355: if (ctxt->cache != NULL) {
1356: xmlXPathContextCachePtr cache =
1357: (xmlXPathContextCachePtr) ctxt->cache;
1358:
1359: cache->dbgCachedAll = 0;
1360: cache->dbgCachedNodeset = 0;
1361: cache->dbgCachedString = 0;
1362: cache->dbgCachedBool = 0;
1363: cache->dbgCachedNumber = 0;
1364: cache->dbgCachedPoint = 0;
1365: cache->dbgCachedRange = 0;
1366: cache->dbgCachedLocset = 0;
1367: cache->dbgCachedUsers = 0;
1368: cache->dbgCachedXSLTTree = 0;
1369: cache->dbgCachedUndefined = 0;
1370:
1371: cache->dbgReusedAll = 0;
1372: cache->dbgReusedNodeset = 0;
1373: cache->dbgReusedString = 0;
1374: cache->dbgReusedBool = 0;
1375: cache->dbgReusedNumber = 0;
1376: cache->dbgReusedPoint = 0;
1377: cache->dbgReusedRange = 0;
1378: cache->dbgReusedLocset = 0;
1379: cache->dbgReusedUsers = 0;
1380: cache->dbgReusedXSLTTree = 0;
1381: cache->dbgReusedUndefined = 0;
1382: }
1383: }
1384:
1385: xmlXPathDebugObjCounterUndefined = 0;
1386: xmlXPathDebugObjCounterNodeset = 0;
1387: xmlXPathDebugObjCounterBool = 0;
1388: xmlXPathDebugObjCounterNumber = 0;
1389: xmlXPathDebugObjCounterString = 0;
1390: xmlXPathDebugObjCounterPoint = 0;
1391: xmlXPathDebugObjCounterRange = 0;
1392: xmlXPathDebugObjCounterLocset = 0;
1393: xmlXPathDebugObjCounterUsers = 0;
1394: xmlXPathDebugObjCounterXSLTTree = 0;
1395: xmlXPathDebugObjCounterAll = 0;
1396:
1397: xmlXPathDebugObjTotalUndefined = 0;
1398: xmlXPathDebugObjTotalNodeset = 0;
1399: xmlXPathDebugObjTotalBool = 0;
1400: xmlXPathDebugObjTotalNumber = 0;
1401: xmlXPathDebugObjTotalString = 0;
1402: xmlXPathDebugObjTotalPoint = 0;
1403: xmlXPathDebugObjTotalRange = 0;
1404: xmlXPathDebugObjTotalLocset = 0;
1405: xmlXPathDebugObjTotalUsers = 0;
1406: xmlXPathDebugObjTotalXSLTTree = 0;
1407: xmlXPathDebugObjTotalAll = 0;
1408:
1409: xmlXPathDebugObjMaxUndefined = 0;
1410: xmlXPathDebugObjMaxNodeset = 0;
1411: xmlXPathDebugObjMaxBool = 0;
1412: xmlXPathDebugObjMaxNumber = 0;
1413: xmlXPathDebugObjMaxString = 0;
1414: xmlXPathDebugObjMaxPoint = 0;
1415: xmlXPathDebugObjMaxRange = 0;
1416: xmlXPathDebugObjMaxLocset = 0;
1417: xmlXPathDebugObjMaxUsers = 0;
1418: xmlXPathDebugObjMaxXSLTTree = 0;
1419: xmlXPathDebugObjMaxAll = 0;
1420:
1421: }
1422:
1423: static void
1424: xmlXPathDebugObjUsageRequested(xmlXPathContextPtr ctxt,
1425: xmlXPathObjectType objType)
1426: {
1427: int isCached = 0;
1428:
1429: if (ctxt != NULL) {
1430: if (ctxt->cache != NULL) {
1431: xmlXPathContextCachePtr cache =
1432: (xmlXPathContextCachePtr) ctxt->cache;
1433:
1434: isCached = 1;
1435:
1436: cache->dbgReusedAll++;
1437: switch (objType) {
1438: case XPATH_UNDEFINED:
1439: cache->dbgReusedUndefined++;
1440: break;
1441: case XPATH_NODESET:
1442: cache->dbgReusedNodeset++;
1443: break;
1444: case XPATH_BOOLEAN:
1445: cache->dbgReusedBool++;
1446: break;
1447: case XPATH_NUMBER:
1448: cache->dbgReusedNumber++;
1449: break;
1450: case XPATH_STRING:
1451: cache->dbgReusedString++;
1452: break;
1453: case XPATH_POINT:
1454: cache->dbgReusedPoint++;
1455: break;
1456: case XPATH_RANGE:
1457: cache->dbgReusedRange++;
1458: break;
1459: case XPATH_LOCATIONSET:
1460: cache->dbgReusedLocset++;
1461: break;
1462: case XPATH_USERS:
1463: cache->dbgReusedUsers++;
1464: break;
1465: case XPATH_XSLT_TREE:
1466: cache->dbgReusedXSLTTree++;
1467: break;
1468: default:
1469: break;
1470: }
1471: }
1472: }
1473:
1474: switch (objType) {
1475: case XPATH_UNDEFINED:
1476: if (! isCached)
1477: xmlXPathDebugObjTotalUndefined++;
1478: xmlXPathDebugObjCounterUndefined++;
1479: if (xmlXPathDebugObjCounterUndefined >
1480: xmlXPathDebugObjMaxUndefined)
1481: xmlXPathDebugObjMaxUndefined =
1482: xmlXPathDebugObjCounterUndefined;
1483: break;
1484: case XPATH_NODESET:
1485: if (! isCached)
1486: xmlXPathDebugObjTotalNodeset++;
1487: xmlXPathDebugObjCounterNodeset++;
1488: if (xmlXPathDebugObjCounterNodeset >
1489: xmlXPathDebugObjMaxNodeset)
1490: xmlXPathDebugObjMaxNodeset =
1491: xmlXPathDebugObjCounterNodeset;
1492: break;
1493: case XPATH_BOOLEAN:
1494: if (! isCached)
1495: xmlXPathDebugObjTotalBool++;
1496: xmlXPathDebugObjCounterBool++;
1497: if (xmlXPathDebugObjCounterBool >
1498: xmlXPathDebugObjMaxBool)
1499: xmlXPathDebugObjMaxBool =
1500: xmlXPathDebugObjCounterBool;
1501: break;
1502: case XPATH_NUMBER:
1503: if (! isCached)
1504: xmlXPathDebugObjTotalNumber++;
1505: xmlXPathDebugObjCounterNumber++;
1506: if (xmlXPathDebugObjCounterNumber >
1507: xmlXPathDebugObjMaxNumber)
1508: xmlXPathDebugObjMaxNumber =
1509: xmlXPathDebugObjCounterNumber;
1510: break;
1511: case XPATH_STRING:
1512: if (! isCached)
1513: xmlXPathDebugObjTotalString++;
1514: xmlXPathDebugObjCounterString++;
1515: if (xmlXPathDebugObjCounterString >
1516: xmlXPathDebugObjMaxString)
1517: xmlXPathDebugObjMaxString =
1518: xmlXPathDebugObjCounterString;
1519: break;
1520: case XPATH_POINT:
1521: if (! isCached)
1522: xmlXPathDebugObjTotalPoint++;
1523: xmlXPathDebugObjCounterPoint++;
1524: if (xmlXPathDebugObjCounterPoint >
1525: xmlXPathDebugObjMaxPoint)
1526: xmlXPathDebugObjMaxPoint =
1527: xmlXPathDebugObjCounterPoint;
1528: break;
1529: case XPATH_RANGE:
1530: if (! isCached)
1531: xmlXPathDebugObjTotalRange++;
1532: xmlXPathDebugObjCounterRange++;
1533: if (xmlXPathDebugObjCounterRange >
1534: xmlXPathDebugObjMaxRange)
1535: xmlXPathDebugObjMaxRange =
1536: xmlXPathDebugObjCounterRange;
1537: break;
1538: case XPATH_LOCATIONSET:
1539: if (! isCached)
1540: xmlXPathDebugObjTotalLocset++;
1541: xmlXPathDebugObjCounterLocset++;
1542: if (xmlXPathDebugObjCounterLocset >
1543: xmlXPathDebugObjMaxLocset)
1544: xmlXPathDebugObjMaxLocset =
1545: xmlXPathDebugObjCounterLocset;
1546: break;
1547: case XPATH_USERS:
1548: if (! isCached)
1549: xmlXPathDebugObjTotalUsers++;
1550: xmlXPathDebugObjCounterUsers++;
1551: if (xmlXPathDebugObjCounterUsers >
1552: xmlXPathDebugObjMaxUsers)
1553: xmlXPathDebugObjMaxUsers =
1554: xmlXPathDebugObjCounterUsers;
1555: break;
1556: case XPATH_XSLT_TREE:
1557: if (! isCached)
1558: xmlXPathDebugObjTotalXSLTTree++;
1559: xmlXPathDebugObjCounterXSLTTree++;
1560: if (xmlXPathDebugObjCounterXSLTTree >
1561: xmlXPathDebugObjMaxXSLTTree)
1562: xmlXPathDebugObjMaxXSLTTree =
1563: xmlXPathDebugObjCounterXSLTTree;
1564: break;
1565: default:
1566: break;
1567: }
1568: if (! isCached)
1569: xmlXPathDebugObjTotalAll++;
1570: xmlXPathDebugObjCounterAll++;
1571: if (xmlXPathDebugObjCounterAll >
1572: xmlXPathDebugObjMaxAll)
1573: xmlXPathDebugObjMaxAll =
1574: xmlXPathDebugObjCounterAll;
1575: }
1576:
1577: static void
1578: xmlXPathDebugObjUsageReleased(xmlXPathContextPtr ctxt,
1579: xmlXPathObjectType objType)
1580: {
1581: int isCached = 0;
1582:
1583: if (ctxt != NULL) {
1584: if (ctxt->cache != NULL) {
1585: xmlXPathContextCachePtr cache =
1586: (xmlXPathContextCachePtr) ctxt->cache;
1587:
1588: isCached = 1;
1589:
1590: cache->dbgCachedAll++;
1591: switch (objType) {
1592: case XPATH_UNDEFINED:
1593: cache->dbgCachedUndefined++;
1594: break;
1595: case XPATH_NODESET:
1596: cache->dbgCachedNodeset++;
1597: break;
1598: case XPATH_BOOLEAN:
1599: cache->dbgCachedBool++;
1600: break;
1601: case XPATH_NUMBER:
1602: cache->dbgCachedNumber++;
1603: break;
1604: case XPATH_STRING:
1605: cache->dbgCachedString++;
1606: break;
1607: case XPATH_POINT:
1608: cache->dbgCachedPoint++;
1609: break;
1610: case XPATH_RANGE:
1611: cache->dbgCachedRange++;
1612: break;
1613: case XPATH_LOCATIONSET:
1614: cache->dbgCachedLocset++;
1615: break;
1616: case XPATH_USERS:
1617: cache->dbgCachedUsers++;
1618: break;
1619: case XPATH_XSLT_TREE:
1620: cache->dbgCachedXSLTTree++;
1621: break;
1622: default:
1623: break;
1624: }
1625:
1626: }
1627: }
1628: switch (objType) {
1629: case XPATH_UNDEFINED:
1630: xmlXPathDebugObjCounterUndefined--;
1631: break;
1632: case XPATH_NODESET:
1633: xmlXPathDebugObjCounterNodeset--;
1634: break;
1635: case XPATH_BOOLEAN:
1636: xmlXPathDebugObjCounterBool--;
1637: break;
1638: case XPATH_NUMBER:
1639: xmlXPathDebugObjCounterNumber--;
1640: break;
1641: case XPATH_STRING:
1642: xmlXPathDebugObjCounterString--;
1643: break;
1644: case XPATH_POINT:
1645: xmlXPathDebugObjCounterPoint--;
1646: break;
1647: case XPATH_RANGE:
1648: xmlXPathDebugObjCounterRange--;
1649: break;
1650: case XPATH_LOCATIONSET:
1651: xmlXPathDebugObjCounterLocset--;
1652: break;
1653: case XPATH_USERS:
1654: xmlXPathDebugObjCounterUsers--;
1655: break;
1656: case XPATH_XSLT_TREE:
1657: xmlXPathDebugObjCounterXSLTTree--;
1658: break;
1659: default:
1660: break;
1661: }
1662: xmlXPathDebugObjCounterAll--;
1663: }
1664:
1665: /* REVISIT TODO: Make this static when committing */
1666: static void
1667: xmlXPathDebugObjUsageDisplay(xmlXPathContextPtr ctxt)
1668: {
1669: int reqAll, reqNodeset, reqString, reqBool, reqNumber,
1670: reqXSLTTree, reqUndefined;
1671: int caAll = 0, caNodeset = 0, caString = 0, caBool = 0,
1672: caNumber = 0, caXSLTTree = 0, caUndefined = 0;
1673: int reAll = 0, reNodeset = 0, reString = 0, reBool = 0,
1674: reNumber = 0, reXSLTTree = 0, reUndefined = 0;
1675: int leftObjs = xmlXPathDebugObjCounterAll;
1676:
1677: reqAll = xmlXPathDebugObjTotalAll;
1678: reqNodeset = xmlXPathDebugObjTotalNodeset;
1679: reqString = xmlXPathDebugObjTotalString;
1680: reqBool = xmlXPathDebugObjTotalBool;
1681: reqNumber = xmlXPathDebugObjTotalNumber;
1682: reqXSLTTree = xmlXPathDebugObjTotalXSLTTree;
1683: reqUndefined = xmlXPathDebugObjTotalUndefined;
1684:
1685: printf("# XPath object usage:\n");
1686:
1687: if (ctxt != NULL) {
1688: if (ctxt->cache != NULL) {
1689: xmlXPathContextCachePtr cache =
1690: (xmlXPathContextCachePtr) ctxt->cache;
1691:
1692: reAll = cache->dbgReusedAll;
1693: reqAll += reAll;
1694: reNodeset = cache->dbgReusedNodeset;
1695: reqNodeset += reNodeset;
1696: reString = cache->dbgReusedString;
1697: reqString += reString;
1698: reBool = cache->dbgReusedBool;
1699: reqBool += reBool;
1700: reNumber = cache->dbgReusedNumber;
1701: reqNumber += reNumber;
1702: reXSLTTree = cache->dbgReusedXSLTTree;
1703: reqXSLTTree += reXSLTTree;
1704: reUndefined = cache->dbgReusedUndefined;
1705: reqUndefined += reUndefined;
1706:
1707: caAll = cache->dbgCachedAll;
1708: caBool = cache->dbgCachedBool;
1709: caNodeset = cache->dbgCachedNodeset;
1710: caString = cache->dbgCachedString;
1711: caNumber = cache->dbgCachedNumber;
1712: caXSLTTree = cache->dbgCachedXSLTTree;
1713: caUndefined = cache->dbgCachedUndefined;
1714:
1715: if (cache->nodesetObjs)
1716: leftObjs -= cache->nodesetObjs->number;
1717: if (cache->stringObjs)
1718: leftObjs -= cache->stringObjs->number;
1719: if (cache->booleanObjs)
1720: leftObjs -= cache->booleanObjs->number;
1721: if (cache->numberObjs)
1722: leftObjs -= cache->numberObjs->number;
1723: if (cache->miscObjs)
1724: leftObjs -= cache->miscObjs->number;
1725: }
1726: }
1727:
1728: printf("# all\n");
1729: printf("# total : %d\n", reqAll);
1730: printf("# left : %d\n", leftObjs);
1731: printf("# created: %d\n", xmlXPathDebugObjTotalAll);
1732: printf("# reused : %d\n", reAll);
1733: printf("# max : %d\n", xmlXPathDebugObjMaxAll);
1734:
1735: printf("# node-sets\n");
1736: printf("# total : %d\n", reqNodeset);
1737: printf("# created: %d\n", xmlXPathDebugObjTotalNodeset);
1738: printf("# reused : %d\n", reNodeset);
1739: printf("# max : %d\n", xmlXPathDebugObjMaxNodeset);
1740:
1741: printf("# strings\n");
1742: printf("# total : %d\n", reqString);
1743: printf("# created: %d\n", xmlXPathDebugObjTotalString);
1744: printf("# reused : %d\n", reString);
1745: printf("# max : %d\n", xmlXPathDebugObjMaxString);
1746:
1747: printf("# booleans\n");
1748: printf("# total : %d\n", reqBool);
1749: printf("# created: %d\n", xmlXPathDebugObjTotalBool);
1750: printf("# reused : %d\n", reBool);
1751: printf("# max : %d\n", xmlXPathDebugObjMaxBool);
1752:
1753: printf("# numbers\n");
1754: printf("# total : %d\n", reqNumber);
1755: printf("# created: %d\n", xmlXPathDebugObjTotalNumber);
1756: printf("# reused : %d\n", reNumber);
1757: printf("# max : %d\n", xmlXPathDebugObjMaxNumber);
1758:
1759: printf("# XSLT result tree fragments\n");
1760: printf("# total : %d\n", reqXSLTTree);
1761: printf("# created: %d\n", xmlXPathDebugObjTotalXSLTTree);
1762: printf("# reused : %d\n", reXSLTTree);
1763: printf("# max : %d\n", xmlXPathDebugObjMaxXSLTTree);
1764:
1765: printf("# undefined\n");
1766: printf("# total : %d\n", reqUndefined);
1767: printf("# created: %d\n", xmlXPathDebugObjTotalUndefined);
1768: printf("# reused : %d\n", reUndefined);
1769: printf("# max : %d\n", xmlXPathDebugObjMaxUndefined);
1770:
1771: }
1772:
1773: #endif /* XP_DEBUG_OBJ_USAGE */
1774:
1775: #endif /* LIBXML_DEBUG_ENABLED */
1776:
1777: /************************************************************************
1778: * *
1779: * XPath object caching *
1780: * *
1781: ************************************************************************/
1782:
1783: /**
1784: * xmlXPathNewCache:
1785: *
1786: * Create a new object cache
1787: *
1788: * Returns the xmlXPathCache just allocated.
1789: */
1790: static xmlXPathContextCachePtr
1791: xmlXPathNewCache(void)
1792: {
1793: xmlXPathContextCachePtr ret;
1794:
1795: ret = (xmlXPathContextCachePtr) xmlMalloc(sizeof(xmlXPathContextCache));
1796: if (ret == NULL) {
1797: xmlXPathErrMemory(NULL, "creating object cache\n");
1798: return(NULL);
1799: }
1800: memset(ret, 0 , (size_t) sizeof(xmlXPathContextCache));
1801: ret->maxNodeset = 100;
1802: ret->maxString = 100;
1803: ret->maxBoolean = 100;
1804: ret->maxNumber = 100;
1805: ret->maxMisc = 100;
1806: return(ret);
1807: }
1808:
1809: static void
1810: xmlXPathCacheFreeObjectList(xmlPointerListPtr list)
1811: {
1812: int i;
1813: xmlXPathObjectPtr obj;
1814:
1815: if (list == NULL)
1816: return;
1817:
1818: for (i = 0; i < list->number; i++) {
1819: obj = list->items[i];
1820: /*
1821: * Note that it is already assured that we don't need to
1822: * look out for namespace nodes in the node-set.
1823: */
1824: if (obj->nodesetval != NULL) {
1825: if (obj->nodesetval->nodeTab != NULL)
1826: xmlFree(obj->nodesetval->nodeTab);
1827: xmlFree(obj->nodesetval);
1828: }
1829: xmlFree(obj);
1830: #ifdef XP_DEBUG_OBJ_USAGE
1831: xmlXPathDebugObjCounterAll--;
1832: #endif
1833: }
1834: xmlPointerListFree(list);
1835: }
1836:
1837: static void
1838: xmlXPathFreeCache(xmlXPathContextCachePtr cache)
1839: {
1840: if (cache == NULL)
1841: return;
1842: if (cache->nodesetObjs)
1843: xmlXPathCacheFreeObjectList(cache->nodesetObjs);
1844: if (cache->stringObjs)
1845: xmlXPathCacheFreeObjectList(cache->stringObjs);
1846: if (cache->booleanObjs)
1847: xmlXPathCacheFreeObjectList(cache->booleanObjs);
1848: if (cache->numberObjs)
1849: xmlXPathCacheFreeObjectList(cache->numberObjs);
1850: if (cache->miscObjs)
1851: xmlXPathCacheFreeObjectList(cache->miscObjs);
1852: xmlFree(cache);
1853: }
1854:
1855: /**
1856: * xmlXPathContextSetCache:
1857: *
1858: * @ctxt: the XPath context
1859: * @active: enables/disables (creates/frees) the cache
1860: * @value: a value with semantics dependant on @options
1861: * @options: options (currently only the value 0 is used)
1862: *
1863: * Creates/frees an object cache on the XPath context.
1864: * If activates XPath objects (xmlXPathObject) will be cached internally
1865: * to be reused.
1866: * @options:
1867: * 0: This will set the XPath object caching:
1868: * @value:
1869: * This will set the maximum number of XPath objects
1870: * to be cached per slot
1871: * There are 5 slots for: node-set, string, number, boolean, and
1872: * misc objects. Use <0 for the default number (100).
1873: * Other values for @options have currently no effect.
1874: *
1875: * Returns 0 if the setting succeeded, and -1 on API or internal errors.
1876: */
1877: int
1878: xmlXPathContextSetCache(xmlXPathContextPtr ctxt,
1879: int active,
1880: int value,
1881: int options)
1882: {
1883: if (ctxt == NULL)
1884: return(-1);
1885: if (active) {
1886: xmlXPathContextCachePtr cache;
1887:
1888: if (ctxt->cache == NULL) {
1889: ctxt->cache = xmlXPathNewCache();
1890: if (ctxt->cache == NULL)
1891: return(-1);
1892: }
1893: cache = (xmlXPathContextCachePtr) ctxt->cache;
1894: if (options == 0) {
1895: if (value < 0)
1896: value = 100;
1897: cache->maxNodeset = value;
1898: cache->maxString = value;
1899: cache->maxNumber = value;
1900: cache->maxBoolean = value;
1901: cache->maxMisc = value;
1902: }
1903: } else if (ctxt->cache != NULL) {
1904: xmlXPathFreeCache((xmlXPathContextCachePtr) ctxt->cache);
1905: ctxt->cache = NULL;
1906: }
1907: return(0);
1908: }
1909:
1910: /**
1911: * xmlXPathCacheWrapNodeSet:
1912: * @ctxt: the XPath context
1913: * @val: the NodePtr value
1914: *
1915: * This is the cached version of xmlXPathWrapNodeSet().
1916: * Wrap the Nodeset @val in a new xmlXPathObjectPtr
1917: *
1918: * Returns the created or reused object.
1919: */
1920: static xmlXPathObjectPtr
1921: xmlXPathCacheWrapNodeSet(xmlXPathContextPtr ctxt, xmlNodeSetPtr val)
1922: {
1923: if ((ctxt != NULL) && (ctxt->cache != NULL)) {
1924: xmlXPathContextCachePtr cache =
1925: (xmlXPathContextCachePtr) ctxt->cache;
1926:
1927: if ((cache->miscObjs != NULL) &&
1928: (cache->miscObjs->number != 0))
1929: {
1930: xmlXPathObjectPtr ret;
1931:
1932: ret = (xmlXPathObjectPtr)
1933: cache->miscObjs->items[--cache->miscObjs->number];
1934: ret->type = XPATH_NODESET;
1935: ret->nodesetval = val;
1936: #ifdef XP_DEBUG_OBJ_USAGE
1937: xmlXPathDebugObjUsageRequested(ctxt, XPATH_NODESET);
1938: #endif
1939: return(ret);
1940: }
1941: }
1942:
1943: return(xmlXPathWrapNodeSet(val));
1944:
1945: }
1946:
1947: /**
1948: * xmlXPathCacheWrapString:
1949: * @ctxt: the XPath context
1950: * @val: the xmlChar * value
1951: *
1952: * This is the cached version of xmlXPathWrapString().
1953: * Wraps the @val string into an XPath object.
1954: *
1955: * Returns the created or reused object.
1956: */
1957: static xmlXPathObjectPtr
1958: xmlXPathCacheWrapString(xmlXPathContextPtr ctxt, xmlChar *val)
1959: {
1960: if ((ctxt != NULL) && (ctxt->cache != NULL)) {
1961: xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache;
1962:
1963: if ((cache->stringObjs != NULL) &&
1964: (cache->stringObjs->number != 0))
1965: {
1966:
1967: xmlXPathObjectPtr ret;
1968:
1969: ret = (xmlXPathObjectPtr)
1970: cache->stringObjs->items[--cache->stringObjs->number];
1971: ret->type = XPATH_STRING;
1972: ret->stringval = val;
1973: #ifdef XP_DEBUG_OBJ_USAGE
1974: xmlXPathDebugObjUsageRequested(ctxt, XPATH_STRING);
1975: #endif
1976: return(ret);
1977: } else if ((cache->miscObjs != NULL) &&
1978: (cache->miscObjs->number != 0))
1979: {
1980: xmlXPathObjectPtr ret;
1981: /*
1982: * Fallback to misc-cache.
1983: */
1984: ret = (xmlXPathObjectPtr)
1985: cache->miscObjs->items[--cache->miscObjs->number];
1986:
1987: ret->type = XPATH_STRING;
1988: ret->stringval = val;
1989: #ifdef XP_DEBUG_OBJ_USAGE
1990: xmlXPathDebugObjUsageRequested(ctxt, XPATH_STRING);
1991: #endif
1992: return(ret);
1993: }
1994: }
1995: return(xmlXPathWrapString(val));
1996: }
1997:
1998: /**
1999: * xmlXPathCacheNewNodeSet:
2000: * @ctxt: the XPath context
2001: * @val: the NodePtr value
2002: *
2003: * This is the cached version of xmlXPathNewNodeSet().
2004: * Acquire an xmlXPathObjectPtr of type NodeSet and initialize
2005: * it with the single Node @val
2006: *
2007: * Returns the created or reused object.
2008: */
2009: static xmlXPathObjectPtr
2010: xmlXPathCacheNewNodeSet(xmlXPathContextPtr ctxt, xmlNodePtr val)
2011: {
2012: if ((ctxt != NULL) && (ctxt->cache)) {
2013: xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache;
2014:
2015: if ((cache->nodesetObjs != NULL) &&
2016: (cache->nodesetObjs->number != 0))
2017: {
2018: xmlXPathObjectPtr ret;
2019: /*
2020: * Use the nodset-cache.
2021: */
2022: ret = (xmlXPathObjectPtr)
2023: cache->nodesetObjs->items[--cache->nodesetObjs->number];
2024: ret->type = XPATH_NODESET;
2025: ret->boolval = 0;
2026: if (val) {
2027: if ((ret->nodesetval->nodeMax == 0) ||
2028: (val->type == XML_NAMESPACE_DECL))
2029: {
2030: xmlXPathNodeSetAddUnique(ret->nodesetval, val);
2031: } else {
2032: ret->nodesetval->nodeTab[0] = val;
2033: ret->nodesetval->nodeNr = 1;
2034: }
2035: }
2036: #ifdef XP_DEBUG_OBJ_USAGE
2037: xmlXPathDebugObjUsageRequested(ctxt, XPATH_NODESET);
2038: #endif
2039: return(ret);
2040: } else if ((cache->miscObjs != NULL) &&
2041: (cache->miscObjs->number != 0))
2042: {
2043: xmlXPathObjectPtr ret;
2044: /*
2045: * Fallback to misc-cache.
2046: */
2047:
2048: ret = (xmlXPathObjectPtr)
2049: cache->miscObjs->items[--cache->miscObjs->number];
2050:
2051: ret->type = XPATH_NODESET;
2052: ret->boolval = 0;
2053: ret->nodesetval = xmlXPathNodeSetCreate(val);
2054: #ifdef XP_DEBUG_OBJ_USAGE
2055: xmlXPathDebugObjUsageRequested(ctxt, XPATH_NODESET);
2056: #endif
2057: return(ret);
2058: }
2059: }
2060: return(xmlXPathNewNodeSet(val));
2061: }
2062:
2063: /**
2064: * xmlXPathCacheNewCString:
2065: * @ctxt: the XPath context
2066: * @val: the char * value
2067: *
2068: * This is the cached version of xmlXPathNewCString().
2069: * Acquire an xmlXPathObjectPtr of type string and of value @val
2070: *
2071: * Returns the created or reused object.
2072: */
2073: static xmlXPathObjectPtr
2074: xmlXPathCacheNewCString(xmlXPathContextPtr ctxt, const char *val)
2075: {
2076: if ((ctxt != NULL) && (ctxt->cache)) {
2077: xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache;
2078:
2079: if ((cache->stringObjs != NULL) &&
2080: (cache->stringObjs->number != 0))
2081: {
2082: xmlXPathObjectPtr ret;
2083:
2084: ret = (xmlXPathObjectPtr)
2085: cache->stringObjs->items[--cache->stringObjs->number];
2086:
2087: ret->type = XPATH_STRING;
2088: ret->stringval = xmlStrdup(BAD_CAST val);
2089: #ifdef XP_DEBUG_OBJ_USAGE
2090: xmlXPathDebugObjUsageRequested(ctxt, XPATH_STRING);
2091: #endif
2092: return(ret);
2093: } else if ((cache->miscObjs != NULL) &&
2094: (cache->miscObjs->number != 0))
2095: {
2096: xmlXPathObjectPtr ret;
2097:
2098: ret = (xmlXPathObjectPtr)
2099: cache->miscObjs->items[--cache->miscObjs->number];
2100:
2101: ret->type = XPATH_STRING;
2102: ret->stringval = xmlStrdup(BAD_CAST val);
2103: #ifdef XP_DEBUG_OBJ_USAGE
2104: xmlXPathDebugObjUsageRequested(ctxt, XPATH_STRING);
2105: #endif
2106: return(ret);
2107: }
2108: }
2109: return(xmlXPathNewCString(val));
2110: }
2111:
2112: /**
2113: * xmlXPathCacheNewString:
2114: * @ctxt: the XPath context
2115: * @val: the xmlChar * value
2116: *
2117: * This is the cached version of xmlXPathNewString().
2118: * Acquire an xmlXPathObjectPtr of type string and of value @val
2119: *
2120: * Returns the created or reused object.
2121: */
2122: static xmlXPathObjectPtr
2123: xmlXPathCacheNewString(xmlXPathContextPtr ctxt, const xmlChar *val)
2124: {
2125: if ((ctxt != NULL) && (ctxt->cache)) {
2126: xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache;
2127:
2128: if ((cache->stringObjs != NULL) &&
2129: (cache->stringObjs->number != 0))
2130: {
2131: xmlXPathObjectPtr ret;
2132:
2133: ret = (xmlXPathObjectPtr)
2134: cache->stringObjs->items[--cache->stringObjs->number];
2135: ret->type = XPATH_STRING;
2136: if (val != NULL)
2137: ret->stringval = xmlStrdup(val);
2138: else
2139: ret->stringval = xmlStrdup((const xmlChar *)"");
2140: #ifdef XP_DEBUG_OBJ_USAGE
2141: xmlXPathDebugObjUsageRequested(ctxt, XPATH_STRING);
2142: #endif
2143: return(ret);
2144: } else if ((cache->miscObjs != NULL) &&
2145: (cache->miscObjs->number != 0))
2146: {
2147: xmlXPathObjectPtr ret;
2148:
2149: ret = (xmlXPathObjectPtr)
2150: cache->miscObjs->items[--cache->miscObjs->number];
2151:
2152: ret->type = XPATH_STRING;
2153: if (val != NULL)
2154: ret->stringval = xmlStrdup(val);
2155: else
2156: ret->stringval = xmlStrdup((const xmlChar *)"");
2157: #ifdef XP_DEBUG_OBJ_USAGE
2158: xmlXPathDebugObjUsageRequested(ctxt, XPATH_STRING);
2159: #endif
2160: return(ret);
2161: }
2162: }
2163: return(xmlXPathNewString(val));
2164: }
2165:
2166: /**
2167: * xmlXPathCacheNewBoolean:
2168: * @ctxt: the XPath context
2169: * @val: the boolean value
2170: *
2171: * This is the cached version of xmlXPathNewBoolean().
2172: * Acquires an xmlXPathObjectPtr of type boolean and of value @val
2173: *
2174: * Returns the created or reused object.
2175: */
2176: static xmlXPathObjectPtr
2177: xmlXPathCacheNewBoolean(xmlXPathContextPtr ctxt, int val)
2178: {
2179: if ((ctxt != NULL) && (ctxt->cache)) {
2180: xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache;
2181:
2182: if ((cache->booleanObjs != NULL) &&
2183: (cache->booleanObjs->number != 0))
2184: {
2185: xmlXPathObjectPtr ret;
2186:
2187: ret = (xmlXPathObjectPtr)
2188: cache->booleanObjs->items[--cache->booleanObjs->number];
2189: ret->type = XPATH_BOOLEAN;
2190: ret->boolval = (val != 0);
2191: #ifdef XP_DEBUG_OBJ_USAGE
2192: xmlXPathDebugObjUsageRequested(ctxt, XPATH_BOOLEAN);
2193: #endif
2194: return(ret);
2195: } else if ((cache->miscObjs != NULL) &&
2196: (cache->miscObjs->number != 0))
2197: {
2198: xmlXPathObjectPtr ret;
2199:
2200: ret = (xmlXPathObjectPtr)
2201: cache->miscObjs->items[--cache->miscObjs->number];
2202:
2203: ret->type = XPATH_BOOLEAN;
2204: ret->boolval = (val != 0);
2205: #ifdef XP_DEBUG_OBJ_USAGE
2206: xmlXPathDebugObjUsageRequested(ctxt, XPATH_BOOLEAN);
2207: #endif
2208: return(ret);
2209: }
2210: }
2211: return(xmlXPathNewBoolean(val));
2212: }
2213:
2214: /**
2215: * xmlXPathCacheNewFloat:
2216: * @ctxt: the XPath context
2217: * @val: the double value
2218: *
2219: * This is the cached version of xmlXPathNewFloat().
2220: * Acquires an xmlXPathObjectPtr of type double and of value @val
2221: *
2222: * Returns the created or reused object.
2223: */
2224: static xmlXPathObjectPtr
2225: xmlXPathCacheNewFloat(xmlXPathContextPtr ctxt, double val)
2226: {
2227: if ((ctxt != NULL) && (ctxt->cache)) {
2228: xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache;
2229:
2230: if ((cache->numberObjs != NULL) &&
2231: (cache->numberObjs->number != 0))
2232: {
2233: xmlXPathObjectPtr ret;
2234:
2235: ret = (xmlXPathObjectPtr)
2236: cache->numberObjs->items[--cache->numberObjs->number];
2237: ret->type = XPATH_NUMBER;
2238: ret->floatval = val;
2239: #ifdef XP_DEBUG_OBJ_USAGE
2240: xmlXPathDebugObjUsageRequested(ctxt, XPATH_NUMBER);
2241: #endif
2242: return(ret);
2243: } else if ((cache->miscObjs != NULL) &&
2244: (cache->miscObjs->number != 0))
2245: {
2246: xmlXPathObjectPtr ret;
2247:
2248: ret = (xmlXPathObjectPtr)
2249: cache->miscObjs->items[--cache->miscObjs->number];
2250:
2251: ret->type = XPATH_NUMBER;
2252: ret->floatval = val;
2253: #ifdef XP_DEBUG_OBJ_USAGE
2254: xmlXPathDebugObjUsageRequested(ctxt, XPATH_NUMBER);
2255: #endif
2256: return(ret);
2257: }
2258: }
2259: return(xmlXPathNewFloat(val));
2260: }
2261:
2262: /**
2263: * xmlXPathCacheConvertString:
2264: * @ctxt: the XPath context
2265: * @val: an XPath object
2266: *
2267: * This is the cached version of xmlXPathConvertString().
2268: * Converts an existing object to its string() equivalent
2269: *
2270: * Returns a created or reused object, the old one is freed (cached)
2271: * (or the operation is done directly on @val)
2272: */
2273:
2274: static xmlXPathObjectPtr
2275: xmlXPathCacheConvertString(xmlXPathContextPtr ctxt, xmlXPathObjectPtr val) {
2276: xmlChar *res = NULL;
2277:
2278: if (val == NULL)
2279: return(xmlXPathCacheNewCString(ctxt, ""));
2280:
2281: switch (val->type) {
2282: case XPATH_UNDEFINED:
2283: #ifdef DEBUG_EXPR
2284: xmlGenericError(xmlGenericErrorContext, "STRING: undefined\n");
2285: #endif
2286: break;
2287: case XPATH_NODESET:
2288: case XPATH_XSLT_TREE:
2289: res = xmlXPathCastNodeSetToString(val->nodesetval);
2290: break;
2291: case XPATH_STRING:
2292: return(val);
2293: case XPATH_BOOLEAN:
2294: res = xmlXPathCastBooleanToString(val->boolval);
2295: break;
2296: case XPATH_NUMBER:
2297: res = xmlXPathCastNumberToString(val->floatval);
2298: break;
2299: case XPATH_USERS:
2300: case XPATH_POINT:
2301: case XPATH_RANGE:
2302: case XPATH_LOCATIONSET:
2303: TODO;
2304: break;
2305: }
2306: xmlXPathReleaseObject(ctxt, val);
2307: if (res == NULL)
2308: return(xmlXPathCacheNewCString(ctxt, ""));
2309: return(xmlXPathCacheWrapString(ctxt, res));
2310: }
2311:
2312: /**
2313: * xmlXPathCacheObjectCopy:
2314: * @ctxt: the XPath context
2315: * @val: the original object
2316: *
2317: * This is the cached version of xmlXPathObjectCopy().
2318: * Acquire a copy of a given object
2319: *
2320: * Returns a created or reused created object.
2321: */
2322: static xmlXPathObjectPtr
2323: xmlXPathCacheObjectCopy(xmlXPathContextPtr ctxt, xmlXPathObjectPtr val)
2324: {
2325: if (val == NULL)
2326: return(NULL);
2327:
2328: if (XP_HAS_CACHE(ctxt)) {
2329: switch (val->type) {
2330: case XPATH_NODESET:
2331: return(xmlXPathCacheWrapNodeSet(ctxt,
2332: xmlXPathNodeSetMerge(NULL, val->nodesetval)));
2333: case XPATH_STRING:
2334: return(xmlXPathCacheNewString(ctxt, val->stringval));
2335: case XPATH_BOOLEAN:
2336: return(xmlXPathCacheNewBoolean(ctxt, val->boolval));
2337: case XPATH_NUMBER:
2338: return(xmlXPathCacheNewFloat(ctxt, val->floatval));
2339: default:
2340: break;
2341: }
2342: }
2343: return(xmlXPathObjectCopy(val));
2344: }
2345:
2346: /**
2347: * xmlXPathCacheConvertBoolean:
2348: * @ctxt: the XPath context
2349: * @val: an XPath object
2350: *
2351: * This is the cached version of xmlXPathConvertBoolean().
2352: * Converts an existing object to its boolean() equivalent
2353: *
2354: * Returns a created or reused object, the old one is freed (or the operation
2355: * is done directly on @val)
2356: */
2357: static xmlXPathObjectPtr
2358: xmlXPathCacheConvertBoolean(xmlXPathContextPtr ctxt, xmlXPathObjectPtr val) {
2359: xmlXPathObjectPtr ret;
2360:
2361: if (val == NULL)
2362: return(xmlXPathCacheNewBoolean(ctxt, 0));
2363: if (val->type == XPATH_BOOLEAN)
2364: return(val);
2365: ret = xmlXPathCacheNewBoolean(ctxt, xmlXPathCastToBoolean(val));
2366: xmlXPathReleaseObject(ctxt, val);
2367: return(ret);
2368: }
2369:
2370: /**
2371: * xmlXPathCacheConvertNumber:
2372: * @ctxt: the XPath context
2373: * @val: an XPath object
2374: *
2375: * This is the cached version of xmlXPathConvertNumber().
2376: * Converts an existing object to its number() equivalent
2377: *
2378: * Returns a created or reused object, the old one is freed (or the operation
2379: * is done directly on @val)
2380: */
2381: static xmlXPathObjectPtr
2382: xmlXPathCacheConvertNumber(xmlXPathContextPtr ctxt, xmlXPathObjectPtr val) {
2383: xmlXPathObjectPtr ret;
2384:
2385: if (val == NULL)
2386: return(xmlXPathCacheNewFloat(ctxt, 0.0));
2387: if (val->type == XPATH_NUMBER)
2388: return(val);
2389: ret = xmlXPathCacheNewFloat(ctxt, xmlXPathCastToNumber(val));
2390: xmlXPathReleaseObject(ctxt, val);
2391: return(ret);
2392: }
2393:
2394: /************************************************************************
2395: * *
2396: * Parser stacks related functions and macros *
2397: * *
2398: ************************************************************************/
2399:
2400: /**
2401: * valuePop:
2402: * @ctxt: an XPath evaluation context
2403: *
2404: * Pops the top XPath object from the value stack
2405: *
2406: * Returns the XPath object just removed
2407: */
2408: xmlXPathObjectPtr
2409: valuePop(xmlXPathParserContextPtr ctxt)
2410: {
2411: xmlXPathObjectPtr ret;
2412:
2413: if ((ctxt == NULL) || (ctxt->valueNr <= 0))
2414: return (NULL);
2415: ctxt->valueNr--;
2416: if (ctxt->valueNr > 0)
2417: ctxt->value = ctxt->valueTab[ctxt->valueNr - 1];
2418: else
2419: ctxt->value = NULL;
2420: ret = ctxt->valueTab[ctxt->valueNr];
2421: ctxt->valueTab[ctxt->valueNr] = NULL;
2422: return (ret);
2423: }
2424: /**
2425: * valuePush:
2426: * @ctxt: an XPath evaluation context
2427: * @value: the XPath object
2428: *
2429: * Pushes a new XPath object on top of the value stack
2430: *
2431: * returns the number of items on the value stack
2432: */
2433: int
2434: valuePush(xmlXPathParserContextPtr ctxt, xmlXPathObjectPtr value)
2435: {
2436: if ((ctxt == NULL) || (value == NULL)) return(-1);
2437: if (ctxt->valueNr >= ctxt->valueMax) {
2438: xmlXPathObjectPtr *tmp;
2439:
2440: tmp = (xmlXPathObjectPtr *) xmlRealloc(ctxt->valueTab,
2441: 2 * ctxt->valueMax *
2442: sizeof(ctxt->valueTab[0]));
2443: if (tmp == NULL) {
2444: xmlGenericError(xmlGenericErrorContext, "realloc failed !\n");
2445: return (0);
2446: }
2447: ctxt->valueMax *= 2;
2448: ctxt->valueTab = tmp;
2449: }
2450: ctxt->valueTab[ctxt->valueNr] = value;
2451: ctxt->value = value;
2452: return (ctxt->valueNr++);
2453: }
2454:
2455: /**
2456: * xmlXPathPopBoolean:
2457: * @ctxt: an XPath parser context
2458: *
2459: * Pops a boolean from the stack, handling conversion if needed.
2460: * Check error with #xmlXPathCheckError.
2461: *
2462: * Returns the boolean
2463: */
2464: int
2465: xmlXPathPopBoolean (xmlXPathParserContextPtr ctxt) {
2466: xmlXPathObjectPtr obj;
2467: int ret;
2468:
2469: obj = valuePop(ctxt);
2470: if (obj == NULL) {
2471: xmlXPathSetError(ctxt, XPATH_INVALID_OPERAND);
2472: return(0);
2473: }
2474: if (obj->type != XPATH_BOOLEAN)
2475: ret = xmlXPathCastToBoolean(obj);
2476: else
2477: ret = obj->boolval;
2478: xmlXPathReleaseObject(ctxt->context, obj);
2479: return(ret);
2480: }
2481:
2482: /**
2483: * xmlXPathPopNumber:
2484: * @ctxt: an XPath parser context
2485: *
2486: * Pops a number from the stack, handling conversion if needed.
2487: * Check error with #xmlXPathCheckError.
2488: *
2489: * Returns the number
2490: */
2491: double
2492: xmlXPathPopNumber (xmlXPathParserContextPtr ctxt) {
2493: xmlXPathObjectPtr obj;
2494: double ret;
2495:
2496: obj = valuePop(ctxt);
2497: if (obj == NULL) {
2498: xmlXPathSetError(ctxt, XPATH_INVALID_OPERAND);
2499: return(0);
2500: }
2501: if (obj->type != XPATH_NUMBER)
2502: ret = xmlXPathCastToNumber(obj);
2503: else
2504: ret = obj->floatval;
2505: xmlXPathReleaseObject(ctxt->context, obj);
2506: return(ret);
2507: }
2508:
2509: /**
2510: * xmlXPathPopString:
2511: * @ctxt: an XPath parser context
2512: *
2513: * Pops a string from the stack, handling conversion if needed.
2514: * Check error with #xmlXPathCheckError.
2515: *
2516: * Returns the string
2517: */
2518: xmlChar *
2519: xmlXPathPopString (xmlXPathParserContextPtr ctxt) {
2520: xmlXPathObjectPtr obj;
2521: xmlChar * ret;
2522:
2523: obj = valuePop(ctxt);
2524: if (obj == NULL) {
2525: xmlXPathSetError(ctxt, XPATH_INVALID_OPERAND);
2526: return(NULL);
2527: }
2528: ret = xmlXPathCastToString(obj); /* this does required strdup */
2529: /* TODO: needs refactoring somewhere else */
2530: if (obj->stringval == ret)
2531: obj->stringval = NULL;
2532: xmlXPathReleaseObject(ctxt->context, obj);
2533: return(ret);
2534: }
2535:
2536: /**
2537: * xmlXPathPopNodeSet:
2538: * @ctxt: an XPath parser context
2539: *
2540: * Pops a node-set from the stack, handling conversion if needed.
2541: * Check error with #xmlXPathCheckError.
2542: *
2543: * Returns the node-set
2544: */
2545: xmlNodeSetPtr
2546: xmlXPathPopNodeSet (xmlXPathParserContextPtr ctxt) {
2547: xmlXPathObjectPtr obj;
2548: xmlNodeSetPtr ret;
2549:
2550: if (ctxt == NULL) return(NULL);
2551: if (ctxt->value == NULL) {
2552: xmlXPathSetError(ctxt, XPATH_INVALID_OPERAND);
2553: return(NULL);
2554: }
2555: if (!xmlXPathStackIsNodeSet(ctxt)) {
2556: xmlXPathSetTypeError(ctxt);
2557: return(NULL);
2558: }
2559: obj = valuePop(ctxt);
2560: ret = obj->nodesetval;
2561: #if 0
2562: /* to fix memory leak of not clearing obj->user */
2563: if (obj->boolval && obj->user != NULL)
2564: xmlFreeNodeList((xmlNodePtr) obj->user);
2565: #endif
2566: obj->nodesetval = NULL;
2567: xmlXPathReleaseObject(ctxt->context, obj);
2568: return(ret);
2569: }
2570:
2571: /**
2572: * xmlXPathPopExternal:
2573: * @ctxt: an XPath parser context
2574: *
2575: * Pops an external object from the stack, handling conversion if needed.
2576: * Check error with #xmlXPathCheckError.
2577: *
2578: * Returns the object
2579: */
2580: void *
2581: xmlXPathPopExternal (xmlXPathParserContextPtr ctxt) {
2582: xmlXPathObjectPtr obj;
2583: void * ret;
2584:
2585: if ((ctxt == NULL) || (ctxt->value == NULL)) {
2586: xmlXPathSetError(ctxt, XPATH_INVALID_OPERAND);
2587: return(NULL);
2588: }
2589: if (ctxt->value->type != XPATH_USERS) {
2590: xmlXPathSetTypeError(ctxt);
2591: return(NULL);
2592: }
2593: obj = valuePop(ctxt);
2594: ret = obj->user;
2595: obj->user = NULL;
2596: xmlXPathReleaseObject(ctxt->context, obj);
2597: return(ret);
2598: }
2599:
2600: /*
2601: * Macros for accessing the content. Those should be used only by the parser,
2602: * and not exported.
2603: *
2604: * Dirty macros, i.e. one need to make assumption on the context to use them
2605: *
2606: * CUR_PTR return the current pointer to the xmlChar to be parsed.
2607: * CUR returns the current xmlChar value, i.e. a 8 bit value
2608: * in ISO-Latin or UTF-8.
2609: * This should be used internally by the parser
2610: * only to compare to ASCII values otherwise it would break when
2611: * running with UTF-8 encoding.
2612: * NXT(n) returns the n'th next xmlChar. Same as CUR is should be used only
2613: * to compare on ASCII based substring.
2614: * SKIP(n) Skip n xmlChar, and must also be used only to skip ASCII defined
2615: * strings within the parser.
2616: * CURRENT Returns the current char value, with the full decoding of
2617: * UTF-8 if we are using this mode. It returns an int.
2618: * NEXT Skip to the next character, this does the proper decoding
2619: * in UTF-8 mode. It also pop-up unfinished entities on the fly.
2620: * It returns the pointer to the current xmlChar.
2621: */
2622:
2623: #define CUR (*ctxt->cur)
2624: #define SKIP(val) ctxt->cur += (val)
2625: #define NXT(val) ctxt->cur[(val)]
2626: #define CUR_PTR ctxt->cur
2627: #define CUR_CHAR(l) xmlXPathCurrentChar(ctxt, &l)
2628:
2629: #define COPY_BUF(l,b,i,v) \
2630: if (l == 1) b[i++] = (xmlChar) v; \
2631: else i += xmlCopyChar(l,&b[i],v)
2632:
2633: #define NEXTL(l) ctxt->cur += l
2634:
2635: #define SKIP_BLANKS \
2636: while (IS_BLANK_CH(*(ctxt->cur))) NEXT
2637:
2638: #define CURRENT (*ctxt->cur)
2639: #define NEXT ((*ctxt->cur) ? ctxt->cur++: ctxt->cur)
2640:
2641:
2642: #ifndef DBL_DIG
2643: #define DBL_DIG 16
2644: #endif
2645: #ifndef DBL_EPSILON
2646: #define DBL_EPSILON 1E-9
2647: #endif
2648:
2649: #define UPPER_DOUBLE 1E9
2650: #define LOWER_DOUBLE 1E-5
2651: #define LOWER_DOUBLE_EXP 5
2652:
2653: #define INTEGER_DIGITS DBL_DIG
2654: #define FRACTION_DIGITS (DBL_DIG + 1 + (LOWER_DOUBLE_EXP))
2655: #define EXPONENT_DIGITS (3 + 2)
2656:
2657: /**
2658: * xmlXPathFormatNumber:
2659: * @number: number to format
2660: * @buffer: output buffer
2661: * @buffersize: size of output buffer
2662: *
2663: * Convert the number into a string representation.
2664: */
2665: static void
2666: xmlXPathFormatNumber(double number, char buffer[], int buffersize)
2667: {
2668: switch (xmlXPathIsInf(number)) {
2669: case 1:
2670: if (buffersize > (int)sizeof("Infinity"))
2671: snprintf(buffer, buffersize, "Infinity");
2672: break;
2673: case -1:
2674: if (buffersize > (int)sizeof("-Infinity"))
2675: snprintf(buffer, buffersize, "-Infinity");
2676: break;
2677: default:
2678: if (xmlXPathIsNaN(number)) {
2679: if (buffersize > (int)sizeof("NaN"))
2680: snprintf(buffer, buffersize, "NaN");
2681: } else if (number == 0 && xmlXPathGetSign(number) != 0) {
2682: snprintf(buffer, buffersize, "0");
2683: } else if (number == ((int) number)) {
2684: char work[30];
2685: char *ptr, *cur;
2686: int value = (int) number;
2687:
2688: ptr = &buffer[0];
2689: if (value == 0) {
2690: *ptr++ = '0';
2691: } else {
2692: snprintf(work, 29, "%d", value);
2693: cur = &work[0];
2694: while ((*cur) && (ptr - buffer < buffersize)) {
2695: *ptr++ = *cur++;
2696: }
2697: }
2698: if (ptr - buffer < buffersize) {
2699: *ptr = 0;
2700: } else if (buffersize > 0) {
2701: ptr--;
2702: *ptr = 0;
2703: }
2704: } else {
2705: /*
2706: For the dimension of work,
2707: DBL_DIG is number of significant digits
2708: EXPONENT is only needed for "scientific notation"
2709: 3 is sign, decimal point, and terminating zero
2710: LOWER_DOUBLE_EXP is max number of leading zeroes in fraction
2711: Note that this dimension is slightly (a few characters)
2712: larger than actually necessary.
2713: */
2714: char work[DBL_DIG + EXPONENT_DIGITS + 3 + LOWER_DOUBLE_EXP];
2715: int integer_place, fraction_place;
2716: char *ptr;
2717: char *after_fraction;
2718: double absolute_value;
2719: int size;
2720:
2721: absolute_value = fabs(number);
2722:
2723: /*
2724: * First choose format - scientific or regular floating point.
2725: * In either case, result is in work, and after_fraction points
2726: * just past the fractional part.
2727: */
2728: if ( ((absolute_value > UPPER_DOUBLE) ||
2729: (absolute_value < LOWER_DOUBLE)) &&
2730: (absolute_value != 0.0) ) {
2731: /* Use scientific notation */
2732: integer_place = DBL_DIG + EXPONENT_DIGITS + 1;
2733: fraction_place = DBL_DIG - 1;
2734: size = snprintf(work, sizeof(work),"%*.*e",
2735: integer_place, fraction_place, number);
2736: while ((size > 0) && (work[size] != 'e')) size--;
2737:
2738: }
2739: else {
2740: /* Use regular notation */
2741: if (absolute_value > 0.0) {
2742: integer_place = (int)log10(absolute_value);
2743: if (integer_place > 0)
2744: fraction_place = DBL_DIG - integer_place - 1;
2745: else
2746: fraction_place = DBL_DIG - integer_place;
2747: } else {
2748: fraction_place = 1;
2749: }
2750: size = snprintf(work, sizeof(work), "%0.*f",
2751: fraction_place, number);
2752: }
2753:
2754: /* Remove fractional trailing zeroes */
2755: after_fraction = work + size;
2756: ptr = after_fraction;
2757: while (*(--ptr) == '0')
2758: ;
2759: if (*ptr != '.')
2760: ptr++;
2761: while ((*ptr++ = *after_fraction++) != 0);
2762:
2763: /* Finally copy result back to caller */
2764: size = strlen(work) + 1;
2765: if (size > buffersize) {
2766: work[buffersize - 1] = 0;
2767: size = buffersize;
2768: }
2769: memmove(buffer, work, size);
2770: }
2771: break;
2772: }
2773: }
2774:
2775:
2776: /************************************************************************
2777: * *
2778: * Routines to handle NodeSets *
2779: * *
2780: ************************************************************************/
2781:
2782: /**
2783: * xmlXPathOrderDocElems:
2784: * @doc: an input document
2785: *
2786: * Call this routine to speed up XPath computation on static documents.
2787: * This stamps all the element nodes with the document order
2788: * Like for line information, the order is kept in the element->content
2789: * field, the value stored is actually - the node number (starting at -1)
2790: * to be able to differentiate from line numbers.
2791: *
2792: * Returns the number of elements found in the document or -1 in case
2793: * of error.
2794: */
2795: long
2796: xmlXPathOrderDocElems(xmlDocPtr doc) {
2797: long count = 0;
2798: xmlNodePtr cur;
2799:
2800: if (doc == NULL)
2801: return(-1);
2802: cur = doc->children;
2803: while (cur != NULL) {
2804: if (cur->type == XML_ELEMENT_NODE) {
2805: cur->content = (void *) (-(++count));
2806: if (cur->children != NULL) {
2807: cur = cur->children;
2808: continue;
2809: }
2810: }
2811: if (cur->next != NULL) {
2812: cur = cur->next;
2813: continue;
2814: }
2815: do {
2816: cur = cur->parent;
2817: if (cur == NULL)
2818: break;
2819: if (cur == (xmlNodePtr) doc) {
2820: cur = NULL;
2821: break;
2822: }
2823: if (cur->next != NULL) {
2824: cur = cur->next;
2825: break;
2826: }
2827: } while (cur != NULL);
2828: }
2829: return(count);
2830: }
2831:
2832: /**
2833: * xmlXPathCmpNodes:
2834: * @node1: the first node
2835: * @node2: the second node
2836: *
2837: * Compare two nodes w.r.t document order
2838: *
2839: * Returns -2 in case of error 1 if first point < second point, 0 if
2840: * it's the same node, -1 otherwise
2841: */
2842: int
2843: xmlXPathCmpNodes(xmlNodePtr node1, xmlNodePtr node2) {
2844: int depth1, depth2;
2845: int attr1 = 0, attr2 = 0;
2846: xmlNodePtr attrNode1 = NULL, attrNode2 = NULL;
2847: xmlNodePtr cur, root;
2848:
2849: if ((node1 == NULL) || (node2 == NULL))
2850: return(-2);
2851: /*
2852: * a couple of optimizations which will avoid computations in most cases
2853: */
2854: if (node1 == node2) /* trivial case */
2855: return(0);
2856: if (node1->type == XML_ATTRIBUTE_NODE) {
2857: attr1 = 1;
2858: attrNode1 = node1;
2859: node1 = node1->parent;
2860: }
2861: if (node2->type == XML_ATTRIBUTE_NODE) {
2862: attr2 = 1;
2863: attrNode2 = node2;
2864: node2 = node2->parent;
2865: }
2866: if (node1 == node2) {
2867: if (attr1 == attr2) {
2868: /* not required, but we keep attributes in order */
2869: if (attr1 != 0) {
2870: cur = attrNode2->prev;
2871: while (cur != NULL) {
2872: if (cur == attrNode1)
2873: return (1);
2874: cur = cur->prev;
2875: }
2876: return (-1);
2877: }
2878: return(0);
2879: }
2880: if (attr2 == 1)
2881: return(1);
2882: return(-1);
2883: }
2884: if ((node1->type == XML_NAMESPACE_DECL) ||
2885: (node2->type == XML_NAMESPACE_DECL))
2886: return(1);
2887: if (node1 == node2->prev)
2888: return(1);
2889: if (node1 == node2->next)
2890: return(-1);
2891:
2892: /*
2893: * Speedup using document order if availble.
2894: */
2895: if ((node1->type == XML_ELEMENT_NODE) &&
2896: (node2->type == XML_ELEMENT_NODE) &&
2897: (0 > (long) node1->content) &&
2898: (0 > (long) node2->content) &&
2899: (node1->doc == node2->doc)) {
2900: long l1, l2;
2901:
2902: l1 = -((long) node1->content);
2903: l2 = -((long) node2->content);
2904: if (l1 < l2)
2905: return(1);
2906: if (l1 > l2)
2907: return(-1);
2908: }
2909:
2910: /*
2911: * compute depth to root
2912: */
2913: for (depth2 = 0, cur = node2;cur->parent != NULL;cur = cur->parent) {
2914: if (cur == node1)
2915: return(1);
2916: depth2++;
2917: }
2918: root = cur;
2919: for (depth1 = 0, cur = node1;cur->parent != NULL;cur = cur->parent) {
2920: if (cur == node2)
2921: return(-1);
2922: depth1++;
2923: }
2924: /*
2925: * Distinct document (or distinct entities :-( ) case.
2926: */
2927: if (root != cur) {
2928: return(-2);
2929: }
2930: /*
2931: * get the nearest common ancestor.
2932: */
2933: while (depth1 > depth2) {
2934: depth1--;
2935: node1 = node1->parent;
2936: }
2937: while (depth2 > depth1) {
2938: depth2--;
2939: node2 = node2->parent;
2940: }
2941: while (node1->parent != node2->parent) {
2942: node1 = node1->parent;
2943: node2 = node2->parent;
2944: /* should not happen but just in case ... */
2945: if ((node1 == NULL) || (node2 == NULL))
2946: return(-2);
2947: }
2948: /*
2949: * Find who's first.
2950: */
2951: if (node1 == node2->prev)
2952: return(1);
2953: if (node1 == node2->next)
2954: return(-1);
2955: /*
2956: * Speedup using document order if availble.
2957: */
2958: if ((node1->type == XML_ELEMENT_NODE) &&
2959: (node2->type == XML_ELEMENT_NODE) &&
2960: (0 > (long) node1->content) &&
2961: (0 > (long) node2->content) &&
2962: (node1->doc == node2->doc)) {
2963: long l1, l2;
2964:
2965: l1 = -((long) node1->content);
2966: l2 = -((long) node2->content);
2967: if (l1 < l2)
2968: return(1);
2969: if (l1 > l2)
2970: return(-1);
2971: }
2972:
2973: for (cur = node1->next;cur != NULL;cur = cur->next)
2974: if (cur == node2)
2975: return(1);
2976: return(-1); /* assume there is no sibling list corruption */
2977: }
2978:
2979: #ifdef XP_OPTIMIZED_NON_ELEM_COMPARISON
2980: /**
2981: * xmlXPathCmpNodesExt:
2982: * @node1: the first node
2983: * @node2: the second node
2984: *
2985: * Compare two nodes w.r.t document order.
2986: * This one is optimized for handling of non-element nodes.
2987: *
2988: * Returns -2 in case of error 1 if first point < second point, 0 if
2989: * it's the same node, -1 otherwise
2990: */
2991: static int
2992: xmlXPathCmpNodesExt(xmlNodePtr node1, xmlNodePtr node2) {
2993: int depth1, depth2;
2994: int misc = 0, precedence1 = 0, precedence2 = 0;
2995: xmlNodePtr miscNode1 = NULL, miscNode2 = NULL;
2996: xmlNodePtr cur, root;
2997: long l1, l2;
2998:
2999: if ((node1 == NULL) || (node2 == NULL))
3000: return(-2);
3001:
3002: if (node1 == node2)
3003: return(0);
3004:
3005: /*
3006: * a couple of optimizations which will avoid computations in most cases
3007: */
3008: switch (node1->type) {
3009: case XML_ELEMENT_NODE:
3010: if (node2->type == XML_ELEMENT_NODE) {
3011: if ((0 > (long) node1->content) && /* TODO: Would a != 0 suffice here? */
3012: (0 > (long) node2->content) &&
3013: (node1->doc == node2->doc))
3014: {
3015: l1 = -((long) node1->content);
3016: l2 = -((long) node2->content);
3017: if (l1 < l2)
3018: return(1);
3019: if (l1 > l2)
3020: return(-1);
3021: } else
3022: goto turtle_comparison;
3023: }
3024: break;
3025: case XML_ATTRIBUTE_NODE:
3026: precedence1 = 1; /* element is owner */
3027: miscNode1 = node1;
3028: node1 = node1->parent;
3029: misc = 1;
3030: break;
3031: case XML_TEXT_NODE:
3032: case XML_CDATA_SECTION_NODE:
3033: case XML_COMMENT_NODE:
3034: case XML_PI_NODE: {
3035: miscNode1 = node1;
3036: /*
3037: * Find nearest element node.
3038: */
3039: if (node1->prev != NULL) {
3040: do {
3041: node1 = node1->prev;
3042: if (node1->type == XML_ELEMENT_NODE) {
3043: precedence1 = 3; /* element in prev-sibl axis */
3044: break;
3045: }
3046: if (node1->prev == NULL) {
3047: precedence1 = 2; /* element is parent */
3048: /*
3049: * URGENT TODO: Are there any cases, where the
3050: * parent of such a node is not an element node?
3051: */
3052: node1 = node1->parent;
3053: break;
3054: }
3055: } while (1);
3056: } else {
3057: precedence1 = 2; /* element is parent */
3058: node1 = node1->parent;
3059: }
3060: if ((node1 == NULL) || (node1->type != XML_ELEMENT_NODE) ||
3061: (0 <= (long) node1->content)) {
3062: /*
3063: * Fallback for whatever case.
3064: */
3065: node1 = miscNode1;
3066: precedence1 = 0;
3067: } else
3068: misc = 1;
3069: }
3070: break;
3071: case XML_NAMESPACE_DECL:
3072: /*
3073: * TODO: why do we return 1 for namespace nodes?
3074: */
3075: return(1);
3076: default:
3077: break;
3078: }
3079: switch (node2->type) {
3080: case XML_ELEMENT_NODE:
3081: break;
3082: case XML_ATTRIBUTE_NODE:
3083: precedence2 = 1; /* element is owner */
3084: miscNode2 = node2;
3085: node2 = node2->parent;
3086: misc = 1;
3087: break;
3088: case XML_TEXT_NODE:
3089: case XML_CDATA_SECTION_NODE:
3090: case XML_COMMENT_NODE:
3091: case XML_PI_NODE: {
3092: miscNode2 = node2;
3093: if (node2->prev != NULL) {
3094: do {
3095: node2 = node2->prev;
3096: if (node2->type == XML_ELEMENT_NODE) {
3097: precedence2 = 3; /* element in prev-sibl axis */
3098: break;
3099: }
3100: if (node2->prev == NULL) {
3101: precedence2 = 2; /* element is parent */
3102: node2 = node2->parent;
3103: break;
3104: }
3105: } while (1);
3106: } else {
3107: precedence2 = 2; /* element is parent */
3108: node2 = node2->parent;
3109: }
3110: if ((node2 == NULL) || (node2->type != XML_ELEMENT_NODE) ||
3111: (0 <= (long) node1->content))
3112: {
3113: node2 = miscNode2;
3114: precedence2 = 0;
3115: } else
3116: misc = 1;
3117: }
3118: break;
3119: case XML_NAMESPACE_DECL:
3120: return(1);
3121: default:
3122: break;
3123: }
3124: if (misc) {
3125: if (node1 == node2) {
3126: if (precedence1 == precedence2) {
3127: /*
3128: * The ugly case; but normally there aren't many
3129: * adjacent non-element nodes around.
3130: */
3131: cur = miscNode2->prev;
3132: while (cur != NULL) {
3133: if (cur == miscNode1)
3134: return(1);
3135: if (cur->type == XML_ELEMENT_NODE)
3136: return(-1);
3137: cur = cur->prev;
3138: }
3139: return (-1);
3140: } else {
3141: /*
3142: * Evaluate based on higher precedence wrt to the element.
3143: * TODO: This assumes attributes are sorted before content.
3144: * Is this 100% correct?
3145: */
3146: if (precedence1 < precedence2)
3147: return(1);
3148: else
3149: return(-1);
3150: }
3151: }
3152: /*
3153: * Special case: One of the helper-elements is contained by the other.
3154: * <foo>
3155: * <node2>
3156: * <node1>Text-1(precedence1 == 2)</node1>
3157: * </node2>
3158: * Text-6(precedence2 == 3)
3159: * </foo>
3160: */
3161: if ((precedence2 == 3) && (precedence1 > 1)) {
3162: cur = node1->parent;
3163: while (cur) {
3164: if (cur == node2)
3165: return(1);
3166: cur = cur->parent;
3167: }
3168: }
3169: if ((precedence1 == 3) && (precedence2 > 1)) {
3170: cur = node2->parent;
3171: while (cur) {
3172: if (cur == node1)
3173: return(-1);
3174: cur = cur->parent;
3175: }
3176: }
3177: }
3178:
3179: /*
3180: * Speedup using document order if availble.
3181: */
3182: if ((node1->type == XML_ELEMENT_NODE) &&
3183: (node2->type == XML_ELEMENT_NODE) &&
3184: (0 > (long) node1->content) &&
3185: (0 > (long) node2->content) &&
3186: (node1->doc == node2->doc)) {
3187:
3188: l1 = -((long) node1->content);
3189: l2 = -((long) node2->content);
3190: if (l1 < l2)
3191: return(1);
3192: if (l1 > l2)
3193: return(-1);
3194: }
3195:
3196: turtle_comparison:
3197:
3198: if (node1 == node2->prev)
3199: return(1);
3200: if (node1 == node2->next)
3201: return(-1);
3202: /*
3203: * compute depth to root
3204: */
3205: for (depth2 = 0, cur = node2;cur->parent != NULL;cur = cur->parent) {
3206: if (cur == node1)
3207: return(1);
3208: depth2++;
3209: }
3210: root = cur;
3211: for (depth1 = 0, cur = node1;cur->parent != NULL;cur = cur->parent) {
3212: if (cur == node2)
3213: return(-1);
3214: depth1++;
3215: }
3216: /*
3217: * Distinct document (or distinct entities :-( ) case.
3218: */
3219: if (root != cur) {
3220: return(-2);
3221: }
3222: /*
3223: * get the nearest common ancestor.
3224: */
3225: while (depth1 > depth2) {
3226: depth1--;
3227: node1 = node1->parent;
3228: }
3229: while (depth2 > depth1) {
3230: depth2--;
3231: node2 = node2->parent;
3232: }
3233: while (node1->parent != node2->parent) {
3234: node1 = node1->parent;
3235: node2 = node2->parent;
3236: /* should not happen but just in case ... */
3237: if ((node1 == NULL) || (node2 == NULL))
3238: return(-2);
3239: }
3240: /*
3241: * Find who's first.
3242: */
3243: if (node1 == node2->prev)
3244: return(1);
3245: if (node1 == node2->next)
3246: return(-1);
3247: /*
3248: * Speedup using document order if availble.
3249: */
3250: if ((node1->type == XML_ELEMENT_NODE) &&
3251: (node2->type == XML_ELEMENT_NODE) &&
3252: (0 > (long) node1->content) &&
3253: (0 > (long) node2->content) &&
3254: (node1->doc == node2->doc)) {
3255:
3256: l1 = -((long) node1->content);
3257: l2 = -((long) node2->content);
3258: if (l1 < l2)
3259: return(1);
3260: if (l1 > l2)
3261: return(-1);
3262: }
3263:
3264: for (cur = node1->next;cur != NULL;cur = cur->next)
3265: if (cur == node2)
3266: return(1);
3267: return(-1); /* assume there is no sibling list corruption */
3268: }
3269: #endif /* XP_OPTIMIZED_NON_ELEM_COMPARISON */
3270:
3271: /**
3272: * xmlXPathNodeSetSort:
3273: * @set: the node set
3274: *
3275: * Sort the node set in document order
3276: */
3277: void
3278: xmlXPathNodeSetSort(xmlNodeSetPtr set) {
3279: int i, j, incr, len;
3280: xmlNodePtr tmp;
3281:
3282: if (set == NULL)
3283: return;
3284:
3285: /* Use Shell's sort to sort the node-set */
3286: len = set->nodeNr;
3287: for (incr = len / 2; incr > 0; incr /= 2) {
3288: for (i = incr; i < len; i++) {
3289: j = i - incr;
3290: while (j >= 0) {
3291: #ifdef XP_OPTIMIZED_NON_ELEM_COMPARISON
3292: if (xmlXPathCmpNodesExt(set->nodeTab[j],
3293: set->nodeTab[j + incr]) == -1)
3294: #else
3295: if (xmlXPathCmpNodes(set->nodeTab[j],
3296: set->nodeTab[j + incr]) == -1)
3297: #endif
3298: {
3299: tmp = set->nodeTab[j];
3300: set->nodeTab[j] = set->nodeTab[j + incr];
3301: set->nodeTab[j + incr] = tmp;
3302: j -= incr;
3303: } else
3304: break;
3305: }
3306: }
3307: }
3308: }
3309:
3310: #define XML_NODESET_DEFAULT 10
3311: /**
3312: * xmlXPathNodeSetDupNs:
3313: * @node: the parent node of the namespace XPath node
3314: * @ns: the libxml namespace declaration node.
3315: *
3316: * Namespace node in libxml don't match the XPath semantic. In a node set
3317: * the namespace nodes are duplicated and the next pointer is set to the
3318: * parent node in the XPath semantic.
3319: *
3320: * Returns the newly created object.
3321: */
3322: static xmlNodePtr
3323: xmlXPathNodeSetDupNs(xmlNodePtr node, xmlNsPtr ns) {
3324: xmlNsPtr cur;
3325:
3326: if ((ns == NULL) || (ns->type != XML_NAMESPACE_DECL))
3327: return(NULL);
3328: if ((node == NULL) || (node->type == XML_NAMESPACE_DECL))
3329: return((xmlNodePtr) ns);
3330:
3331: /*
3332: * Allocate a new Namespace and fill the fields.
3333: */
3334: cur = (xmlNsPtr) xmlMalloc(sizeof(xmlNs));
3335: if (cur == NULL) {
3336: xmlXPathErrMemory(NULL, "duplicating namespace\n");
3337: return(NULL);
3338: }
3339: memset(cur, 0, sizeof(xmlNs));
3340: cur->type = XML_NAMESPACE_DECL;
3341: if (ns->href != NULL)
3342: cur->href = xmlStrdup(ns->href);
3343: if (ns->prefix != NULL)
3344: cur->prefix = xmlStrdup(ns->prefix);
3345: cur->next = (xmlNsPtr) node;
3346: return((xmlNodePtr) cur);
3347: }
3348:
3349: /**
3350: * xmlXPathNodeSetFreeNs:
3351: * @ns: the XPath namespace node found in a nodeset.
3352: *
3353: * Namespace nodes in libxml don't match the XPath semantic. In a node set
3354: * the namespace nodes are duplicated and the next pointer is set to the
3355: * parent node in the XPath semantic. Check if such a node needs to be freed
3356: */
3357: void
3358: xmlXPathNodeSetFreeNs(xmlNsPtr ns) {
3359: if ((ns == NULL) || (ns->type != XML_NAMESPACE_DECL))
3360: return;
3361:
3362: if ((ns->next != NULL) && (ns->next->type != XML_NAMESPACE_DECL)) {
3363: if (ns->href != NULL)
3364: xmlFree((xmlChar *)ns->href);
3365: if (ns->prefix != NULL)
3366: xmlFree((xmlChar *)ns->prefix);
3367: xmlFree(ns);
3368: }
3369: }
3370:
3371: /**
3372: * xmlXPathNodeSetCreate:
3373: * @val: an initial xmlNodePtr, or NULL
3374: *
3375: * Create a new xmlNodeSetPtr of type double and of value @val
3376: *
3377: * Returns the newly created object.
3378: */
3379: xmlNodeSetPtr
3380: xmlXPathNodeSetCreate(xmlNodePtr val) {
3381: xmlNodeSetPtr ret;
3382:
3383: ret = (xmlNodeSetPtr) xmlMalloc(sizeof(xmlNodeSet));
3384: if (ret == NULL) {
3385: xmlXPathErrMemory(NULL, "creating nodeset\n");
3386: return(NULL);
3387: }
3388: memset(ret, 0 , (size_t) sizeof(xmlNodeSet));
3389: if (val != NULL) {
3390: ret->nodeTab = (xmlNodePtr *) xmlMalloc(XML_NODESET_DEFAULT *
3391: sizeof(xmlNodePtr));
3392: if (ret->nodeTab == NULL) {
3393: xmlXPathErrMemory(NULL, "creating nodeset\n");
3394: xmlFree(ret);
3395: return(NULL);
3396: }
3397: memset(ret->nodeTab, 0 ,
3398: XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
3399: ret->nodeMax = XML_NODESET_DEFAULT;
3400: if (val->type == XML_NAMESPACE_DECL) {
3401: xmlNsPtr ns = (xmlNsPtr) val;
3402:
3403: ret->nodeTab[ret->nodeNr++] =
3404: xmlXPathNodeSetDupNs((xmlNodePtr) ns->next, ns);
3405: } else
3406: ret->nodeTab[ret->nodeNr++] = val;
3407: }
3408: return(ret);
3409: }
3410:
3411: /**
3412: * xmlXPathNodeSetCreateSize:
3413: * @size: the initial size of the set
3414: *
3415: * Create a new xmlNodeSetPtr of type double and of value @val
3416: *
3417: * Returns the newly created object.
3418: */
3419: static xmlNodeSetPtr
3420: xmlXPathNodeSetCreateSize(int size) {
3421: xmlNodeSetPtr ret;
3422:
3423: ret = (xmlNodeSetPtr) xmlMalloc(sizeof(xmlNodeSet));
3424: if (ret == NULL) {
3425: xmlXPathErrMemory(NULL, "creating nodeset\n");
3426: return(NULL);
3427: }
3428: memset(ret, 0 , (size_t) sizeof(xmlNodeSet));
3429: if (size < XML_NODESET_DEFAULT)
3430: size = XML_NODESET_DEFAULT;
3431: ret->nodeTab = (xmlNodePtr *) xmlMalloc(size * sizeof(xmlNodePtr));
3432: if (ret->nodeTab == NULL) {
3433: xmlXPathErrMemory(NULL, "creating nodeset\n");
3434: xmlFree(ret);
3435: return(NULL);
3436: }
3437: memset(ret->nodeTab, 0 , size * (size_t) sizeof(xmlNodePtr));
3438: ret->nodeMax = size;
3439: return(ret);
3440: }
3441:
3442: /**
3443: * xmlXPathNodeSetContains:
3444: * @cur: the node-set
3445: * @val: the node
3446: *
3447: * checks whether @cur contains @val
3448: *
3449: * Returns true (1) if @cur contains @val, false (0) otherwise
3450: */
3451: int
3452: xmlXPathNodeSetContains (xmlNodeSetPtr cur, xmlNodePtr val) {
3453: int i;
3454:
3455: if ((cur == NULL) || (val == NULL)) return(0);
3456: if (val->type == XML_NAMESPACE_DECL) {
3457: for (i = 0; i < cur->nodeNr; i++) {
3458: if (cur->nodeTab[i]->type == XML_NAMESPACE_DECL) {
3459: xmlNsPtr ns1, ns2;
3460:
3461: ns1 = (xmlNsPtr) val;
3462: ns2 = (xmlNsPtr) cur->nodeTab[i];
3463: if (ns1 == ns2)
3464: return(1);
3465: if ((ns1->next != NULL) && (ns2->next == ns1->next) &&
3466: (xmlStrEqual(ns1->prefix, ns2->prefix)))
3467: return(1);
3468: }
3469: }
3470: } else {
3471: for (i = 0; i < cur->nodeNr; i++) {
3472: if (cur->nodeTab[i] == val)
3473: return(1);
3474: }
3475: }
3476: return(0);
3477: }
3478:
3479: /**
3480: * xmlXPathNodeSetAddNs:
3481: * @cur: the initial node set
3482: * @node: the hosting node
3483: * @ns: a the namespace node
3484: *
3485: * add a new namespace node to an existing NodeSet
3486: */
3487: void
3488: xmlXPathNodeSetAddNs(xmlNodeSetPtr cur, xmlNodePtr node, xmlNsPtr ns) {
3489: int i;
3490:
3491:
3492: if ((cur == NULL) || (ns == NULL) || (node == NULL) ||
3493: (ns->type != XML_NAMESPACE_DECL) ||
3494: (node->type != XML_ELEMENT_NODE))
3495: return;
3496:
3497: /* @@ with_ns to check whether namespace nodes should be looked at @@ */
3498: /*
3499: * prevent duplicates
3500: */
3501: for (i = 0;i < cur->nodeNr;i++) {
3502: if ((cur->nodeTab[i] != NULL) &&
3503: (cur->nodeTab[i]->type == XML_NAMESPACE_DECL) &&
3504: (((xmlNsPtr)cur->nodeTab[i])->next == (xmlNsPtr) node) &&
3505: (xmlStrEqual(ns->prefix, ((xmlNsPtr)cur->nodeTab[i])->prefix)))
3506: return;
3507: }
3508:
3509: /*
3510: * grow the nodeTab if needed
3511: */
3512: if (cur->nodeMax == 0) {
3513: cur->nodeTab = (xmlNodePtr *) xmlMalloc(XML_NODESET_DEFAULT *
3514: sizeof(xmlNodePtr));
3515: if (cur->nodeTab == NULL) {
3516: xmlXPathErrMemory(NULL, "growing nodeset\n");
3517: return;
3518: }
3519: memset(cur->nodeTab, 0 ,
3520: XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
3521: cur->nodeMax = XML_NODESET_DEFAULT;
3522: } else if (cur->nodeNr == cur->nodeMax) {
3523: xmlNodePtr *temp;
3524:
3525: cur->nodeMax *= 2;
3526: temp = (xmlNodePtr *) xmlRealloc(cur->nodeTab, cur->nodeMax *
3527: sizeof(xmlNodePtr));
3528: if (temp == NULL) {
3529: xmlXPathErrMemory(NULL, "growing nodeset\n");
3530: return;
3531: }
3532: cur->nodeTab = temp;
3533: }
3534: cur->nodeTab[cur->nodeNr++] = xmlXPathNodeSetDupNs(node, ns);
3535: }
3536:
3537: /**
3538: * xmlXPathNodeSetAdd:
3539: * @cur: the initial node set
3540: * @val: a new xmlNodePtr
3541: *
3542: * add a new xmlNodePtr to an existing NodeSet
3543: */
3544: void
3545: xmlXPathNodeSetAdd(xmlNodeSetPtr cur, xmlNodePtr val) {
3546: int i;
3547:
3548: if ((cur == NULL) || (val == NULL)) return;
3549:
3550: #if 0
3551: if ((val->type == XML_ELEMENT_NODE) && (val->name[0] == ' '))
3552: return; /* an XSLT fake node */
3553: #endif
3554:
3555: /* @@ with_ns to check whether namespace nodes should be looked at @@ */
3556: /*
3557: * prevent duplcates
3558: */
3559: for (i = 0;i < cur->nodeNr;i++)
3560: if (cur->nodeTab[i] == val) return;
3561:
3562: /*
3563: * grow the nodeTab if needed
3564: */
3565: if (cur->nodeMax == 0) {
3566: cur->nodeTab = (xmlNodePtr *) xmlMalloc(XML_NODESET_DEFAULT *
3567: sizeof(xmlNodePtr));
3568: if (cur->nodeTab == NULL) {
3569: xmlXPathErrMemory(NULL, "growing nodeset\n");
3570: return;
3571: }
3572: memset(cur->nodeTab, 0 ,
3573: XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
3574: cur->nodeMax = XML_NODESET_DEFAULT;
3575: } else if (cur->nodeNr == cur->nodeMax) {
3576: xmlNodePtr *temp;
3577:
3578: cur->nodeMax *= 2;
3579: temp = (xmlNodePtr *) xmlRealloc(cur->nodeTab, cur->nodeMax *
3580: sizeof(xmlNodePtr));
3581: if (temp == NULL) {
3582: xmlXPathErrMemory(NULL, "growing nodeset\n");
3583: return;
3584: }
3585: cur->nodeTab = temp;
3586: }
3587: if (val->type == XML_NAMESPACE_DECL) {
3588: xmlNsPtr ns = (xmlNsPtr) val;
3589:
3590: cur->nodeTab[cur->nodeNr++] =
3591: xmlXPathNodeSetDupNs((xmlNodePtr) ns->next, ns);
3592: } else
3593: cur->nodeTab[cur->nodeNr++] = val;
3594: }
3595:
3596: /**
3597: * xmlXPathNodeSetAddUnique:
3598: * @cur: the initial node set
3599: * @val: a new xmlNodePtr
3600: *
3601: * add a new xmlNodePtr to an existing NodeSet, optimized version
3602: * when we are sure the node is not already in the set.
3603: */
3604: void
3605: xmlXPathNodeSetAddUnique(xmlNodeSetPtr cur, xmlNodePtr val) {
3606: if ((cur == NULL) || (val == NULL)) return;
3607:
3608: #if 0
3609: if ((val->type == XML_ELEMENT_NODE) && (val->name[0] == ' '))
3610: return; /* an XSLT fake node */
3611: #endif
3612:
3613: /* @@ with_ns to check whether namespace nodes should be looked at @@ */
3614: /*
3615: * grow the nodeTab if needed
3616: */
3617: if (cur->nodeMax == 0) {
3618: cur->nodeTab = (xmlNodePtr *) xmlMalloc(XML_NODESET_DEFAULT *
3619: sizeof(xmlNodePtr));
3620: if (cur->nodeTab == NULL) {
3621: xmlXPathErrMemory(NULL, "growing nodeset\n");
3622: return;
3623: }
3624: memset(cur->nodeTab, 0 ,
3625: XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
3626: cur->nodeMax = XML_NODESET_DEFAULT;
3627: } else if (cur->nodeNr == cur->nodeMax) {
3628: xmlNodePtr *temp;
3629:
3630: cur->nodeMax *= 2;
3631: temp = (xmlNodePtr *) xmlRealloc(cur->nodeTab, cur->nodeMax *
3632: sizeof(xmlNodePtr));
3633: if (temp == NULL) {
3634: xmlXPathErrMemory(NULL, "growing nodeset\n");
3635: return;
3636: }
3637: cur->nodeTab = temp;
3638: }
3639: if (val->type == XML_NAMESPACE_DECL) {
3640: xmlNsPtr ns = (xmlNsPtr) val;
3641:
3642: cur->nodeTab[cur->nodeNr++] =
3643: xmlXPathNodeSetDupNs((xmlNodePtr) ns->next, ns);
3644: } else
3645: cur->nodeTab[cur->nodeNr++] = val;
3646: }
3647:
3648: /**
3649: * xmlXPathNodeSetMerge:
3650: * @val1: the first NodeSet or NULL
3651: * @val2: the second NodeSet
3652: *
3653: * Merges two nodesets, all nodes from @val2 are added to @val1
3654: * if @val1 is NULL, a new set is created and copied from @val2
3655: *
3656: * Returns @val1 once extended or NULL in case of error.
3657: */
3658: xmlNodeSetPtr
3659: xmlXPathNodeSetMerge(xmlNodeSetPtr val1, xmlNodeSetPtr val2) {
3660: int i, j, initNr, skip;
3661: xmlNodePtr n1, n2;
3662:
3663: if (val2 == NULL) return(val1);
3664: if (val1 == NULL) {
3665: val1 = xmlXPathNodeSetCreate(NULL);
3666: if (val1 == NULL)
3667: return (NULL);
3668: #if 0
3669: /*
3670: * TODO: The optimization won't work in every case, since
3671: * those nasty namespace nodes need to be added with
3672: * xmlXPathNodeSetDupNs() to the set; thus a pure
3673: * memcpy is not possible.
3674: * If there was a flag on the nodesetval, indicating that
3675: * some temporary nodes are in, that would be helpfull.
3676: */
3677: /*
3678: * Optimization: Create an equally sized node-set
3679: * and memcpy the content.
3680: */
3681: val1 = xmlXPathNodeSetCreateSize(val2->nodeNr);
3682: if (val1 == NULL)
3683: return(NULL);
3684: if (val2->nodeNr != 0) {
3685: if (val2->nodeNr == 1)
3686: *(val1->nodeTab) = *(val2->nodeTab);
3687: else {
3688: memcpy(val1->nodeTab, val2->nodeTab,
3689: val2->nodeNr * sizeof(xmlNodePtr));
3690: }
3691: val1->nodeNr = val2->nodeNr;
3692: }
3693: return(val1);
3694: #endif
3695: }
3696:
3697: /* @@ with_ns to check whether namespace nodes should be looked at @@ */
3698: initNr = val1->nodeNr;
3699:
3700: for (i = 0;i < val2->nodeNr;i++) {
3701: n2 = val2->nodeTab[i];
3702: /*
3703: * check against duplicates
3704: */
3705: skip = 0;
3706: for (j = 0; j < initNr; j++) {
3707: n1 = val1->nodeTab[j];
3708: if (n1 == n2) {
3709: skip = 1;
3710: break;
3711: } else if ((n1->type == XML_NAMESPACE_DECL) &&
3712: (n2->type == XML_NAMESPACE_DECL)) {
3713: if ((((xmlNsPtr) n1)->next == ((xmlNsPtr) n2)->next) &&
3714: (xmlStrEqual(((xmlNsPtr) n1)->prefix,
3715: ((xmlNsPtr) n2)->prefix)))
3716: {
3717: skip = 1;
3718: break;
3719: }
3720: }
3721: }
3722: if (skip)
3723: continue;
3724:
3725: /*
3726: * grow the nodeTab if needed
3727: */
3728: if (val1->nodeMax == 0) {
3729: val1->nodeTab = (xmlNodePtr *) xmlMalloc(XML_NODESET_DEFAULT *
3730: sizeof(xmlNodePtr));
3731: if (val1->nodeTab == NULL) {
3732: xmlXPathErrMemory(NULL, "merging nodeset\n");
3733: return(NULL);
3734: }
3735: memset(val1->nodeTab, 0 ,
3736: XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
3737: val1->nodeMax = XML_NODESET_DEFAULT;
3738: } else if (val1->nodeNr == val1->nodeMax) {
3739: xmlNodePtr *temp;
3740:
3741: val1->nodeMax *= 2;
3742: temp = (xmlNodePtr *) xmlRealloc(val1->nodeTab, val1->nodeMax *
3743: sizeof(xmlNodePtr));
3744: if (temp == NULL) {
3745: xmlXPathErrMemory(NULL, "merging nodeset\n");
3746: return(NULL);
3747: }
3748: val1->nodeTab = temp;
3749: }
3750: if (n2->type == XML_NAMESPACE_DECL) {
3751: xmlNsPtr ns = (xmlNsPtr) n2;
3752:
3753: val1->nodeTab[val1->nodeNr++] =
3754: xmlXPathNodeSetDupNs((xmlNodePtr) ns->next, ns);
3755: } else
3756: val1->nodeTab[val1->nodeNr++] = n2;
3757: }
3758:
3759: return(val1);
3760: }
3761:
3762: #if 0 /* xmlXPathNodeSetMergeUnique() is currently not used anymore */
3763: /**
3764: * xmlXPathNodeSetMergeUnique:
3765: * @val1: the first NodeSet or NULL
3766: * @val2: the second NodeSet
3767: *
3768: * Merges two nodesets, all nodes from @val2 are added to @val1
3769: * if @val1 is NULL, a new set is created and copied from @val2
3770: *
3771: * Returns @val1 once extended or NULL in case of error.
3772: */
3773: static xmlNodeSetPtr
3774: xmlXPathNodeSetMergeUnique(xmlNodeSetPtr val1, xmlNodeSetPtr val2) {
3775: int i;
3776:
3777: if (val2 == NULL) return(val1);
3778: if (val1 == NULL) {
3779: val1 = xmlXPathNodeSetCreate(NULL);
3780: }
3781: if (val1 == NULL)
3782: return (NULL);
3783:
3784: /* @@ with_ns to check whether namespace nodes should be looked at @@ */
3785:
3786: for (i = 0;i < val2->nodeNr;i++) {
3787: /*
3788: * grow the nodeTab if needed
3789: */
3790: if (val1->nodeMax == 0) {
3791: val1->nodeTab = (xmlNodePtr *) xmlMalloc(XML_NODESET_DEFAULT *
3792: sizeof(xmlNodePtr));
3793: if (val1->nodeTab == NULL) {
3794: xmlXPathErrMemory(NULL, "merging nodeset\n");
3795: return(NULL);
3796: }
3797: memset(val1->nodeTab, 0 ,
3798: XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
3799: val1->nodeMax = XML_NODESET_DEFAULT;
3800: } else if (val1->nodeNr == val1->nodeMax) {
3801: xmlNodePtr *temp;
3802:
3803: val1->nodeMax *= 2;
3804: temp = (xmlNodePtr *) xmlRealloc(val1->nodeTab, val1->nodeMax *
3805: sizeof(xmlNodePtr));
3806: if (temp == NULL) {
3807: xmlXPathErrMemory(NULL, "merging nodeset\n");
3808: return(NULL);
3809: }
3810: val1->nodeTab = temp;
3811: }
3812: if (val2->nodeTab[i]->type == XML_NAMESPACE_DECL) {
3813: xmlNsPtr ns = (xmlNsPtr) val2->nodeTab[i];
3814:
3815: val1->nodeTab[val1->nodeNr++] =
3816: xmlXPathNodeSetDupNs((xmlNodePtr) ns->next, ns);
3817: } else
3818: val1->nodeTab[val1->nodeNr++] = val2->nodeTab[i];
3819: }
3820:
3821: return(val1);
3822: }
3823: #endif /* xmlXPathNodeSetMergeUnique() is currently not used anymore */
3824:
3825: /**
3826: * xmlXPathNodeSetMergeAndClear:
3827: * @set1: the first NodeSet or NULL
3828: * @set2: the second NodeSet
3829: * @hasSet2NsNodes: 1 if set2 contains namespaces nodes
3830: *
3831: * Merges two nodesets, all nodes from @set2 are added to @set1
3832: * if @set1 is NULL, a new set is created and copied from @set2.
3833: * Checks for duplicate nodes. Clears set2.
3834: *
3835: * Returns @set1 once extended or NULL in case of error.
3836: */
3837: static xmlNodeSetPtr
3838: xmlXPathNodeSetMergeAndClear(xmlNodeSetPtr set1, xmlNodeSetPtr set2,
3839: int hasNullEntries)
3840: {
3841: if ((set1 == NULL) && (hasNullEntries == 0)) {
3842: /*
3843: * Note that doing a memcpy of the list, namespace nodes are
3844: * just assigned to set1, since set2 is cleared anyway.
3845: */
3846: set1 = xmlXPathNodeSetCreateSize(set2->nodeNr);
3847: if (set1 == NULL)
3848: return(NULL);
3849: if (set2->nodeNr != 0) {
3850: memcpy(set1->nodeTab, set2->nodeTab,
3851: set2->nodeNr * sizeof(xmlNodePtr));
3852: set1->nodeNr = set2->nodeNr;
3853: }
3854: } else {
3855: int i, j, initNbSet1;
3856: xmlNodePtr n1, n2;
3857:
3858: if (set1 == NULL)
3859: set1 = xmlXPathNodeSetCreate(NULL);
3860: if (set1 == NULL)
3861: return (NULL);
3862:
3863: initNbSet1 = set1->nodeNr;
3864: for (i = 0;i < set2->nodeNr;i++) {
3865: n2 = set2->nodeTab[i];
3866: /*
3867: * Skip NULLed entries.
3868: */
3869: if (n2 == NULL)
3870: continue;
3871: /*
3872: * Skip duplicates.
3873: */
3874: for (j = 0; j < initNbSet1; j++) {
3875: n1 = set1->nodeTab[j];
3876: if (n1 == n2) {
3877: goto skip_node;
3878: } else if ((n1->type == XML_NAMESPACE_DECL) &&
3879: (n2->type == XML_NAMESPACE_DECL))
3880: {
3881: if ((((xmlNsPtr) n1)->next == ((xmlNsPtr) n2)->next) &&
3882: (xmlStrEqual(((xmlNsPtr) n1)->prefix,
3883: ((xmlNsPtr) n2)->prefix)))
3884: {
3885: /*
3886: * Free the namespace node.
3887: */
3888: set2->nodeTab[i] = NULL;
3889: xmlXPathNodeSetFreeNs((xmlNsPtr) n2);
3890: goto skip_node;
3891: }
3892: }
3893: }
3894: /*
3895: * grow the nodeTab if needed
3896: */
3897: if (set1->nodeMax == 0) {
3898: set1->nodeTab = (xmlNodePtr *) xmlMalloc(
3899: XML_NODESET_DEFAULT * sizeof(xmlNodePtr));
3900: if (set1->nodeTab == NULL) {
3901: xmlXPathErrMemory(NULL, "merging nodeset\n");
3902: return(NULL);
3903: }
3904: memset(set1->nodeTab, 0,
3905: XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
3906: set1->nodeMax = XML_NODESET_DEFAULT;
3907: } else if (set1->nodeNr >= set1->nodeMax) {
3908: xmlNodePtr *temp;
3909:
3910: set1->nodeMax *= 2;
3911: temp = (xmlNodePtr *) xmlRealloc(
3912: set1->nodeTab, set1->nodeMax * sizeof(xmlNodePtr));
3913: if (temp == NULL) {
3914: xmlXPathErrMemory(NULL, "merging nodeset\n");
3915: return(NULL);
3916: }
3917: set1->nodeTab = temp;
3918: }
3919: if (n2->type == XML_NAMESPACE_DECL) {
3920: xmlNsPtr ns = (xmlNsPtr) n2;
3921:
3922: set1->nodeTab[set1->nodeNr++] =
3923: xmlXPathNodeSetDupNs((xmlNodePtr) ns->next, ns);
3924: } else
3925: set1->nodeTab[set1->nodeNr++] = n2;
3926: skip_node:
3927: {}
3928: }
3929: }
3930: set2->nodeNr = 0;
3931: return(set1);
3932: }
3933:
3934: /**
3935: * xmlXPathNodeSetMergeAndClearNoDupls:
3936: * @set1: the first NodeSet or NULL
3937: * @set2: the second NodeSet
3938: * @hasSet2NsNodes: 1 if set2 contains namespaces nodes
3939: *
3940: * Merges two nodesets, all nodes from @set2 are added to @set1
3941: * if @set1 is NULL, a new set is created and copied from @set2.
3942: * Doesn't chack for duplicate nodes. Clears set2.
3943: *
3944: * Returns @set1 once extended or NULL in case of error.
3945: */
3946: static xmlNodeSetPtr
3947: xmlXPathNodeSetMergeAndClearNoDupls(xmlNodeSetPtr set1, xmlNodeSetPtr set2,
3948: int hasNullEntries)
3949: {
3950: if (set2 == NULL)
3951: return(set1);
3952: if ((set1 == NULL) && (hasNullEntries == 0)) {
3953: /*
3954: * Note that doing a memcpy of the list, namespace nodes are
3955: * just assigned to set1, since set2 is cleared anyway.
3956: */
3957: set1 = xmlXPathNodeSetCreateSize(set2->nodeNr);
3958: if (set1 == NULL)
3959: return(NULL);
3960: if (set2->nodeNr != 0) {
3961: memcpy(set1->nodeTab, set2->nodeTab,
3962: set2->nodeNr * sizeof(xmlNodePtr));
3963: set1->nodeNr = set2->nodeNr;
3964: }
3965: } else {
3966: int i;
3967: xmlNodePtr n2;
3968:
3969: if (set1 == NULL)
3970: set1 = xmlXPathNodeSetCreate(NULL);
3971: if (set1 == NULL)
3972: return (NULL);
3973:
3974: for (i = 0;i < set2->nodeNr;i++) {
3975: n2 = set2->nodeTab[i];
3976: /*
3977: * Skip NULLed entries.
3978: */
3979: if (n2 == NULL)
3980: continue;
3981: if (set1->nodeMax == 0) {
3982: set1->nodeTab = (xmlNodePtr *) xmlMalloc(
3983: XML_NODESET_DEFAULT * sizeof(xmlNodePtr));
3984: if (set1->nodeTab == NULL) {
3985: xmlXPathErrMemory(NULL, "merging nodeset\n");
3986: return(NULL);
3987: }
3988: memset(set1->nodeTab, 0,
3989: XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
3990: set1->nodeMax = XML_NODESET_DEFAULT;
3991: } else if (set1->nodeNr >= set1->nodeMax) {
3992: xmlNodePtr *temp;
3993:
3994: set1->nodeMax *= 2;
3995: temp = (xmlNodePtr *) xmlRealloc(
3996: set1->nodeTab, set1->nodeMax * sizeof(xmlNodePtr));
3997: if (temp == NULL) {
3998: xmlXPathErrMemory(NULL, "merging nodeset\n");
3999: return(NULL);
4000: }
4001: set1->nodeTab = temp;
4002: }
4003: set1->nodeTab[set1->nodeNr++] = n2;
4004: }
4005: }
4006: set2->nodeNr = 0;
4007: return(set1);
4008: }
4009:
4010: /**
4011: * xmlXPathNodeSetDel:
4012: * @cur: the initial node set
4013: * @val: an xmlNodePtr
4014: *
4015: * Removes an xmlNodePtr from an existing NodeSet
4016: */
4017: void
4018: xmlXPathNodeSetDel(xmlNodeSetPtr cur, xmlNodePtr val) {
4019: int i;
4020:
4021: if (cur == NULL) return;
4022: if (val == NULL) return;
4023:
4024: /*
4025: * find node in nodeTab
4026: */
4027: for (i = 0;i < cur->nodeNr;i++)
4028: if (cur->nodeTab[i] == val) break;
4029:
4030: if (i >= cur->nodeNr) { /* not found */
4031: #ifdef DEBUG
4032: xmlGenericError(xmlGenericErrorContext,
4033: "xmlXPathNodeSetDel: Node %s wasn't found in NodeList\n",
4034: val->name);
4035: #endif
4036: return;
4037: }
4038: if ((cur->nodeTab[i] != NULL) &&
4039: (cur->nodeTab[i]->type == XML_NAMESPACE_DECL))
4040: xmlXPathNodeSetFreeNs((xmlNsPtr) cur->nodeTab[i]);
4041: cur->nodeNr--;
4042: for (;i < cur->nodeNr;i++)
4043: cur->nodeTab[i] = cur->nodeTab[i + 1];
4044: cur->nodeTab[cur->nodeNr] = NULL;
4045: }
4046:
4047: /**
4048: * xmlXPathNodeSetRemove:
4049: * @cur: the initial node set
4050: * @val: the index to remove
4051: *
4052: * Removes an entry from an existing NodeSet list.
4053: */
4054: void
4055: xmlXPathNodeSetRemove(xmlNodeSetPtr cur, int val) {
4056: if (cur == NULL) return;
4057: if (val >= cur->nodeNr) return;
4058: if ((cur->nodeTab[val] != NULL) &&
4059: (cur->nodeTab[val]->type == XML_NAMESPACE_DECL))
4060: xmlXPathNodeSetFreeNs((xmlNsPtr) cur->nodeTab[val]);
4061: cur->nodeNr--;
4062: for (;val < cur->nodeNr;val++)
4063: cur->nodeTab[val] = cur->nodeTab[val + 1];
4064: cur->nodeTab[cur->nodeNr] = NULL;
4065: }
4066:
4067: /**
4068: * xmlXPathFreeNodeSet:
4069: * @obj: the xmlNodeSetPtr to free
4070: *
4071: * Free the NodeSet compound (not the actual nodes !).
4072: */
4073: void
4074: xmlXPathFreeNodeSet(xmlNodeSetPtr obj) {
4075: if (obj == NULL) return;
4076: if (obj->nodeTab != NULL) {
4077: int i;
4078:
4079: /* @@ with_ns to check whether namespace nodes should be looked at @@ */
4080: for (i = 0;i < obj->nodeNr;i++)
4081: if ((obj->nodeTab[i] != NULL) &&
4082: (obj->nodeTab[i]->type == XML_NAMESPACE_DECL))
4083: xmlXPathNodeSetFreeNs((xmlNsPtr) obj->nodeTab[i]);
4084: xmlFree(obj->nodeTab);
4085: }
4086: xmlFree(obj);
4087: }
4088:
4089: /**
4090: * xmlXPathNodeSetClear:
4091: * @set: the node set to clear
4092: *
4093: * Clears the list from all temporary XPath objects (e.g. namespace nodes
4094: * are feed), but does *not* free the list itself. Sets the length of the
4095: * list to 0.
4096: */
4097: static void
4098: xmlXPathNodeSetClear(xmlNodeSetPtr set, int hasNsNodes)
4099: {
4100: if ((set == NULL) || (set->nodeNr <= 0))
4101: return;
4102: else if (hasNsNodes) {
4103: int i;
4104: xmlNodePtr node;
4105:
4106: for (i = 0; i < set->nodeNr; i++) {
4107: node = set->nodeTab[i];
4108: if ((node != NULL) &&
4109: (node->type == XML_NAMESPACE_DECL))
4110: xmlXPathNodeSetFreeNs((xmlNsPtr) node);
4111: }
4112: }
4113: set->nodeNr = 0;
4114: }
4115:
4116: /**
4117: * xmlXPathNodeSetClearFromPos:
4118: * @set: the node set to be cleared
4119: * @pos: the start position to clear from
4120: *
4121: * Clears the list from temporary XPath objects (e.g. namespace nodes
4122: * are feed) starting with the entry at @pos, but does *not* free the list
4123: * itself. Sets the length of the list to @pos.
4124: */
4125: static void
4126: xmlXPathNodeSetClearFromPos(xmlNodeSetPtr set, int pos, int hasNsNodes)
4127: {
4128: if ((set == NULL) || (set->nodeNr <= 0) || (pos >= set->nodeNr))
4129: return;
4130: else if ((hasNsNodes)) {
4131: int i;
4132: xmlNodePtr node;
4133:
4134: for (i = pos; i < set->nodeNr; i++) {
4135: node = set->nodeTab[i];
4136: if ((node != NULL) &&
4137: (node->type == XML_NAMESPACE_DECL))
4138: xmlXPathNodeSetFreeNs((xmlNsPtr) node);
4139: }
4140: }
4141: set->nodeNr = pos;
4142: }
4143:
4144: /**
4145: * xmlXPathFreeValueTree:
4146: * @obj: the xmlNodeSetPtr to free
4147: *
4148: * Free the NodeSet compound and the actual tree, this is different
4149: * from xmlXPathFreeNodeSet()
4150: */
4151: static void
4152: xmlXPathFreeValueTree(xmlNodeSetPtr obj) {
4153: int i;
4154:
4155: if (obj == NULL) return;
4156:
4157: if (obj->nodeTab != NULL) {
4158: for (i = 0;i < obj->nodeNr;i++) {
4159: if (obj->nodeTab[i] != NULL) {
4160: if (obj->nodeTab[i]->type == XML_NAMESPACE_DECL) {
4161: xmlXPathNodeSetFreeNs((xmlNsPtr) obj->nodeTab[i]);
4162: } else {
4163: xmlFreeNodeList(obj->nodeTab[i]);
4164: }
4165: }
4166: }
4167: xmlFree(obj->nodeTab);
4168: }
4169: xmlFree(obj);
4170: }
4171:
4172: #if defined(DEBUG) || defined(DEBUG_STEP)
4173: /**
4174: * xmlGenericErrorContextNodeSet:
4175: * @output: a FILE * for the output
4176: * @obj: the xmlNodeSetPtr to display
4177: *
4178: * Quick display of a NodeSet
4179: */
4180: void
4181: xmlGenericErrorContextNodeSet(FILE *output, xmlNodeSetPtr obj) {
4182: int i;
4183:
4184: if (output == NULL) output = xmlGenericErrorContext;
4185: if (obj == NULL) {
4186: fprintf(output, "NodeSet == NULL !\n");
4187: return;
4188: }
4189: if (obj->nodeNr == 0) {
4190: fprintf(output, "NodeSet is empty\n");
4191: return;
4192: }
4193: if (obj->nodeTab == NULL) {
4194: fprintf(output, " nodeTab == NULL !\n");
4195: return;
4196: }
4197: for (i = 0; i < obj->nodeNr; i++) {
4198: if (obj->nodeTab[i] == NULL) {
4199: fprintf(output, " NULL !\n");
4200: return;
4201: }
4202: if ((obj->nodeTab[i]->type == XML_DOCUMENT_NODE) ||
4203: (obj->nodeTab[i]->type == XML_HTML_DOCUMENT_NODE))
4204: fprintf(output, " /");
4205: else if (obj->nodeTab[i]->name == NULL)
4206: fprintf(output, " noname!");
4207: else fprintf(output, " %s", obj->nodeTab[i]->name);
4208: }
4209: fprintf(output, "\n");
4210: }
4211: #endif
4212:
4213: /**
4214: * xmlXPathNewNodeSet:
4215: * @val: the NodePtr value
4216: *
4217: * Create a new xmlXPathObjectPtr of type NodeSet and initialize
4218: * it with the single Node @val
4219: *
4220: * Returns the newly created object.
4221: */
4222: xmlXPathObjectPtr
4223: xmlXPathNewNodeSet(xmlNodePtr val) {
4224: xmlXPathObjectPtr ret;
4225:
4226: ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
4227: if (ret == NULL) {
4228: xmlXPathErrMemory(NULL, "creating nodeset\n");
4229: return(NULL);
4230: }
4231: memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
4232: ret->type = XPATH_NODESET;
4233: ret->boolval = 0;
4234: ret->nodesetval = xmlXPathNodeSetCreate(val);
4235: /* @@ with_ns to check whether namespace nodes should be looked at @@ */
4236: #ifdef XP_DEBUG_OBJ_USAGE
4237: xmlXPathDebugObjUsageRequested(NULL, XPATH_NODESET);
4238: #endif
4239: return(ret);
4240: }
4241:
4242: /**
4243: * xmlXPathNewValueTree:
4244: * @val: the NodePtr value
4245: *
4246: * Create a new xmlXPathObjectPtr of type Value Tree (XSLT) and initialize
4247: * it with the tree root @val
4248: *
4249: * Returns the newly created object.
4250: */
4251: xmlXPathObjectPtr
4252: xmlXPathNewValueTree(xmlNodePtr val) {
4253: xmlXPathObjectPtr ret;
4254:
4255: ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
4256: if (ret == NULL) {
4257: xmlXPathErrMemory(NULL, "creating result value tree\n");
4258: return(NULL);
4259: }
4260: memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
4261: ret->type = XPATH_XSLT_TREE;
4262: ret->boolval = 1;
4263: ret->user = (void *) val;
4264: ret->nodesetval = xmlXPathNodeSetCreate(val);
4265: #ifdef XP_DEBUG_OBJ_USAGE
4266: xmlXPathDebugObjUsageRequested(NULL, XPATH_XSLT_TREE);
4267: #endif
4268: return(ret);
4269: }
4270:
4271: /**
4272: * xmlXPathNewNodeSetList:
4273: * @val: an existing NodeSet
4274: *
4275: * Create a new xmlXPathObjectPtr of type NodeSet and initialize
4276: * it with the Nodeset @val
4277: *
4278: * Returns the newly created object.
4279: */
4280: xmlXPathObjectPtr
4281: xmlXPathNewNodeSetList(xmlNodeSetPtr val)
4282: {
4283: xmlXPathObjectPtr ret;
4284: int i;
4285:
4286: if (val == NULL)
4287: ret = NULL;
4288: else if (val->nodeTab == NULL)
4289: ret = xmlXPathNewNodeSet(NULL);
4290: else {
4291: ret = xmlXPathNewNodeSet(val->nodeTab[0]);
4292: if (ret)
4293: for (i = 1; i < val->nodeNr; ++i)
4294: xmlXPathNodeSetAddUnique(ret->nodesetval, val->nodeTab[i]);
4295: }
4296:
4297: return (ret);
4298: }
4299:
4300: /**
4301: * xmlXPathWrapNodeSet:
4302: * @val: the NodePtr value
4303: *
4304: * Wrap the Nodeset @val in a new xmlXPathObjectPtr
4305: *
4306: * Returns the newly created object.
4307: */
4308: xmlXPathObjectPtr
4309: xmlXPathWrapNodeSet(xmlNodeSetPtr val) {
4310: xmlXPathObjectPtr ret;
4311:
4312: ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
4313: if (ret == NULL) {
4314: xmlXPathErrMemory(NULL, "creating node set object\n");
4315: return(NULL);
4316: }
4317: memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
4318: ret->type = XPATH_NODESET;
4319: ret->nodesetval = val;
4320: #ifdef XP_DEBUG_OBJ_USAGE
4321: xmlXPathDebugObjUsageRequested(NULL, XPATH_NODESET);
4322: #endif
4323: return(ret);
4324: }
4325:
4326: /**
4327: * xmlXPathFreeNodeSetList:
4328: * @obj: an existing NodeSetList object
4329: *
4330: * Free up the xmlXPathObjectPtr @obj but don't deallocate the objects in
4331: * the list contrary to xmlXPathFreeObject().
4332: */
4333: void
4334: xmlXPathFreeNodeSetList(xmlXPathObjectPtr obj) {
4335: if (obj == NULL) return;
4336: #ifdef XP_DEBUG_OBJ_USAGE
4337: xmlXPathDebugObjUsageReleased(NULL, obj->type);
4338: #endif
4339: xmlFree(obj);
4340: }
4341:
4342: /**
4343: * xmlXPathDifference:
4344: * @nodes1: a node-set
4345: * @nodes2: a node-set
4346: *
4347: * Implements the EXSLT - Sets difference() function:
4348: * node-set set:difference (node-set, node-set)
4349: *
4350: * Returns the difference between the two node sets, or nodes1 if
4351: * nodes2 is empty
4352: */
4353: xmlNodeSetPtr
4354: xmlXPathDifference (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
4355: xmlNodeSetPtr ret;
4356: int i, l1;
4357: xmlNodePtr cur;
4358:
4359: if (xmlXPathNodeSetIsEmpty(nodes2))
4360: return(nodes1);
4361:
4362: ret = xmlXPathNodeSetCreate(NULL);
4363: if (xmlXPathNodeSetIsEmpty(nodes1))
4364: return(ret);
4365:
4366: l1 = xmlXPathNodeSetGetLength(nodes1);
4367:
4368: for (i = 0; i < l1; i++) {
4369: cur = xmlXPathNodeSetItem(nodes1, i);
4370: if (!xmlXPathNodeSetContains(nodes2, cur))
4371: xmlXPathNodeSetAddUnique(ret, cur);
4372: }
4373: return(ret);
4374: }
4375:
4376: /**
4377: * xmlXPathIntersection:
4378: * @nodes1: a node-set
4379: * @nodes2: a node-set
4380: *
4381: * Implements the EXSLT - Sets intersection() function:
4382: * node-set set:intersection (node-set, node-set)
4383: *
4384: * Returns a node set comprising the nodes that are within both the
4385: * node sets passed as arguments
4386: */
4387: xmlNodeSetPtr
4388: xmlXPathIntersection (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
4389: xmlNodeSetPtr ret = xmlXPathNodeSetCreate(NULL);
4390: int i, l1;
4391: xmlNodePtr cur;
4392:
4393: if (ret == NULL)
4394: return(ret);
4395: if (xmlXPathNodeSetIsEmpty(nodes1))
4396: return(ret);
4397: if (xmlXPathNodeSetIsEmpty(nodes2))
4398: return(ret);
4399:
4400: l1 = xmlXPathNodeSetGetLength(nodes1);
4401:
4402: for (i = 0; i < l1; i++) {
4403: cur = xmlXPathNodeSetItem(nodes1, i);
4404: if (xmlXPathNodeSetContains(nodes2, cur))
4405: xmlXPathNodeSetAddUnique(ret, cur);
4406: }
4407: return(ret);
4408: }
4409:
4410: /**
4411: * xmlXPathDistinctSorted:
4412: * @nodes: a node-set, sorted by document order
4413: *
4414: * Implements the EXSLT - Sets distinct() function:
4415: * node-set set:distinct (node-set)
4416: *
4417: * Returns a subset of the nodes contained in @nodes, or @nodes if
4418: * it is empty
4419: */
4420: xmlNodeSetPtr
4421: xmlXPathDistinctSorted (xmlNodeSetPtr nodes) {
4422: xmlNodeSetPtr ret;
4423: xmlHashTablePtr hash;
4424: int i, l;
4425: xmlChar * strval;
4426: xmlNodePtr cur;
4427:
4428: if (xmlXPathNodeSetIsEmpty(nodes))
4429: return(nodes);
4430:
4431: ret = xmlXPathNodeSetCreate(NULL);
4432: if (ret == NULL)
4433: return(ret);
4434: l = xmlXPathNodeSetGetLength(nodes);
4435: hash = xmlHashCreate (l);
4436: for (i = 0; i < l; i++) {
4437: cur = xmlXPathNodeSetItem(nodes, i);
4438: strval = xmlXPathCastNodeToString(cur);
4439: if (xmlHashLookup(hash, strval) == NULL) {
4440: xmlHashAddEntry(hash, strval, strval);
4441: xmlXPathNodeSetAddUnique(ret, cur);
4442: } else {
4443: xmlFree(strval);
4444: }
4445: }
4446: xmlHashFree(hash, (xmlHashDeallocator) xmlFree);
4447: return(ret);
4448: }
4449:
4450: /**
4451: * xmlXPathDistinct:
4452: * @nodes: a node-set
4453: *
4454: * Implements the EXSLT - Sets distinct() function:
4455: * node-set set:distinct (node-set)
4456: * @nodes is sorted by document order, then #exslSetsDistinctSorted
4457: * is called with the sorted node-set
4458: *
4459: * Returns a subset of the nodes contained in @nodes, or @nodes if
4460: * it is empty
4461: */
4462: xmlNodeSetPtr
4463: xmlXPathDistinct (xmlNodeSetPtr nodes) {
4464: if (xmlXPathNodeSetIsEmpty(nodes))
4465: return(nodes);
4466:
4467: xmlXPathNodeSetSort(nodes);
4468: return(xmlXPathDistinctSorted(nodes));
4469: }
4470:
4471: /**
4472: * xmlXPathHasSameNodes:
4473: * @nodes1: a node-set
4474: * @nodes2: a node-set
4475: *
4476: * Implements the EXSLT - Sets has-same-nodes function:
4477: * boolean set:has-same-node(node-set, node-set)
4478: *
4479: * Returns true (1) if @nodes1 shares any node with @nodes2, false (0)
4480: * otherwise
4481: */
4482: int
4483: xmlXPathHasSameNodes (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
4484: int i, l;
4485: xmlNodePtr cur;
4486:
4487: if (xmlXPathNodeSetIsEmpty(nodes1) ||
4488: xmlXPathNodeSetIsEmpty(nodes2))
4489: return(0);
4490:
4491: l = xmlXPathNodeSetGetLength(nodes1);
4492: for (i = 0; i < l; i++) {
4493: cur = xmlXPathNodeSetItem(nodes1, i);
4494: if (xmlXPathNodeSetContains(nodes2, cur))
4495: return(1);
4496: }
4497: return(0);
4498: }
4499:
4500: /**
4501: * xmlXPathNodeLeadingSorted:
4502: * @nodes: a node-set, sorted by document order
4503: * @node: a node
4504: *
4505: * Implements the EXSLT - Sets leading() function:
4506: * node-set set:leading (node-set, node-set)
4507: *
4508: * Returns the nodes in @nodes that precede @node in document order,
4509: * @nodes if @node is NULL or an empty node-set if @nodes
4510: * doesn't contain @node
4511: */
4512: xmlNodeSetPtr
4513: xmlXPathNodeLeadingSorted (xmlNodeSetPtr nodes, xmlNodePtr node) {
4514: int i, l;
4515: xmlNodePtr cur;
4516: xmlNodeSetPtr ret;
4517:
4518: if (node == NULL)
4519: return(nodes);
4520:
4521: ret = xmlXPathNodeSetCreate(NULL);
4522: if (ret == NULL)
4523: return(ret);
4524: if (xmlXPathNodeSetIsEmpty(nodes) ||
4525: (!xmlXPathNodeSetContains(nodes, node)))
4526: return(ret);
4527:
4528: l = xmlXPathNodeSetGetLength(nodes);
4529: for (i = 0; i < l; i++) {
4530: cur = xmlXPathNodeSetItem(nodes, i);
4531: if (cur == node)
4532: break;
4533: xmlXPathNodeSetAddUnique(ret, cur);
4534: }
4535: return(ret);
4536: }
4537:
4538: /**
4539: * xmlXPathNodeLeading:
4540: * @nodes: a node-set
4541: * @node: a node
4542: *
4543: * Implements the EXSLT - Sets leading() function:
4544: * node-set set:leading (node-set, node-set)
4545: * @nodes is sorted by document order, then #exslSetsNodeLeadingSorted
4546: * is called.
4547: *
4548: * Returns the nodes in @nodes that precede @node in document order,
4549: * @nodes if @node is NULL or an empty node-set if @nodes
4550: * doesn't contain @node
4551: */
4552: xmlNodeSetPtr
4553: xmlXPathNodeLeading (xmlNodeSetPtr nodes, xmlNodePtr node) {
4554: xmlXPathNodeSetSort(nodes);
4555: return(xmlXPathNodeLeadingSorted(nodes, node));
4556: }
4557:
4558: /**
4559: * xmlXPathLeadingSorted:
4560: * @nodes1: a node-set, sorted by document order
4561: * @nodes2: a node-set, sorted by document order
4562: *
4563: * Implements the EXSLT - Sets leading() function:
4564: * node-set set:leading (node-set, node-set)
4565: *
4566: * Returns the nodes in @nodes1 that precede the first node in @nodes2
4567: * in document order, @nodes1 if @nodes2 is NULL or empty or
4568: * an empty node-set if @nodes1 doesn't contain @nodes2
4569: */
4570: xmlNodeSetPtr
4571: xmlXPathLeadingSorted (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
4572: if (xmlXPathNodeSetIsEmpty(nodes2))
4573: return(nodes1);
4574: return(xmlXPathNodeLeadingSorted(nodes1,
4575: xmlXPathNodeSetItem(nodes2, 1)));
4576: }
4577:
4578: /**
4579: * xmlXPathLeading:
4580: * @nodes1: a node-set
4581: * @nodes2: a node-set
4582: *
4583: * Implements the EXSLT - Sets leading() function:
4584: * node-set set:leading (node-set, node-set)
4585: * @nodes1 and @nodes2 are sorted by document order, then
4586: * #exslSetsLeadingSorted is called.
4587: *
4588: * Returns the nodes in @nodes1 that precede the first node in @nodes2
4589: * in document order, @nodes1 if @nodes2 is NULL or empty or
4590: * an empty node-set if @nodes1 doesn't contain @nodes2
4591: */
4592: xmlNodeSetPtr
4593: xmlXPathLeading (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
4594: if (xmlXPathNodeSetIsEmpty(nodes2))
4595: return(nodes1);
4596: if (xmlXPathNodeSetIsEmpty(nodes1))
4597: return(xmlXPathNodeSetCreate(NULL));
4598: xmlXPathNodeSetSort(nodes1);
4599: xmlXPathNodeSetSort(nodes2);
4600: return(xmlXPathNodeLeadingSorted(nodes1,
4601: xmlXPathNodeSetItem(nodes2, 1)));
4602: }
4603:
4604: /**
4605: * xmlXPathNodeTrailingSorted:
4606: * @nodes: a node-set, sorted by document order
4607: * @node: a node
4608: *
4609: * Implements the EXSLT - Sets trailing() function:
4610: * node-set set:trailing (node-set, node-set)
4611: *
4612: * Returns the nodes in @nodes that follow @node in document order,
4613: * @nodes if @node is NULL or an empty node-set if @nodes
4614: * doesn't contain @node
4615: */
4616: xmlNodeSetPtr
4617: xmlXPathNodeTrailingSorted (xmlNodeSetPtr nodes, xmlNodePtr node) {
4618: int i, l;
4619: xmlNodePtr cur;
4620: xmlNodeSetPtr ret;
4621:
4622: if (node == NULL)
4623: return(nodes);
4624:
4625: ret = xmlXPathNodeSetCreate(NULL);
4626: if (ret == NULL)
4627: return(ret);
4628: if (xmlXPathNodeSetIsEmpty(nodes) ||
4629: (!xmlXPathNodeSetContains(nodes, node)))
4630: return(ret);
4631:
4632: l = xmlXPathNodeSetGetLength(nodes);
4633: for (i = l - 1; i >= 0; i--) {
4634: cur = xmlXPathNodeSetItem(nodes, i);
4635: if (cur == node)
4636: break;
4637: xmlXPathNodeSetAddUnique(ret, cur);
4638: }
4639: xmlXPathNodeSetSort(ret); /* bug 413451 */
4640: return(ret);
4641: }
4642:
4643: /**
4644: * xmlXPathNodeTrailing:
4645: * @nodes: a node-set
4646: * @node: a node
4647: *
4648: * Implements the EXSLT - Sets trailing() function:
4649: * node-set set:trailing (node-set, node-set)
4650: * @nodes is sorted by document order, then #xmlXPathNodeTrailingSorted
4651: * is called.
4652: *
4653: * Returns the nodes in @nodes that follow @node in document order,
4654: * @nodes if @node is NULL or an empty node-set if @nodes
4655: * doesn't contain @node
4656: */
4657: xmlNodeSetPtr
4658: xmlXPathNodeTrailing (xmlNodeSetPtr nodes, xmlNodePtr node) {
4659: xmlXPathNodeSetSort(nodes);
4660: return(xmlXPathNodeTrailingSorted(nodes, node));
4661: }
4662:
4663: /**
4664: * xmlXPathTrailingSorted:
4665: * @nodes1: a node-set, sorted by document order
4666: * @nodes2: a node-set, sorted by document order
4667: *
4668: * Implements the EXSLT - Sets trailing() function:
4669: * node-set set:trailing (node-set, node-set)
4670: *
4671: * Returns the nodes in @nodes1 that follow the first node in @nodes2
4672: * in document order, @nodes1 if @nodes2 is NULL or empty or
4673: * an empty node-set if @nodes1 doesn't contain @nodes2
4674: */
4675: xmlNodeSetPtr
4676: xmlXPathTrailingSorted (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
4677: if (xmlXPathNodeSetIsEmpty(nodes2))
4678: return(nodes1);
4679: return(xmlXPathNodeTrailingSorted(nodes1,
4680: xmlXPathNodeSetItem(nodes2, 0)));
4681: }
4682:
4683: /**
4684: * xmlXPathTrailing:
4685: * @nodes1: a node-set
4686: * @nodes2: a node-set
4687: *
4688: * Implements the EXSLT - Sets trailing() function:
4689: * node-set set:trailing (node-set, node-set)
4690: * @nodes1 and @nodes2 are sorted by document order, then
4691: * #xmlXPathTrailingSorted is called.
4692: *
4693: * Returns the nodes in @nodes1 that follow the first node in @nodes2
4694: * in document order, @nodes1 if @nodes2 is NULL or empty or
4695: * an empty node-set if @nodes1 doesn't contain @nodes2
4696: */
4697: xmlNodeSetPtr
4698: xmlXPathTrailing (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
4699: if (xmlXPathNodeSetIsEmpty(nodes2))
4700: return(nodes1);
4701: if (xmlXPathNodeSetIsEmpty(nodes1))
4702: return(xmlXPathNodeSetCreate(NULL));
4703: xmlXPathNodeSetSort(nodes1);
4704: xmlXPathNodeSetSort(nodes2);
4705: return(xmlXPathNodeTrailingSorted(nodes1,
4706: xmlXPathNodeSetItem(nodes2, 0)));
4707: }
4708:
4709: /************************************************************************
4710: * *
4711: * Routines to handle extra functions *
4712: * *
4713: ************************************************************************/
4714:
4715: /**
4716: * xmlXPathRegisterFunc:
4717: * @ctxt: the XPath context
4718: * @name: the function name
4719: * @f: the function implementation or NULL
4720: *
4721: * Register a new function. If @f is NULL it unregisters the function
4722: *
4723: * Returns 0 in case of success, -1 in case of error
4724: */
4725: int
4726: xmlXPathRegisterFunc(xmlXPathContextPtr ctxt, const xmlChar *name,
4727: xmlXPathFunction f) {
4728: return(xmlXPathRegisterFuncNS(ctxt, name, NULL, f));
4729: }
4730:
4731: /**
4732: * xmlXPathRegisterFuncNS:
4733: * @ctxt: the XPath context
4734: * @name: the function name
4735: * @ns_uri: the function namespace URI
4736: * @f: the function implementation or NULL
4737: *
4738: * Register a new function. If @f is NULL it unregisters the function
4739: *
4740: * Returns 0 in case of success, -1 in case of error
4741: */
4742: int
4743: xmlXPathRegisterFuncNS(xmlXPathContextPtr ctxt, const xmlChar *name,
4744: const xmlChar *ns_uri, xmlXPathFunction f) {
4745: if (ctxt == NULL)
4746: return(-1);
4747: if (name == NULL)
4748: return(-1);
4749:
4750: if (ctxt->funcHash == NULL)
4751: ctxt->funcHash = xmlHashCreate(0);
4752: if (ctxt->funcHash == NULL)
4753: return(-1);
4754: if (f == NULL)
4755: return(xmlHashRemoveEntry2(ctxt->funcHash, name, ns_uri, NULL));
4756: return(xmlHashAddEntry2(ctxt->funcHash, name, ns_uri, XML_CAST_FPTR(f)));
4757: }
4758:
4759: /**
4760: * xmlXPathRegisterFuncLookup:
4761: * @ctxt: the XPath context
4762: * @f: the lookup function
4763: * @funcCtxt: the lookup data
4764: *
4765: * Registers an external mechanism to do function lookup.
4766: */
4767: void
4768: xmlXPathRegisterFuncLookup (xmlXPathContextPtr ctxt,
4769: xmlXPathFuncLookupFunc f,
4770: void *funcCtxt) {
4771: if (ctxt == NULL)
4772: return;
4773: ctxt->funcLookupFunc = f;
4774: ctxt->funcLookupData = funcCtxt;
4775: }
4776:
4777: /**
4778: * xmlXPathFunctionLookup:
4779: * @ctxt: the XPath context
4780: * @name: the function name
4781: *
4782: * Search in the Function array of the context for the given
4783: * function.
4784: *
4785: * Returns the xmlXPathFunction or NULL if not found
4786: */
4787: xmlXPathFunction
4788: xmlXPathFunctionLookup(xmlXPathContextPtr ctxt, const xmlChar *name) {
4789: if (ctxt == NULL)
4790: return (NULL);
4791:
4792: if (ctxt->funcLookupFunc != NULL) {
4793: xmlXPathFunction ret;
4794: xmlXPathFuncLookupFunc f;
4795:
4796: f = ctxt->funcLookupFunc;
4797: ret = f(ctxt->funcLookupData, name, NULL);
4798: if (ret != NULL)
4799: return(ret);
4800: }
4801: return(xmlXPathFunctionLookupNS(ctxt, name, NULL));
4802: }
4803:
4804: /**
4805: * xmlXPathFunctionLookupNS:
4806: * @ctxt: the XPath context
4807: * @name: the function name
4808: * @ns_uri: the function namespace URI
4809: *
4810: * Search in the Function array of the context for the given
4811: * function.
4812: *
4813: * Returns the xmlXPathFunction or NULL if not found
4814: */
4815: xmlXPathFunction
4816: xmlXPathFunctionLookupNS(xmlXPathContextPtr ctxt, const xmlChar *name,
4817: const xmlChar *ns_uri) {
4818: xmlXPathFunction ret;
4819:
4820: if (ctxt == NULL)
4821: return(NULL);
4822: if (name == NULL)
4823: return(NULL);
4824:
4825: if (ctxt->funcLookupFunc != NULL) {
4826: xmlXPathFuncLookupFunc f;
4827:
4828: f = ctxt->funcLookupFunc;
4829: ret = f(ctxt->funcLookupData, name, ns_uri);
4830: if (ret != NULL)
4831: return(ret);
4832: }
4833:
4834: if (ctxt->funcHash == NULL)
4835: return(NULL);
4836:
4837: XML_CAST_FPTR(ret) = xmlHashLookup2(ctxt->funcHash, name, ns_uri);
4838: return(ret);
4839: }
4840:
4841: /**
4842: * xmlXPathRegisteredFuncsCleanup:
4843: * @ctxt: the XPath context
4844: *
4845: * Cleanup the XPath context data associated to registered functions
4846: */
4847: void
4848: xmlXPathRegisteredFuncsCleanup(xmlXPathContextPtr ctxt) {
4849: if (ctxt == NULL)
4850: return;
4851:
4852: xmlHashFree(ctxt->funcHash, NULL);
4853: ctxt->funcHash = NULL;
4854: }
4855:
4856: /************************************************************************
4857: * *
4858: * Routines to handle Variables *
4859: * *
4860: ************************************************************************/
4861:
4862: /**
4863: * xmlXPathRegisterVariable:
4864: * @ctxt: the XPath context
4865: * @name: the variable name
4866: * @value: the variable value or NULL
4867: *
4868: * Register a new variable value. If @value is NULL it unregisters
4869: * the variable
4870: *
4871: * Returns 0 in case of success, -1 in case of error
4872: */
4873: int
4874: xmlXPathRegisterVariable(xmlXPathContextPtr ctxt, const xmlChar *name,
4875: xmlXPathObjectPtr value) {
4876: return(xmlXPathRegisterVariableNS(ctxt, name, NULL, value));
4877: }
4878:
4879: /**
4880: * xmlXPathRegisterVariableNS:
4881: * @ctxt: the XPath context
4882: * @name: the variable name
4883: * @ns_uri: the variable namespace URI
4884: * @value: the variable value or NULL
4885: *
4886: * Register a new variable value. If @value is NULL it unregisters
4887: * the variable
4888: *
4889: * Returns 0 in case of success, -1 in case of error
4890: */
4891: int
4892: xmlXPathRegisterVariableNS(xmlXPathContextPtr ctxt, const xmlChar *name,
4893: const xmlChar *ns_uri,
4894: xmlXPathObjectPtr value) {
4895: if (ctxt == NULL)
4896: return(-1);
4897: if (name == NULL)
4898: return(-1);
4899:
4900: if (ctxt->varHash == NULL)
4901: ctxt->varHash = xmlHashCreate(0);
4902: if (ctxt->varHash == NULL)
4903: return(-1);
4904: if (value == NULL)
4905: return(xmlHashRemoveEntry2(ctxt->varHash, name, ns_uri,
4906: (xmlHashDeallocator)xmlXPathFreeObject));
4907: return(xmlHashUpdateEntry2(ctxt->varHash, name, ns_uri,
4908: (void *) value,
4909: (xmlHashDeallocator)xmlXPathFreeObject));
4910: }
4911:
4912: /**
4913: * xmlXPathRegisterVariableLookup:
4914: * @ctxt: the XPath context
4915: * @f: the lookup function
4916: * @data: the lookup data
4917: *
4918: * register an external mechanism to do variable lookup
4919: */
4920: void
4921: xmlXPathRegisterVariableLookup(xmlXPathContextPtr ctxt,
4922: xmlXPathVariableLookupFunc f, void *data) {
4923: if (ctxt == NULL)
4924: return;
4925: ctxt->varLookupFunc = f;
4926: ctxt->varLookupData = data;
4927: }
4928:
4929: /**
4930: * xmlXPathVariableLookup:
4931: * @ctxt: the XPath context
4932: * @name: the variable name
4933: *
4934: * Search in the Variable array of the context for the given
4935: * variable value.
4936: *
4937: * Returns a copy of the value or NULL if not found
4938: */
4939: xmlXPathObjectPtr
4940: xmlXPathVariableLookup(xmlXPathContextPtr ctxt, const xmlChar *name) {
4941: if (ctxt == NULL)
4942: return(NULL);
4943:
4944: if (ctxt->varLookupFunc != NULL) {
4945: xmlXPathObjectPtr ret;
4946:
4947: ret = ((xmlXPathVariableLookupFunc)ctxt->varLookupFunc)
4948: (ctxt->varLookupData, name, NULL);
4949: return(ret);
4950: }
4951: return(xmlXPathVariableLookupNS(ctxt, name, NULL));
4952: }
4953:
4954: /**
4955: * xmlXPathVariableLookupNS:
4956: * @ctxt: the XPath context
4957: * @name: the variable name
4958: * @ns_uri: the variable namespace URI
4959: *
4960: * Search in the Variable array of the context for the given
4961: * variable value.
4962: *
4963: * Returns the a copy of the value or NULL if not found
4964: */
4965: xmlXPathObjectPtr
4966: xmlXPathVariableLookupNS(xmlXPathContextPtr ctxt, const xmlChar *name,
4967: const xmlChar *ns_uri) {
4968: if (ctxt == NULL)
4969: return(NULL);
4970:
4971: if (ctxt->varLookupFunc != NULL) {
4972: xmlXPathObjectPtr ret;
4973:
4974: ret = ((xmlXPathVariableLookupFunc)ctxt->varLookupFunc)
4975: (ctxt->varLookupData, name, ns_uri);
4976: if (ret != NULL) return(ret);
4977: }
4978:
4979: if (ctxt->varHash == NULL)
4980: return(NULL);
4981: if (name == NULL)
4982: return(NULL);
4983:
4984: return(xmlXPathCacheObjectCopy(ctxt, (xmlXPathObjectPtr)
4985: xmlHashLookup2(ctxt->varHash, name, ns_uri)));
4986: }
4987:
4988: /**
4989: * xmlXPathRegisteredVariablesCleanup:
4990: * @ctxt: the XPath context
4991: *
4992: * Cleanup the XPath context data associated to registered variables
4993: */
4994: void
4995: xmlXPathRegisteredVariablesCleanup(xmlXPathContextPtr ctxt) {
4996: if (ctxt == NULL)
4997: return;
4998:
4999: xmlHashFree(ctxt->varHash, (xmlHashDeallocator)xmlXPathFreeObject);
5000: ctxt->varHash = NULL;
5001: }
5002:
5003: /**
5004: * xmlXPathRegisterNs:
5005: * @ctxt: the XPath context
5006: * @prefix: the namespace prefix cannot be NULL or empty string
5007: * @ns_uri: the namespace name
5008: *
5009: * Register a new namespace. If @ns_uri is NULL it unregisters
5010: * the namespace
5011: *
5012: * Returns 0 in case of success, -1 in case of error
5013: */
5014: int
5015: xmlXPathRegisterNs(xmlXPathContextPtr ctxt, const xmlChar *prefix,
5016: const xmlChar *ns_uri) {
5017: if (ctxt == NULL)
5018: return(-1);
5019: if (prefix == NULL)
5020: return(-1);
5021: if (prefix[0] == 0)
5022: return(-1);
5023:
5024: if (ctxt->nsHash == NULL)
5025: ctxt->nsHash = xmlHashCreate(10);
5026: if (ctxt->nsHash == NULL)
5027: return(-1);
5028: if (ns_uri == NULL)
5029: return(xmlHashRemoveEntry(ctxt->nsHash, prefix,
5030: (xmlHashDeallocator)xmlFree));
5031: return(xmlHashUpdateEntry(ctxt->nsHash, prefix, (void *) xmlStrdup(ns_uri),
5032: (xmlHashDeallocator)xmlFree));
5033: }
5034:
5035: /**
5036: * xmlXPathNsLookup:
5037: * @ctxt: the XPath context
5038: * @prefix: the namespace prefix value
5039: *
5040: * Search in the namespace declaration array of the context for the given
5041: * namespace name associated to the given prefix
5042: *
5043: * Returns the value or NULL if not found
5044: */
5045: const xmlChar *
5046: xmlXPathNsLookup(xmlXPathContextPtr ctxt, const xmlChar *prefix) {
5047: if (ctxt == NULL)
5048: return(NULL);
5049: if (prefix == NULL)
5050: return(NULL);
5051:
5052: #ifdef XML_XML_NAMESPACE
5053: if (xmlStrEqual(prefix, (const xmlChar *) "xml"))
5054: return(XML_XML_NAMESPACE);
5055: #endif
5056:
5057: if (ctxt->namespaces != NULL) {
5058: int i;
5059:
5060: for (i = 0;i < ctxt->nsNr;i++) {
5061: if ((ctxt->namespaces[i] != NULL) &&
5062: (xmlStrEqual(ctxt->namespaces[i]->prefix, prefix)))
5063: return(ctxt->namespaces[i]->href);
5064: }
5065: }
5066:
5067: return((const xmlChar *) xmlHashLookup(ctxt->nsHash, prefix));
5068: }
5069:
5070: /**
5071: * xmlXPathRegisteredNsCleanup:
5072: * @ctxt: the XPath context
5073: *
5074: * Cleanup the XPath context data associated to registered variables
5075: */
5076: void
5077: xmlXPathRegisteredNsCleanup(xmlXPathContextPtr ctxt) {
5078: if (ctxt == NULL)
5079: return;
5080:
5081: xmlHashFree(ctxt->nsHash, (xmlHashDeallocator)xmlFree);
5082: ctxt->nsHash = NULL;
5083: }
5084:
5085: /************************************************************************
5086: * *
5087: * Routines to handle Values *
5088: * *
5089: ************************************************************************/
5090:
5091: /* Allocations are terrible, one needs to optimize all this !!! */
5092:
5093: /**
5094: * xmlXPathNewFloat:
5095: * @val: the double value
5096: *
5097: * Create a new xmlXPathObjectPtr of type double and of value @val
5098: *
5099: * Returns the newly created object.
5100: */
5101: xmlXPathObjectPtr
5102: xmlXPathNewFloat(double val) {
5103: xmlXPathObjectPtr ret;
5104:
5105: ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
5106: if (ret == NULL) {
5107: xmlXPathErrMemory(NULL, "creating float object\n");
5108: return(NULL);
5109: }
5110: memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
5111: ret->type = XPATH_NUMBER;
5112: ret->floatval = val;
5113: #ifdef XP_DEBUG_OBJ_USAGE
5114: xmlXPathDebugObjUsageRequested(NULL, XPATH_NUMBER);
5115: #endif
5116: return(ret);
5117: }
5118:
5119: /**
5120: * xmlXPathNewBoolean:
5121: * @val: the boolean value
5122: *
5123: * Create a new xmlXPathObjectPtr of type boolean and of value @val
5124: *
5125: * Returns the newly created object.
5126: */
5127: xmlXPathObjectPtr
5128: xmlXPathNewBoolean(int val) {
5129: xmlXPathObjectPtr ret;
5130:
5131: ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
5132: if (ret == NULL) {
5133: xmlXPathErrMemory(NULL, "creating boolean object\n");
5134: return(NULL);
5135: }
5136: memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
5137: ret->type = XPATH_BOOLEAN;
5138: ret->boolval = (val != 0);
5139: #ifdef XP_DEBUG_OBJ_USAGE
5140: xmlXPathDebugObjUsageRequested(NULL, XPATH_BOOLEAN);
5141: #endif
5142: return(ret);
5143: }
5144:
5145: /**
5146: * xmlXPathNewString:
5147: * @val: the xmlChar * value
5148: *
5149: * Create a new xmlXPathObjectPtr of type string and of value @val
5150: *
5151: * Returns the newly created object.
5152: */
5153: xmlXPathObjectPtr
5154: xmlXPathNewString(const xmlChar *val) {
5155: xmlXPathObjectPtr ret;
5156:
5157: ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
5158: if (ret == NULL) {
5159: xmlXPathErrMemory(NULL, "creating string object\n");
5160: return(NULL);
5161: }
5162: memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
5163: ret->type = XPATH_STRING;
5164: if (val != NULL)
5165: ret->stringval = xmlStrdup(val);
5166: else
5167: ret->stringval = xmlStrdup((const xmlChar *)"");
5168: #ifdef XP_DEBUG_OBJ_USAGE
5169: xmlXPathDebugObjUsageRequested(NULL, XPATH_STRING);
5170: #endif
5171: return(ret);
5172: }
5173:
5174: /**
5175: * xmlXPathWrapString:
5176: * @val: the xmlChar * value
5177: *
5178: * Wraps the @val string into an XPath object.
5179: *
5180: * Returns the newly created object.
5181: */
5182: xmlXPathObjectPtr
5183: xmlXPathWrapString (xmlChar *val) {
5184: xmlXPathObjectPtr ret;
5185:
5186: ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
5187: if (ret == NULL) {
5188: xmlXPathErrMemory(NULL, "creating string object\n");
5189: return(NULL);
5190: }
5191: memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
5192: ret->type = XPATH_STRING;
5193: ret->stringval = val;
5194: #ifdef XP_DEBUG_OBJ_USAGE
5195: xmlXPathDebugObjUsageRequested(NULL, XPATH_STRING);
5196: #endif
5197: return(ret);
5198: }
5199:
5200: /**
5201: * xmlXPathNewCString:
5202: * @val: the char * value
5203: *
5204: * Create a new xmlXPathObjectPtr of type string and of value @val
5205: *
5206: * Returns the newly created object.
5207: */
5208: xmlXPathObjectPtr
5209: xmlXPathNewCString(const char *val) {
5210: xmlXPathObjectPtr ret;
5211:
5212: ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
5213: if (ret == NULL) {
5214: xmlXPathErrMemory(NULL, "creating string object\n");
5215: return(NULL);
5216: }
5217: memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
5218: ret->type = XPATH_STRING;
5219: ret->stringval = xmlStrdup(BAD_CAST val);
5220: #ifdef XP_DEBUG_OBJ_USAGE
5221: xmlXPathDebugObjUsageRequested(NULL, XPATH_STRING);
5222: #endif
5223: return(ret);
5224: }
5225:
5226: /**
5227: * xmlXPathWrapCString:
5228: * @val: the char * value
5229: *
5230: * Wraps a string into an XPath object.
5231: *
5232: * Returns the newly created object.
5233: */
5234: xmlXPathObjectPtr
5235: xmlXPathWrapCString (char * val) {
5236: return(xmlXPathWrapString((xmlChar *)(val)));
5237: }
5238:
5239: /**
5240: * xmlXPathWrapExternal:
5241: * @val: the user data
5242: *
5243: * Wraps the @val data into an XPath object.
5244: *
5245: * Returns the newly created object.
5246: */
5247: xmlXPathObjectPtr
5248: xmlXPathWrapExternal (void *val) {
5249: xmlXPathObjectPtr ret;
5250:
5251: ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
5252: if (ret == NULL) {
5253: xmlXPathErrMemory(NULL, "creating user object\n");
5254: return(NULL);
5255: }
5256: memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
5257: ret->type = XPATH_USERS;
5258: ret->user = val;
5259: #ifdef XP_DEBUG_OBJ_USAGE
5260: xmlXPathDebugObjUsageRequested(NULL, XPATH_USERS);
5261: #endif
5262: return(ret);
5263: }
5264:
5265: /**
5266: * xmlXPathObjectCopy:
5267: * @val: the original object
5268: *
5269: * allocate a new copy of a given object
5270: *
5271: * Returns the newly created object.
5272: */
5273: xmlXPathObjectPtr
5274: xmlXPathObjectCopy(xmlXPathObjectPtr val) {
5275: xmlXPathObjectPtr ret;
5276:
5277: if (val == NULL)
5278: return(NULL);
5279:
5280: ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
5281: if (ret == NULL) {
5282: xmlXPathErrMemory(NULL, "copying object\n");
5283: return(NULL);
5284: }
5285: memcpy(ret, val , (size_t) sizeof(xmlXPathObject));
5286: #ifdef XP_DEBUG_OBJ_USAGE
5287: xmlXPathDebugObjUsageRequested(NULL, val->type);
5288: #endif
5289: switch (val->type) {
5290: case XPATH_BOOLEAN:
5291: case XPATH_NUMBER:
5292: case XPATH_POINT:
5293: case XPATH_RANGE:
5294: break;
5295: case XPATH_STRING:
5296: ret->stringval = xmlStrdup(val->stringval);
5297: break;
5298: case XPATH_XSLT_TREE:
5299: #if 0
5300: /*
5301: Removed 11 July 2004 - the current handling of xslt tmpRVT nodes means that
5302: this previous handling is no longer correct, and can cause some serious
5303: problems (ref. bug 145547)
5304: */
5305: if ((val->nodesetval != NULL) &&
5306: (val->nodesetval->nodeTab != NULL)) {
5307: xmlNodePtr cur, tmp;
5308: xmlDocPtr top;
5309:
5310: ret->boolval = 1;
5311: top = xmlNewDoc(NULL);
5312: top->name = (char *)
5313: xmlStrdup(val->nodesetval->nodeTab[0]->name);
5314: ret->user = top;
5315: if (top != NULL) {
5316: top->doc = top;
5317: cur = val->nodesetval->nodeTab[0]->children;
5318: while (cur != NULL) {
5319: tmp = xmlDocCopyNode(cur, top, 1);
5320: xmlAddChild((xmlNodePtr) top, tmp);
5321: cur = cur->next;
5322: }
5323: }
5324:
5325: ret->nodesetval = xmlXPathNodeSetCreate((xmlNodePtr) top);
5326: } else
5327: ret->nodesetval = xmlXPathNodeSetCreate(NULL);
5328: /* Deallocate the copied tree value */
5329: break;
5330: #endif
5331: case XPATH_NODESET:
5332: ret->nodesetval = xmlXPathNodeSetMerge(NULL, val->nodesetval);
5333: /* Do not deallocate the copied tree value */
5334: ret->boolval = 0;
5335: break;
5336: case XPATH_LOCATIONSET:
5337: #ifdef LIBXML_XPTR_ENABLED
5338: {
5339: xmlLocationSetPtr loc = val->user;
5340: ret->user = (void *) xmlXPtrLocationSetMerge(NULL, loc);
5341: break;
5342: }
5343: #endif
5344: case XPATH_USERS:
5345: ret->user = val->user;
5346: break;
5347: case XPATH_UNDEFINED:
5348: xmlGenericError(xmlGenericErrorContext,
5349: "xmlXPathObjectCopy: unsupported type %d\n",
5350: val->type);
5351: break;
5352: }
5353: return(ret);
5354: }
5355:
5356: /**
5357: * xmlXPathFreeObject:
5358: * @obj: the object to free
5359: *
5360: * Free up an xmlXPathObjectPtr object.
5361: */
5362: void
5363: xmlXPathFreeObject(xmlXPathObjectPtr obj) {
5364: if (obj == NULL) return;
5365: if ((obj->type == XPATH_NODESET) || (obj->type == XPATH_XSLT_TREE)) {
5366: if (obj->boolval) {
5367: #if 0
5368: if (obj->user != NULL) {
5369: xmlXPathFreeNodeSet(obj->nodesetval);
5370: xmlFreeNodeList((xmlNodePtr) obj->user);
5371: } else
5372: #endif
5373: obj->type = XPATH_XSLT_TREE; /* TODO: Just for debugging. */
5374: if (obj->nodesetval != NULL)
5375: xmlXPathFreeValueTree(obj->nodesetval);
5376: } else {
5377: if (obj->nodesetval != NULL)
5378: xmlXPathFreeNodeSet(obj->nodesetval);
5379: }
5380: #ifdef LIBXML_XPTR_ENABLED
5381: } else if (obj->type == XPATH_LOCATIONSET) {
5382: if (obj->user != NULL)
5383: xmlXPtrFreeLocationSet(obj->user);
5384: #endif
5385: } else if (obj->type == XPATH_STRING) {
5386: if (obj->stringval != NULL)
5387: xmlFree(obj->stringval);
5388: }
5389: #ifdef XP_DEBUG_OBJ_USAGE
5390: xmlXPathDebugObjUsageReleased(NULL, obj->type);
5391: #endif
5392: xmlFree(obj);
5393: }
5394:
5395: /**
5396: * xmlXPathReleaseObject:
5397: * @obj: the xmlXPathObjectPtr to free or to cache
5398: *
5399: * Depending on the state of the cache this frees the given
5400: * XPath object or stores it in the cache.
5401: */
5402: static void
5403: xmlXPathReleaseObject(xmlXPathContextPtr ctxt, xmlXPathObjectPtr obj)
5404: {
5405: #define XP_CACHE_ADD(sl, o) if (sl == NULL) { \
5406: sl = xmlPointerListCreate(10); if (sl == NULL) goto free_obj; } \
5407: if (xmlPointerListAddSize(sl, obj, 0) == -1) goto free_obj;
5408:
5409: #define XP_CACHE_WANTS(sl, n) ((sl == NULL) || ((sl)->number < n))
5410:
5411: if (obj == NULL)
5412: return;
5413: if ((ctxt == NULL) || (ctxt->cache == NULL)) {
5414: xmlXPathFreeObject(obj);
5415: } else {
5416: xmlXPathContextCachePtr cache =
5417: (xmlXPathContextCachePtr) ctxt->cache;
5418:
5419: switch (obj->type) {
5420: case XPATH_NODESET:
5421: case XPATH_XSLT_TREE:
5422: if (obj->nodesetval != NULL) {
5423: if (obj->boolval) {
5424: /*
5425: * It looks like the @boolval is used for
5426: * evaluation if this an XSLT Result Tree Fragment.
5427: * TODO: Check if this assumption is correct.
5428: */
5429: obj->type = XPATH_XSLT_TREE; /* just for debugging */
5430: xmlXPathFreeValueTree(obj->nodesetval);
5431: obj->nodesetval = NULL;
5432: } else if ((obj->nodesetval->nodeMax <= 40) &&
5433: (XP_CACHE_WANTS(cache->nodesetObjs,
5434: cache->maxNodeset)))
5435: {
5436: XP_CACHE_ADD(cache->nodesetObjs, obj);
5437: goto obj_cached;
5438: } else {
5439: xmlXPathFreeNodeSet(obj->nodesetval);
5440: obj->nodesetval = NULL;
5441: }
5442: }
5443: break;
5444: case XPATH_STRING:
5445: if (obj->stringval != NULL)
5446: xmlFree(obj->stringval);
5447:
5448: if (XP_CACHE_WANTS(cache->stringObjs, cache->maxString)) {
5449: XP_CACHE_ADD(cache->stringObjs, obj);
5450: goto obj_cached;
5451: }
5452: break;
5453: case XPATH_BOOLEAN:
5454: if (XP_CACHE_WANTS(cache->booleanObjs, cache->maxBoolean)) {
5455: XP_CACHE_ADD(cache->booleanObjs, obj);
5456: goto obj_cached;
5457: }
5458: break;
5459: case XPATH_NUMBER:
5460: if (XP_CACHE_WANTS(cache->numberObjs, cache->maxNumber)) {
5461: XP_CACHE_ADD(cache->numberObjs, obj);
5462: goto obj_cached;
5463: }
5464: break;
5465: #ifdef LIBXML_XPTR_ENABLED
5466: case XPATH_LOCATIONSET:
5467: if (obj->user != NULL) {
5468: xmlXPtrFreeLocationSet(obj->user);
5469: }
5470: goto free_obj;
5471: #endif
5472: default:
5473: goto free_obj;
5474: }
5475:
5476: /*
5477: * Fallback to adding to the misc-objects slot.
5478: */
5479: if (XP_CACHE_WANTS(cache->miscObjs, cache->maxMisc)) {
5480: XP_CACHE_ADD(cache->miscObjs, obj);
5481: } else
5482: goto free_obj;
5483:
5484: obj_cached:
5485:
5486: #ifdef XP_DEBUG_OBJ_USAGE
5487: xmlXPathDebugObjUsageReleased(ctxt, obj->type);
5488: #endif
5489:
5490: if (obj->nodesetval != NULL) {
5491: xmlNodeSetPtr tmpset = obj->nodesetval;
5492:
5493: /*
5494: * TODO: Due to those nasty ns-nodes, we need to traverse
5495: * the list and free the ns-nodes.
5496: * URGENT TODO: Check if it's actually slowing things down.
5497: * Maybe we shouldn't try to preserve the list.
5498: */
5499: if (tmpset->nodeNr > 1) {
5500: int i;
5501: xmlNodePtr node;
5502:
5503: for (i = 0; i < tmpset->nodeNr; i++) {
5504: node = tmpset->nodeTab[i];
5505: if ((node != NULL) &&
5506: (node->type == XML_NAMESPACE_DECL))
5507: {
5508: xmlXPathNodeSetFreeNs((xmlNsPtr) node);
5509: }
5510: }
5511: } else if (tmpset->nodeNr == 1) {
5512: if ((tmpset->nodeTab[0] != NULL) &&
5513: (tmpset->nodeTab[0]->type == XML_NAMESPACE_DECL))
5514: xmlXPathNodeSetFreeNs((xmlNsPtr) tmpset->nodeTab[0]);
5515: }
5516: tmpset->nodeNr = 0;
5517: memset(obj, 0, sizeof(xmlXPathObject));
5518: obj->nodesetval = tmpset;
5519: } else
5520: memset(obj, 0, sizeof(xmlXPathObject));
5521:
5522: return;
5523:
5524: free_obj:
5525: /*
5526: * Cache is full; free the object.
5527: */
5528: if (obj->nodesetval != NULL)
5529: xmlXPathFreeNodeSet(obj->nodesetval);
5530: #ifdef XP_DEBUG_OBJ_USAGE
5531: xmlXPathDebugObjUsageReleased(NULL, obj->type);
5532: #endif
5533: xmlFree(obj);
5534: }
5535: return;
5536: }
5537:
5538:
5539: /************************************************************************
5540: * *
5541: * Type Casting Routines *
5542: * *
5543: ************************************************************************/
5544:
5545: /**
5546: * xmlXPathCastBooleanToString:
5547: * @val: a boolean
5548: *
5549: * Converts a boolean to its string value.
5550: *
5551: * Returns a newly allocated string.
5552: */
5553: xmlChar *
5554: xmlXPathCastBooleanToString (int val) {
5555: xmlChar *ret;
5556: if (val)
5557: ret = xmlStrdup((const xmlChar *) "true");
5558: else
5559: ret = xmlStrdup((const xmlChar *) "false");
5560: return(ret);
5561: }
5562:
5563: /**
5564: * xmlXPathCastNumberToString:
5565: * @val: a number
5566: *
5567: * Converts a number to its string value.
5568: *
5569: * Returns a newly allocated string.
5570: */
5571: xmlChar *
5572: xmlXPathCastNumberToString (double val) {
5573: xmlChar *ret;
5574: switch (xmlXPathIsInf(val)) {
5575: case 1:
5576: ret = xmlStrdup((const xmlChar *) "Infinity");
5577: break;
5578: case -1:
5579: ret = xmlStrdup((const xmlChar *) "-Infinity");
5580: break;
5581: default:
5582: if (xmlXPathIsNaN(val)) {
5583: ret = xmlStrdup((const xmlChar *) "NaN");
5584: } else if (val == 0 && xmlXPathGetSign(val) != 0) {
5585: ret = xmlStrdup((const xmlChar *) "0");
5586: } else {
5587: /* could be improved */
5588: char buf[100];
5589: xmlXPathFormatNumber(val, buf, 99);
5590: buf[99] = 0;
5591: ret = xmlStrdup((const xmlChar *) buf);
5592: }
5593: }
5594: return(ret);
5595: }
5596:
5597: /**
5598: * xmlXPathCastNodeToString:
5599: * @node: a node
5600: *
5601: * Converts a node to its string value.
5602: *
5603: * Returns a newly allocated string.
5604: */
5605: xmlChar *
5606: xmlXPathCastNodeToString (xmlNodePtr node) {
5607: xmlChar *ret;
5608: if ((ret = xmlNodeGetContent(node)) == NULL)
5609: ret = xmlStrdup((const xmlChar *) "");
5610: return(ret);
5611: }
5612:
5613: /**
5614: * xmlXPathCastNodeSetToString:
5615: * @ns: a node-set
5616: *
5617: * Converts a node-set to its string value.
5618: *
5619: * Returns a newly allocated string.
5620: */
5621: xmlChar *
5622: xmlXPathCastNodeSetToString (xmlNodeSetPtr ns) {
5623: if ((ns == NULL) || (ns->nodeNr == 0) || (ns->nodeTab == NULL))
5624: return(xmlStrdup((const xmlChar *) ""));
5625:
5626: if (ns->nodeNr > 1)
5627: xmlXPathNodeSetSort(ns);
5628: return(xmlXPathCastNodeToString(ns->nodeTab[0]));
5629: }
5630:
5631: /**
5632: * xmlXPathCastToString:
5633: * @val: an XPath object
5634: *
5635: * Converts an existing object to its string() equivalent
5636: *
5637: * Returns the allocated string value of the object, NULL in case of error.
5638: * It's up to the caller to free the string memory with xmlFree().
5639: */
5640: xmlChar *
5641: xmlXPathCastToString(xmlXPathObjectPtr val) {
5642: xmlChar *ret = NULL;
5643:
5644: if (val == NULL)
5645: return(xmlStrdup((const xmlChar *) ""));
5646: switch (val->type) {
5647: case XPATH_UNDEFINED:
5648: #ifdef DEBUG_EXPR
5649: xmlGenericError(xmlGenericErrorContext, "String: undefined\n");
5650: #endif
5651: ret = xmlStrdup((const xmlChar *) "");
5652: break;
5653: case XPATH_NODESET:
5654: case XPATH_XSLT_TREE:
5655: ret = xmlXPathCastNodeSetToString(val->nodesetval);
5656: break;
5657: case XPATH_STRING:
5658: return(xmlStrdup(val->stringval));
5659: case XPATH_BOOLEAN:
5660: ret = xmlXPathCastBooleanToString(val->boolval);
5661: break;
5662: case XPATH_NUMBER: {
5663: ret = xmlXPathCastNumberToString(val->floatval);
5664: break;
5665: }
5666: case XPATH_USERS:
5667: case XPATH_POINT:
5668: case XPATH_RANGE:
5669: case XPATH_LOCATIONSET:
5670: TODO
5671: ret = xmlStrdup((const xmlChar *) "");
5672: break;
5673: }
5674: return(ret);
5675: }
5676:
5677: /**
5678: * xmlXPathConvertString:
5679: * @val: an XPath object
5680: *
5681: * Converts an existing object to its string() equivalent
5682: *
5683: * Returns the new object, the old one is freed (or the operation
5684: * is done directly on @val)
5685: */
5686: xmlXPathObjectPtr
5687: xmlXPathConvertString(xmlXPathObjectPtr val) {
5688: xmlChar *res = NULL;
5689:
5690: if (val == NULL)
5691: return(xmlXPathNewCString(""));
5692:
5693: switch (val->type) {
5694: case XPATH_UNDEFINED:
5695: #ifdef DEBUG_EXPR
5696: xmlGenericError(xmlGenericErrorContext, "STRING: undefined\n");
5697: #endif
5698: break;
5699: case XPATH_NODESET:
5700: case XPATH_XSLT_TREE:
5701: res = xmlXPathCastNodeSetToString(val->nodesetval);
5702: break;
5703: case XPATH_STRING:
5704: return(val);
5705: case XPATH_BOOLEAN:
5706: res = xmlXPathCastBooleanToString(val->boolval);
5707: break;
5708: case XPATH_NUMBER:
5709: res = xmlXPathCastNumberToString(val->floatval);
5710: break;
5711: case XPATH_USERS:
5712: case XPATH_POINT:
5713: case XPATH_RANGE:
5714: case XPATH_LOCATIONSET:
5715: TODO;
5716: break;
5717: }
5718: xmlXPathFreeObject(val);
5719: if (res == NULL)
5720: return(xmlXPathNewCString(""));
5721: return(xmlXPathWrapString(res));
5722: }
5723:
5724: /**
5725: * xmlXPathCastBooleanToNumber:
5726: * @val: a boolean
5727: *
5728: * Converts a boolean to its number value
5729: *
5730: * Returns the number value
5731: */
5732: double
5733: xmlXPathCastBooleanToNumber(int val) {
5734: if (val)
5735: return(1.0);
5736: return(0.0);
5737: }
5738:
5739: /**
5740: * xmlXPathCastStringToNumber:
5741: * @val: a string
5742: *
5743: * Converts a string to its number value
5744: *
5745: * Returns the number value
5746: */
5747: double
5748: xmlXPathCastStringToNumber(const xmlChar * val) {
5749: return(xmlXPathStringEvalNumber(val));
5750: }
5751:
5752: /**
5753: * xmlXPathCastNodeToNumber:
5754: * @node: a node
5755: *
5756: * Converts a node to its number value
5757: *
5758: * Returns the number value
5759: */
5760: double
5761: xmlXPathCastNodeToNumber (xmlNodePtr node) {
5762: xmlChar *strval;
5763: double ret;
5764:
5765: if (node == NULL)
5766: return(xmlXPathNAN);
5767: strval = xmlXPathCastNodeToString(node);
5768: if (strval == NULL)
5769: return(xmlXPathNAN);
5770: ret = xmlXPathCastStringToNumber(strval);
5771: xmlFree(strval);
5772:
5773: return(ret);
5774: }
5775:
5776: /**
5777: * xmlXPathCastNodeSetToNumber:
5778: * @ns: a node-set
5779: *
5780: * Converts a node-set to its number value
5781: *
5782: * Returns the number value
5783: */
5784: double
5785: xmlXPathCastNodeSetToNumber (xmlNodeSetPtr ns) {
5786: xmlChar *str;
5787: double ret;
5788:
5789: if (ns == NULL)
5790: return(xmlXPathNAN);
5791: str = xmlXPathCastNodeSetToString(ns);
5792: ret = xmlXPathCastStringToNumber(str);
5793: xmlFree(str);
5794: return(ret);
5795: }
5796:
5797: /**
5798: * xmlXPathCastToNumber:
5799: * @val: an XPath object
5800: *
5801: * Converts an XPath object to its number value
5802: *
5803: * Returns the number value
5804: */
5805: double
5806: xmlXPathCastToNumber(xmlXPathObjectPtr val) {
5807: double ret = 0.0;
5808:
5809: if (val == NULL)
5810: return(xmlXPathNAN);
5811: switch (val->type) {
5812: case XPATH_UNDEFINED:
5813: #ifdef DEGUB_EXPR
5814: xmlGenericError(xmlGenericErrorContext, "NUMBER: undefined\n");
5815: #endif
5816: ret = xmlXPathNAN;
5817: break;
5818: case XPATH_NODESET:
5819: case XPATH_XSLT_TREE:
5820: ret = xmlXPathCastNodeSetToNumber(val->nodesetval);
5821: break;
5822: case XPATH_STRING:
5823: ret = xmlXPathCastStringToNumber(val->stringval);
5824: break;
5825: case XPATH_NUMBER:
5826: ret = val->floatval;
5827: break;
5828: case XPATH_BOOLEAN:
5829: ret = xmlXPathCastBooleanToNumber(val->boolval);
5830: break;
5831: case XPATH_USERS:
5832: case XPATH_POINT:
5833: case XPATH_RANGE:
5834: case XPATH_LOCATIONSET:
5835: TODO;
5836: ret = xmlXPathNAN;
5837: break;
5838: }
5839: return(ret);
5840: }
5841:
5842: /**
5843: * xmlXPathConvertNumber:
5844: * @val: an XPath object
5845: *
5846: * Converts an existing object to its number() equivalent
5847: *
5848: * Returns the new object, the old one is freed (or the operation
5849: * is done directly on @val)
5850: */
5851: xmlXPathObjectPtr
5852: xmlXPathConvertNumber(xmlXPathObjectPtr val) {
5853: xmlXPathObjectPtr ret;
5854:
5855: if (val == NULL)
5856: return(xmlXPathNewFloat(0.0));
5857: if (val->type == XPATH_NUMBER)
5858: return(val);
5859: ret = xmlXPathNewFloat(xmlXPathCastToNumber(val));
5860: xmlXPathFreeObject(val);
5861: return(ret);
5862: }
5863:
5864: /**
5865: * xmlXPathCastNumberToBoolean:
5866: * @val: a number
5867: *
5868: * Converts a number to its boolean value
5869: *
5870: * Returns the boolean value
5871: */
5872: int
5873: xmlXPathCastNumberToBoolean (double val) {
5874: if (xmlXPathIsNaN(val) || (val == 0.0))
5875: return(0);
5876: return(1);
5877: }
5878:
5879: /**
5880: * xmlXPathCastStringToBoolean:
5881: * @val: a string
5882: *
5883: * Converts a string to its boolean value
5884: *
5885: * Returns the boolean value
5886: */
5887: int
5888: xmlXPathCastStringToBoolean (const xmlChar *val) {
5889: if ((val == NULL) || (xmlStrlen(val) == 0))
5890: return(0);
5891: return(1);
5892: }
5893:
5894: /**
5895: * xmlXPathCastNodeSetToBoolean:
5896: * @ns: a node-set
5897: *
5898: * Converts a node-set to its boolean value
5899: *
5900: * Returns the boolean value
5901: */
5902: int
5903: xmlXPathCastNodeSetToBoolean (xmlNodeSetPtr ns) {
5904: if ((ns == NULL) || (ns->nodeNr == 0))
5905: return(0);
5906: return(1);
5907: }
5908:
5909: /**
5910: * xmlXPathCastToBoolean:
5911: * @val: an XPath object
5912: *
5913: * Converts an XPath object to its boolean value
5914: *
5915: * Returns the boolean value
5916: */
5917: int
5918: xmlXPathCastToBoolean (xmlXPathObjectPtr val) {
5919: int ret = 0;
5920:
5921: if (val == NULL)
5922: return(0);
5923: switch (val->type) {
5924: case XPATH_UNDEFINED:
5925: #ifdef DEBUG_EXPR
5926: xmlGenericError(xmlGenericErrorContext, "BOOLEAN: undefined\n");
5927: #endif
5928: ret = 0;
5929: break;
5930: case XPATH_NODESET:
5931: case XPATH_XSLT_TREE:
5932: ret = xmlXPathCastNodeSetToBoolean(val->nodesetval);
5933: break;
5934: case XPATH_STRING:
5935: ret = xmlXPathCastStringToBoolean(val->stringval);
5936: break;
5937: case XPATH_NUMBER:
5938: ret = xmlXPathCastNumberToBoolean(val->floatval);
5939: break;
5940: case XPATH_BOOLEAN:
5941: ret = val->boolval;
5942: break;
5943: case XPATH_USERS:
5944: case XPATH_POINT:
5945: case XPATH_RANGE:
5946: case XPATH_LOCATIONSET:
5947: TODO;
5948: ret = 0;
5949: break;
5950: }
5951: return(ret);
5952: }
5953:
5954:
5955: /**
5956: * xmlXPathConvertBoolean:
5957: * @val: an XPath object
5958: *
5959: * Converts an existing object to its boolean() equivalent
5960: *
5961: * Returns the new object, the old one is freed (or the operation
5962: * is done directly on @val)
5963: */
5964: xmlXPathObjectPtr
5965: xmlXPathConvertBoolean(xmlXPathObjectPtr val) {
5966: xmlXPathObjectPtr ret;
5967:
5968: if (val == NULL)
5969: return(xmlXPathNewBoolean(0));
5970: if (val->type == XPATH_BOOLEAN)
5971: return(val);
5972: ret = xmlXPathNewBoolean(xmlXPathCastToBoolean(val));
5973: xmlXPathFreeObject(val);
5974: return(ret);
5975: }
5976:
5977: /************************************************************************
5978: * *
5979: * Routines to handle XPath contexts *
5980: * *
5981: ************************************************************************/
5982:
5983: /**
5984: * xmlXPathNewContext:
5985: * @doc: the XML document
5986: *
5987: * Create a new xmlXPathContext
5988: *
5989: * Returns the xmlXPathContext just allocated. The caller will need to free it.
5990: */
5991: xmlXPathContextPtr
5992: xmlXPathNewContext(xmlDocPtr doc) {
5993: xmlXPathContextPtr ret;
5994:
5995: ret = (xmlXPathContextPtr) xmlMalloc(sizeof(xmlXPathContext));
5996: if (ret == NULL) {
5997: xmlXPathErrMemory(NULL, "creating context\n");
5998: return(NULL);
5999: }
6000: memset(ret, 0 , (size_t) sizeof(xmlXPathContext));
6001: ret->doc = doc;
6002: ret->node = NULL;
6003:
6004: ret->varHash = NULL;
6005:
6006: ret->nb_types = 0;
6007: ret->max_types = 0;
6008: ret->types = NULL;
6009:
6010: ret->funcHash = xmlHashCreate(0);
6011:
6012: ret->nb_axis = 0;
6013: ret->max_axis = 0;
6014: ret->axis = NULL;
6015:
6016: ret->nsHash = NULL;
6017: ret->user = NULL;
6018:
6019: ret->contextSize = -1;
6020: ret->proximityPosition = -1;
6021:
6022: #ifdef XP_DEFAULT_CACHE_ON
6023: if (xmlXPathContextSetCache(ret, 1, -1, 0) == -1) {
6024: xmlXPathFreeContext(ret);
6025: return(NULL);
6026: }
6027: #endif
6028:
6029: xmlXPathRegisterAllFunctions(ret);
6030:
6031: return(ret);
6032: }
6033:
6034: /**
6035: * xmlXPathFreeContext:
6036: * @ctxt: the context to free
6037: *
6038: * Free up an xmlXPathContext
6039: */
6040: void
6041: xmlXPathFreeContext(xmlXPathContextPtr ctxt) {
6042: if (ctxt == NULL) return;
6043:
6044: if (ctxt->cache != NULL)
6045: xmlXPathFreeCache((xmlXPathContextCachePtr) ctxt->cache);
6046: xmlXPathRegisteredNsCleanup(ctxt);
6047: xmlXPathRegisteredFuncsCleanup(ctxt);
6048: xmlXPathRegisteredVariablesCleanup(ctxt);
6049: xmlResetError(&ctxt->lastError);
6050: xmlFree(ctxt);
6051: }
6052:
6053: /************************************************************************
6054: * *
6055: * Routines to handle XPath parser contexts *
6056: * *
6057: ************************************************************************/
6058:
6059: #define CHECK_CTXT(ctxt) \
6060: if (ctxt == NULL) { \
6061: __xmlRaiseError(NULL, NULL, NULL, \
6062: NULL, NULL, XML_FROM_XPATH, \
6063: XML_ERR_INTERNAL_ERROR, XML_ERR_FATAL, \
6064: __FILE__, __LINE__, \
6065: NULL, NULL, NULL, 0, 0, \
6066: "NULL context pointer\n"); \
6067: return(NULL); \
6068: } \
6069:
6070: #define CHECK_CTXT_NEG(ctxt) \
6071: if (ctxt == NULL) { \
6072: __xmlRaiseError(NULL, NULL, NULL, \
6073: NULL, NULL, XML_FROM_XPATH, \
6074: XML_ERR_INTERNAL_ERROR, XML_ERR_FATAL, \
6075: __FILE__, __LINE__, \
6076: NULL, NULL, NULL, 0, 0, \
6077: "NULL context pointer\n"); \
6078: return(-1); \
6079: } \
6080:
6081:
6082: #define CHECK_CONTEXT(ctxt) \
6083: if ((ctxt == NULL) || (ctxt->doc == NULL) || \
6084: (ctxt->doc->children == NULL)) { \
6085: xmlXPatherror(ctxt, __FILE__, __LINE__, XPATH_INVALID_CTXT); \
6086: return(NULL); \
6087: }
6088:
6089:
6090: /**
6091: * xmlXPathNewParserContext:
6092: * @str: the XPath expression
6093: * @ctxt: the XPath context
6094: *
6095: * Create a new xmlXPathParserContext
6096: *
6097: * Returns the xmlXPathParserContext just allocated.
6098: */
6099: xmlXPathParserContextPtr
6100: xmlXPathNewParserContext(const xmlChar *str, xmlXPathContextPtr ctxt) {
6101: xmlXPathParserContextPtr ret;
6102:
6103: ret = (xmlXPathParserContextPtr) xmlMalloc(sizeof(xmlXPathParserContext));
6104: if (ret == NULL) {
6105: xmlXPathErrMemory(ctxt, "creating parser context\n");
6106: return(NULL);
6107: }
6108: memset(ret, 0 , (size_t) sizeof(xmlXPathParserContext));
6109: ret->cur = ret->base = str;
6110: ret->context = ctxt;
6111:
6112: ret->comp = xmlXPathNewCompExpr();
6113: if (ret->comp == NULL) {
6114: xmlFree(ret->valueTab);
6115: xmlFree(ret);
6116: return(NULL);
6117: }
6118: if ((ctxt != NULL) && (ctxt->dict != NULL)) {
6119: ret->comp->dict = ctxt->dict;
6120: xmlDictReference(ret->comp->dict);
6121: }
6122:
6123: return(ret);
6124: }
6125:
6126: /**
6127: * xmlXPathCompParserContext:
6128: * @comp: the XPath compiled expression
6129: * @ctxt: the XPath context
6130: *
6131: * Create a new xmlXPathParserContext when processing a compiled expression
6132: *
6133: * Returns the xmlXPathParserContext just allocated.
6134: */
6135: static xmlXPathParserContextPtr
6136: xmlXPathCompParserContext(xmlXPathCompExprPtr comp, xmlXPathContextPtr ctxt) {
6137: xmlXPathParserContextPtr ret;
6138:
6139: ret = (xmlXPathParserContextPtr) xmlMalloc(sizeof(xmlXPathParserContext));
6140: if (ret == NULL) {
6141: xmlXPathErrMemory(ctxt, "creating evaluation context\n");
6142: return(NULL);
6143: }
6144: memset(ret, 0 , (size_t) sizeof(xmlXPathParserContext));
6145:
6146: /* Allocate the value stack */
6147: ret->valueTab = (xmlXPathObjectPtr *)
6148: xmlMalloc(10 * sizeof(xmlXPathObjectPtr));
6149: if (ret->valueTab == NULL) {
6150: xmlFree(ret);
6151: xmlXPathErrMemory(ctxt, "creating evaluation context\n");
6152: return(NULL);
6153: }
6154: ret->valueNr = 0;
6155: ret->valueMax = 10;
6156: ret->value = NULL;
6157:
6158: ret->context = ctxt;
6159: ret->comp = comp;
6160:
6161: return(ret);
6162: }
6163:
6164: /**
6165: * xmlXPathFreeParserContext:
6166: * @ctxt: the context to free
6167: *
6168: * Free up an xmlXPathParserContext
6169: */
6170: void
6171: xmlXPathFreeParserContext(xmlXPathParserContextPtr ctxt) {
6172: if (ctxt->valueTab != NULL) {
6173: xmlFree(ctxt->valueTab);
6174: }
6175: if (ctxt->comp != NULL) {
6176: #ifdef XPATH_STREAMING
6177: if (ctxt->comp->stream != NULL) {
6178: xmlFreePatternList(ctxt->comp->stream);
6179: ctxt->comp->stream = NULL;
6180: }
6181: #endif
6182: xmlXPathFreeCompExpr(ctxt->comp);
6183: }
6184: xmlFree(ctxt);
6185: }
6186:
6187: /************************************************************************
6188: * *
6189: * The implicit core function library *
6190: * *
6191: ************************************************************************/
6192:
6193: /**
6194: * xmlXPathNodeValHash:
6195: * @node: a node pointer
6196: *
6197: * Function computing the beginning of the string value of the node,
6198: * used to speed up comparisons
6199: *
6200: * Returns an int usable as a hash
6201: */
6202: static unsigned int
6203: xmlXPathNodeValHash(xmlNodePtr node) {
6204: int len = 2;
6205: const xmlChar * string = NULL;
6206: xmlNodePtr tmp = NULL;
6207: unsigned int ret = 0;
6208:
6209: if (node == NULL)
6210: return(0);
6211:
6212: if (node->type == XML_DOCUMENT_NODE) {
6213: tmp = xmlDocGetRootElement((xmlDocPtr) node);
6214: if (tmp == NULL)
6215: node = node->children;
6216: else
6217: node = tmp;
6218:
6219: if (node == NULL)
6220: return(0);
6221: }
6222:
6223: switch (node->type) {
6224: case XML_COMMENT_NODE:
6225: case XML_PI_NODE:
6226: case XML_CDATA_SECTION_NODE:
6227: case XML_TEXT_NODE:
6228: string = node->content;
6229: if (string == NULL)
6230: return(0);
6231: if (string[0] == 0)
6232: return(0);
6233: return(((unsigned int) string[0]) +
6234: (((unsigned int) string[1]) << 8));
6235: case XML_NAMESPACE_DECL:
6236: string = ((xmlNsPtr)node)->href;
6237: if (string == NULL)
6238: return(0);
6239: if (string[0] == 0)
6240: return(0);
6241: return(((unsigned int) string[0]) +
6242: (((unsigned int) string[1]) << 8));
6243: case XML_ATTRIBUTE_NODE:
6244: tmp = ((xmlAttrPtr) node)->children;
6245: break;
6246: case XML_ELEMENT_NODE:
6247: tmp = node->children;
6248: break;
6249: default:
6250: return(0);
6251: }
6252: while (tmp != NULL) {
6253: switch (tmp->type) {
6254: case XML_COMMENT_NODE:
6255: case XML_PI_NODE:
6256: case XML_CDATA_SECTION_NODE:
6257: case XML_TEXT_NODE:
6258: string = tmp->content;
6259: break;
6260: case XML_NAMESPACE_DECL:
6261: string = ((xmlNsPtr)tmp)->href;
6262: break;
6263: default:
6264: break;
6265: }
6266: if ((string != NULL) && (string[0] != 0)) {
6267: if (len == 1) {
6268: return(ret + (((unsigned int) string[0]) << 8));
6269: }
6270: if (string[1] == 0) {
6271: len = 1;
6272: ret = (unsigned int) string[0];
6273: } else {
6274: return(((unsigned int) string[0]) +
6275: (((unsigned int) string[1]) << 8));
6276: }
6277: }
6278: /*
6279: * Skip to next node
6280: */
6281: if ((tmp->children != NULL) && (tmp->type != XML_DTD_NODE)) {
6282: if (tmp->children->type != XML_ENTITY_DECL) {
6283: tmp = tmp->children;
6284: continue;
6285: }
6286: }
6287: if (tmp == node)
6288: break;
6289:
6290: if (tmp->next != NULL) {
6291: tmp = tmp->next;
6292: continue;
6293: }
6294:
6295: do {
6296: tmp = tmp->parent;
6297: if (tmp == NULL)
6298: break;
6299: if (tmp == node) {
6300: tmp = NULL;
6301: break;
6302: }
6303: if (tmp->next != NULL) {
6304: tmp = tmp->next;
6305: break;
6306: }
6307: } while (tmp != NULL);
6308: }
6309: return(ret);
6310: }
6311:
6312: /**
6313: * xmlXPathStringHash:
6314: * @string: a string
6315: *
6316: * Function computing the beginning of the string value of the node,
6317: * used to speed up comparisons
6318: *
6319: * Returns an int usable as a hash
6320: */
6321: static unsigned int
6322: xmlXPathStringHash(const xmlChar * string) {
6323: if (string == NULL)
6324: return((unsigned int) 0);
6325: if (string[0] == 0)
6326: return(0);
6327: return(((unsigned int) string[0]) +
6328: (((unsigned int) string[1]) << 8));
6329: }
6330:
6331: /**
6332: * xmlXPathCompareNodeSetFloat:
6333: * @ctxt: the XPath Parser context
6334: * @inf: less than (1) or greater than (0)
6335: * @strict: is the comparison strict
6336: * @arg: the node set
6337: * @f: the value
6338: *
6339: * Implement the compare operation between a nodeset and a number
6340: * @ns < @val (1, 1, ...
6341: * @ns <= @val (1, 0, ...
6342: * @ns > @val (0, 1, ...
6343: * @ns >= @val (0, 0, ...
6344: *
6345: * If one object to be compared is a node-set and the other is a number,
6346: * then the comparison will be true if and only if there is a node in the
6347: * node-set such that the result of performing the comparison on the number
6348: * to be compared and on the result of converting the string-value of that
6349: * node to a number using the number function is true.
6350: *
6351: * Returns 0 or 1 depending on the results of the test.
6352: */
6353: static int
6354: xmlXPathCompareNodeSetFloat(xmlXPathParserContextPtr ctxt, int inf, int strict,
6355: xmlXPathObjectPtr arg, xmlXPathObjectPtr f) {
6356: int i, ret = 0;
6357: xmlNodeSetPtr ns;
6358: xmlChar *str2;
6359:
6360: if ((f == NULL) || (arg == NULL) ||
6361: ((arg->type != XPATH_NODESET) && (arg->type != XPATH_XSLT_TREE))) {
6362: xmlXPathReleaseObject(ctxt->context, arg);
6363: xmlXPathReleaseObject(ctxt->context, f);
6364: return(0);
6365: }
6366: ns = arg->nodesetval;
6367: if (ns != NULL) {
6368: for (i = 0;i < ns->nodeNr;i++) {
6369: str2 = xmlXPathCastNodeToString(ns->nodeTab[i]);
6370: if (str2 != NULL) {
6371: valuePush(ctxt,
6372: xmlXPathCacheNewString(ctxt->context, str2));
6373: xmlFree(str2);
6374: xmlXPathNumberFunction(ctxt, 1);
6375: valuePush(ctxt, xmlXPathCacheObjectCopy(ctxt->context, f));
6376: ret = xmlXPathCompareValues(ctxt, inf, strict);
6377: if (ret)
6378: break;
6379: }
6380: }
6381: }
6382: xmlXPathReleaseObject(ctxt->context, arg);
6383: xmlXPathReleaseObject(ctxt->context, f);
6384: return(ret);
6385: }
6386:
6387: /**
6388: * xmlXPathCompareNodeSetString:
6389: * @ctxt: the XPath Parser context
6390: * @inf: less than (1) or greater than (0)
6391: * @strict: is the comparison strict
6392: * @arg: the node set
6393: * @s: the value
6394: *
6395: * Implement the compare operation between a nodeset and a string
6396: * @ns < @val (1, 1, ...
6397: * @ns <= @val (1, 0, ...
6398: * @ns > @val (0, 1, ...
6399: * @ns >= @val (0, 0, ...
6400: *
6401: * If one object to be compared is a node-set and the other is a string,
6402: * then the comparison will be true if and only if there is a node in
6403: * the node-set such that the result of performing the comparison on the
6404: * string-value of the node and the other string is true.
6405: *
6406: * Returns 0 or 1 depending on the results of the test.
6407: */
6408: static int
6409: xmlXPathCompareNodeSetString(xmlXPathParserContextPtr ctxt, int inf, int strict,
6410: xmlXPathObjectPtr arg, xmlXPathObjectPtr s) {
6411: int i, ret = 0;
6412: xmlNodeSetPtr ns;
6413: xmlChar *str2;
6414:
6415: if ((s == NULL) || (arg == NULL) ||
6416: ((arg->type != XPATH_NODESET) && (arg->type != XPATH_XSLT_TREE))) {
6417: xmlXPathReleaseObject(ctxt->context, arg);
6418: xmlXPathReleaseObject(ctxt->context, s);
6419: return(0);
6420: }
6421: ns = arg->nodesetval;
6422: if (ns != NULL) {
6423: for (i = 0;i < ns->nodeNr;i++) {
6424: str2 = xmlXPathCastNodeToString(ns->nodeTab[i]);
6425: if (str2 != NULL) {
6426: valuePush(ctxt,
6427: xmlXPathCacheNewString(ctxt->context, str2));
6428: xmlFree(str2);
6429: valuePush(ctxt, xmlXPathCacheObjectCopy(ctxt->context, s));
6430: ret = xmlXPathCompareValues(ctxt, inf, strict);
6431: if (ret)
6432: break;
6433: }
6434: }
6435: }
6436: xmlXPathReleaseObject(ctxt->context, arg);
6437: xmlXPathReleaseObject(ctxt->context, s);
6438: return(ret);
6439: }
6440:
6441: /**
6442: * xmlXPathCompareNodeSets:
6443: * @inf: less than (1) or greater than (0)
6444: * @strict: is the comparison strict
6445: * @arg1: the first node set object
6446: * @arg2: the second node set object
6447: *
6448: * Implement the compare operation on nodesets:
6449: *
6450: * If both objects to be compared are node-sets, then the comparison
6451: * will be true if and only if there is a node in the first node-set
6452: * and a node in the second node-set such that the result of performing
6453: * the comparison on the string-values of the two nodes is true.
6454: * ....
6455: * When neither object to be compared is a node-set and the operator
6456: * is <=, <, >= or >, then the objects are compared by converting both
6457: * objects to numbers and comparing the numbers according to IEEE 754.
6458: * ....
6459: * The number function converts its argument to a number as follows:
6460: * - a string that consists of optional whitespace followed by an
6461: * optional minus sign followed by a Number followed by whitespace
6462: * is converted to the IEEE 754 number that is nearest (according
6463: * to the IEEE 754 round-to-nearest rule) to the mathematical value
6464: * represented by the string; any other string is converted to NaN
6465: *
6466: * Conclusion all nodes need to be converted first to their string value
6467: * and then the comparison must be done when possible
6468: */
6469: static int
6470: xmlXPathCompareNodeSets(int inf, int strict,
6471: xmlXPathObjectPtr arg1, xmlXPathObjectPtr arg2) {
6472: int i, j, init = 0;
6473: double val1;
6474: double *values2;
6475: int ret = 0;
6476: xmlNodeSetPtr ns1;
6477: xmlNodeSetPtr ns2;
6478:
6479: if ((arg1 == NULL) ||
6480: ((arg1->type != XPATH_NODESET) && (arg1->type != XPATH_XSLT_TREE))) {
6481: xmlXPathFreeObject(arg2);
6482: return(0);
6483: }
6484: if ((arg2 == NULL) ||
6485: ((arg2->type != XPATH_NODESET) && (arg2->type != XPATH_XSLT_TREE))) {
6486: xmlXPathFreeObject(arg1);
6487: xmlXPathFreeObject(arg2);
6488: return(0);
6489: }
6490:
6491: ns1 = arg1->nodesetval;
6492: ns2 = arg2->nodesetval;
6493:
6494: if ((ns1 == NULL) || (ns1->nodeNr <= 0)) {
6495: xmlXPathFreeObject(arg1);
6496: xmlXPathFreeObject(arg2);
6497: return(0);
6498: }
6499: if ((ns2 == NULL) || (ns2->nodeNr <= 0)) {
6500: xmlXPathFreeObject(arg1);
6501: xmlXPathFreeObject(arg2);
6502: return(0);
6503: }
6504:
6505: values2 = (double *) xmlMalloc(ns2->nodeNr * sizeof(double));
6506: if (values2 == NULL) {
6507: xmlXPathErrMemory(NULL, "comparing nodesets\n");
6508: xmlXPathFreeObject(arg1);
6509: xmlXPathFreeObject(arg2);
6510: return(0);
6511: }
6512: for (i = 0;i < ns1->nodeNr;i++) {
6513: val1 = xmlXPathCastNodeToNumber(ns1->nodeTab[i]);
6514: if (xmlXPathIsNaN(val1))
6515: continue;
6516: for (j = 0;j < ns2->nodeNr;j++) {
6517: if (init == 0) {
6518: values2[j] = xmlXPathCastNodeToNumber(ns2->nodeTab[j]);
6519: }
6520: if (xmlXPathIsNaN(values2[j]))
6521: continue;
6522: if (inf && strict)
6523: ret = (val1 < values2[j]);
6524: else if (inf && !strict)
6525: ret = (val1 <= values2[j]);
6526: else if (!inf && strict)
6527: ret = (val1 > values2[j]);
6528: else if (!inf && !strict)
6529: ret = (val1 >= values2[j]);
6530: if (ret)
6531: break;
6532: }
6533: if (ret)
6534: break;
6535: init = 1;
6536: }
6537: xmlFree(values2);
6538: xmlXPathFreeObject(arg1);
6539: xmlXPathFreeObject(arg2);
6540: return(ret);
6541: }
6542:
6543: /**
6544: * xmlXPathCompareNodeSetValue:
6545: * @ctxt: the XPath Parser context
6546: * @inf: less than (1) or greater than (0)
6547: * @strict: is the comparison strict
6548: * @arg: the node set
6549: * @val: the value
6550: *
6551: * Implement the compare operation between a nodeset and a value
6552: * @ns < @val (1, 1, ...
6553: * @ns <= @val (1, 0, ...
6554: * @ns > @val (0, 1, ...
6555: * @ns >= @val (0, 0, ...
6556: *
6557: * If one object to be compared is a node-set and the other is a boolean,
6558: * then the comparison will be true if and only if the result of performing
6559: * the comparison on the boolean and on the result of converting
6560: * the node-set to a boolean using the boolean function is true.
6561: *
6562: * Returns 0 or 1 depending on the results of the test.
6563: */
6564: static int
6565: xmlXPathCompareNodeSetValue(xmlXPathParserContextPtr ctxt, int inf, int strict,
6566: xmlXPathObjectPtr arg, xmlXPathObjectPtr val) {
6567: if ((val == NULL) || (arg == NULL) ||
6568: ((arg->type != XPATH_NODESET) && (arg->type != XPATH_XSLT_TREE)))
6569: return(0);
6570:
6571: switch(val->type) {
6572: case XPATH_NUMBER:
6573: return(xmlXPathCompareNodeSetFloat(ctxt, inf, strict, arg, val));
6574: case XPATH_NODESET:
6575: case XPATH_XSLT_TREE:
6576: return(xmlXPathCompareNodeSets(inf, strict, arg, val));
6577: case XPATH_STRING:
6578: return(xmlXPathCompareNodeSetString(ctxt, inf, strict, arg, val));
6579: case XPATH_BOOLEAN:
6580: valuePush(ctxt, arg);
6581: xmlXPathBooleanFunction(ctxt, 1);
6582: valuePush(ctxt, val);
6583: return(xmlXPathCompareValues(ctxt, inf, strict));
6584: default:
6585: TODO
6586: }
6587: return(0);
6588: }
6589:
6590: /**
6591: * xmlXPathEqualNodeSetString:
6592: * @arg: the nodeset object argument
6593: * @str: the string to compare to.
6594: * @neq: flag to show whether for '=' (0) or '!=' (1)
6595: *
6596: * Implement the equal operation on XPath objects content: @arg1 == @arg2
6597: * If one object to be compared is a node-set and the other is a string,
6598: * then the comparison will be true if and only if there is a node in
6599: * the node-set such that the result of performing the comparison on the
6600: * string-value of the node and the other string is true.
6601: *
6602: * Returns 0 or 1 depending on the results of the test.
6603: */
6604: static int
6605: xmlXPathEqualNodeSetString(xmlXPathObjectPtr arg, const xmlChar * str, int neq)
6606: {
6607: int i;
6608: xmlNodeSetPtr ns;
6609: xmlChar *str2;
6610: unsigned int hash;
6611:
6612: if ((str == NULL) || (arg == NULL) ||
6613: ((arg->type != XPATH_NODESET) && (arg->type != XPATH_XSLT_TREE)))
6614: return (0);
6615: ns = arg->nodesetval;
6616: /*
6617: * A NULL nodeset compared with a string is always false
6618: * (since there is no node equal, and no node not equal)
6619: */
6620: if ((ns == NULL) || (ns->nodeNr <= 0) )
6621: return (0);
6622: hash = xmlXPathStringHash(str);
6623: for (i = 0; i < ns->nodeNr; i++) {
6624: if (xmlXPathNodeValHash(ns->nodeTab[i]) == hash) {
6625: str2 = xmlNodeGetContent(ns->nodeTab[i]);
6626: if ((str2 != NULL) && (xmlStrEqual(str, str2))) {
6627: xmlFree(str2);
6628: if (neq)
6629: continue;
6630: return (1);
6631: } else if ((str2 == NULL) && (xmlStrEqual(str, BAD_CAST ""))) {
6632: if (neq)
6633: continue;
6634: return (1);
6635: } else if (neq) {
6636: if (str2 != NULL)
6637: xmlFree(str2);
6638: return (1);
6639: }
6640: if (str2 != NULL)
6641: xmlFree(str2);
6642: } else if (neq)
6643: return (1);
6644: }
6645: return (0);
6646: }
6647:
6648: /**
6649: * xmlXPathEqualNodeSetFloat:
6650: * @arg: the nodeset object argument
6651: * @f: the float to compare to
6652: * @neq: flag to show whether to compare '=' (0) or '!=' (1)
6653: *
6654: * Implement the equal operation on XPath objects content: @arg1 == @arg2
6655: * If one object to be compared is a node-set and the other is a number,
6656: * then the comparison will be true if and only if there is a node in
6657: * the node-set such that the result of performing the comparison on the
6658: * number to be compared and on the result of converting the string-value
6659: * of that node to a number using the number function is true.
6660: *
6661: * Returns 0 or 1 depending on the results of the test.
6662: */
6663: static int
6664: xmlXPathEqualNodeSetFloat(xmlXPathParserContextPtr ctxt,
6665: xmlXPathObjectPtr arg, double f, int neq) {
6666: int i, ret=0;
6667: xmlNodeSetPtr ns;
6668: xmlChar *str2;
6669: xmlXPathObjectPtr val;
6670: double v;
6671:
6672: if ((arg == NULL) ||
6673: ((arg->type != XPATH_NODESET) && (arg->type != XPATH_XSLT_TREE)))
6674: return(0);
6675:
6676: ns = arg->nodesetval;
6677: if (ns != NULL) {
6678: for (i=0;i<ns->nodeNr;i++) {
6679: str2 = xmlXPathCastNodeToString(ns->nodeTab[i]);
6680: if (str2 != NULL) {
6681: valuePush(ctxt, xmlXPathCacheNewString(ctxt->context, str2));
6682: xmlFree(str2);
6683: xmlXPathNumberFunction(ctxt, 1);
6684: val = valuePop(ctxt);
6685: v = val->floatval;
6686: xmlXPathReleaseObject(ctxt->context, val);
6687: if (!xmlXPathIsNaN(v)) {
6688: if ((!neq) && (v==f)) {
6689: ret = 1;
6690: break;
6691: } else if ((neq) && (v!=f)) {
6692: ret = 1;
6693: break;
6694: }
6695: } else { /* NaN is unequal to any value */
6696: if (neq)
6697: ret = 1;
6698: }
6699: }
6700: }
6701: }
6702:
6703: return(ret);
6704: }
6705:
6706:
6707: /**
6708: * xmlXPathEqualNodeSets:
6709: * @arg1: first nodeset object argument
6710: * @arg2: second nodeset object argument
6711: * @neq: flag to show whether to test '=' (0) or '!=' (1)
6712: *
6713: * Implement the equal / not equal operation on XPath nodesets:
6714: * @arg1 == @arg2 or @arg1 != @arg2
6715: * If both objects to be compared are node-sets, then the comparison
6716: * will be true if and only if there is a node in the first node-set and
6717: * a node in the second node-set such that the result of performing the
6718: * comparison on the string-values of the two nodes is true.
6719: *
6720: * (needless to say, this is a costly operation)
6721: *
6722: * Returns 0 or 1 depending on the results of the test.
6723: */
6724: static int
6725: xmlXPathEqualNodeSets(xmlXPathObjectPtr arg1, xmlXPathObjectPtr arg2, int neq) {
6726: int i, j;
6727: unsigned int *hashs1;
6728: unsigned int *hashs2;
6729: xmlChar **values1;
6730: xmlChar **values2;
6731: int ret = 0;
6732: xmlNodeSetPtr ns1;
6733: xmlNodeSetPtr ns2;
6734:
6735: if ((arg1 == NULL) ||
6736: ((arg1->type != XPATH_NODESET) && (arg1->type != XPATH_XSLT_TREE)))
6737: return(0);
6738: if ((arg2 == NULL) ||
6739: ((arg2->type != XPATH_NODESET) && (arg2->type != XPATH_XSLT_TREE)))
6740: return(0);
6741:
6742: ns1 = arg1->nodesetval;
6743: ns2 = arg2->nodesetval;
6744:
6745: if ((ns1 == NULL) || (ns1->nodeNr <= 0))
6746: return(0);
6747: if ((ns2 == NULL) || (ns2->nodeNr <= 0))
6748: return(0);
6749:
6750: /*
6751: * for equal, check if there is a node pertaining to both sets
6752: */
6753: if (neq == 0)
6754: for (i = 0;i < ns1->nodeNr;i++)
6755: for (j = 0;j < ns2->nodeNr;j++)
6756: if (ns1->nodeTab[i] == ns2->nodeTab[j])
6757: return(1);
6758:
6759: values1 = (xmlChar **) xmlMalloc(ns1->nodeNr * sizeof(xmlChar *));
6760: if (values1 == NULL) {
6761: xmlXPathErrMemory(NULL, "comparing nodesets\n");
6762: return(0);
6763: }
6764: hashs1 = (unsigned int *) xmlMalloc(ns1->nodeNr * sizeof(unsigned int));
6765: if (hashs1 == NULL) {
6766: xmlXPathErrMemory(NULL, "comparing nodesets\n");
6767: xmlFree(values1);
6768: return(0);
6769: }
6770: memset(values1, 0, ns1->nodeNr * sizeof(xmlChar *));
6771: values2 = (xmlChar **) xmlMalloc(ns2->nodeNr * sizeof(xmlChar *));
6772: if (values2 == NULL) {
6773: xmlXPathErrMemory(NULL, "comparing nodesets\n");
6774: xmlFree(hashs1);
6775: xmlFree(values1);
6776: return(0);
6777: }
6778: hashs2 = (unsigned int *) xmlMalloc(ns2->nodeNr * sizeof(unsigned int));
6779: if (hashs2 == NULL) {
6780: xmlXPathErrMemory(NULL, "comparing nodesets\n");
6781: xmlFree(hashs1);
6782: xmlFree(values1);
6783: xmlFree(values2);
6784: return(0);
6785: }
6786: memset(values2, 0, ns2->nodeNr * sizeof(xmlChar *));
6787: for (i = 0;i < ns1->nodeNr;i++) {
6788: hashs1[i] = xmlXPathNodeValHash(ns1->nodeTab[i]);
6789: for (j = 0;j < ns2->nodeNr;j++) {
6790: if (i == 0)
6791: hashs2[j] = xmlXPathNodeValHash(ns2->nodeTab[j]);
6792: if (hashs1[i] != hashs2[j]) {
6793: if (neq) {
6794: ret = 1;
6795: break;
6796: }
6797: }
6798: else {
6799: if (values1[i] == NULL)
6800: values1[i] = xmlNodeGetContent(ns1->nodeTab[i]);
6801: if (values2[j] == NULL)
6802: values2[j] = xmlNodeGetContent(ns2->nodeTab[j]);
6803: ret = xmlStrEqual(values1[i], values2[j]) ^ neq;
6804: if (ret)
6805: break;
6806: }
6807: }
6808: if (ret)
6809: break;
6810: }
6811: for (i = 0;i < ns1->nodeNr;i++)
6812: if (values1[i] != NULL)
6813: xmlFree(values1[i]);
6814: for (j = 0;j < ns2->nodeNr;j++)
6815: if (values2[j] != NULL)
6816: xmlFree(values2[j]);
6817: xmlFree(values1);
6818: xmlFree(values2);
6819: xmlFree(hashs1);
6820: xmlFree(hashs2);
6821: return(ret);
6822: }
6823:
6824: static int
6825: xmlXPathEqualValuesCommon(xmlXPathParserContextPtr ctxt,
6826: xmlXPathObjectPtr arg1, xmlXPathObjectPtr arg2) {
6827: int ret = 0;
6828: /*
6829: *At this point we are assured neither arg1 nor arg2
6830: *is a nodeset, so we can just pick the appropriate routine.
6831: */
6832: switch (arg1->type) {
6833: case XPATH_UNDEFINED:
6834: #ifdef DEBUG_EXPR
6835: xmlGenericError(xmlGenericErrorContext,
6836: "Equal: undefined\n");
6837: #endif
6838: break;
6839: case XPATH_BOOLEAN:
6840: switch (arg2->type) {
6841: case XPATH_UNDEFINED:
6842: #ifdef DEBUG_EXPR
6843: xmlGenericError(xmlGenericErrorContext,
6844: "Equal: undefined\n");
6845: #endif
6846: break;
6847: case XPATH_BOOLEAN:
6848: #ifdef DEBUG_EXPR
6849: xmlGenericError(xmlGenericErrorContext,
6850: "Equal: %d boolean %d \n",
6851: arg1->boolval, arg2->boolval);
6852: #endif
6853: ret = (arg1->boolval == arg2->boolval);
6854: break;
6855: case XPATH_NUMBER:
6856: ret = (arg1->boolval ==
6857: xmlXPathCastNumberToBoolean(arg2->floatval));
6858: break;
6859: case XPATH_STRING:
6860: if ((arg2->stringval == NULL) ||
6861: (arg2->stringval[0] == 0)) ret = 0;
6862: else
6863: ret = 1;
6864: ret = (arg1->boolval == ret);
6865: break;
6866: case XPATH_USERS:
6867: case XPATH_POINT:
6868: case XPATH_RANGE:
6869: case XPATH_LOCATIONSET:
6870: TODO
6871: break;
6872: case XPATH_NODESET:
6873: case XPATH_XSLT_TREE:
6874: break;
6875: }
6876: break;
6877: case XPATH_NUMBER:
6878: switch (arg2->type) {
6879: case XPATH_UNDEFINED:
6880: #ifdef DEBUG_EXPR
6881: xmlGenericError(xmlGenericErrorContext,
6882: "Equal: undefined\n");
6883: #endif
6884: break;
6885: case XPATH_BOOLEAN:
6886: ret = (arg2->boolval==
6887: xmlXPathCastNumberToBoolean(arg1->floatval));
6888: break;
6889: case XPATH_STRING:
6890: valuePush(ctxt, arg2);
6891: xmlXPathNumberFunction(ctxt, 1);
6892: arg2 = valuePop(ctxt);
6893: /* no break on purpose */
6894: case XPATH_NUMBER:
6895: /* Hand check NaN and Infinity equalities */
6896: if (xmlXPathIsNaN(arg1->floatval) ||
6897: xmlXPathIsNaN(arg2->floatval)) {
6898: ret = 0;
6899: } else if (xmlXPathIsInf(arg1->floatval) == 1) {
6900: if (xmlXPathIsInf(arg2->floatval) == 1)
6901: ret = 1;
6902: else
6903: ret = 0;
6904: } else if (xmlXPathIsInf(arg1->floatval) == -1) {
6905: if (xmlXPathIsInf(arg2->floatval) == -1)
6906: ret = 1;
6907: else
6908: ret = 0;
6909: } else if (xmlXPathIsInf(arg2->floatval) == 1) {
6910: if (xmlXPathIsInf(arg1->floatval) == 1)
6911: ret = 1;
6912: else
6913: ret = 0;
6914: } else if (xmlXPathIsInf(arg2->floatval) == -1) {
6915: if (xmlXPathIsInf(arg1->floatval) == -1)
6916: ret = 1;
6917: else
6918: ret = 0;
6919: } else {
6920: ret = (arg1->floatval == arg2->floatval);
6921: }
6922: break;
6923: case XPATH_USERS:
6924: case XPATH_POINT:
6925: case XPATH_RANGE:
6926: case XPATH_LOCATIONSET:
6927: TODO
6928: break;
6929: case XPATH_NODESET:
6930: case XPATH_XSLT_TREE:
6931: break;
6932: }
6933: break;
6934: case XPATH_STRING:
6935: switch (arg2->type) {
6936: case XPATH_UNDEFINED:
6937: #ifdef DEBUG_EXPR
6938: xmlGenericError(xmlGenericErrorContext,
6939: "Equal: undefined\n");
6940: #endif
6941: break;
6942: case XPATH_BOOLEAN:
6943: if ((arg1->stringval == NULL) ||
6944: (arg1->stringval[0] == 0)) ret = 0;
6945: else
6946: ret = 1;
6947: ret = (arg2->boolval == ret);
6948: break;
6949: case XPATH_STRING:
6950: ret = xmlStrEqual(arg1->stringval, arg2->stringval);
6951: break;
6952: case XPATH_NUMBER:
6953: valuePush(ctxt, arg1);
6954: xmlXPathNumberFunction(ctxt, 1);
6955: arg1 = valuePop(ctxt);
6956: /* Hand check NaN and Infinity equalities */
6957: if (xmlXPathIsNaN(arg1->floatval) ||
6958: xmlXPathIsNaN(arg2->floatval)) {
6959: ret = 0;
6960: } else if (xmlXPathIsInf(arg1->floatval) == 1) {
6961: if (xmlXPathIsInf(arg2->floatval) == 1)
6962: ret = 1;
6963: else
6964: ret = 0;
6965: } else if (xmlXPathIsInf(arg1->floatval) == -1) {
6966: if (xmlXPathIsInf(arg2->floatval) == -1)
6967: ret = 1;
6968: else
6969: ret = 0;
6970: } else if (xmlXPathIsInf(arg2->floatval) == 1) {
6971: if (xmlXPathIsInf(arg1->floatval) == 1)
6972: ret = 1;
6973: else
6974: ret = 0;
6975: } else if (xmlXPathIsInf(arg2->floatval) == -1) {
6976: if (xmlXPathIsInf(arg1->floatval) == -1)
6977: ret = 1;
6978: else
6979: ret = 0;
6980: } else {
6981: ret = (arg1->floatval == arg2->floatval);
6982: }
6983: break;
6984: case XPATH_USERS:
6985: case XPATH_POINT:
6986: case XPATH_RANGE:
6987: case XPATH_LOCATIONSET:
6988: TODO
6989: break;
6990: case XPATH_NODESET:
6991: case XPATH_XSLT_TREE:
6992: break;
6993: }
6994: break;
6995: case XPATH_USERS:
6996: case XPATH_POINT:
6997: case XPATH_RANGE:
6998: case XPATH_LOCATIONSET:
6999: TODO
7000: break;
7001: case XPATH_NODESET:
7002: case XPATH_XSLT_TREE:
7003: break;
7004: }
7005: xmlXPathReleaseObject(ctxt->context, arg1);
7006: xmlXPathReleaseObject(ctxt->context, arg2);
7007: return(ret);
7008: }
7009:
7010: /**
7011: * xmlXPathEqualValues:
7012: * @ctxt: the XPath Parser context
7013: *
7014: * Implement the equal operation on XPath objects content: @arg1 == @arg2
7015: *
7016: * Returns 0 or 1 depending on the results of the test.
7017: */
7018: int
7019: xmlXPathEqualValues(xmlXPathParserContextPtr ctxt) {
7020: xmlXPathObjectPtr arg1, arg2, argtmp;
7021: int ret = 0;
7022:
7023: if ((ctxt == NULL) || (ctxt->context == NULL)) return(0);
7024: arg2 = valuePop(ctxt);
7025: arg1 = valuePop(ctxt);
7026: if ((arg1 == NULL) || (arg2 == NULL)) {
7027: if (arg1 != NULL)
7028: xmlXPathReleaseObject(ctxt->context, arg1);
7029: else
7030: xmlXPathReleaseObject(ctxt->context, arg2);
7031: XP_ERROR0(XPATH_INVALID_OPERAND);
7032: }
7033:
7034: if (arg1 == arg2) {
7035: #ifdef DEBUG_EXPR
7036: xmlGenericError(xmlGenericErrorContext,
7037: "Equal: by pointer\n");
7038: #endif
7039: xmlXPathFreeObject(arg1);
7040: return(1);
7041: }
7042:
7043: /*
7044: *If either argument is a nodeset, it's a 'special case'
7045: */
7046: if ((arg2->type == XPATH_NODESET) || (arg2->type == XPATH_XSLT_TREE) ||
7047: (arg1->type == XPATH_NODESET) || (arg1->type == XPATH_XSLT_TREE)) {
7048: /*
7049: *Hack it to assure arg1 is the nodeset
7050: */
7051: if ((arg1->type != XPATH_NODESET) && (arg1->type != XPATH_XSLT_TREE)) {
7052: argtmp = arg2;
7053: arg2 = arg1;
7054: arg1 = argtmp;
7055: }
7056: switch (arg2->type) {
7057: case XPATH_UNDEFINED:
7058: #ifdef DEBUG_EXPR
7059: xmlGenericError(xmlGenericErrorContext,
7060: "Equal: undefined\n");
7061: #endif
7062: break;
7063: case XPATH_NODESET:
7064: case XPATH_XSLT_TREE:
7065: ret = xmlXPathEqualNodeSets(arg1, arg2, 0);
7066: break;
7067: case XPATH_BOOLEAN:
7068: if ((arg1->nodesetval == NULL) ||
7069: (arg1->nodesetval->nodeNr == 0)) ret = 0;
7070: else
7071: ret = 1;
7072: ret = (ret == arg2->boolval);
7073: break;
7074: case XPATH_NUMBER:
7075: ret = xmlXPathEqualNodeSetFloat(ctxt, arg1, arg2->floatval, 0);
7076: break;
7077: case XPATH_STRING:
7078: ret = xmlXPathEqualNodeSetString(arg1, arg2->stringval, 0);
7079: break;
7080: case XPATH_USERS:
7081: case XPATH_POINT:
7082: case XPATH_RANGE:
7083: case XPATH_LOCATIONSET:
7084: TODO
7085: break;
7086: }
7087: xmlXPathReleaseObject(ctxt->context, arg1);
7088: xmlXPathReleaseObject(ctxt->context, arg2);
7089: return(ret);
7090: }
7091:
7092: return (xmlXPathEqualValuesCommon(ctxt, arg1, arg2));
7093: }
7094:
7095: /**
7096: * xmlXPathNotEqualValues:
7097: * @ctxt: the XPath Parser context
7098: *
7099: * Implement the equal operation on XPath objects content: @arg1 == @arg2
7100: *
7101: * Returns 0 or 1 depending on the results of the test.
7102: */
7103: int
7104: xmlXPathNotEqualValues(xmlXPathParserContextPtr ctxt) {
7105: xmlXPathObjectPtr arg1, arg2, argtmp;
7106: int ret = 0;
7107:
7108: if ((ctxt == NULL) || (ctxt->context == NULL)) return(0);
7109: arg2 = valuePop(ctxt);
7110: arg1 = valuePop(ctxt);
7111: if ((arg1 == NULL) || (arg2 == NULL)) {
7112: if (arg1 != NULL)
7113: xmlXPathReleaseObject(ctxt->context, arg1);
7114: else
7115: xmlXPathReleaseObject(ctxt->context, arg2);
7116: XP_ERROR0(XPATH_INVALID_OPERAND);
7117: }
7118:
7119: if (arg1 == arg2) {
7120: #ifdef DEBUG_EXPR
7121: xmlGenericError(xmlGenericErrorContext,
7122: "NotEqual: by pointer\n");
7123: #endif
7124: xmlXPathReleaseObject(ctxt->context, arg1);
7125: return(0);
7126: }
7127:
7128: /*
7129: *If either argument is a nodeset, it's a 'special case'
7130: */
7131: if ((arg2->type == XPATH_NODESET) || (arg2->type == XPATH_XSLT_TREE) ||
7132: (arg1->type == XPATH_NODESET) || (arg1->type == XPATH_XSLT_TREE)) {
7133: /*
7134: *Hack it to assure arg1 is the nodeset
7135: */
7136: if ((arg1->type != XPATH_NODESET) && (arg1->type != XPATH_XSLT_TREE)) {
7137: argtmp = arg2;
7138: arg2 = arg1;
7139: arg1 = argtmp;
7140: }
7141: switch (arg2->type) {
7142: case XPATH_UNDEFINED:
7143: #ifdef DEBUG_EXPR
7144: xmlGenericError(xmlGenericErrorContext,
7145: "NotEqual: undefined\n");
7146: #endif
7147: break;
7148: case XPATH_NODESET:
7149: case XPATH_XSLT_TREE:
7150: ret = xmlXPathEqualNodeSets(arg1, arg2, 1);
7151: break;
7152: case XPATH_BOOLEAN:
7153: if ((arg1->nodesetval == NULL) ||
7154: (arg1->nodesetval->nodeNr == 0)) ret = 0;
7155: else
7156: ret = 1;
7157: ret = (ret != arg2->boolval);
7158: break;
7159: case XPATH_NUMBER:
7160: ret = xmlXPathEqualNodeSetFloat(ctxt, arg1, arg2->floatval, 1);
7161: break;
7162: case XPATH_STRING:
7163: ret = xmlXPathEqualNodeSetString(arg1, arg2->stringval,1);
7164: break;
7165: case XPATH_USERS:
7166: case XPATH_POINT:
7167: case XPATH_RANGE:
7168: case XPATH_LOCATIONSET:
7169: TODO
7170: break;
7171: }
7172: xmlXPathReleaseObject(ctxt->context, arg1);
7173: xmlXPathReleaseObject(ctxt->context, arg2);
7174: return(ret);
7175: }
7176:
7177: return (!xmlXPathEqualValuesCommon(ctxt, arg1, arg2));
7178: }
7179:
7180: /**
7181: * xmlXPathCompareValues:
7182: * @ctxt: the XPath Parser context
7183: * @inf: less than (1) or greater than (0)
7184: * @strict: is the comparison strict
7185: *
7186: * Implement the compare operation on XPath objects:
7187: * @arg1 < @arg2 (1, 1, ...
7188: * @arg1 <= @arg2 (1, 0, ...
7189: * @arg1 > @arg2 (0, 1, ...
7190: * @arg1 >= @arg2 (0, 0, ...
7191: *
7192: * When neither object to be compared is a node-set and the operator is
7193: * <=, <, >=, >, then the objects are compared by converted both objects
7194: * to numbers and comparing the numbers according to IEEE 754. The <
7195: * comparison will be true if and only if the first number is less than the
7196: * second number. The <= comparison will be true if and only if the first
7197: * number is less than or equal to the second number. The > comparison
7198: * will be true if and only if the first number is greater than the second
7199: * number. The >= comparison will be true if and only if the first number
7200: * is greater than or equal to the second number.
7201: *
7202: * Returns 1 if the comparison succeeded, 0 if it failed
7203: */
7204: int
7205: xmlXPathCompareValues(xmlXPathParserContextPtr ctxt, int inf, int strict) {
7206: int ret = 0, arg1i = 0, arg2i = 0;
7207: xmlXPathObjectPtr arg1, arg2;
7208:
7209: if ((ctxt == NULL) || (ctxt->context == NULL)) return(0);
7210: arg2 = valuePop(ctxt);
7211: arg1 = valuePop(ctxt);
7212: if ((arg1 == NULL) || (arg2 == NULL)) {
7213: if (arg1 != NULL)
7214: xmlXPathReleaseObject(ctxt->context, arg1);
7215: else
7216: xmlXPathReleaseObject(ctxt->context, arg2);
7217: XP_ERROR0(XPATH_INVALID_OPERAND);
7218: }
7219:
7220: if ((arg2->type == XPATH_NODESET) || (arg2->type == XPATH_XSLT_TREE) ||
7221: (arg1->type == XPATH_NODESET) || (arg1->type == XPATH_XSLT_TREE)) {
7222: /*
7223: * If either argument is a XPATH_NODESET or XPATH_XSLT_TREE the two arguments
7224: * are not freed from within this routine; they will be freed from the
7225: * called routine, e.g. xmlXPathCompareNodeSets or xmlXPathCompareNodeSetValue
7226: */
7227: if (((arg2->type == XPATH_NODESET) || (arg2->type == XPATH_XSLT_TREE)) &&
7228: ((arg1->type == XPATH_NODESET) || (arg1->type == XPATH_XSLT_TREE))){
7229: ret = xmlXPathCompareNodeSets(inf, strict, arg1, arg2);
7230: } else {
7231: if ((arg1->type == XPATH_NODESET) || (arg1->type == XPATH_XSLT_TREE)) {
7232: ret = xmlXPathCompareNodeSetValue(ctxt, inf, strict,
7233: arg1, arg2);
7234: } else {
7235: ret = xmlXPathCompareNodeSetValue(ctxt, !inf, strict,
7236: arg2, arg1);
7237: }
7238: }
7239: return(ret);
7240: }
7241:
7242: if (arg1->type != XPATH_NUMBER) {
7243: valuePush(ctxt, arg1);
7244: xmlXPathNumberFunction(ctxt, 1);
7245: arg1 = valuePop(ctxt);
7246: }
7247: if (arg1->type != XPATH_NUMBER) {
7248: xmlXPathFreeObject(arg1);
7249: xmlXPathFreeObject(arg2);
7250: XP_ERROR0(XPATH_INVALID_OPERAND);
7251: }
7252: if (arg2->type != XPATH_NUMBER) {
7253: valuePush(ctxt, arg2);
7254: xmlXPathNumberFunction(ctxt, 1);
7255: arg2 = valuePop(ctxt);
7256: }
7257: if (arg2->type != XPATH_NUMBER) {
7258: xmlXPathReleaseObject(ctxt->context, arg1);
7259: xmlXPathReleaseObject(ctxt->context, arg2);
7260: XP_ERROR0(XPATH_INVALID_OPERAND);
7261: }
7262: /*
7263: * Add tests for infinity and nan
7264: * => feedback on 3.4 for Inf and NaN
7265: */
7266: /* Hand check NaN and Infinity comparisons */
7267: if (xmlXPathIsNaN(arg1->floatval) || xmlXPathIsNaN(arg2->floatval)) {
7268: ret=0;
7269: } else {
7270: arg1i=xmlXPathIsInf(arg1->floatval);
7271: arg2i=xmlXPathIsInf(arg2->floatval);
7272: if (inf && strict) {
7273: if ((arg1i == -1 && arg2i != -1) ||
7274: (arg2i == 1 && arg1i != 1)) {
7275: ret = 1;
7276: } else if (arg1i == 0 && arg2i == 0) {
7277: ret = (arg1->floatval < arg2->floatval);
7278: } else {
7279: ret = 0;
7280: }
7281: }
7282: else if (inf && !strict) {
7283: if (arg1i == -1 || arg2i == 1) {
7284: ret = 1;
7285: } else if (arg1i == 0 && arg2i == 0) {
7286: ret = (arg1->floatval <= arg2->floatval);
7287: } else {
7288: ret = 0;
7289: }
7290: }
7291: else if (!inf && strict) {
7292: if ((arg1i == 1 && arg2i != 1) ||
7293: (arg2i == -1 && arg1i != -1)) {
7294: ret = 1;
7295: } else if (arg1i == 0 && arg2i == 0) {
7296: ret = (arg1->floatval > arg2->floatval);
7297: } else {
7298: ret = 0;
7299: }
7300: }
7301: else if (!inf && !strict) {
7302: if (arg1i == 1 || arg2i == -1) {
7303: ret = 1;
7304: } else if (arg1i == 0 && arg2i == 0) {
7305: ret = (arg1->floatval >= arg2->floatval);
7306: } else {
7307: ret = 0;
7308: }
7309: }
7310: }
7311: xmlXPathReleaseObject(ctxt->context, arg1);
7312: xmlXPathReleaseObject(ctxt->context, arg2);
7313: return(ret);
7314: }
7315:
7316: /**
7317: * xmlXPathValueFlipSign:
7318: * @ctxt: the XPath Parser context
7319: *
7320: * Implement the unary - operation on an XPath object
7321: * The numeric operators convert their operands to numbers as if
7322: * by calling the number function.
7323: */
7324: void
7325: xmlXPathValueFlipSign(xmlXPathParserContextPtr ctxt) {
7326: if ((ctxt == NULL) || (ctxt->context == NULL)) return;
7327: CAST_TO_NUMBER;
7328: CHECK_TYPE(XPATH_NUMBER);
7329: if (xmlXPathIsNaN(ctxt->value->floatval))
7330: ctxt->value->floatval=xmlXPathNAN;
7331: else if (xmlXPathIsInf(ctxt->value->floatval) == 1)
7332: ctxt->value->floatval=xmlXPathNINF;
7333: else if (xmlXPathIsInf(ctxt->value->floatval) == -1)
7334: ctxt->value->floatval=xmlXPathPINF;
7335: else if (ctxt->value->floatval == 0) {
7336: if (xmlXPathGetSign(ctxt->value->floatval) == 0)
7337: ctxt->value->floatval = xmlXPathNZERO;
7338: else
7339: ctxt->value->floatval = 0;
7340: }
7341: else
7342: ctxt->value->floatval = - ctxt->value->floatval;
7343: }
7344:
7345: /**
7346: * xmlXPathAddValues:
7347: * @ctxt: the XPath Parser context
7348: *
7349: * Implement the add operation on XPath objects:
7350: * The numeric operators convert their operands to numbers as if
7351: * by calling the number function.
7352: */
7353: void
7354: xmlXPathAddValues(xmlXPathParserContextPtr ctxt) {
7355: xmlXPathObjectPtr arg;
7356: double val;
7357:
7358: arg = valuePop(ctxt);
7359: if (arg == NULL)
7360: XP_ERROR(XPATH_INVALID_OPERAND);
7361: val = xmlXPathCastToNumber(arg);
7362: xmlXPathReleaseObject(ctxt->context, arg);
7363: CAST_TO_NUMBER;
7364: CHECK_TYPE(XPATH_NUMBER);
7365: ctxt->value->floatval += val;
7366: }
7367:
7368: /**
7369: * xmlXPathSubValues:
7370: * @ctxt: the XPath Parser context
7371: *
7372: * Implement the subtraction operation on XPath objects:
7373: * The numeric operators convert their operands to numbers as if
7374: * by calling the number function.
7375: */
7376: void
7377: xmlXPathSubValues(xmlXPathParserContextPtr ctxt) {
7378: xmlXPathObjectPtr arg;
7379: double val;
7380:
7381: arg = valuePop(ctxt);
7382: if (arg == NULL)
7383: XP_ERROR(XPATH_INVALID_OPERAND);
7384: val = xmlXPathCastToNumber(arg);
7385: xmlXPathReleaseObject(ctxt->context, arg);
7386: CAST_TO_NUMBER;
7387: CHECK_TYPE(XPATH_NUMBER);
7388: ctxt->value->floatval -= val;
7389: }
7390:
7391: /**
7392: * xmlXPathMultValues:
7393: * @ctxt: the XPath Parser context
7394: *
7395: * Implement the multiply operation on XPath objects:
7396: * The numeric operators convert their operands to numbers as if
7397: * by calling the number function.
7398: */
7399: void
7400: xmlXPathMultValues(xmlXPathParserContextPtr ctxt) {
7401: xmlXPathObjectPtr arg;
7402: double val;
7403:
7404: arg = valuePop(ctxt);
7405: if (arg == NULL)
7406: XP_ERROR(XPATH_INVALID_OPERAND);
7407: val = xmlXPathCastToNumber(arg);
7408: xmlXPathReleaseObject(ctxt->context, arg);
7409: CAST_TO_NUMBER;
7410: CHECK_TYPE(XPATH_NUMBER);
7411: ctxt->value->floatval *= val;
7412: }
7413:
7414: /**
7415: * xmlXPathDivValues:
7416: * @ctxt: the XPath Parser context
7417: *
7418: * Implement the div operation on XPath objects @arg1 / @arg2:
7419: * The numeric operators convert their operands to numbers as if
7420: * by calling the number function.
7421: */
7422: void
7423: xmlXPathDivValues(xmlXPathParserContextPtr ctxt) {
7424: xmlXPathObjectPtr arg;
7425: double val;
7426:
7427: arg = valuePop(ctxt);
7428: if (arg == NULL)
7429: XP_ERROR(XPATH_INVALID_OPERAND);
7430: val = xmlXPathCastToNumber(arg);
7431: xmlXPathReleaseObject(ctxt->context, arg);
7432: CAST_TO_NUMBER;
7433: CHECK_TYPE(XPATH_NUMBER);
7434: if (xmlXPathIsNaN(val) || xmlXPathIsNaN(ctxt->value->floatval))
7435: ctxt->value->floatval = xmlXPathNAN;
7436: else if (val == 0 && xmlXPathGetSign(val) != 0) {
7437: if (ctxt->value->floatval == 0)
7438: ctxt->value->floatval = xmlXPathNAN;
7439: else if (ctxt->value->floatval > 0)
7440: ctxt->value->floatval = xmlXPathNINF;
7441: else if (ctxt->value->floatval < 0)
7442: ctxt->value->floatval = xmlXPathPINF;
7443: }
7444: else if (val == 0) {
7445: if (ctxt->value->floatval == 0)
7446: ctxt->value->floatval = xmlXPathNAN;
7447: else if (ctxt->value->floatval > 0)
7448: ctxt->value->floatval = xmlXPathPINF;
7449: else if (ctxt->value->floatval < 0)
7450: ctxt->value->floatval = xmlXPathNINF;
7451: } else
7452: ctxt->value->floatval /= val;
7453: }
7454:
7455: /**
7456: * xmlXPathModValues:
7457: * @ctxt: the XPath Parser context
7458: *
7459: * Implement the mod operation on XPath objects: @arg1 / @arg2
7460: * The numeric operators convert their operands to numbers as if
7461: * by calling the number function.
7462: */
7463: void
7464: xmlXPathModValues(xmlXPathParserContextPtr ctxt) {
7465: xmlXPathObjectPtr arg;
7466: double arg1, arg2;
7467:
7468: arg = valuePop(ctxt);
7469: if (arg == NULL)
7470: XP_ERROR(XPATH_INVALID_OPERAND);
7471: arg2 = xmlXPathCastToNumber(arg);
7472: xmlXPathReleaseObject(ctxt->context, arg);
7473: CAST_TO_NUMBER;
7474: CHECK_TYPE(XPATH_NUMBER);
7475: arg1 = ctxt->value->floatval;
7476: if (arg2 == 0)
7477: ctxt->value->floatval = xmlXPathNAN;
7478: else {
7479: ctxt->value->floatval = fmod(arg1, arg2);
7480: }
7481: }
7482:
7483: /************************************************************************
7484: * *
7485: * The traversal functions *
7486: * *
7487: ************************************************************************/
7488:
7489: /*
7490: * A traversal function enumerates nodes along an axis.
7491: * Initially it must be called with NULL, and it indicates
7492: * termination on the axis by returning NULL.
7493: */
7494: typedef xmlNodePtr (*xmlXPathTraversalFunction)
7495: (xmlXPathParserContextPtr ctxt, xmlNodePtr cur);
7496:
7497: /*
7498: * xmlXPathTraversalFunctionExt:
7499: * A traversal function enumerates nodes along an axis.
7500: * Initially it must be called with NULL, and it indicates
7501: * termination on the axis by returning NULL.
7502: * The context node of the traversal is specified via @contextNode.
7503: */
7504: typedef xmlNodePtr (*xmlXPathTraversalFunctionExt)
7505: (xmlNodePtr cur, xmlNodePtr contextNode);
7506:
7507: /*
7508: * xmlXPathNodeSetMergeFunction:
7509: * Used for merging node sets in xmlXPathCollectAndTest().
7510: */
7511: typedef xmlNodeSetPtr (*xmlXPathNodeSetMergeFunction)
7512: (xmlNodeSetPtr, xmlNodeSetPtr, int);
7513:
7514:
7515: /**
7516: * xmlXPathNextSelf:
7517: * @ctxt: the XPath Parser context
7518: * @cur: the current node in the traversal
7519: *
7520: * Traversal function for the "self" direction
7521: * The self axis contains just the context node itself
7522: *
7523: * Returns the next element following that axis
7524: */
7525: xmlNodePtr
7526: xmlXPathNextSelf(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
7527: if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
7528: if (cur == NULL)
7529: return(ctxt->context->node);
7530: return(NULL);
7531: }
7532:
7533: /**
7534: * xmlXPathNextChild:
7535: * @ctxt: the XPath Parser context
7536: * @cur: the current node in the traversal
7537: *
7538: * Traversal function for the "child" direction
7539: * The child axis contains the children of the context node in document order.
7540: *
7541: * Returns the next element following that axis
7542: */
7543: xmlNodePtr
7544: xmlXPathNextChild(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
7545: if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
7546: if (cur == NULL) {
7547: if (ctxt->context->node == NULL) return(NULL);
7548: switch (ctxt->context->node->type) {
7549: case XML_ELEMENT_NODE:
7550: case XML_TEXT_NODE:
7551: case XML_CDATA_SECTION_NODE:
7552: case XML_ENTITY_REF_NODE:
7553: case XML_ENTITY_NODE:
7554: case XML_PI_NODE:
7555: case XML_COMMENT_NODE:
7556: case XML_NOTATION_NODE:
7557: case XML_DTD_NODE:
7558: return(ctxt->context->node->children);
7559: case XML_DOCUMENT_NODE:
7560: case XML_DOCUMENT_TYPE_NODE:
7561: case XML_DOCUMENT_FRAG_NODE:
7562: case XML_HTML_DOCUMENT_NODE:
7563: #ifdef LIBXML_DOCB_ENABLED
7564: case XML_DOCB_DOCUMENT_NODE:
7565: #endif
7566: return(((xmlDocPtr) ctxt->context->node)->children);
7567: case XML_ELEMENT_DECL:
7568: case XML_ATTRIBUTE_DECL:
7569: case XML_ENTITY_DECL:
7570: case XML_ATTRIBUTE_NODE:
7571: case XML_NAMESPACE_DECL:
7572: case XML_XINCLUDE_START:
7573: case XML_XINCLUDE_END:
7574: return(NULL);
7575: }
7576: return(NULL);
7577: }
7578: if ((cur->type == XML_DOCUMENT_NODE) ||
7579: (cur->type == XML_HTML_DOCUMENT_NODE))
7580: return(NULL);
7581: return(cur->next);
7582: }
7583:
7584: /**
7585: * xmlXPathNextChildElement:
7586: * @ctxt: the XPath Parser context
7587: * @cur: the current node in the traversal
7588: *
7589: * Traversal function for the "child" direction and nodes of type element.
7590: * The child axis contains the children of the context node in document order.
7591: *
7592: * Returns the next element following that axis
7593: */
7594: static xmlNodePtr
7595: xmlXPathNextChildElement(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
7596: if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
7597: if (cur == NULL) {
7598: cur = ctxt->context->node;
7599: if (cur == NULL) return(NULL);
7600: /*
7601: * Get the first element child.
7602: */
7603: switch (cur->type) {
7604: case XML_ELEMENT_NODE:
7605: case XML_DOCUMENT_FRAG_NODE:
7606: case XML_ENTITY_REF_NODE: /* URGENT TODO: entify-refs as well? */
7607: case XML_ENTITY_NODE:
7608: cur = cur->children;
7609: if (cur != NULL) {
7610: if (cur->type == XML_ELEMENT_NODE)
7611: return(cur);
7612: do {
7613: cur = cur->next;
7614: } while ((cur != NULL) &&
7615: (cur->type != XML_ELEMENT_NODE));
7616: return(cur);
7617: }
7618: return(NULL);
7619: case XML_DOCUMENT_NODE:
7620: case XML_HTML_DOCUMENT_NODE:
7621: #ifdef LIBXML_DOCB_ENABLED
7622: case XML_DOCB_DOCUMENT_NODE:
7623: #endif
7624: return(xmlDocGetRootElement((xmlDocPtr) cur));
7625: default:
7626: return(NULL);
7627: }
7628: return(NULL);
7629: }
7630: /*
7631: * Get the next sibling element node.
7632: */
7633: switch (cur->type) {
7634: case XML_ELEMENT_NODE:
7635: case XML_TEXT_NODE:
7636: case XML_ENTITY_REF_NODE:
7637: case XML_ENTITY_NODE:
7638: case XML_CDATA_SECTION_NODE:
7639: case XML_PI_NODE:
7640: case XML_COMMENT_NODE:
7641: case XML_XINCLUDE_END:
7642: break;
7643: /* case XML_DTD_NODE: */ /* URGENT TODO: DTD-node as well? */
7644: default:
7645: return(NULL);
7646: }
7647: if (cur->next != NULL) {
7648: if (cur->next->type == XML_ELEMENT_NODE)
7649: return(cur->next);
7650: cur = cur->next;
7651: do {
7652: cur = cur->next;
7653: } while ((cur != NULL) && (cur->type != XML_ELEMENT_NODE));
7654: return(cur);
7655: }
7656: return(NULL);
7657: }
7658:
7659: /**
7660: * xmlXPathNextDescendantOrSelfElemParent:
7661: * @ctxt: the XPath Parser context
7662: * @cur: the current node in the traversal
7663: *
7664: * Traversal function for the "descendant-or-self" axis.
7665: * Additionally it returns only nodes which can be parents of
7666: * element nodes.
7667: *
7668: *
7669: * Returns the next element following that axis
7670: */
7671: static xmlNodePtr
7672: xmlXPathNextDescendantOrSelfElemParent(xmlNodePtr cur,
7673: xmlNodePtr contextNode)
7674: {
7675: if (cur == NULL) {
7676: if (contextNode == NULL)
7677: return(NULL);
7678: switch (contextNode->type) {
7679: case XML_ELEMENT_NODE:
7680: case XML_XINCLUDE_START:
7681: case XML_DOCUMENT_FRAG_NODE:
7682: case XML_DOCUMENT_NODE:
7683: #ifdef LIBXML_DOCB_ENABLED
7684: case XML_DOCB_DOCUMENT_NODE:
7685: #endif
7686: case XML_HTML_DOCUMENT_NODE:
7687: return(contextNode);
7688: default:
7689: return(NULL);
7690: }
7691: return(NULL);
7692: } else {
7693: xmlNodePtr start = cur;
7694:
7695: while (cur != NULL) {
7696: switch (cur->type) {
7697: case XML_ELEMENT_NODE:
7698: /* TODO: OK to have XInclude here? */
7699: case XML_XINCLUDE_START:
7700: case XML_DOCUMENT_FRAG_NODE:
7701: if (cur != start)
7702: return(cur);
7703: if (cur->children != NULL) {
7704: cur = cur->children;
7705: continue;
7706: }
7707: break;
7708: /* Not sure if we need those here. */
7709: case XML_DOCUMENT_NODE:
7710: #ifdef LIBXML_DOCB_ENABLED
7711: case XML_DOCB_DOCUMENT_NODE:
7712: #endif
7713: case XML_HTML_DOCUMENT_NODE:
7714: if (cur != start)
7715: return(cur);
7716: return(xmlDocGetRootElement((xmlDocPtr) cur));
7717: default:
7718: break;
7719: }
7720:
7721: next_sibling:
7722: if ((cur == NULL) || (cur == contextNode))
7723: return(NULL);
7724: if (cur->next != NULL) {
7725: cur = cur->next;
7726: } else {
7727: cur = cur->parent;
7728: goto next_sibling;
7729: }
7730: }
7731: }
7732: return(NULL);
7733: }
7734:
7735: /**
7736: * xmlXPathNextDescendant:
7737: * @ctxt: the XPath Parser context
7738: * @cur: the current node in the traversal
7739: *
7740: * Traversal function for the "descendant" direction
7741: * the descendant axis contains the descendants of the context node in document
7742: * order; a descendant is a child or a child of a child and so on.
7743: *
7744: * Returns the next element following that axis
7745: */
7746: xmlNodePtr
7747: xmlXPathNextDescendant(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
7748: if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
7749: if (cur == NULL) {
7750: if (ctxt->context->node == NULL)
7751: return(NULL);
7752: if ((ctxt->context->node->type == XML_ATTRIBUTE_NODE) ||
7753: (ctxt->context->node->type == XML_NAMESPACE_DECL))
7754: return(NULL);
7755:
7756: if (ctxt->context->node == (xmlNodePtr) ctxt->context->doc)
7757: return(ctxt->context->doc->children);
7758: return(ctxt->context->node->children);
7759: }
7760:
7761: if (cur->children != NULL) {
7762: /*
7763: * Do not descend on entities declarations
7764: */
7765: if (cur->children->type != XML_ENTITY_DECL) {
7766: cur = cur->children;
7767: /*
7768: * Skip DTDs
7769: */
7770: if (cur->type != XML_DTD_NODE)
7771: return(cur);
7772: }
7773: }
7774:
7775: if (cur == ctxt->context->node) return(NULL);
7776:
7777: while (cur->next != NULL) {
7778: cur = cur->next;
7779: if ((cur->type != XML_ENTITY_DECL) &&
7780: (cur->type != XML_DTD_NODE))
7781: return(cur);
7782: }
7783:
7784: do {
7785: cur = cur->parent;
7786: if (cur == NULL) break;
7787: if (cur == ctxt->context->node) return(NULL);
7788: if (cur->next != NULL) {
7789: cur = cur->next;
7790: return(cur);
7791: }
7792: } while (cur != NULL);
7793: return(cur);
7794: }
7795:
7796: /**
7797: * xmlXPathNextDescendantOrSelf:
7798: * @ctxt: the XPath Parser context
7799: * @cur: the current node in the traversal
7800: *
7801: * Traversal function for the "descendant-or-self" direction
7802: * the descendant-or-self axis contains the context node and the descendants
7803: * of the context node in document order; thus the context node is the first
7804: * node on the axis, and the first child of the context node is the second node
7805: * on the axis
7806: *
7807: * Returns the next element following that axis
7808: */
7809: xmlNodePtr
7810: xmlXPathNextDescendantOrSelf(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
7811: if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
7812: if (cur == NULL) {
7813: if (ctxt->context->node == NULL)
7814: return(NULL);
7815: if ((ctxt->context->node->type == XML_ATTRIBUTE_NODE) ||
7816: (ctxt->context->node->type == XML_NAMESPACE_DECL))
7817: return(NULL);
7818: return(ctxt->context->node);
7819: }
7820:
7821: return(xmlXPathNextDescendant(ctxt, cur));
7822: }
7823:
7824: /**
7825: * xmlXPathNextParent:
7826: * @ctxt: the XPath Parser context
7827: * @cur: the current node in the traversal
7828: *
7829: * Traversal function for the "parent" direction
7830: * The parent axis contains the parent of the context node, if there is one.
7831: *
7832: * Returns the next element following that axis
7833: */
7834: xmlNodePtr
7835: xmlXPathNextParent(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
7836: if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
7837: /*
7838: * the parent of an attribute or namespace node is the element
7839: * to which the attribute or namespace node is attached
7840: * Namespace handling !!!
7841: */
7842: if (cur == NULL) {
7843: if (ctxt->context->node == NULL) return(NULL);
7844: switch (ctxt->context->node->type) {
7845: case XML_ELEMENT_NODE:
7846: case XML_TEXT_NODE:
7847: case XML_CDATA_SECTION_NODE:
7848: case XML_ENTITY_REF_NODE:
7849: case XML_ENTITY_NODE:
7850: case XML_PI_NODE:
7851: case XML_COMMENT_NODE:
7852: case XML_NOTATION_NODE:
7853: case XML_DTD_NODE:
7854: case XML_ELEMENT_DECL:
7855: case XML_ATTRIBUTE_DECL:
7856: case XML_XINCLUDE_START:
7857: case XML_XINCLUDE_END:
7858: case XML_ENTITY_DECL:
7859: if (ctxt->context->node->parent == NULL)
7860: return((xmlNodePtr) ctxt->context->doc);
7861: if ((ctxt->context->node->parent->type == XML_ELEMENT_NODE) &&
7862: ((ctxt->context->node->parent->name[0] == ' ') ||
7863: (xmlStrEqual(ctxt->context->node->parent->name,
7864: BAD_CAST "fake node libxslt"))))
7865: return(NULL);
7866: return(ctxt->context->node->parent);
7867: case XML_ATTRIBUTE_NODE: {
7868: xmlAttrPtr att = (xmlAttrPtr) ctxt->context->node;
7869:
7870: return(att->parent);
7871: }
7872: case XML_DOCUMENT_NODE:
7873: case XML_DOCUMENT_TYPE_NODE:
7874: case XML_DOCUMENT_FRAG_NODE:
7875: case XML_HTML_DOCUMENT_NODE:
7876: #ifdef LIBXML_DOCB_ENABLED
7877: case XML_DOCB_DOCUMENT_NODE:
7878: #endif
7879: return(NULL);
7880: case XML_NAMESPACE_DECL: {
7881: xmlNsPtr ns = (xmlNsPtr) ctxt->context->node;
7882:
7883: if ((ns->next != NULL) &&
7884: (ns->next->type != XML_NAMESPACE_DECL))
7885: return((xmlNodePtr) ns->next);
7886: return(NULL);
7887: }
7888: }
7889: }
7890: return(NULL);
7891: }
7892:
7893: /**
7894: * xmlXPathNextAncestor:
7895: * @ctxt: the XPath Parser context
7896: * @cur: the current node in the traversal
7897: *
7898: * Traversal function for the "ancestor" direction
7899: * the ancestor axis contains the ancestors of the context node; the ancestors
7900: * of the context node consist of the parent of context node and the parent's
7901: * parent and so on; the nodes are ordered in reverse document order; thus the
7902: * parent is the first node on the axis, and the parent's parent is the second
7903: * node on the axis
7904: *
7905: * Returns the next element following that axis
7906: */
7907: xmlNodePtr
7908: xmlXPathNextAncestor(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
7909: if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
7910: /*
7911: * the parent of an attribute or namespace node is the element
7912: * to which the attribute or namespace node is attached
7913: * !!!!!!!!!!!!!
7914: */
7915: if (cur == NULL) {
7916: if (ctxt->context->node == NULL) return(NULL);
7917: switch (ctxt->context->node->type) {
7918: case XML_ELEMENT_NODE:
7919: case XML_TEXT_NODE:
7920: case XML_CDATA_SECTION_NODE:
7921: case XML_ENTITY_REF_NODE:
7922: case XML_ENTITY_NODE:
7923: case XML_PI_NODE:
7924: case XML_COMMENT_NODE:
7925: case XML_DTD_NODE:
7926: case XML_ELEMENT_DECL:
7927: case XML_ATTRIBUTE_DECL:
7928: case XML_ENTITY_DECL:
7929: case XML_NOTATION_NODE:
7930: case XML_XINCLUDE_START:
7931: case XML_XINCLUDE_END:
7932: if (ctxt->context->node->parent == NULL)
7933: return((xmlNodePtr) ctxt->context->doc);
7934: if ((ctxt->context->node->parent->type == XML_ELEMENT_NODE) &&
7935: ((ctxt->context->node->parent->name[0] == ' ') ||
7936: (xmlStrEqual(ctxt->context->node->parent->name,
7937: BAD_CAST "fake node libxslt"))))
7938: return(NULL);
7939: return(ctxt->context->node->parent);
7940: case XML_ATTRIBUTE_NODE: {
7941: xmlAttrPtr tmp = (xmlAttrPtr) ctxt->context->node;
7942:
7943: return(tmp->parent);
7944: }
7945: case XML_DOCUMENT_NODE:
7946: case XML_DOCUMENT_TYPE_NODE:
7947: case XML_DOCUMENT_FRAG_NODE:
7948: case XML_HTML_DOCUMENT_NODE:
7949: #ifdef LIBXML_DOCB_ENABLED
7950: case XML_DOCB_DOCUMENT_NODE:
7951: #endif
7952: return(NULL);
7953: case XML_NAMESPACE_DECL: {
7954: xmlNsPtr ns = (xmlNsPtr) ctxt->context->node;
7955:
7956: if ((ns->next != NULL) &&
7957: (ns->next->type != XML_NAMESPACE_DECL))
7958: return((xmlNodePtr) ns->next);
7959: /* Bad, how did that namespace end up here ? */
7960: return(NULL);
7961: }
7962: }
7963: return(NULL);
7964: }
7965: if (cur == ctxt->context->doc->children)
7966: return((xmlNodePtr) ctxt->context->doc);
7967: if (cur == (xmlNodePtr) ctxt->context->doc)
7968: return(NULL);
7969: switch (cur->type) {
7970: case XML_ELEMENT_NODE:
7971: case XML_TEXT_NODE:
7972: case XML_CDATA_SECTION_NODE:
7973: case XML_ENTITY_REF_NODE:
7974: case XML_ENTITY_NODE:
7975: case XML_PI_NODE:
7976: case XML_COMMENT_NODE:
7977: case XML_NOTATION_NODE:
7978: case XML_DTD_NODE:
7979: case XML_ELEMENT_DECL:
7980: case XML_ATTRIBUTE_DECL:
7981: case XML_ENTITY_DECL:
7982: case XML_XINCLUDE_START:
7983: case XML_XINCLUDE_END:
7984: if (cur->parent == NULL)
7985: return(NULL);
7986: if ((cur->parent->type == XML_ELEMENT_NODE) &&
7987: ((cur->parent->name[0] == ' ') ||
7988: (xmlStrEqual(cur->parent->name,
7989: BAD_CAST "fake node libxslt"))))
7990: return(NULL);
7991: return(cur->parent);
7992: case XML_ATTRIBUTE_NODE: {
7993: xmlAttrPtr att = (xmlAttrPtr) ctxt->context->node;
7994:
7995: return(att->parent);
7996: }
7997: case XML_NAMESPACE_DECL: {
7998: xmlNsPtr ns = (xmlNsPtr) ctxt->context->node;
7999:
8000: if ((ns->next != NULL) &&
8001: (ns->next->type != XML_NAMESPACE_DECL))
8002: return((xmlNodePtr) ns->next);
8003: /* Bad, how did that namespace end up here ? */
8004: return(NULL);
8005: }
8006: case XML_DOCUMENT_NODE:
8007: case XML_DOCUMENT_TYPE_NODE:
8008: case XML_DOCUMENT_FRAG_NODE:
8009: case XML_HTML_DOCUMENT_NODE:
8010: #ifdef LIBXML_DOCB_ENABLED
8011: case XML_DOCB_DOCUMENT_NODE:
8012: #endif
8013: return(NULL);
8014: }
8015: return(NULL);
8016: }
8017:
8018: /**
8019: * xmlXPathNextAncestorOrSelf:
8020: * @ctxt: the XPath Parser context
8021: * @cur: the current node in the traversal
8022: *
8023: * Traversal function for the "ancestor-or-self" direction
8024: * he ancestor-or-self axis contains the context node and ancestors of
8025: * the context node in reverse document order; thus the context node is
8026: * the first node on the axis, and the context node's parent the second;
8027: * parent here is defined the same as with the parent axis.
8028: *
8029: * Returns the next element following that axis
8030: */
8031: xmlNodePtr
8032: xmlXPathNextAncestorOrSelf(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
8033: if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
8034: if (cur == NULL)
8035: return(ctxt->context->node);
8036: return(xmlXPathNextAncestor(ctxt, cur));
8037: }
8038:
8039: /**
8040: * xmlXPathNextFollowingSibling:
8041: * @ctxt: the XPath Parser context
8042: * @cur: the current node in the traversal
8043: *
8044: * Traversal function for the "following-sibling" direction
8045: * The following-sibling axis contains the following siblings of the context
8046: * node in document order.
8047: *
8048: * Returns the next element following that axis
8049: */
8050: xmlNodePtr
8051: xmlXPathNextFollowingSibling(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
8052: if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
8053: if ((ctxt->context->node->type == XML_ATTRIBUTE_NODE) ||
8054: (ctxt->context->node->type == XML_NAMESPACE_DECL))
8055: return(NULL);
8056: if (cur == (xmlNodePtr) ctxt->context->doc)
8057: return(NULL);
8058: if (cur == NULL)
8059: return(ctxt->context->node->next);
8060: return(cur->next);
8061: }
8062:
8063: /**
8064: * xmlXPathNextPrecedingSibling:
8065: * @ctxt: the XPath Parser context
8066: * @cur: the current node in the traversal
8067: *
8068: * Traversal function for the "preceding-sibling" direction
8069: * The preceding-sibling axis contains the preceding siblings of the context
8070: * node in reverse document order; the first preceding sibling is first on the
8071: * axis; the sibling preceding that node is the second on the axis and so on.
8072: *
8073: * Returns the next element following that axis
8074: */
8075: xmlNodePtr
8076: xmlXPathNextPrecedingSibling(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
8077: if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
8078: if ((ctxt->context->node->type == XML_ATTRIBUTE_NODE) ||
8079: (ctxt->context->node->type == XML_NAMESPACE_DECL))
8080: return(NULL);
8081: if (cur == (xmlNodePtr) ctxt->context->doc)
8082: return(NULL);
8083: if (cur == NULL)
8084: return(ctxt->context->node->prev);
8085: if ((cur->prev != NULL) && (cur->prev->type == XML_DTD_NODE)) {
8086: cur = cur->prev;
8087: if (cur == NULL)
8088: return(ctxt->context->node->prev);
8089: }
8090: return(cur->prev);
8091: }
8092:
8093: /**
8094: * xmlXPathNextFollowing:
8095: * @ctxt: the XPath Parser context
8096: * @cur: the current node in the traversal
8097: *
8098: * Traversal function for the "following" direction
8099: * The following axis contains all nodes in the same document as the context
8100: * node that are after the context node in document order, excluding any
8101: * descendants and excluding attribute nodes and namespace nodes; the nodes
8102: * are ordered in document order
8103: *
8104: * Returns the next element following that axis
8105: */
8106: xmlNodePtr
8107: xmlXPathNextFollowing(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
8108: if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
8109: if ((cur != NULL) && (cur->type != XML_ATTRIBUTE_NODE) &&
8110: (cur->type != XML_NAMESPACE_DECL) && (cur->children != NULL))
8111: return(cur->children);
8112:
8113: if (cur == NULL) {
8114: cur = ctxt->context->node;
8115: if (cur->type == XML_NAMESPACE_DECL)
8116: return(NULL);
8117: if (cur->type == XML_ATTRIBUTE_NODE)
8118: cur = cur->parent;
8119: }
8120: if (cur == NULL) return(NULL) ; /* ERROR */
8121: if (cur->next != NULL) return(cur->next) ;
8122: do {
8123: cur = cur->parent;
8124: if (cur == NULL) break;
8125: if (cur == (xmlNodePtr) ctxt->context->doc) return(NULL);
8126: if (cur->next != NULL) return(cur->next);
8127: } while (cur != NULL);
8128: return(cur);
8129: }
8130:
8131: /*
8132: * xmlXPathIsAncestor:
8133: * @ancestor: the ancestor node
8134: * @node: the current node
8135: *
8136: * Check that @ancestor is a @node's ancestor
8137: *
8138: * returns 1 if @ancestor is a @node's ancestor, 0 otherwise.
8139: */
8140: static int
8141: xmlXPathIsAncestor(xmlNodePtr ancestor, xmlNodePtr node) {
8142: if ((ancestor == NULL) || (node == NULL)) return(0);
8143: /* nodes need to be in the same document */
8144: if (ancestor->doc != node->doc) return(0);
8145: /* avoid searching if ancestor or node is the root node */
8146: if (ancestor == (xmlNodePtr) node->doc) return(1);
8147: if (node == (xmlNodePtr) ancestor->doc) return(0);
8148: while (node->parent != NULL) {
8149: if (node->parent == ancestor)
8150: return(1);
8151: node = node->parent;
8152: }
8153: return(0);
8154: }
8155:
8156: /**
8157: * xmlXPathNextPreceding:
8158: * @ctxt: the XPath Parser context
8159: * @cur: the current node in the traversal
8160: *
8161: * Traversal function for the "preceding" direction
8162: * the preceding axis contains all nodes in the same document as the context
8163: * node that are before the context node in document order, excluding any
8164: * ancestors and excluding attribute nodes and namespace nodes; the nodes are
8165: * ordered in reverse document order
8166: *
8167: * Returns the next element following that axis
8168: */
8169: xmlNodePtr
8170: xmlXPathNextPreceding(xmlXPathParserContextPtr ctxt, xmlNodePtr cur)
8171: {
8172: if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
8173: if (cur == NULL) {
8174: cur = ctxt->context->node;
8175: if (cur->type == XML_NAMESPACE_DECL)
8176: return(NULL);
8177: if (cur->type == XML_ATTRIBUTE_NODE)
8178: return(cur->parent);
8179: }
8180: if (cur == NULL)
8181: return (NULL);
8182: if ((cur->prev != NULL) && (cur->prev->type == XML_DTD_NODE))
8183: cur = cur->prev;
8184: do {
8185: if (cur->prev != NULL) {
8186: for (cur = cur->prev; cur->last != NULL; cur = cur->last) ;
8187: return (cur);
8188: }
8189:
8190: cur = cur->parent;
8191: if (cur == NULL)
8192: return (NULL);
8193: if (cur == ctxt->context->doc->children)
8194: return (NULL);
8195: } while (xmlXPathIsAncestor(cur, ctxt->context->node));
8196: return (cur);
8197: }
8198:
8199: /**
8200: * xmlXPathNextPrecedingInternal:
8201: * @ctxt: the XPath Parser context
8202: * @cur: the current node in the traversal
8203: *
8204: * Traversal function for the "preceding" direction
8205: * the preceding axis contains all nodes in the same document as the context
8206: * node that are before the context node in document order, excluding any
8207: * ancestors and excluding attribute nodes and namespace nodes; the nodes are
8208: * ordered in reverse document order
8209: * This is a faster implementation but internal only since it requires a
8210: * state kept in the parser context: ctxt->ancestor.
8211: *
8212: * Returns the next element following that axis
8213: */
8214: static xmlNodePtr
8215: xmlXPathNextPrecedingInternal(xmlXPathParserContextPtr ctxt,
8216: xmlNodePtr cur)
8217: {
8218: if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
8219: if (cur == NULL) {
8220: cur = ctxt->context->node;
8221: if (cur == NULL)
8222: return (NULL);
8223: if (cur->type == XML_NAMESPACE_DECL)
8224: return (NULL);
8225: ctxt->ancestor = cur->parent;
8226: }
8227: if ((cur->prev != NULL) && (cur->prev->type == XML_DTD_NODE))
8228: cur = cur->prev;
8229: while (cur->prev == NULL) {
8230: cur = cur->parent;
8231: if (cur == NULL)
8232: return (NULL);
8233: if (cur == ctxt->context->doc->children)
8234: return (NULL);
8235: if (cur != ctxt->ancestor)
8236: return (cur);
8237: ctxt->ancestor = cur->parent;
8238: }
8239: cur = cur->prev;
8240: while (cur->last != NULL)
8241: cur = cur->last;
8242: return (cur);
8243: }
8244:
8245: /**
8246: * xmlXPathNextNamespace:
8247: * @ctxt: the XPath Parser context
8248: * @cur: the current attribute in the traversal
8249: *
8250: * Traversal function for the "namespace" direction
8251: * the namespace axis contains the namespace nodes of the context node;
8252: * the order of nodes on this axis is implementation-defined; the axis will
8253: * be empty unless the context node is an element
8254: *
8255: * We keep the XML namespace node at the end of the list.
8256: *
8257: * Returns the next element following that axis
8258: */
8259: xmlNodePtr
8260: xmlXPathNextNamespace(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
8261: if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
8262: if (ctxt->context->node->type != XML_ELEMENT_NODE) return(NULL);
8263: if (ctxt->context->tmpNsList == NULL && cur != (xmlNodePtr) xmlXPathXMLNamespace) {
8264: if (ctxt->context->tmpNsList != NULL)
8265: xmlFree(ctxt->context->tmpNsList);
8266: ctxt->context->tmpNsList =
8267: xmlGetNsList(ctxt->context->doc, ctxt->context->node);
8268: ctxt->context->tmpNsNr = 0;
8269: if (ctxt->context->tmpNsList != NULL) {
8270: while (ctxt->context->tmpNsList[ctxt->context->tmpNsNr] != NULL) {
8271: ctxt->context->tmpNsNr++;
8272: }
8273: }
8274: return((xmlNodePtr) xmlXPathXMLNamespace);
8275: }
8276: if (ctxt->context->tmpNsNr > 0) {
8277: return (xmlNodePtr)ctxt->context->tmpNsList[--ctxt->context->tmpNsNr];
8278: } else {
8279: if (ctxt->context->tmpNsList != NULL)
8280: xmlFree(ctxt->context->tmpNsList);
8281: ctxt->context->tmpNsList = NULL;
8282: return(NULL);
8283: }
8284: }
8285:
8286: /**
8287: * xmlXPathNextAttribute:
8288: * @ctxt: the XPath Parser context
8289: * @cur: the current attribute in the traversal
8290: *
8291: * Traversal function for the "attribute" direction
8292: * TODO: support DTD inherited default attributes
8293: *
8294: * Returns the next element following that axis
8295: */
8296: xmlNodePtr
8297: xmlXPathNextAttribute(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
8298: if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
8299: if (ctxt->context->node == NULL)
8300: return(NULL);
8301: if (ctxt->context->node->type != XML_ELEMENT_NODE)
8302: return(NULL);
8303: if (cur == NULL) {
8304: if (ctxt->context->node == (xmlNodePtr) ctxt->context->doc)
8305: return(NULL);
8306: return((xmlNodePtr)ctxt->context->node->properties);
8307: }
8308: return((xmlNodePtr)cur->next);
8309: }
8310:
8311: /************************************************************************
8312: * *
8313: * NodeTest Functions *
8314: * *
8315: ************************************************************************/
8316:
8317: #define IS_FUNCTION 200
8318:
8319:
8320: /************************************************************************
8321: * *
8322: * Implicit tree core function library *
8323: * *
8324: ************************************************************************/
8325:
8326: /**
8327: * xmlXPathRoot:
8328: * @ctxt: the XPath Parser context
8329: *
8330: * Initialize the context to the root of the document
8331: */
8332: void
8333: xmlXPathRoot(xmlXPathParserContextPtr ctxt) {
8334: if ((ctxt == NULL) || (ctxt->context == NULL))
8335: return;
8336: ctxt->context->node = (xmlNodePtr) ctxt->context->doc;
8337: valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context,
8338: ctxt->context->node));
8339: }
8340:
8341: /************************************************************************
8342: * *
8343: * The explicit core function library *
8344: *http://www.w3.org/Style/XSL/Group/1999/07/xpath-19990705.html#corelib *
8345: * *
8346: ************************************************************************/
8347:
8348:
8349: /**
8350: * xmlXPathLastFunction:
8351: * @ctxt: the XPath Parser context
8352: * @nargs: the number of arguments
8353: *
8354: * Implement the last() XPath function
8355: * number last()
8356: * The last function returns the number of nodes in the context node list.
8357: */
8358: void
8359: xmlXPathLastFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8360: CHECK_ARITY(0);
8361: if (ctxt->context->contextSize >= 0) {
8362: valuePush(ctxt,
8363: xmlXPathCacheNewFloat(ctxt->context,
8364: (double) ctxt->context->contextSize));
8365: #ifdef DEBUG_EXPR
8366: xmlGenericError(xmlGenericErrorContext,
8367: "last() : %d\n", ctxt->context->contextSize);
8368: #endif
8369: } else {
8370: XP_ERROR(XPATH_INVALID_CTXT_SIZE);
8371: }
8372: }
8373:
8374: /**
8375: * xmlXPathPositionFunction:
8376: * @ctxt: the XPath Parser context
8377: * @nargs: the number of arguments
8378: *
8379: * Implement the position() XPath function
8380: * number position()
8381: * The position function returns the position of the context node in the
8382: * context node list. The first position is 1, and so the last position
8383: * will be equal to last().
8384: */
8385: void
8386: xmlXPathPositionFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8387: CHECK_ARITY(0);
8388: if (ctxt->context->proximityPosition >= 0) {
8389: valuePush(ctxt,
8390: xmlXPathCacheNewFloat(ctxt->context,
8391: (double) ctxt->context->proximityPosition));
8392: #ifdef DEBUG_EXPR
8393: xmlGenericError(xmlGenericErrorContext, "position() : %d\n",
8394: ctxt->context->proximityPosition);
8395: #endif
8396: } else {
8397: XP_ERROR(XPATH_INVALID_CTXT_POSITION);
8398: }
8399: }
8400:
8401: /**
8402: * xmlXPathCountFunction:
8403: * @ctxt: the XPath Parser context
8404: * @nargs: the number of arguments
8405: *
8406: * Implement the count() XPath function
8407: * number count(node-set)
8408: */
8409: void
8410: xmlXPathCountFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8411: xmlXPathObjectPtr cur;
8412:
8413: CHECK_ARITY(1);
8414: if ((ctxt->value == NULL) ||
8415: ((ctxt->value->type != XPATH_NODESET) &&
8416: (ctxt->value->type != XPATH_XSLT_TREE)))
8417: XP_ERROR(XPATH_INVALID_TYPE);
8418: cur = valuePop(ctxt);
8419:
8420: if ((cur == NULL) || (cur->nodesetval == NULL))
8421: valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, (double) 0));
8422: else if ((cur->type == XPATH_NODESET) || (cur->type == XPATH_XSLT_TREE)) {
8423: valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context,
8424: (double) cur->nodesetval->nodeNr));
8425: } else {
8426: if ((cur->nodesetval->nodeNr != 1) ||
8427: (cur->nodesetval->nodeTab == NULL)) {
8428: valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, (double) 0));
8429: } else {
8430: xmlNodePtr tmp;
8431: int i = 0;
8432:
8433: tmp = cur->nodesetval->nodeTab[0];
8434: if (tmp != NULL) {
8435: tmp = tmp->children;
8436: while (tmp != NULL) {
8437: tmp = tmp->next;
8438: i++;
8439: }
8440: }
8441: valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, (double) i));
8442: }
8443: }
8444: xmlXPathReleaseObject(ctxt->context, cur);
8445: }
8446:
8447: /**
8448: * xmlXPathGetElementsByIds:
8449: * @doc: the document
8450: * @ids: a whitespace separated list of IDs
8451: *
8452: * Selects elements by their unique ID.
8453: *
8454: * Returns a node-set of selected elements.
8455: */
8456: static xmlNodeSetPtr
8457: xmlXPathGetElementsByIds (xmlDocPtr doc, const xmlChar *ids) {
8458: xmlNodeSetPtr ret;
8459: const xmlChar *cur = ids;
8460: xmlChar *ID;
8461: xmlAttrPtr attr;
8462: xmlNodePtr elem = NULL;
8463:
8464: if (ids == NULL) return(NULL);
8465:
8466: ret = xmlXPathNodeSetCreate(NULL);
8467: if (ret == NULL)
8468: return(ret);
8469:
8470: while (IS_BLANK_CH(*cur)) cur++;
8471: while (*cur != 0) {
8472: while ((!IS_BLANK_CH(*cur)) && (*cur != 0))
8473: cur++;
8474:
8475: ID = xmlStrndup(ids, cur - ids);
8476: if (ID != NULL) {
8477: /*
8478: * We used to check the fact that the value passed
8479: * was an NCName, but this generated much troubles for
8480: * me and Aleksey Sanin, people blatantly violated that
8481: * constaint, like Visa3D spec.
8482: * if (xmlValidateNCName(ID, 1) == 0)
8483: */
8484: attr = xmlGetID(doc, ID);
8485: if (attr != NULL) {
8486: if (attr->type == XML_ATTRIBUTE_NODE)
8487: elem = attr->parent;
8488: else if (attr->type == XML_ELEMENT_NODE)
8489: elem = (xmlNodePtr) attr;
8490: else
8491: elem = NULL;
8492: if (elem != NULL)
8493: xmlXPathNodeSetAdd(ret, elem);
8494: }
8495: xmlFree(ID);
8496: }
8497:
8498: while (IS_BLANK_CH(*cur)) cur++;
8499: ids = cur;
8500: }
8501: return(ret);
8502: }
8503:
8504: /**
8505: * xmlXPathIdFunction:
8506: * @ctxt: the XPath Parser context
8507: * @nargs: the number of arguments
8508: *
8509: * Implement the id() XPath function
8510: * node-set id(object)
8511: * The id function selects elements by their unique ID
8512: * (see [5.2.1 Unique IDs]). When the argument to id is of type node-set,
8513: * then the result is the union of the result of applying id to the
8514: * string value of each of the nodes in the argument node-set. When the
8515: * argument to id is of any other type, the argument is converted to a
8516: * string as if by a call to the string function; the string is split
8517: * into a whitespace-separated list of tokens (whitespace is any sequence
8518: * of characters matching the production S); the result is a node-set
8519: * containing the elements in the same document as the context node that
8520: * have a unique ID equal to any of the tokens in the list.
8521: */
8522: void
8523: xmlXPathIdFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8524: xmlChar *tokens;
8525: xmlNodeSetPtr ret;
8526: xmlXPathObjectPtr obj;
8527:
8528: CHECK_ARITY(1);
8529: obj = valuePop(ctxt);
8530: if (obj == NULL) XP_ERROR(XPATH_INVALID_OPERAND);
8531: if ((obj->type == XPATH_NODESET) || (obj->type == XPATH_XSLT_TREE)) {
8532: xmlNodeSetPtr ns;
8533: int i;
8534:
8535: ret = xmlXPathNodeSetCreate(NULL);
8536: /*
8537: * FIXME -- in an out-of-memory condition this will behave badly.
8538: * The solution is not clear -- we already popped an item from
8539: * ctxt, so the object is in a corrupt state.
8540: */
8541:
8542: if (obj->nodesetval != NULL) {
8543: for (i = 0; i < obj->nodesetval->nodeNr; i++) {
8544: tokens =
8545: xmlXPathCastNodeToString(obj->nodesetval->nodeTab[i]);
8546: ns = xmlXPathGetElementsByIds(ctxt->context->doc, tokens);
8547: ret = xmlXPathNodeSetMerge(ret, ns);
8548: xmlXPathFreeNodeSet(ns);
8549: if (tokens != NULL)
8550: xmlFree(tokens);
8551: }
8552: }
8553: xmlXPathReleaseObject(ctxt->context, obj);
8554: valuePush(ctxt, xmlXPathCacheWrapNodeSet(ctxt->context, ret));
8555: return;
8556: }
8557: obj = xmlXPathCacheConvertString(ctxt->context, obj);
8558: ret = xmlXPathGetElementsByIds(ctxt->context->doc, obj->stringval);
8559: valuePush(ctxt, xmlXPathCacheWrapNodeSet(ctxt->context, ret));
8560: xmlXPathReleaseObject(ctxt->context, obj);
8561: return;
8562: }
8563:
8564: /**
8565: * xmlXPathLocalNameFunction:
8566: * @ctxt: the XPath Parser context
8567: * @nargs: the number of arguments
8568: *
8569: * Implement the local-name() XPath function
8570: * string local-name(node-set?)
8571: * The local-name function returns a string containing the local part
8572: * of the name of the node in the argument node-set that is first in
8573: * document order. If the node-set is empty or the first node has no
8574: * name, an empty string is returned. If the argument is omitted it
8575: * defaults to the context node.
8576: */
8577: void
8578: xmlXPathLocalNameFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8579: xmlXPathObjectPtr cur;
8580:
8581: if (ctxt == NULL) return;
8582:
8583: if (nargs == 0) {
8584: valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context,
8585: ctxt->context->node));
8586: nargs = 1;
8587: }
8588:
8589: CHECK_ARITY(1);
8590: if ((ctxt->value == NULL) ||
8591: ((ctxt->value->type != XPATH_NODESET) &&
8592: (ctxt->value->type != XPATH_XSLT_TREE)))
8593: XP_ERROR(XPATH_INVALID_TYPE);
8594: cur = valuePop(ctxt);
8595:
8596: if ((cur->nodesetval == NULL) || (cur->nodesetval->nodeNr == 0)) {
8597: valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, ""));
8598: } else {
8599: int i = 0; /* Should be first in document order !!!!! */
8600: switch (cur->nodesetval->nodeTab[i]->type) {
8601: case XML_ELEMENT_NODE:
8602: case XML_ATTRIBUTE_NODE:
8603: case XML_PI_NODE:
8604: if (cur->nodesetval->nodeTab[i]->name[0] == ' ')
8605: valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, ""));
8606: else
8607: valuePush(ctxt,
8608: xmlXPathCacheNewString(ctxt->context,
8609: cur->nodesetval->nodeTab[i]->name));
8610: break;
8611: case XML_NAMESPACE_DECL:
8612: valuePush(ctxt, xmlXPathCacheNewString(ctxt->context,
8613: ((xmlNsPtr)cur->nodesetval->nodeTab[i])->prefix));
8614: break;
8615: default:
8616: valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, ""));
8617: }
8618: }
8619: xmlXPathReleaseObject(ctxt->context, cur);
8620: }
8621:
8622: /**
8623: * xmlXPathNamespaceURIFunction:
8624: * @ctxt: the XPath Parser context
8625: * @nargs: the number of arguments
8626: *
8627: * Implement the namespace-uri() XPath function
8628: * string namespace-uri(node-set?)
8629: * The namespace-uri function returns a string containing the
8630: * namespace URI of the expanded name of the node in the argument
8631: * node-set that is first in document order. If the node-set is empty,
8632: * the first node has no name, or the expanded name has no namespace
8633: * URI, an empty string is returned. If the argument is omitted it
8634: * defaults to the context node.
8635: */
8636: void
8637: xmlXPathNamespaceURIFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8638: xmlXPathObjectPtr cur;
8639:
8640: if (ctxt == NULL) return;
8641:
8642: if (nargs == 0) {
8643: valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context,
8644: ctxt->context->node));
8645: nargs = 1;
8646: }
8647: CHECK_ARITY(1);
8648: if ((ctxt->value == NULL) ||
8649: ((ctxt->value->type != XPATH_NODESET) &&
8650: (ctxt->value->type != XPATH_XSLT_TREE)))
8651: XP_ERROR(XPATH_INVALID_TYPE);
8652: cur = valuePop(ctxt);
8653:
8654: if ((cur->nodesetval == NULL) || (cur->nodesetval->nodeNr == 0)) {
8655: valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, ""));
8656: } else {
8657: int i = 0; /* Should be first in document order !!!!! */
8658: switch (cur->nodesetval->nodeTab[i]->type) {
8659: case XML_ELEMENT_NODE:
8660: case XML_ATTRIBUTE_NODE:
8661: if (cur->nodesetval->nodeTab[i]->ns == NULL)
8662: valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, ""));
8663: else
8664: valuePush(ctxt, xmlXPathCacheNewString(ctxt->context,
8665: cur->nodesetval->nodeTab[i]->ns->href));
8666: break;
8667: default:
8668: valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, ""));
8669: }
8670: }
8671: xmlXPathReleaseObject(ctxt->context, cur);
8672: }
8673:
8674: /**
8675: * xmlXPathNameFunction:
8676: * @ctxt: the XPath Parser context
8677: * @nargs: the number of arguments
8678: *
8679: * Implement the name() XPath function
8680: * string name(node-set?)
8681: * The name function returns a string containing a QName representing
8682: * the name of the node in the argument node-set that is first in document
8683: * order. The QName must represent the name with respect to the namespace
8684: * declarations in effect on the node whose name is being represented.
8685: * Typically, this will be the form in which the name occurred in the XML
8686: * source. This need not be the case if there are namespace declarations
8687: * in effect on the node that associate multiple prefixes with the same
8688: * namespace. However, an implementation may include information about
8689: * the original prefix in its representation of nodes; in this case, an
8690: * implementation can ensure that the returned string is always the same
8691: * as the QName used in the XML source. If the argument it omitted it
8692: * defaults to the context node.
8693: * Libxml keep the original prefix so the "real qualified name" used is
8694: * returned.
8695: */
8696: static void
8697: xmlXPathNameFunction(xmlXPathParserContextPtr ctxt, int nargs)
8698: {
8699: xmlXPathObjectPtr cur;
8700:
8701: if (nargs == 0) {
8702: valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context,
8703: ctxt->context->node));
8704: nargs = 1;
8705: }
8706:
8707: CHECK_ARITY(1);
8708: if ((ctxt->value == NULL) ||
8709: ((ctxt->value->type != XPATH_NODESET) &&
8710: (ctxt->value->type != XPATH_XSLT_TREE)))
8711: XP_ERROR(XPATH_INVALID_TYPE);
8712: cur = valuePop(ctxt);
8713:
8714: if ((cur->nodesetval == NULL) || (cur->nodesetval->nodeNr == 0)) {
8715: valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, ""));
8716: } else {
8717: int i = 0; /* Should be first in document order !!!!! */
8718:
8719: switch (cur->nodesetval->nodeTab[i]->type) {
8720: case XML_ELEMENT_NODE:
8721: case XML_ATTRIBUTE_NODE:
8722: if (cur->nodesetval->nodeTab[i]->name[0] == ' ')
8723: valuePush(ctxt,
8724: xmlXPathCacheNewCString(ctxt->context, ""));
8725: else if ((cur->nodesetval->nodeTab[i]->ns == NULL) ||
8726: (cur->nodesetval->nodeTab[i]->ns->prefix == NULL)) {
8727: valuePush(ctxt,
8728: xmlXPathCacheNewString(ctxt->context,
8729: cur->nodesetval->nodeTab[i]->name));
8730: } else {
8731: xmlChar *fullname;
8732:
8733: fullname = xmlBuildQName(cur->nodesetval->nodeTab[i]->name,
8734: cur->nodesetval->nodeTab[i]->ns->prefix,
8735: NULL, 0);
8736: if (fullname == cur->nodesetval->nodeTab[i]->name)
8737: fullname = xmlStrdup(cur->nodesetval->nodeTab[i]->name);
8738: if (fullname == NULL) {
8739: XP_ERROR(XPATH_MEMORY_ERROR);
8740: }
8741: valuePush(ctxt, xmlXPathCacheWrapString(
8742: ctxt->context, fullname));
8743: }
8744: break;
8745: default:
8746: valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context,
8747: cur->nodesetval->nodeTab[i]));
8748: xmlXPathLocalNameFunction(ctxt, 1);
8749: }
8750: }
8751: xmlXPathReleaseObject(ctxt->context, cur);
8752: }
8753:
8754:
8755: /**
8756: * xmlXPathStringFunction:
8757: * @ctxt: the XPath Parser context
8758: * @nargs: the number of arguments
8759: *
8760: * Implement the string() XPath function
8761: * string string(object?)
8762: * The string function converts an object to a string as follows:
8763: * - A node-set is converted to a string by returning the value of
8764: * the node in the node-set that is first in document order.
8765: * If the node-set is empty, an empty string is returned.
8766: * - A number is converted to a string as follows
8767: * + NaN is converted to the string NaN
8768: * + positive zero is converted to the string 0
8769: * + negative zero is converted to the string 0
8770: * + positive infinity is converted to the string Infinity
8771: * + negative infinity is converted to the string -Infinity
8772: * + if the number is an integer, the number is represented in
8773: * decimal form as a Number with no decimal point and no leading
8774: * zeros, preceded by a minus sign (-) if the number is negative
8775: * + otherwise, the number is represented in decimal form as a
8776: * Number including a decimal point with at least one digit
8777: * before the decimal point and at least one digit after the
8778: * decimal point, preceded by a minus sign (-) if the number
8779: * is negative; there must be no leading zeros before the decimal
8780: * point apart possibly from the one required digit immediately
8781: * before the decimal point; beyond the one required digit
8782: * after the decimal point there must be as many, but only as
8783: * many, more digits as are needed to uniquely distinguish the
8784: * number from all other IEEE 754 numeric values.
8785: * - The boolean false value is converted to the string false.
8786: * The boolean true value is converted to the string true.
8787: *
8788: * If the argument is omitted, it defaults to a node-set with the
8789: * context node as its only member.
8790: */
8791: void
8792: xmlXPathStringFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8793: xmlXPathObjectPtr cur;
8794:
8795: if (ctxt == NULL) return;
8796: if (nargs == 0) {
8797: valuePush(ctxt,
8798: xmlXPathCacheWrapString(ctxt->context,
8799: xmlXPathCastNodeToString(ctxt->context->node)));
8800: return;
8801: }
8802:
8803: CHECK_ARITY(1);
8804: cur = valuePop(ctxt);
8805: if (cur == NULL) XP_ERROR(XPATH_INVALID_OPERAND);
8806: valuePush(ctxt, xmlXPathCacheConvertString(ctxt->context, cur));
8807: }
8808:
8809: /**
8810: * xmlXPathStringLengthFunction:
8811: * @ctxt: the XPath Parser context
8812: * @nargs: the number of arguments
8813: *
8814: * Implement the string-length() XPath function
8815: * number string-length(string?)
8816: * The string-length returns the number of characters in the string
8817: * (see [3.6 Strings]). If the argument is omitted, it defaults to
8818: * the context node converted to a string, in other words the value
8819: * of the context node.
8820: */
8821: void
8822: xmlXPathStringLengthFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8823: xmlXPathObjectPtr cur;
8824:
8825: if (nargs == 0) {
8826: if ((ctxt == NULL) || (ctxt->context == NULL))
8827: return;
8828: if (ctxt->context->node == NULL) {
8829: valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, 0));
8830: } else {
8831: xmlChar *content;
8832:
8833: content = xmlXPathCastNodeToString(ctxt->context->node);
8834: valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context,
8835: xmlUTF8Strlen(content)));
8836: xmlFree(content);
8837: }
8838: return;
8839: }
8840: CHECK_ARITY(1);
8841: CAST_TO_STRING;
8842: CHECK_TYPE(XPATH_STRING);
8843: cur = valuePop(ctxt);
8844: valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context,
8845: xmlUTF8Strlen(cur->stringval)));
8846: xmlXPathReleaseObject(ctxt->context, cur);
8847: }
8848:
8849: /**
8850: * xmlXPathConcatFunction:
8851: * @ctxt: the XPath Parser context
8852: * @nargs: the number of arguments
8853: *
8854: * Implement the concat() XPath function
8855: * string concat(string, string, string*)
8856: * The concat function returns the concatenation of its arguments.
8857: */
8858: void
8859: xmlXPathConcatFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8860: xmlXPathObjectPtr cur, newobj;
8861: xmlChar *tmp;
8862:
8863: if (ctxt == NULL) return;
8864: if (nargs < 2) {
8865: CHECK_ARITY(2);
8866: }
8867:
8868: CAST_TO_STRING;
8869: cur = valuePop(ctxt);
8870: if ((cur == NULL) || (cur->type != XPATH_STRING)) {
8871: xmlXPathReleaseObject(ctxt->context, cur);
8872: return;
8873: }
8874: nargs--;
8875:
8876: while (nargs > 0) {
8877: CAST_TO_STRING;
8878: newobj = valuePop(ctxt);
8879: if ((newobj == NULL) || (newobj->type != XPATH_STRING)) {
8880: xmlXPathReleaseObject(ctxt->context, newobj);
8881: xmlXPathReleaseObject(ctxt->context, cur);
8882: XP_ERROR(XPATH_INVALID_TYPE);
8883: }
8884: tmp = xmlStrcat(newobj->stringval, cur->stringval);
8885: newobj->stringval = cur->stringval;
8886: cur->stringval = tmp;
8887: xmlXPathReleaseObject(ctxt->context, newobj);
8888: nargs--;
8889: }
8890: valuePush(ctxt, cur);
8891: }
8892:
8893: /**
8894: * xmlXPathContainsFunction:
8895: * @ctxt: the XPath Parser context
8896: * @nargs: the number of arguments
8897: *
8898: * Implement the contains() XPath function
8899: * boolean contains(string, string)
8900: * The contains function returns true if the first argument string
8901: * contains the second argument string, and otherwise returns false.
8902: */
8903: void
8904: xmlXPathContainsFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8905: xmlXPathObjectPtr hay, needle;
8906:
8907: CHECK_ARITY(2);
8908: CAST_TO_STRING;
8909: CHECK_TYPE(XPATH_STRING);
8910: needle = valuePop(ctxt);
8911: CAST_TO_STRING;
8912: hay = valuePop(ctxt);
8913:
8914: if ((hay == NULL) || (hay->type != XPATH_STRING)) {
8915: xmlXPathReleaseObject(ctxt->context, hay);
8916: xmlXPathReleaseObject(ctxt->context, needle);
8917: XP_ERROR(XPATH_INVALID_TYPE);
8918: }
8919: if (xmlStrstr(hay->stringval, needle->stringval))
8920: valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, 1));
8921: else
8922: valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, 0));
8923: xmlXPathReleaseObject(ctxt->context, hay);
8924: xmlXPathReleaseObject(ctxt->context, needle);
8925: }
8926:
8927: /**
8928: * xmlXPathStartsWithFunction:
8929: * @ctxt: the XPath Parser context
8930: * @nargs: the number of arguments
8931: *
8932: * Implement the starts-with() XPath function
8933: * boolean starts-with(string, string)
8934: * The starts-with function returns true if the first argument string
8935: * starts with the second argument string, and otherwise returns false.
8936: */
8937: void
8938: xmlXPathStartsWithFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8939: xmlXPathObjectPtr hay, needle;
8940: int n;
8941:
8942: CHECK_ARITY(2);
8943: CAST_TO_STRING;
8944: CHECK_TYPE(XPATH_STRING);
8945: needle = valuePop(ctxt);
8946: CAST_TO_STRING;
8947: hay = valuePop(ctxt);
8948:
8949: if ((hay == NULL) || (hay->type != XPATH_STRING)) {
8950: xmlXPathReleaseObject(ctxt->context, hay);
8951: xmlXPathReleaseObject(ctxt->context, needle);
8952: XP_ERROR(XPATH_INVALID_TYPE);
8953: }
8954: n = xmlStrlen(needle->stringval);
8955: if (xmlStrncmp(hay->stringval, needle->stringval, n))
8956: valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, 0));
8957: else
8958: valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, 1));
8959: xmlXPathReleaseObject(ctxt->context, hay);
8960: xmlXPathReleaseObject(ctxt->context, needle);
8961: }
8962:
8963: /**
8964: * xmlXPathSubstringFunction:
8965: * @ctxt: the XPath Parser context
8966: * @nargs: the number of arguments
8967: *
8968: * Implement the substring() XPath function
8969: * string substring(string, number, number?)
8970: * The substring function returns the substring of the first argument
8971: * starting at the position specified in the second argument with
8972: * length specified in the third argument. For example,
8973: * substring("12345",2,3) returns "234". If the third argument is not
8974: * specified, it returns the substring starting at the position specified
8975: * in the second argument and continuing to the end of the string. For
8976: * example, substring("12345",2) returns "2345". More precisely, each
8977: * character in the string (see [3.6 Strings]) is considered to have a
8978: * numeric position: the position of the first character is 1, the position
8979: * of the second character is 2 and so on. The returned substring contains
8980: * those characters for which the position of the character is greater than
8981: * or equal to the second argument and, if the third argument is specified,
8982: * less than the sum of the second and third arguments; the comparisons
8983: * and addition used for the above follow the standard IEEE 754 rules. Thus:
8984: * - substring("12345", 1.5, 2.6) returns "234"
8985: * - substring("12345", 0, 3) returns "12"
8986: * - substring("12345", 0 div 0, 3) returns ""
8987: * - substring("12345", 1, 0 div 0) returns ""
8988: * - substring("12345", -42, 1 div 0) returns "12345"
8989: * - substring("12345", -1 div 0, 1 div 0) returns ""
8990: */
8991: void
8992: xmlXPathSubstringFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8993: xmlXPathObjectPtr str, start, len;
8994: double le=0, in;
8995: int i, l, m;
8996: xmlChar *ret;
8997:
8998: if (nargs < 2) {
8999: CHECK_ARITY(2);
9000: }
9001: if (nargs > 3) {
9002: CHECK_ARITY(3);
9003: }
9004: /*
9005: * take care of possible last (position) argument
9006: */
9007: if (nargs == 3) {
9008: CAST_TO_NUMBER;
9009: CHECK_TYPE(XPATH_NUMBER);
9010: len = valuePop(ctxt);
9011: le = len->floatval;
9012: xmlXPathReleaseObject(ctxt->context, len);
9013: }
9014:
9015: CAST_TO_NUMBER;
9016: CHECK_TYPE(XPATH_NUMBER);
9017: start = valuePop(ctxt);
9018: in = start->floatval;
9019: xmlXPathReleaseObject(ctxt->context, start);
9020: CAST_TO_STRING;
9021: CHECK_TYPE(XPATH_STRING);
9022: str = valuePop(ctxt);
9023: m = xmlUTF8Strlen((const unsigned char *)str->stringval);
9024:
9025: /*
9026: * If last pos not present, calculate last position
9027: */
9028: if (nargs != 3) {
9029: le = (double)m;
9030: if (in < 1.0)
9031: in = 1.0;
9032: }
9033:
9034: /* Need to check for the special cases where either
9035: * the index is NaN, the length is NaN, or both
9036: * arguments are infinity (relying on Inf + -Inf = NaN)
9037: */
9038: if (!xmlXPathIsInf(in) && !xmlXPathIsNaN(in + le)) {
9039: /*
9040: * To meet the requirements of the spec, the arguments
9041: * must be converted to integer format before
9042: * initial index calculations are done
9043: *
9044: * First we go to integer form, rounding up
9045: * and checking for special cases
9046: */
9047: i = (int) in;
9048: if (((double)i)+0.5 <= in) i++;
9049:
9050: if (xmlXPathIsInf(le) == 1) {
9051: l = m;
9052: if (i < 1)
9053: i = 1;
9054: }
9055: else if (xmlXPathIsInf(le) == -1 || le < 0.0)
9056: l = 0;
9057: else {
9058: l = (int) le;
9059: if (((double)l)+0.5 <= le) l++;
9060: }
9061:
9062: /* Now we normalize inidices */
9063: i -= 1;
9064: l += i;
9065: if (i < 0)
9066: i = 0;
9067: if (l > m)
9068: l = m;
9069:
9070: /* number of chars to copy */
9071: l -= i;
9072:
9073: ret = xmlUTF8Strsub(str->stringval, i, l);
9074: }
9075: else {
9076: ret = NULL;
9077: }
9078: if (ret == NULL)
9079: valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, ""));
9080: else {
9081: valuePush(ctxt, xmlXPathCacheNewString(ctxt->context, ret));
9082: xmlFree(ret);
9083: }
9084: xmlXPathReleaseObject(ctxt->context, str);
9085: }
9086:
9087: /**
9088: * xmlXPathSubstringBeforeFunction:
9089: * @ctxt: the XPath Parser context
9090: * @nargs: the number of arguments
9091: *
9092: * Implement the substring-before() XPath function
9093: * string substring-before(string, string)
9094: * The substring-before function returns the substring of the first
9095: * argument string that precedes the first occurrence of the second
9096: * argument string in the first argument string, or the empty string
9097: * if the first argument string does not contain the second argument
9098: * string. For example, substring-before("1999/04/01","/") returns 1999.
9099: */
9100: void
9101: xmlXPathSubstringBeforeFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9102: xmlXPathObjectPtr str;
9103: xmlXPathObjectPtr find;
9104: xmlBufferPtr target;
9105: const xmlChar *point;
9106: int offset;
9107:
9108: CHECK_ARITY(2);
9109: CAST_TO_STRING;
9110: find = valuePop(ctxt);
9111: CAST_TO_STRING;
9112: str = valuePop(ctxt);
9113:
9114: target = xmlBufferCreate();
9115: if (target) {
9116: point = xmlStrstr(str->stringval, find->stringval);
9117: if (point) {
9118: offset = (int)(point - str->stringval);
9119: xmlBufferAdd(target, str->stringval, offset);
9120: }
9121: valuePush(ctxt, xmlXPathCacheNewString(ctxt->context,
9122: xmlBufferContent(target)));
9123: xmlBufferFree(target);
9124: }
9125: xmlXPathReleaseObject(ctxt->context, str);
9126: xmlXPathReleaseObject(ctxt->context, find);
9127: }
9128:
9129: /**
9130: * xmlXPathSubstringAfterFunction:
9131: * @ctxt: the XPath Parser context
9132: * @nargs: the number of arguments
9133: *
9134: * Implement the substring-after() XPath function
9135: * string substring-after(string, string)
9136: * The substring-after function returns the substring of the first
9137: * argument string that follows the first occurrence of the second
9138: * argument string in the first argument string, or the empty stringi
9139: * if the first argument string does not contain the second argument
9140: * string. For example, substring-after("1999/04/01","/") returns 04/01,
9141: * and substring-after("1999/04/01","19") returns 99/04/01.
9142: */
9143: void
9144: xmlXPathSubstringAfterFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9145: xmlXPathObjectPtr str;
9146: xmlXPathObjectPtr find;
9147: xmlBufferPtr target;
9148: const xmlChar *point;
9149: int offset;
9150:
9151: CHECK_ARITY(2);
9152: CAST_TO_STRING;
9153: find = valuePop(ctxt);
9154: CAST_TO_STRING;
9155: str = valuePop(ctxt);
9156:
9157: target = xmlBufferCreate();
9158: if (target) {
9159: point = xmlStrstr(str->stringval, find->stringval);
9160: if (point) {
9161: offset = (int)(point - str->stringval) + xmlStrlen(find->stringval);
9162: xmlBufferAdd(target, &str->stringval[offset],
9163: xmlStrlen(str->stringval) - offset);
9164: }
9165: valuePush(ctxt, xmlXPathCacheNewString(ctxt->context,
9166: xmlBufferContent(target)));
9167: xmlBufferFree(target);
9168: }
9169: xmlXPathReleaseObject(ctxt->context, str);
9170: xmlXPathReleaseObject(ctxt->context, find);
9171: }
9172:
9173: /**
9174: * xmlXPathNormalizeFunction:
9175: * @ctxt: the XPath Parser context
9176: * @nargs: the number of arguments
9177: *
9178: * Implement the normalize-space() XPath function
9179: * string normalize-space(string?)
9180: * The normalize-space function returns the argument string with white
9181: * space normalized by stripping leading and trailing whitespace
9182: * and replacing sequences of whitespace characters by a single
9183: * space. Whitespace characters are the same allowed by the S production
9184: * in XML. If the argument is omitted, it defaults to the context
9185: * node converted to a string, in other words the value of the context node.
9186: */
9187: void
9188: xmlXPathNormalizeFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9189: xmlXPathObjectPtr obj = NULL;
9190: xmlChar *source = NULL;
9191: xmlBufferPtr target;
9192: xmlChar blank;
9193:
9194: if (ctxt == NULL) return;
9195: if (nargs == 0) {
9196: /* Use current context node */
9197: valuePush(ctxt,
9198: xmlXPathCacheWrapString(ctxt->context,
9199: xmlXPathCastNodeToString(ctxt->context->node)));
9200: nargs = 1;
9201: }
9202:
9203: CHECK_ARITY(1);
9204: CAST_TO_STRING;
9205: CHECK_TYPE(XPATH_STRING);
9206: obj = valuePop(ctxt);
9207: source = obj->stringval;
9208:
9209: target = xmlBufferCreate();
9210: if (target && source) {
9211:
9212: /* Skip leading whitespaces */
9213: while (IS_BLANK_CH(*source))
9214: source++;
9215:
9216: /* Collapse intermediate whitespaces, and skip trailing whitespaces */
9217: blank = 0;
9218: while (*source) {
9219: if (IS_BLANK_CH(*source)) {
9220: blank = 0x20;
9221: } else {
9222: if (blank) {
9223: xmlBufferAdd(target, &blank, 1);
9224: blank = 0;
9225: }
9226: xmlBufferAdd(target, source, 1);
9227: }
9228: source++;
9229: }
9230: valuePush(ctxt, xmlXPathCacheNewString(ctxt->context,
9231: xmlBufferContent(target)));
9232: xmlBufferFree(target);
9233: }
9234: xmlXPathReleaseObject(ctxt->context, obj);
9235: }
9236:
9237: /**
9238: * xmlXPathTranslateFunction:
9239: * @ctxt: the XPath Parser context
9240: * @nargs: the number of arguments
9241: *
9242: * Implement the translate() XPath function
9243: * string translate(string, string, string)
9244: * The translate function returns the first argument string with
9245: * occurrences of characters in the second argument string replaced
9246: * by the character at the corresponding position in the third argument
9247: * string. For example, translate("bar","abc","ABC") returns the string
9248: * BAr. If there is a character in the second argument string with no
9249: * character at a corresponding position in the third argument string
9250: * (because the second argument string is longer than the third argument
9251: * string), then occurrences of that character in the first argument
9252: * string are removed. For example, translate("--aaa--","abc-","ABC")
9253: * returns "AAA". If a character occurs more than once in second
9254: * argument string, then the first occurrence determines the replacement
9255: * character. If the third argument string is longer than the second
9256: * argument string, then excess characters are ignored.
9257: */
9258: void
9259: xmlXPathTranslateFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9260: xmlXPathObjectPtr str;
9261: xmlXPathObjectPtr from;
9262: xmlXPathObjectPtr to;
9263: xmlBufferPtr target;
9264: int offset, max;
9265: xmlChar ch;
9266: const xmlChar *point;
9267: xmlChar *cptr;
9268:
9269: CHECK_ARITY(3);
9270:
9271: CAST_TO_STRING;
9272: to = valuePop(ctxt);
9273: CAST_TO_STRING;
9274: from = valuePop(ctxt);
9275: CAST_TO_STRING;
9276: str = valuePop(ctxt);
9277:
9278: target = xmlBufferCreate();
9279: if (target) {
9280: max = xmlUTF8Strlen(to->stringval);
9281: for (cptr = str->stringval; (ch=*cptr); ) {
9282: offset = xmlUTF8Strloc(from->stringval, cptr);
9283: if (offset >= 0) {
9284: if (offset < max) {
9285: point = xmlUTF8Strpos(to->stringval, offset);
9286: if (point)
9287: xmlBufferAdd(target, point, xmlUTF8Strsize(point, 1));
9288: }
9289: } else
9290: xmlBufferAdd(target, cptr, xmlUTF8Strsize(cptr, 1));
9291:
9292: /* Step to next character in input */
9293: cptr++;
9294: if ( ch & 0x80 ) {
9295: /* if not simple ascii, verify proper format */
9296: if ( (ch & 0xc0) != 0xc0 ) {
9297: xmlGenericError(xmlGenericErrorContext,
9298: "xmlXPathTranslateFunction: Invalid UTF8 string\n");
9299: break;
9300: }
9301: /* then skip over remaining bytes for this char */
9302: while ( (ch <<= 1) & 0x80 )
9303: if ( (*cptr++ & 0xc0) != 0x80 ) {
9304: xmlGenericError(xmlGenericErrorContext,
9305: "xmlXPathTranslateFunction: Invalid UTF8 string\n");
9306: break;
9307: }
9308: if (ch & 0x80) /* must have had error encountered */
9309: break;
9310: }
9311: }
9312: }
9313: valuePush(ctxt, xmlXPathCacheNewString(ctxt->context,
9314: xmlBufferContent(target)));
9315: xmlBufferFree(target);
9316: xmlXPathReleaseObject(ctxt->context, str);
9317: xmlXPathReleaseObject(ctxt->context, from);
9318: xmlXPathReleaseObject(ctxt->context, to);
9319: }
9320:
9321: /**
9322: * xmlXPathBooleanFunction:
9323: * @ctxt: the XPath Parser context
9324: * @nargs: the number of arguments
9325: *
9326: * Implement the boolean() XPath function
9327: * boolean boolean(object)
9328: * The boolean function converts its argument to a boolean as follows:
9329: * - a number is true if and only if it is neither positive or
9330: * negative zero nor NaN
9331: * - a node-set is true if and only if it is non-empty
9332: * - a string is true if and only if its length is non-zero
9333: */
9334: void
9335: xmlXPathBooleanFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9336: xmlXPathObjectPtr cur;
9337:
9338: CHECK_ARITY(1);
9339: cur = valuePop(ctxt);
9340: if (cur == NULL) XP_ERROR(XPATH_INVALID_OPERAND);
9341: cur = xmlXPathCacheConvertBoolean(ctxt->context, cur);
9342: valuePush(ctxt, cur);
9343: }
9344:
9345: /**
9346: * xmlXPathNotFunction:
9347: * @ctxt: the XPath Parser context
9348: * @nargs: the number of arguments
9349: *
9350: * Implement the not() XPath function
9351: * boolean not(boolean)
9352: * The not function returns true if its argument is false,
9353: * and false otherwise.
9354: */
9355: void
9356: xmlXPathNotFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9357: CHECK_ARITY(1);
9358: CAST_TO_BOOLEAN;
9359: CHECK_TYPE(XPATH_BOOLEAN);
9360: ctxt->value->boolval = ! ctxt->value->boolval;
9361: }
9362:
9363: /**
9364: * xmlXPathTrueFunction:
9365: * @ctxt: the XPath Parser context
9366: * @nargs: the number of arguments
9367: *
9368: * Implement the true() XPath function
9369: * boolean true()
9370: */
9371: void
9372: xmlXPathTrueFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9373: CHECK_ARITY(0);
9374: valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, 1));
9375: }
9376:
9377: /**
9378: * xmlXPathFalseFunction:
9379: * @ctxt: the XPath Parser context
9380: * @nargs: the number of arguments
9381: *
9382: * Implement the false() XPath function
9383: * boolean false()
9384: */
9385: void
9386: xmlXPathFalseFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9387: CHECK_ARITY(0);
9388: valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, 0));
9389: }
9390:
9391: /**
9392: * xmlXPathLangFunction:
9393: * @ctxt: the XPath Parser context
9394: * @nargs: the number of arguments
9395: *
9396: * Implement the lang() XPath function
9397: * boolean lang(string)
9398: * The lang function returns true or false depending on whether the
9399: * language of the context node as specified by xml:lang attributes
9400: * is the same as or is a sublanguage of the language specified by
9401: * the argument string. The language of the context node is determined
9402: * by the value of the xml:lang attribute on the context node, or, if
9403: * the context node has no xml:lang attribute, by the value of the
9404: * xml:lang attribute on the nearest ancestor of the context node that
9405: * has an xml:lang attribute. If there is no such attribute, then lang
9406: * returns false. If there is such an attribute, then lang returns
9407: * true if the attribute value is equal to the argument ignoring case,
9408: * or if there is some suffix starting with - such that the attribute
9409: * value is equal to the argument ignoring that suffix of the attribute
9410: * value and ignoring case.
9411: */
9412: void
9413: xmlXPathLangFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9414: xmlXPathObjectPtr val = NULL;
9415: const xmlChar *theLang = NULL;
9416: const xmlChar *lang;
9417: int ret = 0;
9418: int i;
9419:
9420: CHECK_ARITY(1);
9421: CAST_TO_STRING;
9422: CHECK_TYPE(XPATH_STRING);
9423: val = valuePop(ctxt);
9424: lang = val->stringval;
9425: theLang = xmlNodeGetLang(ctxt->context->node);
9426: if ((theLang != NULL) && (lang != NULL)) {
9427: for (i = 0;lang[i] != 0;i++)
9428: if (toupper(lang[i]) != toupper(theLang[i]))
9429: goto not_equal;
9430: if ((theLang[i] == 0) || (theLang[i] == '-'))
9431: ret = 1;
9432: }
9433: not_equal:
9434: if (theLang != NULL)
9435: xmlFree((void *)theLang);
9436:
9437: xmlXPathReleaseObject(ctxt->context, val);
9438: valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, ret));
9439: }
9440:
9441: /**
9442: * xmlXPathNumberFunction:
9443: * @ctxt: the XPath Parser context
9444: * @nargs: the number of arguments
9445: *
9446: * Implement the number() XPath function
9447: * number number(object?)
9448: */
9449: void
9450: xmlXPathNumberFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9451: xmlXPathObjectPtr cur;
9452: double res;
9453:
9454: if (ctxt == NULL) return;
9455: if (nargs == 0) {
9456: if (ctxt->context->node == NULL) {
9457: valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, 0.0));
9458: } else {
9459: xmlChar* content = xmlNodeGetContent(ctxt->context->node);
9460:
9461: res = xmlXPathStringEvalNumber(content);
9462: valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, res));
9463: xmlFree(content);
9464: }
9465: return;
9466: }
9467:
9468: CHECK_ARITY(1);
9469: cur = valuePop(ctxt);
9470: valuePush(ctxt, xmlXPathCacheConvertNumber(ctxt->context, cur));
9471: }
9472:
9473: /**
9474: * xmlXPathSumFunction:
9475: * @ctxt: the XPath Parser context
9476: * @nargs: the number of arguments
9477: *
9478: * Implement the sum() XPath function
9479: * number sum(node-set)
9480: * The sum function returns the sum of the values of the nodes in
9481: * the argument node-set.
9482: */
9483: void
9484: xmlXPathSumFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9485: xmlXPathObjectPtr cur;
9486: int i;
9487: double res = 0.0;
9488:
9489: CHECK_ARITY(1);
9490: if ((ctxt->value == NULL) ||
9491: ((ctxt->value->type != XPATH_NODESET) &&
9492: (ctxt->value->type != XPATH_XSLT_TREE)))
9493: XP_ERROR(XPATH_INVALID_TYPE);
9494: cur = valuePop(ctxt);
9495:
9496: if ((cur->nodesetval != NULL) && (cur->nodesetval->nodeNr != 0)) {
9497: for (i = 0; i < cur->nodesetval->nodeNr; i++) {
9498: res += xmlXPathCastNodeToNumber(cur->nodesetval->nodeTab[i]);
9499: }
9500: }
9501: valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, res));
9502: xmlXPathReleaseObject(ctxt->context, cur);
9503: }
9504:
9505: /*
9506: * To assure working code on multiple platforms, we want to only depend
9507: * upon the characteristic truncation of converting a floating point value
9508: * to an integer. Unfortunately, because of the different storage sizes
9509: * of our internal floating point value (double) and integer (int), we
9510: * can't directly convert (see bug 301162). This macro is a messy
9511: * 'workaround'
9512: */
9513: #define XTRUNC(f, v) \
9514: f = fmod((v), INT_MAX); \
9515: f = (v) - (f) + (double)((int)(f));
9516:
9517: /**
9518: * xmlXPathFloorFunction:
9519: * @ctxt: the XPath Parser context
9520: * @nargs: the number of arguments
9521: *
9522: * Implement the floor() XPath function
9523: * number floor(number)
9524: * The floor function returns the largest (closest to positive infinity)
9525: * number that is not greater than the argument and that is an integer.
9526: */
9527: void
9528: xmlXPathFloorFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9529: double f;
9530:
9531: CHECK_ARITY(1);
9532: CAST_TO_NUMBER;
9533: CHECK_TYPE(XPATH_NUMBER);
9534:
9535: XTRUNC(f, ctxt->value->floatval);
9536: if (f != ctxt->value->floatval) {
9537: if (ctxt->value->floatval > 0)
9538: ctxt->value->floatval = f;
9539: else
9540: ctxt->value->floatval = f - 1;
9541: }
9542: }
9543:
9544: /**
9545: * xmlXPathCeilingFunction:
9546: * @ctxt: the XPath Parser context
9547: * @nargs: the number of arguments
9548: *
9549: * Implement the ceiling() XPath function
9550: * number ceiling(number)
9551: * The ceiling function returns the smallest (closest to negative infinity)
9552: * number that is not less than the argument and that is an integer.
9553: */
9554: void
9555: xmlXPathCeilingFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9556: double f;
9557:
9558: CHECK_ARITY(1);
9559: CAST_TO_NUMBER;
9560: CHECK_TYPE(XPATH_NUMBER);
9561:
9562: #if 0
9563: ctxt->value->floatval = ceil(ctxt->value->floatval);
9564: #else
9565: XTRUNC(f, ctxt->value->floatval);
9566: if (f != ctxt->value->floatval) {
9567: if (ctxt->value->floatval > 0)
9568: ctxt->value->floatval = f + 1;
9569: else {
9570: if (ctxt->value->floatval < 0 && f == 0)
9571: ctxt->value->floatval = xmlXPathNZERO;
9572: else
9573: ctxt->value->floatval = f;
9574: }
9575:
9576: }
9577: #endif
9578: }
9579:
9580: /**
9581: * xmlXPathRoundFunction:
9582: * @ctxt: the XPath Parser context
9583: * @nargs: the number of arguments
9584: *
9585: * Implement the round() XPath function
9586: * number round(number)
9587: * The round function returns the number that is closest to the
9588: * argument and that is an integer. If there are two such numbers,
9589: * then the one that is even is returned.
9590: */
9591: void
9592: xmlXPathRoundFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9593: double f;
9594:
9595: CHECK_ARITY(1);
9596: CAST_TO_NUMBER;
9597: CHECK_TYPE(XPATH_NUMBER);
9598:
9599: if ((xmlXPathIsNaN(ctxt->value->floatval)) ||
9600: (xmlXPathIsInf(ctxt->value->floatval) == 1) ||
9601: (xmlXPathIsInf(ctxt->value->floatval) == -1) ||
9602: (ctxt->value->floatval == 0.0))
9603: return;
9604:
9605: XTRUNC(f, ctxt->value->floatval);
9606: if (ctxt->value->floatval < 0) {
9607: if (ctxt->value->floatval < f - 0.5)
9608: ctxt->value->floatval = f - 1;
9609: else
9610: ctxt->value->floatval = f;
9611: if (ctxt->value->floatval == 0)
9612: ctxt->value->floatval = xmlXPathNZERO;
9613: } else {
9614: if (ctxt->value->floatval < f + 0.5)
9615: ctxt->value->floatval = f;
9616: else
9617: ctxt->value->floatval = f + 1;
9618: }
9619: }
9620:
9621: /************************************************************************
9622: * *
9623: * The Parser *
9624: * *
9625: ************************************************************************/
9626:
9627: /*
9628: * a few forward declarations since we use a recursive call based
9629: * implementation.
9630: */
9631: static void xmlXPathCompileExpr(xmlXPathParserContextPtr ctxt, int sort);
9632: static void xmlXPathCompPredicate(xmlXPathParserContextPtr ctxt, int filter);
9633: static void xmlXPathCompLocationPath(xmlXPathParserContextPtr ctxt);
9634: static void xmlXPathCompRelativeLocationPath(xmlXPathParserContextPtr ctxt);
9635: static xmlChar * xmlXPathParseNameComplex(xmlXPathParserContextPtr ctxt,
9636: int qualified);
9637:
9638: /**
9639: * xmlXPathCurrentChar:
9640: * @ctxt: the XPath parser context
9641: * @cur: pointer to the beginning of the char
9642: * @len: pointer to the length of the char read
9643: *
9644: * The current char value, if using UTF-8 this may actually span multiple
9645: * bytes in the input buffer.
9646: *
9647: * Returns the current char value and its length
9648: */
9649:
9650: static int
9651: xmlXPathCurrentChar(xmlXPathParserContextPtr ctxt, int *len) {
9652: unsigned char c;
9653: unsigned int val;
9654: const xmlChar *cur;
9655:
9656: if (ctxt == NULL)
9657: return(0);
9658: cur = ctxt->cur;
9659:
9660: /*
9661: * We are supposed to handle UTF8, check it's valid
9662: * From rfc2044: encoding of the Unicode values on UTF-8:
9663: *
9664: * UCS-4 range (hex.) UTF-8 octet sequence (binary)
9665: * 0000 0000-0000 007F 0xxxxxxx
9666: * 0000 0080-0000 07FF 110xxxxx 10xxxxxx
9667: * 0000 0800-0000 FFFF 1110xxxx 10xxxxxx 10xxxxxx
9668: *
9669: * Check for the 0x110000 limit too
9670: */
9671: c = *cur;
9672: if (c & 0x80) {
9673: if ((cur[1] & 0xc0) != 0x80)
9674: goto encoding_error;
9675: if ((c & 0xe0) == 0xe0) {
9676:
9677: if ((cur[2] & 0xc0) != 0x80)
9678: goto encoding_error;
9679: if ((c & 0xf0) == 0xf0) {
9680: if (((c & 0xf8) != 0xf0) ||
9681: ((cur[3] & 0xc0) != 0x80))
9682: goto encoding_error;
9683: /* 4-byte code */
9684: *len = 4;
9685: val = (cur[0] & 0x7) << 18;
9686: val |= (cur[1] & 0x3f) << 12;
9687: val |= (cur[2] & 0x3f) << 6;
9688: val |= cur[3] & 0x3f;
9689: } else {
9690: /* 3-byte code */
9691: *len = 3;
9692: val = (cur[0] & 0xf) << 12;
9693: val |= (cur[1] & 0x3f) << 6;
9694: val |= cur[2] & 0x3f;
9695: }
9696: } else {
9697: /* 2-byte code */
9698: *len = 2;
9699: val = (cur[0] & 0x1f) << 6;
9700: val |= cur[1] & 0x3f;
9701: }
9702: if (!IS_CHAR(val)) {
9703: XP_ERROR0(XPATH_INVALID_CHAR_ERROR);
9704: }
9705: return(val);
9706: } else {
9707: /* 1-byte code */
9708: *len = 1;
9709: return((int) *cur);
9710: }
9711: encoding_error:
9712: /*
9713: * If we detect an UTF8 error that probably means that the
9714: * input encoding didn't get properly advertised in the
9715: * declaration header. Report the error and switch the encoding
9716: * to ISO-Latin-1 (if you don't like this policy, just declare the
9717: * encoding !)
9718: */
9719: *len = 0;
9720: XP_ERROR0(XPATH_ENCODING_ERROR);
9721: }
9722:
9723: /**
9724: * xmlXPathParseNCName:
9725: * @ctxt: the XPath Parser context
9726: *
9727: * parse an XML namespace non qualified name.
9728: *
9729: * [NS 3] NCName ::= (Letter | '_') (NCNameChar)*
9730: *
9731: * [NS 4] NCNameChar ::= Letter | Digit | '.' | '-' | '_' |
9732: * CombiningChar | Extender
9733: *
9734: * Returns the namespace name or NULL
9735: */
9736:
9737: xmlChar *
9738: xmlXPathParseNCName(xmlXPathParserContextPtr ctxt) {
9739: const xmlChar *in;
9740: xmlChar *ret;
9741: int count = 0;
9742:
9743: if ((ctxt == NULL) || (ctxt->cur == NULL)) return(NULL);
9744: /*
9745: * Accelerator for simple ASCII names
9746: */
9747: in = ctxt->cur;
9748: if (((*in >= 0x61) && (*in <= 0x7A)) ||
9749: ((*in >= 0x41) && (*in <= 0x5A)) ||
9750: (*in == '_')) {
9751: in++;
9752: while (((*in >= 0x61) && (*in <= 0x7A)) ||
9753: ((*in >= 0x41) && (*in <= 0x5A)) ||
9754: ((*in >= 0x30) && (*in <= 0x39)) ||
9755: (*in == '_') || (*in == '.') ||
9756: (*in == '-'))
9757: in++;
9758: if ((*in == ' ') || (*in == '>') || (*in == '/') ||
9759: (*in == '[') || (*in == ']') || (*in == ':') ||
9760: (*in == '@') || (*in == '*')) {
9761: count = in - ctxt->cur;
9762: if (count == 0)
9763: return(NULL);
9764: ret = xmlStrndup(ctxt->cur, count);
9765: ctxt->cur = in;
9766: return(ret);
9767: }
9768: }
9769: return(xmlXPathParseNameComplex(ctxt, 0));
9770: }
9771:
9772:
9773: /**
9774: * xmlXPathParseQName:
9775: * @ctxt: the XPath Parser context
9776: * @prefix: a xmlChar **
9777: *
9778: * parse an XML qualified name
9779: *
9780: * [NS 5] QName ::= (Prefix ':')? LocalPart
9781: *
9782: * [NS 6] Prefix ::= NCName
9783: *
9784: * [NS 7] LocalPart ::= NCName
9785: *
9786: * Returns the function returns the local part, and prefix is updated
9787: * to get the Prefix if any.
9788: */
9789:
9790: static xmlChar *
9791: xmlXPathParseQName(xmlXPathParserContextPtr ctxt, xmlChar **prefix) {
9792: xmlChar *ret = NULL;
9793:
9794: *prefix = NULL;
9795: ret = xmlXPathParseNCName(ctxt);
9796: if (ret && CUR == ':') {
9797: *prefix = ret;
9798: NEXT;
9799: ret = xmlXPathParseNCName(ctxt);
9800: }
9801: return(ret);
9802: }
9803:
9804: /**
9805: * xmlXPathParseName:
9806: * @ctxt: the XPath Parser context
9807: *
9808: * parse an XML name
9809: *
9810: * [4] NameChar ::= Letter | Digit | '.' | '-' | '_' | ':' |
9811: * CombiningChar | Extender
9812: *
9813: * [5] Name ::= (Letter | '_' | ':') (NameChar)*
9814: *
9815: * Returns the namespace name or NULL
9816: */
9817:
9818: xmlChar *
9819: xmlXPathParseName(xmlXPathParserContextPtr ctxt) {
9820: const xmlChar *in;
9821: xmlChar *ret;
9822: int count = 0;
9823:
9824: if ((ctxt == NULL) || (ctxt->cur == NULL)) return(NULL);
9825: /*
9826: * Accelerator for simple ASCII names
9827: */
9828: in = ctxt->cur;
9829: if (((*in >= 0x61) && (*in <= 0x7A)) ||
9830: ((*in >= 0x41) && (*in <= 0x5A)) ||
9831: (*in == '_') || (*in == ':')) {
9832: in++;
9833: while (((*in >= 0x61) && (*in <= 0x7A)) ||
9834: ((*in >= 0x41) && (*in <= 0x5A)) ||
9835: ((*in >= 0x30) && (*in <= 0x39)) ||
9836: (*in == '_') || (*in == '-') ||
9837: (*in == ':') || (*in == '.'))
9838: in++;
9839: if ((*in > 0) && (*in < 0x80)) {
9840: count = in - ctxt->cur;
9841: ret = xmlStrndup(ctxt->cur, count);
9842: ctxt->cur = in;
9843: return(ret);
9844: }
9845: }
9846: return(xmlXPathParseNameComplex(ctxt, 1));
9847: }
9848:
9849: static xmlChar *
9850: xmlXPathParseNameComplex(xmlXPathParserContextPtr ctxt, int qualified) {
9851: xmlChar buf[XML_MAX_NAMELEN + 5];
9852: int len = 0, l;
9853: int c;
9854:
9855: /*
9856: * Handler for more complex cases
9857: */
9858: c = CUR_CHAR(l);
9859: if ((c == ' ') || (c == '>') || (c == '/') || /* accelerators */
9860: (c == '[') || (c == ']') || (c == '@') || /* accelerators */
9861: (c == '*') || /* accelerators */
9862: (!IS_LETTER(c) && (c != '_') &&
9863: ((qualified) && (c != ':')))) {
9864: return(NULL);
9865: }
9866:
9867: while ((c != ' ') && (c != '>') && (c != '/') && /* test bigname.xml */
9868: ((IS_LETTER(c)) || (IS_DIGIT(c)) ||
9869: (c == '.') || (c == '-') ||
9870: (c == '_') || ((qualified) && (c == ':')) ||
9871: (IS_COMBINING(c)) ||
9872: (IS_EXTENDER(c)))) {
9873: COPY_BUF(l,buf,len,c);
9874: NEXTL(l);
9875: c = CUR_CHAR(l);
9876: if (len >= XML_MAX_NAMELEN) {
9877: /*
9878: * Okay someone managed to make a huge name, so he's ready to pay
9879: * for the processing speed.
9880: */
9881: xmlChar *buffer;
9882: int max = len * 2;
9883:
9884: buffer = (xmlChar *) xmlMallocAtomic(max * sizeof(xmlChar));
9885: if (buffer == NULL) {
9886: XP_ERRORNULL(XPATH_MEMORY_ERROR);
9887: }
9888: memcpy(buffer, buf, len);
9889: while ((IS_LETTER(c)) || (IS_DIGIT(c)) || /* test bigname.xml */
9890: (c == '.') || (c == '-') ||
9891: (c == '_') || ((qualified) && (c == ':')) ||
9892: (IS_COMBINING(c)) ||
9893: (IS_EXTENDER(c))) {
9894: if (len + 10 > max) {
9895: max *= 2;
9896: buffer = (xmlChar *) xmlRealloc(buffer,
9897: max * sizeof(xmlChar));
9898: if (buffer == NULL) {
9899: XP_ERRORNULL(XPATH_MEMORY_ERROR);
9900: }
9901: }
9902: COPY_BUF(l,buffer,len,c);
9903: NEXTL(l);
9904: c = CUR_CHAR(l);
9905: }
9906: buffer[len] = 0;
9907: return(buffer);
9908: }
9909: }
9910: if (len == 0)
9911: return(NULL);
9912: return(xmlStrndup(buf, len));
9913: }
9914:
9915: #define MAX_FRAC 20
9916:
9917: /*
9918: * These are used as divisors for the fractional part of a number.
9919: * Since the table includes 1.0 (representing '0' fractional digits),
9920: * it must be dimensioned at MAX_FRAC+1 (bug 133921)
9921: */
9922: static double my_pow10[MAX_FRAC+1] = {
9923: 1.0, 10.0, 100.0, 1000.0, 10000.0,
9924: 100000.0, 1000000.0, 10000000.0, 100000000.0, 1000000000.0,
9925: 10000000000.0, 100000000000.0, 1000000000000.0, 10000000000000.0,
9926: 100000000000000.0,
9927: 1000000000000000.0, 10000000000000000.0, 100000000000000000.0,
9928: 1000000000000000000.0, 10000000000000000000.0, 100000000000000000000.0
9929: };
9930:
9931: /**
9932: * xmlXPathStringEvalNumber:
9933: * @str: A string to scan
9934: *
9935: * [30a] Float ::= Number ('e' Digits?)?
9936: *
9937: * [30] Number ::= Digits ('.' Digits?)?
9938: * | '.' Digits
9939: * [31] Digits ::= [0-9]+
9940: *
9941: * Compile a Number in the string
9942: * In complement of the Number expression, this function also handles
9943: * negative values : '-' Number.
9944: *
9945: * Returns the double value.
9946: */
9947: double
9948: xmlXPathStringEvalNumber(const xmlChar *str) {
9949: const xmlChar *cur = str;
9950: double ret;
9951: int ok = 0;
9952: int isneg = 0;
9953: int exponent = 0;
9954: int is_exponent_negative = 0;
9955: #ifdef __GNUC__
9956: unsigned long tmp = 0;
9957: double temp;
9958: #endif
9959: if (cur == NULL) return(0);
9960: while (IS_BLANK_CH(*cur)) cur++;
9961: if ((*cur != '.') && ((*cur < '0') || (*cur > '9')) && (*cur != '-')) {
9962: return(xmlXPathNAN);
9963: }
9964: if (*cur == '-') {
9965: isneg = 1;
9966: cur++;
9967: }
9968:
9969: #ifdef __GNUC__
9970: /*
9971: * tmp/temp is a workaround against a gcc compiler bug
9972: * http://veillard.com/gcc.bug
9973: */
9974: ret = 0;
9975: while ((*cur >= '0') && (*cur <= '9')) {
9976: ret = ret * 10;
9977: tmp = (*cur - '0');
9978: ok = 1;
9979: cur++;
9980: temp = (double) tmp;
9981: ret = ret + temp;
9982: }
9983: #else
9984: ret = 0;
9985: while ((*cur >= '0') && (*cur <= '9')) {
9986: ret = ret * 10 + (*cur - '0');
9987: ok = 1;
9988: cur++;
9989: }
9990: #endif
9991:
9992: if (*cur == '.') {
9993: int v, frac = 0;
9994: double fraction = 0;
9995:
9996: cur++;
9997: if (((*cur < '0') || (*cur > '9')) && (!ok)) {
9998: return(xmlXPathNAN);
9999: }
10000: while (((*cur >= '0') && (*cur <= '9')) && (frac < MAX_FRAC)) {
10001: v = (*cur - '0');
10002: fraction = fraction * 10 + v;
10003: frac = frac + 1;
10004: cur++;
10005: }
10006: fraction /= my_pow10[frac];
10007: ret = ret + fraction;
10008: while ((*cur >= '0') && (*cur <= '9'))
10009: cur++;
10010: }
10011: if ((*cur == 'e') || (*cur == 'E')) {
10012: cur++;
10013: if (*cur == '-') {
10014: is_exponent_negative = 1;
10015: cur++;
10016: } else if (*cur == '+') {
10017: cur++;
10018: }
10019: while ((*cur >= '0') && (*cur <= '9')) {
10020: exponent = exponent * 10 + (*cur - '0');
10021: cur++;
10022: }
10023: }
10024: while (IS_BLANK_CH(*cur)) cur++;
10025: if (*cur != 0) return(xmlXPathNAN);
10026: if (isneg) ret = -ret;
10027: if (is_exponent_negative) exponent = -exponent;
10028: ret *= pow(10.0, (double)exponent);
10029: return(ret);
10030: }
10031:
10032: /**
10033: * xmlXPathCompNumber:
10034: * @ctxt: the XPath Parser context
10035: *
10036: * [30] Number ::= Digits ('.' Digits?)?
10037: * | '.' Digits
10038: * [31] Digits ::= [0-9]+
10039: *
10040: * Compile a Number, then push it on the stack
10041: *
10042: */
10043: static void
10044: xmlXPathCompNumber(xmlXPathParserContextPtr ctxt)
10045: {
10046: double ret = 0.0;
10047: double mult = 1;
10048: int ok = 0;
10049: int exponent = 0;
10050: int is_exponent_negative = 0;
10051: #ifdef __GNUC__
10052: unsigned long tmp = 0;
10053: double temp;
10054: #endif
10055:
10056: CHECK_ERROR;
10057: if ((CUR != '.') && ((CUR < '0') || (CUR > '9'))) {
10058: XP_ERROR(XPATH_NUMBER_ERROR);
10059: }
10060: #ifdef __GNUC__
10061: /*
10062: * tmp/temp is a workaround against a gcc compiler bug
10063: * http://veillard.com/gcc.bug
10064: */
10065: ret = 0;
10066: while ((CUR >= '0') && (CUR <= '9')) {
10067: ret = ret * 10;
10068: tmp = (CUR - '0');
10069: ok = 1;
10070: NEXT;
10071: temp = (double) tmp;
10072: ret = ret + temp;
10073: }
10074: #else
10075: ret = 0;
10076: while ((CUR >= '0') && (CUR <= '9')) {
10077: ret = ret * 10 + (CUR - '0');
10078: ok = 1;
10079: NEXT;
10080: }
10081: #endif
10082: if (CUR == '.') {
10083: int v, frac = 0;
10084: double fraction = 0;
10085:
10086: NEXT;
10087: if (((CUR < '0') || (CUR > '9')) && (!ok)) {
10088: XP_ERROR(XPATH_NUMBER_ERROR);
10089: }
10090: while ((CUR >= '0') && (CUR <= '9') && (frac < MAX_FRAC)) {
10091: v = (CUR - '0');
10092: fraction = fraction * 10 + v;
10093: frac = frac + 1;
10094: NEXT;
10095: }
10096: fraction /= my_pow10[frac];
10097: ret = ret + fraction;
10098: while ((CUR >= '0') && (CUR <= '9'))
10099: NEXT;
10100: }
10101: if ((CUR == 'e') || (CUR == 'E')) {
10102: NEXT;
10103: if (CUR == '-') {
10104: is_exponent_negative = 1;
10105: NEXT;
10106: } else if (CUR == '+') {
10107: NEXT;
10108: }
10109: while ((CUR >= '0') && (CUR <= '9')) {
10110: exponent = exponent * 10 + (CUR - '0');
10111: NEXT;
10112: }
10113: if (is_exponent_negative)
10114: exponent = -exponent;
10115: ret *= pow(10.0, (double) exponent);
10116: }
10117: PUSH_LONG_EXPR(XPATH_OP_VALUE, XPATH_NUMBER, 0, 0,
10118: xmlXPathCacheNewFloat(ctxt->context, ret), NULL);
10119: }
10120:
10121: /**
10122: * xmlXPathParseLiteral:
10123: * @ctxt: the XPath Parser context
10124: *
10125: * Parse a Literal
10126: *
10127: * [29] Literal ::= '"' [^"]* '"'
10128: * | "'" [^']* "'"
10129: *
10130: * Returns the value found or NULL in case of error
10131: */
10132: static xmlChar *
10133: xmlXPathParseLiteral(xmlXPathParserContextPtr ctxt) {
10134: const xmlChar *q;
10135: xmlChar *ret = NULL;
10136:
10137: if (CUR == '"') {
10138: NEXT;
10139: q = CUR_PTR;
10140: while ((IS_CHAR_CH(CUR)) && (CUR != '"'))
10141: NEXT;
10142: if (!IS_CHAR_CH(CUR)) {
10143: XP_ERRORNULL(XPATH_UNFINISHED_LITERAL_ERROR);
10144: } else {
10145: ret = xmlStrndup(q, CUR_PTR - q);
10146: NEXT;
10147: }
10148: } else if (CUR == '\'') {
10149: NEXT;
10150: q = CUR_PTR;
10151: while ((IS_CHAR_CH(CUR)) && (CUR != '\''))
10152: NEXT;
10153: if (!IS_CHAR_CH(CUR)) {
10154: XP_ERRORNULL(XPATH_UNFINISHED_LITERAL_ERROR);
10155: } else {
10156: ret = xmlStrndup(q, CUR_PTR - q);
10157: NEXT;
10158: }
10159: } else {
10160: XP_ERRORNULL(XPATH_START_LITERAL_ERROR);
10161: }
10162: return(ret);
10163: }
10164:
10165: /**
10166: * xmlXPathCompLiteral:
10167: * @ctxt: the XPath Parser context
10168: *
10169: * Parse a Literal and push it on the stack.
10170: *
10171: * [29] Literal ::= '"' [^"]* '"'
10172: * | "'" [^']* "'"
10173: *
10174: * TODO: xmlXPathCompLiteral memory allocation could be improved.
10175: */
10176: static void
10177: xmlXPathCompLiteral(xmlXPathParserContextPtr ctxt) {
10178: const xmlChar *q;
10179: xmlChar *ret = NULL;
10180:
10181: if (CUR == '"') {
10182: NEXT;
10183: q = CUR_PTR;
10184: while ((IS_CHAR_CH(CUR)) && (CUR != '"'))
10185: NEXT;
10186: if (!IS_CHAR_CH(CUR)) {
10187: XP_ERROR(XPATH_UNFINISHED_LITERAL_ERROR);
10188: } else {
10189: ret = xmlStrndup(q, CUR_PTR - q);
10190: NEXT;
10191: }
10192: } else if (CUR == '\'') {
10193: NEXT;
10194: q = CUR_PTR;
10195: while ((IS_CHAR_CH(CUR)) && (CUR != '\''))
10196: NEXT;
10197: if (!IS_CHAR_CH(CUR)) {
10198: XP_ERROR(XPATH_UNFINISHED_LITERAL_ERROR);
10199: } else {
10200: ret = xmlStrndup(q, CUR_PTR - q);
10201: NEXT;
10202: }
10203: } else {
10204: XP_ERROR(XPATH_START_LITERAL_ERROR);
10205: }
10206: if (ret == NULL) return;
10207: PUSH_LONG_EXPR(XPATH_OP_VALUE, XPATH_STRING, 0, 0,
10208: xmlXPathCacheNewString(ctxt->context, ret), NULL);
10209: xmlFree(ret);
10210: }
10211:
10212: /**
10213: * xmlXPathCompVariableReference:
10214: * @ctxt: the XPath Parser context
10215: *
10216: * Parse a VariableReference, evaluate it and push it on the stack.
10217: *
10218: * The variable bindings consist of a mapping from variable names
10219: * to variable values. The value of a variable is an object, which can be
10220: * of any of the types that are possible for the value of an expression,
10221: * and may also be of additional types not specified here.
10222: *
10223: * Early evaluation is possible since:
10224: * The variable bindings [...] used to evaluate a subexpression are
10225: * always the same as those used to evaluate the containing expression.
10226: *
10227: * [36] VariableReference ::= '$' QName
10228: */
10229: static void
10230: xmlXPathCompVariableReference(xmlXPathParserContextPtr ctxt) {
10231: xmlChar *name;
10232: xmlChar *prefix;
10233:
10234: SKIP_BLANKS;
10235: if (CUR != '$') {
10236: XP_ERROR(XPATH_VARIABLE_REF_ERROR);
10237: }
10238: NEXT;
10239: name = xmlXPathParseQName(ctxt, &prefix);
10240: if (name == NULL) {
10241: XP_ERROR(XPATH_VARIABLE_REF_ERROR);
10242: }
10243: ctxt->comp->last = -1;
10244: PUSH_LONG_EXPR(XPATH_OP_VARIABLE, 0, 0, 0,
10245: name, prefix);
10246: SKIP_BLANKS;
10247: if ((ctxt->context != NULL) && (ctxt->context->flags & XML_XPATH_NOVAR)) {
10248: XP_ERROR(XPATH_UNDEF_VARIABLE_ERROR);
10249: }
10250: }
10251:
10252: /**
10253: * xmlXPathIsNodeType:
10254: * @name: a name string
10255: *
10256: * Is the name given a NodeType one.
10257: *
10258: * [38] NodeType ::= 'comment'
10259: * | 'text'
10260: * | 'processing-instruction'
10261: * | 'node'
10262: *
10263: * Returns 1 if true 0 otherwise
10264: */
10265: int
10266: xmlXPathIsNodeType(const xmlChar *name) {
10267: if (name == NULL)
10268: return(0);
10269:
10270: if (xmlStrEqual(name, BAD_CAST "node"))
10271: return(1);
10272: if (xmlStrEqual(name, BAD_CAST "text"))
10273: return(1);
10274: if (xmlStrEqual(name, BAD_CAST "comment"))
10275: return(1);
10276: if (xmlStrEqual(name, BAD_CAST "processing-instruction"))
10277: return(1);
10278: return(0);
10279: }
10280:
10281: /**
10282: * xmlXPathCompFunctionCall:
10283: * @ctxt: the XPath Parser context
10284: *
10285: * [16] FunctionCall ::= FunctionName '(' ( Argument ( ',' Argument)*)? ')'
10286: * [17] Argument ::= Expr
10287: *
10288: * Compile a function call, the evaluation of all arguments are
10289: * pushed on the stack
10290: */
10291: static void
10292: xmlXPathCompFunctionCall(xmlXPathParserContextPtr ctxt) {
10293: xmlChar *name;
10294: xmlChar *prefix;
10295: int nbargs = 0;
10296: int sort = 1;
10297:
10298: name = xmlXPathParseQName(ctxt, &prefix);
10299: if (name == NULL) {
10300: xmlFree(prefix);
10301: XP_ERROR(XPATH_EXPR_ERROR);
10302: }
10303: SKIP_BLANKS;
10304: #ifdef DEBUG_EXPR
10305: if (prefix == NULL)
10306: xmlGenericError(xmlGenericErrorContext, "Calling function %s\n",
10307: name);
10308: else
10309: xmlGenericError(xmlGenericErrorContext, "Calling function %s:%s\n",
10310: prefix, name);
10311: #endif
10312:
10313: if (CUR != '(') {
10314: XP_ERROR(XPATH_EXPR_ERROR);
10315: }
10316: NEXT;
10317: SKIP_BLANKS;
10318:
10319: /*
10320: * Optimization for count(): we don't need the node-set to be sorted.
10321: */
10322: if ((prefix == NULL) && (name[0] == 'c') &&
10323: xmlStrEqual(name, BAD_CAST "count"))
10324: {
10325: sort = 0;
10326: }
10327: ctxt->comp->last = -1;
10328: if (CUR != ')') {
10329: while (CUR != 0) {
10330: int op1 = ctxt->comp->last;
10331: ctxt->comp->last = -1;
10332: xmlXPathCompileExpr(ctxt, sort);
10333: if (ctxt->error != XPATH_EXPRESSION_OK) {
10334: xmlFree(name);
10335: xmlFree(prefix);
10336: return;
10337: }
10338: PUSH_BINARY_EXPR(XPATH_OP_ARG, op1, ctxt->comp->last, 0, 0);
10339: nbargs++;
10340: if (CUR == ')') break;
10341: if (CUR != ',') {
10342: XP_ERROR(XPATH_EXPR_ERROR);
10343: }
10344: NEXT;
10345: SKIP_BLANKS;
10346: }
10347: }
10348: PUSH_LONG_EXPR(XPATH_OP_FUNCTION, nbargs, 0, 0,
10349: name, prefix);
10350: NEXT;
10351: SKIP_BLANKS;
10352: }
10353:
10354: /**
10355: * xmlXPathCompPrimaryExpr:
10356: * @ctxt: the XPath Parser context
10357: *
10358: * [15] PrimaryExpr ::= VariableReference
10359: * | '(' Expr ')'
10360: * | Literal
10361: * | Number
10362: * | FunctionCall
10363: *
10364: * Compile a primary expression.
10365: */
10366: static void
10367: xmlXPathCompPrimaryExpr(xmlXPathParserContextPtr ctxt) {
10368: SKIP_BLANKS;
10369: if (CUR == '$') xmlXPathCompVariableReference(ctxt);
10370: else if (CUR == '(') {
10371: NEXT;
10372: SKIP_BLANKS;
10373: xmlXPathCompileExpr(ctxt, 1);
10374: CHECK_ERROR;
10375: if (CUR != ')') {
10376: XP_ERROR(XPATH_EXPR_ERROR);
10377: }
10378: NEXT;
10379: SKIP_BLANKS;
10380: } else if (IS_ASCII_DIGIT(CUR) || (CUR == '.' && IS_ASCII_DIGIT(NXT(1)))) {
10381: xmlXPathCompNumber(ctxt);
10382: } else if ((CUR == '\'') || (CUR == '"')) {
10383: xmlXPathCompLiteral(ctxt);
10384: } else {
10385: xmlXPathCompFunctionCall(ctxt);
10386: }
10387: SKIP_BLANKS;
10388: }
10389:
10390: /**
10391: * xmlXPathCompFilterExpr:
10392: * @ctxt: the XPath Parser context
10393: *
10394: * [20] FilterExpr ::= PrimaryExpr
10395: * | FilterExpr Predicate
10396: *
10397: * Compile a filter expression.
10398: * Square brackets are used to filter expressions in the same way that
10399: * they are used in location paths. It is an error if the expression to
10400: * be filtered does not evaluate to a node-set. The context node list
10401: * used for evaluating the expression in square brackets is the node-set
10402: * to be filtered listed in document order.
10403: */
10404:
10405: static void
10406: xmlXPathCompFilterExpr(xmlXPathParserContextPtr ctxt) {
10407: xmlXPathCompPrimaryExpr(ctxt);
10408: CHECK_ERROR;
10409: SKIP_BLANKS;
10410:
10411: while (CUR == '[') {
10412: xmlXPathCompPredicate(ctxt, 1);
10413: SKIP_BLANKS;
10414: }
10415:
10416:
10417: }
10418:
10419: /**
10420: * xmlXPathScanName:
10421: * @ctxt: the XPath Parser context
10422: *
10423: * Trickery: parse an XML name but without consuming the input flow
10424: * Needed to avoid insanity in the parser state.
10425: *
10426: * [4] NameChar ::= Letter | Digit | '.' | '-' | '_' | ':' |
10427: * CombiningChar | Extender
10428: *
10429: * [5] Name ::= (Letter | '_' | ':') (NameChar)*
10430: *
10431: * [6] Names ::= Name (S Name)*
10432: *
10433: * Returns the Name parsed or NULL
10434: */
10435:
10436: static xmlChar *
10437: xmlXPathScanName(xmlXPathParserContextPtr ctxt) {
10438: int len = 0, l;
10439: int c;
10440: const xmlChar *cur;
10441: xmlChar *ret;
10442:
10443: cur = ctxt->cur;
10444:
10445: c = CUR_CHAR(l);
10446: if ((c == ' ') || (c == '>') || (c == '/') || /* accelerators */
10447: (!IS_LETTER(c) && (c != '_') &&
10448: (c != ':'))) {
10449: return(NULL);
10450: }
10451:
10452: while ((c != ' ') && (c != '>') && (c != '/') && /* test bigname.xml */
10453: ((IS_LETTER(c)) || (IS_DIGIT(c)) ||
10454: (c == '.') || (c == '-') ||
10455: (c == '_') || (c == ':') ||
10456: (IS_COMBINING(c)) ||
10457: (IS_EXTENDER(c)))) {
10458: len += l;
10459: NEXTL(l);
10460: c = CUR_CHAR(l);
10461: }
10462: ret = xmlStrndup(cur, ctxt->cur - cur);
10463: ctxt->cur = cur;
10464: return(ret);
10465: }
10466:
10467: /**
10468: * xmlXPathCompPathExpr:
10469: * @ctxt: the XPath Parser context
10470: *
10471: * [19] PathExpr ::= LocationPath
10472: * | FilterExpr
10473: * | FilterExpr '/' RelativeLocationPath
10474: * | FilterExpr '//' RelativeLocationPath
10475: *
10476: * Compile a path expression.
10477: * The / operator and // operators combine an arbitrary expression
10478: * and a relative location path. It is an error if the expression
10479: * does not evaluate to a node-set.
10480: * The / operator does composition in the same way as when / is
10481: * used in a location path. As in location paths, // is short for
10482: * /descendant-or-self::node()/.
10483: */
10484:
10485: static void
10486: xmlXPathCompPathExpr(xmlXPathParserContextPtr ctxt) {
10487: int lc = 1; /* Should we branch to LocationPath ? */
10488: xmlChar *name = NULL; /* we may have to preparse a name to find out */
10489:
10490: SKIP_BLANKS;
10491: if ((CUR == '$') || (CUR == '(') ||
10492: (IS_ASCII_DIGIT(CUR)) ||
10493: (CUR == '\'') || (CUR == '"') ||
10494: (CUR == '.' && IS_ASCII_DIGIT(NXT(1)))) {
10495: lc = 0;
10496: } else if (CUR == '*') {
10497: /* relative or absolute location path */
10498: lc = 1;
10499: } else if (CUR == '/') {
10500: /* relative or absolute location path */
10501: lc = 1;
10502: } else if (CUR == '@') {
10503: /* relative abbreviated attribute location path */
10504: lc = 1;
10505: } else if (CUR == '.') {
10506: /* relative abbreviated attribute location path */
10507: lc = 1;
10508: } else {
10509: /*
10510: * Problem is finding if we have a name here whether it's:
10511: * - a nodetype
10512: * - a function call in which case it's followed by '('
10513: * - an axis in which case it's followed by ':'
10514: * - a element name
10515: * We do an a priori analysis here rather than having to
10516: * maintain parsed token content through the recursive function
10517: * calls. This looks uglier but makes the code easier to
10518: * read/write/debug.
10519: */
10520: SKIP_BLANKS;
10521: name = xmlXPathScanName(ctxt);
10522: if ((name != NULL) && (xmlStrstr(name, (xmlChar *) "::") != NULL)) {
10523: #ifdef DEBUG_STEP
10524: xmlGenericError(xmlGenericErrorContext,
10525: "PathExpr: Axis\n");
10526: #endif
10527: lc = 1;
10528: xmlFree(name);
10529: } else if (name != NULL) {
10530: int len =xmlStrlen(name);
10531:
10532:
10533: while (NXT(len) != 0) {
10534: if (NXT(len) == '/') {
10535: /* element name */
10536: #ifdef DEBUG_STEP
10537: xmlGenericError(xmlGenericErrorContext,
10538: "PathExpr: AbbrRelLocation\n");
10539: #endif
10540: lc = 1;
10541: break;
10542: } else if (IS_BLANK_CH(NXT(len))) {
10543: /* ignore blanks */
10544: ;
10545: } else if (NXT(len) == ':') {
10546: #ifdef DEBUG_STEP
10547: xmlGenericError(xmlGenericErrorContext,
10548: "PathExpr: AbbrRelLocation\n");
10549: #endif
10550: lc = 1;
10551: break;
10552: } else if ((NXT(len) == '(')) {
10553: /* Note Type or Function */
10554: if (xmlXPathIsNodeType(name)) {
10555: #ifdef DEBUG_STEP
10556: xmlGenericError(xmlGenericErrorContext,
10557: "PathExpr: Type search\n");
10558: #endif
10559: lc = 1;
10560: } else {
10561: #ifdef DEBUG_STEP
10562: xmlGenericError(xmlGenericErrorContext,
10563: "PathExpr: function call\n");
10564: #endif
10565: lc = 0;
10566: }
10567: break;
10568: } else if ((NXT(len) == '[')) {
10569: /* element name */
10570: #ifdef DEBUG_STEP
10571: xmlGenericError(xmlGenericErrorContext,
10572: "PathExpr: AbbrRelLocation\n");
10573: #endif
10574: lc = 1;
10575: break;
10576: } else if ((NXT(len) == '<') || (NXT(len) == '>') ||
10577: (NXT(len) == '=')) {
10578: lc = 1;
10579: break;
10580: } else {
10581: lc = 1;
10582: break;
10583: }
10584: len++;
10585: }
10586: if (NXT(len) == 0) {
10587: #ifdef DEBUG_STEP
10588: xmlGenericError(xmlGenericErrorContext,
10589: "PathExpr: AbbrRelLocation\n");
10590: #endif
10591: /* element name */
10592: lc = 1;
10593: }
10594: xmlFree(name);
10595: } else {
10596: /* make sure all cases are covered explicitly */
10597: XP_ERROR(XPATH_EXPR_ERROR);
10598: }
10599: }
10600:
10601: if (lc) {
10602: if (CUR == '/') {
10603: PUSH_LEAVE_EXPR(XPATH_OP_ROOT, 0, 0);
10604: } else {
10605: PUSH_LEAVE_EXPR(XPATH_OP_NODE, 0, 0);
10606: }
10607: xmlXPathCompLocationPath(ctxt);
10608: } else {
10609: xmlXPathCompFilterExpr(ctxt);
10610: CHECK_ERROR;
10611: if ((CUR == '/') && (NXT(1) == '/')) {
10612: SKIP(2);
10613: SKIP_BLANKS;
10614:
10615: PUSH_LONG_EXPR(XPATH_OP_COLLECT, AXIS_DESCENDANT_OR_SELF,
10616: NODE_TEST_TYPE, NODE_TYPE_NODE, NULL, NULL);
10617: PUSH_UNARY_EXPR(XPATH_OP_RESET, ctxt->comp->last, 1, 0);
10618:
10619: xmlXPathCompRelativeLocationPath(ctxt);
10620: } else if (CUR == '/') {
10621: xmlXPathCompRelativeLocationPath(ctxt);
10622: }
10623: }
10624: SKIP_BLANKS;
10625: }
10626:
10627: /**
10628: * xmlXPathCompUnionExpr:
10629: * @ctxt: the XPath Parser context
10630: *
10631: * [18] UnionExpr ::= PathExpr
10632: * | UnionExpr '|' PathExpr
10633: *
10634: * Compile an union expression.
10635: */
10636:
10637: static void
10638: xmlXPathCompUnionExpr(xmlXPathParserContextPtr ctxt) {
10639: xmlXPathCompPathExpr(ctxt);
10640: CHECK_ERROR;
10641: SKIP_BLANKS;
10642: while (CUR == '|') {
10643: int op1 = ctxt->comp->last;
10644: PUSH_LEAVE_EXPR(XPATH_OP_NODE, 0, 0);
10645:
10646: NEXT;
10647: SKIP_BLANKS;
10648: xmlXPathCompPathExpr(ctxt);
10649:
10650: PUSH_BINARY_EXPR(XPATH_OP_UNION, op1, ctxt->comp->last, 0, 0);
10651:
10652: SKIP_BLANKS;
10653: }
10654: }
10655:
10656: /**
10657: * xmlXPathCompUnaryExpr:
10658: * @ctxt: the XPath Parser context
10659: *
10660: * [27] UnaryExpr ::= UnionExpr
10661: * | '-' UnaryExpr
10662: *
10663: * Compile an unary expression.
10664: */
10665:
10666: static void
10667: xmlXPathCompUnaryExpr(xmlXPathParserContextPtr ctxt) {
10668: int minus = 0;
10669: int found = 0;
10670:
10671: SKIP_BLANKS;
10672: while (CUR == '-') {
10673: minus = 1 - minus;
10674: found = 1;
10675: NEXT;
10676: SKIP_BLANKS;
10677: }
10678:
10679: xmlXPathCompUnionExpr(ctxt);
10680: CHECK_ERROR;
10681: if (found) {
10682: if (minus)
10683: PUSH_UNARY_EXPR(XPATH_OP_PLUS, ctxt->comp->last, 2, 0);
10684: else
10685: PUSH_UNARY_EXPR(XPATH_OP_PLUS, ctxt->comp->last, 3, 0);
10686: }
10687: }
10688:
10689: /**
10690: * xmlXPathCompMultiplicativeExpr:
10691: * @ctxt: the XPath Parser context
10692: *
10693: * [26] MultiplicativeExpr ::= UnaryExpr
10694: * | MultiplicativeExpr MultiplyOperator UnaryExpr
10695: * | MultiplicativeExpr 'div' UnaryExpr
10696: * | MultiplicativeExpr 'mod' UnaryExpr
10697: * [34] MultiplyOperator ::= '*'
10698: *
10699: * Compile an Additive expression.
10700: */
10701:
10702: static void
10703: xmlXPathCompMultiplicativeExpr(xmlXPathParserContextPtr ctxt) {
10704: xmlXPathCompUnaryExpr(ctxt);
10705: CHECK_ERROR;
10706: SKIP_BLANKS;
10707: while ((CUR == '*') ||
10708: ((CUR == 'd') && (NXT(1) == 'i') && (NXT(2) == 'v')) ||
10709: ((CUR == 'm') && (NXT(1) == 'o') && (NXT(2) == 'd'))) {
10710: int op = -1;
10711: int op1 = ctxt->comp->last;
10712:
10713: if (CUR == '*') {
10714: op = 0;
10715: NEXT;
10716: } else if (CUR == 'd') {
10717: op = 1;
10718: SKIP(3);
10719: } else if (CUR == 'm') {
10720: op = 2;
10721: SKIP(3);
10722: }
10723: SKIP_BLANKS;
10724: xmlXPathCompUnaryExpr(ctxt);
10725: CHECK_ERROR;
10726: PUSH_BINARY_EXPR(XPATH_OP_MULT, op1, ctxt->comp->last, op, 0);
10727: SKIP_BLANKS;
10728: }
10729: }
10730:
10731: /**
10732: * xmlXPathCompAdditiveExpr:
10733: * @ctxt: the XPath Parser context
10734: *
10735: * [25] AdditiveExpr ::= MultiplicativeExpr
10736: * | AdditiveExpr '+' MultiplicativeExpr
10737: * | AdditiveExpr '-' MultiplicativeExpr
10738: *
10739: * Compile an Additive expression.
10740: */
10741:
10742: static void
10743: xmlXPathCompAdditiveExpr(xmlXPathParserContextPtr ctxt) {
10744:
10745: xmlXPathCompMultiplicativeExpr(ctxt);
10746: CHECK_ERROR;
10747: SKIP_BLANKS;
10748: while ((CUR == '+') || (CUR == '-')) {
10749: int plus;
10750: int op1 = ctxt->comp->last;
10751:
10752: if (CUR == '+') plus = 1;
10753: else plus = 0;
10754: NEXT;
10755: SKIP_BLANKS;
10756: xmlXPathCompMultiplicativeExpr(ctxt);
10757: CHECK_ERROR;
10758: PUSH_BINARY_EXPR(XPATH_OP_PLUS, op1, ctxt->comp->last, plus, 0);
10759: SKIP_BLANKS;
10760: }
10761: }
10762:
10763: /**
10764: * xmlXPathCompRelationalExpr:
10765: * @ctxt: the XPath Parser context
10766: *
10767: * [24] RelationalExpr ::= AdditiveExpr
10768: * | RelationalExpr '<' AdditiveExpr
10769: * | RelationalExpr '>' AdditiveExpr
10770: * | RelationalExpr '<=' AdditiveExpr
10771: * | RelationalExpr '>=' AdditiveExpr
10772: *
10773: * A <= B > C is allowed ? Answer from James, yes with
10774: * (AdditiveExpr <= AdditiveExpr) > AdditiveExpr
10775: * which is basically what got implemented.
10776: *
10777: * Compile a Relational expression, then push the result
10778: * on the stack
10779: */
10780:
10781: static void
10782: xmlXPathCompRelationalExpr(xmlXPathParserContextPtr ctxt) {
10783: xmlXPathCompAdditiveExpr(ctxt);
10784: CHECK_ERROR;
10785: SKIP_BLANKS;
10786: while ((CUR == '<') ||
10787: (CUR == '>') ||
10788: ((CUR == '<') && (NXT(1) == '=')) ||
10789: ((CUR == '>') && (NXT(1) == '='))) {
10790: int inf, strict;
10791: int op1 = ctxt->comp->last;
10792:
10793: if (CUR == '<') inf = 1;
10794: else inf = 0;
10795: if (NXT(1) == '=') strict = 0;
10796: else strict = 1;
10797: NEXT;
10798: if (!strict) NEXT;
10799: SKIP_BLANKS;
10800: xmlXPathCompAdditiveExpr(ctxt);
10801: CHECK_ERROR;
10802: PUSH_BINARY_EXPR(XPATH_OP_CMP, op1, ctxt->comp->last, inf, strict);
10803: SKIP_BLANKS;
10804: }
10805: }
10806:
10807: /**
10808: * xmlXPathCompEqualityExpr:
10809: * @ctxt: the XPath Parser context
10810: *
10811: * [23] EqualityExpr ::= RelationalExpr
10812: * | EqualityExpr '=' RelationalExpr
10813: * | EqualityExpr '!=' RelationalExpr
10814: *
10815: * A != B != C is allowed ? Answer from James, yes with
10816: * (RelationalExpr = RelationalExpr) = RelationalExpr
10817: * (RelationalExpr != RelationalExpr) != RelationalExpr
10818: * which is basically what got implemented.
10819: *
10820: * Compile an Equality expression.
10821: *
10822: */
10823: static void
10824: xmlXPathCompEqualityExpr(xmlXPathParserContextPtr ctxt) {
10825: xmlXPathCompRelationalExpr(ctxt);
10826: CHECK_ERROR;
10827: SKIP_BLANKS;
10828: while ((CUR == '=') || ((CUR == '!') && (NXT(1) == '='))) {
10829: int eq;
10830: int op1 = ctxt->comp->last;
10831:
10832: if (CUR == '=') eq = 1;
10833: else eq = 0;
10834: NEXT;
10835: if (!eq) NEXT;
10836: SKIP_BLANKS;
10837: xmlXPathCompRelationalExpr(ctxt);
10838: CHECK_ERROR;
10839: PUSH_BINARY_EXPR(XPATH_OP_EQUAL, op1, ctxt->comp->last, eq, 0);
10840: SKIP_BLANKS;
10841: }
10842: }
10843:
10844: /**
10845: * xmlXPathCompAndExpr:
10846: * @ctxt: the XPath Parser context
10847: *
10848: * [22] AndExpr ::= EqualityExpr
10849: * | AndExpr 'and' EqualityExpr
10850: *
10851: * Compile an AND expression.
10852: *
10853: */
10854: static void
10855: xmlXPathCompAndExpr(xmlXPathParserContextPtr ctxt) {
10856: xmlXPathCompEqualityExpr(ctxt);
10857: CHECK_ERROR;
10858: SKIP_BLANKS;
10859: while ((CUR == 'a') && (NXT(1) == 'n') && (NXT(2) == 'd')) {
10860: int op1 = ctxt->comp->last;
10861: SKIP(3);
10862: SKIP_BLANKS;
10863: xmlXPathCompEqualityExpr(ctxt);
10864: CHECK_ERROR;
10865: PUSH_BINARY_EXPR(XPATH_OP_AND, op1, ctxt->comp->last, 0, 0);
10866: SKIP_BLANKS;
10867: }
10868: }
10869:
10870: /**
10871: * xmlXPathCompileExpr:
10872: * @ctxt: the XPath Parser context
10873: *
10874: * [14] Expr ::= OrExpr
10875: * [21] OrExpr ::= AndExpr
10876: * | OrExpr 'or' AndExpr
10877: *
10878: * Parse and compile an expression
10879: */
10880: static void
10881: xmlXPathCompileExpr(xmlXPathParserContextPtr ctxt, int sort) {
10882: xmlXPathCompAndExpr(ctxt);
10883: CHECK_ERROR;
10884: SKIP_BLANKS;
10885: while ((CUR == 'o') && (NXT(1) == 'r')) {
10886: int op1 = ctxt->comp->last;
10887: SKIP(2);
10888: SKIP_BLANKS;
10889: xmlXPathCompAndExpr(ctxt);
10890: CHECK_ERROR;
10891: PUSH_BINARY_EXPR(XPATH_OP_OR, op1, ctxt->comp->last, 0, 0);
10892: SKIP_BLANKS;
10893: }
10894: if ((sort) && (ctxt->comp->steps[ctxt->comp->last].op != XPATH_OP_VALUE)) {
10895: /* more ops could be optimized too */
10896: /*
10897: * This is the main place to eliminate sorting for
10898: * operations which don't require a sorted node-set.
10899: * E.g. count().
10900: */
10901: PUSH_UNARY_EXPR(XPATH_OP_SORT, ctxt->comp->last , 0, 0);
10902: }
10903: }
10904:
10905: /**
10906: * xmlXPathCompPredicate:
10907: * @ctxt: the XPath Parser context
10908: * @filter: act as a filter
10909: *
10910: * [8] Predicate ::= '[' PredicateExpr ']'
10911: * [9] PredicateExpr ::= Expr
10912: *
10913: * Compile a predicate expression
10914: */
10915: static void
10916: xmlXPathCompPredicate(xmlXPathParserContextPtr ctxt, int filter) {
10917: int op1 = ctxt->comp->last;
10918:
10919: SKIP_BLANKS;
10920: if (CUR != '[') {
10921: XP_ERROR(XPATH_INVALID_PREDICATE_ERROR);
10922: }
10923: NEXT;
10924: SKIP_BLANKS;
10925:
10926: ctxt->comp->last = -1;
10927: /*
10928: * This call to xmlXPathCompileExpr() will deactivate sorting
10929: * of the predicate result.
10930: * TODO: Sorting is still activated for filters, since I'm not
10931: * sure if needed. Normally sorting should not be needed, since
10932: * a filter can only diminish the number of items in a sequence,
10933: * but won't change its order; so if the initial sequence is sorted,
10934: * subsequent sorting is not needed.
10935: */
10936: if (! filter)
10937: xmlXPathCompileExpr(ctxt, 0);
10938: else
10939: xmlXPathCompileExpr(ctxt, 1);
10940: CHECK_ERROR;
10941:
10942: if (CUR != ']') {
10943: XP_ERROR(XPATH_INVALID_PREDICATE_ERROR);
10944: }
10945:
10946: if (filter)
10947: PUSH_BINARY_EXPR(XPATH_OP_FILTER, op1, ctxt->comp->last, 0, 0);
10948: else
10949: PUSH_BINARY_EXPR(XPATH_OP_PREDICATE, op1, ctxt->comp->last, 0, 0);
10950:
10951: NEXT;
10952: SKIP_BLANKS;
10953: }
10954:
10955: /**
10956: * xmlXPathCompNodeTest:
10957: * @ctxt: the XPath Parser context
10958: * @test: pointer to a xmlXPathTestVal
10959: * @type: pointer to a xmlXPathTypeVal
10960: * @prefix: placeholder for a possible name prefix
10961: *
10962: * [7] NodeTest ::= NameTest
10963: * | NodeType '(' ')'
10964: * | 'processing-instruction' '(' Literal ')'
10965: *
10966: * [37] NameTest ::= '*'
10967: * | NCName ':' '*'
10968: * | QName
10969: * [38] NodeType ::= 'comment'
10970: * | 'text'
10971: * | 'processing-instruction'
10972: * | 'node'
10973: *
10974: * Returns the name found and updates @test, @type and @prefix appropriately
10975: */
10976: static xmlChar *
10977: xmlXPathCompNodeTest(xmlXPathParserContextPtr ctxt, xmlXPathTestVal *test,
10978: xmlXPathTypeVal *type, const xmlChar **prefix,
10979: xmlChar *name) {
10980: int blanks;
10981:
10982: if ((test == NULL) || (type == NULL) || (prefix == NULL)) {
10983: STRANGE;
10984: return(NULL);
10985: }
10986: *type = (xmlXPathTypeVal) 0;
10987: *test = (xmlXPathTestVal) 0;
10988: *prefix = NULL;
10989: SKIP_BLANKS;
10990:
10991: if ((name == NULL) && (CUR == '*')) {
10992: /*
10993: * All elements
10994: */
10995: NEXT;
10996: *test = NODE_TEST_ALL;
10997: return(NULL);
10998: }
10999:
11000: if (name == NULL)
11001: name = xmlXPathParseNCName(ctxt);
11002: if (name == NULL) {
11003: XP_ERRORNULL(XPATH_EXPR_ERROR);
11004: }
11005:
11006: blanks = IS_BLANK_CH(CUR);
11007: SKIP_BLANKS;
11008: if (CUR == '(') {
11009: NEXT;
11010: /*
11011: * NodeType or PI search
11012: */
11013: if (xmlStrEqual(name, BAD_CAST "comment"))
11014: *type = NODE_TYPE_COMMENT;
11015: else if (xmlStrEqual(name, BAD_CAST "node"))
11016: *type = NODE_TYPE_NODE;
11017: else if (xmlStrEqual(name, BAD_CAST "processing-instruction"))
11018: *type = NODE_TYPE_PI;
11019: else if (xmlStrEqual(name, BAD_CAST "text"))
11020: *type = NODE_TYPE_TEXT;
11021: else {
11022: if (name != NULL)
11023: xmlFree(name);
11024: XP_ERRORNULL(XPATH_EXPR_ERROR);
11025: }
11026:
11027: *test = NODE_TEST_TYPE;
11028:
11029: SKIP_BLANKS;
11030: if (*type == NODE_TYPE_PI) {
11031: /*
11032: * Specific case: search a PI by name.
11033: */
11034: if (name != NULL)
11035: xmlFree(name);
11036: name = NULL;
11037: if (CUR != ')') {
11038: name = xmlXPathParseLiteral(ctxt);
11039: CHECK_ERROR NULL;
11040: *test = NODE_TEST_PI;
11041: SKIP_BLANKS;
11042: }
11043: }
11044: if (CUR != ')') {
11045: if (name != NULL)
11046: xmlFree(name);
11047: XP_ERRORNULL(XPATH_UNCLOSED_ERROR);
11048: }
11049: NEXT;
11050: return(name);
11051: }
11052: *test = NODE_TEST_NAME;
11053: if ((!blanks) && (CUR == ':')) {
11054: NEXT;
11055:
11056: /*
11057: * Since currently the parser context don't have a
11058: * namespace list associated:
11059: * The namespace name for this prefix can be computed
11060: * only at evaluation time. The compilation is done
11061: * outside of any context.
11062: */
11063: #if 0
11064: *prefix = xmlXPathNsLookup(ctxt->context, name);
11065: if (name != NULL)
11066: xmlFree(name);
11067: if (*prefix == NULL) {
11068: XP_ERROR0(XPATH_UNDEF_PREFIX_ERROR);
11069: }
11070: #else
11071: *prefix = name;
11072: #endif
11073:
11074: if (CUR == '*') {
11075: /*
11076: * All elements
11077: */
11078: NEXT;
11079: *test = NODE_TEST_ALL;
11080: return(NULL);
11081: }
11082:
11083: name = xmlXPathParseNCName(ctxt);
11084: if (name == NULL) {
11085: XP_ERRORNULL(XPATH_EXPR_ERROR);
11086: }
11087: }
11088: return(name);
11089: }
11090:
11091: /**
11092: * xmlXPathIsAxisName:
11093: * @name: a preparsed name token
11094: *
11095: * [6] AxisName ::= 'ancestor'
11096: * | 'ancestor-or-self'
11097: * | 'attribute'
11098: * | 'child'
11099: * | 'descendant'
11100: * | 'descendant-or-self'
11101: * | 'following'
11102: * | 'following-sibling'
11103: * | 'namespace'
11104: * | 'parent'
11105: * | 'preceding'
11106: * | 'preceding-sibling'
11107: * | 'self'
11108: *
11109: * Returns the axis or 0
11110: */
11111: static xmlXPathAxisVal
11112: xmlXPathIsAxisName(const xmlChar *name) {
11113: xmlXPathAxisVal ret = (xmlXPathAxisVal) 0;
11114: switch (name[0]) {
11115: case 'a':
11116: if (xmlStrEqual(name, BAD_CAST "ancestor"))
11117: ret = AXIS_ANCESTOR;
11118: if (xmlStrEqual(name, BAD_CAST "ancestor-or-self"))
11119: ret = AXIS_ANCESTOR_OR_SELF;
11120: if (xmlStrEqual(name, BAD_CAST "attribute"))
11121: ret = AXIS_ATTRIBUTE;
11122: break;
11123: case 'c':
11124: if (xmlStrEqual(name, BAD_CAST "child"))
11125: ret = AXIS_CHILD;
11126: break;
11127: case 'd':
11128: if (xmlStrEqual(name, BAD_CAST "descendant"))
11129: ret = AXIS_DESCENDANT;
11130: if (xmlStrEqual(name, BAD_CAST "descendant-or-self"))
11131: ret = AXIS_DESCENDANT_OR_SELF;
11132: break;
11133: case 'f':
11134: if (xmlStrEqual(name, BAD_CAST "following"))
11135: ret = AXIS_FOLLOWING;
11136: if (xmlStrEqual(name, BAD_CAST "following-sibling"))
11137: ret = AXIS_FOLLOWING_SIBLING;
11138: break;
11139: case 'n':
11140: if (xmlStrEqual(name, BAD_CAST "namespace"))
11141: ret = AXIS_NAMESPACE;
11142: break;
11143: case 'p':
11144: if (xmlStrEqual(name, BAD_CAST "parent"))
11145: ret = AXIS_PARENT;
11146: if (xmlStrEqual(name, BAD_CAST "preceding"))
11147: ret = AXIS_PRECEDING;
11148: if (xmlStrEqual(name, BAD_CAST "preceding-sibling"))
11149: ret = AXIS_PRECEDING_SIBLING;
11150: break;
11151: case 's':
11152: if (xmlStrEqual(name, BAD_CAST "self"))
11153: ret = AXIS_SELF;
11154: break;
11155: }
11156: return(ret);
11157: }
11158:
11159: /**
11160: * xmlXPathCompStep:
11161: * @ctxt: the XPath Parser context
11162: *
11163: * [4] Step ::= AxisSpecifier NodeTest Predicate*
11164: * | AbbreviatedStep
11165: *
11166: * [12] AbbreviatedStep ::= '.' | '..'
11167: *
11168: * [5] AxisSpecifier ::= AxisName '::'
11169: * | AbbreviatedAxisSpecifier
11170: *
11171: * [13] AbbreviatedAxisSpecifier ::= '@'?
11172: *
11173: * Modified for XPtr range support as:
11174: *
11175: * [4xptr] Step ::= AxisSpecifier NodeTest Predicate*
11176: * | AbbreviatedStep
11177: * | 'range-to' '(' Expr ')' Predicate*
11178: *
11179: * Compile one step in a Location Path
11180: * A location step of . is short for self::node(). This is
11181: * particularly useful in conjunction with //. For example, the
11182: * location path .//para is short for
11183: * self::node()/descendant-or-self::node()/child::para
11184: * and so will select all para descendant elements of the context
11185: * node.
11186: * Similarly, a location step of .. is short for parent::node().
11187: * For example, ../title is short for parent::node()/child::title
11188: * and so will select the title children of the parent of the context
11189: * node.
11190: */
11191: static void
11192: xmlXPathCompStep(xmlXPathParserContextPtr ctxt) {
11193: #ifdef LIBXML_XPTR_ENABLED
11194: int rangeto = 0;
11195: int op2 = -1;
11196: #endif
11197:
11198: SKIP_BLANKS;
11199: if ((CUR == '.') && (NXT(1) == '.')) {
11200: SKIP(2);
11201: SKIP_BLANKS;
11202: PUSH_LONG_EXPR(XPATH_OP_COLLECT, AXIS_PARENT,
11203: NODE_TEST_TYPE, NODE_TYPE_NODE, NULL, NULL);
11204: } else if (CUR == '.') {
11205: NEXT;
11206: SKIP_BLANKS;
11207: } else {
11208: xmlChar *name = NULL;
11209: const xmlChar *prefix = NULL;
11210: xmlXPathTestVal test = (xmlXPathTestVal) 0;
11211: xmlXPathAxisVal axis = (xmlXPathAxisVal) 0;
11212: xmlXPathTypeVal type = (xmlXPathTypeVal) 0;
11213: int op1;
11214:
11215: /*
11216: * The modification needed for XPointer change to the production
11217: */
11218: #ifdef LIBXML_XPTR_ENABLED
11219: if (ctxt->xptr) {
11220: name = xmlXPathParseNCName(ctxt);
11221: if ((name != NULL) && (xmlStrEqual(name, BAD_CAST "range-to"))) {
11222: op2 = ctxt->comp->last;
11223: xmlFree(name);
11224: SKIP_BLANKS;
11225: if (CUR != '(') {
11226: XP_ERROR(XPATH_EXPR_ERROR);
11227: }
11228: NEXT;
11229: SKIP_BLANKS;
11230:
11231: xmlXPathCompileExpr(ctxt, 1);
11232: /* PUSH_BINARY_EXPR(XPATH_OP_RANGETO, op2, ctxt->comp->last, 0, 0); */
11233: CHECK_ERROR;
11234:
11235: SKIP_BLANKS;
11236: if (CUR != ')') {
11237: XP_ERROR(XPATH_EXPR_ERROR);
11238: }
11239: NEXT;
11240: rangeto = 1;
11241: goto eval_predicates;
11242: }
11243: }
11244: #endif
11245: if (CUR == '*') {
11246: axis = AXIS_CHILD;
11247: } else {
11248: if (name == NULL)
11249: name = xmlXPathParseNCName(ctxt);
11250: if (name != NULL) {
11251: axis = xmlXPathIsAxisName(name);
11252: if (axis != 0) {
11253: SKIP_BLANKS;
11254: if ((CUR == ':') && (NXT(1) == ':')) {
11255: SKIP(2);
11256: xmlFree(name);
11257: name = NULL;
11258: } else {
11259: /* an element name can conflict with an axis one :-\ */
11260: axis = AXIS_CHILD;
11261: }
11262: } else {
11263: axis = AXIS_CHILD;
11264: }
11265: } else if (CUR == '@') {
11266: NEXT;
11267: axis = AXIS_ATTRIBUTE;
11268: } else {
11269: axis = AXIS_CHILD;
11270: }
11271: }
11272:
11273: if (ctxt->error != XPATH_EXPRESSION_OK) {
11274: xmlFree(name);
11275: return;
11276: }
11277:
11278: name = xmlXPathCompNodeTest(ctxt, &test, &type, &prefix, name);
11279: if (test == 0)
11280: return;
11281:
11282: if ((prefix != NULL) && (ctxt->context != NULL) &&
11283: (ctxt->context->flags & XML_XPATH_CHECKNS)) {
11284: if (xmlXPathNsLookup(ctxt->context, prefix) == NULL) {
11285: xmlXPathErr(ctxt, XPATH_UNDEF_PREFIX_ERROR);
11286: }
11287: }
11288: #ifdef DEBUG_STEP
11289: xmlGenericError(xmlGenericErrorContext,
11290: "Basis : computing new set\n");
11291: #endif
11292:
11293: #ifdef DEBUG_STEP
11294: xmlGenericError(xmlGenericErrorContext, "Basis : ");
11295: if (ctxt->value == NULL)
11296: xmlGenericError(xmlGenericErrorContext, "no value\n");
11297: else if (ctxt->value->nodesetval == NULL)
11298: xmlGenericError(xmlGenericErrorContext, "Empty\n");
11299: else
11300: xmlGenericErrorContextNodeSet(stdout, ctxt->value->nodesetval);
11301: #endif
11302:
11303: #ifdef LIBXML_XPTR_ENABLED
11304: eval_predicates:
11305: #endif
11306: op1 = ctxt->comp->last;
11307: ctxt->comp->last = -1;
11308:
11309: SKIP_BLANKS;
11310: while (CUR == '[') {
11311: xmlXPathCompPredicate(ctxt, 0);
11312: }
11313:
11314: #ifdef LIBXML_XPTR_ENABLED
11315: if (rangeto) {
11316: PUSH_BINARY_EXPR(XPATH_OP_RANGETO, op2, op1, 0, 0);
11317: } else
11318: #endif
11319: PUSH_FULL_EXPR(XPATH_OP_COLLECT, op1, ctxt->comp->last, axis,
11320: test, type, (void *)prefix, (void *)name);
11321:
11322: }
11323: #ifdef DEBUG_STEP
11324: xmlGenericError(xmlGenericErrorContext, "Step : ");
11325: if (ctxt->value == NULL)
11326: xmlGenericError(xmlGenericErrorContext, "no value\n");
11327: else if (ctxt->value->nodesetval == NULL)
11328: xmlGenericError(xmlGenericErrorContext, "Empty\n");
11329: else
11330: xmlGenericErrorContextNodeSet(xmlGenericErrorContext,
11331: ctxt->value->nodesetval);
11332: #endif
11333: }
11334:
11335: /**
11336: * xmlXPathCompRelativeLocationPath:
11337: * @ctxt: the XPath Parser context
11338: *
11339: * [3] RelativeLocationPath ::= Step
11340: * | RelativeLocationPath '/' Step
11341: * | AbbreviatedRelativeLocationPath
11342: * [11] AbbreviatedRelativeLocationPath ::= RelativeLocationPath '//' Step
11343: *
11344: * Compile a relative location path.
11345: */
11346: static void
11347: xmlXPathCompRelativeLocationPath
11348: (xmlXPathParserContextPtr ctxt) {
11349: SKIP_BLANKS;
11350: if ((CUR == '/') && (NXT(1) == '/')) {
11351: SKIP(2);
11352: SKIP_BLANKS;
11353: PUSH_LONG_EXPR(XPATH_OP_COLLECT, AXIS_DESCENDANT_OR_SELF,
11354: NODE_TEST_TYPE, NODE_TYPE_NODE, NULL, NULL);
11355: } else if (CUR == '/') {
11356: NEXT;
11357: SKIP_BLANKS;
11358: }
11359: xmlXPathCompStep(ctxt);
11360: CHECK_ERROR;
11361: SKIP_BLANKS;
11362: while (CUR == '/') {
11363: if ((CUR == '/') && (NXT(1) == '/')) {
11364: SKIP(2);
11365: SKIP_BLANKS;
11366: PUSH_LONG_EXPR(XPATH_OP_COLLECT, AXIS_DESCENDANT_OR_SELF,
11367: NODE_TEST_TYPE, NODE_TYPE_NODE, NULL, NULL);
11368: xmlXPathCompStep(ctxt);
11369: } else if (CUR == '/') {
11370: NEXT;
11371: SKIP_BLANKS;
11372: xmlXPathCompStep(ctxt);
11373: }
11374: SKIP_BLANKS;
11375: }
11376: }
11377:
11378: /**
11379: * xmlXPathCompLocationPath:
11380: * @ctxt: the XPath Parser context
11381: *
11382: * [1] LocationPath ::= RelativeLocationPath
11383: * | AbsoluteLocationPath
11384: * [2] AbsoluteLocationPath ::= '/' RelativeLocationPath?
11385: * | AbbreviatedAbsoluteLocationPath
11386: * [10] AbbreviatedAbsoluteLocationPath ::=
11387: * '//' RelativeLocationPath
11388: *
11389: * Compile a location path
11390: *
11391: * // is short for /descendant-or-self::node()/. For example,
11392: * //para is short for /descendant-or-self::node()/child::para and
11393: * so will select any para element in the document (even a para element
11394: * that is a document element will be selected by //para since the
11395: * document element node is a child of the root node); div//para is
11396: * short for div/descendant-or-self::node()/child::para and so will
11397: * select all para descendants of div children.
11398: */
11399: static void
11400: xmlXPathCompLocationPath(xmlXPathParserContextPtr ctxt) {
11401: SKIP_BLANKS;
11402: if (CUR != '/') {
11403: xmlXPathCompRelativeLocationPath(ctxt);
11404: } else {
11405: while (CUR == '/') {
11406: if ((CUR == '/') && (NXT(1) == '/')) {
11407: SKIP(2);
11408: SKIP_BLANKS;
11409: PUSH_LONG_EXPR(XPATH_OP_COLLECT, AXIS_DESCENDANT_OR_SELF,
11410: NODE_TEST_TYPE, NODE_TYPE_NODE, NULL, NULL);
11411: xmlXPathCompRelativeLocationPath(ctxt);
11412: } else if (CUR == '/') {
11413: NEXT;
11414: SKIP_BLANKS;
11415: if ((CUR != 0 ) &&
11416: ((IS_ASCII_LETTER(CUR)) || (CUR == '_') || (CUR == '.') ||
11417: (CUR == '@') || (CUR == '*')))
11418: xmlXPathCompRelativeLocationPath(ctxt);
11419: }
11420: CHECK_ERROR;
11421: }
11422: }
11423: }
11424:
11425: /************************************************************************
11426: * *
11427: * XPath precompiled expression evaluation *
11428: * *
11429: ************************************************************************/
11430:
11431: static int
11432: xmlXPathCompOpEval(xmlXPathParserContextPtr ctxt, xmlXPathStepOpPtr op);
11433:
11434: #ifdef DEBUG_STEP
11435: static void
11436: xmlXPathDebugDumpStepAxis(xmlXPathStepOpPtr op,
11437: int nbNodes)
11438: {
11439: xmlGenericError(xmlGenericErrorContext, "new step : ");
11440: switch (op->value) {
11441: case AXIS_ANCESTOR:
11442: xmlGenericError(xmlGenericErrorContext, "axis 'ancestors' ");
11443: break;
11444: case AXIS_ANCESTOR_OR_SELF:
11445: xmlGenericError(xmlGenericErrorContext,
11446: "axis 'ancestors-or-self' ");
11447: break;
11448: case AXIS_ATTRIBUTE:
11449: xmlGenericError(xmlGenericErrorContext, "axis 'attributes' ");
11450: break;
11451: case AXIS_CHILD:
11452: xmlGenericError(xmlGenericErrorContext, "axis 'child' ");
11453: break;
11454: case AXIS_DESCENDANT:
11455: xmlGenericError(xmlGenericErrorContext, "axis 'descendant' ");
11456: break;
11457: case AXIS_DESCENDANT_OR_SELF:
11458: xmlGenericError(xmlGenericErrorContext,
11459: "axis 'descendant-or-self' ");
11460: break;
11461: case AXIS_FOLLOWING:
11462: xmlGenericError(xmlGenericErrorContext, "axis 'following' ");
11463: break;
11464: case AXIS_FOLLOWING_SIBLING:
11465: xmlGenericError(xmlGenericErrorContext,
11466: "axis 'following-siblings' ");
11467: break;
11468: case AXIS_NAMESPACE:
11469: xmlGenericError(xmlGenericErrorContext, "axis 'namespace' ");
11470: break;
11471: case AXIS_PARENT:
11472: xmlGenericError(xmlGenericErrorContext, "axis 'parent' ");
11473: break;
11474: case AXIS_PRECEDING:
11475: xmlGenericError(xmlGenericErrorContext, "axis 'preceding' ");
11476: break;
11477: case AXIS_PRECEDING_SIBLING:
11478: xmlGenericError(xmlGenericErrorContext,
11479: "axis 'preceding-sibling' ");
11480: break;
11481: case AXIS_SELF:
11482: xmlGenericError(xmlGenericErrorContext, "axis 'self' ");
11483: break;
11484: }
11485: xmlGenericError(xmlGenericErrorContext,
11486: " context contains %d nodes\n", nbNodes);
11487: switch (op->value2) {
11488: case NODE_TEST_NONE:
11489: xmlGenericError(xmlGenericErrorContext,
11490: " searching for none !!!\n");
11491: break;
11492: case NODE_TEST_TYPE:
11493: xmlGenericError(xmlGenericErrorContext,
11494: " searching for type %d\n", op->value3);
11495: break;
11496: case NODE_TEST_PI:
11497: xmlGenericError(xmlGenericErrorContext,
11498: " searching for PI !!!\n");
11499: break;
11500: case NODE_TEST_ALL:
11501: xmlGenericError(xmlGenericErrorContext,
11502: " searching for *\n");
11503: break;
11504: case NODE_TEST_NS:
11505: xmlGenericError(xmlGenericErrorContext,
11506: " searching for namespace %s\n",
11507: op->value5);
11508: break;
11509: case NODE_TEST_NAME:
11510: xmlGenericError(xmlGenericErrorContext,
11511: " searching for name %s\n", op->value5);
11512: if (op->value4)
11513: xmlGenericError(xmlGenericErrorContext,
11514: " with namespace %s\n", op->value4);
11515: break;
11516: }
11517: xmlGenericError(xmlGenericErrorContext, "Testing : ");
11518: }
11519: #endif /* DEBUG_STEP */
11520:
11521: static int
11522: xmlXPathCompOpEvalPredicate(xmlXPathParserContextPtr ctxt,
11523: xmlXPathStepOpPtr op,
11524: xmlNodeSetPtr set,
11525: int contextSize,
11526: int hasNsNodes)
11527: {
11528: if (op->ch1 != -1) {
11529: xmlXPathCompExprPtr comp = ctxt->comp;
11530: /*
11531: * Process inner predicates first.
11532: */
11533: if (comp->steps[op->ch1].op != XPATH_OP_PREDICATE) {
11534: /*
11535: * TODO: raise an internal error.
11536: */
11537: }
11538: contextSize = xmlXPathCompOpEvalPredicate(ctxt,
11539: &comp->steps[op->ch1], set, contextSize, hasNsNodes);
11540: CHECK_ERROR0;
11541: if (contextSize <= 0)
11542: return(0);
11543: }
11544: if (op->ch2 != -1) {
11545: xmlXPathContextPtr xpctxt = ctxt->context;
11546: xmlNodePtr contextNode, oldContextNode;
11547: xmlDocPtr oldContextDoc;
11548: int i, res, contextPos = 0, newContextSize;
11549: xmlXPathStepOpPtr exprOp;
11550: xmlXPathObjectPtr contextObj = NULL, exprRes = NULL;
11551:
11552: #ifdef LIBXML_XPTR_ENABLED
11553: /*
11554: * URGENT TODO: Check the following:
11555: * We don't expect location sets if evaluating prediates, right?
11556: * Only filters should expect location sets, right?
11557: */
11558: #endif
11559: /*
11560: * SPEC XPath 1.0:
11561: * "For each node in the node-set to be filtered, the
11562: * PredicateExpr is evaluated with that node as the
11563: * context node, with the number of nodes in the
11564: * node-set as the context size, and with the proximity
11565: * position of the node in the node-set with respect to
11566: * the axis as the context position;"
11567: * @oldset is the node-set" to be filtered.
11568: *
11569: * SPEC XPath 1.0:
11570: * "only predicates change the context position and
11571: * context size (see [2.4 Predicates])."
11572: * Example:
11573: * node-set context pos
11574: * nA 1
11575: * nB 2
11576: * nC 3
11577: * After applying predicate [position() > 1] :
11578: * node-set context pos
11579: * nB 1
11580: * nC 2
11581: */
11582: oldContextNode = xpctxt->node;
11583: oldContextDoc = xpctxt->doc;
11584: /*
11585: * Get the expression of this predicate.
11586: */
11587: exprOp = &ctxt->comp->steps[op->ch2];
11588: newContextSize = 0;
11589: for (i = 0; i < set->nodeNr; i++) {
11590: if (set->nodeTab[i] == NULL)
11591: continue;
11592:
11593: contextNode = set->nodeTab[i];
11594: xpctxt->node = contextNode;
11595: xpctxt->contextSize = contextSize;
11596: xpctxt->proximityPosition = ++contextPos;
11597:
11598: /*
11599: * Also set the xpath document in case things like
11600: * key() are evaluated in the predicate.
11601: */
11602: if ((contextNode->type != XML_NAMESPACE_DECL) &&
11603: (contextNode->doc != NULL))
11604: xpctxt->doc = contextNode->doc;
11605: /*
11606: * Evaluate the predicate expression with 1 context node
11607: * at a time; this node is packaged into a node set; this
11608: * node set is handed over to the evaluation mechanism.
11609: */
11610: if (contextObj == NULL)
11611: contextObj = xmlXPathCacheNewNodeSet(xpctxt, contextNode);
11612: else
11613: xmlXPathNodeSetAddUnique(contextObj->nodesetval,
11614: contextNode);
11615:
11616: valuePush(ctxt, contextObj);
11617:
11618: res = xmlXPathCompOpEvalToBoolean(ctxt, exprOp, 1);
11619:
11620: if ((ctxt->error != XPATH_EXPRESSION_OK) || (res == -1)) {
11621: xmlXPathNodeSetClear(set, hasNsNodes);
11622: newContextSize = 0;
11623: goto evaluation_exit;
11624: }
11625:
11626: if (res != 0) {
11627: newContextSize++;
11628: } else {
11629: /*
11630: * Remove the entry from the initial node set.
11631: */
11632: set->nodeTab[i] = NULL;
11633: if (contextNode->type == XML_NAMESPACE_DECL)
11634: xmlXPathNodeSetFreeNs((xmlNsPtr) contextNode);
11635: }
11636: if (ctxt->value == contextObj) {
11637: /*
11638: * Don't free the temporary XPath object holding the
11639: * context node, in order to avoid massive recreation
11640: * inside this loop.
11641: */
11642: valuePop(ctxt);
11643: xmlXPathNodeSetClear(contextObj->nodesetval, hasNsNodes);
11644: } else {
11645: /*
11646: * TODO: The object was lost in the evaluation machinery.
11647: * Can this happen? Maybe in internal-error cases.
11648: */
11649: contextObj = NULL;
11650: }
11651: }
11652:
11653: if (contextObj != NULL) {
11654: if (ctxt->value == contextObj)
11655: valuePop(ctxt);
11656: xmlXPathReleaseObject(xpctxt, contextObj);
11657: }
11658: evaluation_exit:
11659: if (exprRes != NULL)
11660: xmlXPathReleaseObject(ctxt->context, exprRes);
11661: /*
11662: * Reset/invalidate the context.
11663: */
11664: xpctxt->node = oldContextNode;
11665: xpctxt->doc = oldContextDoc;
11666: xpctxt->contextSize = -1;
11667: xpctxt->proximityPosition = -1;
11668: return(newContextSize);
11669: }
11670: return(contextSize);
11671: }
11672:
11673: static int
11674: xmlXPathCompOpEvalPositionalPredicate(xmlXPathParserContextPtr ctxt,
11675: xmlXPathStepOpPtr op,
11676: xmlNodeSetPtr set,
11677: int contextSize,
11678: int minPos,
11679: int maxPos,
11680: int hasNsNodes)
11681: {
11682: if (op->ch1 != -1) {
11683: xmlXPathCompExprPtr comp = ctxt->comp;
11684: if (comp->steps[op->ch1].op != XPATH_OP_PREDICATE) {
11685: /*
11686: * TODO: raise an internal error.
11687: */
11688: }
11689: contextSize = xmlXPathCompOpEvalPredicate(ctxt,
11690: &comp->steps[op->ch1], set, contextSize, hasNsNodes);
11691: CHECK_ERROR0;
11692: if (contextSize <= 0)
11693: return(0);
11694: }
11695: /*
11696: * Check if the node set contains a sufficient number of nodes for
11697: * the requested range.
11698: */
11699: if (contextSize < minPos) {
11700: xmlXPathNodeSetClear(set, hasNsNodes);
11701: return(0);
11702: }
11703: if (op->ch2 == -1) {
11704: /*
11705: * TODO: Can this ever happen?
11706: */
11707: return (contextSize);
11708: } else {
11709: xmlDocPtr oldContextDoc;
11710: int i, pos = 0, newContextSize = 0, contextPos = 0, res;
11711: xmlXPathStepOpPtr exprOp;
11712: xmlXPathObjectPtr contextObj = NULL, exprRes = NULL;
11713: xmlNodePtr oldContextNode, contextNode = NULL;
11714: xmlXPathContextPtr xpctxt = ctxt->context;
11715:
11716: #ifdef LIBXML_XPTR_ENABLED
11717: /*
11718: * URGENT TODO: Check the following:
11719: * We don't expect location sets if evaluating prediates, right?
11720: * Only filters should expect location sets, right?
11721: */
11722: #endif /* LIBXML_XPTR_ENABLED */
11723:
11724: /*
11725: * Save old context.
11726: */
11727: oldContextNode = xpctxt->node;
11728: oldContextDoc = xpctxt->doc;
11729: /*
11730: * Get the expression of this predicate.
11731: */
11732: exprOp = &ctxt->comp->steps[op->ch2];
11733: for (i = 0; i < set->nodeNr; i++) {
11734: if (set->nodeTab[i] == NULL)
11735: continue;
11736:
11737: contextNode = set->nodeTab[i];
11738: xpctxt->node = contextNode;
11739: xpctxt->contextSize = contextSize;
11740: xpctxt->proximityPosition = ++contextPos;
11741:
11742: /*
11743: * Initialize the new set.
11744: * Also set the xpath document in case things like
11745: * key() evaluation are attempted on the predicate
11746: */
11747: if ((contextNode->type != XML_NAMESPACE_DECL) &&
11748: (contextNode->doc != NULL))
11749: xpctxt->doc = contextNode->doc;
11750: /*
11751: * Evaluate the predicate expression with 1 context node
11752: * at a time; this node is packaged into a node set; this
11753: * node set is handed over to the evaluation mechanism.
11754: */
11755: if (contextObj == NULL)
11756: contextObj = xmlXPathCacheNewNodeSet(xpctxt, contextNode);
11757: else
11758: xmlXPathNodeSetAddUnique(contextObj->nodesetval,
11759: contextNode);
11760:
11761: valuePush(ctxt, contextObj);
11762: res = xmlXPathCompOpEvalToBoolean(ctxt, exprOp, 1);
11763:
11764: if ((ctxt->error != XPATH_EXPRESSION_OK) || (res == -1)) {
11765: xmlXPathObjectPtr tmp;
11766: /* pop the result */
11767: tmp = valuePop(ctxt);
11768: xmlXPathReleaseObject(xpctxt, tmp);
11769: /* then pop off contextObj, which will be freed later */
11770: valuePop(ctxt);
11771: goto evaluation_error;
11772: }
11773:
11774: if (res)
11775: pos++;
11776:
11777: if (res && (pos >= minPos) && (pos <= maxPos)) {
11778: /*
11779: * Fits in the requested range.
11780: */
11781: newContextSize++;
11782: if (minPos == maxPos) {
11783: /*
11784: * Only 1 node was requested.
11785: */
11786: if (contextNode->type == XML_NAMESPACE_DECL) {
11787: /*
11788: * As always: take care of those nasty
11789: * namespace nodes.
11790: */
11791: set->nodeTab[i] = NULL;
11792: }
11793: xmlXPathNodeSetClear(set, hasNsNodes);
11794: set->nodeNr = 1;
11795: set->nodeTab[0] = contextNode;
11796: goto evaluation_exit;
11797: }
11798: if (pos == maxPos) {
11799: /*
11800: * We are done.
11801: */
11802: xmlXPathNodeSetClearFromPos(set, i +1, hasNsNodes);
11803: goto evaluation_exit;
11804: }
11805: } else {
11806: /*
11807: * Remove the entry from the initial node set.
11808: */
11809: set->nodeTab[i] = NULL;
11810: if (contextNode->type == XML_NAMESPACE_DECL)
11811: xmlXPathNodeSetFreeNs((xmlNsPtr) contextNode);
11812: }
11813: if (exprRes != NULL) {
11814: xmlXPathReleaseObject(ctxt->context, exprRes);
11815: exprRes = NULL;
11816: }
11817: if (ctxt->value == contextObj) {
11818: /*
11819: * Don't free the temporary XPath object holding the
11820: * context node, in order to avoid massive recreation
11821: * inside this loop.
11822: */
11823: valuePop(ctxt);
11824: xmlXPathNodeSetClear(contextObj->nodesetval, hasNsNodes);
11825: } else {
11826: /*
11827: * The object was lost in the evaluation machinery.
11828: * Can this happen? Maybe in case of internal-errors.
11829: */
11830: contextObj = NULL;
11831: }
11832: }
11833: goto evaluation_exit;
11834:
11835: evaluation_error:
11836: xmlXPathNodeSetClear(set, hasNsNodes);
11837: newContextSize = 0;
11838:
11839: evaluation_exit:
11840: if (contextObj != NULL) {
11841: if (ctxt->value == contextObj)
11842: valuePop(ctxt);
11843: xmlXPathReleaseObject(xpctxt, contextObj);
11844: }
11845: if (exprRes != NULL)
11846: xmlXPathReleaseObject(ctxt->context, exprRes);
11847: /*
11848: * Reset/invalidate the context.
11849: */
11850: xpctxt->node = oldContextNode;
11851: xpctxt->doc = oldContextDoc;
11852: xpctxt->contextSize = -1;
11853: xpctxt->proximityPosition = -1;
11854: return(newContextSize);
11855: }
11856: return(contextSize);
11857: }
11858:
11859: static int
11860: xmlXPathIsPositionalPredicate(xmlXPathParserContextPtr ctxt,
11861: xmlXPathStepOpPtr op,
11862: int *maxPos)
11863: {
11864:
11865: xmlXPathStepOpPtr exprOp;
11866:
11867: /*
11868: * BIG NOTE: This is not intended for XPATH_OP_FILTER yet!
11869: */
11870:
11871: /*
11872: * If not -1, then ch1 will point to:
11873: * 1) For predicates (XPATH_OP_PREDICATE):
11874: * - an inner predicate operator
11875: * 2) For filters (XPATH_OP_FILTER):
11876: * - an inner filter operater OR
11877: * - an expression selecting the node set.
11878: * E.g. "key('a', 'b')" or "(//foo | //bar)".
11879: */
11880: if ((op->op != XPATH_OP_PREDICATE) && (op->op != XPATH_OP_FILTER))
11881: return(0);
11882:
11883: if (op->ch2 != -1) {
11884: exprOp = &ctxt->comp->steps[op->ch2];
11885: } else
11886: return(0);
11887:
11888: if ((exprOp != NULL) &&
11889: (exprOp->op == XPATH_OP_VALUE) &&
11890: (exprOp->value4 != NULL) &&
11891: (((xmlXPathObjectPtr) exprOp->value4)->type == XPATH_NUMBER))
11892: {
11893: /*
11894: * We have a "[n]" predicate here.
11895: * TODO: Unfortunately this simplistic test here is not
11896: * able to detect a position() predicate in compound
11897: * expressions like "[@attr = 'a" and position() = 1],
11898: * and even not the usage of position() in
11899: * "[position() = 1]"; thus - obviously - a position-range,
11900: * like it "[position() < 5]", is also not detected.
11901: * Maybe we could rewrite the AST to ease the optimization.
11902: */
11903: *maxPos = (int) ((xmlXPathObjectPtr) exprOp->value4)->floatval;
11904:
11905: if (((xmlXPathObjectPtr) exprOp->value4)->floatval ==
11906: (float) *maxPos)
11907: {
11908: return(1);
11909: }
11910: }
11911: return(0);
11912: }
11913:
11914: static int
11915: xmlXPathNodeCollectAndTest(xmlXPathParserContextPtr ctxt,
11916: xmlXPathStepOpPtr op,
11917: xmlNodePtr * first, xmlNodePtr * last,
11918: int toBool)
11919: {
11920:
11921: #define XP_TEST_HIT \
11922: if (hasAxisRange != 0) { \
11923: if (++pos == maxPos) { \
11924: addNode(seq, cur); \
11925: goto axis_range_end; } \
11926: } else { \
11927: addNode(seq, cur); \
11928: if (breakOnFirstHit) goto first_hit; }
11929:
11930: #define XP_TEST_HIT_NS \
11931: if (hasAxisRange != 0) { \
11932: if (++pos == maxPos) { \
11933: hasNsNodes = 1; \
11934: xmlXPathNodeSetAddNs(seq, xpctxt->node, (xmlNsPtr) cur); \
11935: goto axis_range_end; } \
11936: } else { \
11937: hasNsNodes = 1; \
11938: xmlXPathNodeSetAddNs(seq, \
11939: xpctxt->node, (xmlNsPtr) cur); \
11940: if (breakOnFirstHit) goto first_hit; }
11941:
11942: xmlXPathAxisVal axis = (xmlXPathAxisVal) op->value;
11943: xmlXPathTestVal test = (xmlXPathTestVal) op->value2;
11944: xmlXPathTypeVal type = (xmlXPathTypeVal) op->value3;
11945: const xmlChar *prefix = op->value4;
11946: const xmlChar *name = op->value5;
11947: const xmlChar *URI = NULL;
11948:
11949: #ifdef DEBUG_STEP
11950: int nbMatches = 0, prevMatches = 0;
11951: #endif
11952: int total = 0, hasNsNodes = 0;
11953: /* The popped object holding the context nodes */
11954: xmlXPathObjectPtr obj;
11955: /* The set of context nodes for the node tests */
11956: xmlNodeSetPtr contextSeq;
11957: int contextIdx;
11958: xmlNodePtr contextNode;
11959: /* The context node for a compound traversal */
11960: xmlNodePtr outerContextNode;
11961: /* The final resulting node set wrt to all context nodes */
11962: xmlNodeSetPtr outSeq;
11963: /*
11964: * The temporary resulting node set wrt 1 context node.
11965: * Used to feed predicate evaluation.
11966: */
11967: xmlNodeSetPtr seq;
11968: xmlNodePtr cur;
11969: /* First predicate operator */
11970: xmlXPathStepOpPtr predOp;
11971: int maxPos; /* The requested position() (when a "[n]" predicate) */
11972: int hasPredicateRange, hasAxisRange, pos, size, newSize;
11973: int breakOnFirstHit;
11974:
11975: xmlXPathTraversalFunction next = NULL;
11976: /* compound axis traversal */
11977: xmlXPathTraversalFunctionExt outerNext = NULL;
11978: void (*addNode) (xmlNodeSetPtr, xmlNodePtr);
11979: xmlXPathNodeSetMergeFunction mergeAndClear;
11980: xmlNodePtr oldContextNode;
11981: xmlXPathContextPtr xpctxt = ctxt->context;
11982:
11983:
11984: CHECK_TYPE0(XPATH_NODESET);
11985: obj = valuePop(ctxt);
11986: /*
11987: * Setup namespaces.
11988: */
11989: if (prefix != NULL) {
11990: URI = xmlXPathNsLookup(xpctxt, prefix);
11991: if (URI == NULL) {
11992: xmlXPathReleaseObject(xpctxt, obj);
11993: XP_ERROR0(XPATH_UNDEF_PREFIX_ERROR);
11994: }
11995: }
11996: /*
11997: * Setup axis.
11998: *
11999: * MAYBE FUTURE TODO: merging optimizations:
12000: * - If the nodes to be traversed wrt to the initial nodes and
12001: * the current axis cannot overlap, then we could avoid searching
12002: * for duplicates during the merge.
12003: * But the question is how/when to evaluate if they cannot overlap.
12004: * Example: if we know that for two initial nodes, the one is
12005: * not in the ancestor-or-self axis of the other, then we could safely
12006: * avoid a duplicate-aware merge, if the axis to be traversed is e.g.
12007: * the descendant-or-self axis.
12008: */
12009: mergeAndClear = xmlXPathNodeSetMergeAndClear;
12010: switch (axis) {
12011: case AXIS_ANCESTOR:
12012: first = NULL;
12013: next = xmlXPathNextAncestor;
12014: break;
12015: case AXIS_ANCESTOR_OR_SELF:
12016: first = NULL;
12017: next = xmlXPathNextAncestorOrSelf;
12018: break;
12019: case AXIS_ATTRIBUTE:
12020: first = NULL;
12021: last = NULL;
12022: next = xmlXPathNextAttribute;
12023: mergeAndClear = xmlXPathNodeSetMergeAndClearNoDupls;
12024: break;
12025: case AXIS_CHILD:
12026: last = NULL;
12027: if (op->rewriteType == XP_REWRITE_DOS_CHILD_ELEM) {
12028: /*
12029: * This iterator will give us only nodes which can
12030: * hold element nodes.
12031: */
12032: outerNext = xmlXPathNextDescendantOrSelfElemParent;
12033: }
12034: if (((test == NODE_TEST_NAME) || (test == NODE_TEST_ALL)) &&
12035: (type == NODE_TYPE_NODE))
12036: {
12037: /*
12038: * Optimization if an element node type is 'element'.
12039: */
12040: next = xmlXPathNextChildElement;
12041: } else
12042: next = xmlXPathNextChild;
12043: mergeAndClear = xmlXPathNodeSetMergeAndClearNoDupls;
12044: break;
12045: case AXIS_DESCENDANT:
12046: last = NULL;
12047: next = xmlXPathNextDescendant;
12048: break;
12049: case AXIS_DESCENDANT_OR_SELF:
12050: last = NULL;
12051: next = xmlXPathNextDescendantOrSelf;
12052: break;
12053: case AXIS_FOLLOWING:
12054: last = NULL;
12055: next = xmlXPathNextFollowing;
12056: break;
12057: case AXIS_FOLLOWING_SIBLING:
12058: last = NULL;
12059: next = xmlXPathNextFollowingSibling;
12060: break;
12061: case AXIS_NAMESPACE:
12062: first = NULL;
12063: last = NULL;
12064: next = (xmlXPathTraversalFunction) xmlXPathNextNamespace;
12065: mergeAndClear = xmlXPathNodeSetMergeAndClearNoDupls;
12066: break;
12067: case AXIS_PARENT:
12068: first = NULL;
12069: next = xmlXPathNextParent;
12070: break;
12071: case AXIS_PRECEDING:
12072: first = NULL;
12073: next = xmlXPathNextPrecedingInternal;
12074: break;
12075: case AXIS_PRECEDING_SIBLING:
12076: first = NULL;
12077: next = xmlXPathNextPrecedingSibling;
12078: break;
12079: case AXIS_SELF:
12080: first = NULL;
12081: last = NULL;
12082: next = xmlXPathNextSelf;
12083: mergeAndClear = xmlXPathNodeSetMergeAndClearNoDupls;
12084: break;
12085: }
12086:
12087: #ifdef DEBUG_STEP
12088: xmlXPathDebugDumpStepAxis(op,
12089: (obj->nodesetval != NULL) ? obj->nodesetval->nodeNr : 0);
12090: #endif
12091:
12092: if (next == NULL) {
12093: xmlXPathReleaseObject(xpctxt, obj);
12094: return(0);
12095: }
12096: contextSeq = obj->nodesetval;
12097: if ((contextSeq == NULL) || (contextSeq->nodeNr <= 0)) {
12098: xmlXPathReleaseObject(xpctxt, obj);
12099: valuePush(ctxt, xmlXPathCacheWrapNodeSet(xpctxt, NULL));
12100: return(0);
12101: }
12102: /*
12103: * Predicate optimization ---------------------------------------------
12104: * If this step has a last predicate, which contains a position(),
12105: * then we'll optimize (although not exactly "position()", but only
12106: * the short-hand form, i.e., "[n]".
12107: *
12108: * Example - expression "/foo[parent::bar][1]":
12109: *
12110: * COLLECT 'child' 'name' 'node' foo -- op (we are here)
12111: * ROOT -- op->ch1
12112: * PREDICATE -- op->ch2 (predOp)
12113: * PREDICATE -- predOp->ch1 = [parent::bar]
12114: * SORT
12115: * COLLECT 'parent' 'name' 'node' bar
12116: * NODE
12117: * ELEM Object is a number : 1 -- predOp->ch2 = [1]
12118: *
12119: */
12120: maxPos = 0;
12121: predOp = NULL;
12122: hasPredicateRange = 0;
12123: hasAxisRange = 0;
12124: if (op->ch2 != -1) {
12125: /*
12126: * There's at least one predicate. 16 == XPATH_OP_PREDICATE
12127: */
12128: predOp = &ctxt->comp->steps[op->ch2];
12129: if (xmlXPathIsPositionalPredicate(ctxt, predOp, &maxPos)) {
12130: if (predOp->ch1 != -1) {
12131: /*
12132: * Use the next inner predicate operator.
12133: */
12134: predOp = &ctxt->comp->steps[predOp->ch1];
12135: hasPredicateRange = 1;
12136: } else {
12137: /*
12138: * There's no other predicate than the [n] predicate.
12139: */
12140: predOp = NULL;
12141: hasAxisRange = 1;
12142: }
12143: }
12144: }
12145: breakOnFirstHit = ((toBool) && (predOp == NULL)) ? 1 : 0;
12146: /*
12147: * Axis traversal -----------------------------------------------------
12148: */
12149: /*
12150: * 2.3 Node Tests
12151: * - For the attribute axis, the principal node type is attribute.
12152: * - For the namespace axis, the principal node type is namespace.
12153: * - For other axes, the principal node type is element.
12154: *
12155: * A node test * is true for any node of the
12156: * principal node type. For example, child::* will
12157: * select all element children of the context node
12158: */
12159: oldContextNode = xpctxt->node;
12160: addNode = xmlXPathNodeSetAddUnique;
12161: outSeq = NULL;
12162: seq = NULL;
12163: outerContextNode = NULL;
12164: contextNode = NULL;
12165: contextIdx = 0;
12166:
12167:
12168: while ((contextIdx < contextSeq->nodeNr) || (contextNode != NULL)) {
12169: if (outerNext != NULL) {
12170: /*
12171: * This is a compound traversal.
12172: */
12173: if (contextNode == NULL) {
12174: /*
12175: * Set the context for the outer traversal.
12176: */
12177: outerContextNode = contextSeq->nodeTab[contextIdx++];
12178: contextNode = outerNext(NULL, outerContextNode);
12179: } else
12180: contextNode = outerNext(contextNode, outerContextNode);
12181: if (contextNode == NULL)
12182: continue;
12183: /*
12184: * Set the context for the main traversal.
12185: */
12186: xpctxt->node = contextNode;
12187: } else
12188: xpctxt->node = contextSeq->nodeTab[contextIdx++];
12189:
12190: if (seq == NULL) {
12191: seq = xmlXPathNodeSetCreate(NULL);
12192: if (seq == NULL) {
12193: total = 0;
12194: goto error;
12195: }
12196: }
12197: /*
12198: * Traverse the axis and test the nodes.
12199: */
12200: pos = 0;
12201: cur = NULL;
12202: hasNsNodes = 0;
12203: do {
12204: cur = next(ctxt, cur);
12205: if (cur == NULL)
12206: break;
12207:
12208: /*
12209: * QUESTION TODO: What does the "first" and "last" stuff do?
12210: */
12211: if ((first != NULL) && (*first != NULL)) {
12212: if (*first == cur)
12213: break;
12214: if (((total % 256) == 0) &&
12215: #ifdef XP_OPTIMIZED_NON_ELEM_COMPARISON
12216: (xmlXPathCmpNodesExt(*first, cur) >= 0))
12217: #else
12218: (xmlXPathCmpNodes(*first, cur) >= 0))
12219: #endif
12220: {
12221: break;
12222: }
12223: }
12224: if ((last != NULL) && (*last != NULL)) {
12225: if (*last == cur)
12226: break;
12227: if (((total % 256) == 0) &&
12228: #ifdef XP_OPTIMIZED_NON_ELEM_COMPARISON
12229: (xmlXPathCmpNodesExt(cur, *last) >= 0))
12230: #else
12231: (xmlXPathCmpNodes(cur, *last) >= 0))
12232: #endif
12233: {
12234: break;
12235: }
12236: }
12237:
12238: total++;
12239:
12240: #ifdef DEBUG_STEP
12241: xmlGenericError(xmlGenericErrorContext, " %s", cur->name);
12242: #endif
12243:
12244: switch (test) {
12245: case NODE_TEST_NONE:
12246: total = 0;
12247: STRANGE
12248: goto error;
12249: case NODE_TEST_TYPE:
12250: /*
12251: * TODO: Don't we need to use
12252: * xmlXPathNodeSetAddNs() for namespace nodes here?
12253: * Surprisingly, some c14n tests fail, if we do this.
12254: */
12255: if (type == NODE_TYPE_NODE) {
12256: switch (cur->type) {
12257: case XML_DOCUMENT_NODE:
12258: case XML_HTML_DOCUMENT_NODE:
12259: #ifdef LIBXML_DOCB_ENABLED
12260: case XML_DOCB_DOCUMENT_NODE:
12261: #endif
12262: case XML_ELEMENT_NODE:
12263: case XML_ATTRIBUTE_NODE:
12264: case XML_PI_NODE:
12265: case XML_COMMENT_NODE:
12266: case XML_CDATA_SECTION_NODE:
12267: case XML_TEXT_NODE:
12268: case XML_NAMESPACE_DECL:
12269: XP_TEST_HIT
12270: break;
12271: default:
12272: break;
12273: }
12274: } else if (cur->type == type) {
12275: if (type == XML_NAMESPACE_DECL)
12276: XP_TEST_HIT_NS
12277: else
12278: XP_TEST_HIT
12279: } else if ((type == NODE_TYPE_TEXT) &&
12280: (cur->type == XML_CDATA_SECTION_NODE))
12281: {
12282: XP_TEST_HIT
12283: }
12284: break;
12285: case NODE_TEST_PI:
12286: if ((cur->type == XML_PI_NODE) &&
12287: ((name == NULL) || xmlStrEqual(name, cur->name)))
12288: {
12289: XP_TEST_HIT
12290: }
12291: break;
12292: case NODE_TEST_ALL:
12293: if (axis == AXIS_ATTRIBUTE) {
12294: if (cur->type == XML_ATTRIBUTE_NODE)
12295: {
12296: XP_TEST_HIT
12297: }
12298: } else if (axis == AXIS_NAMESPACE) {
12299: if (cur->type == XML_NAMESPACE_DECL)
12300: {
12301: XP_TEST_HIT_NS
12302: }
12303: } else {
12304: if (cur->type == XML_ELEMENT_NODE) {
12305: if (prefix == NULL)
12306: {
12307: XP_TEST_HIT
12308:
12309: } else if ((cur->ns != NULL) &&
12310: (xmlStrEqual(URI, cur->ns->href)))
12311: {
12312: XP_TEST_HIT
12313: }
12314: }
12315: }
12316: break;
12317: case NODE_TEST_NS:{
12318: TODO;
12319: break;
12320: }
12321: case NODE_TEST_NAME:
12322: if (axis == AXIS_ATTRIBUTE) {
12323: if (cur->type != XML_ATTRIBUTE_NODE)
12324: break;
12325: } else if (axis == AXIS_NAMESPACE) {
12326: if (cur->type != XML_NAMESPACE_DECL)
12327: break;
12328: } else {
12329: if (cur->type != XML_ELEMENT_NODE)
12330: break;
12331: }
12332: switch (cur->type) {
12333: case XML_ELEMENT_NODE:
12334: if (xmlStrEqual(name, cur->name)) {
12335: if (prefix == NULL) {
12336: if (cur->ns == NULL)
12337: {
12338: XP_TEST_HIT
12339: }
12340: } else {
12341: if ((cur->ns != NULL) &&
12342: (xmlStrEqual(URI, cur->ns->href)))
12343: {
12344: XP_TEST_HIT
12345: }
12346: }
12347: }
12348: break;
12349: case XML_ATTRIBUTE_NODE:{
12350: xmlAttrPtr attr = (xmlAttrPtr) cur;
12351:
12352: if (xmlStrEqual(name, attr->name)) {
12353: if (prefix == NULL) {
12354: if ((attr->ns == NULL) ||
12355: (attr->ns->prefix == NULL))
12356: {
12357: XP_TEST_HIT
12358: }
12359: } else {
12360: if ((attr->ns != NULL) &&
12361: (xmlStrEqual(URI,
12362: attr->ns->href)))
12363: {
12364: XP_TEST_HIT
12365: }
12366: }
12367: }
12368: break;
12369: }
12370: case XML_NAMESPACE_DECL:
12371: if (cur->type == XML_NAMESPACE_DECL) {
12372: xmlNsPtr ns = (xmlNsPtr) cur;
12373:
12374: if ((ns->prefix != NULL) && (name != NULL)
12375: && (xmlStrEqual(ns->prefix, name)))
12376: {
12377: XP_TEST_HIT_NS
12378: }
12379: }
12380: break;
12381: default:
12382: break;
12383: }
12384: break;
12385: } /* switch(test) */
12386: } while (cur != NULL);
12387:
12388: goto apply_predicates;
12389:
12390: axis_range_end: /* ----------------------------------------------------- */
12391: /*
12392: * We have a "/foo[n]", and position() = n was reached.
12393: * Note that we can have as well "/foo/::parent::foo[1]", so
12394: * a duplicate-aware merge is still needed.
12395: * Merge with the result.
12396: */
12397: if (outSeq == NULL) {
12398: outSeq = seq;
12399: seq = NULL;
12400: } else
12401: outSeq = mergeAndClear(outSeq, seq, 0);
12402: /*
12403: * Break if only a true/false result was requested.
12404: */
12405: if (toBool)
12406: break;
12407: continue;
12408:
12409: first_hit: /* ---------------------------------------------------------- */
12410: /*
12411: * Break if only a true/false result was requested and
12412: * no predicates existed and a node test succeeded.
12413: */
12414: if (outSeq == NULL) {
12415: outSeq = seq;
12416: seq = NULL;
12417: } else
12418: outSeq = mergeAndClear(outSeq, seq, 0);
12419: break;
12420:
12421: #ifdef DEBUG_STEP
12422: if (seq != NULL)
12423: nbMatches += seq->nodeNr;
12424: #endif
12425:
12426: apply_predicates: /* --------------------------------------------------- */
12427: /*
12428: * Apply predicates.
12429: */
12430: if ((predOp != NULL) && (seq->nodeNr > 0)) {
12431: /*
12432: * E.g. when we have a "/foo[some expression][n]".
12433: */
12434: /*
12435: * QUESTION TODO: The old predicate evaluation took into
12436: * account location-sets.
12437: * (E.g. ctxt->value->type == XPATH_LOCATIONSET)
12438: * Do we expect such a set here?
12439: * All what I learned now from the evaluation semantics
12440: * does not indicate that a location-set will be processed
12441: * here, so this looks OK.
12442: */
12443: /*
12444: * Iterate over all predicates, starting with the outermost
12445: * predicate.
12446: * TODO: Problem: we cannot execute the inner predicates first
12447: * since we cannot go back *up* the operator tree!
12448: * Options we have:
12449: * 1) Use of recursive functions (like is it currently done
12450: * via xmlXPathCompOpEval())
12451: * 2) Add a predicate evaluation information stack to the
12452: * context struct
12453: * 3) Change the way the operators are linked; we need a
12454: * "parent" field on xmlXPathStepOp
12455: *
12456: * For the moment, I'll try to solve this with a recursive
12457: * function: xmlXPathCompOpEvalPredicate().
12458: */
12459: size = seq->nodeNr;
12460: if (hasPredicateRange != 0)
12461: newSize = xmlXPathCompOpEvalPositionalPredicate(ctxt,
12462: predOp, seq, size, maxPos, maxPos, hasNsNodes);
12463: else
12464: newSize = xmlXPathCompOpEvalPredicate(ctxt,
12465: predOp, seq, size, hasNsNodes);
12466:
12467: if (ctxt->error != XPATH_EXPRESSION_OK) {
12468: total = 0;
12469: goto error;
12470: }
12471: /*
12472: * Add the filtered set of nodes to the result node set.
12473: */
12474: if (newSize == 0) {
12475: /*
12476: * The predicates filtered all nodes out.
12477: */
12478: xmlXPathNodeSetClear(seq, hasNsNodes);
12479: } else if (seq->nodeNr > 0) {
12480: /*
12481: * Add to result set.
12482: */
12483: if (outSeq == NULL) {
12484: if (size != newSize) {
12485: /*
12486: * We need to merge and clear here, since
12487: * the sequence will contained NULLed entries.
12488: */
12489: outSeq = mergeAndClear(NULL, seq, 1);
12490: } else {
12491: outSeq = seq;
12492: seq = NULL;
12493: }
12494: } else
12495: outSeq = mergeAndClear(outSeq, seq,
12496: (size != newSize) ? 1: 0);
12497: /*
12498: * Break if only a true/false result was requested.
12499: */
12500: if (toBool)
12501: break;
12502: }
12503: } else if (seq->nodeNr > 0) {
12504: /*
12505: * Add to result set.
12506: */
12507: if (outSeq == NULL) {
12508: outSeq = seq;
12509: seq = NULL;
12510: } else {
12511: outSeq = mergeAndClear(outSeq, seq, 0);
12512: }
12513: }
12514: }
12515:
12516: error:
12517: if ((obj->boolval) && (obj->user != NULL)) {
12518: /*
12519: * QUESTION TODO: What does this do and why?
12520: * TODO: Do we have to do this also for the "error"
12521: * cleanup further down?
12522: */
12523: ctxt->value->boolval = 1;
12524: ctxt->value->user = obj->user;
12525: obj->user = NULL;
12526: obj->boolval = 0;
12527: }
12528: xmlXPathReleaseObject(xpctxt, obj);
12529:
12530: /*
12531: * Ensure we return at least an emtpy set.
12532: */
12533: if (outSeq == NULL) {
12534: if ((seq != NULL) && (seq->nodeNr == 0))
12535: outSeq = seq;
12536: else
12537: outSeq = xmlXPathNodeSetCreate(NULL);
12538: /* XXX what if xmlXPathNodeSetCreate returned NULL here? */
12539: }
12540: if ((seq != NULL) && (seq != outSeq)) {
12541: xmlXPathFreeNodeSet(seq);
12542: }
12543: /*
12544: * Hand over the result. Better to push the set also in
12545: * case of errors.
12546: */
12547: valuePush(ctxt, xmlXPathCacheWrapNodeSet(xpctxt, outSeq));
12548: /*
12549: * Reset the context node.
12550: */
12551: xpctxt->node = oldContextNode;
12552:
12553: #ifdef DEBUG_STEP
12554: xmlGenericError(xmlGenericErrorContext,
12555: "\nExamined %d nodes, found %d nodes at that step\n",
12556: total, nbMatches);
12557: #endif
12558:
12559: return(total);
12560: }
12561:
12562: static int
12563: xmlXPathCompOpEvalFilterFirst(xmlXPathParserContextPtr ctxt,
12564: xmlXPathStepOpPtr op, xmlNodePtr * first);
12565:
12566: /**
12567: * xmlXPathCompOpEvalFirst:
12568: * @ctxt: the XPath parser context with the compiled expression
12569: * @op: an XPath compiled operation
12570: * @first: the first elem found so far
12571: *
12572: * Evaluate the Precompiled XPath operation searching only the first
12573: * element in document order
12574: *
12575: * Returns the number of examined objects.
12576: */
12577: static int
12578: xmlXPathCompOpEvalFirst(xmlXPathParserContextPtr ctxt,
12579: xmlXPathStepOpPtr op, xmlNodePtr * first)
12580: {
12581: int total = 0, cur;
12582: xmlXPathCompExprPtr comp;
12583: xmlXPathObjectPtr arg1, arg2;
12584:
12585: CHECK_ERROR0;
12586: comp = ctxt->comp;
12587: switch (op->op) {
12588: case XPATH_OP_END:
12589: return (0);
12590: case XPATH_OP_UNION:
12591: total =
12592: xmlXPathCompOpEvalFirst(ctxt, &comp->steps[op->ch1],
12593: first);
12594: CHECK_ERROR0;
12595: if ((ctxt->value != NULL)
12596: && (ctxt->value->type == XPATH_NODESET)
12597: && (ctxt->value->nodesetval != NULL)
12598: && (ctxt->value->nodesetval->nodeNr >= 1)) {
12599: /*
12600: * limit tree traversing to first node in the result
12601: */
12602: /*
12603: * OPTIMIZE TODO: This implicitely sorts
12604: * the result, even if not needed. E.g. if the argument
12605: * of the count() function, no sorting is needed.
12606: * OPTIMIZE TODO: How do we know if the node-list wasn't
12607: * aready sorted?
12608: */
12609: if (ctxt->value->nodesetval->nodeNr > 1)
12610: xmlXPathNodeSetSort(ctxt->value->nodesetval);
12611: *first = ctxt->value->nodesetval->nodeTab[0];
12612: }
12613: cur =
12614: xmlXPathCompOpEvalFirst(ctxt, &comp->steps[op->ch2],
12615: first);
12616: CHECK_ERROR0;
12617: CHECK_TYPE0(XPATH_NODESET);
12618: arg2 = valuePop(ctxt);
12619:
12620: CHECK_TYPE0(XPATH_NODESET);
12621: arg1 = valuePop(ctxt);
12622:
12623: arg1->nodesetval = xmlXPathNodeSetMerge(arg1->nodesetval,
12624: arg2->nodesetval);
12625: valuePush(ctxt, arg1);
12626: xmlXPathReleaseObject(ctxt->context, arg2);
12627: /* optimizer */
12628: if (total > cur)
12629: xmlXPathCompSwap(op);
12630: return (total + cur);
12631: case XPATH_OP_ROOT:
12632: xmlXPathRoot(ctxt);
12633: return (0);
12634: case XPATH_OP_NODE:
12635: if (op->ch1 != -1)
12636: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
12637: CHECK_ERROR0;
12638: if (op->ch2 != -1)
12639: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
12640: CHECK_ERROR0;
12641: valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context,
12642: ctxt->context->node));
12643: return (total);
12644: case XPATH_OP_RESET:
12645: if (op->ch1 != -1)
12646: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
12647: CHECK_ERROR0;
12648: if (op->ch2 != -1)
12649: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
12650: CHECK_ERROR0;
12651: ctxt->context->node = NULL;
12652: return (total);
12653: case XPATH_OP_COLLECT:{
12654: if (op->ch1 == -1)
12655: return (total);
12656:
12657: total = xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
12658: CHECK_ERROR0;
12659:
12660: total += xmlXPathNodeCollectAndTest(ctxt, op, first, NULL, 0);
12661: return (total);
12662: }
12663: case XPATH_OP_VALUE:
12664: valuePush(ctxt,
12665: xmlXPathCacheObjectCopy(ctxt->context,
12666: (xmlXPathObjectPtr) op->value4));
12667: return (0);
12668: case XPATH_OP_SORT:
12669: if (op->ch1 != -1)
12670: total +=
12671: xmlXPathCompOpEvalFirst(ctxt, &comp->steps[op->ch1],
12672: first);
12673: CHECK_ERROR0;
12674: if ((ctxt->value != NULL)
12675: && (ctxt->value->type == XPATH_NODESET)
12676: && (ctxt->value->nodesetval != NULL)
12677: && (ctxt->value->nodesetval->nodeNr > 1))
12678: xmlXPathNodeSetSort(ctxt->value->nodesetval);
12679: return (total);
12680: #ifdef XP_OPTIMIZED_FILTER_FIRST
12681: case XPATH_OP_FILTER:
12682: total += xmlXPathCompOpEvalFilterFirst(ctxt, op, first);
12683: return (total);
12684: #endif
12685: default:
12686: return (xmlXPathCompOpEval(ctxt, op));
12687: }
12688: }
12689:
12690: /**
12691: * xmlXPathCompOpEvalLast:
12692: * @ctxt: the XPath parser context with the compiled expression
12693: * @op: an XPath compiled operation
12694: * @last: the last elem found so far
12695: *
12696: * Evaluate the Precompiled XPath operation searching only the last
12697: * element in document order
12698: *
12699: * Returns the number of nodes traversed
12700: */
12701: static int
12702: xmlXPathCompOpEvalLast(xmlXPathParserContextPtr ctxt, xmlXPathStepOpPtr op,
12703: xmlNodePtr * last)
12704: {
12705: int total = 0, cur;
12706: xmlXPathCompExprPtr comp;
12707: xmlXPathObjectPtr arg1, arg2;
12708: xmlNodePtr bak;
12709: xmlDocPtr bakd;
12710: int pp;
12711: int cs;
12712:
12713: CHECK_ERROR0;
12714: comp = ctxt->comp;
12715: switch (op->op) {
12716: case XPATH_OP_END:
12717: return (0);
12718: case XPATH_OP_UNION:
12719: bakd = ctxt->context->doc;
12720: bak = ctxt->context->node;
12721: pp = ctxt->context->proximityPosition;
12722: cs = ctxt->context->contextSize;
12723: total =
12724: xmlXPathCompOpEvalLast(ctxt, &comp->steps[op->ch1], last);
12725: CHECK_ERROR0;
12726: if ((ctxt->value != NULL)
12727: && (ctxt->value->type == XPATH_NODESET)
12728: && (ctxt->value->nodesetval != NULL)
12729: && (ctxt->value->nodesetval->nodeNr >= 1)) {
12730: /*
12731: * limit tree traversing to first node in the result
12732: */
12733: if (ctxt->value->nodesetval->nodeNr > 1)
12734: xmlXPathNodeSetSort(ctxt->value->nodesetval);
12735: *last =
12736: ctxt->value->nodesetval->nodeTab[ctxt->value->
12737: nodesetval->nodeNr -
12738: 1];
12739: }
12740: ctxt->context->doc = bakd;
12741: ctxt->context->node = bak;
12742: ctxt->context->proximityPosition = pp;
12743: ctxt->context->contextSize = cs;
12744: cur =
12745: xmlXPathCompOpEvalLast(ctxt, &comp->steps[op->ch2], last);
12746: CHECK_ERROR0;
12747: if ((ctxt->value != NULL)
12748: && (ctxt->value->type == XPATH_NODESET)
12749: && (ctxt->value->nodesetval != NULL)
12750: && (ctxt->value->nodesetval->nodeNr >= 1)) { /* TODO: NOP ? */
12751: }
12752: CHECK_TYPE0(XPATH_NODESET);
12753: arg2 = valuePop(ctxt);
12754:
12755: CHECK_TYPE0(XPATH_NODESET);
12756: arg1 = valuePop(ctxt);
12757:
12758: arg1->nodesetval = xmlXPathNodeSetMerge(arg1->nodesetval,
12759: arg2->nodesetval);
12760: valuePush(ctxt, arg1);
12761: xmlXPathReleaseObject(ctxt->context, arg2);
12762: /* optimizer */
12763: if (total > cur)
12764: xmlXPathCompSwap(op);
12765: return (total + cur);
12766: case XPATH_OP_ROOT:
12767: xmlXPathRoot(ctxt);
12768: return (0);
12769: case XPATH_OP_NODE:
12770: if (op->ch1 != -1)
12771: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
12772: CHECK_ERROR0;
12773: if (op->ch2 != -1)
12774: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
12775: CHECK_ERROR0;
12776: valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context,
12777: ctxt->context->node));
12778: return (total);
12779: case XPATH_OP_RESET:
12780: if (op->ch1 != -1)
12781: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
12782: CHECK_ERROR0;
12783: if (op->ch2 != -1)
12784: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
12785: CHECK_ERROR0;
12786: ctxt->context->node = NULL;
12787: return (total);
12788: case XPATH_OP_COLLECT:{
12789: if (op->ch1 == -1)
12790: return (0);
12791:
12792: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
12793: CHECK_ERROR0;
12794:
12795: total += xmlXPathNodeCollectAndTest(ctxt, op, NULL, last, 0);
12796: return (total);
12797: }
12798: case XPATH_OP_VALUE:
12799: valuePush(ctxt,
12800: xmlXPathCacheObjectCopy(ctxt->context,
12801: (xmlXPathObjectPtr) op->value4));
12802: return (0);
12803: case XPATH_OP_SORT:
12804: if (op->ch1 != -1)
12805: total +=
12806: xmlXPathCompOpEvalLast(ctxt, &comp->steps[op->ch1],
12807: last);
12808: CHECK_ERROR0;
12809: if ((ctxt->value != NULL)
12810: && (ctxt->value->type == XPATH_NODESET)
12811: && (ctxt->value->nodesetval != NULL)
12812: && (ctxt->value->nodesetval->nodeNr > 1))
12813: xmlXPathNodeSetSort(ctxt->value->nodesetval);
12814: return (total);
12815: default:
12816: return (xmlXPathCompOpEval(ctxt, op));
12817: }
12818: }
12819:
12820: #ifdef XP_OPTIMIZED_FILTER_FIRST
12821: static int
12822: xmlXPathCompOpEvalFilterFirst(xmlXPathParserContextPtr ctxt,
12823: xmlXPathStepOpPtr op, xmlNodePtr * first)
12824: {
12825: int total = 0;
12826: xmlXPathCompExprPtr comp;
12827: xmlXPathObjectPtr res;
12828: xmlXPathObjectPtr obj;
12829: xmlNodeSetPtr oldset;
12830: xmlNodePtr oldnode;
12831: xmlDocPtr oldDoc;
12832: int i;
12833:
12834: CHECK_ERROR0;
12835: comp = ctxt->comp;
12836: /*
12837: * Optimization for ()[last()] selection i.e. the last elem
12838: */
12839: if ((op->ch1 != -1) && (op->ch2 != -1) &&
12840: (comp->steps[op->ch1].op == XPATH_OP_SORT) &&
12841: (comp->steps[op->ch2].op == XPATH_OP_SORT)) {
12842: int f = comp->steps[op->ch2].ch1;
12843:
12844: if ((f != -1) &&
12845: (comp->steps[f].op == XPATH_OP_FUNCTION) &&
12846: (comp->steps[f].value5 == NULL) &&
12847: (comp->steps[f].value == 0) &&
12848: (comp->steps[f].value4 != NULL) &&
12849: (xmlStrEqual
12850: (comp->steps[f].value4, BAD_CAST "last"))) {
12851: xmlNodePtr last = NULL;
12852:
12853: total +=
12854: xmlXPathCompOpEvalLast(ctxt,
12855: &comp->steps[op->ch1],
12856: &last);
12857: CHECK_ERROR0;
12858: /*
12859: * The nodeset should be in document order,
12860: * Keep only the last value
12861: */
12862: if ((ctxt->value != NULL) &&
12863: (ctxt->value->type == XPATH_NODESET) &&
12864: (ctxt->value->nodesetval != NULL) &&
12865: (ctxt->value->nodesetval->nodeTab != NULL) &&
12866: (ctxt->value->nodesetval->nodeNr > 1)) {
12867: ctxt->value->nodesetval->nodeTab[0] =
12868: ctxt->value->nodesetval->nodeTab[ctxt->
12869: value->
12870: nodesetval->
12871: nodeNr -
12872: 1];
12873: ctxt->value->nodesetval->nodeNr = 1;
12874: *first = *(ctxt->value->nodesetval->nodeTab);
12875: }
12876: return (total);
12877: }
12878: }
12879:
12880: if (op->ch1 != -1)
12881: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
12882: CHECK_ERROR0;
12883: if (op->ch2 == -1)
12884: return (total);
12885: if (ctxt->value == NULL)
12886: return (total);
12887:
12888: #ifdef LIBXML_XPTR_ENABLED
12889: oldnode = ctxt->context->node;
12890: /*
12891: * Hum are we filtering the result of an XPointer expression
12892: */
12893: if (ctxt->value->type == XPATH_LOCATIONSET) {
12894: xmlXPathObjectPtr tmp = NULL;
12895: xmlLocationSetPtr newlocset = NULL;
12896: xmlLocationSetPtr oldlocset;
12897:
12898: /*
12899: * Extract the old locset, and then evaluate the result of the
12900: * expression for all the element in the locset. use it to grow
12901: * up a new locset.
12902: */
12903: CHECK_TYPE0(XPATH_LOCATIONSET);
12904: obj = valuePop(ctxt);
12905: oldlocset = obj->user;
12906: ctxt->context->node = NULL;
12907:
12908: if ((oldlocset == NULL) || (oldlocset->locNr == 0)) {
12909: ctxt->context->contextSize = 0;
12910: ctxt->context->proximityPosition = 0;
12911: if (op->ch2 != -1)
12912: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
12913: res = valuePop(ctxt);
12914: if (res != NULL) {
12915: xmlXPathReleaseObject(ctxt->context, res);
12916: }
12917: valuePush(ctxt, obj);
12918: CHECK_ERROR0;
12919: return (total);
12920: }
12921: newlocset = xmlXPtrLocationSetCreate(NULL);
12922:
12923: for (i = 0; i < oldlocset->locNr; i++) {
12924: /*
12925: * Run the evaluation with a node list made of a
12926: * single item in the nodelocset.
12927: */
12928: ctxt->context->node = oldlocset->locTab[i]->user;
12929: ctxt->context->contextSize = oldlocset->locNr;
12930: ctxt->context->proximityPosition = i + 1;
12931: if (tmp == NULL) {
12932: tmp = xmlXPathCacheNewNodeSet(ctxt->context,
12933: ctxt->context->node);
12934: } else {
12935: xmlXPathNodeSetAddUnique(tmp->nodesetval,
12936: ctxt->context->node);
12937: }
12938: valuePush(ctxt, tmp);
12939: if (op->ch2 != -1)
12940: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
12941: if (ctxt->error != XPATH_EXPRESSION_OK) {
12942: xmlXPathFreeObject(obj);
12943: return(0);
12944: }
12945: /*
12946: * The result of the evaluation need to be tested to
12947: * decided whether the filter succeeded or not
12948: */
12949: res = valuePop(ctxt);
12950: if (xmlXPathEvaluatePredicateResult(ctxt, res)) {
12951: xmlXPtrLocationSetAdd(newlocset,
12952: xmlXPathCacheObjectCopy(ctxt->context,
12953: oldlocset->locTab[i]));
12954: }
12955: /*
12956: * Cleanup
12957: */
12958: if (res != NULL) {
12959: xmlXPathReleaseObject(ctxt->context, res);
12960: }
12961: if (ctxt->value == tmp) {
12962: valuePop(ctxt);
12963: xmlXPathNodeSetClear(tmp->nodesetval, 1);
12964: /*
12965: * REVISIT TODO: Don't create a temporary nodeset
12966: * for everly iteration.
12967: */
12968: /* OLD: xmlXPathFreeObject(res); */
12969: } else
12970: tmp = NULL;
12971: ctxt->context->node = NULL;
12972: /*
12973: * Only put the first node in the result, then leave.
12974: */
12975: if (newlocset->locNr > 0) {
12976: *first = (xmlNodePtr) oldlocset->locTab[i]->user;
12977: break;
12978: }
12979: }
12980: if (tmp != NULL) {
12981: xmlXPathReleaseObject(ctxt->context, tmp);
12982: }
12983: /*
12984: * The result is used as the new evaluation locset.
12985: */
12986: xmlXPathReleaseObject(ctxt->context, obj);
12987: ctxt->context->node = NULL;
12988: ctxt->context->contextSize = -1;
12989: ctxt->context->proximityPosition = -1;
12990: valuePush(ctxt, xmlXPtrWrapLocationSet(newlocset));
12991: ctxt->context->node = oldnode;
12992: return (total);
12993: }
12994: #endif /* LIBXML_XPTR_ENABLED */
12995:
12996: /*
12997: * Extract the old set, and then evaluate the result of the
12998: * expression for all the element in the set. use it to grow
12999: * up a new set.
13000: */
13001: CHECK_TYPE0(XPATH_NODESET);
13002: obj = valuePop(ctxt);
13003: oldset = obj->nodesetval;
13004:
13005: oldnode = ctxt->context->node;
13006: oldDoc = ctxt->context->doc;
13007: ctxt->context->node = NULL;
13008:
13009: if ((oldset == NULL) || (oldset->nodeNr == 0)) {
13010: ctxt->context->contextSize = 0;
13011: ctxt->context->proximityPosition = 0;
13012: /* QUESTION TODO: Why was this code commented out?
13013: if (op->ch2 != -1)
13014: total +=
13015: xmlXPathCompOpEval(ctxt,
13016: &comp->steps[op->ch2]);
13017: CHECK_ERROR0;
13018: res = valuePop(ctxt);
13019: if (res != NULL)
13020: xmlXPathFreeObject(res);
13021: */
13022: valuePush(ctxt, obj);
13023: ctxt->context->node = oldnode;
13024: CHECK_ERROR0;
13025: } else {
13026: xmlNodeSetPtr newset;
13027: xmlXPathObjectPtr tmp = NULL;
13028: /*
13029: * Initialize the new set.
13030: * Also set the xpath document in case things like
13031: * key() evaluation are attempted on the predicate
13032: */
13033: newset = xmlXPathNodeSetCreate(NULL);
13034: /* XXX what if xmlXPathNodeSetCreate returned NULL? */
13035:
13036: for (i = 0; i < oldset->nodeNr; i++) {
13037: /*
13038: * Run the evaluation with a node list made of
13039: * a single item in the nodeset.
13040: */
13041: ctxt->context->node = oldset->nodeTab[i];
13042: if ((oldset->nodeTab[i]->type != XML_NAMESPACE_DECL) &&
13043: (oldset->nodeTab[i]->doc != NULL))
13044: ctxt->context->doc = oldset->nodeTab[i]->doc;
13045: if (tmp == NULL) {
13046: tmp = xmlXPathCacheNewNodeSet(ctxt->context,
13047: ctxt->context->node);
13048: } else {
13049: xmlXPathNodeSetAddUnique(tmp->nodesetval,
13050: ctxt->context->node);
13051: }
13052: valuePush(ctxt, tmp);
13053: ctxt->context->contextSize = oldset->nodeNr;
13054: ctxt->context->proximityPosition = i + 1;
13055: if (op->ch2 != -1)
13056: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13057: if (ctxt->error != XPATH_EXPRESSION_OK) {
13058: xmlXPathFreeNodeSet(newset);
13059: xmlXPathFreeObject(obj);
13060: return(0);
13061: }
13062: /*
13063: * The result of the evaluation needs to be tested to
13064: * decide whether the filter succeeded or not
13065: */
13066: res = valuePop(ctxt);
13067: if (xmlXPathEvaluatePredicateResult(ctxt, res)) {
13068: xmlXPathNodeSetAdd(newset, oldset->nodeTab[i]);
13069: }
13070: /*
13071: * Cleanup
13072: */
13073: if (res != NULL) {
13074: xmlXPathReleaseObject(ctxt->context, res);
13075: }
13076: if (ctxt->value == tmp) {
13077: valuePop(ctxt);
13078: /*
13079: * Don't free the temporary nodeset
13080: * in order to avoid massive recreation inside this
13081: * loop.
13082: */
13083: xmlXPathNodeSetClear(tmp->nodesetval, 1);
13084: } else
13085: tmp = NULL;
13086: ctxt->context->node = NULL;
13087: /*
13088: * Only put the first node in the result, then leave.
13089: */
13090: if (newset->nodeNr > 0) {
13091: *first = *(newset->nodeTab);
13092: break;
13093: }
13094: }
13095: if (tmp != NULL) {
13096: xmlXPathReleaseObject(ctxt->context, tmp);
13097: }
13098: /*
13099: * The result is used as the new evaluation set.
13100: */
13101: xmlXPathReleaseObject(ctxt->context, obj);
13102: ctxt->context->node = NULL;
13103: ctxt->context->contextSize = -1;
13104: ctxt->context->proximityPosition = -1;
13105: /* may want to move this past the '}' later */
13106: ctxt->context->doc = oldDoc;
13107: valuePush(ctxt, xmlXPathCacheWrapNodeSet(ctxt->context, newset));
13108: }
13109: ctxt->context->node = oldnode;
13110: return(total);
13111: }
13112: #endif /* XP_OPTIMIZED_FILTER_FIRST */
13113:
13114: /**
13115: * xmlXPathCompOpEval:
13116: * @ctxt: the XPath parser context with the compiled expression
13117: * @op: an XPath compiled operation
13118: *
13119: * Evaluate the Precompiled XPath operation
13120: * Returns the number of nodes traversed
13121: */
13122: static int
13123: xmlXPathCompOpEval(xmlXPathParserContextPtr ctxt, xmlXPathStepOpPtr op)
13124: {
13125: int total = 0;
13126: int equal, ret;
13127: xmlXPathCompExprPtr comp;
13128: xmlXPathObjectPtr arg1, arg2;
13129: xmlNodePtr bak;
13130: xmlDocPtr bakd;
13131: int pp;
13132: int cs;
13133:
13134: CHECK_ERROR0;
13135: comp = ctxt->comp;
13136: switch (op->op) {
13137: case XPATH_OP_END:
13138: return (0);
13139: case XPATH_OP_AND:
13140: bakd = ctxt->context->doc;
13141: bak = ctxt->context->node;
13142: pp = ctxt->context->proximityPosition;
13143: cs = ctxt->context->contextSize;
13144: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13145: CHECK_ERROR0;
13146: xmlXPathBooleanFunction(ctxt, 1);
13147: if ((ctxt->value == NULL) || (ctxt->value->boolval == 0))
13148: return (total);
13149: arg2 = valuePop(ctxt);
13150: ctxt->context->doc = bakd;
13151: ctxt->context->node = bak;
13152: ctxt->context->proximityPosition = pp;
13153: ctxt->context->contextSize = cs;
13154: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13155: if (ctxt->error) {
13156: xmlXPathFreeObject(arg2);
13157: return(0);
13158: }
13159: xmlXPathBooleanFunction(ctxt, 1);
13160: arg1 = valuePop(ctxt);
13161: arg1->boolval &= arg2->boolval;
13162: valuePush(ctxt, arg1);
13163: xmlXPathReleaseObject(ctxt->context, arg2);
13164: return (total);
13165: case XPATH_OP_OR:
13166: bakd = ctxt->context->doc;
13167: bak = ctxt->context->node;
13168: pp = ctxt->context->proximityPosition;
13169: cs = ctxt->context->contextSize;
13170: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13171: CHECK_ERROR0;
13172: xmlXPathBooleanFunction(ctxt, 1);
13173: if ((ctxt->value == NULL) || (ctxt->value->boolval == 1))
13174: return (total);
13175: arg2 = valuePop(ctxt);
13176: ctxt->context->doc = bakd;
13177: ctxt->context->node = bak;
13178: ctxt->context->proximityPosition = pp;
13179: ctxt->context->contextSize = cs;
13180: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13181: if (ctxt->error) {
13182: xmlXPathFreeObject(arg2);
13183: return(0);
13184: }
13185: xmlXPathBooleanFunction(ctxt, 1);
13186: arg1 = valuePop(ctxt);
13187: arg1->boolval |= arg2->boolval;
13188: valuePush(ctxt, arg1);
13189: xmlXPathReleaseObject(ctxt->context, arg2);
13190: return (total);
13191: case XPATH_OP_EQUAL:
13192: bakd = ctxt->context->doc;
13193: bak = ctxt->context->node;
13194: pp = ctxt->context->proximityPosition;
13195: cs = ctxt->context->contextSize;
13196: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13197: CHECK_ERROR0;
13198: ctxt->context->doc = bakd;
13199: ctxt->context->node = bak;
13200: ctxt->context->proximityPosition = pp;
13201: ctxt->context->contextSize = cs;
13202: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13203: CHECK_ERROR0;
13204: if (op->value)
13205: equal = xmlXPathEqualValues(ctxt);
13206: else
13207: equal = xmlXPathNotEqualValues(ctxt);
13208: valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, equal));
13209: return (total);
13210: case XPATH_OP_CMP:
13211: bakd = ctxt->context->doc;
13212: bak = ctxt->context->node;
13213: pp = ctxt->context->proximityPosition;
13214: cs = ctxt->context->contextSize;
13215: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13216: CHECK_ERROR0;
13217: ctxt->context->doc = bakd;
13218: ctxt->context->node = bak;
13219: ctxt->context->proximityPosition = pp;
13220: ctxt->context->contextSize = cs;
13221: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13222: CHECK_ERROR0;
13223: ret = xmlXPathCompareValues(ctxt, op->value, op->value2);
13224: valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, ret));
13225: return (total);
13226: case XPATH_OP_PLUS:
13227: bakd = ctxt->context->doc;
13228: bak = ctxt->context->node;
13229: pp = ctxt->context->proximityPosition;
13230: cs = ctxt->context->contextSize;
13231: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13232: CHECK_ERROR0;
13233: if (op->ch2 != -1) {
13234: ctxt->context->doc = bakd;
13235: ctxt->context->node = bak;
13236: ctxt->context->proximityPosition = pp;
13237: ctxt->context->contextSize = cs;
13238: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13239: }
13240: CHECK_ERROR0;
13241: if (op->value == 0)
13242: xmlXPathSubValues(ctxt);
13243: else if (op->value == 1)
13244: xmlXPathAddValues(ctxt);
13245: else if (op->value == 2)
13246: xmlXPathValueFlipSign(ctxt);
13247: else if (op->value == 3) {
13248: CAST_TO_NUMBER;
13249: CHECK_TYPE0(XPATH_NUMBER);
13250: }
13251: return (total);
13252: case XPATH_OP_MULT:
13253: bakd = ctxt->context->doc;
13254: bak = ctxt->context->node;
13255: pp = ctxt->context->proximityPosition;
13256: cs = ctxt->context->contextSize;
13257: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13258: CHECK_ERROR0;
13259: ctxt->context->doc = bakd;
13260: ctxt->context->node = bak;
13261: ctxt->context->proximityPosition = pp;
13262: ctxt->context->contextSize = cs;
13263: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13264: CHECK_ERROR0;
13265: if (op->value == 0)
13266: xmlXPathMultValues(ctxt);
13267: else if (op->value == 1)
13268: xmlXPathDivValues(ctxt);
13269: else if (op->value == 2)
13270: xmlXPathModValues(ctxt);
13271: return (total);
13272: case XPATH_OP_UNION:
13273: bakd = ctxt->context->doc;
13274: bak = ctxt->context->node;
13275: pp = ctxt->context->proximityPosition;
13276: cs = ctxt->context->contextSize;
13277: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13278: CHECK_ERROR0;
13279: ctxt->context->doc = bakd;
13280: ctxt->context->node = bak;
13281: ctxt->context->proximityPosition = pp;
13282: ctxt->context->contextSize = cs;
13283: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13284: CHECK_ERROR0;
13285: CHECK_TYPE0(XPATH_NODESET);
13286: arg2 = valuePop(ctxt);
13287:
13288: CHECK_TYPE0(XPATH_NODESET);
13289: arg1 = valuePop(ctxt);
13290:
13291: if ((arg1->nodesetval == NULL) ||
13292: ((arg2->nodesetval != NULL) &&
13293: (arg2->nodesetval->nodeNr != 0)))
13294: {
13295: arg1->nodesetval = xmlXPathNodeSetMerge(arg1->nodesetval,
13296: arg2->nodesetval);
13297: }
13298:
13299: valuePush(ctxt, arg1);
13300: xmlXPathReleaseObject(ctxt->context, arg2);
13301: return (total);
13302: case XPATH_OP_ROOT:
13303: xmlXPathRoot(ctxt);
13304: return (total);
13305: case XPATH_OP_NODE:
13306: if (op->ch1 != -1)
13307: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13308: CHECK_ERROR0;
13309: if (op->ch2 != -1)
13310: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13311: CHECK_ERROR0;
13312: valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context,
13313: ctxt->context->node));
13314: return (total);
13315: case XPATH_OP_RESET:
13316: if (op->ch1 != -1)
13317: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13318: CHECK_ERROR0;
13319: if (op->ch2 != -1)
13320: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13321: CHECK_ERROR0;
13322: ctxt->context->node = NULL;
13323: return (total);
13324: case XPATH_OP_COLLECT:{
13325: if (op->ch1 == -1)
13326: return (total);
13327:
13328: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13329: CHECK_ERROR0;
13330:
13331: total += xmlXPathNodeCollectAndTest(ctxt, op, NULL, NULL, 0);
13332: return (total);
13333: }
13334: case XPATH_OP_VALUE:
13335: valuePush(ctxt,
13336: xmlXPathCacheObjectCopy(ctxt->context,
13337: (xmlXPathObjectPtr) op->value4));
13338: return (total);
13339: case XPATH_OP_VARIABLE:{
13340: xmlXPathObjectPtr val;
13341:
13342: if (op->ch1 != -1)
13343: total +=
13344: xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13345: if (op->value5 == NULL) {
13346: val = xmlXPathVariableLookup(ctxt->context, op->value4);
13347: if (val == NULL) {
13348: ctxt->error = XPATH_UNDEF_VARIABLE_ERROR;
13349: return(0);
13350: }
13351: valuePush(ctxt, val);
13352: } else {
13353: const xmlChar *URI;
13354:
13355: URI = xmlXPathNsLookup(ctxt->context, op->value5);
13356: if (URI == NULL) {
13357: xmlGenericError(xmlGenericErrorContext,
13358: "xmlXPathCompOpEval: variable %s bound to undefined prefix %s\n",
13359: (char *) op->value4, (char *)op->value5);
13360: return (total);
13361: }
13362: val = xmlXPathVariableLookupNS(ctxt->context,
13363: op->value4, URI);
13364: if (val == NULL) {
13365: ctxt->error = XPATH_UNDEF_VARIABLE_ERROR;
13366: return(0);
13367: }
13368: valuePush(ctxt, val);
13369: }
13370: return (total);
13371: }
13372: case XPATH_OP_FUNCTION:{
13373: xmlXPathFunction func;
13374: const xmlChar *oldFunc, *oldFuncURI;
13375: int i;
13376:
13377: if (op->ch1 != -1)
13378: total +=
13379: xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13380: if (ctxt->valueNr < op->value) {
13381: xmlGenericError(xmlGenericErrorContext,
13382: "xmlXPathCompOpEval: parameter error\n");
13383: ctxt->error = XPATH_INVALID_OPERAND;
13384: return (total);
13385: }
13386: for (i = 0; i < op->value; i++)
13387: if (ctxt->valueTab[(ctxt->valueNr - 1) - i] == NULL) {
13388: xmlGenericError(xmlGenericErrorContext,
13389: "xmlXPathCompOpEval: parameter error\n");
13390: ctxt->error = XPATH_INVALID_OPERAND;
13391: return (total);
13392: }
13393: if (op->cache != NULL)
13394: XML_CAST_FPTR(func) = op->cache;
13395: else {
13396: const xmlChar *URI = NULL;
13397:
13398: if (op->value5 == NULL)
13399: func =
13400: xmlXPathFunctionLookup(ctxt->context,
13401: op->value4);
13402: else {
13403: URI = xmlXPathNsLookup(ctxt->context, op->value5);
13404: if (URI == NULL) {
13405: xmlGenericError(xmlGenericErrorContext,
13406: "xmlXPathCompOpEval: function %s bound to undefined prefix %s\n",
13407: (char *)op->value4, (char *)op->value5);
13408: return (total);
13409: }
13410: func = xmlXPathFunctionLookupNS(ctxt->context,
13411: op->value4, URI);
13412: }
13413: if (func == NULL) {
13414: xmlGenericError(xmlGenericErrorContext,
13415: "xmlXPathCompOpEval: function %s not found\n",
13416: (char *)op->value4);
13417: XP_ERROR0(XPATH_UNKNOWN_FUNC_ERROR);
13418: }
13419: op->cache = XML_CAST_FPTR(func);
13420: op->cacheURI = (void *) URI;
13421: }
13422: oldFunc = ctxt->context->function;
13423: oldFuncURI = ctxt->context->functionURI;
13424: ctxt->context->function = op->value4;
13425: ctxt->context->functionURI = op->cacheURI;
13426: func(ctxt, op->value);
13427: ctxt->context->function = oldFunc;
13428: ctxt->context->functionURI = oldFuncURI;
13429: return (total);
13430: }
13431: case XPATH_OP_ARG:
13432: bakd = ctxt->context->doc;
13433: bak = ctxt->context->node;
13434: pp = ctxt->context->proximityPosition;
13435: cs = ctxt->context->contextSize;
13436: if (op->ch1 != -1)
13437: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13438: ctxt->context->contextSize = cs;
13439: ctxt->context->proximityPosition = pp;
13440: ctxt->context->node = bak;
13441: ctxt->context->doc = bakd;
13442: CHECK_ERROR0;
13443: if (op->ch2 != -1) {
13444: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13445: ctxt->context->doc = bakd;
13446: ctxt->context->node = bak;
13447: CHECK_ERROR0;
13448: }
13449: return (total);
13450: case XPATH_OP_PREDICATE:
13451: case XPATH_OP_FILTER:{
13452: xmlXPathObjectPtr res;
13453: xmlXPathObjectPtr obj, tmp;
13454: xmlNodeSetPtr newset = NULL;
13455: xmlNodeSetPtr oldset;
13456: xmlNodePtr oldnode;
13457: xmlDocPtr oldDoc;
13458: int i;
13459:
13460: /*
13461: * Optimization for ()[1] selection i.e. the first elem
13462: */
13463: if ((op->ch1 != -1) && (op->ch2 != -1) &&
13464: #ifdef XP_OPTIMIZED_FILTER_FIRST
13465: /*
13466: * FILTER TODO: Can we assume that the inner processing
13467: * will result in an ordered list if we have an
13468: * XPATH_OP_FILTER?
13469: * What about an additional field or flag on
13470: * xmlXPathObject like @sorted ? This way we wouln'd need
13471: * to assume anything, so it would be more robust and
13472: * easier to optimize.
13473: */
13474: ((comp->steps[op->ch1].op == XPATH_OP_SORT) || /* 18 */
13475: (comp->steps[op->ch1].op == XPATH_OP_FILTER)) && /* 17 */
13476: #else
13477: (comp->steps[op->ch1].op == XPATH_OP_SORT) &&
13478: #endif
13479: (comp->steps[op->ch2].op == XPATH_OP_VALUE)) { /* 12 */
13480: xmlXPathObjectPtr val;
13481:
13482: val = comp->steps[op->ch2].value4;
13483: if ((val != NULL) && (val->type == XPATH_NUMBER) &&
13484: (val->floatval == 1.0)) {
13485: xmlNodePtr first = NULL;
13486:
13487: total +=
13488: xmlXPathCompOpEvalFirst(ctxt,
13489: &comp->steps[op->ch1],
13490: &first);
13491: CHECK_ERROR0;
13492: /*
13493: * The nodeset should be in document order,
13494: * Keep only the first value
13495: */
13496: if ((ctxt->value != NULL) &&
13497: (ctxt->value->type == XPATH_NODESET) &&
13498: (ctxt->value->nodesetval != NULL) &&
13499: (ctxt->value->nodesetval->nodeNr > 1))
13500: ctxt->value->nodesetval->nodeNr = 1;
13501: return (total);
13502: }
13503: }
13504: /*
13505: * Optimization for ()[last()] selection i.e. the last elem
13506: */
13507: if ((op->ch1 != -1) && (op->ch2 != -1) &&
13508: (comp->steps[op->ch1].op == XPATH_OP_SORT) &&
13509: (comp->steps[op->ch2].op == XPATH_OP_SORT)) {
13510: int f = comp->steps[op->ch2].ch1;
13511:
13512: if ((f != -1) &&
13513: (comp->steps[f].op == XPATH_OP_FUNCTION) &&
13514: (comp->steps[f].value5 == NULL) &&
13515: (comp->steps[f].value == 0) &&
13516: (comp->steps[f].value4 != NULL) &&
13517: (xmlStrEqual
13518: (comp->steps[f].value4, BAD_CAST "last"))) {
13519: xmlNodePtr last = NULL;
13520:
13521: total +=
13522: xmlXPathCompOpEvalLast(ctxt,
13523: &comp->steps[op->ch1],
13524: &last);
13525: CHECK_ERROR0;
13526: /*
13527: * The nodeset should be in document order,
13528: * Keep only the last value
13529: */
13530: if ((ctxt->value != NULL) &&
13531: (ctxt->value->type == XPATH_NODESET) &&
13532: (ctxt->value->nodesetval != NULL) &&
13533: (ctxt->value->nodesetval->nodeTab != NULL) &&
13534: (ctxt->value->nodesetval->nodeNr > 1)) {
13535: ctxt->value->nodesetval->nodeTab[0] =
13536: ctxt->value->nodesetval->nodeTab[ctxt->
13537: value->
13538: nodesetval->
13539: nodeNr -
13540: 1];
13541: ctxt->value->nodesetval->nodeNr = 1;
13542: }
13543: return (total);
13544: }
13545: }
13546: /*
13547: * Process inner predicates first.
13548: * Example "index[parent::book][1]":
13549: * ...
13550: * PREDICATE <-- we are here "[1]"
13551: * PREDICATE <-- process "[parent::book]" first
13552: * SORT
13553: * COLLECT 'parent' 'name' 'node' book
13554: * NODE
13555: * ELEM Object is a number : 1
13556: */
13557: if (op->ch1 != -1)
13558: total +=
13559: xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13560: CHECK_ERROR0;
13561: if (op->ch2 == -1)
13562: return (total);
13563: if (ctxt->value == NULL)
13564: return (total);
13565:
13566: oldnode = ctxt->context->node;
13567:
13568: #ifdef LIBXML_XPTR_ENABLED
13569: /*
13570: * Hum are we filtering the result of an XPointer expression
13571: */
13572: if (ctxt->value->type == XPATH_LOCATIONSET) {
13573: xmlLocationSetPtr newlocset = NULL;
13574: xmlLocationSetPtr oldlocset;
13575:
13576: /*
13577: * Extract the old locset, and then evaluate the result of the
13578: * expression for all the element in the locset. use it to grow
13579: * up a new locset.
13580: */
13581: CHECK_TYPE0(XPATH_LOCATIONSET);
13582: obj = valuePop(ctxt);
13583: oldlocset = obj->user;
13584: ctxt->context->node = NULL;
13585:
13586: if ((oldlocset == NULL) || (oldlocset->locNr == 0)) {
13587: ctxt->context->contextSize = 0;
13588: ctxt->context->proximityPosition = 0;
13589: if (op->ch2 != -1)
13590: total +=
13591: xmlXPathCompOpEval(ctxt,
13592: &comp->steps[op->ch2]);
13593: res = valuePop(ctxt);
13594: if (res != NULL) {
13595: xmlXPathReleaseObject(ctxt->context, res);
13596: }
13597: valuePush(ctxt, obj);
13598: CHECK_ERROR0;
13599: return (total);
13600: }
13601: newlocset = xmlXPtrLocationSetCreate(NULL);
13602:
13603: for (i = 0; i < oldlocset->locNr; i++) {
13604: /*
13605: * Run the evaluation with a node list made of a
13606: * single item in the nodelocset.
13607: */
13608: ctxt->context->node = oldlocset->locTab[i]->user;
13609: ctxt->context->contextSize = oldlocset->locNr;
13610: ctxt->context->proximityPosition = i + 1;
13611: tmp = xmlXPathCacheNewNodeSet(ctxt->context,
13612: ctxt->context->node);
13613: valuePush(ctxt, tmp);
13614:
13615: if (op->ch2 != -1)
13616: total +=
13617: xmlXPathCompOpEval(ctxt,
13618: &comp->steps[op->ch2]);
13619: if (ctxt->error != XPATH_EXPRESSION_OK) {
13620: xmlXPathFreeObject(obj);
13621: return(0);
13622: }
13623:
13624: /*
13625: * The result of the evaluation need to be tested to
13626: * decided whether the filter succeeded or not
13627: */
13628: res = valuePop(ctxt);
13629: if (xmlXPathEvaluatePredicateResult(ctxt, res)) {
13630: xmlXPtrLocationSetAdd(newlocset,
13631: xmlXPathObjectCopy
13632: (oldlocset->locTab[i]));
13633: }
13634:
13635: /*
13636: * Cleanup
13637: */
13638: if (res != NULL) {
13639: xmlXPathReleaseObject(ctxt->context, res);
13640: }
13641: if (ctxt->value == tmp) {
13642: res = valuePop(ctxt);
13643: xmlXPathReleaseObject(ctxt->context, res);
13644: }
13645:
13646: ctxt->context->node = NULL;
13647: }
13648:
13649: /*
13650: * The result is used as the new evaluation locset.
13651: */
13652: xmlXPathReleaseObject(ctxt->context, obj);
13653: ctxt->context->node = NULL;
13654: ctxt->context->contextSize = -1;
13655: ctxt->context->proximityPosition = -1;
13656: valuePush(ctxt, xmlXPtrWrapLocationSet(newlocset));
13657: ctxt->context->node = oldnode;
13658: return (total);
13659: }
13660: #endif /* LIBXML_XPTR_ENABLED */
13661:
13662: /*
13663: * Extract the old set, and then evaluate the result of the
13664: * expression for all the element in the set. use it to grow
13665: * up a new set.
13666: */
13667: CHECK_TYPE0(XPATH_NODESET);
13668: obj = valuePop(ctxt);
13669: oldset = obj->nodesetval;
13670:
13671: oldnode = ctxt->context->node;
13672: oldDoc = ctxt->context->doc;
13673: ctxt->context->node = NULL;
13674:
13675: if ((oldset == NULL) || (oldset->nodeNr == 0)) {
13676: ctxt->context->contextSize = 0;
13677: ctxt->context->proximityPosition = 0;
13678: /*
13679: if (op->ch2 != -1)
13680: total +=
13681: xmlXPathCompOpEval(ctxt,
13682: &comp->steps[op->ch2]);
13683: CHECK_ERROR0;
13684: res = valuePop(ctxt);
13685: if (res != NULL)
13686: xmlXPathFreeObject(res);
13687: */
13688: valuePush(ctxt, obj);
13689: ctxt->context->node = oldnode;
13690: CHECK_ERROR0;
13691: } else {
13692: tmp = NULL;
13693: /*
13694: * Initialize the new set.
13695: * Also set the xpath document in case things like
13696: * key() evaluation are attempted on the predicate
13697: */
13698: newset = xmlXPathNodeSetCreate(NULL);
13699: /*
13700: * SPEC XPath 1.0:
13701: * "For each node in the node-set to be filtered, the
13702: * PredicateExpr is evaluated with that node as the
13703: * context node, with the number of nodes in the
13704: * node-set as the context size, and with the proximity
13705: * position of the node in the node-set with respect to
13706: * the axis as the context position;"
13707: * @oldset is the node-set" to be filtered.
13708: *
13709: * SPEC XPath 1.0:
13710: * "only predicates change the context position and
13711: * context size (see [2.4 Predicates])."
13712: * Example:
13713: * node-set context pos
13714: * nA 1
13715: * nB 2
13716: * nC 3
13717: * After applying predicate [position() > 1] :
13718: * node-set context pos
13719: * nB 1
13720: * nC 2
13721: *
13722: * removed the first node in the node-set, then
13723: * the context position of the
13724: */
13725: for (i = 0; i < oldset->nodeNr; i++) {
13726: /*
13727: * Run the evaluation with a node list made of
13728: * a single item in the nodeset.
13729: */
13730: ctxt->context->node = oldset->nodeTab[i];
13731: if ((oldset->nodeTab[i]->type != XML_NAMESPACE_DECL) &&
13732: (oldset->nodeTab[i]->doc != NULL))
13733: ctxt->context->doc = oldset->nodeTab[i]->doc;
13734: if (tmp == NULL) {
13735: tmp = xmlXPathCacheNewNodeSet(ctxt->context,
13736: ctxt->context->node);
13737: } else {
13738: xmlXPathNodeSetAddUnique(tmp->nodesetval,
13739: ctxt->context->node);
13740: }
13741: valuePush(ctxt, tmp);
13742: ctxt->context->contextSize = oldset->nodeNr;
13743: ctxt->context->proximityPosition = i + 1;
13744: /*
13745: * Evaluate the predicate against the context node.
13746: * Can/should we optimize position() predicates
13747: * here (e.g. "[1]")?
13748: */
13749: if (op->ch2 != -1)
13750: total +=
13751: xmlXPathCompOpEval(ctxt,
13752: &comp->steps[op->ch2]);
13753: if (ctxt->error != XPATH_EXPRESSION_OK) {
13754: xmlXPathFreeNodeSet(newset);
13755: xmlXPathFreeObject(obj);
13756: return(0);
13757: }
13758:
13759: /*
13760: * The result of the evaluation needs to be tested to
13761: * decide whether the filter succeeded or not
13762: */
13763: /*
13764: * OPTIMIZE TODO: Can we use
13765: * xmlXPathNodeSetAdd*Unique()* instead?
13766: */
13767: res = valuePop(ctxt);
13768: if (xmlXPathEvaluatePredicateResult(ctxt, res)) {
13769: xmlXPathNodeSetAdd(newset, oldset->nodeTab[i]);
13770: }
13771:
13772: /*
13773: * Cleanup
13774: */
13775: if (res != NULL) {
13776: xmlXPathReleaseObject(ctxt->context, res);
13777: }
13778: if (ctxt->value == tmp) {
13779: valuePop(ctxt);
13780: xmlXPathNodeSetClear(tmp->nodesetval, 1);
13781: /*
13782: * Don't free the temporary nodeset
13783: * in order to avoid massive recreation inside this
13784: * loop.
13785: */
13786: } else
13787: tmp = NULL;
13788: ctxt->context->node = NULL;
13789: }
13790: if (tmp != NULL)
13791: xmlXPathReleaseObject(ctxt->context, tmp);
13792: /*
13793: * The result is used as the new evaluation set.
13794: */
13795: xmlXPathReleaseObject(ctxt->context, obj);
13796: ctxt->context->node = NULL;
13797: ctxt->context->contextSize = -1;
13798: ctxt->context->proximityPosition = -1;
13799: /* may want to move this past the '}' later */
13800: ctxt->context->doc = oldDoc;
13801: valuePush(ctxt,
13802: xmlXPathCacheWrapNodeSet(ctxt->context, newset));
13803: }
13804: ctxt->context->node = oldnode;
13805: return (total);
13806: }
13807: case XPATH_OP_SORT:
13808: if (op->ch1 != -1)
13809: total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13810: CHECK_ERROR0;
13811: if ((ctxt->value != NULL) &&
13812: (ctxt->value->type == XPATH_NODESET) &&
13813: (ctxt->value->nodesetval != NULL) &&
13814: (ctxt->value->nodesetval->nodeNr > 1))
13815: {
13816: xmlXPathNodeSetSort(ctxt->value->nodesetval);
13817: }
13818: return (total);
13819: #ifdef LIBXML_XPTR_ENABLED
13820: case XPATH_OP_RANGETO:{
13821: xmlXPathObjectPtr range;
13822: xmlXPathObjectPtr res, obj;
13823: xmlXPathObjectPtr tmp;
13824: xmlLocationSetPtr newlocset = NULL;
13825: xmlLocationSetPtr oldlocset;
13826: xmlNodeSetPtr oldset;
13827: int i, j;
13828:
13829: if (op->ch1 != -1)
13830: total +=
13831: xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13832: if (op->ch2 == -1)
13833: return (total);
13834:
13835: if (ctxt->value->type == XPATH_LOCATIONSET) {
13836: /*
13837: * Extract the old locset, and then evaluate the result of the
13838: * expression for all the element in the locset. use it to grow
13839: * up a new locset.
13840: */
13841: CHECK_TYPE0(XPATH_LOCATIONSET);
13842: obj = valuePop(ctxt);
13843: oldlocset = obj->user;
13844:
13845: if ((oldlocset == NULL) || (oldlocset->locNr == 0)) {
13846: ctxt->context->node = NULL;
13847: ctxt->context->contextSize = 0;
13848: ctxt->context->proximityPosition = 0;
13849: total += xmlXPathCompOpEval(ctxt,&comp->steps[op->ch2]);
13850: res = valuePop(ctxt);
13851: if (res != NULL) {
13852: xmlXPathReleaseObject(ctxt->context, res);
13853: }
13854: valuePush(ctxt, obj);
13855: CHECK_ERROR0;
13856: return (total);
13857: }
13858: newlocset = xmlXPtrLocationSetCreate(NULL);
13859:
13860: for (i = 0; i < oldlocset->locNr; i++) {
13861: /*
13862: * Run the evaluation with a node list made of a
13863: * single item in the nodelocset.
13864: */
13865: ctxt->context->node = oldlocset->locTab[i]->user;
13866: ctxt->context->contextSize = oldlocset->locNr;
13867: ctxt->context->proximityPosition = i + 1;
13868: tmp = xmlXPathCacheNewNodeSet(ctxt->context,
13869: ctxt->context->node);
13870: valuePush(ctxt, tmp);
13871:
13872: if (op->ch2 != -1)
13873: total +=
13874: xmlXPathCompOpEval(ctxt,
13875: &comp->steps[op->ch2]);
13876: if (ctxt->error != XPATH_EXPRESSION_OK) {
13877: xmlXPathFreeObject(obj);
13878: return(0);
13879: }
13880:
13881: res = valuePop(ctxt);
13882: if (res->type == XPATH_LOCATIONSET) {
13883: xmlLocationSetPtr rloc =
13884: (xmlLocationSetPtr)res->user;
13885: for (j=0; j<rloc->locNr; j++) {
13886: range = xmlXPtrNewRange(
13887: oldlocset->locTab[i]->user,
13888: oldlocset->locTab[i]->index,
13889: rloc->locTab[j]->user2,
13890: rloc->locTab[j]->index2);
13891: if (range != NULL) {
13892: xmlXPtrLocationSetAdd(newlocset, range);
13893: }
13894: }
13895: } else {
13896: range = xmlXPtrNewRangeNodeObject(
13897: (xmlNodePtr)oldlocset->locTab[i]->user, res);
13898: if (range != NULL) {
13899: xmlXPtrLocationSetAdd(newlocset,range);
13900: }
13901: }
13902:
13903: /*
13904: * Cleanup
13905: */
13906: if (res != NULL) {
13907: xmlXPathReleaseObject(ctxt->context, res);
13908: }
13909: if (ctxt->value == tmp) {
13910: res = valuePop(ctxt);
13911: xmlXPathReleaseObject(ctxt->context, res);
13912: }
13913:
13914: ctxt->context->node = NULL;
13915: }
13916: } else { /* Not a location set */
13917: CHECK_TYPE0(XPATH_NODESET);
13918: obj = valuePop(ctxt);
13919: oldset = obj->nodesetval;
13920: ctxt->context->node = NULL;
13921:
13922: newlocset = xmlXPtrLocationSetCreate(NULL);
13923:
13924: if (oldset != NULL) {
13925: for (i = 0; i < oldset->nodeNr; i++) {
13926: /*
13927: * Run the evaluation with a node list made of a single item
13928: * in the nodeset.
13929: */
13930: ctxt->context->node = oldset->nodeTab[i];
13931: /*
13932: * OPTIMIZE TODO: Avoid recreation for every iteration.
13933: */
13934: tmp = xmlXPathCacheNewNodeSet(ctxt->context,
13935: ctxt->context->node);
13936: valuePush(ctxt, tmp);
13937:
13938: if (op->ch2 != -1)
13939: total +=
13940: xmlXPathCompOpEval(ctxt,
13941: &comp->steps[op->ch2]);
13942: if (ctxt->error != XPATH_EXPRESSION_OK) {
13943: xmlXPathFreeObject(obj);
13944: return(0);
13945: }
13946:
13947: res = valuePop(ctxt);
13948: range =
13949: xmlXPtrNewRangeNodeObject(oldset->nodeTab[i],
13950: res);
13951: if (range != NULL) {
13952: xmlXPtrLocationSetAdd(newlocset, range);
13953: }
13954:
13955: /*
13956: * Cleanup
13957: */
13958: if (res != NULL) {
13959: xmlXPathReleaseObject(ctxt->context, res);
13960: }
13961: if (ctxt->value == tmp) {
13962: res = valuePop(ctxt);
13963: xmlXPathReleaseObject(ctxt->context, res);
13964: }
13965:
13966: ctxt->context->node = NULL;
13967: }
13968: }
13969: }
13970:
13971: /*
13972: * The result is used as the new evaluation set.
13973: */
13974: xmlXPathReleaseObject(ctxt->context, obj);
13975: ctxt->context->node = NULL;
13976: ctxt->context->contextSize = -1;
13977: ctxt->context->proximityPosition = -1;
13978: valuePush(ctxt, xmlXPtrWrapLocationSet(newlocset));
13979: return (total);
13980: }
13981: #endif /* LIBXML_XPTR_ENABLED */
13982: }
13983: xmlGenericError(xmlGenericErrorContext,
13984: "XPath: unknown precompiled operation %d\n", op->op);
13985: return (total);
13986: }
13987:
13988: /**
13989: * xmlXPathCompOpEvalToBoolean:
13990: * @ctxt: the XPath parser context
13991: *
13992: * Evaluates if the expression evaluates to true.
13993: *
13994: * Returns 1 if true, 0 if false and -1 on API or internal errors.
13995: */
13996: static int
13997: xmlXPathCompOpEvalToBoolean(xmlXPathParserContextPtr ctxt,
13998: xmlXPathStepOpPtr op,
13999: int isPredicate)
14000: {
14001: xmlXPathObjectPtr resObj = NULL;
14002:
14003: start:
14004: /* comp = ctxt->comp; */
14005: switch (op->op) {
14006: case XPATH_OP_END:
14007: return (0);
14008: case XPATH_OP_VALUE:
14009: resObj = (xmlXPathObjectPtr) op->value4;
14010: if (isPredicate)
14011: return(xmlXPathEvaluatePredicateResult(ctxt, resObj));
14012: return(xmlXPathCastToBoolean(resObj));
14013: case XPATH_OP_SORT:
14014: /*
14015: * We don't need sorting for boolean results. Skip this one.
14016: */
14017: if (op->ch1 != -1) {
14018: op = &ctxt->comp->steps[op->ch1];
14019: goto start;
14020: }
14021: return(0);
14022: case XPATH_OP_COLLECT:
14023: if (op->ch1 == -1)
14024: return(0);
14025:
14026: xmlXPathCompOpEval(ctxt, &ctxt->comp->steps[op->ch1]);
14027: if (ctxt->error != XPATH_EXPRESSION_OK)
14028: return(-1);
14029:
14030: xmlXPathNodeCollectAndTest(ctxt, op, NULL, NULL, 1);
14031: if (ctxt->error != XPATH_EXPRESSION_OK)
14032: return(-1);
14033:
14034: resObj = valuePop(ctxt);
14035: if (resObj == NULL)
14036: return(-1);
14037: break;
14038: default:
14039: /*
14040: * Fallback to call xmlXPathCompOpEval().
14041: */
14042: xmlXPathCompOpEval(ctxt, op);
14043: if (ctxt->error != XPATH_EXPRESSION_OK)
14044: return(-1);
14045:
14046: resObj = valuePop(ctxt);
14047: if (resObj == NULL)
14048: return(-1);
14049: break;
14050: }
14051:
14052: if (resObj) {
14053: int res;
14054:
14055: if (resObj->type == XPATH_BOOLEAN) {
14056: res = resObj->boolval;
14057: } else if (isPredicate) {
14058: /*
14059: * For predicates a result of type "number" is handled
14060: * differently:
14061: * SPEC XPath 1.0:
14062: * "If the result is a number, the result will be converted
14063: * to true if the number is equal to the context position
14064: * and will be converted to false otherwise;"
14065: */
14066: res = xmlXPathEvaluatePredicateResult(ctxt, resObj);
14067: } else {
14068: res = xmlXPathCastToBoolean(resObj);
14069: }
14070: xmlXPathReleaseObject(ctxt->context, resObj);
14071: return(res);
14072: }
14073:
14074: return(0);
14075: }
14076:
14077: #ifdef XPATH_STREAMING
14078: /**
14079: * xmlXPathRunStreamEval:
14080: * @ctxt: the XPath parser context with the compiled expression
14081: *
14082: * Evaluate the Precompiled Streamable XPath expression in the given context.
14083: */
14084: static int
14085: xmlXPathRunStreamEval(xmlXPathContextPtr ctxt, xmlPatternPtr comp,
14086: xmlXPathObjectPtr *resultSeq, int toBool)
14087: {
14088: int max_depth, min_depth;
14089: int from_root;
14090: int ret, depth;
14091: int eval_all_nodes;
14092: xmlNodePtr cur = NULL, limit = NULL;
14093: xmlStreamCtxtPtr patstream = NULL;
14094:
14095: int nb_nodes = 0;
14096:
14097: if ((ctxt == NULL) || (comp == NULL))
14098: return(-1);
14099: max_depth = xmlPatternMaxDepth(comp);
14100: if (max_depth == -1)
14101: return(-1);
14102: if (max_depth == -2)
14103: max_depth = 10000;
14104: min_depth = xmlPatternMinDepth(comp);
14105: if (min_depth == -1)
14106: return(-1);
14107: from_root = xmlPatternFromRoot(comp);
14108: if (from_root < 0)
14109: return(-1);
14110: #if 0
14111: printf("stream eval: depth %d from root %d\n", max_depth, from_root);
14112: #endif
14113:
14114: if (! toBool) {
14115: if (resultSeq == NULL)
14116: return(-1);
14117: *resultSeq = xmlXPathCacheNewNodeSet(ctxt, NULL);
14118: if (*resultSeq == NULL)
14119: return(-1);
14120: }
14121:
14122: /*
14123: * handle the special cases of "/" amd "." being matched
14124: */
14125: if (min_depth == 0) {
14126: if (from_root) {
14127: /* Select "/" */
14128: if (toBool)
14129: return(1);
14130: xmlXPathNodeSetAddUnique((*resultSeq)->nodesetval,
14131: (xmlNodePtr) ctxt->doc);
14132: } else {
14133: /* Select "self::node()" */
14134: if (toBool)
14135: return(1);
14136: xmlXPathNodeSetAddUnique((*resultSeq)->nodesetval, ctxt->node);
14137: }
14138: }
14139: if (max_depth == 0) {
14140: return(0);
14141: }
14142:
14143: if (from_root) {
14144: cur = (xmlNodePtr)ctxt->doc;
14145: } else if (ctxt->node != NULL) {
14146: switch (ctxt->node->type) {
14147: case XML_ELEMENT_NODE:
14148: case XML_DOCUMENT_NODE:
14149: case XML_DOCUMENT_FRAG_NODE:
14150: case XML_HTML_DOCUMENT_NODE:
14151: #ifdef LIBXML_DOCB_ENABLED
14152: case XML_DOCB_DOCUMENT_NODE:
14153: #endif
14154: cur = ctxt->node;
14155: break;
14156: case XML_ATTRIBUTE_NODE:
14157: case XML_TEXT_NODE:
14158: case XML_CDATA_SECTION_NODE:
14159: case XML_ENTITY_REF_NODE:
14160: case XML_ENTITY_NODE:
14161: case XML_PI_NODE:
14162: case XML_COMMENT_NODE:
14163: case XML_NOTATION_NODE:
14164: case XML_DTD_NODE:
14165: case XML_DOCUMENT_TYPE_NODE:
14166: case XML_ELEMENT_DECL:
14167: case XML_ATTRIBUTE_DECL:
14168: case XML_ENTITY_DECL:
14169: case XML_NAMESPACE_DECL:
14170: case XML_XINCLUDE_START:
14171: case XML_XINCLUDE_END:
14172: break;
14173: }
14174: limit = cur;
14175: }
14176: if (cur == NULL) {
14177: return(0);
14178: }
14179:
14180: patstream = xmlPatternGetStreamCtxt(comp);
14181: if (patstream == NULL) {
14182: /*
14183: * QUESTION TODO: Is this an error?
14184: */
14185: return(0);
14186: }
14187:
14188: eval_all_nodes = xmlStreamWantsAnyNode(patstream);
14189:
14190: if (from_root) {
14191: ret = xmlStreamPush(patstream, NULL, NULL);
14192: if (ret < 0) {
14193: } else if (ret == 1) {
14194: if (toBool)
14195: goto return_1;
14196: xmlXPathNodeSetAddUnique((*resultSeq)->nodesetval, cur);
14197: }
14198: }
14199: depth = 0;
14200: goto scan_children;
14201: next_node:
14202: do {
14203: nb_nodes++;
14204:
14205: switch (cur->type) {
14206: case XML_ELEMENT_NODE:
14207: case XML_TEXT_NODE:
14208: case XML_CDATA_SECTION_NODE:
14209: case XML_COMMENT_NODE:
14210: case XML_PI_NODE:
14211: if (cur->type == XML_ELEMENT_NODE) {
14212: ret = xmlStreamPush(patstream, cur->name,
14213: (cur->ns ? cur->ns->href : NULL));
14214: } else if (eval_all_nodes)
14215: ret = xmlStreamPushNode(patstream, NULL, NULL, cur->type);
14216: else
14217: break;
14218:
14219: if (ret < 0) {
14220: /* NOP. */
14221: } else if (ret == 1) {
14222: if (toBool)
14223: goto return_1;
14224: xmlXPathNodeSetAddUnique((*resultSeq)->nodesetval, cur);
14225: }
14226: if ((cur->children == NULL) || (depth >= max_depth)) {
14227: ret = xmlStreamPop(patstream);
14228: while (cur->next != NULL) {
14229: cur = cur->next;
14230: if ((cur->type != XML_ENTITY_DECL) &&
14231: (cur->type != XML_DTD_NODE))
14232: goto next_node;
14233: }
14234: }
14235: default:
14236: break;
14237: }
14238:
14239: scan_children:
14240: if ((cur->children != NULL) && (depth < max_depth)) {
14241: /*
14242: * Do not descend on entities declarations
14243: */
14244: if (cur->children->type != XML_ENTITY_DECL) {
14245: cur = cur->children;
14246: depth++;
14247: /*
14248: * Skip DTDs
14249: */
14250: if (cur->type != XML_DTD_NODE)
14251: continue;
14252: }
14253: }
14254:
14255: if (cur == limit)
14256: break;
14257:
14258: while (cur->next != NULL) {
14259: cur = cur->next;
14260: if ((cur->type != XML_ENTITY_DECL) &&
14261: (cur->type != XML_DTD_NODE))
14262: goto next_node;
14263: }
14264:
14265: do {
14266: cur = cur->parent;
14267: depth--;
14268: if ((cur == NULL) || (cur == limit))
14269: goto done;
14270: if (cur->type == XML_ELEMENT_NODE) {
14271: ret = xmlStreamPop(patstream);
14272: } else if ((eval_all_nodes) &&
14273: ((cur->type == XML_TEXT_NODE) ||
14274: (cur->type == XML_CDATA_SECTION_NODE) ||
14275: (cur->type == XML_COMMENT_NODE) ||
14276: (cur->type == XML_PI_NODE)))
14277: {
14278: ret = xmlStreamPop(patstream);
14279: }
14280: if (cur->next != NULL) {
14281: cur = cur->next;
14282: break;
14283: }
14284: } while (cur != NULL);
14285:
14286: } while ((cur != NULL) && (depth >= 0));
14287:
14288: done:
14289:
14290: #if 0
14291: printf("stream eval: checked %d nodes selected %d\n",
14292: nb_nodes, retObj->nodesetval->nodeNr);
14293: #endif
14294:
14295: if (patstream)
14296: xmlFreeStreamCtxt(patstream);
14297: return(0);
14298:
14299: return_1:
14300: if (patstream)
14301: xmlFreeStreamCtxt(patstream);
14302: return(1);
14303: }
14304: #endif /* XPATH_STREAMING */
14305:
14306: /**
14307: * xmlXPathRunEval:
14308: * @ctxt: the XPath parser context with the compiled expression
14309: * @toBool: evaluate to a boolean result
14310: *
14311: * Evaluate the Precompiled XPath expression in the given context.
14312: */
14313: static int
14314: xmlXPathRunEval(xmlXPathParserContextPtr ctxt, int toBool)
14315: {
14316: xmlXPathCompExprPtr comp;
14317:
14318: if ((ctxt == NULL) || (ctxt->comp == NULL))
14319: return(-1);
14320:
14321: if (ctxt->valueTab == NULL) {
14322: /* Allocate the value stack */
14323: ctxt->valueTab = (xmlXPathObjectPtr *)
14324: xmlMalloc(10 * sizeof(xmlXPathObjectPtr));
14325: if (ctxt->valueTab == NULL) {
14326: xmlXPathPErrMemory(ctxt, "creating evaluation context\n");
14327: xmlFree(ctxt);
14328: }
14329: ctxt->valueNr = 0;
14330: ctxt->valueMax = 10;
14331: ctxt->value = NULL;
14332: }
14333: #ifdef XPATH_STREAMING
14334: if (ctxt->comp->stream) {
14335: int res;
14336:
14337: if (toBool) {
14338: /*
14339: * Evaluation to boolean result.
14340: */
14341: res = xmlXPathRunStreamEval(ctxt->context,
14342: ctxt->comp->stream, NULL, 1);
14343: if (res != -1)
14344: return(res);
14345: } else {
14346: xmlXPathObjectPtr resObj = NULL;
14347:
14348: /*
14349: * Evaluation to a sequence.
14350: */
14351: res = xmlXPathRunStreamEval(ctxt->context,
14352: ctxt->comp->stream, &resObj, 0);
14353:
14354: if ((res != -1) && (resObj != NULL)) {
14355: valuePush(ctxt, resObj);
14356: return(0);
14357: }
14358: if (resObj != NULL)
14359: xmlXPathReleaseObject(ctxt->context, resObj);
14360: }
14361: /*
14362: * QUESTION TODO: This falls back to normal XPath evaluation
14363: * if res == -1. Is this intended?
14364: */
14365: }
14366: #endif
14367: comp = ctxt->comp;
14368: if (comp->last < 0) {
14369: xmlGenericError(xmlGenericErrorContext,
14370: "xmlXPathRunEval: last is less than zero\n");
14371: return(-1);
14372: }
14373: if (toBool)
14374: return(xmlXPathCompOpEvalToBoolean(ctxt,
14375: &comp->steps[comp->last], 0));
14376: else
14377: xmlXPathCompOpEval(ctxt, &comp->steps[comp->last]);
14378:
14379: return(0);
14380: }
14381:
14382: /************************************************************************
14383: * *
14384: * Public interfaces *
14385: * *
14386: ************************************************************************/
14387:
14388: /**
14389: * xmlXPathEvalPredicate:
14390: * @ctxt: the XPath context
14391: * @res: the Predicate Expression evaluation result
14392: *
14393: * Evaluate a predicate result for the current node.
14394: * A PredicateExpr is evaluated by evaluating the Expr and converting
14395: * the result to a boolean. If the result is a number, the result will
14396: * be converted to true if the number is equal to the position of the
14397: * context node in the context node list (as returned by the position
14398: * function) and will be converted to false otherwise; if the result
14399: * is not a number, then the result will be converted as if by a call
14400: * to the boolean function.
14401: *
14402: * Returns 1 if predicate is true, 0 otherwise
14403: */
14404: int
14405: xmlXPathEvalPredicate(xmlXPathContextPtr ctxt, xmlXPathObjectPtr res) {
14406: if ((ctxt == NULL) || (res == NULL)) return(0);
14407: switch (res->type) {
14408: case XPATH_BOOLEAN:
14409: return(res->boolval);
14410: case XPATH_NUMBER:
14411: return(res->floatval == ctxt->proximityPosition);
14412: case XPATH_NODESET:
14413: case XPATH_XSLT_TREE:
14414: if (res->nodesetval == NULL)
14415: return(0);
14416: return(res->nodesetval->nodeNr != 0);
14417: case XPATH_STRING:
14418: return((res->stringval != NULL) &&
14419: (xmlStrlen(res->stringval) != 0));
14420: default:
14421: STRANGE
14422: }
14423: return(0);
14424: }
14425:
14426: /**
14427: * xmlXPathEvaluatePredicateResult:
14428: * @ctxt: the XPath Parser context
14429: * @res: the Predicate Expression evaluation result
14430: *
14431: * Evaluate a predicate result for the current node.
14432: * A PredicateExpr is evaluated by evaluating the Expr and converting
14433: * the result to a boolean. If the result is a number, the result will
14434: * be converted to true if the number is equal to the position of the
14435: * context node in the context node list (as returned by the position
14436: * function) and will be converted to false otherwise; if the result
14437: * is not a number, then the result will be converted as if by a call
14438: * to the boolean function.
14439: *
14440: * Returns 1 if predicate is true, 0 otherwise
14441: */
14442: int
14443: xmlXPathEvaluatePredicateResult(xmlXPathParserContextPtr ctxt,
14444: xmlXPathObjectPtr res) {
14445: if ((ctxt == NULL) || (res == NULL)) return(0);
14446: switch (res->type) {
14447: case XPATH_BOOLEAN:
14448: return(res->boolval);
14449: case XPATH_NUMBER:
14450: #if defined(__BORLANDC__) || (defined(_MSC_VER) && (_MSC_VER == 1200))
14451: return((res->floatval == ctxt->context->proximityPosition) &&
14452: (!xmlXPathIsNaN(res->floatval))); /* MSC pbm Mark Vakoc !*/
14453: #else
14454: return(res->floatval == ctxt->context->proximityPosition);
14455: #endif
14456: case XPATH_NODESET:
14457: case XPATH_XSLT_TREE:
14458: if (res->nodesetval == NULL)
14459: return(0);
14460: return(res->nodesetval->nodeNr != 0);
14461: case XPATH_STRING:
14462: return((res->stringval != NULL) && (res->stringval[0] != 0));
14463: #ifdef LIBXML_XPTR_ENABLED
14464: case XPATH_LOCATIONSET:{
14465: xmlLocationSetPtr ptr = res->user;
14466: if (ptr == NULL)
14467: return(0);
14468: return (ptr->locNr != 0);
14469: }
14470: #endif
14471: default:
14472: STRANGE
14473: }
14474: return(0);
14475: }
14476:
14477: #ifdef XPATH_STREAMING
14478: /**
14479: * xmlXPathTryStreamCompile:
14480: * @ctxt: an XPath context
14481: * @str: the XPath expression
14482: *
14483: * Try to compile the XPath expression as a streamable subset.
14484: *
14485: * Returns the compiled expression or NULL if failed to compile.
14486: */
14487: static xmlXPathCompExprPtr
14488: xmlXPathTryStreamCompile(xmlXPathContextPtr ctxt, const xmlChar *str) {
14489: /*
14490: * Optimization: use streaming patterns when the XPath expression can
14491: * be compiled to a stream lookup
14492: */
14493: xmlPatternPtr stream;
14494: xmlXPathCompExprPtr comp;
14495: xmlDictPtr dict = NULL;
14496: const xmlChar **namespaces = NULL;
14497: xmlNsPtr ns;
14498: int i, j;
14499:
14500: if ((!xmlStrchr(str, '[')) && (!xmlStrchr(str, '(')) &&
14501: (!xmlStrchr(str, '@'))) {
14502: const xmlChar *tmp;
14503:
14504: /*
14505: * We don't try to handle expressions using the verbose axis
14506: * specifiers ("::"), just the simplied form at this point.
14507: * Additionally, if there is no list of namespaces available and
14508: * there's a ":" in the expression, indicating a prefixed QName,
14509: * then we won't try to compile either. xmlPatterncompile() needs
14510: * to have a list of namespaces at compilation time in order to
14511: * compile prefixed name tests.
14512: */
14513: tmp = xmlStrchr(str, ':');
14514: if ((tmp != NULL) &&
14515: ((ctxt == NULL) || (ctxt->nsNr == 0) || (tmp[1] == ':')))
14516: return(NULL);
14517:
14518: if (ctxt != NULL) {
14519: dict = ctxt->dict;
14520: if (ctxt->nsNr > 0) {
14521: namespaces = xmlMalloc(2 * (ctxt->nsNr + 1) * sizeof(xmlChar*));
14522: if (namespaces == NULL) {
14523: xmlXPathErrMemory(ctxt, "allocating namespaces array\n");
14524: return(NULL);
14525: }
14526: for (i = 0, j = 0; (j < ctxt->nsNr); j++) {
14527: ns = ctxt->namespaces[j];
14528: namespaces[i++] = ns->href;
14529: namespaces[i++] = ns->prefix;
14530: }
14531: namespaces[i++] = NULL;
14532: namespaces[i] = NULL;
14533: }
14534: }
14535:
14536: stream = xmlPatterncompile(str, dict, XML_PATTERN_XPATH,
14537: &namespaces[0]);
14538: if (namespaces != NULL) {
14539: xmlFree((xmlChar **)namespaces);
14540: }
14541: if ((stream != NULL) && (xmlPatternStreamable(stream) == 1)) {
14542: comp = xmlXPathNewCompExpr();
14543: if (comp == NULL) {
14544: xmlXPathErrMemory(ctxt, "allocating streamable expression\n");
14545: return(NULL);
14546: }
14547: comp->stream = stream;
14548: comp->dict = dict;
14549: if (comp->dict)
14550: xmlDictReference(comp->dict);
14551: return(comp);
14552: }
14553: xmlFreePattern(stream);
14554: }
14555: return(NULL);
14556: }
14557: #endif /* XPATH_STREAMING */
14558:
14559: static int
14560: xmlXPathCanRewriteDosExpression(xmlChar *expr)
14561: {
14562: if (expr == NULL)
14563: return(0);
14564: do {
14565: if ((*expr == '/') && (*(++expr) == '/'))
14566: return(1);
14567: } while (*expr++);
14568: return(0);
14569: }
14570: static void
14571: xmlXPathRewriteDOSExpression(xmlXPathCompExprPtr comp, xmlXPathStepOpPtr op)
14572: {
14573: /*
14574: * Try to rewrite "descendant-or-self::node()/foo" to an optimized
14575: * internal representation.
14576: */
14577: if (op->ch1 != -1) {
14578: if ((op->op == XPATH_OP_COLLECT /* 11 */) &&
14579: ((xmlXPathAxisVal) op->value == AXIS_CHILD /* 4 */) &&
14580: ((xmlXPathTestVal) op->value2 == NODE_TEST_NAME /* 5 */) &&
14581: ((xmlXPathTypeVal) op->value3 == NODE_TYPE_NODE /* 0 */))
14582: {
14583: /*
14584: * This is a "child::foo"
14585: */
14586: xmlXPathStepOpPtr prevop = &comp->steps[op->ch1];
14587:
14588: if ((prevop->op == XPATH_OP_COLLECT /* 11 */) &&
14589: (prevop->ch1 != -1) &&
14590: ((xmlXPathAxisVal) prevop->value ==
14591: AXIS_DESCENDANT_OR_SELF) &&
14592: (prevop->ch2 == -1) &&
14593: ((xmlXPathTestVal) prevop->value2 == NODE_TEST_TYPE) &&
14594: ((xmlXPathTypeVal) prevop->value3 == NODE_TYPE_NODE) &&
14595: (comp->steps[prevop->ch1].op == XPATH_OP_ROOT))
14596: {
14597: /*
14598: * This is a "/descendant-or-self::node()" without predicates.
14599: * Eliminate it.
14600: */
14601: op->ch1 = prevop->ch1;
14602: op->rewriteType = XP_REWRITE_DOS_CHILD_ELEM;
14603: }
14604: }
14605: if (op->ch1 != -1)
14606: xmlXPathRewriteDOSExpression(comp, &comp->steps[op->ch1]);
14607: }
14608: if (op->ch2 != -1)
14609: xmlXPathRewriteDOSExpression(comp, &comp->steps[op->ch2]);
14610: }
14611:
14612: /**
14613: * xmlXPathCtxtCompile:
14614: * @ctxt: an XPath context
14615: * @str: the XPath expression
14616: *
14617: * Compile an XPath expression
14618: *
14619: * Returns the xmlXPathCompExprPtr resulting from the compilation or NULL.
14620: * the caller has to free the object.
14621: */
14622: xmlXPathCompExprPtr
14623: xmlXPathCtxtCompile(xmlXPathContextPtr ctxt, const xmlChar *str) {
14624: xmlXPathParserContextPtr pctxt;
14625: xmlXPathCompExprPtr comp;
14626:
14627: #ifdef XPATH_STREAMING
14628: comp = xmlXPathTryStreamCompile(ctxt, str);
14629: if (comp != NULL)
14630: return(comp);
14631: #endif
14632:
14633: xmlXPathInit();
14634:
14635: pctxt = xmlXPathNewParserContext(str, ctxt);
14636: if (pctxt == NULL)
14637: return NULL;
14638: xmlXPathCompileExpr(pctxt, 1);
14639:
14640: if( pctxt->error != XPATH_EXPRESSION_OK )
14641: {
14642: xmlXPathFreeParserContext(pctxt);
14643: return(NULL);
14644: }
14645:
14646: if (*pctxt->cur != 0) {
14647: /*
14648: * aleksey: in some cases this line prints *second* error message
14649: * (see bug #78858) and probably this should be fixed.
14650: * However, we are not sure that all error messages are printed
14651: * out in other places. It's not critical so we leave it as-is for now
14652: */
14653: xmlXPatherror(pctxt, __FILE__, __LINE__, XPATH_EXPR_ERROR);
14654: comp = NULL;
14655: } else {
14656: comp = pctxt->comp;
14657: pctxt->comp = NULL;
14658: }
14659: xmlXPathFreeParserContext(pctxt);
14660:
14661: if (comp != NULL) {
14662: comp->expr = xmlStrdup(str);
14663: #ifdef DEBUG_EVAL_COUNTS
14664: comp->string = xmlStrdup(str);
14665: comp->nb = 0;
14666: #endif
14667: if ((comp->expr != NULL) &&
14668: (comp->nbStep > 2) &&
14669: (comp->last >= 0) &&
14670: (xmlXPathCanRewriteDosExpression(comp->expr) == 1))
14671: {
14672: xmlXPathRewriteDOSExpression(comp, &comp->steps[comp->last]);
14673: }
14674: }
14675: return(comp);
14676: }
14677:
14678: /**
14679: * xmlXPathCompile:
14680: * @str: the XPath expression
14681: *
14682: * Compile an XPath expression
14683: *
14684: * Returns the xmlXPathCompExprPtr resulting from the compilation or NULL.
14685: * the caller has to free the object.
14686: */
14687: xmlXPathCompExprPtr
14688: xmlXPathCompile(const xmlChar *str) {
14689: return(xmlXPathCtxtCompile(NULL, str));
14690: }
14691:
14692: /**
14693: * xmlXPathCompiledEvalInternal:
14694: * @comp: the compiled XPath expression
14695: * @ctxt: the XPath context
14696: * @resObj: the resulting XPath object or NULL
14697: * @toBool: 1 if only a boolean result is requested
14698: *
14699: * Evaluate the Precompiled XPath expression in the given context.
14700: * The caller has to free @resObj.
14701: *
14702: * Returns the xmlXPathObjectPtr resulting from the evaluation or NULL.
14703: * the caller has to free the object.
14704: */
14705: static int
14706: xmlXPathCompiledEvalInternal(xmlXPathCompExprPtr comp,
14707: xmlXPathContextPtr ctxt,
14708: xmlXPathObjectPtr *resObj,
14709: int toBool)
14710: {
14711: xmlXPathParserContextPtr pctxt;
14712: #ifndef LIBXML_THREAD_ENABLED
14713: static int reentance = 0;
14714: #endif
14715: int res;
14716:
14717: CHECK_CTXT_NEG(ctxt)
14718:
14719: if (comp == NULL)
14720: return(-1);
14721: xmlXPathInit();
14722:
14723: #ifndef LIBXML_THREAD_ENABLED
14724: reentance++;
14725: if (reentance > 1)
14726: xmlXPathDisableOptimizer = 1;
14727: #endif
14728:
14729: #ifdef DEBUG_EVAL_COUNTS
14730: comp->nb++;
14731: if ((comp->string != NULL) && (comp->nb > 100)) {
14732: fprintf(stderr, "100 x %s\n", comp->string);
14733: comp->nb = 0;
14734: }
14735: #endif
14736: pctxt = xmlXPathCompParserContext(comp, ctxt);
14737: res = xmlXPathRunEval(pctxt, toBool);
14738:
14739: if (resObj) {
14740: if (pctxt->value == NULL) {
14741: xmlGenericError(xmlGenericErrorContext,
14742: "xmlXPathCompiledEval: evaluation failed\n");
14743: *resObj = NULL;
14744: } else {
14745: *resObj = valuePop(pctxt);
14746: }
14747: }
14748:
14749: /*
14750: * Pop all remaining objects from the stack.
14751: */
14752: if (pctxt->valueNr > 0) {
14753: xmlXPathObjectPtr tmp;
14754: int stack = 0;
14755:
14756: do {
14757: tmp = valuePop(pctxt);
14758: if (tmp != NULL) {
14759: stack++;
14760: xmlXPathReleaseObject(ctxt, tmp);
14761: }
14762: } while (tmp != NULL);
14763: if ((stack != 0) &&
14764: ((toBool) || ((resObj) && (*resObj))))
14765: {
14766: xmlGenericError(xmlGenericErrorContext,
14767: "xmlXPathCompiledEval: %d objects left on the stack.\n",
14768: stack);
14769: }
14770: }
14771:
14772: if ((pctxt->error != XPATH_EXPRESSION_OK) && (resObj) && (*resObj)) {
14773: xmlXPathFreeObject(*resObj);
14774: *resObj = NULL;
14775: }
14776: pctxt->comp = NULL;
14777: xmlXPathFreeParserContext(pctxt);
14778: #ifndef LIBXML_THREAD_ENABLED
14779: reentance--;
14780: #endif
14781:
14782: return(res);
14783: }
14784:
14785: /**
14786: * xmlXPathCompiledEval:
14787: * @comp: the compiled XPath expression
14788: * @ctx: the XPath context
14789: *
14790: * Evaluate the Precompiled XPath expression in the given context.
14791: *
14792: * Returns the xmlXPathObjectPtr resulting from the evaluation or NULL.
14793: * the caller has to free the object.
14794: */
14795: xmlXPathObjectPtr
14796: xmlXPathCompiledEval(xmlXPathCompExprPtr comp, xmlXPathContextPtr ctx)
14797: {
14798: xmlXPathObjectPtr res = NULL;
14799:
14800: xmlXPathCompiledEvalInternal(comp, ctx, &res, 0);
14801: return(res);
14802: }
14803:
14804: /**
14805: * xmlXPathCompiledEvalToBoolean:
14806: * @comp: the compiled XPath expression
14807: * @ctxt: the XPath context
14808: *
14809: * Applies the XPath boolean() function on the result of the given
14810: * compiled expression.
14811: *
14812: * Returns 1 if the expression evaluated to true, 0 if to false and
14813: * -1 in API and internal errors.
14814: */
14815: int
14816: xmlXPathCompiledEvalToBoolean(xmlXPathCompExprPtr comp,
14817: xmlXPathContextPtr ctxt)
14818: {
14819: return(xmlXPathCompiledEvalInternal(comp, ctxt, NULL, 1));
14820: }
14821:
14822: /**
14823: * xmlXPathEvalExpr:
14824: * @ctxt: the XPath Parser context
14825: *
14826: * Parse and evaluate an XPath expression in the given context,
14827: * then push the result on the context stack
14828: */
14829: void
14830: xmlXPathEvalExpr(xmlXPathParserContextPtr ctxt) {
14831: #ifdef XPATH_STREAMING
14832: xmlXPathCompExprPtr comp;
14833: #endif
14834:
14835: if (ctxt == NULL) return;
14836:
14837: #ifdef XPATH_STREAMING
14838: comp = xmlXPathTryStreamCompile(ctxt->context, ctxt->base);
14839: if (comp != NULL) {
14840: if (ctxt->comp != NULL)
14841: xmlXPathFreeCompExpr(ctxt->comp);
14842: ctxt->comp = comp;
14843: if (ctxt->cur != NULL)
14844: while (*ctxt->cur != 0) ctxt->cur++;
14845: } else
14846: #endif
14847: {
14848: xmlXPathCompileExpr(ctxt, 1);
14849: /*
14850: * In this scenario the expression string will sit in ctxt->base.
14851: */
14852: if ((ctxt->error == XPATH_EXPRESSION_OK) &&
14853: (ctxt->comp != NULL) &&
14854: (ctxt->base != NULL) &&
14855: (ctxt->comp->nbStep > 2) &&
14856: (ctxt->comp->last >= 0) &&
14857: (xmlXPathCanRewriteDosExpression((xmlChar *) ctxt->base) == 1))
14858: {
14859: xmlXPathRewriteDOSExpression(ctxt->comp,
14860: &ctxt->comp->steps[ctxt->comp->last]);
14861: }
14862: }
14863: CHECK_ERROR;
14864: xmlXPathRunEval(ctxt, 0);
14865: }
14866:
14867: /**
14868: * xmlXPathEval:
14869: * @str: the XPath expression
14870: * @ctx: the XPath context
14871: *
14872: * Evaluate the XPath Location Path in the given context.
14873: *
14874: * Returns the xmlXPathObjectPtr resulting from the evaluation or NULL.
14875: * the caller has to free the object.
14876: */
14877: xmlXPathObjectPtr
14878: xmlXPathEval(const xmlChar *str, xmlXPathContextPtr ctx) {
14879: xmlXPathParserContextPtr ctxt;
14880: xmlXPathObjectPtr res, tmp, init = NULL;
14881: int stack = 0;
14882:
14883: CHECK_CTXT(ctx)
14884:
14885: xmlXPathInit();
14886:
14887: ctxt = xmlXPathNewParserContext(str, ctx);
14888: if (ctxt == NULL)
14889: return NULL;
14890: xmlXPathEvalExpr(ctxt);
14891:
14892: if (ctxt->value == NULL) {
14893: xmlGenericError(xmlGenericErrorContext,
14894: "xmlXPathEval: evaluation failed\n");
14895: res = NULL;
14896: } else if ((*ctxt->cur != 0) && (ctxt->comp != NULL)
14897: #ifdef XPATH_STREAMING
14898: && (ctxt->comp->stream == NULL)
14899: #endif
14900: ) {
14901: xmlXPatherror(ctxt, __FILE__, __LINE__, XPATH_EXPR_ERROR);
14902: res = NULL;
14903: } else {
14904: res = valuePop(ctxt);
14905: }
14906:
14907: do {
14908: tmp = valuePop(ctxt);
14909: if (tmp != NULL) {
14910: if (tmp != init)
14911: stack++;
14912: xmlXPathReleaseObject(ctx, tmp);
14913: }
14914: } while (tmp != NULL);
14915: if ((stack != 0) && (res != NULL)) {
14916: xmlGenericError(xmlGenericErrorContext,
14917: "xmlXPathEval: %d object left on the stack\n",
14918: stack);
14919: }
14920: if (ctxt->error != XPATH_EXPRESSION_OK) {
14921: xmlXPathFreeObject(res);
14922: res = NULL;
14923: }
14924:
14925: xmlXPathFreeParserContext(ctxt);
14926: return(res);
14927: }
14928:
14929: /**
14930: * xmlXPathEvalExpression:
14931: * @str: the XPath expression
14932: * @ctxt: the XPath context
14933: *
14934: * Evaluate the XPath expression in the given context.
14935: *
14936: * Returns the xmlXPathObjectPtr resulting from the evaluation or NULL.
14937: * the caller has to free the object.
14938: */
14939: xmlXPathObjectPtr
14940: xmlXPathEvalExpression(const xmlChar *str, xmlXPathContextPtr ctxt) {
14941: xmlXPathParserContextPtr pctxt;
14942: xmlXPathObjectPtr res, tmp;
14943: int stack = 0;
14944:
14945: CHECK_CTXT(ctxt)
14946:
14947: xmlXPathInit();
14948:
14949: pctxt = xmlXPathNewParserContext(str, ctxt);
14950: if (pctxt == NULL)
14951: return NULL;
14952: xmlXPathEvalExpr(pctxt);
14953:
14954: if ((*pctxt->cur != 0) || (pctxt->error != XPATH_EXPRESSION_OK)) {
14955: xmlXPatherror(pctxt, __FILE__, __LINE__, XPATH_EXPR_ERROR);
14956: res = NULL;
14957: } else {
14958: res = valuePop(pctxt);
14959: }
14960: do {
14961: tmp = valuePop(pctxt);
14962: if (tmp != NULL) {
14963: xmlXPathReleaseObject(ctxt, tmp);
14964: stack++;
14965: }
14966: } while (tmp != NULL);
14967: if ((stack != 0) && (res != NULL)) {
14968: xmlGenericError(xmlGenericErrorContext,
14969: "xmlXPathEvalExpression: %d object left on the stack\n",
14970: stack);
14971: }
14972: xmlXPathFreeParserContext(pctxt);
14973: return(res);
14974: }
14975:
14976: /************************************************************************
14977: * *
14978: * Extra functions not pertaining to the XPath spec *
14979: * *
14980: ************************************************************************/
14981: /**
14982: * xmlXPathEscapeUriFunction:
14983: * @ctxt: the XPath Parser context
14984: * @nargs: the number of arguments
14985: *
14986: * Implement the escape-uri() XPath function
14987: * string escape-uri(string $str, bool $escape-reserved)
14988: *
14989: * This function applies the URI escaping rules defined in section 2 of [RFC
14990: * 2396] to the string supplied as $uri-part, which typically represents all
14991: * or part of a URI. The effect of the function is to replace any special
14992: * character in the string by an escape sequence of the form %xx%yy...,
14993: * where xxyy... is the hexadecimal representation of the octets used to
14994: * represent the character in UTF-8.
14995: *
14996: * The set of characters that are escaped depends on the setting of the
14997: * boolean argument $escape-reserved.
14998: *
14999: * If $escape-reserved is true, all characters are escaped other than lower
15000: * case letters a-z, upper case letters A-Z, digits 0-9, and the characters
15001: * referred to in [RFC 2396] as "marks": specifically, "-" | "_" | "." | "!"
15002: * | "~" | "*" | "'" | "(" | ")". The "%" character itself is escaped only
15003: * if it is not followed by two hexadecimal digits (that is, 0-9, a-f, and
15004: * A-F).
15005: *
15006: * If $escape-reserved is false, the behavior differs in that characters
15007: * referred to in [RFC 2396] as reserved characters are not escaped. These
15008: * characters are ";" | "/" | "?" | ":" | "@" | "&" | "=" | "+" | "$" | ",".
15009: *
15010: * [RFC 2396] does not define whether escaped URIs should use lower case or
15011: * upper case for hexadecimal digits. To ensure that escaped URIs can be
15012: * compared using string comparison functions, this function must always use
15013: * the upper-case letters A-F.
15014: *
15015: * Generally, $escape-reserved should be set to true when escaping a string
15016: * that is to form a single part of a URI, and to false when escaping an
15017: * entire URI or URI reference.
15018: *
15019: * In the case of non-ascii characters, the string is encoded according to
15020: * utf-8 and then converted according to RFC 2396.
15021: *
15022: * Examples
15023: * xf:escape-uri ("gopher://spinaltap.micro.umn.edu/00/Weather/California/Los%20Angeles#ocean"), true())
15024: * returns "gopher%3A%2F%2Fspinaltap.micro.umn.edu%2F00%2FWeather%2FCalifornia%2FLos%20Angeles%23ocean"
15025: * xf:escape-uri ("gopher://spinaltap.micro.umn.edu/00/Weather/California/Los%20Angeles#ocean"), false())
15026: * returns "gopher://spinaltap.micro.umn.edu/00/Weather/California/Los%20Angeles%23ocean"
15027: *
15028: */
15029: static void
15030: xmlXPathEscapeUriFunction(xmlXPathParserContextPtr ctxt, int nargs) {
15031: xmlXPathObjectPtr str;
15032: int escape_reserved;
15033: xmlBufferPtr target;
15034: xmlChar *cptr;
15035: xmlChar escape[4];
15036:
15037: CHECK_ARITY(2);
15038:
15039: escape_reserved = xmlXPathPopBoolean(ctxt);
15040:
15041: CAST_TO_STRING;
15042: str = valuePop(ctxt);
15043:
15044: target = xmlBufferCreate();
15045:
15046: escape[0] = '%';
15047: escape[3] = 0;
15048:
15049: if (target) {
15050: for (cptr = str->stringval; *cptr; cptr++) {
15051: if ((*cptr >= 'A' && *cptr <= 'Z') ||
15052: (*cptr >= 'a' && *cptr <= 'z') ||
15053: (*cptr >= '0' && *cptr <= '9') ||
15054: *cptr == '-' || *cptr == '_' || *cptr == '.' ||
15055: *cptr == '!' || *cptr == '~' || *cptr == '*' ||
15056: *cptr == '\''|| *cptr == '(' || *cptr == ')' ||
15057: (*cptr == '%' &&
15058: ((cptr[1] >= 'A' && cptr[1] <= 'F') ||
15059: (cptr[1] >= 'a' && cptr[1] <= 'f') ||
15060: (cptr[1] >= '0' && cptr[1] <= '9')) &&
15061: ((cptr[2] >= 'A' && cptr[2] <= 'F') ||
15062: (cptr[2] >= 'a' && cptr[2] <= 'f') ||
15063: (cptr[2] >= '0' && cptr[2] <= '9'))) ||
15064: (!escape_reserved &&
15065: (*cptr == ';' || *cptr == '/' || *cptr == '?' ||
15066: *cptr == ':' || *cptr == '@' || *cptr == '&' ||
15067: *cptr == '=' || *cptr == '+' || *cptr == '$' ||
15068: *cptr == ','))) {
15069: xmlBufferAdd(target, cptr, 1);
15070: } else {
15071: if ((*cptr >> 4) < 10)
15072: escape[1] = '0' + (*cptr >> 4);
15073: else
15074: escape[1] = 'A' - 10 + (*cptr >> 4);
15075: if ((*cptr & 0xF) < 10)
15076: escape[2] = '0' + (*cptr & 0xF);
15077: else
15078: escape[2] = 'A' - 10 + (*cptr & 0xF);
15079:
15080: xmlBufferAdd(target, &escape[0], 3);
15081: }
15082: }
15083: }
15084: valuePush(ctxt, xmlXPathCacheNewString(ctxt->context,
15085: xmlBufferContent(target)));
15086: xmlBufferFree(target);
15087: xmlXPathReleaseObject(ctxt->context, str);
15088: }
15089:
15090: /**
15091: * xmlXPathRegisterAllFunctions:
15092: * @ctxt: the XPath context
15093: *
15094: * Registers all default XPath functions in this context
15095: */
15096: void
15097: xmlXPathRegisterAllFunctions(xmlXPathContextPtr ctxt)
15098: {
15099: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"boolean",
15100: xmlXPathBooleanFunction);
15101: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"ceiling",
15102: xmlXPathCeilingFunction);
15103: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"count",
15104: xmlXPathCountFunction);
15105: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"concat",
15106: xmlXPathConcatFunction);
15107: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"contains",
15108: xmlXPathContainsFunction);
15109: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"id",
15110: xmlXPathIdFunction);
15111: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"false",
15112: xmlXPathFalseFunction);
15113: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"floor",
15114: xmlXPathFloorFunction);
15115: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"last",
15116: xmlXPathLastFunction);
15117: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"lang",
15118: xmlXPathLangFunction);
15119: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"local-name",
15120: xmlXPathLocalNameFunction);
15121: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"not",
15122: xmlXPathNotFunction);
15123: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"name",
15124: xmlXPathNameFunction);
15125: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"namespace-uri",
15126: xmlXPathNamespaceURIFunction);
15127: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"normalize-space",
15128: xmlXPathNormalizeFunction);
15129: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"number",
15130: xmlXPathNumberFunction);
15131: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"position",
15132: xmlXPathPositionFunction);
15133: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"round",
15134: xmlXPathRoundFunction);
15135: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"string",
15136: xmlXPathStringFunction);
15137: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"string-length",
15138: xmlXPathStringLengthFunction);
15139: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"starts-with",
15140: xmlXPathStartsWithFunction);
15141: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"substring",
15142: xmlXPathSubstringFunction);
15143: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"substring-before",
15144: xmlXPathSubstringBeforeFunction);
15145: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"substring-after",
15146: xmlXPathSubstringAfterFunction);
15147: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"sum",
15148: xmlXPathSumFunction);
15149: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"true",
15150: xmlXPathTrueFunction);
15151: xmlXPathRegisterFunc(ctxt, (const xmlChar *)"translate",
15152: xmlXPathTranslateFunction);
15153:
15154: xmlXPathRegisterFuncNS(ctxt, (const xmlChar *)"escape-uri",
15155: (const xmlChar *)"http://www.w3.org/2002/08/xquery-functions",
15156: xmlXPathEscapeUriFunction);
15157: }
15158:
15159: #endif /* LIBXML_XPATH_ENABLED */
15160: #define bottom_xpath
15161: #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