xpath.c@ 58209

Last change on this file since 58209 was 58076, checked in by vboxsync, 9 years ago
upstream fixes post 2.9.2
Property svn:eol-style set to `native`
File size: 418.3 KB

Line
1	/*
2	* xpath.c: XML Path Language implementation
3	* XPath is a language for addressing parts of an XML document,
4	* designed to be used by both XSLT and XPointer
5	*f
6	* Reference: W3C Recommendation 16 November 1999
7	* http://www.w3.org/TR/1999/REC-xpath-19991116
8	* Public reference:
9	* http://www.w3.org/TR/xpath
10	*
11	* See Copyright for the status of this software
12	*
13	* Author: daniel@veillard.com
14	*
15	*/
16
17	#define IN_LIBXML
18	#include "libxml.h"
19
20	#include <string.h>
21
22	#ifdef HAVE_SYS_TYPES_H
23	#include <sys/types.h>
24	#endif
25	#ifdef HAVE_MATH_H
26	#include <math.h>
27	#endif
28	#ifdef HAVE_FLOAT_H
29	#include <float.h>
30	#endif
31	#ifdef HAVE_CTYPE_H
32	#include <ctype.h>
33	#endif
34	#ifdef HAVE_SIGNAL_H
35	#include <signal.h>
36	#endif
37
38	#include <libxml/xmlmemory.h>
39	#include <libxml/tree.h>
40	#include <libxml/valid.h>
41	#include <libxml/xpath.h>
42	#include <libxml/xpathInternals.h>
43	#include <libxml/parserInternals.h>
44	#include <libxml/hash.h>
45	#ifdef LIBXML_XPTR_ENABLED
46	#include <libxml/xpointer.h>
47	#endif
48	#ifdef LIBXML_DEBUG_ENABLED
49	#include <libxml/debugXML.h>
50	#endif
51	#include <libxml/xmlerror.h>
52	#include <libxml/threads.h>
53	#include <libxml/globals.h>
54	#ifdef LIBXML_PATTERN_ENABLED
55	#include <libxml/pattern.h>
56	#endif
57
58	#include "buf.h"
59
60	#ifdef LIBXML_PATTERN_ENABLED
61	#define XPATH_STREAMING
62	#endif
63
64	#define TODO \
65	xmlGenericError(xmlGenericErrorContext, \
66	"Unimplemented block at %s:%d\n", \
67	__FILE__, __LINE__);
68
69	/**
70	* WITH_TIM_SORT:
71	*
72	* Use the Timsort algorithm provided in timsort.h to sort
73	* nodeset as this is a great improvement over the old Shell sort
74	* used in xmlXPathNodeSetSort()
75	*/
76	#define WITH_TIM_SORT
77
78	/*
79	* XP_OPTIMIZED_NON_ELEM_COMPARISON:
80	* If defined, this will use xmlXPathCmpNodesExt() instead of
81	* xmlXPathCmpNodes(). The new function is optimized comparison of
82	* non-element nodes; actually it will speed up comparison only if
83	* xmlXPathOrderDocElems() was called in order to index the elements of
84	* a tree in document order; Libxslt does such an indexing, thus it will
85	* benefit from this optimization.
86	*/
87	#define XP_OPTIMIZED_NON_ELEM_COMPARISON
88
89	/*
90	* XP_OPTIMIZED_FILTER_FIRST:
91	* If defined, this will optimize expressions like "key('foo', 'val')[b][1]"
92	* in a way, that it stop evaluation at the first node.
93	*/
94	#define XP_OPTIMIZED_FILTER_FIRST
95
96	/*
97	* XP_DEBUG_OBJ_USAGE:
98	* Internal flag to enable tracking of how much XPath objects have been
99	* created.
100	*/
101	/* #define XP_DEBUG_OBJ_USAGE */
102
103	/*
104	* XPATH_MAX_STEPS:
105	* when compiling an XPath expression we arbitrary limit the maximum
106	* number of step operation in the compiled expression. 1000000 is
107	* an insanely large value which should never be reached under normal
108	* circumstances
109	*/
110	#define XPATH_MAX_STEPS 1000000
111
112	/*
113	* XPATH_MAX_STACK_DEPTH:
114	* when evaluating an XPath expression we arbitrary limit the maximum
115	* number of object allowed to be pushed on the stack. 1000000 is
116	* an insanely large value which should never be reached under normal
117	* circumstances
118	*/
119	#define XPATH_MAX_STACK_DEPTH 1000000
120
121	/*
122	* XPATH_MAX_NODESET_LENGTH:
123	* when evaluating an XPath expression nodesets are created and we
124	* arbitrary limit the maximum length of those node set. 10000000 is
125	* an insanely large value which should never be reached under normal
126	* circumstances, one would first need to construct an in memory tree
127	* with more than 10 millions nodes.
128	*/
129	#define XPATH_MAX_NODESET_LENGTH 10000000
130
131	/*
132	* TODO:
133	* There are a few spots where some tests are done which depend upon ascii
134	* data. These should be enhanced for full UTF8 support (see particularly
135	* any use of the macros IS_ASCII_CHARACTER and IS_ASCII_DIGIT)
136	*/
137
138	#ifdef XP_OPTIMIZED_NON_ELEM_COMPARISON
139	/**
140	* xmlXPathCmpNodesExt:
141	* @node1: the first node
142	* @node2: the second node
143	*
144	* Compare two nodes w.r.t document order.
145	* This one is optimized for handling of non-element nodes.
146	*
147	* Returns -2 in case of error 1 if first point < second point, 0 if
148	* it's the same node, -1 otherwise
149	*/
150	static int
151	xmlXPathCmpNodesExt(xmlNodePtr node1, xmlNodePtr node2) {
152	int depth1, depth2;
153	int misc = 0, precedence1 = 0, precedence2 = 0;
154	xmlNodePtr miscNode1 = NULL, miscNode2 = NULL;
155	xmlNodePtr cur, root;
156	long l1, l2;
157
158	if ((node1 == NULL) \|\| (node2 == NULL))
159	return(-2);
160
161	if (node1 == node2)
162	return(0);
163
164	/*
165	* a couple of optimizations which will avoid computations in most cases
166	*/
167	switch (node1->type) {
168	case XML_ELEMENT_NODE:
169	if (node2->type == XML_ELEMENT_NODE) {
170	if ((0 > (long) node1->content) && /* TODO: Would a != 0 suffice here? */
171	(0 > (long) node2->content) &&
172	(node1->doc == node2->doc))
173	{
174	l1 = -((long) node1->content);
175	l2 = -((long) node2->content);
176	if (l1 < l2)
177	return(1);
178	if (l1 > l2)
179	return(-1);
180	} else
181	goto turtle_comparison;
182	}
183	break;
184	case XML_ATTRIBUTE_NODE:
185	precedence1 = 1; /* element is owner */
186	miscNode1 = node1;
187	node1 = node1->parent;
188	misc = 1;
189	break;
190	case XML_TEXT_NODE:
191	case XML_CDATA_SECTION_NODE:
192	case XML_COMMENT_NODE:
193	case XML_PI_NODE: {
194	miscNode1 = node1;
195	/*
196	* Find nearest element node.
197	*/
198	if (node1->prev != NULL) {
199	do {
200	node1 = node1->prev;
201	if (node1->type == XML_ELEMENT_NODE) {
202	precedence1 = 3; /* element in prev-sibl axis */
203	break;
204	}
205	if (node1->prev == NULL) {
206	precedence1 = 2; /* element is parent */
207	/*
208	* URGENT TODO: Are there any cases, where the
209	* parent of such a node is not an element node?
210	*/
211	node1 = node1->parent;
212	break;
213	}
214	} while (1);
215	} else {
216	precedence1 = 2; /* element is parent */
217	node1 = node1->parent;
218	}
219	if ((node1 == NULL) \|\| (node1->type != XML_ELEMENT_NODE) \|\|
220	(0 <= (long) node1->content)) {
221	/*
222	* Fallback for whatever case.
223	*/
224	node1 = miscNode1;
225	precedence1 = 0;
226	} else
227	misc = 1;
228	}
229	break;
230	case XML_NAMESPACE_DECL:
231	/*
232	* TODO: why do we return 1 for namespace nodes?
233	*/
234	return(1);
235	default:
236	break;
237	}
238	switch (node2->type) {
239	case XML_ELEMENT_NODE:
240	break;
241	case XML_ATTRIBUTE_NODE:
242	precedence2 = 1; /* element is owner */
243	miscNode2 = node2;
244	node2 = node2->parent;
245	misc = 1;
246	break;
247	case XML_TEXT_NODE:
248	case XML_CDATA_SECTION_NODE:
249	case XML_COMMENT_NODE:
250	case XML_PI_NODE: {
251	miscNode2 = node2;
252	if (node2->prev != NULL) {
253	do {
254	node2 = node2->prev;
255	if (node2->type == XML_ELEMENT_NODE) {
256	precedence2 = 3; /* element in prev-sibl axis */
257	break;
258	}
259	if (node2->prev == NULL) {
260	precedence2 = 2; /* element is parent */
261	node2 = node2->parent;
262	break;
263	}
264	} while (1);
265	} else {
266	precedence2 = 2; /* element is parent */
267	node2 = node2->parent;
268	}
269	if ((node2 == NULL) \|\| (node2->type != XML_ELEMENT_NODE) \|\|
270	(0 <= (long) node2->content))
271	{
272	node2 = miscNode2;
273	precedence2 = 0;
274	} else
275	misc = 1;
276	}
277	break;
278	case XML_NAMESPACE_DECL:
279	return(1);
280	default:
281	break;
282	}
283	if (misc) {
284	if (node1 == node2) {
285	if (precedence1 == precedence2) {
286	/*
287	* The ugly case; but normally there aren't many
288	* adjacent non-element nodes around.
289	*/
290	cur = miscNode2->prev;
291	while (cur != NULL) {
292	if (cur == miscNode1)
293	return(1);
294	if (cur->type == XML_ELEMENT_NODE)
295	return(-1);
296	cur = cur->prev;
297	}
298	return (-1);
299	} else {
300	/*
301	* Evaluate based on higher precedence wrt to the element.
302	* TODO: This assumes attributes are sorted before content.
303	* Is this 100% correct?
304	*/
305	if (precedence1 < precedence2)
306	return(1);
307	else
308	return(-1);
309	}
310	}
311	/*
312	* Special case: One of the helper-elements is contained by the other.
313	* <foo>
314	* <node2>
315	* <node1>Text-1(precedence1 == 2)</node1>
316	* </node2>
317	* Text-6(precedence2 == 3)
318	* </foo>
319	*/
320	if ((precedence2 == 3) && (precedence1 > 1)) {
321	cur = node1->parent;
322	while (cur) {
323	if (cur == node2)
324	return(1);
325	cur = cur->parent;
326	}
327	}
328	if ((precedence1 == 3) && (precedence2 > 1)) {
329	cur = node2->parent;
330	while (cur) {
331	if (cur == node1)
332	return(-1);
333	cur = cur->parent;
334	}
335	}
336	}
337
338	/*
339	* Speedup using document order if availble.
340	*/
341	if ((node1->type == XML_ELEMENT_NODE) &&
342	(node2->type == XML_ELEMENT_NODE) &&
343	(0 > (long) node1->content) &&
344	(0 > (long) node2->content) &&
345	(node1->doc == node2->doc)) {
346
347	l1 = -((long) node1->content);
348	l2 = -((long) node2->content);
349	if (l1 < l2)
350	return(1);
351	if (l1 > l2)
352	return(-1);
353	}
354
355	turtle_comparison:
356
357	if (node1 == node2->prev)
358	return(1);
359	if (node1 == node2->next)
360	return(-1);
361	/*
362	* compute depth to root
363	*/
364	for (depth2 = 0, cur = node2; cur->parent != NULL; cur = cur->parent) {
365	if (cur->parent == node1)
366	return(1);
367	depth2++;
368	}
369	root = cur;
370	for (depth1 = 0, cur = node1; cur->parent != NULL; cur = cur->parent) {
371	if (cur->parent == node2)
372	return(-1);
373	depth1++;
374	}
375	/*
376	* Distinct document (or distinct entities :-( ) case.
377	*/
378	if (root != cur) {
379	return(-2);
380	}
381	/*
382	* get the nearest common ancestor.
383	*/
384	while (depth1 > depth2) {
385	depth1--;
386	node1 = node1->parent;
387	}
388	while (depth2 > depth1) {
389	depth2--;
390	node2 = node2->parent;
391	}
392	while (node1->parent != node2->parent) {
393	node1 = node1->parent;
394	node2 = node2->parent;
395	/* should not happen but just in case ... */
396	if ((node1 == NULL) \|\| (node2 == NULL))
397	return(-2);
398	}
399	/*
400	* Find who's first.
401	*/
402	if (node1 == node2->prev)
403	return(1);
404	if (node1 == node2->next)
405	return(-1);
406	/*
407	* Speedup using document order if availble.
408	*/
409	if ((node1->type == XML_ELEMENT_NODE) &&
410	(node2->type == XML_ELEMENT_NODE) &&
411	(0 > (long) node1->content) &&
412	(0 > (long) node2->content) &&
413	(node1->doc == node2->doc)) {
414
415	l1 = -((long) node1->content);
416	l2 = -((long) node2->content);
417	if (l1 < l2)
418	return(1);
419	if (l1 > l2)
420	return(-1);
421	}
422
423	for (cur = node1->next;cur != NULL;cur = cur->next)
424	if (cur == node2)
425	return(1);
426	return(-1); /* assume there is no sibling list corruption */
427	}
428	#endif /* XP_OPTIMIZED_NON_ELEM_COMPARISON */
429
430	/*
431	* Wrapper for the Timsort argorithm from timsort.h
432	*/
433	#ifdef WITH_TIM_SORT
434	#define SORT_NAME libxml_domnode
435	#define SORT_TYPE xmlNodePtr
436	/**
437	* wrap_cmp:
438	* @x: a node
439	* @y: another node
440	*
441	* Comparison function for the Timsort implementation
442	*
443	* Returns -2 in case of error -1 if first point < second point, 0 if
444	* it's the same node, +1 otherwise
445	*/
446	static
447	int wrap_cmp( xmlNodePtr x, xmlNodePtr y );
448	#ifdef XP_OPTIMIZED_NON_ELEM_COMPARISON
449	static int wrap_cmp( xmlNodePtr x, xmlNodePtr y )
450	{
451	int res = xmlXPathCmpNodesExt(x, y);
452	return res == -2 ? res : -res;
453	}
454	#else
455	static int wrap_cmp( xmlNodePtr x, xmlNodePtr y )
456	{
457	int res = xmlXPathCmpNodes(x, y);
458	return res == -2 ? res : -res;
459	}
460	#endif
461	#define SORT_CMP(x, y) (wrap_cmp(x, y))
462	#include "timsort.h"
463	#endif /* WITH_TIM_SORT */
464
465	#if defined(LIBXML_XPATH_ENABLED) \|\| defined(LIBXML_SCHEMAS_ENABLED)
466
467	/************************************************************************
468	* *
469	* Floating point stuff *
470	* *
471	************************************************************************/
472
473	#ifndef TRIO_REPLACE_STDIO
474	#define TRIO_PUBLIC static
475	#endif
476	#include "trionan.c"
477
478	/*
479	* The lack of portability of this section of the libc is annoying !
480	*/
481	double xmlXPathNAN = 0;
482	double xmlXPathPINF = 1;
483	double xmlXPathNINF = -1;
484	static double xmlXPathNZERO = 0; /* not exported from headers */
485	static int xmlXPathInitialized = 0;
486
487	/**
488	* xmlXPathInit:
489	*
490	* Initialize the XPath environment
491	*/
492	void
493	xmlXPathInit(void) {
494	if (xmlXPathInitialized) return;
495
496	xmlXPathPINF = trio_pinf();
497	xmlXPathNINF = trio_ninf();
498	xmlXPathNAN = trio_nan();
499	xmlXPathNZERO = trio_nzero();
500
501	xmlXPathInitialized = 1;
502	}
503
504	/**
505	* xmlXPathIsNaN:
506	* @val: a double value
507	*
508	* Provides a portable isnan() function to detect whether a double
509	* is a NotaNumber. Based on trio code
510	* http://sourceforge.net/projects/ctrio/
511	*
512	* Returns 1 if the value is a NaN, 0 otherwise
513	*/
514	int
515	xmlXPathIsNaN(double val) {
516	return(trio_isnan(val));
517	}
518
519	/**
520	* xmlXPathIsInf:
521	* @val: a double value
522	*
523	* Provides a portable isinf() function to detect whether a double
524	* is a +Infinite or -Infinite. Based on trio code
525	* http://sourceforge.net/projects/ctrio/
526	*
527	* Returns 1 vi the value is +Infinite, -1 if -Infinite, 0 otherwise
528	*/
529	int
530	xmlXPathIsInf(double val) {
531	return(trio_isinf(val));
532	}
533
534	#endif /* SCHEMAS or XPATH */
535	#ifdef LIBXML_XPATH_ENABLED
536	/**
537	* xmlXPathGetSign:
538	* @val: a double value
539	*
540	* Provides a portable function to detect the sign of a double
541	* Modified from trio code
542	* http://sourceforge.net/projects/ctrio/
543	*
544	* Returns 1 if the value is Negative, 0 if positive
545	*/
546	static int
547	xmlXPathGetSign(double val) {
548	return(trio_signbit(val));
549	}
550
551
552	/*
553	* TODO: when compatibility allows remove all "fake node libxslt" strings
554	* the test should just be name[0] = ' '
555	*/
556	#ifdef DEBUG_XPATH_EXPRESSION
557	#define DEBUG_STEP
558	#define DEBUG_EXPR
559	#define DEBUG_EVAL_COUNTS
560	#endif
561
562	static xmlNs xmlXPathXMLNamespaceStruct = {
563	NULL,
564	XML_NAMESPACE_DECL,
565	XML_XML_NAMESPACE,
566	BAD_CAST "xml",
567	NULL,
568	NULL
569	};
570	static xmlNsPtr xmlXPathXMLNamespace = &xmlXPathXMLNamespaceStruct;
571	#ifndef LIBXML_THREAD_ENABLED
572	/*
573	* Optimizer is disabled only when threaded apps are detected while
574	* the library ain't compiled for thread safety.
575	*/
576	static int xmlXPathDisableOptimizer = 0;
577	#endif
578
579	/************************************************************************
580	* *
581	* Error handling routines *
582	* *
583	************************************************************************/
584
585	/**
586	* XP_ERRORNULL:
587	* @X: the error code
588	*
589	* Macro to raise an XPath error and return NULL.
590	*/
591	#define XP_ERRORNULL(X) \
592	{ xmlXPathErr(ctxt, X); return(NULL); }
593
594	/*
595	* The array xmlXPathErrorMessages corresponds to the enum xmlXPathError
596	*/
597	static const char *xmlXPathErrorMessages[] = {
598	"Ok\n",
599	"Number encoding\n",
600	"Unfinished literal\n",
601	"Start of literal\n",
602	"Expected $ for variable reference\n",
603	"Undefined variable\n",
604	"Invalid predicate\n",
605	"Invalid expression\n",
606	"Missing closing curly brace\n",
607	"Unregistered function\n",
608	"Invalid operand\n",
609	"Invalid type\n",
610	"Invalid number of arguments\n",
611	"Invalid context size\n",
612	"Invalid context position\n",
613	"Memory allocation error\n",
614	"Syntax error\n",
615	"Resource error\n",
616	"Sub resource error\n",
617	"Undefined namespace prefix\n",
618	"Encoding error\n",
619	"Char out of XML range\n",
620	"Invalid or incomplete context\n",
621	"Stack usage error\n",
622	"Forbidden variable\n",
623	"?? Unknown error ??\n" /* Must be last in the list! */
624	};
625	#define MAXERRNO ((int)(sizeof(xmlXPathErrorMessages) / \
626	sizeof(xmlXPathErrorMessages[0])) - 1)
627	/**
628	* xmlXPathErrMemory:
629	* @ctxt: an XPath context
630	* @extra: extra informations
631	*
632	* Handle a redefinition of attribute error
633	*/
634	static void
635	xmlXPathErrMemory(xmlXPathContextPtr ctxt, const char *extra)
636	{
637	if (ctxt != NULL) {
638	if (extra) {
639	xmlChar buf[200];
640
641	xmlStrPrintf(buf, 200,
642	BAD_CAST "Memory allocation failed : %s\n",
643	extra);
644	ctxt->lastError.message = (char *) xmlStrdup(buf);
645	} else {
646	ctxt->lastError.message = (char *)
647	xmlStrdup(BAD_CAST "Memory allocation failed\n");
648	}
649	ctxt->lastError.domain = XML_FROM_XPATH;
650	ctxt->lastError.code = XML_ERR_NO_MEMORY;
651	if (ctxt->error != NULL)
652	ctxt->error(ctxt->userData, &ctxt->lastError);
653	} else {
654	if (extra)
655	__xmlRaiseError(NULL, NULL, NULL,
656	NULL, NULL, XML_FROM_XPATH,
657	XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0,
658	extra, NULL, NULL, 0, 0,
659	"Memory allocation failed : %s\n", extra);
660	else
661	__xmlRaiseError(NULL, NULL, NULL,
662	NULL, NULL, XML_FROM_XPATH,
663	XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0,
664	NULL, NULL, NULL, 0, 0,
665	"Memory allocation failed\n");
666	}
667	}
668
669	/**
670	* xmlXPathPErrMemory:
671	* @ctxt: an XPath parser context
672	* @extra: extra informations
673	*
674	* Handle a redefinition of attribute error
675	*/
676	static void
677	xmlXPathPErrMemory(xmlXPathParserContextPtr ctxt, const char *extra)
678	{
679	if (ctxt == NULL)
680	xmlXPathErrMemory(NULL, extra);
681	else {
682	ctxt->error = XPATH_MEMORY_ERROR;
683	xmlXPathErrMemory(ctxt->context, extra);
684	}
685	}
686
687	/**
688	* xmlXPathErr:
689	* @ctxt: a XPath parser context
690	* @error: the error code
691	*
692	* Handle an XPath error
693	*/
694	void
695	xmlXPathErr(xmlXPathParserContextPtr ctxt, int error)
696	{
697	if ((error < 0) \|\| (error > MAXERRNO))
698	error = MAXERRNO;
699	if (ctxt == NULL) {
700	__xmlRaiseError(NULL, NULL, NULL,
701	NULL, NULL, XML_FROM_XPATH,
702	error + XML_XPATH_EXPRESSION_OK - XPATH_EXPRESSION_OK,
703	XML_ERR_ERROR, NULL, 0,
704	NULL, NULL, NULL, 0, 0,
705	"%s", xmlXPathErrorMessages[error]);
706	return;
707	}
708	ctxt->error = error;
709	if (ctxt->context == NULL) {
710	__xmlRaiseError(NULL, NULL, NULL,
711	NULL, NULL, XML_FROM_XPATH,
712	error + XML_XPATH_EXPRESSION_OK - XPATH_EXPRESSION_OK,
713	XML_ERR_ERROR, NULL, 0,
714	(const char *) ctxt->base, NULL, NULL,
715	ctxt->cur - ctxt->base, 0,
716	"%s", xmlXPathErrorMessages[error]);
717	return;
718	}
719
720	/* cleanup current last error */
721	xmlResetError(&ctxt->context->lastError);
722
723	ctxt->context->lastError.domain = XML_FROM_XPATH;
724	ctxt->context->lastError.code = error + XML_XPATH_EXPRESSION_OK -
725	XPATH_EXPRESSION_OK;
726	ctxt->context->lastError.level = XML_ERR_ERROR;
727	ctxt->context->lastError.str1 = (char *) xmlStrdup(ctxt->base);
728	ctxt->context->lastError.int1 = ctxt->cur - ctxt->base;
729	ctxt->context->lastError.node = ctxt->context->debugNode;
730	if (ctxt->context->error != NULL) {
731	ctxt->context->error(ctxt->context->userData,
732	&ctxt->context->lastError);
733	} else {
734	__xmlRaiseError(NULL, NULL, NULL,
735	NULL, ctxt->context->debugNode, XML_FROM_XPATH,
736	error + XML_XPATH_EXPRESSION_OK - XPATH_EXPRESSION_OK,
737	XML_ERR_ERROR, NULL, 0,
738	(const char *) ctxt->base, NULL, NULL,
739	ctxt->cur - ctxt->base, 0,
740	"%s", xmlXPathErrorMessages[error]);
741	}
742
743	}
744
745	/**
746	* xmlXPatherror:
747	* @ctxt: the XPath Parser context
748	* @file: the file name
749	* @line: the line number
750	* @no: the error number
751	*
752	* Formats an error message.
753	*/
754	void
755	xmlXPatherror(xmlXPathParserContextPtr ctxt, const char *file ATTRIBUTE_UNUSED,
756	int line ATTRIBUTE_UNUSED, int no) {
757	xmlXPathErr(ctxt, no);
758	}
759
760	/************************************************************************
761	* *
762	* Utilities *
763	* *
764	************************************************************************/
765
766	/**
767	* xsltPointerList:
768	*
769	* Pointer-list for various purposes.
770	*/
771	typedef struct _xmlPointerList xmlPointerList;
772	typedef xmlPointerList *xmlPointerListPtr;
773	struct _xmlPointerList {
774	void **items;
775	int number;
776	int size;
777	};
778	/*
779	* TODO: Since such a list-handling is used in xmlschemas.c and libxslt
780	* and here, we should make the functions public.
781	*/
782	static int
783	xmlPointerListAddSize(xmlPointerListPtr list,
784	void *item,
785	int initialSize)
786	{
787	if (list->items == NULL) {
788	if (initialSize <= 0)
789	initialSize = 1;
790	list->items = (void *) xmlMalloc(initialSize sizeof(void *));
791	if (list->items == NULL) {
792	xmlXPathErrMemory(NULL,
793	"xmlPointerListCreate: allocating item\n");
794	return(-1);
795	}
796	list->number = 0;
797	list->size = initialSize;
798	} else if (list->size <= list->number) {
799	if (list->size > 50000000) {
800	xmlXPathErrMemory(NULL,
801	"xmlPointerListAddSize: re-allocating item\n");
802	return(-1);
803	}
804	list->size *= 2;
805	list->items = (void **) xmlRealloc(list->items,
806	list->size * sizeof(void *));
807	if (list->items == NULL) {
808	xmlXPathErrMemory(NULL,
809	"xmlPointerListAddSize: re-allocating item\n");
810	list->size = 0;
811	return(-1);
812	}
813	}
814	list->items[list->number++] = item;
815	return(0);
816	}
817
818	/**
819	* xsltPointerListCreate:
820	*
821	* Creates an xsltPointerList structure.
822	*
823	* Returns a xsltPointerList structure or NULL in case of an error.
824	*/
825	static xmlPointerListPtr
826	xmlPointerListCreate(int initialSize)
827	{
828	xmlPointerListPtr ret;
829
830	ret = xmlMalloc(sizeof(xmlPointerList));
831	if (ret == NULL) {
832	xmlXPathErrMemory(NULL,
833	"xmlPointerListCreate: allocating item\n");
834	return (NULL);
835	}
836	memset(ret, 0, sizeof(xmlPointerList));
837	if (initialSize > 0) {
838	xmlPointerListAddSize(ret, NULL, initialSize);
839	ret->number = 0;
840	}
841	return (ret);
842	}
843
844	/**
845	* xsltPointerListFree:
846	*
847	* Frees the xsltPointerList structure. This does not free
848	* the content of the list.
849	*/
850	static void
851	xmlPointerListFree(xmlPointerListPtr list)
852	{
853	if (list == NULL)
854	return;
855	if (list->items != NULL)
856	xmlFree(list->items);
857	xmlFree(list);
858	}
859
860	/************************************************************************
861	* *
862	* Parser Types *
863	* *
864	************************************************************************/
865
866	/*
867	* Types are private:
868	*/
869
870	typedef enum {
871	XPATH_OP_END=0,
872	XPATH_OP_AND,
873	XPATH_OP_OR,
874	XPATH_OP_EQUAL,
875	XPATH_OP_CMP,
876	XPATH_OP_PLUS,
877	XPATH_OP_MULT,
878	XPATH_OP_UNION,
879	XPATH_OP_ROOT,
880	XPATH_OP_NODE,
881	XPATH_OP_RESET, /* 10 */
882	XPATH_OP_COLLECT,
883	XPATH_OP_VALUE, /* 12 */
884	XPATH_OP_VARIABLE,
885	XPATH_OP_FUNCTION,
886	XPATH_OP_ARG,
887	XPATH_OP_PREDICATE,
888	XPATH_OP_FILTER, /* 17 */
889	XPATH_OP_SORT /* 18 */
890	#ifdef LIBXML_XPTR_ENABLED
891	,XPATH_OP_RANGETO
892	#endif
893	} xmlXPathOp;
894
895	typedef enum {
896	AXIS_ANCESTOR = 1,
897	AXIS_ANCESTOR_OR_SELF,
898	AXIS_ATTRIBUTE,
899	AXIS_CHILD,
900	AXIS_DESCENDANT,
901	AXIS_DESCENDANT_OR_SELF,
902	AXIS_FOLLOWING,
903	AXIS_FOLLOWING_SIBLING,
904	AXIS_NAMESPACE,
905	AXIS_PARENT,
906	AXIS_PRECEDING,
907	AXIS_PRECEDING_SIBLING,
908	AXIS_SELF
909	} xmlXPathAxisVal;
910
911	typedef enum {
912	NODE_TEST_NONE = 0,
913	NODE_TEST_TYPE = 1,
914	NODE_TEST_PI = 2,
915	NODE_TEST_ALL = 3,
916	NODE_TEST_NS = 4,
917	NODE_TEST_NAME = 5
918	} xmlXPathTestVal;
919
920	typedef enum {
921	NODE_TYPE_NODE = 0,
922	NODE_TYPE_COMMENT = XML_COMMENT_NODE,
923	NODE_TYPE_TEXT = XML_TEXT_NODE,
924	NODE_TYPE_PI = XML_PI_NODE
925	} xmlXPathTypeVal;
926
927	typedef struct _xmlXPathStepOp xmlXPathStepOp;
928	typedef xmlXPathStepOp *xmlXPathStepOpPtr;
929	struct _xmlXPathStepOp {
930	xmlXPathOp op; /* The identifier of the operation */
931	int ch1; /* First child */
932	int ch2; /* Second child */
933	int value;
934	int value2;
935	int value3;
936	void *value4;
937	void *value5;
938	void *cache;
939	void *cacheURI;
940	};
941
942	struct _xmlXPathCompExpr {
943	int nbStep; /* Number of steps in this expression */
944	int maxStep; /* Maximum number of steps allocated */
945	xmlXPathStepOp steps; / ops for computation of this expression */
946	int last; /* index of last step in expression */
947	xmlChar expr; / the expression being computed */
948	xmlDictPtr dict; /* the dictionnary to use if any */
949	#ifdef DEBUG_EVAL_COUNTS
950	int nb;
951	xmlChar *string;
952	#endif
953	#ifdef XPATH_STREAMING
954	xmlPatternPtr stream;
955	#endif
956	};
957
958	/************************************************************************
959	* *
960	* Forward declarations *
961	* *
962	************************************************************************/
963	static void
964	xmlXPathFreeValueTree(xmlNodeSetPtr obj);
965	static void
966	xmlXPathReleaseObject(xmlXPathContextPtr ctxt, xmlXPathObjectPtr obj);
967	static int
968	xmlXPathCompOpEvalFirst(xmlXPathParserContextPtr ctxt,
969	xmlXPathStepOpPtr op, xmlNodePtr *first);
970	static int
971	xmlXPathCompOpEvalToBoolean(xmlXPathParserContextPtr ctxt,
972	xmlXPathStepOpPtr op,
973	int isPredicate);
974
975	/************************************************************************
976	* *
977	* Parser Type functions *
978	* *
979	************************************************************************/
980
981	/**
982	* xmlXPathNewCompExpr:
983	*
984	* Create a new Xpath component
985	*
986	* Returns the newly allocated xmlXPathCompExprPtr or NULL in case of error
987	*/
988	static xmlXPathCompExprPtr
989	xmlXPathNewCompExpr(void) {
990	xmlXPathCompExprPtr cur;
991
992	cur = (xmlXPathCompExprPtr) xmlMalloc(sizeof(xmlXPathCompExpr));
993	if (cur == NULL) {
994	xmlXPathErrMemory(NULL, "allocating component\n");
995	return(NULL);
996	}
997	memset(cur, 0, sizeof(xmlXPathCompExpr));
998	cur->maxStep = 10;
999	cur->nbStep = 0;
1000	cur->steps = (xmlXPathStepOp ) xmlMalloc(cur->maxStep
1001	sizeof(xmlXPathStepOp));
1002	if (cur->steps == NULL) {
1003	xmlXPathErrMemory(NULL, "allocating steps\n");
1004	xmlFree(cur);
1005	return(NULL);
1006	}
1007	memset(cur->steps, 0, cur->maxStep * sizeof(xmlXPathStepOp));
1008	cur->last = -1;
1009	#ifdef DEBUG_EVAL_COUNTS
1010	cur->nb = 0;
1011	#endif
1012	return(cur);
1013	}
1014
1015	/**
1016	* xmlXPathFreeCompExpr:
1017	* @comp: an XPATH comp
1018	*
1019	* Free up the memory allocated by @comp
1020	*/
1021	void
1022	xmlXPathFreeCompExpr(xmlXPathCompExprPtr comp)
1023	{
1024	xmlXPathStepOpPtr op;
1025	int i;
1026
1027	if (comp == NULL)
1028	return;
1029	if (comp->dict == NULL) {
1030	for (i = 0; i < comp->nbStep; i++) {
1031	op = &comp->steps[i];
1032	if (op->value4 != NULL) {
1033	if (op->op == XPATH_OP_VALUE)
1034	xmlXPathFreeObject(op->value4);
1035	else
1036	xmlFree(op->value4);
1037	}
1038	if (op->value5 != NULL)
1039	xmlFree(op->value5);
1040	}
1041	} else {
1042	for (i = 0; i < comp->nbStep; i++) {
1043	op = &comp->steps[i];
1044	if (op->value4 != NULL) {
1045	if (op->op == XPATH_OP_VALUE)
1046	xmlXPathFreeObject(op->value4);
1047	}
1048	}
1049	xmlDictFree(comp->dict);
1050	}
1051	if (comp->steps != NULL) {
1052	xmlFree(comp->steps);
1053	}
1054	#ifdef DEBUG_EVAL_COUNTS
1055	if (comp->string != NULL) {
1056	xmlFree(comp->string);
1057	}
1058	#endif
1059	#ifdef XPATH_STREAMING
1060	if (comp->stream != NULL) {
1061	xmlFreePatternList(comp->stream);
1062	}
1063	#endif
1064	if (comp->expr != NULL) {
1065	xmlFree(comp->expr);
1066	}
1067
1068	xmlFree(comp);
1069	}
1070
1071	/**
1072	* xmlXPathCompExprAdd:
1073	* @comp: the compiled expression
1074	* @ch1: first child index
1075	* @ch2: second child index
1076	* @op: an op
1077	* @value: the first int value
1078	* @value2: the second int value
1079	* @value3: the third int value
1080	* @value4: the first string value
1081	* @value5: the second string value
1082	*
1083	* Add a step to an XPath Compiled Expression
1084	*
1085	* Returns -1 in case of failure, the index otherwise
1086	*/
1087	static int
1088	xmlXPathCompExprAdd(xmlXPathCompExprPtr comp, int ch1, int ch2,
1089	xmlXPathOp op, int value,
1090	int value2, int value3, void value4, void value5) {
1091	if (comp->nbStep >= comp->maxStep) {
1092	xmlXPathStepOp *real;
1093
1094	if (comp->maxStep >= XPATH_MAX_STEPS) {
1095	xmlXPathErrMemory(NULL, "adding step\n");
1096	return(-1);
1097	}
1098	comp->maxStep *= 2;
1099	real = (xmlXPathStepOp *) xmlRealloc(comp->steps,
1100	comp->maxStep * sizeof(xmlXPathStepOp));
1101	if (real == NULL) {
1102	comp->maxStep /= 2;
1103	xmlXPathErrMemory(NULL, "adding step\n");
1104	return(-1);
1105	}
1106	comp->steps = real;
1107	}
1108	comp->last = comp->nbStep;
1109	comp->steps[comp->nbStep].ch1 = ch1;
1110	comp->steps[comp->nbStep].ch2 = ch2;
1111	comp->steps[comp->nbStep].op = op;
1112	comp->steps[comp->nbStep].value = value;
1113	comp->steps[comp->nbStep].value2 = value2;
1114	comp->steps[comp->nbStep].value3 = value3;
1115	if ((comp->dict != NULL) &&
1116	((op == XPATH_OP_FUNCTION) \|\| (op == XPATH_OP_VARIABLE) \|\|
1117	(op == XPATH_OP_COLLECT))) {
1118	if (value4 != NULL) {
1119	comp->steps[comp->nbStep].value4 = (xmlChar *)
1120	(void *)xmlDictLookup(comp->dict, value4, -1);
1121	xmlFree(value4);
1122	} else
1123	comp->steps[comp->nbStep].value4 = NULL;
1124	if (value5 != NULL) {
1125	comp->steps[comp->nbStep].value5 = (xmlChar *)
1126	(void *)xmlDictLookup(comp->dict, value5, -1);
1127	xmlFree(value5);
1128	} else
1129	comp->steps[comp->nbStep].value5 = NULL;
1130	} else {
1131	comp->steps[comp->nbStep].value4 = value4;
1132	comp->steps[comp->nbStep].value5 = value5;
1133	}
1134	comp->steps[comp->nbStep].cache = NULL;
1135	return(comp->nbStep++);
1136	}
1137
1138	/**
1139	* xmlXPathCompSwap:
1140	* @comp: the compiled expression
1141	* @op: operation index
1142	*
1143	* Swaps 2 operations in the compiled expression
1144	*/
1145	static void
1146	xmlXPathCompSwap(xmlXPathStepOpPtr op) {
1147	int tmp;
1148
1149	#ifndef LIBXML_THREAD_ENABLED
1150	/*
1151	* Since this manipulates possibly shared variables, this is
1152	* disabled if one detects that the library is used in a multithreaded
1153	* application
1154	*/
1155	if (xmlXPathDisableOptimizer)
1156	return;
1157	#endif
1158
1159	tmp = op->ch1;
1160	op->ch1 = op->ch2;
1161	op->ch2 = tmp;
1162	}
1163
1164	#define PUSH_FULL_EXPR(op, op1, op2, val, val2, val3, val4, val5) \
1165	xmlXPathCompExprAdd(ctxt->comp, (op1), (op2), \
1166	(op), (val), (val2), (val3), (val4), (val5))
1167	#define PUSH_LONG_EXPR(op, val, val2, val3, val4, val5) \
1168	xmlXPathCompExprAdd(ctxt->comp, ctxt->comp->last, -1, \
1169	(op), (val), (val2), (val3), (val4), (val5))
1170
1171	#define PUSH_LEAVE_EXPR(op, val, val2) \
1172	xmlXPathCompExprAdd(ctxt->comp, -1, -1, (op), (val), (val2), 0 ,NULL ,NULL)
1173
1174	#define PUSH_UNARY_EXPR(op, ch, val, val2) \
1175	xmlXPathCompExprAdd(ctxt->comp, (ch), -1, (op), (val), (val2), 0 ,NULL ,NULL)
1176
1177	#define PUSH_BINARY_EXPR(op, ch1, ch2, val, val2) \
1178	xmlXPathCompExprAdd(ctxt->comp, (ch1), (ch2), (op), \
1179	(val), (val2), 0 ,NULL ,NULL)
1180
1181	/************************************************************************
1182	* *
1183	* XPath object cache structures *
1184	* *
1185	************************************************************************/
1186
1187	/* #define XP_DEFAULT_CACHE_ON */
1188
1189	#define XP_HAS_CACHE(c) ((c != NULL) && ((c)->cache != NULL))
1190
1191	typedef struct _xmlXPathContextCache xmlXPathContextCache;
1192	typedef xmlXPathContextCache *xmlXPathContextCachePtr;
1193	struct _xmlXPathContextCache {
1194	xmlPointerListPtr nodesetObjs; /* contains xmlXPathObjectPtr */
1195	xmlPointerListPtr stringObjs; /* contains xmlXPathObjectPtr */
1196	xmlPointerListPtr booleanObjs; /* contains xmlXPathObjectPtr */
1197	xmlPointerListPtr numberObjs; /* contains xmlXPathObjectPtr */
1198	xmlPointerListPtr miscObjs; /* contains xmlXPathObjectPtr */
1199	int maxNodeset;
1200	int maxString;
1201	int maxBoolean;
1202	int maxNumber;
1203	int maxMisc;
1204	#ifdef XP_DEBUG_OBJ_USAGE
1205	int dbgCachedAll;
1206	int dbgCachedNodeset;
1207	int dbgCachedString;
1208	int dbgCachedBool;
1209	int dbgCachedNumber;
1210	int dbgCachedPoint;
1211	int dbgCachedRange;
1212	int dbgCachedLocset;
1213	int dbgCachedUsers;
1214	int dbgCachedXSLTTree;
1215	int dbgCachedUndefined;
1216
1217
1218	int dbgReusedAll;
1219	int dbgReusedNodeset;
1220	int dbgReusedString;
1221	int dbgReusedBool;
1222	int dbgReusedNumber;
1223	int dbgReusedPoint;
1224	int dbgReusedRange;
1225	int dbgReusedLocset;
1226	int dbgReusedUsers;
1227	int dbgReusedXSLTTree;
1228	int dbgReusedUndefined;
1229
1230	#endif
1231	};
1232
1233	/************************************************************************
1234	* *
1235	* Debugging related functions *
1236	* *
1237	************************************************************************/
1238
1239	#define STRANGE \
1240	xmlGenericError(xmlGenericErrorContext, \
1241	"Internal error at %s:%d\n", \
1242	__FILE__, __LINE__);
1243
1244	#ifdef LIBXML_DEBUG_ENABLED
1245	static void
1246	xmlXPathDebugDumpNode(FILE *output, xmlNodePtr cur, int depth) {
1247	int i;
1248	char shift[100];
1249
1250	for (i = 0;((i < depth) && (i < 25));i++)
1251	shift[2 * i] = shift[2 * i + 1] = ' ';
1252	shift[2 * i] = shift[2 * i + 1] = 0;
1253	if (cur == NULL) {
1254	fprintf(output, "%s", shift);
1255	fprintf(output, "Node is NULL !\n");
1256	return;
1257
1258	}
1259
1260	if ((cur->type == XML_DOCUMENT_NODE) \|\|
1261	(cur->type == XML_HTML_DOCUMENT_NODE)) {
1262	fprintf(output, "%s", shift);
1263	fprintf(output, " /\n");
1264	} else if (cur->type == XML_ATTRIBUTE_NODE)
1265	xmlDebugDumpAttr(output, (xmlAttrPtr)cur, depth);
1266	else
1267	xmlDebugDumpOneNode(output, cur, depth);
1268	}
1269	static void
1270	xmlXPathDebugDumpNodeList(FILE *output, xmlNodePtr cur, int depth) {
1271	xmlNodePtr tmp;
1272	int i;
1273	char shift[100];
1274
1275	for (i = 0;((i < depth) && (i < 25));i++)
1276	shift[2 * i] = shift[2 * i + 1] = ' ';
1277	shift[2 * i] = shift[2 * i + 1] = 0;
1278	if (cur == NULL) {
1279	fprintf(output, "%s", shift);
1280	fprintf(output, "Node is NULL !\n");
1281	return;
1282
1283	}
1284
1285	while (cur != NULL) {
1286	tmp = cur;
1287	cur = cur->next;
1288	xmlDebugDumpOneNode(output, tmp, depth);
1289	}
1290	}
1291
1292	static void
1293	xmlXPathDebugDumpNodeSet(FILE *output, xmlNodeSetPtr cur, int depth) {
1294	int i;
1295	char shift[100];
1296
1297	for (i = 0;((i < depth) && (i < 25));i++)
1298	shift[2 * i] = shift[2 * i + 1] = ' ';
1299	shift[2 * i] = shift[2 * i + 1] = 0;
1300
1301	if (cur == NULL) {
1302	fprintf(output, "%s", shift);
1303	fprintf(output, "NodeSet is NULL !\n");
1304	return;
1305
1306	}
1307
1308	if (cur != NULL) {
1309	fprintf(output, "Set contains %d nodes:\n", cur->nodeNr);
1310	for (i = 0;i < cur->nodeNr;i++) {
1311	fprintf(output, "%s", shift);
1312	fprintf(output, "%d", i + 1);
1313	xmlXPathDebugDumpNode(output, cur->nodeTab[i], depth + 1);
1314	}
1315	}
1316	}
1317
1318	static void
1319	xmlXPathDebugDumpValueTree(FILE *output, xmlNodeSetPtr cur, int depth) {
1320	int i;
1321	char shift[100];
1322
1323	for (i = 0;((i < depth) && (i < 25));i++)
1324	shift[2 * i] = shift[2 * i + 1] = ' ';
1325	shift[2 * i] = shift[2 * i + 1] = 0;
1326
1327	if ((cur == NULL) \|\| (cur->nodeNr == 0) \|\| (cur->nodeTab[0] == NULL)) {
1328	fprintf(output, "%s", shift);
1329	fprintf(output, "Value Tree is NULL !\n");
1330	return;
1331
1332	}
1333
1334	fprintf(output, "%s", shift);
1335	fprintf(output, "%d", i + 1);
1336	xmlXPathDebugDumpNodeList(output, cur->nodeTab[0]->children, depth + 1);
1337	}
1338	#if defined(LIBXML_XPTR_ENABLED)
1339	static void
1340	xmlXPathDebugDumpLocationSet(FILE *output, xmlLocationSetPtr cur, int depth) {
1341	int i;
1342	char shift[100];
1343
1344	for (i = 0;((i < depth) && (i < 25));i++)
1345	shift[2 * i] = shift[2 * i + 1] = ' ';
1346	shift[2 * i] = shift[2 * i + 1] = 0;
1347
1348	if (cur == NULL) {
1349	fprintf(output, "%s", shift);
1350	fprintf(output, "LocationSet is NULL !\n");
1351	return;
1352
1353	}
1354
1355	for (i = 0;i < cur->locNr;i++) {
1356	fprintf(output, "%s", shift);
1357	fprintf(output, "%d : ", i + 1);
1358	xmlXPathDebugDumpObject(output, cur->locTab[i], depth + 1);
1359	}
1360	}
1361	#endif /* LIBXML_XPTR_ENABLED */
1362
1363	/**
1364	* xmlXPathDebugDumpObject:
1365	* @output: the FILE * to dump the output
1366	* @cur: the object to inspect
1367	* @depth: indentation level
1368	*
1369	* Dump the content of the object for debugging purposes
1370	*/
1371	void
1372	xmlXPathDebugDumpObject(FILE *output, xmlXPathObjectPtr cur, int depth) {
1373	int i;
1374	char shift[100];
1375
1376	if (output == NULL) return;
1377
1378	for (i = 0;((i < depth) && (i < 25));i++)
1379	shift[2 * i] = shift[2 * i + 1] = ' ';
1380	shift[2 * i] = shift[2 * i + 1] = 0;
1381
1382
1383	fprintf(output, "%s", shift);
1384
1385	if (cur == NULL) {
1386	fprintf(output, "Object is empty (NULL)\n");
1387	return;
1388	}
1389	switch(cur->type) {
1390	case XPATH_UNDEFINED:
1391	fprintf(output, "Object is uninitialized\n");
1392	break;
1393	case XPATH_NODESET:
1394	fprintf(output, "Object is a Node Set :\n");
1395	xmlXPathDebugDumpNodeSet(output, cur->nodesetval, depth);
1396	break;
1397	case XPATH_XSLT_TREE:
1398	fprintf(output, "Object is an XSLT value tree :\n");
1399	xmlXPathDebugDumpValueTree(output, cur->nodesetval, depth);
1400	break;
1401	case XPATH_BOOLEAN:
1402	fprintf(output, "Object is a Boolean : ");
1403	if (cur->boolval) fprintf(output, "true\n");
1404	else fprintf(output, "false\n");
1405	break;
1406	case XPATH_NUMBER:
1407	switch (xmlXPathIsInf(cur->floatval)) {
1408	case 1:
1409	fprintf(output, "Object is a number : Infinity\n");
1410	break;
1411	case -1:
1412	fprintf(output, "Object is a number : -Infinity\n");
1413	break;
1414	default:
1415	if (xmlXPathIsNaN(cur->floatval)) {
1416	fprintf(output, "Object is a number : NaN\n");
1417	} else if (cur->floatval == 0 && xmlXPathGetSign(cur->floatval) != 0) {
1418	fprintf(output, "Object is a number : 0\n");
1419	} else {
1420	fprintf(output, "Object is a number : %0g\n", cur->floatval);
1421	}
1422	}
1423	break;
1424	case XPATH_STRING:
1425	fprintf(output, "Object is a string : ");
1426	xmlDebugDumpString(output, cur->stringval);
1427	fprintf(output, "\n");
1428	break;
1429	case XPATH_POINT:
1430	fprintf(output, "Object is a point : index %d in node", cur->index);
1431	xmlXPathDebugDumpNode(output, (xmlNodePtr) cur->user, depth + 1);
1432	fprintf(output, "\n");
1433	break;
1434	case XPATH_RANGE:
1435	if ((cur->user2 == NULL) \|\|
1436	((cur->user2 == cur->user) && (cur->index == cur->index2))) {
1437	fprintf(output, "Object is a collapsed range :\n");
1438	fprintf(output, "%s", shift);
1439	if (cur->index >= 0)
1440	fprintf(output, "index %d in ", cur->index);
1441	fprintf(output, "node\n");
1442	xmlXPathDebugDumpNode(output, (xmlNodePtr) cur->user,
1443	depth + 1);
1444	} else {
1445	fprintf(output, "Object is a range :\n");
1446	fprintf(output, "%s", shift);
1447	fprintf(output, "From ");
1448	if (cur->index >= 0)
1449	fprintf(output, "index %d in ", cur->index);
1450	fprintf(output, "node\n");
1451	xmlXPathDebugDumpNode(output, (xmlNodePtr) cur->user,
1452	depth + 1);
1453	fprintf(output, "%s", shift);
1454	fprintf(output, "To ");
1455	if (cur->index2 >= 0)
1456	fprintf(output, "index %d in ", cur->index2);
1457	fprintf(output, "node\n");
1458	xmlXPathDebugDumpNode(output, (xmlNodePtr) cur->user2,
1459	depth + 1);
1460	fprintf(output, "\n");
1461	}
1462	break;
1463	case XPATH_LOCATIONSET:
1464	#if defined(LIBXML_XPTR_ENABLED)
1465	fprintf(output, "Object is a Location Set:\n");
1466	xmlXPathDebugDumpLocationSet(output,
1467	(xmlLocationSetPtr) cur->user, depth);
1468	#endif
1469	break;
1470	case XPATH_USERS:
1471	fprintf(output, "Object is user defined\n");
1472	break;
1473	}
1474	}
1475
1476	static void
1477	xmlXPathDebugDumpStepOp(FILE *output, xmlXPathCompExprPtr comp,
1478	xmlXPathStepOpPtr op, int depth) {
1479	int i;
1480	char shift[100];
1481
1482	for (i = 0;((i < depth) && (i < 25));i++)
1483	shift[2 * i] = shift[2 * i + 1] = ' ';
1484	shift[2 * i] = shift[2 * i + 1] = 0;
1485
1486	fprintf(output, "%s", shift);
1487	if (op == NULL) {
1488	fprintf(output, "Step is NULL\n");
1489	return;
1490	}
1491	switch (op->op) {
1492	case XPATH_OP_END:
1493	fprintf(output, "END"); break;
1494	case XPATH_OP_AND:
1495	fprintf(output, "AND"); break;
1496	case XPATH_OP_OR:
1497	fprintf(output, "OR"); break;
1498	case XPATH_OP_EQUAL:
1499	if (op->value)
1500	fprintf(output, "EQUAL =");
1501	else
1502	fprintf(output, "EQUAL !=");
1503	break;
1504	case XPATH_OP_CMP:
1505	if (op->value)
1506	fprintf(output, "CMP <");
1507	else
1508	fprintf(output, "CMP >");
1509	if (!op->value2)
1510	fprintf(output, "=");
1511	break;
1512	case XPATH_OP_PLUS:
1513	if (op->value == 0)
1514	fprintf(output, "PLUS -");
1515	else if (op->value == 1)
1516	fprintf(output, "PLUS +");
1517	else if (op->value == 2)
1518	fprintf(output, "PLUS unary -");
1519	else if (op->value == 3)
1520	fprintf(output, "PLUS unary - -");
1521	break;
1522	case XPATH_OP_MULT:
1523	if (op->value == 0)
1524	fprintf(output, "MULT *");
1525	else if (op->value == 1)
1526	fprintf(output, "MULT div");
1527	else
1528	fprintf(output, "MULT mod");
1529	break;
1530	case XPATH_OP_UNION:
1531	fprintf(output, "UNION"); break;
1532	case XPATH_OP_ROOT:
1533	fprintf(output, "ROOT"); break;
1534	case XPATH_OP_NODE:
1535	fprintf(output, "NODE"); break;
1536	case XPATH_OP_RESET:
1537	fprintf(output, "RESET"); break;
1538	case XPATH_OP_SORT:
1539	fprintf(output, "SORT"); break;
1540	case XPATH_OP_COLLECT: {
1541	xmlXPathAxisVal axis = (xmlXPathAxisVal)op->value;
1542	xmlXPathTestVal test = (xmlXPathTestVal)op->value2;
1543	xmlXPathTypeVal type = (xmlXPathTypeVal)op->value3;
1544	const xmlChar *prefix = op->value4;
1545	const xmlChar *name = op->value5;
1546
1547	fprintf(output, "COLLECT ");
1548	switch (axis) {
1549	case AXIS_ANCESTOR:
1550	fprintf(output, " 'ancestors' "); break;
1551	case AXIS_ANCESTOR_OR_SELF:
1552	fprintf(output, " 'ancestors-or-self' "); break;
1553	case AXIS_ATTRIBUTE:
1554	fprintf(output, " 'attributes' "); break;
1555	case AXIS_CHILD:
1556	fprintf(output, " 'child' "); break;
1557	case AXIS_DESCENDANT:
1558	fprintf(output, " 'descendant' "); break;
1559	case AXIS_DESCENDANT_OR_SELF:
1560	fprintf(output, " 'descendant-or-self' "); break;
1561	case AXIS_FOLLOWING:
1562	fprintf(output, " 'following' "); break;
1563	case AXIS_FOLLOWING_SIBLING:
1564	fprintf(output, " 'following-siblings' "); break;
1565	case AXIS_NAMESPACE:
1566	fprintf(output, " 'namespace' "); break;
1567	case AXIS_PARENT:
1568	fprintf(output, " 'parent' "); break;
1569	case AXIS_PRECEDING:
1570	fprintf(output, " 'preceding' "); break;
1571	case AXIS_PRECEDING_SIBLING:
1572	fprintf(output, " 'preceding-sibling' "); break;
1573	case AXIS_SELF:
1574	fprintf(output, " 'self' "); break;
1575	}
1576	switch (test) {
1577	case NODE_TEST_NONE:
1578	fprintf(output, "'none' "); break;
1579	case NODE_TEST_TYPE:
1580	fprintf(output, "'type' "); break;
1581	case NODE_TEST_PI:
1582	fprintf(output, "'PI' "); break;
1583	case NODE_TEST_ALL:
1584	fprintf(output, "'all' "); break;
1585	case NODE_TEST_NS:
1586	fprintf(output, "'namespace' "); break;
1587	case NODE_TEST_NAME:
1588	fprintf(output, "'name' "); break;
1589	}
1590	switch (type) {
1591	case NODE_TYPE_NODE:
1592	fprintf(output, "'node' "); break;
1593	case NODE_TYPE_COMMENT:
1594	fprintf(output, "'comment' "); break;
1595	case NODE_TYPE_TEXT:
1596	fprintf(output, "'text' "); break;
1597	case NODE_TYPE_PI:
1598	fprintf(output, "'PI' "); break;
1599	}
1600	if (prefix != NULL)
1601	fprintf(output, "%s:", prefix);
1602	if (name != NULL)
1603	fprintf(output, "%s", (const char *) name);
1604	break;
1605
1606	}
1607	case XPATH_OP_VALUE: {
1608	xmlXPathObjectPtr object = (xmlXPathObjectPtr) op->value4;
1609
1610	fprintf(output, "ELEM ");
1611	xmlXPathDebugDumpObject(output, object, 0);
1612	goto finish;
1613	}
1614	case XPATH_OP_VARIABLE: {
1615	const xmlChar *prefix = op->value5;
1616	const xmlChar *name = op->value4;
1617
1618	if (prefix != NULL)
1619	fprintf(output, "VARIABLE %s:%s", prefix, name);
1620	else
1621	fprintf(output, "VARIABLE %s", name);
1622	break;
1623	}
1624	case XPATH_OP_FUNCTION: {
1625	int nbargs = op->value;
1626	const xmlChar *prefix = op->value5;
1627	const xmlChar *name = op->value4;
1628
1629	if (prefix != NULL)
1630	fprintf(output, "FUNCTION %s:%s(%d args)",
1631	prefix, name, nbargs);
1632	else
1633	fprintf(output, "FUNCTION %s(%d args)", name, nbargs);
1634	break;
1635	}
1636	case XPATH_OP_ARG: fprintf(output, "ARG"); break;
1637	case XPATH_OP_PREDICATE: fprintf(output, "PREDICATE"); break;
1638	case XPATH_OP_FILTER: fprintf(output, "FILTER"); break;
1639	#ifdef LIBXML_XPTR_ENABLED
1640	case XPATH_OP_RANGETO: fprintf(output, "RANGETO"); break;
1641	#endif
1642	default:
1643	fprintf(output, "UNKNOWN %d\n", op->op); return;
1644	}
1645	fprintf(output, "\n");
1646	finish:
1647	if (op->ch1 >= 0)
1648	xmlXPathDebugDumpStepOp(output, comp, &comp->steps[op->ch1], depth + 1);
1649	if (op->ch2 >= 0)
1650	xmlXPathDebugDumpStepOp(output, comp, &comp->steps[op->ch2], depth + 1);
1651	}
1652
1653	/**
1654	* xmlXPathDebugDumpCompExpr:
1655	* @output: the FILE * for the output
1656	* @comp: the precompiled XPath expression
1657	* @depth: the indentation level.
1658	*
1659	* Dumps the tree of the compiled XPath expression.
1660	*/
1661	void
1662	xmlXPathDebugDumpCompExpr(FILE *output, xmlXPathCompExprPtr comp,
1663	int depth) {
1664	int i;
1665	char shift[100];
1666
1667	if ((output == NULL) \|\| (comp == NULL)) return;
1668
1669	for (i = 0;((i < depth) && (i < 25));i++)
1670	shift[2 * i] = shift[2 * i + 1] = ' ';
1671	shift[2 * i] = shift[2 * i + 1] = 0;
1672
1673	fprintf(output, "%s", shift);
1674
1675	fprintf(output, "Compiled Expression : %d elements\n",
1676	comp->nbStep);
1677	i = comp->last;
1678	xmlXPathDebugDumpStepOp(output, comp, &comp->steps[i], depth + 1);
1679	}
1680
1681	#ifdef XP_DEBUG_OBJ_USAGE
1682
1683	/*
1684	* XPath object usage related debugging variables.
1685	*/
1686	static int xmlXPathDebugObjCounterUndefined = 0;
1687	static int xmlXPathDebugObjCounterNodeset = 0;
1688	static int xmlXPathDebugObjCounterBool = 0;
1689	static int xmlXPathDebugObjCounterNumber = 0;
1690	static int xmlXPathDebugObjCounterString = 0;
1691	static int xmlXPathDebugObjCounterPoint = 0;
1692	static int xmlXPathDebugObjCounterRange = 0;
1693	static int xmlXPathDebugObjCounterLocset = 0;
1694	static int xmlXPathDebugObjCounterUsers = 0;
1695	static int xmlXPathDebugObjCounterXSLTTree = 0;
1696	static int xmlXPathDebugObjCounterAll = 0;
1697
1698	static int xmlXPathDebugObjTotalUndefined = 0;
1699	static int xmlXPathDebugObjTotalNodeset = 0;
1700	static int xmlXPathDebugObjTotalBool = 0;
1701	static int xmlXPathDebugObjTotalNumber = 0;
1702	static int xmlXPathDebugObjTotalString = 0;
1703	static int xmlXPathDebugObjTotalPoint = 0;
1704	static int xmlXPathDebugObjTotalRange = 0;
1705	static int xmlXPathDebugObjTotalLocset = 0;
1706	static int xmlXPathDebugObjTotalUsers = 0;
1707	static int xmlXPathDebugObjTotalXSLTTree = 0;
1708	static int xmlXPathDebugObjTotalAll = 0;
1709
1710	static int xmlXPathDebugObjMaxUndefined = 0;
1711	static int xmlXPathDebugObjMaxNodeset = 0;
1712	static int xmlXPathDebugObjMaxBool = 0;
1713	static int xmlXPathDebugObjMaxNumber = 0;
1714	static int xmlXPathDebugObjMaxString = 0;
1715	static int xmlXPathDebugObjMaxPoint = 0;
1716	static int xmlXPathDebugObjMaxRange = 0;
1717	static int xmlXPathDebugObjMaxLocset = 0;
1718	static int xmlXPathDebugObjMaxUsers = 0;
1719	static int xmlXPathDebugObjMaxXSLTTree = 0;
1720	static int xmlXPathDebugObjMaxAll = 0;
1721
1722	/* REVISIT TODO: Make this static when committing */
1723	static void
1724	xmlXPathDebugObjUsageReset(xmlXPathContextPtr ctxt)
1725	{
1726	if (ctxt != NULL) {
1727	if (ctxt->cache != NULL) {
1728	xmlXPathContextCachePtr cache =
1729	(xmlXPathContextCachePtr) ctxt->cache;
1730
1731	cache->dbgCachedAll = 0;
1732	cache->dbgCachedNodeset = 0;
1733	cache->dbgCachedString = 0;
1734	cache->dbgCachedBool = 0;
1735	cache->dbgCachedNumber = 0;
1736	cache->dbgCachedPoint = 0;
1737	cache->dbgCachedRange = 0;
1738	cache->dbgCachedLocset = 0;
1739	cache->dbgCachedUsers = 0;
1740	cache->dbgCachedXSLTTree = 0;
1741	cache->dbgCachedUndefined = 0;
1742
1743	cache->dbgReusedAll = 0;
1744	cache->dbgReusedNodeset = 0;
1745	cache->dbgReusedString = 0;
1746	cache->dbgReusedBool = 0;
1747	cache->dbgReusedNumber = 0;
1748	cache->dbgReusedPoint = 0;
1749	cache->dbgReusedRange = 0;
1750	cache->dbgReusedLocset = 0;
1751	cache->dbgReusedUsers = 0;
1752	cache->dbgReusedXSLTTree = 0;
1753	cache->dbgReusedUndefined = 0;
1754	}
1755	}
1756
1757	xmlXPathDebugObjCounterUndefined = 0;
1758	xmlXPathDebugObjCounterNodeset = 0;
1759	xmlXPathDebugObjCounterBool = 0;
1760	xmlXPathDebugObjCounterNumber = 0;
1761	xmlXPathDebugObjCounterString = 0;
1762	xmlXPathDebugObjCounterPoint = 0;
1763	xmlXPathDebugObjCounterRange = 0;
1764	xmlXPathDebugObjCounterLocset = 0;
1765	xmlXPathDebugObjCounterUsers = 0;
1766	xmlXPathDebugObjCounterXSLTTree = 0;
1767	xmlXPathDebugObjCounterAll = 0;
1768
1769	xmlXPathDebugObjTotalUndefined = 0;
1770	xmlXPathDebugObjTotalNodeset = 0;
1771	xmlXPathDebugObjTotalBool = 0;
1772	xmlXPathDebugObjTotalNumber = 0;
1773	xmlXPathDebugObjTotalString = 0;
1774	xmlXPathDebugObjTotalPoint = 0;
1775	xmlXPathDebugObjTotalRange = 0;
1776	xmlXPathDebugObjTotalLocset = 0;
1777	xmlXPathDebugObjTotalUsers = 0;
1778	xmlXPathDebugObjTotalXSLTTree = 0;
1779	xmlXPathDebugObjTotalAll = 0;
1780
1781	xmlXPathDebugObjMaxUndefined = 0;
1782	xmlXPathDebugObjMaxNodeset = 0;
1783	xmlXPathDebugObjMaxBool = 0;
1784	xmlXPathDebugObjMaxNumber = 0;
1785	xmlXPathDebugObjMaxString = 0;
1786	xmlXPathDebugObjMaxPoint = 0;
1787	xmlXPathDebugObjMaxRange = 0;
1788	xmlXPathDebugObjMaxLocset = 0;
1789	xmlXPathDebugObjMaxUsers = 0;
1790	xmlXPathDebugObjMaxXSLTTree = 0;
1791	xmlXPathDebugObjMaxAll = 0;
1792
1793	}
1794
1795	static void
1796	xmlXPathDebugObjUsageRequested(xmlXPathContextPtr ctxt,
1797	xmlXPathObjectType objType)
1798	{
1799	int isCached = 0;
1800
1801	if (ctxt != NULL) {
1802	if (ctxt->cache != NULL) {
1803	xmlXPathContextCachePtr cache =
1804	(xmlXPathContextCachePtr) ctxt->cache;
1805
1806	isCached = 1;
1807
1808	cache->dbgReusedAll++;
1809	switch (objType) {
1810	case XPATH_UNDEFINED:
1811	cache->dbgReusedUndefined++;
1812	break;
1813	case XPATH_NODESET:
1814	cache->dbgReusedNodeset++;
1815	break;
1816	case XPATH_BOOLEAN:
1817	cache->dbgReusedBool++;
1818	break;
1819	case XPATH_NUMBER:
1820	cache->dbgReusedNumber++;
1821	break;
1822	case XPATH_STRING:
1823	cache->dbgReusedString++;
1824	break;
1825	case XPATH_POINT:
1826	cache->dbgReusedPoint++;
1827	break;
1828	case XPATH_RANGE:
1829	cache->dbgReusedRange++;
1830	break;
1831	case XPATH_LOCATIONSET:
1832	cache->dbgReusedLocset++;
1833	break;
1834	case XPATH_USERS:
1835	cache->dbgReusedUsers++;
1836	break;
1837	case XPATH_XSLT_TREE:
1838	cache->dbgReusedXSLTTree++;
1839	break;
1840	default:
1841	break;
1842	}
1843	}
1844	}
1845
1846	switch (objType) {
1847	case XPATH_UNDEFINED:
1848	if (! isCached)
1849	xmlXPathDebugObjTotalUndefined++;
1850	xmlXPathDebugObjCounterUndefined++;
1851	if (xmlXPathDebugObjCounterUndefined >
1852	xmlXPathDebugObjMaxUndefined)
1853	xmlXPathDebugObjMaxUndefined =
1854	xmlXPathDebugObjCounterUndefined;
1855	break;
1856	case XPATH_NODESET:
1857	if (! isCached)
1858	xmlXPathDebugObjTotalNodeset++;
1859	xmlXPathDebugObjCounterNodeset++;
1860	if (xmlXPathDebugObjCounterNodeset >
1861	xmlXPathDebugObjMaxNodeset)
1862	xmlXPathDebugObjMaxNodeset =
1863	xmlXPathDebugObjCounterNodeset;
1864	break;
1865	case XPATH_BOOLEAN:
1866	if (! isCached)
1867	xmlXPathDebugObjTotalBool++;
1868	xmlXPathDebugObjCounterBool++;
1869	if (xmlXPathDebugObjCounterBool >
1870	xmlXPathDebugObjMaxBool)
1871	xmlXPathDebugObjMaxBool =
1872	xmlXPathDebugObjCounterBool;
1873	break;
1874	case XPATH_NUMBER:
1875	if (! isCached)
1876	xmlXPathDebugObjTotalNumber++;
1877	xmlXPathDebugObjCounterNumber++;
1878	if (xmlXPathDebugObjCounterNumber >
1879	xmlXPathDebugObjMaxNumber)
1880	xmlXPathDebugObjMaxNumber =
1881	xmlXPathDebugObjCounterNumber;
1882	break;
1883	case XPATH_STRING:
1884	if (! isCached)
1885	xmlXPathDebugObjTotalString++;
1886	xmlXPathDebugObjCounterString++;
1887	if (xmlXPathDebugObjCounterString >
1888	xmlXPathDebugObjMaxString)
1889	xmlXPathDebugObjMaxString =
1890	xmlXPathDebugObjCounterString;
1891	break;
1892	case XPATH_POINT:
1893	if (! isCached)
1894	xmlXPathDebugObjTotalPoint++;
1895	xmlXPathDebugObjCounterPoint++;
1896	if (xmlXPathDebugObjCounterPoint >
1897	xmlXPathDebugObjMaxPoint)
1898	xmlXPathDebugObjMaxPoint =
1899	xmlXPathDebugObjCounterPoint;
1900	break;
1901	case XPATH_RANGE:
1902	if (! isCached)
1903	xmlXPathDebugObjTotalRange++;
1904	xmlXPathDebugObjCounterRange++;
1905	if (xmlXPathDebugObjCounterRange >
1906	xmlXPathDebugObjMaxRange)
1907	xmlXPathDebugObjMaxRange =
1908	xmlXPathDebugObjCounterRange;
1909	break;
1910	case XPATH_LOCATIONSET:
1911	if (! isCached)
1912	xmlXPathDebugObjTotalLocset++;
1913	xmlXPathDebugObjCounterLocset++;
1914	if (xmlXPathDebugObjCounterLocset >
1915	xmlXPathDebugObjMaxLocset)
1916	xmlXPathDebugObjMaxLocset =
1917	xmlXPathDebugObjCounterLocset;
1918	break;
1919	case XPATH_USERS:
1920	if (! isCached)
1921	xmlXPathDebugObjTotalUsers++;
1922	xmlXPathDebugObjCounterUsers++;
1923	if (xmlXPathDebugObjCounterUsers >
1924	xmlXPathDebugObjMaxUsers)
1925	xmlXPathDebugObjMaxUsers =
1926	xmlXPathDebugObjCounterUsers;
1927	break;
1928	case XPATH_XSLT_TREE:
1929	if (! isCached)
1930	xmlXPathDebugObjTotalXSLTTree++;
1931	xmlXPathDebugObjCounterXSLTTree++;
1932	if (xmlXPathDebugObjCounterXSLTTree >
1933	xmlXPathDebugObjMaxXSLTTree)
1934	xmlXPathDebugObjMaxXSLTTree =
1935	xmlXPathDebugObjCounterXSLTTree;
1936	break;
1937	default:
1938	break;
1939	}
1940	if (! isCached)
1941	xmlXPathDebugObjTotalAll++;
1942	xmlXPathDebugObjCounterAll++;
1943	if (xmlXPathDebugObjCounterAll >
1944	xmlXPathDebugObjMaxAll)
1945	xmlXPathDebugObjMaxAll =
1946	xmlXPathDebugObjCounterAll;
1947	}
1948
1949	static void
1950	xmlXPathDebugObjUsageReleased(xmlXPathContextPtr ctxt,
1951	xmlXPathObjectType objType)
1952	{
1953	int isCached = 0;
1954
1955	if (ctxt != NULL) {
1956	if (ctxt->cache != NULL) {
1957	xmlXPathContextCachePtr cache =
1958	(xmlXPathContextCachePtr) ctxt->cache;
1959
1960	isCached = 1;
1961
1962	cache->dbgCachedAll++;
1963	switch (objType) {
1964	case XPATH_UNDEFINED:
1965	cache->dbgCachedUndefined++;
1966	break;
1967	case XPATH_NODESET:
1968	cache->dbgCachedNodeset++;
1969	break;
1970	case XPATH_BOOLEAN:
1971	cache->dbgCachedBool++;
1972	break;
1973	case XPATH_NUMBER:
1974	cache->dbgCachedNumber++;
1975	break;
1976	case XPATH_STRING:
1977	cache->dbgCachedString++;
1978	break;
1979	case XPATH_POINT:
1980	cache->dbgCachedPoint++;
1981	break;
1982	case XPATH_RANGE:
1983	cache->dbgCachedRange++;
1984	break;
1985	case XPATH_LOCATIONSET:
1986	cache->dbgCachedLocset++;
1987	break;
1988	case XPATH_USERS:
1989	cache->dbgCachedUsers++;
1990	break;
1991	case XPATH_XSLT_TREE:
1992	cache->dbgCachedXSLTTree++;
1993	break;
1994	default:
1995	break;
1996	}
1997
1998	}
1999	}
2000	switch (objType) {
2001	case XPATH_UNDEFINED:
2002	xmlXPathDebugObjCounterUndefined--;
2003	break;
2004	case XPATH_NODESET:
2005	xmlXPathDebugObjCounterNodeset--;
2006	break;
2007	case XPATH_BOOLEAN:
2008	xmlXPathDebugObjCounterBool--;
2009	break;
2010	case XPATH_NUMBER:
2011	xmlXPathDebugObjCounterNumber--;
2012	break;
2013	case XPATH_STRING:
2014	xmlXPathDebugObjCounterString--;
2015	break;
2016	case XPATH_POINT:
2017	xmlXPathDebugObjCounterPoint--;
2018	break;
2019	case XPATH_RANGE:
2020	xmlXPathDebugObjCounterRange--;
2021	break;
2022	case XPATH_LOCATIONSET:
2023	xmlXPathDebugObjCounterLocset--;
2024	break;
2025	case XPATH_USERS:
2026	xmlXPathDebugObjCounterUsers--;
2027	break;
2028	case XPATH_XSLT_TREE:
2029	xmlXPathDebugObjCounterXSLTTree--;
2030	break;
2031	default:
2032	break;
2033	}
2034	xmlXPathDebugObjCounterAll--;
2035	}
2036
2037	/* REVISIT TODO: Make this static when committing */
2038	static void
2039	xmlXPathDebugObjUsageDisplay(xmlXPathContextPtr ctxt)
2040	{
2041	int reqAll, reqNodeset, reqString, reqBool, reqNumber,
2042	reqXSLTTree, reqUndefined;
2043	int caAll = 0, caNodeset = 0, caString = 0, caBool = 0,
2044	caNumber = 0, caXSLTTree = 0, caUndefined = 0;
2045	int reAll = 0, reNodeset = 0, reString = 0, reBool = 0,
2046	reNumber = 0, reXSLTTree = 0, reUndefined = 0;
2047	int leftObjs = xmlXPathDebugObjCounterAll;
2048
2049	reqAll = xmlXPathDebugObjTotalAll;
2050	reqNodeset = xmlXPathDebugObjTotalNodeset;
2051	reqString = xmlXPathDebugObjTotalString;
2052	reqBool = xmlXPathDebugObjTotalBool;
2053	reqNumber = xmlXPathDebugObjTotalNumber;
2054	reqXSLTTree = xmlXPathDebugObjTotalXSLTTree;
2055	reqUndefined = xmlXPathDebugObjTotalUndefined;
2056
2057	printf("# XPath object usage:\n");
2058
2059	if (ctxt != NULL) {
2060	if (ctxt->cache != NULL) {
2061	xmlXPathContextCachePtr cache =
2062	(xmlXPathContextCachePtr) ctxt->cache;
2063
2064	reAll = cache->dbgReusedAll;
2065	reqAll += reAll;
2066	reNodeset = cache->dbgReusedNodeset;
2067	reqNodeset += reNodeset;
2068	reString = cache->dbgReusedString;
2069	reqString += reString;
2070	reBool = cache->dbgReusedBool;
2071	reqBool += reBool;
2072	reNumber = cache->dbgReusedNumber;
2073	reqNumber += reNumber;
2074	reXSLTTree = cache->dbgReusedXSLTTree;
2075	reqXSLTTree += reXSLTTree;
2076	reUndefined = cache->dbgReusedUndefined;
2077	reqUndefined += reUndefined;
2078
2079	caAll = cache->dbgCachedAll;
2080	caBool = cache->dbgCachedBool;
2081	caNodeset = cache->dbgCachedNodeset;
2082	caString = cache->dbgCachedString;
2083	caNumber = cache->dbgCachedNumber;
2084	caXSLTTree = cache->dbgCachedXSLTTree;
2085	caUndefined = cache->dbgCachedUndefined;
2086
2087	if (cache->nodesetObjs)
2088	leftObjs -= cache->nodesetObjs->number;
2089	if (cache->stringObjs)
2090	leftObjs -= cache->stringObjs->number;
2091	if (cache->booleanObjs)
2092	leftObjs -= cache->booleanObjs->number;
2093	if (cache->numberObjs)
2094	leftObjs -= cache->numberObjs->number;
2095	if (cache->miscObjs)
2096	leftObjs -= cache->miscObjs->number;
2097	}
2098	}
2099
2100	printf("# all\n");
2101	printf("# total : %d\n", reqAll);
2102	printf("# left : %d\n", leftObjs);
2103	printf("# created: %d\n", xmlXPathDebugObjTotalAll);
2104	printf("# reused : %d\n", reAll);
2105	printf("# max : %d\n", xmlXPathDebugObjMaxAll);
2106
2107	printf("# node-sets\n");
2108	printf("# total : %d\n", reqNodeset);
2109	printf("# created: %d\n", xmlXPathDebugObjTotalNodeset);
2110	printf("# reused : %d\n", reNodeset);
2111	printf("# max : %d\n", xmlXPathDebugObjMaxNodeset);
2112
2113	printf("# strings\n");
2114	printf("# total : %d\n", reqString);
2115	printf("# created: %d\n", xmlXPathDebugObjTotalString);
2116	printf("# reused : %d\n", reString);
2117	printf("# max : %d\n", xmlXPathDebugObjMaxString);
2118
2119	printf("# booleans\n");
2120	printf("# total : %d\n", reqBool);
2121	printf("# created: %d\n", xmlXPathDebugObjTotalBool);
2122	printf("# reused : %d\n", reBool);
2123	printf("# max : %d\n", xmlXPathDebugObjMaxBool);
2124
2125	printf("# numbers\n");
2126	printf("# total : %d\n", reqNumber);
2127	printf("# created: %d\n", xmlXPathDebugObjTotalNumber);
2128	printf("# reused : %d\n", reNumber);
2129	printf("# max : %d\n", xmlXPathDebugObjMaxNumber);
2130
2131	printf("# XSLT result tree fragments\n");
2132	printf("# total : %d\n", reqXSLTTree);
2133	printf("# created: %d\n", xmlXPathDebugObjTotalXSLTTree);
2134	printf("# reused : %d\n", reXSLTTree);
2135	printf("# max : %d\n", xmlXPathDebugObjMaxXSLTTree);
2136
2137	printf("# undefined\n");
2138	printf("# total : %d\n", reqUndefined);
2139	printf("# created: %d\n", xmlXPathDebugObjTotalUndefined);
2140	printf("# reused : %d\n", reUndefined);
2141	printf("# max : %d\n", xmlXPathDebugObjMaxUndefined);
2142
2143	}
2144
2145	#endif /* XP_DEBUG_OBJ_USAGE */
2146
2147	#endif /* LIBXML_DEBUG_ENABLED */
2148
2149	/************************************************************************
2150	* *
2151	* XPath object caching *
2152	* *
2153	************************************************************************/
2154
2155	/**
2156	* xmlXPathNewCache:
2157	*
2158	* Create a new object cache
2159	*
2160	* Returns the xmlXPathCache just allocated.
2161	*/
2162	static xmlXPathContextCachePtr
2163	xmlXPathNewCache(void)
2164	{
2165	xmlXPathContextCachePtr ret;
2166
2167	ret = (xmlXPathContextCachePtr) xmlMalloc(sizeof(xmlXPathContextCache));
2168	if (ret == NULL) {
2169	xmlXPathErrMemory(NULL, "creating object cache\n");
2170	return(NULL);
2171	}
2172	memset(ret, 0 , (size_t) sizeof(xmlXPathContextCache));
2173	ret->maxNodeset = 100;
2174	ret->maxString = 100;
2175	ret->maxBoolean = 100;
2176	ret->maxNumber = 100;
2177	ret->maxMisc = 100;
2178	return(ret);
2179	}
2180
2181	static void
2182	xmlXPathCacheFreeObjectList(xmlPointerListPtr list)
2183	{
2184	int i;
2185	xmlXPathObjectPtr obj;
2186
2187	if (list == NULL)
2188	return;
2189
2190	for (i = 0; i < list->number; i++) {
2191	obj = list->items[i];
2192	/*
2193	* Note that it is already assured that we don't need to
2194	* look out for namespace nodes in the node-set.
2195	*/
2196	if (obj->nodesetval != NULL) {
2197	if (obj->nodesetval->nodeTab != NULL)
2198	xmlFree(obj->nodesetval->nodeTab);
2199	xmlFree(obj->nodesetval);
2200	}
2201	xmlFree(obj);
2202	#ifdef XP_DEBUG_OBJ_USAGE
2203	xmlXPathDebugObjCounterAll--;
2204	#endif
2205	}
2206	xmlPointerListFree(list);
2207	}
2208
2209	static void
2210	xmlXPathFreeCache(xmlXPathContextCachePtr cache)
2211	{
2212	if (cache == NULL)
2213	return;
2214	if (cache->nodesetObjs)
2215	xmlXPathCacheFreeObjectList(cache->nodesetObjs);
2216	if (cache->stringObjs)
2217	xmlXPathCacheFreeObjectList(cache->stringObjs);
2218	if (cache->booleanObjs)
2219	xmlXPathCacheFreeObjectList(cache->booleanObjs);
2220	if (cache->numberObjs)
2221	xmlXPathCacheFreeObjectList(cache->numberObjs);
2222	if (cache->miscObjs)
2223	xmlXPathCacheFreeObjectList(cache->miscObjs);
2224	xmlFree(cache);
2225	}
2226
2227	/**
2228	* xmlXPathContextSetCache:
2229	*
2230	* @ctxt: the XPath context
2231	* @active: enables/disables (creates/frees) the cache
2232	* @value: a value with semantics dependant on @options
2233	* @options: options (currently only the value 0 is used)
2234	*
2235	* Creates/frees an object cache on the XPath context.
2236	* If activates XPath objects (xmlXPathObject) will be cached internally
2237	* to be reused.
2238	* @options:
2239	* 0: This will set the XPath object caching:
2240	* @value:
2241	* This will set the maximum number of XPath objects
2242	* to be cached per slot
2243	* There are 5 slots for: node-set, string, number, boolean, and
2244	* misc objects. Use <0 for the default number (100).
2245	* Other values for @options have currently no effect.
2246	*
2247	* Returns 0 if the setting succeeded, and -1 on API or internal errors.
2248	*/
2249	int
2250	xmlXPathContextSetCache(xmlXPathContextPtr ctxt,
2251	int active,
2252	int value,
2253	int options)
2254	{
2255	if (ctxt == NULL)
2256	return(-1);
2257	if (active) {
2258	xmlXPathContextCachePtr cache;
2259
2260	if (ctxt->cache == NULL) {
2261	ctxt->cache = xmlXPathNewCache();
2262	if (ctxt->cache == NULL)
2263	return(-1);
2264	}
2265	cache = (xmlXPathContextCachePtr) ctxt->cache;
2266	if (options == 0) {
2267	if (value < 0)
2268	value = 100;
2269	cache->maxNodeset = value;
2270	cache->maxString = value;
2271	cache->maxNumber = value;
2272	cache->maxBoolean = value;
2273	cache->maxMisc = value;
2274	}
2275	} else if (ctxt->cache != NULL) {
2276	xmlXPathFreeCache((xmlXPathContextCachePtr) ctxt->cache);
2277	ctxt->cache = NULL;
2278	}
2279	return(0);
2280	}
2281
2282	/**
2283	* xmlXPathCacheWrapNodeSet:
2284	* @ctxt: the XPath context
2285	* @val: the NodePtr value
2286	*
2287	* This is the cached version of xmlXPathWrapNodeSet().
2288	* Wrap the Nodeset @val in a new xmlXPathObjectPtr
2289	*
2290	* Returns the created or reused object.
2291	*/
2292	static xmlXPathObjectPtr
2293	xmlXPathCacheWrapNodeSet(xmlXPathContextPtr ctxt, xmlNodeSetPtr val)
2294	{
2295	if ((ctxt != NULL) && (ctxt->cache != NULL)) {
2296	xmlXPathContextCachePtr cache =
2297	(xmlXPathContextCachePtr) ctxt->cache;
2298
2299	if ((cache->miscObjs != NULL) &&
2300	(cache->miscObjs->number != 0))
2301	{
2302	xmlXPathObjectPtr ret;
2303
2304	ret = (xmlXPathObjectPtr)
2305	cache->miscObjs->items[--cache->miscObjs->number];
2306	ret->type = XPATH_NODESET;
2307	ret->nodesetval = val;
2308	#ifdef XP_DEBUG_OBJ_USAGE
2309	xmlXPathDebugObjUsageRequested(ctxt, XPATH_NODESET);
2310	#endif
2311	return(ret);
2312	}
2313	}
2314
2315	return(xmlXPathWrapNodeSet(val));
2316
2317	}
2318
2319	/**
2320	* xmlXPathCacheWrapString:
2321	* @ctxt: the XPath context
2322	* @val: the xmlChar * value
2323	*
2324	* This is the cached version of xmlXPathWrapString().
2325	* Wraps the @val string into an XPath object.
2326	*
2327	* Returns the created or reused object.
2328	*/
2329	static xmlXPathObjectPtr
2330	xmlXPathCacheWrapString(xmlXPathContextPtr ctxt, xmlChar *val)
2331	{
2332	if ((ctxt != NULL) && (ctxt->cache != NULL)) {
2333	xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache;
2334
2335	if ((cache->stringObjs != NULL) &&
2336	(cache->stringObjs->number != 0))
2337	{
2338
2339	xmlXPathObjectPtr ret;
2340
2341	ret = (xmlXPathObjectPtr)
2342	cache->stringObjs->items[--cache->stringObjs->number];
2343	ret->type = XPATH_STRING;
2344	ret->stringval = val;
2345	#ifdef XP_DEBUG_OBJ_USAGE
2346	xmlXPathDebugObjUsageRequested(ctxt, XPATH_STRING);
2347	#endif
2348	return(ret);
2349	} else if ((cache->miscObjs != NULL) &&
2350	(cache->miscObjs->number != 0))
2351	{
2352	xmlXPathObjectPtr ret;
2353	/*
2354	* Fallback to misc-cache.
2355	*/
2356	ret = (xmlXPathObjectPtr)
2357	cache->miscObjs->items[--cache->miscObjs->number];
2358
2359	ret->type = XPATH_STRING;
2360	ret->stringval = val;
2361	#ifdef XP_DEBUG_OBJ_USAGE
2362	xmlXPathDebugObjUsageRequested(ctxt, XPATH_STRING);
2363	#endif
2364	return(ret);
2365	}
2366	}
2367	return(xmlXPathWrapString(val));
2368	}
2369
2370	/**
2371	* xmlXPathCacheNewNodeSet:
2372	* @ctxt: the XPath context
2373	* @val: the NodePtr value
2374	*
2375	* This is the cached version of xmlXPathNewNodeSet().
2376	* Acquire an xmlXPathObjectPtr of type NodeSet and initialize
2377	* it with the single Node @val
2378	*
2379	* Returns the created or reused object.
2380	*/
2381	static xmlXPathObjectPtr
2382	xmlXPathCacheNewNodeSet(xmlXPathContextPtr ctxt, xmlNodePtr val)
2383	{
2384	if ((ctxt != NULL) && (ctxt->cache)) {
2385	xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache;
2386
2387	if ((cache->nodesetObjs != NULL) &&
2388	(cache->nodesetObjs->number != 0))
2389	{
2390	xmlXPathObjectPtr ret;
2391	/*
2392	* Use the nodset-cache.
2393	*/
2394	ret = (xmlXPathObjectPtr)
2395	cache->nodesetObjs->items[--cache->nodesetObjs->number];
2396	ret->type = XPATH_NODESET;
2397	ret->boolval = 0;
2398	if (val) {
2399	if ((ret->nodesetval->nodeMax == 0) \|\|
2400	(val->type == XML_NAMESPACE_DECL))
2401	{
2402	xmlXPathNodeSetAddUnique(ret->nodesetval, val);
2403	} else {
2404	ret->nodesetval->nodeTab[0] = val;
2405	ret->nodesetval->nodeNr = 1;
2406	}
2407	}
2408	#ifdef XP_DEBUG_OBJ_USAGE
2409	xmlXPathDebugObjUsageRequested(ctxt, XPATH_NODESET);
2410	#endif
2411	return(ret);
2412	} else if ((cache->miscObjs != NULL) &&
2413	(cache->miscObjs->number != 0))
2414	{
2415	xmlXPathObjectPtr ret;
2416	/*
2417	* Fallback to misc-cache.
2418	*/
2419
2420	ret = (xmlXPathObjectPtr)
2421	cache->miscObjs->items[--cache->miscObjs->number];
2422
2423	ret->type = XPATH_NODESET;
2424	ret->boolval = 0;
2425	ret->nodesetval = xmlXPathNodeSetCreate(val);
2426	if (ret->nodesetval == NULL) {
2427	ctxt->lastError.domain = XML_FROM_XPATH;
2428	ctxt->lastError.code = XML_ERR_NO_MEMORY;
2429	return(NULL);
2430	}
2431	#ifdef XP_DEBUG_OBJ_USAGE
2432	xmlXPathDebugObjUsageRequested(ctxt, XPATH_NODESET);
2433	#endif
2434	return(ret);
2435	}
2436	}
2437	return(xmlXPathNewNodeSet(val));
2438	}
2439
2440	/**
2441	* xmlXPathCacheNewCString:
2442	* @ctxt: the XPath context
2443	* @val: the char * value
2444	*
2445	* This is the cached version of xmlXPathNewCString().
2446	* Acquire an xmlXPathObjectPtr of type string and of value @val
2447	*
2448	* Returns the created or reused object.
2449	*/
2450	static xmlXPathObjectPtr
2451	xmlXPathCacheNewCString(xmlXPathContextPtr ctxt, const char *val)
2452	{
2453	if ((ctxt != NULL) && (ctxt->cache)) {
2454	xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache;
2455
2456	if ((cache->stringObjs != NULL) &&
2457	(cache->stringObjs->number != 0))
2458	{
2459	xmlXPathObjectPtr ret;
2460
2461	ret = (xmlXPathObjectPtr)
2462	cache->stringObjs->items[--cache->stringObjs->number];
2463
2464	ret->type = XPATH_STRING;
2465	ret->stringval = xmlStrdup(BAD_CAST val);
2466	#ifdef XP_DEBUG_OBJ_USAGE
2467	xmlXPathDebugObjUsageRequested(ctxt, XPATH_STRING);
2468	#endif
2469	return(ret);
2470	} else if ((cache->miscObjs != NULL) &&
2471	(cache->miscObjs->number != 0))
2472	{
2473	xmlXPathObjectPtr ret;
2474
2475	ret = (xmlXPathObjectPtr)
2476	cache->miscObjs->items[--cache->miscObjs->number];
2477
2478	ret->type = XPATH_STRING;
2479	ret->stringval = xmlStrdup(BAD_CAST val);
2480	#ifdef XP_DEBUG_OBJ_USAGE
2481	xmlXPathDebugObjUsageRequested(ctxt, XPATH_STRING);
2482	#endif
2483	return(ret);
2484	}
2485	}
2486	return(xmlXPathNewCString(val));
2487	}
2488
2489	/**
2490	* xmlXPathCacheNewString:
2491	* @ctxt: the XPath context
2492	* @val: the xmlChar * value
2493	*
2494	* This is the cached version of xmlXPathNewString().
2495	* Acquire an xmlXPathObjectPtr of type string and of value @val
2496	*
2497	* Returns the created or reused object.
2498	*/
2499	static xmlXPathObjectPtr
2500	xmlXPathCacheNewString(xmlXPathContextPtr ctxt, const xmlChar *val)
2501	{
2502	if ((ctxt != NULL) && (ctxt->cache)) {
2503	xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache;
2504
2505	if ((cache->stringObjs != NULL) &&
2506	(cache->stringObjs->number != 0))
2507	{
2508	xmlXPathObjectPtr ret;
2509
2510	ret = (xmlXPathObjectPtr)
2511	cache->stringObjs->items[--cache->stringObjs->number];
2512	ret->type = XPATH_STRING;
2513	if (val != NULL)
2514	ret->stringval = xmlStrdup(val);
2515	else
2516	ret->stringval = xmlStrdup((const xmlChar *)"");
2517	#ifdef XP_DEBUG_OBJ_USAGE
2518	xmlXPathDebugObjUsageRequested(ctxt, XPATH_STRING);
2519	#endif
2520	return(ret);
2521	} else if ((cache->miscObjs != NULL) &&
2522	(cache->miscObjs->number != 0))
2523	{
2524	xmlXPathObjectPtr ret;
2525
2526	ret = (xmlXPathObjectPtr)
2527	cache->miscObjs->items[--cache->miscObjs->number];
2528
2529	ret->type = XPATH_STRING;
2530	if (val != NULL)
2531	ret->stringval = xmlStrdup(val);
2532	else
2533	ret->stringval = xmlStrdup((const xmlChar *)"");
2534	#ifdef XP_DEBUG_OBJ_USAGE
2535	xmlXPathDebugObjUsageRequested(ctxt, XPATH_STRING);
2536	#endif
2537	return(ret);
2538	}
2539	}
2540	return(xmlXPathNewString(val));
2541	}
2542
2543	/**
2544	* xmlXPathCacheNewBoolean:
2545	* @ctxt: the XPath context
2546	* @val: the boolean value
2547	*
2548	* This is the cached version of xmlXPathNewBoolean().
2549	* Acquires an xmlXPathObjectPtr of type boolean and of value @val
2550	*
2551	* Returns the created or reused object.
2552	*/
2553	static xmlXPathObjectPtr
2554	xmlXPathCacheNewBoolean(xmlXPathContextPtr ctxt, int val)
2555	{
2556	if ((ctxt != NULL) && (ctxt->cache)) {
2557	xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache;
2558
2559	if ((cache->booleanObjs != NULL) &&
2560	(cache->booleanObjs->number != 0))
2561	{
2562	xmlXPathObjectPtr ret;
2563
2564	ret = (xmlXPathObjectPtr)
2565	cache->booleanObjs->items[--cache->booleanObjs->number];
2566	ret->type = XPATH_BOOLEAN;
2567	ret->boolval = (val != 0);
2568	#ifdef XP_DEBUG_OBJ_USAGE
2569	xmlXPathDebugObjUsageRequested(ctxt, XPATH_BOOLEAN);
2570	#endif
2571	return(ret);
2572	} else if ((cache->miscObjs != NULL) &&
2573	(cache->miscObjs->number != 0))
2574	{
2575	xmlXPathObjectPtr ret;
2576
2577	ret = (xmlXPathObjectPtr)
2578	cache->miscObjs->items[--cache->miscObjs->number];
2579
2580	ret->type = XPATH_BOOLEAN;
2581	ret->boolval = (val != 0);
2582	#ifdef XP_DEBUG_OBJ_USAGE
2583	xmlXPathDebugObjUsageRequested(ctxt, XPATH_BOOLEAN);
2584	#endif
2585	return(ret);
2586	}
2587	}
2588	return(xmlXPathNewBoolean(val));
2589	}
2590
2591	/**
2592	* xmlXPathCacheNewFloat:
2593	* @ctxt: the XPath context
2594	* @val: the double value
2595	*
2596	* This is the cached version of xmlXPathNewFloat().
2597	* Acquires an xmlXPathObjectPtr of type double and of value @val
2598	*
2599	* Returns the created or reused object.
2600	*/
2601	static xmlXPathObjectPtr
2602	xmlXPathCacheNewFloat(xmlXPathContextPtr ctxt, double val)
2603	{
2604	if ((ctxt != NULL) && (ctxt->cache)) {
2605	xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache;
2606
2607	if ((cache->numberObjs != NULL) &&
2608	(cache->numberObjs->number != 0))
2609	{
2610	xmlXPathObjectPtr ret;
2611
2612	ret = (xmlXPathObjectPtr)
2613	cache->numberObjs->items[--cache->numberObjs->number];
2614	ret->type = XPATH_NUMBER;
2615	ret->floatval = val;
2616	#ifdef XP_DEBUG_OBJ_USAGE
2617	xmlXPathDebugObjUsageRequested(ctxt, XPATH_NUMBER);
2618	#endif
2619	return(ret);
2620	} else if ((cache->miscObjs != NULL) &&
2621	(cache->miscObjs->number != 0))
2622	{
2623	xmlXPathObjectPtr ret;
2624
2625	ret = (xmlXPathObjectPtr)
2626	cache->miscObjs->items[--cache->miscObjs->number];
2627
2628	ret->type = XPATH_NUMBER;
2629	ret->floatval = val;
2630	#ifdef XP_DEBUG_OBJ_USAGE
2631	xmlXPathDebugObjUsageRequested(ctxt, XPATH_NUMBER);
2632	#endif
2633	return(ret);
2634	}
2635	}
2636	return(xmlXPathNewFloat(val));
2637	}
2638
2639	/**
2640	* xmlXPathCacheConvertString:
2641	* @ctxt: the XPath context
2642	* @val: an XPath object
2643	*
2644	* This is the cached version of xmlXPathConvertString().
2645	* Converts an existing object to its string() equivalent
2646	*
2647	* Returns a created or reused object, the old one is freed (cached)
2648	* (or the operation is done directly on @val)
2649	*/
2650
2651	static xmlXPathObjectPtr
2652	xmlXPathCacheConvertString(xmlXPathContextPtr ctxt, xmlXPathObjectPtr val) {
2653	xmlChar *res = NULL;
2654
2655	if (val == NULL)
2656	return(xmlXPathCacheNewCString(ctxt, ""));
2657
2658	switch (val->type) {
2659	case XPATH_UNDEFINED:
2660	#ifdef DEBUG_EXPR
2661	xmlGenericError(xmlGenericErrorContext, "STRING: undefined\n");
2662	#endif
2663	break;
2664	case XPATH_NODESET:
2665	case XPATH_XSLT_TREE:
2666	res = xmlXPathCastNodeSetToString(val->nodesetval);
2667	break;
2668	case XPATH_STRING:
2669	return(val);
2670	case XPATH_BOOLEAN:
2671	res = xmlXPathCastBooleanToString(val->boolval);
2672	break;
2673	case XPATH_NUMBER:
2674	res = xmlXPathCastNumberToString(val->floatval);
2675	break;
2676	case XPATH_USERS:
2677	case XPATH_POINT:
2678	case XPATH_RANGE:
2679	case XPATH_LOCATIONSET:
2680	TODO;
2681	break;
2682	}
2683	xmlXPathReleaseObject(ctxt, val);
2684	if (res == NULL)
2685	return(xmlXPathCacheNewCString(ctxt, ""));
2686	return(xmlXPathCacheWrapString(ctxt, res));
2687	}
2688
2689	/**
2690	* xmlXPathCacheObjectCopy:
2691	* @ctxt: the XPath context
2692	* @val: the original object
2693	*
2694	* This is the cached version of xmlXPathObjectCopy().
2695	* Acquire a copy of a given object
2696	*
2697	* Returns a created or reused created object.
2698	*/
2699	static xmlXPathObjectPtr
2700	xmlXPathCacheObjectCopy(xmlXPathContextPtr ctxt, xmlXPathObjectPtr val)
2701	{
2702	if (val == NULL)
2703	return(NULL);
2704
2705	if (XP_HAS_CACHE(ctxt)) {
2706	switch (val->type) {
2707	case XPATH_NODESET:
2708	return(xmlXPathCacheWrapNodeSet(ctxt,
2709	xmlXPathNodeSetMerge(NULL, val->nodesetval)));
2710	case XPATH_STRING:
2711	return(xmlXPathCacheNewString(ctxt, val->stringval));
2712	case XPATH_BOOLEAN:
2713	return(xmlXPathCacheNewBoolean(ctxt, val->boolval));
2714	case XPATH_NUMBER:
2715	return(xmlXPathCacheNewFloat(ctxt, val->floatval));
2716	default:
2717	break;
2718	}
2719	}
2720	return(xmlXPathObjectCopy(val));
2721	}
2722
2723	/**
2724	* xmlXPathCacheConvertBoolean:
2725	* @ctxt: the XPath context
2726	* @val: an XPath object
2727	*
2728	* This is the cached version of xmlXPathConvertBoolean().
2729	* Converts an existing object to its boolean() equivalent
2730	*
2731	* Returns a created or reused object, the old one is freed (or the operation
2732	* is done directly on @val)
2733	*/
2734	static xmlXPathObjectPtr
2735	xmlXPathCacheConvertBoolean(xmlXPathContextPtr ctxt, xmlXPathObjectPtr val) {
2736	xmlXPathObjectPtr ret;
2737
2738	if (val == NULL)
2739	return(xmlXPathCacheNewBoolean(ctxt, 0));
2740	if (val->type == XPATH_BOOLEAN)
2741	return(val);
2742	ret = xmlXPathCacheNewBoolean(ctxt, xmlXPathCastToBoolean(val));
2743	xmlXPathReleaseObject(ctxt, val);
2744	return(ret);
2745	}
2746
2747	/**
2748	* xmlXPathCacheConvertNumber:
2749	* @ctxt: the XPath context
2750	* @val: an XPath object
2751	*
2752	* This is the cached version of xmlXPathConvertNumber().
2753	* Converts an existing object to its number() equivalent
2754	*
2755	* Returns a created or reused object, the old one is freed (or the operation
2756	* is done directly on @val)
2757	*/
2758	static xmlXPathObjectPtr
2759	xmlXPathCacheConvertNumber(xmlXPathContextPtr ctxt, xmlXPathObjectPtr val) {
2760	xmlXPathObjectPtr ret;
2761
2762	if (val == NULL)
2763	return(xmlXPathCacheNewFloat(ctxt, 0.0));
2764	if (val->type == XPATH_NUMBER)
2765	return(val);
2766	ret = xmlXPathCacheNewFloat(ctxt, xmlXPathCastToNumber(val));
2767	xmlXPathReleaseObject(ctxt, val);
2768	return(ret);
2769	}
2770
2771	/************************************************************************
2772	* *
2773	* Parser stacks related functions and macros *
2774	* *
2775	************************************************************************/
2776
2777	/**
2778	* xmlXPathSetFrame:
2779	* @ctxt: an XPath parser context
2780	*
2781	* Set the callee evaluation frame
2782	*
2783	* Returns the previous frame value to be restored once done
2784	*/
2785	static int
2786	xmlXPathSetFrame(xmlXPathParserContextPtr ctxt) {
2787	int ret;
2788
2789	if (ctxt == NULL)
2790	return(0);
2791	ret = ctxt->valueFrame;
2792	ctxt->valueFrame = ctxt->valueNr;
2793	return(ret);
2794	}
2795
2796	/**
2797	* xmlXPathPopFrame:
2798	* @ctxt: an XPath parser context
2799	* @frame: the previous frame value
2800	*
2801	* Remove the callee evaluation frame
2802	*/
2803	static void
2804	xmlXPathPopFrame(xmlXPathParserContextPtr ctxt, int frame) {
2805	if (ctxt == NULL)
2806	return;
2807	if (ctxt->valueNr < ctxt->valueFrame) {
2808	xmlXPatherror(ctxt, __FILE__, __LINE__, XPATH_STACK_ERROR);
2809	}
2810	ctxt->valueFrame = frame;
2811	}
2812
2813	/**
2814	* valuePop:
2815	* @ctxt: an XPath evaluation context
2816	*
2817	* Pops the top XPath object from the value stack
2818	*
2819	* Returns the XPath object just removed
2820	*/
2821	xmlXPathObjectPtr
2822	valuePop(xmlXPathParserContextPtr ctxt)
2823	{
2824	xmlXPathObjectPtr ret;
2825
2826	if ((ctxt == NULL) \|\| (ctxt->valueNr <= 0))
2827	return (NULL);
2828
2829	if (ctxt->valueNr <= ctxt->valueFrame) {
2830	xmlXPatherror(ctxt, __FILE__, __LINE__, XPATH_STACK_ERROR);
2831	return (NULL);
2832	}
2833
2834	ctxt->valueNr--;
2835	if (ctxt->valueNr > 0)
2836	ctxt->value = ctxt->valueTab[ctxt->valueNr - 1];
2837	else
2838	ctxt->value = NULL;
2839	ret = ctxt->valueTab[ctxt->valueNr];
2840	ctxt->valueTab[ctxt->valueNr] = NULL;
2841	return (ret);
2842	}
2843	/**
2844	* valuePush:
2845	* @ctxt: an XPath evaluation context
2846	* @value: the XPath object
2847	*
2848	* Pushes a new XPath object on top of the value stack
2849	*
2850	* returns the number of items on the value stack
2851	*/
2852	int
2853	valuePush(xmlXPathParserContextPtr ctxt, xmlXPathObjectPtr value)
2854	{
2855	if ((ctxt == NULL) \|\| (value == NULL)) return(-1);
2856	if (ctxt->valueNr >= ctxt->valueMax) {
2857	xmlXPathObjectPtr *tmp;
2858
2859	if (ctxt->valueMax >= XPATH_MAX_STACK_DEPTH) {
2860	xmlXPathErrMemory(NULL, "XPath stack depth limit reached\n");
2861	ctxt->error = XPATH_MEMORY_ERROR;
2862	return (0);
2863	}
2864	tmp = (xmlXPathObjectPtr *) xmlRealloc(ctxt->valueTab,
2865	2 * ctxt->valueMax *
2866	sizeof(ctxt->valueTab[0]));
2867	if (tmp == NULL) {
2868	xmlXPathErrMemory(NULL, "pushing value\n");
2869	ctxt->error = XPATH_MEMORY_ERROR;
2870	return (0);
2871	}
2872	ctxt->valueMax *= 2;
2873	ctxt->valueTab = tmp;
2874	}
2875	ctxt->valueTab[ctxt->valueNr] = value;
2876	ctxt->value = value;
2877	return (ctxt->valueNr++);
2878	}
2879
2880	/**
2881	* xmlXPathPopBoolean:
2882	* @ctxt: an XPath parser context
2883	*
2884	* Pops a boolean from the stack, handling conversion if needed.
2885	* Check error with #xmlXPathCheckError.
2886	*
2887	* Returns the boolean
2888	*/
2889	int
2890	xmlXPathPopBoolean (xmlXPathParserContextPtr ctxt) {
2891	xmlXPathObjectPtr obj;
2892	int ret;
2893
2894	obj = valuePop(ctxt);
2895	if (obj == NULL) {
2896	xmlXPathSetError(ctxt, XPATH_INVALID_OPERAND);
2897	return(0);
2898	}
2899	if (obj->type != XPATH_BOOLEAN)
2900	ret = xmlXPathCastToBoolean(obj);
2901	else
2902	ret = obj->boolval;
2903	xmlXPathReleaseObject(ctxt->context, obj);
2904	return(ret);
2905	}
2906
2907	/**
2908	* xmlXPathPopNumber:
2909	* @ctxt: an XPath parser context
2910	*
2911	* Pops a number from the stack, handling conversion if needed.
2912	* Check error with #xmlXPathCheckError.
2913	*
2914	* Returns the number
2915	*/
2916	double
2917	xmlXPathPopNumber (xmlXPathParserContextPtr ctxt) {
2918	xmlXPathObjectPtr obj;
2919	double ret;
2920
2921	obj = valuePop(ctxt);
2922	if (obj == NULL) {
2923	xmlXPathSetError(ctxt, XPATH_INVALID_OPERAND);
2924	return(0);
2925	}
2926	if (obj->type != XPATH_NUMBER)
2927	ret = xmlXPathCastToNumber(obj);
2928	else
2929	ret = obj->floatval;
2930	xmlXPathReleaseObject(ctxt->context, obj);
2931	return(ret);
2932	}
2933
2934	/**
2935	* xmlXPathPopString:
2936	* @ctxt: an XPath parser context
2937	*
2938	* Pops a string from the stack, handling conversion if needed.
2939	* Check error with #xmlXPathCheckError.
2940	*
2941	* Returns the string
2942	*/
2943	xmlChar *
2944	xmlXPathPopString (xmlXPathParserContextPtr ctxt) {
2945	xmlXPathObjectPtr obj;
2946	xmlChar * ret;
2947
2948	obj = valuePop(ctxt);
2949	if (obj == NULL) {
2950	xmlXPathSetError(ctxt, XPATH_INVALID_OPERAND);
2951	return(NULL);
2952	}
2953	ret = xmlXPathCastToString(obj); /* this does required strdup */
2954	/* TODO: needs refactoring somewhere else */
2955	if (obj->stringval == ret)
2956	obj->stringval = NULL;
2957	xmlXPathReleaseObject(ctxt->context, obj);
2958	return(ret);
2959	}
2960
2961	/**
2962	* xmlXPathPopNodeSet:
2963	* @ctxt: an XPath parser context
2964	*
2965	* Pops a node-set from the stack, handling conversion if needed.
2966	* Check error with #xmlXPathCheckError.
2967	*
2968	* Returns the node-set
2969	*/
2970	xmlNodeSetPtr
2971	xmlXPathPopNodeSet (xmlXPathParserContextPtr ctxt) {
2972	xmlXPathObjectPtr obj;
2973	xmlNodeSetPtr ret;
2974
2975	if (ctxt == NULL) return(NULL);
2976	if (ctxt->value == NULL) {
2977	xmlXPathSetError(ctxt, XPATH_INVALID_OPERAND);
2978	return(NULL);
2979	}
2980	if (!xmlXPathStackIsNodeSet(ctxt)) {
2981	xmlXPathSetTypeError(ctxt);
2982	return(NULL);
2983	}
2984	obj = valuePop(ctxt);
2985	ret = obj->nodesetval;
2986	#if 0
2987	/* to fix memory leak of not clearing obj->user */
2988	if (obj->boolval && obj->user != NULL)
2989	xmlFreeNodeList((xmlNodePtr) obj->user);
2990	#endif
2991	obj->nodesetval = NULL;
2992	xmlXPathReleaseObject(ctxt->context, obj);
2993	return(ret);
2994	}
2995
2996	/**
2997	* xmlXPathPopExternal:
2998	* @ctxt: an XPath parser context
2999	*
3000	* Pops an external object from the stack, handling conversion if needed.
3001	* Check error with #xmlXPathCheckError.
3002	*
3003	* Returns the object
3004	*/
3005	void *
3006	xmlXPathPopExternal (xmlXPathParserContextPtr ctxt) {
3007	xmlXPathObjectPtr obj;
3008	void * ret;
3009
3010	if ((ctxt == NULL) \|\| (ctxt->value == NULL)) {
3011	xmlXPathSetError(ctxt, XPATH_INVALID_OPERAND);
3012	return(NULL);
3013	}
3014	if (ctxt->value->type != XPATH_USERS) {
3015	xmlXPathSetTypeError(ctxt);
3016	return(NULL);
3017	}
3018	obj = valuePop(ctxt);
3019	ret = obj->user;
3020	obj->user = NULL;
3021	xmlXPathReleaseObject(ctxt->context, obj);
3022	return(ret);
3023	}
3024
3025	/*
3026	* Macros for accessing the content. Those should be used only by the parser,
3027	* and not exported.
3028	*
3029	* Dirty macros, i.e. one need to make assumption on the context to use them
3030	*
3031	* CUR_PTR return the current pointer to the xmlChar to be parsed.
3032	* CUR returns the current xmlChar value, i.e. a 8 bit value
3033	* in ISO-Latin or UTF-8.
3034	* This should be used internally by the parser
3035	* only to compare to ASCII values otherwise it would break when
3036	* running with UTF-8 encoding.
3037	* NXT(n) returns the n'th next xmlChar. Same as CUR is should be used only
3038	* to compare on ASCII based substring.
3039	* SKIP(n) Skip n xmlChar, and must also be used only to skip ASCII defined
3040	* strings within the parser.
3041	* CURRENT Returns the current char value, with the full decoding of
3042	* UTF-8 if we are using this mode. It returns an int.
3043	* NEXT Skip to the next character, this does the proper decoding
3044	* in UTF-8 mode. It also pop-up unfinished entities on the fly.
3045	* It returns the pointer to the current xmlChar.
3046	*/
3047
3048	#define CUR (*ctxt->cur)
3049	#define SKIP(val) ctxt->cur += (val)
3050	#define NXT(val) ctxt->cur[(val)]
3051	#define CUR_PTR ctxt->cur
3052	#define CUR_CHAR(l) xmlXPathCurrentChar(ctxt, &l)
3053
3054	#define COPY_BUF(l,b,i,v) \
3055	if (l == 1) b[i++] = (xmlChar) v; \
3056	else i += xmlCopyChar(l,&b[i],v)
3057
3058	#define NEXTL(l) ctxt->cur += l
3059
3060	#define SKIP_BLANKS \
3061	while (IS_BLANK_CH(*(ctxt->cur))) NEXT
3062
3063	#define CURRENT (*ctxt->cur)
3064	#define NEXT ((*ctxt->cur) ? ctxt->cur++: ctxt->cur)
3065
3066
3067	#ifndef DBL_DIG
3068	#define DBL_DIG 16
3069	#endif
3070	#ifndef DBL_EPSILON
3071	#define DBL_EPSILON 1E-9
3072	#endif
3073
3074	#define UPPER_DOUBLE 1E9
3075	#define LOWER_DOUBLE 1E-5
3076	#define LOWER_DOUBLE_EXP 5
3077
3078	#define INTEGER_DIGITS DBL_DIG
3079	#define FRACTION_DIGITS (DBL_DIG + 1 + (LOWER_DOUBLE_EXP))
3080	#define EXPONENT_DIGITS (3 + 2)
3081
3082	/**
3083	* xmlXPathFormatNumber:
3084	* @number: number to format
3085	* @buffer: output buffer
3086	* @buffersize: size of output buffer
3087	*
3088	* Convert the number into a string representation.
3089	*/
3090	static void
3091	xmlXPathFormatNumber(double number, char buffer[], int buffersize)
3092	{
3093	switch (xmlXPathIsInf(number)) {
3094	case 1:
3095	if (buffersize > (int)sizeof("Infinity"))
3096	snprintf(buffer, buffersize, "Infinity");
3097	break;
3098	case -1:
3099	if (buffersize > (int)sizeof("-Infinity"))
3100	snprintf(buffer, buffersize, "-Infinity");
3101	break;
3102	default:
3103	if (xmlXPathIsNaN(number)) {
3104	if (buffersize > (int)sizeof("NaN"))
3105	snprintf(buffer, buffersize, "NaN");
3106	} else if (number == 0 && xmlXPathGetSign(number) != 0) {
3107	snprintf(buffer, buffersize, "0");
3108	} else if (number == ((int) number)) {
3109	char work[30];
3110	char ptr, cur;
3111	int value = (int) number;
3112
3113	ptr = &buffer[0];
3114	if (value == 0) {
3115	*ptr++ = '0';
3116	} else {
3117	snprintf(work, 29, "%d", value);
3118	cur = &work[0];
3119	while ((*cur) && (ptr - buffer < buffersize)) {
3120	ptr++ = cur++;
3121	}
3122	}
3123	if (ptr - buffer < buffersize) {
3124	*ptr = 0;
3125	} else if (buffersize > 0) {
3126	ptr--;
3127	*ptr = 0;
3128	}
3129	} else {
3130	/*
3131	For the dimension of work,
3132	DBL_DIG is number of significant digits
3133	EXPONENT is only needed for "scientific notation"
3134	3 is sign, decimal point, and terminating zero
3135	LOWER_DOUBLE_EXP is max number of leading zeroes in fraction
3136	Note that this dimension is slightly (a few characters)
3137	larger than actually necessary.
3138	*/
3139	char work[DBL_DIG + EXPONENT_DIGITS + 3 + LOWER_DOUBLE_EXP];
3140	int integer_place, fraction_place;
3141	char *ptr;
3142	char *after_fraction;
3143	double absolute_value;
3144	int size;
3145
3146	absolute_value = fabs(number);
3147
3148	/*
3149	* First choose format - scientific or regular floating point.
3150	* In either case, result is in work, and after_fraction points
3151	* just past the fractional part.
3152	*/
3153	if ( ((absolute_value > UPPER_DOUBLE) \|\|
3154	(absolute_value < LOWER_DOUBLE)) &&
3155	(absolute_value != 0.0) ) {
3156	/* Use scientific notation */
3157	integer_place = DBL_DIG + EXPONENT_DIGITS + 1;
3158	fraction_place = DBL_DIG - 1;
3159	size = snprintf(work, sizeof(work),"%.e",
3160	integer_place, fraction_place, number);
3161	while ((size > 0) && (work[size] != 'e')) size--;
3162
3163	}
3164	else {
3165	/* Use regular notation */
3166	if (absolute_value > 0.0) {
3167	integer_place = (int)log10(absolute_value);
3168	if (integer_place > 0)
3169	fraction_place = DBL_DIG - integer_place - 1;
3170	else
3171	fraction_place = DBL_DIG - integer_place;
3172	} else {
3173	fraction_place = 1;
3174	}
3175	size = snprintf(work, sizeof(work), "%0.*f",
3176	fraction_place, number);
3177	}
3178
3179	/* Remove leading spaces sometimes inserted by snprintf */
3180	while (work[0] == ' ') {
3181	for (ptr = &work[0];(ptr[0] = ptr[1]);ptr++);
3182	size--;
3183	}
3184
3185	/* Remove fractional trailing zeroes */
3186	after_fraction = work + size;
3187	ptr = after_fraction;
3188	while (*(--ptr) == '0')
3189	;
3190	if (*ptr != '.')
3191	ptr++;
3192	while ((ptr++ = after_fraction++) != 0);
3193
3194	/* Finally copy result back to caller */
3195	size = strlen(work) + 1;
3196	if (size > buffersize) {
3197	work[buffersize - 1] = 0;
3198	size = buffersize;
3199	}
3200	memmove(buffer, work, size);
3201	}
3202	break;
3203	}
3204	}
3205
3206
3207	/************************************************************************
3208	* *
3209	* Routines to handle NodeSets *
3210	* *
3211	************************************************************************/
3212
3213	/**
3214	* xmlXPathOrderDocElems:
3215	* @doc: an input document
3216	*
3217	* Call this routine to speed up XPath computation on static documents.
3218	* This stamps all the element nodes with the document order
3219	* Like for line information, the order is kept in the element->content
3220	* field, the value stored is actually - the node number (starting at -1)
3221	* to be able to differentiate from line numbers.
3222	*
3223	* Returns the number of elements found in the document or -1 in case
3224	* of error.
3225	*/
3226	long
3227	xmlXPathOrderDocElems(xmlDocPtr doc) {
3228	long count = 0;
3229	xmlNodePtr cur;
3230
3231	if (doc == NULL)
3232	return(-1);
3233	cur = doc->children;
3234	while (cur != NULL) {
3235	if (cur->type == XML_ELEMENT_NODE) {
3236	cur->content = (void *) (-(++count));
3237	if (cur->children != NULL) {
3238	cur = cur->children;
3239	continue;
3240	}
3241	}
3242	if (cur->next != NULL) {
3243	cur = cur->next;
3244	continue;
3245	}
3246	do {
3247	cur = cur->parent;
3248	if (cur == NULL)
3249	break;
3250	if (cur == (xmlNodePtr) doc) {
3251	cur = NULL;
3252	break;
3253	}
3254	if (cur->next != NULL) {
3255	cur = cur->next;
3256	break;
3257	}
3258	} while (cur != NULL);
3259	}
3260	return(count);
3261	}
3262
3263	/**
3264	* xmlXPathCmpNodes:
3265	* @node1: the first node
3266	* @node2: the second node
3267	*
3268	* Compare two nodes w.r.t document order
3269	*
3270	* Returns -2 in case of error 1 if first point < second point, 0 if
3271	* it's the same node, -1 otherwise
3272	*/
3273	int
3274	xmlXPathCmpNodes(xmlNodePtr node1, xmlNodePtr node2) {
3275	int depth1, depth2;
3276	int attr1 = 0, attr2 = 0;
3277	xmlNodePtr attrNode1 = NULL, attrNode2 = NULL;
3278	xmlNodePtr cur, root;
3279
3280	if ((node1 == NULL) \|\| (node2 == NULL))
3281	return(-2);
3282	/*
3283	* a couple of optimizations which will avoid computations in most cases
3284	*/
3285	if (node1 == node2) /* trivial case */
3286	return(0);
3287	if (node1->type == XML_ATTRIBUTE_NODE) {
3288	attr1 = 1;
3289	attrNode1 = node1;
3290	node1 = node1->parent;
3291	}
3292	if (node2->type == XML_ATTRIBUTE_NODE) {
3293	attr2 = 1;
3294	attrNode2 = node2;
3295	node2 = node2->parent;
3296	}
3297	if (node1 == node2) {
3298	if (attr1 == attr2) {
3299	/* not required, but we keep attributes in order */
3300	if (attr1 != 0) {
3301	cur = attrNode2->prev;
3302	while (cur != NULL) {
3303	if (cur == attrNode1)
3304	return (1);
3305	cur = cur->prev;
3306	}
3307	return (-1);
3308	}
3309	return(0);
3310	}
3311	if (attr2 == 1)
3312	return(1);
3313	return(-1);
3314	}
3315	if ((node1->type == XML_NAMESPACE_DECL) \|\|
3316	(node2->type == XML_NAMESPACE_DECL))
3317	return(1);
3318	if (node1 == node2->prev)
3319	return(1);
3320	if (node1 == node2->next)
3321	return(-1);
3322
3323	/*
3324	* Speedup using document order if availble.
3325	*/
3326	if ((node1->type == XML_ELEMENT_NODE) &&
3327	(node2->type == XML_ELEMENT_NODE) &&
3328	(0 > (long) node1->content) &&
3329	(0 > (long) node2->content) &&
3330	(node1->doc == node2->doc)) {
3331	long l1, l2;
3332
3333	l1 = -((long) node1->content);
3334	l2 = -((long) node2->content);
3335	if (l1 < l2)
3336	return(1);
3337	if (l1 > l2)
3338	return(-1);
3339	}
3340
3341	/*
3342	* compute depth to root
3343	*/
3344	for (depth2 = 0, cur = node2;cur->parent != NULL;cur = cur->parent) {
3345	if (cur == node1)
3346	return(1);
3347	depth2++;
3348	}
3349	root = cur;
3350	for (depth1 = 0, cur = node1;cur->parent != NULL;cur = cur->parent) {
3351	if (cur == node2)
3352	return(-1);
3353	depth1++;
3354	}
3355	/*
3356	* Distinct document (or distinct entities :-( ) case.
3357	*/
3358	if (root != cur) {
3359	return(-2);
3360	}
3361	/*
3362	* get the nearest common ancestor.
3363	*/
3364	while (depth1 > depth2) {
3365	depth1--;
3366	node1 = node1->parent;
3367	}
3368	while (depth2 > depth1) {
3369	depth2--;
3370	node2 = node2->parent;
3371	}
3372	while (node1->parent != node2->parent) {
3373	node1 = node1->parent;
3374	node2 = node2->parent;
3375	/* should not happen but just in case ... */
3376	if ((node1 == NULL) \|\| (node2 == NULL))
3377	return(-2);
3378	}
3379	/*
3380	* Find who's first.
3381	*/
3382	if (node1 == node2->prev)
3383	return(1);
3384	if (node1 == node2->next)
3385	return(-1);
3386	/*
3387	* Speedup using document order if availble.
3388	*/
3389	if ((node1->type == XML_ELEMENT_NODE) &&
3390	(node2->type == XML_ELEMENT_NODE) &&
3391	(0 > (long) node1->content) &&
3392	(0 > (long) node2->content) &&
3393	(node1->doc == node2->doc)) {
3394	long l1, l2;
3395
3396	l1 = -((long) node1->content);
3397	l2 = -((long) node2->content);
3398	if (l1 < l2)
3399	return(1);
3400	if (l1 > l2)
3401	return(-1);
3402	}
3403
3404	for (cur = node1->next;cur != NULL;cur = cur->next)
3405	if (cur == node2)
3406	return(1);
3407	return(-1); /* assume there is no sibling list corruption */
3408	}
3409
3410	/**
3411	* xmlXPathNodeSetSort:
3412	* @set: the node set
3413	*
3414	* Sort the node set in document order
3415	*/
3416	void
3417	xmlXPathNodeSetSort(xmlNodeSetPtr set) {
3418	#ifndef WITH_TIM_SORT
3419	int i, j, incr, len;
3420	xmlNodePtr tmp;
3421	#endif
3422
3423	if (set == NULL)
3424	return;
3425
3426	#ifndef WITH_TIM_SORT
3427	/*
3428	* Use the old Shell's sort implementation to sort the node-set
3429	* Timsort ought to be quite faster
3430	*/
3431	len = set->nodeNr;
3432	for (incr = len / 2; incr > 0; incr /= 2) {
3433	for (i = incr; i < len; i++) {
3434	j = i - incr;
3435	while (j >= 0) {
3436	#ifdef XP_OPTIMIZED_NON_ELEM_COMPARISON
3437	if (xmlXPathCmpNodesExt(set->nodeTab[j],
3438	set->nodeTab[j + incr]) == -1)
3439	#else
3440	if (xmlXPathCmpNodes(set->nodeTab[j],
3441	set->nodeTab[j + incr]) == -1)
3442	#endif
3443	{
3444	tmp = set->nodeTab[j];
3445	set->nodeTab[j] = set->nodeTab[j + incr];
3446	set->nodeTab[j + incr] = tmp;
3447	j -= incr;
3448	} else
3449	break;
3450	}
3451	}
3452	}
3453	#else /* WITH_TIM_SORT */
3454	libxml_domnode_tim_sort(set->nodeTab, set->nodeNr);
3455	#endif /* WITH_TIM_SORT */
3456	}
3457
3458	#define XML_NODESET_DEFAULT 10
3459	/**
3460	* xmlXPathNodeSetDupNs:
3461	* @node: the parent node of the namespace XPath node
3462	* @ns: the libxml namespace declaration node.
3463	*
3464	* Namespace node in libxml don't match the XPath semantic. In a node set
3465	* the namespace nodes are duplicated and the next pointer is set to the
3466	* parent node in the XPath semantic.
3467	*
3468	* Returns the newly created object.
3469	*/
3470	static xmlNodePtr
3471	xmlXPathNodeSetDupNs(xmlNodePtr node, xmlNsPtr ns) {
3472	xmlNsPtr cur;
3473
3474	if ((ns == NULL) \|\| (ns->type != XML_NAMESPACE_DECL))
3475	return(NULL);
3476	if ((node == NULL) \|\| (node->type == XML_NAMESPACE_DECL))
3477	return((xmlNodePtr) ns);
3478
3479	/*
3480	* Allocate a new Namespace and fill the fields.
3481	*/
3482	cur = (xmlNsPtr) xmlMalloc(sizeof(xmlNs));
3483	if (cur == NULL) {
3484	xmlXPathErrMemory(NULL, "duplicating namespace\n");
3485	return(NULL);
3486	}
3487	memset(cur, 0, sizeof(xmlNs));
3488	cur->type = XML_NAMESPACE_DECL;
3489	if (ns->href != NULL)
3490	cur->href = xmlStrdup(ns->href);
3491	if (ns->prefix != NULL)
3492	cur->prefix = xmlStrdup(ns->prefix);
3493	cur->next = (xmlNsPtr) node;
3494	return((xmlNodePtr) cur);
3495	}
3496
3497	/**
3498	* xmlXPathNodeSetFreeNs:
3499	* @ns: the XPath namespace node found in a nodeset.
3500	*
3501	* Namespace nodes in libxml don't match the XPath semantic. In a node set
3502	* the namespace nodes are duplicated and the next pointer is set to the
3503	* parent node in the XPath semantic. Check if such a node needs to be freed
3504	*/
3505	void
3506	xmlXPathNodeSetFreeNs(xmlNsPtr ns) {
3507	if ((ns == NULL) \|\| (ns->type != XML_NAMESPACE_DECL))
3508	return;
3509
3510	if ((ns->next != NULL) && (ns->next->type != XML_NAMESPACE_DECL)) {
3511	if (ns->href != NULL)
3512	xmlFree((xmlChar *)ns->href);
3513	if (ns->prefix != NULL)
3514	xmlFree((xmlChar *)ns->prefix);
3515	xmlFree(ns);
3516	}
3517	}
3518
3519	/**
3520	* xmlXPathNodeSetCreate:
3521	* @val: an initial xmlNodePtr, or NULL
3522	*
3523	* Create a new xmlNodeSetPtr of type double and of value @val
3524	*
3525	* Returns the newly created object.
3526	*/
3527	xmlNodeSetPtr
3528	xmlXPathNodeSetCreate(xmlNodePtr val) {
3529	xmlNodeSetPtr ret;
3530
3531	ret = (xmlNodeSetPtr) xmlMalloc(sizeof(xmlNodeSet));
3532	if (ret == NULL) {
3533	xmlXPathErrMemory(NULL, "creating nodeset\n");
3534	return(NULL);
3535	}
3536	memset(ret, 0 , (size_t) sizeof(xmlNodeSet));
3537	if (val != NULL) {
3538	ret->nodeTab = (xmlNodePtr ) xmlMalloc(XML_NODESET_DEFAULT
3539	sizeof(xmlNodePtr));
3540	if (ret->nodeTab == NULL) {
3541	xmlXPathErrMemory(NULL, "creating nodeset\n");
3542	xmlFree(ret);
3543	return(NULL);
3544	}
3545	memset(ret->nodeTab, 0 ,
3546	XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
3547	ret->nodeMax = XML_NODESET_DEFAULT;
3548	if (val->type == XML_NAMESPACE_DECL) {
3549	xmlNsPtr ns = (xmlNsPtr) val;
3550
3551	ret->nodeTab[ret->nodeNr++] =
3552	xmlXPathNodeSetDupNs((xmlNodePtr) ns->next, ns);
3553	} else
3554	ret->nodeTab[ret->nodeNr++] = val;
3555	}
3556	return(ret);
3557	}
3558
3559	/**
3560	* xmlXPathNodeSetCreateSize:
3561	* @size: the initial size of the set
3562	*
3563	* Create a new xmlNodeSetPtr of type double and of value @val
3564	*
3565	* Returns the newly created object.
3566	*/
3567	static xmlNodeSetPtr
3568	xmlXPathNodeSetCreateSize(int size) {
3569	xmlNodeSetPtr ret;
3570
3571	ret = (xmlNodeSetPtr) xmlMalloc(sizeof(xmlNodeSet));
3572	if (ret == NULL) {
3573	xmlXPathErrMemory(NULL, "creating nodeset\n");
3574	return(NULL);
3575	}
3576	memset(ret, 0 , (size_t) sizeof(xmlNodeSet));
3577	if (size < XML_NODESET_DEFAULT)
3578	size = XML_NODESET_DEFAULT;
3579	ret->nodeTab = (xmlNodePtr ) xmlMalloc(size sizeof(xmlNodePtr));
3580	if (ret->nodeTab == NULL) {
3581	xmlXPathErrMemory(NULL, "creating nodeset\n");
3582	xmlFree(ret);
3583	return(NULL);
3584	}
3585	memset(ret->nodeTab, 0 , size * (size_t) sizeof(xmlNodePtr));
3586	ret->nodeMax = size;
3587	return(ret);
3588	}
3589
3590	/**
3591	* xmlXPathNodeSetContains:
3592	* @cur: the node-set
3593	* @val: the node
3594	*
3595	* checks whether @cur contains @val
3596	*
3597	* Returns true (1) if @cur contains @val, false (0) otherwise
3598	*/
3599	int
3600	xmlXPathNodeSetContains (xmlNodeSetPtr cur, xmlNodePtr val) {
3601	int i;
3602
3603	if ((cur == NULL) \|\| (val == NULL)) return(0);
3604	if (val->type == XML_NAMESPACE_DECL) {
3605	for (i = 0; i < cur->nodeNr; i++) {
3606	if (cur->nodeTab[i]->type == XML_NAMESPACE_DECL) {
3607	xmlNsPtr ns1, ns2;
3608
3609	ns1 = (xmlNsPtr) val;
3610	ns2 = (xmlNsPtr) cur->nodeTab[i];
3611	if (ns1 == ns2)
3612	return(1);
3613	if ((ns1->next != NULL) && (ns2->next == ns1->next) &&
3614	(xmlStrEqual(ns1->prefix, ns2->prefix)))
3615	return(1);
3616	}
3617	}
3618	} else {
3619	for (i = 0; i < cur->nodeNr; i++) {
3620	if (cur->nodeTab[i] == val)
3621	return(1);
3622	}
3623	}
3624	return(0);
3625	}
3626
3627	/**
3628	* xmlXPathNodeSetAddNs:
3629	* @cur: the initial node set
3630	* @node: the hosting node
3631	* @ns: a the namespace node
3632	*
3633	* add a new namespace node to an existing NodeSet
3634	*
3635	* Returns 0 in case of success and -1 in case of error
3636	*/
3637	int
3638	xmlXPathNodeSetAddNs(xmlNodeSetPtr cur, xmlNodePtr node, xmlNsPtr ns) {
3639	int i;
3640
3641
3642	if ((cur == NULL) \|\| (ns == NULL) \|\| (node == NULL) \|\|
3643	(ns->type != XML_NAMESPACE_DECL) \|\|
3644	(node->type != XML_ELEMENT_NODE))
3645	return(-1);
3646
3647	/* @@ with_ns to check whether namespace nodes should be looked at @@ */
3648	/*
3649	* prevent duplicates
3650	*/
3651	for (i = 0;i < cur->nodeNr;i++) {
3652	if ((cur->nodeTab[i] != NULL) &&
3653	(cur->nodeTab[i]->type == XML_NAMESPACE_DECL) &&
3654	(((xmlNsPtr)cur->nodeTab[i])->next == (xmlNsPtr) node) &&
3655	(xmlStrEqual(ns->prefix, ((xmlNsPtr)cur->nodeTab[i])->prefix)))
3656	return(0);
3657	}
3658
3659	/*
3660	* grow the nodeTab if needed
3661	*/
3662	if (cur->nodeMax == 0) {
3663	cur->nodeTab = (xmlNodePtr ) xmlMalloc(XML_NODESET_DEFAULT
3664	sizeof(xmlNodePtr));
3665	if (cur->nodeTab == NULL) {
3666	xmlXPathErrMemory(NULL, "growing nodeset\n");
3667	return(-1);
3668	}
3669	memset(cur->nodeTab, 0 ,
3670	XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
3671	cur->nodeMax = XML_NODESET_DEFAULT;
3672	} else if (cur->nodeNr == cur->nodeMax) {
3673	xmlNodePtr *temp;
3674
3675	if (cur->nodeMax >= XPATH_MAX_NODESET_LENGTH) {
3676	xmlXPathErrMemory(NULL, "growing nodeset hit limit\n");
3677	return(-1);
3678	}
3679	temp = (xmlNodePtr ) xmlRealloc(cur->nodeTab, cur->nodeMax 2 *
3680	sizeof(xmlNodePtr));
3681	if (temp == NULL) {
3682	xmlXPathErrMemory(NULL, "growing nodeset\n");
3683	return(-1);
3684	}
3685	cur->nodeMax *= 2;
3686	cur->nodeTab = temp;
3687	}
3688	cur->nodeTab[cur->nodeNr++] = xmlXPathNodeSetDupNs(node, ns);
3689	return(0);
3690	}
3691
3692	/**
3693	* xmlXPathNodeSetAdd:
3694	* @cur: the initial node set
3695	* @val: a new xmlNodePtr
3696	*
3697	* add a new xmlNodePtr to an existing NodeSet
3698	*
3699	* Returns 0 in case of success, and -1 in case of error
3700	*/
3701	int
3702	xmlXPathNodeSetAdd(xmlNodeSetPtr cur, xmlNodePtr val) {
3703	int i;
3704
3705	if ((cur == NULL) \|\| (val == NULL)) return(-1);
3706
3707	/* @@ with_ns to check whether namespace nodes should be looked at @@ */
3708	/*
3709	* prevent duplcates
3710	*/
3711	for (i = 0;i < cur->nodeNr;i++)
3712	if (cur->nodeTab[i] == val) return(0);
3713
3714	/*
3715	* grow the nodeTab if needed
3716	*/
3717	if (cur->nodeMax == 0) {
3718	cur->nodeTab = (xmlNodePtr ) xmlMalloc(XML_NODESET_DEFAULT
3719	sizeof(xmlNodePtr));
3720	if (cur->nodeTab == NULL) {
3721	xmlXPathErrMemory(NULL, "growing nodeset\n");
3722	return(-1);
3723	}
3724	memset(cur->nodeTab, 0 ,
3725	XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
3726	cur->nodeMax = XML_NODESET_DEFAULT;
3727	} else if (cur->nodeNr == cur->nodeMax) {
3728	xmlNodePtr *temp;
3729
3730	if (cur->nodeMax >= XPATH_MAX_NODESET_LENGTH) {
3731	xmlXPathErrMemory(NULL, "growing nodeset hit limit\n");
3732	return(-1);
3733	}
3734	temp = (xmlNodePtr ) xmlRealloc(cur->nodeTab, cur->nodeMax 2 *
3735	sizeof(xmlNodePtr));
3736	if (temp == NULL) {
3737	xmlXPathErrMemory(NULL, "growing nodeset\n");
3738	return(-1);
3739	}
3740	cur->nodeMax *= 2;
3741	cur->nodeTab = temp;
3742	}
3743	if (val->type == XML_NAMESPACE_DECL) {
3744	xmlNsPtr ns = (xmlNsPtr) val;
3745
3746	cur->nodeTab[cur->nodeNr++] =
3747	xmlXPathNodeSetDupNs((xmlNodePtr) ns->next, ns);
3748	} else
3749	cur->nodeTab[cur->nodeNr++] = val;
3750	return(0);
3751	}
3752
3753	/**
3754	* xmlXPathNodeSetAddUnique:
3755	* @cur: the initial node set
3756	* @val: a new xmlNodePtr
3757	*
3758	* add a new xmlNodePtr to an existing NodeSet, optimized version
3759	* when we are sure the node is not already in the set.
3760	*
3761	* Returns 0 in case of success and -1 in case of failure
3762	*/
3763	int
3764	xmlXPathNodeSetAddUnique(xmlNodeSetPtr cur, xmlNodePtr val) {
3765	if ((cur == NULL) \|\| (val == NULL)) return(-1);
3766
3767	/* @@ with_ns to check whether namespace nodes should be looked at @@ */
3768	/*
3769	* grow the nodeTab if needed
3770	*/
3771	if (cur->nodeMax == 0) {
3772	cur->nodeTab = (xmlNodePtr ) xmlMalloc(XML_NODESET_DEFAULT
3773	sizeof(xmlNodePtr));
3774	if (cur->nodeTab == NULL) {
3775	xmlXPathErrMemory(NULL, "growing nodeset\n");
3776	return(-1);
3777	}
3778	memset(cur->nodeTab, 0 ,
3779	XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
3780	cur->nodeMax = XML_NODESET_DEFAULT;
3781	} else if (cur->nodeNr == cur->nodeMax) {
3782	xmlNodePtr *temp;
3783
3784	if (cur->nodeMax >= XPATH_MAX_NODESET_LENGTH) {
3785	xmlXPathErrMemory(NULL, "growing nodeset hit limit\n");
3786	return(-1);
3787	}
3788	temp = (xmlNodePtr ) xmlRealloc(cur->nodeTab, cur->nodeMax 2 *
3789	sizeof(xmlNodePtr));
3790	if (temp == NULL) {
3791	xmlXPathErrMemory(NULL, "growing nodeset\n");
3792	return(-1);
3793	}
3794	cur->nodeTab = temp;
3795	cur->nodeMax *= 2;
3796	}
3797	if (val->type == XML_NAMESPACE_DECL) {
3798	xmlNsPtr ns = (xmlNsPtr) val;
3799
3800	cur->nodeTab[cur->nodeNr++] =
3801	xmlXPathNodeSetDupNs((xmlNodePtr) ns->next, ns);
3802	} else
3803	cur->nodeTab[cur->nodeNr++] = val;
3804	return(0);
3805	}
3806
3807	/**
3808	* xmlXPathNodeSetMerge:
3809	* @val1: the first NodeSet or NULL
3810	* @val2: the second NodeSet
3811	*
3812	* Merges two nodesets, all nodes from @val2 are added to @val1
3813	* if @val1 is NULL, a new set is created and copied from @val2
3814	*
3815	* Returns @val1 once extended or NULL in case of error.
3816	*/
3817	xmlNodeSetPtr
3818	xmlXPathNodeSetMerge(xmlNodeSetPtr val1, xmlNodeSetPtr val2) {
3819	int i, j, initNr, skip;
3820	xmlNodePtr n1, n2;
3821
3822	if (val2 == NULL) return(val1);
3823	if (val1 == NULL) {
3824	val1 = xmlXPathNodeSetCreate(NULL);
3825	if (val1 == NULL)
3826	return (NULL);
3827	#if 0
3828	/*
3829	* TODO: The optimization won't work in every case, since
3830	* those nasty namespace nodes need to be added with
3831	* xmlXPathNodeSetDupNs() to the set; thus a pure
3832	* memcpy is not possible.
3833	* If there was a flag on the nodesetval, indicating that
3834	* some temporary nodes are in, that would be helpfull.
3835	*/
3836	/*
3837	* Optimization: Create an equally sized node-set
3838	* and memcpy the content.
3839	*/
3840	val1 = xmlXPathNodeSetCreateSize(val2->nodeNr);
3841	if (val1 == NULL)
3842	return(NULL);
3843	if (val2->nodeNr != 0) {
3844	if (val2->nodeNr == 1)
3845	(val1->nodeTab) = (val2->nodeTab);
3846	else {
3847	memcpy(val1->nodeTab, val2->nodeTab,
3848	val2->nodeNr * sizeof(xmlNodePtr));
3849	}
3850	val1->nodeNr = val2->nodeNr;
3851	}
3852	return(val1);
3853	#endif
3854	}
3855
3856	/* @@ with_ns to check whether namespace nodes should be looked at @@ */
3857	initNr = val1->nodeNr;
3858
3859	for (i = 0;i < val2->nodeNr;i++) {
3860	n2 = val2->nodeTab[i];
3861	/*
3862	* check against duplicates
3863	*/
3864	skip = 0;
3865	for (j = 0; j < initNr; j++) {
3866	n1 = val1->nodeTab[j];
3867	if (n1 == n2) {
3868	skip = 1;
3869	break;
3870	} else if ((n1->type == XML_NAMESPACE_DECL) &&
3871	(n2->type == XML_NAMESPACE_DECL)) {
3872	if ((((xmlNsPtr) n1)->next == ((xmlNsPtr) n2)->next) &&
3873	(xmlStrEqual(((xmlNsPtr) n1)->prefix,
3874	((xmlNsPtr) n2)->prefix)))
3875	{
3876	skip = 1;
3877	break;
3878	}
3879	}
3880	}
3881	if (skip)
3882	continue;
3883
3884	/*
3885	* grow the nodeTab if needed
3886	*/
3887	if (val1->nodeMax == 0) {
3888	val1->nodeTab = (xmlNodePtr ) xmlMalloc(XML_NODESET_DEFAULT
3889	sizeof(xmlNodePtr));
3890	if (val1->nodeTab == NULL) {
3891	xmlXPathErrMemory(NULL, "merging nodeset\n");
3892	return(NULL);
3893	}
3894	memset(val1->nodeTab, 0 ,
3895	XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
3896	val1->nodeMax = XML_NODESET_DEFAULT;
3897	} else if (val1->nodeNr == val1->nodeMax) {
3898	xmlNodePtr *temp;
3899
3900	if (val1->nodeMax >= XPATH_MAX_NODESET_LENGTH) {
3901	xmlXPathErrMemory(NULL, "merging nodeset hit limit\n");
3902	return(NULL);
3903	}
3904	temp = (xmlNodePtr ) xmlRealloc(val1->nodeTab, val1->nodeMax 2 *
3905	sizeof(xmlNodePtr));
3906	if (temp == NULL) {
3907	xmlXPathErrMemory(NULL, "merging nodeset\n");
3908	return(NULL);
3909	}
3910	val1->nodeTab = temp;
3911	val1->nodeMax *= 2;
3912	}
3913	if (n2->type == XML_NAMESPACE_DECL) {
3914	xmlNsPtr ns = (xmlNsPtr) n2;
3915
3916	val1->nodeTab[val1->nodeNr++] =
3917	xmlXPathNodeSetDupNs((xmlNodePtr) ns->next, ns);
3918	} else
3919	val1->nodeTab[val1->nodeNr++] = n2;
3920	}
3921
3922	return(val1);
3923	}
3924
3925
3926	/**
3927	* xmlXPathNodeSetMergeAndClear:
3928	* @set1: the first NodeSet or NULL
3929	* @set2: the second NodeSet
3930	* @hasSet2NsNodes: 1 if set2 contains namespaces nodes
3931	*
3932	* Merges two nodesets, all nodes from @set2 are added to @set1
3933	* if @set1 is NULL, a new set is created and copied from @set2.
3934	* Checks for duplicate nodes. Clears set2.
3935	*
3936	* Returns @set1 once extended or NULL in case of error.
3937	*/
3938	static xmlNodeSetPtr
3939	xmlXPathNodeSetMergeAndClear(xmlNodeSetPtr set1, xmlNodeSetPtr set2,
3940	int hasNullEntries)
3941	{
3942	if ((set1 == NULL) && (hasNullEntries == 0)) {
3943	/*
3944	* Note that doing a memcpy of the list, namespace nodes are
3945	* just assigned to set1, since set2 is cleared anyway.
3946	*/
3947	set1 = xmlXPathNodeSetCreateSize(set2->nodeNr);
3948	if (set1 == NULL)
3949	return(NULL);
3950	if (set2->nodeNr != 0) {
3951	memcpy(set1->nodeTab, set2->nodeTab,
3952	set2->nodeNr * sizeof(xmlNodePtr));
3953	set1->nodeNr = set2->nodeNr;
3954	}
3955	} else {
3956	int i, j, initNbSet1;
3957	xmlNodePtr n1, n2;
3958
3959	if (set1 == NULL)
3960	set1 = xmlXPathNodeSetCreate(NULL);
3961	if (set1 == NULL)
3962	return (NULL);
3963
3964	initNbSet1 = set1->nodeNr;
3965	for (i = 0;i < set2->nodeNr;i++) {
3966	n2 = set2->nodeTab[i];
3967	/*
3968	* Skip NULLed entries.
3969	*/
3970	if (n2 == NULL)
3971	continue;
3972	/*
3973	* Skip duplicates.
3974	*/
3975	for (j = 0; j < initNbSet1; j++) {
3976	n1 = set1->nodeTab[j];
3977	if (n1 == n2) {
3978	goto skip_node;
3979	} else if ((n1->type == XML_NAMESPACE_DECL) &&
3980	(n2->type == XML_NAMESPACE_DECL))
3981	{
3982	if ((((xmlNsPtr) n1)->next == ((xmlNsPtr) n2)->next) &&
3983	(xmlStrEqual(((xmlNsPtr) n1)->prefix,
3984	((xmlNsPtr) n2)->prefix)))
3985	{
3986	/*
3987	* Free the namespace node.
3988	*/
3989	set2->nodeTab[i] = NULL;
3990	xmlXPathNodeSetFreeNs((xmlNsPtr) n2);
3991	goto skip_node;
3992	}
3993	}
3994	}
3995	/*
3996	* grow the nodeTab if needed
3997	*/
3998	if (set1->nodeMax == 0) {
3999	set1->nodeTab = (xmlNodePtr *) xmlMalloc(
4000	XML_NODESET_DEFAULT * sizeof(xmlNodePtr));
4001	if (set1->nodeTab == NULL) {
4002	xmlXPathErrMemory(NULL, "merging nodeset\n");
4003	return(NULL);
4004	}
4005	memset(set1->nodeTab, 0,
4006	XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
4007	set1->nodeMax = XML_NODESET_DEFAULT;
4008	} else if (set1->nodeNr >= set1->nodeMax) {
4009	xmlNodePtr *temp;
4010
4011	if (set1->nodeMax >= XPATH_MAX_NODESET_LENGTH) {
4012	xmlXPathErrMemory(NULL, "merging nodeset hit limit\n");
4013	return(NULL);
4014	}
4015	temp = (xmlNodePtr *) xmlRealloc(
4016	set1->nodeTab, set1->nodeMax * 2 * sizeof(xmlNodePtr));
4017	if (temp == NULL) {
4018	xmlXPathErrMemory(NULL, "merging nodeset\n");
4019	return(NULL);
4020	}
4021	set1->nodeTab = temp;
4022	set1->nodeMax *= 2;
4023	}
4024	if (n2->type == XML_NAMESPACE_DECL) {
4025	xmlNsPtr ns = (xmlNsPtr) n2;
4026
4027	set1->nodeTab[set1->nodeNr++] =
4028	xmlXPathNodeSetDupNs((xmlNodePtr) ns->next, ns);
4029	} else
4030	set1->nodeTab[set1->nodeNr++] = n2;
4031	skip_node:
4032	{}
4033	}
4034	}
4035	set2->nodeNr = 0;
4036	return(set1);
4037	}
4038
4039	/**
4040	* xmlXPathNodeSetMergeAndClearNoDupls:
4041	* @set1: the first NodeSet or NULL
4042	* @set2: the second NodeSet
4043	* @hasSet2NsNodes: 1 if set2 contains namespaces nodes
4044	*
4045	* Merges two nodesets, all nodes from @set2 are added to @set1
4046	* if @set1 is NULL, a new set is created and copied from @set2.
4047	* Doesn't chack for duplicate nodes. Clears set2.
4048	*
4049	* Returns @set1 once extended or NULL in case of error.
4050	*/
4051	static xmlNodeSetPtr
4052	xmlXPathNodeSetMergeAndClearNoDupls(xmlNodeSetPtr set1, xmlNodeSetPtr set2,
4053	int hasNullEntries)
4054	{
4055	if (set2 == NULL)
4056	return(set1);
4057	if ((set1 == NULL) && (hasNullEntries == 0)) {
4058	/*
4059	* Note that doing a memcpy of the list, namespace nodes are
4060	* just assigned to set1, since set2 is cleared anyway.
4061	*/
4062	set1 = xmlXPathNodeSetCreateSize(set2->nodeNr);
4063	if (set1 == NULL)
4064	return(NULL);
4065	if (set2->nodeNr != 0) {
4066	memcpy(set1->nodeTab, set2->nodeTab,
4067	set2->nodeNr * sizeof(xmlNodePtr));
4068	set1->nodeNr = set2->nodeNr;
4069	}
4070	} else {
4071	int i;
4072	xmlNodePtr n2;
4073
4074	if (set1 == NULL)
4075	set1 = xmlXPathNodeSetCreate(NULL);
4076	if (set1 == NULL)
4077	return (NULL);
4078
4079	for (i = 0;i < set2->nodeNr;i++) {
4080	n2 = set2->nodeTab[i];
4081	/*
4082	* Skip NULLed entries.
4083	*/
4084	if (n2 == NULL)
4085	continue;
4086	if (set1->nodeMax == 0) {
4087	set1->nodeTab = (xmlNodePtr *) xmlMalloc(
4088	XML_NODESET_DEFAULT * sizeof(xmlNodePtr));
4089	if (set1->nodeTab == NULL) {
4090	xmlXPathErrMemory(NULL, "merging nodeset\n");
4091	return(NULL);
4092	}
4093	memset(set1->nodeTab, 0,
4094	XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
4095	set1->nodeMax = XML_NODESET_DEFAULT;
4096	} else if (set1->nodeNr >= set1->nodeMax) {
4097	xmlNodePtr *temp;
4098
4099	if (set1->nodeMax >= XPATH_MAX_NODESET_LENGTH) {
4100	xmlXPathErrMemory(NULL, "merging nodeset hit limit\n");
4101	return(NULL);
4102	}
4103	temp = (xmlNodePtr *) xmlRealloc(
4104	set1->nodeTab, set1->nodeMax * 2 * sizeof(xmlNodePtr));
4105	if (temp == NULL) {
4106	xmlXPathErrMemory(NULL, "merging nodeset\n");
4107	return(NULL);
4108	}
4109	set1->nodeTab = temp;
4110	set1->nodeMax *= 2;
4111	}
4112	set1->nodeTab[set1->nodeNr++] = n2;
4113	}
4114	}
4115	set2->nodeNr = 0;
4116	return(set1);
4117	}
4118
4119	/**
4120	* xmlXPathNodeSetDel:
4121	* @cur: the initial node set
4122	* @val: an xmlNodePtr
4123	*
4124	* Removes an xmlNodePtr from an existing NodeSet
4125	*/
4126	void
4127	xmlXPathNodeSetDel(xmlNodeSetPtr cur, xmlNodePtr val) {
4128	int i;
4129
4130	if (cur == NULL) return;
4131	if (val == NULL) return;
4132
4133	/*
4134	* find node in nodeTab
4135	*/
4136	for (i = 0;i < cur->nodeNr;i++)
4137	if (cur->nodeTab[i] == val) break;
4138
4139	if (i >= cur->nodeNr) { /* not found */
4140	#ifdef DEBUG
4141	xmlGenericError(xmlGenericErrorContext,
4142	"xmlXPathNodeSetDel: Node %s wasn't found in NodeList\n",
4143	val->name);
4144	#endif
4145	return;
4146	}
4147	if ((cur->nodeTab[i] != NULL) &&
4148	(cur->nodeTab[i]->type == XML_NAMESPACE_DECL))
4149	xmlXPathNodeSetFreeNs((xmlNsPtr) cur->nodeTab[i]);
4150	cur->nodeNr--;
4151	for (;i < cur->nodeNr;i++)
4152	cur->nodeTab[i] = cur->nodeTab[i + 1];
4153	cur->nodeTab[cur->nodeNr] = NULL;
4154	}
4155
4156	/**
4157	* xmlXPathNodeSetRemove:
4158	* @cur: the initial node set
4159	* @val: the index to remove
4160	*
4161	* Removes an entry from an existing NodeSet list.
4162	*/
4163	void
4164	xmlXPathNodeSetRemove(xmlNodeSetPtr cur, int val) {
4165	if (cur == NULL) return;
4166	if (val >= cur->nodeNr) return;
4167	if ((cur->nodeTab[val] != NULL) &&
4168	(cur->nodeTab[val]->type == XML_NAMESPACE_DECL))
4169	xmlXPathNodeSetFreeNs((xmlNsPtr) cur->nodeTab[val]);
4170	cur->nodeNr--;
4171	for (;val < cur->nodeNr;val++)
4172	cur->nodeTab[val] = cur->nodeTab[val + 1];
4173	cur->nodeTab[cur->nodeNr] = NULL;
4174	}
4175
4176	/**
4177	* xmlXPathFreeNodeSet:
4178	* @obj: the xmlNodeSetPtr to free
4179	*
4180	* Free the NodeSet compound (not the actual nodes !).
4181	*/
4182	void
4183	xmlXPathFreeNodeSet(xmlNodeSetPtr obj) {
4184	if (obj == NULL) return;
4185	if (obj->nodeTab != NULL) {
4186	int i;
4187
4188	/* @@ with_ns to check whether namespace nodes should be looked at @@ */
4189	for (i = 0;i < obj->nodeNr;i++)
4190	if ((obj->nodeTab[i] != NULL) &&
4191	(obj->nodeTab[i]->type == XML_NAMESPACE_DECL))
4192	xmlXPathNodeSetFreeNs((xmlNsPtr) obj->nodeTab[i]);
4193	xmlFree(obj->nodeTab);
4194	}
4195	xmlFree(obj);
4196	}
4197
4198	/**
4199	* xmlXPathNodeSetClear:
4200	* @set: the node set to clear
4201	*
4202	* Clears the list from all temporary XPath objects (e.g. namespace nodes
4203	* are feed), but does not free the list itself. Sets the length of the
4204	* list to 0.
4205	*/
4206	static void
4207	xmlXPathNodeSetClear(xmlNodeSetPtr set, int hasNsNodes)
4208	{
4209	if ((set == NULL) \|\| (set->nodeNr <= 0))
4210	return;
4211	else if (hasNsNodes) {
4212	int i;
4213	xmlNodePtr node;
4214
4215	for (i = 0; i < set->nodeNr; i++) {
4216	node = set->nodeTab[i];
4217	if ((node != NULL) &&
4218	(node->type == XML_NAMESPACE_DECL))
4219	xmlXPathNodeSetFreeNs((xmlNsPtr) node);
4220	}
4221	}
4222	set->nodeNr = 0;
4223	}
4224
4225	/**
4226	* xmlXPathNodeSetClearFromPos:
4227	* @set: the node set to be cleared
4228	* @pos: the start position to clear from
4229	*
4230	* Clears the list from temporary XPath objects (e.g. namespace nodes
4231	* are feed) starting with the entry at @pos, but does not free the list
4232	* itself. Sets the length of the list to @pos.
4233	*/
4234	static void
4235	xmlXPathNodeSetClearFromPos(xmlNodeSetPtr set, int pos, int hasNsNodes)
4236	{
4237	if ((set == NULL) \|\| (set->nodeNr <= 0) \|\| (pos >= set->nodeNr))
4238	return;
4239	else if ((hasNsNodes)) {
4240	int i;
4241	xmlNodePtr node;
4242
4243	for (i = pos; i < set->nodeNr; i++) {
4244	node = set->nodeTab[i];
4245	if ((node != NULL) &&
4246	(node->type == XML_NAMESPACE_DECL))
4247	xmlXPathNodeSetFreeNs((xmlNsPtr) node);
4248	}
4249	}
4250	set->nodeNr = pos;
4251	}
4252
4253	/**
4254	* xmlXPathFreeValueTree:
4255	* @obj: the xmlNodeSetPtr to free
4256	*
4257	* Free the NodeSet compound and the actual tree, this is different
4258	* from xmlXPathFreeNodeSet()
4259	*/
4260	static void
4261	xmlXPathFreeValueTree(xmlNodeSetPtr obj) {
4262	int i;
4263
4264	if (obj == NULL) return;
4265
4266	if (obj->nodeTab != NULL) {
4267	for (i = 0;i < obj->nodeNr;i++) {
4268	if (obj->nodeTab[i] != NULL) {
4269	if (obj->nodeTab[i]->type == XML_NAMESPACE_DECL) {
4270	xmlXPathNodeSetFreeNs((xmlNsPtr) obj->nodeTab[i]);
4271	} else {
4272	xmlFreeNodeList(obj->nodeTab[i]);
4273	}
4274	}
4275	}
4276	xmlFree(obj->nodeTab);
4277	}
4278	xmlFree(obj);
4279	}
4280
4281	#if defined(DEBUG) \|\| defined(DEBUG_STEP)
4282	/**
4283	* xmlGenericErrorContextNodeSet:
4284	* @output: a FILE * for the output
4285	* @obj: the xmlNodeSetPtr to display
4286	*
4287	* Quick display of a NodeSet
4288	*/
4289	void
4290	xmlGenericErrorContextNodeSet(FILE *output, xmlNodeSetPtr obj) {
4291	int i;
4292
4293	if (output == NULL) output = xmlGenericErrorContext;
4294	if (obj == NULL) {
4295	fprintf(output, "NodeSet == NULL !\n");
4296	return;
4297	}
4298	if (obj->nodeNr == 0) {
4299	fprintf(output, "NodeSet is empty\n");
4300	return;
4301	}
4302	if (obj->nodeTab == NULL) {
4303	fprintf(output, " nodeTab == NULL !\n");
4304	return;
4305	}
4306	for (i = 0; i < obj->nodeNr; i++) {
4307	if (obj->nodeTab[i] == NULL) {
4308	fprintf(output, " NULL !\n");
4309	return;
4310	}
4311	if ((obj->nodeTab[i]->type == XML_DOCUMENT_NODE) \|\|
4312	(obj->nodeTab[i]->type == XML_HTML_DOCUMENT_NODE))
4313	fprintf(output, " /");
4314	else if (obj->nodeTab[i]->name == NULL)
4315	fprintf(output, " noname!");
4316	else fprintf(output, " %s", obj->nodeTab[i]->name);
4317	}
4318	fprintf(output, "\n");
4319	}
4320	#endif
4321
4322	/**
4323	* xmlXPathNewNodeSet:
4324	* @val: the NodePtr value
4325	*
4326	* Create a new xmlXPathObjectPtr of type NodeSet and initialize
4327	* it with the single Node @val
4328	*
4329	* Returns the newly created object.
4330	*/
4331	xmlXPathObjectPtr
4332	xmlXPathNewNodeSet(xmlNodePtr val) {
4333	xmlXPathObjectPtr ret;
4334
4335	ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
4336	if (ret == NULL) {
4337	xmlXPathErrMemory(NULL, "creating nodeset\n");
4338	return(NULL);
4339	}
4340	memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
4341	ret->type = XPATH_NODESET;
4342	ret->boolval = 0;
4343	ret->nodesetval = xmlXPathNodeSetCreate(val);
4344	/* @@ with_ns to check whether namespace nodes should be looked at @@ */
4345	#ifdef XP_DEBUG_OBJ_USAGE
4346	xmlXPathDebugObjUsageRequested(NULL, XPATH_NODESET);
4347	#endif
4348	return(ret);
4349	}
4350
4351	/**
4352	* xmlXPathNewValueTree:
4353	* @val: the NodePtr value
4354	*
4355	* Create a new xmlXPathObjectPtr of type Value Tree (XSLT) and initialize
4356	* it with the tree root @val
4357	*
4358	* Returns the newly created object.
4359	*/
4360	xmlXPathObjectPtr
4361	xmlXPathNewValueTree(xmlNodePtr val) {
4362	xmlXPathObjectPtr ret;
4363
4364	ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
4365	if (ret == NULL) {
4366	xmlXPathErrMemory(NULL, "creating result value tree\n");
4367	return(NULL);
4368	}
4369	memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
4370	ret->type = XPATH_XSLT_TREE;
4371	ret->boolval = 1;
4372	ret->user = (void *) val;
4373	ret->nodesetval = xmlXPathNodeSetCreate(val);
4374	#ifdef XP_DEBUG_OBJ_USAGE
4375	xmlXPathDebugObjUsageRequested(NULL, XPATH_XSLT_TREE);
4376	#endif
4377	return(ret);
4378	}
4379
4380	/**
4381	* xmlXPathNewNodeSetList:
4382	* @val: an existing NodeSet
4383	*
4384	* Create a new xmlXPathObjectPtr of type NodeSet and initialize
4385	* it with the Nodeset @val
4386	*
4387	* Returns the newly created object.
4388	*/
4389	xmlXPathObjectPtr
4390	xmlXPathNewNodeSetList(xmlNodeSetPtr val)
4391	{
4392	xmlXPathObjectPtr ret;
4393	int i;
4394
4395	if (val == NULL)
4396	ret = NULL;
4397	else if (val->nodeTab == NULL)
4398	ret = xmlXPathNewNodeSet(NULL);
4399	else {
4400	ret = xmlXPathNewNodeSet(val->nodeTab[0]);
4401	if (ret) {
4402	for (i = 1; i < val->nodeNr; ++i) {
4403	if (xmlXPathNodeSetAddUnique(ret->nodesetval, val->nodeTab[i])
4404	< 0) break;
4405	}
4406	}
4407	}
4408
4409	return (ret);
4410	}
4411
4412	/**
4413	* xmlXPathWrapNodeSet:
4414	* @val: the NodePtr value
4415	*
4416	* Wrap the Nodeset @val in a new xmlXPathObjectPtr
4417	*
4418	* Returns the newly created object.
4419	*/
4420	xmlXPathObjectPtr
4421	xmlXPathWrapNodeSet(xmlNodeSetPtr val) {
4422	xmlXPathObjectPtr ret;
4423
4424	ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
4425	if (ret == NULL) {
4426	xmlXPathErrMemory(NULL, "creating node set object\n");
4427	return(NULL);
4428	}
4429	memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
4430	ret->type = XPATH_NODESET;
4431	ret->nodesetval = val;
4432	#ifdef XP_DEBUG_OBJ_USAGE
4433	xmlXPathDebugObjUsageRequested(NULL, XPATH_NODESET);
4434	#endif
4435	return(ret);
4436	}
4437
4438	/**
4439	* xmlXPathFreeNodeSetList:
4440	* @obj: an existing NodeSetList object
4441	*
4442	* Free up the xmlXPathObjectPtr @obj but don't deallocate the objects in
4443	* the list contrary to xmlXPathFreeObject().
4444	*/
4445	void
4446	xmlXPathFreeNodeSetList(xmlXPathObjectPtr obj) {
4447	if (obj == NULL) return;
4448	#ifdef XP_DEBUG_OBJ_USAGE
4449	xmlXPathDebugObjUsageReleased(NULL, obj->type);
4450	#endif
4451	xmlFree(obj);
4452	}
4453
4454	/**
4455	* xmlXPathDifference:
4456	* @nodes1: a node-set
4457	* @nodes2: a node-set
4458	*
4459	* Implements the EXSLT - Sets difference() function:
4460	* node-set set:difference (node-set, node-set)
4461	*
4462	* Returns the difference between the two node sets, or nodes1 if
4463	* nodes2 is empty
4464	*/
4465	xmlNodeSetPtr
4466	xmlXPathDifference (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
4467	xmlNodeSetPtr ret;
4468	int i, l1;
4469	xmlNodePtr cur;
4470
4471	if (xmlXPathNodeSetIsEmpty(nodes2))
4472	return(nodes1);
4473
4474	ret = xmlXPathNodeSetCreate(NULL);
4475	if (xmlXPathNodeSetIsEmpty(nodes1))
4476	return(ret);
4477
4478	l1 = xmlXPathNodeSetGetLength(nodes1);
4479
4480	for (i = 0; i < l1; i++) {
4481	cur = xmlXPathNodeSetItem(nodes1, i);
4482	if (!xmlXPathNodeSetContains(nodes2, cur)) {
4483	if (xmlXPathNodeSetAddUnique(ret, cur) < 0)
4484	break;
4485	}
4486	}
4487	return(ret);
4488	}
4489
4490	/**
4491	* xmlXPathIntersection:
4492	* @nodes1: a node-set
4493	* @nodes2: a node-set
4494	*
4495	* Implements the EXSLT - Sets intersection() function:
4496	* node-set set:intersection (node-set, node-set)
4497	*
4498	* Returns a node set comprising the nodes that are within both the
4499	* node sets passed as arguments
4500	*/
4501	xmlNodeSetPtr
4502	xmlXPathIntersection (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
4503	xmlNodeSetPtr ret = xmlXPathNodeSetCreate(NULL);
4504	int i, l1;
4505	xmlNodePtr cur;
4506
4507	if (ret == NULL)
4508	return(ret);
4509	if (xmlXPathNodeSetIsEmpty(nodes1))
4510	return(ret);
4511	if (xmlXPathNodeSetIsEmpty(nodes2))
4512	return(ret);
4513
4514	l1 = xmlXPathNodeSetGetLength(nodes1);
4515
4516	for (i = 0; i < l1; i++) {
4517	cur = xmlXPathNodeSetItem(nodes1, i);
4518	if (xmlXPathNodeSetContains(nodes2, cur)) {
4519	if (xmlXPathNodeSetAddUnique(ret, cur) < 0)
4520	break;
4521	}
4522	}
4523	return(ret);
4524	}
4525
4526	/**
4527	* xmlXPathDistinctSorted:
4528	* @nodes: a node-set, sorted by document order
4529	*
4530	* Implements the EXSLT - Sets distinct() function:
4531	* node-set set:distinct (node-set)
4532	*
4533	* Returns a subset of the nodes contained in @nodes, or @nodes if
4534	* it is empty
4535	*/
4536	xmlNodeSetPtr
4537	xmlXPathDistinctSorted (xmlNodeSetPtr nodes) {
4538	xmlNodeSetPtr ret;
4539	xmlHashTablePtr hash;
4540	int i, l;
4541	xmlChar * strval;
4542	xmlNodePtr cur;
4543
4544	if (xmlXPathNodeSetIsEmpty(nodes))
4545	return(nodes);
4546
4547	ret = xmlXPathNodeSetCreate(NULL);
4548	if (ret == NULL)
4549	return(ret);
4550	l = xmlXPathNodeSetGetLength(nodes);
4551	hash = xmlHashCreate (l);
4552	for (i = 0; i < l; i++) {
4553	cur = xmlXPathNodeSetItem(nodes, i);
4554	strval = xmlXPathCastNodeToString(cur);
4555	if (xmlHashLookup(hash, strval) == NULL) {
4556	xmlHashAddEntry(hash, strval, strval);
4557	if (xmlXPathNodeSetAddUnique(ret, cur) < 0)
4558	break;
4559	} else {
4560	xmlFree(strval);
4561	}
4562	}
4563	xmlHashFree(hash, (xmlHashDeallocator) xmlFree);
4564	return(ret);
4565	}
4566
4567	/**
4568	* xmlXPathDistinct:
4569	* @nodes: a node-set
4570	*
4571	* Implements the EXSLT - Sets distinct() function:
4572	* node-set set:distinct (node-set)
4573	* @nodes is sorted by document order, then #exslSetsDistinctSorted
4574	* is called with the sorted node-set
4575	*
4576	* Returns a subset of the nodes contained in @nodes, or @nodes if
4577	* it is empty
4578	*/
4579	xmlNodeSetPtr
4580	xmlXPathDistinct (xmlNodeSetPtr nodes) {
4581	if (xmlXPathNodeSetIsEmpty(nodes))
4582	return(nodes);
4583
4584	xmlXPathNodeSetSort(nodes);
4585	return(xmlXPathDistinctSorted(nodes));
4586	}
4587
4588	/**
4589	* xmlXPathHasSameNodes:
4590	* @nodes1: a node-set
4591	* @nodes2: a node-set
4592	*
4593	* Implements the EXSLT - Sets has-same-nodes function:
4594	* boolean set:has-same-node(node-set, node-set)
4595	*
4596	* Returns true (1) if @nodes1 shares any node with @nodes2, false (0)
4597	* otherwise
4598	*/
4599	int
4600	xmlXPathHasSameNodes (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
4601	int i, l;
4602	xmlNodePtr cur;
4603
4604	if (xmlXPathNodeSetIsEmpty(nodes1) \|\|
4605	xmlXPathNodeSetIsEmpty(nodes2))
4606	return(0);
4607
4608	l = xmlXPathNodeSetGetLength(nodes1);
4609	for (i = 0; i < l; i++) {
4610	cur = xmlXPathNodeSetItem(nodes1, i);
4611	if (xmlXPathNodeSetContains(nodes2, cur))
4612	return(1);
4613	}
4614	return(0);
4615	}
4616
4617	/**
4618	* xmlXPathNodeLeadingSorted:
4619	* @nodes: a node-set, sorted by document order
4620	* @node: a node
4621	*
4622	* Implements the EXSLT - Sets leading() function:
4623	* node-set set:leading (node-set, node-set)
4624	*
4625	* Returns the nodes in @nodes that precede @node in document order,
4626	* @nodes if @node is NULL or an empty node-set if @nodes
4627	* doesn't contain @node
4628	*/
4629	xmlNodeSetPtr
4630	xmlXPathNodeLeadingSorted (xmlNodeSetPtr nodes, xmlNodePtr node) {
4631	int i, l;
4632	xmlNodePtr cur;
4633	xmlNodeSetPtr ret;
4634
4635	if (node == NULL)
4636	return(nodes);
4637
4638	ret = xmlXPathNodeSetCreate(NULL);
4639	if (ret == NULL)
4640	return(ret);
4641	if (xmlXPathNodeSetIsEmpty(nodes) \|\|
4642	(!xmlXPathNodeSetContains(nodes, node)))
4643	return(ret);
4644
4645	l = xmlXPathNodeSetGetLength(nodes);
4646	for (i = 0; i < l; i++) {
4647	cur = xmlXPathNodeSetItem(nodes, i);
4648	if (cur == node)
4649	break;
4650	if (xmlXPathNodeSetAddUnique(ret, cur) < 0)
4651	break;
4652	}
4653	return(ret);
4654	}
4655
4656	/**
4657	* xmlXPathNodeLeading:
4658	* @nodes: a node-set
4659	* @node: a node
4660	*
4661	* Implements the EXSLT - Sets leading() function:
4662	* node-set set:leading (node-set, node-set)
4663	* @nodes is sorted by document order, then #exslSetsNodeLeadingSorted
4664	* is called.
4665	*
4666	* Returns the nodes in @nodes that precede @node in document order,
4667	* @nodes if @node is NULL or an empty node-set if @nodes
4668	* doesn't contain @node
4669	*/
4670	xmlNodeSetPtr
4671	xmlXPathNodeLeading (xmlNodeSetPtr nodes, xmlNodePtr node) {
4672	xmlXPathNodeSetSort(nodes);
4673	return(xmlXPathNodeLeadingSorted(nodes, node));
4674	}
4675
4676	/**
4677	* xmlXPathLeadingSorted:
4678	* @nodes1: a node-set, sorted by document order
4679	* @nodes2: a node-set, sorted by document order
4680	*
4681	* Implements the EXSLT - Sets leading() function:
4682	* node-set set:leading (node-set, node-set)
4683	*
4684	* Returns the nodes in @nodes1 that precede the first node in @nodes2
4685	* in document order, @nodes1 if @nodes2 is NULL or empty or
4686	* an empty node-set if @nodes1 doesn't contain @nodes2
4687	*/
4688	xmlNodeSetPtr
4689	xmlXPathLeadingSorted (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
4690	if (xmlXPathNodeSetIsEmpty(nodes2))
4691	return(nodes1);
4692	return(xmlXPathNodeLeadingSorted(nodes1,
4693	xmlXPathNodeSetItem(nodes2, 1)));
4694	}
4695
4696	/**
4697	* xmlXPathLeading:
4698	* @nodes1: a node-set
4699	* @nodes2: a node-set
4700	*
4701	* Implements the EXSLT - Sets leading() function:
4702	* node-set set:leading (node-set, node-set)
4703	* @nodes1 and @nodes2 are sorted by document order, then
4704	* #exslSetsLeadingSorted is called.
4705	*
4706	* Returns the nodes in @nodes1 that precede the first node in @nodes2
4707	* in document order, @nodes1 if @nodes2 is NULL or empty or
4708	* an empty node-set if @nodes1 doesn't contain @nodes2
4709	*/
4710	xmlNodeSetPtr
4711	xmlXPathLeading (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
4712	if (xmlXPathNodeSetIsEmpty(nodes2))
4713	return(nodes1);
4714	if (xmlXPathNodeSetIsEmpty(nodes1))
4715	return(xmlXPathNodeSetCreate(NULL));
4716	xmlXPathNodeSetSort(nodes1);
4717	xmlXPathNodeSetSort(nodes2);
4718	return(xmlXPathNodeLeadingSorted(nodes1,
4719	xmlXPathNodeSetItem(nodes2, 1)));
4720	}
4721
4722	/**
4723	* xmlXPathNodeTrailingSorted:
4724	* @nodes: a node-set, sorted by document order
4725	* @node: a node
4726	*
4727	* Implements the EXSLT - Sets trailing() function:
4728	* node-set set:trailing (node-set, node-set)
4729	*
4730	* Returns the nodes in @nodes that follow @node in document order,
4731	* @nodes if @node is NULL or an empty node-set if @nodes
4732	* doesn't contain @node
4733	*/
4734	xmlNodeSetPtr
4735	xmlXPathNodeTrailingSorted (xmlNodeSetPtr nodes, xmlNodePtr node) {
4736	int i, l;
4737	xmlNodePtr cur;
4738	xmlNodeSetPtr ret;
4739
4740	if (node == NULL)
4741	return(nodes);
4742
4743	ret = xmlXPathNodeSetCreate(NULL);
4744	if (ret == NULL)
4745	return(ret);
4746	if (xmlXPathNodeSetIsEmpty(nodes) \|\|
4747	(!xmlXPathNodeSetContains(nodes, node)))
4748	return(ret);
4749
4750	l = xmlXPathNodeSetGetLength(nodes);
4751	for (i = l - 1; i >= 0; i--) {
4752	cur = xmlXPathNodeSetItem(nodes, i);
4753	if (cur == node)
4754	break;
4755	if (xmlXPathNodeSetAddUnique(ret, cur) < 0)
4756	break;
4757	}
4758	xmlXPathNodeSetSort(ret); /* bug 413451 */
4759	return(ret);
4760	}
4761
4762	/**
4763	* xmlXPathNodeTrailing:
4764	* @nodes: a node-set
4765	* @node: a node
4766	*
4767	* Implements the EXSLT - Sets trailing() function:
4768	* node-set set:trailing (node-set, node-set)
4769	* @nodes is sorted by document order, then #xmlXPathNodeTrailingSorted
4770	* is called.
4771	*
4772	* Returns the nodes in @nodes that follow @node in document order,
4773	* @nodes if @node is NULL or an empty node-set if @nodes
4774	* doesn't contain @node
4775	*/
4776	xmlNodeSetPtr
4777	xmlXPathNodeTrailing (xmlNodeSetPtr nodes, xmlNodePtr node) {
4778	xmlXPathNodeSetSort(nodes);
4779	return(xmlXPathNodeTrailingSorted(nodes, node));
4780	}
4781
4782	/**
4783	* xmlXPathTrailingSorted:
4784	* @nodes1: a node-set, sorted by document order
4785	* @nodes2: a node-set, sorted by document order
4786	*
4787	* Implements the EXSLT - Sets trailing() function:
4788	* node-set set:trailing (node-set, node-set)
4789	*
4790	* Returns the nodes in @nodes1 that follow the first node in @nodes2
4791	* in document order, @nodes1 if @nodes2 is NULL or empty or
4792	* an empty node-set if @nodes1 doesn't contain @nodes2
4793	*/
4794	xmlNodeSetPtr
4795	xmlXPathTrailingSorted (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
4796	if (xmlXPathNodeSetIsEmpty(nodes2))
4797	return(nodes1);
4798	return(xmlXPathNodeTrailingSorted(nodes1,
4799	xmlXPathNodeSetItem(nodes2, 0)));
4800	}
4801
4802	/**
4803	* xmlXPathTrailing:
4804	* @nodes1: a node-set
4805	* @nodes2: a node-set
4806	*
4807	* Implements the EXSLT - Sets trailing() function:
4808	* node-set set:trailing (node-set, node-set)
4809	* @nodes1 and @nodes2 are sorted by document order, then
4810	* #xmlXPathTrailingSorted is called.
4811	*
4812	* Returns the nodes in @nodes1 that follow the first node in @nodes2
4813	* in document order, @nodes1 if @nodes2 is NULL or empty or
4814	* an empty node-set if @nodes1 doesn't contain @nodes2
4815	*/
4816	xmlNodeSetPtr
4817	xmlXPathTrailing (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
4818	if (xmlXPathNodeSetIsEmpty(nodes2))
4819	return(nodes1);
4820	if (xmlXPathNodeSetIsEmpty(nodes1))
4821	return(xmlXPathNodeSetCreate(NULL));
4822	xmlXPathNodeSetSort(nodes1);
4823	xmlXPathNodeSetSort(nodes2);
4824	return(xmlXPathNodeTrailingSorted(nodes1,
4825	xmlXPathNodeSetItem(nodes2, 0)));
4826	}
4827
4828	/************************************************************************
4829	* *
4830	* Routines to handle extra functions *
4831	* *
4832	************************************************************************/
4833
4834	/**
4835	* xmlXPathRegisterFunc:
4836	* @ctxt: the XPath context
4837	* @name: the function name
4838	* @f: the function implementation or NULL
4839	*
4840	* Register a new function. If @f is NULL it unregisters the function
4841	*
4842	* Returns 0 in case of success, -1 in case of error
4843	*/
4844	int
4845	xmlXPathRegisterFunc(xmlXPathContextPtr ctxt, const xmlChar *name,
4846	xmlXPathFunction f) {
4847	return(xmlXPathRegisterFuncNS(ctxt, name, NULL, f));
4848	}
4849
4850	/**
4851	* xmlXPathRegisterFuncNS:
4852	* @ctxt: the XPath context
4853	* @name: the function name
4854	* @ns_uri: the function namespace URI
4855	* @f: the function implementation or NULL
4856	*
4857	* Register a new function. If @f is NULL it unregisters the function
4858	*
4859	* Returns 0 in case of success, -1 in case of error
4860	*/
4861	int
4862	xmlXPathRegisterFuncNS(xmlXPathContextPtr ctxt, const xmlChar *name,
4863	const xmlChar *ns_uri, xmlXPathFunction f) {
4864	if (ctxt == NULL)
4865	return(-1);
4866	if (name == NULL)
4867	return(-1);
4868
4869	if (ctxt->funcHash == NULL)
4870	ctxt->funcHash = xmlHashCreate(0);
4871	if (ctxt->funcHash == NULL)
4872	return(-1);
4873	if (f == NULL)
4874	return(xmlHashRemoveEntry2(ctxt->funcHash, name, ns_uri, NULL));
4875	return(xmlHashAddEntry2(ctxt->funcHash, name, ns_uri, XML_CAST_FPTR(f)));
4876	}
4877
4878	/**
4879	* xmlXPathRegisterFuncLookup:
4880	* @ctxt: the XPath context
4881	* @f: the lookup function
4882	* @funcCtxt: the lookup data
4883	*
4884	* Registers an external mechanism to do function lookup.
4885	*/
4886	void
4887	xmlXPathRegisterFuncLookup (xmlXPathContextPtr ctxt,
4888	xmlXPathFuncLookupFunc f,
4889	void *funcCtxt) {
4890	if (ctxt == NULL)
4891	return;
4892	ctxt->funcLookupFunc = f;
4893	ctxt->funcLookupData = funcCtxt;
4894	}
4895
4896	/**
4897	* xmlXPathFunctionLookup:
4898	* @ctxt: the XPath context
4899	* @name: the function name
4900	*
4901	* Search in the Function array of the context for the given
4902	* function.
4903	*
4904	* Returns the xmlXPathFunction or NULL if not found
4905	*/
4906	xmlXPathFunction
4907	xmlXPathFunctionLookup(xmlXPathContextPtr ctxt, const xmlChar *name) {
4908	if (ctxt == NULL)
4909	return (NULL);
4910
4911	if (ctxt->funcLookupFunc != NULL) {
4912	xmlXPathFunction ret;
4913	xmlXPathFuncLookupFunc f;
4914
4915	f = ctxt->funcLookupFunc;
4916	ret = f(ctxt->funcLookupData, name, NULL);
4917	if (ret != NULL)
4918	return(ret);
4919	}
4920	return(xmlXPathFunctionLookupNS(ctxt, name, NULL));
4921	}
4922
4923	/**
4924	* xmlXPathFunctionLookupNS:
4925	* @ctxt: the XPath context
4926	* @name: the function name
4927	* @ns_uri: the function namespace URI
4928	*
4929	* Search in the Function array of the context for the given
4930	* function.
4931	*
4932	* Returns the xmlXPathFunction or NULL if not found
4933	*/
4934	xmlXPathFunction
4935	xmlXPathFunctionLookupNS(xmlXPathContextPtr ctxt, const xmlChar *name,
4936	const xmlChar *ns_uri) {
4937	xmlXPathFunction ret;
4938
4939	if (ctxt == NULL)
4940	return(NULL);
4941	if (name == NULL)
4942	return(NULL);
4943
4944	if (ctxt->funcLookupFunc != NULL) {
4945	xmlXPathFuncLookupFunc f;
4946
4947	f = ctxt->funcLookupFunc;
4948	ret = f(ctxt->funcLookupData, name, ns_uri);
4949	if (ret != NULL)
4950	return(ret);
4951	}
4952
4953	if (ctxt->funcHash == NULL)
4954	return(NULL);
4955
4956	XML_CAST_FPTR(ret) = xmlHashLookup2(ctxt->funcHash, name, ns_uri);
4957	return(ret);
4958	}
4959
4960	/**
4961	* xmlXPathRegisteredFuncsCleanup:
4962	* @ctxt: the XPath context
4963	*
4964	* Cleanup the XPath context data associated to registered functions
4965	*/
4966	void
4967	xmlXPathRegisteredFuncsCleanup(xmlXPathContextPtr ctxt) {
4968	if (ctxt == NULL)
4969	return;
4970
4971	xmlHashFree(ctxt->funcHash, NULL);
4972	ctxt->funcHash = NULL;
4973	}
4974
4975	/************************************************************************
4976	* *
4977	* Routines to handle Variables *
4978	* *
4979	************************************************************************/
4980
4981	/**
4982	* xmlXPathRegisterVariable:
4983	* @ctxt: the XPath context
4984	* @name: the variable name
4985	* @value: the variable value or NULL
4986	*
4987	* Register a new variable value. If @value is NULL it unregisters
4988	* the variable
4989	*
4990	* Returns 0 in case of success, -1 in case of error
4991	*/
4992	int
4993	xmlXPathRegisterVariable(xmlXPathContextPtr ctxt, const xmlChar *name,
4994	xmlXPathObjectPtr value) {
4995	return(xmlXPathRegisterVariableNS(ctxt, name, NULL, value));
4996	}
4997
4998	/**
4999	* xmlXPathRegisterVariableNS:
5000	* @ctxt: the XPath context
5001	* @name: the variable name
5002	* @ns_uri: the variable namespace URI
5003	* @value: the variable value or NULL
5004	*
5005	* Register a new variable value. If @value is NULL it unregisters
5006	* the variable
5007	*
5008	* Returns 0 in case of success, -1 in case of error
5009	*/
5010	int
5011	xmlXPathRegisterVariableNS(xmlXPathContextPtr ctxt, const xmlChar *name,
5012	const xmlChar *ns_uri,
5013	xmlXPathObjectPtr value) {
5014	if (ctxt == NULL)
5015	return(-1);
5016	if (name == NULL)
5017	return(-1);
5018
5019	if (ctxt->varHash == NULL)
5020	ctxt->varHash = xmlHashCreate(0);
5021	if (ctxt->varHash == NULL)
5022	return(-1);
5023	if (value == NULL)
5024	return(xmlHashRemoveEntry2(ctxt->varHash, name, ns_uri,
5025	(xmlHashDeallocator)xmlXPathFreeObject));
5026	return(xmlHashUpdateEntry2(ctxt->varHash, name, ns_uri,
5027	(void *) value,
5028	(xmlHashDeallocator)xmlXPathFreeObject));
5029	}
5030
5031	/**
5032	* xmlXPathRegisterVariableLookup:
5033	* @ctxt: the XPath context
5034	* @f: the lookup function
5035	* @data: the lookup data
5036	*
5037	* register an external mechanism to do variable lookup
5038	*/
5039	void
5040	xmlXPathRegisterVariableLookup(xmlXPathContextPtr ctxt,
5041	xmlXPathVariableLookupFunc f, void *data) {
5042	if (ctxt == NULL)
5043	return;
5044	ctxt->varLookupFunc = f;
5045	ctxt->varLookupData = data;
5046	}
5047
5048	/**
5049	* xmlXPathVariableLookup:
5050	* @ctxt: the XPath context
5051	* @name: the variable name
5052	*
5053	* Search in the Variable array of the context for the given
5054	* variable value.
5055	*
5056	* Returns a copy of the value or NULL if not found
5057	*/
5058	xmlXPathObjectPtr
5059	xmlXPathVariableLookup(xmlXPathContextPtr ctxt, const xmlChar *name) {
5060	if (ctxt == NULL)
5061	return(NULL);
5062
5063	if (ctxt->varLookupFunc != NULL) {
5064	xmlXPathObjectPtr ret;
5065
5066	ret = ((xmlXPathVariableLookupFunc)ctxt->varLookupFunc)
5067	(ctxt->varLookupData, name, NULL);
5068	return(ret);
5069	}
5070	return(xmlXPathVariableLookupNS(ctxt, name, NULL));
5071	}
5072
5073	/**
5074	* xmlXPathVariableLookupNS:
5075	* @ctxt: the XPath context
5076	* @name: the variable name
5077	* @ns_uri: the variable namespace URI
5078	*
5079	* Search in the Variable array of the context for the given
5080	* variable value.
5081	*
5082	* Returns the a copy of the value or NULL if not found
5083	*/
5084	xmlXPathObjectPtr
5085	xmlXPathVariableLookupNS(xmlXPathContextPtr ctxt, const xmlChar *name,
5086	const xmlChar *ns_uri) {
5087	if (ctxt == NULL)
5088	return(NULL);
5089
5090	if (ctxt->varLookupFunc != NULL) {
5091	xmlXPathObjectPtr ret;
5092
5093	ret = ((xmlXPathVariableLookupFunc)ctxt->varLookupFunc)
5094	(ctxt->varLookupData, name, ns_uri);
5095	if (ret != NULL) return(ret);
5096	}
5097
5098	if (ctxt->varHash == NULL)
5099	return(NULL);
5100	if (name == NULL)
5101	return(NULL);
5102
5103	return(xmlXPathCacheObjectCopy(ctxt, (xmlXPathObjectPtr)
5104	xmlHashLookup2(ctxt->varHash, name, ns_uri)));
5105	}
5106
5107	/**
5108	* xmlXPathRegisteredVariablesCleanup:
5109	* @ctxt: the XPath context
5110	*
5111	* Cleanup the XPath context data associated to registered variables
5112	*/
5113	void
5114	xmlXPathRegisteredVariablesCleanup(xmlXPathContextPtr ctxt) {
5115	if (ctxt == NULL)
5116	return;
5117
5118	xmlHashFree(ctxt->varHash, (xmlHashDeallocator)xmlXPathFreeObject);
5119	ctxt->varHash = NULL;
5120	}
5121
5122	/**
5123	* xmlXPathRegisterNs:
5124	* @ctxt: the XPath context
5125	* @prefix: the namespace prefix cannot be NULL or empty string
5126	* @ns_uri: the namespace name
5127	*
5128	* Register a new namespace. If @ns_uri is NULL it unregisters
5129	* the namespace
5130	*
5131	* Returns 0 in case of success, -1 in case of error
5132	*/
5133	int
5134	xmlXPathRegisterNs(xmlXPathContextPtr ctxt, const xmlChar *prefix,
5135	const xmlChar *ns_uri) {
5136	if (ctxt == NULL)
5137	return(-1);
5138	if (prefix == NULL)
5139	return(-1);
5140	if (prefix[0] == 0)
5141	return(-1);
5142
5143	if (ctxt->nsHash == NULL)
5144	ctxt->nsHash = xmlHashCreate(10);
5145	if (ctxt->nsHash == NULL)
5146	return(-1);
5147	if (ns_uri == NULL)
5148	return(xmlHashRemoveEntry(ctxt->nsHash, prefix,
5149	(xmlHashDeallocator)xmlFree));
5150	return(xmlHashUpdateEntry(ctxt->nsHash, prefix, (void *) xmlStrdup(ns_uri),
5151	(xmlHashDeallocator)xmlFree));
5152	}
5153
5154	/**
5155	* xmlXPathNsLookup:
5156	* @ctxt: the XPath context
5157	* @prefix: the namespace prefix value
5158	*
5159	* Search in the namespace declaration array of the context for the given
5160	* namespace name associated to the given prefix
5161	*
5162	* Returns the value or NULL if not found
5163	*/
5164	const xmlChar *
5165	xmlXPathNsLookup(xmlXPathContextPtr ctxt, const xmlChar *prefix) {
5166	if (ctxt == NULL)
5167	return(NULL);
5168	if (prefix == NULL)
5169	return(NULL);
5170
5171	#ifdef XML_XML_NAMESPACE
5172	if (xmlStrEqual(prefix, (const xmlChar *) "xml"))
5173	return(XML_XML_NAMESPACE);
5174	#endif
5175
5176	if (ctxt->namespaces != NULL) {
5177	int i;
5178
5179	for (i = 0;i < ctxt->nsNr;i++) {
5180	if ((ctxt->namespaces[i] != NULL) &&
5181	(xmlStrEqual(ctxt->namespaces[i]->prefix, prefix)))
5182	return(ctxt->namespaces[i]->href);
5183	}
5184	}
5185
5186	return((const xmlChar *) xmlHashLookup(ctxt->nsHash, prefix));
5187	}
5188
5189	/**
5190	* xmlXPathRegisteredNsCleanup:
5191	* @ctxt: the XPath context
5192	*
5193	* Cleanup the XPath context data associated to registered variables
5194	*/
5195	void
5196	xmlXPathRegisteredNsCleanup(xmlXPathContextPtr ctxt) {
5197	if (ctxt == NULL)
5198	return;
5199
5200	xmlHashFree(ctxt->nsHash, (xmlHashDeallocator)xmlFree);
5201	ctxt->nsHash = NULL;
5202	}
5203
5204	/************************************************************************
5205	* *
5206	* Routines to handle Values *
5207	* *
5208	************************************************************************/
5209
5210	/* Allocations are terrible, one needs to optimize all this !!! */
5211
5212	/**
5213	* xmlXPathNewFloat:
5214	* @val: the double value
5215	*
5216	* Create a new xmlXPathObjectPtr of type double and of value @val
5217	*
5218	* Returns the newly created object.
5219	*/
5220	xmlXPathObjectPtr
5221	xmlXPathNewFloat(double val) {
5222	xmlXPathObjectPtr ret;
5223
5224	ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
5225	if (ret == NULL) {
5226	xmlXPathErrMemory(NULL, "creating float object\n");
5227	return(NULL);
5228	}
5229	memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
5230	ret->type = XPATH_NUMBER;
5231	ret->floatval = val;
5232	#ifdef XP_DEBUG_OBJ_USAGE
5233	xmlXPathDebugObjUsageRequested(NULL, XPATH_NUMBER);
5234	#endif
5235	return(ret);
5236	}
5237
5238	/**
5239	* xmlXPathNewBoolean:
5240	* @val: the boolean value
5241	*
5242	* Create a new xmlXPathObjectPtr of type boolean and of value @val
5243	*
5244	* Returns the newly created object.
5245	*/
5246	xmlXPathObjectPtr
5247	xmlXPathNewBoolean(int val) {
5248	xmlXPathObjectPtr ret;
5249
5250	ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
5251	if (ret == NULL) {
5252	xmlXPathErrMemory(NULL, "creating boolean object\n");
5253	return(NULL);
5254	}
5255	memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
5256	ret->type = XPATH_BOOLEAN;
5257	ret->boolval = (val != 0);
5258	#ifdef XP_DEBUG_OBJ_USAGE
5259	xmlXPathDebugObjUsageRequested(NULL, XPATH_BOOLEAN);
5260	#endif
5261	return(ret);
5262	}
5263
5264	/**
5265	* xmlXPathNewString:
5266	* @val: the xmlChar * value
5267	*
5268	* Create a new xmlXPathObjectPtr of type string and of value @val
5269	*
5270	* Returns the newly created object.
5271	*/
5272	xmlXPathObjectPtr
5273	xmlXPathNewString(const xmlChar *val) {
5274	xmlXPathObjectPtr ret;
5275
5276	ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
5277	if (ret == NULL) {
5278	xmlXPathErrMemory(NULL, "creating string object\n");
5279	return(NULL);
5280	}
5281	memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
5282	ret->type = XPATH_STRING;
5283	if (val != NULL)
5284	ret->stringval = xmlStrdup(val);
5285	else
5286	ret->stringval = xmlStrdup((const xmlChar *)"");
5287	#ifdef XP_DEBUG_OBJ_USAGE
5288	xmlXPathDebugObjUsageRequested(NULL, XPATH_STRING);
5289	#endif
5290	return(ret);
5291	}
5292
5293	/**
5294	* xmlXPathWrapString:
5295	* @val: the xmlChar * value
5296	*
5297	* Wraps the @val string into an XPath object.
5298	*
5299	* Returns the newly created object.
5300	*/
5301	xmlXPathObjectPtr
5302	xmlXPathWrapString (xmlChar *val) {
5303	xmlXPathObjectPtr ret;
5304
5305	ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
5306	if (ret == NULL) {
5307	xmlXPathErrMemory(NULL, "creating string object\n");
5308	return(NULL);
5309	}
5310	memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
5311	ret->type = XPATH_STRING;
5312	ret->stringval = val;
5313	#ifdef XP_DEBUG_OBJ_USAGE
5314	xmlXPathDebugObjUsageRequested(NULL, XPATH_STRING);
5315	#endif
5316	return(ret);
5317	}
5318
5319	/**
5320	* xmlXPathNewCString:
5321	* @val: the char * value
5322	*
5323	* Create a new xmlXPathObjectPtr of type string and of value @val
5324	*
5325	* Returns the newly created object.
5326	*/
5327	xmlXPathObjectPtr
5328	xmlXPathNewCString(const char *val) {
5329	xmlXPathObjectPtr ret;
5330
5331	ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
5332	if (ret == NULL) {
5333	xmlXPathErrMemory(NULL, "creating string object\n");
5334	return(NULL);
5335	}
5336	memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
5337	ret->type = XPATH_STRING;
5338	ret->stringval = xmlStrdup(BAD_CAST val);
5339	#ifdef XP_DEBUG_OBJ_USAGE
5340	xmlXPathDebugObjUsageRequested(NULL, XPATH_STRING);
5341	#endif
5342	return(ret);
5343	}
5344
5345	/**
5346	* xmlXPathWrapCString:
5347	* @val: the char * value
5348	*
5349	* Wraps a string into an XPath object.
5350	*
5351	* Returns the newly created object.
5352	*/
5353	xmlXPathObjectPtr
5354	xmlXPathWrapCString (char * val) {
5355	return(xmlXPathWrapString((xmlChar *)(val)));
5356	}
5357
5358	/**
5359	* xmlXPathWrapExternal:
5360	* @val: the user data
5361	*
5362	* Wraps the @val data into an XPath object.
5363	*
5364	* Returns the newly created object.
5365	*/
5366	xmlXPathObjectPtr
5367	xmlXPathWrapExternal (void *val) {
5368	xmlXPathObjectPtr ret;
5369
5370	ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
5371	if (ret == NULL) {
5372	xmlXPathErrMemory(NULL, "creating user object\n");
5373	return(NULL);
5374	}
5375	memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
5376	ret->type = XPATH_USERS;
5377	ret->user = val;
5378	#ifdef XP_DEBUG_OBJ_USAGE
5379	xmlXPathDebugObjUsageRequested(NULL, XPATH_USERS);
5380	#endif
5381	return(ret);
5382	}
5383
5384	/**
5385	* xmlXPathObjectCopy:
5386	* @val: the original object
5387	*
5388	* allocate a new copy of a given object
5389	*
5390	* Returns the newly created object.
5391	*/
5392	xmlXPathObjectPtr
5393	xmlXPathObjectCopy(xmlXPathObjectPtr val) {
5394	xmlXPathObjectPtr ret;
5395
5396	if (val == NULL)
5397	return(NULL);
5398
5399	ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
5400	if (ret == NULL) {
5401	xmlXPathErrMemory(NULL, "copying object\n");
5402	return(NULL);
5403	}
5404	memcpy(ret, val , (size_t) sizeof(xmlXPathObject));
5405	#ifdef XP_DEBUG_OBJ_USAGE
5406	xmlXPathDebugObjUsageRequested(NULL, val->type);
5407	#endif
5408	switch (val->type) {
5409	case XPATH_BOOLEAN:
5410	case XPATH_NUMBER:
5411	case XPATH_POINT:
5412	case XPATH_RANGE:
5413	break;
5414	case XPATH_STRING:
5415	ret->stringval = xmlStrdup(val->stringval);
5416	break;
5417	case XPATH_XSLT_TREE:
5418	#if 0
5419	/*
5420	Removed 11 July 2004 - the current handling of xslt tmpRVT nodes means that
5421	this previous handling is no longer correct, and can cause some serious
5422	problems (ref. bug 145547)
5423	*/
5424	if ((val->nodesetval != NULL) &&
5425	(val->nodesetval->nodeTab != NULL)) {
5426	xmlNodePtr cur, tmp;
5427	xmlDocPtr top;
5428
5429	ret->boolval = 1;
5430	top = xmlNewDoc(NULL);
5431	top->name = (char *)
5432	xmlStrdup(val->nodesetval->nodeTab[0]->name);
5433	ret->user = top;
5434	if (top != NULL) {
5435	top->doc = top;
5436	cur = val->nodesetval->nodeTab[0]->children;
5437	while (cur != NULL) {
5438	tmp = xmlDocCopyNode(cur, top, 1);
5439	xmlAddChild((xmlNodePtr) top, tmp);
5440	cur = cur->next;
5441	}
5442	}
5443
5444	ret->nodesetval = xmlXPathNodeSetCreate((xmlNodePtr) top);
5445	} else
5446	ret->nodesetval = xmlXPathNodeSetCreate(NULL);
5447	/* Deallocate the copied tree value */
5448	break;
5449	#endif
5450	case XPATH_NODESET:
5451	ret->nodesetval = xmlXPathNodeSetMerge(NULL, val->nodesetval);
5452	/* Do not deallocate the copied tree value */
5453	ret->boolval = 0;
5454	break;
5455	case XPATH_LOCATIONSET:
5456	#ifdef LIBXML_XPTR_ENABLED
5457	{
5458	xmlLocationSetPtr loc = val->user;
5459	ret->user = (void *) xmlXPtrLocationSetMerge(NULL, loc);
5460	break;
5461	}
5462	#endif
5463	case XPATH_USERS:
5464	ret->user = val->user;
5465	break;
5466	case XPATH_UNDEFINED:
5467	xmlGenericError(xmlGenericErrorContext,
5468	"xmlXPathObjectCopy: unsupported type %d\n",
5469	val->type);
5470	break;
5471	}
5472	return(ret);
5473	}
5474
5475	/**
5476	* xmlXPathFreeObject:
5477	* @obj: the object to free
5478	*
5479	* Free up an xmlXPathObjectPtr object.
5480	*/
5481	void
5482	xmlXPathFreeObject(xmlXPathObjectPtr obj) {
5483	if (obj == NULL) return;
5484	if ((obj->type == XPATH_NODESET) \|\| (obj->type == XPATH_XSLT_TREE)) {
5485	if (obj->boolval) {
5486	#if 0
5487	if (obj->user != NULL) {
5488	xmlXPathFreeNodeSet(obj->nodesetval);
5489	xmlFreeNodeList((xmlNodePtr) obj->user);
5490	} else
5491	#endif
5492	obj->type = XPATH_XSLT_TREE; /* TODO: Just for debugging. */
5493	if (obj->nodesetval != NULL)
5494	xmlXPathFreeValueTree(obj->nodesetval);
5495	} else {
5496	if (obj->nodesetval != NULL)
5497	xmlXPathFreeNodeSet(obj->nodesetval);
5498	}
5499	#ifdef LIBXML_XPTR_ENABLED
5500	} else if (obj->type == XPATH_LOCATIONSET) {
5501	if (obj->user != NULL)
5502	xmlXPtrFreeLocationSet(obj->user);
5503	#endif
5504	} else if (obj->type == XPATH_STRING) {
5505	if (obj->stringval != NULL)
5506	xmlFree(obj->stringval);
5507	}
5508	#ifdef XP_DEBUG_OBJ_USAGE
5509	xmlXPathDebugObjUsageReleased(NULL, obj->type);
5510	#endif
5511	xmlFree(obj);
5512	}
5513
5514	/**
5515	* xmlXPathReleaseObject:
5516	* @obj: the xmlXPathObjectPtr to free or to cache
5517	*
5518	* Depending on the state of the cache this frees the given
5519	* XPath object or stores it in the cache.
5520	*/
5521	static void
5522	xmlXPathReleaseObject(xmlXPathContextPtr ctxt, xmlXPathObjectPtr obj)
5523	{
5524	#define XP_CACHE_ADD(sl, o) if (sl == NULL) { \
5525	sl = xmlPointerListCreate(10); if (sl == NULL) goto free_obj; } \
5526	if (xmlPointerListAddSize(sl, obj, 0) == -1) goto free_obj;
5527
5528	#define XP_CACHE_WANTS(sl, n) ((sl == NULL) \|\| ((sl)->number < n))
5529
5530	if (obj == NULL)
5531	return;
5532	if ((ctxt == NULL) \|\| (ctxt->cache == NULL)) {
5533	xmlXPathFreeObject(obj);
5534	} else {
5535	xmlXPathContextCachePtr cache =
5536	(xmlXPathContextCachePtr) ctxt->cache;
5537
5538	switch (obj->type) {
5539	case XPATH_NODESET:
5540	case XPATH_XSLT_TREE:
5541	if (obj->nodesetval != NULL) {
5542	if (obj->boolval) {
5543	/*
5544	* It looks like the @boolval is used for
5545	* evaluation if this an XSLT Result Tree Fragment.
5546	* TODO: Check if this assumption is correct.
5547	*/
5548	obj->type = XPATH_XSLT_TREE; /* just for debugging */
5549	xmlXPathFreeValueTree(obj->nodesetval);
5550	obj->nodesetval = NULL;
5551	} else if ((obj->nodesetval->nodeMax <= 40) &&
5552	(XP_CACHE_WANTS(cache->nodesetObjs,
5553	cache->maxNodeset)))
5554	{
5555	XP_CACHE_ADD(cache->nodesetObjs, obj);
5556	goto obj_cached;
5557	} else {
5558	xmlXPathFreeNodeSet(obj->nodesetval);
5559	obj->nodesetval = NULL;
5560	}
5561	}
5562	break;
5563	case XPATH_STRING:
5564	if (obj->stringval != NULL)
5565	xmlFree(obj->stringval);
5566
5567	if (XP_CACHE_WANTS(cache->stringObjs, cache->maxString)) {
5568	XP_CACHE_ADD(cache->stringObjs, obj);
5569	goto obj_cached;
5570	}
5571	break;
5572	case XPATH_BOOLEAN:
5573	if (XP_CACHE_WANTS(cache->booleanObjs, cache->maxBoolean)) {
5574	XP_CACHE_ADD(cache->booleanObjs, obj);
5575	goto obj_cached;
5576	}
5577	break;
5578	case XPATH_NUMBER:
5579	if (XP_CACHE_WANTS(cache->numberObjs, cache->maxNumber)) {
5580	XP_CACHE_ADD(cache->numberObjs, obj);
5581	goto obj_cached;
5582	}
5583	break;
5584	#ifdef LIBXML_XPTR_ENABLED
5585	case XPATH_LOCATIONSET:
5586	if (obj->user != NULL) {
5587	xmlXPtrFreeLocationSet(obj->user);
5588	}
5589	goto free_obj;
5590	#endif
5591	default:
5592	goto free_obj;
5593	}
5594
5595	/*
5596	* Fallback to adding to the misc-objects slot.
5597	*/
5598	if (XP_CACHE_WANTS(cache->miscObjs, cache->maxMisc)) {
5599	XP_CACHE_ADD(cache->miscObjs, obj);
5600	} else
5601	goto free_obj;
5602
5603	obj_cached:
5604
5605	#ifdef XP_DEBUG_OBJ_USAGE
5606	xmlXPathDebugObjUsageReleased(ctxt, obj->type);
5607	#endif
5608
5609	if (obj->nodesetval != NULL) {
5610	xmlNodeSetPtr tmpset = obj->nodesetval;
5611
5612	/*
5613	* TODO: Due to those nasty ns-nodes, we need to traverse
5614	* the list and free the ns-nodes.
5615	* URGENT TODO: Check if it's actually slowing things down.
5616	* Maybe we shouldn't try to preserve the list.
5617	*/
5618	if (tmpset->nodeNr > 1) {
5619	int i;
5620	xmlNodePtr node;
5621
5622	for (i = 0; i < tmpset->nodeNr; i++) {
5623	node = tmpset->nodeTab[i];
5624	if ((node != NULL) &&
5625	(node->type == XML_NAMESPACE_DECL))
5626	{
5627	xmlXPathNodeSetFreeNs((xmlNsPtr) node);
5628	}
5629	}
5630	} else if (tmpset->nodeNr == 1) {
5631	if ((tmpset->nodeTab[0] != NULL) &&
5632	(tmpset->nodeTab[0]->type == XML_NAMESPACE_DECL))
5633	xmlXPathNodeSetFreeNs((xmlNsPtr) tmpset->nodeTab[0]);
5634	}
5635	tmpset->nodeNr = 0;
5636	memset(obj, 0, sizeof(xmlXPathObject));
5637	obj->nodesetval = tmpset;
5638	} else
5639	memset(obj, 0, sizeof(xmlXPathObject));
5640
5641	return;
5642
5643	free_obj:
5644	/*
5645	* Cache is full; free the object.
5646	*/
5647	if (obj->nodesetval != NULL)
5648	xmlXPathFreeNodeSet(obj->nodesetval);
5649	#ifdef XP_DEBUG_OBJ_USAGE
5650	xmlXPathDebugObjUsageReleased(NULL, obj->type);
5651	#endif
5652	xmlFree(obj);
5653	}
5654	return;
5655	}
5656
5657
5658	/************************************************************************
5659	* *
5660	* Type Casting Routines *
5661	* *
5662	************************************************************************/
5663
5664	/**
5665	* xmlXPathCastBooleanToString:
5666	* @val: a boolean
5667	*
5668	* Converts a boolean to its string value.
5669	*
5670	* Returns a newly allocated string.
5671	*/
5672	xmlChar *
5673	xmlXPathCastBooleanToString (int val) {
5674	xmlChar *ret;
5675	if (val)
5676	ret = xmlStrdup((const xmlChar *) "true");
5677	else
5678	ret = xmlStrdup((const xmlChar *) "false");
5679	return(ret);
5680	}
5681
5682	/**
5683	* xmlXPathCastNumberToString:
5684	* @val: a number
5685	*
5686	* Converts a number to its string value.
5687	*
5688	* Returns a newly allocated string.
5689	*/
5690	xmlChar *
5691	xmlXPathCastNumberToString (double val) {
5692	xmlChar *ret;
5693	switch (xmlXPathIsInf(val)) {
5694	case 1:
5695	ret = xmlStrdup((const xmlChar *) "Infinity");
5696	break;
5697	case -1:
5698	ret = xmlStrdup((const xmlChar *) "-Infinity");
5699	break;
5700	default:
5701	if (xmlXPathIsNaN(val)) {
5702	ret = xmlStrdup((const xmlChar *) "NaN");
5703	} else if (val == 0 && xmlXPathGetSign(val) != 0) {
5704	ret = xmlStrdup((const xmlChar *) "0");
5705	} else {
5706	/* could be improved */
5707	char buf[100];
5708	xmlXPathFormatNumber(val, buf, 99);
5709	buf[99] = 0;
5710	ret = xmlStrdup((const xmlChar *) buf);
5711	}
5712	}
5713	return(ret);
5714	}
5715
5716	/**
5717	* xmlXPathCastNodeToString:
5718	* @node: a node
5719	*
5720	* Converts a node to its string value.
5721	*
5722	* Returns a newly allocated string.
5723	*/
5724	xmlChar *
5725	xmlXPathCastNodeToString (xmlNodePtr node) {
5726	xmlChar *ret;
5727	if ((ret = xmlNodeGetContent(node)) == NULL)
5728	ret = xmlStrdup((const xmlChar *) "");
5729	return(ret);
5730	}
5731
5732	/**
5733	* xmlXPathCastNodeSetToString:
5734	* @ns: a node-set
5735	*
5736	* Converts a node-set to its string value.
5737	*
5738	* Returns a newly allocated string.
5739	*/
5740	xmlChar *
5741	xmlXPathCastNodeSetToString (xmlNodeSetPtr ns) {
5742	if ((ns == NULL) \|\| (ns->nodeNr == 0) \|\| (ns->nodeTab == NULL))
5743	return(xmlStrdup((const xmlChar *) ""));
5744
5745	if (ns->nodeNr > 1)
5746	xmlXPathNodeSetSort(ns);
5747	return(xmlXPathCastNodeToString(ns->nodeTab[0]));
5748	}
5749
5750	/**
5751	* xmlXPathCastToString:
5752	* @val: an XPath object
5753	*
5754	* Converts an existing object to its string() equivalent
5755	*
5756	* Returns the allocated string value of the object, NULL in case of error.
5757	* It's up to the caller to free the string memory with xmlFree().
5758	*/
5759	xmlChar *
5760	xmlXPathCastToString(xmlXPathObjectPtr val) {
5761	xmlChar *ret = NULL;
5762
5763	if (val == NULL)
5764	return(xmlStrdup((const xmlChar *) ""));
5765	switch (val->type) {
5766	case XPATH_UNDEFINED:
5767	#ifdef DEBUG_EXPR
5768	xmlGenericError(xmlGenericErrorContext, "String: undefined\n");
5769	#endif
5770	ret = xmlStrdup((const xmlChar *) "");
5771	break;
5772	case XPATH_NODESET:
5773	case XPATH_XSLT_TREE:
5774	ret = xmlXPathCastNodeSetToString(val->nodesetval);
5775	break;
5776	case XPATH_STRING:
5777	return(xmlStrdup(val->stringval));
5778	case XPATH_BOOLEAN:
5779	ret = xmlXPathCastBooleanToString(val->boolval);
5780	break;
5781	case XPATH_NUMBER: {
5782	ret = xmlXPathCastNumberToString(val->floatval);
5783	break;
5784	}
5785	case XPATH_USERS:
5786	case XPATH_POINT:
5787	case XPATH_RANGE:
5788	case XPATH_LOCATIONSET:
5789	TODO
5790	ret = xmlStrdup((const xmlChar *) "");
5791	break;
5792	}
5793	return(ret);
5794	}
5795
5796	/**
5797	* xmlXPathConvertString:
5798	* @val: an XPath object
5799	*
5800	* Converts an existing object to its string() equivalent
5801	*
5802	* Returns the new object, the old one is freed (or the operation
5803	* is done directly on @val)
5804	*/
5805	xmlXPathObjectPtr
5806	xmlXPathConvertString(xmlXPathObjectPtr val) {
5807	xmlChar *res = NULL;
5808
5809	if (val == NULL)
5810	return(xmlXPathNewCString(""));
5811
5812	switch (val->type) {
5813	case XPATH_UNDEFINED:
5814	#ifdef DEBUG_EXPR
5815	xmlGenericError(xmlGenericErrorContext, "STRING: undefined\n");
5816	#endif
5817	break;
5818	case XPATH_NODESET:
5819	case XPATH_XSLT_TREE:
5820	res = xmlXPathCastNodeSetToString(val->nodesetval);
5821	break;
5822	case XPATH_STRING:
5823	return(val);
5824	case XPATH_BOOLEAN:
5825	res = xmlXPathCastBooleanToString(val->boolval);
5826	break;
5827	case XPATH_NUMBER:
5828	res = xmlXPathCastNumberToString(val->floatval);
5829	break;
5830	case XPATH_USERS:
5831	case XPATH_POINT:
5832	case XPATH_RANGE:
5833	case XPATH_LOCATIONSET:
5834	TODO;
5835	break;
5836	}
5837	xmlXPathFreeObject(val);
5838	if (res == NULL)
5839	return(xmlXPathNewCString(""));
5840	return(xmlXPathWrapString(res));
5841	}
5842
5843	/**
5844	* xmlXPathCastBooleanToNumber:
5845	* @val: a boolean
5846	*
5847	* Converts a boolean to its number value
5848	*
5849	* Returns the number value
5850	*/
5851	double
5852	xmlXPathCastBooleanToNumber(int val) {
5853	if (val)
5854	return(1.0);
5855	return(0.0);
5856	}
5857
5858	/**
5859	* xmlXPathCastStringToNumber:
5860	* @val: a string
5861	*
5862	* Converts a string to its number value
5863	*
5864	* Returns the number value
5865	*/
5866	double
5867	xmlXPathCastStringToNumber(const xmlChar * val) {
5868	return(xmlXPathStringEvalNumber(val));
5869	}
5870
5871	/**
5872	* xmlXPathCastNodeToNumber:
5873	* @node: a node
5874	*
5875	* Converts a node to its number value
5876	*
5877	* Returns the number value
5878	*/
5879	double
5880	xmlXPathCastNodeToNumber (xmlNodePtr node) {
5881	xmlChar *strval;
5882	double ret;
5883
5884	if (node == NULL)
5885	return(xmlXPathNAN);
5886	strval = xmlXPathCastNodeToString(node);
5887	if (strval == NULL)
5888	return(xmlXPathNAN);
5889	ret = xmlXPathCastStringToNumber(strval);
5890	xmlFree(strval);
5891
5892	return(ret);
5893	}
5894
5895	/**
5896	* xmlXPathCastNodeSetToNumber:
5897	* @ns: a node-set
5898	*
5899	* Converts a node-set to its number value
5900	*
5901	* Returns the number value
5902	*/
5903	double
5904	xmlXPathCastNodeSetToNumber (xmlNodeSetPtr ns) {
5905	xmlChar *str;
5906	double ret;
5907
5908	if (ns == NULL)
5909	return(xmlXPathNAN);
5910	str = xmlXPathCastNodeSetToString(ns);
5911	ret = xmlXPathCastStringToNumber(str);
5912	xmlFree(str);
5913	return(ret);
5914	}
5915
5916	/**
5917	* xmlXPathCastToNumber:
5918	* @val: an XPath object
5919	*
5920	* Converts an XPath object to its number value
5921	*
5922	* Returns the number value
5923	*/
5924	double
5925	xmlXPathCastToNumber(xmlXPathObjectPtr val) {
5926	double ret = 0.0;
5927
5928	if (val == NULL)
5929	return(xmlXPathNAN);
5930	switch (val->type) {
5931	case XPATH_UNDEFINED:
5932	#ifdef DEGUB_EXPR
5933	xmlGenericError(xmlGenericErrorContext, "NUMBER: undefined\n");
5934	#endif
5935	ret = xmlXPathNAN;
5936	break;
5937	case XPATH_NODESET:
5938	case XPATH_XSLT_TREE:
5939	ret = xmlXPathCastNodeSetToNumber(val->nodesetval);
5940	break;
5941	case XPATH_STRING:
5942	ret = xmlXPathCastStringToNumber(val->stringval);
5943	break;
5944	case XPATH_NUMBER:
5945	ret = val->floatval;
5946	break;
5947	case XPATH_BOOLEAN:
5948	ret = xmlXPathCastBooleanToNumber(val->boolval);
5949	break;
5950	case XPATH_USERS:
5951	case XPATH_POINT:
5952	case XPATH_RANGE:
5953	case XPATH_LOCATIONSET:
5954	TODO;
5955	ret = xmlXPathNAN;
5956	break;
5957	}
5958	return(ret);
5959	}
5960
5961	/**
5962	* xmlXPathConvertNumber:
5963	* @val: an XPath object
5964	*
5965	* Converts an existing object to its number() equivalent
5966	*
5967	* Returns the new object, the old one is freed (or the operation
5968	* is done directly on @val)
5969	*/
5970	xmlXPathObjectPtr
5971	xmlXPathConvertNumber(xmlXPathObjectPtr val) {
5972	xmlXPathObjectPtr ret;
5973
5974	if (val == NULL)
5975	return(xmlXPathNewFloat(0.0));
5976	if (val->type == XPATH_NUMBER)
5977	return(val);
5978	ret = xmlXPathNewFloat(xmlXPathCastToNumber(val));
5979	xmlXPathFreeObject(val);
5980	return(ret);
5981	}
5982
5983	/**
5984	* xmlXPathCastNumberToBoolean:
5985	* @val: a number
5986	*
5987	* Converts a number to its boolean value
5988	*
5989	* Returns the boolean value
5990	*/
5991	int
5992	xmlXPathCastNumberToBoolean (double val) {
5993	if (xmlXPathIsNaN(val) \|\| (val == 0.0))
5994	return(0);
5995	return(1);
5996	}
5997
5998	/**
5999	* xmlXPathCastStringToBoolean:
6000	* @val: a string
6001	*
6002	* Converts a string to its boolean value
6003	*
6004	* Returns the boolean value
6005	*/
6006	int
6007	xmlXPathCastStringToBoolean (const xmlChar *val) {
6008	if ((val == NULL) \|\| (xmlStrlen(val) == 0))
6009	return(0);
6010	return(1);
6011	}
6012
6013	/**
6014	* xmlXPathCastNodeSetToBoolean:
6015	* @ns: a node-set
6016	*
6017	* Converts a node-set to its boolean value
6018	*
6019	* Returns the boolean value
6020	*/
6021	int
6022	xmlXPathCastNodeSetToBoolean (xmlNodeSetPtr ns) {
6023	if ((ns == NULL) \|\| (ns->nodeNr == 0))
6024	return(0);
6025	return(1);
6026	}
6027
6028	/**
6029	* xmlXPathCastToBoolean:
6030	* @val: an XPath object
6031	*
6032	* Converts an XPath object to its boolean value
6033	*
6034	* Returns the boolean value
6035	*/
6036	int
6037	xmlXPathCastToBoolean (xmlXPathObjectPtr val) {
6038	int ret = 0;
6039
6040	if (val == NULL)
6041	return(0);
6042	switch (val->type) {
6043	case XPATH_UNDEFINED:
6044	#ifdef DEBUG_EXPR
6045	xmlGenericError(xmlGenericErrorContext, "BOOLEAN: undefined\n");
6046	#endif
6047	ret = 0;
6048	break;
6049	case XPATH_NODESET:
6050	case XPATH_XSLT_TREE:
6051	ret = xmlXPathCastNodeSetToBoolean(val->nodesetval);
6052	break;
6053	case XPATH_STRING:
6054	ret = xmlXPathCastStringToBoolean(val->stringval);
6055	break;
6056	case XPATH_NUMBER:
6057	ret = xmlXPathCastNumberToBoolean(val->floatval);
6058	break;
6059	case XPATH_BOOLEAN:
6060	ret = val->boolval;
6061	break;
6062	case XPATH_USERS:
6063	case XPATH_POINT:
6064	case XPATH_RANGE:
6065	case XPATH_LOCATIONSET:
6066	TODO;
6067	ret = 0;
6068	break;
6069	}
6070	return(ret);
6071	}
6072
6073
6074	/**
6075	* xmlXPathConvertBoolean:
6076	* @val: an XPath object
6077	*
6078	* Converts an existing object to its boolean() equivalent
6079	*
6080	* Returns the new object, the old one is freed (or the operation
6081	* is done directly on @val)
6082	*/
6083	xmlXPathObjectPtr
6084	xmlXPathConvertBoolean(xmlXPathObjectPtr val) {
6085	xmlXPathObjectPtr ret;
6086
6087	if (val == NULL)
6088	return(xmlXPathNewBoolean(0));
6089	if (val->type == XPATH_BOOLEAN)
6090	return(val);
6091	ret = xmlXPathNewBoolean(xmlXPathCastToBoolean(val));
6092	xmlXPathFreeObject(val);
6093	return(ret);
6094	}
6095
6096	/************************************************************************
6097	* *
6098	* Routines to handle XPath contexts *
6099	* *
6100	************************************************************************/
6101
6102	/**
6103	* xmlXPathNewContext:
6104	* @doc: the XML document
6105	*
6106	* Create a new xmlXPathContext
6107	*
6108	* Returns the xmlXPathContext just allocated. The caller will need to free it.
6109	*/
6110	xmlXPathContextPtr
6111	xmlXPathNewContext(xmlDocPtr doc) {
6112	xmlXPathContextPtr ret;
6113
6114	ret = (xmlXPathContextPtr) xmlMalloc(sizeof(xmlXPathContext));
6115	if (ret == NULL) {
6116	xmlXPathErrMemory(NULL, "creating context\n");
6117	return(NULL);
6118	}
6119	memset(ret, 0 , (size_t) sizeof(xmlXPathContext));
6120	ret->doc = doc;
6121	ret->node = NULL;
6122
6123	ret->varHash = NULL;
6124
6125	ret->nb_types = 0;
6126	ret->max_types = 0;
6127	ret->types = NULL;
6128
6129	ret->funcHash = xmlHashCreate(0);
6130
6131	ret->nb_axis = 0;
6132	ret->max_axis = 0;
6133	ret->axis = NULL;
6134
6135	ret->nsHash = NULL;
6136	ret->user = NULL;
6137
6138	ret->contextSize = -1;
6139	ret->proximityPosition = -1;
6140
6141	#ifdef XP_DEFAULT_CACHE_ON
6142	if (xmlXPathContextSetCache(ret, 1, -1, 0) == -1) {
6143	xmlXPathFreeContext(ret);
6144	return(NULL);
6145	}
6146	#endif
6147
6148	xmlXPathRegisterAllFunctions(ret);
6149
6150	return(ret);
6151	}
6152
6153	/**
6154	* xmlXPathFreeContext:
6155	* @ctxt: the context to free
6156	*
6157	* Free up an xmlXPathContext
6158	*/
6159	void
6160	xmlXPathFreeContext(xmlXPathContextPtr ctxt) {
6161	if (ctxt == NULL) return;
6162
6163	if (ctxt->cache != NULL)
6164	xmlXPathFreeCache((xmlXPathContextCachePtr) ctxt->cache);
6165	xmlXPathRegisteredNsCleanup(ctxt);
6166	xmlXPathRegisteredFuncsCleanup(ctxt);
6167	xmlXPathRegisteredVariablesCleanup(ctxt);
6168	xmlResetError(&ctxt->lastError);
6169	xmlFree(ctxt);
6170	}
6171
6172	/************************************************************************
6173	* *
6174	* Routines to handle XPath parser contexts *
6175	* *
6176	************************************************************************/
6177
6178	#define CHECK_CTXT(ctxt) \
6179	if (ctxt == NULL) { \
6180	__xmlRaiseError(NULL, NULL, NULL, \
6181	NULL, NULL, XML_FROM_XPATH, \
6182	XML_ERR_INTERNAL_ERROR, XML_ERR_FATAL, \
6183	__FILE__, __LINE__, \
6184	NULL, NULL, NULL, 0, 0, \
6185	"NULL context pointer\n"); \
6186	return(NULL); \
6187	} \
6188
6189	#define CHECK_CTXT_NEG(ctxt) \
6190	if (ctxt == NULL) { \
6191	__xmlRaiseError(NULL, NULL, NULL, \
6192	NULL, NULL, XML_FROM_XPATH, \
6193	XML_ERR_INTERNAL_ERROR, XML_ERR_FATAL, \
6194	__FILE__, __LINE__, \
6195	NULL, NULL, NULL, 0, 0, \
6196	"NULL context pointer\n"); \
6197	return(-1); \
6198	} \
6199
6200
6201	#define CHECK_CONTEXT(ctxt) \
6202	if ((ctxt == NULL) \|\| (ctxt->doc == NULL) \|\| \
6203	(ctxt->doc->children == NULL)) { \
6204	xmlXPatherror(ctxt, __FILE__, __LINE__, XPATH_INVALID_CTXT); \
6205	return(NULL); \
6206	}
6207
6208
6209	/**
6210	* xmlXPathNewParserContext:
6211	* @str: the XPath expression
6212	* @ctxt: the XPath context
6213	*
6214	* Create a new xmlXPathParserContext
6215	*
6216	* Returns the xmlXPathParserContext just allocated.
6217	*/
6218	xmlXPathParserContextPtr
6219	xmlXPathNewParserContext(const xmlChar *str, xmlXPathContextPtr ctxt) {
6220	xmlXPathParserContextPtr ret;
6221
6222	ret = (xmlXPathParserContextPtr) xmlMalloc(sizeof(xmlXPathParserContext));
6223	if (ret == NULL) {
6224	xmlXPathErrMemory(ctxt, "creating parser context\n");
6225	return(NULL);
6226	}
6227	memset(ret, 0 , (size_t) sizeof(xmlXPathParserContext));
6228	ret->cur = ret->base = str;
6229	ret->context = ctxt;
6230
6231	ret->comp = xmlXPathNewCompExpr();
6232	if (ret->comp == NULL) {
6233	xmlFree(ret->valueTab);
6234	xmlFree(ret);
6235	return(NULL);
6236	}
6237	if ((ctxt != NULL) && (ctxt->dict != NULL)) {
6238	ret->comp->dict = ctxt->dict;
6239	xmlDictReference(ret->comp->dict);
6240	}
6241
6242	return(ret);
6243	}
6244
6245	/**
6246	* xmlXPathCompParserContext:
6247	* @comp: the XPath compiled expression
6248	* @ctxt: the XPath context
6249	*
6250	* Create a new xmlXPathParserContext when processing a compiled expression
6251	*
6252	* Returns the xmlXPathParserContext just allocated.
6253	*/
6254	static xmlXPathParserContextPtr
6255	xmlXPathCompParserContext(xmlXPathCompExprPtr comp, xmlXPathContextPtr ctxt) {
6256	xmlXPathParserContextPtr ret;
6257
6258	ret = (xmlXPathParserContextPtr) xmlMalloc(sizeof(xmlXPathParserContext));
6259	if (ret == NULL) {
6260	xmlXPathErrMemory(ctxt, "creating evaluation context\n");
6261	return(NULL);
6262	}
6263	memset(ret, 0 , (size_t) sizeof(xmlXPathParserContext));
6264
6265	/* Allocate the value stack */
6266	ret->valueTab = (xmlXPathObjectPtr *)
6267	xmlMalloc(10 * sizeof(xmlXPathObjectPtr));
6268	if (ret->valueTab == NULL) {
6269	xmlFree(ret);
6270	xmlXPathErrMemory(ctxt, "creating evaluation context\n");
6271	return(NULL);
6272	}
6273	ret->valueNr = 0;
6274	ret->valueMax = 10;
6275	ret->value = NULL;
6276	ret->valueFrame = 0;
6277
6278	ret->context = ctxt;
6279	ret->comp = comp;
6280
6281	return(ret);
6282	}
6283
6284	/**
6285	* xmlXPathFreeParserContext:
6286	* @ctxt: the context to free
6287	*
6288	* Free up an xmlXPathParserContext
6289	*/
6290	void
6291	xmlXPathFreeParserContext(xmlXPathParserContextPtr ctxt) {
6292	if (ctxt->valueTab != NULL) {
6293	xmlFree(ctxt->valueTab);
6294	}
6295	if (ctxt->comp != NULL) {
6296	#ifdef XPATH_STREAMING
6297	if (ctxt->comp->stream != NULL) {
6298	xmlFreePatternList(ctxt->comp->stream);
6299	ctxt->comp->stream = NULL;
6300	}
6301	#endif
6302	xmlXPathFreeCompExpr(ctxt->comp);
6303	}
6304	xmlFree(ctxt);
6305	}
6306
6307	/************************************************************************
6308	* *
6309	* The implicit core function library *
6310	* *
6311	************************************************************************/
6312
6313	/**
6314	* xmlXPathNodeValHash:
6315	* @node: a node pointer
6316	*
6317	* Function computing the beginning of the string value of the node,
6318	* used to speed up comparisons
6319	*
6320	* Returns an int usable as a hash
6321	*/
6322	static unsigned int
6323	xmlXPathNodeValHash(xmlNodePtr node) {
6324	int len = 2;
6325	const xmlChar * string = NULL;
6326	xmlNodePtr tmp = NULL;
6327	unsigned int ret = 0;
6328
6329	if (node == NULL)
6330	return(0);
6331
6332	if (node->type == XML_DOCUMENT_NODE) {
6333	tmp = xmlDocGetRootElement((xmlDocPtr) node);
6334	if (tmp == NULL)
6335	node = node->children;
6336	else
6337	node = tmp;
6338
6339	if (node == NULL)
6340	return(0);
6341	}
6342
6343	switch (node->type) {
6344	case XML_COMMENT_NODE:
6345	case XML_PI_NODE:
6346	case XML_CDATA_SECTION_NODE:
6347	case XML_TEXT_NODE:
6348	string = node->content;
6349	if (string == NULL)
6350	return(0);
6351	if (string[0] == 0)
6352	return(0);
6353	return(((unsigned int) string[0]) +
6354	(((unsigned int) string[1]) << 8));
6355	case XML_NAMESPACE_DECL:
6356	string = ((xmlNsPtr)node)->href;
6357	if (string == NULL)
6358	return(0);
6359	if (string[0] == 0)
6360	return(0);
6361	return(((unsigned int) string[0]) +
6362	(((unsigned int) string[1]) << 8));
6363	case XML_ATTRIBUTE_NODE:
6364	tmp = ((xmlAttrPtr) node)->children;
6365	break;
6366	case XML_ELEMENT_NODE:
6367	tmp = node->children;
6368	break;
6369	default:
6370	return(0);
6371	}
6372	while (tmp != NULL) {
6373	switch (tmp->type) {
6374	case XML_COMMENT_NODE:
6375	case XML_PI_NODE:
6376	case XML_CDATA_SECTION_NODE:
6377	case XML_TEXT_NODE:
6378	string = tmp->content;
6379	break;
6380	case XML_NAMESPACE_DECL:
6381	string = ((xmlNsPtr)tmp)->href;
6382	break;
6383	default:
6384	break;
6385	}
6386	if ((string != NULL) && (string[0] != 0)) {
6387	if (len == 1) {
6388	return(ret + (((unsigned int) string[0]) << 8));
6389	}
6390	if (string[1] == 0) {
6391	len = 1;
6392	ret = (unsigned int) string[0];
6393	} else {
6394	return(((unsigned int) string[0]) +
6395	(((unsigned int) string[1]) << 8));
6396	}
6397	}
6398	/*
6399	* Skip to next node
6400	*/
6401	if ((tmp->children != NULL) && (tmp->type != XML_DTD_NODE)) {
6402	if (tmp->children->type != XML_ENTITY_DECL) {
6403	tmp = tmp->children;
6404	continue;
6405	}
6406	}
6407	if (tmp == node)
6408	break;
6409
6410	if (tmp->next != NULL) {
6411	tmp = tmp->next;
6412	continue;
6413	}
6414
6415	do {
6416	tmp = tmp->parent;
6417	if (tmp == NULL)
6418	break;
6419	if (tmp == node) {
6420	tmp = NULL;
6421	break;
6422	}
6423	if (tmp->next != NULL) {
6424	tmp = tmp->next;
6425	break;
6426	}
6427	} while (tmp != NULL);
6428	}
6429	return(ret);
6430	}
6431
6432	/**
6433	* xmlXPathStringHash:
6434	* @string: a string
6435	*
6436	* Function computing the beginning of the string value of the node,
6437	* used to speed up comparisons
6438	*
6439	* Returns an int usable as a hash
6440	*/
6441	static unsigned int
6442	xmlXPathStringHash(const xmlChar * string) {
6443	if (string == NULL)
6444	return((unsigned int) 0);
6445	if (string[0] == 0)
6446	return(0);
6447	return(((unsigned int) string[0]) +
6448	(((unsigned int) string[1]) << 8));
6449	}
6450
6451	/**
6452	* xmlXPathCompareNodeSetFloat:
6453	* @ctxt: the XPath Parser context
6454	* @inf: less than (1) or greater than (0)
6455	* @strict: is the comparison strict
6456	* @arg: the node set
6457	* @f: the value
6458	*
6459	* Implement the compare operation between a nodeset and a number
6460	* @ns < @val (1, 1, ...
6461	* @ns <= @val (1, 0, ...
6462	* @ns > @val (0, 1, ...
6463	* @ns >= @val (0, 0, ...
6464	*
6465	* If one object to be compared is a node-set and the other is a number,
6466	* then the comparison will be true if and only if there is a node in the
6467	* node-set such that the result of performing the comparison on the number
6468	* to be compared and on the result of converting the string-value of that
6469	* node to a number using the number function is true.
6470	*
6471	* Returns 0 or 1 depending on the results of the test.
6472	*/
6473	static int
6474	xmlXPathCompareNodeSetFloat(xmlXPathParserContextPtr ctxt, int inf, int strict,
6475	xmlXPathObjectPtr arg, xmlXPathObjectPtr f) {
6476	int i, ret = 0;
6477	xmlNodeSetPtr ns;
6478	xmlChar *str2;
6479
6480	if ((f == NULL) \|\| (arg == NULL) \|\|
6481	((arg->type != XPATH_NODESET) && (arg->type != XPATH_XSLT_TREE))) {
6482	xmlXPathReleaseObject(ctxt->context, arg);
6483	xmlXPathReleaseObject(ctxt->context, f);
6484	return(0);
6485	}
6486	ns = arg->nodesetval;
6487	if (ns != NULL) {
6488	for (i = 0;i < ns->nodeNr;i++) {
6489	str2 = xmlXPathCastNodeToString(ns->nodeTab[i]);
6490	if (str2 != NULL) {
6491	valuePush(ctxt,
6492	xmlXPathCacheNewString(ctxt->context, str2));
6493	xmlFree(str2);
6494	xmlXPathNumberFunction(ctxt, 1);
6495	valuePush(ctxt, xmlXPathCacheObjectCopy(ctxt->context, f));
6496	ret = xmlXPathCompareValues(ctxt, inf, strict);
6497	if (ret)
6498	break;
6499	}
6500	}
6501	}
6502	xmlXPathReleaseObject(ctxt->context, arg);
6503	xmlXPathReleaseObject(ctxt->context, f);
6504	return(ret);
6505	}
6506
6507	/**
6508	* xmlXPathCompareNodeSetString:
6509	* @ctxt: the XPath Parser context
6510	* @inf: less than (1) or greater than (0)
6511	* @strict: is the comparison strict
6512	* @arg: the node set
6513	* @s: the value
6514	*
6515	* Implement the compare operation between a nodeset and a string
6516	* @ns < @val (1, 1, ...
6517	* @ns <= @val (1, 0, ...
6518	* @ns > @val (0, 1, ...
6519	* @ns >= @val (0, 0, ...
6520	*
6521	* If one object to be compared is a node-set and the other is a string,
6522	* then the comparison will be true if and only if there is a node in
6523	* the node-set such that the result of performing the comparison on the
6524	* string-value of the node and the other string is true.
6525	*
6526	* Returns 0 or 1 depending on the results of the test.
6527	*/
6528	static int
6529	xmlXPathCompareNodeSetString(xmlXPathParserContextPtr ctxt, int inf, int strict,
6530	xmlXPathObjectPtr arg, xmlXPathObjectPtr s) {
6531	int i, ret = 0;
6532	xmlNodeSetPtr ns;
6533	xmlChar *str2;
6534
6535	if ((s == NULL) \|\| (arg == NULL) \|\|
6536	((arg->type != XPATH_NODESET) && (arg->type != XPATH_XSLT_TREE))) {
6537	xmlXPathReleaseObject(ctxt->context, arg);
6538	xmlXPathReleaseObject(ctxt->context, s);
6539	return(0);
6540	}
6541	ns = arg->nodesetval;
6542	if (ns != NULL) {
6543	for (i = 0;i < ns->nodeNr;i++) {
6544	str2 = xmlXPathCastNodeToString(ns->nodeTab[i]);
6545	if (str2 != NULL) {
6546	valuePush(ctxt,
6547	xmlXPathCacheNewString(ctxt->context, str2));
6548	xmlFree(str2);
6549	valuePush(ctxt, xmlXPathCacheObjectCopy(ctxt->context, s));
6550	ret = xmlXPathCompareValues(ctxt, inf, strict);
6551	if (ret)
6552	break;
6553	}
6554	}
6555	}
6556	xmlXPathReleaseObject(ctxt->context, arg);
6557	xmlXPathReleaseObject(ctxt->context, s);
6558	return(ret);
6559	}
6560
6561	/**
6562	* xmlXPathCompareNodeSets:
6563	* @inf: less than (1) or greater than (0)
6564	* @strict: is the comparison strict
6565	* @arg1: the first node set object
6566	* @arg2: the second node set object
6567	*
6568	* Implement the compare operation on nodesets:
6569	*
6570	* If both objects to be compared are node-sets, then the comparison
6571	* will be true if and only if there is a node in the first node-set
6572	* and a node in the second node-set such that the result of performing
6573	* the comparison on the string-values of the two nodes is true.
6574	* ....
6575	* When neither object to be compared is a node-set and the operator
6576	* is <=, <, >= or >, then the objects are compared by converting both
6577	* objects to numbers and comparing the numbers according to IEEE 754.
6578	* ....
6579	* The number function converts its argument to a number as follows:
6580	* - a string that consists of optional whitespace followed by an
6581	* optional minus sign followed by a Number followed by whitespace
6582	* is converted to the IEEE 754 number that is nearest (according
6583	* to the IEEE 754 round-to-nearest rule) to the mathematical value
6584	* represented by the string; any other string is converted to NaN
6585	*
6586	* Conclusion all nodes need to be converted first to their string value
6587	* and then the comparison must be done when possible
6588	*/
6589	static int
6590	xmlXPathCompareNodeSets(int inf, int strict,
6591	xmlXPathObjectPtr arg1, xmlXPathObjectPtr arg2) {
6592	int i, j, init = 0;
6593	double val1;
6594	double *values2;
6595	int ret = 0;
6596	xmlNodeSetPtr ns1;
6597	xmlNodeSetPtr ns2;
6598
6599	if ((arg1 == NULL) \|\|
6600	((arg1->type != XPATH_NODESET) && (arg1->type != XPATH_XSLT_TREE))) {
6601	xmlXPathFreeObject(arg2);
6602	return(0);
6603	}
6604	if ((arg2 == NULL) \|\|
6605	((arg2->type != XPATH_NODESET) && (arg2->type != XPATH_XSLT_TREE))) {
6606	xmlXPathFreeObject(arg1);
6607	xmlXPathFreeObject(arg2);
6608	return(0);
6609	}
6610
6611	ns1 = arg1->nodesetval;
6612	ns2 = arg2->nodesetval;
6613
6614	if ((ns1 == NULL) \|\| (ns1->nodeNr <= 0)) {
6615	xmlXPathFreeObject(arg1);
6616	xmlXPathFreeObject(arg2);
6617	return(0);
6618	}
6619	if ((ns2 == NULL) \|\| (ns2->nodeNr <= 0)) {
6620	xmlXPathFreeObject(arg1);
6621	xmlXPathFreeObject(arg2);
6622	return(0);
6623	}
6624
6625	values2 = (double ) xmlMalloc(ns2->nodeNr sizeof(double));
6626	if (values2 == NULL) {
6627	xmlXPathErrMemory(NULL, "comparing nodesets\n");
6628	xmlXPathFreeObject(arg1);
6629	xmlXPathFreeObject(arg2);
6630	return(0);
6631	}
6632	for (i = 0;i < ns1->nodeNr;i++) {
6633	val1 = xmlXPathCastNodeToNumber(ns1->nodeTab[i]);
6634	if (xmlXPathIsNaN(val1))
6635	continue;
6636	for (j = 0;j < ns2->nodeNr;j++) {
6637	if (init == 0) {
6638	values2[j] = xmlXPathCastNodeToNumber(ns2->nodeTab[j]);
6639	}
6640	if (xmlXPathIsNaN(values2[j]))
6641	continue;
6642	if (inf && strict)
6643	ret = (val1 < values2[j]);
6644	else if (inf && !strict)
6645	ret = (val1 <= values2[j]);
6646	else if (!inf && strict)
6647	ret = (val1 > values2[j]);
6648	else if (!inf && !strict)
6649	ret = (val1 >= values2[j]);
6650	if (ret)
6651	break;
6652	}
6653	if (ret)
6654	break;
6655	init = 1;
6656	}
6657	xmlFree(values2);
6658	xmlXPathFreeObject(arg1);
6659	xmlXPathFreeObject(arg2);
6660	return(ret);
6661	}
6662
6663	/**
6664	* xmlXPathCompareNodeSetValue:
6665	* @ctxt: the XPath Parser context
6666	* @inf: less than (1) or greater than (0)
6667	* @strict: is the comparison strict
6668	* @arg: the node set
6669	* @val: the value
6670	*
6671	* Implement the compare operation between a nodeset and a value
6672	* @ns < @val (1, 1, ...
6673	* @ns <= @val (1, 0, ...
6674	* @ns > @val (0, 1, ...
6675	* @ns >= @val (0, 0, ...
6676	*
6677	* If one object to be compared is a node-set and the other is a boolean,
6678	* then the comparison will be true if and only if the result of performing
6679	* the comparison on the boolean and on the result of converting
6680	* the node-set to a boolean using the boolean function is true.
6681	*
6682	* Returns 0 or 1 depending on the results of the test.
6683	*/
6684	static int
6685	xmlXPathCompareNodeSetValue(xmlXPathParserContextPtr ctxt, int inf, int strict,
6686	xmlXPathObjectPtr arg, xmlXPathObjectPtr val) {
6687	if ((val == NULL) \|\| (arg == NULL) \|\|
6688	((arg->type != XPATH_NODESET) && (arg->type != XPATH_XSLT_TREE)))
6689	return(0);
6690
6691	switch(val->type) {
6692	case XPATH_NUMBER:
6693	return(xmlXPathCompareNodeSetFloat(ctxt, inf, strict, arg, val));
6694	case XPATH_NODESET:
6695	case XPATH_XSLT_TREE:
6696	return(xmlXPathCompareNodeSets(inf, strict, arg, val));
6697	case XPATH_STRING:
6698	return(xmlXPathCompareNodeSetString(ctxt, inf, strict, arg, val));
6699	case XPATH_BOOLEAN:
6700	valuePush(ctxt, arg);
6701	xmlXPathBooleanFunction(ctxt, 1);
6702	valuePush(ctxt, val);
6703	return(xmlXPathCompareValues(ctxt, inf, strict));
6704	default:
6705	TODO
6706	}
6707	return(0);
6708	}
6709
6710	/**
6711	* xmlXPathEqualNodeSetString:
6712	* @arg: the nodeset object argument
6713	* @str: the string to compare to.
6714	* @neq: flag to show whether for '=' (0) or '!=' (1)
6715	*
6716	* Implement the equal operation on XPath objects content: @arg1 == @arg2
6717	* If one object to be compared is a node-set and the other is a string,
6718	* then the comparison will be true if and only if there is a node in
6719	* the node-set such that the result of performing the comparison on the
6720	* string-value of the node and the other string is true.
6721	*
6722	* Returns 0 or 1 depending on the results of the test.
6723	*/
6724	static int
6725	xmlXPathEqualNodeSetString(xmlXPathObjectPtr arg, const xmlChar * str, int neq)
6726	{
6727	int i;
6728	xmlNodeSetPtr ns;
6729	xmlChar *str2;
6730	unsigned int hash;
6731
6732	if ((str == NULL) \|\| (arg == NULL) \|\|
6733	((arg->type != XPATH_NODESET) && (arg->type != XPATH_XSLT_TREE)))
6734	return (0);
6735	ns = arg->nodesetval;
6736	/*
6737	* A NULL nodeset compared with a string is always false
6738	* (since there is no node equal, and no node not equal)
6739	*/
6740	if ((ns == NULL) \|\| (ns->nodeNr <= 0) )
6741	return (0);
6742	hash = xmlXPathStringHash(str);
6743	for (i = 0; i < ns->nodeNr; i++) {
6744	if (xmlXPathNodeValHash(ns->nodeTab[i]) == hash) {
6745	str2 = xmlNodeGetContent(ns->nodeTab[i]);
6746	if ((str2 != NULL) && (xmlStrEqual(str, str2))) {
6747	xmlFree(str2);
6748	if (neq)
6749	continue;
6750	return (1);
6751	} else if ((str2 == NULL) && (xmlStrEqual(str, BAD_CAST ""))) {
6752	if (neq)
6753	continue;
6754	return (1);
6755	} else if (neq) {
6756	if (str2 != NULL)
6757	xmlFree(str2);
6758	return (1);
6759	}
6760	if (str2 != NULL)
6761	xmlFree(str2);
6762	} else if (neq)
6763	return (1);
6764	}
6765	return (0);
6766	}
6767
6768	/**
6769	* xmlXPathEqualNodeSetFloat:
6770	* @arg: the nodeset object argument
6771	* @f: the float to compare to
6772	* @neq: flag to show whether to compare '=' (0) or '!=' (1)
6773	*
6774	* Implement the equal operation on XPath objects content: @arg1 == @arg2
6775	* If one object to be compared is a node-set and the other is a number,
6776	* then the comparison will be true if and only if there is a node in
6777	* the node-set such that the result of performing the comparison on the
6778	* number to be compared and on the result of converting the string-value
6779	* of that node to a number using the number function is true.
6780	*
6781	* Returns 0 or 1 depending on the results of the test.
6782	*/
6783	static int
6784	xmlXPathEqualNodeSetFloat(xmlXPathParserContextPtr ctxt,
6785	xmlXPathObjectPtr arg, double f, int neq) {
6786	int i, ret=0;
6787	xmlNodeSetPtr ns;
6788	xmlChar *str2;
6789	xmlXPathObjectPtr val;
6790	double v;
6791
6792	if ((arg == NULL) \|\|
6793	((arg->type != XPATH_NODESET) && (arg->type != XPATH_XSLT_TREE)))
6794	return(0);
6795
6796	ns = arg->nodesetval;
6797	if (ns != NULL) {
6798	for (i=0;i<ns->nodeNr;i++) {
6799	str2 = xmlXPathCastNodeToString(ns->nodeTab[i]);
6800	if (str2 != NULL) {
6801	valuePush(ctxt, xmlXPathCacheNewString(ctxt->context, str2));
6802	xmlFree(str2);
6803	xmlXPathNumberFunction(ctxt, 1);
6804	val = valuePop(ctxt);
6805	v = val->floatval;
6806	xmlXPathReleaseObject(ctxt->context, val);
6807	if (!xmlXPathIsNaN(v)) {
6808	if ((!neq) && (v==f)) {
6809	ret = 1;
6810	break;
6811	} else if ((neq) && (v!=f)) {
6812	ret = 1;
6813	break;
6814	}
6815	} else { /* NaN is unequal to any value */
6816	if (neq)
6817	ret = 1;
6818	}
6819	}
6820	}
6821	}
6822
6823	return(ret);
6824	}
6825
6826
6827	/**
6828	* xmlXPathEqualNodeSets:
6829	* @arg1: first nodeset object argument
6830	* @arg2: second nodeset object argument
6831	* @neq: flag to show whether to test '=' (0) or '!=' (1)
6832	*
6833	* Implement the equal / not equal operation on XPath nodesets:
6834	* @arg1 == @arg2 or @arg1 != @arg2
6835	* If both objects to be compared are node-sets, then the comparison
6836	* will be true if and only if there is a node in the first node-set and
6837	* a node in the second node-set such that the result of performing the
6838	* comparison on the string-values of the two nodes is true.
6839	*
6840	* (needless to say, this is a costly operation)
6841	*
6842	* Returns 0 or 1 depending on the results of the test.
6843	*/
6844	static int
6845	xmlXPathEqualNodeSets(xmlXPathObjectPtr arg1, xmlXPathObjectPtr arg2, int neq) {
6846	int i, j;
6847	unsigned int *hashs1;
6848	unsigned int *hashs2;
6849	xmlChar **values1;
6850	xmlChar **values2;
6851	int ret = 0;
6852	xmlNodeSetPtr ns1;
6853	xmlNodeSetPtr ns2;
6854
6855	if ((arg1 == NULL) \|\|
6856	((arg1->type != XPATH_NODESET) && (arg1->type != XPATH_XSLT_TREE)))
6857	return(0);
6858	if ((arg2 == NULL) \|\|
6859	((arg2->type != XPATH_NODESET) && (arg2->type != XPATH_XSLT_TREE)))
6860	return(0);
6861
6862	ns1 = arg1->nodesetval;
6863	ns2 = arg2->nodesetval;
6864
6865	if ((ns1 == NULL) \|\| (ns1->nodeNr <= 0))
6866	return(0);
6867	if ((ns2 == NULL) \|\| (ns2->nodeNr <= 0))
6868	return(0);
6869
6870	/*
6871	* for equal, check if there is a node pertaining to both sets
6872	*/
6873	if (neq == 0)
6874	for (i = 0;i < ns1->nodeNr;i++)
6875	for (j = 0;j < ns2->nodeNr;j++)
6876	if (ns1->nodeTab[i] == ns2->nodeTab[j])
6877	return(1);
6878
6879	values1 = (xmlChar *) xmlMalloc(ns1->nodeNr sizeof(xmlChar *));
6880	if (values1 == NULL) {
6881	xmlXPathErrMemory(NULL, "comparing nodesets\n");
6882	return(0);
6883	}
6884	hashs1 = (unsigned int ) xmlMalloc(ns1->nodeNr sizeof(unsigned int));
6885	if (hashs1 == NULL) {
6886	xmlXPathErrMemory(NULL, "comparing nodesets\n");
6887	xmlFree(values1);
6888	return(0);
6889	}
6890	memset(values1, 0, ns1->nodeNr * sizeof(xmlChar *));
6891	values2 = (xmlChar *) xmlMalloc(ns2->nodeNr sizeof(xmlChar *));
6892	if (values2 == NULL) {
6893	xmlXPathErrMemory(NULL, "comparing nodesets\n");
6894	xmlFree(hashs1);
6895	xmlFree(values1);
6896	return(0);
6897	}
6898	hashs2 = (unsigned int ) xmlMalloc(ns2->nodeNr sizeof(unsigned int));
6899	if (hashs2 == NULL) {
6900	xmlXPathErrMemory(NULL, "comparing nodesets\n");
6901	xmlFree(hashs1);
6902	xmlFree(values1);
6903	xmlFree(values2);
6904	return(0);
6905	}
6906	memset(values2, 0, ns2->nodeNr * sizeof(xmlChar *));
6907	for (i = 0;i < ns1->nodeNr;i++) {
6908	hashs1[i] = xmlXPathNodeValHash(ns1->nodeTab[i]);
6909	for (j = 0;j < ns2->nodeNr;j++) {
6910	if (i == 0)
6911	hashs2[j] = xmlXPathNodeValHash(ns2->nodeTab[j]);
6912	if (hashs1[i] != hashs2[j]) {
6913	if (neq) {
6914	ret = 1;
6915	break;
6916	}
6917	}
6918	else {
6919	if (values1[i] == NULL)
6920	values1[i] = xmlNodeGetContent(ns1->nodeTab[i]);
6921	if (values2[j] == NULL)
6922	values2[j] = xmlNodeGetContent(ns2->nodeTab[j]);
6923	ret = xmlStrEqual(values1[i], values2[j]) ^ neq;
6924	if (ret)
6925	break;
6926	}
6927	}
6928	if (ret)
6929	break;
6930	}
6931	for (i = 0;i < ns1->nodeNr;i++)
6932	if (values1[i] != NULL)
6933	xmlFree(values1[i]);
6934	for (j = 0;j < ns2->nodeNr;j++)
6935	if (values2[j] != NULL)
6936	xmlFree(values2[j]);
6937	xmlFree(values1);
6938	xmlFree(values2);
6939	xmlFree(hashs1);
6940	xmlFree(hashs2);
6941	return(ret);
6942	}
6943
6944	static int
6945	xmlXPathEqualValuesCommon(xmlXPathParserContextPtr ctxt,
6946	xmlXPathObjectPtr arg1, xmlXPathObjectPtr arg2) {
6947	int ret = 0;
6948	/*
6949	*At this point we are assured neither arg1 nor arg2
6950	*is a nodeset, so we can just pick the appropriate routine.
6951	*/
6952	switch (arg1->type) {
6953	case XPATH_UNDEFINED:
6954	#ifdef DEBUG_EXPR
6955	xmlGenericError(xmlGenericErrorContext,
6956	"Equal: undefined\n");
6957	#endif
6958	break;
6959	case XPATH_BOOLEAN:
6960	switch (arg2->type) {
6961	case XPATH_UNDEFINED:
6962	#ifdef DEBUG_EXPR
6963	xmlGenericError(xmlGenericErrorContext,
6964	"Equal: undefined\n");
6965	#endif
6966	break;
6967	case XPATH_BOOLEAN:
6968	#ifdef DEBUG_EXPR
6969	xmlGenericError(xmlGenericErrorContext,
6970	"Equal: %d boolean %d \n",
6971	arg1->boolval, arg2->boolval);
6972	#endif
6973	ret = (arg1->boolval == arg2->boolval);
6974	break;
6975	case XPATH_NUMBER:
6976	ret = (arg1->boolval ==
6977	xmlXPathCastNumberToBoolean(arg2->floatval));
6978	break;
6979	case XPATH_STRING:
6980	if ((arg2->stringval == NULL) \|\|
6981	(arg2->stringval[0] == 0)) ret = 0;
6982	else
6983	ret = 1;
6984	ret = (arg1->boolval == ret);
6985	break;
6986	case XPATH_USERS:
6987	case XPATH_POINT:
6988	case XPATH_RANGE:
6989	case XPATH_LOCATIONSET:
6990	TODO
6991	break;
6992	case XPATH_NODESET:
6993	case XPATH_XSLT_TREE:
6994	break;
6995	}
6996	break;
6997	case XPATH_NUMBER:
6998	switch (arg2->type) {
6999	case XPATH_UNDEFINED:
7000	#ifdef DEBUG_EXPR
7001	xmlGenericError(xmlGenericErrorContext,
7002	"Equal: undefined\n");
7003	#endif
7004	break;
7005	case XPATH_BOOLEAN:
7006	ret = (arg2->boolval==
7007	xmlXPathCastNumberToBoolean(arg1->floatval));
7008	break;
7009	case XPATH_STRING:
7010	valuePush(ctxt, arg2);
7011	xmlXPathNumberFunction(ctxt, 1);
7012	arg2 = valuePop(ctxt);
7013	/* no break on purpose */
7014	case XPATH_NUMBER:
7015	/* Hand check NaN and Infinity equalities */
7016	if (xmlXPathIsNaN(arg1->floatval) \|\|
7017	xmlXPathIsNaN(arg2->floatval)) {
7018	ret = 0;
7019	} else if (xmlXPathIsInf(arg1->floatval) == 1) {
7020	if (xmlXPathIsInf(arg2->floatval) == 1)
7021	ret = 1;
7022	else
7023	ret = 0;
7024	} else if (xmlXPathIsInf(arg1->floatval) == -1) {
7025	if (xmlXPathIsInf(arg2->floatval) == -1)
7026	ret = 1;
7027	else
7028	ret = 0;
7029	} else if (xmlXPathIsInf(arg2->floatval) == 1) {
7030	if (xmlXPathIsInf(arg1->floatval) == 1)
7031	ret = 1;
7032	else
7033	ret = 0;
7034	} else if (xmlXPathIsInf(arg2->floatval) == -1) {
7035	if (xmlXPathIsInf(arg1->floatval) == -1)
7036	ret = 1;
7037	else
7038	ret = 0;
7039	} else {
7040	ret = (arg1->floatval == arg2->floatval);
7041	}
7042	break;
7043	case XPATH_USERS:
7044	case XPATH_POINT:
7045	case XPATH_RANGE:
7046	case XPATH_LOCATIONSET:
7047	TODO
7048	break;
7049	case XPATH_NODESET:
7050	case XPATH_XSLT_TREE:
7051	break;
7052	}
7053	break;
7054	case XPATH_STRING:
7055	switch (arg2->type) {
7056	case XPATH_UNDEFINED:
7057	#ifdef DEBUG_EXPR
7058	xmlGenericError(xmlGenericErrorContext,
7059	"Equal: undefined\n");
7060	#endif
7061	break;
7062	case XPATH_BOOLEAN:
7063	if ((arg1->stringval == NULL) \|\|
7064	(arg1->stringval[0] == 0)) ret = 0;
7065	else
7066	ret = 1;
7067	ret = (arg2->boolval == ret);
7068	break;
7069	case XPATH_STRING:
7070	ret = xmlStrEqual(arg1->stringval, arg2->stringval);
7071	break;
7072	case XPATH_NUMBER:
7073	valuePush(ctxt, arg1);
7074	xmlXPathNumberFunction(ctxt, 1);
7075	arg1 = valuePop(ctxt);
7076	/* Hand check NaN and Infinity equalities */
7077	if (xmlXPathIsNaN(arg1->floatval) \|\|
7078	xmlXPathIsNaN(arg2->floatval)) {
7079	ret = 0;
7080	} else if (xmlXPathIsInf(arg1->floatval) == 1) {
7081	if (xmlXPathIsInf(arg2->floatval) == 1)
7082	ret = 1;
7083	else
7084	ret = 0;
7085	} else if (xmlXPathIsInf(arg1->floatval) == -1) {
7086	if (xmlXPathIsInf(arg2->floatval) == -1)
7087	ret = 1;
7088	else
7089	ret = 0;
7090	} else if (xmlXPathIsInf(arg2->floatval) == 1) {
7091	if (xmlXPathIsInf(arg1->floatval) == 1)
7092	ret = 1;
7093	else
7094	ret = 0;
7095	} else if (xmlXPathIsInf(arg2->floatval) == -1) {
7096	if (xmlXPathIsInf(arg1->floatval) == -1)
7097	ret = 1;
7098	else
7099	ret = 0;
7100	} else {
7101	ret = (arg1->floatval == arg2->floatval);
7102	}
7103	break;
7104	case XPATH_USERS:
7105	case XPATH_POINT:
7106	case XPATH_RANGE:
7107	case XPATH_LOCATIONSET:
7108	TODO
7109	break;
7110	case XPATH_NODESET:
7111	case XPATH_XSLT_TREE:
7112	break;
7113	}
7114	break;
7115	case XPATH_USERS:
7116	case XPATH_POINT:
7117	case XPATH_RANGE:
7118	case XPATH_LOCATIONSET:
7119	TODO
7120	break;
7121	case XPATH_NODESET:
7122	case XPATH_XSLT_TREE:
7123	break;
7124	}
7125	xmlXPathReleaseObject(ctxt->context, arg1);
7126	xmlXPathReleaseObject(ctxt->context, arg2);
7127	return(ret);
7128	}
7129
7130	/**
7131	* xmlXPathEqualValues:
7132	* @ctxt: the XPath Parser context
7133	*
7134	* Implement the equal operation on XPath objects content: @arg1 == @arg2
7135	*
7136	* Returns 0 or 1 depending on the results of the test.
7137	*/
7138	int
7139	xmlXPathEqualValues(xmlXPathParserContextPtr ctxt) {
7140	xmlXPathObjectPtr arg1, arg2, argtmp;
7141	int ret = 0;
7142
7143	if ((ctxt == NULL) \|\| (ctxt->context == NULL)) return(0);
7144	arg2 = valuePop(ctxt);
7145	arg1 = valuePop(ctxt);
7146	if ((arg1 == NULL) \|\| (arg2 == NULL)) {
7147	if (arg1 != NULL)
7148	xmlXPathReleaseObject(ctxt->context, arg1);
7149	else
7150	xmlXPathReleaseObject(ctxt->context, arg2);
7151	XP_ERROR0(XPATH_INVALID_OPERAND);
7152	}
7153
7154	if (arg1 == arg2) {
7155	#ifdef DEBUG_EXPR
7156	xmlGenericError(xmlGenericErrorContext,
7157	"Equal: by pointer\n");
7158	#endif
7159	xmlXPathFreeObject(arg1);
7160	return(1);
7161	}
7162
7163	/*
7164	*If either argument is a nodeset, it's a 'special case'
7165	*/
7166	if ((arg2->type == XPATH_NODESET) \|\| (arg2->type == XPATH_XSLT_TREE) \|\|
7167	(arg1->type == XPATH_NODESET) \|\| (arg1->type == XPATH_XSLT_TREE)) {
7168	/*
7169	*Hack it to assure arg1 is the nodeset
7170	*/
7171	if ((arg1->type != XPATH_NODESET) && (arg1->type != XPATH_XSLT_TREE)) {
7172	argtmp = arg2;
7173	arg2 = arg1;
7174	arg1 = argtmp;
7175	}
7176	switch (arg2->type) {
7177	case XPATH_UNDEFINED:
7178	#ifdef DEBUG_EXPR
7179	xmlGenericError(xmlGenericErrorContext,
7180	"Equal: undefined\n");
7181	#endif
7182	break;
7183	case XPATH_NODESET:
7184	case XPATH_XSLT_TREE:
7185	ret = xmlXPathEqualNodeSets(arg1, arg2, 0);
7186	break;
7187	case XPATH_BOOLEAN:
7188	if ((arg1->nodesetval == NULL) \|\|
7189	(arg1->nodesetval->nodeNr == 0)) ret = 0;
7190	else
7191	ret = 1;
7192	ret = (ret == arg2->boolval);
7193	break;
7194	case XPATH_NUMBER:
7195	ret = xmlXPathEqualNodeSetFloat(ctxt, arg1, arg2->floatval, 0);
7196	break;
7197	case XPATH_STRING:
7198	ret = xmlXPathEqualNodeSetString(arg1, arg2->stringval, 0);
7199	break;
7200	case XPATH_USERS:
7201	case XPATH_POINT:
7202	case XPATH_RANGE:
7203	case XPATH_LOCATIONSET:
7204	TODO
7205	break;
7206	}
7207	xmlXPathReleaseObject(ctxt->context, arg1);
7208	xmlXPathReleaseObject(ctxt->context, arg2);
7209	return(ret);
7210	}
7211
7212	return (xmlXPathEqualValuesCommon(ctxt, arg1, arg2));
7213	}
7214
7215	/**
7216	* xmlXPathNotEqualValues:
7217	* @ctxt: the XPath Parser context
7218	*
7219	* Implement the equal operation on XPath objects content: @arg1 == @arg2
7220	*
7221	* Returns 0 or 1 depending on the results of the test.
7222	*/
7223	int
7224	xmlXPathNotEqualValues(xmlXPathParserContextPtr ctxt) {
7225	xmlXPathObjectPtr arg1, arg2, argtmp;
7226	int ret = 0;
7227
7228	if ((ctxt == NULL) \|\| (ctxt->context == NULL)) return(0);
7229	arg2 = valuePop(ctxt);
7230	arg1 = valuePop(ctxt);
7231	if ((arg1 == NULL) \|\| (arg2 == NULL)) {
7232	if (arg1 != NULL)
7233	xmlXPathReleaseObject(ctxt->context, arg1);
7234	else
7235	xmlXPathReleaseObject(ctxt->context, arg2);
7236	XP_ERROR0(XPATH_INVALID_OPERAND);
7237	}
7238
7239	if (arg1 == arg2) {
7240	#ifdef DEBUG_EXPR
7241	xmlGenericError(xmlGenericErrorContext,
7242	"NotEqual: by pointer\n");
7243	#endif
7244	xmlXPathReleaseObject(ctxt->context, arg1);
7245	return(0);
7246	}
7247
7248	/*
7249	*If either argument is a nodeset, it's a 'special case'
7250	*/
7251	if ((arg2->type == XPATH_NODESET) \|\| (arg2->type == XPATH_XSLT_TREE) \|\|
7252	(arg1->type == XPATH_NODESET) \|\| (arg1->type == XPATH_XSLT_TREE)) {
7253	/*
7254	*Hack it to assure arg1 is the nodeset
7255	*/
7256	if ((arg1->type != XPATH_NODESET) && (arg1->type != XPATH_XSLT_TREE)) {
7257	argtmp = arg2;
7258	arg2 = arg1;
7259	arg1 = argtmp;
7260	}
7261	switch (arg2->type) {
7262	case XPATH_UNDEFINED:
7263	#ifdef DEBUG_EXPR
7264	xmlGenericError(xmlGenericErrorContext,
7265	"NotEqual: undefined\n");
7266	#endif
7267	break;
7268	case XPATH_NODESET:
7269	case XPATH_XSLT_TREE:
7270	ret = xmlXPathEqualNodeSets(arg1, arg2, 1);
7271	break;
7272	case XPATH_BOOLEAN:
7273	if ((arg1->nodesetval == NULL) \|\|
7274	(arg1->nodesetval->nodeNr == 0)) ret = 0;
7275	else
7276	ret = 1;
7277	ret = (ret != arg2->boolval);
7278	break;
7279	case XPATH_NUMBER:
7280	ret = xmlXPathEqualNodeSetFloat(ctxt, arg1, arg2->floatval, 1);
7281	break;
7282	case XPATH_STRING:
7283	ret = xmlXPathEqualNodeSetString(arg1, arg2->stringval,1);
7284	break;
7285	case XPATH_USERS:
7286	case XPATH_POINT:
7287	case XPATH_RANGE:
7288	case XPATH_LOCATIONSET:
7289	TODO
7290	break;
7291	}
7292	xmlXPathReleaseObject(ctxt->context, arg1);
7293	xmlXPathReleaseObject(ctxt->context, arg2);
7294	return(ret);
7295	}
7296
7297	return (!xmlXPathEqualValuesCommon(ctxt, arg1, arg2));
7298	}
7299
7300	/**
7301	* xmlXPathCompareValues:
7302	* @ctxt: the XPath Parser context
7303	* @inf: less than (1) or greater than (0)
7304	* @strict: is the comparison strict
7305	*
7306	* Implement the compare operation on XPath objects:
7307	* @arg1 < @arg2 (1, 1, ...
7308	* @arg1 <= @arg2 (1, 0, ...
7309	* @arg1 > @arg2 (0, 1, ...
7310	* @arg1 >= @arg2 (0, 0, ...
7311	*
7312	* When neither object to be compared is a node-set and the operator is
7313	* <=, <, >=, >, then the objects are compared by converted both objects
7314	* to numbers and comparing the numbers according to IEEE 754. The <
7315	* comparison will be true if and only if the first number is less than the
7316	* second number. The <= comparison will be true if and only if the first
7317	* number is less than or equal to the second number. The > comparison
7318	* will be true if and only if the first number is greater than the second
7319	* number. The >= comparison will be true if and only if the first number
7320	* is greater than or equal to the second number.
7321	*
7322	* Returns 1 if the comparison succeeded, 0 if it failed
7323	*/
7324	int
7325	xmlXPathCompareValues(xmlXPathParserContextPtr ctxt, int inf, int strict) {
7326	int ret = 0, arg1i = 0, arg2i = 0;
7327	xmlXPathObjectPtr arg1, arg2;
7328
7329	if ((ctxt == NULL) \|\| (ctxt->context == NULL)) return(0);
7330	arg2 = valuePop(ctxt);
7331	arg1 = valuePop(ctxt);
7332	if ((arg1 == NULL) \|\| (arg2 == NULL)) {
7333	if (arg1 != NULL)
7334	xmlXPathReleaseObject(ctxt->context, arg1);
7335	else
7336	xmlXPathReleaseObject(ctxt->context, arg2);
7337	XP_ERROR0(XPATH_INVALID_OPERAND);
7338	}
7339
7340	if ((arg2->type == XPATH_NODESET) \|\| (arg2->type == XPATH_XSLT_TREE) \|\|
7341	(arg1->type == XPATH_NODESET) \|\| (arg1->type == XPATH_XSLT_TREE)) {
7342	/*
7343	* If either argument is a XPATH_NODESET or XPATH_XSLT_TREE the two arguments
7344	* are not freed from within this routine; they will be freed from the
7345	* called routine, e.g. xmlXPathCompareNodeSets or xmlXPathCompareNodeSetValue
7346	*/
7347	if (((arg2->type == XPATH_NODESET) \|\| (arg2->type == XPATH_XSLT_TREE)) &&
7348	((arg1->type == XPATH_NODESET) \|\| (arg1->type == XPATH_XSLT_TREE))){
7349	ret = xmlXPathCompareNodeSets(inf, strict, arg1, arg2);
7350	} else {
7351	if ((arg1->type == XPATH_NODESET) \|\| (arg1->type == XPATH_XSLT_TREE)) {
7352	ret = xmlXPathCompareNodeSetValue(ctxt, inf, strict,
7353	arg1, arg2);
7354	} else {
7355	ret = xmlXPathCompareNodeSetValue(ctxt, !inf, strict,
7356	arg2, arg1);
7357	}
7358	}
7359	return(ret);
7360	}
7361
7362	if (arg1->type != XPATH_NUMBER) {
7363	valuePush(ctxt, arg1);
7364	xmlXPathNumberFunction(ctxt, 1);
7365	arg1 = valuePop(ctxt);
7366	}
7367	if (arg1->type != XPATH_NUMBER) {
7368	xmlXPathFreeObject(arg1);
7369	xmlXPathFreeObject(arg2);
7370	XP_ERROR0(XPATH_INVALID_OPERAND);
7371	}
7372	if (arg2->type != XPATH_NUMBER) {
7373	valuePush(ctxt, arg2);
7374	xmlXPathNumberFunction(ctxt, 1);
7375	arg2 = valuePop(ctxt);
7376	}
7377	if (arg2->type != XPATH_NUMBER) {
7378	xmlXPathReleaseObject(ctxt->context, arg1);
7379	xmlXPathReleaseObject(ctxt->context, arg2);
7380	XP_ERROR0(XPATH_INVALID_OPERAND);
7381	}
7382	/*
7383	* Add tests for infinity and nan
7384	* => feedback on 3.4 for Inf and NaN
7385	*/
7386	/* Hand check NaN and Infinity comparisons */
7387	if (xmlXPathIsNaN(arg1->floatval) \|\| xmlXPathIsNaN(arg2->floatval)) {
7388	ret=0;
7389	} else {
7390	arg1i=xmlXPathIsInf(arg1->floatval);
7391	arg2i=xmlXPathIsInf(arg2->floatval);
7392	if (inf && strict) {
7393	if ((arg1i == -1 && arg2i != -1) \|\|
7394	(arg2i == 1 && arg1i != 1)) {
7395	ret = 1;
7396	} else if (arg1i == 0 && arg2i == 0) {
7397	ret = (arg1->floatval < arg2->floatval);
7398	} else {
7399	ret = 0;
7400	}
7401	}
7402	else if (inf && !strict) {
7403	if (arg1i == -1 \|\| arg2i == 1) {
7404	ret = 1;
7405	} else if (arg1i == 0 && arg2i == 0) {
7406	ret = (arg1->floatval <= arg2->floatval);
7407	} else {
7408	ret = 0;
7409	}
7410	}
7411	else if (!inf && strict) {
7412	if ((arg1i == 1 && arg2i != 1) \|\|
7413	(arg2i == -1 && arg1i != -1)) {
7414	ret = 1;
7415	} else if (arg1i == 0 && arg2i == 0) {
7416	ret = (arg1->floatval > arg2->floatval);
7417	} else {
7418	ret = 0;
7419	}
7420	}
7421	else if (!inf && !strict) {
7422	if (arg1i == 1 \|\| arg2i == -1) {
7423	ret = 1;
7424	} else if (arg1i == 0 && arg2i == 0) {
7425	ret = (arg1->floatval >= arg2->floatval);
7426	} else {
7427	ret = 0;
7428	}
7429	}
7430	}
7431	xmlXPathReleaseObject(ctxt->context, arg1);
7432	xmlXPathReleaseObject(ctxt->context, arg2);
7433	return(ret);
7434	}
7435
7436	/**
7437	* xmlXPathValueFlipSign:
7438	* @ctxt: the XPath Parser context
7439	*
7440	* Implement the unary - operation on an XPath object
7441	* The numeric operators convert their operands to numbers as if
7442	* by calling the number function.
7443	*/
7444	void
7445	xmlXPathValueFlipSign(xmlXPathParserContextPtr ctxt) {
7446	if ((ctxt == NULL) \|\| (ctxt->context == NULL)) return;
7447	CAST_TO_NUMBER;
7448	CHECK_TYPE(XPATH_NUMBER);
7449	if (xmlXPathIsNaN(ctxt->value->floatval))
7450	ctxt->value->floatval=xmlXPathNAN;
7451	else if (xmlXPathIsInf(ctxt->value->floatval) == 1)
7452	ctxt->value->floatval=xmlXPathNINF;
7453	else if (xmlXPathIsInf(ctxt->value->floatval) == -1)
7454	ctxt->value->floatval=xmlXPathPINF;
7455	else if (ctxt->value->floatval == 0) {
7456	if (xmlXPathGetSign(ctxt->value->floatval) == 0)
7457	ctxt->value->floatval = xmlXPathNZERO;
7458	else
7459	ctxt->value->floatval = 0;
7460	}
7461	else
7462	ctxt->value->floatval = - ctxt->value->floatval;
7463	}
7464
7465	/**
7466	* xmlXPathAddValues:
7467	* @ctxt: the XPath Parser context
7468	*
7469	* Implement the add operation on XPath objects:
7470	* The numeric operators convert their operands to numbers as if
7471	* by calling the number function.
7472	*/
7473	void
7474	xmlXPathAddValues(xmlXPathParserContextPtr ctxt) {
7475	xmlXPathObjectPtr arg;
7476	double val;
7477
7478	arg = valuePop(ctxt);
7479	if (arg == NULL)
7480	XP_ERROR(XPATH_INVALID_OPERAND);
7481	val = xmlXPathCastToNumber(arg);
7482	xmlXPathReleaseObject(ctxt->context, arg);
7483	CAST_TO_NUMBER;
7484	CHECK_TYPE(XPATH_NUMBER);
7485	ctxt->value->floatval += val;
7486	}
7487
7488	/**
7489	* xmlXPathSubValues:
7490	* @ctxt: the XPath Parser context
7491	*
7492	* Implement the subtraction operation on XPath objects:
7493	* The numeric operators convert their operands to numbers as if
7494	* by calling the number function.
7495	*/
7496	void
7497	xmlXPathSubValues(xmlXPathParserContextPtr ctxt) {
7498	xmlXPathObjectPtr arg;
7499	double val;
7500
7501	arg = valuePop(ctxt);
7502	if (arg == NULL)
7503	XP_ERROR(XPATH_INVALID_OPERAND);
7504	val = xmlXPathCastToNumber(arg);
7505	xmlXPathReleaseObject(ctxt->context, arg);
7506	CAST_TO_NUMBER;
7507	CHECK_TYPE(XPATH_NUMBER);
7508	ctxt->value->floatval -= val;
7509	}
7510
7511	/**
7512	* xmlXPathMultValues:
7513	* @ctxt: the XPath Parser context
7514	*
7515	* Implement the multiply operation on XPath objects:
7516	* The numeric operators convert their operands to numbers as if
7517	* by calling the number function.
7518	*/
7519	void
7520	xmlXPathMultValues(xmlXPathParserContextPtr ctxt) {
7521	xmlXPathObjectPtr arg;
7522	double val;
7523
7524	arg = valuePop(ctxt);
7525	if (arg == NULL)
7526	XP_ERROR(XPATH_INVALID_OPERAND);
7527	val = xmlXPathCastToNumber(arg);
7528	xmlXPathReleaseObject(ctxt->context, arg);
7529	CAST_TO_NUMBER;
7530	CHECK_TYPE(XPATH_NUMBER);
7531	ctxt->value->floatval *= val;
7532	}
7533
7534	/**
7535	* xmlXPathDivValues:
7536	* @ctxt: the XPath Parser context
7537	*
7538	* Implement the div operation on XPath objects @arg1 / @arg2:
7539	* The numeric operators convert their operands to numbers as if
7540	* by calling the number function.
7541	*/
7542	void
7543	xmlXPathDivValues(xmlXPathParserContextPtr ctxt) {
7544	xmlXPathObjectPtr arg;
7545	double val;
7546
7547	arg = valuePop(ctxt);
7548	if (arg == NULL)
7549	XP_ERROR(XPATH_INVALID_OPERAND);
7550	val = xmlXPathCastToNumber(arg);
7551	xmlXPathReleaseObject(ctxt->context, arg);
7552	CAST_TO_NUMBER;
7553	CHECK_TYPE(XPATH_NUMBER);
7554	if (xmlXPathIsNaN(val) \|\| xmlXPathIsNaN(ctxt->value->floatval))
7555	ctxt->value->floatval = xmlXPathNAN;
7556	else if (val == 0 && xmlXPathGetSign(val) != 0) {
7557	if (ctxt->value->floatval == 0)
7558	ctxt->value->floatval = xmlXPathNAN;
7559	else if (ctxt->value->floatval > 0)
7560	ctxt->value->floatval = xmlXPathNINF;
7561	else if (ctxt->value->floatval < 0)
7562	ctxt->value->floatval = xmlXPathPINF;
7563	}
7564	else if (val == 0) {
7565	if (ctxt->value->floatval == 0)
7566	ctxt->value->floatval = xmlXPathNAN;
7567	else if (ctxt->value->floatval > 0)
7568	ctxt->value->floatval = xmlXPathPINF;
7569	else if (ctxt->value->floatval < 0)
7570	ctxt->value->floatval = xmlXPathNINF;
7571	} else
7572	ctxt->value->floatval /= val;
7573	}
7574
7575	/**
7576	* xmlXPathModValues:
7577	* @ctxt: the XPath Parser context
7578	*
7579	* Implement the mod operation on XPath objects: @arg1 / @arg2
7580	* The numeric operators convert their operands to numbers as if
7581	* by calling the number function.
7582	*/
7583	void
7584	xmlXPathModValues(xmlXPathParserContextPtr ctxt) {
7585	xmlXPathObjectPtr arg;
7586	double arg1, arg2;
7587
7588	arg = valuePop(ctxt);
7589	if (arg == NULL)
7590	XP_ERROR(XPATH_INVALID_OPERAND);
7591	arg2 = xmlXPathCastToNumber(arg);
7592	xmlXPathReleaseObject(ctxt->context, arg);
7593	CAST_TO_NUMBER;
7594	CHECK_TYPE(XPATH_NUMBER);
7595	arg1 = ctxt->value->floatval;
7596	if (arg2 == 0)
7597	ctxt->value->floatval = xmlXPathNAN;
7598	else {
7599	ctxt->value->floatval = fmod(arg1, arg2);
7600	}
7601	}
7602
7603	/************************************************************************
7604	* *
7605	* The traversal functions *
7606	* *
7607	************************************************************************/
7608
7609	/*
7610	* A traversal function enumerates nodes along an axis.
7611	* Initially it must be called with NULL, and it indicates
7612	* termination on the axis by returning NULL.
7613	*/
7614	typedef xmlNodePtr (*xmlXPathTraversalFunction)
7615	(xmlXPathParserContextPtr ctxt, xmlNodePtr cur);
7616
7617	/*
7618	* xmlXPathTraversalFunctionExt:
7619	* A traversal function enumerates nodes along an axis.
7620	* Initially it must be called with NULL, and it indicates
7621	* termination on the axis by returning NULL.
7622	* The context node of the traversal is specified via @contextNode.
7623	*/
7624	typedef xmlNodePtr (*xmlXPathTraversalFunctionExt)
7625	(xmlNodePtr cur, xmlNodePtr contextNode);
7626
7627	/*
7628	* xmlXPathNodeSetMergeFunction:
7629	* Used for merging node sets in xmlXPathCollectAndTest().
7630	*/
7631	typedef xmlNodeSetPtr (*xmlXPathNodeSetMergeFunction)
7632	(xmlNodeSetPtr, xmlNodeSetPtr, int);
7633
7634
7635	/**
7636	* xmlXPathNextSelf:
7637	* @ctxt: the XPath Parser context
7638	* @cur: the current node in the traversal
7639	*
7640	* Traversal function for the "self" direction
7641	* The self axis contains just the context node itself
7642	*
7643	* Returns the next element following that axis
7644	*/
7645	xmlNodePtr
7646	xmlXPathNextSelf(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
7647	if ((ctxt == NULL) \|\| (ctxt->context == NULL)) return(NULL);
7648	if (cur == NULL)
7649	return(ctxt->context->node);
7650	return(NULL);
7651	}
7652
7653	/**
7654	* xmlXPathNextChild:
7655	* @ctxt: the XPath Parser context
7656	* @cur: the current node in the traversal
7657	*
7658	* Traversal function for the "child" direction
7659	* The child axis contains the children of the context node in document order.
7660	*
7661	* Returns the next element following that axis
7662	*/
7663	xmlNodePtr
7664	xmlXPathNextChild(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
7665	if ((ctxt == NULL) \|\| (ctxt->context == NULL)) return(NULL);
7666	if (cur == NULL) {
7667	if (ctxt->context->node == NULL) return(NULL);
7668	switch (ctxt->context->node->type) {
7669	case XML_ELEMENT_NODE:
7670	case XML_TEXT_NODE:
7671	case XML_CDATA_SECTION_NODE:
7672	case XML_ENTITY_REF_NODE:
7673	case XML_ENTITY_NODE:
7674	case XML_PI_NODE:
7675	case XML_COMMENT_NODE:
7676	case XML_NOTATION_NODE:
7677	case XML_DTD_NODE:
7678	return(ctxt->context->node->children);
7679	case XML_DOCUMENT_NODE:
7680	case XML_DOCUMENT_TYPE_NODE:
7681	case XML_DOCUMENT_FRAG_NODE:
7682	case XML_HTML_DOCUMENT_NODE:
7683	#ifdef LIBXML_DOCB_ENABLED
7684	case XML_DOCB_DOCUMENT_NODE:
7685	#endif
7686	return(((xmlDocPtr) ctxt->context->node)->children);
7687	case XML_ELEMENT_DECL:
7688	case XML_ATTRIBUTE_DECL:
7689	case XML_ENTITY_DECL:
7690	case XML_ATTRIBUTE_NODE:
7691	case XML_NAMESPACE_DECL:
7692	case XML_XINCLUDE_START:
7693	case XML_XINCLUDE_END:
7694	return(NULL);
7695	}
7696	return(NULL);
7697	}
7698	if ((cur->type == XML_DOCUMENT_NODE) \|\|
7699	(cur->type == XML_HTML_DOCUMENT_NODE))
7700	return(NULL);
7701	return(cur->next);
7702	}
7703
7704	/**
7705	* xmlXPathNextChildElement:
7706	* @ctxt: the XPath Parser context
7707	* @cur: the current node in the traversal
7708	*
7709	* Traversal function for the "child" direction and nodes of type element.
7710	* The child axis contains the children of the context node in document order.
7711	*
7712	* Returns the next element following that axis
7713	*/
7714	static xmlNodePtr
7715	xmlXPathNextChildElement(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
7716	if ((ctxt == NULL) \|\| (ctxt->context == NULL)) return(NULL);
7717	if (cur == NULL) {
7718	cur = ctxt->context->node;
7719	if (cur == NULL) return(NULL);
7720	/*
7721	* Get the first element child.
7722	*/
7723	switch (cur->type) {
7724	case XML_ELEMENT_NODE:
7725	case XML_DOCUMENT_FRAG_NODE:
7726	case XML_ENTITY_REF_NODE: /* URGENT TODO: entify-refs as well? */
7727	case XML_ENTITY_NODE:
7728	cur = cur->children;
7729	if (cur != NULL) {
7730	if (cur->type == XML_ELEMENT_NODE)
7731	return(cur);
7732	do {
7733	cur = cur->next;
7734	} while ((cur != NULL) &&
7735	(cur->type != XML_ELEMENT_NODE));
7736	return(cur);
7737	}
7738	return(NULL);
7739	case XML_DOCUMENT_NODE:
7740	case XML_HTML_DOCUMENT_NODE:
7741	#ifdef LIBXML_DOCB_ENABLED
7742	case XML_DOCB_DOCUMENT_NODE:
7743	#endif
7744	return(xmlDocGetRootElement((xmlDocPtr) cur));
7745	default:
7746	return(NULL);
7747	}
7748	return(NULL);
7749	}
7750	/*
7751	* Get the next sibling element node.
7752	*/
7753	switch (cur->type) {
7754	case XML_ELEMENT_NODE:
7755	case XML_TEXT_NODE:
7756	case XML_ENTITY_REF_NODE:
7757	case XML_ENTITY_NODE:
7758	case XML_CDATA_SECTION_NODE:
7759	case XML_PI_NODE:
7760	case XML_COMMENT_NODE:
7761	case XML_XINCLUDE_END:
7762	break;
7763	/* case XML_DTD_NODE: / / URGENT TODO: DTD-node as well? */
7764	default:
7765	return(NULL);
7766	}
7767	if (cur->next != NULL) {
7768	if (cur->next->type == XML_ELEMENT_NODE)
7769	return(cur->next);
7770	cur = cur->next;
7771	do {
7772	cur = cur->next;
7773	} while ((cur != NULL) && (cur->type != XML_ELEMENT_NODE));
7774	return(cur);
7775	}
7776	return(NULL);
7777	}
7778
7779	#if 0
7780	/**
7781	* xmlXPathNextDescendantOrSelfElemParent:
7782	* @ctxt: the XPath Parser context
7783	* @cur: the current node in the traversal
7784	*
7785	* Traversal function for the "descendant-or-self" axis.
7786	* Additionally it returns only nodes which can be parents of
7787	* element nodes.
7788	*
7789	*
7790	* Returns the next element following that axis
7791	*/
7792	static xmlNodePtr
7793	xmlXPathNextDescendantOrSelfElemParent(xmlNodePtr cur,
7794	xmlNodePtr contextNode)
7795	{
7796	if (cur == NULL) {
7797	if (contextNode == NULL)
7798	return(NULL);
7799	switch (contextNode->type) {
7800	case XML_ELEMENT_NODE:
7801	case XML_XINCLUDE_START:
7802	case XML_DOCUMENT_FRAG_NODE:
7803	case XML_DOCUMENT_NODE:
7804	#ifdef LIBXML_DOCB_ENABLED
7805	case XML_DOCB_DOCUMENT_NODE:
7806	#endif
7807	case XML_HTML_DOCUMENT_NODE:
7808	return(contextNode);
7809	default:
7810	return(NULL);
7811	}
7812	return(NULL);
7813	} else {
7814	xmlNodePtr start = cur;
7815
7816	while (cur != NULL) {
7817	switch (cur->type) {
7818	case XML_ELEMENT_NODE:
7819	/* TODO: OK to have XInclude here? */
7820	case XML_XINCLUDE_START:
7821	case XML_DOCUMENT_FRAG_NODE:
7822	if (cur != start)
7823	return(cur);
7824	if (cur->children != NULL) {
7825	cur = cur->children;
7826	continue;
7827	}
7828	break;
7829	/* Not sure if we need those here. */
7830	case XML_DOCUMENT_NODE:
7831	#ifdef LIBXML_DOCB_ENABLED
7832	case XML_DOCB_DOCUMENT_NODE:
7833	#endif
7834	case XML_HTML_DOCUMENT_NODE:
7835	if (cur != start)
7836	return(cur);
7837	return(xmlDocGetRootElement((xmlDocPtr) cur));
7838	default:
7839	break;
7840	}
7841
7842	next_sibling:
7843	if ((cur == NULL) \|\| (cur == contextNode))
7844	return(NULL);
7845	if (cur->next != NULL) {
7846	cur = cur->next;
7847	} else {
7848	cur = cur->parent;
7849	goto next_sibling;
7850	}
7851	}
7852	}
7853	return(NULL);
7854	}
7855	#endif
7856
7857	/**
7858	* xmlXPathNextDescendant:
7859	* @ctxt: the XPath Parser context
7860	* @cur: the current node in the traversal
7861	*
7862	* Traversal function for the "descendant" direction
7863	* the descendant axis contains the descendants of the context node in document
7864	* order; a descendant is a child or a child of a child and so on.
7865	*
7866	* Returns the next element following that axis
7867	*/
7868	xmlNodePtr
7869	xmlXPathNextDescendant(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
7870	if ((ctxt == NULL) \|\| (ctxt->context == NULL)) return(NULL);
7871	if (cur == NULL) {
7872	if (ctxt->context->node == NULL)
7873	return(NULL);
7874	if ((ctxt->context->node->type == XML_ATTRIBUTE_NODE) \|\|
7875	(ctxt->context->node->type == XML_NAMESPACE_DECL))
7876	return(NULL);
7877
7878	if (ctxt->context->node == (xmlNodePtr) ctxt->context->doc)
7879	return(ctxt->context->doc->children);
7880	return(ctxt->context->node->children);
7881	}
7882
7883	if (cur->type == XML_NAMESPACE_DECL)
7884	return(NULL);
7885	if (cur->children != NULL) {
7886	/*
7887	* Do not descend on entities declarations
7888	*/
7889	if (cur->children->type != XML_ENTITY_DECL) {
7890	cur = cur->children;
7891	/*
7892	* Skip DTDs
7893	*/
7894	if (cur->type != XML_DTD_NODE)
7895	return(cur);
7896	}
7897	}
7898
7899	if (cur == ctxt->context->node) return(NULL);
7900
7901	while (cur->next != NULL) {
7902	cur = cur->next;
7903	if ((cur->type != XML_ENTITY_DECL) &&
7904	(cur->type != XML_DTD_NODE))
7905	return(cur);
7906	}
7907
7908	do {
7909	cur = cur->parent;
7910	if (cur == NULL) break;
7911	if (cur == ctxt->context->node) return(NULL);
7912	if (cur->next != NULL) {
7913	cur = cur->next;
7914	return(cur);
7915	}
7916	} while (cur != NULL);
7917	return(cur);
7918	}
7919
7920	/**
7921	* xmlXPathNextDescendantOrSelf:
7922	* @ctxt: the XPath Parser context
7923	* @cur: the current node in the traversal
7924	*
7925	* Traversal function for the "descendant-or-self" direction
7926	* the descendant-or-self axis contains the context node and the descendants
7927	* of the context node in document order; thus the context node is the first
7928	* node on the axis, and the first child of the context node is the second node
7929	* on the axis
7930	*
7931	* Returns the next element following that axis
7932	*/
7933	xmlNodePtr
7934	xmlXPathNextDescendantOrSelf(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
7935	if ((ctxt == NULL) \|\| (ctxt->context == NULL)) return(NULL);
7936	if (cur == NULL) {
7937	if (ctxt->context->node == NULL)
7938	return(NULL);
7939	if ((ctxt->context->node->type == XML_ATTRIBUTE_NODE) \|\|
7940	(ctxt->context->node->type == XML_NAMESPACE_DECL))
7941	return(NULL);
7942	return(ctxt->context->node);
7943	}
7944
7945	return(xmlXPathNextDescendant(ctxt, cur));
7946	}
7947
7948	/**
7949	* xmlXPathNextParent:
7950	* @ctxt: the XPath Parser context
7951	* @cur: the current node in the traversal
7952	*
7953	* Traversal function for the "parent" direction
7954	* The parent axis contains the parent of the context node, if there is one.
7955	*
7956	* Returns the next element following that axis
7957	*/
7958	xmlNodePtr
7959	xmlXPathNextParent(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
7960	if ((ctxt == NULL) \|\| (ctxt->context == NULL)) return(NULL);
7961	/*
7962	* the parent of an attribute or namespace node is the element
7963	* to which the attribute or namespace node is attached
7964	* Namespace handling !!!
7965	*/
7966	if (cur == NULL) {
7967	if (ctxt->context->node == NULL) return(NULL);
7968	switch (ctxt->context->node->type) {
7969	case XML_ELEMENT_NODE:
7970	case XML_TEXT_NODE:
7971	case XML_CDATA_SECTION_NODE:
7972	case XML_ENTITY_REF_NODE:
7973	case XML_ENTITY_NODE:
7974	case XML_PI_NODE:
7975	case XML_COMMENT_NODE:
7976	case XML_NOTATION_NODE:
7977	case XML_DTD_NODE:
7978	case XML_ELEMENT_DECL:
7979	case XML_ATTRIBUTE_DECL:
7980	case XML_XINCLUDE_START:
7981	case XML_XINCLUDE_END:
7982	case XML_ENTITY_DECL:
7983	if (ctxt->context->node->parent == NULL)
7984	return((xmlNodePtr) ctxt->context->doc);
7985	if ((ctxt->context->node->parent->type == XML_ELEMENT_NODE) &&
7986	((ctxt->context->node->parent->name[0] == ' ') \|\|
7987	(xmlStrEqual(ctxt->context->node->parent->name,
7988	BAD_CAST "fake node libxslt"))))
7989	return(NULL);
7990	return(ctxt->context->node->parent);
7991	case XML_ATTRIBUTE_NODE: {
7992	xmlAttrPtr att = (xmlAttrPtr) ctxt->context->node;
7993
7994	return(att->parent);
7995	}
7996	case XML_DOCUMENT_NODE:
7997	case XML_DOCUMENT_TYPE_NODE:
7998	case XML_DOCUMENT_FRAG_NODE:
7999	case XML_HTML_DOCUMENT_NODE:
8000	#ifdef LIBXML_DOCB_ENABLED
8001	case XML_DOCB_DOCUMENT_NODE:
8002	#endif
8003	return(NULL);
8004	case XML_NAMESPACE_DECL: {
8005	xmlNsPtr ns = (xmlNsPtr) ctxt->context->node;
8006
8007	if ((ns->next != NULL) &&
8008	(ns->next->type != XML_NAMESPACE_DECL))
8009	return((xmlNodePtr) ns->next);
8010	return(NULL);
8011	}
8012	}
8013	}
8014	return(NULL);
8015	}
8016
8017	/**
8018	* xmlXPathNextAncestor:
8019	* @ctxt: the XPath Parser context
8020	* @cur: the current node in the traversal
8021	*
8022	* Traversal function for the "ancestor" direction
8023	* the ancestor axis contains the ancestors of the context node; the ancestors
8024	* of the context node consist of the parent of context node and the parent's
8025	* parent and so on; the nodes are ordered in reverse document order; thus the
8026	* parent is the first node on the axis, and the parent's parent is the second
8027	* node on the axis
8028	*
8029	* Returns the next element following that axis
8030	*/
8031	xmlNodePtr
8032	xmlXPathNextAncestor(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
8033	if ((ctxt == NULL) \|\| (ctxt->context == NULL)) return(NULL);
8034	/*
8035	* the parent of an attribute or namespace node is the element
8036	* to which the attribute or namespace node is attached
8037	* !!!!!!!!!!!!!
8038	*/
8039	if (cur == NULL) {
8040	if (ctxt->context->node == NULL) return(NULL);
8041	switch (ctxt->context->node->type) {
8042	case XML_ELEMENT_NODE:
8043	case XML_TEXT_NODE:
8044	case XML_CDATA_SECTION_NODE:
8045	case XML_ENTITY_REF_NODE:
8046	case XML_ENTITY_NODE:
8047	case XML_PI_NODE:
8048	case XML_COMMENT_NODE:
8049	case XML_DTD_NODE:
8050	case XML_ELEMENT_DECL:
8051	case XML_ATTRIBUTE_DECL:
8052	case XML_ENTITY_DECL:
8053	case XML_NOTATION_NODE:
8054	case XML_XINCLUDE_START:
8055	case XML_XINCLUDE_END:
8056	if (ctxt->context->node->parent == NULL)
8057	return((xmlNodePtr) ctxt->context->doc);
8058	if ((ctxt->context->node->parent->type == XML_ELEMENT_NODE) &&
8059	((ctxt->context->node->parent->name[0] == ' ') \|\|
8060	(xmlStrEqual(ctxt->context->node->parent->name,
8061	BAD_CAST "fake node libxslt"))))
8062	return(NULL);
8063	return(ctxt->context->node->parent);
8064	case XML_ATTRIBUTE_NODE: {
8065	xmlAttrPtr tmp = (xmlAttrPtr) ctxt->context->node;
8066
8067	return(tmp->parent);
8068	}
8069	case XML_DOCUMENT_NODE:
8070	case XML_DOCUMENT_TYPE_NODE:
8071	case XML_DOCUMENT_FRAG_NODE:
8072	case XML_HTML_DOCUMENT_NODE:
8073	#ifdef LIBXML_DOCB_ENABLED
8074	case XML_DOCB_DOCUMENT_NODE:
8075	#endif
8076	return(NULL);
8077	case XML_NAMESPACE_DECL: {
8078	xmlNsPtr ns = (xmlNsPtr) ctxt->context->node;
8079
8080	if ((ns->next != NULL) &&
8081	(ns->next->type != XML_NAMESPACE_DECL))
8082	return((xmlNodePtr) ns->next);
8083	/* Bad, how did that namespace end up here ? */
8084	return(NULL);
8085	}
8086	}
8087	return(NULL);
8088	}
8089	if (cur == ctxt->context->doc->children)
8090	return((xmlNodePtr) ctxt->context->doc);
8091	if (cur == (xmlNodePtr) ctxt->context->doc)
8092	return(NULL);
8093	switch (cur->type) {
8094	case XML_ELEMENT_NODE:
8095	case XML_TEXT_NODE:
8096	case XML_CDATA_SECTION_NODE:
8097	case XML_ENTITY_REF_NODE:
8098	case XML_ENTITY_NODE:
8099	case XML_PI_NODE:
8100	case XML_COMMENT_NODE:
8101	case XML_NOTATION_NODE:
8102	case XML_DTD_NODE:
8103	case XML_ELEMENT_DECL:
8104	case XML_ATTRIBUTE_DECL:
8105	case XML_ENTITY_DECL:
8106	case XML_XINCLUDE_START:
8107	case XML_XINCLUDE_END:
8108	if (cur->parent == NULL)
8109	return(NULL);
8110	if ((cur->parent->type == XML_ELEMENT_NODE) &&
8111	((cur->parent->name[0] == ' ') \|\|
8112	(xmlStrEqual(cur->parent->name,
8113	BAD_CAST "fake node libxslt"))))
8114	return(NULL);
8115	return(cur->parent);
8116	case XML_ATTRIBUTE_NODE: {
8117	xmlAttrPtr att = (xmlAttrPtr) ctxt->context->node;
8118
8119	return(att->parent);
8120	}
8121	case XML_NAMESPACE_DECL: {
8122	xmlNsPtr ns = (xmlNsPtr) ctxt->context->node;
8123
8124	if ((ns->next != NULL) &&
8125	(ns->next->type != XML_NAMESPACE_DECL))
8126	return((xmlNodePtr) ns->next);
8127	/* Bad, how did that namespace end up here ? */
8128	return(NULL);
8129	}
8130	case XML_DOCUMENT_NODE:
8131	case XML_DOCUMENT_TYPE_NODE:
8132	case XML_DOCUMENT_FRAG_NODE:
8133	case XML_HTML_DOCUMENT_NODE:
8134	#ifdef LIBXML_DOCB_ENABLED
8135	case XML_DOCB_DOCUMENT_NODE:
8136	#endif
8137	return(NULL);
8138	}
8139	return(NULL);
8140	}
8141
8142	/**
8143	* xmlXPathNextAncestorOrSelf:
8144	* @ctxt: the XPath Parser context
8145	* @cur: the current node in the traversal
8146	*
8147	* Traversal function for the "ancestor-or-self" direction
8148	* he ancestor-or-self axis contains the context node and ancestors of
8149	* the context node in reverse document order; thus the context node is
8150	* the first node on the axis, and the context node's parent the second;
8151	* parent here is defined the same as with the parent axis.
8152	*
8153	* Returns the next element following that axis
8154	*/
8155	xmlNodePtr
8156	xmlXPathNextAncestorOrSelf(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
8157	if ((ctxt == NULL) \|\| (ctxt->context == NULL)) return(NULL);
8158	if (cur == NULL)
8159	return(ctxt->context->node);
8160	return(xmlXPathNextAncestor(ctxt, cur));
8161	}
8162
8163	/**
8164	* xmlXPathNextFollowingSibling:
8165	* @ctxt: the XPath Parser context
8166	* @cur: the current node in the traversal
8167	*
8168	* Traversal function for the "following-sibling" direction
8169	* The following-sibling axis contains the following siblings of the context
8170	* node in document order.
8171	*
8172	* Returns the next element following that axis
8173	*/
8174	xmlNodePtr
8175	xmlXPathNextFollowingSibling(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
8176	if ((ctxt == NULL) \|\| (ctxt->context == NULL)) return(NULL);
8177	if ((ctxt->context->node->type == XML_ATTRIBUTE_NODE) \|\|
8178	(ctxt->context->node->type == XML_NAMESPACE_DECL))
8179	return(NULL);
8180	if (cur == (xmlNodePtr) ctxt->context->doc)
8181	return(NULL);
8182	if (cur == NULL)
8183	return(ctxt->context->node->next);
8184	return(cur->next);
8185	}
8186
8187	/**
8188	* xmlXPathNextPrecedingSibling:
8189	* @ctxt: the XPath Parser context
8190	* @cur: the current node in the traversal
8191	*
8192	* Traversal function for the "preceding-sibling" direction
8193	* The preceding-sibling axis contains the preceding siblings of the context
8194	* node in reverse document order; the first preceding sibling is first on the
8195	* axis; the sibling preceding that node is the second on the axis and so on.
8196	*
8197	* Returns the next element following that axis
8198	*/
8199	xmlNodePtr
8200	xmlXPathNextPrecedingSibling(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
8201	if ((ctxt == NULL) \|\| (ctxt->context == NULL)) return(NULL);
8202	if ((ctxt->context->node->type == XML_ATTRIBUTE_NODE) \|\|
8203	(ctxt->context->node->type == XML_NAMESPACE_DECL))
8204	return(NULL);
8205	if (cur == (xmlNodePtr) ctxt->context->doc)
8206	return(NULL);
8207	if (cur == NULL)
8208	return(ctxt->context->node->prev);
8209	if ((cur->prev != NULL) && (cur->prev->type == XML_DTD_NODE)) {
8210	cur = cur->prev;
8211	if (cur == NULL)
8212	return(ctxt->context->node->prev);
8213	}
8214	return(cur->prev);
8215	}
8216
8217	/**
8218	* xmlXPathNextFollowing:
8219	* @ctxt: the XPath Parser context
8220	* @cur: the current node in the traversal
8221	*
8222	* Traversal function for the "following" direction
8223	* The following axis contains all nodes in the same document as the context
8224	* node that are after the context node in document order, excluding any
8225	* descendants and excluding attribute nodes and namespace nodes; the nodes
8226	* are ordered in document order
8227	*
8228	* Returns the next element following that axis
8229	*/
8230	xmlNodePtr
8231	xmlXPathNextFollowing(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
8232	if ((ctxt == NULL) \|\| (ctxt->context == NULL)) return(NULL);
8233	if ((cur != NULL) && (cur->type != XML_ATTRIBUTE_NODE) &&
8234	(cur->type != XML_NAMESPACE_DECL) && (cur->children != NULL))
8235	return(cur->children);
8236
8237	if (cur == NULL) {
8238	cur = ctxt->context->node;
8239	if (cur->type == XML_NAMESPACE_DECL)
8240	return(NULL);
8241	if (cur->type == XML_ATTRIBUTE_NODE)
8242	cur = cur->parent;
8243	}
8244	if (cur == NULL) return(NULL) ; /* ERROR */
8245	if (cur->next != NULL) return(cur->next) ;
8246	do {
8247	cur = cur->parent;
8248	if (cur == NULL) break;
8249	if (cur == (xmlNodePtr) ctxt->context->doc) return(NULL);
8250	if (cur->next != NULL) return(cur->next);
8251	} while (cur != NULL);
8252	return(cur);
8253	}
8254
8255	/*
8256	* xmlXPathIsAncestor:
8257	* @ancestor: the ancestor node
8258	* @node: the current node
8259	*
8260	* Check that @ancestor is a @node's ancestor
8261	*
8262	* returns 1 if @ancestor is a @node's ancestor, 0 otherwise.
8263	*/
8264	static int
8265	xmlXPathIsAncestor(xmlNodePtr ancestor, xmlNodePtr node) {
8266	if ((ancestor == NULL) \|\| (node == NULL)) return(0);
8267	if (node->type == XML_NAMESPACE_DECL)
8268	return(0);
8269	if (ancestor->type == XML_NAMESPACE_DECL)
8270	return(0);
8271	/* nodes need to be in the same document */
8272	if (ancestor->doc != node->doc) return(0);
8273	/* avoid searching if ancestor or node is the root node */
8274	if (ancestor == (xmlNodePtr) node->doc) return(1);
8275	if (node == (xmlNodePtr) ancestor->doc) return(0);
8276	while (node->parent != NULL) {
8277	if (node->parent == ancestor)
8278	return(1);
8279	node = node->parent;
8280	}
8281	return(0);
8282	}
8283
8284	/**
8285	* xmlXPathNextPreceding:
8286	* @ctxt: the XPath Parser context
8287	* @cur: the current node in the traversal
8288	*
8289	* Traversal function for the "preceding" direction
8290	* the preceding axis contains all nodes in the same document as the context
8291	* node that are before the context node in document order, excluding any
8292	* ancestors and excluding attribute nodes and namespace nodes; the nodes are
8293	* ordered in reverse document order
8294	*
8295	* Returns the next element following that axis
8296	*/
8297	xmlNodePtr
8298	xmlXPathNextPreceding(xmlXPathParserContextPtr ctxt, xmlNodePtr cur)
8299	{
8300	if ((ctxt == NULL) \|\| (ctxt->context == NULL)) return(NULL);
8301	if (cur == NULL) {
8302	cur = ctxt->context->node;
8303	if (cur->type == XML_NAMESPACE_DECL)
8304	return(NULL);
8305	if (cur->type == XML_ATTRIBUTE_NODE)
8306	return(cur->parent);
8307	}
8308	if ((cur == NULL) \|\| (cur->type == XML_NAMESPACE_DECL))
8309	return (NULL);
8310	if ((cur->prev != NULL) && (cur->prev->type == XML_DTD_NODE))
8311	cur = cur->prev;
8312	do {
8313	if (cur->prev != NULL) {
8314	for (cur = cur->prev; cur->last != NULL; cur = cur->last) ;
8315	return (cur);
8316	}
8317
8318	cur = cur->parent;
8319	if (cur == NULL)
8320	return (NULL);
8321	if (cur == ctxt->context->doc->children)
8322	return (NULL);
8323	} while (xmlXPathIsAncestor(cur, ctxt->context->node));
8324	return (cur);
8325	}
8326
8327	/**
8328	* xmlXPathNextPrecedingInternal:
8329	* @ctxt: the XPath Parser context
8330	* @cur: the current node in the traversal
8331	*
8332	* Traversal function for the "preceding" direction
8333	* the preceding axis contains all nodes in the same document as the context
8334	* node that are before the context node in document order, excluding any
8335	* ancestors and excluding attribute nodes and namespace nodes; the nodes are
8336	* ordered in reverse document order
8337	* This is a faster implementation but internal only since it requires a
8338	* state kept in the parser context: ctxt->ancestor.
8339	*
8340	* Returns the next element following that axis
8341	*/
8342	static xmlNodePtr
8343	xmlXPathNextPrecedingInternal(xmlXPathParserContextPtr ctxt,
8344	xmlNodePtr cur)
8345	{
8346	if ((ctxt == NULL) \|\| (ctxt->context == NULL)) return(NULL);
8347	if (cur == NULL) {
8348	cur = ctxt->context->node;
8349	if (cur == NULL)
8350	return (NULL);
8351	if (cur->type == XML_NAMESPACE_DECL)
8352	return (NULL);
8353	ctxt->ancestor = cur->parent;
8354	}
8355	if (cur->type == XML_NAMESPACE_DECL)
8356	return(NULL);
8357	if ((cur->prev != NULL) && (cur->prev->type == XML_DTD_NODE))
8358	cur = cur->prev;
8359	while (cur->prev == NULL) {
8360	cur = cur->parent;
8361	if (cur == NULL)
8362	return (NULL);
8363	if (cur == ctxt->context->doc->children)
8364	return (NULL);
8365	if (cur != ctxt->ancestor)
8366	return (cur);
8367	ctxt->ancestor = cur->parent;
8368	}
8369	cur = cur->prev;
8370	while (cur->last != NULL)
8371	cur = cur->last;
8372	return (cur);
8373	}
8374
8375	/**
8376	* xmlXPathNextNamespace:
8377	* @ctxt: the XPath Parser context
8378	* @cur: the current attribute in the traversal
8379	*
8380	* Traversal function for the "namespace" direction
8381	* the namespace axis contains the namespace nodes of the context node;
8382	* the order of nodes on this axis is implementation-defined; the axis will
8383	* be empty unless the context node is an element
8384	*
8385	* We keep the XML namespace node at the end of the list.
8386	*
8387	* Returns the next element following that axis
8388	*/
8389	xmlNodePtr
8390	xmlXPathNextNamespace(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
8391	if ((ctxt == NULL) \|\| (ctxt->context == NULL)) return(NULL);
8392	if (ctxt->context->node->type != XML_ELEMENT_NODE) return(NULL);
8393	if (ctxt->context->tmpNsList == NULL && cur != (xmlNodePtr) xmlXPathXMLNamespace) {
8394	if (ctxt->context->tmpNsList != NULL)
8395	xmlFree(ctxt->context->tmpNsList);
8396	ctxt->context->tmpNsList =
8397	xmlGetNsList(ctxt->context->doc, ctxt->context->node);
8398	ctxt->context->tmpNsNr = 0;
8399	if (ctxt->context->tmpNsList != NULL) {
8400	while (ctxt->context->tmpNsList[ctxt->context->tmpNsNr] != NULL) {
8401	ctxt->context->tmpNsNr++;
8402	}
8403	}
8404	return((xmlNodePtr) xmlXPathXMLNamespace);
8405	}
8406	if (ctxt->context->tmpNsNr > 0) {
8407	return (xmlNodePtr)ctxt->context->tmpNsList[--ctxt->context->tmpNsNr];
8408	} else {
8409	if (ctxt->context->tmpNsList != NULL)
8410	xmlFree(ctxt->context->tmpNsList);
8411	ctxt->context->tmpNsList = NULL;
8412	return(NULL);
8413	}
8414	}
8415
8416	/**
8417	* xmlXPathNextAttribute:
8418	* @ctxt: the XPath Parser context
8419	* @cur: the current attribute in the traversal
8420	*
8421	* Traversal function for the "attribute" direction
8422	* TODO: support DTD inherited default attributes
8423	*
8424	* Returns the next element following that axis
8425	*/
8426	xmlNodePtr
8427	xmlXPathNextAttribute(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
8428	if ((ctxt == NULL) \|\| (ctxt->context == NULL)) return(NULL);
8429	if (ctxt->context->node == NULL)
8430	return(NULL);
8431	if (ctxt->context->node->type != XML_ELEMENT_NODE)
8432	return(NULL);
8433	if (cur == NULL) {
8434	if (ctxt->context->node == (xmlNodePtr) ctxt->context->doc)
8435	return(NULL);
8436	return((xmlNodePtr)ctxt->context->node->properties);
8437	}
8438	return((xmlNodePtr)cur->next);
8439	}
8440
8441	/************************************************************************
8442	* *
8443	* NodeTest Functions *
8444	* *
8445	************************************************************************/
8446
8447	#define IS_FUNCTION 200
8448
8449
8450	/************************************************************************
8451	* *
8452	* Implicit tree core function library *
8453	* *
8454	************************************************************************/
8455
8456	/**
8457	* xmlXPathRoot:
8458	* @ctxt: the XPath Parser context
8459	*
8460	* Initialize the context to the root of the document
8461	*/
8462	void
8463	xmlXPathRoot(xmlXPathParserContextPtr ctxt) {
8464	if ((ctxt == NULL) \|\| (ctxt->context == NULL))
8465	return;
8466	ctxt->context->node = (xmlNodePtr) ctxt->context->doc;
8467	valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context,
8468	ctxt->context->node));
8469	}
8470
8471	/************************************************************************
8472	* *
8473	* The explicit core function library *
8474	http://www.w3.org/Style/XSL/Group/1999/07/xpath-19990705.html#corelib
8475	* *
8476	************************************************************************/
8477
8478
8479	/**
8480	* xmlXPathLastFunction:
8481	* @ctxt: the XPath Parser context
8482	* @nargs: the number of arguments
8483	*
8484	* Implement the last() XPath function
8485	* number last()
8486	* The last function returns the number of nodes in the context node list.
8487	*/
8488	void
8489	xmlXPathLastFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8490	CHECK_ARITY(0);
8491	if (ctxt->context->contextSize >= 0) {
8492	valuePush(ctxt,
8493	xmlXPathCacheNewFloat(ctxt->context,
8494	(double) ctxt->context->contextSize));
8495	#ifdef DEBUG_EXPR
8496	xmlGenericError(xmlGenericErrorContext,
8497	"last() : %d\n", ctxt->context->contextSize);
8498	#endif
8499	} else {
8500	XP_ERROR(XPATH_INVALID_CTXT_SIZE);
8501	}
8502	}
8503
8504	/**
8505	* xmlXPathPositionFunction:
8506	* @ctxt: the XPath Parser context
8507	* @nargs: the number of arguments
8508	*
8509	* Implement the position() XPath function
8510	* number position()
8511	* The position function returns the position of the context node in the
8512	* context node list. The first position is 1, and so the last position
8513	* will be equal to last().
8514	*/
8515	void
8516	xmlXPathPositionFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8517	CHECK_ARITY(0);
8518	if (ctxt->context->proximityPosition >= 0) {
8519	valuePush(ctxt,
8520	xmlXPathCacheNewFloat(ctxt->context,
8521	(double) ctxt->context->proximityPosition));
8522	#ifdef DEBUG_EXPR
8523	xmlGenericError(xmlGenericErrorContext, "position() : %d\n",
8524	ctxt->context->proximityPosition);
8525	#endif
8526	} else {
8527	XP_ERROR(XPATH_INVALID_CTXT_POSITION);
8528	}
8529	}
8530
8531	/**
8532	* xmlXPathCountFunction:
8533	* @ctxt: the XPath Parser context
8534	* @nargs: the number of arguments
8535	*
8536	* Implement the count() XPath function
8537	* number count(node-set)
8538	*/
8539	void
8540	xmlXPathCountFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8541	xmlXPathObjectPtr cur;
8542
8543	CHECK_ARITY(1);
8544	if ((ctxt->value == NULL) \|\|
8545	((ctxt->value->type != XPATH_NODESET) &&
8546	(ctxt->value->type != XPATH_XSLT_TREE)))
8547	XP_ERROR(XPATH_INVALID_TYPE);
8548	cur = valuePop(ctxt);
8549
8550	if ((cur == NULL) \|\| (cur->nodesetval == NULL))
8551	valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, (double) 0));
8552	else if ((cur->type == XPATH_NODESET) \|\| (cur->type == XPATH_XSLT_TREE)) {
8553	valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context,
8554	(double) cur->nodesetval->nodeNr));
8555	} else {
8556	if ((cur->nodesetval->nodeNr != 1) \|\|
8557	(cur->nodesetval->nodeTab == NULL)) {
8558	valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, (double) 0));
8559	} else {
8560	xmlNodePtr tmp;
8561	int i = 0;
8562
8563	tmp = cur->nodesetval->nodeTab[0];
8564	if ((tmp != NULL) && (tmp->type != XML_NAMESPACE_DECL)) {
8565	tmp = tmp->children;
8566	while (tmp != NULL) {
8567	tmp = tmp->next;
8568	i++;
8569	}
8570	}
8571	valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, (double) i));
8572	}
8573	}
8574	xmlXPathReleaseObject(ctxt->context, cur);
8575	}
8576
8577	/**
8578	* xmlXPathGetElementsByIds:
8579	* @doc: the document
8580	* @ids: a whitespace separated list of IDs
8581	*
8582	* Selects elements by their unique ID.
8583	*
8584	* Returns a node-set of selected elements.
8585	*/
8586	static xmlNodeSetPtr
8587	xmlXPathGetElementsByIds (xmlDocPtr doc, const xmlChar *ids) {
8588	xmlNodeSetPtr ret;
8589	const xmlChar *cur = ids;
8590	xmlChar *ID;
8591	xmlAttrPtr attr;
8592	xmlNodePtr elem = NULL;
8593
8594	if (ids == NULL) return(NULL);
8595
8596	ret = xmlXPathNodeSetCreate(NULL);
8597	if (ret == NULL)
8598	return(ret);
8599
8600	while (IS_BLANK_CH(*cur)) cur++;
8601	while (*cur != 0) {
8602	while ((!IS_BLANK_CH(cur)) && (cur != 0))
8603	cur++;
8604
8605	ID = xmlStrndup(ids, cur - ids);
8606	if (ID != NULL) {
8607	/*
8608	* We used to check the fact that the value passed
8609	* was an NCName, but this generated much troubles for
8610	* me and Aleksey Sanin, people blatantly violated that
8611	* constaint, like Visa3D spec.
8612	* if (xmlValidateNCName(ID, 1) == 0)
8613	*/
8614	attr = xmlGetID(doc, ID);
8615	if (attr != NULL) {
8616	if (attr->type == XML_ATTRIBUTE_NODE)
8617	elem = attr->parent;
8618	else if (attr->type == XML_ELEMENT_NODE)
8619	elem = (xmlNodePtr) attr;
8620	else
8621	elem = NULL;
8622	if (elem != NULL)
8623	xmlXPathNodeSetAdd(ret, elem);
8624	}
8625	xmlFree(ID);
8626	}
8627
8628	while (IS_BLANK_CH(*cur)) cur++;
8629	ids = cur;
8630	}
8631	return(ret);
8632	}
8633
8634	/**
8635	* xmlXPathIdFunction:
8636	* @ctxt: the XPath Parser context
8637	* @nargs: the number of arguments
8638	*
8639	* Implement the id() XPath function
8640	* node-set id(object)
8641	* The id function selects elements by their unique ID
8642	* (see [5.2.1 Unique IDs]). When the argument to id is of type node-set,
8643	* then the result is the union of the result of applying id to the
8644	* string value of each of the nodes in the argument node-set. When the
8645	* argument to id is of any other type, the argument is converted to a
8646	* string as if by a call to the string function; the string is split
8647	* into a whitespace-separated list of tokens (whitespace is any sequence
8648	* of characters matching the production S); the result is a node-set
8649	* containing the elements in the same document as the context node that
8650	* have a unique ID equal to any of the tokens in the list.
8651	*/
8652	void
8653	xmlXPathIdFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8654	xmlChar *tokens;
8655	xmlNodeSetPtr ret;
8656	xmlXPathObjectPtr obj;
8657
8658	CHECK_ARITY(1);
8659	obj = valuePop(ctxt);
8660	if (obj == NULL) XP_ERROR(XPATH_INVALID_OPERAND);
8661	if ((obj->type == XPATH_NODESET) \|\| (obj->type == XPATH_XSLT_TREE)) {
8662	xmlNodeSetPtr ns;
8663	int i;
8664
8665	ret = xmlXPathNodeSetCreate(NULL);
8666	/*
8667	* FIXME -- in an out-of-memory condition this will behave badly.
8668	* The solution is not clear -- we already popped an item from
8669	* ctxt, so the object is in a corrupt state.
8670	*/
8671
8672	if (obj->nodesetval != NULL) {
8673	for (i = 0; i < obj->nodesetval->nodeNr; i++) {
8674	tokens =
8675	xmlXPathCastNodeToString(obj->nodesetval->nodeTab[i]);
8676	ns = xmlXPathGetElementsByIds(ctxt->context->doc, tokens);
8677	ret = xmlXPathNodeSetMerge(ret, ns);
8678	xmlXPathFreeNodeSet(ns);
8679	if (tokens != NULL)
8680	xmlFree(tokens);
8681	}
8682	}
8683	xmlXPathReleaseObject(ctxt->context, obj);
8684	valuePush(ctxt, xmlXPathCacheWrapNodeSet(ctxt->context, ret));
8685	return;
8686	}
8687	obj = xmlXPathCacheConvertString(ctxt->context, obj);
8688	ret = xmlXPathGetElementsByIds(ctxt->context->doc, obj->stringval);
8689	valuePush(ctxt, xmlXPathCacheWrapNodeSet(ctxt->context, ret));
8690	xmlXPathReleaseObject(ctxt->context, obj);
8691	return;
8692	}
8693
8694	/**
8695	* xmlXPathLocalNameFunction:
8696	* @ctxt: the XPath Parser context
8697	* @nargs: the number of arguments
8698	*
8699	* Implement the local-name() XPath function
8700	* string local-name(node-set?)
8701	* The local-name function returns a string containing the local part
8702	* of the name of the node in the argument node-set that is first in
8703	* document order. If the node-set is empty or the first node has no
8704	* name, an empty string is returned. If the argument is omitted it
8705	* defaults to the context node.
8706	*/
8707	void
8708	xmlXPathLocalNameFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8709	xmlXPathObjectPtr cur;
8710
8711	if (ctxt == NULL) return;
8712
8713	if (nargs == 0) {
8714	valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context,
8715	ctxt->context->node));
8716	nargs = 1;
8717	}
8718
8719	CHECK_ARITY(1);
8720	if ((ctxt->value == NULL) \|\|
8721	((ctxt->value->type != XPATH_NODESET) &&
8722	(ctxt->value->type != XPATH_XSLT_TREE)))
8723	XP_ERROR(XPATH_INVALID_TYPE);
8724	cur = valuePop(ctxt);
8725
8726	if ((cur->nodesetval == NULL) \|\| (cur->nodesetval->nodeNr == 0)) {
8727	valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, ""));
8728	} else {
8729	int i = 0; /* Should be first in document order !!!!! */
8730	switch (cur->nodesetval->nodeTab[i]->type) {
8731	case XML_ELEMENT_NODE:
8732	case XML_ATTRIBUTE_NODE:
8733	case XML_PI_NODE:
8734	if (cur->nodesetval->nodeTab[i]->name[0] == ' ')
8735	valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, ""));
8736	else
8737	valuePush(ctxt,
8738	xmlXPathCacheNewString(ctxt->context,
8739	cur->nodesetval->nodeTab[i]->name));
8740	break;
8741	case XML_NAMESPACE_DECL:
8742	valuePush(ctxt, xmlXPathCacheNewString(ctxt->context,
8743	((xmlNsPtr)cur->nodesetval->nodeTab[i])->prefix));
8744	break;
8745	default:
8746	valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, ""));
8747	}
8748	}
8749	xmlXPathReleaseObject(ctxt->context, cur);
8750	}
8751
8752	/**
8753	* xmlXPathNamespaceURIFunction:
8754	* @ctxt: the XPath Parser context
8755	* @nargs: the number of arguments
8756	*
8757	* Implement the namespace-uri() XPath function
8758	* string namespace-uri(node-set?)
8759	* The namespace-uri function returns a string containing the
8760	* namespace URI of the expanded name of the node in the argument
8761	* node-set that is first in document order. If the node-set is empty,
8762	* the first node has no name, or the expanded name has no namespace
8763	* URI, an empty string is returned. If the argument is omitted it
8764	* defaults to the context node.
8765	*/
8766	void
8767	xmlXPathNamespaceURIFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8768	xmlXPathObjectPtr cur;
8769
8770	if (ctxt == NULL) return;
8771
8772	if (nargs == 0) {
8773	valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context,
8774	ctxt->context->node));
8775	nargs = 1;
8776	}
8777	CHECK_ARITY(1);
8778	if ((ctxt->value == NULL) \|\|
8779	((ctxt->value->type != XPATH_NODESET) &&
8780	(ctxt->value->type != XPATH_XSLT_TREE)))
8781	XP_ERROR(XPATH_INVALID_TYPE);
8782	cur = valuePop(ctxt);
8783
8784	if ((cur->nodesetval == NULL) \|\| (cur->nodesetval->nodeNr == 0)) {
8785	valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, ""));
8786	} else {
8787	int i = 0; /* Should be first in document order !!!!! */
8788	switch (cur->nodesetval->nodeTab[i]->type) {
8789	case XML_ELEMENT_NODE:
8790	case XML_ATTRIBUTE_NODE:
8791	if (cur->nodesetval->nodeTab[i]->ns == NULL)
8792	valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, ""));
8793	else
8794	valuePush(ctxt, xmlXPathCacheNewString(ctxt->context,
8795	cur->nodesetval->nodeTab[i]->ns->href));
8796	break;
8797	default:
8798	valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, ""));
8799	}
8800	}
8801	xmlXPathReleaseObject(ctxt->context, cur);
8802	}
8803
8804	/**
8805	* xmlXPathNameFunction:
8806	* @ctxt: the XPath Parser context
8807	* @nargs: the number of arguments
8808	*
8809	* Implement the name() XPath function
8810	* string name(node-set?)
8811	* The name function returns a string containing a QName representing
8812	* the name of the node in the argument node-set that is first in document
8813	* order. The QName must represent the name with respect to the namespace
8814	* declarations in effect on the node whose name is being represented.
8815	* Typically, this will be the form in which the name occurred in the XML
8816	* source. This need not be the case if there are namespace declarations
8817	* in effect on the node that associate multiple prefixes with the same
8818	* namespace. However, an implementation may include information about
8819	* the original prefix in its representation of nodes; in this case, an
8820	* implementation can ensure that the returned string is always the same
8821	* as the QName used in the XML source. If the argument it omitted it
8822	* defaults to the context node.
8823	* Libxml keep the original prefix so the "real qualified name" used is
8824	* returned.
8825	*/
8826	static void
8827	xmlXPathNameFunction(xmlXPathParserContextPtr ctxt, int nargs)
8828	{
8829	xmlXPathObjectPtr cur;
8830
8831	if (nargs == 0) {
8832	valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context,
8833	ctxt->context->node));
8834	nargs = 1;
8835	}
8836
8837	CHECK_ARITY(1);
8838	if ((ctxt->value == NULL) \|\|
8839	((ctxt->value->type != XPATH_NODESET) &&
8840	(ctxt->value->type != XPATH_XSLT_TREE)))
8841	XP_ERROR(XPATH_INVALID_TYPE);
8842	cur = valuePop(ctxt);
8843
8844	if ((cur->nodesetval == NULL) \|\| (cur->nodesetval->nodeNr == 0)) {
8845	valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, ""));
8846	} else {
8847	int i = 0; /* Should be first in document order !!!!! */
8848
8849	switch (cur->nodesetval->nodeTab[i]->type) {
8850	case XML_ELEMENT_NODE:
8851	case XML_ATTRIBUTE_NODE:
8852	if (cur->nodesetval->nodeTab[i]->name[0] == ' ')
8853	valuePush(ctxt,
8854	xmlXPathCacheNewCString(ctxt->context, ""));
8855	else if ((cur->nodesetval->nodeTab[i]->ns == NULL) \|\|
8856	(cur->nodesetval->nodeTab[i]->ns->prefix == NULL)) {
8857	valuePush(ctxt,
8858	xmlXPathCacheNewString(ctxt->context,
8859	cur->nodesetval->nodeTab[i]->name));
8860	} else {
8861	xmlChar *fullname;
8862
8863	fullname = xmlBuildQName(cur->nodesetval->nodeTab[i]->name,
8864	cur->nodesetval->nodeTab[i]->ns->prefix,
8865	NULL, 0);
8866	if (fullname == cur->nodesetval->nodeTab[i]->name)
8867	fullname = xmlStrdup(cur->nodesetval->nodeTab[i]->name);
8868	if (fullname == NULL) {
8869	XP_ERROR(XPATH_MEMORY_ERROR);
8870	}
8871	valuePush(ctxt, xmlXPathCacheWrapString(
8872	ctxt->context, fullname));
8873	}
8874	break;
8875	default:
8876	valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context,
8877	cur->nodesetval->nodeTab[i]));
8878	xmlXPathLocalNameFunction(ctxt, 1);
8879	}
8880	}
8881	xmlXPathReleaseObject(ctxt->context, cur);
8882	}
8883
8884
8885	/**
8886	* xmlXPathStringFunction:
8887	* @ctxt: the XPath Parser context
8888	* @nargs: the number of arguments
8889	*
8890	* Implement the string() XPath function
8891	* string string(object?)
8892	* The string function converts an object to a string as follows:
8893	* - A node-set is converted to a string by returning the value of
8894	* the node in the node-set that is first in document order.
8895	* If the node-set is empty, an empty string is returned.
8896	* - A number is converted to a string as follows
8897	* + NaN is converted to the string NaN
8898	* + positive zero is converted to the string 0
8899	* + negative zero is converted to the string 0
8900	* + positive infinity is converted to the string Infinity
8901	* + negative infinity is converted to the string -Infinity
8902	* + if the number is an integer, the number is represented in
8903	* decimal form as a Number with no decimal point and no leading
8904	* zeros, preceded by a minus sign (-) if the number is negative
8905	* + otherwise, the number is represented in decimal form as a
8906	* Number including a decimal point with at least one digit
8907	* before the decimal point and at least one digit after the
8908	* decimal point, preceded by a minus sign (-) if the number
8909	* is negative; there must be no leading zeros before the decimal
8910	* point apart possibly from the one required digit immediately
8911	* before the decimal point; beyond the one required digit
8912	* after the decimal point there must be as many, but only as
8913	* many, more digits as are needed to uniquely distinguish the
8914	* number from all other IEEE 754 numeric values.
8915	* - The boolean false value is converted to the string false.
8916	* The boolean true value is converted to the string true.
8917	*
8918	* If the argument is omitted, it defaults to a node-set with the
8919	* context node as its only member.
8920	*/
8921	void
8922	xmlXPathStringFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8923	xmlXPathObjectPtr cur;
8924
8925	if (ctxt == NULL) return;
8926	if (nargs == 0) {
8927	valuePush(ctxt,
8928	xmlXPathCacheWrapString(ctxt->context,
8929	xmlXPathCastNodeToString(ctxt->context->node)));
8930	return;
8931	}
8932
8933	CHECK_ARITY(1);
8934	cur = valuePop(ctxt);
8935	if (cur == NULL) XP_ERROR(XPATH_INVALID_OPERAND);
8936	valuePush(ctxt, xmlXPathCacheConvertString(ctxt->context, cur));
8937	}
8938
8939	/**
8940	* xmlXPathStringLengthFunction:
8941	* @ctxt: the XPath Parser context
8942	* @nargs: the number of arguments
8943	*
8944	* Implement the string-length() XPath function
8945	* number string-length(string?)
8946	* The string-length returns the number of characters in the string
8947	* (see [3.6 Strings]). If the argument is omitted, it defaults to
8948	* the context node converted to a string, in other words the value
8949	* of the context node.
8950	*/
8951	void
8952	xmlXPathStringLengthFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8953	xmlXPathObjectPtr cur;
8954
8955	if (nargs == 0) {
8956	if ((ctxt == NULL) \|\| (ctxt->context == NULL))
8957	return;
8958	if (ctxt->context->node == NULL) {
8959	valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, 0));
8960	} else {
8961	xmlChar *content;
8962
8963	content = xmlXPathCastNodeToString(ctxt->context->node);
8964	valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context,
8965	xmlUTF8Strlen(content)));
8966	xmlFree(content);
8967	}
8968	return;
8969	}
8970	CHECK_ARITY(1);
8971	CAST_TO_STRING;
8972	CHECK_TYPE(XPATH_STRING);
8973	cur = valuePop(ctxt);
8974	valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context,
8975	xmlUTF8Strlen(cur->stringval)));
8976	xmlXPathReleaseObject(ctxt->context, cur);
8977	}
8978
8979	/**
8980	* xmlXPathConcatFunction:
8981	* @ctxt: the XPath Parser context
8982	* @nargs: the number of arguments
8983	*
8984	* Implement the concat() XPath function
8985	* string concat(string, string, string*)
8986	* The concat function returns the concatenation of its arguments.
8987	*/
8988	void
8989	xmlXPathConcatFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8990	xmlXPathObjectPtr cur, newobj;
8991	xmlChar *tmp;
8992
8993	if (ctxt == NULL) return;
8994	if (nargs < 2) {
8995	CHECK_ARITY(2);
8996	}
8997
8998	CAST_TO_STRING;
8999	cur = valuePop(ctxt);
9000	if ((cur == NULL) \|\| (cur->type != XPATH_STRING)) {
9001	xmlXPathReleaseObject(ctxt->context, cur);
9002	return;
9003	}
9004	nargs--;
9005
9006	while (nargs > 0) {
9007	CAST_TO_STRING;
9008	newobj = valuePop(ctxt);
9009	if ((newobj == NULL) \|\| (newobj->type != XPATH_STRING)) {
9010	xmlXPathReleaseObject(ctxt->context, newobj);
9011	xmlXPathReleaseObject(ctxt->context, cur);
9012	XP_ERROR(XPATH_INVALID_TYPE);
9013	}
9014	tmp = xmlStrcat(newobj->stringval, cur->stringval);
9015	newobj->stringval = cur->stringval;
9016	cur->stringval = tmp;
9017	xmlXPathReleaseObject(ctxt->context, newobj);
9018	nargs--;
9019	}
9020	valuePush(ctxt, cur);
9021	}
9022
9023	/**
9024	* xmlXPathContainsFunction:
9025	* @ctxt: the XPath Parser context
9026	* @nargs: the number of arguments
9027	*
9028	* Implement the contains() XPath function
9029	* boolean contains(string, string)
9030	* The contains function returns true if the first argument string
9031	* contains the second argument string, and otherwise returns false.
9032	*/
9033	void
9034	xmlXPathContainsFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9035	xmlXPathObjectPtr hay, needle;
9036
9037	CHECK_ARITY(2);
9038	CAST_TO_STRING;
9039	CHECK_TYPE(XPATH_STRING);
9040	needle = valuePop(ctxt);
9041	CAST_TO_STRING;
9042	hay = valuePop(ctxt);
9043
9044	if ((hay == NULL) \|\| (hay->type != XPATH_STRING)) {
9045	xmlXPathReleaseObject(ctxt->context, hay);
9046	xmlXPathReleaseObject(ctxt->context, needle);
9047	XP_ERROR(XPATH_INVALID_TYPE);
9048	}
9049	if (xmlStrstr(hay->stringval, needle->stringval))
9050	valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, 1));
9051	else
9052	valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, 0));
9053	xmlXPathReleaseObject(ctxt->context, hay);
9054	xmlXPathReleaseObject(ctxt->context, needle);
9055	}
9056
9057	/**
9058	* xmlXPathStartsWithFunction:
9059	* @ctxt: the XPath Parser context
9060	* @nargs: the number of arguments
9061	*
9062	* Implement the starts-with() XPath function
9063	* boolean starts-with(string, string)
9064	* The starts-with function returns true if the first argument string
9065	* starts with the second argument string, and otherwise returns false.
9066	*/
9067	void
9068	xmlXPathStartsWithFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9069	xmlXPathObjectPtr hay, needle;
9070	int n;
9071
9072	CHECK_ARITY(2);
9073	CAST_TO_STRING;
9074	CHECK_TYPE(XPATH_STRING);
9075	needle = valuePop(ctxt);
9076	CAST_TO_STRING;
9077	hay = valuePop(ctxt);
9078
9079	if ((hay == NULL) \|\| (hay->type != XPATH_STRING)) {
9080	xmlXPathReleaseObject(ctxt->context, hay);
9081	xmlXPathReleaseObject(ctxt->context, needle);
9082	XP_ERROR(XPATH_INVALID_TYPE);
9083	}
9084	n = xmlStrlen(needle->stringval);
9085	if (xmlStrncmp(hay->stringval, needle->stringval, n))
9086	valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, 0));
9087	else
9088	valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, 1));
9089	xmlXPathReleaseObject(ctxt->context, hay);
9090	xmlXPathReleaseObject(ctxt->context, needle);
9091	}
9092
9093	/**
9094	* xmlXPathSubstringFunction:
9095	* @ctxt: the XPath Parser context
9096	* @nargs: the number of arguments
9097	*
9098	* Implement the substring() XPath function
9099	* string substring(string, number, number?)
9100	* The substring function returns the substring of the first argument
9101	* starting at the position specified in the second argument with
9102	* length specified in the third argument. For example,
9103	* substring("12345",2,3) returns "234". If the third argument is not
9104	* specified, it returns the substring starting at the position specified
9105	* in the second argument and continuing to the end of the string. For
9106	* example, substring("12345",2) returns "2345". More precisely, each
9107	* character in the string (see [3.6 Strings]) is considered to have a
9108	* numeric position: the position of the first character is 1, the position
9109	* of the second character is 2 and so on. The returned substring contains
9110	* those characters for which the position of the character is greater than
9111	* or equal to the second argument and, if the third argument is specified,
9112	* less than the sum of the second and third arguments; the comparisons
9113	* and addition used for the above follow the standard IEEE 754 rules. Thus:
9114	* - substring("12345", 1.5, 2.6) returns "234"
9115	* - substring("12345", 0, 3) returns "12"
9116	* - substring("12345", 0 div 0, 3) returns ""
9117	* - substring("12345", 1, 0 div 0) returns ""
9118	* - substring("12345", -42, 1 div 0) returns "12345"
9119	* - substring("12345", -1 div 0, 1 div 0) returns ""
9120	*/
9121	void
9122	xmlXPathSubstringFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9123	xmlXPathObjectPtr str, start, len;
9124	double le=0, in;
9125	int i, l, m;
9126	xmlChar *ret;
9127
9128	if (nargs < 2) {
9129	CHECK_ARITY(2);
9130	}
9131	if (nargs > 3) {
9132	CHECK_ARITY(3);
9133	}
9134	/*
9135	* take care of possible last (position) argument
9136	*/
9137	if (nargs == 3) {
9138	CAST_TO_NUMBER;
9139	CHECK_TYPE(XPATH_NUMBER);
9140	len = valuePop(ctxt);
9141	le = len->floatval;
9142	xmlXPathReleaseObject(ctxt->context, len);
9143	}
9144
9145	CAST_TO_NUMBER;
9146	CHECK_TYPE(XPATH_NUMBER);
9147	start = valuePop(ctxt);
9148	in = start->floatval;
9149	xmlXPathReleaseObject(ctxt->context, start);
9150	CAST_TO_STRING;
9151	CHECK_TYPE(XPATH_STRING);
9152	str = valuePop(ctxt);
9153	m = xmlUTF8Strlen((const unsigned char *)str->stringval);
9154
9155	/*
9156	* If last pos not present, calculate last position
9157	*/
9158	if (nargs != 3) {
9159	le = (double)m;
9160	if (in < 1.0)
9161	in = 1.0;
9162	}
9163
9164	/* Need to check for the special cases where either
9165	* the index is NaN, the length is NaN, or both
9166	* arguments are infinity (relying on Inf + -Inf = NaN)
9167	*/
9168	if (!xmlXPathIsInf(in) && !xmlXPathIsNaN(in + le)) {
9169	/*
9170	* To meet the requirements of the spec, the arguments
9171	* must be converted to integer format before
9172	* initial index calculations are done
9173	*
9174	* First we go to integer form, rounding up
9175	* and checking for special cases
9176	*/
9177	i = (int) in;
9178	if (((double)i)+0.5 <= in) i++;
9179
9180	if (xmlXPathIsInf(le) == 1) {
9181	l = m;
9182	if (i < 1)
9183	i = 1;
9184	}
9185	else if (xmlXPathIsInf(le) == -1 \|\| le < 0.0)
9186	l = 0;
9187	else {
9188	l = (int) le;
9189	if (((double)l)+0.5 <= le) l++;
9190	}
9191
9192	/* Now we normalize inidices */
9193	i -= 1;
9194	l += i;
9195	if (i < 0)
9196	i = 0;
9197	if (l > m)
9198	l = m;
9199
9200	/* number of chars to copy */
9201	l -= i;
9202
9203	ret = xmlUTF8Strsub(str->stringval, i, l);
9204	}
9205	else {
9206	ret = NULL;
9207	}
9208	if (ret == NULL)
9209	valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, ""));
9210	else {
9211	valuePush(ctxt, xmlXPathCacheNewString(ctxt->context, ret));
9212	xmlFree(ret);
9213	}
9214	xmlXPathReleaseObject(ctxt->context, str);
9215	}
9216
9217	/**
9218	* xmlXPathSubstringBeforeFunction:
9219	* @ctxt: the XPath Parser context
9220	* @nargs: the number of arguments
9221	*
9222	* Implement the substring-before() XPath function
9223	* string substring-before(string, string)
9224	* The substring-before function returns the substring of the first
9225	* argument string that precedes the first occurrence of the second
9226	* argument string in the first argument string, or the empty string
9227	* if the first argument string does not contain the second argument
9228	* string. For example, substring-before("1999/04/01","/") returns 1999.
9229	*/
9230	void
9231	xmlXPathSubstringBeforeFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9232	xmlXPathObjectPtr str;
9233	xmlXPathObjectPtr find;
9234	xmlBufPtr target;
9235	const xmlChar *point;
9236	int offset;
9237
9238	CHECK_ARITY(2);
9239	CAST_TO_STRING;
9240	find = valuePop(ctxt);
9241	CAST_TO_STRING;
9242	str = valuePop(ctxt);
9243
9244	target = xmlBufCreate();
9245	if (target) {
9246	point = xmlStrstr(str->stringval, find->stringval);
9247	if (point) {
9248	offset = (int)(point - str->stringval);
9249	xmlBufAdd(target, str->stringval, offset);
9250	}
9251	valuePush(ctxt, xmlXPathCacheNewString(ctxt->context,
9252	xmlBufContent(target)));
9253	xmlBufFree(target);
9254	}
9255	xmlXPathReleaseObject(ctxt->context, str);
9256	xmlXPathReleaseObject(ctxt->context, find);
9257	}
9258
9259	/**
9260	* xmlXPathSubstringAfterFunction:
9261	* @ctxt: the XPath Parser context
9262	* @nargs: the number of arguments
9263	*
9264	* Implement the substring-after() XPath function
9265	* string substring-after(string, string)
9266	* The substring-after function returns the substring of the first
9267	* argument string that follows the first occurrence of the second
9268	* argument string in the first argument string, or the empty stringi
9269	* if the first argument string does not contain the second argument
9270	* string. For example, substring-after("1999/04/01","/") returns 04/01,
9271	* and substring-after("1999/04/01","19") returns 99/04/01.
9272	*/
9273	void
9274	xmlXPathSubstringAfterFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9275	xmlXPathObjectPtr str;
9276	xmlXPathObjectPtr find;
9277	xmlBufPtr target;
9278	const xmlChar *point;
9279	int offset;
9280
9281	CHECK_ARITY(2);
9282	CAST_TO_STRING;
9283	find = valuePop(ctxt);
9284	CAST_TO_STRING;
9285	str = valuePop(ctxt);
9286
9287	target = xmlBufCreate();
9288	if (target) {
9289	point = xmlStrstr(str->stringval, find->stringval);
9290	if (point) {
9291	offset = (int)(point - str->stringval) + xmlStrlen(find->stringval);
9292	xmlBufAdd(target, &str->stringval[offset],
9293	xmlStrlen(str->stringval) - offset);
9294	}
9295	valuePush(ctxt, xmlXPathCacheNewString(ctxt->context,
9296	xmlBufContent(target)));
9297	xmlBufFree(target);
9298	}
9299	xmlXPathReleaseObject(ctxt->context, str);
9300	xmlXPathReleaseObject(ctxt->context, find);
9301	}
9302
9303	/**
9304	* xmlXPathNormalizeFunction:
9305	* @ctxt: the XPath Parser context
9306	* @nargs: the number of arguments
9307	*
9308	* Implement the normalize-space() XPath function
9309	* string normalize-space(string?)
9310	* The normalize-space function returns the argument string with white
9311	* space normalized by stripping leading and trailing whitespace
9312	* and replacing sequences of whitespace characters by a single
9313	* space. Whitespace characters are the same allowed by the S production
9314	* in XML. If the argument is omitted, it defaults to the context
9315	* node converted to a string, in other words the value of the context node.
9316	*/
9317	void
9318	xmlXPathNormalizeFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9319	xmlXPathObjectPtr obj = NULL;
9320	xmlChar *source = NULL;
9321	xmlBufPtr target;
9322	xmlChar blank;
9323
9324	if (ctxt == NULL) return;
9325	if (nargs == 0) {
9326	/* Use current context node */
9327	valuePush(ctxt,
9328	xmlXPathCacheWrapString(ctxt->context,
9329	xmlXPathCastNodeToString(ctxt->context->node)));
9330	nargs = 1;
9331	}
9332
9333	CHECK_ARITY(1);
9334	CAST_TO_STRING;
9335	CHECK_TYPE(XPATH_STRING);
9336	obj = valuePop(ctxt);
9337	source = obj->stringval;
9338
9339	target = xmlBufCreate();
9340	if (target && source) {
9341
9342	/* Skip leading whitespaces */
9343	while (IS_BLANK_CH(*source))
9344	source++;
9345
9346	/* Collapse intermediate whitespaces, and skip trailing whitespaces */
9347	blank = 0;
9348	while (*source) {
9349	if (IS_BLANK_CH(*source)) {
9350	blank = 0x20;
9351	} else {
9352	if (blank) {
9353	xmlBufAdd(target, &blank, 1);
9354	blank = 0;
9355	}
9356	xmlBufAdd(target, source, 1);
9357	}
9358	source++;
9359	}
9360	valuePush(ctxt, xmlXPathCacheNewString(ctxt->context,
9361	xmlBufContent(target)));
9362	xmlBufFree(target);
9363	}
9364	xmlXPathReleaseObject(ctxt->context, obj);
9365	}
9366
9367	/**
9368	* xmlXPathTranslateFunction:
9369	* @ctxt: the XPath Parser context
9370	* @nargs: the number of arguments
9371	*
9372	* Implement the translate() XPath function
9373	* string translate(string, string, string)
9374	* The translate function returns the first argument string with
9375	* occurrences of characters in the second argument string replaced
9376	* by the character at the corresponding position in the third argument
9377	* string. For example, translate("bar","abc","ABC") returns the string
9378	* BAr. If there is a character in the second argument string with no
9379	* character at a corresponding position in the third argument string
9380	* (because the second argument string is longer than the third argument
9381	* string), then occurrences of that character in the first argument
9382	* string are removed. For example, translate("--aaa--","abc-","ABC")
9383	* returns "AAA". If a character occurs more than once in second
9384	* argument string, then the first occurrence determines the replacement
9385	* character. If the third argument string is longer than the second
9386	* argument string, then excess characters are ignored.
9387	*/
9388	void
9389	xmlXPathTranslateFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9390	xmlXPathObjectPtr str;
9391	xmlXPathObjectPtr from;
9392	xmlXPathObjectPtr to;
9393	xmlBufPtr target;
9394	int offset, max;
9395	xmlChar ch;
9396	const xmlChar *point;
9397	xmlChar *cptr;
9398
9399	CHECK_ARITY(3);
9400
9401	CAST_TO_STRING;
9402	to = valuePop(ctxt);
9403	CAST_TO_STRING;
9404	from = valuePop(ctxt);
9405	CAST_TO_STRING;
9406	str = valuePop(ctxt);
9407
9408	target = xmlBufCreate();
9409	if (target) {
9410	max = xmlUTF8Strlen(to->stringval);
9411	for (cptr = str->stringval; (ch=*cptr); ) {
9412	offset = xmlUTF8Strloc(from->stringval, cptr);
9413	if (offset >= 0) {
9414	if (offset < max) {
9415	point = xmlUTF8Strpos(to->stringval, offset);
9416	if (point)
9417	xmlBufAdd(target, point, xmlUTF8Strsize(point, 1));
9418	}
9419	} else
9420	xmlBufAdd(target, cptr, xmlUTF8Strsize(cptr, 1));
9421
9422	/* Step to next character in input */
9423	cptr++;
9424	if ( ch & 0x80 ) {
9425	/* if not simple ascii, verify proper format */
9426	if ( (ch & 0xc0) != 0xc0 ) {
9427	xmlGenericError(xmlGenericErrorContext,
9428	"xmlXPathTranslateFunction: Invalid UTF8 string\n");
9429	/* not asserting an XPath error is probably better */
9430	break;
9431	}
9432	/* then skip over remaining bytes for this char */
9433	while ( (ch <<= 1) & 0x80 )
9434	if ( (*cptr++ & 0xc0) != 0x80 ) {
9435	xmlGenericError(xmlGenericErrorContext,
9436	"xmlXPathTranslateFunction: Invalid UTF8 string\n");
9437	/* not asserting an XPath error is probably better */
9438	break;
9439	}
9440	if (ch & 0x80) /* must have had error encountered */
9441	break;
9442	}
9443	}
9444	}
9445	valuePush(ctxt, xmlXPathCacheNewString(ctxt->context,
9446	xmlBufContent(target)));
9447	xmlBufFree(target);
9448	xmlXPathReleaseObject(ctxt->context, str);
9449	xmlXPathReleaseObject(ctxt->context, from);
9450	xmlXPathReleaseObject(ctxt->context, to);
9451	}
9452
9453	/**
9454	* xmlXPathBooleanFunction:
9455	* @ctxt: the XPath Parser context
9456	* @nargs: the number of arguments
9457	*
9458	* Implement the boolean() XPath function
9459	* boolean boolean(object)
9460	* The boolean function converts its argument to a boolean as follows:
9461	* - a number is true if and only if it is neither positive or
9462	* negative zero nor NaN
9463	* - a node-set is true if and only if it is non-empty
9464	* - a string is true if and only if its length is non-zero
9465	*/
9466	void
9467	xmlXPathBooleanFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9468	xmlXPathObjectPtr cur;
9469
9470	CHECK_ARITY(1);
9471	cur = valuePop(ctxt);
9472	if (cur == NULL) XP_ERROR(XPATH_INVALID_OPERAND);
9473	cur = xmlXPathCacheConvertBoolean(ctxt->context, cur);
9474	valuePush(ctxt, cur);
9475	}
9476
9477	/**
9478	* xmlXPathNotFunction:
9479	* @ctxt: the XPath Parser context
9480	* @nargs: the number of arguments
9481	*
9482	* Implement the not() XPath function
9483	* boolean not(boolean)
9484	* The not function returns true if its argument is false,
9485	* and false otherwise.
9486	*/
9487	void
9488	xmlXPathNotFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9489	CHECK_ARITY(1);
9490	CAST_TO_BOOLEAN;
9491	CHECK_TYPE(XPATH_BOOLEAN);
9492	ctxt->value->boolval = ! ctxt->value->boolval;
9493	}
9494
9495	/**
9496	* xmlXPathTrueFunction:
9497	* @ctxt: the XPath Parser context
9498	* @nargs: the number of arguments
9499	*
9500	* Implement the true() XPath function
9501	* boolean true()
9502	*/
9503	void
9504	xmlXPathTrueFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9505	CHECK_ARITY(0);
9506	valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, 1));
9507	}
9508
9509	/**
9510	* xmlXPathFalseFunction:
9511	* @ctxt: the XPath Parser context
9512	* @nargs: the number of arguments
9513	*
9514	* Implement the false() XPath function
9515	* boolean false()
9516	*/
9517	void
9518	xmlXPathFalseFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9519	CHECK_ARITY(0);
9520	valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, 0));
9521	}
9522
9523	/**
9524	* xmlXPathLangFunction:
9525	* @ctxt: the XPath Parser context
9526	* @nargs: the number of arguments
9527	*
9528	* Implement the lang() XPath function
9529	* boolean lang(string)
9530	* The lang function returns true or false depending on whether the
9531	* language of the context node as specified by xml:lang attributes
9532	* is the same as or is a sublanguage of the language specified by
9533	* the argument string. The language of the context node is determined
9534	* by the value of the xml:lang attribute on the context node, or, if
9535	* the context node has no xml:lang attribute, by the value of the
9536	* xml:lang attribute on the nearest ancestor of the context node that
9537	* has an xml:lang attribute. If there is no such attribute, then lang
9538	* returns false. If there is such an attribute, then lang returns
9539	* true if the attribute value is equal to the argument ignoring case,
9540	* or if there is some suffix starting with - such that the attribute
9541	* value is equal to the argument ignoring that suffix of the attribute
9542	* value and ignoring case.
9543	*/
9544	void
9545	xmlXPathLangFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9546	xmlXPathObjectPtr val = NULL;
9547	const xmlChar *theLang = NULL;
9548	const xmlChar *lang;
9549	int ret = 0;
9550	int i;
9551
9552	CHECK_ARITY(1);
9553	CAST_TO_STRING;
9554	CHECK_TYPE(XPATH_STRING);
9555	val = valuePop(ctxt);
9556	lang = val->stringval;
9557	theLang = xmlNodeGetLang(ctxt->context->node);
9558	if ((theLang != NULL) && (lang != NULL)) {
9559	for (i = 0;lang[i] != 0;i++)
9560	if (toupper(lang[i]) != toupper(theLang[i]))
9561	goto not_equal;
9562	if ((theLang[i] == 0) \|\| (theLang[i] == '-'))
9563	ret = 1;
9564	}
9565	not_equal:
9566	if (theLang != NULL)
9567	xmlFree((void *)theLang);
9568
9569	xmlXPathReleaseObject(ctxt->context, val);
9570	valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, ret));
9571	}
9572
9573	/**
9574	* xmlXPathNumberFunction:
9575	* @ctxt: the XPath Parser context
9576	* @nargs: the number of arguments
9577	*
9578	* Implement the number() XPath function
9579	* number number(object?)
9580	*/
9581	void
9582	xmlXPathNumberFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9583	xmlXPathObjectPtr cur;
9584	double res;
9585
9586	if (ctxt == NULL) return;
9587	if (nargs == 0) {
9588	if (ctxt->context->node == NULL) {
9589	valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, 0.0));
9590	} else {
9591	xmlChar* content = xmlNodeGetContent(ctxt->context->node);
9592
9593	res = xmlXPathStringEvalNumber(content);
9594	valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, res));
9595	xmlFree(content);
9596	}
9597	return;
9598	}
9599
9600	CHECK_ARITY(1);
9601	cur = valuePop(ctxt);
9602	valuePush(ctxt, xmlXPathCacheConvertNumber(ctxt->context, cur));
9603	}
9604
9605	/**
9606	* xmlXPathSumFunction:
9607	* @ctxt: the XPath Parser context
9608	* @nargs: the number of arguments
9609	*
9610	* Implement the sum() XPath function
9611	* number sum(node-set)
9612	* The sum function returns the sum of the values of the nodes in
9613	* the argument node-set.
9614	*/
9615	void
9616	xmlXPathSumFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9617	xmlXPathObjectPtr cur;
9618	int i;
9619	double res = 0.0;
9620
9621	CHECK_ARITY(1);
9622	if ((ctxt->value == NULL) \|\|
9623	((ctxt->value->type != XPATH_NODESET) &&
9624	(ctxt->value->type != XPATH_XSLT_TREE)))
9625	XP_ERROR(XPATH_INVALID_TYPE);
9626	cur = valuePop(ctxt);
9627
9628	if ((cur->nodesetval != NULL) && (cur->nodesetval->nodeNr != 0)) {
9629	for (i = 0; i < cur->nodesetval->nodeNr; i++) {
9630	res += xmlXPathCastNodeToNumber(cur->nodesetval->nodeTab[i]);
9631	}
9632	}
9633	valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, res));
9634	xmlXPathReleaseObject(ctxt->context, cur);
9635	}
9636
9637	/*
9638	* To assure working code on multiple platforms, we want to only depend
9639	* upon the characteristic truncation of converting a floating point value
9640	* to an integer. Unfortunately, because of the different storage sizes
9641	* of our internal floating point value (double) and integer (int), we
9642	* can't directly convert (see bug 301162). This macro is a messy
9643	* 'workaround'
9644	*/
9645	#define XTRUNC(f, v) \
9646	f = fmod((v), INT_MAX); \
9647	f = (v) - (f) + (double)((int)(f));
9648
9649	/**
9650	* xmlXPathFloorFunction:
9651	* @ctxt: the XPath Parser context
9652	* @nargs: the number of arguments
9653	*
9654	* Implement the floor() XPath function
9655	* number floor(number)
9656	* The floor function returns the largest (closest to positive infinity)
9657	* number that is not greater than the argument and that is an integer.
9658	*/
9659	void
9660	xmlXPathFloorFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9661	double f;
9662
9663	CHECK_ARITY(1);
9664	CAST_TO_NUMBER;
9665	CHECK_TYPE(XPATH_NUMBER);
9666
9667	XTRUNC(f, ctxt->value->floatval);
9668	if (f != ctxt->value->floatval) {
9669	if (ctxt->value->floatval > 0)
9670	ctxt->value->floatval = f;
9671	else
9672	ctxt->value->floatval = f - 1;
9673	}
9674	}
9675
9676	/**
9677	* xmlXPathCeilingFunction:
9678	* @ctxt: the XPath Parser context
9679	* @nargs: the number of arguments
9680	*
9681	* Implement the ceiling() XPath function
9682	* number ceiling(number)
9683	* The ceiling function returns the smallest (closest to negative infinity)
9684	* number that is not less than the argument and that is an integer.
9685	*/
9686	void
9687	xmlXPathCeilingFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9688	double f;
9689
9690	CHECK_ARITY(1);
9691	CAST_TO_NUMBER;
9692	CHECK_TYPE(XPATH_NUMBER);
9693
9694	#if 0
9695	ctxt->value->floatval = ceil(ctxt->value->floatval);
9696	#else
9697	XTRUNC(f, ctxt->value->floatval);
9698	if (f != ctxt->value->floatval) {
9699	if (ctxt->value->floatval > 0)
9700	ctxt->value->floatval = f + 1;
9701	else {
9702	if (ctxt->value->floatval < 0 && f == 0)
9703	ctxt->value->floatval = xmlXPathNZERO;
9704	else
9705	ctxt->value->floatval = f;
9706	}
9707
9708	}
9709	#endif
9710	}
9711
9712	/**
9713	* xmlXPathRoundFunction:
9714	* @ctxt: the XPath Parser context
9715	* @nargs: the number of arguments
9716	*
9717	* Implement the round() XPath function
9718	* number round(number)
9719	* The round function returns the number that is closest to the
9720	* argument and that is an integer. If there are two such numbers,
9721	* then the one that is even is returned.
9722	*/
9723	void
9724	xmlXPathRoundFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9725	double f;
9726
9727	CHECK_ARITY(1);
9728	CAST_TO_NUMBER;
9729	CHECK_TYPE(XPATH_NUMBER);
9730
9731	if ((xmlXPathIsNaN(ctxt->value->floatval)) \|\|
9732	(xmlXPathIsInf(ctxt->value->floatval) == 1) \|\|
9733	(xmlXPathIsInf(ctxt->value->floatval) == -1) \|\|
9734	(ctxt->value->floatval == 0.0))
9735	return;
9736
9737	XTRUNC(f, ctxt->value->floatval);
9738	if (ctxt->value->floatval < 0) {
9739	if (ctxt->value->floatval < f - 0.5)
9740	ctxt->value->floatval = f - 1;
9741	else
9742	ctxt->value->floatval = f;
9743	if (ctxt->value->floatval == 0)
9744	ctxt->value->floatval = xmlXPathNZERO;
9745	} else {
9746	if (ctxt->value->floatval < f + 0.5)
9747	ctxt->value->floatval = f;
9748	else
9749	ctxt->value->floatval = f + 1;
9750	}
9751	}
9752
9753	/************************************************************************
9754	* *
9755	* The Parser *
9756	* *
9757	************************************************************************/
9758
9759	/*
9760	* a few forward declarations since we use a recursive call based
9761	* implementation.
9762	*/
9763	static void xmlXPathCompileExpr(xmlXPathParserContextPtr ctxt, int sort);
9764	static void xmlXPathCompPredicate(xmlXPathParserContextPtr ctxt, int filter);
9765	static void xmlXPathCompLocationPath(xmlXPathParserContextPtr ctxt);
9766	static void xmlXPathCompRelativeLocationPath(xmlXPathParserContextPtr ctxt);
9767	static xmlChar * xmlXPathParseNameComplex(xmlXPathParserContextPtr ctxt,
9768	int qualified);
9769
9770	/**
9771	* xmlXPathCurrentChar:
9772	* @ctxt: the XPath parser context
9773	* @cur: pointer to the beginning of the char
9774	* @len: pointer to the length of the char read
9775	*
9776	* The current char value, if using UTF-8 this may actually span multiple
9777	* bytes in the input buffer.
9778	*
9779	* Returns the current char value and its length
9780	*/
9781
9782	static int
9783	xmlXPathCurrentChar(xmlXPathParserContextPtr ctxt, int *len) {
9784	unsigned char c;
9785	unsigned int val;
9786	const xmlChar *cur;
9787
9788	if (ctxt == NULL)
9789	return(0);
9790	cur = ctxt->cur;
9791
9792	/*
9793	* We are supposed to handle UTF8, check it's valid
9794	* From rfc2044: encoding of the Unicode values on UTF-8:
9795	*
9796	* UCS-4 range (hex.) UTF-8 octet sequence (binary)
9797	* 0000 0000-0000 007F 0xxxxxxx
9798	* 0000 0080-0000 07FF 110xxxxx 10xxxxxx
9799	* 0000 0800-0000 FFFF 1110xxxx 10xxxxxx 10xxxxxx
9800	*
9801	* Check for the 0x110000 limit too
9802	*/
9803	c = *cur;
9804	if (c & 0x80) {
9805	if ((cur[1] & 0xc0) != 0x80)
9806	goto encoding_error;
9807	if ((c & 0xe0) == 0xe0) {
9808
9809	if ((cur[2] & 0xc0) != 0x80)
9810	goto encoding_error;
9811	if ((c & 0xf0) == 0xf0) {
9812	if (((c & 0xf8) != 0xf0) \|\|
9813	((cur[3] & 0xc0) != 0x80))
9814	goto encoding_error;
9815	/* 4-byte code */
9816	*len = 4;
9817	val = (cur[0] & 0x7) << 18;
9818	val \|= (cur[1] & 0x3f) << 12;
9819	val \|= (cur[2] & 0x3f) << 6;
9820	val \|= cur[3] & 0x3f;
9821	} else {
9822	/* 3-byte code */
9823	*len = 3;
9824	val = (cur[0] & 0xf) << 12;
9825	val \|= (cur[1] & 0x3f) << 6;
9826	val \|= cur[2] & 0x3f;
9827	}
9828	} else {
9829	/* 2-byte code */
9830	*len = 2;
9831	val = (cur[0] & 0x1f) << 6;
9832	val \|= cur[1] & 0x3f;
9833	}
9834	if (!IS_CHAR(val)) {
9835	XP_ERROR0(XPATH_INVALID_CHAR_ERROR);
9836	}
9837	return(val);
9838	} else {
9839	/* 1-byte code */
9840	*len = 1;
9841	return((int) *cur);
9842	}
9843	encoding_error:
9844	/*
9845	* If we detect an UTF8 error that probably means that the
9846	* input encoding didn't get properly advertised in the
9847	* declaration header. Report the error and switch the encoding
9848	* to ISO-Latin-1 (if you don't like this policy, just declare the
9849	* encoding !)
9850	*/
9851	*len = 0;
9852	XP_ERROR0(XPATH_ENCODING_ERROR);
9853	}
9854
9855	/**
9856	* xmlXPathParseNCName:
9857	* @ctxt: the XPath Parser context
9858	*
9859	* parse an XML namespace non qualified name.
9860	*
9861	* [NS 3] NCName ::= (Letter \| '_') (NCNameChar)*
9862	*
9863	* [NS 4] NCNameChar ::= Letter \| Digit \| '.' \| '-' \| '_' \|
9864	* CombiningChar \| Extender
9865	*
9866	* Returns the namespace name or NULL
9867	*/
9868
9869	xmlChar *
9870	xmlXPathParseNCName(xmlXPathParserContextPtr ctxt) {
9871	const xmlChar *in;
9872	xmlChar *ret;
9873	int count = 0;
9874
9875	if ((ctxt == NULL) \|\| (ctxt->cur == NULL)) return(NULL);
9876	/*
9877	* Accelerator for simple ASCII names
9878	*/
9879	in = ctxt->cur;
9880	if (((in >= 0x61) && (in <= 0x7A)) \|\|
9881	((in >= 0x41) && (in <= 0x5A)) \|\|
9882	(*in == '_')) {
9883	in++;
9884	while (((in >= 0x61) && (in <= 0x7A)) \|\|
9885	((in >= 0x41) && (in <= 0x5A)) \|\|
9886	((in >= 0x30) && (in <= 0x39)) \|\|
9887	(in == '_') \|\| (in == '.') \|\|
9888	(*in == '-'))
9889	in++;
9890	if ((in == ' ') \|\| (in == '>') \|\| (*in == '/') \|\|
9891	(in == '[') \|\| (in == ']') \|\| (*in == ':') \|\|
9892	(in == '@') \|\| (in == '*')) {
9893	count = in - ctxt->cur;
9894	if (count == 0)
9895	return(NULL);
9896	ret = xmlStrndup(ctxt->cur, count);
9897	ctxt->cur = in;
9898	return(ret);
9899	}
9900	}
9901	return(xmlXPathParseNameComplex(ctxt, 0));
9902	}
9903
9904
9905	/**
9906	* xmlXPathParseQName:
9907	* @ctxt: the XPath Parser context
9908	* @prefix: a xmlChar **
9909	*
9910	* parse an XML qualified name
9911	*
9912	* [NS 5] QName ::= (Prefix ':')? LocalPart
9913	*
9914	* [NS 6] Prefix ::= NCName
9915	*
9916	* [NS 7] LocalPart ::= NCName
9917	*
9918	* Returns the function returns the local part, and prefix is updated
9919	* to get the Prefix if any.
9920	*/
9921
9922	static xmlChar *
9923	xmlXPathParseQName(xmlXPathParserContextPtr ctxt, xmlChar **prefix) {
9924	xmlChar *ret = NULL;
9925
9926	*prefix = NULL;
9927	ret = xmlXPathParseNCName(ctxt);
9928	if (ret && CUR == ':') {
9929	*prefix = ret;
9930	NEXT;
9931	ret = xmlXPathParseNCName(ctxt);
9932	}
9933	return(ret);
9934	}
9935
9936	/**
9937	* xmlXPathParseName:
9938	* @ctxt: the XPath Parser context
9939	*
9940	* parse an XML name
9941	*
9942	* [4] NameChar ::= Letter \| Digit \| '.' \| '-' \| '_' \| ':' \|
9943	* CombiningChar \| Extender
9944	*
9945	* [5] Name ::= (Letter \| '_' \| ':') (NameChar)*
9946	*
9947	* Returns the namespace name or NULL
9948	*/
9949
9950	xmlChar *
9951	xmlXPathParseName(xmlXPathParserContextPtr ctxt) {
9952	const xmlChar *in;
9953	xmlChar *ret;
9954	size_t count = 0;
9955
9956	if ((ctxt == NULL) \|\| (ctxt->cur == NULL)) return(NULL);
9957	/*
9958	* Accelerator for simple ASCII names
9959	*/
9960	in = ctxt->cur;
9961	if (((in >= 0x61) && (in <= 0x7A)) \|\|
9962	((in >= 0x41) && (in <= 0x5A)) \|\|
9963	(in == '_') \|\| (in == ':')) {
9964	in++;
9965	while (((in >= 0x61) && (in <= 0x7A)) \|\|
9966	((in >= 0x41) && (in <= 0x5A)) \|\|
9967	((in >= 0x30) && (in <= 0x39)) \|\|
9968	(in == '_') \|\| (in == '-') \|\|
9969	(in == ':') \|\| (in == '.'))
9970	in++;
9971	if ((in > 0) && (in < 0x80)) {
9972	count = in - ctxt->cur;
9973	if (count > XML_MAX_NAME_LENGTH) {
9974	ctxt->cur = in;
9975	XP_ERRORNULL(XPATH_EXPR_ERROR);
9976	}
9977	ret = xmlStrndup(ctxt->cur, count);
9978	ctxt->cur = in;
9979	return(ret);
9980	}
9981	}
9982	return(xmlXPathParseNameComplex(ctxt, 1));
9983	}
9984
9985	static xmlChar *
9986	xmlXPathParseNameComplex(xmlXPathParserContextPtr ctxt, int qualified) {
9987	xmlChar buf[XML_MAX_NAMELEN + 5];
9988	int len = 0, l;
9989	int c;
9990
9991	/*
9992	* Handler for more complex cases
9993	*/
9994	c = CUR_CHAR(l);
9995	if ((c == ' ') \|\| (c == '>') \|\| (c == '/') \|\| /* accelerators */
9996	(c == '[') \|\| (c == ']') \|\| (c == '@') \|\| /* accelerators */
9997	(c == '') \|\| / accelerators */
9998	(!IS_LETTER(c) && (c != '_') &&
9999	((qualified) && (c != ':')))) {
10000	return(NULL);
10001	}
10002
10003	while ((c != ' ') && (c != '>') && (c != '/') && /* test bigname.xml */
10004	((IS_LETTER(c)) \|\| (IS_DIGIT(c)) \|\|
10005	(c == '.') \|\| (c == '-') \|\|
10006	(c == '_') \|\| ((qualified) && (c == ':')) \|\|
10007	(IS_COMBINING(c)) \|\|
10008	(IS_EXTENDER(c)))) {
10009	COPY_BUF(l,buf,len,c);
10010	NEXTL(l);
10011	c = CUR_CHAR(l);
10012	if (len >= XML_MAX_NAMELEN) {
10013	/*
10014	* Okay someone managed to make a huge name, so he's ready to pay
10015	* for the processing speed.
10016	*/
10017	xmlChar *buffer;
10018	int max = len * 2;
10019
10020	if (len > XML_MAX_NAME_LENGTH) {
10021	XP_ERRORNULL(XPATH_EXPR_ERROR);
10022	}
10023	buffer = (xmlChar ) xmlMallocAtomic(max sizeof(xmlChar));
10024	if (buffer == NULL) {
10025	XP_ERRORNULL(XPATH_MEMORY_ERROR);
10026	}
10027	memcpy(buffer, buf, len);
10028	while ((IS_LETTER(c)) \|\| (IS_DIGIT(c)) \|\| /* test bigname.xml */
10029	(c == '.') \|\| (c == '-') \|\|
10030	(c == '_') \|\| ((qualified) && (c == ':')) \|\|
10031	(IS_COMBINING(c)) \|\|
10032	(IS_EXTENDER(c))) {
10033	if (len + 10 > max) {
10034	if (max > XML_MAX_NAME_LENGTH) {
10035	XP_ERRORNULL(XPATH_EXPR_ERROR);
10036	}
10037	max *= 2;
10038	buffer = (xmlChar *) xmlRealloc(buffer,
10039	max * sizeof(xmlChar));
10040	if (buffer == NULL) {
10041	XP_ERRORNULL(XPATH_MEMORY_ERROR);
10042	}
10043	}
10044	COPY_BUF(l,buffer,len,c);
10045	NEXTL(l);
10046	c = CUR_CHAR(l);
10047	}
10048	buffer[len] = 0;
10049	return(buffer);
10050	}
10051	}
10052	if (len == 0)
10053	return(NULL);
10054	return(xmlStrndup(buf, len));
10055	}
10056
10057	#define MAX_FRAC 20
10058
10059	/*
10060	* These are used as divisors for the fractional part of a number.
10061	* Since the table includes 1.0 (representing '0' fractional digits),
10062	* it must be dimensioned at MAX_FRAC+1 (bug 133921)
10063	*/
10064	static double my_pow10[MAX_FRAC+1] = {
10065	1.0, 10.0, 100.0, 1000.0, 10000.0,
10066	100000.0, 1000000.0, 10000000.0, 100000000.0, 1000000000.0,
10067	10000000000.0, 100000000000.0, 1000000000000.0, 10000000000000.0,
10068	100000000000000.0,
10069	1000000000000000.0, 10000000000000000.0, 100000000000000000.0,
10070	1000000000000000000.0, 10000000000000000000.0, 100000000000000000000.0
10071	};
10072
10073	/**
10074	* xmlXPathStringEvalNumber:
10075	* @str: A string to scan
10076	*
10077	* [30a] Float ::= Number ('e' Digits?)?
10078	*
10079	* [30] Number ::= Digits ('.' Digits?)?
10080	* \| '.' Digits
10081	* [31] Digits ::= [0-9]+
10082	*
10083	* Compile a Number in the string
10084	* In complement of the Number expression, this function also handles
10085	* negative values : '-' Number.
10086	*
10087	* Returns the double value.
10088	*/
10089	double
10090	xmlXPathStringEvalNumber(const xmlChar *str) {
10091	const xmlChar *cur = str;
10092	double ret;
10093	int ok = 0;
10094	int isneg = 0;
10095	int exponent = 0;
10096	int is_exponent_negative = 0;
10097	#ifdef __GNUC__
10098	unsigned long tmp = 0;
10099	double temp;
10100	#endif
10101	if (cur == NULL) return(0);
10102	while (IS_BLANK_CH(*cur)) cur++;
10103	if ((cur != '.') && ((cur < '0') \|\| (cur > '9')) && (cur != '-')) {
10104	return(xmlXPathNAN);
10105	}
10106	if (*cur == '-') {
10107	isneg = 1;
10108	cur++;
10109	}
10110
10111	#ifdef __GNUC__
10112	/*
10113	* tmp/temp is a workaround against a gcc compiler bug
10114	* http://veillard.com/gcc.bug
10115	*/
10116	ret = 0;
10117	while ((cur >= '0') && (cur <= '9')) {
10118	ret = ret * 10;
10119	tmp = (*cur - '0');
10120	ok = 1;
10121	cur++;
10122	temp = (double) tmp;
10123	ret = ret + temp;
10124	}
10125	#else
10126	ret = 0;
10127	while ((cur >= '0') && (cur <= '9')) {
10128	ret = ret * 10 + (*cur - '0');
10129	ok = 1;
10130	cur++;
10131	}
10132	#endif
10133
10134	if (*cur == '.') {
10135	int v, frac = 0;
10136	double fraction = 0;
10137
10138	cur++;
10139	if (((cur < '0') \|\| (cur > '9')) && (!ok)) {
10140	return(xmlXPathNAN);
10141	}
10142	while (((cur >= '0') && (cur <= '9')) && (frac < MAX_FRAC)) {
10143	v = (*cur - '0');
10144	fraction = fraction * 10 + v;
10145	frac = frac + 1;
10146	cur++;
10147	}
10148	fraction /= my_pow10[frac];
10149	ret = ret + fraction;
10150	while ((cur >= '0') && (cur <= '9'))
10151	cur++;
10152	}
10153	if ((cur == 'e') \|\| (cur == 'E')) {
10154	cur++;
10155	if (*cur == '-') {
10156	is_exponent_negative = 1;
10157	cur++;
10158	} else if (*cur == '+') {
10159	cur++;
10160	}
10161	while ((cur >= '0') && (cur <= '9')) {
10162	exponent = exponent * 10 + (*cur - '0');
10163	cur++;
10164	}
10165	}
10166	while (IS_BLANK_CH(*cur)) cur++;
10167	if (*cur != 0) return(xmlXPathNAN);
10168	if (isneg) ret = -ret;
10169	if (is_exponent_negative) exponent = -exponent;
10170	ret *= pow(10.0, (double)exponent);
10171	return(ret);
10172	}
10173
10174	/**
10175	* xmlXPathCompNumber:
10176	* @ctxt: the XPath Parser context
10177	*
10178	* [30] Number ::= Digits ('.' Digits?)?
10179	* \| '.' Digits
10180	* [31] Digits ::= [0-9]+
10181	*
10182	* Compile a Number, then push it on the stack
10183	*
10184	*/
10185	static void
10186	xmlXPathCompNumber(xmlXPathParserContextPtr ctxt)
10187	{
10188	double ret = 0.0;
10189	int ok = 0;
10190	int exponent = 0;
10191	int is_exponent_negative = 0;
10192	#ifdef __GNUC__
10193	unsigned long tmp = 0;
10194	double temp;
10195	#endif
10196
10197	CHECK_ERROR;
10198	if ((CUR != '.') && ((CUR < '0') \|\| (CUR > '9'))) {
10199	XP_ERROR(XPATH_NUMBER_ERROR);
10200	}
10201	#ifdef __GNUC__
10202	/*
10203	* tmp/temp is a workaround against a gcc compiler bug
10204	* http://veillard.com/gcc.bug
10205	*/
10206	ret = 0;
10207	while ((CUR >= '0') && (CUR <= '9')) {
10208	ret = ret * 10;
10209	tmp = (CUR - '0');
10210	ok = 1;
10211	NEXT;
10212	temp = (double) tmp;
10213	ret = ret + temp;
10214	}
10215	#else
10216	ret = 0;
10217	while ((CUR >= '0') && (CUR <= '9')) {
10218	ret = ret * 10 + (CUR - '0');
10219	ok = 1;
10220	NEXT;
10221	}
10222	#endif
10223	if (CUR == '.') {
10224	int v, frac = 0;
10225	double fraction = 0;
10226
10227	NEXT;
10228	if (((CUR < '0') \|\| (CUR > '9')) && (!ok)) {
10229	XP_ERROR(XPATH_NUMBER_ERROR);
10230	}
10231	while ((CUR >= '0') && (CUR <= '9') && (frac < MAX_FRAC)) {
10232	v = (CUR - '0');
10233	fraction = fraction * 10 + v;
10234	frac = frac + 1;
10235	NEXT;
10236	}
10237	fraction /= my_pow10[frac];
10238	ret = ret + fraction;
10239	while ((CUR >= '0') && (CUR <= '9'))
10240	NEXT;
10241	}
10242	if ((CUR == 'e') \|\| (CUR == 'E')) {
10243	NEXT;
10244	if (CUR == '-') {
10245	is_exponent_negative = 1;
10246	NEXT;
10247	} else if (CUR == '+') {
10248	NEXT;
10249	}
10250	while ((CUR >= '0') && (CUR <= '9')) {
10251	exponent = exponent * 10 + (CUR - '0');
10252	NEXT;
10253	}
10254	if (is_exponent_negative)
10255	exponent = -exponent;
10256	ret *= pow(10.0, (double) exponent);
10257	}
10258	PUSH_LONG_EXPR(XPATH_OP_VALUE, XPATH_NUMBER, 0, 0,
10259	xmlXPathCacheNewFloat(ctxt->context, ret), NULL);
10260	}
10261
10262	/**
10263	* xmlXPathParseLiteral:
10264	* @ctxt: the XPath Parser context
10265	*
10266	* Parse a Literal
10267	*
10268	* [29] Literal ::= '"' [^"]* '"'
10269	* \| "'" [^']* "'"
10270	*
10271	* Returns the value found or NULL in case of error
10272	*/
10273	static xmlChar *
10274	xmlXPathParseLiteral(xmlXPathParserContextPtr ctxt) {
10275	const xmlChar *q;
10276	xmlChar *ret = NULL;
10277
10278	if (CUR == '"') {
10279	NEXT;
10280	q = CUR_PTR;
10281	while ((IS_CHAR_CH(CUR)) && (CUR != '"'))
10282	NEXT;
10283	if (!IS_CHAR_CH(CUR)) {
10284	XP_ERRORNULL(XPATH_UNFINISHED_LITERAL_ERROR);
10285	} else {
10286	ret = xmlStrndup(q, CUR_PTR - q);
10287	NEXT;
10288	}
10289	} else if (CUR == '\'') {
10290	NEXT;
10291	q = CUR_PTR;
10292	while ((IS_CHAR_CH(CUR)) && (CUR != '\''))
10293	NEXT;
10294	if (!IS_CHAR_CH(CUR)) {
10295	XP_ERRORNULL(XPATH_UNFINISHED_LITERAL_ERROR);
10296	} else {
10297	ret = xmlStrndup(q, CUR_PTR - q);
10298	NEXT;
10299	}
10300	} else {
10301	XP_ERRORNULL(XPATH_START_LITERAL_ERROR);
10302	}
10303	return(ret);
10304	}
10305
10306	/**
10307	* xmlXPathCompLiteral:
10308	* @ctxt: the XPath Parser context
10309	*
10310	* Parse a Literal and push it on the stack.
10311	*
10312	* [29] Literal ::= '"' [^"]* '"'
10313	* \| "'" [^']* "'"
10314	*
10315	* TODO: xmlXPathCompLiteral memory allocation could be improved.
10316	*/
10317	static void
10318	xmlXPathCompLiteral(xmlXPathParserContextPtr ctxt) {
10319	const xmlChar *q;
10320	xmlChar *ret = NULL;
10321
10322	if (CUR == '"') {
10323	NEXT;
10324	q = CUR_PTR;
10325	while ((IS_CHAR_CH(CUR)) && (CUR != '"'))
10326	NEXT;
10327	if (!IS_CHAR_CH(CUR)) {
10328	XP_ERROR(XPATH_UNFINISHED_LITERAL_ERROR);
10329	} else {
10330	ret = xmlStrndup(q, CUR_PTR - q);
10331	NEXT;
10332	}
10333	} else if (CUR == '\'') {
10334	NEXT;
10335	q = CUR_PTR;
10336	while ((IS_CHAR_CH(CUR)) && (CUR != '\''))
10337	NEXT;
10338	if (!IS_CHAR_CH(CUR)) {
10339	XP_ERROR(XPATH_UNFINISHED_LITERAL_ERROR);
10340	} else {
10341	ret = xmlStrndup(q, CUR_PTR - q);
10342	NEXT;
10343	}
10344	} else {
10345	XP_ERROR(XPATH_START_LITERAL_ERROR);
10346	}
10347	if (ret == NULL) return;
10348	PUSH_LONG_EXPR(XPATH_OP_VALUE, XPATH_STRING, 0, 0,
10349	xmlXPathCacheNewString(ctxt->context, ret), NULL);
10350	xmlFree(ret);
10351	}
10352
10353	/**
10354	* xmlXPathCompVariableReference:
10355	* @ctxt: the XPath Parser context
10356	*
10357	* Parse a VariableReference, evaluate it and push it on the stack.
10358	*
10359	* The variable bindings consist of a mapping from variable names
10360	* to variable values. The value of a variable is an object, which can be
10361	* of any of the types that are possible for the value of an expression,
10362	* and may also be of additional types not specified here.
10363	*
10364	* Early evaluation is possible since:
10365	* The variable bindings [...] used to evaluate a subexpression are
10366	* always the same as those used to evaluate the containing expression.
10367	*
10368	* [36] VariableReference ::= '$' QName
10369	*/
10370	static void
10371	xmlXPathCompVariableReference(xmlXPathParserContextPtr ctxt) {
10372	xmlChar *name;
10373	xmlChar *prefix;
10374
10375	SKIP_BLANKS;
10376	if (CUR != '$') {
10377	XP_ERROR(XPATH_VARIABLE_REF_ERROR);
10378	}
10379	NEXT;
10380	name = xmlXPathParseQName(ctxt, &prefix);
10381	if (name == NULL) {
10382	XP_ERROR(XPATH_VARIABLE_REF_ERROR);
10383	}
10384	ctxt->comp->last = -1;
10385	PUSH_LONG_EXPR(XPATH_OP_VARIABLE, 0, 0, 0,
10386	name, prefix);
10387	SKIP_BLANKS;
10388	if ((ctxt->context != NULL) && (ctxt->context->flags & XML_XPATH_NOVAR)) {
10389	XP_ERROR(XPATH_FORBID_VARIABLE_ERROR);
10390	}
10391	}
10392
10393	/**
10394	* xmlXPathIsNodeType:
10395	* @name: a name string
10396	*
10397	* Is the name given a NodeType one.
10398	*
10399	* [38] NodeType ::= 'comment'
10400	* \| 'text'
10401	* \| 'processing-instruction'
10402	* \| 'node'
10403	*
10404	* Returns 1 if true 0 otherwise
10405	*/
10406	int
10407	xmlXPathIsNodeType(const xmlChar *name) {
10408	if (name == NULL)
10409	return(0);
10410
10411	if (xmlStrEqual(name, BAD_CAST "node"))
10412	return(1);
10413	if (xmlStrEqual(name, BAD_CAST "text"))
10414	return(1);
10415	if (xmlStrEqual(name, BAD_CAST "comment"))
10416	return(1);
10417	if (xmlStrEqual(name, BAD_CAST "processing-instruction"))
10418	return(1);
10419	return(0);
10420	}
10421
10422	/**
10423	* xmlXPathCompFunctionCall:
10424	* @ctxt: the XPath Parser context
10425	*
10426	* [16] FunctionCall ::= FunctionName '(' ( Argument ( ',' Argument)*)? ')'
10427	* [17] Argument ::= Expr
10428	*
10429	* Compile a function call, the evaluation of all arguments are
10430	* pushed on the stack
10431	*/
10432	static void
10433	xmlXPathCompFunctionCall(xmlXPathParserContextPtr ctxt) {
10434	xmlChar *name;
10435	xmlChar *prefix;
10436	int nbargs = 0;
10437	int sort = 1;
10438
10439	name = xmlXPathParseQName(ctxt, &prefix);
10440	if (name == NULL) {
10441	xmlFree(prefix);
10442	XP_ERROR(XPATH_EXPR_ERROR);
10443	}
10444	SKIP_BLANKS;
10445	#ifdef DEBUG_EXPR
10446	if (prefix == NULL)
10447	xmlGenericError(xmlGenericErrorContext, "Calling function %s\n",
10448	name);
10449	else
10450	xmlGenericError(xmlGenericErrorContext, "Calling function %s:%s\n",
10451	prefix, name);
10452	#endif
10453
10454	if (CUR != '(') {
10455	XP_ERROR(XPATH_EXPR_ERROR);
10456	}
10457	NEXT;
10458	SKIP_BLANKS;
10459
10460	/*
10461	* Optimization for count(): we don't need the node-set to be sorted.
10462	*/
10463	if ((prefix == NULL) && (name[0] == 'c') &&
10464	xmlStrEqual(name, BAD_CAST "count"))
10465	{
10466	sort = 0;
10467	}
10468	ctxt->comp->last = -1;
10469	if (CUR != ')') {
10470	while (CUR != 0) {
10471	int op1 = ctxt->comp->last;
10472	ctxt->comp->last = -1;
10473	xmlXPathCompileExpr(ctxt, sort);
10474	if (ctxt->error != XPATH_EXPRESSION_OK) {
10475	xmlFree(name);
10476	xmlFree(prefix);
10477	return;
10478	}
10479	PUSH_BINARY_EXPR(XPATH_OP_ARG, op1, ctxt->comp->last, 0, 0);
10480	nbargs++;
10481	if (CUR == ')') break;
10482	if (CUR != ',') {
10483	XP_ERROR(XPATH_EXPR_ERROR);
10484	}
10485	NEXT;
10486	SKIP_BLANKS;
10487	}
10488	}
10489	PUSH_LONG_EXPR(XPATH_OP_FUNCTION, nbargs, 0, 0,
10490	name, prefix);
10491	NEXT;
10492	SKIP_BLANKS;
10493	}
10494
10495	/**
10496	* xmlXPathCompPrimaryExpr:
10497	* @ctxt: the XPath Parser context
10498	*
10499	* [15] PrimaryExpr ::= VariableReference
10500	* \| '(' Expr ')'
10501	* \| Literal
10502	* \| Number
10503	* \| FunctionCall
10504	*
10505	* Compile a primary expression.
10506	*/
10507	static void
10508	xmlXPathCompPrimaryExpr(xmlXPathParserContextPtr ctxt) {
10509	SKIP_BLANKS;
10510	if (CUR == '$') xmlXPathCompVariableReference(ctxt);
10511	else if (CUR == '(') {
10512	NEXT;
10513	SKIP_BLANKS;
10514	xmlXPathCompileExpr(ctxt, 1);
10515	CHECK_ERROR;
10516	if (CUR != ')') {
10517	XP_ERROR(XPATH_EXPR_ERROR);
10518	}
10519	NEXT;
10520	SKIP_BLANKS;
10521	} else if (IS_ASCII_DIGIT(CUR) \|\| (CUR == '.' && IS_ASCII_DIGIT(NXT(1)))) {
10522	xmlXPathCompNumber(ctxt);
10523	} else if ((CUR == '\'') \|\| (CUR == '"')) {
10524	xmlXPathCompLiteral(ctxt);
10525	} else {
10526	xmlXPathCompFunctionCall(ctxt);
10527	}
10528	SKIP_BLANKS;
10529	}
10530
10531	/**
10532	* xmlXPathCompFilterExpr:
10533	* @ctxt: the XPath Parser context
10534	*
10535	* [20] FilterExpr ::= PrimaryExpr
10536	* \| FilterExpr Predicate
10537	*
10538	* Compile a filter expression.
10539	* Square brackets are used to filter expressions in the same way that
10540	* they are used in location paths. It is an error if the expression to
10541	* be filtered does not evaluate to a node-set. The context node list
10542	* used for evaluating the expression in square brackets is the node-set
10543	* to be filtered listed in document order.
10544	*/
10545
10546	static void
10547	xmlXPathCompFilterExpr(xmlXPathParserContextPtr ctxt) {
10548	xmlXPathCompPrimaryExpr(ctxt);
10549	CHECK_ERROR;
10550	SKIP_BLANKS;
10551
10552	while (CUR == '[') {
10553	xmlXPathCompPredicate(ctxt, 1);
10554	SKIP_BLANKS;
10555	}
10556
10557
10558	}
10559
10560	/**
10561	* xmlXPathScanName:
10562	* @ctxt: the XPath Parser context
10563	*
10564	* Trickery: parse an XML name but without consuming the input flow
10565	* Needed to avoid insanity in the parser state.
10566	*
10567	* [4] NameChar ::= Letter \| Digit \| '.' \| '-' \| '_' \| ':' \|
10568	* CombiningChar \| Extender
10569	*
10570	* [5] Name ::= (Letter \| '_' \| ':') (NameChar)*
10571	*
10572	* [6] Names ::= Name (S Name)*
10573	*
10574	* Returns the Name parsed or NULL
10575	*/
10576
10577	static xmlChar *
10578	xmlXPathScanName(xmlXPathParserContextPtr ctxt) {
10579	int len = 0, l;
10580	int c;
10581	const xmlChar *cur;
10582	xmlChar *ret;
10583
10584	cur = ctxt->cur;
10585
10586	c = CUR_CHAR(l);
10587	if ((c == ' ') \|\| (c == '>') \|\| (c == '/') \|\| /* accelerators */
10588	(!IS_LETTER(c) && (c != '_') &&
10589	(c != ':'))) {
10590	return(NULL);
10591	}
10592
10593	while ((c != ' ') && (c != '>') && (c != '/') && /* test bigname.xml */
10594	((IS_LETTER(c)) \|\| (IS_DIGIT(c)) \|\|
10595	(c == '.') \|\| (c == '-') \|\|
10596	(c == '_') \|\| (c == ':') \|\|
10597	(IS_COMBINING(c)) \|\|
10598	(IS_EXTENDER(c)))) {
10599	len += l;
10600	NEXTL(l);
10601	c = CUR_CHAR(l);
10602	}
10603	ret = xmlStrndup(cur, ctxt->cur - cur);
10604	ctxt->cur = cur;
10605	return(ret);
10606	}
10607
10608	/**
10609	* xmlXPathCompPathExpr:
10610	* @ctxt: the XPath Parser context
10611	*
10612	* [19] PathExpr ::= LocationPath
10613	* \| FilterExpr
10614	* \| FilterExpr '/' RelativeLocationPath
10615	* \| FilterExpr '//' RelativeLocationPath
10616	*
10617	* Compile a path expression.
10618	* The / operator and // operators combine an arbitrary expression
10619	* and a relative location path. It is an error if the expression
10620	* does not evaluate to a node-set.
10621	* The / operator does composition in the same way as when / is
10622	* used in a location path. As in location paths, // is short for
10623	* /descendant-or-self::node()/.
10624	*/
10625
10626	static void
10627	xmlXPathCompPathExpr(xmlXPathParserContextPtr ctxt) {
10628	int lc = 1; /* Should we branch to LocationPath ? */
10629	xmlChar name = NULL; / we may have to preparse a name to find out */
10630
10631	SKIP_BLANKS;
10632	if ((CUR == '$') \|\| (CUR == '(') \|\|
10633	(IS_ASCII_DIGIT(CUR)) \|\|
10634	(CUR == '\'') \|\| (CUR == '"') \|\|
10635	(CUR == '.' && IS_ASCII_DIGIT(NXT(1)))) {
10636	lc = 0;
10637	} else if (CUR == '*') {
10638	/* relative or absolute location path */
10639	lc = 1;
10640	} else if (CUR == '/') {
10641	/* relative or absolute location path */
10642	lc = 1;
10643	} else if (CUR == '@') {
10644	/* relative abbreviated attribute location path */
10645	lc = 1;
10646	} else if (CUR == '.') {
10647	/* relative abbreviated attribute location path */
10648	lc = 1;
10649	} else {
10650	/*
10651	* Problem is finding if we have a name here whether it's:
10652	* - a nodetype
10653	* - a function call in which case it's followed by '('
10654	* - an axis in which case it's followed by ':'
10655	* - a element name
10656	* We do an a priori analysis here rather than having to
10657	* maintain parsed token content through the recursive function
10658	* calls. This looks uglier but makes the code easier to
10659	* read/write/debug.
10660	*/
10661	SKIP_BLANKS;
10662	name = xmlXPathScanName(ctxt);
10663	if ((name != NULL) && (xmlStrstr(name, (xmlChar *) "::") != NULL)) {
10664	#ifdef DEBUG_STEP
10665	xmlGenericError(xmlGenericErrorContext,
10666	"PathExpr: Axis\n");
10667	#endif
10668	lc = 1;
10669	xmlFree(name);
10670	} else if (name != NULL) {
10671	int len =xmlStrlen(name);
10672
10673
10674	while (NXT(len) != 0) {
10675	if (NXT(len) == '/') {
10676	/* element name */
10677	#ifdef DEBUG_STEP
10678	xmlGenericError(xmlGenericErrorContext,
10679	"PathExpr: AbbrRelLocation\n");
10680	#endif
10681	lc = 1;
10682	break;
10683	} else if (IS_BLANK_CH(NXT(len))) {
10684	/* ignore blanks */
10685	;
10686	} else if (NXT(len) == ':') {
10687	#ifdef DEBUG_STEP
10688	xmlGenericError(xmlGenericErrorContext,
10689	"PathExpr: AbbrRelLocation\n");
10690	#endif
10691	lc = 1;
10692	break;
10693	} else if ((NXT(len) == '(')) {
10694	/* Note Type or Function */
10695	if (xmlXPathIsNodeType(name)) {
10696	#ifdef DEBUG_STEP
10697	xmlGenericError(xmlGenericErrorContext,
10698	"PathExpr: Type search\n");
10699	#endif
10700	lc = 1;
10701	} else {
10702	#ifdef DEBUG_STEP
10703	xmlGenericError(xmlGenericErrorContext,
10704	"PathExpr: function call\n");
10705	#endif
10706	lc = 0;
10707	}
10708	break;
10709	} else if ((NXT(len) == '[')) {
10710	/* element name */
10711	#ifdef DEBUG_STEP
10712	xmlGenericError(xmlGenericErrorContext,
10713	"PathExpr: AbbrRelLocation\n");
10714	#endif
10715	lc = 1;
10716	break;
10717	} else if ((NXT(len) == '<') \|\| (NXT(len) == '>') \|\|
10718	(NXT(len) == '=')) {
10719	lc = 1;
10720	break;
10721	} else {
10722	lc = 1;
10723	break;
10724	}
10725	len++;
10726	}
10727	if (NXT(len) == 0) {
10728	#ifdef DEBUG_STEP
10729	xmlGenericError(xmlGenericErrorContext,
10730	"PathExpr: AbbrRelLocation\n");
10731	#endif
10732	/* element name */
10733	lc = 1;
10734	}
10735	xmlFree(name);
10736	} else {
10737	/* make sure all cases are covered explicitly */
10738	XP_ERROR(XPATH_EXPR_ERROR);
10739	}
10740	}
10741
10742	if (lc) {
10743	if (CUR == '/') {
10744	PUSH_LEAVE_EXPR(XPATH_OP_ROOT, 0, 0);
10745	} else {
10746	PUSH_LEAVE_EXPR(XPATH_OP_NODE, 0, 0);
10747	}
10748	xmlXPathCompLocationPath(ctxt);
10749	} else {
10750	xmlXPathCompFilterExpr(ctxt);
10751	CHECK_ERROR;
10752	if ((CUR == '/') && (NXT(1) == '/')) {
10753	SKIP(2);
10754	SKIP_BLANKS;
10755
10756	PUSH_LONG_EXPR(XPATH_OP_COLLECT, AXIS_DESCENDANT_OR_SELF,
10757	NODE_TEST_TYPE, NODE_TYPE_NODE, NULL, NULL);
10758	PUSH_UNARY_EXPR(XPATH_OP_RESET, ctxt->comp->last, 1, 0);
10759
10760	xmlXPathCompRelativeLocationPath(ctxt);
10761	} else if (CUR == '/') {
10762	xmlXPathCompRelativeLocationPath(ctxt);
10763	}
10764	}
10765	SKIP_BLANKS;
10766	}
10767
10768	/**
10769	* xmlXPathCompUnionExpr:
10770	* @ctxt: the XPath Parser context
10771	*
10772	* [18] UnionExpr ::= PathExpr
10773	* \| UnionExpr '\|' PathExpr
10774	*
10775	* Compile an union expression.
10776	*/
10777
10778	static void
10779	xmlXPathCompUnionExpr(xmlXPathParserContextPtr ctxt) {
10780	xmlXPathCompPathExpr(ctxt);
10781	CHECK_ERROR;
10782	SKIP_BLANKS;
10783	while (CUR == '\|') {
10784	int op1 = ctxt->comp->last;
10785	PUSH_LEAVE_EXPR(XPATH_OP_NODE, 0, 0);
10786
10787	NEXT;
10788	SKIP_BLANKS;
10789	xmlXPathCompPathExpr(ctxt);
10790
10791	PUSH_BINARY_EXPR(XPATH_OP_UNION, op1, ctxt->comp->last, 0, 0);
10792
10793	SKIP_BLANKS;
10794	}
10795	}
10796
10797	/**
10798	* xmlXPathCompUnaryExpr:
10799	* @ctxt: the XPath Parser context
10800	*
10801	* [27] UnaryExpr ::= UnionExpr
10802	* \| '-' UnaryExpr
10803	*
10804	* Compile an unary expression.
10805	*/
10806
10807	static void
10808	xmlXPathCompUnaryExpr(xmlXPathParserContextPtr ctxt) {
10809	int minus = 0;
10810	int found = 0;
10811
10812	SKIP_BLANKS;
10813	while (CUR == '-') {
10814	minus = 1 - minus;
10815	found = 1;
10816	NEXT;
10817	SKIP_BLANKS;
10818	}
10819
10820	xmlXPathCompUnionExpr(ctxt);
10821	CHECK_ERROR;
10822	if (found) {
10823	if (minus)
10824	PUSH_UNARY_EXPR(XPATH_OP_PLUS, ctxt->comp->last, 2, 0);
10825	else
10826	PUSH_UNARY_EXPR(XPATH_OP_PLUS, ctxt->comp->last, 3, 0);
10827	}
10828	}
10829
10830	/**
10831	* xmlXPathCompMultiplicativeExpr:
10832	* @ctxt: the XPath Parser context
10833	*
10834	* [26] MultiplicativeExpr ::= UnaryExpr
10835	* \| MultiplicativeExpr MultiplyOperator UnaryExpr
10836	* \| MultiplicativeExpr 'div' UnaryExpr
10837	* \| MultiplicativeExpr 'mod' UnaryExpr
10838	* [34] MultiplyOperator ::= '*'
10839	*
10840	* Compile an Additive expression.
10841	*/
10842
10843	static void
10844	xmlXPathCompMultiplicativeExpr(xmlXPathParserContextPtr ctxt) {
10845	xmlXPathCompUnaryExpr(ctxt);
10846	CHECK_ERROR;
10847	SKIP_BLANKS;
10848	while ((CUR == '*') \|\|
10849	((CUR == 'd') && (NXT(1) == 'i') && (NXT(2) == 'v')) \|\|
10850	((CUR == 'm') && (NXT(1) == 'o') && (NXT(2) == 'd'))) {
10851	int op = -1;
10852	int op1 = ctxt->comp->last;
10853
10854	if (CUR == '*') {
10855	op = 0;
10856	NEXT;
10857	} else if (CUR == 'd') {
10858	op = 1;
10859	SKIP(3);
10860	} else if (CUR == 'm') {
10861	op = 2;
10862	SKIP(3);
10863	}
10864	SKIP_BLANKS;
10865	xmlXPathCompUnaryExpr(ctxt);
10866	CHECK_ERROR;
10867	PUSH_BINARY_EXPR(XPATH_OP_MULT, op1, ctxt->comp->last, op, 0);
10868	SKIP_BLANKS;
10869	}
10870	}
10871
10872	/**
10873	* xmlXPathCompAdditiveExpr:
10874	* @ctxt: the XPath Parser context
10875	*
10876	* [25] AdditiveExpr ::= MultiplicativeExpr
10877	* \| AdditiveExpr '+' MultiplicativeExpr
10878	* \| AdditiveExpr '-' MultiplicativeExpr
10879	*
10880	* Compile an Additive expression.
10881	*/
10882
10883	static void
10884	xmlXPathCompAdditiveExpr(xmlXPathParserContextPtr ctxt) {
10885
10886	xmlXPathCompMultiplicativeExpr(ctxt);
10887	CHECK_ERROR;
10888	SKIP_BLANKS;
10889	while ((CUR == '+') \|\| (CUR == '-')) {
10890	int plus;
10891	int op1 = ctxt->comp->last;
10892
10893	if (CUR == '+') plus = 1;
10894	else plus = 0;
10895	NEXT;
10896	SKIP_BLANKS;
10897	xmlXPathCompMultiplicativeExpr(ctxt);
10898	CHECK_ERROR;
10899	PUSH_BINARY_EXPR(XPATH_OP_PLUS, op1, ctxt->comp->last, plus, 0);
10900	SKIP_BLANKS;
10901	}
10902	}
10903
10904	/**
10905	* xmlXPathCompRelationalExpr:
10906	* @ctxt: the XPath Parser context
10907	*
10908	* [24] RelationalExpr ::= AdditiveExpr
10909	* \| RelationalExpr '<' AdditiveExpr
10910	* \| RelationalExpr '>' AdditiveExpr
10911	* \| RelationalExpr '<=' AdditiveExpr
10912	* \| RelationalExpr '>=' AdditiveExpr
10913	*
10914	* A <= B > C is allowed ? Answer from James, yes with
10915	* (AdditiveExpr <= AdditiveExpr) > AdditiveExpr
10916	* which is basically what got implemented.
10917	*
10918	* Compile a Relational expression, then push the result
10919	* on the stack
10920	*/
10921
10922	static void
10923	xmlXPathCompRelationalExpr(xmlXPathParserContextPtr ctxt) {
10924	xmlXPathCompAdditiveExpr(ctxt);
10925	CHECK_ERROR;
10926	SKIP_BLANKS;
10927	while ((CUR == '<') \|\|
10928	(CUR == '>') \|\|
10929	((CUR == '<') && (NXT(1) == '=')) \|\|
10930	((CUR == '>') && (NXT(1) == '='))) {
10931	int inf, strict;
10932	int op1 = ctxt->comp->last;
10933
10934	if (CUR == '<') inf = 1;
10935	else inf = 0;
10936	if (NXT(1) == '=') strict = 0;
10937	else strict = 1;
10938	NEXT;
10939	if (!strict) NEXT;
10940	SKIP_BLANKS;
10941	xmlXPathCompAdditiveExpr(ctxt);
10942	CHECK_ERROR;
10943	PUSH_BINARY_EXPR(XPATH_OP_CMP, op1, ctxt->comp->last, inf, strict);
10944	SKIP_BLANKS;
10945	}
10946	}
10947
10948	/**
10949	* xmlXPathCompEqualityExpr:
10950	* @ctxt: the XPath Parser context
10951	*
10952	* [23] EqualityExpr ::= RelationalExpr
10953	* \| EqualityExpr '=' RelationalExpr
10954	* \| EqualityExpr '!=' RelationalExpr
10955	*
10956	* A != B != C is allowed ? Answer from James, yes with
10957	* (RelationalExpr = RelationalExpr) = RelationalExpr
10958	* (RelationalExpr != RelationalExpr) != RelationalExpr
10959	* which is basically what got implemented.
10960	*
10961	* Compile an Equality expression.
10962	*
10963	*/
10964	static void
10965	xmlXPathCompEqualityExpr(xmlXPathParserContextPtr ctxt) {
10966	xmlXPathCompRelationalExpr(ctxt);
10967	CHECK_ERROR;
10968	SKIP_BLANKS;
10969	while ((CUR == '=') \|\| ((CUR == '!') && (NXT(1) == '='))) {
10970	int eq;
10971	int op1 = ctxt->comp->last;
10972
10973	if (CUR == '=') eq = 1;
10974	else eq = 0;
10975	NEXT;
10976	if (!eq) NEXT;
10977	SKIP_BLANKS;
10978	xmlXPathCompRelationalExpr(ctxt);
10979	CHECK_ERROR;
10980	PUSH_BINARY_EXPR(XPATH_OP_EQUAL, op1, ctxt->comp->last, eq, 0);
10981	SKIP_BLANKS;
10982	}
10983	}
10984
10985	/**
10986	* xmlXPathCompAndExpr:
10987	* @ctxt: the XPath Parser context
10988	*
10989	* [22] AndExpr ::= EqualityExpr
10990	* \| AndExpr 'and' EqualityExpr
10991	*
10992	* Compile an AND expression.
10993	*
10994	*/
10995	static void
10996	xmlXPathCompAndExpr(xmlXPathParserContextPtr ctxt) {
10997	xmlXPathCompEqualityExpr(ctxt);
10998	CHECK_ERROR;
10999	SKIP_BLANKS;
11000	while ((CUR == 'a') && (NXT(1) == 'n') && (NXT(2) == 'd')) {
11001	int op1 = ctxt->comp->last;
11002	SKIP(3);
11003	SKIP_BLANKS;
11004	xmlXPathCompEqualityExpr(ctxt);
11005	CHECK_ERROR;
11006	PUSH_BINARY_EXPR(XPATH_OP_AND, op1, ctxt->comp->last, 0, 0);
11007	SKIP_BLANKS;
11008	}
11009	}
11010
11011	/**
11012	* xmlXPathCompileExpr:
11013	* @ctxt: the XPath Parser context
11014	*
11015	* [14] Expr ::= OrExpr
11016	* [21] OrExpr ::= AndExpr
11017	* \| OrExpr 'or' AndExpr
11018	*
11019	* Parse and compile an expression
11020	*/
11021	static void
11022	xmlXPathCompileExpr(xmlXPathParserContextPtr ctxt, int sort) {
11023	xmlXPathCompAndExpr(ctxt);
11024	CHECK_ERROR;
11025	SKIP_BLANKS;
11026	while ((CUR == 'o') && (NXT(1) == 'r')) {
11027	int op1 = ctxt->comp->last;
11028	SKIP(2);
11029	SKIP_BLANKS;
11030	xmlXPathCompAndExpr(ctxt);
11031	CHECK_ERROR;
11032	PUSH_BINARY_EXPR(XPATH_OP_OR, op1, ctxt->comp->last, 0, 0);
11033	SKIP_BLANKS;
11034	}
11035	if ((sort) && (ctxt->comp->steps[ctxt->comp->last].op != XPATH_OP_VALUE)) {
11036	/* more ops could be optimized too */
11037	/*
11038	* This is the main place to eliminate sorting for
11039	* operations which don't require a sorted node-set.
11040	* E.g. count().
11041	*/
11042	PUSH_UNARY_EXPR(XPATH_OP_SORT, ctxt->comp->last , 0, 0);
11043	}
11044	}
11045
11046	/**
11047	* xmlXPathCompPredicate:
11048	* @ctxt: the XPath Parser context
11049	* @filter: act as a filter
11050	*
11051	* [8] Predicate ::= '[' PredicateExpr ']'
11052	* [9] PredicateExpr ::= Expr
11053	*
11054	* Compile a predicate expression
11055	*/
11056	static void
11057	xmlXPathCompPredicate(xmlXPathParserContextPtr ctxt, int filter) {
11058	int op1 = ctxt->comp->last;
11059
11060	SKIP_BLANKS;
11061	if (CUR != '[') {
11062	XP_ERROR(XPATH_INVALID_PREDICATE_ERROR);
11063	}
11064	NEXT;
11065	SKIP_BLANKS;
11066
11067	ctxt->comp->last = -1;
11068	/*
11069	* This call to xmlXPathCompileExpr() will deactivate sorting
11070	* of the predicate result.
11071	* TODO: Sorting is still activated for filters, since I'm not
11072	* sure if needed. Normally sorting should not be needed, since
11073	* a filter can only diminish the number of items in a sequence,
11074	* but won't change its order; so if the initial sequence is sorted,
11075	* subsequent sorting is not needed.
11076	*/
11077	if (! filter)
11078	xmlXPathCompileExpr(ctxt, 0);
11079	else
11080	xmlXPathCompileExpr(ctxt, 1);
11081	CHECK_ERROR;
11082
11083	if (CUR != ']') {
11084	XP_ERROR(XPATH_INVALID_PREDICATE_ERROR);
11085	}
11086
11087	if (filter)
11088	PUSH_BINARY_EXPR(XPATH_OP_FILTER, op1, ctxt->comp->last, 0, 0);
11089	else
11090	PUSH_BINARY_EXPR(XPATH_OP_PREDICATE, op1, ctxt->comp->last, 0, 0);
11091
11092	NEXT;
11093	SKIP_BLANKS;
11094	}
11095
11096	/**
11097	* xmlXPathCompNodeTest:
11098	* @ctxt: the XPath Parser context
11099	* @test: pointer to a xmlXPathTestVal
11100	* @type: pointer to a xmlXPathTypeVal
11101	* @prefix: placeholder for a possible name prefix
11102	*
11103	* [7] NodeTest ::= NameTest
11104	* \| NodeType '(' ')'
11105	* \| 'processing-instruction' '(' Literal ')'
11106	*
11107	* [37] NameTest ::= '*'
11108	* \| NCName ':' '*'
11109	* \| QName
11110	* [38] NodeType ::= 'comment'
11111	* \| 'text'
11112	* \| 'processing-instruction'
11113	* \| 'node'
11114	*
11115	* Returns the name found and updates @test, @type and @prefix appropriately
11116	*/
11117	static xmlChar *
11118	xmlXPathCompNodeTest(xmlXPathParserContextPtr ctxt, xmlXPathTestVal *test,
11119	xmlXPathTypeVal type, const xmlChar *prefix,
11120	xmlChar *name) {
11121	int blanks;
11122
11123	if ((test == NULL) \|\| (type == NULL) \|\| (prefix == NULL)) {
11124	STRANGE;
11125	return(NULL);
11126	}
11127	*type = (xmlXPathTypeVal) 0;
11128	*test = (xmlXPathTestVal) 0;
11129	*prefix = NULL;
11130	SKIP_BLANKS;
11131
11132	if ((name == NULL) && (CUR == '*')) {
11133	/*
11134	* All elements
11135	*/
11136	NEXT;
11137	*test = NODE_TEST_ALL;
11138	return(NULL);
11139	}
11140
11141	if (name == NULL)
11142	name = xmlXPathParseNCName(ctxt);
11143	if (name == NULL) {
11144	XP_ERRORNULL(XPATH_EXPR_ERROR);
11145	}
11146
11147	blanks = IS_BLANK_CH(CUR);
11148	SKIP_BLANKS;
11149	if (CUR == '(') {
11150	NEXT;
11151	/*
11152	* NodeType or PI search
11153	*/
11154	if (xmlStrEqual(name, BAD_CAST "comment"))
11155	*type = NODE_TYPE_COMMENT;
11156	else if (xmlStrEqual(name, BAD_CAST "node"))
11157	*type = NODE_TYPE_NODE;
11158	else if (xmlStrEqual(name, BAD_CAST "processing-instruction"))
11159	*type = NODE_TYPE_PI;
11160	else if (xmlStrEqual(name, BAD_CAST "text"))
11161	*type = NODE_TYPE_TEXT;
11162	else {
11163	if (name != NULL)
11164	xmlFree(name);
11165	XP_ERRORNULL(XPATH_EXPR_ERROR);
11166	}
11167
11168	*test = NODE_TEST_TYPE;
11169
11170	SKIP_BLANKS;
11171	if (*type == NODE_TYPE_PI) {
11172	/*
11173	* Specific case: search a PI by name.
11174	*/
11175	if (name != NULL)
11176	xmlFree(name);
11177	name = NULL;
11178	if (CUR != ')') {
11179	name = xmlXPathParseLiteral(ctxt);
11180	CHECK_ERROR NULL;
11181	*test = NODE_TEST_PI;
11182	SKIP_BLANKS;
11183	}
11184	}
11185	if (CUR != ')') {
11186	if (name != NULL)
11187	xmlFree(name);
11188	XP_ERRORNULL(XPATH_UNCLOSED_ERROR);
11189	}
11190	NEXT;
11191	return(name);
11192	}
11193	*test = NODE_TEST_NAME;
11194	if ((!blanks) && (CUR == ':')) {
11195	NEXT;
11196
11197	/*
11198	* Since currently the parser context don't have a
11199	* namespace list associated:
11200	* The namespace name for this prefix can be computed
11201	* only at evaluation time. The compilation is done
11202	* outside of any context.
11203	*/
11204	#if 0
11205	*prefix = xmlXPathNsLookup(ctxt->context, name);
11206	if (name != NULL)
11207	xmlFree(name);
11208	if (*prefix == NULL) {
11209	XP_ERROR0(XPATH_UNDEF_PREFIX_ERROR);
11210	}
11211	#else
11212	*prefix = name;
11213	#endif
11214
11215	if (CUR == '*') {
11216	/*
11217	* All elements
11218	*/
11219	NEXT;
11220	*test = NODE_TEST_ALL;
11221	return(NULL);
11222	}
11223
11224	name = xmlXPathParseNCName(ctxt);
11225	if (name == NULL) {
11226	XP_ERRORNULL(XPATH_EXPR_ERROR);
11227	}
11228	}
11229	return(name);
11230	}
11231
11232	/**
11233	* xmlXPathIsAxisName:
11234	* @name: a preparsed name token
11235	*
11236	* [6] AxisName ::= 'ancestor'
11237	* \| 'ancestor-or-self'
11238	* \| 'attribute'
11239	* \| 'child'
11240	* \| 'descendant'
11241	* \| 'descendant-or-self'
11242	* \| 'following'
11243	* \| 'following-sibling'
11244	* \| 'namespace'
11245	* \| 'parent'
11246	* \| 'preceding'
11247	* \| 'preceding-sibling'
11248	* \| 'self'
11249	*
11250	* Returns the axis or 0
11251	*/
11252	static xmlXPathAxisVal
11253	xmlXPathIsAxisName(const xmlChar *name) {
11254	xmlXPathAxisVal ret = (xmlXPathAxisVal) 0;
11255	switch (name[0]) {
11256	case 'a':
11257	if (xmlStrEqual(name, BAD_CAST "ancestor"))
11258	ret = AXIS_ANCESTOR;
11259	if (xmlStrEqual(name, BAD_CAST "ancestor-or-self"))
11260	ret = AXIS_ANCESTOR_OR_SELF;
11261	if (xmlStrEqual(name, BAD_CAST "attribute"))
11262	ret = AXIS_ATTRIBUTE;
11263	break;
11264	case 'c':
11265	if (xmlStrEqual(name, BAD_CAST "child"))
11266	ret = AXIS_CHILD;
11267	break;
11268	case 'd':
11269	if (xmlStrEqual(name, BAD_CAST "descendant"))
11270	ret = AXIS_DESCENDANT;
11271	if (xmlStrEqual(name, BAD_CAST "descendant-or-self"))
11272	ret = AXIS_DESCENDANT_OR_SELF;
11273	break;
11274	case 'f':
11275	if (xmlStrEqual(name, BAD_CAST "following"))
11276	ret = AXIS_FOLLOWING;
11277	if (xmlStrEqual(name, BAD_CAST "following-sibling"))
11278	ret = AXIS_FOLLOWING_SIBLING;
11279	break;
11280	case 'n':
11281	if (xmlStrEqual(name, BAD_CAST "namespace"))
11282	ret = AXIS_NAMESPACE;
11283	break;
11284	case 'p':
11285	if (xmlStrEqual(name, BAD_CAST "parent"))
11286	ret = AXIS_PARENT;
11287	if (xmlStrEqual(name, BAD_CAST "preceding"))
11288	ret = AXIS_PRECEDING;
11289	if (xmlStrEqual(name, BAD_CAST "preceding-sibling"))
11290	ret = AXIS_PRECEDING_SIBLING;
11291	break;
11292	case 's':
11293	if (xmlStrEqual(name, BAD_CAST "self"))
11294	ret = AXIS_SELF;
11295	break;
11296	}
11297	return(ret);
11298	}
11299
11300	/**
11301	* xmlXPathCompStep:
11302	* @ctxt: the XPath Parser context
11303	*
11304	* [4] Step ::= AxisSpecifier NodeTest Predicate*
11305	* \| AbbreviatedStep
11306	*
11307	* [12] AbbreviatedStep ::= '.' \| '..'
11308	*
11309	* [5] AxisSpecifier ::= AxisName '::'
11310	* \| AbbreviatedAxisSpecifier
11311	*
11312	* [13] AbbreviatedAxisSpecifier ::= '@'?
11313	*
11314	* Modified for XPtr range support as:
11315	*
11316	* [4xptr] Step ::= AxisSpecifier NodeTest Predicate*
11317	* \| AbbreviatedStep
11318	* \| 'range-to' '(' Expr ')' Predicate*
11319	*
11320	* Compile one step in a Location Path
11321	* A location step of . is short for self::node(). This is
11322	* particularly useful in conjunction with //. For example, the
11323	* location path .//para is short for
11324	* self::node()/descendant-or-self::node()/child::para
11325	* and so will select all para descendant elements of the context
11326	* node.
11327	* Similarly, a location step of .. is short for parent::node().
11328	* For example, ../title is short for parent::node()/child::title
11329	* and so will select the title children of the parent of the context
11330	* node.
11331	*/
11332	static void
11333	xmlXPathCompStep(xmlXPathParserContextPtr ctxt) {
11334	#ifdef LIBXML_XPTR_ENABLED
11335	int rangeto = 0;
11336	int op2 = -1;
11337	#endif
11338
11339	SKIP_BLANKS;
11340	if ((CUR == '.') && (NXT(1) == '.')) {
11341	SKIP(2);
11342	SKIP_BLANKS;
11343	PUSH_LONG_EXPR(XPATH_OP_COLLECT, AXIS_PARENT,
11344	NODE_TEST_TYPE, NODE_TYPE_NODE, NULL, NULL);
11345	} else if (CUR == '.') {
11346	NEXT;
11347	SKIP_BLANKS;
11348	} else {
11349	xmlChar *name = NULL;
11350	const xmlChar *prefix = NULL;
11351	xmlXPathTestVal test = (xmlXPathTestVal) 0;
11352	xmlXPathAxisVal axis = (xmlXPathAxisVal) 0;
11353	xmlXPathTypeVal type = (xmlXPathTypeVal) 0;
11354	int op1;
11355
11356	/*
11357	* The modification needed for XPointer change to the production
11358	*/
11359	#ifdef LIBXML_XPTR_ENABLED
11360	if (ctxt->xptr) {
11361	name = xmlXPathParseNCName(ctxt);
11362	if ((name != NULL) && (xmlStrEqual(name, BAD_CAST "range-to"))) {
11363	op2 = ctxt->comp->last;
11364	xmlFree(name);
11365	SKIP_BLANKS;
11366	if (CUR != '(') {
11367	XP_ERROR(XPATH_EXPR_ERROR);
11368	}
11369	NEXT;
11370	SKIP_BLANKS;
11371
11372	xmlXPathCompileExpr(ctxt, 1);
11373	/* PUSH_BINARY_EXPR(XPATH_OP_RANGETO, op2, ctxt->comp->last, 0, 0); */
11374	CHECK_ERROR;
11375
11376	SKIP_BLANKS;
11377	if (CUR != ')') {
11378	XP_ERROR(XPATH_EXPR_ERROR);
11379	}
11380	NEXT;
11381	rangeto = 1;
11382	goto eval_predicates;
11383	}
11384	}
11385	#endif
11386	if (CUR == '*') {
11387	axis = AXIS_CHILD;
11388	} else {
11389	if (name == NULL)
11390	name = xmlXPathParseNCName(ctxt);
11391	if (name != NULL) {
11392	axis = xmlXPathIsAxisName(name);
11393	if (axis != 0) {
11394	SKIP_BLANKS;
11395	if ((CUR == ':') && (NXT(1) == ':')) {
11396	SKIP(2);
11397	xmlFree(name);
11398	name = NULL;
11399	} else {
11400	/* an element name can conflict with an axis one :-\ */
11401	axis = AXIS_CHILD;
11402	}
11403	} else {
11404	axis = AXIS_CHILD;
11405	}
11406	} else if (CUR == '@') {
11407	NEXT;
11408	axis = AXIS_ATTRIBUTE;
11409	} else {
11410	axis = AXIS_CHILD;
11411	}
11412	}
11413
11414	if (ctxt->error != XPATH_EXPRESSION_OK) {
11415	xmlFree(name);
11416	return;
11417	}
11418
11419	name = xmlXPathCompNodeTest(ctxt, &test, &type, &prefix, name);
11420	if (test == 0)
11421	return;
11422
11423	if ((prefix != NULL) && (ctxt->context != NULL) &&
11424	(ctxt->context->flags & XML_XPATH_CHECKNS)) {
11425	if (xmlXPathNsLookup(ctxt->context, prefix) == NULL) {
11426	xmlXPathErr(ctxt, XPATH_UNDEF_PREFIX_ERROR);
11427	}
11428	}
11429	#ifdef DEBUG_STEP
11430	xmlGenericError(xmlGenericErrorContext,
11431	"Basis : computing new set\n");
11432	#endif
11433
11434	#ifdef DEBUG_STEP
11435	xmlGenericError(xmlGenericErrorContext, "Basis : ");
11436	if (ctxt->value == NULL)
11437	xmlGenericError(xmlGenericErrorContext, "no value\n");
11438	else if (ctxt->value->nodesetval == NULL)
11439	xmlGenericError(xmlGenericErrorContext, "Empty\n");
11440	else
11441	xmlGenericErrorContextNodeSet(stdout, ctxt->value->nodesetval);
11442	#endif
11443
11444	#ifdef LIBXML_XPTR_ENABLED
11445	eval_predicates:
11446	#endif
11447	op1 = ctxt->comp->last;
11448	ctxt->comp->last = -1;
11449
11450	SKIP_BLANKS;
11451	while (CUR == '[') {
11452	xmlXPathCompPredicate(ctxt, 0);
11453	}
11454
11455	#ifdef LIBXML_XPTR_ENABLED
11456	if (rangeto) {
11457	PUSH_BINARY_EXPR(XPATH_OP_RANGETO, op2, op1, 0, 0);
11458	} else
11459	#endif
11460	PUSH_FULL_EXPR(XPATH_OP_COLLECT, op1, ctxt->comp->last, axis,
11461	test, type, (void )prefix, (void )name);
11462
11463	}
11464	#ifdef DEBUG_STEP
11465	xmlGenericError(xmlGenericErrorContext, "Step : ");
11466	if (ctxt->value == NULL)
11467	xmlGenericError(xmlGenericErrorContext, "no value\n");
11468	else if (ctxt->value->nodesetval == NULL)
11469	xmlGenericError(xmlGenericErrorContext, "Empty\n");
11470	else
11471	xmlGenericErrorContextNodeSet(xmlGenericErrorContext,
11472	ctxt->value->nodesetval);
11473	#endif
11474	}
11475
11476	/**
11477	* xmlXPathCompRelativeLocationPath:
11478	* @ctxt: the XPath Parser context
11479	*
11480	* [3] RelativeLocationPath ::= Step
11481	* \| RelativeLocationPath '/' Step
11482	* \| AbbreviatedRelativeLocationPath
11483	* [11] AbbreviatedRelativeLocationPath ::= RelativeLocationPath '//' Step
11484	*
11485	* Compile a relative location path.
11486	*/
11487	static void
11488	xmlXPathCompRelativeLocationPath
11489	(xmlXPathParserContextPtr ctxt) {
11490	SKIP_BLANKS;
11491	if ((CUR == '/') && (NXT(1) == '/')) {
11492	SKIP(2);
11493	SKIP_BLANKS;
11494	PUSH_LONG_EXPR(XPATH_OP_COLLECT, AXIS_DESCENDANT_OR_SELF,
11495	NODE_TEST_TYPE, NODE_TYPE_NODE, NULL, NULL);
11496	} else if (CUR == '/') {
11497	NEXT;
11498	SKIP_BLANKS;
11499	}
11500	xmlXPathCompStep(ctxt);
11501	CHECK_ERROR;
11502	SKIP_BLANKS;
11503	while (CUR == '/') {
11504	if ((CUR == '/') && (NXT(1) == '/')) {
11505	SKIP(2);
11506	SKIP_BLANKS;
11507	PUSH_LONG_EXPR(XPATH_OP_COLLECT, AXIS_DESCENDANT_OR_SELF,
11508	NODE_TEST_TYPE, NODE_TYPE_NODE, NULL, NULL);
11509	xmlXPathCompStep(ctxt);
11510	} else if (CUR == '/') {
11511	NEXT;
11512	SKIP_BLANKS;
11513	xmlXPathCompStep(ctxt);
11514	}
11515	SKIP_BLANKS;
11516	}
11517	}
11518
11519	/**
11520	* xmlXPathCompLocationPath:
11521	* @ctxt: the XPath Parser context
11522	*
11523	* [1] LocationPath ::= RelativeLocationPath
11524	* \| AbsoluteLocationPath
11525	* [2] AbsoluteLocationPath ::= '/' RelativeLocationPath?
11526	* \| AbbreviatedAbsoluteLocationPath
11527	* [10] AbbreviatedAbsoluteLocationPath ::=
11528	* '//' RelativeLocationPath
11529	*
11530	* Compile a location path
11531	*
11532	* // is short for /descendant-or-self::node()/. For example,
11533	* //para is short for /descendant-or-self::node()/child::para and
11534	* so will select any para element in the document (even a para element
11535	* that is a document element will be selected by //para since the
11536	* document element node is a child of the root node); div//para is
11537	* short for div/descendant-or-self::node()/child::para and so will
11538	* select all para descendants of div children.
11539	*/
11540	static void
11541	xmlXPathCompLocationPath(xmlXPathParserContextPtr ctxt) {
11542	SKIP_BLANKS;
11543	if (CUR != '/') {
11544	xmlXPathCompRelativeLocationPath(ctxt);
11545	} else {
11546	while (CUR == '/') {
11547	if ((CUR == '/') && (NXT(1) == '/')) {
11548	SKIP(2);
11549	SKIP_BLANKS;
11550	PUSH_LONG_EXPR(XPATH_OP_COLLECT, AXIS_DESCENDANT_OR_SELF,
11551	NODE_TEST_TYPE, NODE_TYPE_NODE, NULL, NULL);
11552	xmlXPathCompRelativeLocationPath(ctxt);
11553	} else if (CUR == '/') {
11554	NEXT;
11555	SKIP_BLANKS;
11556	if ((CUR != 0 ) &&
11557	((IS_ASCII_LETTER(CUR)) \|\| (CUR == '_') \|\| (CUR == '.') \|\|
11558	(CUR == '@') \|\| (CUR == '*')))
11559	xmlXPathCompRelativeLocationPath(ctxt);
11560	}
11561	CHECK_ERROR;
11562	}
11563	}
11564	}
11565
11566	/************************************************************************
11567	* *
11568	* XPath precompiled expression evaluation *
11569	* *
11570	************************************************************************/
11571
11572	static int
11573	xmlXPathCompOpEval(xmlXPathParserContextPtr ctxt, xmlXPathStepOpPtr op);
11574
11575	#ifdef DEBUG_STEP
11576	static void
11577	xmlXPathDebugDumpStepAxis(xmlXPathStepOpPtr op,
11578	int nbNodes)
11579	{
11580	xmlGenericError(xmlGenericErrorContext, "new step : ");
11581	switch (op->value) {
11582	case AXIS_ANCESTOR:
11583	xmlGenericError(xmlGenericErrorContext, "axis 'ancestors' ");
11584	break;
11585	case AXIS_ANCESTOR_OR_SELF:
11586	xmlGenericError(xmlGenericErrorContext,
11587	"axis 'ancestors-or-self' ");
11588	break;
11589	case AXIS_ATTRIBUTE:
11590	xmlGenericError(xmlGenericErrorContext, "axis 'attributes' ");
11591	break;
11592	case AXIS_CHILD:
11593	xmlGenericError(xmlGenericErrorContext, "axis 'child' ");
11594	break;
11595	case AXIS_DESCENDANT:
11596	xmlGenericError(xmlGenericErrorContext, "axis 'descendant' ");
11597	break;
11598	case AXIS_DESCENDANT_OR_SELF:
11599	xmlGenericError(xmlGenericErrorContext,
11600	"axis 'descendant-or-self' ");
11601	break;
11602	case AXIS_FOLLOWING:
11603	xmlGenericError(xmlGenericErrorContext, "axis 'following' ");
11604	break;
11605	case AXIS_FOLLOWING_SIBLING:
11606	xmlGenericError(xmlGenericErrorContext,
11607	"axis 'following-siblings' ");
11608	break;
11609	case AXIS_NAMESPACE:
11610	xmlGenericError(xmlGenericErrorContext, "axis 'namespace' ");
11611	break;
11612	case AXIS_PARENT:
11613	xmlGenericError(xmlGenericErrorContext, "axis 'parent' ");
11614	break;
11615	case AXIS_PRECEDING:
11616	xmlGenericError(xmlGenericErrorContext, "axis 'preceding' ");
11617	break;
11618	case AXIS_PRECEDING_SIBLING:
11619	xmlGenericError(xmlGenericErrorContext,
11620	"axis 'preceding-sibling' ");
11621	break;
11622	case AXIS_SELF:
11623	xmlGenericError(xmlGenericErrorContext, "axis 'self' ");
11624	break;
11625	}
11626	xmlGenericError(xmlGenericErrorContext,
11627	" context contains %d nodes\n", nbNodes);
11628	switch (op->value2) {
11629	case NODE_TEST_NONE:
11630	xmlGenericError(xmlGenericErrorContext,
11631	" searching for none !!!\n");
11632	break;
11633	case NODE_TEST_TYPE:
11634	xmlGenericError(xmlGenericErrorContext,
11635	" searching for type %d\n", op->value3);
11636	break;
11637	case NODE_TEST_PI:
11638	xmlGenericError(xmlGenericErrorContext,
11639	" searching for PI !!!\n");
11640	break;
11641	case NODE_TEST_ALL:
11642	xmlGenericError(xmlGenericErrorContext,
11643	" searching for *\n");
11644	break;
11645	case NODE_TEST_NS:
11646	xmlGenericError(xmlGenericErrorContext,
11647	" searching for namespace %s\n",
11648	op->value5);
11649	break;
11650	case NODE_TEST_NAME:
11651	xmlGenericError(xmlGenericErrorContext,
11652	" searching for name %s\n", op->value5);
11653	if (op->value4)
11654	xmlGenericError(xmlGenericErrorContext,
11655	" with namespace %s\n", op->value4);
11656	break;
11657	}
11658	xmlGenericError(xmlGenericErrorContext, "Testing : ");
11659	}
11660	#endif /* DEBUG_STEP */
11661
11662	static int
11663	xmlXPathCompOpEvalPredicate(xmlXPathParserContextPtr ctxt,
11664	xmlXPathStepOpPtr op,
11665	xmlNodeSetPtr set,
11666	int contextSize,
11667	int hasNsNodes)
11668	{
11669	if (op->ch1 != -1) {
11670	xmlXPathCompExprPtr comp = ctxt->comp;
11671	/*
11672	* Process inner predicates first.
11673	*/
11674	if (comp->steps[op->ch1].op != XPATH_OP_PREDICATE) {
11675	/*
11676	* TODO: raise an internal error.
11677	*/
11678	}
11679	contextSize = xmlXPathCompOpEvalPredicate(ctxt,
11680	&comp->steps[op->ch1], set, contextSize, hasNsNodes);
11681	CHECK_ERROR0;
11682	if (contextSize <= 0)
11683	return(0);
11684	}
11685	if (op->ch2 != -1) {
11686	xmlXPathContextPtr xpctxt = ctxt->context;
11687	xmlNodePtr contextNode, oldContextNode;
11688	xmlDocPtr oldContextDoc;
11689	int i, res, contextPos = 0, newContextSize;
11690	xmlXPathStepOpPtr exprOp;
11691	xmlXPathObjectPtr contextObj = NULL, exprRes = NULL;
11692
11693	#ifdef LIBXML_XPTR_ENABLED
11694	/*
11695	* URGENT TODO: Check the following:
11696	* We don't expect location sets if evaluating prediates, right?
11697	* Only filters should expect location sets, right?
11698	*/
11699	#endif
11700	/*
11701	* SPEC XPath 1.0:
11702	* "For each node in the node-set to be filtered, the
11703	* PredicateExpr is evaluated with that node as the
11704	* context node, with the number of nodes in the
11705	* node-set as the context size, and with the proximity
11706	* position of the node in the node-set with respect to
11707	* the axis as the context position;"
11708	* @oldset is the node-set" to be filtered.
11709	*
11710	* SPEC XPath 1.0:
11711	* "only predicates change the context position and
11712	* context size (see [2.4 Predicates])."
11713	* Example:
11714	* node-set context pos
11715	* nA 1
11716	* nB 2
11717	* nC 3
11718	* After applying predicate [position() > 1] :
11719	* node-set context pos
11720	* nB 1
11721	* nC 2
11722	*/
11723	oldContextNode = xpctxt->node;
11724	oldContextDoc = xpctxt->doc;
11725	/*
11726	* Get the expression of this predicate.
11727	*/
11728	exprOp = &ctxt->comp->steps[op->ch2];
11729	newContextSize = 0;
11730	for (i = 0; i < set->nodeNr; i++) {
11731	if (set->nodeTab[i] == NULL)
11732	continue;
11733
11734	contextNode = set->nodeTab[i];
11735	xpctxt->node = contextNode;
11736	xpctxt->contextSize = contextSize;
11737	xpctxt->proximityPosition = ++contextPos;
11738
11739	/*
11740	* Also set the xpath document in case things like
11741	* key() are evaluated in the predicate.
11742	*/
11743	if ((contextNode->type != XML_NAMESPACE_DECL) &&
11744	(contextNode->doc != NULL))
11745	xpctxt->doc = contextNode->doc;
11746	/*
11747	* Evaluate the predicate expression with 1 context node
11748	* at a time; this node is packaged into a node set; this
11749	* node set is handed over to the evaluation mechanism.
11750	*/
11751	if (contextObj == NULL)
11752	contextObj = xmlXPathCacheNewNodeSet(xpctxt, contextNode);
11753	else {
11754	if (xmlXPathNodeSetAddUnique(contextObj->nodesetval,
11755	contextNode) < 0) {
11756	ctxt->error = XPATH_MEMORY_ERROR;
11757	goto evaluation_exit;
11758	}
11759	}
11760
11761	valuePush(ctxt, contextObj);
11762
11763	res = xmlXPathCompOpEvalToBoolean(ctxt, exprOp, 1);
11764
11765	if ((ctxt->error != XPATH_EXPRESSION_OK) \|\| (res == -1)) {
11766	xmlXPathNodeSetClear(set, hasNsNodes);
11767	newContextSize = 0;
11768	goto evaluation_exit;
11769	}
11770
11771	if (res != 0) {
11772	newContextSize++;
11773	} else {
11774	/*
11775	* Remove the entry from the initial node set.
11776	*/
11777	set->nodeTab[i] = NULL;
11778	if (contextNode->type == XML_NAMESPACE_DECL)
11779	xmlXPathNodeSetFreeNs((xmlNsPtr) contextNode);
11780	}
11781	if (ctxt->value == contextObj) {
11782	/*
11783	* Don't free the temporary XPath object holding the
11784	* context node, in order to avoid massive recreation
11785	* inside this loop.
11786	*/
11787	valuePop(ctxt);
11788	xmlXPathNodeSetClear(contextObj->nodesetval, hasNsNodes);
11789	} else {
11790	/*
11791	* TODO: The object was lost in the evaluation machinery.
11792	* Can this happen? Maybe in internal-error cases.
11793	*/
11794	contextObj = NULL;
11795	}
11796	}
11797
11798	if (contextObj != NULL) {
11799	if (ctxt->value == contextObj)
11800	valuePop(ctxt);
11801	xmlXPathReleaseObject(xpctxt, contextObj);
11802	}
11803	evaluation_exit:
11804	if (exprRes != NULL)
11805	xmlXPathReleaseObject(ctxt->context, exprRes);
11806	/*
11807	* Reset/invalidate the context.
11808	*/
11809	xpctxt->node = oldContextNode;
11810	xpctxt->doc = oldContextDoc;
11811	xpctxt->contextSize = -1;
11812	xpctxt->proximityPosition = -1;
11813	return(newContextSize);
11814	}
11815	return(contextSize);
11816	}
11817
11818	static int
11819	xmlXPathCompOpEvalPositionalPredicate(xmlXPathParserContextPtr ctxt,
11820	xmlXPathStepOpPtr op,
11821	xmlNodeSetPtr set,
11822	int contextSize,
11823	int minPos,
11824	int maxPos,
11825	int hasNsNodes)
11826	{
11827	if (op->ch1 != -1) {
11828	xmlXPathCompExprPtr comp = ctxt->comp;
11829	if (comp->steps[op->ch1].op != XPATH_OP_PREDICATE) {
11830	/*
11831	* TODO: raise an internal error.
11832	*/
11833	}
11834	contextSize = xmlXPathCompOpEvalPredicate(ctxt,
11835	&comp->steps[op->ch1], set, contextSize, hasNsNodes);
11836	CHECK_ERROR0;
11837	if (contextSize <= 0)
11838	return(0);
11839	}
11840	/*
11841	* Check if the node set contains a sufficient number of nodes for
11842	* the requested range.
11843	*/
11844	if (contextSize < minPos) {
11845	xmlXPathNodeSetClear(set, hasNsNodes);
11846	return(0);
11847	}
11848	if (op->ch2 == -1) {
11849	/*
11850	* TODO: Can this ever happen?
11851	*/
11852	return (contextSize);
11853	} else {
11854	xmlDocPtr oldContextDoc;
11855	int i, pos = 0, newContextSize = 0, contextPos = 0, res;
11856	xmlXPathStepOpPtr exprOp;
11857	xmlXPathObjectPtr contextObj = NULL, exprRes = NULL;
11858	xmlNodePtr oldContextNode, contextNode = NULL;
11859	xmlXPathContextPtr xpctxt = ctxt->context;
11860	int frame;
11861
11862	#ifdef LIBXML_XPTR_ENABLED
11863	/*
11864	* URGENT TODO: Check the following:
11865	* We don't expect location sets if evaluating prediates, right?
11866	* Only filters should expect location sets, right?
11867	*/
11868	#endif /* LIBXML_XPTR_ENABLED */
11869
11870	/*
11871	* Save old context.
11872	*/
11873	oldContextNode = xpctxt->node;
11874	oldContextDoc = xpctxt->doc;
11875	/*
11876	* Get the expression of this predicate.
11877	*/
11878	exprOp = &ctxt->comp->steps[op->ch2];
11879	for (i = 0; i < set->nodeNr; i++) {
11880	xmlXPathObjectPtr tmp;
11881
11882	if (set->nodeTab[i] == NULL)
11883	continue;
11884
11885	contextNode = set->nodeTab[i];
11886	xpctxt->node = contextNode;
11887	xpctxt->contextSize = contextSize;
11888	xpctxt->proximityPosition = ++contextPos;
11889
11890	/*
11891	* Initialize the new set.
11892	* Also set the xpath document in case things like
11893	* key() evaluation are attempted on the predicate
11894	*/
11895	if ((contextNode->type != XML_NAMESPACE_DECL) &&
11896	(contextNode->doc != NULL))
11897	xpctxt->doc = contextNode->doc;
11898	/*
11899	* Evaluate the predicate expression with 1 context node
11900	* at a time; this node is packaged into a node set; this
11901	* node set is handed over to the evaluation mechanism.
11902	*/
11903	if (contextObj == NULL)
11904	contextObj = xmlXPathCacheNewNodeSet(xpctxt, contextNode);
11905	else {
11906	if (xmlXPathNodeSetAddUnique(contextObj->nodesetval,
11907	contextNode) < 0) {
11908	ctxt->error = XPATH_MEMORY_ERROR;
11909	goto evaluation_exit;
11910	}
11911	}
11912
11913	frame = xmlXPathSetFrame(ctxt);
11914	valuePush(ctxt, contextObj);
11915	res = xmlXPathCompOpEvalToBoolean(ctxt, exprOp, 1);
11916	tmp = valuePop(ctxt);
11917	xmlXPathPopFrame(ctxt, frame);
11918
11919	if ((ctxt->error != XPATH_EXPRESSION_OK) \|\| (res == -1)) {
11920	while (tmp != contextObj) {
11921	/*
11922	* Free up the result
11923	* then pop off contextObj, which will be freed later
11924	*/
11925	xmlXPathReleaseObject(xpctxt, tmp);
11926	tmp = valuePop(ctxt);
11927	}
11928	goto evaluation_error;
11929	}
11930	/* push the result back onto the stack */
11931	valuePush(ctxt, tmp);
11932
11933	if (res)
11934	pos++;
11935
11936	if (res && (pos >= minPos) && (pos <= maxPos)) {
11937	/*
11938	* Fits in the requested range.
11939	*/
11940	newContextSize++;
11941	if (minPos == maxPos) {
11942	/*
11943	* Only 1 node was requested.
11944	*/
11945	if (contextNode->type == XML_NAMESPACE_DECL) {
11946	/*
11947	* As always: take care of those nasty
11948	* namespace nodes.
11949	*/
11950	set->nodeTab[i] = NULL;
11951	}
11952	xmlXPathNodeSetClear(set, hasNsNodes);
11953	set->nodeNr = 1;
11954	set->nodeTab[0] = contextNode;
11955	goto evaluation_exit;
11956	}
11957	if (pos == maxPos) {
11958	/*
11959	* We are done.
11960	*/
11961	xmlXPathNodeSetClearFromPos(set, i +1, hasNsNodes);
11962	goto evaluation_exit;
11963	}
11964	} else {
11965	/*
11966	* Remove the entry from the initial node set.
11967	*/
11968	set->nodeTab[i] = NULL;
11969	if (contextNode->type == XML_NAMESPACE_DECL)
11970	xmlXPathNodeSetFreeNs((xmlNsPtr) contextNode);
11971	}
11972	if (exprRes != NULL) {
11973	xmlXPathReleaseObject(ctxt->context, exprRes);
11974	exprRes = NULL;
11975	}
11976	if (ctxt->value == contextObj) {
11977	/*
11978	* Don't free the temporary XPath object holding the
11979	* context node, in order to avoid massive recreation
11980	* inside this loop.
11981	*/
11982	valuePop(ctxt);
11983	xmlXPathNodeSetClear(contextObj->nodesetval, hasNsNodes);
11984	} else {
11985	/*
11986	* The object was lost in the evaluation machinery.
11987	* Can this happen? Maybe in case of internal-errors.
11988	*/
11989	contextObj = NULL;
11990	}
11991	}
11992	goto evaluation_exit;
11993
11994	evaluation_error:
11995	xmlXPathNodeSetClear(set, hasNsNodes);
11996	newContextSize = 0;
11997
11998	evaluation_exit:
11999	if (contextObj != NULL) {
12000	if (ctxt->value == contextObj)
12001	valuePop(ctxt);
12002	xmlXPathReleaseObject(xpctxt, contextObj);
12003	}
12004	if (exprRes != NULL)
12005	xmlXPathReleaseObject(ctxt->context, exprRes);
12006	/*
12007	* Reset/invalidate the context.
12008	*/
12009	xpctxt->node = oldContextNode;
12010	xpctxt->doc = oldContextDoc;
12011	xpctxt->contextSize = -1;
12012	xpctxt->proximityPosition = -1;
12013	return(newContextSize);
12014	}
12015	return(contextSize);
12016	}
12017
12018	static int
12019	xmlXPathIsPositionalPredicate(xmlXPathParserContextPtr ctxt,
12020	xmlXPathStepOpPtr op,
12021	int *maxPos)
12022	{
12023
12024	xmlXPathStepOpPtr exprOp;
12025
12026	/*
12027	* BIG NOTE: This is not intended for XPATH_OP_FILTER yet!
12028	*/
12029
12030	/*
12031	* If not -1, then ch1 will point to:
12032	* 1) For predicates (XPATH_OP_PREDICATE):
12033	* - an inner predicate operator
12034	* 2) For filters (XPATH_OP_FILTER):
12035	* - an inner filter operater OR
12036	* - an expression selecting the node set.
12037	* E.g. "key('a', 'b')" or "(//foo \| //bar)".
12038	*/
12039	if ((op->op != XPATH_OP_PREDICATE) && (op->op != XPATH_OP_FILTER))
12040	return(0);
12041
12042	if (op->ch2 != -1) {
12043	exprOp = &ctxt->comp->steps[op->ch2];
12044	} else
12045	return(0);
12046
12047	if ((exprOp != NULL) &&
12048	(exprOp->op == XPATH_OP_VALUE) &&
12049	(exprOp->value4 != NULL) &&
12050	(((xmlXPathObjectPtr) exprOp->value4)->type == XPATH_NUMBER))
12051	{
12052	/*
12053	* We have a "[n]" predicate here.
12054	* TODO: Unfortunately this simplistic test here is not
12055	* able to detect a position() predicate in compound
12056	* expressions like "[@attr = 'a" and position() = 1],
12057	* and even not the usage of position() in
12058	* "[position() = 1]"; thus - obviously - a position-range,
12059	* like it "[position() < 5]", is also not detected.
12060	* Maybe we could rewrite the AST to ease the optimization.
12061	*/
12062	*maxPos = (int) ((xmlXPathObjectPtr) exprOp->value4)->floatval;
12063
12064	if (((xmlXPathObjectPtr) exprOp->value4)->floatval ==
12065	(float) *maxPos)
12066	{
12067	return(1);
12068	}
12069	}
12070	return(0);
12071	}
12072
12073	static int
12074	xmlXPathNodeCollectAndTest(xmlXPathParserContextPtr ctxt,
12075	xmlXPathStepOpPtr op,
12076	xmlNodePtr * first, xmlNodePtr * last,
12077	int toBool)
12078	{
12079
12080	#define XP_TEST_HIT \
12081	if (hasAxisRange != 0) { \
12082	if (++pos == maxPos) { \
12083	if (addNode(seq, cur) < 0) \
12084	ctxt->error = XPATH_MEMORY_ERROR; \
12085	goto axis_range_end; } \
12086	} else { \
12087	if (addNode(seq, cur) < 0) \
12088	ctxt->error = XPATH_MEMORY_ERROR; \
12089	if (breakOnFirstHit) goto first_hit; }
12090
12091	#define XP_TEST_HIT_NS \
12092	if (hasAxisRange != 0) { \
12093	if (++pos == maxPos) { \
12094	hasNsNodes = 1; \
12095	if (xmlXPathNodeSetAddNs(seq, xpctxt->node, (xmlNsPtr) cur) < 0) \
12096	ctxt->error = XPATH_MEMORY_ERROR; \
12097	goto axis_range_end; } \
12098	} else { \
12099	hasNsNodes = 1; \
12100	if (xmlXPathNodeSetAddNs(seq, xpctxt->node, (xmlNsPtr) cur) < 0) \
12101	ctxt->error = XPATH_MEMORY_ERROR; \
12102	if (breakOnFirstHit) goto first_hit; }
12103
12104	xmlXPathAxisVal axis = (xmlXPathAxisVal) op->value;
12105	xmlXPathTestVal test = (xmlXPathTestVal) op->value2;
12106	xmlXPathTypeVal type = (xmlXPathTypeVal) op->value3;
12107	const xmlChar *prefix = op->value4;
12108	const xmlChar *name = op->value5;
12109	const xmlChar *URI = NULL;
12110
12111	#ifdef DEBUG_STEP
12112	int nbMatches = 0, prevMatches = 0;
12113	#endif
12114	int total = 0, hasNsNodes = 0;
12115	/* The popped object holding the context nodes */
12116	xmlXPathObjectPtr obj;
12117	/* The set of context nodes for the node tests */
12118	xmlNodeSetPtr contextSeq;
12119	int contextIdx;
12120	xmlNodePtr contextNode;
12121	/* The final resulting node set wrt to all context nodes */
12122	xmlNodeSetPtr outSeq;
12123	/*
12124	* The temporary resulting node set wrt 1 context node.
12125	* Used to feed predicate evaluation.
12126	*/
12127	xmlNodeSetPtr seq;
12128	xmlNodePtr cur;
12129	/* First predicate operator */
12130	xmlXPathStepOpPtr predOp;
12131	int maxPos; /* The requested position() (when a "[n]" predicate) */
12132	int hasPredicateRange, hasAxisRange, pos, size, newSize;
12133	int breakOnFirstHit;
12134
12135	xmlXPathTraversalFunction next = NULL;
12136	int (*addNode) (xmlNodeSetPtr, xmlNodePtr);
12137	xmlXPathNodeSetMergeFunction mergeAndClear;
12138	xmlNodePtr oldContextNode;
12139	xmlXPathContextPtr xpctxt = ctxt->context;
12140
12141
12142	CHECK_TYPE0(XPATH_NODESET);
12143	obj = valuePop(ctxt);
12144	/*
12145	* Setup namespaces.
12146	*/
12147	if (prefix != NULL) {
12148	URI = xmlXPathNsLookup(xpctxt, prefix);
12149	if (URI == NULL) {
12150	xmlXPathReleaseObject(xpctxt, obj);
12151	XP_ERROR0(XPATH_UNDEF_PREFIX_ERROR);
12152	}
12153	}
12154	/*
12155	* Setup axis.
12156	*
12157	* MAYBE FUTURE TODO: merging optimizations:
12158	* - If the nodes to be traversed wrt to the initial nodes and
12159	* the current axis cannot overlap, then we could avoid searching
12160	* for duplicates during the merge.
12161	* But the question is how/when to evaluate if they cannot overlap.
12162	* Example: if we know that for two initial nodes, the one is
12163	* not in the ancestor-or-self axis of the other, then we could safely
12164	* avoid a duplicate-aware merge, if the axis to be traversed is e.g.
12165	* the descendant-or-self axis.
12166	*/
12167	mergeAndClear = xmlXPathNodeSetMergeAndClear;
12168	switch (axis) {
12169	case AXIS_ANCESTOR:
12170	first = NULL;
12171	next = xmlXPathNextAncestor;
12172	break;
12173	case AXIS_ANCESTOR_OR_SELF:
12174	first = NULL;
12175	next = xmlXPathNextAncestorOrSelf;
12176	break;
12177	case AXIS_ATTRIBUTE:
12178	first = NULL;
12179	last = NULL;
12180	next = xmlXPathNextAttribute;
12181	mergeAndClear = xmlXPathNodeSetMergeAndClearNoDupls;
12182	break;
12183	case AXIS_CHILD:
12184	last = NULL;
12185	if (((test == NODE_TEST_NAME) \|\| (test == NODE_TEST_ALL)) &&
12186	(type == NODE_TYPE_NODE))
12187	{
12188	/*
12189	* Optimization if an element node type is 'element'.
12190	*/
12191	next = xmlXPathNextChildElement;
12192	} else
12193	next = xmlXPathNextChild;
12194	mergeAndClear = xmlXPathNodeSetMergeAndClearNoDupls;
12195	break;
12196	case AXIS_DESCENDANT:
12197	last = NULL;
12198	next = xmlXPathNextDescendant;
12199	break;
12200	case AXIS_DESCENDANT_OR_SELF:
12201	last = NULL;
12202	next = xmlXPathNextDescendantOrSelf;
12203	break;
12204	case AXIS_FOLLOWING:
12205	last = NULL;
12206	next = xmlXPathNextFollowing;
12207	break;
12208	case AXIS_FOLLOWING_SIBLING:
12209	last = NULL;
12210	next = xmlXPathNextFollowingSibling;
12211	break;
12212	case AXIS_NAMESPACE:
12213	first = NULL;
12214	last = NULL;
12215	next = (xmlXPathTraversalFunction) xmlXPathNextNamespace;
12216	mergeAndClear = xmlXPathNodeSetMergeAndClearNoDupls;
12217	break;
12218	case AXIS_PARENT:
12219	first = NULL;
12220	next = xmlXPathNextParent;
12221	break;
12222	case AXIS_PRECEDING:
12223	first = NULL;
12224	next = xmlXPathNextPrecedingInternal;
12225	break;
12226	case AXIS_PRECEDING_SIBLING:
12227	first = NULL;
12228	next = xmlXPathNextPrecedingSibling;
12229	break;
12230	case AXIS_SELF:
12231	first = NULL;
12232	last = NULL;
12233	next = xmlXPathNextSelf;
12234	mergeAndClear = xmlXPathNodeSetMergeAndClearNoDupls;
12235	break;
12236	}
12237
12238	#ifdef DEBUG_STEP
12239	xmlXPathDebugDumpStepAxis(op,
12240	(obj->nodesetval != NULL) ? obj->nodesetval->nodeNr : 0);
12241	#endif
12242
12243	if (next == NULL) {
12244	xmlXPathReleaseObject(xpctxt, obj);
12245	return(0);
12246	}
12247	contextSeq = obj->nodesetval;
12248	if ((contextSeq == NULL) \|\| (contextSeq->nodeNr <= 0)) {
12249	xmlXPathReleaseObject(xpctxt, obj);
12250	valuePush(ctxt, xmlXPathCacheWrapNodeSet(xpctxt, NULL));
12251	return(0);
12252	}
12253	/*
12254	* Predicate optimization ---------------------------------------------
12255	* If this step has a last predicate, which contains a position(),
12256	* then we'll optimize (although not exactly "position()", but only
12257	* the short-hand form, i.e., "[n]".
12258	*
12259	* Example - expression "/foo[parent::bar][1]":
12260	*
12261	* COLLECT 'child' 'name' 'node' foo -- op (we are here)
12262	* ROOT -- op->ch1
12263	* PREDICATE -- op->ch2 (predOp)
12264	* PREDICATE -- predOp->ch1 = [parent::bar]
12265	* SORT
12266	* COLLECT 'parent' 'name' 'node' bar
12267	* NODE
12268	* ELEM Object is a number : 1 -- predOp->ch2 = [1]
12269	*
12270	*/
12271	maxPos = 0;
12272	predOp = NULL;
12273	hasPredicateRange = 0;
12274	hasAxisRange = 0;
12275	if (op->ch2 != -1) {
12276	/*
12277	* There's at least one predicate. 16 == XPATH_OP_PREDICATE
12278	*/
12279	predOp = &ctxt->comp->steps[op->ch2];
12280	if (xmlXPathIsPositionalPredicate(ctxt, predOp, &maxPos)) {
12281	if (predOp->ch1 != -1) {
12282	/*
12283	* Use the next inner predicate operator.
12284	*/
12285	predOp = &ctxt->comp->steps[predOp->ch1];
12286	hasPredicateRange = 1;
12287	} else {
12288	/*
12289	* There's no other predicate than the [n] predicate.
12290	*/
12291	predOp = NULL;
12292	hasAxisRange = 1;
12293	}
12294	}
12295	}
12296	breakOnFirstHit = ((toBool) && (predOp == NULL)) ? 1 : 0;
12297	/*
12298	* Axis traversal -----------------------------------------------------
12299	*/
12300	/*
12301	* 2.3 Node Tests
12302	* - For the attribute axis, the principal node type is attribute.
12303	* - For the namespace axis, the principal node type is namespace.
12304	* - For other axes, the principal node type is element.
12305	*
12306	* A node test * is true for any node of the
12307	* principal node type. For example, child::* will
12308	* select all element children of the context node
12309	*/
12310	oldContextNode = xpctxt->node;
12311	addNode = xmlXPathNodeSetAddUnique;
12312	outSeq = NULL;
12313	seq = NULL;
12314	contextNode = NULL;
12315	contextIdx = 0;
12316
12317
12318	while (((contextIdx < contextSeq->nodeNr) \|\| (contextNode != NULL)) &&
12319	(ctxt->error == XPATH_EXPRESSION_OK)) {
12320	xpctxt->node = contextSeq->nodeTab[contextIdx++];
12321
12322	if (seq == NULL) {
12323	seq = xmlXPathNodeSetCreate(NULL);
12324	if (seq == NULL) {
12325	total = 0;
12326	goto error;
12327	}
12328	}
12329	/*
12330	* Traverse the axis and test the nodes.
12331	*/
12332	pos = 0;
12333	cur = NULL;
12334	hasNsNodes = 0;
12335	do {
12336	cur = next(ctxt, cur);
12337	if (cur == NULL)
12338	break;
12339
12340	/*
12341	* QUESTION TODO: What does the "first" and "last" stuff do?
12342	*/
12343	if ((first != NULL) && (*first != NULL)) {
12344	if (*first == cur)
12345	break;
12346	if (((total % 256) == 0) &&
12347	#ifdef XP_OPTIMIZED_NON_ELEM_COMPARISON
12348	(xmlXPathCmpNodesExt(*first, cur) >= 0))
12349	#else
12350	(xmlXPathCmpNodes(*first, cur) >= 0))
12351	#endif
12352	{
12353	break;
12354	}
12355	}
12356	if ((last != NULL) && (*last != NULL)) {
12357	if (*last == cur)
12358	break;
12359	if (((total % 256) == 0) &&
12360	#ifdef XP_OPTIMIZED_NON_ELEM_COMPARISON
12361	(xmlXPathCmpNodesExt(cur, *last) >= 0))
12362	#else
12363	(xmlXPathCmpNodes(cur, *last) >= 0))
12364	#endif
12365	{
12366	break;
12367	}
12368	}
12369
12370	total++;
12371
12372	#ifdef DEBUG_STEP
12373	xmlGenericError(xmlGenericErrorContext, " %s", cur->name);
12374	#endif
12375
12376	switch (test) {
12377	case NODE_TEST_NONE:
12378	total = 0;
12379	STRANGE
12380	goto error;
12381	case NODE_TEST_TYPE:
12382	/*
12383	* TODO: Don't we need to use
12384	* xmlXPathNodeSetAddNs() for namespace nodes here?
12385	* Surprisingly, some c14n tests fail, if we do this.
12386	*/
12387	if (type == NODE_TYPE_NODE) {
12388	switch (cur->type) {
12389	case XML_DOCUMENT_NODE:
12390	case XML_HTML_DOCUMENT_NODE:
12391	#ifdef LIBXML_DOCB_ENABLED
12392	case XML_DOCB_DOCUMENT_NODE:
12393	#endif
12394	case XML_ELEMENT_NODE:
12395	case XML_ATTRIBUTE_NODE:
12396	case XML_PI_NODE:
12397	case XML_COMMENT_NODE:
12398	case XML_CDATA_SECTION_NODE:
12399	case XML_TEXT_NODE:
12400	case XML_NAMESPACE_DECL:
12401	XP_TEST_HIT
12402	break;
12403	default:
12404	break;
12405	}
12406	} else if (cur->type == type) {
12407	if (cur->type == XML_NAMESPACE_DECL)
12408	XP_TEST_HIT_NS
12409	else
12410	XP_TEST_HIT
12411	} else if ((type == NODE_TYPE_TEXT) &&
12412	(cur->type == XML_CDATA_SECTION_NODE))
12413	{
12414	XP_TEST_HIT
12415	}
12416	break;
12417	case NODE_TEST_PI:
12418	if ((cur->type == XML_PI_NODE) &&
12419	((name == NULL) \|\| xmlStrEqual(name, cur->name)))
12420	{
12421	XP_TEST_HIT
12422	}
12423	break;
12424	case NODE_TEST_ALL:
12425	if (axis == AXIS_ATTRIBUTE) {
12426	if (cur->type == XML_ATTRIBUTE_NODE)
12427	{
12428	if (prefix == NULL)
12429	{
12430	XP_TEST_HIT
12431	} else if ((cur->ns != NULL) &&
12432	(xmlStrEqual(URI, cur->ns->href)))
12433	{
12434	XP_TEST_HIT
12435	}
12436	}
12437	} else if (axis == AXIS_NAMESPACE) {
12438	if (cur->type == XML_NAMESPACE_DECL)
12439	{
12440	XP_TEST_HIT_NS
12441	}
12442	} else {
12443	if (cur->type == XML_ELEMENT_NODE) {
12444	if (prefix == NULL)
12445	{
12446	XP_TEST_HIT
12447
12448	} else if ((cur->ns != NULL) &&
12449	(xmlStrEqual(URI, cur->ns->href)))
12450	{
12451	XP_TEST_HIT
12452	}
12453	}
12454	}
12455	break;
12456	case NODE_TEST_NS:{
12457	TODO;
12458	break;
12459	}
12460	case NODE_TEST_NAME:
12461	if (axis == AXIS_ATTRIBUTE) {
12462	if (cur->type != XML_ATTRIBUTE_NODE)
12463	break;
12464	} else if (axis == AXIS_NAMESPACE) {
12465	if (cur->type != XML_NAMESPACE_DECL)
12466	break;
12467	} else {
12468	if (cur->type != XML_ELEMENT_NODE)
12469	break;
12470	}
12471	switch (cur->type) {
12472	case XML_ELEMENT_NODE:
12473	if (xmlStrEqual(name, cur->name)) {
12474	if (prefix == NULL) {
12475	if (cur->ns == NULL)
12476	{
12477	XP_TEST_HIT
12478	}
12479	} else {
12480	if ((cur->ns != NULL) &&
12481	(xmlStrEqual(URI, cur->ns->href)))
12482	{
12483	XP_TEST_HIT
12484	}
12485	}
12486	}
12487	break;
12488	case XML_ATTRIBUTE_NODE:{
12489	xmlAttrPtr attr = (xmlAttrPtr) cur;
12490
12491	if (xmlStrEqual(name, attr->name)) {
12492	if (prefix == NULL) {
12493	if ((attr->ns == NULL) \|\|
12494	(attr->ns->prefix == NULL))
12495	{
12496	XP_TEST_HIT
12497	}
12498	} else {
12499	if ((attr->ns != NULL) &&
12500	(xmlStrEqual(URI,
12501	attr->ns->href)))
12502	{
12503	XP_TEST_HIT
12504	}
12505	}
12506	}
12507	break;
12508	}
12509	case XML_NAMESPACE_DECL:
12510	if (cur->type == XML_NAMESPACE_DECL) {
12511	xmlNsPtr ns = (xmlNsPtr) cur;
12512
12513	if ((ns->prefix != NULL) && (name != NULL)
12514	&& (xmlStrEqual(ns->prefix, name)))
12515	{
12516	XP_TEST_HIT_NS
12517	}
12518	}
12519	break;
12520	default:
12521	break;
12522	}
12523	break;
12524	} /* switch(test) */
12525	} while ((cur != NULL) && (ctxt->error == XPATH_EXPRESSION_OK));
12526
12527	goto apply_predicates;
12528
12529	axis_range_end: /* ----------------------------------------------------- */
12530	/*
12531	* We have a "/foo[n]", and position() = n was reached.
12532	* Note that we can have as well "/foo/::parent::foo[1]", so
12533	* a duplicate-aware merge is still needed.
12534	* Merge with the result.
12535	*/
12536	if (outSeq == NULL) {
12537	outSeq = seq;
12538	seq = NULL;
12539	} else
12540	outSeq = mergeAndClear(outSeq, seq, 0);
12541	/*
12542	* Break if only a true/false result was requested.
12543	*/
12544	if (toBool)
12545	break;
12546	continue;
12547
12548	first_hit: /* ---------------------------------------------------------- */
12549	/*
12550	* Break if only a true/false result was requested and
12551	* no predicates existed and a node test succeeded.
12552	*/
12553	if (outSeq == NULL) {
12554	outSeq = seq;
12555	seq = NULL;
12556	} else
12557	outSeq = mergeAndClear(outSeq, seq, 0);
12558	break;
12559
12560	#ifdef DEBUG_STEP
12561	if (seq != NULL)
12562	nbMatches += seq->nodeNr;
12563	#endif
12564
12565	apply_predicates: /* --------------------------------------------------- */
12566	if (ctxt->error != XPATH_EXPRESSION_OK)
12567	goto error;
12568
12569	/*
12570	* Apply predicates.
12571	*/
12572	if ((predOp != NULL) && (seq->nodeNr > 0)) {
12573	/*
12574	* E.g. when we have a "/foo[some expression][n]".
12575	*/
12576	/*
12577	* QUESTION TODO: The old predicate evaluation took into
12578	* account location-sets.
12579	* (E.g. ctxt->value->type == XPATH_LOCATIONSET)
12580	* Do we expect such a set here?
12581	* All what I learned now from the evaluation semantics
12582	* does not indicate that a location-set will be processed
12583	* here, so this looks OK.
12584	*/
12585	/*
12586	* Iterate over all predicates, starting with the outermost
12587	* predicate.
12588	* TODO: Problem: we cannot execute the inner predicates first
12589	* since we cannot go back up the operator tree!
12590	* Options we have:
12591	* 1) Use of recursive functions (like is it currently done
12592	* via xmlXPathCompOpEval())
12593	* 2) Add a predicate evaluation information stack to the
12594	* context struct
12595	* 3) Change the way the operators are linked; we need a
12596	* "parent" field on xmlXPathStepOp
12597	*
12598	* For the moment, I'll try to solve this with a recursive
12599	* function: xmlXPathCompOpEvalPredicate().
12600	*/
12601	size = seq->nodeNr;
12602	if (hasPredicateRange != 0)
12603	newSize = xmlXPathCompOpEvalPositionalPredicate(ctxt,
12604	predOp, seq, size, maxPos, maxPos, hasNsNodes);
12605	else
12606	newSize = xmlXPathCompOpEvalPredicate(ctxt,
12607	predOp, seq, size, hasNsNodes);
12608
12609	if (ctxt->error != XPATH_EXPRESSION_OK) {
12610	total = 0;
12611	goto error;
12612	}
12613	/*
12614	* Add the filtered set of nodes to the result node set.
12615	*/
12616	if (newSize == 0) {
12617	/*
12618	* The predicates filtered all nodes out.
12619	*/
12620	xmlXPathNodeSetClear(seq, hasNsNodes);
12621	} else if (seq->nodeNr > 0) {
12622	/*
12623	* Add to result set.
12624	*/
12625	if (outSeq == NULL) {
12626	if (size != newSize) {
12627	/*
12628	* We need to merge and clear here, since
12629	* the sequence will contained NULLed entries.
12630	*/
12631	outSeq = mergeAndClear(NULL, seq, 1);
12632	} else {
12633	outSeq = seq;
12634	seq = NULL;
12635	}
12636	} else
12637	outSeq = mergeAndClear(outSeq, seq,
12638	(size != newSize) ? 1: 0);
12639	/*
12640	* Break if only a true/false result was requested.
12641	*/
12642	if (toBool)
12643	break;
12644	}
12645	} else if (seq->nodeNr > 0) {
12646	/*
12647	* Add to result set.
12648	*/
12649	if (outSeq == NULL) {
12650	outSeq = seq;
12651	seq = NULL;
12652	} else {
12653	outSeq = mergeAndClear(outSeq, seq, 0);
12654	}
12655	}
12656	}
12657
12658	error:
12659	if ((obj->boolval) && (obj->user != NULL)) {
12660	/*
12661	* QUESTION TODO: What does this do and why?
12662	* TODO: Do we have to do this also for the "error"
12663	* cleanup further down?
12664	*/
12665	ctxt->value->boolval = 1;
12666	ctxt->value->user = obj->user;
12667	obj->user = NULL;
12668	obj->boolval = 0;
12669	}
12670	xmlXPathReleaseObject(xpctxt, obj);
12671
12672	/*
12673	* Ensure we return at least an emtpy set.
12674	*/
12675	if (outSeq == NULL) {
12676	if ((seq != NULL) && (seq->nodeNr == 0))
12677	outSeq = seq;
12678	else
12679	outSeq = xmlXPathNodeSetCreate(NULL);
12680	/* XXX what if xmlXPathNodeSetCreate returned NULL here? */
12681	}
12682	if ((seq != NULL) && (seq != outSeq)) {
12683	xmlXPathFreeNodeSet(seq);
12684	}
12685	/*
12686	* Hand over the result. Better to push the set also in
12687	* case of errors.
12688	*/
12689	valuePush(ctxt, xmlXPathCacheWrapNodeSet(xpctxt, outSeq));
12690	/*
12691	* Reset the context node.
12692	*/
12693	xpctxt->node = oldContextNode;
12694
12695	#ifdef DEBUG_STEP
12696	xmlGenericError(xmlGenericErrorContext,
12697	"\nExamined %d nodes, found %d nodes at that step\n",
12698	total, nbMatches);
12699	#endif
12700
12701	return(total);
12702	}
12703
12704	static int
12705	xmlXPathCompOpEvalFilterFirst(xmlXPathParserContextPtr ctxt,
12706	xmlXPathStepOpPtr op, xmlNodePtr * first);
12707
12708	/**
12709	* xmlXPathCompOpEvalFirst:
12710	* @ctxt: the XPath parser context with the compiled expression
12711	* @op: an XPath compiled operation
12712	* @first: the first elem found so far
12713	*
12714	* Evaluate the Precompiled XPath operation searching only the first
12715	* element in document order
12716	*
12717	* Returns the number of examined objects.
12718	*/
12719	static int
12720	xmlXPathCompOpEvalFirst(xmlXPathParserContextPtr ctxt,
12721	xmlXPathStepOpPtr op, xmlNodePtr * first)
12722	{
12723	int total = 0, cur;
12724	xmlXPathCompExprPtr comp;
12725	xmlXPathObjectPtr arg1, arg2;
12726
12727	CHECK_ERROR0;
12728	comp = ctxt->comp;
12729	switch (op->op) {
12730	case XPATH_OP_END:
12731	return (0);
12732	case XPATH_OP_UNION:
12733	total =
12734	xmlXPathCompOpEvalFirst(ctxt, &comp->steps[op->ch1],
12735	first);
12736	CHECK_ERROR0;
12737	if ((ctxt->value != NULL)
12738	&& (ctxt->value->type == XPATH_NODESET)
12739	&& (ctxt->value->nodesetval != NULL)
12740	&& (ctxt->value->nodesetval->nodeNr >= 1)) {
12741	/*
12742	* limit tree traversing to first node in the result
12743	*/
12744	/*
12745	* OPTIMIZE TODO: This implicitely sorts
12746	* the result, even if not needed. E.g. if the argument
12747	* of the count() function, no sorting is needed.
12748	* OPTIMIZE TODO: How do we know if the node-list wasn't
12749	* aready sorted?
12750	*/
12751	if (ctxt->value->nodesetval->nodeNr > 1)
12752	xmlXPathNodeSetSort(ctxt->value->nodesetval);
12753	*first = ctxt->value->nodesetval->nodeTab[0];
12754	}
12755	cur =
12756	xmlXPathCompOpEvalFirst(ctxt, &comp->steps[op->ch2],
12757	first);
12758	CHECK_ERROR0;
12759	CHECK_TYPE0(XPATH_NODESET);
12760	arg2 = valuePop(ctxt);
12761
12762	CHECK_TYPE0(XPATH_NODESET);
12763	arg1 = valuePop(ctxt);
12764
12765	arg1->nodesetval = xmlXPathNodeSetMerge(arg1->nodesetval,
12766	arg2->nodesetval);
12767	valuePush(ctxt, arg1);
12768	xmlXPathReleaseObject(ctxt->context, arg2);
12769	/* optimizer */
12770	if (total > cur)
12771	xmlXPathCompSwap(op);
12772	return (total + cur);
12773	case XPATH_OP_ROOT:
12774	xmlXPathRoot(ctxt);
12775	return (0);
12776	case XPATH_OP_NODE:
12777	if (op->ch1 != -1)
12778	total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
12779	CHECK_ERROR0;
12780	if (op->ch2 != -1)
12781	total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
12782	CHECK_ERROR0;
12783	valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context,
12784	ctxt->context->node));
12785	return (total);
12786	case XPATH_OP_RESET:
12787	if (op->ch1 != -1)
12788	total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
12789	CHECK_ERROR0;
12790	if (op->ch2 != -1)
12791	total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
12792	CHECK_ERROR0;
12793	ctxt->context->node = NULL;
12794	return (total);
12795	case XPATH_OP_COLLECT:{
12796	if (op->ch1 == -1)
12797	return (total);
12798
12799	total = xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
12800	CHECK_ERROR0;
12801
12802	total += xmlXPathNodeCollectAndTest(ctxt, op, first, NULL, 0);
12803	return (total);
12804	}
12805	case XPATH_OP_VALUE:
12806	valuePush(ctxt,
12807	xmlXPathCacheObjectCopy(ctxt->context,
12808	(xmlXPathObjectPtr) op->value4));
12809	return (0);
12810	case XPATH_OP_SORT:
12811	if (op->ch1 != -1)
12812	total +=
12813	xmlXPathCompOpEvalFirst(ctxt, &comp->steps[op->ch1],
12814	first);
12815	CHECK_ERROR0;
12816	if ((ctxt->value != NULL)
12817	&& (ctxt->value->type == XPATH_NODESET)
12818	&& (ctxt->value->nodesetval != NULL)
12819	&& (ctxt->value->nodesetval->nodeNr > 1))
12820	xmlXPathNodeSetSort(ctxt->value->nodesetval);
12821	return (total);
12822	#ifdef XP_OPTIMIZED_FILTER_FIRST
12823	case XPATH_OP_FILTER:
12824	total += xmlXPathCompOpEvalFilterFirst(ctxt, op, first);
12825	return (total);
12826	#endif
12827	default:
12828	return (xmlXPathCompOpEval(ctxt, op));
12829	}
12830	}
12831
12832	/**
12833	* xmlXPathCompOpEvalLast:
12834	* @ctxt: the XPath parser context with the compiled expression
12835	* @op: an XPath compiled operation
12836	* @last: the last elem found so far
12837	*
12838	* Evaluate the Precompiled XPath operation searching only the last
12839	* element in document order
12840	*
12841	* Returns the number of nodes traversed
12842	*/
12843	static int
12844	xmlXPathCompOpEvalLast(xmlXPathParserContextPtr ctxt, xmlXPathStepOpPtr op,
12845	xmlNodePtr * last)
12846	{
12847	int total = 0, cur;
12848	xmlXPathCompExprPtr comp;
12849	xmlXPathObjectPtr arg1, arg2;
12850	xmlNodePtr bak;
12851	xmlDocPtr bakd;
12852	int pp;
12853	int cs;
12854
12855	CHECK_ERROR0;
12856	comp = ctxt->comp;
12857	switch (op->op) {
12858	case XPATH_OP_END:
12859	return (0);
12860	case XPATH_OP_UNION:
12861	bakd = ctxt->context->doc;
12862	bak = ctxt->context->node;
12863	pp = ctxt->context->proximityPosition;
12864	cs = ctxt->context->contextSize;
12865	total =
12866	xmlXPathCompOpEvalLast(ctxt, &comp->steps[op->ch1], last);
12867	CHECK_ERROR0;
12868	if ((ctxt->value != NULL)
12869	&& (ctxt->value->type == XPATH_NODESET)
12870	&& (ctxt->value->nodesetval != NULL)
12871	&& (ctxt->value->nodesetval->nodeNr >= 1)) {
12872	/*
12873	* limit tree traversing to first node in the result
12874	*/
12875	if (ctxt->value->nodesetval->nodeNr > 1)
12876	xmlXPathNodeSetSort(ctxt->value->nodesetval);
12877	*last =
12878	ctxt->value->nodesetval->nodeTab[ctxt->value->
12879	nodesetval->nodeNr -
12880	1];
12881	}
12882	ctxt->context->doc = bakd;
12883	ctxt->context->node = bak;
12884	ctxt->context->proximityPosition = pp;
12885	ctxt->context->contextSize = cs;
12886	cur =
12887	xmlXPathCompOpEvalLast(ctxt, &comp->steps[op->ch2], last);
12888	CHECK_ERROR0;
12889	if ((ctxt->value != NULL)
12890	&& (ctxt->value->type == XPATH_NODESET)
12891	&& (ctxt->value->nodesetval != NULL)
12892	&& (ctxt->value->nodesetval->nodeNr >= 1)) { /* TODO: NOP ? */
12893	}
12894	CHECK_TYPE0(XPATH_NODESET);
12895	arg2 = valuePop(ctxt);
12896
12897	CHECK_TYPE0(XPATH_NODESET);
12898	arg1 = valuePop(ctxt);
12899
12900	arg1->nodesetval = xmlXPathNodeSetMerge(arg1->nodesetval,
12901	arg2->nodesetval);
12902	valuePush(ctxt, arg1);
12903	xmlXPathReleaseObject(ctxt->context, arg2);
12904	/* optimizer */
12905	if (total > cur)
12906	xmlXPathCompSwap(op);
12907	return (total + cur);
12908	case XPATH_OP_ROOT:
12909	xmlXPathRoot(ctxt);
12910	return (0);
12911	case XPATH_OP_NODE:
12912	if (op->ch1 != -1)
12913	total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
12914	CHECK_ERROR0;
12915	if (op->ch2 != -1)
12916	total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
12917	CHECK_ERROR0;
12918	valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context,
12919	ctxt->context->node));
12920	return (total);
12921	case XPATH_OP_RESET:
12922	if (op->ch1 != -1)
12923	total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
12924	CHECK_ERROR0;
12925	if (op->ch2 != -1)
12926	total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
12927	CHECK_ERROR0;
12928	ctxt->context->node = NULL;
12929	return (total);
12930	case XPATH_OP_COLLECT:{
12931	if (op->ch1 == -1)
12932	return (0);
12933
12934	total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
12935	CHECK_ERROR0;
12936
12937	total += xmlXPathNodeCollectAndTest(ctxt, op, NULL, last, 0);
12938	return (total);
12939	}
12940	case XPATH_OP_VALUE:
12941	valuePush(ctxt,
12942	xmlXPathCacheObjectCopy(ctxt->context,
12943	(xmlXPathObjectPtr) op->value4));
12944	return (0);
12945	case XPATH_OP_SORT:
12946	if (op->ch1 != -1)
12947	total +=
12948	xmlXPathCompOpEvalLast(ctxt, &comp->steps[op->ch1],
12949	last);
12950	CHECK_ERROR0;
12951	if ((ctxt->value != NULL)
12952	&& (ctxt->value->type == XPATH_NODESET)
12953	&& (ctxt->value->nodesetval != NULL)
12954	&& (ctxt->value->nodesetval->nodeNr > 1))
12955	xmlXPathNodeSetSort(ctxt->value->nodesetval);
12956	return (total);
12957	default:
12958	return (xmlXPathCompOpEval(ctxt, op));
12959	}
12960	}
12961
12962	#ifdef XP_OPTIMIZED_FILTER_FIRST
12963	static int
12964	xmlXPathCompOpEvalFilterFirst(xmlXPathParserContextPtr ctxt,
12965	xmlXPathStepOpPtr op, xmlNodePtr * first)
12966	{
12967	int total = 0;
12968	xmlXPathCompExprPtr comp;
12969	xmlXPathObjectPtr res;
12970	xmlXPathObjectPtr obj;
12971	xmlNodeSetPtr oldset;
12972	xmlNodePtr oldnode;
12973	xmlDocPtr oldDoc;
12974	int i;
12975
12976	CHECK_ERROR0;
12977	comp = ctxt->comp;
12978	/*
12979	* Optimization for ()[last()] selection i.e. the last elem
12980	*/
12981	if ((op->ch1 != -1) && (op->ch2 != -1) &&
12982	(comp->steps[op->ch1].op == XPATH_OP_SORT) &&
12983	(comp->steps[op->ch2].op == XPATH_OP_SORT)) {
12984	int f = comp->steps[op->ch2].ch1;
12985
12986	if ((f != -1) &&
12987	(comp->steps[f].op == XPATH_OP_FUNCTION) &&
12988	(comp->steps[f].value5 == NULL) &&
12989	(comp->steps[f].value == 0) &&
12990	(comp->steps[f].value4 != NULL) &&
12991	(xmlStrEqual
12992	(comp->steps[f].value4, BAD_CAST "last"))) {
12993	xmlNodePtr last = NULL;
12994
12995	total +=
12996	xmlXPathCompOpEvalLast(ctxt,
12997	&comp->steps[op->ch1],
12998	&last);
12999	CHECK_ERROR0;
13000	/*
13001	* The nodeset should be in document order,
13002	* Keep only the last value
13003	*/
13004	if ((ctxt->value != NULL) &&
13005	(ctxt->value->type == XPATH_NODESET) &&
13006	(ctxt->value->nodesetval != NULL) &&
13007	(ctxt->value->nodesetval->nodeTab != NULL) &&
13008	(ctxt->value->nodesetval->nodeNr > 1)) {
13009	ctxt->value->nodesetval->nodeTab[0] =
13010	ctxt->value->nodesetval->nodeTab[ctxt->
13011	value->
13012	nodesetval->
13013	nodeNr -
13014	1];
13015	ctxt->value->nodesetval->nodeNr = 1;
13016	first = (ctxt->value->nodesetval->nodeTab);
13017	}
13018	return (total);
13019	}
13020	}
13021
13022	if (op->ch1 != -1)
13023	total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13024	CHECK_ERROR0;
13025	if (op->ch2 == -1)
13026	return (total);
13027	if (ctxt->value == NULL)
13028	return (total);
13029
13030	#ifdef LIBXML_XPTR_ENABLED
13031	oldnode = ctxt->context->node;
13032	/*
13033	* Hum are we filtering the result of an XPointer expression
13034	*/
13035	if (ctxt->value->type == XPATH_LOCATIONSET) {
13036	xmlXPathObjectPtr tmp = NULL;
13037	xmlLocationSetPtr newlocset = NULL;
13038	xmlLocationSetPtr oldlocset;
13039
13040	/*
13041	* Extract the old locset, and then evaluate the result of the
13042	* expression for all the element in the locset. use it to grow
13043	* up a new locset.
13044	*/
13045	CHECK_TYPE0(XPATH_LOCATIONSET);
13046	obj = valuePop(ctxt);
13047	oldlocset = obj->user;
13048	ctxt->context->node = NULL;
13049
13050	if ((oldlocset == NULL) \|\| (oldlocset->locNr == 0)) {
13051	ctxt->context->contextSize = 0;
13052	ctxt->context->proximityPosition = 0;
13053	if (op->ch2 != -1)
13054	total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13055	res = valuePop(ctxt);
13056	if (res != NULL) {
13057	xmlXPathReleaseObject(ctxt->context, res);
13058	}
13059	valuePush(ctxt, obj);
13060	CHECK_ERROR0;
13061	return (total);
13062	}
13063	newlocset = xmlXPtrLocationSetCreate(NULL);
13064
13065	for (i = 0; i < oldlocset->locNr; i++) {
13066	/*
13067	* Run the evaluation with a node list made of a
13068	* single item in the nodelocset.
13069	*/
13070	ctxt->context->node = oldlocset->locTab[i]->user;
13071	ctxt->context->contextSize = oldlocset->locNr;
13072	ctxt->context->proximityPosition = i + 1;
13073	if (tmp == NULL) {
13074	tmp = xmlXPathCacheNewNodeSet(ctxt->context,
13075	ctxt->context->node);
13076	} else {
13077	if (xmlXPathNodeSetAddUnique(tmp->nodesetval,
13078	ctxt->context->node) < 0) {
13079	ctxt->error = XPATH_MEMORY_ERROR;
13080	}
13081	}
13082	valuePush(ctxt, tmp);
13083	if (op->ch2 != -1)
13084	total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13085	if (ctxt->error != XPATH_EXPRESSION_OK) {
13086	xmlXPathFreeObject(obj);
13087	return(0);
13088	}
13089	/*
13090	* The result of the evaluation need to be tested to
13091	* decided whether the filter succeeded or not
13092	*/
13093	res = valuePop(ctxt);
13094	if (xmlXPathEvaluatePredicateResult(ctxt, res)) {
13095	xmlXPtrLocationSetAdd(newlocset,
13096	xmlXPathCacheObjectCopy(ctxt->context,
13097	oldlocset->locTab[i]));
13098	}
13099	/*
13100	* Cleanup
13101	*/
13102	if (res != NULL) {
13103	xmlXPathReleaseObject(ctxt->context, res);
13104	}
13105	if (ctxt->value == tmp) {
13106	valuePop(ctxt);
13107	xmlXPathNodeSetClear(tmp->nodesetval, 1);
13108	/*
13109	* REVISIT TODO: Don't create a temporary nodeset
13110	* for everly iteration.
13111	*/
13112	/* OLD: xmlXPathFreeObject(res); */
13113	} else
13114	tmp = NULL;
13115	ctxt->context->node = NULL;
13116	/*
13117	* Only put the first node in the result, then leave.
13118	*/
13119	if (newlocset->locNr > 0) {
13120	*first = (xmlNodePtr) oldlocset->locTab[i]->user;
13121	break;
13122	}
13123	}
13124	if (tmp != NULL) {
13125	xmlXPathReleaseObject(ctxt->context, tmp);
13126	}
13127	/*
13128	* The result is used as the new evaluation locset.
13129	*/
13130	xmlXPathReleaseObject(ctxt->context, obj);
13131	ctxt->context->node = NULL;
13132	ctxt->context->contextSize = -1;
13133	ctxt->context->proximityPosition = -1;
13134	valuePush(ctxt, xmlXPtrWrapLocationSet(newlocset));
13135	ctxt->context->node = oldnode;
13136	return (total);
13137	}
13138	#endif /* LIBXML_XPTR_ENABLED */
13139
13140	/*
13141	* Extract the old set, and then evaluate the result of the
13142	* expression for all the element in the set. use it to grow
13143	* up a new set.
13144	*/
13145	CHECK_TYPE0(XPATH_NODESET);
13146	obj = valuePop(ctxt);
13147	oldset = obj->nodesetval;
13148
13149	oldnode = ctxt->context->node;
13150	oldDoc = ctxt->context->doc;
13151	ctxt->context->node = NULL;
13152
13153	if ((oldset == NULL) \|\| (oldset->nodeNr == 0)) {
13154	ctxt->context->contextSize = 0;
13155	ctxt->context->proximityPosition = 0;
13156	/* QUESTION TODO: Why was this code commented out?
13157	if (op->ch2 != -1)
13158	total +=
13159	xmlXPathCompOpEval(ctxt,
13160	&comp->steps[op->ch2]);
13161	CHECK_ERROR0;
13162	res = valuePop(ctxt);
13163	if (res != NULL)
13164	xmlXPathFreeObject(res);
13165	*/
13166	valuePush(ctxt, obj);
13167	ctxt->context->node = oldnode;
13168	CHECK_ERROR0;
13169	} else {
13170	xmlNodeSetPtr newset;
13171	xmlXPathObjectPtr tmp = NULL;
13172	/*
13173	* Initialize the new set.
13174	* Also set the xpath document in case things like
13175	* key() evaluation are attempted on the predicate
13176	*/
13177	newset = xmlXPathNodeSetCreate(NULL);
13178	/* XXX what if xmlXPathNodeSetCreate returned NULL? */
13179
13180	for (i = 0; i < oldset->nodeNr; i++) {
13181	/*
13182	* Run the evaluation with a node list made of
13183	* a single item in the nodeset.
13184	*/
13185	ctxt->context->node = oldset->nodeTab[i];
13186	if ((oldset->nodeTab[i]->type != XML_NAMESPACE_DECL) &&
13187	(oldset->nodeTab[i]->doc != NULL))
13188	ctxt->context->doc = oldset->nodeTab[i]->doc;
13189	if (tmp == NULL) {
13190	tmp = xmlXPathCacheNewNodeSet(ctxt->context,
13191	ctxt->context->node);
13192	} else {
13193	if (xmlXPathNodeSetAddUnique(tmp->nodesetval,
13194	ctxt->context->node) < 0) {
13195	ctxt->error = XPATH_MEMORY_ERROR;
13196	}
13197	}
13198	valuePush(ctxt, tmp);
13199	ctxt->context->contextSize = oldset->nodeNr;
13200	ctxt->context->proximityPosition = i + 1;
13201	if (op->ch2 != -1)
13202	total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13203	if (ctxt->error != XPATH_EXPRESSION_OK) {
13204	xmlXPathFreeNodeSet(newset);
13205	xmlXPathFreeObject(obj);
13206	return(0);
13207	}
13208	/*
13209	* The result of the evaluation needs to be tested to
13210	* decide whether the filter succeeded or not
13211	*/
13212	res = valuePop(ctxt);
13213	if (xmlXPathEvaluatePredicateResult(ctxt, res)) {
13214	if (xmlXPathNodeSetAdd(newset, oldset->nodeTab[i]) < 0)
13215	ctxt->error = XPATH_MEMORY_ERROR;
13216	}
13217	/*
13218	* Cleanup
13219	*/
13220	if (res != NULL) {
13221	xmlXPathReleaseObject(ctxt->context, res);
13222	}
13223	if (ctxt->value == tmp) {
13224	valuePop(ctxt);
13225	/*
13226	* Don't free the temporary nodeset
13227	* in order to avoid massive recreation inside this
13228	* loop.
13229	*/
13230	xmlXPathNodeSetClear(tmp->nodesetval, 1);
13231	} else
13232	tmp = NULL;
13233	ctxt->context->node = NULL;
13234	/*
13235	* Only put the first node in the result, then leave.
13236	*/
13237	if (newset->nodeNr > 0) {
13238	first = (newset->nodeTab);
13239	break;
13240	}
13241	}
13242	if (tmp != NULL) {
13243	xmlXPathReleaseObject(ctxt->context, tmp);
13244	}
13245	/*
13246	* The result is used as the new evaluation set.
13247	*/
13248	xmlXPathReleaseObject(ctxt->context, obj);
13249	ctxt->context->node = NULL;
13250	ctxt->context->contextSize = -1;
13251	ctxt->context->proximityPosition = -1;
13252	/* may want to move this past the '}' later */
13253	ctxt->context->doc = oldDoc;
13254	valuePush(ctxt, xmlXPathCacheWrapNodeSet(ctxt->context, newset));
13255	}
13256	ctxt->context->node = oldnode;
13257	return(total);
13258	}
13259	#endif /* XP_OPTIMIZED_FILTER_FIRST */
13260
13261	/**
13262	* xmlXPathCompOpEval:
13263	* @ctxt: the XPath parser context with the compiled expression
13264	* @op: an XPath compiled operation
13265	*
13266	* Evaluate the Precompiled XPath operation
13267	* Returns the number of nodes traversed
13268	*/
13269	static int
13270	xmlXPathCompOpEval(xmlXPathParserContextPtr ctxt, xmlXPathStepOpPtr op)
13271	{
13272	int total = 0;
13273	int equal, ret;
13274	xmlXPathCompExprPtr comp;
13275	xmlXPathObjectPtr arg1, arg2;
13276	xmlNodePtr bak;
13277	xmlDocPtr bakd;
13278	int pp;
13279	int cs;
13280
13281	CHECK_ERROR0;
13282	comp = ctxt->comp;
13283	switch (op->op) {
13284	case XPATH_OP_END:
13285	return (0);
13286	case XPATH_OP_AND:
13287	bakd = ctxt->context->doc;
13288	bak = ctxt->context->node;
13289	pp = ctxt->context->proximityPosition;
13290	cs = ctxt->context->contextSize;
13291	total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13292	CHECK_ERROR0;
13293	xmlXPathBooleanFunction(ctxt, 1);
13294	if ((ctxt->value == NULL) \|\| (ctxt->value->boolval == 0))
13295	return (total);
13296	arg2 = valuePop(ctxt);
13297	ctxt->context->doc = bakd;
13298	ctxt->context->node = bak;
13299	ctxt->context->proximityPosition = pp;
13300	ctxt->context->contextSize = cs;
13301	total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13302	if (ctxt->error) {
13303	xmlXPathFreeObject(arg2);
13304	return(0);
13305	}
13306	xmlXPathBooleanFunction(ctxt, 1);
13307	arg1 = valuePop(ctxt);
13308	arg1->boolval &= arg2->boolval;
13309	valuePush(ctxt, arg1);
13310	xmlXPathReleaseObject(ctxt->context, arg2);
13311	return (total);
13312	case XPATH_OP_OR:
13313	bakd = ctxt->context->doc;
13314	bak = ctxt->context->node;
13315	pp = ctxt->context->proximityPosition;
13316	cs = ctxt->context->contextSize;
13317	total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13318	CHECK_ERROR0;
13319	xmlXPathBooleanFunction(ctxt, 1);
13320	if ((ctxt->value == NULL) \|\| (ctxt->value->boolval == 1))
13321	return (total);
13322	arg2 = valuePop(ctxt);
13323	ctxt->context->doc = bakd;
13324	ctxt->context->node = bak;
13325	ctxt->context->proximityPosition = pp;
13326	ctxt->context->contextSize = cs;
13327	total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13328	if (ctxt->error) {
13329	xmlXPathFreeObject(arg2);
13330	return(0);
13331	}
13332	xmlXPathBooleanFunction(ctxt, 1);
13333	arg1 = valuePop(ctxt);
13334	arg1->boolval \|= arg2->boolval;
13335	valuePush(ctxt, arg1);
13336	xmlXPathReleaseObject(ctxt->context, arg2);
13337	return (total);
13338	case XPATH_OP_EQUAL:
13339	bakd = ctxt->context->doc;
13340	bak = ctxt->context->node;
13341	pp = ctxt->context->proximityPosition;
13342	cs = ctxt->context->contextSize;
13343	total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13344	CHECK_ERROR0;
13345	ctxt->context->doc = bakd;
13346	ctxt->context->node = bak;
13347	ctxt->context->proximityPosition = pp;
13348	ctxt->context->contextSize = cs;
13349	total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13350	CHECK_ERROR0;
13351	if (op->value)
13352	equal = xmlXPathEqualValues(ctxt);
13353	else
13354	equal = xmlXPathNotEqualValues(ctxt);
13355	valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, equal));
13356	return (total);
13357	case XPATH_OP_CMP:
13358	bakd = ctxt->context->doc;
13359	bak = ctxt->context->node;
13360	pp = ctxt->context->proximityPosition;
13361	cs = ctxt->context->contextSize;
13362	total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13363	CHECK_ERROR0;
13364	ctxt->context->doc = bakd;
13365	ctxt->context->node = bak;
13366	ctxt->context->proximityPosition = pp;
13367	ctxt->context->contextSize = cs;
13368	total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13369	CHECK_ERROR0;
13370	ret = xmlXPathCompareValues(ctxt, op->value, op->value2);
13371	valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, ret));
13372	return (total);
13373	case XPATH_OP_PLUS:
13374	bakd = ctxt->context->doc;
13375	bak = ctxt->context->node;
13376	pp = ctxt->context->proximityPosition;
13377	cs = ctxt->context->contextSize;
13378	total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13379	CHECK_ERROR0;
13380	if (op->ch2 != -1) {
13381	ctxt->context->doc = bakd;
13382	ctxt->context->node = bak;
13383	ctxt->context->proximityPosition = pp;
13384	ctxt->context->contextSize = cs;
13385	total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13386	}
13387	CHECK_ERROR0;
13388	if (op->value == 0)
13389	xmlXPathSubValues(ctxt);
13390	else if (op->value == 1)
13391	xmlXPathAddValues(ctxt);
13392	else if (op->value == 2)
13393	xmlXPathValueFlipSign(ctxt);
13394	else if (op->value == 3) {
13395	CAST_TO_NUMBER;
13396	CHECK_TYPE0(XPATH_NUMBER);
13397	}
13398	return (total);
13399	case XPATH_OP_MULT:
13400	bakd = ctxt->context->doc;
13401	bak = ctxt->context->node;
13402	pp = ctxt->context->proximityPosition;
13403	cs = ctxt->context->contextSize;
13404	total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13405	CHECK_ERROR0;
13406	ctxt->context->doc = bakd;
13407	ctxt->context->node = bak;
13408	ctxt->context->proximityPosition = pp;
13409	ctxt->context->contextSize = cs;
13410	total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13411	CHECK_ERROR0;
13412	if (op->value == 0)
13413	xmlXPathMultValues(ctxt);
13414	else if (op->value == 1)
13415	xmlXPathDivValues(ctxt);
13416	else if (op->value == 2)
13417	xmlXPathModValues(ctxt);
13418	return (total);
13419	case XPATH_OP_UNION:
13420	bakd = ctxt->context->doc;
13421	bak = ctxt->context->node;
13422	pp = ctxt->context->proximityPosition;
13423	cs = ctxt->context->contextSize;
13424	total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13425	CHECK_ERROR0;
13426	ctxt->context->doc = bakd;
13427	ctxt->context->node = bak;
13428	ctxt->context->proximityPosition = pp;
13429	ctxt->context->contextSize = cs;
13430	total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13431	CHECK_ERROR0;
13432	CHECK_TYPE0(XPATH_NODESET);
13433	arg2 = valuePop(ctxt);
13434
13435	CHECK_TYPE0(XPATH_NODESET);
13436	arg1 = valuePop(ctxt);
13437
13438	if ((arg1->nodesetval == NULL) \|\|
13439	((arg2->nodesetval != NULL) &&
13440	(arg2->nodesetval->nodeNr != 0)))
13441	{
13442	arg1->nodesetval = xmlXPathNodeSetMerge(arg1->nodesetval,
13443	arg2->nodesetval);
13444	}
13445
13446	valuePush(ctxt, arg1);
13447	xmlXPathReleaseObject(ctxt->context, arg2);
13448	return (total);
13449	case XPATH_OP_ROOT:
13450	xmlXPathRoot(ctxt);
13451	return (total);
13452	case XPATH_OP_NODE:
13453	if (op->ch1 != -1)
13454	total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13455	CHECK_ERROR0;
13456	if (op->ch2 != -1)
13457	total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13458	CHECK_ERROR0;
13459	valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context,
13460	ctxt->context->node));
13461	return (total);
13462	case XPATH_OP_RESET:
13463	if (op->ch1 != -1)
13464	total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13465	CHECK_ERROR0;
13466	if (op->ch2 != -1)
13467	total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13468	CHECK_ERROR0;
13469	ctxt->context->node = NULL;
13470	return (total);
13471	case XPATH_OP_COLLECT:{
13472	if (op->ch1 == -1)
13473	return (total);
13474
13475	total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13476	CHECK_ERROR0;
13477
13478	total += xmlXPathNodeCollectAndTest(ctxt, op, NULL, NULL, 0);
13479	return (total);
13480	}
13481	case XPATH_OP_VALUE:
13482	valuePush(ctxt,
13483	xmlXPathCacheObjectCopy(ctxt->context,
13484	(xmlXPathObjectPtr) op->value4));
13485	return (total);
13486	case XPATH_OP_VARIABLE:{
13487	xmlXPathObjectPtr val;
13488
13489	if (op->ch1 != -1)
13490	total +=
13491	xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13492	if (op->value5 == NULL) {
13493	val = xmlXPathVariableLookup(ctxt->context, op->value4);
13494	if (val == NULL) {
13495	ctxt->error = XPATH_UNDEF_VARIABLE_ERROR;
13496	return(0);
13497	}
13498	valuePush(ctxt, val);
13499	} else {
13500	const xmlChar *URI;
13501
13502	URI = xmlXPathNsLookup(ctxt->context, op->value5);
13503	if (URI == NULL) {
13504	xmlGenericError(xmlGenericErrorContext,
13505	"xmlXPathCompOpEval: variable %s bound to undefined prefix %s\n",
13506	(char ) op->value4, (char )op->value5);
13507	ctxt->error = XPATH_UNDEF_PREFIX_ERROR;
13508	return (total);
13509	}
13510	val = xmlXPathVariableLookupNS(ctxt->context,
13511	op->value4, URI);
13512	if (val == NULL) {
13513	ctxt->error = XPATH_UNDEF_VARIABLE_ERROR;
13514	return(0);
13515	}
13516	valuePush(ctxt, val);
13517	}
13518	return (total);
13519	}
13520	case XPATH_OP_FUNCTION:{
13521	xmlXPathFunction func;
13522	const xmlChar oldFunc, oldFuncURI;
13523	int i;
13524	int frame;
13525
13526	frame = xmlXPathSetFrame(ctxt);
13527	if (op->ch1 != -1) {
13528	total +=
13529	xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13530	if (ctxt->error != XPATH_EXPRESSION_OK) {
13531	xmlXPathPopFrame(ctxt, frame);
13532	return (total);
13533	}
13534	}
13535	if (ctxt->valueNr < ctxt->valueFrame + op->value) {
13536	xmlGenericError(xmlGenericErrorContext,
13537	"xmlXPathCompOpEval: parameter error\n");
13538	ctxt->error = XPATH_INVALID_OPERAND;
13539	xmlXPathPopFrame(ctxt, frame);
13540	return (total);
13541	}
13542	for (i = 0; i < op->value; i++) {
13543	if (ctxt->valueTab[(ctxt->valueNr - 1) - i] == NULL) {
13544	xmlGenericError(xmlGenericErrorContext,
13545	"xmlXPathCompOpEval: parameter error\n");
13546	ctxt->error = XPATH_INVALID_OPERAND;
13547	xmlXPathPopFrame(ctxt, frame);
13548	return (total);
13549	}
13550	}
13551	if (op->cache != NULL)
13552	XML_CAST_FPTR(func) = op->cache;
13553	else {
13554	const xmlChar *URI = NULL;
13555
13556	if (op->value5 == NULL)
13557	func =
13558	xmlXPathFunctionLookup(ctxt->context,
13559	op->value4);
13560	else {
13561	URI = xmlXPathNsLookup(ctxt->context, op->value5);
13562	if (URI == NULL) {
13563	xmlGenericError(xmlGenericErrorContext,
13564	"xmlXPathCompOpEval: function %s bound to undefined prefix %s\n",
13565	(char )op->value4, (char )op->value5);
13566	xmlXPathPopFrame(ctxt, frame);
13567	ctxt->error = XPATH_UNDEF_PREFIX_ERROR;
13568	return (total);
13569	}
13570	func = xmlXPathFunctionLookupNS(ctxt->context,
13571	op->value4, URI);
13572	}
13573	if (func == NULL) {
13574	xmlGenericError(xmlGenericErrorContext,
13575	"xmlXPathCompOpEval: function %s not found\n",
13576	(char *)op->value4);
13577	XP_ERROR0(XPATH_UNKNOWN_FUNC_ERROR);
13578	}
13579	op->cache = XML_CAST_FPTR(func);
13580	op->cacheURI = (void *) URI;
13581	}
13582	oldFunc = ctxt->context->function;
13583	oldFuncURI = ctxt->context->functionURI;
13584	ctxt->context->function = op->value4;
13585	ctxt->context->functionURI = op->cacheURI;
13586	func(ctxt, op->value);
13587	ctxt->context->function = oldFunc;
13588	ctxt->context->functionURI = oldFuncURI;
13589	xmlXPathPopFrame(ctxt, frame);
13590	return (total);
13591	}
13592	case XPATH_OP_ARG:
13593	bakd = ctxt->context->doc;
13594	bak = ctxt->context->node;
13595	pp = ctxt->context->proximityPosition;
13596	cs = ctxt->context->contextSize;
13597	if (op->ch1 != -1) {
13598	total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13599	ctxt->context->contextSize = cs;
13600	ctxt->context->proximityPosition = pp;
13601	ctxt->context->node = bak;
13602	ctxt->context->doc = bakd;
13603	CHECK_ERROR0;
13604	}
13605	if (op->ch2 != -1) {
13606	total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13607	ctxt->context->contextSize = cs;
13608	ctxt->context->proximityPosition = pp;
13609	ctxt->context->node = bak;
13610	ctxt->context->doc = bakd;
13611	CHECK_ERROR0;
13612	}
13613	return (total);
13614	case XPATH_OP_PREDICATE:
13615	case XPATH_OP_FILTER:{
13616	xmlXPathObjectPtr res;
13617	xmlXPathObjectPtr obj, tmp;
13618	xmlNodeSetPtr newset = NULL;
13619	xmlNodeSetPtr oldset;
13620	xmlNodePtr oldnode;
13621	xmlDocPtr oldDoc;
13622	int i;
13623
13624	/*
13625	* Optimization for ()[1] selection i.e. the first elem
13626	*/
13627	if ((op->ch1 != -1) && (op->ch2 != -1) &&
13628	#ifdef XP_OPTIMIZED_FILTER_FIRST
13629	/*
13630	* FILTER TODO: Can we assume that the inner processing
13631	* will result in an ordered list if we have an
13632	* XPATH_OP_FILTER?
13633	* What about an additional field or flag on
13634	* xmlXPathObject like @sorted ? This way we wouln'd need
13635	* to assume anything, so it would be more robust and
13636	* easier to optimize.
13637	*/
13638	((comp->steps[op->ch1].op == XPATH_OP_SORT) \|\| /* 18 */
13639	(comp->steps[op->ch1].op == XPATH_OP_FILTER)) && /* 17 */
13640	#else
13641	(comp->steps[op->ch1].op == XPATH_OP_SORT) &&
13642	#endif
13643	(comp->steps[op->ch2].op == XPATH_OP_VALUE)) { /* 12 */
13644	xmlXPathObjectPtr val;
13645
13646	val = comp->steps[op->ch2].value4;
13647	if ((val != NULL) && (val->type == XPATH_NUMBER) &&
13648	(val->floatval == 1.0)) {
13649	xmlNodePtr first = NULL;
13650
13651	total +=
13652	xmlXPathCompOpEvalFirst(ctxt,
13653	&comp->steps[op->ch1],
13654	&first);
13655	CHECK_ERROR0;
13656	/*
13657	* The nodeset should be in document order,
13658	* Keep only the first value
13659	*/
13660	if ((ctxt->value != NULL) &&
13661	(ctxt->value->type == XPATH_NODESET) &&
13662	(ctxt->value->nodesetval != NULL) &&
13663	(ctxt->value->nodesetval->nodeNr > 1))
13664	ctxt->value->nodesetval->nodeNr = 1;
13665	return (total);
13666	}
13667	}
13668	/*
13669	* Optimization for ()[last()] selection i.e. the last elem
13670	*/
13671	if ((op->ch1 != -1) && (op->ch2 != -1) &&
13672	(comp->steps[op->ch1].op == XPATH_OP_SORT) &&
13673	(comp->steps[op->ch2].op == XPATH_OP_SORT)) {
13674	int f = comp->steps[op->ch2].ch1;
13675
13676	if ((f != -1) &&
13677	(comp->steps[f].op == XPATH_OP_FUNCTION) &&
13678	(comp->steps[f].value5 == NULL) &&
13679	(comp->steps[f].value == 0) &&
13680	(comp->steps[f].value4 != NULL) &&
13681	(xmlStrEqual
13682	(comp->steps[f].value4, BAD_CAST "last"))) {
13683	xmlNodePtr last = NULL;
13684
13685	total +=
13686	xmlXPathCompOpEvalLast(ctxt,
13687	&comp->steps[op->ch1],
13688	&last);
13689	CHECK_ERROR0;
13690	/*
13691	* The nodeset should be in document order,
13692	* Keep only the last value
13693	*/
13694	if ((ctxt->value != NULL) &&
13695	(ctxt->value->type == XPATH_NODESET) &&
13696	(ctxt->value->nodesetval != NULL) &&
13697	(ctxt->value->nodesetval->nodeTab != NULL) &&
13698	(ctxt->value->nodesetval->nodeNr > 1)) {
13699	ctxt->value->nodesetval->nodeTab[0] =
13700	ctxt->value->nodesetval->nodeTab[ctxt->
13701	value->
13702	nodesetval->
13703	nodeNr -
13704	1];
13705	ctxt->value->nodesetval->nodeNr = 1;
13706	}
13707	return (total);
13708	}
13709	}
13710	/*
13711	* Process inner predicates first.
13712	* Example "index[parent::book][1]":
13713	* ...
13714	* PREDICATE <-- we are here "[1]"
13715	* PREDICATE <-- process "[parent::book]" first
13716	* SORT
13717	* COLLECT 'parent' 'name' 'node' book
13718	* NODE
13719	* ELEM Object is a number : 1
13720	*/
13721	if (op->ch1 != -1)
13722	total +=
13723	xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13724	CHECK_ERROR0;
13725	if (op->ch2 == -1)
13726	return (total);
13727	if (ctxt->value == NULL)
13728	return (total);
13729
13730	oldnode = ctxt->context->node;
13731
13732	#ifdef LIBXML_XPTR_ENABLED
13733	/*
13734	* Hum are we filtering the result of an XPointer expression
13735	*/
13736	if (ctxt->value->type == XPATH_LOCATIONSET) {
13737	xmlLocationSetPtr newlocset = NULL;
13738	xmlLocationSetPtr oldlocset;
13739
13740	/*
13741	* Extract the old locset, and then evaluate the result of the
13742	* expression for all the element in the locset. use it to grow
13743	* up a new locset.
13744	*/
13745	CHECK_TYPE0(XPATH_LOCATIONSET);
13746	obj = valuePop(ctxt);
13747	oldlocset = obj->user;
13748	ctxt->context->node = NULL;
13749
13750	if ((oldlocset == NULL) \|\| (oldlocset->locNr == 0)) {
13751	ctxt->context->contextSize = 0;
13752	ctxt->context->proximityPosition = 0;
13753	if (op->ch2 != -1)
13754	total +=
13755	xmlXPathCompOpEval(ctxt,
13756	&comp->steps[op->ch2]);
13757	res = valuePop(ctxt);
13758	if (res != NULL) {
13759	xmlXPathReleaseObject(ctxt->context, res);
13760	}
13761	valuePush(ctxt, obj);
13762	CHECK_ERROR0;
13763	return (total);
13764	}
13765	newlocset = xmlXPtrLocationSetCreate(NULL);
13766
13767	for (i = 0; i < oldlocset->locNr; i++) {
13768	/*
13769	* Run the evaluation with a node list made of a
13770	* single item in the nodelocset.
13771	*/
13772	ctxt->context->node = oldlocset->locTab[i]->user;
13773	ctxt->context->contextSize = oldlocset->locNr;
13774	ctxt->context->proximityPosition = i + 1;
13775	tmp = xmlXPathCacheNewNodeSet(ctxt->context,
13776	ctxt->context->node);
13777	valuePush(ctxt, tmp);
13778
13779	if (op->ch2 != -1)
13780	total +=
13781	xmlXPathCompOpEval(ctxt,
13782	&comp->steps[op->ch2]);
13783	if (ctxt->error != XPATH_EXPRESSION_OK) {
13784	xmlXPathFreeObject(obj);
13785	return(0);
13786	}
13787
13788	/*
13789	* The result of the evaluation need to be tested to
13790	* decided whether the filter succeeded or not
13791	*/
13792	res = valuePop(ctxt);
13793	if (xmlXPathEvaluatePredicateResult(ctxt, res)) {
13794	xmlXPtrLocationSetAdd(newlocset,
13795	xmlXPathObjectCopy
13796	(oldlocset->locTab[i]));
13797	}
13798
13799	/*
13800	* Cleanup
13801	*/
13802	if (res != NULL) {
13803	xmlXPathReleaseObject(ctxt->context, res);
13804	}
13805	if (ctxt->value == tmp) {
13806	res = valuePop(ctxt);
13807	xmlXPathReleaseObject(ctxt->context, res);
13808	}
13809
13810	ctxt->context->node = NULL;
13811	}
13812
13813	/*
13814	* The result is used as the new evaluation locset.
13815	*/
13816	xmlXPathReleaseObject(ctxt->context, obj);
13817	ctxt->context->node = NULL;
13818	ctxt->context->contextSize = -1;
13819	ctxt->context->proximityPosition = -1;
13820	valuePush(ctxt, xmlXPtrWrapLocationSet(newlocset));
13821	ctxt->context->node = oldnode;
13822	return (total);
13823	}
13824	#endif /* LIBXML_XPTR_ENABLED */
13825
13826	/*
13827	* Extract the old set, and then evaluate the result of the
13828	* expression for all the element in the set. use it to grow
13829	* up a new set.
13830	*/
13831	CHECK_TYPE0(XPATH_NODESET);
13832	obj = valuePop(ctxt);
13833	oldset = obj->nodesetval;
13834
13835	oldnode = ctxt->context->node;
13836	oldDoc = ctxt->context->doc;
13837	ctxt->context->node = NULL;
13838
13839	if ((oldset == NULL) \|\| (oldset->nodeNr == 0)) {
13840	ctxt->context->contextSize = 0;
13841	ctxt->context->proximityPosition = 0;
13842	/*
13843	if (op->ch2 != -1)
13844	total +=
13845	xmlXPathCompOpEval(ctxt,
13846	&comp->steps[op->ch2]);
13847	CHECK_ERROR0;
13848	res = valuePop(ctxt);
13849	if (res != NULL)
13850	xmlXPathFreeObject(res);
13851	*/
13852	valuePush(ctxt, obj);
13853	ctxt->context->node = oldnode;
13854	CHECK_ERROR0;
13855	} else {
13856	tmp = NULL;
13857	/*
13858	* Initialize the new set.
13859	* Also set the xpath document in case things like
13860	* key() evaluation are attempted on the predicate
13861	*/
13862	newset = xmlXPathNodeSetCreate(NULL);
13863	/*
13864	* SPEC XPath 1.0:
13865	* "For each node in the node-set to be filtered, the
13866	* PredicateExpr is evaluated with that node as the
13867	* context node, with the number of nodes in the
13868	* node-set as the context size, and with the proximity
13869	* position of the node in the node-set with respect to
13870	* the axis as the context position;"
13871	* @oldset is the node-set" to be filtered.
13872	*
13873	* SPEC XPath 1.0:
13874	* "only predicates change the context position and
13875	* context size (see [2.4 Predicates])."
13876	* Example:
13877	* node-set context pos
13878	* nA 1
13879	* nB 2
13880	* nC 3
13881	* After applying predicate [position() > 1] :
13882	* node-set context pos
13883	* nB 1
13884	* nC 2
13885	*
13886	* removed the first node in the node-set, then
13887	* the context position of the
13888	*/
13889	for (i = 0; i < oldset->nodeNr; i++) {
13890	/*
13891	* Run the evaluation with a node list made of
13892	* a single item in the nodeset.
13893	*/
13894	ctxt->context->node = oldset->nodeTab[i];
13895	if ((oldset->nodeTab[i]->type != XML_NAMESPACE_DECL) &&
13896	(oldset->nodeTab[i]->doc != NULL))
13897	ctxt->context->doc = oldset->nodeTab[i]->doc;
13898	if (tmp == NULL) {
13899	tmp = xmlXPathCacheNewNodeSet(ctxt->context,
13900	ctxt->context->node);
13901	} else {
13902	if (xmlXPathNodeSetAddUnique(tmp->nodesetval,
13903	ctxt->context->node) < 0) {
13904	ctxt->error = XPATH_MEMORY_ERROR;
13905	}
13906	}
13907	valuePush(ctxt, tmp);
13908	ctxt->context->contextSize = oldset->nodeNr;
13909	ctxt->context->proximityPosition = i + 1;
13910	/*
13911	* Evaluate the predicate against the context node.
13912	* Can/should we optimize position() predicates
13913	* here (e.g. "[1]")?
13914	*/
13915	if (op->ch2 != -1)
13916	total +=
13917	xmlXPathCompOpEval(ctxt,
13918	&comp->steps[op->ch2]);
13919	if (ctxt->error != XPATH_EXPRESSION_OK) {
13920	xmlXPathFreeNodeSet(newset);
13921	xmlXPathFreeObject(obj);
13922	return(0);
13923	}
13924
13925	/*
13926	* The result of the evaluation needs to be tested to
13927	* decide whether the filter succeeded or not
13928	*/
13929	/*
13930	* OPTIMIZE TODO: Can we use
13931	* xmlXPathNodeSetAddUnique() instead?
13932	*/
13933	res = valuePop(ctxt);
13934	if (xmlXPathEvaluatePredicateResult(ctxt, res)) {
13935	if (xmlXPathNodeSetAdd(newset, oldset->nodeTab[i])
13936	< 0)
13937	ctxt->error = XPATH_MEMORY_ERROR;
13938	}
13939
13940	/*
13941	* Cleanup
13942	*/
13943	if (res != NULL) {
13944	xmlXPathReleaseObject(ctxt->context, res);
13945	}
13946	if (ctxt->value == tmp) {
13947	valuePop(ctxt);
13948	xmlXPathNodeSetClear(tmp->nodesetval, 1);
13949	/*
13950	* Don't free the temporary nodeset
13951	* in order to avoid massive recreation inside this
13952	* loop.
13953	*/
13954	} else
13955	tmp = NULL;
13956	ctxt->context->node = NULL;
13957	}
13958	if (tmp != NULL)
13959	xmlXPathReleaseObject(ctxt->context, tmp);
13960	/*
13961	* The result is used as the new evaluation set.
13962	*/
13963	xmlXPathReleaseObject(ctxt->context, obj);
13964	ctxt->context->node = NULL;
13965	ctxt->context->contextSize = -1;
13966	ctxt->context->proximityPosition = -1;
13967	/* may want to move this past the '}' later */
13968	ctxt->context->doc = oldDoc;
13969	valuePush(ctxt,
13970	xmlXPathCacheWrapNodeSet(ctxt->context, newset));
13971	}
13972	ctxt->context->node = oldnode;
13973	return (total);
13974	}
13975	case XPATH_OP_SORT:
13976	if (op->ch1 != -1)
13977	total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13978	CHECK_ERROR0;
13979	if ((ctxt->value != NULL) &&
13980	(ctxt->value->type == XPATH_NODESET) &&
13981	(ctxt->value->nodesetval != NULL) &&
13982	(ctxt->value->nodesetval->nodeNr > 1))
13983	{
13984	xmlXPathNodeSetSort(ctxt->value->nodesetval);
13985	}
13986	return (total);
13987	#ifdef LIBXML_XPTR_ENABLED
13988	case XPATH_OP_RANGETO:{
13989	xmlXPathObjectPtr range;
13990	xmlXPathObjectPtr res, obj;
13991	xmlXPathObjectPtr tmp;
13992	xmlLocationSetPtr newlocset = NULL;
13993	xmlLocationSetPtr oldlocset;
13994	xmlNodeSetPtr oldset;
13995	int i, j;
13996
13997	if (op->ch1 != -1)
13998	total +=
13999	xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
14000	if (op->ch2 == -1)
14001	return (total);
14002
14003	if (ctxt->value->type == XPATH_LOCATIONSET) {
14004	/*
14005	* Extract the old locset, and then evaluate the result of the
14006	* expression for all the element in the locset. use it to grow
14007	* up a new locset.
14008	*/
14009	CHECK_TYPE0(XPATH_LOCATIONSET);
14010	obj = valuePop(ctxt);
14011	oldlocset = obj->user;
14012
14013	if ((oldlocset == NULL) \|\| (oldlocset->locNr == 0)) {
14014	ctxt->context->node = NULL;
14015	ctxt->context->contextSize = 0;
14016	ctxt->context->proximityPosition = 0;
14017	total += xmlXPathCompOpEval(ctxt,&comp->steps[op->ch2]);
14018	res = valuePop(ctxt);
14019	if (res != NULL) {
14020	xmlXPathReleaseObject(ctxt->context, res);
14021	}
14022	valuePush(ctxt, obj);
14023	CHECK_ERROR0;
14024	return (total);
14025	}
14026	newlocset = xmlXPtrLocationSetCreate(NULL);
14027
14028	for (i = 0; i < oldlocset->locNr; i++) {
14029	/*
14030	* Run the evaluation with a node list made of a
14031	* single item in the nodelocset.
14032	*/
14033	ctxt->context->node = oldlocset->locTab[i]->user;
14034	ctxt->context->contextSize = oldlocset->locNr;
14035	ctxt->context->proximityPosition = i + 1;
14036	tmp = xmlXPathCacheNewNodeSet(ctxt->context,
14037	ctxt->context->node);
14038	valuePush(ctxt, tmp);
14039
14040	if (op->ch2 != -1)
14041	total +=
14042	xmlXPathCompOpEval(ctxt,
14043	&comp->steps[op->ch2]);
14044	if (ctxt->error != XPATH_EXPRESSION_OK) {
14045	xmlXPathFreeObject(obj);
14046	return(0);
14047	}
14048
14049	res = valuePop(ctxt);
14050	if (res->type == XPATH_LOCATIONSET) {
14051	xmlLocationSetPtr rloc =
14052	(xmlLocationSetPtr)res->user;
14053	for (j=0; j<rloc->locNr; j++) {
14054	range = xmlXPtrNewRange(
14055	oldlocset->locTab[i]->user,
14056	oldlocset->locTab[i]->index,
14057	rloc->locTab[j]->user2,
14058	rloc->locTab[j]->index2);
14059	if (range != NULL) {
14060	xmlXPtrLocationSetAdd(newlocset, range);
14061	}
14062	}
14063	} else {
14064	range = xmlXPtrNewRangeNodeObject(
14065	(xmlNodePtr)oldlocset->locTab[i]->user, res);
14066	if (range != NULL) {
14067	xmlXPtrLocationSetAdd(newlocset,range);
14068	}
14069	}
14070
14071	/*
14072	* Cleanup
14073	*/
14074	if (res != NULL) {
14075	xmlXPathReleaseObject(ctxt->context, res);
14076	}
14077	if (ctxt->value == tmp) {
14078	res = valuePop(ctxt);
14079	xmlXPathReleaseObject(ctxt->context, res);
14080	}
14081
14082	ctxt->context->node = NULL;
14083	}
14084	} else { /* Not a location set */
14085	CHECK_TYPE0(XPATH_NODESET);
14086	obj = valuePop(ctxt);
14087	oldset = obj->nodesetval;
14088	ctxt->context->node = NULL;
14089
14090	newlocset = xmlXPtrLocationSetCreate(NULL);
14091
14092	if (oldset != NULL) {
14093	for (i = 0; i < oldset->nodeNr; i++) {
14094	/*
14095	* Run the evaluation with a node list made of a single item
14096	* in the nodeset.
14097	*/
14098	ctxt->context->node = oldset->nodeTab[i];
14099	/*
14100	* OPTIMIZE TODO: Avoid recreation for every iteration.
14101	*/
14102	tmp = xmlXPathCacheNewNodeSet(ctxt->context,
14103	ctxt->context->node);
14104	valuePush(ctxt, tmp);
14105
14106	if (op->ch2 != -1)
14107	total +=
14108	xmlXPathCompOpEval(ctxt,
14109	&comp->steps[op->ch2]);
14110	if (ctxt->error != XPATH_EXPRESSION_OK) {
14111	xmlXPathFreeObject(obj);
14112	return(0);
14113	}
14114
14115	res = valuePop(ctxt);
14116	range =
14117	xmlXPtrNewRangeNodeObject(oldset->nodeTab[i],
14118	res);
14119	if (range != NULL) {
14120	xmlXPtrLocationSetAdd(newlocset, range);
14121	}
14122
14123	/*
14124	* Cleanup
14125	*/
14126	if (res != NULL) {
14127	xmlXPathReleaseObject(ctxt->context, res);
14128	}
14129	if (ctxt->value == tmp) {
14130	res = valuePop(ctxt);
14131	xmlXPathReleaseObject(ctxt->context, res);
14132	}
14133
14134	ctxt->context->node = NULL;
14135	}
14136	}
14137	}
14138
14139	/*
14140	* The result is used as the new evaluation set.
14141	*/
14142	xmlXPathReleaseObject(ctxt->context, obj);
14143	ctxt->context->node = NULL;
14144	ctxt->context->contextSize = -1;
14145	ctxt->context->proximityPosition = -1;
14146	valuePush(ctxt, xmlXPtrWrapLocationSet(newlocset));
14147	return (total);
14148	}
14149	#endif /* LIBXML_XPTR_ENABLED */
14150	}
14151	xmlGenericError(xmlGenericErrorContext,
14152	"XPath: unknown precompiled operation %d\n", op->op);
14153	ctxt->error = XPATH_INVALID_OPERAND;
14154	return (total);
14155	}
14156
14157	/**
14158	* xmlXPathCompOpEvalToBoolean:
14159	* @ctxt: the XPath parser context
14160	*
14161	* Evaluates if the expression evaluates to true.
14162	*
14163	* Returns 1 if true, 0 if false and -1 on API or internal errors.
14164	*/
14165	static int
14166	xmlXPathCompOpEvalToBoolean(xmlXPathParserContextPtr ctxt,
14167	xmlXPathStepOpPtr op,
14168	int isPredicate)
14169	{
14170	xmlXPathObjectPtr resObj = NULL;
14171
14172	start:
14173	/* comp = ctxt->comp; */
14174	switch (op->op) {
14175	case XPATH_OP_END:
14176	return (0);
14177	case XPATH_OP_VALUE:
14178	resObj = (xmlXPathObjectPtr) op->value4;
14179	if (isPredicate)
14180	return(xmlXPathEvaluatePredicateResult(ctxt, resObj));
14181	return(xmlXPathCastToBoolean(resObj));
14182	case XPATH_OP_SORT:
14183	/*
14184	* We don't need sorting for boolean results. Skip this one.
14185	*/
14186	if (op->ch1 != -1) {
14187	op = &ctxt->comp->steps[op->ch1];
14188	goto start;
14189	}
14190	return(0);
14191	case XPATH_OP_COLLECT:
14192	if (op->ch1 == -1)
14193	return(0);
14194
14195	xmlXPathCompOpEval(ctxt, &ctxt->comp->steps[op->ch1]);
14196	if (ctxt->error != XPATH_EXPRESSION_OK)
14197	return(-1);
14198
14199	xmlXPathNodeCollectAndTest(ctxt, op, NULL, NULL, 1);
14200	if (ctxt->error != XPATH_EXPRESSION_OK)
14201	return(-1);
14202
14203	resObj = valuePop(ctxt);
14204	if (resObj == NULL)
14205	return(-1);
14206	break;
14207	default:
14208	/*
14209	* Fallback to call xmlXPathCompOpEval().
14210	*/
14211	xmlXPathCompOpEval(ctxt, op);
14212	if (ctxt->error != XPATH_EXPRESSION_OK)
14213	return(-1);
14214
14215	resObj = valuePop(ctxt);
14216	if (resObj == NULL)
14217	return(-1);
14218	break;
14219	}
14220
14221	if (resObj) {
14222	int res;
14223
14224	if (resObj->type == XPATH_BOOLEAN) {
14225	res = resObj->boolval;
14226	} else if (isPredicate) {
14227	/*
14228	* For predicates a result of type "number" is handled
14229	* differently:
14230	* SPEC XPath 1.0:
14231	* "If the result is a number, the result will be converted
14232	* to true if the number is equal to the context position
14233	* and will be converted to false otherwise;"
14234	*/
14235	res = xmlXPathEvaluatePredicateResult(ctxt, resObj);
14236	} else {
14237	res = xmlXPathCastToBoolean(resObj);
14238	}
14239	xmlXPathReleaseObject(ctxt->context, resObj);
14240	return(res);
14241	}
14242
14243	return(0);
14244	}
14245
14246	#ifdef XPATH_STREAMING
14247	/**
14248	* xmlXPathRunStreamEval:
14249	* @ctxt: the XPath parser context with the compiled expression
14250	*
14251	* Evaluate the Precompiled Streamable XPath expression in the given context.
14252	*/
14253	static int
14254	xmlXPathRunStreamEval(xmlXPathContextPtr ctxt, xmlPatternPtr comp,
14255	xmlXPathObjectPtr *resultSeq, int toBool)
14256	{
14257	int max_depth, min_depth;
14258	int from_root;
14259	int ret, depth;
14260	int eval_all_nodes;
14261	xmlNodePtr cur = NULL, limit = NULL;
14262	xmlStreamCtxtPtr patstream = NULL;
14263
14264	int nb_nodes = 0;
14265
14266	if ((ctxt == NULL) \|\| (comp == NULL))
14267	return(-1);
14268	max_depth = xmlPatternMaxDepth(comp);
14269	if (max_depth == -1)
14270	return(-1);
14271	if (max_depth == -2)
14272	max_depth = 10000;
14273	min_depth = xmlPatternMinDepth(comp);
14274	if (min_depth == -1)
14275	return(-1);
14276	from_root = xmlPatternFromRoot(comp);
14277	if (from_root < 0)
14278	return(-1);
14279	#if 0
14280	printf("stream eval: depth %d from root %d\n", max_depth, from_root);
14281	#endif
14282
14283	if (! toBool) {
14284	if (resultSeq == NULL)
14285	return(-1);
14286	*resultSeq = xmlXPathCacheNewNodeSet(ctxt, NULL);
14287	if (*resultSeq == NULL)
14288	return(-1);
14289	}
14290
14291	/*
14292	* handle the special cases of "/" amd "." being matched
14293	*/
14294	if (min_depth == 0) {
14295	if (from_root) {
14296	/* Select "/" */
14297	if (toBool)
14298	return(1);
14299	xmlXPathNodeSetAddUnique((*resultSeq)->nodesetval,
14300	(xmlNodePtr) ctxt->doc);
14301	} else {
14302	/* Select "self::node()" */
14303	if (toBool)
14304	return(1);
14305	xmlXPathNodeSetAddUnique((*resultSeq)->nodesetval, ctxt->node);
14306	}
14307	}
14308	if (max_depth == 0) {
14309	return(0);
14310	}
14311
14312	if (from_root) {
14313	cur = (xmlNodePtr)ctxt->doc;
14314	} else if (ctxt->node != NULL) {
14315	switch (ctxt->node->type) {
14316	case XML_ELEMENT_NODE:
14317	case XML_DOCUMENT_NODE:
14318	case XML_DOCUMENT_FRAG_NODE:
14319	case XML_HTML_DOCUMENT_NODE:
14320	#ifdef LIBXML_DOCB_ENABLED
14321	case XML_DOCB_DOCUMENT_NODE:
14322	#endif
14323	cur = ctxt->node;
14324	break;
14325	case XML_ATTRIBUTE_NODE:
14326	case XML_TEXT_NODE:
14327	case XML_CDATA_SECTION_NODE:
14328	case XML_ENTITY_REF_NODE:
14329	case XML_ENTITY_NODE:
14330	case XML_PI_NODE:
14331	case XML_COMMENT_NODE:
14332	case XML_NOTATION_NODE:
14333	case XML_DTD_NODE:
14334	case XML_DOCUMENT_TYPE_NODE:
14335	case XML_ELEMENT_DECL:
14336	case XML_ATTRIBUTE_DECL:
14337	case XML_ENTITY_DECL:
14338	case XML_NAMESPACE_DECL:
14339	case XML_XINCLUDE_START:
14340	case XML_XINCLUDE_END:
14341	break;
14342	}
14343	limit = cur;
14344	}
14345	if (cur == NULL) {
14346	return(0);
14347	}
14348
14349	patstream = xmlPatternGetStreamCtxt(comp);
14350	if (patstream == NULL) {
14351	/*
14352	* QUESTION TODO: Is this an error?
14353	*/
14354	return(0);
14355	}
14356
14357	eval_all_nodes = xmlStreamWantsAnyNode(patstream);
14358
14359	if (from_root) {
14360	ret = xmlStreamPush(patstream, NULL, NULL);
14361	if (ret < 0) {
14362	} else if (ret == 1) {
14363	if (toBool)
14364	goto return_1;
14365	xmlXPathNodeSetAddUnique((*resultSeq)->nodesetval, cur);
14366	}
14367	}
14368	depth = 0;
14369	goto scan_children;
14370	next_node:
14371	do {
14372	nb_nodes++;
14373
14374	switch (cur->type) {
14375	case XML_ELEMENT_NODE:
14376	case XML_TEXT_NODE:
14377	case XML_CDATA_SECTION_NODE:
14378	case XML_COMMENT_NODE:
14379	case XML_PI_NODE:
14380	if (cur->type == XML_ELEMENT_NODE) {
14381	ret = xmlStreamPush(patstream, cur->name,
14382	(cur->ns ? cur->ns->href : NULL));
14383	} else if (eval_all_nodes)
14384	ret = xmlStreamPushNode(patstream, NULL, NULL, cur->type);
14385	else
14386	break;
14387
14388	if (ret < 0) {
14389	/* NOP. */
14390	} else if (ret == 1) {
14391	if (toBool)
14392	goto return_1;
14393	if (xmlXPathNodeSetAddUnique((*resultSeq)->nodesetval, cur)
14394	< 0) {
14395	ctxt->lastError.domain = XML_FROM_XPATH;
14396	ctxt->lastError.code = XML_ERR_NO_MEMORY;
14397	}
14398	}
14399	if ((cur->children == NULL) \|\| (depth >= max_depth)) {
14400	ret = xmlStreamPop(patstream);
14401	while (cur->next != NULL) {
14402	cur = cur->next;
14403	if ((cur->type != XML_ENTITY_DECL) &&
14404	(cur->type != XML_DTD_NODE))
14405	goto next_node;
14406	}
14407	}
14408	default:
14409	break;
14410	}
14411
14412	scan_children:
14413	if (cur->type == XML_NAMESPACE_DECL) break;
14414	if ((cur->children != NULL) && (depth < max_depth)) {
14415	/*
14416	* Do not descend on entities declarations
14417	*/
14418	if (cur->children->type != XML_ENTITY_DECL) {
14419	cur = cur->children;
14420	depth++;
14421	/*
14422	* Skip DTDs
14423	*/
14424	if (cur->type != XML_DTD_NODE)
14425	continue;
14426	}
14427	}
14428
14429	if (cur == limit)
14430	break;
14431
14432	while (cur->next != NULL) {
14433	cur = cur->next;
14434	if ((cur->type != XML_ENTITY_DECL) &&
14435	(cur->type != XML_DTD_NODE))
14436	goto next_node;
14437	}
14438
14439	do {
14440	cur = cur->parent;
14441	depth--;
14442	if ((cur == NULL) \|\| (cur == limit))
14443	goto done;
14444	if (cur->type == XML_ELEMENT_NODE) {
14445	ret = xmlStreamPop(patstream);
14446	} else if ((eval_all_nodes) &&
14447	((cur->type == XML_TEXT_NODE) \|\|
14448	(cur->type == XML_CDATA_SECTION_NODE) \|\|
14449	(cur->type == XML_COMMENT_NODE) \|\|
14450	(cur->type == XML_PI_NODE)))
14451	{
14452	ret = xmlStreamPop(patstream);
14453	}
14454	if (cur->next != NULL) {
14455	cur = cur->next;
14456	break;
14457	}
14458	} while (cur != NULL);
14459
14460	} while ((cur != NULL) && (depth >= 0));
14461
14462	done:
14463
14464	#if 0
14465	printf("stream eval: checked %d nodes selected %d\n",
14466	nb_nodes, retObj->nodesetval->nodeNr);
14467	#endif
14468
14469	if (patstream)
14470	xmlFreeStreamCtxt(patstream);
14471	return(0);
14472
14473	return_1:
14474	if (patstream)
14475	xmlFreeStreamCtxt(patstream);
14476	return(1);
14477	}
14478	#endif /* XPATH_STREAMING */
14479
14480	/**
14481	* xmlXPathRunEval:
14482	* @ctxt: the XPath parser context with the compiled expression
14483	* @toBool: evaluate to a boolean result
14484	*
14485	* Evaluate the Precompiled XPath expression in the given context.
14486	*/
14487	static int
14488	xmlXPathRunEval(xmlXPathParserContextPtr ctxt, int toBool)
14489	{
14490	xmlXPathCompExprPtr comp;
14491
14492	if ((ctxt == NULL) \|\| (ctxt->comp == NULL))
14493	return(-1);
14494
14495	if (ctxt->valueTab == NULL) {
14496	/* Allocate the value stack */
14497	ctxt->valueTab = (xmlXPathObjectPtr *)
14498	xmlMalloc(10 * sizeof(xmlXPathObjectPtr));
14499	if (ctxt->valueTab == NULL) {
14500	xmlXPathPErrMemory(ctxt, "creating evaluation context\n");
14501	xmlFree(ctxt);
14502	}
14503	ctxt->valueNr = 0;
14504	ctxt->valueMax = 10;
14505	ctxt->value = NULL;
14506	ctxt->valueFrame = 0;
14507	}
14508	#ifdef XPATH_STREAMING
14509	if (ctxt->comp->stream) {
14510	int res;
14511
14512	if (toBool) {
14513	/*
14514	* Evaluation to boolean result.
14515	*/
14516	res = xmlXPathRunStreamEval(ctxt->context,
14517	ctxt->comp->stream, NULL, 1);
14518	if (res != -1)
14519	return(res);
14520	} else {
14521	xmlXPathObjectPtr resObj = NULL;
14522
14523	/*
14524	* Evaluation to a sequence.
14525	*/
14526	res = xmlXPathRunStreamEval(ctxt->context,
14527	ctxt->comp->stream, &resObj, 0);
14528
14529	if ((res != -1) && (resObj != NULL)) {
14530	valuePush(ctxt, resObj);
14531	return(0);
14532	}
14533	if (resObj != NULL)
14534	xmlXPathReleaseObject(ctxt->context, resObj);
14535	}
14536	/*
14537	* QUESTION TODO: This falls back to normal XPath evaluation
14538	* if res == -1. Is this intended?
14539	*/
14540	}
14541	#endif
14542	comp = ctxt->comp;
14543	if (comp->last < 0) {
14544	xmlGenericError(xmlGenericErrorContext,
14545	"xmlXPathRunEval: last is less than zero\n");
14546	return(-1);
14547	}
14548	if (toBool)
14549	return(xmlXPathCompOpEvalToBoolean(ctxt,
14550	&comp->steps[comp->last], 0));
14551	else
14552	xmlXPathCompOpEval(ctxt, &comp->steps[comp->last]);
14553
14554	return(0);
14555	}
14556
14557	/************************************************************************
14558	* *
14559	* Public interfaces *
14560	* *
14561	************************************************************************/
14562
14563	/**
14564	* xmlXPathEvalPredicate:
14565	* @ctxt: the XPath context
14566	* @res: the Predicate Expression evaluation result
14567	*
14568	* Evaluate a predicate result for the current node.
14569	* A PredicateExpr is evaluated by evaluating the Expr and converting
14570	* the result to a boolean. If the result is a number, the result will
14571	* be converted to true if the number is equal to the position of the
14572	* context node in the context node list (as returned by the position
14573	* function) and will be converted to false otherwise; if the result
14574	* is not a number, then the result will be converted as if by a call
14575	* to the boolean function.
14576	*
14577	* Returns 1 if predicate is true, 0 otherwise
14578	*/
14579	int
14580	xmlXPathEvalPredicate(xmlXPathContextPtr ctxt, xmlXPathObjectPtr res) {
14581	if ((ctxt == NULL) \|\| (res == NULL)) return(0);
14582	switch (res->type) {
14583	case XPATH_BOOLEAN:
14584	return(res->boolval);
14585	case XPATH_NUMBER:
14586	return(res->floatval == ctxt->proximityPosition);
14587	case XPATH_NODESET:
14588	case XPATH_XSLT_TREE:
14589	if (res->nodesetval == NULL)
14590	return(0);
14591	return(res->nodesetval->nodeNr != 0);
14592	case XPATH_STRING:
14593	return((res->stringval != NULL) &&
14594	(xmlStrlen(res->stringval) != 0));
14595	default:
14596	STRANGE
14597	}
14598	return(0);
14599	}
14600
14601	/**
14602	* xmlXPathEvaluatePredicateResult:
14603	* @ctxt: the XPath Parser context
14604	* @res: the Predicate Expression evaluation result
14605	*
14606	* Evaluate a predicate result for the current node.
14607	* A PredicateExpr is evaluated by evaluating the Expr and converting
14608	* the result to a boolean. If the result is a number, the result will
14609	* be converted to true if the number is equal to the position of the
14610	* context node in the context node list (as returned by the position
14611	* function) and will be converted to false otherwise; if the result
14612	* is not a number, then the result will be converted as if by a call
14613	* to the boolean function.
14614	*
14615	* Returns 1 if predicate is true, 0 otherwise
14616	*/
14617	int
14618	xmlXPathEvaluatePredicateResult(xmlXPathParserContextPtr ctxt,
14619	xmlXPathObjectPtr res) {
14620	if ((ctxt == NULL) \|\| (res == NULL)) return(0);
14621	switch (res->type) {
14622	case XPATH_BOOLEAN:
14623	return(res->boolval);
14624	case XPATH_NUMBER:
14625	#if defined(__BORLANDC__) \|\| (defined(_MSC_VER) && (_MSC_VER == 1200))
14626	return((res->floatval == ctxt->context->proximityPosition) &&
14627	(!xmlXPathIsNaN(res->floatval))); /* MSC pbm Mark Vakoc !*/
14628	#else
14629	return(res->floatval == ctxt->context->proximityPosition);
14630	#endif
14631	case XPATH_NODESET:
14632	case XPATH_XSLT_TREE:
14633	if (res->nodesetval == NULL)
14634	return(0);
14635	return(res->nodesetval->nodeNr != 0);
14636	case XPATH_STRING:
14637	return((res->stringval != NULL) && (res->stringval[0] != 0));
14638	#ifdef LIBXML_XPTR_ENABLED
14639	case XPATH_LOCATIONSET:{
14640	xmlLocationSetPtr ptr = res->user;
14641	if (ptr == NULL)
14642	return(0);
14643	return (ptr->locNr != 0);
14644	}
14645	#endif
14646	default:
14647	STRANGE
14648	}
14649	return(0);
14650	}
14651
14652	#ifdef XPATH_STREAMING
14653	/**
14654	* xmlXPathTryStreamCompile:
14655	* @ctxt: an XPath context
14656	* @str: the XPath expression
14657	*
14658	* Try to compile the XPath expression as a streamable subset.
14659	*
14660	* Returns the compiled expression or NULL if failed to compile.
14661	*/
14662	static xmlXPathCompExprPtr
14663	xmlXPathTryStreamCompile(xmlXPathContextPtr ctxt, const xmlChar *str) {
14664	/*
14665	* Optimization: use streaming patterns when the XPath expression can
14666	* be compiled to a stream lookup
14667	*/
14668	xmlPatternPtr stream;
14669	xmlXPathCompExprPtr comp;
14670	xmlDictPtr dict = NULL;
14671	const xmlChar **namespaces = NULL;
14672	xmlNsPtr ns;
14673	int i, j;
14674
14675	if ((!xmlStrchr(str, '[')) && (!xmlStrchr(str, '(')) &&
14676	(!xmlStrchr(str, '@'))) {
14677	const xmlChar *tmp;
14678
14679	/*
14680	* We don't try to handle expressions using the verbose axis
14681	* specifiers ("::"), just the simplied form at this point.
14682	* Additionally, if there is no list of namespaces available and
14683	* there's a ":" in the expression, indicating a prefixed QName,
14684	* then we won't try to compile either. xmlPatterncompile() needs
14685	* to have a list of namespaces at compilation time in order to
14686	* compile prefixed name tests.
14687	*/
14688	tmp = xmlStrchr(str, ':');
14689	if ((tmp != NULL) &&
14690	((ctxt == NULL) \|\| (ctxt->nsNr == 0) \|\| (tmp[1] == ':')))
14691	return(NULL);
14692
14693	if (ctxt != NULL) {
14694	dict = ctxt->dict;
14695	if (ctxt->nsNr > 0) {
14696	namespaces = xmlMalloc(2 * (ctxt->nsNr + 1) * sizeof(xmlChar*));
14697	if (namespaces == NULL) {
14698	xmlXPathErrMemory(ctxt, "allocating namespaces array\n");
14699	return(NULL);
14700	}
14701	for (i = 0, j = 0; (j < ctxt->nsNr); j++) {
14702	ns = ctxt->namespaces[j];
14703	namespaces[i++] = ns->href;
14704	namespaces[i++] = ns->prefix;
14705	}
14706	namespaces[i++] = NULL;
14707	namespaces[i] = NULL;
14708	}
14709	}
14710
14711	stream = xmlPatterncompile(str, dict, XML_PATTERN_XPATH,
14712	&namespaces[0]);
14713	if (namespaces != NULL) {
14714	xmlFree((xmlChar **)namespaces);
14715	}
14716	if ((stream != NULL) && (xmlPatternStreamable(stream) == 1)) {
14717	comp = xmlXPathNewCompExpr();
14718	if (comp == NULL) {
14719	xmlXPathErrMemory(ctxt, "allocating streamable expression\n");
14720	return(NULL);
14721	}
14722	comp->stream = stream;
14723	comp->dict = dict;
14724	if (comp->dict)
14725	xmlDictReference(comp->dict);
14726	return(comp);
14727	}
14728	xmlFreePattern(stream);
14729	}
14730	return(NULL);
14731	}
14732	#endif /* XPATH_STREAMING */
14733
14734	static void
14735	xmlXPathOptimizeExpression(xmlXPathCompExprPtr comp, xmlXPathStepOpPtr op)
14736	{
14737	/*
14738	* Try to rewrite "descendant-or-self::node()/foo" to an optimized
14739	* internal representation.
14740	*/
14741
14742	if ((op->op == XPATH_OP_COLLECT /* 11 */) &&
14743	(op->ch1 != -1) &&
14744	(op->ch2 == -1 /* no predicate */))
14745	{
14746	xmlXPathStepOpPtr prevop = &comp->steps[op->ch1];
14747
14748	if ((prevop->op == XPATH_OP_COLLECT /* 11 */) &&
14749	((xmlXPathAxisVal) prevop->value ==
14750	AXIS_DESCENDANT_OR_SELF) &&
14751	(prevop->ch2 == -1) &&
14752	((xmlXPathTestVal) prevop->value2 == NODE_TEST_TYPE) &&
14753	((xmlXPathTypeVal) prevop->value3 == NODE_TYPE_NODE))
14754	{
14755	/*
14756	* This is a "descendant-or-self::node()" without predicates.
14757	* Try to eliminate it.
14758	*/
14759
14760	switch ((xmlXPathAxisVal) op->value) {
14761	case AXIS_CHILD:
14762	case AXIS_DESCENDANT:
14763	/*
14764	* Convert "descendant-or-self::node()/child::" or
14765	* "descendant-or-self::node()/descendant::" to
14766	* "descendant::"
14767	*/
14768	op->ch1 = prevop->ch1;
14769	op->value = AXIS_DESCENDANT;
14770	break;
14771	case AXIS_SELF:
14772	case AXIS_DESCENDANT_OR_SELF:
14773	/*
14774	* Convert "descendant-or-self::node()/self::" or
14775	* "descendant-or-self::node()/descendant-or-self::" to
14776	* to "descendant-or-self::"
14777	*/
14778	op->ch1 = prevop->ch1;
14779	op->value = AXIS_DESCENDANT_OR_SELF;
14780	break;
14781	default:
14782	break;
14783	}
14784	}
14785	}
14786
14787	/* Recurse */
14788	if (op->ch1 != -1)
14789	xmlXPathOptimizeExpression(comp, &comp->steps[op->ch1]);
14790	if (op->ch2 != -1)
14791	xmlXPathOptimizeExpression(comp, &comp->steps[op->ch2]);
14792	}
14793
14794	/**
14795	* xmlXPathCtxtCompile:
14796	* @ctxt: an XPath context
14797	* @str: the XPath expression
14798	*
14799	* Compile an XPath expression
14800	*
14801	* Returns the xmlXPathCompExprPtr resulting from the compilation or NULL.
14802	* the caller has to free the object.
14803	*/
14804	xmlXPathCompExprPtr
14805	xmlXPathCtxtCompile(xmlXPathContextPtr ctxt, const xmlChar *str) {
14806	xmlXPathParserContextPtr pctxt;
14807	xmlXPathCompExprPtr comp;
14808
14809	#ifdef XPATH_STREAMING
14810	comp = xmlXPathTryStreamCompile(ctxt, str);
14811	if (comp != NULL)
14812	return(comp);
14813	#endif
14814
14815	xmlXPathInit();
14816
14817	pctxt = xmlXPathNewParserContext(str, ctxt);
14818	if (pctxt == NULL)
14819	return NULL;
14820	xmlXPathCompileExpr(pctxt, 1);
14821
14822	if( pctxt->error != XPATH_EXPRESSION_OK )
14823	{
14824	xmlXPathFreeParserContext(pctxt);
14825	return(NULL);
14826	}
14827
14828	if (*pctxt->cur != 0) {
14829	/*
14830	* aleksey: in some cases this line prints second error message
14831	* (see bug #78858) and probably this should be fixed.
14832	* However, we are not sure that all error messages are printed
14833	* out in other places. It's not critical so we leave it as-is for now
14834	*/
14835	xmlXPatherror(pctxt, __FILE__, __LINE__, XPATH_EXPR_ERROR);
14836	comp = NULL;
14837	} else {
14838	comp = pctxt->comp;
14839	pctxt->comp = NULL;
14840	}
14841	xmlXPathFreeParserContext(pctxt);
14842
14843	if (comp != NULL) {
14844	comp->expr = xmlStrdup(str);
14845	#ifdef DEBUG_EVAL_COUNTS
14846	comp->string = xmlStrdup(str);
14847	comp->nb = 0;
14848	#endif
14849	if ((comp->nbStep > 1) && (comp->last >= 0)) {
14850	xmlXPathOptimizeExpression(comp, &comp->steps[comp->last]);
14851	}
14852	}
14853	return(comp);
14854	}
14855
14856	/**
14857	* xmlXPathCompile:
14858	* @str: the XPath expression
14859	*
14860	* Compile an XPath expression
14861	*
14862	* Returns the xmlXPathCompExprPtr resulting from the compilation or NULL.
14863	* the caller has to free the object.
14864	*/
14865	xmlXPathCompExprPtr
14866	xmlXPathCompile(const xmlChar *str) {
14867	return(xmlXPathCtxtCompile(NULL, str));
14868	}
14869
14870	/**
14871	* xmlXPathCompiledEvalInternal:
14872	* @comp: the compiled XPath expression
14873	* @ctxt: the XPath context
14874	* @resObj: the resulting XPath object or NULL
14875	* @toBool: 1 if only a boolean result is requested
14876	*
14877	* Evaluate the Precompiled XPath expression in the given context.
14878	* The caller has to free @resObj.
14879	*
14880	* Returns the xmlXPathObjectPtr resulting from the evaluation or NULL.
14881	* the caller has to free the object.
14882	*/
14883	static int
14884	xmlXPathCompiledEvalInternal(xmlXPathCompExprPtr comp,
14885	xmlXPathContextPtr ctxt,
14886	xmlXPathObjectPtr *resObj,
14887	int toBool)
14888	{
14889	xmlXPathParserContextPtr pctxt;
14890	#ifndef LIBXML_THREAD_ENABLED
14891	static int reentance = 0;
14892	#endif
14893	int res;
14894
14895	CHECK_CTXT_NEG(ctxt)
14896
14897	if (comp == NULL)
14898	return(-1);
14899	xmlXPathInit();
14900
14901	#ifndef LIBXML_THREAD_ENABLED
14902	reentance++;
14903	if (reentance > 1)
14904	xmlXPathDisableOptimizer = 1;
14905	#endif
14906
14907	#ifdef DEBUG_EVAL_COUNTS
14908	comp->nb++;
14909	if ((comp->string != NULL) && (comp->nb > 100)) {
14910	fprintf(stderr, "100 x %s\n", comp->string);
14911	comp->nb = 0;
14912	}
14913	#endif
14914	pctxt = xmlXPathCompParserContext(comp, ctxt);
14915	res = xmlXPathRunEval(pctxt, toBool);
14916
14917	if (resObj) {
14918	if (pctxt->value == NULL) {
14919	xmlGenericError(xmlGenericErrorContext,
14920	"xmlXPathCompiledEval: evaluation failed\n");
14921	*resObj = NULL;
14922	} else {
14923	*resObj = valuePop(pctxt);
14924	}
14925	}
14926
14927	/*
14928	* Pop all remaining objects from the stack.
14929	*/
14930	if (pctxt->valueNr > 0) {
14931	xmlXPathObjectPtr tmp;
14932	int stack = 0;
14933
14934	do {
14935	tmp = valuePop(pctxt);
14936	if (tmp != NULL) {
14937	stack++;
14938	xmlXPathReleaseObject(ctxt, tmp);
14939	}
14940	} while (tmp != NULL);
14941	if ((stack != 0) &&
14942	((toBool) \|\| ((resObj) && (*resObj))))
14943	{
14944	xmlGenericError(xmlGenericErrorContext,
14945	"xmlXPathCompiledEval: %d objects left on the stack.\n",
14946	stack);
14947	}
14948	}
14949
14950	if ((pctxt->error != XPATH_EXPRESSION_OK) && (resObj) && (*resObj)) {
14951	xmlXPathFreeObject(*resObj);
14952	*resObj = NULL;
14953	}
14954	pctxt->comp = NULL;
14955	xmlXPathFreeParserContext(pctxt);
14956	#ifndef LIBXML_THREAD_ENABLED
14957	reentance--;
14958	#endif
14959
14960	return(res);
14961	}
14962
14963	/**
14964	* xmlXPathCompiledEval:
14965	* @comp: the compiled XPath expression
14966	* @ctx: the XPath context
14967	*
14968	* Evaluate the Precompiled XPath expression in the given context.
14969	*
14970	* Returns the xmlXPathObjectPtr resulting from the evaluation or NULL.
14971	* the caller has to free the object.
14972	*/
14973	xmlXPathObjectPtr
14974	xmlXPathCompiledEval(xmlXPathCompExprPtr comp, xmlXPathContextPtr ctx)
14975	{
14976	xmlXPathObjectPtr res = NULL;
14977
14978	xmlXPathCompiledEvalInternal(comp, ctx, &res, 0);
14979	return(res);
14980	}
14981
14982	/**
14983	* xmlXPathCompiledEvalToBoolean:
14984	* @comp: the compiled XPath expression
14985	* @ctxt: the XPath context
14986	*
14987	* Applies the XPath boolean() function on the result of the given
14988	* compiled expression.
14989	*
14990	* Returns 1 if the expression evaluated to true, 0 if to false and
14991	* -1 in API and internal errors.
14992	*/
14993	int
14994	xmlXPathCompiledEvalToBoolean(xmlXPathCompExprPtr comp,
14995	xmlXPathContextPtr ctxt)
14996	{
14997	return(xmlXPathCompiledEvalInternal(comp, ctxt, NULL, 1));
14998	}
14999
15000	/**
15001	* xmlXPathEvalExpr:
15002	* @ctxt: the XPath Parser context
15003	*
15004	* Parse and evaluate an XPath expression in the given context,
15005	* then push the result on the context stack
15006	*/
15007	void
15008	xmlXPathEvalExpr(xmlXPathParserContextPtr ctxt) {
15009	#ifdef XPATH_STREAMING
15010	xmlXPathCompExprPtr comp;
15011	#endif
15012
15013	if (ctxt == NULL) return;
15014
15015	#ifdef XPATH_STREAMING
15016	comp = xmlXPathTryStreamCompile(ctxt->context, ctxt->base);
15017	if (comp != NULL) {
15018	if (ctxt->comp != NULL)
15019	xmlXPathFreeCompExpr(ctxt->comp);
15020	ctxt->comp = comp;
15021	if (ctxt->cur != NULL)
15022	while (*ctxt->cur != 0) ctxt->cur++;
15023	} else
15024	#endif
15025	{
15026	xmlXPathCompileExpr(ctxt, 1);
15027	if ((ctxt->error == XPATH_EXPRESSION_OK) &&
15028	(ctxt->comp != NULL) &&
15029	(ctxt->comp->nbStep > 1) &&
15030	(ctxt->comp->last >= 0))
15031	{
15032	xmlXPathOptimizeExpression(ctxt->comp,
15033	&ctxt->comp->steps[ctxt->comp->last]);
15034	}
15035	}
15036	CHECK_ERROR;
15037	xmlXPathRunEval(ctxt, 0);
15038	}
15039
15040	/**
15041	* xmlXPathEval:
15042	* @str: the XPath expression
15043	* @ctx: the XPath context
15044	*
15045	* Evaluate the XPath Location Path in the given context.
15046	*
15047	* Returns the xmlXPathObjectPtr resulting from the evaluation or NULL.
15048	* the caller has to free the object.
15049	*/
15050	xmlXPathObjectPtr
15051	xmlXPathEval(const xmlChar *str, xmlXPathContextPtr ctx) {
15052	xmlXPathParserContextPtr ctxt;
15053	xmlXPathObjectPtr res, tmp, init = NULL;
15054	int stack = 0;
15055
15056	CHECK_CTXT(ctx)
15057
15058	xmlXPathInit();
15059
15060	ctxt = xmlXPathNewParserContext(str, ctx);
15061	if (ctxt == NULL)
15062	return NULL;
15063	xmlXPathEvalExpr(ctxt);
15064
15065	if (ctxt->value == NULL) {
15066	xmlGenericError(xmlGenericErrorContext,
15067	"xmlXPathEval: evaluation failed\n");
15068	res = NULL;
15069	} else if ((*ctxt->cur != 0) && (ctxt->comp != NULL)
15070	#ifdef XPATH_STREAMING
15071	&& (ctxt->comp->stream == NULL)
15072	#endif
15073	) {
15074	xmlXPatherror(ctxt, __FILE__, __LINE__, XPATH_EXPR_ERROR);
15075	res = NULL;
15076	} else {
15077	res = valuePop(ctxt);
15078	}
15079
15080	do {
15081	tmp = valuePop(ctxt);
15082	if (tmp != NULL) {
15083	if (tmp != init)
15084	stack++;
15085	xmlXPathReleaseObject(ctx, tmp);
15086	}
15087	} while (tmp != NULL);
15088	if ((stack != 0) && (res != NULL)) {
15089	xmlGenericError(xmlGenericErrorContext,
15090	"xmlXPathEval: %d object left on the stack\n",
15091	stack);
15092	}
15093	if (ctxt->error != XPATH_EXPRESSION_OK) {
15094	xmlXPathFreeObject(res);
15095	res = NULL;
15096	}
15097
15098	xmlXPathFreeParserContext(ctxt);
15099	return(res);
15100	}
15101
15102	/**
15103	* xmlXPathSetContextNode:
15104	* @node: the node to to use as the context node
15105	* @ctx: the XPath context
15106	*
15107	* Sets 'node' as the context node. The node must be in the same
15108	* document as that associated with the context.
15109	*
15110	* Returns -1 in case of error or 0 if successful
15111	*/
15112	int
15113	xmlXPathSetContextNode(xmlNodePtr node, xmlXPathContextPtr ctx) {
15114	if ((node == NULL) \|\| (ctx == NULL))
15115	return(-1);
15116
15117	if (node->doc == ctx->doc) {
15118	ctx->node = node;
15119	return(0);
15120	}
15121	return(-1);
15122	}
15123
15124	/**
15125	* xmlXPathNodeEval:
15126	* @node: the node to to use as the context node
15127	* @str: the XPath expression
15128	* @ctx: the XPath context
15129	*
15130	* Evaluate the XPath Location Path in the given context. The node 'node'
15131	* is set as the context node. The context node is not restored.
15132	*
15133	* Returns the xmlXPathObjectPtr resulting from the evaluation or NULL.
15134	* the caller has to free the object.
15135	*/
15136	xmlXPathObjectPtr
15137	xmlXPathNodeEval(xmlNodePtr node, const xmlChar *str, xmlXPathContextPtr ctx) {
15138	if (str == NULL)
15139	return(NULL);
15140	if (xmlXPathSetContextNode(node, ctx) < 0)
15141	return(NULL);
15142	return(xmlXPathEval(str, ctx));
15143	}
15144
15145	/**
15146	* xmlXPathEvalExpression:
15147	* @str: the XPath expression
15148	* @ctxt: the XPath context
15149	*
15150	* Evaluate the XPath expression in the given context.
15151	*
15152	* Returns the xmlXPathObjectPtr resulting from the evaluation or NULL.
15153	* the caller has to free the object.
15154	*/
15155	xmlXPathObjectPtr
15156	xmlXPathEvalExpression(const xmlChar *str, xmlXPathContextPtr ctxt) {
15157	xmlXPathParserContextPtr pctxt;
15158	xmlXPathObjectPtr res, tmp;
15159	int stack = 0;
15160
15161	CHECK_CTXT(ctxt)
15162
15163	xmlXPathInit();
15164
15165	pctxt = xmlXPathNewParserContext(str, ctxt);
15166	if (pctxt == NULL)
15167	return NULL;
15168	xmlXPathEvalExpr(pctxt);
15169
15170	if ((*pctxt->cur != 0) \|\| (pctxt->error != XPATH_EXPRESSION_OK)) {
15171	xmlXPatherror(pctxt, __FILE__, __LINE__, XPATH_EXPR_ERROR);
15172	res = NULL;
15173	} else {
15174	res = valuePop(pctxt);
15175	}
15176	do {
15177	tmp = valuePop(pctxt);
15178	if (tmp != NULL) {
15179	xmlXPathReleaseObject(ctxt, tmp);
15180	stack++;
15181	}
15182	} while (tmp != NULL);
15183	if ((stack != 0) && (res != NULL)) {
15184	xmlGenericError(xmlGenericErrorContext,
15185	"xmlXPathEvalExpression: %d object left on the stack\n",
15186	stack);
15187	}
15188	xmlXPathFreeParserContext(pctxt);
15189	return(res);
15190	}
15191
15192	/************************************************************************
15193	* *
15194	* Extra functions not pertaining to the XPath spec *
15195	* *
15196	************************************************************************/
15197	/**
15198	* xmlXPathEscapeUriFunction:
15199	* @ctxt: the XPath Parser context
15200	* @nargs: the number of arguments
15201	*
15202	* Implement the escape-uri() XPath function
15203	* string escape-uri(string $str, bool $escape-reserved)
15204	*
15205	* This function applies the URI escaping rules defined in section 2 of [RFC
15206	* 2396] to the string supplied as $uri-part, which typically represents all
15207	* or part of a URI. The effect of the function is to replace any special
15208	* character in the string by an escape sequence of the form %xx%yy...,
15209	* where xxyy... is the hexadecimal representation of the octets used to
15210	* represent the character in UTF-8.
15211	*
15212	* The set of characters that are escaped depends on the setting of the
15213	* boolean argument $escape-reserved.
15214	*
15215	* If $escape-reserved is true, all characters are escaped other than lower
15216	* case letters a-z, upper case letters A-Z, digits 0-9, and the characters
15217	* referred to in [RFC 2396] as "marks": specifically, "-" \| "_" \| "." \| "!"
15218	* \| "~" \| "*" \| "'" \| "(" \| ")". The "%" character itself is escaped only
15219	* if it is not followed by two hexadecimal digits (that is, 0-9, a-f, and
15220	* A-F).
15221	*
15222	* If $escape-reserved is false, the behavior differs in that characters
15223	* referred to in [RFC 2396] as reserved characters are not escaped. These
15224	* characters are ";" \| "/" \| "?" \| ":" \| "@" \| "&" \| "=" \| "+" \| "$" \| ",".
15225	*
15226	* [RFC 2396] does not define whether escaped URIs should use lower case or
15227	* upper case for hexadecimal digits. To ensure that escaped URIs can be
15228	* compared using string comparison functions, this function must always use
15229	* the upper-case letters A-F.
15230	*
15231	* Generally, $escape-reserved should be set to true when escaping a string
15232	* that is to form a single part of a URI, and to false when escaping an
15233	* entire URI or URI reference.
15234	*
15235	* In the case of non-ascii characters, the string is encoded according to
15236	* utf-8 and then converted according to RFC 2396.
15237	*
15238	* Examples
15239	* xf:escape-uri ("gopher://spinaltap.micro.umn.edu/00/Weather/California/Los%20Angeles#ocean"), true())
15240	* returns "gopher%3A%2F%2Fspinaltap.micro.umn.edu%2F00%2FWeather%2FCalifornia%2FLos%20Angeles%23ocean"
15241	* xf:escape-uri ("gopher://spinaltap.micro.umn.edu/00/Weather/California/Los%20Angeles#ocean"), false())
15242	* returns "gopher://spinaltap.micro.umn.edu/00/Weather/California/Los%20Angeles%23ocean"
15243	*
15244	*/
15245	static void
15246	xmlXPathEscapeUriFunction(xmlXPathParserContextPtr ctxt, int nargs) {
15247	xmlXPathObjectPtr str;
15248	int escape_reserved;
15249	xmlBufPtr target;
15250	xmlChar *cptr;
15251	xmlChar escape[4];
15252
15253	CHECK_ARITY(2);
15254
15255	escape_reserved = xmlXPathPopBoolean(ctxt);
15256
15257	CAST_TO_STRING;
15258	str = valuePop(ctxt);
15259
15260	target = xmlBufCreate();
15261
15262	escape[0] = '%';
15263	escape[3] = 0;
15264
15265	if (target) {
15266	for (cptr = str->stringval; *cptr; cptr++) {
15267	if ((cptr >= 'A' && cptr <= 'Z') \|\|
15268	(cptr >= 'a' && cptr <= 'z') \|\|
15269	(cptr >= '0' && cptr <= '9') \|\|
15270	cptr == '-' \|\| cptr == '_' \|\| *cptr == '.' \|\|
15271	cptr == '!' \|\| cptr == '~' \|\| cptr == '' \|\|
15272	cptr == '\''\|\| cptr == '(' \|\| *cptr == ')' \|\|
15273	(*cptr == '%' &&
15274	((cptr[1] >= 'A' && cptr[1] <= 'F') \|\|
15275	(cptr[1] >= 'a' && cptr[1] <= 'f') \|\|
15276	(cptr[1] >= '0' && cptr[1] <= '9')) &&
15277	((cptr[2] >= 'A' && cptr[2] <= 'F') \|\|
15278	(cptr[2] >= 'a' && cptr[2] <= 'f') \|\|
15279	(cptr[2] >= '0' && cptr[2] <= '9'))) \|\|
15280	(!escape_reserved &&
15281	(cptr == ';' \|\| cptr == '/' \|\| *cptr == '?' \|\|
15282	cptr == ':' \|\| cptr == '@' \|\| *cptr == '&' \|\|
15283	cptr == '=' \|\| cptr == '+' \|\| *cptr == '$' \|\|
15284	*cptr == ','))) {
15285	xmlBufAdd(target, cptr, 1);
15286	} else {
15287	if ((*cptr >> 4) < 10)
15288	escape[1] = '0' + (*cptr >> 4);
15289	else
15290	escape[1] = 'A' - 10 + (*cptr >> 4);
15291	if ((*cptr & 0xF) < 10)
15292	escape[2] = '0' + (*cptr & 0xF);
15293	else
15294	escape[2] = 'A' - 10 + (*cptr & 0xF);
15295
15296	xmlBufAdd(target, &escape[0], 3);
15297	}
15298	}
15299	}
15300	valuePush(ctxt, xmlXPathCacheNewString(ctxt->context,
15301	xmlBufContent(target)));
15302	xmlBufFree(target);
15303	xmlXPathReleaseObject(ctxt->context, str);
15304	}
15305
15306	/**
15307	* xmlXPathRegisterAllFunctions:
15308	* @ctxt: the XPath context
15309	*
15310	* Registers all default XPath functions in this context
15311	*/
15312	void
15313	xmlXPathRegisterAllFunctions(xmlXPathContextPtr ctxt)
15314	{
15315	xmlXPathRegisterFunc(ctxt, (const xmlChar *)"boolean",
15316	xmlXPathBooleanFunction);
15317	xmlXPathRegisterFunc(ctxt, (const xmlChar *)"ceiling",
15318	xmlXPathCeilingFunction);
15319	xmlXPathRegisterFunc(ctxt, (const xmlChar *)"count",
15320	xmlXPathCountFunction);
15321	xmlXPathRegisterFunc(ctxt, (const xmlChar *)"concat",
15322	xmlXPathConcatFunction);
15323	xmlXPathRegisterFunc(ctxt, (const xmlChar *)"contains",
15324	xmlXPathContainsFunction);
15325	xmlXPathRegisterFunc(ctxt, (const xmlChar *)"id",
15326	xmlXPathIdFunction);
15327	xmlXPathRegisterFunc(ctxt, (const xmlChar *)"false",
15328	xmlXPathFalseFunction);
15329	xmlXPathRegisterFunc(ctxt, (const xmlChar *)"floor",
15330	xmlXPathFloorFunction);
15331	xmlXPathRegisterFunc(ctxt, (const xmlChar *)"last",
15332	xmlXPathLastFunction);
15333	xmlXPathRegisterFunc(ctxt, (const xmlChar *)"lang",
15334	xmlXPathLangFunction);
15335	xmlXPathRegisterFunc(ctxt, (const xmlChar *)"local-name",
15336	xmlXPathLocalNameFunction);
15337	xmlXPathRegisterFunc(ctxt, (const xmlChar *)"not",
15338	xmlXPathNotFunction);
15339	xmlXPathRegisterFunc(ctxt, (const xmlChar *)"name",
15340	xmlXPathNameFunction);
15341	xmlXPathRegisterFunc(ctxt, (const xmlChar *)"namespace-uri",
15342	xmlXPathNamespaceURIFunction);
15343	xmlXPathRegisterFunc(ctxt, (const xmlChar *)"normalize-space",
15344	xmlXPathNormalizeFunction);
15345	xmlXPathRegisterFunc(ctxt, (const xmlChar *)"number",
15346	xmlXPathNumberFunction);
15347	xmlXPathRegisterFunc(ctxt, (const xmlChar *)"position",
15348	xmlXPathPositionFunction);
15349	xmlXPathRegisterFunc(ctxt, (const xmlChar *)"round",
15350	xmlXPathRoundFunction);
15351	xmlXPathRegisterFunc(ctxt, (const xmlChar *)"string",
15352	xmlXPathStringFunction);
15353	xmlXPathRegisterFunc(ctxt, (const xmlChar *)"string-length",
15354	xmlXPathStringLengthFunction);
15355	xmlXPathRegisterFunc(ctxt, (const xmlChar *)"starts-with",
15356	xmlXPathStartsWithFunction);
15357	xmlXPathRegisterFunc(ctxt, (const xmlChar *)"substring",
15358	xmlXPathSubstringFunction);
15359	xmlXPathRegisterFunc(ctxt, (const xmlChar *)"substring-before",
15360	xmlXPathSubstringBeforeFunction);
15361	xmlXPathRegisterFunc(ctxt, (const xmlChar *)"substring-after",
15362	xmlXPathSubstringAfterFunction);
15363	xmlXPathRegisterFunc(ctxt, (const xmlChar *)"sum",
15364	xmlXPathSumFunction);
15365	xmlXPathRegisterFunc(ctxt, (const xmlChar *)"true",
15366	xmlXPathTrueFunction);
15367	xmlXPathRegisterFunc(ctxt, (const xmlChar *)"translate",
15368	xmlXPathTranslateFunction);
15369
15370	xmlXPathRegisterFuncNS(ctxt, (const xmlChar *)"escape-uri",
15371	(const xmlChar *)"http://www.w3.org/2002/08/xquery-functions",
15372	xmlXPathEscapeUriFunction);
15373	}
15374
15375	#endif /* LIBXML_XPATH_ENABLED */
15376	#define bottom_xpath
15377	#include "elfgcchack.h"

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

source: vbox/trunk/src/libs/libxml2-2.9.2/xpath.c@ 58209

Download in other formats: