Gnome XML Library Reference Manual
<<< Previous Page | Home | Up | Next Page >>>

# xpathInternals

## Name

xpathInternals --

## Synopsis

    #define     xmlXPathSetError                (ctxt, err)
    #define     xmlXPathSetArityError           (ctxt)
    #define     xmlXPathSetTypeError            (ctxt)
    #define     xmlXPathGetError                (ctxt)
    #define     xmlXPathCheckError              (ctxt)
    #define     xmlXPathGetDocument             (ctxt)
    #define     xmlXPathGetContextNode          (ctxt)
    int         xmlXPathPopBoolean              (xmlXPathParserContextPtr ctxt);
    double      xmlXPathPopNumber               (xmlXPathParserContextPtr ctxt);
    xmlChar*    xmlXPathPopString               (xmlXPathParserContextPtr ctxt);
    xmlNodeSetPtr xmlXPathPopNodeSet            (xmlXPathParserContextPtr ctxt);
    void*       xmlXPathPopExternal             (xmlXPathParserContextPtr ctxt);
    #define     xmlXPathReturnBoolean           (ctxt, val)
    #define     xmlXPathReturnTrue              (ctxt)
    #define     xmlXPathReturnFalse             (ctxt)
    #define     xmlXPathReturnNumber            (ctxt, val)
    #define     xmlXPathReturnString            (ctxt, str)
    #define     xmlXPathReturnEmptyString       (ctxt)
    #define     xmlXPathReturnNodeSet           (ctxt, ns)
    #define     xmlXPathReturnEmptyNodeSet      (ctxt)
    #define     xmlXPathReturnExternal          (ctxt, val)
    #define     xmlXPathStackIsNodeSet          (ctxt)
    #define     xmlXPathStackIsExternal         (ctxt)
    #define     xmlXPathEmptyNodeSet            (ns)
    #define     CHECK_ERROR
    #define     CHECK_ERROR0
    #define     XP_ERROR                        (X)
    #define     XP_ERROR0                       (X)
    #define     CHECK_TYPE                      (typeval)
    #define     CHECK_TYPE0                     (typeval)
    #define     CHECK_ARITY                     (x)
    #define     CAST_TO_STRING
    #define     CAST_TO_NUMBER
    #define     CAST_TO_BOOLEAN
    xmlXPathObjectPtr (*xmlXPathVariableLookupFunc)
                                                (void *ctxt,
                                                 const xmlChar *name,
                                                 const xmlChar *ns_uri);
    void        xmlXPathRegisterVariableLookup  (xmlXPathContextPtr ctxt,
                                                 xmlXPathVariableLookupFunc f,
                                                 void *data);
    xmlXPathFunction (*xmlXPathFuncLookupFunc)  (void *ctxt,
                                                 const xmlChar *name,
                                                 const xmlChar *ns_uri);
    void        xmlXPathRegisterFuncLookup      (xmlXPathContextPtr ctxt,
                                                 xmlXPathFuncLookupFunc f,
                                                 void *funcCtxt);
    void        xmlXPatherror                   (xmlXPathParserContextPtr ctxt,
                                                 const char *file,
                                                 int line,
                                                 int no);
    void        xmlXPathDebugDumpObject         (FILE *output,
                                                 xmlXPathObjectPtr cur,
                                                 int depth);
    void        xmlXPathDebugDumpCompExpr       (FILE *output,
                                                 xmlXPathCompExprPtr comp,
                                                 int depth);
    int         xmlXPathNodeSetContains         (xmlNodeSetPtr cur,
                                                 xmlNodePtr val);
    xmlNodeSetPtr xmlXPathDifference            (xmlNodeSetPtr nodes1,
                                                 xmlNodeSetPtr nodes2);
    xmlNodeSetPtr xmlXPathIntersection          (xmlNodeSetPtr nodes1,
                                                 xmlNodeSetPtr nodes2);
    xmlNodeSetPtr xmlXPathDistinctSorted        (xmlNodeSetPtr nodes);
    xmlNodeSetPtr xmlXPathDistinct              (xmlNodeSetPtr nodes);
    int         xmlXPathHasSameNodes            (xmlNodeSetPtr nodes1,
                                                 xmlNodeSetPtr nodes2);
    xmlNodeSetPtr xmlXPathNodeLeadingSorted     (xmlNodeSetPtr nodes,
                                                 xmlNodePtr node);
    xmlNodeSetPtr xmlXPathLeadingSorted         (xmlNodeSetPtr nodes1,
                                                 xmlNodeSetPtr nodes2);
    xmlNodeSetPtr xmlXPathNodeLeading           (xmlNodeSetPtr nodes,
                                                 xmlNodePtr node);
    xmlNodeSetPtr xmlXPathLeading               (xmlNodeSetPtr nodes1,
                                                 xmlNodeSetPtr nodes2);
    xmlNodeSetPtr xmlXPathNodeTrailingSorted    (xmlNodeSetPtr nodes,
                                                 xmlNodePtr node);
    xmlNodeSetPtr xmlXPathTrailingSorted        (xmlNodeSetPtr nodes1,
                                                 xmlNodeSetPtr nodes2);
    xmlNodeSetPtr xmlXPathNodeTrailing          (xmlNodeSetPtr nodes,
                                                 xmlNodePtr node);
    xmlNodeSetPtr xmlXPathTrailing              (xmlNodeSetPtr nodes1,
                                                 xmlNodeSetPtr nodes2);
    int         xmlXPathRegisterNs              (xmlXPathContextPtr ctxt,
                                                 const xmlChar *prefix,
                                                 const xmlChar *ns_uri);
    const xmlChar* xmlXPathNsLookup             (xmlXPathContextPtr ctxt,
                                                 const xmlChar *prefix);
    void        xmlXPathRegisteredNsCleanup     (xmlXPathContextPtr ctxt);
    int         xmlXPathRegisterFunc            (xmlXPathContextPtr ctxt,
                                                 const xmlChar *name,
                                                 xmlXPathFunction f);
    int         xmlXPathRegisterFuncNS          (xmlXPathContextPtr ctxt,
                                                 const xmlChar *name,
                                                 const xmlChar *ns_uri,
                                                 xmlXPathFunction f);
    int         xmlXPathRegisterVariable        (xmlXPathContextPtr ctxt,
                                                 const xmlChar *name,
                                                 xmlXPathObjectPtr value);
    int         xmlXPathRegisterVariableNS      (xmlXPathContextPtr ctxt,
                                                 const xmlChar *name,
                                                 const xmlChar *ns_uri,
                                                 xmlXPathObjectPtr value);
    xmlXPathFunction xmlXPathFunctionLookup     (xmlXPathContextPtr ctxt,
                                                 const xmlChar *name);
    xmlXPathFunction xmlXPathFunctionLookupNS   (xmlXPathContextPtr ctxt,
                                                 const xmlChar *name,
                                                 const xmlChar *ns_uri);
    void        xmlXPathRegisteredFuncsCleanup  (xmlXPathContextPtr ctxt);
    xmlXPathObjectPtr xmlXPathVariableLookup    (xmlXPathContextPtr ctxt,
                                                 const xmlChar *name);
    xmlXPathObjectPtr xmlXPathVariableLookupNS  (xmlXPathContextPtr ctxt,
                                                 const xmlChar *name,
                                                 const xmlChar *ns_uri);
    void        xmlXPathRegisteredVariablesCleanup
                                                (xmlXPathContextPtr ctxt);
    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 xmlXPathNewCString        (const char *val);
    xmlXPathObjectPtr xmlXPathWrapString        (xmlChar *val);
    xmlXPathObjectPtr xmlXPathWrapCString       (char *val);
    xmlXPathObjectPtr xmlXPathNewFloat          (double val);
    xmlXPathObjectPtr xmlXPathNewBoolean        (int val);
    xmlXPathObjectPtr xmlXPathNewNodeSet        (xmlNodePtr val);
    xmlXPathObjectPtr xmlXPathNewValueTree      (xmlNodePtr val);
    void        xmlXPathNodeSetAdd              (xmlNodeSetPtr cur,
                                                 xmlNodePtr val);
    void        xmlXPathNodeSetAddUnique        (xmlNodeSetPtr cur,
                                                 xmlNodePtr val);
    void        xmlXPathNodeSetAddNs            (xmlNodeSetPtr cur,
                                                 xmlNodePtr node,
                                                 xmlNsPtr ns);
    void        xmlXPathNodeSetSort             (xmlNodeSetPtr set);
    void        xmlXPathRoot                    (xmlXPathParserContextPtr ctxt);
    void        xmlXPathEvalExpr                (xmlXPathParserContextPtr ctxt);
    xmlChar*    xmlXPathParseName               (xmlXPathParserContextPtr ctxt);
    xmlChar*    xmlXPathParseNCName             (xmlXPathParserContextPtr ctxt);
    double      xmlXPathStringEvalNumber        (const xmlChar *str);
    int         xmlXPathEvaluatePredicateResult (xmlXPathParserContextPtr ctxt,
                                                 xmlXPathObjectPtr res);
    void        xmlXPathRegisterAllFunctions    (xmlXPathContextPtr ctxt);
    xmlNodeSetPtr xmlXPathNodeSetMerge          (xmlNodeSetPtr val1,
                                                 xmlNodeSetPtr val2);
    void        xmlXPathNodeSetDel              (xmlNodeSetPtr cur,
                                                 xmlNodePtr val);
    void        xmlXPathNodeSetRemove           (xmlNodeSetPtr cur,
                                                 int val);
    xmlXPathObjectPtr xmlXPathNewNodeSetList    (xmlNodeSetPtr val);
    xmlXPathObjectPtr xmlXPathWrapNodeSet       (xmlNodeSetPtr val);
    xmlXPathObjectPtr xmlXPathWrapExternal      (void *val);
    int         xmlXPathEqualValues             (xmlXPathParserContextPtr ctxt);
    int         xmlXPathNotEqualValues          (xmlXPathParserContextPtr ctxt);
    int         xmlXPathCompareValues           (xmlXPathParserContextPtr ctxt,
                                                 int inf,
                                                 int strict);
    void        xmlXPathValueFlipSign           (xmlXPathParserContextPtr ctxt);
    void        xmlXPathAddValues               (xmlXPathParserContextPtr ctxt);
    void        xmlXPathSubValues               (xmlXPathParserContextPtr ctxt);
    void        xmlXPathMultValues              (xmlXPathParserContextPtr ctxt);
    void        xmlXPathDivValues               (xmlXPathParserContextPtr ctxt);
    void        xmlXPathModValues               (xmlXPathParserContextPtr ctxt);
    int         xmlXPathIsNodeType              (const xmlChar *name);
    xmlNodePtr  xmlXPathNextSelf                (xmlXPathParserContextPtr ctxt,
                                                 xmlNodePtr cur);
    xmlNodePtr  xmlXPathNextChild               (xmlXPathParserContextPtr ctxt,
                                                 xmlNodePtr cur);
    xmlNodePtr  xmlXPathNextDescendant          (xmlXPathParserContextPtr ctxt,
                                                 xmlNodePtr cur);
    xmlNodePtr  xmlXPathNextDescendantOrSelf    (xmlXPathParserContextPtr ctxt,
                                                 xmlNodePtr cur);
    xmlNodePtr  xmlXPathNextParent              (xmlXPathParserContextPtr ctxt,
                                                 xmlNodePtr cur);
    xmlNodePtr  xmlXPathNextAncestorOrSelf      (xmlXPathParserContextPtr ctxt,
                                                 xmlNodePtr cur);
    xmlNodePtr  xmlXPathNextFollowingSibling    (xmlXPathParserContextPtr ctxt,
                                                 xmlNodePtr cur);
    xmlNodePtr  xmlXPathNextFollowing           (xmlXPathParserContextPtr ctxt,
                                                 xmlNodePtr cur);
    xmlNodePtr  xmlXPathNextNamespace           (xmlXPathParserContextPtr ctxt,
                                                 xmlNodePtr cur);
    xmlNodePtr  xmlXPathNextAttribute           (xmlXPathParserContextPtr ctxt,
                                                 xmlNodePtr cur);
    xmlNodePtr  xmlXPathNextPreceding           (xmlXPathParserContextPtr ctxt,
                                                 xmlNodePtr cur);
    xmlNodePtr  xmlXPathNextAncestor            (xmlXPathParserContextPtr ctxt,
                                                 xmlNodePtr cur);
    xmlNodePtr  xmlXPathNextPrecedingSibling    (xmlXPathParserContextPtr ctxt,
                                                 xmlNodePtr cur);
    void        xmlXPathLastFunction            (xmlXPathParserContextPtr ctxt,
                                                 int nargs);
    void        xmlXPathPositionFunction        (xmlXPathParserContextPtr ctxt,
                                                 int nargs);
    void        xmlXPathCountFunction           (xmlXPathParserContextPtr ctxt,
                                                 int nargs);
    void        xmlXPathIdFunction              (xmlXPathParserContextPtr ctxt,
                                                 int nargs);
    void        xmlXPathLocalNameFunction       (xmlXPathParserContextPtr ctxt,
                                                 int nargs);
    void        xmlXPathNamespaceURIFunction    (xmlXPathParserContextPtr ctxt,
                                                 int nargs);
    void        xmlXPathStringFunction          (xmlXPathParserContextPtr ctxt,
                                                 int nargs);
    void        xmlXPathStringLengthFunction    (xmlXPathParserContextPtr ctxt,
                                                 int nargs);
    void        xmlXPathConcatFunction          (xmlXPathParserContextPtr ctxt,
                                                 int nargs);
    void        xmlXPathContainsFunction        (xmlXPathParserContextPtr ctxt,
                                                 int nargs);
    void        xmlXPathStartsWithFunction      (xmlXPathParserContextPtr ctxt,
                                                 int nargs);
    void        xmlXPathSubstringFunction       (xmlXPathParserContextPtr ctxt,
                                                 int nargs);
    void        xmlXPathSubstringBeforeFunction (xmlXPathParserContextPtr ctxt,
                                                 int nargs);
    void        xmlXPathSubstringAfterFunction  (xmlXPathParserContextPtr ctxt,
                                                 int nargs);
    void        xmlXPathNormalizeFunction       (xmlXPathParserContextPtr ctxt,
                                                 int nargs);
    void        xmlXPathTranslateFunction       (xmlXPathParserContextPtr ctxt,
                                                 int nargs);
    void        xmlXPathNotFunction             (xmlXPathParserContextPtr ctxt,
                                                 int nargs);
    void        xmlXPathTrueFunction            (xmlXPathParserContextPtr ctxt,
                                                 int nargs);
    void        xmlXPathFalseFunction           (xmlXPathParserContextPtr ctxt,
                                                 int nargs);
    void        xmlXPathLangFunction            (xmlXPathParserContextPtr ctxt,
                                                 int nargs);
    void        xmlXPathNumberFunction          (xmlXPathParserContextPtr ctxt,
                                                 int nargs);
    void        xmlXPathSumFunction             (xmlXPathParserContextPtr ctxt,
                                                 int nargs);
    void        xmlXPathFloorFunction           (xmlXPathParserContextPtr ctxt,
                                                 int nargs);
    void        xmlXPathCeilingFunction         (xmlXPathParserContextPtr ctxt,
                                                 int nargs);
    void        xmlXPathRoundFunction           (xmlXPathParserContextPtr ctxt,
                                                 int nargs);
    void        xmlXPathBooleanFunction         (xmlXPathParserContextPtr ctxt,
                                                 int nargs);
    void        xmlXPathNodeSetFreeNs           (xmlNsPtr ns);

