Synopsis

struct xmlXPathContext

struct xmlXPathContext {

    xmlDocPtr doc;			/* The current document */
    xmlNodePtr node;			/* The current node */

    int nb_variables_unused;		/* unused (hash table) */
    int max_variables_unused;		/* unused (hash table) */
    xmlHashTablePtr varHash;		/* Hash table of defined variables */

    int nb_types;			/* number of defined types */
    int max_types;			/* max number of types */
    xmlXPathTypePtr types;		/* Array of defined types */

    int nb_funcs_unused;		/* unused (hash table) */
    int max_funcs_unused;		/* unused (hash table) */
    xmlHashTablePtr funcHash;		/* Hash table of defined funcs */

    int nb_axis;			/* number of defined axis */
    int max_axis;			/* max number of axis */
    xmlXPathAxisPtr axis;		/* Array of defined axis */

    /* the namespace nodes of the context node */
    xmlNsPtr *namespaces;		/* Array of namespaces */
    int nsNr;				/* number of namespace in scope */
    void *user;				/* function to free */

    /* extra variables */
    int contextSize;			/* the context size */
    int proximityPosition;		/* the proximity position */

    /* extra stuff for XPointer */
    int xptr;				/* it this an XPointer context */
    xmlNodePtr here;			/* for here() */
    xmlNodePtr origin;			/* for origin() */

    /* the set of namespace declarations in scope for the expression */
    xmlHashTablePtr nsHash;		/* The namespaces hash table */
    void *varLookupFunc;		/* variable lookup func */
    void *varLookupData;		/* variable lookup data */

    /* Possibility to link in an extra item */
    void *extra;                        /* needed for XSLT */

    /* The function name and URI when calling a function */
    const xmlChar *function;
    const xmlChar *functionURI;

    /* function lookup function and data */
    void *funcLookupFunc;		/* function lookup func */
    void *funcLookupData;		/* function lookup data */

    /* temporary namespace lists kept for walking the namespace axis */
    xmlNsPtr *tmpNsList;		/* Array of namespaces */
    int tmpNsNr;			/* number of namespace in scope */

    /* error reporting mechanism */
    void *userData;                     /* user specific data block */
    xmlStructuredErrorFunc error;       /* the callback in case of errors */
    xmlError lastError;			/* the last error */
    xmlNodePtr debugNode;		/* the source node XSLT */
};

Expression evaluation occurs with respect to a context. he context consists of: - a node (the context node) - a node list (the context node list) - a set of variable bindings - a function library - the set of namespace declarations in scope for the expression Following the switch to hash tables, this need to be trimmed up at the next binary incompatible release.

xmlXPathContextPtr

typedef xmlXPathContext *xmlXPathContextPtr;

struct xmlXPathParserContext

struct xmlXPathParserContext {

    const xmlChar *cur;			/* the current char being parsed */
    const xmlChar *base;			/* the full expression */

    int error;				/* error code */

    xmlXPathContextPtr  context;	/* the evaluation context */
    xmlXPathObjectPtr     value;	/* the current value */
    int                 valueNr;	/* number of values stacked */
    int                valueMax;	/* max number of values stacked */
    xmlXPathObjectPtr *valueTab;	/* stack of values */

    xmlXPathCompExprPtr comp;		/* the precompiled expression */
    int xptr;				/* it this an XPointer expression */
    xmlNodePtr         ancestor;	/* used for walking preceding axis */
};

An XPath parser context. It contains pure parsing informations, an xmlXPathContext, and the stack of objects.

xmlXPathParserContextPtr

typedef xmlXPathParserContext *xmlXPathParserContextPtr;

enum xmlXPathError

typedef enum {
    XPATH_EXPRESSION_OK = 0,
    XPATH_NUMBER_ERROR,
    XPATH_UNFINISHED_LITERAL_ERROR,
    XPATH_START_LITERAL_ERROR,
    XPATH_VARIABLE_REF_ERROR,
    XPATH_UNDEF_VARIABLE_ERROR,
    XPATH_INVALID_PREDICATE_ERROR,
    XPATH_EXPR_ERROR,
    XPATH_UNCLOSED_ERROR,
    XPATH_UNKNOWN_FUNC_ERROR,
    XPATH_INVALID_OPERAND,
    XPATH_INVALID_TYPE,
    XPATH_INVALID_ARITY,
    XPATH_INVALID_CTXT_SIZE,
    XPATH_INVALID_CTXT_POSITION,
    XPATH_MEMORY_ERROR,
    XPTR_SYNTAX_ERROR,
    XPTR_RESOURCE_ERROR,
    XPTR_SUB_RESOURCE_ERROR,
    XPATH_UNDEF_PREFIX_ERROR,
    XPATH_ENCODING_ERROR,
    XPATH_INVALID_CHAR_ERROR
} xmlXPathError;

