/*

 * 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

 */

/* To avoid EBCDIC trouble when parsing on zOS */

#if defined(__MVS__)

#pragma convert("ISO8859-1")

#endif

#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.

 */

#include <string.h>

#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 LIBXML_ATTR_FORMAT(3,0)

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;

    }

    /* cleanup current last error */

    xmlResetError(&ctxt->context->lastError);

    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);

    }

    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);

}

/**

 * xmlXPtrNewRangeInternal:

 * @start:  the starting node

 * @startindex:  the start index

 * @end:  the ending point

 * @endindex:  the ending index

 *

 * Internal function to create a new xmlXPathObjectPtr of type range

 *

 * Returns the newly created object.

 */

static xmlXPathObjectPtr

xmlXPtrNewRangeInternal(xmlNodePtr start, int startindex,

                        xmlNodePtr end, int endindex) {

    xmlXPathObjectPtr ret;

    /*

     * Namespace nodes must be copied (see xmlXPathNodeSetDupNs).

     * Disallow them for now.

     */

    if ((start != NULL) && (start->type == XML_NAMESPACE_DECL))

	return(NULL);

    if ((end != NULL) && (end->type == XML_NAMESPACE_DECL))

	return(NULL);

    ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));

    if (ret == NULL) {

        xmlXPtrErrMemory("allocating range");

	return(NULL);

    }

    memset(ret, 0, sizeof(xmlXPathObject));

    ret->type = XPATH_RANGE;

    ret->user = start;

    ret->index = startindex;

    ret->user2 = end;

    ret->index2 = endindex;

    return(ret);

}

/**

 * 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 = xmlXPtrNewRangeInternal(start, startindex, end, 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 = xmlXPtrNewRangeInternal(start->user, start->index, end->user,

                                  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 = xmlXPtrNewRangeInternal(start->user, start->index, end, -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 = xmlXPtrNewRangeInternal(start, -1, end->user, 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 = xmlXPtrNewRangeInternal(start, -1, end, -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 = xmlXPtrNewRangeInternal(start, -1, NULL, -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) {

    xmlNodePtr endNode;

    int endIndex;

    xmlXPathObjectPtr ret;

    if (start == NULL)

	return(NULL);

    if (end == NULL)

	return(NULL);

    switch (end->type) {

	case XPATH_POINT:

	    endNode = end->user;

	    endIndex = end->index;

	    break;

	case XPATH_RANGE:

	    endNode = end->user2;

	    endIndex = end->index2;

	    break;

	case XPATH_NODESET:

	    /*

	     * Empty set ...

	     */

	    if ((end->nodesetval == NULL) || (end->nodesetval->nodeNr <= 0))

		return(NULL);

	    endNode = end->nodesetval->nodeTab[end->nodesetval->nodeNr - 1];

	    endIndex = -1;

	    break;

	default:

	    /* TODO */

	    return(NULL);

    }

    ret = xmlXPtrNewRangeInternal(start, -1, endNode, endIndex);

    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);

    }

    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);

	}

	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;

	}

	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);

    }

    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);

    }

    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);

    }

    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