@img/sharp-libvips-dev 1.2.2 → 1.2.4-rc.0

package/include/libxml2/libxml/xpath.h

@@ -1,6 +1,9 @@
-/*
- * Summary: XML Path Language implementation
- * Description: API for the XML Path Language implementation
+/**
+ * @file
+ * 
+ * @brief XML Path Language implementation
+ * 
+ * API for the XML Path Language implementation
  *
  * XML Path Language implementation
  * XPath is a language for addressing parts of an XML document,
@@ -11,9 +14,9 @@
  * W3C Recommendation 16 November 1999
  *     http://www.w3.org/TR/1999/REC-xpath-19991116
  *
- * Copy: See Copyright for the status of this software.
+ * @copyright See Copyright for the status of this software.
  *
- * Author: Daniel Veillard
+ * @author Daniel Veillard
  */
 
 #ifndef __XML_XPATH_H__
@@ -31,8 +34,10 @@
 extern "C" {
 #endif
 
+/** XPath context */
 typedef struct _xmlXPathContext xmlXPathContext;
 typedef xmlXPathContext *xmlXPathContextPtr;
+/** XPath parser and evaluation context */
 typedef struct _xmlXPathParserContext xmlXPathParserContext;
 typedef xmlXPathParserContext *xmlXPathParserContextPtr;
 
@@ -70,29 +75,30 @@ typedef enum {
     XPATH_RECURSION_LIMIT_EXCEEDED
 } xmlXPathError;
 
-/*
- * A node-set (an unordered collection of nodes without duplicates).
- */
+/** XPath node set */
 typedef struct _xmlNodeSet xmlNodeSet;
 typedef xmlNodeSet *xmlNodeSetPtr;
+/**
+ * A node-set (an unordered collection of nodes without duplicates).
+ */
 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 whether namespace nodes should be looked at @@ */
+    /** number of nodes in the set */
+    int nodeNr;
+    /** size of the array as allocated */
+    int nodeMax;
+    /** array of nodes in no particular order */
+    xmlNode **nodeTab;
 };
 
-/*
+/**
  * An expression is evaluated to yield an object, which
  * has one of the following four basic types:
+ *
  *   - node-set
  *   - boolean
  *   - number
  *   - string
- *
- * @@ XPointer will add more types !
  */
