libxml2/include/libxml/xpathInternals.h

   1 /*
   2  * xpathInternals.c: internal interfaces for XML Path Language implementation
   3  *                   used to build new modules on top of XPath
   4  *
   5  * See COPYRIGHT for the status of this software
   6  *
   7  * Author: daniel@veillard.com
   8  */
   9
  10 #ifndef __XML_XPATH_INTERNALS_H__
  11 #define __XML_XPATH_INTERNALS_H__
  12
  13 #include <libxml/xmlversion.h>
  14 #include <libxml/xpath.h>
  15
  16 #ifdef __cplusplus
  17 extern "C" {
  18 #endif
  19
  20 /************************************************************************
  21  *                                                                      *
  22  *                      Helpers                                         *
  23  *                                                                      *
  24  ************************************************************************/
  25
  26 /**
  27  * Many of these macros may later turn into functions. They
  28  * shouldn't be used in #ifdef's preprocessor instructions.
  29  */
  30 /**
  31  * xmlXPathSetError:
  32  * @ctxt:  an XPath parser context
  33  * @err:  an xmlXPathError code
  34  *
  35  * Raises an error.
  36  */
  37 #define xmlXPathSetError(ctxt, err)                                     \
  38     { xmlXPatherror((ctxt), __FILE__, __LINE__, (err));                 \
  39       (ctxt)->error = (err); }
  40
  41 /**
  42  * xmlXPathSetArityError:
  43  * @ctxt:  an XPath parser context
  44  *
  45  * Raises an XPATH_INVALID_ARITY error.
  46  */
  47 #define xmlXPathSetArityError(ctxt)                                     \
  48     xmlXPathSetError((ctxt), XPATH_INVALID_ARITY)
  49
  50 /**
  51  * xmlXPathSetTypeError:
  52  * @ctxt:  an XPath parser context
  53  *
  54  * Raises an XPATH_INVALID_TYPE error.
  55  */
  56 #define xmlXPathSetTypeError(ctxt)                                      \
  57     xmlXPathSetError((ctxt), XPATH_INVALID_TYPE)
  58
  59 /**
  60  * xmlXPathGetError:
  61  * @ctxt:  an XPath parser context
  62  *
  63  * Get the error code of an XPath context.
  64  *
  65  * Returns the context error.
  66  */
  67 #define xmlXPathGetError(ctxt)    ((ctxt)->error)
  68
  69 /**
  70  * xmlXPathCheckError:
  71  * @ctxt:  an XPath parser context
  72  *
  73  * Check if an XPath error was raised.
  74  *
  75  * Returns true if an error has been raised, false otherwise.
  76  */
  77 #define xmlXPathCheckError(ctxt)  ((ctxt)->error != XPATH_EXPRESSION_OK)
  78
  79 /**
  80  * xmlXPathGetDocument:
  81  * @ctxt:  an XPath parser context
  82  *
  83  * Get the document of an XPath context.
  84  *
  85  * Returns the context document.
  86  */
  87 #define xmlXPathGetDocument(ctxt)       ((ctxt)->context->doc)
  88
  89 /**
  90  * xmlXPathGetContextNode:
  91  * @ctxt: an XPath parser context
  92  *
  93  * Get the context node of an XPath context.
  94  *
  95  * Returns the context node.
  96  */
  97 #define xmlXPathGetContextNode(ctxt)    ((ctxt)->context->node)
  98
  99 int             xmlXPathPopBoolean      (xmlXPathParserContextPtr ctxt);
 100 double          xmlXPathPopNumber       (xmlXPathParserContextPtr ctxt);
 101 xmlChar *       xmlXPathPopString       (xmlXPathParserContextPtr ctxt);
 102 xmlNodeSetPtr   xmlXPathPopNodeSet      (xmlXPathParserContextPtr ctxt);
 103 void *          xmlXPathPopExternal     (xmlXPathParserContextPtr ctxt);
 104
 105 /**
 106  * xmlXPathReturnBoolean:
 107  * @ctxt:  an XPath parser context
 108  * @val:  a boolean
 109  *
 110  * Pushes the boolean @val on the context stack.
 111  */
 112 #define xmlXPathReturnBoolean(ctxt, val)                                \
 113     valuePush((ctxt), xmlXPathNewBoolean(val))
 114
 115 /**
 116  * xmlXPathReturnTrue:
 117  * @ctxt:  an XPath parser context
 118  *
 119  * Pushes true on the context stack.
 120  */
 121 #define xmlXPathReturnTrue(ctxt)   xmlXPathReturnBoolean((ctxt), 1)
 122
 123 /**
 124  * xmlXPathReturnFalse:
 125  * @ctxt:  an XPath parser context
 126  *
 127  * Pushes false on the context stack.
 128  */
 129 #define xmlXPathReturnFalse(ctxt)  xmlXPathReturnBoolean((ctxt), 0)
 130
 131 /**
 132  * xmlXPathReturnNumber:
 133  * @ctxt:  an XPath parser context
 134  * @val:  a double
 135  *
 136  * Pushes the double @val on the context stack.
 137  */
 138 #define xmlXPathReturnNumber(ctxt, val)                                 \
 139     valuePush((ctxt), xmlXPathNewFloat(val))
 140
 141 /**
 142  * xmlXPathReturnString:
 143  * @ctxt:  an XPath parser context
 144  * @str:  a string
 145  *
 146  * Pushes the string @str on the context stack.
 147  */
 148 #define xmlXPathReturnString(ctxt, str)                                 \
 149     valuePush((ctxt), xmlXPathWrapString(str))
 150
 151 /**
 152  * xmlXPathReturnEmptyString:
 153  * @ctxt:  an XPath parser context
 154  *
 155  * Pushes an empty string on the stack.
 156  */
 157 #define xmlXPathReturnEmptyString(ctxt)                                 \
 158     valuePush((ctxt), xmlXPathNewCString(""))
 159
 160 /**
 161  * xmlXPathReturnNodeSet:
 162  * @ctxt:  an XPath parser context
 163  * @ns:  a node-set
 164  *
 165  * Pushes the node-set @ns on the context stack.
 166  */
 167 #define xmlXPathReturnNodeSet(ctxt, ns)                                 \
 168     valuePush((ctxt), xmlXPathWrapNodeSet(ns))
 169
 170 /**
 171  * xmlXPathReturnEmptyNodeSet:
 172  * @ctxt:  an XPath parser context
 173  *
 174  * Pushes an empty node-set on the context stack.
 175  */
 176 #define xmlXPathReturnEmptyNodeSet(ctxt)                                \
 177     valuePush((ctxt), xmlXPathNewNodeSet(NULL))
 178
 179 /**
 180  * xmlXPathReturnExternal:
 181  * @ctxt:  an XPath parser context
 182  * @val:  user data
 183  *
 184  * Pushes user data on the context stack.
 185  */
 186 #define xmlXPathReturnExternal(ctxt, val)                               \
 187     valuePush((ctxt), xmlXPathWrapExternal(val))
 188
 189 /**
 190  * xmlXPathStackIsNodeSet:
 191  * @ctxt: an XPath parser context
 192  *
 193  * Check if the current value on the XPath stack is a node set or
 194  * an XSLT value tree.
 195  *
 196  * Returns true if the current object on the stack is a node-set.
 197  */
 198 #define xmlXPathStackIsNodeSet(ctxt)                                    \
 199     (((ctxt)->value != NULL)                                            \
 200      && (((ctxt)->value->type == XPATH_NODESET)                         \
 201          || ((ctxt)->value->type == XPATH_XSLT_TREE)))
 202
 203 /**
 204  * xmlXPathStackIsExternal:
 205  * @ctxt: an XPath parser context
 206  *
 207  * Checks if the current value on the XPath stack is an external
 208  * object.
 209  *
 210  * Returns true if the current object on the stack is an external
 211  * object.
 212  */
 213 #define xmlXPathStackIsExternal(ctxt)                                   \
 214         ((ctxt->value != NULL) && (ctxt->value->type == XPATH_USERS))
 215
 216 /**
 217  * xmlXPathEmptyNodeSet:
 218  * @ns:  a node-set
 219  *
 220  * Empties a node-set.
 221  */
 222 #define xmlXPathEmptyNodeSet(ns)                                        \
 223     { while ((ns)->nodeNr > 0) (ns)->nodeTab[(ns)->nodeNr--] = NULL; }
 224
 225 /**
 226  * CHECK_ERROR:
 227  *
 228  * Macro to return from the function if an XPath error was detected.
 229  */
 230 #define CHECK_ERROR                                                     \
 231     if (ctxt->error != XPATH_EXPRESSION_OK) return
 232
 233 /**
 234  * CHECK_ERROR0:
 235  *
 236  * Macro to return 0 from the function if an XPath error was detected.
 237  */
 238 #define CHECK_ERROR0                                                    \
 239     if (ctxt->error != XPATH_EXPRESSION_OK) return(0)
 240
 241 /**
 242  * XP_ERROR:
 243  * @X:  the error code
 244  *
 245  * Macro to raise an XPath error and return.
 246  */
 247 #define XP_ERROR(X)                                                     \
 248     { xmlXPatherror(ctxt, __FILE__, __LINE__, X);                       \
 249       ctxt->error = (X); return; }
 250
 251 /**
 252  * XP_ERROR0:
 253  * @X:  the error code
 254  *
 255  * Macro to raise an XPath error and return 0.
 256  */
 257 #define XP_ERROR0(X)                                                    \
 258     { xmlXPatherror(ctxt, __FILE__, __LINE__, X);                       \
 259       ctxt->error = (X); return(0); }
 260
 261 /**
 262  * CHECK_TYPE:
 263  * @typeval:  the XPath type
 264  *
 265  * Macro to check that the value on top of the XPath stack is of a given
 266  * type.
 267  */
 268 #define CHECK_TYPE(typeval)                                             \
 269     if ((ctxt->value == NULL) || (ctxt->value->type != typeval))        \
 270         XP_ERROR(XPATH_INVALID_TYPE)
 271
 272 /**
 273  * CHECK_TYPE0:
 274  * @typeval:  the XPath type
 275  *
 276  * Macro to check that the value on top of the XPath stack is of a given
 277  * type. Return(0) in case of failure
 278  */
 279 #define CHECK_TYPE0(typeval)                                            \
 280     if ((ctxt->value == NULL) || (ctxt->value->type != typeval))        \
 281         XP_ERROR0(XPATH_INVALID_TYPE)
 282
 283 /**
 284  * CHECK_ARITY:
 285  * @x:  the number of expected args
 286  *
 287  * Macro to check that the number of args passed to an XPath function matches.
 288  */
 289 #define CHECK_ARITY(x)                                                  \
 290     if (nargs != (x))                                                   \
 291         XP_ERROR(XPATH_INVALID_ARITY);
 292
 293 /**
 294  * CAST_TO_STRING:
 295  *
 296  * Macro to try to cast the value on the top of the XPath stack to a string.
 297  */
 298 #define CAST_TO_STRING                                                  \
 299     if ((ctxt->value != NULL) && (ctxt->value->type != XPATH_STRING))   \
 300         xmlXPathStringFunction(ctxt, 1);
 301
 302 /**
 303  * CAST_TO_NUMBER:
 304  *
 305  * Macro to try to cast the value on the top of the XPath stack to a number.
 306  */
 307 #define CAST_TO_NUMBER                                                  \
 308     if ((ctxt->value != NULL) && (ctxt->value->type != XPATH_NUMBER))   \
 309         xmlXPathNumberFunction(ctxt, 1);
 310
 311 /**
 312  * CAST_TO_BOOLEAN:
 313  *
 314  * Macro to try to cast the value on the top of the XPath stack to a boolean.
 315  */
 316 #define CAST_TO_BOOLEAN                                                 \
 317     if ((ctxt->value != NULL) && (ctxt->value->type != XPATH_BOOLEAN))  \
 318         xmlXPathBooleanFunction(ctxt, 1);
 319
 320 /*
 321  * Variable Lookup forwarding.
 322  */
 323 /**
 324  * xmlXPathVariableLookupFunc:
 325  * @ctxt:  an XPath context
 326  * @name:  name of the variable
 327  * @ns_uri:  the namespace name hosting this variable
 328  *
 329  * Prototype for callbacks used to plug variable lookup in the XPath
 330  * engine.
 331  *
 332  * Returns the XPath object value or NULL if not found.
 333  */
 334 typedef xmlXPathObjectPtr (*xmlXPathVariableLookupFunc) (void *ctxt,
 335                                          const xmlChar *name,
 336                                          const xmlChar *ns_uri);
 337
 338 void    xmlXPathRegisterVariableLookup  (xmlXPathContextPtr ctxt,
 339                                          xmlXPathVariableLookupFunc f,
 340                                          void *data);
 341
 342 /*
 343  * Function Lookup forwarding.
 344  */
 345 /**
 346  * xmlXPathFuncLookupFunc:
 347  * @ctxt:  an XPath context
 348  * @name:  name of the function
 349  * @ns_uri:  the namespace name hosting this function
 350  *
 351  * Prototype for callbacks used to plug function lookup in the XPath
 352  * engine.
 353  *
 354  * Returns the XPath function or NULL if not found.
 355  */
 356 typedef xmlXPathFunction (*xmlXPathFuncLookupFunc) (void *ctxt,
 357                                          const xmlChar *name,
 358                                          const xmlChar *ns_uri);
 359
 360 void    xmlXPathRegisterFuncLookup      (xmlXPathContextPtr ctxt,
 361                                          xmlXPathFuncLookupFunc f,
 362                                          void *funcCtxt);
 363
 364 /*
 365  * Error reporting.
 366  */
 367 void            xmlXPatherror   (xmlXPathParserContextPtr ctxt,
 368                                  const char *file,
 369                                  int line,
 370                                  int no);
 371
 372 void            xmlXPathDebugDumpObject (FILE *output,
 373                                          xmlXPathObjectPtr cur,
 374                                          int depth);
 375 void            xmlXPathDebugDumpCompExpr(FILE *output,
 376                                          xmlXPathCompExprPtr comp,
 377                                          int depth);
 378
 379 /**
 380  * NodeSet handling.
 381  */
 382 int             xmlXPathNodeSetContains         (xmlNodeSetPtr cur,
 383                                                  xmlNodePtr val);
 384 xmlNodeSetPtr   xmlXPathDifference              (xmlNodeSetPtr nodes1,
 385                                                  xmlNodeSetPtr nodes2);
 386 xmlNodeSetPtr   xmlXPathIntersection            (xmlNodeSetPtr nodes1,
 387                                                  xmlNodeSetPtr nodes2);
 388
 389 xmlNodeSetPtr   xmlXPathDistinctSorted          (xmlNodeSetPtr nodes);
 390 xmlNodeSetPtr   xmlXPathDistinct                (xmlNodeSetPtr nodes);
 391
 392 int             xmlXPathHasSameNodes            (xmlNodeSetPtr nodes1,
 393                                                  xmlNodeSetPtr nodes2);
 394
 395 xmlNodeSetPtr   xmlXPathNodeLeadingSorted       (xmlNodeSetPtr nodes,
 396                                                  xmlNodePtr node);
 397 xmlNodeSetPtr   xmlXPathLeadingSorted           (xmlNodeSetPtr nodes1,
 398                                                  xmlNodeSetPtr nodes2);
 399 xmlNodeSetPtr   xmlXPathNodeLeading             (xmlNodeSetPtr nodes,
 400                                                  xmlNodePtr node);
 401 xmlNodeSetPtr   xmlXPathLeading                 (xmlNodeSetPtr nodes1,
 402                                                  xmlNodeSetPtr nodes2);
 403
 404 xmlNodeSetPtr   xmlXPathNodeTrailingSorted      (xmlNodeSetPtr nodes,
 405                                                  xmlNodePtr node);
 406 xmlNodeSetPtr   xmlXPathTrailingSorted          (xmlNodeSetPtr nodes1,
 407                                                  xmlNodeSetPtr nodes2);
 408 xmlNodeSetPtr   xmlXPathNodeTrailing            (xmlNodeSetPtr nodes,
 409                                                  xmlNodePtr node);
 410 xmlNodeSetPtr   xmlXPathTrailing                (xmlNodeSetPtr nodes1,
 411                                                  xmlNodeSetPtr nodes2);
 412
 413
 414 /**
 415  * Extending a context.
 416  */
 417
 418 int                xmlXPathRegisterNs           (xmlXPathContextPtr ctxt,
 419                                                  const xmlChar *prefix,
 420                                                  const xmlChar *ns_uri);
 421 const xmlChar *    xmlXPathNsLookup             (xmlXPathContextPtr ctxt,
 422                                                  const xmlChar *prefix);
 423 void               xmlXPathRegisteredNsCleanup  (xmlXPathContextPtr ctxt);
 424
 425 int                xmlXPathRegisterFunc         (xmlXPathContextPtr ctxt,
 426                                                  const xmlChar *name,
 427                                                  xmlXPathFunction f);
 428 int                xmlXPathRegisterFuncNS       (xmlXPathContextPtr ctxt,
 429                                                  const xmlChar *name,
 430                                                  const xmlChar *ns_uri,
 431                                                  xmlXPathFunction f);
 432 int                xmlXPathRegisterVariable     (xmlXPathContextPtr ctxt,
 433                                                  const xmlChar *name,
 434                                                  xmlXPathObjectPtr value);
 435 int                xmlXPathRegisterVariableNS   (xmlXPathContextPtr ctxt,
 436                                                  const xmlChar *name,
 437                                                  const xmlChar *ns_uri,
 438                                                  xmlXPathObjectPtr value);
 439 xmlXPathFunction   xmlXPathFunctionLookup       (xmlXPathContextPtr ctxt,
 440                                                  const xmlChar *name);
 441 xmlXPathFunction   xmlXPathFunctionLookupNS     (xmlXPathContextPtr ctxt,
 442                                                  const xmlChar *name,
 443                                                  const xmlChar *ns_uri);
 444 void               xmlXPathRegisteredFuncsCleanup(xmlXPathContextPtr ctxt);
 445 xmlXPathObjectPtr  xmlXPathVariableLookup       (xmlXPathContextPtr ctxt,
 446                                                  const xmlChar *name);
 447 xmlXPathObjectPtr  xmlXPathVariableLookupNS     (xmlXPathContextPtr ctxt,
 448                                                  const xmlChar *name,
 449                                                  const xmlChar *ns_uri);
 450 void               xmlXPathRegisteredVariablesCleanup(xmlXPathContextPtr ctxt);
 451
 452 /**
 453  * Utilities to extend XPath.
 454  */
 455 xmlXPathParserContextPtr
 456                   xmlXPathNewParserContext      (const xmlChar *str,
 457                                                  xmlXPathContextPtr ctxt);
 458 void              xmlXPathFreeParserContext     (xmlXPathParserContextPtr ctxt);
 459
 460 /* TODO: remap to xmlXPathValuePop and Push. */
 461 xmlXPathObjectPtr valuePop                      (xmlXPathParserContextPtr ctxt);
 462 int               valuePush                     (xmlXPathParserContextPtr ctxt,
 463                                                 xmlXPathObjectPtr value);
 464
 465 xmlXPathObjectPtr xmlXPathNewString             (const xmlChar *val);
 466 xmlXPathObjectPtr xmlXPathNewCString            (const char *val);
 467 xmlXPathObjectPtr xmlXPathWrapString            (xmlChar *val);
 468 xmlXPathObjectPtr xmlXPathWrapCString           (char * val);
 469 xmlXPathObjectPtr xmlXPathNewFloat              (double val);
 470 xmlXPathObjectPtr xmlXPathNewBoolean            (int val);
 471 xmlXPathObjectPtr xmlXPathNewNodeSet            (xmlNodePtr val);
 472 xmlXPathObjectPtr xmlXPathNewValueTree          (xmlNodePtr val);
 473 void              xmlXPathNodeSetAdd            (xmlNodeSetPtr cur,
 474                                                  xmlNodePtr val);
 475 void              xmlXPathNodeSetAddUnique      (xmlNodeSetPtr cur,
 476                                                  xmlNodePtr val);
 477 void              xmlXPathNodeSetAddNs          (xmlNodeSetPtr cur,
 478                                                  xmlNodePtr node,
 479                                                  xmlNsPtr ns);
 480 void              xmlXPathNodeSetSort           (xmlNodeSetPtr set);
 481
 482 void              xmlXPathRoot                  (xmlXPathParserContextPtr ctxt);
 483 void              xmlXPathEvalExpr              (xmlXPathParserContextPtr ctxt);
 484 xmlChar *         xmlXPathParseName             (xmlXPathParserContextPtr ctxt);
 485 xmlChar *         xmlXPathParseNCName           (xmlXPathParserContextPtr ctxt);
 486
 487 /*
 488  * Existing functions.
 489  */
 490 double xmlXPathStringEvalNumber(const xmlChar *str);
 491 int xmlXPathEvaluatePredicateResult(xmlXPathParserContextPtr ctxt,
 492                                     xmlXPathObjectPtr res);
 493 void xmlXPathRegisterAllFunctions(xmlXPathContextPtr ctxt);
 494 xmlNodeSetPtr xmlXPathNodeSetMerge(xmlNodeSetPtr val1, xmlNodeSetPtr val2);
 495 void xmlXPathNodeSetDel(xmlNodeSetPtr cur, xmlNodePtr val);
 496 void xmlXPathNodeSetRemove(xmlNodeSetPtr cur, int val);
 497 xmlXPathObjectPtr xmlXPathNewNodeSetList(xmlNodeSetPtr val);
 498 xmlXPathObjectPtr xmlXPathWrapNodeSet(xmlNodeSetPtr val);
 499 xmlXPathObjectPtr xmlXPathWrapExternal(void *val);
 500
 501 int xmlXPathEqualValues(xmlXPathParserContextPtr ctxt);
 502 int xmlXPathNotEqualValues(xmlXPathParserContextPtr ctxt);
 503 int xmlXPathCompareValues(xmlXPathParserContextPtr ctxt, int inf, int strict);
 504 void xmlXPathValueFlipSign(xmlXPathParserContextPtr ctxt);
 505 void xmlXPathAddValues(xmlXPathParserContextPtr ctxt);
 506 void xmlXPathSubValues(xmlXPathParserContextPtr ctxt);
 507 void xmlXPathMultValues(xmlXPathParserContextPtr ctxt);
 508 void xmlXPathDivValues(xmlXPathParserContextPtr ctxt);
 509 void xmlXPathModValues(xmlXPathParserContextPtr ctxt);
 510
 511 int xmlXPathIsNodeType(const xmlChar *name);
 512
 513 /*
 514  * Some of the axis navigation routines.
 515  */
 516 xmlNodePtr xmlXPathNextSelf(xmlXPathParserContextPtr ctxt,
 517                         xmlNodePtr cur);
 518 xmlNodePtr xmlXPathNextChild(xmlXPathParserContextPtr ctxt,
 519                         xmlNodePtr cur);
 520 xmlNodePtr xmlXPathNextDescendant(xmlXPathParserContextPtr ctxt,
 521                         xmlNodePtr cur);
 522 xmlNodePtr xmlXPathNextDescendantOrSelf(xmlXPathParserContextPtr ctxt,
 523                         xmlNodePtr cur);
 524 xmlNodePtr xmlXPathNextParent(xmlXPathParserContextPtr ctxt,
 525                         xmlNodePtr cur);
 526 xmlNodePtr xmlXPathNextAncestorOrSelf(xmlXPathParserContextPtr ctxt,
 527                         xmlNodePtr cur);
 528 xmlNodePtr xmlXPathNextFollowingSibling(xmlXPathParserContextPtr ctxt,
 529                         xmlNodePtr cur);
 530 xmlNodePtr xmlXPathNextFollowing(xmlXPathParserContextPtr ctxt,
 531                         xmlNodePtr cur);
 532 xmlNodePtr xmlXPathNextNamespace(xmlXPathParserContextPtr ctxt,
 533                         xmlNodePtr cur);
 534 xmlNodePtr xmlXPathNextAttribute(xmlXPathParserContextPtr ctxt,
 535                         xmlNodePtr cur);
 536 xmlNodePtr xmlXPathNextPreceding(xmlXPathParserContextPtr ctxt,
 537                         xmlNodePtr cur);
 538 xmlNodePtr xmlXPathNextAncestor(xmlXPathParserContextPtr ctxt,
 539                         xmlNodePtr cur);
 540 xmlNodePtr xmlXPathNextPrecedingSibling(xmlXPathParserContextPtr ctxt,
 541                         xmlNodePtr cur);
 542 /*
 543  * The official core of XPath functions.
 544  */
 545 void xmlXPathLastFunction(xmlXPathParserContextPtr ctxt, int nargs);
 546 void xmlXPathPositionFunction(xmlXPathParserContextPtr ctxt, int nargs);
 547 void xmlXPathCountFunction(xmlXPathParserContextPtr ctxt, int nargs);
 548 void xmlXPathIdFunction(xmlXPathParserContextPtr ctxt, int nargs);
 549 void xmlXPathLocalNameFunction(xmlXPathParserContextPtr ctxt, int nargs);
 550 void xmlXPathNamespaceURIFunction(xmlXPathParserContextPtr ctxt, int nargs);
 551 void xmlXPathStringFunction(xmlXPathParserContextPtr ctxt, int nargs);
 552 void xmlXPathStringLengthFunction(xmlXPathParserContextPtr ctxt, int nargs);
 553 void xmlXPathConcatFunction(xmlXPathParserContextPtr ctxt, int nargs);
 554 void xmlXPathContainsFunction(xmlXPathParserContextPtr ctxt, int nargs);
 555 void xmlXPathStartsWithFunction(xmlXPathParserContextPtr ctxt, int nargs);
 556 void xmlXPathSubstringFunction(xmlXPathParserContextPtr ctxt, int nargs);
 557 void xmlXPathSubstringBeforeFunction(xmlXPathParserContextPtr ctxt, int nargs);
 558 void xmlXPathSubstringAfterFunction(xmlXPathParserContextPtr ctxt, int nargs);
 559 void xmlXPathNormalizeFunction(xmlXPathParserContextPtr ctxt, int nargs);
 560 void xmlXPathTranslateFunction(xmlXPathParserContextPtr ctxt, int nargs);
 561 void xmlXPathNotFunction(xmlXPathParserContextPtr ctxt, int nargs);
 562 void xmlXPathTrueFunction(xmlXPathParserContextPtr ctxt, int nargs);
 563 void xmlXPathFalseFunction(xmlXPathParserContextPtr ctxt, int nargs);
 564 void xmlXPathLangFunction(xmlXPathParserContextPtr ctxt, int nargs);
 565 void xmlXPathNumberFunction(xmlXPathParserContextPtr ctxt, int nargs);
 566 void xmlXPathSumFunction(xmlXPathParserContextPtr ctxt, int nargs);
 567 void xmlXPathFloorFunction(xmlXPathParserContextPtr ctxt, int nargs);
 568 void xmlXPathCeilingFunction(xmlXPathParserContextPtr ctxt, int nargs);
 569 void xmlXPathRoundFunction(xmlXPathParserContextPtr ctxt, int nargs);
 570 void xmlXPathBooleanFunction(xmlXPathParserContextPtr ctxt, int nargs);
 571
 572 /**
 573  * Really internal functions
 574  */
 575 void xmlXPathNodeSetFreeNs(xmlNsPtr ns);
 576
 577 #ifdef __cplusplus
 578 }
 579 #endif
 580 #endif /* ! __XML_XPATH_INTERNALS_H__ */