xpath

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

typedef xmlXPathContext *xmlXPathContextPtr;

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

typedef xmlXPathParserContext *xmlXPathParserContextPtr;

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

typedef xmlNodeSet *xmlNodeSetPtr;

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 {
    xmlXPathObjectType type;
    xmlNodeSetPtr nodesetval;
    int boolval;
    double floatval;
    xmlChar *stringval;
    void *user;
    int index;
    void *user2;
    int index2;
};

typedef xmlXPathObject *xmlXPathObjectPtr;

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

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

typedef xmlXPathType *xmlXPathTypePtr;

struct xmlXPathVariable {
    const xmlChar       *name;		/* the variable name */
    xmlXPathObjectPtr value;		/* the value */
};

typedef xmlXPathVariable *xmlXPathVariablePtr;

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

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

typedef xmlXPathFunct *xmlXPathFuncPtr;

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

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

typedef xmlXPathAxis *xmlXPathAxisPtr;

struct xmlXPathCompExpr;

typedef xmlXPathCompExpr *xmlXPathCompExprPtr;

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

int         xmlXPathIsNaN                   (double val);

int         xmlXPathIsInf                   (double val);

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

#define     xmlXPathNodeSetItem(ns, index)

#define     xmlXPathNodeSetIsEmpty(ns)

void        xmlXPathFreeObject              (xmlXPathObjectPtr obj);

xmlNodeSetPtr xmlXPathNodeSetCreate         (xmlNodePtr val);

void        xmlXPathFreeNodeSetList         (xmlXPathObjectPtr obj);

void        xmlXPathFreeNodeSet             (xmlNodeSetPtr obj);

xmlXPathObjectPtr xmlXPathObjectCopy        (xmlXPathObjectPtr val);

int         xmlXPathCmpNodes                (xmlNodePtr node1,
                                             xmlNodePtr node2);

int         xmlXPathCastNumberToBoolean     (double val);

int         xmlXPathCastStringToBoolean     (const xmlChar *val);

int         xmlXPathCastNodeSetToBoolean    (xmlNodeSetPtr ns);

int         xmlXPathCastToBoolean           (xmlXPathObjectPtr val);

double      xmlXPathCastBooleanToNumber     (int val);

double      xmlXPathCastStringToNumber      (const xmlChar *val);

double      xmlXPathCastNodeToNumber        (xmlNodePtr node);

double      xmlXPathCastNodeSetToNumber     (xmlNodeSetPtr ns);

double      xmlXPathCastToNumber            (xmlXPathObjectPtr val);

xmlChar*    xmlXPathCastBooleanToString     (int val);

xmlChar*    xmlXPathCastNumberToString      (double val);

xmlChar*    xmlXPathCastNodeToString        (xmlNodePtr node);

xmlChar*    xmlXPathCastNodeSetToString     (xmlNodeSetPtr ns);

xmlChar*    xmlXPathCastToString            (xmlXPathObjectPtr val);

xmlXPathObjectPtr xmlXPathConvertBoolean    (xmlXPathObjectPtr val);

xmlXPathObjectPtr xmlXPathConvertNumber     (xmlXPathObjectPtr val);

xmlXPathObjectPtr xmlXPathConvertString     (xmlXPathObjectPtr val);

void        xmlXPathInit                    (void);

xmlXPathContextPtr xmlXPathNewContext       (xmlDocPtr doc);

void        xmlXPathFreeContext             (xmlXPathContextPtr ctxt);

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

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

int         xmlXPathEvalPredicate           (xmlXPathContextPtr ctxt,
                                             xmlXPathObjectPtr res);

xmlXPathCompExprPtr xmlXPathCompile         (const xmlChar *str);

xmlXPathObjectPtr xmlXPathCompiledEval      (xmlXPathCompExprPtr comp,
                                             xmlXPathContextPtr ctx);

void        xmlXPathFreeCompExpr            (xmlXPathCompExprPtr comp);