xpath.h

/*

 * Summary: XML Path Language implementation

 * Description: API for the XML Path Language implementation

 *

 * XML Path Language implementation

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

 * designed to be used by both XSLT and XPointer

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

 *

 * Implements

 * W3C Recommendation 16 November 1999

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

 *

 * Copy: See Copyright for the status of this software.

 *

 * Author: Daniel Veillard

 */



#ifndef __XML_XPATH_H__

#define __XML_XPATH_H__



#include <libxml/xmlversion.h>



#ifdef LIBXML_XPATH_ENABLED



#include <libxml/xmlerror.h>

#include <libxml/tree.h>

#include <libxml/hash.h>

#endif /* LIBXML_XPATH_ENABLED */



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

#ifdef __cplusplus

extern "C" {

#endif

#endif /* LIBXML_XPATH_ENABLED or LIBXML_SCHEMAS_ENABLED */

        

#ifdef LIBXML_XPATH_ENABLED

typedef struct _xmlXPathContext xmlXPathContext;

typedef xmlXPathContext *xmlXPathContextPtr;

typedef struct _xmlXPathParserContext xmlXPathParserContext;

typedef xmlXPathParserContext *xmlXPathParserContextPtr;



typedef enum {

    XPATH_EXPRESSION_OK = 0,

    XPATH_NUMBER_ERROR,

    XPATH_UNFINISHED_LITERAL_ERROR,

    XPATH_START_LITERAL_ERROR,

    XPATH_VARIABLE_REF_ERROR,

    XPATH_UNDEF_VARIABLE_ERROR,

    XPATH_INVALID_PREDICATE_ERROR,

    XPATH_EXPR_ERROR,

    XPATH_UNCLOSED_ERROR,

    XPATH_UNKNOWN_FUNC_ERROR,

    XPATH_INVALID_OPERAND,

    XPATH_INVALID_TYPE,

    XPATH_INVALID_ARITY,

    XPATH_INVALID_CTXT_SIZE,

    XPATH_INVALID_CTXT_POSITION,

    XPATH_MEMORY_ERROR,

    XPTR_SYNTAX_ERROR,

    XPTR_RESOURCE_ERROR,

    XPTR_SUB_RESOURCE_ERROR,

    XPATH_UNDEF_PREFIX_ERROR,

    XPATH_ENCODING_ERROR,

    XPATH_INVALID_CHAR_ERROR,

    XPATH_INVALID_CTXT

} xmlXPathError;



/*

 * A node-set (an unordered collection of nodes without duplicates).

 */

typedef struct _xmlNodeSet xmlNodeSet;

typedef xmlNodeSet *xmlNodeSetPtr;

struct _xmlNodeSet {

    int nodeNr;                 /* number of nodes in the set */

    int nodeMax;                /* size of the array as allocated */

    xmlNodePtr *nodeTab;        /* array of nodes in no particular order */

    /* @@ with_ns to check wether namespace nodes should be looked at @@ */

};



/*

 * An expression is evaluated to yield an object, which

 * has one of the following four basic types:

 *   - node-set

 *   - boolean

 *   - number

 *   - string

 *

 * @@ XPointer will add more types !

 */



typedef enum {

    XPATH_UNDEFINED = 0,

    XPATH_NODESET = 1,

    XPATH_BOOLEAN = 2,

    XPATH_NUMBER = 3,

    XPATH_STRING = 4,

    XPATH_POINT = 5,

    XPATH_RANGE = 6,

    XPATH_LOCATIONSET = 7,

    XPATH_USERS = 8,

    XPATH_XSLT_TREE = 9  /* An XSLT value tree, non modifiable */

} xmlXPathObjectType;



typedef struct _xmlXPathObject xmlXPathObject;

typedef xmlXPathObject *xmlXPathObjectPtr;

struct _xmlXPathObject {

    xmlXPathObjectType type;

    xmlNodeSetPtr nodesetval;

    int boolval;

    double floatval;

    xmlChar *stringval;

    void *user;

    int index;

    void *user2;

    int index2;

};



typedef int (*xmlXPathConvertFunc) (xmlXPathObjectPtr obj, int type);



/*

 * Extra type: a name and a conversion function.

 */



typedef struct _xmlXPathType xmlXPathType;

typedef xmlXPathType *xmlXPathTypePtr;

struct _xmlXPathType {

    const xmlChar         *name;                /* the type name */

    xmlXPathConvertFunc func;           /* the conversion function */

};



/*

 * Extra variable: a name and a value.

 */



typedef struct _xmlXPathVariable xmlXPathVariable;

typedef xmlXPathVariable *xmlXPathVariablePtr;

struct _xmlXPathVariable {

    const xmlChar       *name;          /* the variable name */

    xmlXPathObjectPtr value;            /* the value */

};



typedef void (*xmlXPathEvalFunc)(xmlXPathParserContextPtr ctxt,

                                 int nargs);



/*

 * Extra function: a name and a evaluation function.

 */



typedef struct _xmlXPathFunct xmlXPathFunct;

typedef xmlXPathFunct *xmlXPathFuncPtr;

struct _xmlXPathFunct {

    const xmlChar      *name;           /* the function name */

    xmlXPathEvalFunc func;              /* the evaluation function */

};



typedef xmlXPathObjectPtr (*xmlXPathAxisFunc) (xmlXPathParserContextPtr ctxt,

                                 xmlXPathObjectPtr cur);



/*

 * Extra axis: a name and an axis function.

 */



typedef struct _xmlXPathAxis xmlXPathAxis;

typedef xmlXPathAxis *xmlXPathAxisPtr;

struct _xmlXPathAxis {

    const xmlChar      *name;           /* the axis name */

    xmlXPathAxisFunc func;              /* the search function */

};



typedef void (*xmlXPathFunction) (xmlXPathParserContextPtr ctxt, int nargs);



/*

 * Function and Variable Lookup.

 */



typedef xmlXPathObjectPtr (*xmlXPathVariableLookupFunc) (void *ctxt,

                                         const xmlChar *name,

                                         const xmlChar *ns_uri);



typedef xmlXPathFunction (*xmlXPathFuncLookupFunc) (void *ctxt,

                                         const xmlChar *name,

                                         const xmlChar *ns_uri);



struct _xmlXPathContext {

    xmlDocPtr doc;                      /* The current document */

    xmlNodePtr node;                    /* The current node */



    int nb_variables_unused;            /* unused (hash table) */

    int max_variables_unused;           /* unused (hash table) */

    xmlHashTablePtr varHash;            /* Hash table of defined variables */



    int nb_types;                       /* number of defined types */

    int max_types;                      /* max number of types */

    xmlXPathTypePtr types;              /* Array of defined types */



    int nb_funcs_unused;                /* unused (hash table) */

    int max_funcs_unused;               /* unused (hash table) */

    xmlHashTablePtr funcHash;           /* Hash table of defined funcs */



    int nb_axis;                        /* number of defined axis */

    int max_axis;                       /* max number of axis */

    xmlXPathAxisPtr axis;               /* Array of defined axis */



    /* the namespace nodes of the context node */

    xmlNsPtr *namespaces;               /* Array of namespaces */

    int nsNr;                           /* number of namespace in scope */

    void *user;                         /* function to free */



    /* extra variables */

    int contextSize;                    /* the context size */

    int proximityPosition;              /* the proximity position */



    /* extra stuff for XPointer */

    int xptr;                           /* it this an XPointer context */

    xmlNodePtr here;                    /* for here() */

    xmlNodePtr origin;                  /* for origin() */



    /* the set of namespace declarations in scope for the expression */

    xmlHashTablePtr nsHash;             /* The namespaces hash table */

    xmlXPathVariableLookupFunc varLookupFunc;/* variable lookup func */

    void *varLookupData;                /* variable lookup data */



    /* Possibility to link in an extra item */

    void *extra;                        /* needed for XSLT */



    /* The function name and URI when calling a function */

    const xmlChar *function;

    const xmlChar *functionURI;



    /* function lookup function and data */

    xmlXPathFuncLookupFunc funcLookupFunc;/* function lookup func */

    void *funcLookupData;               /* function lookup data */



    /* temporary namespace lists kept for walking the namespace axis */

    xmlNsPtr *tmpNsList;                /* Array of namespaces */

    int tmpNsNr;                        /* number of namespace in scope */



    /* error reporting mechanism */

    void *userData;                     /* user specific data block */

    xmlStructuredErrorFunc error;       /* the callback in case of errors */

    xmlError lastError;                 /* the last error */

    xmlNodePtr debugNode;               /* the source node XSLT */



    /* dictionnary */

    xmlDictPtr dict;                    /* dictionnary if any */

};



/*

 * The structure of a compiled expression form is not public.

 */



typedef struct _xmlXPathCompExpr xmlXPathCompExpr;

typedef xmlXPathCompExpr *xmlXPathCompExprPtr;



struct _xmlXPathParserContext {

    const xmlChar *cur;                 /* the current char being parsed */

    const xmlChar *base;                        /* the full expression */



    int error;                          /* error code */



    xmlXPathContextPtr  context;        /* the evaluation context */

    xmlXPathObjectPtr     value;        /* the current value */

    int                 valueNr;        /* number of values stacked */

    int                valueMax;        /* max number of values stacked */

    xmlXPathObjectPtr *valueTab;        /* stack of values */



    xmlXPathCompExprPtr comp;           /* the precompiled expression */

    int xptr;                           /* it this an XPointer expression */

    xmlNodePtr         ancestor;        /* used for walking preceding axis */

};



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

 *                                                                      *

 *                      Public API                                      *

 *                                                                      *

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



XMLPUBVAR double xmlXPathNAN;

XMLPUBVAR double xmlXPathPINF;

XMLPUBVAR double xmlXPathNINF;



/* These macros may later turn into functions */

#define xmlXPathNodeSetGetLength(ns) ((ns) ? (ns)->nodeNr : 0)

#define xmlXPathNodeSetItem(ns, index)                          \

                ((((ns) != NULL) &&                             \

                  ((index) >= 0) && ((index) < (ns)->nodeNr)) ? \

                 (ns)->nodeTab[(index)]                         \

                 : NULL)

#define xmlXPathNodeSetIsEmpty(ns)                                      \

    (((ns) == NULL) || ((ns)->nodeNr == 0) || ((ns)->nodeTab == NULL))





XMLPUBFUN void XMLCALL             

                    xmlXPathFreeObject          (xmlXPathObjectPtr obj);

XMLPUBFUN xmlNodeSetPtr XMLCALL    

                    xmlXPathNodeSetCreate       (xmlNodePtr val);

XMLPUBFUN void XMLCALL             

                    xmlXPathFreeNodeSetList     (xmlXPathObjectPtr obj);

XMLPUBFUN void XMLCALL             

                    xmlXPathFreeNodeSet         (xmlNodeSetPtr obj);

XMLPUBFUN xmlXPathObjectPtr XMLCALL  

                    xmlXPathObjectCopy          (xmlXPathObjectPtr val);

XMLPUBFUN int XMLCALL              

                    xmlXPathCmpNodes            (xmlNodePtr node1,

                                                 xmlNodePtr node2);

XMLPUBFUN int XMLCALL              

                    xmlXPathCastNumberToBoolean (double val);

XMLPUBFUN int XMLCALL              

                    xmlXPathCastStringToBoolean (const xmlChar * val);

XMLPUBFUN int XMLCALL              

                    xmlXPathCastNodeSetToBoolean(xmlNodeSetPtr ns);

XMLPUBFUN int XMLCALL              

                    xmlXPathCastToBoolean       (xmlXPathObjectPtr val);



XMLPUBFUN double XMLCALL                   

                    xmlXPathCastBooleanToNumber (int val);

XMLPUBFUN double XMLCALL                   

                    xmlXPathCastStringToNumber  (const xmlChar * val);

XMLPUBFUN double XMLCALL                   

                    xmlXPathCastNodeToNumber    (xmlNodePtr node);

XMLPUBFUN double XMLCALL                   

                    xmlXPathCastNodeSetToNumber (xmlNodeSetPtr ns);

XMLPUBFUN double XMLCALL                   

                    xmlXPathCastToNumber        (xmlXPathObjectPtr val);



XMLPUBFUN xmlChar * XMLCALL        

                    xmlXPathCastBooleanToString (int val);

XMLPUBFUN xmlChar * XMLCALL        

                    xmlXPathCastNumberToString  (double val);

XMLPUBFUN xmlChar * XMLCALL        

                    xmlXPathCastNodeToString    (xmlNodePtr node);

XMLPUBFUN xmlChar * XMLCALL        

                    xmlXPathCastNodeSetToString (xmlNodeSetPtr ns);

XMLPUBFUN xmlChar * XMLCALL        

                    xmlXPathCastToString        (xmlXPathObjectPtr val);



XMLPUBFUN xmlXPathObjectPtr XMLCALL  

                    xmlXPathConvertBoolean      (xmlXPathObjectPtr val);

XMLPUBFUN xmlXPathObjectPtr XMLCALL  

                    xmlXPathConvertNumber       (xmlXPathObjectPtr val);

XMLPUBFUN xmlXPathObjectPtr XMLCALL  

                    xmlXPathConvertString       (xmlXPathObjectPtr val);



XMLPUBFUN xmlXPathContextPtr XMLCALL 

                    xmlXPathNewContext          (xmlDocPtr doc);

XMLPUBFUN void XMLCALL             

                    xmlXPathFreeContext         (xmlXPathContextPtr ctxt);



XMLPUBFUN long XMLCALL               

                    xmlXPathOrderDocElems       (xmlDocPtr doc);

XMLPUBFUN xmlXPathObjectPtr XMLCALL  

                    xmlXPathEval                (const xmlChar *str,

                                                 xmlXPathContextPtr ctx);

XMLPUBFUN xmlXPathObjectPtr XMLCALL  

                    xmlXPathEvalExpression      (const xmlChar *str,

                                                 xmlXPathContextPtr ctxt);

XMLPUBFUN int XMLCALL                

                    xmlXPathEvalPredicate       (xmlXPathContextPtr ctxt,

                                                 xmlXPathObjectPtr res);

XMLPUBFUN xmlXPathCompExprPtr XMLCALL 

                    xmlXPathCompile             (const xmlChar *str);

XMLPUBFUN xmlXPathCompExprPtr XMLCALL 

                    xmlXPathCtxtCompile         (xmlXPathContextPtr ctxt,

                                                 const xmlChar *str);

XMLPUBFUN xmlXPathObjectPtr XMLCALL   

                    xmlXPathCompiledEval        (xmlXPathCompExprPtr comp,

                                                 xmlXPathContextPtr ctx);

XMLPUBFUN void XMLCALL                

                    xmlXPathFreeCompExpr        (xmlXPathCompExprPtr comp);

#endif /* LIBXML_XPATH_ENABLED */

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

XMLPUBFUN void XMLCALL             

                    xmlXPathInit                (void);

XMLPUBFUN int XMLCALL

                xmlXPathIsNaN   (double val);

XMLPUBFUN int XMLCALL

                xmlXPathIsInf   (double val);



#ifdef __cplusplus

}

#endif



#endif /* LIBXML_XPATH_ENABLED or LIBXML_SCHEMAS_ENABLED*/

#endif /* ! __XML_XPATH_H__ */

---