## Description

## Details

### xmlXPathSetError()

    #define     xmlXPathSetError(ctxt, err)

Raises an error.

`ctxt` : |
`err` : |

### xmlXPathSetArityError()

    #define     xmlXPathSetArityError(ctxt)

Raises an XPATH_INVALID_ARITY error.

`ctxt` : |

### xmlXPathSetTypeError()

    #define     xmlXPathSetTypeError(ctxt)

Raises an XPATH_INVALID_TYPE error.

`ctxt` : |

### xmlXPathGetError()

    #define     xmlXPathGetError(ctxt)

Get the error code of an XPath context.

`ctxt` : |

### xmlXPathCheckError()

    #define     xmlXPathCheckError(ctxt)

Check if an XPath error was raised.

`ctxt` : |

### xmlXPathGetDocument()

    #define     xmlXPathGetDocument(ctxt)

Get the document of an XPath context.

`ctxt` : |

### xmlXPathGetContextNode()

    #define     xmlXPathGetContextNode(ctxt)

Get the context node of an XPath context.

`ctxt` : |

### xmlXPathPopBoolean ()

    int         xmlXPathPopBoolean              (xmlXPathParserContextPtr ctxt);

Pops a boolean from the stack, handling conversion if needed. Check error with xmlXPathCheckError.

