/*

 * xpath.c: XML Path Language implementation

 *          XPath is a language for addressing parts of an XML document,

 *          designed to be used by both XSLT and XPointer

 *

 * Reference: W3C Recommendation 16 November 1999

 *     http://www.w3.org/TR/1999/REC-xpath-19991116

 * Public reference:

 *     http://www.w3.org/TR/xpath

 *

 * See Copyright for the status of this software

 *

 * Author: daniel@veillard.com

 *

 */

#define IN_LIBXML

#include "XmlEnglibxml.h"

#include <string.h>

// TODO: XE Cleanup

#ifdef HAVE_SYS_TYPES_H

#include <sys/types.h>

#endif

#ifdef HAVE_MATH_H

#include <math.h>

#endif

#if defined(HAVE_CTYPE_H)

#include <ctype.h>

#endif

#ifdef HAVE_SIGNAL_H

#include <signal.h>

#endif

#include "Libxml2_globals.h"

//#include "Libxml2_xmlmemory.h"

//#include "Libxml2_xpath.h"

//#include "Libxml2_tree.h"

//#include "Libxml2_valid.h"

#include "Libxml2_xpathInternals.h"

#include "Libxml2_parserInternals.h"

//#include "Libxml2_hash.h"

#ifdef LIBXML_XPTR_ENABLED

#include "Libxml2_xpointer.h"

#endif

#ifdef LIBXML_DEBUG_ENABLED

#include <debugXML.h>

#endif

//#include "Libxml2_xmlerror.h"

//#include "Libxml2_threads.h"

// TODO: remove/rename TODO

#define TODO                                                        \

    xmlGenericError(xmlGenericErrorContext,                         \

        EMBED_ERRTXT("Unimplemented block at %s:%d\n"),             \

            __FILE__, __LINE__);

#if defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_XPATH_ENABLED)

/************************************************************************

 *                                                                      *

 *          Floating point stuff                                        *

 *                                                                      *

 ************************************************************************/

#ifndef TRIO_REPLACE_STDIO

//#define TRIO_PUBLIC static

#endif

#include "Libxml2_trionan.inc"

/**

 * xmlXPathInit:

 *

 * Initialize the XPath environment

 *

 * OOM: never (so far -- soon hash tables will be created here)

 */

void

xmlXPathInit(void) {

    if (xmlXPathInitialized) return;

    xmlXPathPINF = trio_pinf();

    xmlXPathNINF = trio_ninf();

    xmlXPathNAN = trio_nan();

    xmlXPathNZERO = trio_nzero();

    xmlXPathInitialized = 1;

    // TODO: Register all XPath functions in reusable hash table here

}

/**

 * xeXPathCleanup:

 *

 * Free any reusable by XPath module resources

 */

void xeXPathCleanup()

{

#ifdef XMLENGINE_XPATH_FUNC_HASH_OPTIMIZED

    if (xmlXPathDefaultFunctionsHash)

        xmlHashFree(xmlXPathDefaultFunctionsHash, NULL);

    xmlXPathDefaultFunctionsHash = NULL;

    if (xmlXPathIntermediaryExtensionFunctionsHash)

        xmlHashFree(xmlXPathIntermediaryExtensionFunctionsHash, NULL);

    xmlXPathIntermediaryExtensionFunctionsHash = NULL;

#endif

}

// DONE: OPTIMIZE: Define as macro or inliner

/**

 * xmlXPathIsNaN:

 * @val:  a double value

 *

 * Provides a portable isnan() function to detect whether a double

 * is a NotaNumber. Based on trio code

 * http://sourceforge.net/projects/ctrio/

 *

 * Returns 1 if the value is a NaN, 0 otherwise

 */

/*

inline int xmlXPathIsNaN(double val) {

    return(trio_isnan(val));

}*/

//#define xmlXPathIsNaN(val) trio_isnan(val)

//#define xmlXPathIsNaN(val) trio_isnan(val)

// DONE: OPTIMIZE: Define as macro or inliner

/**

 * xmlXPathIsInf:

 * @val:  a double value

 *

 * Provides a portable isinf() function to detect whether a double

 * is a +Infinite or -Infinite. Based on trio code

 * http://sourceforge.net/projects/ctrio/

 *

 * Returns 1 vi the value is +Infinite, -1 if -Infinite, 0 otherwise

 */

