/*

 * libxml2_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

 * Portion Copyright © 2009 Nokia Corporation and/or its subsidiary(-ies). All rights reserved. 

 */

#define IN_LIBXML

#include "xmlenglibxml.h"

/*

 * 

 *       

 * 

 *       

 *       

 */

#include <string.h>

#include <stdapis/libxml2/libxml2_xpointer.h>

#include <stdapis/libxml2/libxml2_xmlmemory.h>

#include <stdapis/libxml2/libxml2_parserinternals.h>

#include <stdapis/libxml2/libxml2_uri.h>

#include <stdapis/libxml2/libxml2_xpath.h>

#include <stdapis/libxml2/libxml2_xpathinternals.h>

#include <stdapis/libxml2/libxml2_xmlerror.h>

#include "libxml2_xmlerror2.h"

#include <stdapis/libxml2/libxml2_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 "libxml2_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:

 * @param 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:

 * @param ctxt an XPTR evaluation context

 * @param 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:

 * @param 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)

        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:

 * @param 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)

        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:

 * @param cur the node

 * @param 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)

        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:

 * @param node1 the first node

 * @param index1 the first index

 * @param node2 the second node

 * @param 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:

 * @param node the xmlNodePtr

 * @param 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:

 * @param 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:

 * @param range1 the first range

 * @param 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:

 * @param start the starting node

 * @param startindex the start index

 * @param end the ending point

 * @param endindex the ending index

 *

 * Create a new xmlXPathObjectPtr of type range

 *

 * Returns the newly created object.

 */

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

    }

    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:

 * @param start the starting point

 * @param end the ending point

 *

 * Create a new xmlXPathObjectPtr of type range using 2 Points

 *

 * Returns the newly created object.

 */

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

    }

    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:

 * @param start the starting point

 * @param end the ending node

 *

 * Create a new xmlXPathObjectPtr of type range from a point to a node

 *

 * Returns the newly created object.

 */

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

    }

    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:

 * @param start the starting node

 * @param end the ending point

 *

 * Create a new xmlXPathObjectPtr of type range from a node to a point

 *

 * Returns the newly created object.

 */

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

    }

    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:

 * @param start the starting node

 * @param end the ending node

 *

 * Create a new xmlXPathObjectPtr of type range using 2 nodes

 *

 * Returns the newly created object.

 */

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

    }

    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:

 * @param start the starting and ending node

 *

 * Create a new xmlXPathObjectPtr of type range using a single nodes

 *

 * Returns the newly created object.

 */

XMLPUBFUNEXPORT xmlXPathObjectPtr

xmlXPtrNewCollapsedRange(xmlNodePtr start)

{

    xmlXPathObjectPtr ret;

    if (start == NULL)

        return(NULL);

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

    if (!ret) {

        xmlXPtrErrMemory("allocating range");

        return(NULL);

    }

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

    ret->type = XPATH_RANGE;

    ret->user = start;