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

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

### 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,
        XPATH_UNDEF_PREFIX_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` : |

### xmlXPathInit ()

    void        xmlXPathInit                    (void);

Initialize the XPath environment

### xmlXPathNewContext ()

    xmlXPathContextPtr xmlXPathNewContext       (xmlDocPtr doc);

Create a new xmlXPathContext

`doc` : |
Returns : |

### xmlXPathFreeContext ()

    void        xmlXPathFreeContext             (xmlXPathContextPtr ctxt);

Free up an xmlXPathContext

`ctxt` : |

### 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` : |

### 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` : |
Returns : |

### xmlXPathFreeNodeSetList ()

    void        xmlXPathFreeNodeSetList         (xmlXPathObjectPtr obj);

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

`obj` : |

### xmlXPathFreeNodeSet ()

    void        xmlXPathFreeNodeSet             (xmlNodeSetPtr obj);

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

`obj` : |

### xmlXPathObjectCopy ()

    xmlXPathObjectPtr xmlXPathObjectCopy        (xmlXPathObjectPtr val);

allocate a new copy of a given object

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

<<< Previous Page | Home | Up | Next Page >>>
HTMLtree | xpathInternals