/*

inline int xmlXPathIsInf(double val) {

    return(trio_isinf(val));

}

*/

#define xmlXPathIsInf(val) trio_isinf(val)

#endif /* SCHEMAS or XPATH */

#ifdef LIBXML_XPATH_ENABLED

// TODO: OPTIMIZE: Define as macro or inliner

/**

 * xmlXPathGetSign:

 * @val:  a double value

 *

 * Provides a portable function to detect the sign of a double

 * Modified from trio code

 * http://sourceforge.net/projects/ctrio/

 *

 * Returns 1 if the value is Negative, 0 if positive

 */

/*

inline int xmlXPathGetSign(double val) {

    return(trio_signbit(val));

}

*/

#define xmlXPathGetSign(val) trio_signbit(val)

/*

 * TODO: when compatibility allows remove all "fake node libxslt" strings

 *       the test should just be name[0] = ' '

 */

/* #define DEBUG */

/* #define DEBUG_STEP */

/* #define DEBUG_STEP_NTH */

/* #define DEBUG_EXPR */

/* #define DEBUG_EVAL_COUNTS */

static const xmlNs xmlXPathXMLNamespaceStruct = {

    NULL,

    XML_NAMESPACE_DECL,

    XML_XML_NAMESPACE,

    BAD_CAST "xml",

    NULL

};

static const xmlNsPtr xmlXPathXMLNamespace = (xmlNsPtr)&xmlXPathXMLNamespaceStruct;

/************************************************************************

 *                                                                      *

 *          Error handling routines                                     *

 *                                                                      *

 ************************************************************************/

/*

 * The array xmlXPathErrorMessages corresponds to the enum xmlXPathError

 */

const char *const xmlXPathErrorMessages[] = {

    EMBED_ERRTXT("Ok\n"),

    EMBED_ERRTXT("Number encoding\n"),

    EMBED_ERRTXT("Unfinished literal\n"),

    EMBED_ERRTXT("Start of literal\n"),

    EMBED_ERRTXT("Expected $ for variable reference\n"),

    EMBED_ERRTXT("Undefined variable\n"),

    EMBED_ERRTXT("Invalid predicate\n"),

    EMBED_ERRTXT("Invalid expression\n"),

    EMBED_ERRTXT("Missing closing curly brace\n"),

    EMBED_ERRTXT("Unregistered function\n"),

    EMBED_ERRTXT("Invalid operand\n"),

    EMBED_ERRTXT("Invalid type\n"),

    EMBED_ERRTXT("Invalid number of arguments\n"),

    EMBED_ERRTXT("Invalid context size\n"),

    EMBED_ERRTXT("Invalid context position\n"),

    EMBED_ERRTXT("Memory allocation error\n"),

    EMBED_ERRTXT("Syntax error\n"),

    EMBED_ERRTXT("Resource error\n"),

    EMBED_ERRTXT("Sub resource error\n"),

    EMBED_ERRTXT("Undefined namespace prefix\n"),

    EMBED_ERRTXT("Encoding error\n"),

    EMBED_ERRTXT("Char out of XML range\n")

};

// TODO: OPTIMIZATION: Not required for Symbian

/**

 * xmlXPathErrMemory:

 * @ctxt:  an XPath context

 * @extra:  extra informations

 *

 * Handle a redefinition of attribute error

 */

static void

xmlXPathErrMemory(xmlXPathContextPtr ctxt, const char *extra)

{

    if (ctxt != NULL) {

        if (extra) {

            xmlChar buf[200];

            xmlStrPrintf(buf, 200,

                  BAD_CAST EMBED_ERRTXT("Memory allocation failed : %s\n"), extra);

            ctxt->lastError.message = (char *) xmlStrdup(buf);

        } else {

            ctxt->lastError.message = (char *)

                xmlStrdup(BAD_CAST EMBED_ERRTXT("Memory allocation failed\n"));

        }

        ctxt->lastError.domain = XML_FROM_XPATH;

        ctxt->lastError.code = XML_ERR_NO_MEMORY;

    if (ctxt->error != NULL)

        ctxt->error(ctxt->userData, &ctxt->lastError);

    } else {

        if (extra)

            __xmlRaiseError(NULL, NULL, NULL,

                            NULL, NULL, XML_FROM_XPATH,

                            XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0,

                            extra, NULL, NULL, 0, 0,

                            EMBED_ERRTXT("Memory allocation failed : %s\n"), extra);

        else

            __xmlRaiseError(NULL, NULL, NULL,

                            NULL, NULL, XML_FROM_XPATH,

                            XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0,

                            NULL, NULL, NULL, 0, 0,

                            EMBED_ERRTXT("Memory allocation failed\n"));

    }

}

/**

 * xmlXPathErrMemory:

 * @ctxt:  an XPath parser context

 * @extra:  extra informations

 *

 * Handle a redefinition of attribute error

 */

// TODO: Obviously, something wrong here: ctxt!=NULL for sure

static void

xmlXPathPErrMemory(xmlXPathParserContextPtr ctxt, const char *extra)

{

    ctxt->error = XPATH_MEMORY_ERROR;

    if (ctxt == NULL)

        xmlXPathErrMemory(NULL, extra);

    else

        xmlXPathErrMemory(ctxt->context, extra);

}

/**

 * xmlXPathErr:

 * @ctxt:  a XPath parser context

 * @error:  the error code

 *

 * Handle a Relax NG Parsing error

 */

void

xmlXPathErr(xmlXPathParserContextPtr ctxt, int error)

{

    // TODO: OPTIMIZE: Combine two (or even all three) IF blocks into one

    if (ctxt == NULL) {

        __xmlRaiseError(NULL, NULL, NULL,

                NULL, NULL, XML_FROM_XPATH,

                error + XML_XPATH_EXPRESSION_OK - XPATH_EXPRESSION_OK,

                XML_ERR_ERROR, NULL, 0,

                NULL, NULL, NULL, 0, 0,

                xmlXPathErrorMessages[error]);

        return;

    }

    ctxt->error = error;

    if (ctxt->context == NULL) {

        __xmlRaiseError(NULL, NULL, NULL,

                NULL, NULL, XML_FROM_XPATH,

                error + XML_XPATH_EXPRESSION_OK - XPATH_EXPRESSION_OK,

                XML_ERR_ERROR, NULL, 0,

                (const char *) ctxt->base, NULL, NULL,

                ctxt->cur - ctxt->base, 0,

                xmlXPathErrorMessages[error]);

        return;

    }

    // TODO: OPTIMIZE: make a proxy for lastError

    ctxt->context->lastError.domain = XML_FROM_XPATH;

    ctxt->context->lastError.code = error + XML_XPATH_EXPRESSION_OK - XPATH_EXPRESSION_OK;

    ctxt->context->lastError.level = XML_ERR_ERROR;

    if (ctxt->context->lastError.str1) // agathe added

        xmlFree(ctxt->context->lastError.str1);

    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_XPATH,

                error + XML_XPATH_EXPRESSION_OK - XPATH_EXPRESSION_OK,

                XML_ERR_ERROR, NULL, 0,

                (const char *) ctxt->base, NULL, NULL,

                ctxt->cur - ctxt->base, 0,

                xmlXPathErrorMessages[error]);

    }

}

// DONE: OPTIMIZE: Use macro instead of function call

//       Macro added in xpathInternals.h

/**

 * xmlXPatherror:

 * @ctxt:  the XPath Parser context

 * @file:  the file name

 * @line:  the line number

 * @no:  the error number

 *

 * Formats an error message.

 */

//void

//xmlXPatherror(xmlXPathParserContextPtr ctxt, const char* file ATTRIBUTE_UNUSED,

//              int line ATTRIBUTE_UNUSED , int no)

//{

//    xmlXPathErr(ctxt, no);

//}

/************************************************************************

 *                                                                      *

 *          Parser Types                                                *

 *                                                                      *

 ************************************************************************/

/*

 * Types are private:

 */

typedef enum {

    AXIS_ANCESTOR = 1,

    AXIS_ANCESTOR_OR_SELF,

    AXIS_ATTRIBUTE,

    AXIS_CHILD,

    AXIS_DESCENDANT,

    AXIS_DESCENDANT_OR_SELF,

    AXIS_FOLLOWING,

    AXIS_FOLLOWING_SIBLING,

    AXIS_NAMESPACE,

    AXIS_PARENT,

    AXIS_PRECEDING,

    AXIS_PRECEDING_SIBLING,

    AXIS_SELF

} xmlXPathAxisVal;

