| /* |
| * xpointer.c : Code to handle XML Pointer |
| * |
| * Base implementation was made accordingly to |
| * W3C Candidate Recommendation 7 June 2000 |
| * http://www.w3.org/TR/2000/CR-xptr-20000607 |
| * |
| * Added support for the element() scheme described in: |
| * W3C Proposed Recommendation 13 November 2002 |
| * http://www.w3.org/TR/2002/PR-xptr-element-20021113/ |
| * |
| * See Copyright for the status of this software. |
| * |
| * daniel@veillard.com |
| */ |
| |
| #define IN_LIBXML |
| #include "libxml.h" |
| |
| /* |
| * TODO: better handling of error cases, the full expression should |
| * be parsed beforehand instead of a progressive evaluation |
| * TODO: Access into entities references are not supported now ... |
| * need a start to be able to pop out of entities refs since |
| * parent is the endity declaration, not the ref. |
| */ |
| |
| #ifdef HAVE_STRING_H |
| #include <string.h> |
| #endif |
| #include <libxml/xpointer.h> |
| #include <libxml/xmlmemory.h> |
| #include <libxml/parserInternals.h> |
| #include <libxml/uri.h> |
| #include <libxml/xpath.h> |
| #include <libxml/xpathInternals.h> |
| #include <libxml/xmlerror.h> |
| #include <libxml/globals.h> |
| |
| #ifdef LIBXML_XPTR_ENABLED |
| |
| /* Add support of the xmlns() xpointer scheme to initialize the namespaces */ |
| #define XPTR_XMLNS_SCHEME |
| |
| /* #define DEBUG_RANGES */ |
| #ifdef DEBUG_RANGES |
| #ifdef LIBXML_DEBUG_ENABLED |
| #include <libxml/debugXML.h> |
| #endif |
| #endif |
| |
| #define TODO \ |
| xmlGenericError(xmlGenericErrorContext, \ |
| "Unimplemented block at %s:%d\n", \ |
| __FILE__, __LINE__); |
| |
| #define STRANGE \ |
| xmlGenericError(xmlGenericErrorContext, \ |
| "Internal error at %s:%d\n", \ |
| __FILE__, __LINE__); |
| |
| /************************************************************************ |
| * * |
| * Some factorized error routines * |
| * * |
| ************************************************************************/ |
| |
| /** |
| * xmlXPtrErrMemory: |
| * @extra: extra informations |
| * |
| * Handle a redefinition of attribute error |
| */ |
| static void |
| xmlXPtrErrMemory(const char *extra) |
| { |
| __xmlRaiseError(NULL, NULL, NULL, NULL, NULL, XML_FROM_XPOINTER, |
| XML_ERR_NO_MEMORY, XML_ERR_ERROR, NULL, 0, extra, |
| NULL, NULL, 0, 0, |
| "Memory allocation failed : %s\n", extra); |
| } |
| |
| /** |
| * xmlXPtrErr: |
| * @ctxt: an XPTR evaluation context |
| * @extra: extra informations |
| * |
| * Handle a redefinition of attribute error |
| */ |
| static void |
| xmlXPtrErr(xmlXPathParserContextPtr ctxt, int error, |
| const char * msg, const xmlChar *extra) |
| { |
| if (ctxt != NULL) |
| ctxt->error = error; |
| if ((ctxt == NULL) || (ctxt->context == NULL)) { |
| __xmlRaiseError(NULL, NULL, NULL, |
| NULL, NULL, XML_FROM_XPOINTER, error, |
| XML_ERR_ERROR, NULL, 0, |
| (const char *) extra, NULL, NULL, 0, 0, |
| msg, extra); |
| return; |
| } |
| ctxt->context->lastError.domain = XML_FROM_XPOINTER; |
| ctxt->context->lastError.code = error; |
| ctxt->context->lastError.level = XML_ERR_ERROR; |
| ctxt->context->lastError.str1 = (char *) xmlStrdup(ctxt->base); |
| ctxt->context->lastError.int1 = ctxt->cur - ctxt->base; |
| ctxt->context->lastError.node = ctxt->context->debugNode; |
| if (ctxt->context->error != NULL) { |
| ctxt->context->error(ctxt->context->userData, |
| &ctxt->context->lastError); |
| } else { |
| __xmlRaiseError(NULL, NULL, NULL, |
| NULL, ctxt->context->debugNode, XML_FROM_XPOINTER, |
| error, XML_ERR_ERROR, NULL, 0, |
| (const char *) extra, (const char *) ctxt->base, NULL, |
| ctxt->cur - ctxt->base, 0, |
| msg, extra); |
| } |
| } |
| |
| /************************************************************************ |
| * * |
| * A few helper functions for child sequences * |
| * * |
| ************************************************************************/ |
| /* xmlXPtrAdvanceNode is a private function, but used by xinclude.c */ |
| xmlNodePtr xmlXPtrAdvanceNode(xmlNodePtr cur, int *level); |
| /** |
| * xmlXPtrGetArity: |
| * @cur: the node |
| * |
| * Returns the number of child for an element, -1 in case of error |
| */ |
| static int |
| xmlXPtrGetArity(xmlNodePtr cur) { |
| int i; |
| if ((cur == NULL) || (cur->type == XML_NAMESPACE_DECL)) |
| return(-1); |
| cur = cur->children; |
| for (i = 0;cur != NULL;cur = cur->next) { |
| if ((cur->type == XML_ELEMENT_NODE) || |
| (cur->type == XML_DOCUMENT_NODE) || |
| (cur->type == XML_HTML_DOCUMENT_NODE)) { |
| i++; |
| } |
| } |
| return(i); |
| } |
| |
| /** |
| * xmlXPtrGetIndex: |
| * @cur: the node |
| * |
| * Returns the index of the node in its parent children list, -1 |
| * in case of error |
| */ |
| static int |
| xmlXPtrGetIndex(xmlNodePtr cur) { |
| int i; |
| if ((cur == NULL) || (cur->type == XML_NAMESPACE_DECL)) |
| return(-1); |
| for (i = 1;cur != NULL;cur = cur->prev) { |
| if ((cur->type == XML_ELEMENT_NODE) || |
| (cur->type == XML_DOCUMENT_NODE) || |
| (cur->type == XML_HTML_DOCUMENT_NODE)) { |
| i++; |
| } |
| } |
| return(i); |
| } |
| |
| /** |
| * xmlXPtrGetNthChild: |
| * @cur: the node |
| * @no: the child number |
| * |
| * Returns the @no'th element child of @cur or NULL |
| */ |
| static xmlNodePtr |
| xmlXPtrGetNthChild(xmlNodePtr cur, int no) { |
| int i; |
| if ((cur == NULL) || (cur->type == XML_NAMESPACE_DECL)) |
| return(cur); |
| cur = cur->children; |
| for (i = 0;i <= no;cur = cur->next) { |
| if (cur == NULL) |
| return(cur); |
| if ((cur->type == XML_ELEMENT_NODE) || |
| (cur->type == XML_DOCUMENT_NODE) || |
| (cur->type == XML_HTML_DOCUMENT_NODE)) { |
| i++; |
| if (i == no) |
| break; |
| } |
| } |
| return(cur); |
| } |
| |
| /************************************************************************ |
| * * |
| * Handling of XPointer specific types * |
| * * |
| ************************************************************************/ |
| |
| /** |
| * xmlXPtrCmpPoints: |
| * @node1: the first node |
| * @index1: the first index |
| * @node2: the second node |
| * @index2: the second index |
| * |
| * Compare two points w.r.t document order |
| * |
| * Returns -2 in case of error 1 if first point < second point, 0 if |
| * that's the same point, -1 otherwise |
| */ |
| static int |
| xmlXPtrCmpPoints(xmlNodePtr node1, int index1, xmlNodePtr node2, int index2) { |
| if ((node1 == NULL) || (node2 == NULL)) |
| return(-2); |
| /* |
| * a couple of optimizations which will avoid computations in most cases |
| */ |
| if (node1 == node2) { |
| if (index1 < index2) |
| return(1); |
| if (index1 > index2) |
| return(-1); |
| return(0); |
| } |
| return(xmlXPathCmpNodes(node1, node2)); |
| } |
| |
| /** |
| * xmlXPtrNewPoint: |
| * @node: the xmlNodePtr |
| * @indx: the indx within the node |
| * |
| * Create a new xmlXPathObjectPtr of type point |
| * |
| * Returns the newly created object. |
| */ |
| static xmlXPathObjectPtr |
| xmlXPtrNewPoint(xmlNodePtr node, int indx) { |
| xmlXPathObjectPtr ret; |
| |
| if (node == NULL) |
| return(NULL); |
| if (indx < 0) |
| return(NULL); |
| |
| ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject)); |
| if (ret == NULL) { |
| xmlXPtrErrMemory("allocating point"); |
| return(NULL); |
| } |
| XML_MEMSET(ret, 0 , (size_t) sizeof(xmlXPathObject)); |
| ret->type = XPATH_POINT; |
| ret->user = (void *) node; |
| ret->index = indx; |
| return(ret); |
| } |
| |
| /** |
| * xmlXPtrRangeCheckOrder: |
| * @range: an object range |
| * |
| * Make sure the points in the range are in the right order |
| */ |
| static void |
| xmlXPtrRangeCheckOrder(xmlXPathObjectPtr range) { |
| int tmp; |
| xmlNodePtr tmp2; |
| if (range == NULL) |
| return; |
| if (range->type != XPATH_RANGE) |
| return; |
| if (range->user2 == NULL) |
| return; |
| tmp = xmlXPtrCmpPoints(range->user, range->index, |
| range->user2, range->index2); |
| if (tmp == -1) { |
| tmp2 = range->user; |
| range->user = range->user2; |
| range->user2 = tmp2; |
| tmp = range->index; |
| range->index = range->index2; |
| range->index2 = tmp; |
| } |
| } |
| |
| /** |
| * xmlXPtrRangesEqual: |
| * @range1: the first range |
| * @range2: the second range |
| * |
| * Compare two ranges |
| * |
| * Returns 1 if equal, 0 otherwise |
| */ |
| static int |
| xmlXPtrRangesEqual(xmlXPathObjectPtr range1, xmlXPathObjectPtr range2) { |
| if (range1 == range2) |
| return(1); |
| if ((range1 == NULL) || (range2 == NULL)) |
| return(0); |
| if (range1->type != range2->type) |
| return(0); |
| if (range1->type != XPATH_RANGE) |
| return(0); |
| if (range1->user != range2->user) |
| return(0); |
| if (range1->index != range2->index) |
| return(0); |
| if (range1->user2 != range2->user2) |
| return(0); |
| if (range1->index2 != range2->index2) |
| return(0); |
| return(1); |
| } |
| |
| /** |
| * xmlXPtrNewRange: |
| * @start: the starting node |
| * @startindex: the start index |
| * @end: the ending point |
| * @endindex: the ending index |
| * |
| * Create a new xmlXPathObjectPtr of type range |
| * |
| * Returns the newly created object. |
| */ |
| xmlXPathObjectPtr |
| xmlXPtrNewRange(xmlNodePtr start, int startindex, |
| xmlNodePtr end, int endindex) { |
| xmlXPathObjectPtr ret; |
| |
| if (start == NULL) |
| return(NULL); |
| if (end == NULL) |
| return(NULL); |
| if (startindex < 0) |
| return(NULL); |
| if (endindex < 0) |
| return(NULL); |
| |
| ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject)); |
| if (ret == NULL) { |
| xmlXPtrErrMemory("allocating range"); |
| return(NULL); |
| } |
| XML_MEMSET(ret, 0 , (size_t) sizeof(xmlXPathObject)); |
| ret->type = XPATH_RANGE; |
| ret->user = start; |
| ret->index = startindex; |
| ret->user2 = end; |
| ret->index2 = endindex; |
| xmlXPtrRangeCheckOrder(ret); |
| return(ret); |
| } |
| |
| /** |
| * xmlXPtrNewRangePoints: |
| * @start: the starting point |
| * @end: the ending point |
| * |
| * Create a new xmlXPathObjectPtr of type range using 2 Points |
| * |
| * Returns the newly created object. |
| */ |
| xmlXPathObjectPtr |
| xmlXPtrNewRangePoints(xmlXPathObjectPtr start, xmlXPathObjectPtr end) { |
| xmlXPathObjectPtr ret; |
| |
| if (start == NULL) |
| return(NULL); |
| if (end == NULL) |
| return(NULL); |
| if (start->type != XPATH_POINT) |
| return(NULL); |
| if (end->type != XPATH_POINT) |
| return(NULL); |
| |
| ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject)); |
| if (ret == NULL) { |
| xmlXPtrErrMemory("allocating range"); |
| return(NULL); |
| } |
| XML_MEMSET(ret, 0 , (size_t) sizeof(xmlXPathObject)); |
| ret->type = XPATH_RANGE; |
| ret->user = start->user; |
| ret->index = start->index; |
| ret->user2 = end->user; |
| ret->index2 = end->index; |
| xmlXPtrRangeCheckOrder(ret); |
| return(ret); |
| } |
| |
| /** |
| * xmlXPtrNewRangePointNode: |
| * @start: the starting point |
| * @end: the ending node |
| * |
| * Create a new xmlXPathObjectPtr of type range from a point to a node |
| * |
| * Returns the newly created object. |
| */ |
| xmlXPathObjectPtr |
| xmlXPtrNewRangePointNode(xmlXPathObjectPtr start, xmlNodePtr end) { |
| xmlXPathObjectPtr ret; |
| |
| if (start == NULL) |
| return(NULL); |
| if (end == NULL) |
| return(NULL); |
| if (start->type != XPATH_POINT) |
| return(NULL); |
| |
| ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject)); |
| if (ret == NULL) { |
| xmlXPtrErrMemory("allocating range"); |
| return(NULL); |
| } |
| XML_MEMSET(ret, 0 , (size_t) sizeof(xmlXPathObject)); |
| ret->type = XPATH_RANGE; |
| ret->user = start->user; |
| ret->index = start->index; |
| ret->user2 = end; |
| ret->index2 = -1; |
| xmlXPtrRangeCheckOrder(ret); |
| return(ret); |
| } |
| |
| /** |
| * xmlXPtrNewRangeNodePoint: |
| * @start: the starting node |
| * @end: the ending point |
| * |
| * Create a new xmlXPathObjectPtr of type range from a node to a point |
| * |
| * Returns the newly created object. |
| */ |
| xmlXPathObjectPtr |
| xmlXPtrNewRangeNodePoint(xmlNodePtr start, xmlXPathObjectPtr end) { |
| xmlXPathObjectPtr ret; |
| |
| if (start == NULL) |
| return(NULL); |
| if (end == NULL) |
| return(NULL); |
| if (start->type != XPATH_POINT) |
| return(NULL); |
| if (end->type != XPATH_POINT) |
| return(NULL); |
| |
| ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject)); |
| if (ret == NULL) { |
| xmlXPtrErrMemory("allocating range"); |
| return(NULL); |
| } |
| XML_MEMSET(ret, 0 , (size_t) sizeof(xmlXPathObject)); |
| ret->type = XPATH_RANGE; |
| ret->user = start; |
| ret->index = -1; |
| ret->user2 = end->user; |
| ret->index2 = end->index; |
| xmlXPtrRangeCheckOrder(ret); |
| return(ret); |
| } |
| |
| /** |
| * xmlXPtrNewRangeNodes: |
| * @start: the starting node |
| * @end: the ending node |
| * |
| * Create a new xmlXPathObjectPtr of type range using 2 nodes |
| * |
| * Returns the newly created object. |
| */ |
| xmlXPathObjectPtr |
| xmlXPtrNewRangeNodes(xmlNodePtr start, xmlNodePtr end) { |
| xmlXPathObjectPtr ret; |
| |
| if (start == NULL) |
| return(NULL); |
| if (end == NULL) |
| return(NULL); |
| |
| ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject)); |
| if (ret == NULL) { |
| xmlXPtrErrMemory("allocating range"); |
| return(NULL); |
| } |
| XML_MEMSET(ret, 0 , (size_t) sizeof(xmlXPathObject)); |
| ret->type = XPATH_RANGE; |
| ret->user = start; |
| ret->index = -1; |
| ret->user2 = end; |
| ret->index2 = -1; |
| xmlXPtrRangeCheckOrder(ret); |
| return(ret); |
| } |
| |
| /** |
| * xmlXPtrNewCollapsedRange: |
| * @start: the starting and ending node |
| * |
| * Create a new xmlXPathObjectPtr of type range using a single nodes |
| * |
| * Returns the newly created object. |
| */ |
| xmlXPathObjectPtr |
| xmlXPtrNewCollapsedRange(xmlNodePtr start) { |
| xmlXPathObjectPtr ret; |
| |
| if (start == NULL) |
| return(NULL); |
| |
| ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject)); |
| if (ret == NULL) { |
| xmlXPtrErrMemory("allocating range"); |
| return(NULL); |
| } |
| XML_MEMSET(ret, 0 , (size_t) sizeof(xmlXPathObject)); |
| ret->type = XPATH_RANGE; |
| ret->user = start; |
| ret->index = -1; |
| ret->user2 = NULL; |
| ret->index2 = -1; |
| return(ret); |
| } |
| |
| /** |
| * xmlXPtrNewRangeNodeObject: |
| * @start: the starting node |
| * @end: the ending object |
| * |
| * Create a new xmlXPathObjectPtr of type range from a not to an object |
| * |
| * Returns the newly created object. |
| */ |
| xmlXPathObjectPtr |
| xmlXPtrNewRangeNodeObject(xmlNodePtr start, xmlXPathObjectPtr end) { |
| xmlXPathObjectPtr ret; |
| |
| if (start == NULL) |
| return(NULL); |
| if (end == NULL) |
| return(NULL); |
| switch (end->type) { |
| case XPATH_POINT: |
| case XPATH_RANGE: |
| break; |
| case XPATH_NODESET: |
| /* |
| * Empty set ... |
| */ |
| if (end->nodesetval->nodeNr <= 0) |
| return(NULL); |
| break; |
| default: |
| /* TODO */ |
| return(NULL); |
| } |
| |
| ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject)); |
| if (ret == NULL) { |
| xmlXPtrErrMemory("allocating range"); |
| return(NULL); |
| } |
| XML_MEMSET(ret, 0 , (size_t) sizeof(xmlXPathObject)); |
| ret->type = XPATH_RANGE; |
| ret->user = start; |
| ret->index = -1; |
| switch (end->type) { |
| case XPATH_POINT: |
| ret->user2 = end->user; |
| ret->index2 = end->index; |
| break; |
| case XPATH_RANGE: |
| ret->user2 = end->user2; |
| ret->index2 = end->index2; |
| break; |
| case XPATH_NODESET: { |
| ret->user2 = end->nodesetval->nodeTab[end->nodesetval->nodeNr - 1]; |
| ret->index2 = -1; |
| break; |
| } |
| default: |
| STRANGE |
| return(NULL); |
| } |
| xmlXPtrRangeCheckOrder(ret); |
| return(ret); |
| } |
| |
| #define XML_RANGESET_DEFAULT 10 |
| |
| /** |
| * xmlXPtrLocationSetCreate: |
| * @val: an initial xmlXPathObjectPtr, or NULL |
| * |
| * Create a new xmlLocationSetPtr of type double and of value @val |
| * |
| * Returns the newly created object. |
| */ |
| xmlLocationSetPtr |
| xmlXPtrLocationSetCreate(xmlXPathObjectPtr val) { |
| xmlLocationSetPtr ret; |
| |
| ret = (xmlLocationSetPtr) xmlMalloc(sizeof(xmlLocationSet)); |
| if (ret == NULL) { |
| xmlXPtrErrMemory("allocating locationset"); |
| return(NULL); |
| } |
| XML_MEMSET(ret, 0 , (size_t) sizeof(xmlLocationSet)); |
| if (val != NULL) { |
| ret->locTab = (xmlXPathObjectPtr *) xmlMalloc(XML_RANGESET_DEFAULT * |
| sizeof(xmlXPathObjectPtr)); |
| if (ret->locTab == NULL) { |
| xmlXPtrErrMemory("allocating locationset"); |
| xmlFree(ret); |
| return(NULL); |
| } |
| XML_MEMSET(ret->locTab, 0 , |
| XML_RANGESET_DEFAULT * (size_t) sizeof(xmlXPathObjectPtr)); |
| ret->locMax = XML_RANGESET_DEFAULT; |
| ret->locTab[ret->locNr++] = val; |
| } |
| return(ret); |
| } |
| |
| /** |
| * xmlXPtrLocationSetAdd: |
| * @cur: the initial range set |
| * @val: a new xmlXPathObjectPtr |
| * |
| * add a new xmlXPathObjectPtr to an existing LocationSet |
| * If the location already exist in the set @val is freed. |
| */ |
| void |
| xmlXPtrLocationSetAdd(xmlLocationSetPtr cur, xmlXPathObjectPtr val) { |
| int i; |
| |
| if ((cur == NULL) || (val == NULL)) return; |
| |
| /* |
| * check against doublons |
| */ |
| for (i = 0;i < cur->locNr;i++) { |
| if (xmlXPtrRangesEqual(cur->locTab[i], val)) { |
| xmlXPathFreeObject(val); |
| return; |
| } |
| } |
| |
| /* |
| * grow the locTab if needed |
| */ |
| if (cur->locMax == 0) { |
| cur->locTab = (xmlXPathObjectPtr *) xmlMalloc(XML_RANGESET_DEFAULT * |
| sizeof(xmlXPathObjectPtr)); |
| if (cur->locTab == NULL) { |
| xmlXPtrErrMemory("adding location to set"); |
| return; |
| } |
| XML_MEMSET(cur->locTab, 0 , |
| XML_RANGESET_DEFAULT * (size_t) sizeof(xmlXPathObjectPtr)); |
| cur->locMax = XML_RANGESET_DEFAULT; |
| } else if (cur->locNr == cur->locMax) { |
| xmlXPathObjectPtr *temp; |
| |
| cur->locMax *= 2; |
| temp = (xmlXPathObjectPtr *) xmlRealloc(cur->locTab, cur->locMax * |
| sizeof(xmlXPathObjectPtr)); |
| if (temp == NULL) { |
| xmlXPtrErrMemory("adding location to set"); |
| return; |
| } |
| cur->locTab = temp; |
| } |
| cur->locTab[cur->locNr++] = val; |
| } |
| |
| /** |
| * xmlXPtrLocationSetMerge: |
| * @val1: the first LocationSet |
| * @val2: the second LocationSet |
| * |
| * Merges two rangesets, all ranges from @val2 are added to @val1 |
| * |
| * Returns val1 once extended or NULL in case of error. |
| */ |
| xmlLocationSetPtr |
| xmlXPtrLocationSetMerge(xmlLocationSetPtr val1, xmlLocationSetPtr val2) { |
| int i; |
| |
| if (val1 == NULL) return(NULL); |
| if (val2 == NULL) return(val1); |
| |
| /* |
| * !!!!! this can be optimized a lot, knowing that both |
| * val1 and val2 already have unicity of their values. |
| */ |
| |
| for (i = 0;i < val2->locNr;i++) |
| xmlXPtrLocationSetAdd(val1, val2->locTab[i]); |
| |
| return(val1); |
| } |
| |
| /** |
| * xmlXPtrLocationSetDel: |
| * @cur: the initial range set |
| * @val: an xmlXPathObjectPtr |
| * |
| * Removes an xmlXPathObjectPtr from an existing LocationSet |
| */ |
| void |
| xmlXPtrLocationSetDel(xmlLocationSetPtr cur, xmlXPathObjectPtr val) { |
| int i; |
| |
| if (cur == NULL) return; |
| if (val == NULL) return; |
| |
| /* |
| * check against doublons |
| */ |
| for (i = 0;i < cur->locNr;i++) |
| if (cur->locTab[i] == val) break; |
| |
| if (i >= cur->locNr) { |
| #ifdef DEBUG |
| xmlGenericError(xmlGenericErrorContext, |
| "xmlXPtrLocationSetDel: Range wasn't found in RangeList\n"); |
| #endif |
| return; |
| } |
| cur->locNr--; |
| for (;i < cur->locNr;i++) |
| cur->locTab[i] = cur->locTab[i + 1]; |
| cur->locTab[cur->locNr] = NULL; |
| } |
| |
| /** |
| * xmlXPtrLocationSetRemove: |
| * @cur: the initial range set |
| * @val: the index to remove |
| * |
| * Removes an entry from an existing LocationSet list. |
| */ |
| void |
| xmlXPtrLocationSetRemove(xmlLocationSetPtr cur, int val) { |
| if (cur == NULL) return; |
| if (val >= cur->locNr) return; |
| cur->locNr--; |
| for (;val < cur->locNr;val++) |
| cur->locTab[val] = cur->locTab[val + 1]; |
| cur->locTab[cur->locNr] = NULL; |
| } |
| |
| /** |
| * xmlXPtrFreeLocationSet: |
| * @obj: the xmlLocationSetPtr to free |
| * |
| * Free the LocationSet compound (not the actual ranges !). |
| */ |
| void |
| xmlXPtrFreeLocationSet(xmlLocationSetPtr obj) { |
| int i; |
| |
| if (obj == NULL) return; |
| if (obj->locTab != NULL) { |
| for (i = 0;i < obj->locNr; i++) { |
| xmlXPathFreeObject(obj->locTab[i]); |
| } |
| xmlFree(obj->locTab); |
| } |
| xmlFree(obj); |
| } |
| |
| /** |
| * xmlXPtrNewLocationSetNodes: |
| * @start: the start NodePtr value |
| * @end: the end NodePtr value or NULL |
| * |
| * Create a new xmlXPathObjectPtr of type LocationSet and initialize |
| * it with the single range made of the two nodes @start and @end |
| * |
| * Returns the newly created object. |
| */ |
| xmlXPathObjectPtr |
| xmlXPtrNewLocationSetNodes(xmlNodePtr start, xmlNodePtr end) { |
| xmlXPathObjectPtr ret; |
| |
| ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject)); |
| if (ret == NULL) { |
| xmlXPtrErrMemory("allocating locationset"); |
| return(NULL); |
| } |
| XML_MEMSET(ret, 0 , (size_t) sizeof(xmlXPathObject)); |
| ret->type = XPATH_LOCATIONSET; |
| if (end == NULL) |
| ret->user = xmlXPtrLocationSetCreate(xmlXPtrNewCollapsedRange(start)); |
| else |
| ret->user = xmlXPtrLocationSetCreate(xmlXPtrNewRangeNodes(start,end)); |
| return(ret); |
| } |
| |
| /** |
| * xmlXPtrNewLocationSetNodeSet: |
| * @set: a node set |
| * |
| * Create a new xmlXPathObjectPtr of type LocationSet and initialize |
| * it with all the nodes from @set |
| * |
| * Returns the newly created object. |
| */ |
| xmlXPathObjectPtr |
| xmlXPtrNewLocationSetNodeSet(xmlNodeSetPtr set) { |
| xmlXPathObjectPtr ret; |
| |
| ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject)); |
| if (ret == NULL) { |
| xmlXPtrErrMemory("allocating locationset"); |
| return(NULL); |
| } |
| XML_MEMSET(ret, 0 , (size_t) sizeof(xmlXPathObject)); |
| ret->type = XPATH_LOCATIONSET; |
| if (set != NULL) { |
| int i; |
| xmlLocationSetPtr newset; |
| |
| newset = xmlXPtrLocationSetCreate(NULL); |
| if (newset == NULL) |
| return(ret); |
| |
| for (i = 0;i < set->nodeNr;i++) |
| xmlXPtrLocationSetAdd(newset, |
| xmlXPtrNewCollapsedRange(set->nodeTab[i])); |
| |
| ret->user = (void *) newset; |
| } |
| return(ret); |
| } |
| |
| /** |
| * xmlXPtrWrapLocationSet: |
| * @val: the LocationSet value |
| * |
| * Wrap the LocationSet @val in a new xmlXPathObjectPtr |
| * |
| * Returns the newly created object. |
| */ |
| xmlXPathObjectPtr |
| xmlXPtrWrapLocationSet(xmlLocationSetPtr val) { |
| xmlXPathObjectPtr ret; |
| |
| ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject)); |
| if (ret == NULL) { |
| xmlXPtrErrMemory("allocating locationset"); |
| return(NULL); |
| } |
| XML_MEMSET(ret, 0 , (size_t) sizeof(xmlXPathObject)); |
| ret->type = XPATH_LOCATIONSET; |
| ret->user = (void *) val; |
| return(ret); |
| } |
| |
| /************************************************************************ |
| * * |
| * The parser * |
| * * |
| ************************************************************************/ |
| |
| static void xmlXPtrEvalChildSeq(xmlXPathParserContextPtr ctxt, xmlChar *name); |
| |
| /* |
| * Macros for accessing the content. Those should be used only by the parser, |
| * and not exported. |
| * |
| * Dirty macros, i.e. one need to make assumption on the context to use them |
| * |
| * CUR_PTR return the current pointer to the xmlChar to be parsed. |
| * CUR returns the current xmlChar value, i.e. a 8 bit value |
| * in ISO-Latin or UTF-8. |
| * This should be used internally by the parser |
| * only to compare to ASCII values otherwise it would break when |
| * running with UTF-8 encoding. |
| * NXT(n) returns the n'th next xmlChar. Same as CUR is should be used only |
| * to compare on ASCII based substring. |
| * SKIP(n) Skip n xmlChar, and must also be used only to skip ASCII defined |
| * strings within the parser. |
| * CURRENT Returns the current char value, with the full decoding of |
| * UTF-8 if we are using this mode. It returns an int. |
| * NEXT Skip to the next character, this does the proper decoding |
| * in UTF-8 mode. It also pop-up unfinished entities on the fly. |
| * It returns the pointer to the current xmlChar. |
| */ |
| |
| #define CUR (*ctxt->cur) |
| #define SKIP(val) ctxt->cur += (val) |
| #define NXT(val) ctxt->cur[(val)] |
| #define CUR_PTR ctxt->cur |
| |
| #define SKIP_BLANKS \ |
| while (IS_BLANK_CH(*(ctxt->cur))) NEXT |
| |
| #define CURRENT (*ctxt->cur) |
| #define NEXT ((*ctxt->cur) ? ctxt->cur++: ctxt->cur) |
| |
| /* |
| * xmlXPtrGetChildNo: |
| * @ctxt: the XPointer Parser context |
| * @index: the child number |
| * |
| * Move the current node of the nodeset on the stack to the |
| * given child if found |
| */ |
| static void |
| xmlXPtrGetChildNo(xmlXPathParserContextPtr ctxt, int indx) { |
| xmlNodePtr cur = NULL; |
| xmlXPathObjectPtr obj; |
| xmlNodeSetPtr oldset; |
| |
| CHECK_TYPE(XPATH_NODESET); |
| obj = valuePop(ctxt); |
| oldset = obj->nodesetval; |
| if ((indx <= 0) || (oldset == NULL) || (oldset->nodeNr != 1)) { |
| xmlXPathFreeObject(obj); |
| valuePush(ctxt, xmlXPathNewNodeSet(NULL)); |
| return; |
| } |
| cur = xmlXPtrGetNthChild(oldset->nodeTab[0], indx); |
| if (cur == NULL) { |
| xmlXPathFreeObject(obj); |
| valuePush(ctxt, xmlXPathNewNodeSet(NULL)); |
| return; |
| } |
| oldset->nodeTab[0] = cur; |
| valuePush(ctxt, obj); |
| } |
| |
| /** |
| * xmlXPtrEvalXPtrPart: |
| * @ctxt: the XPointer Parser context |
| * @name: the preparsed Scheme for the XPtrPart |
| * |
| * XPtrPart ::= 'xpointer' '(' XPtrExpr ')' |
| * | Scheme '(' SchemeSpecificExpr ')' |
| * |
| * Scheme ::= NCName - 'xpointer' [VC: Non-XPointer schemes] |
| * |
| * SchemeSpecificExpr ::= StringWithBalancedParens |
| * |
| * StringWithBalancedParens ::= |
| * [^()]* ('(' StringWithBalancedParens ')' [^()]*)* |
| * [VC: Parenthesis escaping] |
| * |
| * XPtrExpr ::= Expr [VC: Parenthesis escaping] |
| * |
| * VC: Parenthesis escaping: |
| * The end of an XPointer part is signaled by the right parenthesis ")" |
| * character that is balanced with the left parenthesis "(" character |
| * that began the part. Any unbalanced parenthesis character inside the |
| * expression, even within literals, must be escaped with a circumflex (^) |
| * character preceding it. If the expression contains any literal |
| * occurrences of the circumflex, each must be escaped with an additional |
| * circumflex (that is, ^^). If the unescaped parentheses in the expression |
| * are not balanced, a syntax error results. |
| * |
| * Parse and evaluate an XPtrPart. Basically it generates the unescaped |
| * string and if the scheme is 'xpointer' it will call the XPath interpreter. |
| * |
| * TODO: there is no new scheme registration mechanism |
| */ |
| |
| static void |
| xmlXPtrEvalXPtrPart(xmlXPathParserContextPtr ctxt, xmlChar *name) { |
| xmlChar *buffer, *cur; |
| int len; |
| int level; |
| |
| if (name == NULL) |
| name = xmlXPathParseName(ctxt); |
| if (name == NULL) |
| XP_ERROR(XPATH_EXPR_ERROR); |
| |
| if (CUR != '(') |
| XP_ERROR(XPATH_EXPR_ERROR); |
| NEXT; |
| level = 1; |
| |
| len = xmlStrlen(ctxt->cur); |
| len++; |
| buffer = (xmlChar *) xmlMallocAtomic(len * sizeof (xmlChar)); |
| if (buffer == NULL) { |
| xmlXPtrErrMemory("allocating buffer"); |
| return; |
| } |
| |
| cur = buffer; |
| while (CUR != 0) { |
| if (CUR == ')') { |
| level--; |
| if (level == 0) { |
| NEXT; |
| break; |
| } |
| } else if (CUR == '(') { |
| level++; |
| } else if (CUR == '^') { |
| if ((NXT(1) == ')') || (NXT(1) == '(') || (NXT(1) == '^')) { |
| NEXT; |
| } |
| } |
| *cur++ = CUR; |
| NEXT; |
| } |
| *cur = 0; |
| |
| if ((level != 0) && (CUR == 0)) { |
| xmlFree(buffer); |
| XP_ERROR(XPTR_SYNTAX_ERROR); |
| } |
| |
| if (xmlStrEqual(name, (xmlChar *) "xpointer")) { |
| const xmlChar *left = CUR_PTR; |
| |
| CUR_PTR = buffer; |
| /* |
| * To evaluate an xpointer scheme element (4.3) we need: |
| * context initialized to the root |
| * context position initalized to 1 |
| * context size initialized to 1 |
| */ |
| ctxt->context->node = (xmlNodePtr)ctxt->context->doc; |
| ctxt->context->proximityPosition = 1; |
| ctxt->context->contextSize = 1; |
| xmlXPathEvalExpr(ctxt); |
| CUR_PTR=left; |
| } else if (xmlStrEqual(name, (xmlChar *) "element")) { |
| const xmlChar *left = CUR_PTR; |
| xmlChar *name2; |
| |
| CUR_PTR = buffer; |
| if (buffer[0] == '/') { |
| xmlXPathRoot(ctxt); |
| xmlXPtrEvalChildSeq(ctxt, NULL); |
| } else { |
| name2 = xmlXPathParseName(ctxt); |
| if (name2 == NULL) { |
| CUR_PTR = left; |
| xmlFree(buffer); |
| XP_ERROR(XPATH_EXPR_ERROR); |
| } |
| xmlXPtrEvalChildSeq(ctxt, name2); |
| } |
| CUR_PTR = left; |
| #ifdef XPTR_XMLNS_SCHEME |
| } else if (xmlStrEqual(name, (xmlChar *) "xmlns")) { |
| const xmlChar *left = CUR_PTR; |
| xmlChar *prefix; |
| xmlChar *URI; |
| xmlURIPtr value; |
| |
| CUR_PTR = buffer; |
| prefix = xmlXPathParseNCName(ctxt); |
| if (prefix == NULL) { |
| xmlFree(buffer); |
| xmlFree(name); |
| XP_ERROR(XPTR_SYNTAX_ERROR); |
| } |
| SKIP_BLANKS; |
| if (CUR != '=') { |
| xmlFree(prefix); |
| xmlFree(buffer); |
| xmlFree(name); |
| XP_ERROR(XPTR_SYNTAX_ERROR); |
| } |
| NEXT; |
| SKIP_BLANKS; |
| /* @@ check escaping in the XPointer WD */ |
| |
| value = xmlParseURI((const char *)ctxt->cur); |
| if (value == NULL) { |
| xmlFree(prefix); |
| xmlFree(buffer); |
| xmlFree(name); |
| XP_ERROR(XPTR_SYNTAX_ERROR); |
| } |
| URI = xmlSaveUri(value); |
| xmlFreeURI(value); |
| if (URI == NULL) { |
| xmlFree(prefix); |
| xmlFree(buffer); |
| xmlFree(name); |
| XP_ERROR(XPATH_MEMORY_ERROR); |
| } |
| |
| xmlXPathRegisterNs(ctxt->context, prefix, URI); |
| CUR_PTR = left; |
| xmlFree(URI); |
| xmlFree(prefix); |
| #endif /* XPTR_XMLNS_SCHEME */ |
| } else { |
| xmlXPtrErr(ctxt, XML_XPTR_UNKNOWN_SCHEME, |
| "unsupported scheme '%s'\n", name); |
| } |
| xmlFree(buffer); |
| xmlFree(name); |
| } |
| |
| /** |
| * xmlXPtrEvalFullXPtr: |
| * @ctxt: the XPointer Parser context |
| * @name: the preparsed Scheme for the first XPtrPart |
| * |
| * FullXPtr ::= XPtrPart (S? XPtrPart)* |
| * |
| * As the specs says: |
| * ----------- |
| * When multiple XPtrParts are provided, they must be evaluated in |
| * left-to-right order. If evaluation of one part fails, the nexti |
| * is evaluated. The following conditions cause XPointer part failure: |
| * |
| * - An unknown scheme |
| * - A scheme that does not locate any sub-resource present in the resource |
| * - A scheme that is not applicable to the media type of the resource |
| * |
| * The XPointer application must consume a failed XPointer part and |
| * attempt to evaluate the next one, if any. The result of the first |
| * XPointer part whose evaluation succeeds is taken to be the fragment |
| * located by the XPointer as a whole. If all the parts fail, the result |
| * for the XPointer as a whole is a sub-resource error. |
| * ----------- |
| * |
| * Parse and evaluate a Full XPtr i.e. possibly a cascade of XPath based |
| * expressions or other schemes. |
| */ |
| static void |
| xmlXPtrEvalFullXPtr(xmlXPathParserContextPtr ctxt, xmlChar *name) { |
| if (name == NULL) |
| name = xmlXPathParseName(ctxt); |
| if (name == NULL) |
| XP_ERROR(XPATH_EXPR_ERROR); |
| while (name != NULL) { |
| ctxt->error = XPATH_EXPRESSION_OK; |
| xmlXPtrEvalXPtrPart(ctxt, name); |
| |
| /* in case of syntax error, break here */ |
| if ((ctxt->error != XPATH_EXPRESSION_OK) && |
| (ctxt->error != XML_XPTR_UNKNOWN_SCHEME)) |
| return; |
| |
| /* |
| * If the returned value is a non-empty nodeset |
| * or location set, return here. |
| */ |
| if (ctxt->value != NULL) { |
| xmlXPathObjectPtr obj = ctxt->value; |
| |
| switch (obj->type) { |
| case XPATH_LOCATIONSET: { |
| xmlLocationSetPtr loc = ctxt->value->user; |
| if ((loc != NULL) && (loc->locNr > 0)) |
| return; |
| break; |
| } |
| case XPATH_NODESET: { |
| xmlNodeSetPtr loc = ctxt->value->nodesetval; |
| if ((loc != NULL) && (loc->nodeNr > 0)) |
| return; |
| break; |
| } |
| default: |
| break; |
| } |
| |
| /* |
| * Evaluating to improper values is equivalent to |
| * a sub-resource error, clean-up the stack |
| */ |
| do { |
| obj = valuePop(ctxt); |
| if (obj != NULL) { |
| xmlXPathFreeObject(obj); |
| } |
| } while (obj != NULL); |
| } |
| |
| /* |
| * Is there another XPointer part. |
| */ |
| SKIP_BLANKS; |
| name = xmlXPathParseName(ctxt); |
| } |
| } |
| |
| /** |
| * xmlXPtrEvalChildSeq: |
| * @ctxt: the XPointer Parser context |
| * @name: a possible ID name of the child sequence |
| * |
| * ChildSeq ::= '/1' ('/' [0-9]*)* |
| * | Name ('/' [0-9]*)+ |
| * |
| * Parse and evaluate a Child Sequence. This routine also handle the |
| * case of a Bare Name used to get a document ID. |
| */ |
| static void |
| xmlXPtrEvalChildSeq(xmlXPathParserContextPtr ctxt, xmlChar *name) { |
| /* |
| * XPointer don't allow by syntax to address in mutirooted trees |
| * this might prove useful in some cases, warn about it. |
| */ |
| if ((name == NULL) && (CUR == '/') && (NXT(1) != '1')) { |
| xmlXPtrErr(ctxt, XML_XPTR_CHILDSEQ_START, |
| "warning: ChildSeq not starting by /1\n", NULL); |
| } |
| |
| if (name != NULL) { |
| valuePush(ctxt, xmlXPathNewString(name)); |
| xmlFree(name); |
| xmlXPathIdFunction(ctxt, 1); |
| CHECK_ERROR; |
| } |
| |
| while (CUR == '/') { |
| int child = 0; |
| NEXT; |
| |
| while ((CUR >= '0') && (CUR <= '9')) { |
| child = child * 10 + (CUR - '0'); |
| NEXT; |
| } |
| xmlXPtrGetChildNo(ctxt, child); |
| } |
| } |
| |
| |
| /** |
| * xmlXPtrEvalXPointer: |
| * @ctxt: the XPointer Parser context |
| * |
| * XPointer ::= Name |
| * | ChildSeq |
| * | FullXPtr |
| * |
| * Parse and evaluate an XPointer |
| */ |
| static void |
| xmlXPtrEvalXPointer(xmlXPathParserContextPtr ctxt) { |
| if (ctxt->valueTab == NULL) { |
| /* Allocate the value stack */ |
| ctxt->valueTab = (xmlXPathObjectPtr *) |
| xmlMalloc(10 * sizeof(xmlXPathObjectPtr)); |
| if (ctxt->valueTab == NULL) { |
| xmlXPtrErrMemory("allocating evaluation context"); |
| return; |
| } |
| ctxt->valueNr = 0; |
| ctxt->valueMax = 10; |
| ctxt->value = NULL; |
| ctxt->valueFrame = 0; |
| } |
| SKIP_BLANKS; |
| if (CUR == '/') { |
| xmlXPathRoot(ctxt); |
| xmlXPtrEvalChildSeq(ctxt, NULL); |
| } else { |
| xmlChar *name; |
| |
| name = xmlXPathParseName(ctxt); |
| if (name == NULL) |
| XP_ERROR(XPATH_EXPR_ERROR); |
| if (CUR == '(') { |
| xmlXPtrEvalFullXPtr(ctxt, name); |
| /* Short evaluation */ |
| return; |
| } else { |
| /* this handle both Bare Names and Child Sequences */ |
| xmlXPtrEvalChildSeq(ctxt, name); |
| } |
| } |
| SKIP_BLANKS; |
| if (CUR != 0) |
| XP_ERROR(XPATH_EXPR_ERROR); |
| } |
| |
| |
| /************************************************************************ |
| * * |
| * General routines * |
| * * |
| ************************************************************************/ |
| |
| static |
| void xmlXPtrStringRangeFunction(xmlXPathParserContextPtr ctxt, int nargs); |
| static |
| void xmlXPtrStartPointFunction(xmlXPathParserContextPtr ctxt, int nargs); |
| static |
| void xmlXPtrEndPointFunction(xmlXPathParserContextPtr ctxt, int nargs); |
| static |
| void xmlXPtrHereFunction(xmlXPathParserContextPtr ctxt, int nargs); |
| static |
| void xmlXPtrOriginFunction(xmlXPathParserContextPtr ctxt, int nargs); |
| static |
| void xmlXPtrRangeInsideFunction(xmlXPathParserContextPtr ctxt, int nargs); |
| static |
| void xmlXPtrRangeFunction(xmlXPathParserContextPtr ctxt, int nargs); |
| |
| /** |
| * xmlXPtrNewContext: |
| * @doc: the XML document |
| * @here: the node that directly contains the XPointer being evaluated or NULL |
| * @origin: the element from which a user or program initiated traversal of |
| * the link, or NULL. |
| * |
| * Create a new XPointer context |
| * |
| * Returns the xmlXPathContext just allocated. |
| */ |
| xmlXPathContextPtr |
| xmlXPtrNewContext(xmlDocPtr doc, xmlNodePtr here, xmlNodePtr origin) { |
| xmlXPathContextPtr ret; |
| |
| ret = xmlXPathNewContext(doc); |
| if (ret == NULL) |
| return(ret); |
| ret->xptr = 1; |
| ret->here = here; |
| ret->origin = origin; |
| |
| xmlXPathRegisterFunc(ret, (xmlChar *)"range-to", |
| xmlXPtrRangeToFunction); |
| xmlXPathRegisterFunc(ret, (xmlChar *)"range", |
| xmlXPtrRangeFunction); |
| xmlXPathRegisterFunc(ret, (xmlChar *)"range-inside", |
| xmlXPtrRangeInsideFunction); |
| xmlXPathRegisterFunc(ret, (xmlChar *)"string-range", |
| xmlXPtrStringRangeFunction); |
| xmlXPathRegisterFunc(ret, (xmlChar *)"start-point", |
| xmlXPtrStartPointFunction); |
| xmlXPathRegisterFunc(ret, (xmlChar *)"end-point", |
| xmlXPtrEndPointFunction); |
| xmlXPathRegisterFunc(ret, (xmlChar *)"here", |
| xmlXPtrHereFunction); |
| xmlXPathRegisterFunc(ret, (xmlChar *)" origin", |
| xmlXPtrOriginFunction); |
| |
| return(ret); |
| } |
| |
| /** |
| * xmlXPtrEval: |
| * @str: the XPointer expression |
| * @ctx: the XPointer context |
| * |
| * Evaluate the XPath Location Path in the given context. |
| * |
| * Returns the xmlXPathObjectPtr resulting from the evaluation or NULL. |
| * the caller has to free the object. |
| */ |
| xmlXPathObjectPtr |
| xmlXPtrEval(const xmlChar *str, xmlXPathContextPtr ctx) { |
| xmlXPathParserContextPtr ctxt; |
| xmlXPathObjectPtr res = NULL, tmp; |
| xmlXPathObjectPtr init = NULL; |
| int stack = 0; |
| |
| xmlXPathInit(); |
| |
| if ((ctx == NULL) || (str == NULL)) |
| return(NULL); |
| |
| ctxt = xmlXPathNewParserContext(str, ctx); |
| if (ctxt == NULL) |
| return(NULL); |
| ctxt->xptr = 1; |
| xmlXPtrEvalXPointer(ctxt); |
| |
| if ((ctxt->value != NULL) && |
| (ctxt->value->type != XPATH_NODESET) && |
| (ctxt->value->type != XPATH_LOCATIONSET)) { |
| xmlXPtrErr(ctxt, XML_XPTR_EVAL_FAILED, |
| "xmlXPtrEval: evaluation failed to return a node set\n", |
| NULL); |
| } else { |
| res = valuePop(ctxt); |
| } |
| |
| do { |
| tmp = valuePop(ctxt); |
| if (tmp != NULL) { |
| if (tmp != init) { |
| if (tmp->type == XPATH_NODESET) { |
| /* |
| * Evaluation may push a root nodeset which is unused |
| */ |
| xmlNodeSetPtr set; |
| set = tmp->nodesetval; |
| if ((set->nodeNr != 1) || |
| (set->nodeTab[0] != (xmlNodePtr) ctx->doc)) |
| stack++; |
| } else |
| stack++; |
| } |
| xmlXPathFreeObject(tmp); |
| } |
| } while (tmp != NULL); |
| if (stack != 0) { |
| xmlXPtrErr(ctxt, XML_XPTR_EXTRA_OBJECTS, |
| "xmlXPtrEval: object(s) left on the eval stack\n", |
| NULL); |
| } |
| if (ctxt->error != XPATH_EXPRESSION_OK) { |
| xmlXPathFreeObject(res); |
| res = NULL; |
| } |
| |
| xmlXPathFreeParserContext(ctxt); |
| return(res); |
| } |
| |
| /** |
| * xmlXPtrBuildRangeNodeList: |
| * @range: a range object |
| * |
| * Build a node list tree copy of the range |
| * |
| * Returns an xmlNodePtr list or NULL. |
| * the caller has to free the node tree. |
| */ |
| static xmlNodePtr |
| xmlXPtrBuildRangeNodeList(xmlXPathObjectPtr range) { |
| /* pointers to generated nodes */ |
| xmlNodePtr list = NULL, last = NULL, parent = NULL, tmp; |
| /* pointers to traversal nodes */ |
| xmlNodePtr start, cur, end; |
| int index1, index2; |
| |
| if (range == NULL) |
| return(NULL); |
| if (range->type != XPATH_RANGE) |
| return(NULL); |
| start = (xmlNodePtr) range->user; |
| |
| if ((start == NULL) || (start->type == XML_NAMESPACE_DECL)) |
| return(NULL); |
| end = range->user2; |
| if (end == NULL) |
| return(xmlCopyNode(start, 1)); |
| if (end->type == XML_NAMESPACE_DECL) |
| return(NULL); |
| |
| cur = start; |
| index1 = range->index; |
| index2 = range->index2; |
| while (cur != NULL) { |
| if (cur == end) { |
| if (cur->type == XML_TEXT_NODE) { |
| const xmlChar *content = cur->content; |
| int len; |
| |
| if (content == NULL) { |
| tmp = xmlNewTextLen(NULL, 0); |
| } else { |
| len = index2; |
| if ((cur == start) && (index1 > 1)) { |
| content += (index1 - 1); |
| len -= (index1 - 1); |
| index1 = 0; |
| } else { |
| len = index2; |
| } |
| tmp = xmlNewTextLen(content, len); |
| } |
| /* single sub text node selection */ |
| if (list == NULL) |
| return(tmp); |
| /* prune and return full set */ |
| if (last != NULL) |
| xmlAddNextSibling(last, tmp); |
| else |
| xmlAddChild(parent, tmp); |
| return(list); |
| } else { |
| tmp = xmlCopyNode(cur, 0); |
| if (list == NULL) |
| list = tmp; |
| else { |
| if (last != NULL) |
| xmlAddNextSibling(last, tmp); |
| else |
| xmlAddChild(parent, tmp); |
| } |
| last = NULL; |
| parent = tmp; |
| |
| if (index2 > 1) { |
| end = xmlXPtrGetNthChild(cur, index2 - 1); |
| index2 = 0; |
| } |
| if ((cur == start) && (index1 > 1)) { |
| cur = xmlXPtrGetNthChild(cur, index1 - 1); |
| index1 = 0; |
| } else { |
| cur = cur->children; |
| } |
| /* |
| * Now gather the remaining nodes from cur to end |
| */ |
| continue; /* while */ |
| } |
| } else if ((cur == start) && |
| (list == NULL) /* looks superfluous but ... */ ) { |
| if ((cur->type == XML_TEXT_NODE) || |
| (cur->type == XML_CDATA_SECTION_NODE)) { |
| const xmlChar *content = cur->content; |
| |
| if (content == NULL) { |
| tmp = xmlNewTextLen(NULL, 0); |
| } else { |
| if (index1 > 1) { |
| content += (index1 - 1); |
| } |
| tmp = xmlNewText(content); |
| } |
| last = list = tmp; |
| } else { |
| if ((cur == start) && (index1 > 1)) { |
| tmp = xmlCopyNode(cur, 0); |
| list = tmp; |
| parent = tmp; |
| last = NULL; |
| cur = xmlXPtrGetNthChild(cur, index1 - 1); |
| index1 = 0; |
| /* |
| * Now gather the remaining nodes from cur to end |
| */ |
| continue; /* while */ |
| } |
| tmp = xmlCopyNode(cur, 1); |
| list = tmp; |
| parent = NULL; |
| last = tmp; |
| } |
| } else { |
| tmp = NULL; |
| switch (cur->type) { |
| case XML_DTD_NODE: |
| case XML_ELEMENT_DECL: |
| case XML_ATTRIBUTE_DECL: |
| case XML_ENTITY_NODE: |
| /* Do not copy DTD informations */ |
| break; |
| case XML_ENTITY_DECL: |
| TODO /* handle crossing entities -> stack needed */ |
| break; |
| case XML_XINCLUDE_START: |
| case XML_XINCLUDE_END: |
| /* don't consider it part of the tree content */ |
| break; |
| case XML_ATTRIBUTE_NODE: |
| /* Humm, should not happen ! */ |
| STRANGE |
| break; |
| default: |
| tmp = xmlCopyNode(cur, 1); |
| break; |
| } |
| if (tmp != NULL) { |
| if ((list == NULL) || ((last == NULL) && (parent == NULL))) { |
| STRANGE |
| return(NULL); |
| } |
| if (last != NULL) |
| xmlAddNextSibling(last, tmp); |
| else { |
| xmlAddChild(parent, tmp); |
| last = tmp; |
| } |
| } |
| } |
| /* |
| * Skip to next node in document order |
| */ |
| if ((list == NULL) || ((last == NULL) && (parent == NULL))) { |
| STRANGE |
| return(NULL); |
| } |
| cur = xmlXPtrAdvanceNode(cur, NULL); |
| } |
| return(list); |
| } |
| |
| /** |
| * xmlXPtrBuildNodeList: |
| * @obj: the XPointer result from the evaluation. |
| * |
| * Build a node list tree copy of the XPointer result. |
| * This will drop Attributes and Namespace declarations. |
| * |
| * Returns an xmlNodePtr list or NULL. |
| * the caller has to free the node tree. |
| */ |
| xmlNodePtr |
| xmlXPtrBuildNodeList(xmlXPathObjectPtr obj) { |
| xmlNodePtr list = NULL, last = NULL; |
| int i; |
| |
| if (obj == NULL) |
| return(NULL); |
| switch (obj->type) { |
| case XPATH_NODESET: { |
| xmlNodeSetPtr set = obj->nodesetval; |
| if (set == NULL) |
| return(NULL); |
| for (i = 0;i < set->nodeNr;i++) { |
| if (set->nodeTab[i] == NULL) |
| continue; |
| switch (set->nodeTab[i]->type) { |
| case XML_TEXT_NODE: |
| case XML_CDATA_SECTION_NODE: |
| case XML_ELEMENT_NODE: |
| case XML_ENTITY_REF_NODE: |
| case XML_ENTITY_NODE: |
| case XML_PI_NODE: |
| case XML_COMMENT_NODE: |
| case XML_DOCUMENT_NODE: |
| case XML_HTML_DOCUMENT_NODE: |
| #ifdef LIBXML_DOCB_ENABLED |
| case XML_DOCB_DOCUMENT_NODE: |
| #endif |
| case XML_XINCLUDE_START: |
| case XML_XINCLUDE_END: |
| break; |
| case XML_ATTRIBUTE_NODE: |
| case XML_NAMESPACE_DECL: |
| case XML_DOCUMENT_TYPE_NODE: |
| case XML_DOCUMENT_FRAG_NODE: |
| case XML_NOTATION_NODE: |
| case XML_DTD_NODE: |
| case XML_ELEMENT_DECL: |
| case XML_ATTRIBUTE_DECL: |
| case XML_ENTITY_DECL: |
| continue; /* for */ |
| } |
| if (last == NULL) |
| list = last = xmlCopyNode(set->nodeTab[i], 1); |
| else { |
| xmlAddNextSibling(last, xmlCopyNode(set->nodeTab[i], 1)); |
| if (last->next != NULL) |
| last = last->next; |
| } |
| } |
| break; |
| } |
| case XPATH_LOCATIONSET: { |
| xmlLocationSetPtr set = (xmlLocationSetPtr) obj->user; |
| if (set == NULL) |
| return(NULL); |
| for (i = 0;i < set->locNr;i++) { |
| if (last == NULL) |
| list = last = xmlXPtrBuildNodeList(set->locTab[i]); |
| else |
| xmlAddNextSibling(last, |
| xmlXPtrBuildNodeList(set->locTab[i])); |
| if (last != NULL) { |
| while (last->next != NULL) |
| last = last->next; |
| } |
| } |
| break; |
| } |
| case XPATH_RANGE: |
| return(xmlXPtrBuildRangeNodeList(obj)); |
| case XPATH_POINT: |
| return(xmlCopyNode(obj->user, 0)); |
| default: |
| break; |
| } |
| return(list); |
| } |
| |
| /************************************************************************ |
| * * |
| * XPointer functions * |
| * * |
| ************************************************************************/ |
| |
| /** |
| * xmlXPtrNbLocChildren: |
| * @node: an xmlNodePtr |
| * |
| * Count the number of location children of @node or the length of the |
| * string value in case of text/PI/Comments nodes |
| * |
| * Returns the number of location children |
| */ |
| static int |
| xmlXPtrNbLocChildren(xmlNodePtr node) { |
| int ret = 0; |
| if (node == NULL) |
| return(-1); |
| switch (node->type) { |
| case XML_HTML_DOCUMENT_NODE: |
| case XML_DOCUMENT_NODE: |
| case XML_ELEMENT_NODE: |
| node = node->children; |
| while (node != NULL) { |
| if (node->type == XML_ELEMENT_NODE) |
| ret++; |
| node = node->next; |
| } |
| break; |
| case XML_ATTRIBUTE_NODE: |
| return(-1); |
| |
| case XML_PI_NODE: |
| case XML_COMMENT_NODE: |
| case XML_TEXT_NODE: |
| case XML_CDATA_SECTION_NODE: |
| case XML_ENTITY_REF_NODE: |
| ret = xmlStrlen(node->content); |
| break; |
| default: |
| return(-1); |
| } |
| return(ret); |
| } |
| |
| /** |
| * xmlXPtrHereFunction: |
| * @ctxt: the XPointer Parser context |
| * @nargs: the number of args |
| * |
| * Function implementing here() operation |
| * as described in 5.4.3 |
| */ |
| static void |
| xmlXPtrHereFunction(xmlXPathParserContextPtr ctxt, int nargs) { |
| CHECK_ARITY(0); |
| |
| if (ctxt->context->here == NULL) |
| XP_ERROR(XPTR_SYNTAX_ERROR); |
| |
| valuePush(ctxt, xmlXPtrNewLocationSetNodes(ctxt->context->here, NULL)); |
| } |
| |
| /** |
| * xmlXPtrOriginFunction: |
| * @ctxt: the XPointer Parser context |
| * @nargs: the number of args |
| * |
| * Function implementing origin() operation |
| * as described in 5.4.3 |
| */ |
| static void |
| xmlXPtrOriginFunction(xmlXPathParserContextPtr ctxt, int nargs) { |
| CHECK_ARITY(0); |
| |
| if (ctxt->context->origin == NULL) |
| XP_ERROR(XPTR_SYNTAX_ERROR); |
| |
| valuePush(ctxt, xmlXPtrNewLocationSetNodes(ctxt->context->origin, NULL)); |
| } |
| |
| /** |
| * xmlXPtrStartPointFunction: |
| * @ctxt: the XPointer Parser context |
| * @nargs: the number of args |
| * |
| * Function implementing start-point() operation |
| * as described in 5.4.3 |
| * ---------------- |
| * location-set start-point(location-set) |
| * |
| * For each location x in the argument location-set, start-point adds a |
| * location of type point to the result location-set. That point represents |
| * the start point of location x and is determined by the following rules: |
| * |
| * - If x is of type point, the start point is x. |
| * - If x is of type range, the start point is the start point of x. |
| * - If x is of type root, element, text, comment, or processing instruction, |
| * - the container node of the start point is x and the index is 0. |
| * - If x is of type attribute or namespace, the function must signal a |
| * syntax error. |
| * ---------------- |
| * |
| */ |
| static void |
| xmlXPtrStartPointFunction(xmlXPathParserContextPtr ctxt, int nargs) { |
| xmlXPathObjectPtr tmp, obj, point; |
| xmlLocationSetPtr newset = NULL; |
| xmlLocationSetPtr oldset = NULL; |
| |
| CHECK_ARITY(1); |
| if ((ctxt->value == NULL) || |
| ((ctxt->value->type != XPATH_LOCATIONSET) && |
| (ctxt->value->type != XPATH_NODESET))) |
| XP_ERROR(XPATH_INVALID_TYPE) |
| |
| obj = valuePop(ctxt); |
| if (obj->type == XPATH_NODESET) { |
| /* |
| * First convert to a location set |
| */ |
| tmp = xmlXPtrNewLocationSetNodeSet(obj->nodesetval); |
| xmlXPathFreeObject(obj); |
| if (tmp == NULL) |
| XP_ERROR(XPATH_MEMORY_ERROR) |
| obj = tmp; |
| } |
| |
| newset = xmlXPtrLocationSetCreate(NULL); |
| if (newset == NULL) { |
| xmlXPathFreeObject(obj); |
| XP_ERROR(XPATH_MEMORY_ERROR); |
| } |
| oldset = (xmlLocationSetPtr) obj->user; |
| if (oldset != NULL) { |
| int i; |
| |
| for (i = 0; i < oldset->locNr; i++) { |
| tmp = oldset->locTab[i]; |
| if (tmp == NULL) |
| continue; |
| point = NULL; |
| switch (tmp->type) { |
| case XPATH_POINT: |
| point = xmlXPtrNewPoint(tmp->user, tmp->index); |
| break; |
| case XPATH_RANGE: { |
| xmlNodePtr node = tmp->user; |
| if (node != NULL) { |
| if (node->type == XML_ATTRIBUTE_NODE) { |
| /* TODO: Namespace Nodes ??? */ |
| xmlXPathFreeObject(obj); |
| xmlXPtrFreeLocationSet(newset); |
| XP_ERROR(XPTR_SYNTAX_ERROR); |
| } |
| point = xmlXPtrNewPoint(node, tmp->index); |
| } |
| break; |
| } |
| default: |
| /*** Should we raise an error ? |
| xmlXPathFreeObject(obj); |
| xmlXPathFreeObject(newset); |
| XP_ERROR(XPATH_INVALID_TYPE) |
| ***/ |
| break; |
| } |
| if (point != NULL) |
| xmlXPtrLocationSetAdd(newset, point); |
| } |
| } |
| xmlXPathFreeObject(obj); |
| valuePush(ctxt, xmlXPtrWrapLocationSet(newset)); |
| } |
| |
| /** |
| * xmlXPtrEndPointFunction: |
| * @ctxt: the XPointer Parser context |
| * @nargs: the number of args |
| * |
| * Function implementing end-point() operation |
| * as described in 5.4.3 |
| * ---------------------------- |
| * location-set end-point(location-set) |
| * |
| * For each location x in the argument location-set, end-point adds a |
| * location of type point to the result location-set. That point represents |
| * the end point of location x and is determined by the following rules: |
| * |
| * - If x is of type point, the resulting point is x. |
| * - If x is of type range, the resulting point is the end point of x. |
| * - If x is of type root or element, the container node of the resulting |
| * point is x and the index is the number of location children of x. |
| * - If x is of type text, comment, or processing instruction, the container |
| * node of the resulting point is x and the index is the length of the |
| * string-value of x. |
| * - If x is of type attribute or namespace, the function must signal a |
| * syntax error. |
| * ---------------------------- |
| */ |
| static void |
| xmlXPtrEndPointFunction(xmlXPathParserContextPtr ctxt, int nargs) { |
| xmlXPathObjectPtr tmp, obj, point; |
| xmlLocationSetPtr newset = NULL; |
| xmlLocationSetPtr oldset = NULL; |
| |
| CHECK_ARITY(1); |
| if ((ctxt->value == NULL) || |
| ((ctxt->value->type != XPATH_LOCATIONSET) && |
| (ctxt->value->type != XPATH_NODESET))) |
| XP_ERROR(XPATH_INVALID_TYPE) |
| |
| obj = valuePop(ctxt); |
| if (obj->type == XPATH_NODESET) { |
| /* |
| * First convert to a location set |
| */ |
| tmp = xmlXPtrNewLocationSetNodeSet(obj->nodesetval); |
| xmlXPathFreeObject(obj); |
| if (tmp == NULL) |
| XP_ERROR(XPATH_MEMORY_ERROR) |
| obj = tmp; |
| } |
| |
| newset = xmlXPtrLocationSetCreate(NULL); |
| if (newset == NULL) { |
| xmlXPathFreeObject(obj); |
| XP_ERROR(XPATH_MEMORY_ERROR); |
| } |
| oldset = (xmlLocationSetPtr) obj->user; |
| if (oldset != NULL) { |
| int i; |
| |
| for (i = 0; i < oldset->locNr; i++) { |
| tmp = oldset->locTab[i]; |
| if (tmp == NULL) |
| continue; |
| point = NULL; |
| switch (tmp->type) { |
| case XPATH_POINT: |
| point = xmlXPtrNewPoint(tmp->user, tmp->index); |
| break; |
| case XPATH_RANGE: { |
| xmlNodePtr node = tmp->user2; |
| if (node != NULL) { |
| if (node->type == XML_ATTRIBUTE_NODE) { |
| /* TODO: Namespace Nodes ??? */ |
| xmlXPathFreeObject(obj); |
| xmlXPtrFreeLocationSet(newset); |
| XP_ERROR(XPTR_SYNTAX_ERROR); |
| } |
| point = xmlXPtrNewPoint(node, tmp->index2); |
| } else if (tmp->user == NULL) { |
| point = xmlXPtrNewPoint(node, |
| xmlXPtrNbLocChildren(node)); |
| } |
| break; |
| } |
| default: |
| /*** Should we raise an error ? |
| xmlXPathFreeObject(obj); |
| xmlXPathFreeObject(newset); |
| XP_ERROR(XPATH_INVALID_TYPE) |
| ***/ |
| break; |
| } |
| if (point != NULL) |
| xmlXPtrLocationSetAdd(newset, point); |
| } |
| } |
| xmlXPathFreeObject(obj); |
| valuePush(ctxt, xmlXPtrWrapLocationSet(newset)); |
| } |
| |
| |
| /** |
| * xmlXPtrCoveringRange: |
| * @ctxt: the XPointer Parser context |
| * @loc: the location for which the covering range must be computed |
| * |
| * A covering range is a range that wholly encompasses a location |
| * Section 5.3.3. Covering Ranges for All Location Types |
| * http://www.w3.org/TR/xptr#N2267 |
| * |
| * Returns a new location or NULL in case of error |
| */ |
| static xmlXPathObjectPtr |
| xmlXPtrCoveringRange(xmlXPathParserContextPtr ctxt, xmlXPathObjectPtr loc) { |
| if (loc == NULL) |
| return(NULL); |
| if ((ctxt == NULL) || (ctxt->context == NULL) || |
| (ctxt->context->doc == NULL)) |
| return(NULL); |
| switch (loc->type) { |
| case XPATH_POINT: |
| return(xmlXPtrNewRange(loc->user, loc->index, |
| loc->user, loc->index)); |
| case XPATH_RANGE: |
| if (loc->user2 != NULL) { |
| return(xmlXPtrNewRange(loc->user, loc->index, |
| loc->user2, loc->index2)); |
| } else { |
| xmlNodePtr node = (xmlNodePtr) loc->user; |
| if (node == (xmlNodePtr) ctxt->context->doc) { |
| return(xmlXPtrNewRange(node, 0, node, |
| xmlXPtrGetArity(node))); |
| } else { |
| switch (node->type) { |
| case XML_ATTRIBUTE_NODE: |
| /* !!! our model is slightly different than XPath */ |
| return(xmlXPtrNewRange(node, 0, node, |
| xmlXPtrGetArity(node))); |
| case XML_ELEMENT_NODE: |
| case XML_TEXT_NODE: |
| case XML_CDATA_SECTION_NODE: |
| case XML_ENTITY_REF_NODE: |
| case XML_PI_NODE: |
| case XML_COMMENT_NODE: |
| case XML_DOCUMENT_NODE: |
| case XML_NOTATION_NODE: |
| case XML_HTML_DOCUMENT_NODE: { |
| int indx = xmlXPtrGetIndex(node); |
| |
| node = node->parent; |
| return(xmlXPtrNewRange(node, indx - 1, |
| node, indx + 1)); |
| } |
| default: |
| return(NULL); |
| } |
| } |
| } |
| default: |
| TODO /* missed one case ??? */ |
| } |
| return(NULL); |
| } |
| |
| /** |
| * xmlXPtrRangeFunction: |
| * @ctxt: the XPointer Parser context |
| * @nargs: the number of args |
| * |
| * Function implementing the range() function 5.4.3 |
| * location-set range(location-set ) |
| * |
| * The range function returns ranges covering the locations in |
| * the argument location-set. For each location x in the argument |
| * location-set, a range location representing the covering range of |
| * x is added to the result location-set. |
| */ |
| static void |
| xmlXPtrRangeFunction(xmlXPathParserContextPtr ctxt, int nargs) { |
| int i; |
| xmlXPathObjectPtr set; |
| xmlLocationSetPtr oldset; |
| xmlLocationSetPtr newset; |
| |
| CHECK_ARITY(1); |
| if ((ctxt->value == NULL) || |
| ((ctxt->value->type != XPATH_LOCATIONSET) && |
| (ctxt->value->type != XPATH_NODESET))) |
| XP_ERROR(XPATH_INVALID_TYPE) |
| |
| set = valuePop(ctxt); |
| if (set->type == XPATH_NODESET) { |
| xmlXPathObjectPtr tmp; |
| |
| /* |
| * First convert to a location set |
| */ |
| tmp = xmlXPtrNewLocationSetNodeSet(set->nodesetval); |
| xmlXPathFreeObject(set); |
| if (tmp == NULL) |
| XP_ERROR(XPATH_MEMORY_ERROR) |
| set = tmp; |
| } |
| oldset = (xmlLocationSetPtr) set->user; |
| |
| /* |
| * The loop is to compute the covering range for each item and add it |
| */ |
| newset = xmlXPtrLocationSetCreate(NULL); |
| if (newset == NULL) { |
| xmlXPathFreeObject(set); |
| XP_ERROR(XPATH_MEMORY_ERROR); |
| } |
| for (i = 0;i < oldset->locNr;i++) { |
| xmlXPtrLocationSetAdd(newset, |
| xmlXPtrCoveringRange(ctxt, oldset->locTab[i])); |
| } |
| |
| /* |
| * Save the new value and cleanup |
| */ |
| valuePush(ctxt, xmlXPtrWrapLocationSet(newset)); |
| xmlXPathFreeObject(set); |
| } |
| |
| /** |
| * xmlXPtrInsideRange: |
| * @ctxt: the XPointer Parser context |
| * @loc: the location for which the inside range must be computed |
| * |
| * A inside range is a range described in the range-inside() description |
| * |
| * Returns a new location or NULL in case of error |
| */ |
| static xmlXPathObjectPtr |
| xmlXPtrInsideRange(xmlXPathParserContextPtr ctxt, xmlXPathObjectPtr loc) { |
| if (loc == NULL) |
| return(NULL); |
| if ((ctxt == NULL) || (ctxt->context == NULL) || |
| (ctxt->context->doc == NULL)) |
| return(NULL); |
| switch (loc->type) { |
| case XPATH_POINT: { |
| xmlNodePtr node = (xmlNodePtr) loc->user; |
| switch (node->type) { |
| case XML_PI_NODE: |
| case XML_COMMENT_NODE: |
| case XML_TEXT_NODE: |
| case XML_CDATA_SECTION_NODE: { |
| if (node->content == NULL) { |
| return(xmlXPtrNewRange(node, 0, node, 0)); |
| } else { |
| return(xmlXPtrNewRange(node, 0, node, |
| xmlStrlen(node->content))); |
| } |
| } |
| case XML_ATTRIBUTE_NODE: |
| case XML_ELEMENT_NODE: |
| case XML_ENTITY_REF_NODE: |
| case XML_DOCUMENT_NODE: |
| case XML_NOTATION_NODE: |
| case XML_HTML_DOCUMENT_NODE: { |
| return(xmlXPtrNewRange(node, 0, node, |
| xmlXPtrGetArity(node))); |
| } |
| default: |
| break; |
| } |
| return(NULL); |
| } |
| case XPATH_RANGE: { |
| xmlNodePtr node = (xmlNodePtr) loc->user; |
| if (loc->user2 != NULL) { |
| return(xmlXPtrNewRange(node, loc->index, |
| loc->user2, loc->index2)); |
| } else { |
| switch (node->type) { |
| case XML_PI_NODE: |
| case XML_COMMENT_NODE: |
| case XML_TEXT_NODE: |
| case XML_CDATA_SECTION_NODE: { |
| if (node->content == NULL) { |
| return(xmlXPtrNewRange(node, 0, node, 0)); |
| } else { |
| return(xmlXPtrNewRange(node, 0, node, |
| xmlStrlen(node->content))); |
| } |
| } |
| case XML_ATTRIBUTE_NODE: |
| case XML_ELEMENT_NODE: |
| case XML_ENTITY_REF_NODE: |
| case XML_DOCUMENT_NODE: |
| case XML_NOTATION_NODE: |
| case XML_HTML_DOCUMENT_NODE: { |
| return(xmlXPtrNewRange(node, 0, node, |
| xmlXPtrGetArity(node))); |
| } |
| default: |
| break; |
| } |
| return(NULL); |
| } |
| } |
| default: |
| TODO /* missed one case ??? */ |
| } |
| return(NULL); |
| } |
| |
| /** |
| * xmlXPtrRangeInsideFunction: |
| * @ctxt: the XPointer Parser context |
| * @nargs: the number of args |
| * |
| * Function implementing the range-inside() function 5.4.3 |
| * location-set range-inside(location-set ) |
| * |
| * The range-inside function returns ranges covering the contents of |
| * the locations in the argument location-set. For each location x in |
| * the argument location-set, a range location is added to the result |
| * location-set. If x is a range location, then x is added to the |
| * result location-set. If x is not a range location, then x is used |
| * as the container location of the start and end points of the range |
| * location to be added; the index of the start point of the range is |
| * zero; if the end point is a character point then its index is the |
| * length of the string-value of x, and otherwise is the number of |
| * location children of x. |
| * |
| */ |
| static void |
| xmlXPtrRangeInsideFunction(xmlXPathParserContextPtr ctxt, int nargs) { |
| int i; |
| xmlXPathObjectPtr set; |
| xmlLocationSetPtr oldset; |
| xmlLocationSetPtr newset; |
| |
| CHECK_ARITY(1); |
| if ((ctxt->value == NULL) || |
| ((ctxt->value->type != XPATH_LOCATIONSET) && |
| (ctxt->value->type != XPATH_NODESET))) |
| XP_ERROR(XPATH_INVALID_TYPE) |
| |
| set = valuePop(ctxt); |
| if (set->type == XPATH_NODESET) { |
| xmlXPathObjectPtr tmp; |
| |
| /* |
| * First convert to a location set |
| */ |
| tmp = xmlXPtrNewLocationSetNodeSet(set->nodesetval); |
| xmlXPathFreeObject(set); |
| if (tmp == NULL) |
| XP_ERROR(XPATH_MEMORY_ERROR) |
| set = tmp; |
| } |
| oldset = (xmlLocationSetPtr) set->user; |
| |
| /* |
| * The loop is to compute the covering range for each item and add it |
| */ |
| newset = xmlXPtrLocationSetCreate(NULL); |
| if (newset == NULL) { |
| xmlXPathFreeObject(set); |
| XP_ERROR(XPATH_MEMORY_ERROR); |
| } |
| for (i = 0;i < oldset->locNr;i++) { |
| xmlXPtrLocationSetAdd(newset, |
| xmlXPtrInsideRange(ctxt, oldset->locTab[i])); |
| } |
| |
| /* |
| * Save the new value and cleanup |
| */ |
| valuePush(ctxt, xmlXPtrWrapLocationSet(newset)); |
| xmlXPathFreeObject(set); |
| } |
| |
| /** |
| * xmlXPtrRangeToFunction: |
| * @ctxt: the XPointer Parser context |
| * @nargs: the number of args |
| * |
| * Implement the range-to() XPointer function |
| */ |
| void |
| xmlXPtrRangeToFunction(xmlXPathParserContextPtr ctxt, int nargs) { |
| xmlXPathObjectPtr range; |
| const xmlChar *cur; |
| xmlXPathObjectPtr res, obj; |
| xmlXPathObjectPtr tmp; |
| xmlLocationSetPtr newset = NULL; |
| xmlNodeSetPtr oldset; |
| int i; |
| |
| if (ctxt == NULL) return; |
| CHECK_ARITY(1); |
| /* |
| * Save the expression pointer since we will have to evaluate |
| * it multiple times. Initialize the new set. |
| */ |
| CHECK_TYPE(XPATH_NODESET); |
| obj = valuePop(ctxt); |
| oldset = obj->nodesetval; |
| ctxt->context->node = NULL; |
| |
| cur = ctxt->cur; |
| newset = xmlXPtrLocationSetCreate(NULL); |
| |
| for (i = 0; i < oldset->nodeNr; i++) { |
| ctxt->cur = cur; |
| |
| /* |
| * Run the evaluation with a node list made of a single item |
| * in the nodeset. |
| */ |
| ctxt->context->node = oldset->nodeTab[i]; |
| tmp = xmlXPathNewNodeSet(ctxt->context->node); |
| valuePush(ctxt, tmp); |
| |
| xmlXPathEvalExpr(ctxt); |
| CHECK_ERROR; |
| |
| /* |
| * The result of the evaluation need to be tested to |
| * decided whether the filter succeeded or not |
| */ |
| res = valuePop(ctxt); |
| range = xmlXPtrNewRangeNodeObject(oldset->nodeTab[i], res); |
| if (range != NULL) { |
| xmlXPtrLocationSetAdd(newset, range); |
| } |
| |
| /* |
| * Cleanup |
| */ |
| if (res != NULL) |
| xmlXPathFreeObject(res); |
| if (ctxt->value == tmp) { |
| res = valuePop(ctxt); |
| xmlXPathFreeObject(res); |
| } |
| |
| ctxt->context->node = NULL; |
| } |
| |
| /* |
| * The result is used as the new evaluation set. |
| */ |
| xmlXPathFreeObject(obj); |
| ctxt->context->node = NULL; |
| ctxt->context->contextSize = -1; |
| ctxt->context->proximityPosition = -1; |
| valuePush(ctxt, xmlXPtrWrapLocationSet(newset)); |
| } |
| |
| /** |
| * xmlXPtrAdvanceNode: |
| * @cur: the node |
| * @level: incremented/decremented to show level in tree |
| * |
| * Advance to the next element or text node in document order |
| * TODO: add a stack for entering/exiting entities |
| * |
| * Returns -1 in case of failure, 0 otherwise |
| */ |
| xmlNodePtr |
| xmlXPtrAdvanceNode(xmlNodePtr cur, int *level) { |
| next: |
| if ((cur == NULL) || (cur->type == XML_NAMESPACE_DECL)) |
| return(NULL); |
| if (cur->children != NULL) { |
| cur = cur->children ; |
| if (level != NULL) |
| (*level)++; |
| goto found; |
| } |
| skip: /* This label should only be needed if something is wrong! */ |
| if (cur->next != NULL) { |
| cur = cur->next; |
| goto found; |
| } |
| do { |
| cur = cur->parent; |
| if (level != NULL) |
| (*level)--; |
| if (cur == NULL) return(NULL); |
| if (cur->next != NULL) { |
| cur = cur->next; |
| goto found; |
| } |
| } while (cur != NULL); |
| |
| found: |
| if ((cur->type != XML_ELEMENT_NODE) && |
| (cur->type != XML_TEXT_NODE) && |
| (cur->type != XML_DOCUMENT_NODE) && |
| (cur->type != XML_HTML_DOCUMENT_NODE) && |
| (cur->type != XML_CDATA_SECTION_NODE)) { |
| if (cur->type == XML_ENTITY_REF_NODE) { /* Shouldn't happen */ |
| TODO |
| goto skip; |
| } |
| goto next; |
| } |
| return(cur); |
| } |
| |
| /** |
| * xmlXPtrAdvanceChar: |
| * @node: the node |
| * @indx: the indx |
| * @bytes: the number of bytes |
| * |
| * Advance a point of the associated number of bytes (not UTF8 chars) |
| * |
| * Returns -1 in case of failure, 0 otherwise |
| */ |
| static int |
| xmlXPtrAdvanceChar(xmlNodePtr *node, int *indx, int bytes) { |
| xmlNodePtr cur; |
| int pos; |
| int len; |
| |
| if ((node == NULL) || (indx == NULL)) |
| return(-1); |
| cur = *node; |
| if ((cur == NULL) || (cur->type == XML_NAMESPACE_DECL)) |
| return(-1); |
| pos = *indx; |
| |
| while (bytes >= 0) { |
| /* |
| * First position to the beginning of the first text node |
| * corresponding to this point |
| */ |
| while ((cur != NULL) && |
| ((cur->type == XML_ELEMENT_NODE) || |
| (cur->type == XML_DOCUMENT_NODE) || |
| (cur->type == XML_HTML_DOCUMENT_NODE))) { |
| if (pos > 0) { |
| cur = xmlXPtrGetNthChild(cur, pos); |
| pos = 0; |
| } else { |
| cur = xmlXPtrAdvanceNode(cur, NULL); |
| pos = 0; |
| } |
| } |
| |
| if (cur == NULL) { |
| *node = NULL; |
| *indx = 0; |
| return(-1); |
| } |
| |
| /* |
| * if there is no move needed return the current value. |
| */ |
| if (pos == 0) pos = 1; |
| if (bytes == 0) { |
| *node = cur; |
| *indx = pos; |
| return(0); |
| } |
| /* |
| * We should have a text (or cdata) node ... |
| */ |
| len = 0; |
| if ((cur->type != XML_ELEMENT_NODE) && |
| (cur->content != NULL)) { |
| len = xmlStrlen(cur->content); |
| } |
| if (pos > len) { |
| /* Strange, the indx in the text node is greater than it's len */ |
| STRANGE |
| pos = len; |
| } |
| if (pos + bytes >= len) { |
| bytes -= (len - pos); |
| cur = xmlXPtrAdvanceNode(cur, NULL); |
| pos = 0; |
| } else if (pos + bytes < len) { |
| pos += bytes; |
| *node = cur; |
| *indx = pos; |
| return(0); |
| } |
| } |
| return(-1); |
| } |
| |
| /** |
| * xmlXPtrMatchString: |
| * @string: the string to search |
| * @start: the start textnode |
| * @startindex: the start index |
| * @end: the end textnode IN/OUT |
| * @endindex: the end index IN/OUT |
| * |
| * Check whether the document contains @string at the position |
| * (@start, @startindex) and limited by the (@end, @endindex) point |
| * |
| * Returns -1 in case of failure, 0 if not found, 1 if found in which case |
| * (@start, @startindex) will indicate the position of the beginning |
| * of the range and (@end, @endindex) will indicate the end |
| * of the range |
| */ |
| static int |
| xmlXPtrMatchString(const xmlChar *string, xmlNodePtr start, int startindex, |
| xmlNodePtr *end, int *endindex) { |
| xmlNodePtr cur; |
| int pos; /* 0 based */ |
| int len; /* in bytes */ |
| int stringlen; /* in bytes */ |
| int match; |
| |
| if (string == NULL) |
| return(-1); |
| if ((start == NULL) || (start->type == XML_NAMESPACE_DECL)) |
| return(-1); |
| if ((end == NULL) || (*end == NULL) || |
| ((*end)->type == XML_NAMESPACE_DECL) || (endindex == NULL)) |
| return(-1); |
| cur = start; |
| pos = startindex - 1; |
| stringlen = xmlStrlen(string); |
| |
| while (stringlen > 0) { |
| if ((cur == *end) && (pos + stringlen > *endindex)) |
| return(0); |
| |
| if ((cur->type != XML_ELEMENT_NODE) && (cur->content != NULL)) { |
| len = xmlStrlen(cur->content); |
| if (len >= pos + stringlen) { |
| match = (!xmlStrncmp(&cur->content[pos], string, stringlen)); |
| if (match) { |
| #ifdef DEBUG_RANGES |
| xmlGenericError(xmlGenericErrorContext, |
| "found range %d bytes at index %d of ->", |
| stringlen, pos + 1); |
| xmlDebugDumpString(stdout, cur->content); |
| xmlGenericError(xmlGenericErrorContext, "\n"); |
| #endif |
| *end = cur; |
| *endindex = pos + stringlen; |
| return(1); |
| } else { |
| return(0); |
| } |
| } else { |
| int sub = len - pos; |
| match = (!xmlStrncmp(&cur->content[pos], string, sub)); |
| if (match) { |
| #ifdef DEBUG_RANGES |
| xmlGenericError(xmlGenericErrorContext, |
| "found subrange %d bytes at index %d of ->", |
| sub, pos + 1); |
| xmlDebugDumpString(stdout, cur->content); |
| xmlGenericError(xmlGenericErrorContext, "\n"); |
| #endif |
| string = &string[sub]; |
| stringlen -= sub; |
| } else { |
| return(0); |
| } |
| } |
| } |
| cur = xmlXPtrAdvanceNode(cur, NULL); |
| if (cur == NULL) |
| return(0); |
| pos = 0; |
| } |
| return(1); |
| } |
| |
| /** |
| * xmlXPtrSearchString: |
| * @string: the string to search |
| * @start: the start textnode IN/OUT |
| * @startindex: the start index IN/OUT |
| * @end: the end textnode |
| * @endindex: the end index |
| * |
| * Search the next occurrence of @string within the document content |
| * until the (@end, @endindex) point is reached |
| * |
| * Returns -1 in case of failure, 0 if not found, 1 if found in which case |
| * (@start, @startindex) will indicate the position of the beginning |
| * of the range and (@end, @endindex) will indicate the end |
| * of the range |
| */ |
| static int |
| xmlXPtrSearchString(const xmlChar *string, xmlNodePtr *start, int *startindex, |
| xmlNodePtr *end, int *endindex) { |
| xmlNodePtr cur; |
| const xmlChar *str; |
| int pos; /* 0 based */ |
| int len; /* in bytes */ |
| xmlChar first; |
| |
| if (string == NULL) |
| return(-1); |
| if ((start == NULL) || (*start == NULL) || |
| ((*start)->type == XML_NAMESPACE_DECL) || (startindex == NULL)) |
| return(-1); |
| if ((end == NULL) || (endindex == NULL)) |
| return(-1); |
| cur = *start; |
| pos = *startindex - 1; |
| first = string[0]; |
| |
| while (cur != NULL) { |
| if ((cur->type != XML_ELEMENT_NODE) && (cur->content != NULL)) { |
| len = xmlStrlen(cur->content); |
| while (pos <= len) { |
| if (first != 0) { |
| str = xmlStrchr(&cur->content[pos], first); |
| if (str != NULL) { |
| pos = (str - (xmlChar *)(cur->content)); |
| #ifdef DEBUG_RANGES |
| xmlGenericError(xmlGenericErrorContext, |
| "found '%c' at index %d of ->", |
| first, pos + 1); |
| xmlDebugDumpString(stdout, cur->content); |
| xmlGenericError(xmlGenericErrorContext, "\n"); |
| #endif |
| if (xmlXPtrMatchString(string, cur, pos + 1, |
| end, endindex)) { |
| *start = cur; |
| *startindex = pos + 1; |
| return(1); |
| } |
| pos++; |
| } else { |
| pos = len + 1; |
| } |
| } else { |
| /* |
| * An empty string is considered to match before each |
| * character of the string-value and after the final |
| * character. |
| */ |
| #ifdef DEBUG_RANGES |
| xmlGenericError(xmlGenericErrorContext, |
| "found '' at index %d of ->", |
| pos + 1); |
| xmlDebugDumpString(stdout, cur->content); |
| xmlGenericError(xmlGenericErrorContext, "\n"); |
| #endif |
| *start = cur; |
| *startindex = pos + 1; |
| *end = cur; |
| *endindex = pos + 1; |
| return(1); |
| } |
| } |
| } |
| if ((cur == *end) && (pos >= *endindex)) |
| return(0); |
| cur = xmlXPtrAdvanceNode(cur, NULL); |
| if (cur == NULL) |
| return(0); |
| pos = 1; |
| } |
| return(0); |
| } |
| |
| /** |
| * xmlXPtrGetLastChar: |
| * @node: the node |
| * @index: the index |
| * |
| * Computes the point coordinates of the last char of this point |
| * |
| * Returns -1 in case of failure, 0 otherwise |
| */ |
| static int |
| xmlXPtrGetLastChar(xmlNodePtr *node, int *indx) { |
| xmlNodePtr cur; |
| int pos, len = 0; |
| |
| if ((node == NULL) || (*node == NULL) || |
| ((*node)->type == XML_NAMESPACE_DECL) || (indx == NULL)) |
| return(-1); |
| cur = *node; |
| pos = *indx; |
| |
| if ((cur->type == XML_ELEMENT_NODE) || |
| (cur->type == XML_DOCUMENT_NODE) || |
| (cur->type == XML_HTML_DOCUMENT_NODE)) { |
| if (pos > 0) { |
| cur = xmlXPtrGetNthChild(cur, pos); |
| } |
| } |
| while (cur != NULL) { |
| if (cur->last != NULL) |
| cur = cur->last; |
| else if ((cur->type != XML_ELEMENT_NODE) && |
| (cur->content != NULL)) { |
| len = xmlStrlen(cur->content); |
| break; |
| } else { |
| return(-1); |
| } |
| } |
| if (cur == NULL) |
| return(-1); |
| *node = cur; |
| *indx = len; |
| return(0); |
| } |
| |
| /** |
| * xmlXPtrGetStartPoint: |
| * @obj: an range |
| * @node: the resulting node |
| * @indx: the resulting index |
| * |
| * read the object and return the start point coordinates. |
| * |
| * Returns -1 in case of failure, 0 otherwise |
| */ |
| static int |
| xmlXPtrGetStartPoint(xmlXPathObjectPtr obj, xmlNodePtr *node, int *indx) { |
| if ((obj == NULL) || (node == NULL) || (indx == NULL)) |
| return(-1); |
| |
| switch (obj->type) { |
| case XPATH_POINT: |
| *node = obj->user; |
| if (obj->index <= 0) |
| *indx = 0; |
| else |
| *indx = obj->index; |
| return(0); |
| case XPATH_RANGE: |
| *node = obj->user; |
| if (obj->index <= 0) |
| *indx = 0; |
| else |
| *indx = obj->index; |
| return(0); |
| default: |
| break; |
| } |
| return(-1); |
| } |
| |
| /** |
| * xmlXPtrGetEndPoint: |
| * @obj: an range |
| * @node: the resulting node |
| * @indx: the resulting indx |
| * |
| * read the object and return the end point coordinates. |
| * |
| * Returns -1 in case of failure, 0 otherwise |
| */ |
| static int |
| xmlXPtrGetEndPoint(xmlXPathObjectPtr obj, xmlNodePtr *node, int *indx) { |
| if ((obj == NULL) || (node == NULL) || (indx == NULL)) |
| return(-1); |
| |
| switch (obj->type) { |
| case XPATH_POINT: |
| *node = obj->user; |
| if (obj->index <= 0) |
| *indx = 0; |
| else |
| *indx = obj->index; |
| return(0); |
| case XPATH_RANGE: |
| *node = obj->user; |
| if (obj->index <= 0) |
| *indx = 0; |
| else |
| *indx = obj->index; |
| return(0); |
| default: |
| break; |
| } |
| return(-1); |
| } |
| |
| /** |
| * xmlXPtrStringRangeFunction: |
| * @ctxt: the XPointer Parser context |
| * @nargs: the number of args |
| * |
| * Function implementing the string-range() function |
| * range as described in 5.4.2 |
| * |
| * ------------------------------ |
| * [Definition: For each location in the location-set argument, |
| * string-range returns a set of string ranges, a set of substrings in a |
| * string. Specifically, the string-value of the location is searched for |
| * substrings that match the string argument, and the resulting location-set |
| * will contain a range location for each non-overlapping match.] |
| * An empty string is considered to match before each character of the |
| * string-value and after the final character. Whitespace in a string |
| * is matched literally, with no normalization except that provided by |
| * XML for line ends. The third argument gives the position of the first |
| * character to be in the resulting range, relative to the start of the |
| * match. The default value is 1, which makes the range start immediately |
| * before the first character of the matched string. The fourth argument |
| * gives the number of characters in the range; the default is that the |
| * range extends to the end of the matched string. |
| * |
| * Element boundaries, as well as entire embedded nodes such as processing |
| * instructions and comments, are ignored as defined in [XPath]. |
| * |
| * If the string in the second argument is not found in the string-value |
| * of the location, or if a value in the third or fourth argument indicates |
| * a string that is beyond the beginning or end of the document, the |
| * expression fails. |
| * |
| * The points of the range-locations in the returned location-set will |
| * all be character points. |
| * ------------------------------ |
| */ |
| static void |
| xmlXPtrStringRangeFunction(xmlXPathParserContextPtr ctxt, int nargs) { |
| int i, startindex, endindex = 0, fendindex; |
| xmlNodePtr start, end = 0, fend; |
| xmlXPathObjectPtr set; |
| xmlLocationSetPtr oldset; |
| xmlLocationSetPtr newset; |
| xmlXPathObjectPtr string; |
| xmlXPathObjectPtr position = NULL; |
| xmlXPathObjectPtr number = NULL; |
| int found, pos = 0, num = 0; |
| |
| /* |
| * Grab the arguments |
| */ |
| if ((nargs < 2) || (nargs > 4)) |
| XP_ERROR(XPATH_INVALID_ARITY); |
| |
| if (nargs >= 4) { |
| CHECK_TYPE(XPATH_NUMBER); |
| number = valuePop(ctxt); |
| if (number != NULL) |
| num = (int) number->floatval; |
| } |
| if (nargs >= 3) { |
| CHECK_TYPE(XPATH_NUMBER); |
| position = valuePop(ctxt); |
| if (position != NULL) |
| pos = (int) position->floatval; |
| } |
| CHECK_TYPE(XPATH_STRING); |
| string = valuePop(ctxt); |
| if ((ctxt->value == NULL) || |
| ((ctxt->value->type != XPATH_LOCATIONSET) && |
| (ctxt->value->type != XPATH_NODESET))) |
| XP_ERROR(XPATH_INVALID_TYPE) |
| |
| set = valuePop(ctxt); |
| newset = xmlXPtrLocationSetCreate(NULL); |
| if (newset == NULL) { |
| xmlXPathFreeObject(set); |
| XP_ERROR(XPATH_MEMORY_ERROR); |
| } |
| if (set->nodesetval == NULL) { |
| goto error; |
| } |
| if (set->type == XPATH_NODESET) { |
| xmlXPathObjectPtr tmp; |
| |
| /* |
| * First convert to a location set |
| */ |
| tmp = xmlXPtrNewLocationSetNodeSet(set->nodesetval); |
| xmlXPathFreeObject(set); |
| if (tmp == NULL) |
| XP_ERROR(XPATH_MEMORY_ERROR) |
| set = tmp; |
| } |
| oldset = (xmlLocationSetPtr) set->user; |
| |
| /* |
| * The loop is to search for each element in the location set |
| * the list of location set corresponding to that search |
| */ |
| for (i = 0;i < oldset->locNr;i++) { |
| #ifdef DEBUG_RANGES |
| xmlXPathDebugDumpObject(stdout, oldset->locTab[i], 0); |
| #endif |
| |
| xmlXPtrGetStartPoint(oldset->locTab[i], &start, &startindex); |
| xmlXPtrGetEndPoint(oldset->locTab[i], &end, &endindex); |
| xmlXPtrAdvanceChar(&start, &startindex, 0); |
| xmlXPtrGetLastChar(&end, &endindex); |
| |
| #ifdef DEBUG_RANGES |
| xmlGenericError(xmlGenericErrorContext, |
| "from index %d of ->", startindex); |
| xmlDebugDumpString(stdout, start->content); |
| xmlGenericError(xmlGenericErrorContext, "\n"); |
| xmlGenericError(xmlGenericErrorContext, |
| "to index %d of ->", endindex); |
| xmlDebugDumpString(stdout, end->content); |
| xmlGenericError(xmlGenericErrorContext, "\n"); |
| #endif |
| do { |
| fend = end; |
| fendindex = endindex; |
| found = xmlXPtrSearchString(string->stringval, &start, &startindex, |
| &fend, &fendindex); |
| if (found == 1) { |
| if (position == NULL) { |
| xmlXPtrLocationSetAdd(newset, |
| xmlXPtrNewRange(start, startindex, fend, fendindex)); |
| } else if (xmlXPtrAdvanceChar(&start, &startindex, |
| pos - 1) == 0) { |
| if ((number != NULL) && (num > 0)) { |
| int rindx; |
| xmlNodePtr rend; |
| rend = start; |
| rindx = startindex - 1; |
| if (xmlXPtrAdvanceChar(&rend, &rindx, |
| num) == 0) { |
| xmlXPtrLocationSetAdd(newset, |
| xmlXPtrNewRange(start, startindex, |
| rend, rindx)); |
| } |
| } else if ((number != NULL) && (num <= 0)) { |
| xmlXPtrLocationSetAdd(newset, |
| xmlXPtrNewRange(start, startindex, |
| start, startindex)); |
| } else { |
| xmlXPtrLocationSetAdd(newset, |
| xmlXPtrNewRange(start, startindex, |
| fend, fendindex)); |
| } |
| } |
| start = fend; |
| startindex = fendindex; |
| if (string->stringval[0] == 0) |
| startindex++; |
| } |
| } while (found == 1); |
| } |
| |
| /* |
| * Save the new value and cleanup |
| */ |
| error: |
| valuePush(ctxt, xmlXPtrWrapLocationSet(newset)); |
| xmlXPathFreeObject(set); |
| xmlXPathFreeObject(string); |
| if (position) xmlXPathFreeObject(position); |
| if (number) xmlXPathFreeObject(number); |
| } |
| |
| /** |
| * xmlXPtrEvalRangePredicate: |
| * @ctxt: the XPointer Parser context |
| * |
| * [8] Predicate ::= '[' PredicateExpr ']' |
| * [9] PredicateExpr ::= Expr |
| * |
| * Evaluate a predicate as in xmlXPathEvalPredicate() but for |
| * a Location Set instead of a node set |
| */ |
| void |
| xmlXPtrEvalRangePredicate(xmlXPathParserContextPtr ctxt) { |
| const xmlChar *cur; |
| xmlXPathObjectPtr res; |
| xmlXPathObjectPtr obj, tmp; |
| xmlLocationSetPtr newset = NULL; |
| xmlLocationSetPtr oldset; |
| int i; |
| |
| if (ctxt == NULL) return; |
| |
| SKIP_BLANKS; |
| if (CUR != '[') { |
| XP_ERROR(XPATH_INVALID_PREDICATE_ERROR); |
| } |
| NEXT; |
| SKIP_BLANKS; |
| |
| /* |
| * Extract the old set, and then evaluate the result of the |
| * expression for all the element in the set. use it to grow |
| * up a new set. |
| */ |
| CHECK_TYPE(XPATH_LOCATIONSET); |
| obj = valuePop(ctxt); |
| oldset = obj->user; |
| ctxt->context->node = NULL; |
| |
| if ((oldset == NULL) || (oldset->locNr == 0)) { |
| ctxt->context->contextSize = 0; |
| ctxt->context->proximityPosition = 0; |
| xmlXPathEvalExpr(ctxt); |
| res = valuePop(ctxt); |
| if (res != NULL) |
| xmlXPathFreeObject(res); |
| valuePush(ctxt, obj); |
| CHECK_ERROR; |
| } else { |
| /* |
| * Save the expression pointer since we will have to evaluate |
| * it multiple times. Initialize the new set. |
| */ |
| cur = ctxt->cur; |
| newset = xmlXPtrLocationSetCreate(NULL); |
| |
| for (i = 0; i < oldset->locNr; i++) { |
| ctxt->cur = cur; |
| |
| /* |
| * Run the evaluation with a node list made of a single item |
| * in the nodeset. |
| */ |
| ctxt->context->node = oldset->locTab[i]->user; |
| tmp = xmlXPathNewNodeSet(ctxt->context->node); |
| valuePush(ctxt, tmp); |
| ctxt->context->contextSize = oldset->locNr; |
| ctxt->context->proximityPosition = i + 1; |
| |
| xmlXPathEvalExpr(ctxt); |
| CHECK_ERROR; |
| |
| /* |
| * The result of the evaluation need to be tested to |
| * decided whether the filter succeeded or not |
| */ |
| res = valuePop(ctxt); |
| if (xmlXPathEvaluatePredicateResult(ctxt, res)) { |
| xmlXPtrLocationSetAdd(newset, |
| xmlXPathObjectCopy(oldset->locTab[i])); |
| } |
| |
| /* |
| * Cleanup |
| */ |
| if (res != NULL) |
| xmlXPathFreeObject(res); |
| if (ctxt->value == tmp) { |
| res = valuePop(ctxt); |
| xmlXPathFreeObject(res); |
| } |
| |
| ctxt->context->node = NULL; |
| } |
| |
| /* |
| * The result is used as the new evaluation set. |
| */ |
| xmlXPathFreeObject(obj); |
| ctxt->context->node = NULL; |
| ctxt->context->contextSize = -1; |
| ctxt->context->proximityPosition = -1; |
| valuePush(ctxt, xmlXPtrWrapLocationSet(newset)); |
| } |
| if (CUR != ']') { |
| XP_ERROR(XPATH_INVALID_PREDICATE_ERROR); |
| } |
| |
| NEXT; |
| SKIP_BLANKS; |
| } |
| |
| #define bottom_xpointer |
| #include "elfgcchack.h" |
| #endif |
| |