-
 typedef enum {
     XPATH_UNDEFINED = 0,
     XPATH_NODESET = 1,
@@ -103,19 +109,28 @@ typedef enum {
     XPATH_XSLT_TREE = 9  /* An XSLT value tree, non modifiable */
 } xmlXPathObjectType;
 
-/** DOC_DISABLE */
+/** @cond IGNORE */
 #define XPATH_POINT 5
 #define XPATH_RANGE 6
 #define XPATH_LOCATIONSET 7
-/** DOC_ENABLE */
+/** @endcond */
 
+/** XPath object */
 typedef struct _xmlXPathObject xmlXPathObject;
 typedef xmlXPathObject *xmlXPathObjectPtr;
+/**
+ * An XPath object
+ */
 struct _xmlXPathObject {
+    /** object type */
     xmlXPathObjectType type;
-    xmlNodeSetPtr nodesetval;
+    /** node set */
+    xmlNodeSet *nodesetval;
+    /** boolean */
     int boolval;
+    /** number */
     double floatval;
+    /** string */
     xmlChar *stringval;
     void *user;
     int index;
@@ -123,22 +138,12 @@ struct _xmlXPathObject {
     int index2;
 };
 
-/**
- * xmlXPathConvertFunc:
- * @obj:  an XPath object
- * @type:  the number of the target type
- *
- * A conversion function is associated to a type and used to cast
- * the new type to primitive values.
- *
- * Returns -1 in case of error, 0 otherwise
- */
-typedef int (*xmlXPathConvertFunc) (xmlXPathObjectPtr obj, int type);
+/** @cond ignore */
 
 /*
- * Extra type: a name and a conversion function.
+ * unused
  */
-
+typedef int (*xmlXPathConvertFunc) (xmlXPathObject *obj, int type);
 typedef struct _xmlXPathType xmlXPathType;
 typedef xmlXPathType *xmlXPathTypePtr;
 struct _xmlXPathType {
@@ -147,31 +152,20 @@ struct _xmlXPathType {
 };
 
 /*
- * Extra variable: a name and a value.
+ * unused
  */
-
 typedef struct _xmlXPathVariable xmlXPathVariable;
 typedef xmlXPathVariable *xmlXPathVariablePtr;
 struct _xmlXPathVariable {
     const xmlChar       *name;		/* the variable name */
-    xmlXPathObjectPtr value;		/* the value */
+    xmlXPathObject *value;		/* the value */
 };
 
-/**
- * xmlXPathEvalFunc:
- * @ctxt: an XPath parser context
- * @nargs: the number of arguments passed to the function
- *
- * An XPath evaluation function, the parameters are on the XPath context stack.
- */
-
-typedef void (*xmlXPathEvalFunc)(xmlXPathParserContextPtr ctxt,
-	                         int nargs);
-
 /*
- * Extra function: a name and a evaluation function.
+ * unused
  */
-
+typedef void (*xmlXPathEvalFunc)(xmlXPathParserContext *ctxt,
+	                         int nargs);
 typedef struct _xmlXPathFunct xmlXPathFunct;
 typedef xmlXPathFunct *xmlXPathFuncPtr;
 struct _xmlXPathFunct {
@@ -179,25 +173,11 @@ struct _xmlXPathFunct {
     xmlXPathEvalFunc func;		/* the evaluation function */
 };
 
-/**
- * xmlXPathAxisFunc:
- * @ctxt:  the XPath interpreter context
- * @cur:  the previous node being explored on that axis
- *
- * 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.
- *
- * Returns the next node in that axis or NULL if at the end of the axis.
- */
-
-typedef xmlXPathObjectPtr (*xmlXPathAxisFunc) (xmlXPathParserContextPtr ctxt,
-				 xmlXPathObjectPtr cur);
-
 /*
- * Extra axis: a name and an axis function.
+ * unused
  */
-
+typedef xmlXPathObject *(*xmlXPathAxisFunc) (xmlXPathParserContext *ctxt,
+				 xmlXPathObject *cur);
 typedef struct _xmlXPathAxis xmlXPathAxis;
 typedef xmlXPathAxis *xmlXPathAxisPtr;
 struct _xmlXPathAxis {
@@ -205,72 +185,62 @@ struct _xmlXPathAxis {
     xmlXPathAxisFunc func;		/* the search function */
 };
 
+/** @endcond */
+
 /**
- * xmlXPathFunction:
- * @ctxt:  the XPath interprestation context
- * @nargs:  the number of arguments
- *
  * An XPath function.
  * The arguments (if any) are popped out from the context stack
  * and the result is pushed on the stack.
+ *
+ * @param ctxt  the XPath interprestation context
+ * @param nargs  the number of arguments
  */
 
-typedef void (*xmlXPathFunction) (xmlXPathParserContextPtr ctxt, int nargs);
+typedef void (*xmlXPathFunction) (xmlXPathParserContext *ctxt, int nargs);
 
 /*
  * Function and Variable Lookup.
  */
 
 /**
- * xmlXPathVariableLookupFunc:
- * @ctxt:  an XPath context
- * @name:  name of the variable
- * @ns_uri:  the namespace name hosting this variable
- *
  * Prototype for callbacks used to plug variable lookup in the XPath
  * engine.
  *
- * Returns the XPath object value or NULL if not found.
+ * @param ctxt  an XPath context
+ * @param name  name of the variable
+ * @param ns_uri  the namespace name hosting this variable
+ * @returns the XPath object value or NULL if not found.
  */
-typedef xmlXPathObjectPtr (*xmlXPathVariableLookupFunc) (void *ctxt,
+typedef xmlXPathObject *(*xmlXPathVariableLookupFunc) (void *ctxt,
                                          const xmlChar *name,
                                          const xmlChar *ns_uri);
 
 /**
- * xmlXPathFuncLookupFunc:
- * @ctxt:  an XPath context
- * @name:  name of the function
- * @ns_uri:  the namespace name hosting this function
- *
  * Prototype for callbacks used to plug function lookup in the XPath
  * engine.
  *
- * Returns the XPath function or NULL if not found.
+ * @param ctxt  an XPath context
+ * @param name  name of the function
+ * @param ns_uri  the namespace name hosting this function
+ * @returns the XPath function or NULL if not found.
  */
 typedef xmlXPathFunction (*xmlXPathFuncLookupFunc) (void *ctxt,
 					 const xmlChar *name,
 					 const xmlChar *ns_uri);
 
 /**
- * xmlXPathFlags:
  * Flags for XPath engine compilation and runtime
  */
 /**
- * XML_XPATH_CHECKNS:
- *
  * check namespaces at compilation
  */
 #define XML_XPATH_CHECKNS (1<<0)
 /**
- * XML_XPATH_NOVAR:
- *
  * forbid variables in expression
  */
 #define XML_XPATH_NOVAR	  (1<<1)
 
 /**
- * xmlXPathContext:
- *
  * Expression evaluation occurs with respect to a context.
  * he context consists of:
  *    - a node (the context node)
@@ -284,71 +254,98 @@ typedef xmlXPathFunction (*xmlXPathFuncLookupFunc) (void *ctxt,
  * for an XPath evaluation so you may need to initialize it again
  * before the next call.
  */
-
 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;				/* is 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 */
-    xmlXPathVariableLookupFunc varLookupFunc;/* variable lookup func */
-    void *varLookupData;		/* variable lookup data */
-
-    /* Possibility to link in an extra item */
-    void *extra;                        /* needed for XSLT */
+    /** The current document */
+    xmlDoc *doc;
+    /** The current node */
+    xmlNode *node;
+
+    /* unused (hash table) */
+    int nb_variables_unused;
+    /* unused (hash table) */
+    int max_variables_unused;
+    /* Hash table of defined variables */
+    xmlHashTable *varHash;
+
+    /* number of defined types */
+    int nb_types;
+    /* max number of types */
+    int max_types;
+    /* Array of defined types */
+    xmlXPathType *types;
+
+    /* unused (hash table) */
+    int nb_funcs_unused;
+    /* unused (hash table) */
+    int max_funcs_unused;
+    /* Hash table of defined funcs */
+    xmlHashTable *funcHash;
+
+    /* number of defined axis */
+    int nb_axis;
+    /* max number of axis */
+    int max_axis;
+    /* Array of defined axis */
+    xmlXPathAxis *axis;
+
+    /* Array of namespaces */
+    xmlNs **namespaces;
+    /* number of namespace in scope */
+    int nsNr;
+    /* function to free */
+    void *user;
 
-    /* The function name and URI when calling a function */
+    /** the context size */
+    int contextSize;
+    /** the proximity position */
+    int proximityPosition;
+
+    /* is this an XPointer context? */
+    int xptr;
+    /* for here() */
+    xmlNode *here;
+    /* for origin() */
+    xmlNode *origin;
+
+    /* The namespaces hash table */
+    xmlHashTable *nsHash;
+    /* variable lookup func */
+    xmlXPathVariableLookupFunc varLookupFunc;
+    /* variable lookup data */
+    void *varLookupData;
+
+    /* needed for XSLT */
+    void *extra;
+
+    /* The function name when calling a function */
     const xmlChar *function;
+    /* The namespace URI when calling a function */
     const xmlChar *functionURI;
 
-    /* function lookup function and data */
-    xmlXPathFuncLookupFunc funcLookupFunc;/* function lookup func */
-    void *funcLookupData;		/* function lookup data */
+    /* function lookup func */
+    xmlXPathFuncLookupFunc funcLookupFunc;
+    /* function lookup data */
+    void *funcLookupData;
 
-    /* temporary namespace lists kept for walking the namespace axis */
-    xmlNsPtr *tmpNsList;		/* Array of namespaces */
-    int tmpNsNr;			/* number of namespaces in scope */
+    /* Array of temp namespaces */
+    xmlNs **tmpNsList;
+    /* number of namespaces in scope */
+    int tmpNsNr;
 
-    /* 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 */
+    /* user specific data block */
+    void *userData;
+    /* the callback in case of errors */
+    xmlStructuredErrorFunc error;
+    /* the last error */
+    xmlError lastError;
+    /* the source node XSLT */
+    xmlNode *debugNode;
 
-    /* dictionary */
-    xmlDictPtr dict;			/* dictionary if any */
+    /* dictionary if any */
+    xmlDict *dict;
 
-    int flags;				/* flags to control compilation */
+    /** flags to control compilation */
+    int flags;
 
     /* Cache for reusal of XPath objects */
     void *cache;
@@ -359,36 +356,45 @@ struct _xmlXPathContext {
     int depth;
 };
 
-/*
- * The structure of a compiled expression form is not public.
- */
-
+/** Compiled XPath expression */
 typedef struct _xmlXPathCompExpr xmlXPathCompExpr;
 typedef xmlXPathCompExpr *xmlXPathCompExprPtr;
 
 /**
- * xmlXPathParserContext:
- *
  * An XPath parser context. It contains pure parsing information,
  * an xmlXPathContext, and the stack of objects.
+ *
+ * This struct is used for evaluation as well and misnamed.
  */
 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 */
-
-    int              valueFrame;        /* always zero for compatibility */
+    /* the current char being parsed */
+    const xmlChar *cur;
+    /* the full expression */
+    const xmlChar *base;
+
+    /** error code */
+    int error;
+
+    /** the evaluation context */
+    xmlXPathContext    *context;
+    /** the current value */
+    xmlXPathObject       *value;
+    /* number of values stacked */
+    int                 valueNr;
+    /* max number of values stacked */
+    int                valueMax;
+    /* stack of values */
+    xmlXPathObject **valueTab;
+
+    /* the precompiled expression */
+    xmlXPathCompExpr *comp;
+    /* it this an XPointer expression */
+    int xptr;
+    /* used for walking preceding axis */
+    xmlNode           *ancestor;
+
+    /* always zero for compatibility */
+    int              valueFrame;
 };
 
 /************************************************************************
@@ -401,6 +407,8 @@ struct _xmlXPathParserContext {
  * Objects and Nodesets handling
  */
 
+/** @cond ignore */
+
 XML_DEPRECATED
 XMLPUBVAR double xmlXPathNAN;
 XML_DEPRECATED
@@ -410,23 +418,19 @@ XMLPUBVAR double xmlXPathNINF;
 
 /* These macros may later turn into functions */
 /**
- * xmlXPathNodeSetGetLength:
- * @ns:  a node-set
- *
  * Implement a functionality similar to the DOM NodeList.length.
  *
- * Returns the number of nodes in the node-set.
+ * @param ns  a node-set
+ * @returns the number of nodes in the node-set.
  */
 #define xmlXPathNodeSetGetLength(ns) ((ns) ? (ns)->nodeNr : 0)
 /**
- * xmlXPathNodeSetItem:
- * @ns:  a node-set
- * @index:  index of a node in the set
- *
  * Implements a functionality similar to the DOM NodeList.item().
  *
- * Returns the xmlNodePtr at the given @index in @ns or NULL if
- *         @index is out of range (0 to length-1)
+ * @param ns  a node-set
+ * @param index  index of a node in the set
+ * @returns the xmlNode at the given `index` in `ns` or NULL if
+ *         `index` is out of range (0 to length-1)
  */
 #define xmlXPathNodeSetItem(ns, index)				\
 		((((ns) != NULL) &&				\
@@ -434,30 +438,29 @@ XMLPUBVAR double xmlXPathNINF;
 		 (ns)->nodeTab[(index)]				\
 		 : NULL)
 /**
- * xmlXPathNodeSetIsEmpty:
- * @ns: a node-set
- *
- * Checks whether @ns is empty or not.
+ * Checks whether `ns` is empty or not.
  *
- * Returns %TRUE if @ns is an empty node-set.
+ * @param ns  a node-set
+ * @returns %TRUE if `ns` is an empty node-set.
  */
 #define xmlXPathNodeSetIsEmpty(ns)                                      \
     (((ns) == NULL) || ((ns)->nodeNr == 0) || ((ns)->nodeTab == NULL))
 
+/** @endcond */
 
 XMLPUBFUN void
-		    xmlXPathFreeObject		(xmlXPathObjectPtr obj);
-XMLPUBFUN xmlNodeSetPtr
-		    xmlXPathNodeSetCreate	(xmlNodePtr val);
+		    xmlXPathFreeObject		(xmlXPathObject *obj);
+XMLPUBFUN xmlNodeSet *
+		    xmlXPathNodeSetCreate	(xmlNode *val);
 XMLPUBFUN void
-		    xmlXPathFreeNodeSetList	(xmlXPathObjectPtr obj);
+		    xmlXPathFreeNodeSetList	(xmlXPathObject *obj);
 XMLPUBFUN void
-		    xmlXPathFreeNodeSet		(xmlNodeSetPtr obj);
-XMLPUBFUN xmlXPathObjectPtr
-		    xmlXPathObjectCopy		(xmlXPathObjectPtr val);
+		    xmlXPathFreeNodeSet		(xmlNodeSet *obj);
+XMLPUBFUN xmlXPathObject *
+		    xmlXPathObjectCopy		(xmlXPathObject *val);
 XMLPUBFUN int
-		    xmlXPathCmpNodes		(xmlNodePtr node1,
-						 xmlNodePtr node2);
+		    xmlXPathCmpNodes		(xmlNode *node1,
+						 xmlNode *node2);
 /**
  * Conversion functions to basic types.
  */
@@ -466,52 +469,52 @@ XMLPUBFUN int
 XMLPUBFUN int
 		    xmlXPathCastStringToBoolean	(const xmlChar * val);
 XMLPUBFUN int
-		    xmlXPathCastNodeSetToBoolean(xmlNodeSetPtr ns);
+		    xmlXPathCastNodeSetToBoolean(xmlNodeSet *ns);
 XMLPUBFUN int
-		    xmlXPathCastToBoolean	(xmlXPathObjectPtr val);
+		    xmlXPathCastToBoolean	(xmlXPathObject *val);
 
 XMLPUBFUN double
 		    xmlXPathCastBooleanToNumber	(int val);
 XMLPUBFUN double
 		    xmlXPathCastStringToNumber	(const xmlChar * val);
 XMLPUBFUN double
-		    xmlXPathCastNodeToNumber	(xmlNodePtr node);
+		    xmlXPathCastNodeToNumber	(xmlNode *node);
 XMLPUBFUN double
-		    xmlXPathCastNodeSetToNumber	(xmlNodeSetPtr ns);
+		    xmlXPathCastNodeSetToNumber	(xmlNodeSet *ns);
 XMLPUBFUN double
-		    xmlXPathCastToNumber	(xmlXPathObjectPtr val);
+		    xmlXPathCastToNumber	(xmlXPathObject *val);
 
 XMLPUBFUN xmlChar *
 		    xmlXPathCastBooleanToString	(int val);
 XMLPUBFUN xmlChar *
 		    xmlXPathCastNumberToString	(double val);
 XMLPUBFUN xmlChar *
-		    xmlXPathCastNodeToString	(xmlNodePtr node);
+		    xmlXPathCastNodeToString	(xmlNode *node);
 XMLPUBFUN xmlChar *
-		    xmlXPathCastNodeSetToString	(xmlNodeSetPtr ns);
+		    xmlXPathCastNodeSetToString	(xmlNodeSet *ns);
 XMLPUBFUN xmlChar *
-		    xmlXPathCastToString	(xmlXPathObjectPtr val);
+		    xmlXPathCastToString	(xmlXPathObject *val);
 
-XMLPUBFUN xmlXPathObjectPtr
-		    xmlXPathConvertBoolean	(xmlXPathObjectPtr val);
-XMLPUBFUN xmlXPathObjectPtr
-		    xmlXPathConvertNumber	(xmlXPathObjectPtr val);
-XMLPUBFUN xmlXPathObjectPtr
-		    xmlXPathConvertString	(xmlXPathObjectPtr val);
+XMLPUBFUN xmlXPathObject *
+		    xmlXPathConvertBoolean	(xmlXPathObject *val);
+XMLPUBFUN xmlXPathObject *
+		    xmlXPathConvertNumber	(xmlXPathObject *val);
+XMLPUBFUN xmlXPathObject *
+		    xmlXPathConvertString	(xmlXPathObject *val);
 
 /**
  * Context handling.
  */
-XMLPUBFUN xmlXPathContextPtr
-		    xmlXPathNewContext		(xmlDocPtr doc);
+XMLPUBFUN xmlXPathContext *
+		    xmlXPathNewContext		(xmlDoc *doc);
 XMLPUBFUN void
-		    xmlXPathFreeContext		(xmlXPathContextPtr ctxt);
+		    xmlXPathFreeContext		(xmlXPathContext *ctxt);
 XMLPUBFUN void
-		    xmlXPathSetErrorHandler(xmlXPathContextPtr ctxt,
+		    xmlXPathSetErrorHandler(xmlXPathContext *ctxt,
 					    xmlStructuredErrorFunc handler,
 					    void *context);
 XMLPUBFUN int
-		    xmlXPathContextSetCache(xmlXPathContextPtr ctxt,
+		    xmlXPathContextSetCache(xmlXPathContext *ctxt,
 				            int active,
 					    int value,
 					    int options);
@@ -519,39 +522,39 @@ XMLPUBFUN int
  * Evaluation functions.
  */
 XMLPUBFUN long
-		    xmlXPathOrderDocElems	(xmlDocPtr doc);
+		    xmlXPathOrderDocElems	(xmlDoc *doc);
 XMLPUBFUN int
-		    xmlXPathSetContextNode	(xmlNodePtr node,
-						 xmlXPathContextPtr ctx);
-XMLPUBFUN xmlXPathObjectPtr
-		    xmlXPathNodeEval		(xmlNodePtr node,
+		    xmlXPathSetContextNode	(xmlNode *node,
+						 xmlXPathContext *ctx);
+XMLPUBFUN xmlXPathObject *
+		    xmlXPathNodeEval		(xmlNode *node,
 						 const xmlChar *str,
-						 xmlXPathContextPtr ctx);
-XMLPUBFUN xmlXPathObjectPtr
+						 xmlXPathContext *ctx);
+XMLPUBFUN xmlXPathObject *
 		    xmlXPathEval		(const xmlChar *str,
-						 xmlXPathContextPtr ctx);
-XMLPUBFUN xmlXPathObjectPtr
+						 xmlXPathContext *ctx);
+XMLPUBFUN xmlXPathObject *
 		    xmlXPathEvalExpression	(const xmlChar *str,
-						 xmlXPathContextPtr ctxt);
+						 xmlXPathContext *ctxt);
 XMLPUBFUN int
-		    xmlXPathEvalPredicate	(xmlXPathContextPtr ctxt,
-						 xmlXPathObjectPtr res);
+		    xmlXPathEvalPredicate	(xmlXPathContext *ctxt,
+						 xmlXPathObject *res);
 /**
  * Separate compilation/evaluation entry points.
  */
-XMLPUBFUN xmlXPathCompExprPtr
+XMLPUBFUN xmlXPathCompExpr *
 		    xmlXPathCompile		(const xmlChar *str);
-XMLPUBFUN xmlXPathCompExprPtr
-		    xmlXPathCtxtCompile		(xmlXPathContextPtr ctxt,
+XMLPUBFUN xmlXPathCompExpr *
+		    xmlXPathCtxtCompile		(xmlXPathContext *ctxt,
 						 const xmlChar *str);
-XMLPUBFUN xmlXPathObjectPtr
-		    xmlXPathCompiledEval	(xmlXPathCompExprPtr comp,
-						 xmlXPathContextPtr ctx);
+XMLPUBFUN xmlXPathObject *
+		    xmlXPathCompiledEval	(xmlXPathCompExpr *comp,
+						 xmlXPathContext *ctx);
 XMLPUBFUN int
-		    xmlXPathCompiledEvalToBoolean(xmlXPathCompExprPtr comp,
-						 xmlXPathContextPtr ctxt);
+		    xmlXPathCompiledEvalToBoolean(xmlXPathCompExpr *comp,
+						 xmlXPathContext *ctxt);
 XMLPUBFUN void
-		    xmlXPathFreeCompExpr	(xmlXPathCompExprPtr comp);
+		    xmlXPathFreeCompExpr	(xmlXPathCompExpr *comp);
 
 XML_DEPRECATED
 XMLPUBFUN void