typedef enum {

    NODE_TEST_NONE  = 0,

    NODE_TEST_TYPE  = 1,

    NODE_TEST_PI    = 2,

    NODE_TEST_ALL   = 3,

    NODE_TEST_NS    = 4,

    NODE_TEST_NAME  = 5

} xmlXPathTestVal;

typedef enum {

    NODE_TYPE_NODE    = 0,

    NODE_TYPE_COMMENT = XML_COMMENT_NODE,

    NODE_TYPE_TEXT    = XML_TEXT_NODE,

    NODE_TYPE_PI      = XML_PI_NODE

} xmlXPathTypeVal;

/************************************************************************

 *                                                                      *

 *          Parser Type functions                                       *

 *                                                                      *

 ************************************************************************/

/**

 * xmlXPathNewCompExpr:

 *

 * Create a new Xpath component

 *

 * Returns the newly allocated xmlXPathCompExprPtr or NULL in case of error

 */

static xmlXPathCompExprPtr

xmlXPathNewCompExpr(void) {

    xmlXPathCompExprPtr cur;

    cur = (xmlXPathCompExprPtr) xmlMalloc(sizeof(xmlXPathCompExpr));

    if (cur == NULL) {

        xmlXPathErrMemory(NULL, EMBED_ERRTXT("allocating component\n"));

        return(NULL);

    }

    memset(cur, 0, sizeof(xmlXPathCompExpr));

    cur->maxStep = 10; /* TODO: XPath context can be configured by maxStep parameter */

    cur->nbStep = 0;

    cur->steps = (xmlXPathStepOp *) xmlMalloc(cur->maxStep * sizeof(xmlXPathStepOp));

    if (cur->steps == NULL) {

        xmlXPathErrMemory(NULL, EMBED_ERRTXT("allocating steps\n"));

        xmlFree(cur);

        return(NULL);

    }

    memset(cur->steps, 0, cur->maxStep * sizeof(xmlXPathStepOp));

    cur->last = -1;

#ifdef DEBUG_EVAL_COUNTS

    cur->nb = 0;

#endif

    return(cur);

}

/**

 * xmlXPathFreeCompExpr:

 * @comp:  an XPATH comp

 *

 * Free up the memory allocated by @comp

 */

void

xmlXPathFreeCompExpr(xmlXPathCompExprPtr comp)

{

    xmlXPathStepOpPtr op;

    int i;

    if (comp == NULL)

        return;

    if (comp->dict == NULL) {

        for (i = 0; i < comp->nbStep; i++) {

            op = &comp->steps[i];

            if (op->value4 != NULL) {

                if (op->op == XPATH_OP_VALUE)

                    xmlXPathFreeObject((xmlXPathObjectPtr)op->value4);

                else

                    xmlFree(op->value4);

            }

            if (op->value5 != NULL)

                xmlFree(op->value5);

        }

    } else {

        for (i = 0; i < comp->nbStep; i++) {

            op = &comp->steps[i];

            if (op->value4 != NULL) {

                if (op->op == XPATH_OP_VALUE)

                    xmlXPathFreeObject((xmlXPathObjectPtr)op->value4);

            }

        }

        xmlDictFree(comp->dict);

    }

    if (comp->steps != NULL) {

        xmlFree(comp->steps);

    }

#ifdef DEBUG_EVAL_COUNTS

    if (comp->string != NULL) {

        xmlFree(comp->string);

    }

#endif

    if (comp->expr != NULL) {

        xmlFree(comp->expr);

    }

    xmlFree(comp);

}

/**

 * xmlXPathCompExprAdd:

 * @comp:  the compiled expression

 * @ch1: first child index

 * @ch2: second child index

 * @op:  an op

 * @value:  the first int value

 * @value2:  the second int value

 * @value3:  the third int value

 * @value4:  the first string value

 * @value5:  the second string value

 *

 * Add a step to an XPath Compiled Expression

 *

 * Returns -1 in case of failure, the index otherwise

 */

static int

xmlXPathCompExprAdd(xmlXPathCompExprPtr comp, int ch1, int ch2,

                    xmlXPathOp op, int value,

                    int value2, int value3, void *value4, void *value5)

{

    xmlXPathStepOpPtr step;

    if (comp->nbStep >= comp->maxStep)

    {

        xmlXPathStepOp *real;

        comp->maxStep *= 2;

        real = (xmlXPathStepOp *) xmlRealloc(comp->steps, comp->maxStep * sizeof(xmlXPathStepOp));

        if (real == NULL) {