`ctxt` : |
Returns : |

### xmlXPathPopNumber ()

    double      xmlXPathPopNumber               (xmlXPathParserContextPtr ctxt);

Pops a number from the stack, handling conversion if needed. Check error with xmlXPathCheckError.

`ctxt` : |
Returns : |

### xmlXPathPopString ()

    xmlChar*    xmlXPathPopString               (xmlXPathParserContextPtr ctxt);

Pops a string from the stack, handling conversion if needed. Check error with xmlXPathCheckError.

`ctxt` : |
Returns : |

### xmlXPathPopNodeSet ()

    xmlNodeSetPtr xmlXPathPopNodeSet            (xmlXPathParserContextPtr ctxt);

Pops a node-set from the stack, handling conversion if needed. Check error with xmlXPathCheckError.

`ctxt` : |
Returns : |

### xmlXPathPopExternal ()

    void*       xmlXPathPopExternal             (xmlXPathParserContextPtr ctxt);

Pops an external object from the stack, handling conversion if needed. Check error with xmlXPathCheckError.

`ctxt` : |

### xmlXPathReturnBoolean()

    #define     xmlXPathReturnBoolean(ctxt, val)

Pushes the boolean `val` on the context stack.

`ctxt` : |
`val` : |

### xmlXPathReturnTrue()

    #define     xmlXPathReturnTrue(ctxt)

Pushes true on the context stack.

`ctxt` : |

### xmlXPathReturnFalse()

    #define     xmlXPathReturnFalse(ctxt)

Pushes false on the context stack.

`ctxt` : |

### xmlXPathReturnNumber()

    #define     xmlXPathReturnNumber(ctxt, val)

Pushes the double `val` on the context stack.

`ctxt` : |
`val` : |

### xmlXPathReturnString()

    #define     xmlXPathReturnString(ctxt, str)

Pushes the string `str` on the context stack.

`ctxt` : |
`str` : |

### xmlXPathReturnEmptyString()

    #define     xmlXPathReturnEmptyString(ctxt)

Pushes an empty string on the stack.

`ctxt` : |

### xmlXPathReturnNodeSet()

    #define     xmlXPathReturnNodeSet(ctxt, ns)

Pushes the node-set `ns` on the context stack.

`ctxt` : |
`ns` : |

### xmlXPathReturnEmptyNodeSet()

    #define     xmlXPathReturnEmptyNodeSet(ctxt)

Pushes an empty node-set on the context stack.

`ctxt` : |

### xmlXPathReturnExternal()

    #define     xmlXPathReturnExternal(ctxt, val)

Pushes user data on the context stack.

`ctxt` : |
`val` : |

### xmlXPathStackIsNodeSet()

    #define     xmlXPathStackIsNodeSet(ctxt)

Check if the current value on the XPath stack is a node set or an XSLT value tree.

`ctxt` : |

### xmlXPathStackIsExternal()

    #define     xmlXPathStackIsExternal(ctxt)

Checks if the current value on the XPath stack is an external object.

`ctxt` : |

### xmlXPathEmptyNodeSet()

    #define     xmlXPathEmptyNodeSet(ns)

Empties a node-set.

`ns` : |

### CHECK_ERROR

    #define     CHECK_ERROR

Macro to return from the function if an XPath error was detected.

### CHECK_ERROR0

    #define     CHECK_ERROR0

Macro to return 0 from the function if an XPath error was detected.

### XP_ERROR()

    #define     XP_ERROR(X)

Macro to raise an XPath error and return.

`X` : |

### XP_ERROR0()

    #define     XP_ERROR0(X)

Macro to raise an XPath error and return 0.

`X` : |

### CHECK_TYPE()

    #define     CHECK_TYPE(typeval)

Macro to check that the value on top of the XPath stack is of a given type.

`typeval` : |

### CHECK_TYPE0()

    #define     CHECK_TYPE0(typeval)

Macro to check that the value on top of the XPath stack is of a given type. Return(0) in case of failure

`typeval` : |

### CHECK_ARITY()

    #define     CHECK_ARITY(x)

Macro to check that the number of args passed to an XPath function matches.

`x` : |

### CAST_TO_STRING

    #define     CAST_TO_STRING

Macro to try to cast the value on the top of the XPath stack to a string.

### CAST_TO_NUMBER

    #define     CAST_TO_NUMBER

Macro to try to cast the value on the top of the XPath stack to a number.

### CAST_TO_BOOLEAN

    #define     CAST_TO_BOOLEAN

Macro to try to cast the value on the top of the XPath stack to a boolean.

### xmlXPathVariableLookupFunc ()

    xmlXPathObjectPtr (*xmlXPathVariableLookupFunc)
                                                (void *ctxt,
                                                 const xmlChar *name,
                                                 const xmlChar *ns_uri);

Prototype for callbacks used to plug variable lookup in the XPath engine.

`ctxt` : |
`name` : |
`ns_uri` : |
Returns : |

### xmlXPathRegisterVariableLookup ()

    void        xmlXPathRegisterVariableLookup  (xmlXPathContextPtr ctxt,
                                                 xmlXPathVariableLookupFunc f,
                                                 void *data);

register an external mechanism to do variable lookup

`ctxt` : |
`f` : |
`data` : |

### xmlXPathFuncLookupFunc ()

    xmlXPathFunction (*xmlXPathFuncLookupFunc)  (void *ctxt,
                                                 const xmlChar *name,
                                                 const xmlChar *ns_uri);

Prototype for callbacks used to plug function lookup in the XPath engine.

`ctxt` : |
`name` : |
`ns_uri` : |
Returns : |

### xmlXPathRegisterFuncLookup ()

    void        xmlXPathRegisterFuncLookup      (xmlXPathContextPtr ctxt,
                                                 xmlXPathFuncLookupFunc f,
                                                 void *funcCtxt);

Registers an external mechanism to do function lookup.

`ctxt` : |
`f` : |
`funcCtxt` : |