struct xmlNodeSet

struct xmlNodeSet {

    int nodeNr;			/* number of nodes in the set */
    int nodeMax;		/* size of the array as allocated */
    xmlNodePtr *nodeTab;	/* array of nodes in no particular order */
    /* @@ with_ns to check wether namespace nodes should be looked at @@ */
};

xmlNodeSetPtr

typedef xmlNodeSet *xmlNodeSetPtr;

enum xmlXPathObjectType

typedef enum {
    XPATH_UNDEFINED = 0,
    XPATH_NODESET = 1,
    XPATH_BOOLEAN = 2,
    XPATH_NUMBER = 3,
    XPATH_STRING = 4,
    XPATH_POINT = 5,
    XPATH_RANGE = 6,
    XPATH_LOCATIONSET = 7,
    XPATH_USERS = 8,
    XPATH_XSLT_TREE = 9  /* An XSLT value tree, non modifiable */
} xmlXPathObjectType;

struct xmlXPathObject

struct xmlXPathObject {

    xmlXPathObjectType type;
    xmlNodeSetPtr nodesetval;
    int boolval;
    double floatval;
    xmlChar *stringval;
    void *user;
    int index;
    void *user2;
    int index2;
};

xmlXPathObjectPtr

typedef xmlXPathObject *xmlXPathObjectPtr;

xmlXPathConvertFunc ()

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

A conversion function is associated to a type and used to cast the new type to primitive values.

struct xmlXPathType

struct xmlXPathType {

    const xmlChar         *name;		/* the type name */
    xmlXPathConvertFunc func;		/* the conversion function */
};

xmlXPathTypePtr

typedef xmlXPathType *xmlXPathTypePtr;

struct xmlXPathVariable

struct xmlXPathVariable {

    const xmlChar       *name;		/* the variable name */
    xmlXPathObjectPtr value;		/* the value */
};

xmlXPathVariablePtr

typedef xmlXPathVariable *xmlXPathVariablePtr;

xmlXPathEvalFunc ()

void        (*xmlXPathEvalFunc)             (xmlXPathParserContextPtr ctxt,
                                             int nargs);

An XPath evaluation function, the parameters are on the XPath context stack.

struct xmlXPathFunct

struct xmlXPathFunct {

    const xmlChar      *name;		/* the function name */
    xmlXPathEvalFunc func;		/* the evaluation function */
};

xmlXPathFuncPtr

typedef xmlXPathFunct *xmlXPathFuncPtr;

xmlXPathAxisFunc ()

xmlXPathObjectPtr (*xmlXPathAxisFunc)       (xmlXPathParserContextPtr ctxt,
                                             xmlXPathObjectPtr cur);

An axis traversal function. To traverse an axis, the engine calls the first time with cur == NULL and repeat until the function returns NULL indicating the end of the axis traversal.

struct xmlXPathAxis

struct xmlXPathAxis {

    const xmlChar      *name;		/* the axis name */
    xmlXPathAxisFunc func;		/* the search function */
};

xmlXPathAxisPtr

typedef xmlXPathAxis *xmlXPathAxisPtr;

struct xmlXPathCompExpr

struct xmlXPathCompExpr;

xmlXPathCompExprPtr

typedef xmlXPathCompExpr *xmlXPathCompExprPtr;

xmlXPathFunction ()

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

An XPath function. The arguments (if any) are popped out from the context stack and the result is pushed on the stack.

xmlXPathNAN

extern double xmlXPathNAN;

xmlXPathPINF

extern double xmlXPathPINF;

xmlXPathNINF

extern double xmlXPathNINF;

xmlXPathNodeSetGetLength()

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

Implement a functionality similar to the DOM NodeList.length.

xmlXPathNodeSetItem()

#define     xmlXPathNodeSetItem(ns, index)

Implements a functionality similar to the DOM NodeList.item().

xmlXPathNodeSetIsEmpty()

#define     xmlXPathNodeSetIsEmpty(ns)

Checks whether ns is empty or not.