include/reactos/libs/libxml/xpath.h

   1 /*
   2  * Summary: XML Path Language implementation
   3  * Description: API for the XML Path Language implementation
   4  *
   5  * XML Path Language implementation
   6  * XPath is a language for addressing parts of an XML document,
   7  * designed to be used by both XSLT and XPointer
   8  *     http://www.w3.org/TR/xpath
   9  *
  10  * Implements
  11  * W3C Recommendation 16 November 1999
  12  *     http://www.w3.org/TR/1999/REC-xpath-19991116
  13  *
  14  * Copy: See Copyright for the status of this software.
  15  *
  16  * Author: Daniel Veillard
  17  */
  18
  19 #ifndef __XML_XPATH_H__
  20 #define __XML_XPATH_H__
  21
  22 #include <libxml/xmlversion.h>
  23
  24 #ifdef LIBXML_XPATH_ENABLED
  25
  26 #include <libxml/xmlerror.h>
  27 #include <libxml/tree.h>
  28 #include <libxml/hash.h>
  29 #endif /* LIBXML_XPATH_ENABLED */
  30
  31 #if defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
  32 #ifdef __cplusplus
  33 extern "C" {
  34 #endif
  35 #endif /* LIBXML_XPATH_ENABLED or LIBXML_SCHEMAS_ENABLED */
  36
  37 #ifdef LIBXML_XPATH_ENABLED
  38
  39 typedef struct _xmlXPathContext xmlXPathContext;
  40 typedef xmlXPathContext *xmlXPathContextPtr;
  41 typedef struct _xmlXPathParserContext xmlXPathParserContext;
  42 typedef xmlXPathParserContext *xmlXPathParserContextPtr;
  43
  44 /**
  45  * The set of XPath error codes.
  46  */
  47
  48 typedef enum {
  49     XPATH_EXPRESSION_OK = 0,
  50     XPATH_NUMBER_ERROR,
  51     XPATH_UNFINISHED_LITERAL_ERROR,
  52     XPATH_START_LITERAL_ERROR,
  53     XPATH_VARIABLE_REF_ERROR,
  54     XPATH_UNDEF_VARIABLE_ERROR,
  55     XPATH_INVALID_PREDICATE_ERROR,
  56     XPATH_EXPR_ERROR,
  57     XPATH_UNCLOSED_ERROR,
  58     XPATH_UNKNOWN_FUNC_ERROR,
  59     XPATH_INVALID_OPERAND,
  60     XPATH_INVALID_TYPE,
  61     XPATH_INVALID_ARITY,
  62     XPATH_INVALID_CTXT_SIZE,
  63     XPATH_INVALID_CTXT_POSITION,
  64     XPATH_MEMORY_ERROR,
  65     XPTR_SYNTAX_ERROR,
  66     XPTR_RESOURCE_ERROR,
  67     XPTR_SUB_RESOURCE_ERROR,
  68     XPATH_UNDEF_PREFIX_ERROR,
  69     XPATH_ENCODING_ERROR,
  70     XPATH_INVALID_CHAR_ERROR,
  71     XPATH_INVALID_CTXT,
  72     XPATH_STACK_ERROR,
  73     XPATH_FORBID_VARIABLE_ERROR
  74 } xmlXPathError;
  75
  76 /*
  77  * A node-set (an unordered collection of nodes without duplicates).
  78  */
  79 typedef struct _xmlNodeSet xmlNodeSet;
  80 typedef xmlNodeSet *xmlNodeSetPtr;
  81 struct _xmlNodeSet {
  82     int nodeNr;                 /* number of nodes in the set */
  83     int nodeMax;                /* size of the array as allocated */
  84     xmlNodePtr *nodeTab;        /* array of nodes in no particular order */
  85     /* @@ with_ns to check wether namespace nodes should be looked at @@ */
  86 };
  87
  88 /*
  89  * An expression is evaluated to yield an object, which
  90  * has one of the following four basic types:
  91  *   - node-set
  92  *   - boolean
  93  *   - number
  94  *   - string
  95  *
  96  * @@ XPointer will add more types !
  97  */
  98
  99 typedef enum {
 100     XPATH_UNDEFINED = 0,
 101     XPATH_NODESET = 1,
 102     XPATH_BOOLEAN = 2,
 103     XPATH_NUMBER = 3,
 104     XPATH_STRING = 4,
 105     XPATH_POINT = 5,
 106     XPATH_RANGE = 6,
 107     XPATH_LOCATIONSET = 7,
 108     XPATH_USERS = 8,
 109     XPATH_XSLT_TREE = 9  /* An XSLT value tree, non modifiable */
 110 } xmlXPathObjectType;
 111
 112 typedef struct _xmlXPathObject xmlXPathObject;
 113 typedef xmlXPathObject *xmlXPathObjectPtr;
 114 struct _xmlXPathObject {
 115     xmlXPathObjectType type;
 116     xmlNodeSetPtr nodesetval;
 117     int boolval;
 118     double floatval;
 119     xmlChar *stringval;
 120     void *user;
 121     int index;
 122     void *user2;
 123     int index2;
 124 };
 125
 126 /**
 127  * xmlXPathConvertFunc:
 128  * @obj:  an XPath object
 129  * @type:  the number of the target type
 130  *
 131  * A conversion function is associated to a type and used to cast
 132  * the new type to primitive values.
 133  *
 134  * Returns -1 in case of error, 0 otherwise
 135  */
 136 typedef int (*xmlXPathConvertFunc) (xmlXPathObjectPtr obj, int type);
 137
 138 /*
 139  * Extra type: a name and a conversion function.
 140  */
 141
 142 typedef struct _xmlXPathType xmlXPathType;
 143 typedef xmlXPathType *xmlXPathTypePtr;
 144 struct _xmlXPathType {
 145     const xmlChar         *name;                /* the type name */
 146     xmlXPathConvertFunc func;           /* the conversion function */
 147 };
 148
 149 /*
 150  * Extra variable: a name and a value.
 151  */
 152
 153 typedef struct _xmlXPathVariable xmlXPathVariable;
 154 typedef xmlXPathVariable *xmlXPathVariablePtr;
 155 struct _xmlXPathVariable {
 156     const xmlChar       *name;          /* the variable name */
 157     xmlXPathObjectPtr value;            /* the value */
 158 };
 159
 160 /**
 161  * xmlXPathEvalFunc:
 162  * @ctxt: an XPath parser context
 163  * @nargs: the number of arguments passed to the function
 164  *
 165  * An XPath evaluation function, the parameters are on the XPath context stack.
 166  */
 167
 168 typedef void (*xmlXPathEvalFunc)(xmlXPathParserContextPtr ctxt,
 169                                  int nargs);
 170
 171 /*
 172  * Extra function: a name and a evaluation function.
 173  */
 174
 175 typedef struct _xmlXPathFunct xmlXPathFunct;
 176 typedef xmlXPathFunct *xmlXPathFuncPtr;
 177 struct _xmlXPathFunct {
 178     const xmlChar      *name;           /* the function name */
 179     xmlXPathEvalFunc func;              /* the evaluation function */
 180 };
 181
 182 /**
 183  * xmlXPathAxisFunc:
 184  * @ctxt:  the XPath interpreter context
 185  * @cur:  the previous node being explored on that axis
 186  *
 187  * An axis traversal function. To traverse an axis, the engine calls
 188  * the first time with cur == NULL and repeat until the function returns
 189  * NULL indicating the end of the axis traversal.
 190  *
 191  * Returns the next node in that axis or NULL if at the end of the axis.
 192  */
 193
 194 typedef xmlXPathObjectPtr (*xmlXPathAxisFunc) (xmlXPathParserContextPtr ctxt,
 195                                  xmlXPathObjectPtr cur);
 196
 197 /*
 198  * Extra axis: a name and an axis function.
 199  */
 200
 201 typedef struct _xmlXPathAxis xmlXPathAxis;
 202 typedef xmlXPathAxis *xmlXPathAxisPtr;
 203 struct _xmlXPathAxis {
 204     const xmlChar      *name;           /* the axis name */
 205     xmlXPathAxisFunc func;              /* the search function */
 206 };
 207
 208 /**
 209  * xmlXPathFunction:
 210  * @ctxt:  the XPath interprestation context
 211  * @nargs:  the number of arguments
 212  *
 213  * An XPath function.
 214  * The arguments (if any) are popped out from the context stack
 215  * and the result is pushed on the stack.
 216  */
 217
 218 typedef void (*xmlXPathFunction) (xmlXPathParserContextPtr ctxt, int nargs);
 219
 220 /*
 221  * Function and Variable Lookup.
 222  */
 223
 224 /**
 225  * xmlXPathVariableLookupFunc:
 226  * @ctxt:  an XPath context
 227  * @name:  name of the variable
 228  * @ns_uri:  the namespace name hosting this variable
 229  *
 230  * Prototype for callbacks used to plug variable lookup in the XPath
 231  * engine.
 232  *
 233  * Returns the XPath object value or NULL if not found.
 234  */
 235 typedef xmlXPathObjectPtr (*xmlXPathVariableLookupFunc) (void *ctxt,
 236                                          const xmlChar *name,
 237                                          const xmlChar *ns_uri);
 238
 239 /**
 240  * xmlXPathFuncLookupFunc:
 241  * @ctxt:  an XPath context
 242  * @name:  name of the function
 243  * @ns_uri:  the namespace name hosting this function
 244  *
 245  * Prototype for callbacks used to plug function lookup in the XPath
 246  * engine.
 247  *
 248  * Returns the XPath function or NULL if not found.
 249  */
 250 typedef xmlXPathFunction (*xmlXPathFuncLookupFunc) (void *ctxt,
 251                                          const xmlChar *name,
 252                                          const xmlChar *ns_uri);
 253
 254 /**
 255  * xmlXPathFlags:
 256  * Flags for XPath engine compilation and runtime
 257  */
 258 /**
 259  * XML_XPATH_CHECKNS:
 260  *
 261  * check namespaces at compilation
 262  */
 263 #define XML_XPATH_CHECKNS (1<<0)
 264 /**
 265  * XML_XPATH_NOVAR:
 266  *
 267  * forbid variables in expression
 268  */
 269 #define XML_XPATH_NOVAR   (1<<1)
 270
 271 /**
 272  * xmlXPathContext:
 273  *
 274  * Expression evaluation occurs with respect to a context.
 275  * he context consists of:
 276  *    - a node (the context node)
 277  *    - a node list (the context node list)
 278  *    - a set of variable bindings
 279  *    - a function library
 280  *    - the set of namespace declarations in scope for the expression
 281  * Following the switch to hash tables, this need to be trimmed up at
 282  * the next binary incompatible release.
 283  * The node may be modified when the context is passed to libxml2
 284  * for an XPath evaluation so you may need to initialize it again
 285  * before the next call.
 286  */
 287
 288 struct _xmlXPathContext {
 289     xmlDocPtr doc;                      /* The current document */
 290     xmlNodePtr node;                    /* The current node */
 291
 292     int nb_variables_unused;            /* unused (hash table) */
 293     int max_variables_unused;           /* unused (hash table) */
 294     xmlHashTablePtr varHash;            /* Hash table of defined variables */
 295
 296     int nb_types;                       /* number of defined types */
 297     int max_types;                      /* max number of types */
 298     xmlXPathTypePtr types;              /* Array of defined types */
 299
 300     int nb_funcs_unused;                /* unused (hash table) */
 301     int max_funcs_unused;               /* unused (hash table) */
 302     xmlHashTablePtr funcHash;           /* Hash table of defined funcs */
 303
 304     int nb_axis;                        /* number of defined axis */
 305     int max_axis;                       /* max number of axis */
 306     xmlXPathAxisPtr axis;               /* Array of defined axis */
 307
 308     /* the namespace nodes of the context node */
 309     xmlNsPtr *namespaces;               /* Array of namespaces */
 310     int nsNr;                           /* number of namespace in scope */
 311     void *user;                         /* function to free */
 312
 313     /* extra variables */
 314     int contextSize;                    /* the context size */
 315     int proximityPosition;              /* the proximity position */
 316
 317     /* extra stuff for XPointer */
 318     int xptr;                           /* is this an XPointer context? */
 319     xmlNodePtr here;                    /* for here() */
 320     xmlNodePtr origin;                  /* for origin() */
 321
 322     /* the set of namespace declarations in scope for the expression */
 323     xmlHashTablePtr nsHash;             /* The namespaces hash table */
 324     xmlXPathVariableLookupFunc varLookupFunc;/* variable lookup func */
 325     void *varLookupData;                /* variable lookup data */
 326
 327     /* Possibility to link in an extra item */
 328     void *extra;                        /* needed for XSLT */
 329
 330     /* The function name and URI when calling a function */
 331     const xmlChar *function;
 332     const xmlChar *functionURI;
 333
 334     /* function lookup function and data */
 335     xmlXPathFuncLookupFunc funcLookupFunc;/* function lookup func */
 336     void *funcLookupData;               /* function lookup data */
 337
 338     /* temporary namespace lists kept for walking the namespace axis */
 339     xmlNsPtr *tmpNsList;                /* Array of namespaces */
 340     int tmpNsNr;                        /* number of namespaces in scope */
 341
 342     /* error reporting mechanism */
 343     void *userData;                     /* user specific data block */
 344     xmlStructuredErrorFunc error;       /* the callback in case of errors */
 345     xmlError lastError;                 /* the last error */
 346     xmlNodePtr debugNode;               /* the source node XSLT */
 347
 348     /* dictionary */
 349     xmlDictPtr dict;                    /* dictionary if any */
 350
 351     int flags;                          /* flags to control compilation */
 352
 353     /* Cache for reusal of XPath objects */
 354     void *cache;
 355 };
 356
 357 /*
 358  * The structure of a compiled expression form is not public.
 359  */
 360
 361 typedef struct _xmlXPathCompExpr xmlXPathCompExpr;
 362 typedef xmlXPathCompExpr *xmlXPathCompExprPtr;
 363
 364 /**
 365  * xmlXPathParserContext:
 366  *
 367  * An XPath parser context. It contains pure parsing informations,
 368  * an xmlXPathContext, and the stack of objects.
 369  */
 370 struct _xmlXPathParserContext {
 371     const xmlChar *cur;                 /* the current char being parsed */
 372     const xmlChar *base;                        /* the full expression */
 373
 374     int error;                          /* error code */
 375
 376     xmlXPathContextPtr  context;        /* the evaluation context */
 377     xmlXPathObjectPtr     value;        /* the current value */
 378     int                 valueNr;        /* number of values stacked */
 379     int                valueMax;        /* max number of values stacked */
 380     xmlXPathObjectPtr *valueTab;        /* stack of values */
 381
 382     xmlXPathCompExprPtr comp;           /* the precompiled expression */
 383     int xptr;                           /* it this an XPointer expression */
 384     xmlNodePtr         ancestor;        /* used for walking preceding axis */
 385
 386     int              valueFrame;        /* used to limit Pop on the stack */
 387 };
 388
 389 /************************************************************************
 390  *                                                                      *
 391  *                      Public API                                      *
 392  *                                                                      *
 393  ************************************************************************/
 394
 395 /**
 396  * Objects and Nodesets handling
 397  */
 398
 399 XMLPUBVAR double xmlXPathNAN;
 400 XMLPUBVAR double xmlXPathPINF;
 401 XMLPUBVAR double xmlXPathNINF;
 402
 403 /* These macros may later turn into functions */
 404 /**
 405  * xmlXPathNodeSetGetLength:
 406  * @ns:  a node-set
 407  *
 408  * Implement a functionality similar to the DOM NodeList.length.
 409  *
 410  * Returns the number of nodes in the node-set.
 411  */
 412 #define xmlXPathNodeSetGetLength(ns) ((ns) ? (ns)->nodeNr : 0)
 413 /**
 414  * xmlXPathNodeSetItem:
 415  * @ns:  a node-set
 416  * @index:  index of a node in the set
 417  *
 418  * Implements a functionality similar to the DOM NodeList.item().
 419  *
 420  * Returns the xmlNodePtr at the given @index in @ns or NULL if
 421  *         @index is out of range (0 to length-1)
 422  */
 423 #define xmlXPathNodeSetItem(ns, index)                          \
 424                 ((((ns) != NULL) &&                             \
 425                   ((index) >= 0) && ((index) < (ns)->nodeNr)) ? \
 426                  (ns)->nodeTab[(index)]                         \
 427                  : NULL)
 428 /**
 429  * xmlXPathNodeSetIsEmpty:
 430  * @ns: a node-set
 431  *
 432  * Checks whether @ns is empty or not.
 433  *
 434  * Returns %TRUE if @ns is an empty node-set.
 435  */
 436 #define xmlXPathNodeSetIsEmpty(ns)                                      \
 437     (((ns) == NULL) || ((ns)->nodeNr == 0) || ((ns)->nodeTab == NULL))
 438
 439
 440 XMLPUBFUN void XMLCALL
 441                     xmlXPathFreeObject          (xmlXPathObjectPtr obj);
 442 XMLPUBFUN xmlNodeSetPtr XMLCALL
 443                     xmlXPathNodeSetCreate       (xmlNodePtr val);
 444 XMLPUBFUN void XMLCALL
 445                     xmlXPathFreeNodeSetList     (xmlXPathObjectPtr obj);
 446 XMLPUBFUN void XMLCALL
 447                     xmlXPathFreeNodeSet         (xmlNodeSetPtr obj);
 448 XMLPUBFUN xmlXPathObjectPtr XMLCALL
 449                     xmlXPathObjectCopy          (xmlXPathObjectPtr val);
 450 XMLPUBFUN int XMLCALL
 451                     xmlXPathCmpNodes            (xmlNodePtr node1,
 452                                                  xmlNodePtr node2);
 453 /**
 454  * Conversion functions to basic types.
 455  */
 456 XMLPUBFUN int XMLCALL
 457                     xmlXPathCastNumberToBoolean (double val);
 458 XMLPUBFUN int XMLCALL
 459                     xmlXPathCastStringToBoolean (const xmlChar * val);
 460 XMLPUBFUN int XMLCALL
 461                     xmlXPathCastNodeSetToBoolean(xmlNodeSetPtr ns);
 462 XMLPUBFUN int XMLCALL
 463                     xmlXPathCastToBoolean       (xmlXPathObjectPtr val);
 464
 465 XMLPUBFUN double XMLCALL
 466                     xmlXPathCastBooleanToNumber (int val);
 467 XMLPUBFUN double XMLCALL
 468                     xmlXPathCastStringToNumber  (const xmlChar * val);
 469 XMLPUBFUN double XMLCALL
 470                     xmlXPathCastNodeToNumber    (xmlNodePtr node);
 471 XMLPUBFUN double XMLCALL
 472                     xmlXPathCastNodeSetToNumber (xmlNodeSetPtr ns);
 473 XMLPUBFUN double XMLCALL
 474                     xmlXPathCastToNumber        (xmlXPathObjectPtr val);
 475
 476 XMLPUBFUN xmlChar * XMLCALL
 477                     xmlXPathCastBooleanToString (int val);
 478 XMLPUBFUN xmlChar * XMLCALL
 479                     xmlXPathCastNumberToString  (double val);
 480 XMLPUBFUN xmlChar * XMLCALL
 481                     xmlXPathCastNodeToString    (xmlNodePtr node);
 482 XMLPUBFUN xmlChar * XMLCALL
 483                     xmlXPathCastNodeSetToString (xmlNodeSetPtr ns);
 484 XMLPUBFUN xmlChar * XMLCALL
 485                     xmlXPathCastToString        (xmlXPathObjectPtr val);
 486
 487 XMLPUBFUN xmlXPathObjectPtr XMLCALL
 488                     xmlXPathConvertBoolean      (xmlXPathObjectPtr val);
 489 XMLPUBFUN xmlXPathObjectPtr XMLCALL
 490                     xmlXPathConvertNumber       (xmlXPathObjectPtr val);
 491 XMLPUBFUN xmlXPathObjectPtr XMLCALL
 492                     xmlXPathConvertString       (xmlXPathObjectPtr val);
 493
 494 /**
 495  * Context handling.
 496  */
 497 XMLPUBFUN xmlXPathContextPtr XMLCALL
 498                     xmlXPathNewContext          (xmlDocPtr doc);
 499 XMLPUBFUN void XMLCALL
 500                     xmlXPathFreeContext         (xmlXPathContextPtr ctxt);
 501 XMLPUBFUN int XMLCALL
 502                     xmlXPathContextSetCache(xmlXPathContextPtr ctxt,
 503                                             int active,
 504                                             int value,
 505                                             int options);
 506 /**
 507  * Evaluation functions.
 508  */
 509 XMLPUBFUN long XMLCALL
 510                     xmlXPathOrderDocElems       (xmlDocPtr doc);
 511 XMLPUBFUN xmlXPathObjectPtr XMLCALL
 512                     xmlXPathEval                (const xmlChar *str,
 513                                                  xmlXPathContextPtr ctx);
 514 XMLPUBFUN xmlXPathObjectPtr XMLCALL
 515                     xmlXPathEvalExpression      (const xmlChar *str,
 516                                                  xmlXPathContextPtr ctxt);
 517 XMLPUBFUN int XMLCALL
 518                     xmlXPathEvalPredicate       (xmlXPathContextPtr ctxt,
 519                                                  xmlXPathObjectPtr res);
 520 /**
 521  * Separate compilation/evaluation entry points.
 522  */
 523 XMLPUBFUN xmlXPathCompExprPtr XMLCALL
 524                     xmlXPathCompile             (const xmlChar *str);
 525 XMLPUBFUN xmlXPathCompExprPtr XMLCALL
 526                     xmlXPathCtxtCompile         (xmlXPathContextPtr ctxt,
 527                                                  const xmlChar *str);
 528 XMLPUBFUN xmlXPathObjectPtr XMLCALL
 529                     xmlXPathCompiledEval        (xmlXPathCompExprPtr comp,
 530                                                  xmlXPathContextPtr ctx);
 531 XMLPUBFUN int XMLCALL
 532                     xmlXPathCompiledEvalToBoolean(xmlXPathCompExprPtr comp,
 533                                                  xmlXPathContextPtr ctxt);
 534 XMLPUBFUN void XMLCALL
 535                     xmlXPathFreeCompExpr        (xmlXPathCompExprPtr comp);
 536 #endif /* LIBXML_XPATH_ENABLED */
 537 #if defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
 538 XMLPUBFUN void XMLCALL
 539                     xmlXPathInit                (void);
 540 XMLPUBFUN int XMLCALL
 541                 xmlXPathIsNaN   (double val);
 542 XMLPUBFUN int XMLCALL
 543                 xmlXPathIsInf   (double val);
 544
 545 #ifdef __cplusplus
 546 }
 547 #endif
 548
 549 #endif /* LIBXML_XPATH_ENABLED or LIBXML_SCHEMAS_ENABLED*/
 550 #endif /* ! __XML_XPATH_H__ */