### xmlXPatherror ()

    void        xmlXPatherror                   (xmlXPathParserContextPtr ctxt,
                                                 const char *file,
                                                 int line,
                                                 int no);

Formats an error message.

`ctxt` : |
`file` : |
`line` : |
`no` : |

### xmlXPathDebugDumpObject ()

    void        xmlXPathDebugDumpObject         (FILE *output,
                                                 xmlXPathObjectPtr cur,
                                                 int depth);

Dump the content of the object for debugging purposes

`output` : |
`cur` : |
`depth` : |

### xmlXPathDebugDumpCompExpr ()

    void        xmlXPathDebugDumpCompExpr       (FILE *output,
                                                 xmlXPathCompExprPtr comp,
                                                 int depth);

Dumps the tree of the compiled XPath expression.

`output` : |
`comp` : |
`depth` : |

### xmlXPathNodeSetContains ()

    int         xmlXPathNodeSetContains         (xmlNodeSetPtr cur,
                                                 xmlNodePtr val);

checks whether `cur` contains `val`

`cur` : |
`val` : |
Returns : |

### xmlXPathDifference ()

    xmlNodeSetPtr xmlXPathDifference            (xmlNodeSetPtr nodes1,
                                                 xmlNodeSetPtr nodes2);

Implements the EXSLT - Sets difference() function: node-set set:difference (node-set, node-set)

`nodes1` : |
`nodes2` : |
Returns : |

### xmlXPathIntersection ()

    xmlNodeSetPtr xmlXPathIntersection          (xmlNodeSetPtr nodes1,
                                                 xmlNodeSetPtr nodes2);

Implements the EXSLT - Sets intersection() function: node-set set:intersection (node-set, node-set)

`nodes1` : |
`nodes2` : |
Returns : |

### xmlXPathDistinctSorted ()

    xmlNodeSetPtr xmlXPathDistinctSorted        (xmlNodeSetPtr nodes);

Implements the EXSLT - Sets distinct() function: node-set set:distinct (node-set)

`nodes` : |
Returns : |

### xmlXPathDistinct ()

    xmlNodeSetPtr xmlXPathDistinct              (xmlNodeSetPtr nodes);

Implements the EXSLT - Sets distinct() function: node-set set:distinct (node-set) `nodes` is sorted by document order, then exslSetsDistinctSorted is called with the sorted node-set

`nodes` : |
Returns : |

### xmlXPathHasSameNodes ()

    int         xmlXPathHasSameNodes            (xmlNodeSetPtr nodes1,
                                                 xmlNodeSetPtr nodes2);

Implements the EXSLT - Sets has-same-nodes function: boolean set:has-same-node(node-set, node-set)

`nodes1` : |
`nodes2` : |
Returns : |

### xmlXPathNodeLeadingSorted ()

    xmlNodeSetPtr xmlXPathNodeLeadingSorted     (xmlNodeSetPtr nodes,
                                                 xmlNodePtr node);

Implements the EXSLT - Sets leading() function: node-set set:leading (node-set, node-set)

`nodes` : |
`node` : |
Returns : |

### xmlXPathLeadingSorted ()

    xmlNodeSetPtr xmlXPathLeadingSorted         (xmlNodeSetPtr nodes1,
                                                 xmlNodeSetPtr nodes2);

Implements the EXSLT - Sets leading() function: node-set set:leading (node-set, node-set)

`nodes1` : |
`nodes2` : |
Returns : |

### xmlXPathNodeLeading ()

    xmlNodeSetPtr xmlXPathNodeLeading           (xmlNodeSetPtr nodes,
                                                 xmlNodePtr node);

Implements the EXSLT - Sets leading() function: node-set set:leading (node-set, node-set) `nodes` is sorted by document order, then exslSetsNodeLeadingSorted is called.

`nodes` : |
`node` : |
Returns : |

### xmlXPathLeading ()

    xmlNodeSetPtr xmlXPathLeading               (xmlNodeSetPtr nodes1,
                                                 xmlNodeSetPtr nodes2);

Implements the EXSLT - Sets leading() function: node-set set:leading (node-set, node-set) `nodes1` and `nodes2` are sorted by document order, then exslSetsLeadingSorted is called.

`nodes1` : |
`nodes2` : |
Returns : |

### xmlXPathNodeTrailingSorted ()

    xmlNodeSetPtr xmlXPathNodeTrailingSorted    (xmlNodeSetPtr nodes,
                                                 xmlNodePtr node);

Implements the EXSLT - Sets trailing() function: node-set set:trailing (node-set, node-set)

`nodes` : |
`node` : |
Returns : |

### xmlXPathTrailingSorted ()

    xmlNodeSetPtr xmlXPathTrailingSorted        (xmlNodeSetPtr nodes1,
                                                 xmlNodeSetPtr nodes2);

Implements the EXSLT - Sets trailing() function: node-set set:trailing (node-set, node-set)

`nodes1` : |
`nodes2` : |
Returns : |

### xmlXPathNodeTrailing ()

    xmlNodeSetPtr xmlXPathNodeTrailing          (xmlNodeSetPtr nodes,
                                                 xmlNodePtr node);

Implements the EXSLT - Sets trailing() function: node-set set:trailing (node-set, node-set) `nodes` is sorted by document order, then xmlXPathNodeTrailingSorted is called.

`nodes` : |
`node` : |
Returns : |

### xmlXPathTrailing ()

    xmlNodeSetPtr xmlXPathTrailing              (xmlNodeSetPtr nodes1,
                                                 xmlNodeSetPtr nodes2);

Implements the EXSLT - Sets trailing() function: node-set set:trailing (node-set, node-set) `nodes1` and `nodes2` are sorted by document order, then xmlXPathTrailingSorted is called.

`nodes1` : |
`nodes2` : |
Returns : |

### xmlXPathRegisterNs ()

    int         xmlXPathRegisterNs              (xmlXPathContextPtr ctxt,
                                                 const xmlChar *prefix,
                                                 const xmlChar *ns_uri);

Register a new namespace. If `ns_uri` is NULL it unregisters the namespace

`ctxt` : |
`prefix` : |
`ns_uri` : |
Returns : |

### xmlXPathNsLookup ()

    const xmlChar* xmlXPathNsLookup             (xmlXPathContextPtr ctxt,
                                                 const xmlChar *prefix);

Search in the namespace declaration array of the context for the given namespace name associated to the given prefix

`ctxt` : |
`prefix` : |
Returns : |

### xmlXPathRegisteredNsCleanup ()

    void        xmlXPathRegisteredNsCleanup     (xmlXPathContextPtr ctxt);

Cleanup the XPath context data associated to registered variables

`ctxt` : |

### xmlXPathRegisterFunc ()

    int         xmlXPathRegisterFunc            (xmlXPathContextPtr ctxt,
                                                 const xmlChar *name,
                                                 xmlXPathFunction f);

Register a new function. If `f` is NULL it unregisters the function

`ctxt` : |
`name` : |
`f` : |
Returns : |

### xmlXPathRegisterFuncNS ()

    int         xmlXPathRegisterFuncNS          (xmlXPathContextPtr ctxt,
                                                 const xmlChar *name,
                                                 const xmlChar *ns_uri,
                                                 xmlXPathFunction f);

Register a new function. If `f` is NULL it unregisters the function

`ctxt` : |
`name` : |
`ns_uri` : |
`f` : |
Returns : |

### xmlXPathRegisterVariable ()

    int         xmlXPathRegisterVariable        (xmlXPathContextPtr ctxt,
                                                 const xmlChar *name,
                                                 xmlXPathObjectPtr value);

Register a new variable value. If `value` is NULL it unregisters the variable

`ctxt` : |
`name` : |
`value` : |
Returns : |

### xmlXPathRegisterVariableNS ()

    int         xmlXPathRegisterVariableNS      (xmlXPathContextPtr ctxt,
                                                 const xmlChar *name,
                                                 const xmlChar *ns_uri,
                                                 xmlXPathObjectPtr value);

Register a new variable value. If `value` is NULL it unregisters the variable

`ctxt` : |
`name` : |
`ns_uri` : |
`value` : |
Returns : |

### xmlXPathFunctionLookup ()

    xmlXPathFunction xmlXPathFunctionLookup     (xmlXPathContextPtr ctxt,
                                                 const xmlChar *name);

Search in the Function array of the context for the given function.

`ctxt` : |
`name` : |
Returns : |

### xmlXPathFunctionLookupNS ()

    xmlXPathFunction xmlXPathFunctionLookupNS   (xmlXPathContextPtr ctxt,
                                                 const xmlChar *name,
                                                 const xmlChar *ns_uri);

Search in the Function array of the context for the given function.

`ctxt` : |
`name` : |
`ns_uri` : |
Returns : |

### xmlXPathRegisteredFuncsCleanup ()

    void        xmlXPathRegisteredFuncsCleanup  (xmlXPathContextPtr ctxt);

Cleanup the XPath context data associated to registered functions

`ctxt` : |

### xmlXPathVariableLookup ()

    xmlXPathObjectPtr xmlXPathVariableLookup    (xmlXPathContextPtr ctxt,
                                                 const xmlChar *name);

Search in the Variable array of the context for the given variable value.

`ctxt` : |
`name` : |
Returns : |

### xmlXPathVariableLookupNS ()

    xmlXPathObjectPtr xmlXPathVariableLookupNS  (xmlXPathContextPtr ctxt,
                                                 const xmlChar *name,
                                                 const xmlChar *ns_uri);

Search in the Variable array of the context for the given variable value.

`ctxt` : |
`name` : |
`ns_uri` : |
Returns : |

### xmlXPathRegisteredVariablesCleanup ()

    void        xmlXPathRegisteredVariablesCleanup
                                                (xmlXPathContextPtr ctxt);

Cleanup the XPath context data associated to registered variables

`ctxt` : |

### xmlXPathNewParserContext ()

    xmlXPathParserContextPtr xmlXPathNewParserContext
                                                (const xmlChar *str,
                                                 xmlXPathContextPtr ctxt);

Create a new xmlXPathParserContext

`str` : |
`ctxt` : |
Returns : |

### xmlXPathFreeParserContext ()

    void        xmlXPathFreeParserContext       (xmlXPathParserContextPtr ctxt);

Free up an xmlXPathParserContext

`ctxt` : |

### valuePop ()

    xmlXPathObjectPtr valuePop                  (xmlXPathParserContextPtr ctxt);

Pops the top XPath object from the value stack

`ctxt` : |
Returns : |

### valuePush ()

    int         valuePush                       (xmlXPathParserContextPtr ctxt,
                                                 xmlXPathObjectPtr value);

Pushes a new XPath object on top of the value stack

`ctxt` : |
`value` : |
Returns : |

### xmlXPathNewString ()

    xmlXPathObjectPtr xmlXPathNewString         (const xmlChar *val);

Create a new xmlXPathObjectPtr of type string and of value `val`

`val` : |
Returns : |

### xmlXPathNewCString ()

    xmlXPathObjectPtr xmlXPathNewCString        (const char *val);

Create a new xmlXPathObjectPtr of type string and of value `val`

`val` : |
Returns : |

### xmlXPathWrapString ()

    xmlXPathObjectPtr xmlXPathWrapString        (xmlChar *val);

Wraps the `val` string into an XPath object.

`val` : |
Returns : |

### xmlXPathWrapCString ()

    xmlXPathObjectPtr xmlXPathWrapCString       (char *val);

Wraps a string into an XPath object.

`val` : |
Returns : |

### xmlXPathNewFloat ()

    xmlXPathObjectPtr xmlXPathNewFloat          (double val);

Create a new xmlXPathObjectPtr of type double and of value `val`

`val` : |
Returns : |

### xmlXPathNewBoolean ()

    xmlXPathObjectPtr xmlXPathNewBoolean        (int val);

Create a new xmlXPathObjectPtr of type boolean and of value `val`

`val` : |
Returns : |

### xmlXPathNewNodeSet ()

    xmlXPathObjectPtr xmlXPathNewNodeSet        (xmlNodePtr val);

Create a new xmlXPathObjectPtr of type NodeSet and initialize it with the single Node `val`

`val` : |
Returns : |

### xmlXPathNewValueTree ()

    xmlXPathObjectPtr xmlXPathNewValueTree      (xmlNodePtr val);

Create a new xmlXPathObjectPtr of type Value Tree (XSLT) and initialize it with the tree root `val`

`val` : |
Returns : |

### xmlXPathNodeSetAdd ()

    void        xmlXPathNodeSetAdd              (xmlNodeSetPtr cur,
                                                 xmlNodePtr val);

add a new xmlNodePtr to an existing NodeSet

`cur` : |
`val` : |

### xmlXPathNodeSetAddUnique ()

    void        xmlXPathNodeSetAddUnique        (xmlNodeSetPtr cur,
                                                 xmlNodePtr val);

add a new xmlNodePtr to an existing NodeSet, optimized version when we are sure the node is not already in the set.

`cur` : |
`val` : |

### xmlXPathNodeSetAddNs ()

    void        xmlXPathNodeSetAddNs            (xmlNodeSetPtr cur,
                                                 xmlNodePtr node,
                                                 xmlNsPtr ns);

add a new namespace node to an existing NodeSet

`cur` : |
`node` : |
`ns` : |

### xmlXPathNodeSetSort ()

    void        xmlXPathNodeSetSort             (xmlNodeSetPtr set);

Sort the node set in document order

`set` : |

### xmlXPathRoot ()

    void        xmlXPathRoot                    (xmlXPathParserContextPtr ctxt);

Initialize the context to the root of the document

`ctxt` : |

### xmlXPathEvalExpr ()

    void        xmlXPathEvalExpr                (xmlXPathParserContextPtr ctxt);

Parse and evaluate an XPath expression in the given context, then push the result on the context stack

`ctxt` : |

### xmlXPathParseName ()

    xmlChar*    xmlXPathParseName               (xmlXPathParserContextPtr ctxt);

parse an XML name

[4] NameChar ::= Letter | Digit | '.' | '-' | '_' | ':' | CombiningChar | Extender

[5] Name ::= (Letter | '_' | ':') (NameChar)*

`ctxt` : |
Returns : |

### xmlXPathParseNCName ()

    xmlChar*    xmlXPathParseNCName             (xmlXPathParserContextPtr ctxt);

parse an XML namespace non qualified name.

[NS 3] NCName ::= (Letter | '_') (NCNameChar)*

[NS 4] NCNameChar ::= Letter | Digit | '.' | '-' | '_' | CombiningChar | Extender

`ctxt` : |
Returns : |

### xmlXPathStringEvalNumber ()

    double      xmlXPathStringEvalNumber        (const xmlChar *str);

[30a] Float ::= Number ('e' Digits?)?

[30] Number ::= Digits ('.' Digits?)? | '.' Digits [31] Digits ::= [0-9]+

Compile a Number in the string In complement of the Number expression, this function also handles negative values : '-' Number.

`str` : |
Returns : |

### xmlXPathEvaluatePredicateResult ()

    int         xmlXPathEvaluatePredicateResult (xmlXPathParserContextPtr ctxt,
                                                 xmlXPathObjectPtr res);

