xpath.h@ 43891

Last change on this file since 43891 was 42884, checked in by vboxsync, 12 years ago
libxml: patch from upstream
Property svn:eol-style set to `native`
File size: 15.8 KB

Line
1	/*
2	* Summary: XML Path Language implementation
3	* Description: API for the XML Path Language implementation
4	*
5	* XML Path Language implementation
6	* XPath is a language for addressing parts of an XML document,
7	* designed to be used by both XSLT and XPointer
8	* http://www.w3.org/TR/xpath
9	*
10	* Implements
11	* W3C Recommendation 16 November 1999
12	* http://www.w3.org/TR/1999/REC-xpath-19991116
13	*
14	* Copy: See Copyright for the status of this software.
15	*
16	* Author: Daniel Veillard
17	*/
18
19	#ifndef __XML_XPATH_H__
20	#define __XML_XPATH_H__
21
22	#include <libxml/xmlversion.h>
23
24	#ifdef LIBXML_XPATH_ENABLED
25
26	#include <libxml/xmlerror.h>
27	#include <libxml/tree.h>
28	#include <libxml/hash.h>
29	#endif /* LIBXML_XPATH_ENABLED */
30
31	#if defined(LIBXML_XPATH_ENABLED) \|\| defined(LIBXML_SCHEMAS_ENABLED)
32	#ifdef __cplusplus
33	extern "C" {
34	#endif
35	#endif /* LIBXML_XPATH_ENABLED or LIBXML_SCHEMAS_ENABLED */
36
37	#ifdef LIBXML_XPATH_ENABLED
38
39	typedef struct _xmlXPathContext xmlXPathContext;
40	typedef xmlXPathContext *xmlXPathContextPtr;
41	typedef struct _xmlXPathParserContext xmlXPathParserContext;
42	typedef xmlXPathParserContext *xmlXPathParserContextPtr;
43
44	/**
45	* The set of XPath error codes.
46	*/
47
48	typedef enum {
49	XPATH_EXPRESSION_OK = 0,
50	XPATH_NUMBER_ERROR,
51	XPATH_UNFINISHED_LITERAL_ERROR,
52	XPATH_START_LITERAL_ERROR,
53	XPATH_VARIABLE_REF_ERROR,
54	XPATH_UNDEF_VARIABLE_ERROR,
55	XPATH_INVALID_PREDICATE_ERROR,
56	XPATH_EXPR_ERROR,
57	XPATH_UNCLOSED_ERROR,
58	XPATH_UNKNOWN_FUNC_ERROR,
59	XPATH_INVALID_OPERAND,
60	XPATH_INVALID_TYPE,
61	XPATH_INVALID_ARITY,
62	XPATH_INVALID_CTXT_SIZE,
63	XPATH_INVALID_CTXT_POSITION,
64	XPATH_MEMORY_ERROR,
65	XPTR_SYNTAX_ERROR,
66	XPTR_RESOURCE_ERROR,
67	XPTR_SUB_RESOURCE_ERROR,
68	XPATH_UNDEF_PREFIX_ERROR,
69	XPATH_ENCODING_ERROR,
70	XPATH_INVALID_CHAR_ERROR,
71	XPATH_INVALID_CTXT,
72	XPATH_STACK_ERROR
73	} xmlXPathError;
74
75	/*
76	* A node-set (an unordered collection of nodes without duplicates).
77	*/
78	typedef struct _xmlNodeSet xmlNodeSet;
79	typedef xmlNodeSet *xmlNodeSetPtr;
80	struct _xmlNodeSet {
81	int nodeNr; /* number of nodes in the set */
82	int nodeMax; /* size of the array as allocated */
83	xmlNodePtr nodeTab; / array of nodes in no particular order */
84	/* @@ with_ns to check wether namespace nodes should be looked at @@ */
85	};
86
87	/*
88	* An expression is evaluated to yield an object, which
89	* has one of the following four basic types:
90	* - node-set
91	* - boolean
92	* - number
93	* - string
94	*
95	* @@ XPointer will add more types !
96	*/
97
98	typedef enum {
99	XPATH_UNDEFINED = 0,
100	XPATH_NODESET = 1,
101	XPATH_BOOLEAN = 2,
102	XPATH_NUMBER = 3,
103	XPATH_STRING = 4,
104	XPATH_POINT = 5,
105	XPATH_RANGE = 6,
106	XPATH_LOCATIONSET = 7,
107	XPATH_USERS = 8,
108	XPATH_XSLT_TREE = 9 /* An XSLT value tree, non modifiable */
109	} xmlXPathObjectType;
110
111	typedef struct _xmlXPathObject xmlXPathObject;
112	typedef xmlXPathObject *xmlXPathObjectPtr;
113	struct _xmlXPathObject {
114	xmlXPathObjectType type;
115	xmlNodeSetPtr nodesetval;
116	int boolval;
117	double floatval;
118	xmlChar *stringval;
119	void *user;
120	int index;
121	void *user2;
122	int index2;
123	};
124
125	/**
126	* xmlXPathConvertFunc:
127	* @obj: an XPath object
128	* @type: the number of the target type
129	*
130	* A conversion function is associated to a type and used to cast
131	* the new type to primitive values.
132	*
133	* Returns -1 in case of error, 0 otherwise
134	*/
135	typedef int (*xmlXPathConvertFunc) (xmlXPathObjectPtr obj, int type);
136
137	/*
138	* Extra type: a name and a conversion function.
139	*/
140
141	typedef struct _xmlXPathType xmlXPathType;
142	typedef xmlXPathType *xmlXPathTypePtr;
143	struct _xmlXPathType {
144	const xmlChar name; / the type name */
145	xmlXPathConvertFunc func; /* the conversion function */
146	};
147
148	/*
149	* Extra variable: a name and a value.
150	*/
151
152	typedef struct _xmlXPathVariable xmlXPathVariable;
153	typedef xmlXPathVariable *xmlXPathVariablePtr;
154	struct _xmlXPathVariable {
155	const xmlChar name; / the variable name */
156	xmlXPathObjectPtr value; /* the value */
157	};
158
159	/**
160	* xmlXPathEvalFunc:
161	* @ctxt: an XPath parser context
162	* @nargs: the number of arguments passed to the function
163	*
164	* An XPath evaluation function, the parameters are on the XPath context stack.
165	*/
166
167	typedef void (*xmlXPathEvalFunc)(xmlXPathParserContextPtr ctxt,
168	int nargs);
169
170	/*
171	* Extra function: a name and a evaluation function.
172	*/
173
174	typedef struct _xmlXPathFunct xmlXPathFunct;
175	typedef xmlXPathFunct *xmlXPathFuncPtr;
176	struct _xmlXPathFunct {
177	const xmlChar name; / the function name */
178	xmlXPathEvalFunc func; /* the evaluation function */
179	};
180
181	/**
182	* xmlXPathAxisFunc:
183	* @ctxt: the XPath interpreter context
184	* @cur: the previous node being explored on that axis
185	*
186	* An axis traversal function. To traverse an axis, the engine calls
187	* the first time with cur == NULL and repeat until the function returns
188	* NULL indicating the end of the axis traversal.
189	*
190	* Returns the next node in that axis or NULL if at the end of the axis.
191	*/
192
193	typedef xmlXPathObjectPtr (*xmlXPathAxisFunc) (xmlXPathParserContextPtr ctxt,
194	xmlXPathObjectPtr cur);
195
196	/*
197	* Extra axis: a name and an axis function.
198	*/
199
200	typedef struct _xmlXPathAxis xmlXPathAxis;
201	typedef xmlXPathAxis *xmlXPathAxisPtr;
202	struct _xmlXPathAxis {
203	const xmlChar name; / the axis name */
204	xmlXPathAxisFunc func; /* the search function */
205	};
206
207	/**
208	* xmlXPathFunction:
209	* @ctxt: the XPath interprestation context
210	* @nargs: the number of arguments
211	*
212	* An XPath function.
213	* The arguments (if any) are popped out from the context stack
214	* and the result is pushed on the stack.
215	*/
216
217	typedef void (*xmlXPathFunction) (xmlXPathParserContextPtr ctxt, int nargs);
218
219	/*
220	* Function and Variable Lookup.
221	*/
222
223	/**
224	* xmlXPathVariableLookupFunc:
225	* @ctxt: an XPath context
226	* @name: name of the variable
227	* @ns_uri: the namespace name hosting this variable
228	*
229	* Prototype for callbacks used to plug variable lookup in the XPath
230	* engine.
231	*
232	* Returns the XPath object value or NULL if not found.
233	*/
234	typedef xmlXPathObjectPtr (xmlXPathVariableLookupFunc) (void ctxt,
235	const xmlChar *name,
236	const xmlChar *ns_uri);
237
238	/**
239	* xmlXPathFuncLookupFunc:
240	* @ctxt: an XPath context
241	* @name: name of the function
242	* @ns_uri: the namespace name hosting this function
243	*
244	* Prototype for callbacks used to plug function lookup in the XPath
245	* engine.
246	*
247	* Returns the XPath function or NULL if not found.
248	*/
249	typedef xmlXPathFunction (xmlXPathFuncLookupFunc) (void ctxt,
250	const xmlChar *name,
251	const xmlChar *ns_uri);
252
253	/**
254	* xmlXPathFlags:
255	* Flags for XPath engine compilation and runtime
256	*/
257	/**
258	* XML_XPATH_CHECKNS:
259	*
260	* check namespaces at compilation
261	*/
262	#define XML_XPATH_CHECKNS (1<<0)
263	/**
264	* XML_XPATH_NOVAR:
265	*
266	* forbid variables in expression
267	*/
268	#define XML_XPATH_NOVAR (1<<1)
269
270	/**
271	* xmlXPathContext:
272	*
273	* Expression evaluation occurs with respect to a context.
274	* he context consists of:
275	* - a node (the context node)
276	* - a node list (the context node list)
277	* - a set of variable bindings
278	* - a function library
279	* - the set of namespace declarations in scope for the expression
280	* Following the switch to hash tables, this need to be trimmed up at
281	* the next binary incompatible release.
282	*/
283
284	struct _xmlXPathContext {
285	xmlDocPtr doc; /* The current document */
286	xmlNodePtr node; /* The current node */
287
288	int nb_variables_unused; /* unused (hash table) */
289	int max_variables_unused; /* unused (hash table) */
290	xmlHashTablePtr varHash; /* Hash table of defined variables */
291
292	int nb_types; /* number of defined types */
293	int max_types; /* max number of types */
294	xmlXPathTypePtr types; /* Array of defined types */
295
296	int nb_funcs_unused; /* unused (hash table) */
297	int max_funcs_unused; /* unused (hash table) */
298	xmlHashTablePtr funcHash; /* Hash table of defined funcs */
299
300	int nb_axis; /* number of defined axis */
301	int max_axis; /* max number of axis */
302	xmlXPathAxisPtr axis; /* Array of defined axis */
303
304	/* the namespace nodes of the context node */
305	xmlNsPtr namespaces; / Array of namespaces */
306	int nsNr; /* number of namespace in scope */
307	void user; / function to free */
308
309	/* extra variables */
310	int contextSize; /* the context size */
311	int proximityPosition; /* the proximity position */
312
313	/* extra stuff for XPointer */
314	int xptr; /* is this an XPointer context? */
315	xmlNodePtr here; /* for here() */
316	xmlNodePtr origin; /* for origin() */
317
318	/* the set of namespace declarations in scope for the expression */
319	xmlHashTablePtr nsHash; /* The namespaces hash table */
320	xmlXPathVariableLookupFunc varLookupFunc;/* variable lookup func */
321	void varLookupData; / variable lookup data */
322
323	/* Possibility to link in an extra item */
324	void extra; / needed for XSLT */
325
326	/* The function name and URI when calling a function */
327	const xmlChar *function;
328	const xmlChar *functionURI;
329
330	/* function lookup function and data */
331	xmlXPathFuncLookupFunc funcLookupFunc;/* function lookup func */
332	void funcLookupData; / function lookup data */
333
334	/* temporary namespace lists kept for walking the namespace axis */
335	xmlNsPtr tmpNsList; / Array of namespaces */
336	int tmpNsNr; /* number of namespaces in scope */
337
338	/* error reporting mechanism */
339	void userData; / user specific data block */
340	xmlStructuredErrorFunc error; /* the callback in case of errors */
341	xmlError lastError; /* the last error */
342	xmlNodePtr debugNode; /* the source node XSLT */
343
344	/* dictionary */
345	xmlDictPtr dict; /* dictionary if any */
346
347	int flags; /* flags to control compilation */
348
349	/* Cache for reusal of XPath objects */
350	void *cache;
351	};
352
353	/*
354	* The structure of a compiled expression form is not public.
355	*/
356
357	typedef struct _xmlXPathCompExpr xmlXPathCompExpr;
358	typedef xmlXPathCompExpr *xmlXPathCompExprPtr;
359
360	/**
361	* xmlXPathParserContext:
362	*
363	* An XPath parser context. It contains pure parsing informations,
364	* an xmlXPathContext, and the stack of objects.
365	*/
366	struct _xmlXPathParserContext {
367	const xmlChar cur; / the current char being parsed */
368	const xmlChar base; / the full expression */
369
370	int error; /* error code */
371
372	xmlXPathContextPtr context; /* the evaluation context */
373	xmlXPathObjectPtr value; /* the current value */
374	int valueNr; /* number of values stacked */
375	int valueMax; /* max number of values stacked */
376	xmlXPathObjectPtr valueTab; / stack of values */
377
378	xmlXPathCompExprPtr comp; /* the precompiled expression */
379	int xptr; /* it this an XPointer expression */
380	xmlNodePtr ancestor; /* used for walking preceding axis */
381
382	int valueFrame; /* used to limit Pop on the stack */
383	};
384
385	/************************************************************************
386	* *
387	* Public API *
388	* *
389	************************************************************************/
390
391	/**
392	* Objects and Nodesets handling
393	*/
394
395	XMLPUBVAR double xmlXPathNAN;
396	XMLPUBVAR double xmlXPathPINF;
397	XMLPUBVAR double xmlXPathNINF;
398
399	/* These macros may later turn into functions */
400	/**
401	* xmlXPathNodeSetGetLength:
402	* @ns: a node-set
403	*
404	* Implement a functionality similar to the DOM NodeList.length.
405	*
406	* Returns the number of nodes in the node-set.
407	*/
408	#define xmlXPathNodeSetGetLength(ns) ((ns) ? (ns)->nodeNr : 0)
409	/**
410	* xmlXPathNodeSetItem:
411	* @ns: a node-set
412	* @index: index of a node in the set
413	*
414	* Implements a functionality similar to the DOM NodeList.item().
415	*
416	* Returns the xmlNodePtr at the given @index in @ns or NULL if
417	* @index is out of range (0 to length-1)
418	*/
419	#define xmlXPathNodeSetItem(ns, index) \
420	((((ns) != NULL) && \
421	((index) >= 0) && ((index) < (ns)->nodeNr)) ? \
422	(ns)->nodeTab[(index)] \
423	: NULL)
424	/**
425	* xmlXPathNodeSetIsEmpty:
426	* @ns: a node-set
427	*
428	* Checks whether @ns is empty or not.
429	*
430	* Returns %TRUE if @ns is an empty node-set.
431	*/
432	#define xmlXPathNodeSetIsEmpty(ns) \
433	(((ns) == NULL) \|\| ((ns)->nodeNr == 0) \|\| ((ns)->nodeTab == NULL))
434
435
436	XMLPUBFUN void XMLCALL
437	xmlXPathFreeObject (xmlXPathObjectPtr obj);
438	XMLPUBFUN xmlNodeSetPtr XMLCALL
439	xmlXPathNodeSetCreate (xmlNodePtr val);
440	XMLPUBFUN void XMLCALL
441	xmlXPathFreeNodeSetList (xmlXPathObjectPtr obj);
442	XMLPUBFUN void XMLCALL
443	xmlXPathFreeNodeSet (xmlNodeSetPtr obj);
444	XMLPUBFUN xmlXPathObjectPtr XMLCALL
445	xmlXPathObjectCopy (xmlXPathObjectPtr val);
446	XMLPUBFUN int XMLCALL
447	xmlXPathCmpNodes (xmlNodePtr node1,
448	xmlNodePtr node2);
449	/**
450	* Conversion functions to basic types.
451	*/
452	XMLPUBFUN int XMLCALL
453	xmlXPathCastNumberToBoolean (double val);
454	XMLPUBFUN int XMLCALL
455	xmlXPathCastStringToBoolean (const xmlChar * val);
456	XMLPUBFUN int XMLCALL
457	xmlXPathCastNodeSetToBoolean(xmlNodeSetPtr ns);
458	XMLPUBFUN int XMLCALL
459	xmlXPathCastToBoolean (xmlXPathObjectPtr val);
460
461	XMLPUBFUN double XMLCALL
462	xmlXPathCastBooleanToNumber (int val);
463	XMLPUBFUN double XMLCALL
464	xmlXPathCastStringToNumber (const xmlChar * val);
465	XMLPUBFUN double XMLCALL
466	xmlXPathCastNodeToNumber (xmlNodePtr node);
467	XMLPUBFUN double XMLCALL
468	xmlXPathCastNodeSetToNumber (xmlNodeSetPtr ns);
469	XMLPUBFUN double XMLCALL
470	xmlXPathCastToNumber (xmlXPathObjectPtr val);
471
472	XMLPUBFUN xmlChar * XMLCALL
473	xmlXPathCastBooleanToString (int val);
474	XMLPUBFUN xmlChar * XMLCALL
475	xmlXPathCastNumberToString (double val);
476	XMLPUBFUN xmlChar * XMLCALL
477	xmlXPathCastNodeToString (xmlNodePtr node);
478	XMLPUBFUN xmlChar * XMLCALL
479	xmlXPathCastNodeSetToString (xmlNodeSetPtr ns);
480	XMLPUBFUN xmlChar * XMLCALL
481	xmlXPathCastToString (xmlXPathObjectPtr val);
482
483	XMLPUBFUN xmlXPathObjectPtr XMLCALL
484	xmlXPathConvertBoolean (xmlXPathObjectPtr val);
485	XMLPUBFUN xmlXPathObjectPtr XMLCALL
486	xmlXPathConvertNumber (xmlXPathObjectPtr val);
487	XMLPUBFUN xmlXPathObjectPtr XMLCALL
488	xmlXPathConvertString (xmlXPathObjectPtr val);
489
490	/**
491	* Context handling.
492	*/
493	XMLPUBFUN xmlXPathContextPtr XMLCALL
494	xmlXPathNewContext (xmlDocPtr doc);
495	XMLPUBFUN void XMLCALL
496	xmlXPathFreeContext (xmlXPathContextPtr ctxt);
497	XMLPUBFUN int XMLCALL
498	xmlXPathContextSetCache(xmlXPathContextPtr ctxt,
499	int active,
500	int value,
501	int options);
502	/**
503	* Evaluation functions.
504	*/
505	XMLPUBFUN long XMLCALL
506	xmlXPathOrderDocElems (xmlDocPtr doc);
507	XMLPUBFUN xmlXPathObjectPtr XMLCALL
508	xmlXPathEval (const xmlChar *str,
509	xmlXPathContextPtr ctx);
510	XMLPUBFUN xmlXPathObjectPtr XMLCALL
511	xmlXPathEvalExpression (const xmlChar *str,
512	xmlXPathContextPtr ctxt);
513	XMLPUBFUN int XMLCALL
514	xmlXPathEvalPredicate (xmlXPathContextPtr ctxt,
515	xmlXPathObjectPtr res);
516	/**
517	* Separate compilation/evaluation entry points.
518	*/
519	XMLPUBFUN xmlXPathCompExprPtr XMLCALL
520	xmlXPathCompile (const xmlChar *str);
521	XMLPUBFUN xmlXPathCompExprPtr XMLCALL
522	xmlXPathCtxtCompile (xmlXPathContextPtr ctxt,
523	const xmlChar *str);
524	XMLPUBFUN xmlXPathObjectPtr XMLCALL
525	xmlXPathCompiledEval (xmlXPathCompExprPtr comp,
526	xmlXPathContextPtr ctx);
527	XMLPUBFUN int XMLCALL
528	xmlXPathCompiledEvalToBoolean(xmlXPathCompExprPtr comp,
529	xmlXPathContextPtr ctxt);
530	XMLPUBFUN void XMLCALL
531	xmlXPathFreeCompExpr (xmlXPathCompExprPtr comp);
532	#endif /* LIBXML_XPATH_ENABLED */
533	#if defined(LIBXML_XPATH_ENABLED) \|\| defined(LIBXML_SCHEMAS_ENABLED)
534	XMLPUBFUN void XMLCALL
535	xmlXPathInit (void);
536	XMLPUBFUN int XMLCALL
537	xmlXPathIsNaN (double val);
538	XMLPUBFUN int XMLCALL
539	xmlXPathIsInf (double val);
540
541	#ifdef __cplusplus
542	}
543	#endif
544
545	#endif /* LIBXML_XPATH_ENABLED or LIBXML_SCHEMAS_ENABLED*/
546	#endif /* ! __XML_XPATH_H__ */

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/libs/libxml2-2.6.31/include/libxml/xpath.h@ 43891

Download in other formats: