| /* |
| * xpath.c: interface for XML Path Language implementation |
| * |
| * Reference: W3C Working Draft 5 July 1999 |
| * http://www.w3.org/Style/XSL/Group/1999/07/xpath-19990705.html |
| * |
| * See COPYRIGHT for the status of this software |
| * |
| * Author: Daniel.Veillard@w3.org |
| */ |
| |
| #ifndef __XML_XPATH_H__ |
| #define __XML_XPATH_H__ |
| |
| #include <libxml/tree.h> |
| |
| #ifdef __cplusplus |
| extern "C" { |
| #endif |
| |
| typedef struct _xmlXPathContext xmlXPathContext; |
| typedef xmlXPathContext *xmlXPathContextPtr; |
| typedef struct _xmlXPathParserContext xmlXPathParserContext; |
| typedef xmlXPathParserContext *xmlXPathParserContextPtr; |
| |
| /** |
| * The set of XPath error codes |
| */ |
| |
| 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 |
| } 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 */ |
| }; |
| |
| /* |
| * 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 |
| } 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; |
| }; |
| |
| /* |
| * A conversion function is associated to a type and used to cast |
| * the new type to primitive values. |
| */ |
| 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 */ |
| }; |
| |
| /* |
| * an evaluation function, the parameters are on the context stack |
| */ |
| |
| 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 */ |
| }; |
| |
| /* |
| * An axis traversal function. To traverse an axis, the engine calls |
| * the first time with cur == NULL and repeat until the function returns |
| * NULL indicating the end of the axis traversal. |
| */ |
| |
| 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 */ |
| }; |
| |
| /* |
| * Expression evaluation occurs with respect to a context. |
| * he context consists of: |
| * - a node (the context node) |
| * - a node list (the context node list) |
| * - a set of variable bindings |
| * - a function library |
| * - the set of namespace declarations in scope for the expression |
| */ |
| |
| struct _xmlXPathContext { |
| xmlDocPtr doc; /* The current document */ |
| xmlNodePtr node; /* The current node */ |
| |
| int nb_variables; /* number of defined variables */ |
| int max_variables; /* max number of variables */ |
| xmlXPathVariablePtr *variables; /* Array 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; /* number of defined funcs */ |
| int max_funcs; /* max number of funcs */ |
| xmlXPathFuncPtr *funcs; /* Array of defined funcs */ |
| |
| int nb_axis; /* number of defined axis */ |
| int max_axis; /* max number of axis */ |
| xmlXPathAxisPtr *axis; /* Array of defined axis */ |
| |
| /* Namespace traversal should be implemented with user */ |
| xmlNsPtr *namespaces; /* The namespaces lookup */ |
| int nsNr; /* the current Namespace index */ |
| void *user; /* user defined extra info */ |
| |
| /* 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() */ |
| }; |
| |
| /* |
| * An XPath parser context, it contains pure parsing informations, |
| * an xmlXPathContext, and the stack of objects. |
| */ |
| 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 */ |
| }; |
| |
| /* |
| * An XPath function |
| * The arguments (if any) are popped out of the context stack |
| * and the result is pushed on the stack. |
| */ |
| |
| typedef void (*xmlXPathFunction) (xmlXPathParserContextPtr ctxt, int nargs); |
| |
| /************************************************************************ |
| * * |
| * Helpers * |
| * * |
| ************************************************************************/ |
| |
| #define CHECK_ERROR \ |
| if (ctxt->error != XPATH_EXPRESSION_OK) return |
| |
| #define CHECK_ERROR0 \ |
| if (ctxt->error != XPATH_EXPRESSION_OK) return(0) |
| |
| #define XP_ERROR(X) \ |
| { xmlXPatherror(ctxt, __FILE__, __LINE__, X); \ |
| ctxt->error = (X); return; } |
| |
| #define XP_ERROR0(X) \ |
| { xmlXPatherror(ctxt, __FILE__, __LINE__, X); \ |
| ctxt->error = (X); return(0); } |
| |
| #define CHECK_TYPE(typeval) \ |
| if ((ctxt->value == NULL) || (ctxt->value->type != typeval)) \ |
| XP_ERROR(XPATH_INVALID_TYPE) \ |
| |
| #define CHECK_ARITY(x) \ |
| if (nargs != (x)) { \ |
| XP_ERROR(XPATH_INVALID_ARITY); \ |
| } \ |
| |
| void xmlXPatherror (xmlXPathParserContextPtr ctxt, |
| const char *file, |
| int line, |
| int no); |
| |
| /** |
| * Utilities to extend XPath (XPointer) |
| */ |
| xmlXPathParserContextPtr |
| xmlXPathNewParserContext (const xmlChar *str, |
| xmlXPathContextPtr ctxt); |
| void xmlXPathFreeParserContext (xmlXPathParserContextPtr ctxt); |
| |
| xmlXPathObjectPtr valuePop (xmlXPathParserContextPtr ctxt); |
| int valuePush (xmlXPathParserContextPtr ctxt, |
| xmlXPathObjectPtr value); |
| |
| xmlXPathObjectPtr xmlXPathNewString (const xmlChar *val); |
| xmlXPathObjectPtr xmlXPathNewNodeSet (xmlNodePtr val); |
| void xmlXPathNodeSetAdd (xmlNodeSetPtr cur, |
| xmlNodePtr val); |
| |
| |
| void xmlXPathIdFunction (xmlXPathParserContextPtr ctxt, |
| int nargs); |
| void xmlXPathRoot (xmlXPathParserContextPtr ctxt); |
| void xmlXPathEvalExpr (xmlXPathParserContextPtr ctxt); |
| xmlChar * xmlXPathParseName (xmlXPathParserContextPtr ctxt); |
| |
| /************************************************************************ |
| * * |
| * Public API * |
| * * |
| ************************************************************************/ |
| |
| /** |
| * Extending a context |
| */ |
| int xmlXPathRegisterFunc (xmlXPathContextPtr ctxt, |
| const xmlChar *name, |
| xmlXPathFunction f); |
| int xmlXPathRegisterVariable (xmlXPathContextPtr ctxt, |
| const xmlChar *name, |
| xmlXPathObjectPtr value); |
| |
| /** |
| * Evaluation functions. |
| */ |
| void xmlXPathInit (void); |
| xmlXPathContextPtr xmlXPathNewContext (xmlDocPtr doc); |
| void xmlXPathFreeContext (xmlXPathContextPtr ctxt); |
| xmlXPathObjectPtr xmlXPathEval (const xmlChar *str, |
| xmlXPathContextPtr ctxt); |
| xmlXPathObjectPtr xmlXPathEvalXPtrExpr (const xmlChar *str, |
| xmlXPathContextPtr ctxt); |
| void xmlXPathFreeObject (xmlXPathObjectPtr obj); |
| xmlXPathObjectPtr xmlXPathEvalExpression (const xmlChar *str, |
| xmlXPathContextPtr ctxt); |
| xmlNodeSetPtr xmlXPathNodeSetCreate (xmlNodePtr val); |
| void xmlXPathFreeNodeSetList (xmlXPathObjectPtr obj); |
| void xmlXPathFreeNodeSet (xmlNodeSetPtr obj); |
| xmlXPathObjectPtr xmlXPathObjectCopy (xmlXPathObjectPtr val); |
| |
| |
| #ifdef __cplusplus |
| } |
| #endif |
| #endif /* ! __XML_XPATH_H__ */ |