Evaluate a predicate result for the current node. A PredicateExpr is evaluated by evaluating the Expr and converting the result to a boolean. If the result is a number, the result will be converted to true if the number is equal to the position of the context node in the context node list (as returned by the position function) and will be converted to false otherwise; if the result is not a number, then the result will be converted as if by a call to the boolean function.

`ctxt` : |
`res` : |
Returns : |

### xmlXPathRegisterAllFunctions ()

    void        xmlXPathRegisterAllFunctions    (xmlXPathContextPtr ctxt);

Registers all default XPath functions in this context

`ctxt` : |

### xmlXPathNodeSetMerge ()

    xmlNodeSetPtr xmlXPathNodeSetMerge          (xmlNodeSetPtr val1,
                                                 xmlNodeSetPtr val2);

Merges two nodesets, all nodes from `val2` are added to `val1` if `val1` is NULL, a new set is created and copied from `val2`

`val1` : |
`val2` : |
Returns : |

### xmlXPathNodeSetDel ()

    void        xmlXPathNodeSetDel              (xmlNodeSetPtr cur,
                                                 xmlNodePtr val);

Removes an xmlNodePtr from an existing NodeSet

`cur` : |
`val` : |

### xmlXPathNodeSetRemove ()

    void        xmlXPathNodeSetRemove           (xmlNodeSetPtr cur,
                                                 int val);

Removes an entry from an existing NodeSet list.

`cur` : |
`val` : |

### xmlXPathNewNodeSetList ()

    xmlXPathObjectPtr xmlXPathNewNodeSetList    (xmlNodeSetPtr val);

Create a new xmlXPathObjectPtr of type NodeSet and initialize it with the Nodeset `val`

`val` : |
Returns : |

### xmlXPathWrapNodeSet ()

    xmlXPathObjectPtr xmlXPathWrapNodeSet       (xmlNodeSetPtr val);

Wrap the Nodeset `val` in a new xmlXPathObjectPtr

`val` : |
Returns : |

### xmlXPathWrapExternal ()

    xmlXPathObjectPtr xmlXPathWrapExternal      (void *val);

Wraps the `val` data into an XPath object.

`val` : |
Returns : |

### xmlXPathEqualValues ()

    int         xmlXPathEqualValues             (xmlXPathParserContextPtr ctxt);

Implement the equal operation on XPath objects content: `arg1` == `arg2`

`ctxt` : |
Returns : |

### xmlXPathNotEqualValues ()

    int         xmlXPathNotEqualValues          (xmlXPathParserContextPtr ctxt);

Implement the equal operation on XPath objects content: `arg1` == `arg2`

`ctxt` : |
Returns : |

### xmlXPathCompareValues ()

    int         xmlXPathCompareValues           (xmlXPathParserContextPtr ctxt,
                                                 int inf,
                                                 int strict);

