Annotation of embedaddon/libxml2/xpointer.c, revision 1.1.1.1
1.1 misho 1: /*
2: * xpointer.c : Code to handle XML Pointer
3: *
4: * Base implementation was made accordingly to
5: * W3C Candidate Recommendation 7 June 2000
6: * http://www.w3.org/TR/2000/CR-xptr-20000607
7: *
8: * Added support for the element() scheme described in:
9: * W3C Proposed Recommendation 13 November 2002
10: * http://www.w3.org/TR/2002/PR-xptr-element-20021113/
11: *
12: * See Copyright for the status of this software.
13: *
14: * daniel@veillard.com
15: */
16:
17: #define IN_LIBXML
18: #include "libxml.h"
19:
20: /*
21: * TODO: better handling of error cases, the full expression should
22: * be parsed beforehand instead of a progressive evaluation
23: * TODO: Access into entities references are not supported now ...
24: * need a start to be able to pop out of entities refs since
25: * parent is the endity declaration, not the ref.
26: */
27:
28: #include <string.h>
29: #include <libxml/xpointer.h>
30: #include <libxml/xmlmemory.h>
31: #include <libxml/parserInternals.h>
32: #include <libxml/uri.h>
33: #include <libxml/xpath.h>
34: #include <libxml/xpathInternals.h>
35: #include <libxml/xmlerror.h>
36: #include <libxml/globals.h>
37:
38: #ifdef LIBXML_XPTR_ENABLED
39:
40: /* Add support of the xmlns() xpointer scheme to initialize the namespaces */
41: #define XPTR_XMLNS_SCHEME
42:
43: /* #define DEBUG_RANGES */
44: #ifdef DEBUG_RANGES
45: #ifdef LIBXML_DEBUG_ENABLED
46: #include <libxml/debugXML.h>
47: #endif
48: #endif
49:
50: #define TODO \
51: xmlGenericError(xmlGenericErrorContext, \
52: "Unimplemented block at %s:%d\n", \
53: __FILE__, __LINE__);
54:
55: #define STRANGE \
56: xmlGenericError(xmlGenericErrorContext, \
57: "Internal error at %s:%d\n", \
58: __FILE__, __LINE__);
59:
60: /************************************************************************
61: * *
62: * Some factorized error routines *
63: * *
64: ************************************************************************/
65:
66: /**
67: * xmlXPtrErrMemory:
68: * @extra: extra informations
69: *
70: * Handle a redefinition of attribute error
71: */
72: static void
73: xmlXPtrErrMemory(const char *extra)
74: {
75: __xmlRaiseError(NULL, NULL, NULL, NULL, NULL, XML_FROM_XPOINTER,
76: XML_ERR_NO_MEMORY, XML_ERR_ERROR, NULL, 0, extra,
77: NULL, NULL, 0, 0,
78: "Memory allocation failed : %s\n", extra);
79: }
80:
81: /**
82: * xmlXPtrErr:
83: * @ctxt: an XPTR evaluation context
84: * @extra: extra informations
85: *
86: * Handle a redefinition of attribute error
87: */
88: static void
89: xmlXPtrErr(xmlXPathParserContextPtr ctxt, int error,
90: const char * msg, const xmlChar *extra)
91: {
92: if (ctxt != NULL)
93: ctxt->error = error;
94: if ((ctxt == NULL) || (ctxt->context == NULL)) {
95: __xmlRaiseError(NULL, NULL, NULL,
96: NULL, NULL, XML_FROM_XPOINTER, error,
97: XML_ERR_ERROR, NULL, 0,
98: (const char *) extra, NULL, NULL, 0, 0,
99: msg, extra);
100: return;
101: }
102: ctxt->context->lastError.domain = XML_FROM_XPOINTER;
103: ctxt->context->lastError.code = error;
104: ctxt->context->lastError.level = XML_ERR_ERROR;
105: ctxt->context->lastError.str1 = (char *) xmlStrdup(ctxt->base);
106: ctxt->context->lastError.int1 = ctxt->cur - ctxt->base;
107: ctxt->context->lastError.node = ctxt->context->debugNode;
108: if (ctxt->context->error != NULL) {
109: ctxt->context->error(ctxt->context->userData,
110: &ctxt->context->lastError);
111: } else {
112: __xmlRaiseError(NULL, NULL, NULL,
113: NULL, ctxt->context->debugNode, XML_FROM_XPOINTER,
114: error, XML_ERR_ERROR, NULL, 0,
115: (const char *) extra, (const char *) ctxt->base, NULL,
116: ctxt->cur - ctxt->base, 0,
117: msg, extra);
118: }
119: }
120:
121: /************************************************************************
122: * *
123: * A few helper functions for child sequences *
124: * *
125: ************************************************************************/
126: /* xmlXPtrAdvanceNode is a private function, but used by xinclude.c */
127: xmlNodePtr xmlXPtrAdvanceNode(xmlNodePtr cur, int *level);
128: /**
129: * xmlXPtrGetArity:
130: * @cur: the node
131: *
132: * Returns the number of child for an element, -1 in case of error
133: */
134: static int
135: xmlXPtrGetArity(xmlNodePtr cur) {
136: int i;
137: if (cur == NULL)
138: return(-1);
139: cur = cur->children;
140: for (i = 0;cur != NULL;cur = cur->next) {
141: if ((cur->type == XML_ELEMENT_NODE) ||
142: (cur->type == XML_DOCUMENT_NODE) ||
143: (cur->type == XML_HTML_DOCUMENT_NODE)) {
144: i++;
145: }
146: }
147: return(i);
148: }
149:
150: /**
151: * xmlXPtrGetIndex:
152: * @cur: the node
153: *
154: * Returns the index of the node in its parent children list, -1
155: * in case of error
156: */
157: static int
158: xmlXPtrGetIndex(xmlNodePtr cur) {
159: int i;
160: if (cur == NULL)
161: return(-1);
162: for (i = 1;cur != NULL;cur = cur->prev) {
163: if ((cur->type == XML_ELEMENT_NODE) ||
164: (cur->type == XML_DOCUMENT_NODE) ||
165: (cur->type == XML_HTML_DOCUMENT_NODE)) {
166: i++;
167: }
168: }
169: return(i);
170: }
171:
172: /**
173: * xmlXPtrGetNthChild:
174: * @cur: the node
175: * @no: the child number
176: *
177: * Returns the @no'th element child of @cur or NULL
178: */
179: static xmlNodePtr
180: xmlXPtrGetNthChild(xmlNodePtr cur, int no) {
181: int i;
182: if (cur == NULL)
183: return(cur);
184: cur = cur->children;
185: for (i = 0;i <= no;cur = cur->next) {
186: if (cur == NULL)
187: return(cur);
188: if ((cur->type == XML_ELEMENT_NODE) ||
189: (cur->type == XML_DOCUMENT_NODE) ||
190: (cur->type == XML_HTML_DOCUMENT_NODE)) {
191: i++;
192: if (i == no)
193: break;
194: }
195: }
196: return(cur);
197: }
198:
199: /************************************************************************
200: * *
201: * Handling of XPointer specific types *
202: * *
203: ************************************************************************/
204:
205: /**
206: * xmlXPtrCmpPoints:
207: * @node1: the first node
208: * @index1: the first index
209: * @node2: the second node
210: * @index2: the second index
211: *
212: * Compare two points w.r.t document order
213: *
214: * Returns -2 in case of error 1 if first point < second point, 0 if
215: * that's the same point, -1 otherwise
216: */
217: static int
218: xmlXPtrCmpPoints(xmlNodePtr node1, int index1, xmlNodePtr node2, int index2) {
219: if ((node1 == NULL) || (node2 == NULL))
220: return(-2);
221: /*
222: * a couple of optimizations which will avoid computations in most cases
223: */
224: if (node1 == node2) {
225: if (index1 < index2)
226: return(1);
227: if (index1 > index2)
228: return(-1);
229: return(0);
230: }
231: return(xmlXPathCmpNodes(node1, node2));
232: }
233:
234: /**
235: * xmlXPtrNewPoint:
236: * @node: the xmlNodePtr
237: * @indx: the indx within the node
238: *
239: * Create a new xmlXPathObjectPtr of type point
240: *
241: * Returns the newly created object.
242: */
243: static xmlXPathObjectPtr
244: xmlXPtrNewPoint(xmlNodePtr node, int indx) {
245: xmlXPathObjectPtr ret;
246:
247: if (node == NULL)
248: return(NULL);
249: if (indx < 0)
250: return(NULL);
251:
252: ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
253: if (ret == NULL) {
254: xmlXPtrErrMemory("allocating point");
255: return(NULL);
256: }
257: memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
258: ret->type = XPATH_POINT;
259: ret->user = (void *) node;
260: ret->index = indx;
261: return(ret);
262: }
263:
264: /**
265: * xmlXPtrRangeCheckOrder:
266: * @range: an object range
267: *
268: * Make sure the points in the range are in the right order
269: */
270: static void
271: xmlXPtrRangeCheckOrder(xmlXPathObjectPtr range) {
272: int tmp;
273: xmlNodePtr tmp2;
274: if (range == NULL)
275: return;
276: if (range->type != XPATH_RANGE)
277: return;
278: if (range->user2 == NULL)
279: return;
280: tmp = xmlXPtrCmpPoints(range->user, range->index,
281: range->user2, range->index2);
282: if (tmp == -1) {
283: tmp2 = range->user;
284: range->user = range->user2;
285: range->user2 = tmp2;
286: tmp = range->index;
287: range->index = range->index2;
288: range->index2 = tmp;
289: }
290: }
291:
292: /**
293: * xmlXPtrRangesEqual:
294: * @range1: the first range
295: * @range2: the second range
296: *
297: * Compare two ranges
298: *
299: * Returns 1 if equal, 0 otherwise
300: */
301: static int
302: xmlXPtrRangesEqual(xmlXPathObjectPtr range1, xmlXPathObjectPtr range2) {
303: if (range1 == range2)
304: return(1);
305: if ((range1 == NULL) || (range2 == NULL))
306: return(0);
307: if (range1->type != range2->type)
308: return(0);
309: if (range1->type != XPATH_RANGE)
310: return(0);
311: if (range1->user != range2->user)
312: return(0);
313: if (range1->index != range2->index)
314: return(0);
315: if (range1->user2 != range2->user2)
316: return(0);
317: if (range1->index2 != range2->index2)
318: return(0);
319: return(1);
320: }
321:
322: /**
323: * xmlXPtrNewRange:
324: * @start: the starting node
325: * @startindex: the start index
326: * @end: the ending point
327: * @endindex: the ending index
328: *
329: * Create a new xmlXPathObjectPtr of type range
330: *
331: * Returns the newly created object.
332: */
333: xmlXPathObjectPtr
334: xmlXPtrNewRange(xmlNodePtr start, int startindex,
335: xmlNodePtr end, int endindex) {
336: xmlXPathObjectPtr ret;
337:
338: if (start == NULL)
339: return(NULL);
340: if (end == NULL)
341: return(NULL);
342: if (startindex < 0)
343: return(NULL);
344: if (endindex < 0)
345: return(NULL);
346:
347: ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
348: if (ret == NULL) {
349: xmlXPtrErrMemory("allocating range");
350: return(NULL);
351: }
352: memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
353: ret->type = XPATH_RANGE;
354: ret->user = start;
355: ret->index = startindex;
356: ret->user2 = end;
357: ret->index2 = endindex;
358: xmlXPtrRangeCheckOrder(ret);
359: return(ret);
360: }
361:
362: /**
363: * xmlXPtrNewRangePoints:
364: * @start: the starting point
365: * @end: the ending point
366: *
367: * Create a new xmlXPathObjectPtr of type range using 2 Points
368: *
369: * Returns the newly created object.
370: */
371: xmlXPathObjectPtr
372: xmlXPtrNewRangePoints(xmlXPathObjectPtr start, xmlXPathObjectPtr end) {
373: xmlXPathObjectPtr ret;
374:
375: if (start == NULL)
376: return(NULL);
377: if (end == NULL)
378: return(NULL);
379: if (start->type != XPATH_POINT)
380: return(NULL);
381: if (end->type != XPATH_POINT)
382: return(NULL);
383:
384: ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
385: if (ret == NULL) {
386: xmlXPtrErrMemory("allocating range");
387: return(NULL);
388: }
389: memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
390: ret->type = XPATH_RANGE;
391: ret->user = start->user;
392: ret->index = start->index;
393: ret->user2 = end->user;
394: ret->index2 = end->index;
395: xmlXPtrRangeCheckOrder(ret);
396: return(ret);
397: }
398:
399: /**
400: * xmlXPtrNewRangePointNode:
401: * @start: the starting point
402: * @end: the ending node
403: *
404: * Create a new xmlXPathObjectPtr of type range from a point to a node
405: *
406: * Returns the newly created object.
407: */
408: xmlXPathObjectPtr
409: xmlXPtrNewRangePointNode(xmlXPathObjectPtr start, xmlNodePtr end) {
410: xmlXPathObjectPtr ret;
411:
412: if (start == NULL)
413: return(NULL);
414: if (end == NULL)
415: return(NULL);
416: if (start->type != XPATH_POINT)
417: return(NULL);
418:
419: ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
420: if (ret == NULL) {
421: xmlXPtrErrMemory("allocating range");
422: return(NULL);
423: }
424: memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
425: ret->type = XPATH_RANGE;
426: ret->user = start->user;
427: ret->index = start->index;
428: ret->user2 = end;
429: ret->index2 = -1;
430: xmlXPtrRangeCheckOrder(ret);
431: return(ret);
432: }
433:
434: /**
435: * xmlXPtrNewRangeNodePoint:
436: * @start: the starting node
437: * @end: the ending point
438: *
439: * Create a new xmlXPathObjectPtr of type range from a node to a point
440: *
441: * Returns the newly created object.
442: */
443: xmlXPathObjectPtr
444: xmlXPtrNewRangeNodePoint(xmlNodePtr start, xmlXPathObjectPtr end) {
445: xmlXPathObjectPtr ret;
446:
447: if (start == NULL)
448: return(NULL);
449: if (end == NULL)
450: return(NULL);
451: if (start->type != XPATH_POINT)
452: return(NULL);
453: if (end->type != XPATH_POINT)
454: return(NULL);
455:
456: ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
457: if (ret == NULL) {
458: xmlXPtrErrMemory("allocating range");
459: return(NULL);
460: }
461: memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
462: ret->type = XPATH_RANGE;
463: ret->user = start;
464: ret->index = -1;
465: ret->user2 = end->user;
466: ret->index2 = end->index;
467: xmlXPtrRangeCheckOrder(ret);
468: return(ret);
469: }
470:
471: /**
472: * xmlXPtrNewRangeNodes:
473: * @start: the starting node
474: * @end: the ending node
475: *
476: * Create a new xmlXPathObjectPtr of type range using 2 nodes
477: *
478: * Returns the newly created object.
479: */
480: xmlXPathObjectPtr
481: xmlXPtrNewRangeNodes(xmlNodePtr start, xmlNodePtr end) {
482: xmlXPathObjectPtr ret;
483:
484: if (start == NULL)
485: return(NULL);
486: if (end == NULL)
487: return(NULL);
488:
489: ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
490: if (ret == NULL) {
491: xmlXPtrErrMemory("allocating range");
492: return(NULL);
493: }
494: memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
495: ret->type = XPATH_RANGE;
496: ret->user = start;
497: ret->index = -1;
498: ret->user2 = end;
499: ret->index2 = -1;
500: xmlXPtrRangeCheckOrder(ret);
501: return(ret);
502: }
503:
504: /**
505: * xmlXPtrNewCollapsedRange:
506: * @start: the starting and ending node
507: *
508: * Create a new xmlXPathObjectPtr of type range using a single nodes
509: *
510: * Returns the newly created object.
511: */
512: xmlXPathObjectPtr
513: xmlXPtrNewCollapsedRange(xmlNodePtr start) {
514: xmlXPathObjectPtr ret;
515:
516: if (start == NULL)
517: return(NULL);
518:
519: ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
520: if (ret == NULL) {
521: xmlXPtrErrMemory("allocating range");
522: return(NULL);
523: }
524: memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
525: ret->type = XPATH_RANGE;
526: ret->user = start;
527: ret->index = -1;
528: ret->user2 = NULL;
529: ret->index2 = -1;
530: return(ret);
531: }
532:
533: /**
534: * xmlXPtrNewRangeNodeObject:
535: * @start: the starting node
536: * @end: the ending object
537: *
538: * Create a new xmlXPathObjectPtr of type range from a not to an object
539: *
540: * Returns the newly created object.
541: */
542: xmlXPathObjectPtr
543: xmlXPtrNewRangeNodeObject(xmlNodePtr start, xmlXPathObjectPtr end) {
544: xmlXPathObjectPtr ret;
545:
546: if (start == NULL)
547: return(NULL);
548: if (end == NULL)
549: return(NULL);
550: switch (end->type) {
551: case XPATH_POINT:
552: case XPATH_RANGE:
553: break;
554: case XPATH_NODESET:
555: /*
556: * Empty set ...
557: */
558: if (end->nodesetval->nodeNr <= 0)
559: return(NULL);
560: break;
561: default:
562: /* TODO */
563: return(NULL);
564: }
565:
566: ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
567: if (ret == NULL) {
568: xmlXPtrErrMemory("allocating range");
569: return(NULL);
570: }
571: memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
572: ret->type = XPATH_RANGE;
573: ret->user = start;
574: ret->index = -1;
575: switch (end->type) {
576: case XPATH_POINT:
577: ret->user2 = end->user;
578: ret->index2 = end->index;
579: break;
580: case XPATH_RANGE:
581: ret->user2 = end->user2;
582: ret->index2 = end->index2;
583: break;
584: case XPATH_NODESET: {
585: ret->user2 = end->nodesetval->nodeTab[end->nodesetval->nodeNr - 1];
586: ret->index2 = -1;
587: break;
588: }
589: default:
590: STRANGE
591: return(NULL);
592: }
593: xmlXPtrRangeCheckOrder(ret);
594: return(ret);
595: }
596:
597: #define XML_RANGESET_DEFAULT 10
598:
599: /**
600: * xmlXPtrLocationSetCreate:
601: * @val: an initial xmlXPathObjectPtr, or NULL
602: *
603: * Create a new xmlLocationSetPtr of type double and of value @val
604: *
605: * Returns the newly created object.
606: */
607: xmlLocationSetPtr
608: xmlXPtrLocationSetCreate(xmlXPathObjectPtr val) {
609: xmlLocationSetPtr ret;
610:
611: ret = (xmlLocationSetPtr) xmlMalloc(sizeof(xmlLocationSet));
612: if (ret == NULL) {
613: xmlXPtrErrMemory("allocating locationset");
614: return(NULL);
615: }
616: memset(ret, 0 , (size_t) sizeof(xmlLocationSet));
617: if (val != NULL) {
618: ret->locTab = (xmlXPathObjectPtr *) xmlMalloc(XML_RANGESET_DEFAULT *
619: sizeof(xmlXPathObjectPtr));
620: if (ret->locTab == NULL) {
621: xmlXPtrErrMemory("allocating locationset");
622: xmlFree(ret);
623: return(NULL);
624: }
625: memset(ret->locTab, 0 ,
626: XML_RANGESET_DEFAULT * (size_t) sizeof(xmlXPathObjectPtr));
627: ret->locMax = XML_RANGESET_DEFAULT;
628: ret->locTab[ret->locNr++] = val;
629: }
630: return(ret);
631: }
632:
633: /**
634: * xmlXPtrLocationSetAdd:
635: * @cur: the initial range set
636: * @val: a new xmlXPathObjectPtr
637: *
638: * add a new xmlXPathObjectPtr to an existing LocationSet
639: * If the location already exist in the set @val is freed.
640: */
641: void
642: xmlXPtrLocationSetAdd(xmlLocationSetPtr cur, xmlXPathObjectPtr val) {
643: int i;
644:
645: if ((cur == NULL) || (val == NULL)) return;
646:
647: /*
648: * check against doublons
649: */
650: for (i = 0;i < cur->locNr;i++) {
651: if (xmlXPtrRangesEqual(cur->locTab[i], val)) {
652: xmlXPathFreeObject(val);
653: return;
654: }
655: }
656:
657: /*
658: * grow the locTab if needed
659: */
660: if (cur->locMax == 0) {
661: cur->locTab = (xmlXPathObjectPtr *) xmlMalloc(XML_RANGESET_DEFAULT *
662: sizeof(xmlXPathObjectPtr));
663: if (cur->locTab == NULL) {
664: xmlXPtrErrMemory("adding location to set");
665: return;
666: }
667: memset(cur->locTab, 0 ,
668: XML_RANGESET_DEFAULT * (size_t) sizeof(xmlXPathObjectPtr));
669: cur->locMax = XML_RANGESET_DEFAULT;
670: } else if (cur->locNr == cur->locMax) {
671: xmlXPathObjectPtr *temp;
672:
673: cur->locMax *= 2;
674: temp = (xmlXPathObjectPtr *) xmlRealloc(cur->locTab, cur->locMax *
675: sizeof(xmlXPathObjectPtr));
676: if (temp == NULL) {
677: xmlXPtrErrMemory("adding location to set");
678: return;
679: }
680: cur->locTab = temp;
681: }
682: cur->locTab[cur->locNr++] = val;
683: }
684:
685: /**
686: * xmlXPtrLocationSetMerge:
687: * @val1: the first LocationSet
688: * @val2: the second LocationSet
689: *
690: * Merges two rangesets, all ranges from @val2 are added to @val1
691: *
692: * Returns val1 once extended or NULL in case of error.
693: */
694: xmlLocationSetPtr
695: xmlXPtrLocationSetMerge(xmlLocationSetPtr val1, xmlLocationSetPtr val2) {
696: int i;
697:
698: if (val1 == NULL) return(NULL);
699: if (val2 == NULL) return(val1);
700:
701: /*
702: * !!!!! this can be optimized a lot, knowing that both
703: * val1 and val2 already have unicity of their values.
704: */
705:
706: for (i = 0;i < val2->locNr;i++)
707: xmlXPtrLocationSetAdd(val1, val2->locTab[i]);
708:
709: return(val1);
710: }
711:
712: /**
713: * xmlXPtrLocationSetDel:
714: * @cur: the initial range set
715: * @val: an xmlXPathObjectPtr
716: *
717: * Removes an xmlXPathObjectPtr from an existing LocationSet
718: */
719: void
720: xmlXPtrLocationSetDel(xmlLocationSetPtr cur, xmlXPathObjectPtr val) {
721: int i;
722:
723: if (cur == NULL) return;
724: if (val == NULL) return;
725:
726: /*
727: * check against doublons
728: */
729: for (i = 0;i < cur->locNr;i++)
730: if (cur->locTab[i] == val) break;
731:
732: if (i >= cur->locNr) {
733: #ifdef DEBUG
734: xmlGenericError(xmlGenericErrorContext,
735: "xmlXPtrLocationSetDel: Range wasn't found in RangeList\n");
736: #endif
737: return;
738: }
739: cur->locNr--;
740: for (;i < cur->locNr;i++)
741: cur->locTab[i] = cur->locTab[i + 1];
742: cur->locTab[cur->locNr] = NULL;
743: }
744:
745: /**
746: * xmlXPtrLocationSetRemove:
747: * @cur: the initial range set
748: * @val: the index to remove
749: *
750: * Removes an entry from an existing LocationSet list.
751: */
752: void
753: xmlXPtrLocationSetRemove(xmlLocationSetPtr cur, int val) {
754: if (cur == NULL) return;
755: if (val >= cur->locNr) return;
756: cur->locNr--;
757: for (;val < cur->locNr;val++)
758: cur->locTab[val] = cur->locTab[val + 1];
759: cur->locTab[cur->locNr] = NULL;
760: }
761:
762: /**
763: * xmlXPtrFreeLocationSet:
764: * @obj: the xmlLocationSetPtr to free
765: *
766: * Free the LocationSet compound (not the actual ranges !).
767: */
768: void
769: xmlXPtrFreeLocationSet(xmlLocationSetPtr obj) {
770: int i;
771:
772: if (obj == NULL) return;
773: if (obj->locTab != NULL) {
774: for (i = 0;i < obj->locNr; i++) {
775: xmlXPathFreeObject(obj->locTab[i]);
776: }
777: xmlFree(obj->locTab);
778: }
779: xmlFree(obj);
780: }
781:
782: /**
783: * xmlXPtrNewLocationSetNodes:
784: * @start: the start NodePtr value
785: * @end: the end NodePtr value or NULL
786: *
787: * Create a new xmlXPathObjectPtr of type LocationSet and initialize
788: * it with the single range made of the two nodes @start and @end
789: *
790: * Returns the newly created object.
791: */
792: xmlXPathObjectPtr
793: xmlXPtrNewLocationSetNodes(xmlNodePtr start, xmlNodePtr end) {
794: xmlXPathObjectPtr ret;
795:
796: ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
797: if (ret == NULL) {
798: xmlXPtrErrMemory("allocating locationset");
799: return(NULL);
800: }
801: memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
802: ret->type = XPATH_LOCATIONSET;
803: if (end == NULL)
804: ret->user = xmlXPtrLocationSetCreate(xmlXPtrNewCollapsedRange(start));
805: else
806: ret->user = xmlXPtrLocationSetCreate(xmlXPtrNewRangeNodes(start,end));
807: return(ret);
808: }
809:
810: /**
811: * xmlXPtrNewLocationSetNodeSet:
812: * @set: a node set
813: *
814: * Create a new xmlXPathObjectPtr of type LocationSet and initialize
815: * it with all the nodes from @set
816: *
817: * Returns the newly created object.
818: */
819: xmlXPathObjectPtr
820: xmlXPtrNewLocationSetNodeSet(xmlNodeSetPtr set) {
821: xmlXPathObjectPtr ret;
822:
823: ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
824: if (ret == NULL) {
825: xmlXPtrErrMemory("allocating locationset");
826: return(NULL);
827: }
828: memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
829: ret->type = XPATH_LOCATIONSET;
830: if (set != NULL) {
831: int i;
832: xmlLocationSetPtr newset;
833:
834: newset = xmlXPtrLocationSetCreate(NULL);
835: if (newset == NULL)
836: return(ret);
837:
838: for (i = 0;i < set->nodeNr;i++)
839: xmlXPtrLocationSetAdd(newset,
840: xmlXPtrNewCollapsedRange(set->nodeTab[i]));
841:
842: ret->user = (void *) newset;
843: }
844: return(ret);
845: }
846:
847: /**
848: * xmlXPtrWrapLocationSet:
849: * @val: the LocationSet value
850: *
851: * Wrap the LocationSet @val in a new xmlXPathObjectPtr
852: *
853: * Returns the newly created object.
854: */
855: xmlXPathObjectPtr
856: xmlXPtrWrapLocationSet(xmlLocationSetPtr val) {
857: xmlXPathObjectPtr ret;
858:
859: ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
860: if (ret == NULL) {
861: xmlXPtrErrMemory("allocating locationset");
862: return(NULL);
863: }
864: memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
865: ret->type = XPATH_LOCATIONSET;
866: ret->user = (void *) val;
867: return(ret);
868: }
869:
870: /************************************************************************
871: * *
872: * The parser *
873: * *
874: ************************************************************************/
875:
876: static void xmlXPtrEvalChildSeq(xmlXPathParserContextPtr ctxt, xmlChar *name);
877:
878: /*
879: * Macros for accessing the content. Those should be used only by the parser,
880: * and not exported.
881: *
882: * Dirty macros, i.e. one need to make assumption on the context to use them
883: *
884: * CUR_PTR return the current pointer to the xmlChar to be parsed.
885: * CUR returns the current xmlChar value, i.e. a 8 bit value
886: * in ISO-Latin or UTF-8.
887: * This should be used internally by the parser
888: * only to compare to ASCII values otherwise it would break when
889: * running with UTF-8 encoding.
890: * NXT(n) returns the n'th next xmlChar. Same as CUR is should be used only
891: * to compare on ASCII based substring.
892: * SKIP(n) Skip n xmlChar, and must also be used only to skip ASCII defined
893: * strings within the parser.
894: * CURRENT Returns the current char value, with the full decoding of
895: * UTF-8 if we are using this mode. It returns an int.
896: * NEXT Skip to the next character, this does the proper decoding
897: * in UTF-8 mode. It also pop-up unfinished entities on the fly.
898: * It returns the pointer to the current xmlChar.
899: */
900:
901: #define CUR (*ctxt->cur)
902: #define SKIP(val) ctxt->cur += (val)
903: #define NXT(val) ctxt->cur[(val)]
904: #define CUR_PTR ctxt->cur
905:
906: #define SKIP_BLANKS \
907: while (IS_BLANK_CH(*(ctxt->cur))) NEXT
908:
909: #define CURRENT (*ctxt->cur)
910: #define NEXT ((*ctxt->cur) ? ctxt->cur++: ctxt->cur)
911:
912: /*
913: * xmlXPtrGetChildNo:
914: * @ctxt: the XPointer Parser context
915: * @index: the child number
916: *
917: * Move the current node of the nodeset on the stack to the
918: * given child if found
919: */
920: static void
921: xmlXPtrGetChildNo(xmlXPathParserContextPtr ctxt, int indx) {
922: xmlNodePtr cur = NULL;
923: xmlXPathObjectPtr obj;
924: xmlNodeSetPtr oldset;
925:
926: CHECK_TYPE(XPATH_NODESET);
927: obj = valuePop(ctxt);
928: oldset = obj->nodesetval;
929: if ((indx <= 0) || (oldset == NULL) || (oldset->nodeNr != 1)) {
930: xmlXPathFreeObject(obj);
931: valuePush(ctxt, xmlXPathNewNodeSet(NULL));
932: return;
933: }
934: cur = xmlXPtrGetNthChild(oldset->nodeTab[0], indx);
935: if (cur == NULL) {
936: xmlXPathFreeObject(obj);
937: valuePush(ctxt, xmlXPathNewNodeSet(NULL));
938: return;
939: }
940: oldset->nodeTab[0] = cur;
941: valuePush(ctxt, obj);
942: }
943:
944: /**
945: * xmlXPtrEvalXPtrPart:
946: * @ctxt: the XPointer Parser context
947: * @name: the preparsed Scheme for the XPtrPart
948: *
949: * XPtrPart ::= 'xpointer' '(' XPtrExpr ')'
950: * | Scheme '(' SchemeSpecificExpr ')'
951: *
952: * Scheme ::= NCName - 'xpointer' [VC: Non-XPointer schemes]
953: *
954: * SchemeSpecificExpr ::= StringWithBalancedParens
955: *
956: * StringWithBalancedParens ::=
957: * [^()]* ('(' StringWithBalancedParens ')' [^()]*)*
958: * [VC: Parenthesis escaping]
959: *
960: * XPtrExpr ::= Expr [VC: Parenthesis escaping]
961: *
962: * VC: Parenthesis escaping:
963: * The end of an XPointer part is signaled by the right parenthesis ")"
964: * character that is balanced with the left parenthesis "(" character
965: * that began the part. Any unbalanced parenthesis character inside the
966: * expression, even within literals, must be escaped with a circumflex (^)
967: * character preceding it. If the expression contains any literal
968: * occurrences of the circumflex, each must be escaped with an additional
969: * circumflex (that is, ^^). If the unescaped parentheses in the expression
970: * are not balanced, a syntax error results.
971: *
972: * Parse and evaluate an XPtrPart. Basically it generates the unescaped
973: * string and if the scheme is 'xpointer' it will call the XPath interpreter.
974: *
975: * TODO: there is no new scheme registration mechanism
976: */
977:
978: static void
979: xmlXPtrEvalXPtrPart(xmlXPathParserContextPtr ctxt, xmlChar *name) {
980: xmlChar *buffer, *cur;
981: int len;
982: int level;
983:
984: if (name == NULL)
985: name = xmlXPathParseName(ctxt);
986: if (name == NULL)
987: XP_ERROR(XPATH_EXPR_ERROR);
988:
989: if (CUR != '(')
990: XP_ERROR(XPATH_EXPR_ERROR);
991: NEXT;
992: level = 1;
993:
994: len = xmlStrlen(ctxt->cur);
995: len++;
996: buffer = (xmlChar *) xmlMallocAtomic(len * sizeof (xmlChar));
997: if (buffer == NULL) {
998: xmlXPtrErrMemory("allocating buffer");
999: return;
1000: }
1001:
1002: cur = buffer;
1003: while (CUR != 0) {
1004: if (CUR == ')') {
1005: level--;
1006: if (level == 0) {
1007: NEXT;
1008: break;
1009: }
1010: *cur++ = CUR;
1011: } else if (CUR == '(') {
1012: level++;
1013: *cur++ = CUR;
1014: } else if (CUR == '^') {
1015: NEXT;
1016: if ((CUR == ')') || (CUR == '(') || (CUR == '^')) {
1017: *cur++ = CUR;
1018: } else {
1019: *cur++ = '^';
1020: *cur++ = CUR;
1021: }
1022: } else {
1023: *cur++ = CUR;
1024: }
1025: NEXT;
1026: }
1027: *cur = 0;
1028:
1029: if ((level != 0) && (CUR == 0)) {
1030: xmlFree(buffer);
1031: XP_ERROR(XPTR_SYNTAX_ERROR);
1032: }
1033:
1034: if (xmlStrEqual(name, (xmlChar *) "xpointer")) {
1035: const xmlChar *left = CUR_PTR;
1036:
1037: CUR_PTR = buffer;
1038: /*
1039: * To evaluate an xpointer scheme element (4.3) we need:
1040: * context initialized to the root
1041: * context position initalized to 1
1042: * context size initialized to 1
1043: */
1044: ctxt->context->node = (xmlNodePtr)ctxt->context->doc;
1045: ctxt->context->proximityPosition = 1;
1046: ctxt->context->contextSize = 1;
1047: xmlXPathEvalExpr(ctxt);
1048: CUR_PTR=left;
1049: } else if (xmlStrEqual(name, (xmlChar *) "element")) {
1050: const xmlChar *left = CUR_PTR;
1051: xmlChar *name2;
1052:
1053: CUR_PTR = buffer;
1054: if (buffer[0] == '/') {
1055: xmlXPathRoot(ctxt);
1056: xmlXPtrEvalChildSeq(ctxt, NULL);
1057: } else {
1058: name2 = xmlXPathParseName(ctxt);
1059: if (name2 == NULL) {
1060: CUR_PTR = left;
1061: xmlFree(buffer);
1062: XP_ERROR(XPATH_EXPR_ERROR);
1063: }
1064: xmlXPtrEvalChildSeq(ctxt, name2);
1065: }
1066: CUR_PTR = left;
1067: #ifdef XPTR_XMLNS_SCHEME
1068: } else if (xmlStrEqual(name, (xmlChar *) "xmlns")) {
1069: const xmlChar *left = CUR_PTR;
1070: xmlChar *prefix;
1071: xmlChar *URI;
1072: xmlURIPtr value;
1073:
1074: CUR_PTR = buffer;
1075: prefix = xmlXPathParseNCName(ctxt);
1076: if (prefix == NULL) {
1077: xmlFree(buffer);
1078: xmlFree(name);
1079: XP_ERROR(XPTR_SYNTAX_ERROR);
1080: }
1081: SKIP_BLANKS;
1082: if (CUR != '=') {
1083: xmlFree(prefix);
1084: xmlFree(buffer);
1085: xmlFree(name);
1086: XP_ERROR(XPTR_SYNTAX_ERROR);
1087: }
1088: NEXT;
1089: SKIP_BLANKS;
1090: /* @@ check escaping in the XPointer WD */
1091:
1092: value = xmlParseURI((const char *)ctxt->cur);
1093: if (value == NULL) {
1094: xmlFree(prefix);
1095: xmlFree(buffer);
1096: xmlFree(name);
1097: XP_ERROR(XPTR_SYNTAX_ERROR);
1098: }
1099: URI = xmlSaveUri(value);
1100: xmlFreeURI(value);
1101: if (URI == NULL) {
1102: xmlFree(prefix);
1103: xmlFree(buffer);
1104: xmlFree(name);
1105: XP_ERROR(XPATH_MEMORY_ERROR);
1106: }
1107:
1108: xmlXPathRegisterNs(ctxt->context, prefix, URI);
1109: CUR_PTR = left;
1110: xmlFree(URI);
1111: xmlFree(prefix);
1112: #endif /* XPTR_XMLNS_SCHEME */
1113: } else {
1114: xmlXPtrErr(ctxt, XML_XPTR_UNKNOWN_SCHEME,
1115: "unsupported scheme '%s'\n", name);
1116: }
1117: xmlFree(buffer);
1118: xmlFree(name);
1119: }
1120:
1121: /**
1122: * xmlXPtrEvalFullXPtr:
1123: * @ctxt: the XPointer Parser context
1124: * @name: the preparsed Scheme for the first XPtrPart
1125: *
1126: * FullXPtr ::= XPtrPart (S? XPtrPart)*
1127: *
1128: * As the specs says:
1129: * -----------
1130: * When multiple XPtrParts are provided, they must be evaluated in
1131: * left-to-right order. If evaluation of one part fails, the nexti
1132: * is evaluated. The following conditions cause XPointer part failure:
1133: *
1134: * - An unknown scheme
1135: * - A scheme that does not locate any sub-resource present in the resource
1136: * - A scheme that is not applicable to the media type of the resource
1137: *
1138: * The XPointer application must consume a failed XPointer part and
1139: * attempt to evaluate the next one, if any. The result of the first
1140: * XPointer part whose evaluation succeeds is taken to be the fragment
1141: * located by the XPointer as a whole. If all the parts fail, the result
1142: * for the XPointer as a whole is a sub-resource error.
1143: * -----------
1144: *
1145: * Parse and evaluate a Full XPtr i.e. possibly a cascade of XPath based
1146: * expressions or other schemes.
1147: */
1148: static void
1149: xmlXPtrEvalFullXPtr(xmlXPathParserContextPtr ctxt, xmlChar *name) {
1150: if (name == NULL)
1151: name = xmlXPathParseName(ctxt);
1152: if (name == NULL)
1153: XP_ERROR(XPATH_EXPR_ERROR);
1154: while (name != NULL) {
1155: ctxt->error = XPATH_EXPRESSION_OK;
1156: xmlXPtrEvalXPtrPart(ctxt, name);
1157:
1158: /* in case of syntax error, break here */
1159: if ((ctxt->error != XPATH_EXPRESSION_OK) &&
1160: (ctxt->error != XML_XPTR_UNKNOWN_SCHEME))
1161: return;
1162:
1163: /*
1164: * If the returned value is a non-empty nodeset
1165: * or location set, return here.
1166: */
1167: if (ctxt->value != NULL) {
1168: xmlXPathObjectPtr obj = ctxt->value;
1169:
1170: switch (obj->type) {
1171: case XPATH_LOCATIONSET: {
1172: xmlLocationSetPtr loc = ctxt->value->user;
1173: if ((loc != NULL) && (loc->locNr > 0))
1174: return;
1175: break;
1176: }
1177: case XPATH_NODESET: {
1178: xmlNodeSetPtr loc = ctxt->value->nodesetval;
1179: if ((loc != NULL) && (loc->nodeNr > 0))
1180: return;
1181: break;
1182: }
1183: default:
1184: break;
1185: }
1186:
1187: /*
1188: * Evaluating to improper values is equivalent to
1189: * a sub-resource error, clean-up the stack
1190: */
1191: do {
1192: obj = valuePop(ctxt);
1193: if (obj != NULL) {
1194: xmlXPathFreeObject(obj);
1195: }
1196: } while (obj != NULL);
1197: }
1198:
1199: /*
1200: * Is there another XPointer part.
1201: */
1202: SKIP_BLANKS;
1203: name = xmlXPathParseName(ctxt);
1204: }
1205: }
1206:
1207: /**
1208: * xmlXPtrEvalChildSeq:
1209: * @ctxt: the XPointer Parser context
1210: * @name: a possible ID name of the child sequence
1211: *
1212: * ChildSeq ::= '/1' ('/' [0-9]*)*
1213: * | Name ('/' [0-9]*)+
1214: *
1215: * Parse and evaluate a Child Sequence. This routine also handle the
1216: * case of a Bare Name used to get a document ID.
1217: */
1218: static void
1219: xmlXPtrEvalChildSeq(xmlXPathParserContextPtr ctxt, xmlChar *name) {
1220: /*
1221: * XPointer don't allow by syntax to address in mutirooted trees
1222: * this might prove useful in some cases, warn about it.
1223: */
1224: if ((name == NULL) && (CUR == '/') && (NXT(1) != '1')) {
1225: xmlXPtrErr(ctxt, XML_XPTR_CHILDSEQ_START,
1226: "warning: ChildSeq not starting by /1\n", NULL);
1227: }
1228:
1229: if (name != NULL) {
1230: valuePush(ctxt, xmlXPathNewString(name));
1231: xmlFree(name);
1232: xmlXPathIdFunction(ctxt, 1);
1233: CHECK_ERROR;
1234: }
1235:
1236: while (CUR == '/') {
1237: int child = 0;
1238: NEXT;
1239:
1240: while ((CUR >= '0') && (CUR <= '9')) {
1241: child = child * 10 + (CUR - '0');
1242: NEXT;
1243: }
1244: xmlXPtrGetChildNo(ctxt, child);
1245: }
1246: }
1247:
1248:
1249: /**
1250: * xmlXPtrEvalXPointer:
1251: * @ctxt: the XPointer Parser context
1252: *
1253: * XPointer ::= Name
1254: * | ChildSeq
1255: * | FullXPtr
1256: *
1257: * Parse and evaluate an XPointer
1258: */
1259: static void
1260: xmlXPtrEvalXPointer(xmlXPathParserContextPtr ctxt) {
1261: if (ctxt->valueTab == NULL) {
1262: /* Allocate the value stack */
1263: ctxt->valueTab = (xmlXPathObjectPtr *)
1264: xmlMalloc(10 * sizeof(xmlXPathObjectPtr));
1265: if (ctxt->valueTab == NULL) {
1266: xmlXPtrErrMemory("allocating evaluation context");
1267: return;
1268: }
1269: ctxt->valueNr = 0;
1270: ctxt->valueMax = 10;
1271: ctxt->value = NULL;
1272: }
1273: SKIP_BLANKS;
1274: if (CUR == '/') {
1275: xmlXPathRoot(ctxt);
1276: xmlXPtrEvalChildSeq(ctxt, NULL);
1277: } else {
1278: xmlChar *name;
1279:
1280: name = xmlXPathParseName(ctxt);
1281: if (name == NULL)
1282: XP_ERROR(XPATH_EXPR_ERROR);
1283: if (CUR == '(') {
1284: xmlXPtrEvalFullXPtr(ctxt, name);
1285: /* Short evaluation */
1286: return;
1287: } else {
1288: /* this handle both Bare Names and Child Sequences */
1289: xmlXPtrEvalChildSeq(ctxt, name);
1290: }
1291: }
1292: SKIP_BLANKS;
1293: if (CUR != 0)
1294: XP_ERROR(XPATH_EXPR_ERROR);
1295: }
1296:
1297:
1298: /************************************************************************
1299: * *
1300: * General routines *
1301: * *
1302: ************************************************************************/
1303:
1304: static
1305: void xmlXPtrStringRangeFunction(xmlXPathParserContextPtr ctxt, int nargs);
1306: static
1307: void xmlXPtrStartPointFunction(xmlXPathParserContextPtr ctxt, int nargs);
1308: static
1309: void xmlXPtrEndPointFunction(xmlXPathParserContextPtr ctxt, int nargs);
1310: static
1311: void xmlXPtrHereFunction(xmlXPathParserContextPtr ctxt, int nargs);
1312: static
1313: void xmlXPtrOriginFunction(xmlXPathParserContextPtr ctxt, int nargs);
1314: static
1315: void xmlXPtrRangeInsideFunction(xmlXPathParserContextPtr ctxt, int nargs);
1316: static
1317: void xmlXPtrRangeFunction(xmlXPathParserContextPtr ctxt, int nargs);
1318:
1319: /**
1320: * xmlXPtrNewContext:
1321: * @doc: the XML document
1322: * @here: the node that directly contains the XPointer being evaluated or NULL
1323: * @origin: the element from which a user or program initiated traversal of
1324: * the link, or NULL.
1325: *
1326: * Create a new XPointer context
1327: *
1328: * Returns the xmlXPathContext just allocated.
1329: */
1330: xmlXPathContextPtr
1331: xmlXPtrNewContext(xmlDocPtr doc, xmlNodePtr here, xmlNodePtr origin) {
1332: xmlXPathContextPtr ret;
1333:
1334: ret = xmlXPathNewContext(doc);
1335: if (ret == NULL)
1336: return(ret);
1337: ret->xptr = 1;
1338: ret->here = here;
1339: ret->origin = origin;
1340:
1341: xmlXPathRegisterFunc(ret, (xmlChar *)"range-to",
1342: xmlXPtrRangeToFunction);
1343: xmlXPathRegisterFunc(ret, (xmlChar *)"range",
1344: xmlXPtrRangeFunction);
1345: xmlXPathRegisterFunc(ret, (xmlChar *)"range-inside",
1346: xmlXPtrRangeInsideFunction);
1347: xmlXPathRegisterFunc(ret, (xmlChar *)"string-range",
1348: xmlXPtrStringRangeFunction);
1349: xmlXPathRegisterFunc(ret, (xmlChar *)"start-point",
1350: xmlXPtrStartPointFunction);
1351: xmlXPathRegisterFunc(ret, (xmlChar *)"end-point",
1352: xmlXPtrEndPointFunction);
1353: xmlXPathRegisterFunc(ret, (xmlChar *)"here",
1354: xmlXPtrHereFunction);
1355: xmlXPathRegisterFunc(ret, (xmlChar *)" origin",
1356: xmlXPtrOriginFunction);
1357:
1358: return(ret);
1359: }
1360:
1361: /**
1362: * xmlXPtrEval:
1363: * @str: the XPointer expression
1364: * @ctx: the XPointer context
1365: *
1366: * Evaluate the XPath Location Path in the given context.
1367: *
1368: * Returns the xmlXPathObjectPtr resulting from the evaluation or NULL.
1369: * the caller has to free the object.
1370: */
1371: xmlXPathObjectPtr
1372: xmlXPtrEval(const xmlChar *str, xmlXPathContextPtr ctx) {
1373: xmlXPathParserContextPtr ctxt;
1374: xmlXPathObjectPtr res = NULL, tmp;
1375: xmlXPathObjectPtr init = NULL;
1376: int stack = 0;
1377:
1378: xmlXPathInit();
1379:
1380: if ((ctx == NULL) || (str == NULL))
1381: return(NULL);
1382:
1383: ctxt = xmlXPathNewParserContext(str, ctx);
1384: ctxt->xptr = 1;
1385: xmlXPtrEvalXPointer(ctxt);
1386:
1387: if ((ctxt->value != NULL) &&
1388: (ctxt->value->type != XPATH_NODESET) &&
1389: (ctxt->value->type != XPATH_LOCATIONSET)) {
1390: xmlXPtrErr(ctxt, XML_XPTR_EVAL_FAILED,
1391: "xmlXPtrEval: evaluation failed to return a node set\n",
1392: NULL);
1393: } else {
1394: res = valuePop(ctxt);
1395: }
1396:
1397: do {
1398: tmp = valuePop(ctxt);
1399: if (tmp != NULL) {
1400: if (tmp != init) {
1401: if (tmp->type == XPATH_NODESET) {
1402: /*
1403: * Evaluation may push a root nodeset which is unused
1404: */
1405: xmlNodeSetPtr set;
1406: set = tmp->nodesetval;
1407: if ((set->nodeNr != 1) ||
1408: (set->nodeTab[0] != (xmlNodePtr) ctx->doc))
1409: stack++;
1410: } else
1411: stack++;
1412: }
1413: xmlXPathFreeObject(tmp);
1414: }
1415: } while (tmp != NULL);
1416: if (stack != 0) {
1417: xmlXPtrErr(ctxt, XML_XPTR_EXTRA_OBJECTS,
1418: "xmlXPtrEval: object(s) left on the eval stack\n",
1419: NULL);
1420: }
1421: if (ctxt->error != XPATH_EXPRESSION_OK) {
1422: xmlXPathFreeObject(res);
1423: res = NULL;
1424: }
1425:
1426: xmlXPathFreeParserContext(ctxt);
1427: return(res);
1428: }
1429:
1430: /**
1431: * xmlXPtrBuildRangeNodeList:
1432: * @range: a range object
1433: *
1434: * Build a node list tree copy of the range
1435: *
1436: * Returns an xmlNodePtr list or NULL.
1437: * the caller has to free the node tree.
1438: */
1439: static xmlNodePtr
1440: xmlXPtrBuildRangeNodeList(xmlXPathObjectPtr range) {
1441: /* pointers to generated nodes */
1442: xmlNodePtr list = NULL, last = NULL, parent = NULL, tmp;
1443: /* pointers to traversal nodes */
1444: xmlNodePtr start, cur, end;
1445: int index1, index2;
1446:
1447: if (range == NULL)
1448: return(NULL);
1449: if (range->type != XPATH_RANGE)
1450: return(NULL);
1451: start = (xmlNodePtr) range->user;
1452:
1453: if (start == NULL)
1454: return(NULL);
1455: end = range->user2;
1456: if (end == NULL)
1457: return(xmlCopyNode(start, 1));
1458:
1459: cur = start;
1460: index1 = range->index;
1461: index2 = range->index2;
1462: while (cur != NULL) {
1463: if (cur == end) {
1464: if (cur->type == XML_TEXT_NODE) {
1465: const xmlChar *content = cur->content;
1466: int len;
1467:
1468: if (content == NULL) {
1469: tmp = xmlNewTextLen(NULL, 0);
1470: } else {
1471: len = index2;
1472: if ((cur == start) && (index1 > 1)) {
1473: content += (index1 - 1);
1474: len -= (index1 - 1);
1475: index1 = 0;
1476: } else {
1477: len = index2;
1478: }
1479: tmp = xmlNewTextLen(content, len);
1480: }
1481: /* single sub text node selection */
1482: if (list == NULL)
1483: return(tmp);
1484: /* prune and return full set */
1485: if (last != NULL)
1486: xmlAddNextSibling(last, tmp);
1487: else
1488: xmlAddChild(parent, tmp);
1489: return(list);
1490: } else {
1491: tmp = xmlCopyNode(cur, 0);
1492: if (list == NULL)
1493: list = tmp;
1494: else {
1495: if (last != NULL)
1496: xmlAddNextSibling(last, tmp);
1497: else
1498: xmlAddChild(parent, tmp);
1499: }
1500: last = NULL;
1501: parent = tmp;
1502:
1503: if (index2 > 1) {
1504: end = xmlXPtrGetNthChild(cur, index2 - 1);
1505: index2 = 0;
1506: }
1507: if ((cur == start) && (index1 > 1)) {
1508: cur = xmlXPtrGetNthChild(cur, index1 - 1);
1509: index1 = 0;
1510: } else {
1511: cur = cur->children;
1512: }
1513: /*
1514: * Now gather the remaining nodes from cur to end
1515: */
1516: continue; /* while */
1517: }
1518: } else if ((cur == start) &&
1519: (list == NULL) /* looks superfluous but ... */ ) {
1520: if ((cur->type == XML_TEXT_NODE) ||
1521: (cur->type == XML_CDATA_SECTION_NODE)) {
1522: const xmlChar *content = cur->content;
1523:
1524: if (content == NULL) {
1525: tmp = xmlNewTextLen(NULL, 0);
1526: } else {
1527: if (index1 > 1) {
1528: content += (index1 - 1);
1529: }
1530: tmp = xmlNewText(content);
1531: }
1532: last = list = tmp;
1533: } else {
1534: if ((cur == start) && (index1 > 1)) {
1535: tmp = xmlCopyNode(cur, 0);
1536: list = tmp;
1537: parent = tmp;
1538: last = NULL;
1539: cur = xmlXPtrGetNthChild(cur, index1 - 1);
1540: index1 = 0;
1541: /*
1542: * Now gather the remaining nodes from cur to end
1543: */
1544: continue; /* while */
1545: }
1546: tmp = xmlCopyNode(cur, 1);
1547: list = tmp;
1548: parent = NULL;
1549: last = tmp;
1550: }
1551: } else {
1552: tmp = NULL;
1553: switch (cur->type) {
1554: case XML_DTD_NODE:
1555: case XML_ELEMENT_DECL:
1556: case XML_ATTRIBUTE_DECL:
1557: case XML_ENTITY_NODE:
1558: /* Do not copy DTD informations */
1559: break;
1560: case XML_ENTITY_DECL:
1561: TODO /* handle crossing entities -> stack needed */
1562: break;
1563: case XML_XINCLUDE_START:
1564: case XML_XINCLUDE_END:
1565: /* don't consider it part of the tree content */
1566: break;
1567: case XML_ATTRIBUTE_NODE:
1568: /* Humm, should not happen ! */
1569: STRANGE
1570: break;
1571: default:
1572: tmp = xmlCopyNode(cur, 1);
1573: break;
1574: }
1575: if (tmp != NULL) {
1576: if ((list == NULL) || ((last == NULL) && (parent == NULL))) {
1577: STRANGE
1578: return(NULL);
1579: }
1580: if (last != NULL)
1581: xmlAddNextSibling(last, tmp);
1582: else {
1583: xmlAddChild(parent, tmp);
1584: last = tmp;
1585: }
1586: }
1587: }
1588: /*
1589: * Skip to next node in document order
1590: */
1591: if ((list == NULL) || ((last == NULL) && (parent == NULL))) {
1592: STRANGE
1593: return(NULL);
1594: }
1595: cur = xmlXPtrAdvanceNode(cur, NULL);
1596: }
1597: return(list);
1598: }
1599:
1600: /**
1601: * xmlXPtrBuildNodeList:
1602: * @obj: the XPointer result from the evaluation.
1603: *
1604: * Build a node list tree copy of the XPointer result.
1605: * This will drop Attributes and Namespace declarations.
1606: *
1607: * Returns an xmlNodePtr list or NULL.
1608: * the caller has to free the node tree.
1609: */
1610: xmlNodePtr
1611: xmlXPtrBuildNodeList(xmlXPathObjectPtr obj) {
1612: xmlNodePtr list = NULL, last = NULL;
1613: int i;
1614:
1615: if (obj == NULL)
1616: return(NULL);
1617: switch (obj->type) {
1618: case XPATH_NODESET: {
1619: xmlNodeSetPtr set = obj->nodesetval;
1620: if (set == NULL)
1621: return(NULL);
1622: for (i = 0;i < set->nodeNr;i++) {
1623: if (set->nodeTab[i] == NULL)
1624: continue;
1625: switch (set->nodeTab[i]->type) {
1626: case XML_TEXT_NODE:
1627: case XML_CDATA_SECTION_NODE:
1628: case XML_ELEMENT_NODE:
1629: case XML_ENTITY_REF_NODE:
1630: case XML_ENTITY_NODE:
1631: case XML_PI_NODE:
1632: case XML_COMMENT_NODE:
1633: case XML_DOCUMENT_NODE:
1634: case XML_HTML_DOCUMENT_NODE:
1635: #ifdef LIBXML_DOCB_ENABLED
1636: case XML_DOCB_DOCUMENT_NODE:
1637: #endif
1638: case XML_XINCLUDE_START:
1639: case XML_XINCLUDE_END:
1640: break;
1641: case XML_ATTRIBUTE_NODE:
1642: case XML_NAMESPACE_DECL:
1643: case XML_DOCUMENT_TYPE_NODE:
1644: case XML_DOCUMENT_FRAG_NODE:
1645: case XML_NOTATION_NODE:
1646: case XML_DTD_NODE:
1647: case XML_ELEMENT_DECL:
1648: case XML_ATTRIBUTE_DECL:
1649: case XML_ENTITY_DECL:
1650: continue; /* for */
1651: }
1652: if (last == NULL)
1653: list = last = xmlCopyNode(set->nodeTab[i], 1);
1654: else {
1655: xmlAddNextSibling(last, xmlCopyNode(set->nodeTab[i], 1));
1656: if (last->next != NULL)
1657: last = last->next;
1658: }
1659: }
1660: break;
1661: }
1662: case XPATH_LOCATIONSET: {
1663: xmlLocationSetPtr set = (xmlLocationSetPtr) obj->user;
1664: if (set == NULL)
1665: return(NULL);
1666: for (i = 0;i < set->locNr;i++) {
1667: if (last == NULL)
1668: list = last = xmlXPtrBuildNodeList(set->locTab[i]);
1669: else
1670: xmlAddNextSibling(last,
1671: xmlXPtrBuildNodeList(set->locTab[i]));
1672: if (last != NULL) {
1673: while (last->next != NULL)
1674: last = last->next;
1675: }
1676: }
1677: break;
1678: }
1679: case XPATH_RANGE:
1680: return(xmlXPtrBuildRangeNodeList(obj));
1681: case XPATH_POINT:
1682: return(xmlCopyNode(obj->user, 0));
1683: default:
1684: break;
1685: }
1686: return(list);
1687: }
1688:
1689: /************************************************************************
1690: * *
1691: * XPointer functions *
1692: * *
1693: ************************************************************************/
1694:
1695: /**
1696: * xmlXPtrNbLocChildren:
1697: * @node: an xmlNodePtr
1698: *
1699: * Count the number of location children of @node or the length of the
1700: * string value in case of text/PI/Comments nodes
1701: *
1702: * Returns the number of location children
1703: */
1704: static int
1705: xmlXPtrNbLocChildren(xmlNodePtr node) {
1706: int ret = 0;
1707: if (node == NULL)
1708: return(-1);
1709: switch (node->type) {
1710: case XML_HTML_DOCUMENT_NODE:
1711: case XML_DOCUMENT_NODE:
1712: case XML_ELEMENT_NODE:
1713: node = node->children;
1714: while (node != NULL) {
1715: if (node->type == XML_ELEMENT_NODE)
1716: ret++;
1717: node = node->next;
1718: }
1719: break;
1720: case XML_ATTRIBUTE_NODE:
1721: return(-1);
1722:
1723: case XML_PI_NODE:
1724: case XML_COMMENT_NODE:
1725: case XML_TEXT_NODE:
1726: case XML_CDATA_SECTION_NODE:
1727: case XML_ENTITY_REF_NODE:
1728: ret = xmlStrlen(node->content);
1729: break;
1730: default:
1731: return(-1);
1732: }
1733: return(ret);
1734: }
1735:
1736: /**
1737: * xmlXPtrHereFunction:
1738: * @ctxt: the XPointer Parser context
1739: * @nargs: the number of args
1740: *
1741: * Function implementing here() operation
1742: * as described in 5.4.3
1743: */
1744: static void
1745: xmlXPtrHereFunction(xmlXPathParserContextPtr ctxt, int nargs) {
1746: CHECK_ARITY(0);
1747:
1748: if (ctxt->context->here == NULL)
1749: XP_ERROR(XPTR_SYNTAX_ERROR);
1750:
1751: valuePush(ctxt, xmlXPtrNewLocationSetNodes(ctxt->context->here, NULL));
1752: }
1753:
1754: /**
1755: * xmlXPtrOriginFunction:
1756: * @ctxt: the XPointer Parser context
1757: * @nargs: the number of args
1758: *
1759: * Function implementing origin() operation
1760: * as described in 5.4.3
1761: */
1762: static void
1763: xmlXPtrOriginFunction(xmlXPathParserContextPtr ctxt, int nargs) {
1764: CHECK_ARITY(0);
1765:
1766: if (ctxt->context->origin == NULL)
1767: XP_ERROR(XPTR_SYNTAX_ERROR);
1768:
1769: valuePush(ctxt, xmlXPtrNewLocationSetNodes(ctxt->context->origin, NULL));
1770: }
1771:
1772: /**
1773: * xmlXPtrStartPointFunction:
1774: * @ctxt: the XPointer Parser context
1775: * @nargs: the number of args
1776: *
1777: * Function implementing start-point() operation
1778: * as described in 5.4.3
1779: * ----------------
1780: * location-set start-point(location-set)
1781: *
1782: * For each location x in the argument location-set, start-point adds a
1783: * location of type point to the result location-set. That point represents
1784: * the start point of location x and is determined by the following rules:
1785: *
1786: * - If x is of type point, the start point is x.
1787: * - If x is of type range, the start point is the start point of x.
1788: * - If x is of type root, element, text, comment, or processing instruction,
1789: * - the container node of the start point is x and the index is 0.
1790: * - If x is of type attribute or namespace, the function must signal a
1791: * syntax error.
1792: * ----------------
1793: *
1794: */
1795: static void
1796: xmlXPtrStartPointFunction(xmlXPathParserContextPtr ctxt, int nargs) {
1797: xmlXPathObjectPtr tmp, obj, point;
1798: xmlLocationSetPtr newset = NULL;
1799: xmlLocationSetPtr oldset = NULL;
1800:
1801: CHECK_ARITY(1);
1802: if ((ctxt->value == NULL) ||
1803: ((ctxt->value->type != XPATH_LOCATIONSET) &&
1804: (ctxt->value->type != XPATH_NODESET)))
1805: XP_ERROR(XPATH_INVALID_TYPE)
1806:
1807: obj = valuePop(ctxt);
1808: if (obj->type == XPATH_NODESET) {
1809: /*
1810: * First convert to a location set
1811: */
1812: tmp = xmlXPtrNewLocationSetNodeSet(obj->nodesetval);
1813: xmlXPathFreeObject(obj);
1814: obj = tmp;
1815: }
1816:
1817: newset = xmlXPtrLocationSetCreate(NULL);
1818: if (newset == NULL) {
1819: xmlXPathFreeObject(obj);
1820: XP_ERROR(XPATH_MEMORY_ERROR);
1821: }
1822: oldset = (xmlLocationSetPtr) obj->user;
1823: if (oldset != NULL) {
1824: int i;
1825:
1826: for (i = 0; i < oldset->locNr; i++) {
1827: tmp = oldset->locTab[i];
1828: if (tmp == NULL)
1829: continue;
1830: point = NULL;
1831: switch (tmp->type) {
1832: case XPATH_POINT:
1833: point = xmlXPtrNewPoint(tmp->user, tmp->index);
1834: break;
1835: case XPATH_RANGE: {
1836: xmlNodePtr node = tmp->user;
1837: if (node != NULL) {
1838: if (node->type == XML_ATTRIBUTE_NODE) {
1839: /* TODO: Namespace Nodes ??? */
1840: xmlXPathFreeObject(obj);
1841: xmlXPtrFreeLocationSet(newset);
1842: XP_ERROR(XPTR_SYNTAX_ERROR);
1843: }
1844: point = xmlXPtrNewPoint(node, tmp->index);
1845: }
1846: break;
1847: }
1848: default:
1849: /*** Should we raise an error ?
1850: xmlXPathFreeObject(obj);
1851: xmlXPathFreeObject(newset);
1852: XP_ERROR(XPATH_INVALID_TYPE)
1853: ***/
1854: break;
1855: }
1856: if (point != NULL)
1857: xmlXPtrLocationSetAdd(newset, point);
1858: }
1859: }
1860: xmlXPathFreeObject(obj);
1861: valuePush(ctxt, xmlXPtrWrapLocationSet(newset));
1862: }
1863:
1864: /**
1865: * xmlXPtrEndPointFunction:
1866: * @ctxt: the XPointer Parser context
1867: * @nargs: the number of args
1868: *
1869: * Function implementing end-point() operation
1870: * as described in 5.4.3
1871: * ----------------------------
1872: * location-set end-point(location-set)
1873: *
1874: * For each location x in the argument location-set, end-point adds a
1875: * location of type point to the result location-set. That point represents
1876: * the end point of location x and is determined by the following rules:
1877: *
1878: * - If x is of type point, the resulting point is x.
1879: * - If x is of type range, the resulting point is the end point of x.
1880: * - If x is of type root or element, the container node of the resulting
1881: * point is x and the index is the number of location children of x.
1882: * - If x is of type text, comment, or processing instruction, the container
1883: * node of the resulting point is x and the index is the length of the
1884: * string-value of x.
1885: * - If x is of type attribute or namespace, the function must signal a
1886: * syntax error.
1887: * ----------------------------
1888: */
1889: static void
1890: xmlXPtrEndPointFunction(xmlXPathParserContextPtr ctxt, int nargs) {
1891: xmlXPathObjectPtr tmp, obj, point;
1892: xmlLocationSetPtr newset = NULL;
1893: xmlLocationSetPtr oldset = NULL;
1894:
1895: CHECK_ARITY(1);
1896: if ((ctxt->value == NULL) ||
1897: ((ctxt->value->type != XPATH_LOCATIONSET) &&
1898: (ctxt->value->type != XPATH_NODESET)))
1899: XP_ERROR(XPATH_INVALID_TYPE)
1900:
1901: obj = valuePop(ctxt);
1902: if (obj->type == XPATH_NODESET) {
1903: /*
1904: * First convert to a location set
1905: */
1906: tmp = xmlXPtrNewLocationSetNodeSet(obj->nodesetval);
1907: xmlXPathFreeObject(obj);
1908: obj = tmp;
1909: }
1910:
1911: newset = xmlXPtrLocationSetCreate(NULL);
1912: oldset = (xmlLocationSetPtr) obj->user;
1913: if (oldset != NULL) {
1914: int i;
1915:
1916: for (i = 0; i < oldset->locNr; i++) {
1917: tmp = oldset->locTab[i];
1918: if (tmp == NULL)
1919: continue;
1920: point = NULL;
1921: switch (tmp->type) {
1922: case XPATH_POINT:
1923: point = xmlXPtrNewPoint(tmp->user, tmp->index);
1924: break;
1925: case XPATH_RANGE: {
1926: xmlNodePtr node = tmp->user2;
1927: if (node != NULL) {
1928: if (node->type == XML_ATTRIBUTE_NODE) {
1929: /* TODO: Namespace Nodes ??? */
1930: xmlXPathFreeObject(obj);
1931: xmlXPtrFreeLocationSet(newset);
1932: XP_ERROR(XPTR_SYNTAX_ERROR);
1933: }
1934: point = xmlXPtrNewPoint(node, tmp->index2);
1935: } else if (tmp->user == NULL) {
1936: point = xmlXPtrNewPoint(node,
1937: xmlXPtrNbLocChildren(node));
1938: }
1939: break;
1940: }
1941: default:
1942: /*** Should we raise an error ?
1943: xmlXPathFreeObject(obj);
1944: xmlXPathFreeObject(newset);
1945: XP_ERROR(XPATH_INVALID_TYPE)
1946: ***/
1947: break;
1948: }
1949: if (point != NULL)
1950: xmlXPtrLocationSetAdd(newset, point);
1951: }
1952: }
1953: xmlXPathFreeObject(obj);
1954: valuePush(ctxt, xmlXPtrWrapLocationSet(newset));
1955: }
1956:
1957:
1958: /**
1959: * xmlXPtrCoveringRange:
1960: * @ctxt: the XPointer Parser context
1961: * @loc: the location for which the covering range must be computed
1962: *
1963: * A covering range is a range that wholly encompasses a location
1964: * Section 5.3.3. Covering Ranges for All Location Types
1965: * http://www.w3.org/TR/xptr#N2267
1966: *
1967: * Returns a new location or NULL in case of error
1968: */
1969: static xmlXPathObjectPtr
1970: xmlXPtrCoveringRange(xmlXPathParserContextPtr ctxt, xmlXPathObjectPtr loc) {
1971: if (loc == NULL)
1972: return(NULL);
1973: if ((ctxt == NULL) || (ctxt->context == NULL) ||
1974: (ctxt->context->doc == NULL))
1975: return(NULL);
1976: switch (loc->type) {
1977: case XPATH_POINT:
1978: return(xmlXPtrNewRange(loc->user, loc->index,
1979: loc->user, loc->index));
1980: case XPATH_RANGE:
1981: if (loc->user2 != NULL) {
1982: return(xmlXPtrNewRange(loc->user, loc->index,
1983: loc->user2, loc->index2));
1984: } else {
1985: xmlNodePtr node = (xmlNodePtr) loc->user;
1986: if (node == (xmlNodePtr) ctxt->context->doc) {
1987: return(xmlXPtrNewRange(node, 0, node,
1988: xmlXPtrGetArity(node)));
1989: } else {
1990: switch (node->type) {
1991: case XML_ATTRIBUTE_NODE:
1992: /* !!! our model is slightly different than XPath */
1993: return(xmlXPtrNewRange(node, 0, node,
1994: xmlXPtrGetArity(node)));
1995: case XML_ELEMENT_NODE:
1996: case XML_TEXT_NODE:
1997: case XML_CDATA_SECTION_NODE:
1998: case XML_ENTITY_REF_NODE:
1999: case XML_PI_NODE:
2000: case XML_COMMENT_NODE:
2001: case XML_DOCUMENT_NODE:
2002: case XML_NOTATION_NODE:
2003: case XML_HTML_DOCUMENT_NODE: {
2004: int indx = xmlXPtrGetIndex(node);
2005:
2006: node = node->parent;
2007: return(xmlXPtrNewRange(node, indx - 1,
2008: node, indx + 1));
2009: }
2010: default:
2011: return(NULL);
2012: }
2013: }
2014: }
2015: default:
2016: TODO /* missed one case ??? */
2017: }
2018: return(NULL);
2019: }
2020:
2021: /**
2022: * xmlXPtrRangeFunction:
2023: * @ctxt: the XPointer Parser context
2024: * @nargs: the number of args
2025: *
2026: * Function implementing the range() function 5.4.3
2027: * location-set range(location-set )
2028: *
2029: * The range function returns ranges covering the locations in
2030: * the argument location-set. For each location x in the argument
2031: * location-set, a range location representing the covering range of
2032: * x is added to the result location-set.
2033: */
2034: static void
2035: xmlXPtrRangeFunction(xmlXPathParserContextPtr ctxt, int nargs) {
2036: int i;
2037: xmlXPathObjectPtr set;
2038: xmlLocationSetPtr oldset;
2039: xmlLocationSetPtr newset;
2040:
2041: CHECK_ARITY(1);
2042: if ((ctxt->value == NULL) ||
2043: ((ctxt->value->type != XPATH_LOCATIONSET) &&
2044: (ctxt->value->type != XPATH_NODESET)))
2045: XP_ERROR(XPATH_INVALID_TYPE)
2046:
2047: set = valuePop(ctxt);
2048: if (set->type == XPATH_NODESET) {
2049: xmlXPathObjectPtr tmp;
2050:
2051: /*
2052: * First convert to a location set
2053: */
2054: tmp = xmlXPtrNewLocationSetNodeSet(set->nodesetval);
2055: xmlXPathFreeObject(set);
2056: set = tmp;
2057: }
2058: oldset = (xmlLocationSetPtr) set->user;
2059:
2060: /*
2061: * The loop is to compute the covering range for each item and add it
2062: */
2063: newset = xmlXPtrLocationSetCreate(NULL);
2064: for (i = 0;i < oldset->locNr;i++) {
2065: xmlXPtrLocationSetAdd(newset,
2066: xmlXPtrCoveringRange(ctxt, oldset->locTab[i]));
2067: }
2068:
2069: /*
2070: * Save the new value and cleanup
2071: */
2072: valuePush(ctxt, xmlXPtrWrapLocationSet(newset));
2073: xmlXPathFreeObject(set);
2074: }
2075:
2076: /**
2077: * xmlXPtrInsideRange:
2078: * @ctxt: the XPointer Parser context
2079: * @loc: the location for which the inside range must be computed
2080: *
2081: * A inside range is a range described in the range-inside() description
2082: *
2083: * Returns a new location or NULL in case of error
2084: */
2085: static xmlXPathObjectPtr
2086: xmlXPtrInsideRange(xmlXPathParserContextPtr ctxt, xmlXPathObjectPtr loc) {
2087: if (loc == NULL)
2088: return(NULL);
2089: if ((ctxt == NULL) || (ctxt->context == NULL) ||
2090: (ctxt->context->doc == NULL))
2091: return(NULL);
2092: switch (loc->type) {
2093: case XPATH_POINT: {
2094: xmlNodePtr node = (xmlNodePtr) loc->user;
2095: switch (node->type) {
2096: case XML_PI_NODE:
2097: case XML_COMMENT_NODE:
2098: case XML_TEXT_NODE:
2099: case XML_CDATA_SECTION_NODE: {
2100: if (node->content == NULL) {
2101: return(xmlXPtrNewRange(node, 0, node, 0));
2102: } else {
2103: return(xmlXPtrNewRange(node, 0, node,
2104: xmlStrlen(node->content)));
2105: }
2106: }
2107: case XML_ATTRIBUTE_NODE:
2108: case XML_ELEMENT_NODE:
2109: case XML_ENTITY_REF_NODE:
2110: case XML_DOCUMENT_NODE:
2111: case XML_NOTATION_NODE:
2112: case XML_HTML_DOCUMENT_NODE: {
2113: return(xmlXPtrNewRange(node, 0, node,
2114: xmlXPtrGetArity(node)));
2115: }
2116: default:
2117: break;
2118: }
2119: return(NULL);
2120: }
2121: case XPATH_RANGE: {
2122: xmlNodePtr node = (xmlNodePtr) loc->user;
2123: if (loc->user2 != NULL) {
2124: return(xmlXPtrNewRange(node, loc->index,
2125: loc->user2, loc->index2));
2126: } else {
2127: switch (node->type) {
2128: case XML_PI_NODE:
2129: case XML_COMMENT_NODE:
2130: case XML_TEXT_NODE:
2131: case XML_CDATA_SECTION_NODE: {
2132: if (node->content == NULL) {
2133: return(xmlXPtrNewRange(node, 0, node, 0));
2134: } else {
2135: return(xmlXPtrNewRange(node, 0, node,
2136: xmlStrlen(node->content)));
2137: }
2138: }
2139: case XML_ATTRIBUTE_NODE:
2140: case XML_ELEMENT_NODE:
2141: case XML_ENTITY_REF_NODE:
2142: case XML_DOCUMENT_NODE:
2143: case XML_NOTATION_NODE:
2144: case XML_HTML_DOCUMENT_NODE: {
2145: return(xmlXPtrNewRange(node, 0, node,
2146: xmlXPtrGetArity(node)));
2147: }
2148: default:
2149: break;
2150: }
2151: return(NULL);
2152: }
2153: }
2154: default:
2155: TODO /* missed one case ??? */
2156: }
2157: return(NULL);
2158: }
2159:
2160: /**
2161: * xmlXPtrRangeInsideFunction:
2162: * @ctxt: the XPointer Parser context
2163: * @nargs: the number of args
2164: *
2165: * Function implementing the range-inside() function 5.4.3
2166: * location-set range-inside(location-set )
2167: *
2168: * The range-inside function returns ranges covering the contents of
2169: * the locations in the argument location-set. For each location x in
2170: * the argument location-set, a range location is added to the result
2171: * location-set. If x is a range location, then x is added to the
2172: * result location-set. If x is not a range location, then x is used
2173: * as the container location of the start and end points of the range
2174: * location to be added; the index of the start point of the range is
2175: * zero; if the end point is a character point then its index is the
2176: * length of the string-value of x, and otherwise is the number of
2177: * location children of x.
2178: *
2179: */
2180: static void
2181: xmlXPtrRangeInsideFunction(xmlXPathParserContextPtr ctxt, int nargs) {
2182: int i;
2183: xmlXPathObjectPtr set;
2184: xmlLocationSetPtr oldset;
2185: xmlLocationSetPtr newset;
2186:
2187: CHECK_ARITY(1);
2188: if ((ctxt->value == NULL) ||
2189: ((ctxt->value->type != XPATH_LOCATIONSET) &&
2190: (ctxt->value->type != XPATH_NODESET)))
2191: XP_ERROR(XPATH_INVALID_TYPE)
2192:
2193: set = valuePop(ctxt);
2194: if (set->type == XPATH_NODESET) {
2195: xmlXPathObjectPtr tmp;
2196:
2197: /*
2198: * First convert to a location set
2199: */
2200: tmp = xmlXPtrNewLocationSetNodeSet(set->nodesetval);
2201: xmlXPathFreeObject(set);
2202: set = tmp;
2203: }
2204: oldset = (xmlLocationSetPtr) set->user;
2205:
2206: /*
2207: * The loop is to compute the covering range for each item and add it
2208: */
2209: newset = xmlXPtrLocationSetCreate(NULL);
2210: for (i = 0;i < oldset->locNr;i++) {
2211: xmlXPtrLocationSetAdd(newset,
2212: xmlXPtrInsideRange(ctxt, oldset->locTab[i]));
2213: }
2214:
2215: /*
2216: * Save the new value and cleanup
2217: */
2218: valuePush(ctxt, xmlXPtrWrapLocationSet(newset));
2219: xmlXPathFreeObject(set);
2220: }
2221:
2222: /**
2223: * xmlXPtrRangeToFunction:
2224: * @ctxt: the XPointer Parser context
2225: * @nargs: the number of args
2226: *
2227: * Implement the range-to() XPointer function
2228: */
2229: void
2230: xmlXPtrRangeToFunction(xmlXPathParserContextPtr ctxt, int nargs) {
2231: xmlXPathObjectPtr range;
2232: const xmlChar *cur;
2233: xmlXPathObjectPtr res, obj;
2234: xmlXPathObjectPtr tmp;
2235: xmlLocationSetPtr newset = NULL;
2236: xmlNodeSetPtr oldset;
2237: int i;
2238:
2239: if (ctxt == NULL) return;
2240: CHECK_ARITY(1);
2241: /*
2242: * Save the expression pointer since we will have to evaluate
2243: * it multiple times. Initialize the new set.
2244: */
2245: CHECK_TYPE(XPATH_NODESET);
2246: obj = valuePop(ctxt);
2247: oldset = obj->nodesetval;
2248: ctxt->context->node = NULL;
2249:
2250: cur = ctxt->cur;
2251: newset = xmlXPtrLocationSetCreate(NULL);
2252:
2253: for (i = 0; i < oldset->nodeNr; i++) {
2254: ctxt->cur = cur;
2255:
2256: /*
2257: * Run the evaluation with a node list made of a single item
2258: * in the nodeset.
2259: */
2260: ctxt->context->node = oldset->nodeTab[i];
2261: tmp = xmlXPathNewNodeSet(ctxt->context->node);
2262: valuePush(ctxt, tmp);
2263:
2264: xmlXPathEvalExpr(ctxt);
2265: CHECK_ERROR;
2266:
2267: /*
2268: * The result of the evaluation need to be tested to
2269: * decided whether the filter succeeded or not
2270: */
2271: res = valuePop(ctxt);
2272: range = xmlXPtrNewRangeNodeObject(oldset->nodeTab[i], res);
2273: if (range != NULL) {
2274: xmlXPtrLocationSetAdd(newset, range);
2275: }
2276:
2277: /*
2278: * Cleanup
2279: */
2280: if (res != NULL)
2281: xmlXPathFreeObject(res);
2282: if (ctxt->value == tmp) {
2283: res = valuePop(ctxt);
2284: xmlXPathFreeObject(res);
2285: }
2286:
2287: ctxt->context->node = NULL;
2288: }
2289:
2290: /*
2291: * The result is used as the new evaluation set.
2292: */
2293: xmlXPathFreeObject(obj);
2294: ctxt->context->node = NULL;
2295: ctxt->context->contextSize = -1;
2296: ctxt->context->proximityPosition = -1;
2297: valuePush(ctxt, xmlXPtrWrapLocationSet(newset));
2298: }
2299:
2300: /**
2301: * xmlXPtrAdvanceNode:
2302: * @cur: the node
2303: * @level: incremented/decremented to show level in tree
2304: *
2305: * Advance to the next element or text node in document order
2306: * TODO: add a stack for entering/exiting entities
2307: *
2308: * Returns -1 in case of failure, 0 otherwise
2309: */
2310: xmlNodePtr
2311: xmlXPtrAdvanceNode(xmlNodePtr cur, int *level) {
2312: next:
2313: if (cur == NULL)
2314: return(NULL);
2315: if (cur->children != NULL) {
2316: cur = cur->children ;
2317: if (level != NULL)
2318: (*level)++;
2319: goto found;
2320: }
2321: skip: /* This label should only be needed if something is wrong! */
2322: if (cur->next != NULL) {
2323: cur = cur->next;
2324: goto found;
2325: }
2326: do {
2327: cur = cur->parent;
2328: if (level != NULL)
2329: (*level)--;
2330: if (cur == NULL) return(NULL);
2331: if (cur->next != NULL) {
2332: cur = cur->next;
2333: goto found;
2334: }
2335: } while (cur != NULL);
2336:
2337: found:
2338: if ((cur->type != XML_ELEMENT_NODE) &&
2339: (cur->type != XML_TEXT_NODE) &&
2340: (cur->type != XML_DOCUMENT_NODE) &&
2341: (cur->type != XML_HTML_DOCUMENT_NODE) &&
2342: (cur->type != XML_CDATA_SECTION_NODE)) {
2343: if (cur->type == XML_ENTITY_REF_NODE) { /* Shouldn't happen */
2344: TODO
2345: goto skip;
2346: }
2347: goto next;
2348: }
2349: return(cur);
2350: }
2351:
2352: /**
2353: * xmlXPtrAdvanceChar:
2354: * @node: the node
2355: * @indx: the indx
2356: * @bytes: the number of bytes
2357: *
2358: * Advance a point of the associated number of bytes (not UTF8 chars)
2359: *
2360: * Returns -1 in case of failure, 0 otherwise
2361: */
2362: static int
2363: xmlXPtrAdvanceChar(xmlNodePtr *node, int *indx, int bytes) {
2364: xmlNodePtr cur;
2365: int pos;
2366: int len;
2367:
2368: if ((node == NULL) || (indx == NULL))
2369: return(-1);
2370: cur = *node;
2371: if (cur == NULL)
2372: return(-1);
2373: pos = *indx;
2374:
2375: while (bytes >= 0) {
2376: /*
2377: * First position to the beginning of the first text node
2378: * corresponding to this point
2379: */
2380: while ((cur != NULL) &&
2381: ((cur->type == XML_ELEMENT_NODE) ||
2382: (cur->type == XML_DOCUMENT_NODE) ||
2383: (cur->type == XML_HTML_DOCUMENT_NODE))) {
2384: if (pos > 0) {
2385: cur = xmlXPtrGetNthChild(cur, pos);
2386: pos = 0;
2387: } else {
2388: cur = xmlXPtrAdvanceNode(cur, NULL);
2389: pos = 0;
2390: }
2391: }
2392:
2393: if (cur == NULL) {
2394: *node = NULL;
2395: *indx = 0;
2396: return(-1);
2397: }
2398:
2399: /*
2400: * if there is no move needed return the current value.
2401: */
2402: if (pos == 0) pos = 1;
2403: if (bytes == 0) {
2404: *node = cur;
2405: *indx = pos;
2406: return(0);
2407: }
2408: /*
2409: * We should have a text (or cdata) node ...
2410: */
2411: len = 0;
2412: if ((cur->type != XML_ELEMENT_NODE) &&
2413: (cur->content != NULL)) {
2414: len = xmlStrlen(cur->content);
2415: }
2416: if (pos > len) {
2417: /* Strange, the indx in the text node is greater than it's len */
2418: STRANGE
2419: pos = len;
2420: }
2421: if (pos + bytes >= len) {
2422: bytes -= (len - pos);
2423: cur = xmlXPtrAdvanceNode(cur, NULL);
2424: pos = 0;
2425: } else if (pos + bytes < len) {
2426: pos += bytes;
2427: *node = cur;
2428: *indx = pos;
2429: return(0);
2430: }
2431: }
2432: return(-1);
2433: }
2434:
2435: /**
2436: * xmlXPtrMatchString:
2437: * @string: the string to search
2438: * @start: the start textnode
2439: * @startindex: the start index
2440: * @end: the end textnode IN/OUT
2441: * @endindex: the end index IN/OUT
2442: *
2443: * Check whether the document contains @string at the position
2444: * (@start, @startindex) and limited by the (@end, @endindex) point
2445: *
2446: * Returns -1 in case of failure, 0 if not found, 1 if found in which case
2447: * (@start, @startindex) will indicate the position of the beginning
2448: * of the range and (@end, @endindex) will indicate the end
2449: * of the range
2450: */
2451: static int
2452: xmlXPtrMatchString(const xmlChar *string, xmlNodePtr start, int startindex,
2453: xmlNodePtr *end, int *endindex) {
2454: xmlNodePtr cur;
2455: int pos; /* 0 based */
2456: int len; /* in bytes */
2457: int stringlen; /* in bytes */
2458: int match;
2459:
2460: if (string == NULL)
2461: return(-1);
2462: if (start == NULL)
2463: return(-1);
2464: if ((end == NULL) || (endindex == NULL))
2465: return(-1);
2466: cur = start;
2467: if (cur == NULL)
2468: return(-1);
2469: pos = startindex - 1;
2470: stringlen = xmlStrlen(string);
2471:
2472: while (stringlen > 0) {
2473: if ((cur == *end) && (pos + stringlen > *endindex))
2474: return(0);
2475:
2476: if ((cur->type != XML_ELEMENT_NODE) && (cur->content != NULL)) {
2477: len = xmlStrlen(cur->content);
2478: if (len >= pos + stringlen) {
2479: match = (!xmlStrncmp(&cur->content[pos], string, stringlen));
2480: if (match) {
2481: #ifdef DEBUG_RANGES
2482: xmlGenericError(xmlGenericErrorContext,
2483: "found range %d bytes at index %d of ->",
2484: stringlen, pos + 1);
2485: xmlDebugDumpString(stdout, cur->content);
2486: xmlGenericError(xmlGenericErrorContext, "\n");
2487: #endif
2488: *end = cur;
2489: *endindex = pos + stringlen;
2490: return(1);
2491: } else {
2492: return(0);
2493: }
2494: } else {
2495: int sub = len - pos;
2496: match = (!xmlStrncmp(&cur->content[pos], string, sub));
2497: if (match) {
2498: #ifdef DEBUG_RANGES
2499: xmlGenericError(xmlGenericErrorContext,
2500: "found subrange %d bytes at index %d of ->",
2501: sub, pos + 1);
2502: xmlDebugDumpString(stdout, cur->content);
2503: xmlGenericError(xmlGenericErrorContext, "\n");
2504: #endif
2505: string = &string[sub];
2506: stringlen -= sub;
2507: } else {
2508: return(0);
2509: }
2510: }
2511: }
2512: cur = xmlXPtrAdvanceNode(cur, NULL);
2513: if (cur == NULL)
2514: return(0);
2515: pos = 0;
2516: }
2517: return(1);
2518: }
2519:
2520: /**
2521: * xmlXPtrSearchString:
2522: * @string: the string to search
2523: * @start: the start textnode IN/OUT
2524: * @startindex: the start index IN/OUT
2525: * @end: the end textnode
2526: * @endindex: the end index
2527: *
2528: * Search the next occurrence of @string within the document content
2529: * until the (@end, @endindex) point is reached
2530: *
2531: * Returns -1 in case of failure, 0 if not found, 1 if found in which case
2532: * (@start, @startindex) will indicate the position of the beginning
2533: * of the range and (@end, @endindex) will indicate the end
2534: * of the range
2535: */
2536: static int
2537: xmlXPtrSearchString(const xmlChar *string, xmlNodePtr *start, int *startindex,
2538: xmlNodePtr *end, int *endindex) {
2539: xmlNodePtr cur;
2540: const xmlChar *str;
2541: int pos; /* 0 based */
2542: int len; /* in bytes */
2543: xmlChar first;
2544:
2545: if (string == NULL)
2546: return(-1);
2547: if ((start == NULL) || (startindex == NULL))
2548: return(-1);
2549: if ((end == NULL) || (endindex == NULL))
2550: return(-1);
2551: cur = *start;
2552: if (cur == NULL)
2553: return(-1);
2554: pos = *startindex - 1;
2555: first = string[0];
2556:
2557: while (cur != NULL) {
2558: if ((cur->type != XML_ELEMENT_NODE) && (cur->content != NULL)) {
2559: len = xmlStrlen(cur->content);
2560: while (pos <= len) {
2561: if (first != 0) {
2562: str = xmlStrchr(&cur->content[pos], first);
2563: if (str != NULL) {
2564: pos = (str - (xmlChar *)(cur->content));
2565: #ifdef DEBUG_RANGES
2566: xmlGenericError(xmlGenericErrorContext,
2567: "found '%c' at index %d of ->",
2568: first, pos + 1);
2569: xmlDebugDumpString(stdout, cur->content);
2570: xmlGenericError(xmlGenericErrorContext, "\n");
2571: #endif
2572: if (xmlXPtrMatchString(string, cur, pos + 1,
2573: end, endindex)) {
2574: *start = cur;
2575: *startindex = pos + 1;
2576: return(1);
2577: }
2578: pos++;
2579: } else {
2580: pos = len + 1;
2581: }
2582: } else {
2583: /*
2584: * An empty string is considered to match before each
2585: * character of the string-value and after the final
2586: * character.
2587: */
2588: #ifdef DEBUG_RANGES
2589: xmlGenericError(xmlGenericErrorContext,
2590: "found '' at index %d of ->",
2591: pos + 1);
2592: xmlDebugDumpString(stdout, cur->content);
2593: xmlGenericError(xmlGenericErrorContext, "\n");
2594: #endif
2595: *start = cur;
2596: *startindex = pos + 1;
2597: *end = cur;
2598: *endindex = pos + 1;
2599: return(1);
2600: }
2601: }
2602: }
2603: if ((cur == *end) && (pos >= *endindex))
2604: return(0);
2605: cur = xmlXPtrAdvanceNode(cur, NULL);
2606: if (cur == NULL)
2607: return(0);
2608: pos = 1;
2609: }
2610: return(0);
2611: }
2612:
2613: /**
2614: * xmlXPtrGetLastChar:
2615: * @node: the node
2616: * @index: the index
2617: *
2618: * Computes the point coordinates of the last char of this point
2619: *
2620: * Returns -1 in case of failure, 0 otherwise
2621: */
2622: static int
2623: xmlXPtrGetLastChar(xmlNodePtr *node, int *indx) {
2624: xmlNodePtr cur;
2625: int pos, len = 0;
2626:
2627: if ((node == NULL) || (indx == NULL))
2628: return(-1);
2629: cur = *node;
2630: pos = *indx;
2631:
2632: if (cur == NULL)
2633: return(-1);
2634:
2635: if ((cur->type == XML_ELEMENT_NODE) ||
2636: (cur->type == XML_DOCUMENT_NODE) ||
2637: (cur->type == XML_HTML_DOCUMENT_NODE)) {
2638: if (pos > 0) {
2639: cur = xmlXPtrGetNthChild(cur, pos);
2640: }
2641: }
2642: while (cur != NULL) {
2643: if (cur->last != NULL)
2644: cur = cur->last;
2645: else if ((cur->type != XML_ELEMENT_NODE) &&
2646: (cur->content != NULL)) {
2647: len = xmlStrlen(cur->content);
2648: break;
2649: } else {
2650: return(-1);
2651: }
2652: }
2653: if (cur == NULL)
2654: return(-1);
2655: *node = cur;
2656: *indx = len;
2657: return(0);
2658: }
2659:
2660: /**
2661: * xmlXPtrGetStartPoint:
2662: * @obj: an range
2663: * @node: the resulting node
2664: * @indx: the resulting index
2665: *
2666: * read the object and return the start point coordinates.
2667: *
2668: * Returns -1 in case of failure, 0 otherwise
2669: */
2670: static int
2671: xmlXPtrGetStartPoint(xmlXPathObjectPtr obj, xmlNodePtr *node, int *indx) {
2672: if ((obj == NULL) || (node == NULL) || (indx == NULL))
2673: return(-1);
2674:
2675: switch (obj->type) {
2676: case XPATH_POINT:
2677: *node = obj->user;
2678: if (obj->index <= 0)
2679: *indx = 0;
2680: else
2681: *indx = obj->index;
2682: return(0);
2683: case XPATH_RANGE:
2684: *node = obj->user;
2685: if (obj->index <= 0)
2686: *indx = 0;
2687: else
2688: *indx = obj->index;
2689: return(0);
2690: default:
2691: break;
2692: }
2693: return(-1);
2694: }
2695:
2696: /**
2697: * xmlXPtrGetEndPoint:
2698: * @obj: an range
2699: * @node: the resulting node
2700: * @indx: the resulting indx
2701: *
2702: * read the object and return the end point coordinates.
2703: *
2704: * Returns -1 in case of failure, 0 otherwise
2705: */
2706: static int
2707: xmlXPtrGetEndPoint(xmlXPathObjectPtr obj, xmlNodePtr *node, int *indx) {
2708: if ((obj == NULL) || (node == NULL) || (indx == NULL))
2709: return(-1);
2710:
2711: switch (obj->type) {
2712: case XPATH_POINT:
2713: *node = obj->user;
2714: if (obj->index <= 0)
2715: *indx = 0;
2716: else
2717: *indx = obj->index;
2718: return(0);
2719: case XPATH_RANGE:
2720: *node = obj->user;
2721: if (obj->index <= 0)
2722: *indx = 0;
2723: else
2724: *indx = obj->index;
2725: return(0);
2726: default:
2727: break;
2728: }
2729: return(-1);
2730: }
2731:
2732: /**
2733: * xmlXPtrStringRangeFunction:
2734: * @ctxt: the XPointer Parser context
2735: * @nargs: the number of args
2736: *
2737: * Function implementing the string-range() function
2738: * range as described in 5.4.2
2739: *
2740: * ------------------------------
2741: * [Definition: For each location in the location-set argument,
2742: * string-range returns a set of string ranges, a set of substrings in a
2743: * string. Specifically, the string-value of the location is searched for
2744: * substrings that match the string argument, and the resulting location-set
2745: * will contain a range location for each non-overlapping match.]
2746: * An empty string is considered to match before each character of the
2747: * string-value and after the final character. Whitespace in a string
2748: * is matched literally, with no normalization except that provided by
2749: * XML for line ends. The third argument gives the position of the first
2750: * character to be in the resulting range, relative to the start of the
2751: * match. The default value is 1, which makes the range start immediately
2752: * before the first character of the matched string. The fourth argument
2753: * gives the number of characters in the range; the default is that the
2754: * range extends to the end of the matched string.
2755: *
2756: * Element boundaries, as well as entire embedded nodes such as processing
2757: * instructions and comments, are ignored as defined in [XPath].
2758: *
2759: * If the string in the second argument is not found in the string-value
2760: * of the location, or if a value in the third or fourth argument indicates
2761: * a string that is beyond the beginning or end of the document, the
2762: * expression fails.
2763: *
2764: * The points of the range-locations in the returned location-set will
2765: * all be character points.
2766: * ------------------------------
2767: */
2768: static void
2769: xmlXPtrStringRangeFunction(xmlXPathParserContextPtr ctxt, int nargs) {
2770: int i, startindex, endindex = 0, fendindex;
2771: xmlNodePtr start, end = 0, fend;
2772: xmlXPathObjectPtr set;
2773: xmlLocationSetPtr oldset;
2774: xmlLocationSetPtr newset;
2775: xmlXPathObjectPtr string;
2776: xmlXPathObjectPtr position = NULL;
2777: xmlXPathObjectPtr number = NULL;
2778: int found, pos = 0, num = 0;
2779:
2780: /*
2781: * Grab the arguments
2782: */
2783: if ((nargs < 2) || (nargs > 4))
2784: XP_ERROR(XPATH_INVALID_ARITY);
2785:
2786: if (nargs >= 4) {
2787: CHECK_TYPE(XPATH_NUMBER);
2788: number = valuePop(ctxt);
2789: if (number != NULL)
2790: num = (int) number->floatval;
2791: }
2792: if (nargs >= 3) {
2793: CHECK_TYPE(XPATH_NUMBER);
2794: position = valuePop(ctxt);
2795: if (position != NULL)
2796: pos = (int) position->floatval;
2797: }
2798: CHECK_TYPE(XPATH_STRING);
2799: string = valuePop(ctxt);
2800: if ((ctxt->value == NULL) ||
2801: ((ctxt->value->type != XPATH_LOCATIONSET) &&
2802: (ctxt->value->type != XPATH_NODESET)))
2803: XP_ERROR(XPATH_INVALID_TYPE)
2804:
2805: set = valuePop(ctxt);
2806: newset = xmlXPtrLocationSetCreate(NULL);
2807: if (set->nodesetval == NULL) {
2808: goto error;
2809: }
2810: if (set->type == XPATH_NODESET) {
2811: xmlXPathObjectPtr tmp;
2812:
2813: /*
2814: * First convert to a location set
2815: */
2816: tmp = xmlXPtrNewLocationSetNodeSet(set->nodesetval);
2817: xmlXPathFreeObject(set);
2818: set = tmp;
2819: }
2820: oldset = (xmlLocationSetPtr) set->user;
2821:
2822: /*
2823: * The loop is to search for each element in the location set
2824: * the list of location set corresponding to that search
2825: */
2826: for (i = 0;i < oldset->locNr;i++) {
2827: #ifdef DEBUG_RANGES
2828: xmlXPathDebugDumpObject(stdout, oldset->locTab[i], 0);
2829: #endif
2830:
2831: xmlXPtrGetStartPoint(oldset->locTab[i], &start, &startindex);
2832: xmlXPtrGetEndPoint(oldset->locTab[i], &end, &endindex);
2833: xmlXPtrAdvanceChar(&start, &startindex, 0);
2834: xmlXPtrGetLastChar(&end, &endindex);
2835:
2836: #ifdef DEBUG_RANGES
2837: xmlGenericError(xmlGenericErrorContext,
2838: "from index %d of ->", startindex);
2839: xmlDebugDumpString(stdout, start->content);
2840: xmlGenericError(xmlGenericErrorContext, "\n");
2841: xmlGenericError(xmlGenericErrorContext,
2842: "to index %d of ->", endindex);
2843: xmlDebugDumpString(stdout, end->content);
2844: xmlGenericError(xmlGenericErrorContext, "\n");
2845: #endif
2846: do {
2847: fend = end;
2848: fendindex = endindex;
2849: found = xmlXPtrSearchString(string->stringval, &start, &startindex,
2850: &fend, &fendindex);
2851: if (found == 1) {
2852: if (position == NULL) {
2853: xmlXPtrLocationSetAdd(newset,
2854: xmlXPtrNewRange(start, startindex, fend, fendindex));
2855: } else if (xmlXPtrAdvanceChar(&start, &startindex,
2856: pos - 1) == 0) {
2857: if ((number != NULL) && (num > 0)) {
2858: int rindx;
2859: xmlNodePtr rend;
2860: rend = start;
2861: rindx = startindex - 1;
2862: if (xmlXPtrAdvanceChar(&rend, &rindx,
2863: num) == 0) {
2864: xmlXPtrLocationSetAdd(newset,
2865: xmlXPtrNewRange(start, startindex,
2866: rend, rindx));
2867: }
2868: } else if ((number != NULL) && (num <= 0)) {
2869: xmlXPtrLocationSetAdd(newset,
2870: xmlXPtrNewRange(start, startindex,
2871: start, startindex));
2872: } else {
2873: xmlXPtrLocationSetAdd(newset,
2874: xmlXPtrNewRange(start, startindex,
2875: fend, fendindex));
2876: }
2877: }
2878: start = fend;
2879: startindex = fendindex;
2880: if (string->stringval[0] == 0)
2881: startindex++;
2882: }
2883: } while (found == 1);
2884: }
2885:
2886: /*
2887: * Save the new value and cleanup
2888: */
2889: error:
2890: valuePush(ctxt, xmlXPtrWrapLocationSet(newset));
2891: xmlXPathFreeObject(set);
2892: xmlXPathFreeObject(string);
2893: if (position) xmlXPathFreeObject(position);
2894: if (number) xmlXPathFreeObject(number);
2895: }
2896:
2897: /**
2898: * xmlXPtrEvalRangePredicate:
2899: * @ctxt: the XPointer Parser context
2900: *
2901: * [8] Predicate ::= '[' PredicateExpr ']'
2902: * [9] PredicateExpr ::= Expr
2903: *
2904: * Evaluate a predicate as in xmlXPathEvalPredicate() but for
2905: * a Location Set instead of a node set
2906: */
2907: void
2908: xmlXPtrEvalRangePredicate(xmlXPathParserContextPtr ctxt) {
2909: const xmlChar *cur;
2910: xmlXPathObjectPtr res;
2911: xmlXPathObjectPtr obj, tmp;
2912: xmlLocationSetPtr newset = NULL;
2913: xmlLocationSetPtr oldset;
2914: int i;
2915:
2916: if (ctxt == NULL) return;
2917:
2918: SKIP_BLANKS;
2919: if (CUR != '[') {
2920: XP_ERROR(XPATH_INVALID_PREDICATE_ERROR);
2921: }
2922: NEXT;
2923: SKIP_BLANKS;
2924:
2925: /*
2926: * Extract the old set, and then evaluate the result of the
2927: * expression for all the element in the set. use it to grow
2928: * up a new set.
2929: */
2930: CHECK_TYPE(XPATH_LOCATIONSET);
2931: obj = valuePop(ctxt);
2932: oldset = obj->user;
2933: ctxt->context->node = NULL;
2934:
2935: if ((oldset == NULL) || (oldset->locNr == 0)) {
2936: ctxt->context->contextSize = 0;
2937: ctxt->context->proximityPosition = 0;
2938: xmlXPathEvalExpr(ctxt);
2939: res = valuePop(ctxt);
2940: if (res != NULL)
2941: xmlXPathFreeObject(res);
2942: valuePush(ctxt, obj);
2943: CHECK_ERROR;
2944: } else {
2945: /*
2946: * Save the expression pointer since we will have to evaluate
2947: * it multiple times. Initialize the new set.
2948: */
2949: cur = ctxt->cur;
2950: newset = xmlXPtrLocationSetCreate(NULL);
2951:
2952: for (i = 0; i < oldset->locNr; i++) {
2953: ctxt->cur = cur;
2954:
2955: /*
2956: * Run the evaluation with a node list made of a single item
2957: * in the nodeset.
2958: */
2959: ctxt->context->node = oldset->locTab[i]->user;
2960: tmp = xmlXPathNewNodeSet(ctxt->context->node);
2961: valuePush(ctxt, tmp);
2962: ctxt->context->contextSize = oldset->locNr;
2963: ctxt->context->proximityPosition = i + 1;
2964:
2965: xmlXPathEvalExpr(ctxt);
2966: CHECK_ERROR;
2967:
2968: /*
2969: * The result of the evaluation need to be tested to
2970: * decided whether the filter succeeded or not
2971: */
2972: res = valuePop(ctxt);
2973: if (xmlXPathEvaluatePredicateResult(ctxt, res)) {
2974: xmlXPtrLocationSetAdd(newset,
2975: xmlXPathObjectCopy(oldset->locTab[i]));
2976: }
2977:
2978: /*
2979: * Cleanup
2980: */
2981: if (res != NULL)
2982: xmlXPathFreeObject(res);
2983: if (ctxt->value == tmp) {
2984: res = valuePop(ctxt);
2985: xmlXPathFreeObject(res);
2986: }
2987:
2988: ctxt->context->node = NULL;
2989: }
2990:
2991: /*
2992: * The result is used as the new evaluation set.
2993: */
2994: xmlXPathFreeObject(obj);
2995: ctxt->context->node = NULL;
2996: ctxt->context->contextSize = -1;
2997: ctxt->context->proximityPosition = -1;
2998: valuePush(ctxt, xmlXPtrWrapLocationSet(newset));
2999: }
3000: if (CUR != ']') {
3001: XP_ERROR(XPATH_INVALID_PREDICATE_ERROR);
3002: }
3003:
3004: NEXT;
3005: SKIP_BLANKS;
3006: }
3007:
3008: #define bottom_xpointer
3009: #include "elfgcchack.h"
3010: #endif
3011:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to xpointer.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