Annotation of embedaddon/libxml2/include/libxml/xpath.h, revision 1.1.1.1
1.1 misho 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: } xmlXPathError;
73:
74: /*
75: * A node-set (an unordered collection of nodes without duplicates).
76: */
77: typedef struct _xmlNodeSet xmlNodeSet;
78: typedef xmlNodeSet *xmlNodeSetPtr;
79: struct _xmlNodeSet {
80: int nodeNr; /* number of nodes in the set */
81: int nodeMax; /* size of the array as allocated */
82: xmlNodePtr *nodeTab; /* array of nodes in no particular order */
83: /* @@ with_ns to check wether namespace nodes should be looked at @@ */
84: };
85:
86: /*
87: * An expression is evaluated to yield an object, which
88: * has one of the following four basic types:
89: * - node-set
90: * - boolean
91: * - number
92: * - string
93: *
94: * @@ XPointer will add more types !
95: */
96:
97: typedef enum {
98: XPATH_UNDEFINED = 0,
99: XPATH_NODESET = 1,
100: XPATH_BOOLEAN = 2,
101: XPATH_NUMBER = 3,
102: XPATH_STRING = 4,
103: XPATH_POINT = 5,
104: XPATH_RANGE = 6,
105: XPATH_LOCATIONSET = 7,
106: XPATH_USERS = 8,
107: XPATH_XSLT_TREE = 9 /* An XSLT value tree, non modifiable */
108: } xmlXPathObjectType;
109:
110: typedef struct _xmlXPathObject xmlXPathObject;
111: typedef xmlXPathObject *xmlXPathObjectPtr;
112: struct _xmlXPathObject {
113: xmlXPathObjectType type;
114: xmlNodeSetPtr nodesetval;
115: int boolval;
116: double floatval;
117: xmlChar *stringval;
118: void *user;
119: int index;
120: void *user2;
121: int index2;
122: };
123:
124: /**
125: * xmlXPathConvertFunc:
126: * @obj: an XPath object
127: * @type: the number of the target type
128: *
129: * A conversion function is associated to a type and used to cast
130: * the new type to primitive values.
131: *
132: * Returns -1 in case of error, 0 otherwise
133: */
134: typedef int (*xmlXPathConvertFunc) (xmlXPathObjectPtr obj, int type);
135:
136: /*
137: * Extra type: a name and a conversion function.
138: */
139:
140: typedef struct _xmlXPathType xmlXPathType;
141: typedef xmlXPathType *xmlXPathTypePtr;
142: struct _xmlXPathType {
143: const xmlChar *name; /* the type name */
144: xmlXPathConvertFunc func; /* the conversion function */
145: };
146:
147: /*
148: * Extra variable: a name and a value.
149: */
150:
151: typedef struct _xmlXPathVariable xmlXPathVariable;
152: typedef xmlXPathVariable *xmlXPathVariablePtr;
153: struct _xmlXPathVariable {
154: const xmlChar *name; /* the variable name */
155: xmlXPathObjectPtr value; /* the value */
156: };
157:
158: /**
159: * xmlXPathEvalFunc:
160: * @ctxt: an XPath parser context
161: * @nargs: the number of arguments passed to the function
162: *
163: * An XPath evaluation function, the parameters are on the XPath context stack.
164: */
165:
166: typedef void (*xmlXPathEvalFunc)(xmlXPathParserContextPtr ctxt,
167: int nargs);
168:
169: /*
170: * Extra function: a name and a evaluation function.
171: */
172:
173: typedef struct _xmlXPathFunct xmlXPathFunct;
174: typedef xmlXPathFunct *xmlXPathFuncPtr;
175: struct _xmlXPathFunct {
176: const xmlChar *name; /* the function name */
177: xmlXPathEvalFunc func; /* the evaluation function */
178: };
179:
180: /**
181: * xmlXPathAxisFunc:
182: * @ctxt: the XPath interpreter context
183: * @cur: the previous node being explored on that axis
184: *
185: * An axis traversal function. To traverse an axis, the engine calls
186: * the first time with cur == NULL and repeat until the function returns
187: * NULL indicating the end of the axis traversal.
188: *
189: * Returns the next node in that axis or NULL if at the end of the axis.
190: */
191:
192: typedef xmlXPathObjectPtr (*xmlXPathAxisFunc) (xmlXPathParserContextPtr ctxt,
193: xmlXPathObjectPtr cur);
194:
195: /*
196: * Extra axis: a name and an axis function.
197: */
198:
199: typedef struct _xmlXPathAxis xmlXPathAxis;
200: typedef xmlXPathAxis *xmlXPathAxisPtr;
201: struct _xmlXPathAxis {
202: const xmlChar *name; /* the axis name */
203: xmlXPathAxisFunc func; /* the search function */
204: };
205:
206: /**
207: * xmlXPathFunction:
208: * @ctxt: the XPath interprestation context
209: * @nargs: the number of arguments
210: *
211: * An XPath function.
212: * The arguments (if any) are popped out from the context stack
213: * and the result is pushed on the stack.
214: */
215:
216: typedef void (*xmlXPathFunction) (xmlXPathParserContextPtr ctxt, int nargs);
217:
218: /*
219: * Function and Variable Lookup.
220: */
221:
222: /**
223: * xmlXPathVariableLookupFunc:
224: * @ctxt: an XPath context
225: * @name: name of the variable
226: * @ns_uri: the namespace name hosting this variable
227: *
228: * Prototype for callbacks used to plug variable lookup in the XPath
229: * engine.
230: *
231: * Returns the XPath object value or NULL if not found.
232: */
233: typedef xmlXPathObjectPtr (*xmlXPathVariableLookupFunc) (void *ctxt,
234: const xmlChar *name,
235: const xmlChar *ns_uri);
236:
237: /**
238: * xmlXPathFuncLookupFunc:
239: * @ctxt: an XPath context
240: * @name: name of the function
241: * @ns_uri: the namespace name hosting this function
242: *
243: * Prototype for callbacks used to plug function lookup in the XPath
244: * engine.
245: *
246: * Returns the XPath function or NULL if not found.
247: */
248: typedef xmlXPathFunction (*xmlXPathFuncLookupFunc) (void *ctxt,
249: const xmlChar *name,
250: const xmlChar *ns_uri);
251:
252: /**
253: * xmlXPathFlags:
254: * Flags for XPath engine compilation and runtime
255: */
256: /**
257: * XML_XPATH_CHECKNS:
258: *
259: * check namespaces at compilation
260: */
261: #define XML_XPATH_CHECKNS (1<<0)
262: /**
263: * XML_XPATH_NOVAR:
264: *
265: * forbid variables in expression
266: */
267: #define XML_XPATH_NOVAR (1<<1)
268:
269: /**
270: * xmlXPathContext:
271: *
272: * Expression evaluation occurs with respect to a context.
273: * he context consists of:
274: * - a node (the context node)
275: * - a node list (the context node list)
276: * - a set of variable bindings
277: * - a function library
278: * - the set of namespace declarations in scope for the expression
279: * Following the switch to hash tables, this need to be trimmed up at
280: * the next binary incompatible release.
281: * The node may be modified when the context is passed to libxml2
282: * for an XPath evaluation so you may need to initialize it again
283: * before the next call.
284: */
285:
286: struct _xmlXPathContext {
287: xmlDocPtr doc; /* The current document */
288: xmlNodePtr node; /* The current node */
289:
290: int nb_variables_unused; /* unused (hash table) */
291: int max_variables_unused; /* unused (hash table) */
292: xmlHashTablePtr varHash; /* Hash table of defined variables */
293:
294: int nb_types; /* number of defined types */
295: int max_types; /* max number of types */
296: xmlXPathTypePtr types; /* Array of defined types */
297:
298: int nb_funcs_unused; /* unused (hash table) */
299: int max_funcs_unused; /* unused (hash table) */
300: xmlHashTablePtr funcHash; /* Hash table of defined funcs */
301:
302: int nb_axis; /* number of defined axis */
303: int max_axis; /* max number of axis */
304: xmlXPathAxisPtr axis; /* Array of defined axis */
305:
306: /* the namespace nodes of the context node */
307: xmlNsPtr *namespaces; /* Array of namespaces */
308: int nsNr; /* number of namespace in scope */
309: void *user; /* function to free */
310:
311: /* extra variables */
312: int contextSize; /* the context size */
313: int proximityPosition; /* the proximity position */
314:
315: /* extra stuff for XPointer */
316: int xptr; /* is this an XPointer context? */
317: xmlNodePtr here; /* for here() */
318: xmlNodePtr origin; /* for origin() */
319:
320: /* the set of namespace declarations in scope for the expression */
321: xmlHashTablePtr nsHash; /* The namespaces hash table */
322: xmlXPathVariableLookupFunc varLookupFunc;/* variable lookup func */
323: void *varLookupData; /* variable lookup data */
324:
325: /* Possibility to link in an extra item */
326: void *extra; /* needed for XSLT */
327:
328: /* The function name and URI when calling a function */
329: const xmlChar *function;
330: const xmlChar *functionURI;
331:
332: /* function lookup function and data */
333: xmlXPathFuncLookupFunc funcLookupFunc;/* function lookup func */
334: void *funcLookupData; /* function lookup data */
335:
336: /* temporary namespace lists kept for walking the namespace axis */
337: xmlNsPtr *tmpNsList; /* Array of namespaces */
338: int tmpNsNr; /* number of namespaces in scope */
339:
340: /* error reporting mechanism */
341: void *userData; /* user specific data block */
342: xmlStructuredErrorFunc error; /* the callback in case of errors */
343: xmlError lastError; /* the last error */
344: xmlNodePtr debugNode; /* the source node XSLT */
345:
346: /* dictionary */
347: xmlDictPtr dict; /* dictionary if any */
348:
349: int flags; /* flags to control compilation */
350:
351: /* Cache for reusal of XPath objects */
352: void *cache;
353: };
354:
355: /*
356: * The structure of a compiled expression form is not public.
357: */
358:
359: typedef struct _xmlXPathCompExpr xmlXPathCompExpr;
360: typedef xmlXPathCompExpr *xmlXPathCompExprPtr;
361:
362: /**
363: * xmlXPathParserContext:
364: *
365: * An XPath parser context. It contains pure parsing informations,
366: * an xmlXPathContext, and the stack of objects.
367: */
368: struct _xmlXPathParserContext {
369: const xmlChar *cur; /* the current char being parsed */
370: const xmlChar *base; /* the full expression */
371:
372: int error; /* error code */
373:
374: xmlXPathContextPtr context; /* the evaluation context */
375: xmlXPathObjectPtr value; /* the current value */
376: int valueNr; /* number of values stacked */
377: int valueMax; /* max number of values stacked */
378: xmlXPathObjectPtr *valueTab; /* stack of values */
379:
380: xmlXPathCompExprPtr comp; /* the precompiled expression */
381: int xptr; /* it this an XPointer expression */
382: xmlNodePtr ancestor; /* used for walking preceding axis */
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__ */
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