Implement the compare operation on XPath objects: `arg1` < `arg2` (1, 1, ... `arg1` <= `arg2` (1, 0, ... `arg1` > `arg2` (0, 1, ... `arg1` >= `arg2` (0, 0, ...

When neither object to be compared is a node-set and the operator is <=, <, >=, >, then the objects are compared by converted both objects to numbers and comparing the numbers according to IEEE 754. The < comparison will be true if and only if the first number is less than the second number. The <= comparison will be true if and only if the first number is less than or equal to the second number. The > comparison will be true if and only if the first number is greater than the second number. The >= comparison will be true if and only if the first number is greater than or equal to the second number.

`ctxt` : |
`inf` : |
`strict` : |
Returns : |

### xmlXPathValueFlipSign ()

    void        xmlXPathValueFlipSign           (xmlXPathParserContextPtr ctxt);

Implement the unary - operation on an XPath object The numeric operators convert their operands to numbers as if by calling the number function.

`ctxt` : |

### xmlXPathAddValues ()

    void        xmlXPathAddValues               (xmlXPathParserContextPtr ctxt);

Implement the add operation on XPath objects: The numeric operators convert their operands to numbers as if by calling the number function.

`ctxt` : |

### xmlXPathSubValues ()

    void        xmlXPathSubValues               (xmlXPathParserContextPtr ctxt);

Implement the subtraction operation on XPath objects: The numeric operators convert their operands to numbers as if by calling the number function.

`ctxt` : |

### xmlXPathMultValues ()

    void        xmlXPathMultValues              (xmlXPathParserContextPtr ctxt);

Implement the multiply operation on XPath objects: The numeric operators convert their operands to numbers as if by calling the number function.

`ctxt` : |

### xmlXPathDivValues ()

    void        xmlXPathDivValues               (xmlXPathParserContextPtr ctxt);

Implement the div operation on XPath objects `arg1` / `arg2`: The numeric operators convert their operands to numbers as if by calling the number function.

`ctxt` : |

### xmlXPathModValues ()

    void        xmlXPathModValues               (xmlXPathParserContextPtr ctxt);

Implement the mod operation on XPath objects: `arg1` / `arg2` The numeric operators convert their operands to numbers as if by calling the number function.

`ctxt` : |

### xmlXPathIsNodeType ()

    int         xmlXPathIsNodeType              (const xmlChar *name);

Is the name given a NodeType one.

[38] NodeType ::= 'comment' | 'text' | 'processing-instruction' | 'node'

`name` : |
Returns : |

### xmlXPathNextSelf ()

    xmlNodePtr  xmlXPathNextSelf                (xmlXPathParserContextPtr ctxt,
                                                 xmlNodePtr cur);

Traversal function for the "self" direction The self axis contains just the context node itself

`ctxt` : |
`cur` : |
Returns : |

### xmlXPathNextChild ()

    xmlNodePtr  xmlXPathNextChild               (xmlXPathParserContextPtr ctxt,
                                                 xmlNodePtr cur);

Traversal function for the "child" direction The child axis contains the children of the context node in document order.

`ctxt` : |
`cur` : |
Returns : |

### xmlXPathNextDescendant ()

    xmlNodePtr  xmlXPathNextDescendant          (xmlXPathParserContextPtr ctxt,
                                                 xmlNodePtr cur);

Traversal function for the "descendant" direction the descendant axis contains the descendants of the context node in document order; a descendant is a child or a child of a child and so on.

`ctxt` : |
`cur` : |
Returns : |

### xmlXPathNextDescendantOrSelf ()

    xmlNodePtr  xmlXPathNextDescendantOrSelf    (xmlXPathParserContextPtr ctxt,
                                                 xmlNodePtr cur);

Traversal function for the "descendant-or-self" direction the descendant-or-self axis contains the context node and the descendants of the context node in document order; thus the context node is the first node on the axis, and the first child of the context node is the second node on the axis

`ctxt` : |
`cur` : |
Returns : |

### xmlXPathNextParent ()

    xmlNodePtr  xmlXPathNextParent              (xmlXPathParserContextPtr ctxt,
                                                 xmlNodePtr cur);

Traversal function for the "parent" direction The parent axis contains the parent of the context node, if there is one.

`ctxt` : |
`cur` : |
Returns : |

### xmlXPathNextAncestorOrSelf ()

    xmlNodePtr  xmlXPathNextAncestorOrSelf      (xmlXPathParserContextPtr ctxt,
                                                 xmlNodePtr cur);

Traversal function for the "ancestor-or-self" direction he ancestor-or-self axis contains the context node and ancestors of the context node in reverse document order; thus the context node is the first node on the axis, and the context node's parent the second; parent here is defined the same as with the parent axis.

`ctxt` : |
`cur` : |
Returns : |

### xmlXPathNextFollowingSibling ()

    xmlNodePtr  xmlXPathNextFollowingSibling    (xmlXPathParserContextPtr ctxt,
                                                 xmlNodePtr cur);

Traversal function for the "following-sibling" direction The following-sibling axis contains the following siblings of the context node in document order.

`ctxt` : |
`cur` : |
Returns : |

### xmlXPathNextFollowing ()

    xmlNodePtr  xmlXPathNextFollowing           (xmlXPathParserContextPtr ctxt,
                                                 xmlNodePtr cur);

Traversal function for the "following" direction The following axis contains all nodes in the same document as the context node that are after the context node in document order, excluding any descendants and excluding attribute nodes and namespace nodes; the nodes are ordered in document order

`ctxt` : |
`cur` : |
Returns : |

### xmlXPathNextNamespace ()

    xmlNodePtr  xmlXPathNextNamespace           (xmlXPathParserContextPtr ctxt,
                                                 xmlNodePtr cur);

Traversal function for the "namespace" direction the namespace axis contains the namespace nodes of the context node; the order of nodes on this axis is implementation-defined; the axis will be empty unless the context node is an element

We keep the XML namespace node at the end of the list.

`ctxt` : |
`cur` : |
Returns : |

### xmlXPathNextAttribute ()

    xmlNodePtr  xmlXPathNextAttribute           (xmlXPathParserContextPtr ctxt,
                                                 xmlNodePtr cur);

Traversal function for the "attribute" direction TODO: support DTD inherited default attributes

`ctxt` : |
`cur` : |
Returns : |

### xmlXPathNextPreceding ()

    xmlNodePtr  xmlXPathNextPreceding           (xmlXPathParserContextPtr ctxt,
                                                 xmlNodePtr cur);

Traversal function for the "preceding" direction the preceding axis contains all nodes in the same document as the context node that are before the context node in document order, excluding any ancestors and excluding attribute nodes and namespace nodes; the nodes are ordered in reverse document order

`ctxt` : |
`cur` : |
Returns : |

### xmlXPathNextAncestor ()

    xmlNodePtr  xmlXPathNextAncestor            (xmlXPathParserContextPtr ctxt,
                                                 xmlNodePtr cur);

Traversal function for the "ancestor" direction the ancestor axis contains the ancestors of the context node; the ancestors of the context node consist of the parent of context node and the parent's parent and so on; the nodes are ordered in reverse document order; thus the parent is the first node on the axis, and the parent's parent is the second node on the axis

`ctxt` : |
`cur` : |
Returns : |

### xmlXPathNextPrecedingSibling ()

    xmlNodePtr  xmlXPathNextPrecedingSibling    (xmlXPathParserContextPtr ctxt,
                                                 xmlNodePtr cur);

Traversal function for the "preceding-sibling" direction The preceding-sibling axis contains the preceding siblings of the context node in reverse document order; the first preceding sibling is first on the axis; the sibling preceding that node is the second on the axis and so on.

`ctxt` : |
`cur` : |
Returns : |

### xmlXPathLastFunction ()

    void        xmlXPathLastFunction            (xmlXPathParserContextPtr ctxt,
                                                 int nargs);

Implement the last() XPath function number last() The last function returns the number of nodes in the context node list.

`ctxt` : |
`nargs` : |

### xmlXPathPositionFunction ()

    void        xmlXPathPositionFunction        (xmlXPathParserContextPtr ctxt,
                                                 int nargs);

Implement the position() XPath function number position() The position function returns the position of the context node in the context node list. The first position is 1, and so the last position will be equal to last().

`ctxt` : |
`nargs` : |

### xmlXPathCountFunction ()

    void        xmlXPathCountFunction           (xmlXPathParserContextPtr ctxt,
                                                 int nargs);

Implement the count() XPath function number count(node-set)

`ctxt` : |
`nargs` : |

### xmlXPathIdFunction ()

    void        xmlXPathIdFunction              (xmlXPathParserContextPtr ctxt,
                                                 int nargs);

Implement the id() XPath function node-set id(object) The id function selects elements by their unique ID (see [5.2.1 Unique IDs]). When the argument to id is of type node-set, then the result is the union of the result of applying id to the string value of each of the nodes in the argument node-set. When the argument to id is of any other type, the argument is converted to a string as if by a call to the string function; the string is split into a whitespace-separated list of tokens (whitespace is any sequence of characters matching the production S); the result is a node-set containing the elements in the same document as the context node that have a unique ID equal to any of the tokens in the list.

`ctxt` : |
`nargs` : |

### xmlXPathLocalNameFunction ()

    void        xmlXPathLocalNameFunction       (xmlXPathParserContextPtr ctxt,
                                                 int nargs);

Implement the local-name() XPath function string local-name(node-set?) The local-name function returns a string containing the local part of the name of the node in the argument node-set that is first in document order. If the node-set is empty or the first node has no name, an empty string is returned. If the argument is omitted it defaults to the context node.

`ctxt` : |
`nargs` : |

### xmlXPathNamespaceURIFunction ()

    void        xmlXPathNamespaceURIFunction    (xmlXPathParserContextPtr ctxt,
                                                 int nargs);

Implement the namespace-uri() XPath function string namespace-uri(node-set?) The namespace-uri function returns a string containing the namespace URI of the expanded name of the node in the argument node-set that is first in document order. If the node-set is empty, the first node has no name, or the expanded name has no namespace URI, an empty string is returned. If the argument is omitted it defaults to the context node.

`ctxt` : |
`nargs` : |

### xmlXPathStringFunction ()

    void        xmlXPathStringFunction          (xmlXPathParserContextPtr ctxt,
                                                 int nargs);

Implement the string() XPath function string string(object?) he string function converts an object to a string as follows: - A node-set is converted to a string by returning the value of the node in the node-set that is first in document order. If the node-set is empty, an empty string is returned. - A number is converted to a string as follows + NaN is converted to the string NaN + positive zero is converted to the string 0 + negative zero is converted to the string 0 + positive infinity is converted to the string Infinity + negative infinity is converted to the string -Infinity + if the number is an integer, the number is represented in decimal form as a Number with no decimal point and no leading zeros, preceded by a minus sign (-) if the number is negative + otherwise, the number is represented in decimal form as a Number including a decimal point with at least one digit before the decimal point and at least one digit after the decimal point, preceded by a minus sign (-) if the number is negative; there must be no leading zeros before the decimal point apart possibly from the one required digit immediately before the decimal point; beyond the one required digit after the decimal point there must be as many, but only as many, more digits as are needed to uniquely distinguish the number from all other IEEE 754 numeric values. - The boolean false value is converted to the string false. The boolean true value is converted to the string true.

If the argument is omitted, it defaults to a node-set with the context node as its only member.

`ctxt` : |
`nargs` : |

### xmlXPathStringLengthFunction ()

    void        xmlXPathStringLengthFunction    (xmlXPathParserContextPtr ctxt,
                                                 int nargs);

Implement the string-length() XPath function number string-length(string?) The string-length returns the number of characters in the string (see [3.6 Strings]). If the argument is omitted, it defaults to the context node converted to a string, in other words the value of the context node.

`ctxt` : |
`nargs` : |

### xmlXPathConcatFunction ()

    void        xmlXPathConcatFunction          (xmlXPathParserContextPtr ctxt,
                                                 int nargs);

Implement the concat() XPath function string concat(string, string, string*) The concat function returns the concatenation of its arguments.

`ctxt` : |
`nargs` : |

### xmlXPathContainsFunction ()

    void        xmlXPathContainsFunction        (xmlXPathParserContextPtr ctxt,
                                                 int nargs);

Implement the contains() XPath function boolean contains(string, string) The contains function returns true if the first argument string contains the second argument string, and otherwise returns false.

`ctxt` : |
`nargs` : |

### xmlXPathStartsWithFunction ()

    void        xmlXPathStartsWithFunction      (xmlXPathParserContextPtr ctxt,
                                                 int nargs);

Implement the starts-with() XPath function boolean starts-with(string, string) The starts-with function returns true if the first argument string starts with the second argument string, and otherwise returns false.

`ctxt` : |
`nargs` : |

### xmlXPathSubstringFunction ()

    void        xmlXPathSubstringFunction       (xmlXPathParserContextPtr ctxt,
                                                 int nargs);

Implement the substring() XPath function string substring(string, number, number?) The substring function returns the substring of the first argument starting at the position specified in the second argument with length specified in the third argument. For example, substring("12345",2,3) returns "234". If the third argument is not specified, it returns the substring starting at the position specified in the second argument and continuing to the end of the string. For example, substring("12345",2) returns "2345". More precisely, each character in the string (see [3.6 Strings]) is considered to have a numeric position: the position of the first character is 1, the position of the second character is 2 and so on. The returned substring contains those characters for which the position of the character is greater than or equal to the second argument and, if the third argument is specified, less than the sum of the second and third arguments; the comparisons and addition used for the above follow the standard IEEE 754 rules. Thus: - substring("12345", 1.5, 2.6) returns "234" - substring("12345", 0, 3) returns "12" - substring("12345", 0 div 0, 3) returns "" - substring("12345", 1, 0 div 0) returns "" - substring("12345", -42, 1 div 0) returns "12345" - substring("12345", -1 div 0, 1 div 0) returns ""

`ctxt` : |
`nargs` : |

### xmlXPathSubstringBeforeFunction ()

    void        xmlXPathSubstringBeforeFunction (xmlXPathParserContextPtr ctxt,
                                                 int nargs);

Implement the substring-before() XPath function string substring-before(string, string) The substring-before function returns the substring of the first argument string that precedes the first occurrence of the second argument string in the first argument string, or the empty string if the first argument string does not contain the second argument string. For example, substring-before("1999/04/01","/") returns 1999.

`ctxt` : |
`nargs` : |

### xmlXPathSubstringAfterFunction ()

    void        xmlXPathSubstringAfterFunction  (xmlXPathParserContextPtr ctxt,
                                                 int nargs);

Implement the substring-after() XPath function string substring-after(string, string) The substring-after function returns the substring of the first argument string that follows the first occurrence of the second argument string in the first argument string, or the empty stringi if the first argument string does not contain the second argument string. For example, substring-after("1999/04/01","/") returns 04/01, and substring-after("1999/04/01","19") returns 99/04/01.

`ctxt` : |
`nargs` : |

### xmlXPathNormalizeFunction ()

    void        xmlXPathNormalizeFunction       (xmlXPathParserContextPtr ctxt,
                                                 int nargs);

Implement the normalize-space() XPath function string normalize-space(string?) The normalize-space function returns the argument string with white space normalized by stripping leading and trailing whitespace and replacing sequences of whitespace characters by a single space. Whitespace characters are the same allowed by the S production in XML. If the argument is omitted, it defaults to the context node converted to a string, in other words the value of the context node.

`ctxt` : |
`nargs` : |

### xmlXPathTranslateFunction ()

    void        xmlXPathTranslateFunction       (xmlXPathParserContextPtr ctxt,
                                                 int nargs);

Implement the translate() XPath function string translate(string, string, string) The translate function returns the first argument string with occurrences of characters in the second argument string replaced by the character at the corresponding position in the third argument string. For example, translate("bar","abc","ABC") returns the string BAr. If there is a character in the second argument string with no character at a corresponding position in the third argument string (because the second argument string is longer than the third argument string), then occurrences of that character in the first argument string are removed. For example, translate("--aaa--","abc-","ABC")

`ctxt` : |
`nargs` : |

### xmlXPathNotFunction ()

    void        xmlXPathNotFunction             (xmlXPathParserContextPtr ctxt,
                                                 int nargs);

Implement the not() XPath function boolean not(boolean) The not function returns true if its argument is false, and false otherwise.

`ctxt` : |
`nargs` : |

### xmlXPathTrueFunction ()

    void        xmlXPathTrueFunction            (xmlXPathParserContextPtr ctxt,
                                                 int nargs);

Implement the true() XPath function boolean true()

`ctxt` : |
`nargs` : |

### xmlXPathFalseFunction ()

    void        xmlXPathFalseFunction           (xmlXPathParserContextPtr ctxt,
                                                 int nargs);

Implement the false() XPath function boolean false()

`ctxt` : |
`nargs` : |

### xmlXPathLangFunction ()

    void        xmlXPathLangFunction            (xmlXPathParserContextPtr ctxt,
                                                 int nargs);

Implement the lang() XPath function boolean lang(string) The lang function returns true or false depending on whether the language of the context node as specified by xml:lang attributes is the same as or is a sublanguage of the language specified by the argument string. The language of the context node is determined by the value of the xml:lang attribute on the context node, or, if the context node has no xml:lang attribute, by the value of the xml:lang attribute on the nearest ancestor of the context node that has an xml:lang attribute. If there is no such attribute, then lang

`ctxt` : |
`nargs` : |

### xmlXPathNumberFunction ()

    void        xmlXPathNumberFunction          (xmlXPathParserContextPtr ctxt,
                                                 int nargs);

Implement the number() XPath function number number(object?)

`ctxt` : |
`nargs` : |

### xmlXPathSumFunction ()

    void        xmlXPathSumFunction             (xmlXPathParserContextPtr ctxt,
                                                 int nargs);

Implement the sum() XPath function number sum(node-set) The sum function returns the sum of the values of the nodes in the argument node-set.

`ctxt` : |
`nargs` : |

### xmlXPathFloorFunction ()

    void        xmlXPathFloorFunction           (xmlXPathParserContextPtr ctxt,
                                                 int nargs);

Implement the floor() XPath function number floor(number) The floor function returns the largest (closest to positive infinity) number that is not greater than the argument and that is an integer.

`ctxt` : |
`nargs` : |

### xmlXPathCeilingFunction ()

    void        xmlXPathCeilingFunction         (xmlXPathParserContextPtr ctxt,
                                                 int nargs);

Implement the ceiling() XPath function number ceiling(number) The ceiling function returns the smallest (closest to negative infinity) number that is not less than the argument and that is an integer.

`ctxt` : |
`nargs` : |

### xmlXPathRoundFunction ()

    void        xmlXPathRoundFunction           (xmlXPathParserContextPtr ctxt,
                                                 int nargs);

Implement the round() XPath function number round(number) The round function returns the number that is closest to the argument and that is an integer. If there are two such numbers, then the one that is even is returned.

`ctxt` : |
`nargs` : |

### xmlXPathBooleanFunction ()

    void        xmlXPathBooleanFunction         (xmlXPathParserContextPtr ctxt,
                                                 int nargs);

Implement the boolean() XPath function boolean boolean(object) he boolean function converts its argument to a boolean as follows: - a number is true if and only if it is neither positive or negative zero nor NaN - a node-set is true if and only if it is non-empty - a string is true if and only if its length is non-zero

`ctxt` : |
`nargs` : |

### xmlXPathNodeSetFreeNs ()

    void        xmlXPathNodeSetFreeNs           (xmlNsPtr ns);

Namespace node in libxml don't match the XPath semantic. In a node set the namespace nodes are duplicated and the next pointer is set to the parent node in the XPath semantic. Check if such a node need to be freed

`ns` : |

<<< Previous Page | Home | Up | Next Page >>>
xpath | xpointer