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