xpath

Name

xpath —

Synopsis



struct      xmlXPathContext;
typedef     xmlXPathContextPtr;
struct      xmlXPathParserContext;
typedef     xmlXPathParserContextPtr;
enum        xmlXPathError;
struct      xmlNodeSet;
typedef     xmlNodeSetPtr;
enum        xmlXPathObjectType;
struct      xmlXPathObject;
typedef     xmlXPathObjectPtr;
int         (*xmlXPathConvertFunc)          (xmlXPathObjectPtr obj,
                                             int type);
struct      xmlXPathType;
typedef     xmlXPathTypePtr;
struct      xmlXPathVariable;
typedef     xmlXPathVariablePtr;
void        (*xmlXPathEvalFunc)             (xmlXPathParserContextPtr ctxt,
                                             int nargs);
struct      xmlXPathFunct;
typedef     xmlXPathFuncPtr;
xmlXPathObjectPtr (*xmlXPathAxisFunc)       (xmlXPathParserContextPtr ctxt,
                                             xmlXPathObjectPtr cur);
struct      xmlXPathAxis;
typedef     xmlXPathAxisPtr;
void        (*xmlXPathFunction)             (xmlXPathParserContextPtr ctxt,
                                             int nargs);
#define     CHECK_ERROR
#define     CHECK_ERROR0
#define     XP_ERROR                        (X)
#define     XP_ERROR0                       (X)
#define     CHECK_TYPE                      (typeval)
void        xmlXPathDebugDumpObject         (FILE *output,
                                             xmlXPathObjectPtr cur,
                                             int depth);
xmlXPathParserContextPtr xmlXPathNewParserContext
                                            (const xmlChar *str,
                                             xmlXPathContextPtr ctxt);
void        xmlXPathFreeParserContext       (xmlXPathParserContextPtr ctxt);
xmlXPathObjectPtr valuePop                  (xmlXPathParserContextPtr ctxt);
int         valuePush                       (xmlXPathParserContextPtr ctxt,
                                             xmlXPathObjectPtr value);
xmlXPathObjectPtr xmlXPathNewString         (const xmlChar *val);
xmlXPathObjectPtr xmlXPathNewNodeSet        (xmlNodePtr val);
void        xmlXPathNodeSetAdd              (xmlNodeSetPtr cur,
                                             xmlNodePtr val);
void        xmlXPathIdFunction              (xmlXPathParserContextPtr ctxt,
                                             int nargs);
void        xmlXPathRoot                    (xmlXPathParserContextPtr ctxt);
void        xmlXPathEvalExpr                (xmlXPathParserContextPtr ctxt);
xmlChar*    xmlXPathParseName               (xmlXPathParserContextPtr ctxt);
int         xmlXPathRegisterFunc            (xmlXPathContextPtr ctxt,
                                             const xmlChar *name,
                                             xmlXPathFunction f);
int         xmlXPathRegisterVariable        (xmlXPathContextPtr ctxt,
                                             const xmlChar *name,
                                             xmlXPathObjectPtr value);
void        xmlXPathInit                    (void);
xmlXPathContextPtr xmlXPathNewContext       (xmlDocPtr doc);
void        xmlXPathFreeContext             (xmlXPathContextPtr ctxt);
xmlXPathObjectPtr xmlXPathEval              (const xmlChar *str,
                                             xmlXPathContextPtr ctxt);
xmlXPathObjectPtr xmlXPathEvalXPtrExpr      (const xmlChar *str,
                                             xmlXPathContextPtr ctxt);
void        xmlXPathFreeObject              (xmlXPathObjectPtr obj);
xmlXPathObjectPtr xmlXPathEvalExpression    (const xmlChar *str,
                                             xmlXPathContextPtr ctxt);
xmlNodeSetPtr xmlXPathNodeSetCreate         (xmlNodePtr val);
void        xmlXPathFreeNodeSetList         (xmlXPathObjectPtr obj);
void        xmlXPathFreeNodeSet             (xmlNodeSetPtr obj);
xmlXPathObjectPtr xmlXPathObjectCopy        (xmlXPathObjectPtr val);

Description

Details

struct xmlXPathContext

struct xmlXPathContext {
    xmlDocPtr doc;			/* The current document */
    xmlNodePtr node;			/* The current node */

    int nb_variables;			/* number of defined variables */
    int max_variables;			/* max number of variables */
    xmlXPathVariablePtr variables;	/* Array of defined variables */

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

    int nb_funcs;			/* number of defined funcs */
    int max_funcs;			/* max number of funcs */
    xmlXPathFuncPtr funcs;		/* Array of defined funcs */

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

    /* Namespace traversal should be implemented with user */
    xmlNsPtr *namespaces;		/* The namespaces lookup */
    int nsNr;				/* the current Namespace index */
    void *user;				/* user defined extra info */

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

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


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 */
};


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
} xmlXPathError;

Create a new xmlNodeSetPtr of type double and of value val


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 */
};


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
} 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);

obj : 
type : 
Returns : 


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);

ctxt : 
nargs : 


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);

ctxt : 
cur : 
Returns : 


struct xmlXPathAxis

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


xmlXPathAxisPtr

typedef xmlXPathAxis *xmlXPathAxisPtr;


xmlXPathFunction ()

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

ctxt : 
nargs : 


CHECK_ERROR

#define     CHECK_ERROR


CHECK_ERROR0

#define     CHECK_ERROR0


XP_ERROR()

#define     XP_ERROR(X)

X : 


XP_ERROR0()

#define     XP_ERROR0(X)

X : 


CHECK_TYPE()

#define     CHECK_TYPE(typeval)

typeval : 


xmlXPathDebugDumpObject ()

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

output : 
cur : 
depth : 


xmlXPathNewParserContext ()

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

Create a new xmlXPathParserContext

str : the XPath expression
ctxt : the XPath context
Returns :the xmlXPathParserContext just allocated.


xmlXPathFreeParserContext ()

void        xmlXPathFreeParserContext       (xmlXPathParserContextPtr ctxt);

Free up an xmlXPathParserContext

ctxt : the context to free


valuePop ()

xmlXPathObjectPtr valuePop                  (xmlXPathParserContextPtr ctxt);

ctxt : 
Returns : 


valuePush ()

int         valuePush                       (xmlXPathParserContextPtr ctxt,
                                             xmlXPathObjectPtr value);

ctxt : 
value : 
Returns : 


xmlXPathNewString ()

xmlXPathObjectPtr xmlXPathNewString         (const xmlChar *val);

Create a new xmlXPathObjectPtr of type string and of value val

val : the xmlChar * value
Returns :the newly created object.


xmlXPathNewNodeSet ()

xmlXPathObjectPtr xmlXPathNewNodeSet        (xmlNodePtr val);

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

val : the NodePtr value
Returns :the newly created object.


xmlXPathNodeSetAdd ()

void        xmlXPathNodeSetAdd              (xmlNodeSetPtr cur,
                                             xmlNodePtr val);

add a new xmlNodePtr ot an existing NodeSet

cur : the initial node set
val : a new xmlNodePtr


xmlXPathIdFunction ()

void        xmlXPathIdFunction              (xmlXPathParserContextPtr ctxt,
                                             int nargs);

Implement the id() XPath function 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 : the XPath Parser context
nargs : 


xmlXPathRoot ()

void        xmlXPathRoot                    (xmlXPathParserContextPtr ctxt);

Initialize the context to the root of the document

ctxt : the XPath Parser context


xmlXPathEvalExpr ()

void        xmlXPathEvalExpr                (xmlXPathParserContextPtr ctxt);

[14] Expr ::= OrExpr [21] OrExpr ::= AndExpr | OrExpr 'or' AndExpr

Parse and evaluate an expression, then push the result on the stack

ctxt : the XPath Parser context


xmlXPathParseName ()

xmlChar*    xmlXPathParseName               (xmlXPathParserContextPtr ctxt);

parse an XML name

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

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

ctxt : the XPointer Parser context
Returns :the namespace name or NULL


xmlXPathRegisterFunc ()

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

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

ctxt : the XPath context
name : the function name
f : the function implementation or NULL
Returns :0 in case of success, -1 in case of error


xmlXPathRegisterVariable ()

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

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

ctxt : the XPath context
name : the variable name
value : the variable value or NULL
Returns :0 in case of success, -1 in case of error


xmlXPathInit ()

void        xmlXPathInit                    (void);

Initialize the XPath environment


xmlXPathNewContext ()

xmlXPathContextPtr xmlXPathNewContext       (xmlDocPtr doc);

Create a new xmlXPathContext

doc : the XML document
Returns :the xmlXPathContext just allocated.


xmlXPathFreeContext ()

void        xmlXPathFreeContext             (xmlXPathContextPtr ctxt);

Free up an xmlXPathContext

ctxt : the context to free


xmlXPathEval ()

xmlXPathObjectPtr xmlXPathEval              (const xmlChar *str,
                                             xmlXPathContextPtr ctxt);

Evaluate the XPath Location Path in the given context.

str : the XPath expression
ctxt : 
Returns :the xmlXPathObjectPtr resulting from the eveluation or NULL. the caller has to free the object.


xmlXPathEvalXPtrExpr ()

xmlXPathObjectPtr xmlXPathEvalXPtrExpr      (const xmlChar *str,
                                             xmlXPathContextPtr ctxt);

str : 
ctxt : 
Returns : 


xmlXPathFreeObject ()

void        xmlXPathFreeObject              (xmlXPathObjectPtr obj);

Free up an xmlXPathObjectPtr object.

obj : the object to free


xmlXPathEvalExpression ()

xmlXPathObjectPtr xmlXPathEvalExpression    (const xmlChar *str,
                                             xmlXPathContextPtr ctxt);

Evaluate the XPath expression in the given context.

str : the XPath expression
ctxt : the XPath context
Returns :the xmlXPathObjectPtr resulting from the evaluation or NULL. the caller has to free the object.


xmlXPathNodeSetCreate ()

xmlNodeSetPtr xmlXPathNodeSetCreate         (xmlNodePtr val);

Create a new xmlNodeSetPtr of type double and of value val

val : an initial xmlNodePtr, or NULL
Returns :the newly created object.


xmlXPathFreeNodeSetList ()

void        xmlXPathFreeNodeSetList         (xmlXPathObjectPtr obj);

Free up the xmlXPathObjectPtr obj but don't deallocate the objects in the list contrary to xmlXPathFreeObject().

obj : an existing NodeSetList object


xmlXPathFreeNodeSet ()

void        xmlXPathFreeNodeSet             (xmlNodeSetPtr obj);

Free the NodeSet compound (not the actual nodes !).

obj : the xmlNodeSetPtr to free


xmlXPathObjectCopy ()

xmlXPathObjectPtr xmlXPathObjectCopy        (xmlXPathObjectPtr val);

allocate a new copy of a given object

val : the original object
Returns :the newly created object.