~ubuntu-branches/ubuntu/utopic/libxml2/utopic
» Revision
43.2.6
: .pc/0007-Fix-XPath-optimization-with-predicates.patch/xpath.c
« back to all changes in this revision
Viewing changes to .pc/0007-Fix-XPath-optimization-with-predicates.patch/xpath.c
- browse files at revision 43.2.6
- compare with another revision
- download diff
- download tarball
- view history from revision 43.2.6
- Committer: Package Import Robot
- Author(s): Aron Xu, Christian Svensson, Daniel Schepler, Helmut Grohne, Adam Conrad, Matthias Klose, Aron Xu
- Date: 2014-07-09 05:40:15 UTC
- mto: This revision was merged to the branch mainline in revision 75.
- Revision ID: package-import@ubuntu.com-20140709054015-rdnfjxrf3zvmw6l7
[ Christian Svensson ]
* Do not build-depend on readline (Closes: #742350)
[ Daniel Schepler ]
* Patch to bootstrap without python (Closes: #738080)
[ Helmut Grohne ]
* Drop unneeded B-D on perl and binutils (Closes: #753005)
[ Adam Conrad ]
* Actually run dh_autoreconf, which the old/new mixed rules file misses.
[ Matthias Klose ]
* Add patch to fix python multiarch issue
* Allow the package to cross-build by tweaking B-Ds on python
* Set PYTHON_LIBS for cross builds
[ Aron Xu ]
* Use correct $CC
* Configure udeb without python
* New round of cherry-picking upstream fixes
- Includes fixes for CVE-2014-0191 (Closes: #747309).
* Call prename with -vf
* Require python-all-dev (>= 2.7.5-5~)
* Bump std-ver: 3.9.4 -> 3.9.5, no change
* Do not build-depend on readline (Closes: #742350)
[ Daniel Schepler ]
* Patch to bootstrap without python (Closes: #738080)
[ Helmut Grohne ]
* Drop unneeded B-D on perl and binutils (Closes: #753005)
[ Adam Conrad ]
* Actually run dh_autoreconf, which the old/new mixed rules file misses.
[ Matthias Klose ]
* Add patch to fix python multiarch issue
* Allow the package to cross-build by tweaking B-Ds on python
* Set PYTHON_LIBS for cross builds
[ Aron Xu ]
* Use correct $CC
* Configure udeb without python
* New round of cherry-picking upstream fixes
- Includes fixes for CVE-2014-0191 (Closes: #747309).
* Call prename with -vf
* Require python-all-dev (>= 2.7.5-5~)
* Bump std-ver: 3.9.4 -> 3.9.5, no change
- files added:
- .pc/0002-fix-python-multiarch-includes.patch
- .pc/0002-fix-python-multiarch-includes.patch/python
- .pc/0003-Fix-an-error-in-xmlCleanupParser.patch
- .pc/0004-Fix-missing-break-on-last-function-for-attributes.patch
- .pc/0004-Fix-missing-break-on-last-function-for-attributes.patch/python
- .pc/0005-xmllint-memory-should-fail-on-empty-files.patch
- .pc/0006-properly-quote-the-namespace-uris-written-out-during.patch
- .pc/0007-Fix-a-parsing-bug-on-non-ascii-element-and-CR-LF-usa.patch
- .pc/0008-missing-else-in-xlink.c.patch
- .pc/0009-Catch-malloc-error-and-exit-accordingly.patch
- .pc/0010-Fix-handling-of-mmap-errors.patch
- .pc/0011-Avoid-crash-if-allocation-fails.patch
- .pc/0012-Fix-a-possible-NULL-dereference.patch
- .pc/0013-Clear-up-a-potential-NULL-dereference.patch
- .pc/0014-Fix-XPath-optimization-with-predicates.patch
- .pc/0015-xmllint-pretty-crashed-without-following-numeric-arg.patch
- .pc/0016-Fix-potential-NULL-pointer-dereferences-in-regexp-co.patch
- .pc/0017-Fix-a-potential-NULL-dereference-in-tree-code.patch
- .pc/0018-Fix-pointer-dereferenced-before-null-check.patch
- .pc/0019-Fix-a-bug-loading-some-compressed-files.patch
- .pc/0020-Avoid-a-possibility-of-dangling-encoding-handler.patch
- .pc/0021-Fix-a-couple-of-missing-NULL-checks.patch
- .pc/0022-adding-init-calls-to-xml-and-html-Read-parsing-entry.patch
- .pc/0023-Handling-of-XPath-function-arguments-in-error-case.patch
- .pc/0024-Missing-initialization-for-the-catalog-module.patch
- .pc/0025-Fix-an-fd-leak-in-an-error-case.patch
- .pc/0026-fixing-a-ptotential-uninitialized-access.patch
- .pc/0027-Fix-xmlTextWriterWriteElement-when-a-null-content-is.patch
- .pc/0028-Avoid-a-possible-NULL-pointer-dereference.patch
- .pc/0029-Do-not-fetch-external-parameter-entities.patch
- .pc/0030-Avoid-Possible-null-pointer-dereference-in-memory-de.patch
- .pc/0031-xmllint-was-not-parsing-the-c14n11-flag.patch
- .pc/0032-Fix-regressions-introduced-by-CVE-2014-0191-patch.patch
- files removed:
- .pc/0002-Fix-an-error-in-xmlCleanupParser.patch
- .pc/0003-Fix-missing-break-on-last-function-for-attributes.patch
- .pc/0003-Fix-missing-break-on-last-function-for-attributes.patch/python
- .pc/0004-xmllint-memory-should-fail-on-empty-files.patch
- .pc/0005-properly-quote-the-namespace-uris-written-out-during.patch
- .pc/0006-Fix-a-parsing-bug-on-non-ascii-element-and-CR-LF-usa.patch
- .pc/0007-Fix-XPath-optimization-with-predicates.patch
- files modified:
- .pc/applied-patches
added
removed
.pc/0007-Fix-XPath-optimization-with-predicates.patch/xpath.c
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
/*
139
* Wrapper for the Timsort argorithm from timsort.h
140
*/
141
#ifdef WITH_TIM_SORT
142
#define SORT_NAME libxml_domnode
143
#define SORT_TYPE xmlNodePtr
144
/**
145
* wrap_cmp:
146
* @x: a node
147
* @y: another node
148
*
149
* Comparison function for the Timsort implementation
150
*
151
* Returns -2 in case of error -1 if first point < second point, 0 if
152
* it's the same node, +1 otherwise
153
*/
154
static
155
int wrap_cmp( xmlNodePtr x, xmlNodePtr y );
156
#ifdef XP_OPTIMIZED_NON_ELEM_COMPARISON
157
static int xmlXPathCmpNodesExt(xmlNodePtr, xmlNodePtr);
158
static int wrap_cmp( xmlNodePtr x, xmlNodePtr y )
159
{
160
int res = xmlXPathCmpNodesExt(x, y);
161
return res == -2 ? res : -res;
162
}
163
#else
164
static int wrap_cmp( xmlNodePtr x, xmlNodePtr y )
165
{
166
int res = xmlXPathCmpNodes(x, y);
167
return res == -2 ? res : -res;
168
}
169
#endif
170
#define SORT_CMP(x, y) (wrap_cmp(x, y))
171
#include "timsort.h"
172
#endif /* WITH_TIM_SORT */
173
174
#if defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
175
176
/************************************************************************
177
* *
178
* Floating point stuff *
179
* *
180
************************************************************************/
181
182
#ifndef TRIO_REPLACE_STDIO
183
#define TRIO_PUBLIC static
184
#endif
185
#include "trionan.c"
186
187
/*
188
* The lack of portability of this section of the libc is annoying !
189
*/
190
double xmlXPathNAN = 0;
191
double xmlXPathPINF = 1;
192
double xmlXPathNINF = -1;
193
static double xmlXPathNZERO = 0; /* not exported from headers */
194
static int xmlXPathInitialized = 0;
195
196
/**
197
* xmlXPathInit:
198
*
199
* Initialize the XPath environment
200
*/
201
void
202
xmlXPathInit(void) {
203
if (xmlXPathInitialized) return;
204
205
xmlXPathPINF = trio_pinf();
206
xmlXPathNINF = trio_ninf();
207
xmlXPathNAN = trio_nan();
208
xmlXPathNZERO = trio_nzero();
209
210
xmlXPathInitialized = 1;
211
}
212
213
/**
214
* xmlXPathIsNaN:
215
* @val: a double value
216
*
217
* Provides a portable isnan() function to detect whether a double
218
* is a NotaNumber. Based on trio code
219
* http://sourceforge.net/projects/ctrio/
220
*
221
* Returns 1 if the value is a NaN, 0 otherwise
222
*/
223
int
224
xmlXPathIsNaN(double val) {
225
return(trio_isnan(val));
226
}
227
228
/**
229
* xmlXPathIsInf:
230
* @val: a double value
231
*
232
* Provides a portable isinf() function to detect whether a double
233
* is a +Infinite or -Infinite. Based on trio code
234
* http://sourceforge.net/projects/ctrio/
235
*
236
* Returns 1 vi the value is +Infinite, -1 if -Infinite, 0 otherwise
237
*/
238
int
239
xmlXPathIsInf(double val) {
240
return(trio_isinf(val));
241
}
242
243
#endif /* SCHEMAS or XPATH */
244
#ifdef LIBXML_XPATH_ENABLED
245
/**
246
* xmlXPathGetSign:
247
* @val: a double value
248
*
249
* Provides a portable function to detect the sign of a double
250
* Modified from trio code
251
* http://sourceforge.net/projects/ctrio/
252
*
253
* Returns 1 if the value is Negative, 0 if positive
254
*/
255
static int
256
xmlXPathGetSign(double val) {
257
return(trio_signbit(val));
258
}
259
260
261
/*
262
* TODO: when compatibility allows remove all "fake node libxslt" strings
263
* the test should just be name[0] = ' '
264
*/
265
#ifdef DEBUG_XPATH_EXPRESSION
266
#define DEBUG_STEP
267
#define DEBUG_EXPR
268
#define DEBUG_EVAL_COUNTS
269
#endif
270
271
static xmlNs xmlXPathXMLNamespaceStruct = {
272
NULL,
273
XML_NAMESPACE_DECL,
274
XML_XML_NAMESPACE,
275
BAD_CAST "xml",
276
NULL,
277
NULL
278
};
279
static xmlNsPtr xmlXPathXMLNamespace = &xmlXPathXMLNamespaceStruct;
280
#ifndef LIBXML_THREAD_ENABLED
281
/*
282
* Optimizer is disabled only when threaded apps are detected while
283
* the library ain't compiled for thread safety.
284
*/
285
static int xmlXPathDisableOptimizer = 0;
286
#endif
287
288
/************************************************************************
289
* *
290
* Error handling routines *
291
* *
292
************************************************************************/
293
294
/**
295
* XP_ERRORNULL:
296
* @X: the error code
297
*
298
* Macro to raise an XPath error and return NULL.
299
*/
300
#define XP_ERRORNULL(X) \
301
{ xmlXPathErr(ctxt, X); return(NULL); }
302
303
/*
304
* The array xmlXPathErrorMessages corresponds to the enum xmlXPathError
305
*/
306
static const char *xmlXPathErrorMessages[] = {
307
"Ok\n",
308
"Number encoding\n",
309
"Unfinished literal\n",
310
"Start of literal\n",
311
"Expected $ for variable reference\n",
312
"Undefined variable\n",
313
"Invalid predicate\n",
314
"Invalid expression\n",
315
"Missing closing curly brace\n",
316
"Unregistered function\n",
317
"Invalid operand\n",
318
"Invalid type\n",
319
"Invalid number of arguments\n",
320
"Invalid context size\n",
321
"Invalid context position\n",
322
"Memory allocation error\n",
323
"Syntax error\n",
324
"Resource error\n",
325
"Sub resource error\n",
326
"Undefined namespace prefix\n",
327
"Encoding error\n",
328
"Char out of XML range\n",
329
"Invalid or incomplete context\n",
330
"Stack usage errror\n",
331
"Forbidden variable\n",
332
"?? Unknown error ??\n" /* Must be last in the list! */
333
};
334
#define MAXERRNO ((int)(sizeof(xmlXPathErrorMessages) / \
335
sizeof(xmlXPathErrorMessages[0])) - 1)
336
/**
337
* xmlXPathErrMemory:
338
* @ctxt: an XPath context
339
* @extra: extra informations
340
*
341
* Handle a redefinition of attribute error
342
*/
343
static void
344
xmlXPathErrMemory(xmlXPathContextPtr ctxt, const char *extra)
345
{
346
if (ctxt != NULL) {
347
if (extra) {
348
xmlChar buf[200];
349
350
xmlStrPrintf(buf, 200,
351
BAD_CAST "Memory allocation failed : %s\n",
352
extra);
353
ctxt->lastError.message = (char *) xmlStrdup(buf);
354
} else {
355
ctxt->lastError.message = (char *)
356
xmlStrdup(BAD_CAST "Memory allocation failed\n");
357
}
358
ctxt->lastError.domain = XML_FROM_XPATH;
359
ctxt->lastError.code = XML_ERR_NO_MEMORY;
360
if (ctxt->error != NULL)
361
ctxt->error(ctxt->userData, &ctxt->lastError);
362
} else {
363
if (extra)
364
__xmlRaiseError(NULL, NULL, NULL,
365
NULL, NULL, XML_FROM_XPATH,
366
XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0,
367
extra, NULL, NULL, 0, 0,
368
"Memory allocation failed : %s\n", extra);
369
else
370
__xmlRaiseError(NULL, NULL, NULL,
371
NULL, NULL, XML_FROM_XPATH,
372
XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0,
373
NULL, NULL, NULL, 0, 0,
374
"Memory allocation failed\n");
375
}
376
}
377
378
/**
379
* xmlXPathPErrMemory:
380
* @ctxt: an XPath parser context
381
* @extra: extra informations
382
*
383
* Handle a redefinition of attribute error
384
*/
385
static void
386
xmlXPathPErrMemory(xmlXPathParserContextPtr ctxt, const char *extra)
387
{
388
if (ctxt == NULL)
389
xmlXPathErrMemory(NULL, extra);
390
else {
391
ctxt->error = XPATH_MEMORY_ERROR;
392
xmlXPathErrMemory(ctxt->context, extra);
393
}
394
}
395
396
/**
397
* xmlXPathErr:
398
* @ctxt: a XPath parser context
399
* @error: the error code
400
*
401
* Handle an XPath error
402
*/
403
void
404
xmlXPathErr(xmlXPathParserContextPtr ctxt, int error)
405
{
406
if ((error < 0) || (error > MAXERRNO))
407
error = MAXERRNO;
408
if (ctxt == NULL) {
409
__xmlRaiseError(NULL, NULL, NULL,
410
NULL, NULL, XML_FROM_XPATH,
411
error + XML_XPATH_EXPRESSION_OK - XPATH_EXPRESSION_OK,
412
XML_ERR_ERROR, NULL, 0,
413
NULL, NULL, NULL, 0, 0,
414
"%s", xmlXPathErrorMessages[error]);
415
return;
416
}
417
ctxt->error = error;
418
if (ctxt->context == NULL) {
419
__xmlRaiseError(NULL, NULL, NULL,
420
NULL, NULL, XML_FROM_XPATH,
421
error + XML_XPATH_EXPRESSION_OK - XPATH_EXPRESSION_OK,
422
XML_ERR_ERROR, NULL, 0,
423
(const char *) ctxt->base, NULL, NULL,
424
ctxt->cur - ctxt->base, 0,
425
"%s", xmlXPathErrorMessages[error]);
426
return;
427
}
428
429
/* cleanup current last error */
430
xmlResetError(&ctxt->context->lastError);
431
432
ctxt->context->lastError.domain = XML_FROM_XPATH;
433
ctxt->context->lastError.code = error + XML_XPATH_EXPRESSION_OK -
434
XPATH_EXPRESSION_OK;
435
ctxt->context->lastError.level = XML_ERR_ERROR;
436
ctxt->context->lastError.str1 = (char *) xmlStrdup(ctxt->base);
437
ctxt->context->lastError.int1 = ctxt->cur - ctxt->base;
438
ctxt->context->lastError.node = ctxt->context->debugNode;
439
if (ctxt->context->error != NULL) {
440
ctxt->context->error(ctxt->context->userData,
441
&ctxt->context->lastError);
442
} else {
443
__xmlRaiseError(NULL, NULL, NULL,
444
NULL, ctxt->context->debugNode, XML_FROM_XPATH,
445
error + XML_XPATH_EXPRESSION_OK - XPATH_EXPRESSION_OK,
446
XML_ERR_ERROR, NULL, 0,
447
(const char *) ctxt->base, NULL, NULL,
448
ctxt->cur - ctxt->base, 0,
449
"%s", xmlXPathErrorMessages[error]);
450
}
451
452
}
453
454
/**
455
* xmlXPatherror:
456
* @ctxt: the XPath Parser context
457
* @file: the file name
458
* @line: the line number
459
* @no: the error number
460
*
461
* Formats an error message.
462
*/
463
void
464
xmlXPatherror(xmlXPathParserContextPtr ctxt, const char *file ATTRIBUTE_UNUSED,
465
int line ATTRIBUTE_UNUSED, int no) {
466
xmlXPathErr(ctxt, no);
467
}
468
469
/************************************************************************
470
* *
471
* Utilities *
472
* *
473
************************************************************************/
474
475
/**
476
* xsltPointerList:
477
*
478
* Pointer-list for various purposes.
479
*/
480
typedef struct _xmlPointerList xmlPointerList;
481
typedef xmlPointerList *xmlPointerListPtr;
482
struct _xmlPointerList {
483
void **items;
484
int number;
485
int size;
486
};
487
/*
488
* TODO: Since such a list-handling is used in xmlschemas.c and libxslt
489
* and here, we should make the functions public.
490
*/
491
static int
492
xmlPointerListAddSize(xmlPointerListPtr list,
493
void *item,
494
int initialSize)
495
{
496
if (list->items == NULL) {
497
if (initialSize <= 0)
498
initialSize = 1;
499
list->items = (void **) xmlMalloc(initialSize * sizeof(void *));
500
if (list->items == NULL) {
501
xmlXPathErrMemory(NULL,
502
"xmlPointerListCreate: allocating item\n");
503
return(-1);
504
}
505
list->number = 0;
506
list->size = initialSize;
507
} else if (list->size <= list->number) {
508
if (list->size > 50000000) {
509
xmlXPathErrMemory(NULL,
510
"xmlPointerListAddSize: re-allocating item\n");
511
return(-1);
512
}
513
list->size *= 2;
514
list->items = (void **) xmlRealloc(list->items,
515
list->size * sizeof(void *));
516
if (list->items == NULL) {
517
xmlXPathErrMemory(NULL,
518
"xmlPointerListAddSize: re-allocating item\n");
519
list->size = 0;
520
return(-1);
521
}
522
}
523
list->items[list->number++] = item;
524
return(0);
525
}
526
527
/**
528
* xsltPointerListCreate:
529
*
530
* Creates an xsltPointerList structure.
531
*
532
* Returns a xsltPointerList structure or NULL in case of an error.
533
*/
534
static xmlPointerListPtr
535
xmlPointerListCreate(int initialSize)
536
{
537
xmlPointerListPtr ret;
538
539
ret = xmlMalloc(sizeof(xmlPointerList));
540
if (ret == NULL) {
541
xmlXPathErrMemory(NULL,
542
"xmlPointerListCreate: allocating item\n");
543
return (NULL);
544
}
545
memset(ret, 0, sizeof(xmlPointerList));
546
if (initialSize > 0) {
547
xmlPointerListAddSize(ret, NULL, initialSize);
548
ret->number = 0;
549
}
550
return (ret);
551
}
552
553
/**
554
* xsltPointerListFree:
555
*
556
* Frees the xsltPointerList structure. This does not free
557
* the content of the list.
558
*/
559
static void
560
xmlPointerListFree(xmlPointerListPtr list)
561
{
562
if (list == NULL)
563
return;
564
if (list->items != NULL)
565
xmlFree(list->items);
566
xmlFree(list);
567
}
568
569
/************************************************************************
570
* *
571
* Parser Types *
572
* *
573
************************************************************************/
574
575
/*
576
* Types are private:
577
*/
578
579
typedef enum {
580
XPATH_OP_END=0,
581
XPATH_OP_AND,
582
XPATH_OP_OR,
583
XPATH_OP_EQUAL,
584
XPATH_OP_CMP,
585
XPATH_OP_PLUS,
586
XPATH_OP_MULT,
587
XPATH_OP_UNION,
588
XPATH_OP_ROOT,
589
XPATH_OP_NODE,
590
XPATH_OP_RESET, /* 10 */
591
XPATH_OP_COLLECT,
592
XPATH_OP_VALUE, /* 12 */
593
XPATH_OP_VARIABLE,
594
XPATH_OP_FUNCTION,
595
XPATH_OP_ARG,
596
XPATH_OP_PREDICATE,
597
XPATH_OP_FILTER, /* 17 */
598
XPATH_OP_SORT /* 18 */
599
#ifdef LIBXML_XPTR_ENABLED
600
,XPATH_OP_RANGETO
601
#endif
602
} xmlXPathOp;
603
604
typedef enum {
605
AXIS_ANCESTOR = 1,
606
AXIS_ANCESTOR_OR_SELF,
607
AXIS_ATTRIBUTE,
608
AXIS_CHILD,
609
AXIS_DESCENDANT,
610
AXIS_DESCENDANT_OR_SELF,
611
AXIS_FOLLOWING,
612
AXIS_FOLLOWING_SIBLING,
613
AXIS_NAMESPACE,
614
AXIS_PARENT,
615
AXIS_PRECEDING,
616
AXIS_PRECEDING_SIBLING,
617
AXIS_SELF
618
} xmlXPathAxisVal;
619
620
typedef enum {
621
NODE_TEST_NONE = 0,
622
NODE_TEST_TYPE = 1,
623
NODE_TEST_PI = 2,
624
NODE_TEST_ALL = 3,
625
NODE_TEST_NS = 4,
626
NODE_TEST_NAME = 5
627
} xmlXPathTestVal;
628
629
typedef enum {
630
NODE_TYPE_NODE = 0,
631
NODE_TYPE_COMMENT = XML_COMMENT_NODE,
632
NODE_TYPE_TEXT = XML_TEXT_NODE,
633
NODE_TYPE_PI = XML_PI_NODE
634
} xmlXPathTypeVal;
635
636
typedef struct _xmlXPathStepOp xmlXPathStepOp;
637
typedef xmlXPathStepOp *xmlXPathStepOpPtr;
638
struct _xmlXPathStepOp {
639
xmlXPathOp op; /* The identifier of the operation */
640
int ch1; /* First child */
641
int ch2; /* Second child */
642
int value;
643
int value2;
644
int value3;
645
void *value4;
646
void *value5;
647
void *cache;
648
void *cacheURI;
649
};
650
651
struct _xmlXPathCompExpr {
652
int nbStep; /* Number of steps in this expression */
653
int maxStep; /* Maximum number of steps allocated */
654
xmlXPathStepOp *steps; /* ops for computation of this expression */
655
int last; /* index of last step in expression */
656
xmlChar *expr; /* the expression being computed */
657
xmlDictPtr dict; /* the dictionnary to use if any */
658
#ifdef DEBUG_EVAL_COUNTS
659
int nb;
660
xmlChar *string;
661
#endif
662
#ifdef XPATH_STREAMING
663
xmlPatternPtr stream;
664
#endif
665
};
666
667
/************************************************************************
668
* *
669
* Forward declarations *
670
* *
671
************************************************************************/
672
static void
673
xmlXPathFreeValueTree(xmlNodeSetPtr obj);
674
static void
675
xmlXPathReleaseObject(xmlXPathContextPtr ctxt, xmlXPathObjectPtr obj);
676
static int
677
xmlXPathCompOpEvalFirst(xmlXPathParserContextPtr ctxt,
678
xmlXPathStepOpPtr op, xmlNodePtr *first);
679
static int
680
xmlXPathCompOpEvalToBoolean(xmlXPathParserContextPtr ctxt,
681
xmlXPathStepOpPtr op,
682
int isPredicate);
683
684
/************************************************************************
685
* *
686
* Parser Type functions *
687
* *
688
************************************************************************/
689
690
/**
691
* xmlXPathNewCompExpr:
692
*
693
* Create a new Xpath component
694
*
695
* Returns the newly allocated xmlXPathCompExprPtr or NULL in case of error
696
*/
697
static xmlXPathCompExprPtr
698
xmlXPathNewCompExpr(void) {
699
xmlXPathCompExprPtr cur;
700
701
cur = (xmlXPathCompExprPtr) xmlMalloc(sizeof(xmlXPathCompExpr));
702
if (cur == NULL) {
703
xmlXPathErrMemory(NULL, "allocating component\n");
704
return(NULL);
705
}
706
memset(cur, 0, sizeof(xmlXPathCompExpr));
707
cur->maxStep = 10;
708
cur->nbStep = 0;
709
cur->steps = (xmlXPathStepOp *) xmlMalloc(cur->maxStep *
710
sizeof(xmlXPathStepOp));
711
if (cur->steps == NULL) {
712
xmlXPathErrMemory(NULL, "allocating steps\n");
713
xmlFree(cur);
714
return(NULL);
715
}
716
memset(cur->steps, 0, cur->maxStep * sizeof(xmlXPathStepOp));
717
cur->last = -1;
718
#ifdef DEBUG_EVAL_COUNTS
719
cur->nb = 0;
720
#endif
721
return(cur);
722
}
723
724
/**
725
* xmlXPathFreeCompExpr:
726
* @comp: an XPATH comp
727
*
728
* Free up the memory allocated by @comp
729
*/
730
void
731
xmlXPathFreeCompExpr(xmlXPathCompExprPtr comp)
732
{
733
xmlXPathStepOpPtr op;
734
int i;
735
736
if (comp == NULL)
737
return;
738
if (comp->dict == NULL) {
739
for (i = 0; i < comp->nbStep; i++) {
740
op = &comp->steps[i];
741
if (op->value4 != NULL) {
742
if (op->op == XPATH_OP_VALUE)
743
xmlXPathFreeObject(op->value4);
744
else
745
xmlFree(op->value4);
746
}
747
if (op->value5 != NULL)
748
xmlFree(op->value5);
749
}
750
} else {
751
for (i = 0; i < comp->nbStep; i++) {
752
op = &comp->steps[i];
753
if (op->value4 != NULL) {
754
if (op->op == XPATH_OP_VALUE)
755
xmlXPathFreeObject(op->value4);
756
}
757
}
758
xmlDictFree(comp->dict);
759
}
760
if (comp->steps != NULL) {
761
xmlFree(comp->steps);
762
}
763
#ifdef DEBUG_EVAL_COUNTS
764
if (comp->string != NULL) {
765
xmlFree(comp->string);
766
}
767
#endif
768
#ifdef XPATH_STREAMING
769
if (comp->stream != NULL) {
770
xmlFreePatternList(comp->stream);
771
}
772
#endif
773
if (comp->expr != NULL) {
774
xmlFree(comp->expr);
775
}
776
777
xmlFree(comp);
778
}
779
780
/**
781
* xmlXPathCompExprAdd:
782
* @comp: the compiled expression
783
* @ch1: first child index
784
* @ch2: second child index
785
* @op: an op
786
* @value: the first int value
787
* @value2: the second int value
788
* @value3: the third int value
789
* @value4: the first string value
790
* @value5: the second string value
791
*
792
* Add a step to an XPath Compiled Expression
793
*
794
* Returns -1 in case of failure, the index otherwise
795
*/
796
static int
797
xmlXPathCompExprAdd(xmlXPathCompExprPtr comp, int ch1, int ch2,
798
xmlXPathOp op, int value,
799
int value2, int value3, void *value4, void *value5) {
800
if (comp->nbStep >= comp->maxStep) {
801
xmlXPathStepOp *real;
802
803
if (comp->maxStep >= XPATH_MAX_STEPS) {
804
xmlXPathErrMemory(NULL, "adding step\n");
805
return(-1);
806
}
807
comp->maxStep *= 2;
808
real = (xmlXPathStepOp *) xmlRealloc(comp->steps,
809
comp->maxStep * sizeof(xmlXPathStepOp));
810
if (real == NULL) {
811
comp->maxStep /= 2;
812
xmlXPathErrMemory(NULL, "adding step\n");
813
return(-1);
814
}
815
comp->steps = real;
816
}
817
comp->last = comp->nbStep;
818
comp->steps[comp->nbStep].ch1 = ch1;
819
comp->steps[comp->nbStep].ch2 = ch2;
820
comp->steps[comp->nbStep].op = op;
821
comp->steps[comp->nbStep].value = value;
822
comp->steps[comp->nbStep].value2 = value2;
823
comp->steps[comp->nbStep].value3 = value3;
824
if ((comp->dict != NULL) &&
825
((op == XPATH_OP_FUNCTION) || (op == XPATH_OP_VARIABLE) ||
826
(op == XPATH_OP_COLLECT))) {
827
if (value4 != NULL) {
828
comp->steps[comp->nbStep].value4 = (xmlChar *)
829
(void *)xmlDictLookup(comp->dict, value4, -1);
830
xmlFree(value4);
831
} else
832
comp->steps[comp->nbStep].value4 = NULL;
833
if (value5 != NULL) {
834
comp->steps[comp->nbStep].value5 = (xmlChar *)
835
(void *)xmlDictLookup(comp->dict, value5, -1);
836
xmlFree(value5);
837
} else
838
comp->steps[comp->nbStep].value5 = NULL;
839
} else {
840
comp->steps[comp->nbStep].value4 = value4;
841
comp->steps[comp->nbStep].value5 = value5;
842
}
843
comp->steps[comp->nbStep].cache = NULL;
844
return(comp->nbStep++);
845
}
846
847
/**
848
* xmlXPathCompSwap:
849
* @comp: the compiled expression
850
* @op: operation index
851
*
852
* Swaps 2 operations in the compiled expression
853
*/
854
static void
855
xmlXPathCompSwap(xmlXPathStepOpPtr op) {
856
int tmp;
857
858
#ifndef LIBXML_THREAD_ENABLED
859
/*
860
* Since this manipulates possibly shared variables, this is
861
* disabled if one detects that the library is used in a multithreaded
862
* application
863
*/
864
if (xmlXPathDisableOptimizer)
865
return;
866
#endif
867
868
tmp = op->ch1;
869
op->ch1 = op->ch2;
870
op->ch2 = tmp;
871
}
872
873
#define PUSH_FULL_EXPR(op, op1, op2, val, val2, val3, val4, val5) \
874
xmlXPathCompExprAdd(ctxt->comp, (op1), (op2), \
875
(op), (val), (val2), (val3), (val4), (val5))
876
#define PUSH_LONG_EXPR(op, val, val2, val3, val4, val5) \
877
xmlXPathCompExprAdd(ctxt->comp, ctxt->comp->last, -1, \
878
(op), (val), (val2), (val3), (val4), (val5))
879
880
#define PUSH_LEAVE_EXPR(op, val, val2) \
881
xmlXPathCompExprAdd(ctxt->comp, -1, -1, (op), (val), (val2), 0 ,NULL ,NULL)
882
883
#define PUSH_UNARY_EXPR(op, ch, val, val2) \
884
xmlXPathCompExprAdd(ctxt->comp, (ch), -1, (op), (val), (val2), 0 ,NULL ,NULL)
885
886
#define PUSH_BINARY_EXPR(op, ch1, ch2, val, val2) \
887
xmlXPathCompExprAdd(ctxt->comp, (ch1), (ch2), (op), \
888
(val), (val2), 0 ,NULL ,NULL)
889
890
/************************************************************************
891
* *
892
* XPath object cache structures *
893
* *
894
************************************************************************/
895
896
/* #define XP_DEFAULT_CACHE_ON */
897
898
#define XP_HAS_CACHE(c) ((c != NULL) && ((c)->cache != NULL))
899
900
typedef struct _xmlXPathContextCache xmlXPathContextCache;
901
typedef xmlXPathContextCache *xmlXPathContextCachePtr;
902
struct _xmlXPathContextCache {
903
xmlPointerListPtr nodesetObjs; /* contains xmlXPathObjectPtr */
904
xmlPointerListPtr stringObjs; /* contains xmlXPathObjectPtr */
905
xmlPointerListPtr booleanObjs; /* contains xmlXPathObjectPtr */
906
xmlPointerListPtr numberObjs; /* contains xmlXPathObjectPtr */
907
xmlPointerListPtr miscObjs; /* contains xmlXPathObjectPtr */
908
int maxNodeset;
909
int maxString;
910
int maxBoolean;
911
int maxNumber;
912
int maxMisc;
913
#ifdef XP_DEBUG_OBJ_USAGE
914
int dbgCachedAll;
915
int dbgCachedNodeset;
916
int dbgCachedString;
917
int dbgCachedBool;
918
int dbgCachedNumber;
919
int dbgCachedPoint;
920
int dbgCachedRange;
921
int dbgCachedLocset;
922
int dbgCachedUsers;
923
int dbgCachedXSLTTree;
924
int dbgCachedUndefined;
925
926
927
int dbgReusedAll;
928
int dbgReusedNodeset;
929
int dbgReusedString;
930
int dbgReusedBool;
931
int dbgReusedNumber;
932
int dbgReusedPoint;
933
int dbgReusedRange;
934
int dbgReusedLocset;
935
int dbgReusedUsers;
936
int dbgReusedXSLTTree;
937
int dbgReusedUndefined;
938
939
#endif
940
};
941
942
/************************************************************************
943
* *
944
* Debugging related functions *
945
* *
946
************************************************************************/
947
948
#define STRANGE \
949
xmlGenericError(xmlGenericErrorContext, \
950
"Internal error at %s:%d\n", \
951
__FILE__, __LINE__);
952
953
#ifdef LIBXML_DEBUG_ENABLED
954
static void
955
xmlXPathDebugDumpNode(FILE *output, xmlNodePtr cur, int depth) {
956
int i;
957
char shift[100];
958
959
for (i = 0;((i < depth) && (i < 25));i++)
960
shift[2 * i] = shift[2 * i + 1] = ' ';
961
shift[2 * i] = shift[2 * i + 1] = 0;
962
if (cur == NULL) {
963
fprintf(output, "%s", shift);
964
fprintf(output, "Node is NULL !\n");
965
return;
966
967
}
968
969
if ((cur->type == XML_DOCUMENT_NODE) ||
970
(cur->type == XML_HTML_DOCUMENT_NODE)) {
971
fprintf(output, "%s", shift);
972
fprintf(output, " /\n");
973
} else if (cur->type == XML_ATTRIBUTE_NODE)
974
xmlDebugDumpAttr(output, (xmlAttrPtr)cur, depth);
975
else
976
xmlDebugDumpOneNode(output, cur, depth);
977
}
978
static void
979
xmlXPathDebugDumpNodeList(FILE *output, xmlNodePtr cur, int depth) {
980
xmlNodePtr tmp;
981
int i;
982
char shift[100];
983
984
for (i = 0;((i < depth) && (i < 25));i++)
985
shift[2 * i] = shift[2 * i + 1] = ' ';
986
shift[2 * i] = shift[2 * i + 1] = 0;
987
if (cur == NULL) {
988
fprintf(output, "%s", shift);
989
fprintf(output, "Node is NULL !\n");
990
return;
991
992
}
993
994
while (cur != NULL) {
995
tmp = cur;
996
cur = cur->next;
997
xmlDebugDumpOneNode(output, tmp, depth);
998
}
999
}
1000
1001
static void
1002
xmlXPathDebugDumpNodeSet(FILE *output, xmlNodeSetPtr cur, int depth) {
1003
int i;
1004
char shift[100];
1005
1006
for (i = 0;((i < depth) && (i < 25));i++)
1007
shift[2 * i] = shift[2 * i + 1] = ' ';
1008
shift[2 * i] = shift[2 * i + 1] = 0;
1009
1010
if (cur == NULL) {
1011
fprintf(output, "%s", shift);
1012
fprintf(output, "NodeSet is NULL !\n");
1013
return;
1014
1015
}
1016
1017
if (cur != NULL) {
1018
fprintf(output, "Set contains %d nodes:\n", cur->nodeNr);
1019
for (i = 0;i < cur->nodeNr;i++) {
1020
fprintf(output, "%s", shift);
1021
fprintf(output, "%d", i + 1);
1022
xmlXPathDebugDumpNode(output, cur->nodeTab[i], depth + 1);
1023
}
1024
}
1025
}
1026
1027
static void
1028
xmlXPathDebugDumpValueTree(FILE *output, xmlNodeSetPtr cur, int depth) {
1029
int i;
1030
char shift[100];
1031
1032
for (i = 0;((i < depth) && (i < 25));i++)
1033
shift[2 * i] = shift[2 * i + 1] = ' ';
1034
shift[2 * i] = shift[2 * i + 1] = 0;
1035
1036
if ((cur == NULL) || (cur->nodeNr == 0) || (cur->nodeTab[0] == NULL)) {
1037
fprintf(output, "%s", shift);
1038
fprintf(output, "Value Tree is NULL !\n");
1039
return;
1040
1041
}
1042
1043
fprintf(output, "%s", shift);
1044
fprintf(output, "%d", i + 1);
1045
xmlXPathDebugDumpNodeList(output, cur->nodeTab[0]->children, depth + 1);
1046
}
1047
#if defined(LIBXML_XPTR_ENABLED)
1048
static void
1049
xmlXPathDebugDumpLocationSet(FILE *output, xmlLocationSetPtr cur, int depth) {
1050
int i;
1051
char shift[100];
1052
1053
for (i = 0;((i < depth) && (i < 25));i++)
1054
shift[2 * i] = shift[2 * i + 1] = ' ';
1055
shift[2 * i] = shift[2 * i + 1] = 0;
1056
1057
if (cur == NULL) {
1058
fprintf(output, "%s", shift);
1059
fprintf(output, "LocationSet is NULL !\n");
1060
return;
1061
1062
}
1063
1064
for (i = 0;i < cur->locNr;i++) {
1065
fprintf(output, "%s", shift);
1066
fprintf(output, "%d : ", i + 1);
1067
xmlXPathDebugDumpObject(output, cur->locTab[i], depth + 1);
1068
}
1069
}
1070
#endif /* LIBXML_XPTR_ENABLED */
1071
1072
/**
1073
* xmlXPathDebugDumpObject:
1074
* @output: the FILE * to dump the output
1075
* @cur: the object to inspect
1076
* @depth: indentation level
1077
*
1078
* Dump the content of the object for debugging purposes
1079
*/
1080
void
1081
xmlXPathDebugDumpObject(FILE *output, xmlXPathObjectPtr cur, int depth) {
1082
int i;
1083
char shift[100];
1084
1085
if (output == NULL) return;
1086
1087
for (i = 0;((i < depth) && (i < 25));i++)
1088
shift[2 * i] = shift[2 * i + 1] = ' ';
1089
shift[2 * i] = shift[2 * i + 1] = 0;
1090
1091
1092
fprintf(output, "%s", shift);
1093
1094
if (cur == NULL) {
1095
fprintf(output, "Object is empty (NULL)\n");
1096
return;
1097
}
1098
switch(cur->type) {
1099
case XPATH_UNDEFINED:
1100
fprintf(output, "Object is uninitialized\n");
1101
break;
1102
case XPATH_NODESET:
1103
fprintf(output, "Object is a Node Set :\n");
1104
xmlXPathDebugDumpNodeSet(output, cur->nodesetval, depth);
1105
break;
1106
case XPATH_XSLT_TREE:
1107
fprintf(output, "Object is an XSLT value tree :\n");
1108
xmlXPathDebugDumpValueTree(output, cur->nodesetval, depth);
1109
break;
1110
case XPATH_BOOLEAN:
1111
fprintf(output, "Object is a Boolean : ");
1112
if (cur->boolval) fprintf(output, "true\n");
1113
else fprintf(output, "false\n");
1114
break;
1115
case XPATH_NUMBER:
1116
switch (xmlXPathIsInf(cur->floatval)) {
1117
case 1:
1118
fprintf(output, "Object is a number : Infinity\n");
1119
break;
1120
case -1:
1121
fprintf(output, "Object is a number : -Infinity\n");
1122
break;
1123
default:
1124
if (xmlXPathIsNaN(cur->floatval)) {
1125
fprintf(output, "Object is a number : NaN\n");
1126
} else if (cur->floatval == 0 && xmlXPathGetSign(cur->floatval) != 0) {
1127
fprintf(output, "Object is a number : 0\n");
1128
} else {
1129
fprintf(output, "Object is a number : %0g\n", cur->floatval);
1130
}
1131
}
1132
break;
1133
case XPATH_STRING:
1134
fprintf(output, "Object is a string : ");
1135
xmlDebugDumpString(output, cur->stringval);
1136
fprintf(output, "\n");
1137
break;
1138
case XPATH_POINT:
1139
fprintf(output, "Object is a point : index %d in node", cur->index);
1140
xmlXPathDebugDumpNode(output, (xmlNodePtr) cur->user, depth + 1);
1141
fprintf(output, "\n");
1142
break;
1143
case XPATH_RANGE:
1144
if ((cur->user2 == NULL) ||
1145
((cur->user2 == cur->user) && (cur->index == cur->index2))) {
1146
fprintf(output, "Object is a collapsed range :\n");
1147
fprintf(output, "%s", shift);
1148
if (cur->index >= 0)
1149
fprintf(output, "index %d in ", cur->index);
1150
fprintf(output, "node\n");
1151
xmlXPathDebugDumpNode(output, (xmlNodePtr) cur->user,
1152
depth + 1);
1153
} else {
1154
fprintf(output, "Object is a range :\n");
1155
fprintf(output, "%s", shift);
1156
fprintf(output, "From ");
1157
if (cur->index >= 0)
1158
fprintf(output, "index %d in ", cur->index);
1159
fprintf(output, "node\n");
1160
xmlXPathDebugDumpNode(output, (xmlNodePtr) cur->user,
1161
depth + 1);
1162
fprintf(output, "%s", shift);
1163
fprintf(output, "To ");
1164
if (cur->index2 >= 0)
1165
fprintf(output, "index %d in ", cur->index2);
1166
fprintf(output, "node\n");
1167
xmlXPathDebugDumpNode(output, (xmlNodePtr) cur->user2,
1168
depth + 1);
1169
fprintf(output, "\n");
1170
}
1171
break;
1172
case XPATH_LOCATIONSET:
1173
#if defined(LIBXML_XPTR_ENABLED)
1174
fprintf(output, "Object is a Location Set:\n");
1175
xmlXPathDebugDumpLocationSet(output,
1176
(xmlLocationSetPtr) cur->user, depth);
1177
#endif
1178
break;
1179
case XPATH_USERS:
1180
fprintf(output, "Object is user defined\n");
1181
break;
1182
}
1183
}
1184
1185
static void
1186
xmlXPathDebugDumpStepOp(FILE *output, xmlXPathCompExprPtr comp,
1187
xmlXPathStepOpPtr op, int depth) {
1188
int i;
1189
char shift[100];
1190
1191
for (i = 0;((i < depth) && (i < 25));i++)
1192
shift[2 * i] = shift[2 * i + 1] = ' ';
1193
shift[2 * i] = shift[2 * i + 1] = 0;
1194
1195
fprintf(output, "%s", shift);
1196
if (op == NULL) {
1197
fprintf(output, "Step is NULL\n");
1198
return;
1199
}
1200
switch (op->op) {
1201
case XPATH_OP_END:
1202
fprintf(output, "END"); break;
1203
case XPATH_OP_AND:
1204
fprintf(output, "AND"); break;
1205
case XPATH_OP_OR:
1206
fprintf(output, "OR"); break;
1207
case XPATH_OP_EQUAL:
1208
if (op->value)
1209
fprintf(output, "EQUAL =");
1210
else
1211
fprintf(output, "EQUAL !=");
1212
break;
1213
case XPATH_OP_CMP:
1214
if (op->value)
1215
fprintf(output, "CMP <");
1216
else
1217
fprintf(output, "CMP >");
1218
if (!op->value2)
1219
fprintf(output, "=");
1220
break;
1221
case XPATH_OP_PLUS:
1222
if (op->value == 0)
1223
fprintf(output, "PLUS -");
1224
else if (op->value == 1)
1225
fprintf(output, "PLUS +");
1226
else if (op->value == 2)
1227
fprintf(output, "PLUS unary -");
1228
else if (op->value == 3)
1229
fprintf(output, "PLUS unary - -");
1230
break;
1231
case XPATH_OP_MULT:
1232
if (op->value == 0)
1233
fprintf(output, "MULT *");
1234
else if (op->value == 1)
1235
fprintf(output, "MULT div");
1236
else
1237
fprintf(output, "MULT mod");
1238
break;
1239
case XPATH_OP_UNION:
1240
fprintf(output, "UNION"); break;
1241
case XPATH_OP_ROOT:
1242
fprintf(output, "ROOT"); break;
1243
case XPATH_OP_NODE:
1244
fprintf(output, "NODE"); break;
1245
case XPATH_OP_RESET:
1246
fprintf(output, "RESET"); break;
1247
case XPATH_OP_SORT:
1248
fprintf(output, "SORT"); break;
1249
case XPATH_OP_COLLECT: {
1250
xmlXPathAxisVal axis = (xmlXPathAxisVal)op->value;
1251
xmlXPathTestVal test = (xmlXPathTestVal)op->value2;
1252
xmlXPathTypeVal type = (xmlXPathTypeVal)op->value3;
1253
const xmlChar *prefix = op->value4;
1254
const xmlChar *name = op->value5;
1255
1256
fprintf(output, "COLLECT ");
1257
switch (axis) {
1258
case AXIS_ANCESTOR:
1259
fprintf(output, " 'ancestors' "); break;
1260
case AXIS_ANCESTOR_OR_SELF:
1261
fprintf(output, " 'ancestors-or-self' "); break;
1262
case AXIS_ATTRIBUTE:
1263
fprintf(output, " 'attributes' "); break;
1264
case AXIS_CHILD:
1265
fprintf(output, " 'child' "); break;
1266
case AXIS_DESCENDANT:
1267
fprintf(output, " 'descendant' "); break;
1268
case AXIS_DESCENDANT_OR_SELF:
1269
fprintf(output, " 'descendant-or-self' "); break;
1270
case AXIS_FOLLOWING:
1271
fprintf(output, " 'following' "); break;
1272
case AXIS_FOLLOWING_SIBLING:
1273
fprintf(output, " 'following-siblings' "); break;
1274
case AXIS_NAMESPACE:
1275
fprintf(output, " 'namespace' "); break;
1276
case AXIS_PARENT:
1277
fprintf(output, " 'parent' "); break;
1278
case AXIS_PRECEDING:
1279
fprintf(output, " 'preceding' "); break;
1280
case AXIS_PRECEDING_SIBLING:
1281
fprintf(output, " 'preceding-sibling' "); break;
1282
case AXIS_SELF:
1283
fprintf(output, " 'self' "); break;
1284
}
1285
switch (test) {
1286
case NODE_TEST_NONE:
1287
fprintf(output, "'none' "); break;
1288
case NODE_TEST_TYPE:
1289
fprintf(output, "'type' "); break;
1290
case NODE_TEST_PI:
1291
fprintf(output, "'PI' "); break;
1292
case NODE_TEST_ALL:
1293
fprintf(output, "'all' "); break;
1294
case NODE_TEST_NS:
1295
fprintf(output, "'namespace' "); break;
1296
case NODE_TEST_NAME:
1297
fprintf(output, "'name' "); break;
1298
}
1299
switch (type) {
1300
case NODE_TYPE_NODE:
1301
fprintf(output, "'node' "); break;
1302
case NODE_TYPE_COMMENT:
1303
fprintf(output, "'comment' "); break;
1304
case NODE_TYPE_TEXT:
1305
fprintf(output, "'text' "); break;
1306
case NODE_TYPE_PI:
1307
fprintf(output, "'PI' "); break;
1308
}
1309
if (prefix != NULL)
1310
fprintf(output, "%s:", prefix);
1311
if (name != NULL)
1312
fprintf(output, "%s", (const char *) name);
1313
break;
1314
1315
}
1316
case XPATH_OP_VALUE: {
1317
xmlXPathObjectPtr object = (xmlXPathObjectPtr) op->value4;
1318
1319
fprintf(output, "ELEM ");
1320
xmlXPathDebugDumpObject(output, object, 0);
1321
goto finish;
1322
}
1323
case XPATH_OP_VARIABLE: {
1324
const xmlChar *prefix = op->value5;
1325
const xmlChar *name = op->value4;
1326
1327
if (prefix != NULL)
1328
fprintf(output, "VARIABLE %s:%s", prefix, name);
1329
else
1330
fprintf(output, "VARIABLE %s", name);
1331
break;
1332
}
1333
case XPATH_OP_FUNCTION: {
1334
int nbargs = op->value;
1335
const xmlChar *prefix = op->value5;
1336
const xmlChar *name = op->value4;
1337
1338
if (prefix != NULL)
1339
fprintf(output, "FUNCTION %s:%s(%d args)",
1340
prefix, name, nbargs);
1341
else
1342
fprintf(output, "FUNCTION %s(%d args)", name, nbargs);
1343
break;
1344
}
1345
case XPATH_OP_ARG: fprintf(output, "ARG"); break;
1346
case XPATH_OP_PREDICATE: fprintf(output, "PREDICATE"); break;
1347
case XPATH_OP_FILTER: fprintf(output, "FILTER"); break;
1348
#ifdef LIBXML_XPTR_ENABLED
1349
case XPATH_OP_RANGETO: fprintf(output, "RANGETO"); break;
1350
#endif
1351
default:
1352
fprintf(output, "UNKNOWN %d\n", op->op); return;
1353
}
1354
fprintf(output, "\n");
1355
finish:
1356
if (op->ch1 >= 0)
1357
xmlXPathDebugDumpStepOp(output, comp, &comp->steps[op->ch1], depth + 1);
1358
if (op->ch2 >= 0)
1359
xmlXPathDebugDumpStepOp(output, comp, &comp->steps[op->ch2], depth + 1);
1360
}
1361
1362
/**
1363
* xmlXPathDebugDumpCompExpr:
1364
* @output: the FILE * for the output
1365
* @comp: the precompiled XPath expression
1366
* @depth: the indentation level.
1367
*
1368
* Dumps the tree of the compiled XPath expression.
1369
*/
1370
void
1371
xmlXPathDebugDumpCompExpr(FILE *output, xmlXPathCompExprPtr comp,
1372
int depth) {
1373
int i;
1374
char shift[100];
1375
1376
if ((output == NULL) || (comp == 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
fprintf(output, "%s", shift);
1383
1384
fprintf(output, "Compiled Expression : %d elements\n",
1385
comp->nbStep);
1386
i = comp->last;
1387
xmlXPathDebugDumpStepOp(output, comp, &comp->steps[i], depth + 1);
1388
}
1389
1390
#ifdef XP_DEBUG_OBJ_USAGE
1391
1392
/*
1393
* XPath object usage related debugging variables.
1394
*/
1395
static int xmlXPathDebugObjCounterUndefined = 0;
1396
static int xmlXPathDebugObjCounterNodeset = 0;
1397
static int xmlXPathDebugObjCounterBool = 0;
1398
static int xmlXPathDebugObjCounterNumber = 0;
1399
static int xmlXPathDebugObjCounterString = 0;
1400
static int xmlXPathDebugObjCounterPoint = 0;
1401
static int xmlXPathDebugObjCounterRange = 0;
1402
static int xmlXPathDebugObjCounterLocset = 0;
1403
static int xmlXPathDebugObjCounterUsers = 0;
1404
static int xmlXPathDebugObjCounterXSLTTree = 0;
1405
static int xmlXPathDebugObjCounterAll = 0;
1406
1407
static int xmlXPathDebugObjTotalUndefined = 0;
1408
static int xmlXPathDebugObjTotalNodeset = 0;
1409
static int xmlXPathDebugObjTotalBool = 0;
1410
static int xmlXPathDebugObjTotalNumber = 0;
1411
static int xmlXPathDebugObjTotalString = 0;
1412
static int xmlXPathDebugObjTotalPoint = 0;
1413
static int xmlXPathDebugObjTotalRange = 0;
1414
static int xmlXPathDebugObjTotalLocset = 0;
1415
static int xmlXPathDebugObjTotalUsers = 0;
1416
static int xmlXPathDebugObjTotalXSLTTree = 0;
1417
static int xmlXPathDebugObjTotalAll = 0;
1418
1419
static int xmlXPathDebugObjMaxUndefined = 0;
1420
static int xmlXPathDebugObjMaxNodeset = 0;
1421
static int xmlXPathDebugObjMaxBool = 0;
1422
static int xmlXPathDebugObjMaxNumber = 0;
1423
static int xmlXPathDebugObjMaxString = 0;
1424
static int xmlXPathDebugObjMaxPoint = 0;
1425
static int xmlXPathDebugObjMaxRange = 0;
1426
static int xmlXPathDebugObjMaxLocset = 0;
1427
static int xmlXPathDebugObjMaxUsers = 0;
1428
static int xmlXPathDebugObjMaxXSLTTree = 0;
1429
static int xmlXPathDebugObjMaxAll = 0;
1430
1431
/* REVISIT TODO: Make this static when committing */
1432
static void
1433
xmlXPathDebugObjUsageReset(xmlXPathContextPtr ctxt)
1434
{
1435
if (ctxt != NULL) {
1436
if (ctxt->cache != NULL) {
1437
xmlXPathContextCachePtr cache =
1438
(xmlXPathContextCachePtr) ctxt->cache;
1439
1440
cache->dbgCachedAll = 0;
1441
cache->dbgCachedNodeset = 0;
1442
cache->dbgCachedString = 0;
1443
cache->dbgCachedBool = 0;
1444
cache->dbgCachedNumber = 0;
1445
cache->dbgCachedPoint = 0;
1446
cache->dbgCachedRange = 0;
1447
cache->dbgCachedLocset = 0;
1448
cache->dbgCachedUsers = 0;
1449
cache->dbgCachedXSLTTree = 0;
1450
cache->dbgCachedUndefined = 0;
1451
1452
cache->dbgReusedAll = 0;
1453
cache->dbgReusedNodeset = 0;
1454
cache->dbgReusedString = 0;
1455
cache->dbgReusedBool = 0;
1456
cache->dbgReusedNumber = 0;
1457
cache->dbgReusedPoint = 0;
1458
cache->dbgReusedRange = 0;
1459
cache->dbgReusedLocset = 0;
1460
cache->dbgReusedUsers = 0;
1461
cache->dbgReusedXSLTTree = 0;
1462
cache->dbgReusedUndefined = 0;
1463
}
1464
}
1465
1466
xmlXPathDebugObjCounterUndefined = 0;
1467
xmlXPathDebugObjCounterNodeset = 0;
1468
xmlXPathDebugObjCounterBool = 0;
1469
xmlXPathDebugObjCounterNumber = 0;
1470
xmlXPathDebugObjCounterString = 0;
1471
xmlXPathDebugObjCounterPoint = 0;
1472
xmlXPathDebugObjCounterRange = 0;
1473
xmlXPathDebugObjCounterLocset = 0;
1474
xmlXPathDebugObjCounterUsers = 0;
1475
xmlXPathDebugObjCounterXSLTTree = 0;
1476
xmlXPathDebugObjCounterAll = 0;
1477
1478
xmlXPathDebugObjTotalUndefined = 0;
1479
xmlXPathDebugObjTotalNodeset = 0;
1480
xmlXPathDebugObjTotalBool = 0;
1481
xmlXPathDebugObjTotalNumber = 0;
1482
xmlXPathDebugObjTotalString = 0;
1483
xmlXPathDebugObjTotalPoint = 0;
1484
xmlXPathDebugObjTotalRange = 0;
1485
xmlXPathDebugObjTotalLocset = 0;
1486
xmlXPathDebugObjTotalUsers = 0;
1487
xmlXPathDebugObjTotalXSLTTree = 0;
1488
xmlXPathDebugObjTotalAll = 0;
1489
1490
xmlXPathDebugObjMaxUndefined = 0;
1491
xmlXPathDebugObjMaxNodeset = 0;
1492
xmlXPathDebugObjMaxBool = 0;
1493
xmlXPathDebugObjMaxNumber = 0;
1494
xmlXPathDebugObjMaxString = 0;
1495
xmlXPathDebugObjMaxPoint = 0;
1496
xmlXPathDebugObjMaxRange = 0;
1497
xmlXPathDebugObjMaxLocset = 0;
1498
xmlXPathDebugObjMaxUsers = 0;
1499
xmlXPathDebugObjMaxXSLTTree = 0;
1500
xmlXPathDebugObjMaxAll = 0;
1501
1502
}
1503
1504
static void
1505
xmlXPathDebugObjUsageRequested(xmlXPathContextPtr ctxt,
1506
xmlXPathObjectType objType)
1507
{
1508
int isCached = 0;
1509
1510
if (ctxt != NULL) {
1511
if (ctxt->cache != NULL) {
1512
xmlXPathContextCachePtr cache =
1513
(xmlXPathContextCachePtr) ctxt->cache;
1514
1515
isCached = 1;
1516
1517
cache->dbgReusedAll++;
1518
switch (objType) {
1519
case XPATH_UNDEFINED:
1520
cache->dbgReusedUndefined++;
1521
break;
1522
case XPATH_NODESET:
1523
cache->dbgReusedNodeset++;
1524
break;
1525
case XPATH_BOOLEAN:
1526
cache->dbgReusedBool++;
1527
break;
1528
case XPATH_NUMBER:
1529
cache->dbgReusedNumber++;
1530
break;
1531
case XPATH_STRING:
1532
cache->dbgReusedString++;
1533
break;
1534
case XPATH_POINT:
1535
cache->dbgReusedPoint++;
1536
break;
1537
case XPATH_RANGE:
1538
cache->dbgReusedRange++;
1539
break;
1540
case XPATH_LOCATIONSET:
1541
cache->dbgReusedLocset++;
1542
break;
1543
case XPATH_USERS:
1544
cache->dbgReusedUsers++;
1545
break;
1546
case XPATH_XSLT_TREE:
1547
cache->dbgReusedXSLTTree++;
1548
break;
1549
default:
1550
break;
1551
}
1552
}
1553
}
1554
1555
switch (objType) {
1556
case XPATH_UNDEFINED:
1557
if (! isCached)
1558
xmlXPathDebugObjTotalUndefined++;
1559
xmlXPathDebugObjCounterUndefined++;
1560
if (xmlXPathDebugObjCounterUndefined >
1561
xmlXPathDebugObjMaxUndefined)
1562
xmlXPathDebugObjMaxUndefined =
1563
xmlXPathDebugObjCounterUndefined;
1564
break;
1565
case XPATH_NODESET:
1566
if (! isCached)
1567
xmlXPathDebugObjTotalNodeset++;
1568
xmlXPathDebugObjCounterNodeset++;
1569
if (xmlXPathDebugObjCounterNodeset >
1570
xmlXPathDebugObjMaxNodeset)
1571
xmlXPathDebugObjMaxNodeset =
1572
xmlXPathDebugObjCounterNodeset;
1573
break;
1574
case XPATH_BOOLEAN:
1575
if (! isCached)
1576
xmlXPathDebugObjTotalBool++;
1577
xmlXPathDebugObjCounterBool++;
1578
if (xmlXPathDebugObjCounterBool >
1579
xmlXPathDebugObjMaxBool)
1580
xmlXPathDebugObjMaxBool =
1581
xmlXPathDebugObjCounterBool;
1582
break;
1583
case XPATH_NUMBER:
1584
if (! isCached)
1585
xmlXPathDebugObjTotalNumber++;
1586
xmlXPathDebugObjCounterNumber++;
1587
if (xmlXPathDebugObjCounterNumber >
1588
xmlXPathDebugObjMaxNumber)
1589
xmlXPathDebugObjMaxNumber =
1590
xmlXPathDebugObjCounterNumber;
1591
break;
1592
case XPATH_STRING:
1593
if (! isCached)
1594
xmlXPathDebugObjTotalString++;
1595
xmlXPathDebugObjCounterString++;
1596
if (xmlXPathDebugObjCounterString >
1597
xmlXPathDebugObjMaxString)
1598
xmlXPathDebugObjMaxString =
1599
xmlXPathDebugObjCounterString;
1600
break;
1601
case XPATH_POINT:
1602
if (! isCached)
1603
xmlXPathDebugObjTotalPoint++;
1604
xmlXPathDebugObjCounterPoint++;
1605
if (xmlXPathDebugObjCounterPoint >
1606
xmlXPathDebugObjMaxPoint)
1607
xmlXPathDebugObjMaxPoint =
1608
xmlXPathDebugObjCounterPoint;
1609
break;
1610
case XPATH_RANGE:
1611
if (! isCached)
1612
xmlXPathDebugObjTotalRange++;
1613
xmlXPathDebugObjCounterRange++;
1614
if (xmlXPathDebugObjCounterRange >
1615
xmlXPathDebugObjMaxRange)
1616
xmlXPathDebugObjMaxRange =
1617
xmlXPathDebugObjCounterRange;
1618
break;
1619
case XPATH_LOCATIONSET:
1620
if (! isCached)
1621
xmlXPathDebugObjTotalLocset++;
1622
xmlXPathDebugObjCounterLocset++;
1623
if (xmlXPathDebugObjCounterLocset >
1624
xmlXPathDebugObjMaxLocset)
1625
xmlXPathDebugObjMaxLocset =
1626
xmlXPathDebugObjCounterLocset;
1627
break;
1628
case XPATH_USERS:
1629
if (! isCached)
1630
xmlXPathDebugObjTotalUsers++;
1631
xmlXPathDebugObjCounterUsers++;
1632
if (xmlXPathDebugObjCounterUsers >
1633
xmlXPathDebugObjMaxUsers)
1634
xmlXPathDebugObjMaxUsers =
1635
xmlXPathDebugObjCounterUsers;
1636
break;
1637
case XPATH_XSLT_TREE:
1638
if (! isCached)
1639
xmlXPathDebugObjTotalXSLTTree++;
1640
xmlXPathDebugObjCounterXSLTTree++;
1641
if (xmlXPathDebugObjCounterXSLTTree >
1642
xmlXPathDebugObjMaxXSLTTree)
1643
xmlXPathDebugObjMaxXSLTTree =
1644
xmlXPathDebugObjCounterXSLTTree;
1645
break;
1646
default:
1647
break;
1648
}
1649
if (! isCached)
1650
xmlXPathDebugObjTotalAll++;
1651
xmlXPathDebugObjCounterAll++;
1652
if (xmlXPathDebugObjCounterAll >
1653
xmlXPathDebugObjMaxAll)
1654
xmlXPathDebugObjMaxAll =
1655
xmlXPathDebugObjCounterAll;
1656
}
1657
1658
static void
1659
xmlXPathDebugObjUsageReleased(xmlXPathContextPtr ctxt,
1660
xmlXPathObjectType objType)
1661
{
1662
int isCached = 0;
1663
1664
if (ctxt != NULL) {
1665
if (ctxt->cache != NULL) {
1666
xmlXPathContextCachePtr cache =
1667
(xmlXPathContextCachePtr) ctxt->cache;
1668
1669
isCached = 1;
1670
1671
cache->dbgCachedAll++;
1672
switch (objType) {
1673
case XPATH_UNDEFINED:
1674
cache->dbgCachedUndefined++;
1675
break;
1676
case XPATH_NODESET:
1677
cache->dbgCachedNodeset++;
1678
break;
1679
case XPATH_BOOLEAN:
1680
cache->dbgCachedBool++;
1681
break;
1682
case XPATH_NUMBER:
1683
cache->dbgCachedNumber++;
1684
break;
1685
case XPATH_STRING:
1686
cache->dbgCachedString++;
1687
break;
1688
case XPATH_POINT:
1689
cache->dbgCachedPoint++;
1690
break;
1691
case XPATH_RANGE:
1692
cache->dbgCachedRange++;
1693
break;
1694
case XPATH_LOCATIONSET:
1695
cache->dbgCachedLocset++;
1696
break;
1697
case XPATH_USERS:
1698
cache->dbgCachedUsers++;
1699
break;
1700
case XPATH_XSLT_TREE:
1701
cache->dbgCachedXSLTTree++;
1702
break;
1703
default:
1704
break;
1705
}
1706
1707
}
1708
}
1709
switch (objType) {
1710
case XPATH_UNDEFINED:
1711
xmlXPathDebugObjCounterUndefined--;
1712
break;
1713
case XPATH_NODESET:
1714
xmlXPathDebugObjCounterNodeset--;
1715
break;
1716
case XPATH_BOOLEAN:
1717
xmlXPathDebugObjCounterBool--;
1718
break;
1719
case XPATH_NUMBER:
1720
xmlXPathDebugObjCounterNumber--;
1721
break;
1722
case XPATH_STRING:
1723
xmlXPathDebugObjCounterString--;
1724
break;
1725
case XPATH_POINT:
1726
xmlXPathDebugObjCounterPoint--;
1727
break;
1728
case XPATH_RANGE:
1729
xmlXPathDebugObjCounterRange--;
1730
break;
1731
case XPATH_LOCATIONSET:
1732
xmlXPathDebugObjCounterLocset--;
1733
break;
1734
case XPATH_USERS:
1735
xmlXPathDebugObjCounterUsers--;
1736
break;
1737
case XPATH_XSLT_TREE:
1738
xmlXPathDebugObjCounterXSLTTree--;
1739
break;
1740
default:
1741
break;
1742
}
1743
xmlXPathDebugObjCounterAll--;
1744
}
1745
1746
/* REVISIT TODO: Make this static when committing */
1747
static void
1748
xmlXPathDebugObjUsageDisplay(xmlXPathContextPtr ctxt)
1749
{
1750
int reqAll, reqNodeset, reqString, reqBool, reqNumber,
1751
reqXSLTTree, reqUndefined;
1752
int caAll = 0, caNodeset = 0, caString = 0, caBool = 0,
1753
caNumber = 0, caXSLTTree = 0, caUndefined = 0;
1754
int reAll = 0, reNodeset = 0, reString = 0, reBool = 0,
1755
reNumber = 0, reXSLTTree = 0, reUndefined = 0;
1756
int leftObjs = xmlXPathDebugObjCounterAll;
1757
1758
reqAll = xmlXPathDebugObjTotalAll;
1759
reqNodeset = xmlXPathDebugObjTotalNodeset;
1760
reqString = xmlXPathDebugObjTotalString;
1761
reqBool = xmlXPathDebugObjTotalBool;
1762
reqNumber = xmlXPathDebugObjTotalNumber;
1763
reqXSLTTree = xmlXPathDebugObjTotalXSLTTree;
1764
reqUndefined = xmlXPathDebugObjTotalUndefined;
1765
1766
printf("# XPath object usage:\n");
1767
1768
if (ctxt != NULL) {
1769
if (ctxt->cache != NULL) {
1770
xmlXPathContextCachePtr cache =
1771
(xmlXPathContextCachePtr) ctxt->cache;
1772
1773
reAll = cache->dbgReusedAll;
1774
reqAll += reAll;
1775
reNodeset = cache->dbgReusedNodeset;
1776
reqNodeset += reNodeset;
1777
reString = cache->dbgReusedString;
1778
reqString += reString;
1779
reBool = cache->dbgReusedBool;
1780
reqBool += reBool;
1781
reNumber = cache->dbgReusedNumber;
1782
reqNumber += reNumber;
1783
reXSLTTree = cache->dbgReusedXSLTTree;
1784
reqXSLTTree += reXSLTTree;
1785
reUndefined = cache->dbgReusedUndefined;
1786
reqUndefined += reUndefined;
1787
1788
caAll = cache->dbgCachedAll;
1789
caBool = cache->dbgCachedBool;
1790
caNodeset = cache->dbgCachedNodeset;
1791
caString = cache->dbgCachedString;
1792
caNumber = cache->dbgCachedNumber;
1793
caXSLTTree = cache->dbgCachedXSLTTree;
1794
caUndefined = cache->dbgCachedUndefined;
1795
1796
if (cache->nodesetObjs)
1797
leftObjs -= cache->nodesetObjs->number;
1798
if (cache->stringObjs)
1799
leftObjs -= cache->stringObjs->number;
1800
if (cache->booleanObjs)
1801
leftObjs -= cache->booleanObjs->number;
1802
if (cache->numberObjs)
1803
leftObjs -= cache->numberObjs->number;
1804
if (cache->miscObjs)
1805
leftObjs -= cache->miscObjs->number;
1806
}
1807
}
1808
1809
printf("# all\n");
1810
printf("# total : %d\n", reqAll);
1811
printf("# left : %d\n", leftObjs);
1812
printf("# created: %d\n", xmlXPathDebugObjTotalAll);
1813
printf("# reused : %d\n", reAll);
1814
printf("# max : %d\n", xmlXPathDebugObjMaxAll);
1815
1816
printf("# node-sets\n");
1817
printf("# total : %d\n", reqNodeset);
1818
printf("# created: %d\n", xmlXPathDebugObjTotalNodeset);
1819
printf("# reused : %d\n", reNodeset);
1820
printf("# max : %d\n", xmlXPathDebugObjMaxNodeset);
1821
1822
printf("# strings\n");
1823
printf("# total : %d\n", reqString);
1824
printf("# created: %d\n", xmlXPathDebugObjTotalString);
1825
printf("# reused : %d\n", reString);
1826
printf("# max : %d\n", xmlXPathDebugObjMaxString);
1827
1828
printf("# booleans\n");
1829
printf("# total : %d\n", reqBool);
1830
printf("# created: %d\n", xmlXPathDebugObjTotalBool);
1831
printf("# reused : %d\n", reBool);
1832
printf("# max : %d\n", xmlXPathDebugObjMaxBool);
1833
1834
printf("# numbers\n");
1835
printf("# total : %d\n", reqNumber);
1836
printf("# created: %d\n", xmlXPathDebugObjTotalNumber);
1837
printf("# reused : %d\n", reNumber);
1838
printf("# max : %d\n", xmlXPathDebugObjMaxNumber);
1839
1840
printf("# XSLT result tree fragments\n");
1841
printf("# total : %d\n", reqXSLTTree);
1842
printf("# created: %d\n", xmlXPathDebugObjTotalXSLTTree);
1843
printf("# reused : %d\n", reXSLTTree);
1844
printf("# max : %d\n", xmlXPathDebugObjMaxXSLTTree);
1845
1846
printf("# undefined\n");
1847
printf("# total : %d\n", reqUndefined);
1848
printf("# created: %d\n", xmlXPathDebugObjTotalUndefined);
1849
printf("# reused : %d\n", reUndefined);
1850
printf("# max : %d\n", xmlXPathDebugObjMaxUndefined);
1851
1852
}
1853
1854
#endif /* XP_DEBUG_OBJ_USAGE */
1855
1856
#endif /* LIBXML_DEBUG_ENABLED */
1857
1858
/************************************************************************
1859
* *
1860
* XPath object caching *
1861
* *
1862
************************************************************************/
1863
1864
/**
1865
* xmlXPathNewCache:
1866
*
1867
* Create a new object cache
1868
*
1869
* Returns the xmlXPathCache just allocated.
1870
*/
1871
static xmlXPathContextCachePtr
1872
xmlXPathNewCache(void)
1873
{
1874
xmlXPathContextCachePtr ret;
1875
1876
ret = (xmlXPathContextCachePtr) xmlMalloc(sizeof(xmlXPathContextCache));
1877
if (ret == NULL) {
1878
xmlXPathErrMemory(NULL, "creating object cache\n");
1879
return(NULL);
1880
}
1881
memset(ret, 0 , (size_t) sizeof(xmlXPathContextCache));
1882
ret->maxNodeset = 100;
1883
ret->maxString = 100;
1884
ret->maxBoolean = 100;
1885
ret->maxNumber = 100;
1886
ret->maxMisc = 100;
1887
return(ret);
1888
}
1889
1890
static void
1891
xmlXPathCacheFreeObjectList(xmlPointerListPtr list)
1892
{
1893
int i;
1894
xmlXPathObjectPtr obj;
1895
1896
if (list == NULL)
1897
return;
1898
1899
for (i = 0; i < list->number; i++) {
1900
obj = list->items[i];
1901
/*
1902
* Note that it is already assured that we don't need to
1903
* look out for namespace nodes in the node-set.
1904
*/
1905
if (obj->nodesetval != NULL) {
1906
if (obj->nodesetval->nodeTab != NULL)
1907
xmlFree(obj->nodesetval->nodeTab);
1908
xmlFree(obj->nodesetval);
1909
}
1910
xmlFree(obj);
1911
#ifdef XP_DEBUG_OBJ_USAGE
1912
xmlXPathDebugObjCounterAll--;
1913
#endif
1914
}
1915
xmlPointerListFree(list);
1916
}
1917
1918
static void
1919
xmlXPathFreeCache(xmlXPathContextCachePtr cache)
1920
{
1921
if (cache == NULL)
1922
return;
1923
if (cache->nodesetObjs)
1924
xmlXPathCacheFreeObjectList(cache->nodesetObjs);
1925
if (cache->stringObjs)
1926
xmlXPathCacheFreeObjectList(cache->stringObjs);
1927
if (cache->booleanObjs)
1928
xmlXPathCacheFreeObjectList(cache->booleanObjs);
1929
if (cache->numberObjs)
1930
xmlXPathCacheFreeObjectList(cache->numberObjs);
1931
if (cache->miscObjs)
1932
xmlXPathCacheFreeObjectList(cache->miscObjs);
1933
xmlFree(cache);
1934
}
1935
1936
/**
1937
* xmlXPathContextSetCache:
1938
*
1939
* @ctxt: the XPath context
1940
* @active: enables/disables (creates/frees) the cache
1941
* @value: a value with semantics dependant on @options
1942
* @options: options (currently only the value 0 is used)
1943
*
1944
* Creates/frees an object cache on the XPath context.
1945
* If activates XPath objects (xmlXPathObject) will be cached internally
1946
* to be reused.
1947
* @options:
1948
* 0: This will set the XPath object caching:
1949
* @value:
1950
* This will set the maximum number of XPath objects
1951
* to be cached per slot
1952
* There are 5 slots for: node-set, string, number, boolean, and
1953
* misc objects. Use <0 for the default number (100).
1954
* Other values for @options have currently no effect.
1955
*
1956
* Returns 0 if the setting succeeded, and -1 on API or internal errors.
1957
*/
1958
int
1959
xmlXPathContextSetCache(xmlXPathContextPtr ctxt,
1960
int active,
1961
int value,
1962
int options)
1963
{
1964
if (ctxt == NULL)
1965
return(-1);
1966
if (active) {
1967
xmlXPathContextCachePtr cache;
1968
1969
if (ctxt->cache == NULL) {
1970
ctxt->cache = xmlXPathNewCache();
1971
if (ctxt->cache == NULL)
1972
return(-1);
1973
}
1974
cache = (xmlXPathContextCachePtr) ctxt->cache;
1975
if (options == 0) {
1976
if (value < 0)
1977
value = 100;
1978
cache->maxNodeset = value;
1979
cache->maxString = value;
1980
cache->maxNumber = value;
1981
cache->maxBoolean = value;
1982
cache->maxMisc = value;
1983
}
1984
} else if (ctxt->cache != NULL) {
1985
xmlXPathFreeCache((xmlXPathContextCachePtr) ctxt->cache);
1986
ctxt->cache = NULL;
1987
}
1988
return(0);
1989
}
1990
1991
/**
1992
* xmlXPathCacheWrapNodeSet:
1993
* @ctxt: the XPath context
1994
* @val: the NodePtr value
1995
*
1996
* This is the cached version of xmlXPathWrapNodeSet().
1997
* Wrap the Nodeset @val in a new xmlXPathObjectPtr
1998
*
1999
* Returns the created or reused object.
2000
*/
2001
static xmlXPathObjectPtr
2002
xmlXPathCacheWrapNodeSet(xmlXPathContextPtr ctxt, xmlNodeSetPtr val)
2003
{
2004
if ((ctxt != NULL) && (ctxt->cache != NULL)) {
2005
xmlXPathContextCachePtr cache =
2006
(xmlXPathContextCachePtr) ctxt->cache;
2007
2008
if ((cache->miscObjs != NULL) &&
2009
(cache->miscObjs->number != 0))
2010
{
2011
xmlXPathObjectPtr ret;
2012
2013
ret = (xmlXPathObjectPtr)
2014
cache->miscObjs->items[--cache->miscObjs->number];
2015
ret->type = XPATH_NODESET;
2016
ret->nodesetval = val;
2017
#ifdef XP_DEBUG_OBJ_USAGE
2018
xmlXPathDebugObjUsageRequested(ctxt, XPATH_NODESET);
2019
#endif
2020
return(ret);
2021
}
2022
}
2023
2024
return(xmlXPathWrapNodeSet(val));
2025
2026
}
2027
2028
/**
2029
* xmlXPathCacheWrapString:
2030
* @ctxt: the XPath context
2031
* @val: the xmlChar * value
2032
*
2033
* This is the cached version of xmlXPathWrapString().
2034
* Wraps the @val string into an XPath object.
2035
*
2036
* Returns the created or reused object.
2037
*/
2038
static xmlXPathObjectPtr
2039
xmlXPathCacheWrapString(xmlXPathContextPtr ctxt, xmlChar *val)
2040
{
2041
if ((ctxt != NULL) && (ctxt->cache != NULL)) {
2042
xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache;
2043
2044
if ((cache->stringObjs != NULL) &&
2045
(cache->stringObjs->number != 0))
2046
{
2047
2048
xmlXPathObjectPtr ret;
2049
2050
ret = (xmlXPathObjectPtr)
2051
cache->stringObjs->items[--cache->stringObjs->number];
2052
ret->type = XPATH_STRING;
2053
ret->stringval = val;
2054
#ifdef XP_DEBUG_OBJ_USAGE
2055
xmlXPathDebugObjUsageRequested(ctxt, XPATH_STRING);
2056
#endif
2057
return(ret);
2058
} else if ((cache->miscObjs != NULL) &&
2059
(cache->miscObjs->number != 0))
2060
{
2061
xmlXPathObjectPtr ret;
2062
/*
2063
* Fallback to misc-cache.
2064
*/
2065
ret = (xmlXPathObjectPtr)
2066
cache->miscObjs->items[--cache->miscObjs->number];
2067
2068
ret->type = XPATH_STRING;
2069
ret->stringval = val;
2070
#ifdef XP_DEBUG_OBJ_USAGE
2071
xmlXPathDebugObjUsageRequested(ctxt, XPATH_STRING);
2072
#endif
2073
return(ret);
2074
}
2075
}
2076
return(xmlXPathWrapString(val));
2077
}
2078
2079
/**
2080
* xmlXPathCacheNewNodeSet:
2081
* @ctxt: the XPath context
2082
* @val: the NodePtr value
2083
*
2084
* This is the cached version of xmlXPathNewNodeSet().
2085
* Acquire an xmlXPathObjectPtr of type NodeSet and initialize
2086
* it with the single Node @val
2087
*
2088
* Returns the created or reused object.
2089
*/
2090
static xmlXPathObjectPtr
2091
xmlXPathCacheNewNodeSet(xmlXPathContextPtr ctxt, xmlNodePtr val)
2092
{
2093
if ((ctxt != NULL) && (ctxt->cache)) {
2094
xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache;
2095
2096
if ((cache->nodesetObjs != NULL) &&
2097
(cache->nodesetObjs->number != 0))
2098
{
2099
xmlXPathObjectPtr ret;
2100
/*
2101
* Use the nodset-cache.
2102
*/
2103
ret = (xmlXPathObjectPtr)
2104
cache->nodesetObjs->items[--cache->nodesetObjs->number];
2105
ret->type = XPATH_NODESET;
2106
ret->boolval = 0;
2107
if (val) {
2108
if ((ret->nodesetval->nodeMax == 0) ||
2109
(val->type == XML_NAMESPACE_DECL))
2110
{
2111
xmlXPathNodeSetAddUnique(ret->nodesetval, val);
2112
} else {
2113
ret->nodesetval->nodeTab[0] = val;
2114
ret->nodesetval->nodeNr = 1;
2115
}
2116
}
2117
#ifdef XP_DEBUG_OBJ_USAGE
2118
xmlXPathDebugObjUsageRequested(ctxt, XPATH_NODESET);
2119
#endif
2120
return(ret);
2121
} else if ((cache->miscObjs != NULL) &&
2122
(cache->miscObjs->number != 0))
2123
{
2124
xmlXPathObjectPtr ret;
2125
/*
2126
* Fallback to misc-cache.
2127
*/
2128
2129
ret = (xmlXPathObjectPtr)
2130
cache->miscObjs->items[--cache->miscObjs->number];
2131
2132
ret->type = XPATH_NODESET;
2133
ret->boolval = 0;
2134
ret->nodesetval = xmlXPathNodeSetCreate(val);
2135
if (ret->nodesetval == NULL) {
2136
ctxt->lastError.domain = XML_FROM_XPATH;
2137
ctxt->lastError.code = XML_ERR_NO_MEMORY;
2138
return(NULL);
2139
}
2140
#ifdef XP_DEBUG_OBJ_USAGE
2141
xmlXPathDebugObjUsageRequested(ctxt, XPATH_NODESET);
2142
#endif
2143
return(ret);
2144
}
2145
}
2146
return(xmlXPathNewNodeSet(val));
2147
}
2148
2149
/**
2150
* xmlXPathCacheNewCString:
2151
* @ctxt: the XPath context
2152
* @val: the char * value
2153
*
2154
* This is the cached version of xmlXPathNewCString().
2155
* Acquire an xmlXPathObjectPtr of type string and of value @val
2156
*
2157
* Returns the created or reused object.
2158
*/
2159
static xmlXPathObjectPtr
2160
xmlXPathCacheNewCString(xmlXPathContextPtr ctxt, const char *val)
2161
{
2162
if ((ctxt != NULL) && (ctxt->cache)) {
2163
xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache;
2164
2165
if ((cache->stringObjs != NULL) &&
2166
(cache->stringObjs->number != 0))
2167
{
2168
xmlXPathObjectPtr ret;
2169
2170
ret = (xmlXPathObjectPtr)
2171
cache->stringObjs->items[--cache->stringObjs->number];
2172
2173
ret->type = XPATH_STRING;
2174
ret->stringval = xmlStrdup(BAD_CAST val);
2175
#ifdef XP_DEBUG_OBJ_USAGE
2176
xmlXPathDebugObjUsageRequested(ctxt, XPATH_STRING);
2177
#endif
2178
return(ret);
2179
} else if ((cache->miscObjs != NULL) &&
2180
(cache->miscObjs->number != 0))
2181
{
2182
xmlXPathObjectPtr ret;
2183
2184
ret = (xmlXPathObjectPtr)
2185
cache->miscObjs->items[--cache->miscObjs->number];
2186
2187
ret->type = XPATH_STRING;
2188
ret->stringval = xmlStrdup(BAD_CAST val);
2189
#ifdef XP_DEBUG_OBJ_USAGE
2190
xmlXPathDebugObjUsageRequested(ctxt, XPATH_STRING);
2191
#endif
2192
return(ret);
2193
}
2194
}
2195
return(xmlXPathNewCString(val));
2196
}
2197
2198
/**
2199
* xmlXPathCacheNewString:
2200
* @ctxt: the XPath context
2201
* @val: the xmlChar * value
2202
*
2203
* This is the cached version of xmlXPathNewString().
2204
* Acquire an xmlXPathObjectPtr of type string and of value @val
2205
*
2206
* Returns the created or reused object.
2207
*/
2208
static xmlXPathObjectPtr
2209
xmlXPathCacheNewString(xmlXPathContextPtr ctxt, const xmlChar *val)
2210
{
2211
if ((ctxt != NULL) && (ctxt->cache)) {
2212
xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache;
2213
2214
if ((cache->stringObjs != NULL) &&
2215
(cache->stringObjs->number != 0))
2216
{
2217
xmlXPathObjectPtr ret;
2218
2219
ret = (xmlXPathObjectPtr)
2220
cache->stringObjs->items[--cache->stringObjs->number];
2221
ret->type = XPATH_STRING;
2222
if (val != NULL)
2223
ret->stringval = xmlStrdup(val);
2224
else
2225
ret->stringval = xmlStrdup((const xmlChar *)"");
2226
#ifdef XP_DEBUG_OBJ_USAGE
2227
xmlXPathDebugObjUsageRequested(ctxt, XPATH_STRING);
2228
#endif
2229
return(ret);
2230
} else if ((cache->miscObjs != NULL) &&
2231
(cache->miscObjs->number != 0))
2232
{
2233
xmlXPathObjectPtr ret;
2234
2235
ret = (xmlXPathObjectPtr)
2236
cache->miscObjs->items[--cache->miscObjs->number];
2237
2238
ret->type = XPATH_STRING;
2239
if (val != NULL)
2240
ret->stringval = xmlStrdup(val);
2241
else
2242
ret->stringval = xmlStrdup((const xmlChar *)"");
2243
#ifdef XP_DEBUG_OBJ_USAGE
2244
xmlXPathDebugObjUsageRequested(ctxt, XPATH_STRING);
2245
#endif
2246
return(ret);
2247
}
2248
}
2249
return(xmlXPathNewString(val));
2250
}
2251
2252
/**
2253
* xmlXPathCacheNewBoolean:
2254
* @ctxt: the XPath context
2255
* @val: the boolean value
2256
*
2257
* This is the cached version of xmlXPathNewBoolean().
2258
* Acquires an xmlXPathObjectPtr of type boolean and of value @val
2259
*
2260
* Returns the created or reused object.
2261
*/
2262
static xmlXPathObjectPtr
2263
xmlXPathCacheNewBoolean(xmlXPathContextPtr ctxt, int val)
2264
{
2265
if ((ctxt != NULL) && (ctxt->cache)) {
2266
xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache;
2267
2268
if ((cache->booleanObjs != NULL) &&
2269
(cache->booleanObjs->number != 0))
2270
{
2271
xmlXPathObjectPtr ret;
2272
2273
ret = (xmlXPathObjectPtr)
2274
cache->booleanObjs->items[--cache->booleanObjs->number];
2275
ret->type = XPATH_BOOLEAN;
2276
ret->boolval = (val != 0);
2277
#ifdef XP_DEBUG_OBJ_USAGE
2278
xmlXPathDebugObjUsageRequested(ctxt, XPATH_BOOLEAN);
2279
#endif
2280
return(ret);
2281
} else if ((cache->miscObjs != NULL) &&
2282
(cache->miscObjs->number != 0))
2283
{
2284
xmlXPathObjectPtr ret;
2285
2286
ret = (xmlXPathObjectPtr)
2287
cache->miscObjs->items[--cache->miscObjs->number];
2288
2289
ret->type = XPATH_BOOLEAN;
2290
ret->boolval = (val != 0);
2291
#ifdef XP_DEBUG_OBJ_USAGE
2292
xmlXPathDebugObjUsageRequested(ctxt, XPATH_BOOLEAN);
2293
#endif
2294
return(ret);
2295
}
2296
}
2297
return(xmlXPathNewBoolean(val));
2298
}
2299
2300
/**
2301
* xmlXPathCacheNewFloat:
2302
* @ctxt: the XPath context
2303
* @val: the double value
2304
*
2305
* This is the cached version of xmlXPathNewFloat().
2306
* Acquires an xmlXPathObjectPtr of type double and of value @val
2307
*
2308
* Returns the created or reused object.
2309
*/
2310
static xmlXPathObjectPtr
2311
xmlXPathCacheNewFloat(xmlXPathContextPtr ctxt, double val)
2312
{
2313
if ((ctxt != NULL) && (ctxt->cache)) {
2314
xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache;
2315
2316
if ((cache->numberObjs != NULL) &&
2317
(cache->numberObjs->number != 0))
2318
{
2319
xmlXPathObjectPtr ret;
2320
2321
ret = (xmlXPathObjectPtr)
2322
cache->numberObjs->items[--cache->numberObjs->number];
2323
ret->type = XPATH_NUMBER;
2324
ret->floatval = val;
2325
#ifdef XP_DEBUG_OBJ_USAGE
2326
xmlXPathDebugObjUsageRequested(ctxt, XPATH_NUMBER);
2327
#endif
2328
return(ret);
2329
} else if ((cache->miscObjs != NULL) &&
2330
(cache->miscObjs->number != 0))
2331
{
2332
xmlXPathObjectPtr ret;
2333
2334
ret = (xmlXPathObjectPtr)
2335
cache->miscObjs->items[--cache->miscObjs->number];
2336
2337
ret->type = XPATH_NUMBER;
2338
ret->floatval = val;
2339
#ifdef XP_DEBUG_OBJ_USAGE
2340
xmlXPathDebugObjUsageRequested(ctxt, XPATH_NUMBER);
2341
#endif
2342
return(ret);
2343
}
2344
}
2345
return(xmlXPathNewFloat(val));
2346
}
2347
2348
/**
2349
* xmlXPathCacheConvertString:
2350
* @ctxt: the XPath context
2351
* @val: an XPath object
2352
*
2353
* This is the cached version of xmlXPathConvertString().
2354
* Converts an existing object to its string() equivalent
2355
*
2356
* Returns a created or reused object, the old one is freed (cached)
2357
* (or the operation is done directly on @val)
2358
*/
2359
2360
static xmlXPathObjectPtr
2361
xmlXPathCacheConvertString(xmlXPathContextPtr ctxt, xmlXPathObjectPtr val) {
2362
xmlChar *res = NULL;
2363
2364
if (val == NULL)
2365
return(xmlXPathCacheNewCString(ctxt, ""));
2366
2367
switch (val->type) {
2368
case XPATH_UNDEFINED:
2369
#ifdef DEBUG_EXPR
2370
xmlGenericError(xmlGenericErrorContext, "STRING: undefined\n");
2371
#endif
2372
break;
2373
case XPATH_NODESET:
2374
case XPATH_XSLT_TREE:
2375
res = xmlXPathCastNodeSetToString(val->nodesetval);
2376
break;
2377
case XPATH_STRING:
2378
return(val);
2379
case XPATH_BOOLEAN:
2380
res = xmlXPathCastBooleanToString(val->boolval);
2381
break;
2382
case XPATH_NUMBER:
2383
res = xmlXPathCastNumberToString(val->floatval);
2384
break;
2385
case XPATH_USERS:
2386
case XPATH_POINT:
2387
case XPATH_RANGE:
2388
case XPATH_LOCATIONSET:
2389
TODO;
2390
break;
2391
}
2392
xmlXPathReleaseObject(ctxt, val);
2393
if (res == NULL)
2394
return(xmlXPathCacheNewCString(ctxt, ""));
2395
return(xmlXPathCacheWrapString(ctxt, res));
2396
}
2397
2398
/**
2399
* xmlXPathCacheObjectCopy:
2400
* @ctxt: the XPath context
2401
* @val: the original object
2402
*
2403
* This is the cached version of xmlXPathObjectCopy().
2404
* Acquire a copy of a given object
2405
*
2406
* Returns a created or reused created object.
2407
*/
2408
static xmlXPathObjectPtr
2409
xmlXPathCacheObjectCopy(xmlXPathContextPtr ctxt, xmlXPathObjectPtr val)
2410
{
2411
if (val == NULL)
2412
return(NULL);
2413
2414
if (XP_HAS_CACHE(ctxt)) {
2415
switch (val->type) {
2416
case XPATH_NODESET:
2417
return(xmlXPathCacheWrapNodeSet(ctxt,
2418
xmlXPathNodeSetMerge(NULL, val->nodesetval)));
2419
case XPATH_STRING:
2420
return(xmlXPathCacheNewString(ctxt, val->stringval));
2421
case XPATH_BOOLEAN:
2422
return(xmlXPathCacheNewBoolean(ctxt, val->boolval));
2423
case XPATH_NUMBER:
2424
return(xmlXPathCacheNewFloat(ctxt, val->floatval));
2425
default:
2426
break;
2427
}
2428
}
2429
return(xmlXPathObjectCopy(val));
2430
}
2431
2432
/**
2433
* xmlXPathCacheConvertBoolean:
2434
* @ctxt: the XPath context
2435
* @val: an XPath object
2436
*
2437
* This is the cached version of xmlXPathConvertBoolean().
2438
* Converts an existing object to its boolean() equivalent
2439
*
2440
* Returns a created or reused object, the old one is freed (or the operation
2441
* is done directly on @val)
2442
*/
2443
static xmlXPathObjectPtr
2444
xmlXPathCacheConvertBoolean(xmlXPathContextPtr ctxt, xmlXPathObjectPtr val) {
2445
xmlXPathObjectPtr ret;
2446
2447
if (val == NULL)
2448
return(xmlXPathCacheNewBoolean(ctxt, 0));
2449
if (val->type == XPATH_BOOLEAN)
2450
return(val);
2451
ret = xmlXPathCacheNewBoolean(ctxt, xmlXPathCastToBoolean(val));
2452
xmlXPathReleaseObject(ctxt, val);
2453
return(ret);
2454
}
2455
2456
/**
2457
* xmlXPathCacheConvertNumber:
2458
* @ctxt: the XPath context
2459
* @val: an XPath object
2460
*
2461
* This is the cached version of xmlXPathConvertNumber().
2462
* Converts an existing object to its number() equivalent
2463
*
2464
* Returns a created or reused object, the old one is freed (or the operation
2465
* is done directly on @val)
2466
*/
2467
static xmlXPathObjectPtr
2468
xmlXPathCacheConvertNumber(xmlXPathContextPtr ctxt, xmlXPathObjectPtr val) {
2469
xmlXPathObjectPtr ret;
2470
2471
if (val == NULL)
2472
return(xmlXPathCacheNewFloat(ctxt, 0.0));
2473
if (val->type == XPATH_NUMBER)
2474
return(val);
2475
ret = xmlXPathCacheNewFloat(ctxt, xmlXPathCastToNumber(val));
2476
xmlXPathReleaseObject(ctxt, val);
2477
return(ret);
2478
}
2479
2480
/************************************************************************
2481
* *
2482
* Parser stacks related functions and macros *
2483
* *
2484
************************************************************************/
2485
2486
/**
2487
* xmlXPathSetFrame:
2488
* @ctxt: an XPath parser context
2489
*
2490
* Set the callee evaluation frame
2491
*
2492
* Returns the previous frame value to be restored once done
2493
*/
2494
static int
2495
xmlXPathSetFrame(xmlXPathParserContextPtr ctxt) {
2496
int ret;
2497
2498
if (ctxt == NULL)
2499
return(0);
2500
ret = ctxt->valueFrame;
2501
ctxt->valueFrame = ctxt->valueNr;
2502
return(ret);
2503
}
2504
2505
/**
2506
* xmlXPathPopFrame:
2507
* @ctxt: an XPath parser context
2508
* @frame: the previous frame value
2509
*
2510
* Remove the callee evaluation frame
2511
*/
2512
static void
2513
xmlXPathPopFrame(xmlXPathParserContextPtr ctxt, int frame) {
2514
if (ctxt == NULL)
2515
return;
2516
if (ctxt->valueNr < ctxt->valueFrame) {
2517
xmlXPatherror(ctxt, __FILE__, __LINE__, XPATH_STACK_ERROR);
2518
}
2519
ctxt->valueFrame = frame;
2520
}
2521
2522
/**
2523
* valuePop:
2524
* @ctxt: an XPath evaluation context
2525
*
2526
* Pops the top XPath object from the value stack
2527
*
2528
* Returns the XPath object just removed
2529
*/
2530
xmlXPathObjectPtr
2531
valuePop(xmlXPathParserContextPtr ctxt)
2532
{
2533
xmlXPathObjectPtr ret;
2534
2535
if ((ctxt == NULL) || (ctxt->valueNr <= 0))
2536
return (NULL);
2537
2538
if (ctxt->valueNr <= ctxt->valueFrame) {
2539
xmlXPatherror(ctxt, __FILE__, __LINE__, XPATH_STACK_ERROR);
2540
return (NULL);
2541
}
2542
2543
ctxt->valueNr--;
2544
if (ctxt->valueNr > 0)
2545
ctxt->value = ctxt->valueTab[ctxt->valueNr - 1];
2546
else
2547
ctxt->value = NULL;
2548
ret = ctxt->valueTab[ctxt->valueNr];
2549
ctxt->valueTab[ctxt->valueNr] = NULL;
2550
return (ret);
2551
}
2552
/**
2553
* valuePush:
2554
* @ctxt: an XPath evaluation context
2555
* @value: the XPath object
2556
*
2557
* Pushes a new XPath object on top of the value stack
2558
*
2559
* returns the number of items on the value stack
2560
*/
2561
int
2562
valuePush(xmlXPathParserContextPtr ctxt, xmlXPathObjectPtr value)
2563
{
2564
if ((ctxt == NULL) || (value == NULL)) return(-1);
2565
if (ctxt->valueNr >= ctxt->valueMax) {
2566
xmlXPathObjectPtr *tmp;
2567
2568
if (ctxt->valueMax >= XPATH_MAX_STACK_DEPTH) {
2569
xmlXPathErrMemory(NULL, "XPath stack depth limit reached\n");
2570
ctxt->error = XPATH_MEMORY_ERROR;
2571
return (0);
2572
}
2573
tmp = (xmlXPathObjectPtr *) xmlRealloc(ctxt->valueTab,
2574
2 * ctxt->valueMax *
2575
sizeof(ctxt->valueTab[0]));
2576
if (tmp == NULL) {
2577
xmlXPathErrMemory(NULL, "pushing value\n");
2578
ctxt->error = XPATH_MEMORY_ERROR;
2579
return (0);
2580
}
2581
ctxt->valueMax *= 2;
2582
ctxt->valueTab = tmp;
2583
}
2584
ctxt->valueTab[ctxt->valueNr] = value;
2585
ctxt->value = value;
2586
return (ctxt->valueNr++);
2587
}
2588
2589
/**
2590
* xmlXPathPopBoolean:
2591
* @ctxt: an XPath parser context
2592
*
2593
* Pops a boolean from the stack, handling conversion if needed.
2594
* Check error with #xmlXPathCheckError.
2595
*
2596
* Returns the boolean
2597
*/
2598
int
2599
xmlXPathPopBoolean (xmlXPathParserContextPtr ctxt) {
2600
xmlXPathObjectPtr obj;
2601
int ret;
2602
2603
obj = valuePop(ctxt);
2604
if (obj == NULL) {
2605
xmlXPathSetError(ctxt, XPATH_INVALID_OPERAND);
2606
return(0);
2607
}
2608
if (obj->type != XPATH_BOOLEAN)
2609
ret = xmlXPathCastToBoolean(obj);
2610
else
2611
ret = obj->boolval;
2612
xmlXPathReleaseObject(ctxt->context, obj);
2613
return(ret);
2614
}
2615
2616
/**
2617
* xmlXPathPopNumber:
2618
* @ctxt: an XPath parser context
2619
*
2620
* Pops a number from the stack, handling conversion if needed.
2621
* Check error with #xmlXPathCheckError.
2622
*
2623
* Returns the number
2624
*/
2625
double
2626
xmlXPathPopNumber (xmlXPathParserContextPtr ctxt) {
2627
xmlXPathObjectPtr obj;
2628
double ret;
2629
2630
obj = valuePop(ctxt);
2631
if (obj == NULL) {
2632
xmlXPathSetError(ctxt, XPATH_INVALID_OPERAND);
2633
return(0);
2634
}
2635
if (obj->type != XPATH_NUMBER)
2636
ret = xmlXPathCastToNumber(obj);
2637
else
2638
ret = obj->floatval;
2639
xmlXPathReleaseObject(ctxt->context, obj);
2640
return(ret);
2641
}
2642
2643
/**
2644
* xmlXPathPopString:
2645
* @ctxt: an XPath parser context
2646
*
2647
* Pops a string from the stack, handling conversion if needed.
2648
* Check error with #xmlXPathCheckError.
2649
*
2650
* Returns the string
2651
*/
2652
xmlChar *
2653
xmlXPathPopString (xmlXPathParserContextPtr ctxt) {
2654
xmlXPathObjectPtr obj;
2655
xmlChar * ret;
2656
2657
obj = valuePop(ctxt);
2658
if (obj == NULL) {
2659
xmlXPathSetError(ctxt, XPATH_INVALID_OPERAND);
2660
return(NULL);
2661
}
2662
ret = xmlXPathCastToString(obj); /* this does required strdup */
2663
/* TODO: needs refactoring somewhere else */
2664
if (obj->stringval == ret)
2665
obj->stringval = NULL;
2666
xmlXPathReleaseObject(ctxt->context, obj);
2667
return(ret);
2668
}
2669
2670
/**
2671
* xmlXPathPopNodeSet:
2672
* @ctxt: an XPath parser context
2673
*
2674
* Pops a node-set from the stack, handling conversion if needed.
2675
* Check error with #xmlXPathCheckError.
2676
*
2677
* Returns the node-set
2678
*/
2679
xmlNodeSetPtr
2680
xmlXPathPopNodeSet (xmlXPathParserContextPtr ctxt) {
2681
xmlXPathObjectPtr obj;
2682
xmlNodeSetPtr ret;
2683
2684
if (ctxt == NULL) return(NULL);
2685
if (ctxt->value == NULL) {
2686
xmlXPathSetError(ctxt, XPATH_INVALID_OPERAND);
2687
return(NULL);
2688
}
2689
if (!xmlXPathStackIsNodeSet(ctxt)) {
2690
xmlXPathSetTypeError(ctxt);
2691
return(NULL);
2692
}
2693
obj = valuePop(ctxt);
2694
ret = obj->nodesetval;
2695
#if 0
2696
/* to fix memory leak of not clearing obj->user */
2697
if (obj->boolval && obj->user != NULL)
2698
xmlFreeNodeList((xmlNodePtr) obj->user);
2699
#endif
2700
obj->nodesetval = NULL;
2701
xmlXPathReleaseObject(ctxt->context, obj);
2702
return(ret);
2703
}
2704
2705
/**
2706
* xmlXPathPopExternal:
2707
* @ctxt: an XPath parser context
2708
*
2709
* Pops an external object from the stack, handling conversion if needed.
2710
* Check error with #xmlXPathCheckError.
2711
*
2712
* Returns the object
2713
*/
2714
void *
2715
xmlXPathPopExternal (xmlXPathParserContextPtr ctxt) {
2716
xmlXPathObjectPtr obj;
2717
void * ret;
2718
2719
if ((ctxt == NULL) || (ctxt->value == NULL)) {
2720
xmlXPathSetError(ctxt, XPATH_INVALID_OPERAND);
2721
return(NULL);
2722
}
2723
if (ctxt->value->type != XPATH_USERS) {
2724
xmlXPathSetTypeError(ctxt);
2725
return(NULL);
2726
}
2727
obj = valuePop(ctxt);
2728
ret = obj->user;
2729
obj->user = NULL;
2730
xmlXPathReleaseObject(ctxt->context, obj);
2731
return(ret);
2732
}
2733
2734
/*
2735
* Macros for accessing the content. Those should be used only by the parser,
2736
* and not exported.
2737
*
2738
* Dirty macros, i.e. one need to make assumption on the context to use them
2739
*
2740
* CUR_PTR return the current pointer to the xmlChar to be parsed.
2741
* CUR returns the current xmlChar value, i.e. a 8 bit value
2742
* in ISO-Latin or UTF-8.
2743
* This should be used internally by the parser
2744
* only to compare to ASCII values otherwise it would break when
2745
* running with UTF-8 encoding.
2746
* NXT(n) returns the n'th next xmlChar. Same as CUR is should be used only
2747
* to compare on ASCII based substring.
2748
* SKIP(n) Skip n xmlChar, and must also be used only to skip ASCII defined
2749
* strings within the parser.
2750
* CURRENT Returns the current char value, with the full decoding of
2751
* UTF-8 if we are using this mode. It returns an int.
2752
* NEXT Skip to the next character, this does the proper decoding
2753
* in UTF-8 mode. It also pop-up unfinished entities on the fly.
2754
* It returns the pointer to the current xmlChar.
2755
*/
2756
2757
#define CUR (*ctxt->cur)
2758
#define SKIP(val) ctxt->cur += (val)
2759
#define NXT(val) ctxt->cur[(val)]
2760
#define CUR_PTR ctxt->cur
2761
#define CUR_CHAR(l) xmlXPathCurrentChar(ctxt, &l)
2762
2763
#define COPY_BUF(l,b,i,v) \
2764
if (l == 1) b[i++] = (xmlChar) v; \
2765
else i += xmlCopyChar(l,&b[i],v)
2766
2767
#define NEXTL(l) ctxt->cur += l
2768
2769
#define SKIP_BLANKS \
2770
while (IS_BLANK_CH(*(ctxt->cur))) NEXT
2771
2772
#define CURRENT (*ctxt->cur)
2773
#define NEXT ((*ctxt->cur) ? ctxt->cur++: ctxt->cur)
2774
2775
2776
#ifndef DBL_DIG
2777
#define DBL_DIG 16
2778
#endif
2779
#ifndef DBL_EPSILON
2780
#define DBL_EPSILON 1E-9
2781
#endif
2782
2783
#define UPPER_DOUBLE 1E9
2784
#define LOWER_DOUBLE 1E-5
2785
#define LOWER_DOUBLE_EXP 5
2786
2787
#define INTEGER_DIGITS DBL_DIG
2788
#define FRACTION_DIGITS (DBL_DIG + 1 + (LOWER_DOUBLE_EXP))
2789
#define EXPONENT_DIGITS (3 + 2)
2790
2791
/**
2792
* xmlXPathFormatNumber:
2793
* @number: number to format
2794
* @buffer: output buffer
2795
* @buffersize: size of output buffer
2796
*
2797
* Convert the number into a string representation.
2798
*/
2799
static void
2800
xmlXPathFormatNumber(double number, char buffer[], int buffersize)
2801
{
2802
switch (xmlXPathIsInf(number)) {
2803
case 1:
2804
if (buffersize > (int)sizeof("Infinity"))
2805
snprintf(buffer, buffersize, "Infinity");
2806
break;
2807
case -1:
2808
if (buffersize > (int)sizeof("-Infinity"))
2809
snprintf(buffer, buffersize, "-Infinity");
2810
break;
2811
default:
2812
if (xmlXPathIsNaN(number)) {
2813
if (buffersize > (int)sizeof("NaN"))
2814
snprintf(buffer, buffersize, "NaN");
2815
} else if (number == 0 && xmlXPathGetSign(number) != 0) {
2816
snprintf(buffer, buffersize, "0");
2817
} else if (number == ((int) number)) {
2818
char work[30];
2819
char *ptr, *cur;
2820
int value = (int) number;
2821
2822
ptr = &buffer[0];
2823
if (value == 0) {
2824
*ptr++ = '0';
2825
} else {
2826
snprintf(work, 29, "%d", value);
2827
cur = &work[0];
2828
while ((*cur) && (ptr - buffer < buffersize)) {
2829
*ptr++ = *cur++;
2830
}
2831
}
2832
if (ptr - buffer < buffersize) {
2833
*ptr = 0;
2834
} else if (buffersize > 0) {
2835
ptr--;
2836
*ptr = 0;
2837
}
2838
} else {
2839
/*
2840
For the dimension of work,
2841
DBL_DIG is number of significant digits
2842
EXPONENT is only needed for "scientific notation"
2843
3 is sign, decimal point, and terminating zero
2844
LOWER_DOUBLE_EXP is max number of leading zeroes in fraction
2845
Note that this dimension is slightly (a few characters)
2846
larger than actually necessary.
2847
*/
2848
char work[DBL_DIG + EXPONENT_DIGITS + 3 + LOWER_DOUBLE_EXP];
2849
int integer_place, fraction_place;
2850
char *ptr;
2851
char *after_fraction;
2852
double absolute_value;
2853
int size;
2854
2855
absolute_value = fabs(number);
2856
2857
/*
2858
* First choose format - scientific or regular floating point.
2859
* In either case, result is in work, and after_fraction points
2860
* just past the fractional part.
2861
*/
2862
if ( ((absolute_value > UPPER_DOUBLE) ||
2863
(absolute_value < LOWER_DOUBLE)) &&
2864
(absolute_value != 0.0) ) {
2865
/* Use scientific notation */
2866
integer_place = DBL_DIG + EXPONENT_DIGITS + 1;
2867
fraction_place = DBL_DIG - 1;
2868
size = snprintf(work, sizeof(work),"%*.*e",
2869
integer_place, fraction_place, number);
2870
while ((size > 0) && (work[size] != 'e')) size--;
2871
2872
}
2873
else {
2874
/* Use regular notation */
2875
if (absolute_value > 0.0) {
2876
integer_place = (int)log10(absolute_value);
2877
if (integer_place > 0)
2878
fraction_place = DBL_DIG - integer_place - 1;
2879
else
2880
fraction_place = DBL_DIG - integer_place;
2881
} else {
2882
fraction_place = 1;
2883
}
2884
size = snprintf(work, sizeof(work), "%0.*f",
2885
fraction_place, number);
2886
}
2887
2888
/* Remove fractional trailing zeroes */
2889
after_fraction = work + size;
2890
ptr = after_fraction;
2891
while (*(--ptr) == '0')
2892
;
2893
if (*ptr != '.')
2894
ptr++;
2895
while ((*ptr++ = *after_fraction++) != 0);
2896
2897
/* Finally copy result back to caller */
2898
size = strlen(work) + 1;
2899
if (size > buffersize) {
2900
work[buffersize - 1] = 0;
2901
size = buffersize;
2902
}
2903
memmove(buffer, work, size);
2904
}
2905
break;
2906
}
2907
}
2908
2909
2910
/************************************************************************
2911
* *
2912
* Routines to handle NodeSets *
2913
* *
2914
************************************************************************/
2915
2916
/**
2917
* xmlXPathOrderDocElems:
2918
* @doc: an input document
2919
*
2920
* Call this routine to speed up XPath computation on static documents.
2921
* This stamps all the element nodes with the document order
2922
* Like for line information, the order is kept in the element->content
2923
* field, the value stored is actually - the node number (starting at -1)
2924
* to be able to differentiate from line numbers.
2925
*
2926
* Returns the number of elements found in the document or -1 in case
2927
* of error.
2928
*/
2929
long
2930
xmlXPathOrderDocElems(xmlDocPtr doc) {
2931
long count = 0;
2932
xmlNodePtr cur;
2933
2934
if (doc == NULL)
2935
return(-1);
2936
cur = doc->children;
2937
while (cur != NULL) {
2938
if (cur->type == XML_ELEMENT_NODE) {
2939
cur->content = (void *) (-(++count));
2940
if (cur->children != NULL) {
2941
cur = cur->children;
2942
continue;
2943
}
2944
}
2945
if (cur->next != NULL) {
2946
cur = cur->next;
2947
continue;
2948
}
2949
do {
2950
cur = cur->parent;
2951
if (cur == NULL)
2952
break;
2953
if (cur == (xmlNodePtr) doc) {
2954
cur = NULL;
2955
break;
2956
}
2957
if (cur->next != NULL) {
2958
cur = cur->next;
2959
break;
2960
}
2961
} while (cur != NULL);
2962
}
2963
return(count);
2964
}
2965
2966
/**
2967
* xmlXPathCmpNodes:
2968
* @node1: the first node
2969
* @node2: the second node
2970
*
2971
* Compare two nodes w.r.t document order
2972
*
2973
* Returns -2 in case of error 1 if first point < second point, 0 if
2974
* it's the same node, -1 otherwise
2975
*/
2976
int
2977
xmlXPathCmpNodes(xmlNodePtr node1, xmlNodePtr node2) {
2978
int depth1, depth2;
2979
int attr1 = 0, attr2 = 0;
2980
xmlNodePtr attrNode1 = NULL, attrNode2 = NULL;
2981
xmlNodePtr cur, root;
2982
2983
if ((node1 == NULL) || (node2 == NULL))
2984
return(-2);
2985
/*
2986
* a couple of optimizations which will avoid computations in most cases
2987
*/
2988
if (node1 == node2) /* trivial case */
2989
return(0);
2990
if (node1->type == XML_ATTRIBUTE_NODE) {
2991
attr1 = 1;
2992
attrNode1 = node1;
2993
node1 = node1->parent;
2994
}
2995
if (node2->type == XML_ATTRIBUTE_NODE) {
2996
attr2 = 1;
2997
attrNode2 = node2;
2998
node2 = node2->parent;
2999
}
3000
if (node1 == node2) {
3001
if (attr1 == attr2) {
3002
/* not required, but we keep attributes in order */
3003
if (attr1 != 0) {
3004
cur = attrNode2->prev;
3005
while (cur != NULL) {
3006
if (cur == attrNode1)
3007
return (1);
3008
cur = cur->prev;
3009
}
3010
return (-1);
3011
}
3012
return(0);
3013
}
3014
if (attr2 == 1)
3015
return(1);
3016
return(-1);
3017
}
3018
if ((node1->type == XML_NAMESPACE_DECL) ||
3019
(node2->type == XML_NAMESPACE_DECL))
3020
return(1);
3021
if (node1 == node2->prev)
3022
return(1);
3023
if (node1 == node2->next)
3024
return(-1);
3025
3026
/*
3027
* Speedup using document order if availble.
3028
*/
3029
if ((node1->type == XML_ELEMENT_NODE) &&
3030
(node2->type == XML_ELEMENT_NODE) &&
3031
(0 > (long) node1->content) &&
3032
(0 > (long) node2->content) &&
3033
(node1->doc == node2->doc)) {
3034
long l1, l2;
3035
3036
l1 = -((long) node1->content);
3037
l2 = -((long) node2->content);
3038
if (l1 < l2)
3039
return(1);
3040
if (l1 > l2)
3041
return(-1);
3042
}
3043
3044
/*
3045
* compute depth to root
3046
*/
3047
for (depth2 = 0, cur = node2;cur->parent != NULL;cur = cur->parent) {
3048
if (cur == node1)
3049
return(1);
3050
depth2++;
3051
}
3052
root = cur;
3053
for (depth1 = 0, cur = node1;cur->parent != NULL;cur = cur->parent) {
3054
if (cur == node2)
3055
return(-1);
3056
depth1++;
3057
}
3058
/*
3059
* Distinct document (or distinct entities :-( ) case.
3060
*/
3061
if (root != cur) {
3062
return(-2);
3063
}
3064
/*
3065
* get the nearest common ancestor.
3066
*/
3067
while (depth1 > depth2) {
3068
depth1--;
3069
node1 = node1->parent;
3070
}
3071
while (depth2 > depth1) {
3072
depth2--;
3073
node2 = node2->parent;
3074
}
3075
while (node1->parent != node2->parent) {
3076
node1 = node1->parent;
3077
node2 = node2->parent;
3078
/* should not happen but just in case ... */
3079
if ((node1 == NULL) || (node2 == NULL))
3080
return(-2);
3081
}
3082
/*
3083
* Find who's first.
3084
*/
3085
if (node1 == node2->prev)
3086
return(1);
3087
if (node1 == node2->next)
3088
return(-1);
3089
/*
3090
* Speedup using document order if availble.
3091
*/
3092
if ((node1->type == XML_ELEMENT_NODE) &&
3093
(node2->type == XML_ELEMENT_NODE) &&
3094
(0 > (long) node1->content) &&
3095
(0 > (long) node2->content) &&
3096
(node1->doc == node2->doc)) {
3097
long l1, l2;
3098
3099
l1 = -((long) node1->content);
3100
l2 = -((long) node2->content);
3101
if (l1 < l2)
3102
return(1);
3103
if (l1 > l2)
3104
return(-1);
3105
}
3106
3107
for (cur = node1->next;cur != NULL;cur = cur->next)
3108
if (cur == node2)
3109
return(1);
3110
return(-1); /* assume there is no sibling list corruption */
3111
}
3112
3113
#ifdef XP_OPTIMIZED_NON_ELEM_COMPARISON
3114
/**
3115
* xmlXPathCmpNodesExt:
3116
* @node1: the first node
3117
* @node2: the second node
3118
*
3119
* Compare two nodes w.r.t document order.
3120
* This one is optimized for handling of non-element nodes.
3121
*
3122
* Returns -2 in case of error 1 if first point < second point, 0 if
3123
* it's the same node, -1 otherwise
3124
*/
3125
static int
3126
xmlXPathCmpNodesExt(xmlNodePtr node1, xmlNodePtr node2) {
3127
int depth1, depth2;
3128
int misc = 0, precedence1 = 0, precedence2 = 0;
3129
xmlNodePtr miscNode1 = NULL, miscNode2 = NULL;
3130
xmlNodePtr cur, root;
3131
long l1, l2;
3132
3133
if ((node1 == NULL) || (node2 == NULL))
3134
return(-2);
3135
3136
if (node1 == node2)
3137
return(0);
3138
3139
/*
3140
* a couple of optimizations which will avoid computations in most cases
3141
*/
3142
switch (node1->type) {
3143
case XML_ELEMENT_NODE:
3144
if (node2->type == XML_ELEMENT_NODE) {
3145
if ((0 > (long) node1->content) && /* TODO: Would a != 0 suffice here? */
3146
(0 > (long) node2->content) &&
3147
(node1->doc == node2->doc))
3148
{
3149
l1 = -((long) node1->content);
3150
l2 = -((long) node2->content);
3151
if (l1 < l2)
3152
return(1);
3153
if (l1 > l2)
3154
return(-1);
3155
} else
3156
goto turtle_comparison;
3157
}
3158
break;
3159
case XML_ATTRIBUTE_NODE:
3160
precedence1 = 1; /* element is owner */
3161
miscNode1 = node1;
3162
node1 = node1->parent;
3163
misc = 1;
3164
break;
3165
case XML_TEXT_NODE:
3166
case XML_CDATA_SECTION_NODE:
3167
case XML_COMMENT_NODE:
3168
case XML_PI_NODE: {
3169
miscNode1 = node1;
3170
/*
3171
* Find nearest element node.
3172
*/
3173
if (node1->prev != NULL) {
3174
do {
3175
node1 = node1->prev;
3176
if (node1->type == XML_ELEMENT_NODE) {
3177
precedence1 = 3; /* element in prev-sibl axis */
3178
break;
3179
}
3180
if (node1->prev == NULL) {
3181
precedence1 = 2; /* element is parent */
3182
/*
3183
* URGENT TODO: Are there any cases, where the
3184
* parent of such a node is not an element node?
3185
*/
3186
node1 = node1->parent;
3187
break;
3188
}
3189
} while (1);
3190
} else {
3191
precedence1 = 2; /* element is parent */
3192
node1 = node1->parent;
3193
}
3194
if ((node1 == NULL) || (node1->type != XML_ELEMENT_NODE) ||
3195
(0 <= (long) node1->content)) {
3196
/*
3197
* Fallback for whatever case.
3198
*/
3199
node1 = miscNode1;
3200
precedence1 = 0;
3201
} else
3202
misc = 1;
3203
}
3204
break;
3205
case XML_NAMESPACE_DECL:
3206
/*
3207
* TODO: why do we return 1 for namespace nodes?
3208
*/
3209
return(1);
3210
default:
3211
break;
3212
}
3213
switch (node2->type) {
3214
case XML_ELEMENT_NODE:
3215
break;
3216
case XML_ATTRIBUTE_NODE:
3217
precedence2 = 1; /* element is owner */
3218
miscNode2 = node2;
3219
node2 = node2->parent;
3220
misc = 1;
3221
break;
3222
case XML_TEXT_NODE:
3223
case XML_CDATA_SECTION_NODE:
3224
case XML_COMMENT_NODE:
3225
case XML_PI_NODE: {
3226
miscNode2 = node2;
3227
if (node2->prev != NULL) {
3228
do {
3229
node2 = node2->prev;
3230
if (node2->type == XML_ELEMENT_NODE) {
3231
precedence2 = 3; /* element in prev-sibl axis */
3232
break;
3233
}
3234
if (node2->prev == NULL) {
3235
precedence2 = 2; /* element is parent */
3236
node2 = node2->parent;
3237
break;
3238
}
3239
} while (1);
3240
} else {
3241
precedence2 = 2; /* element is parent */
3242
node2 = node2->parent;
3243
}
3244
if ((node2 == NULL) || (node2->type != XML_ELEMENT_NODE) ||
3245
(0 <= (long) node1->content))
3246
{
3247
node2 = miscNode2;
3248
precedence2 = 0;
3249
} else
3250
misc = 1;
3251
}
3252
break;
3253
case XML_NAMESPACE_DECL:
3254
return(1);
3255
default:
3256
break;
3257
}
3258
if (misc) {
3259
if (node1 == node2) {
3260
if (precedence1 == precedence2) {
3261
/*
3262
* The ugly case; but normally there aren't many
3263
* adjacent non-element nodes around.
3264
*/
3265
cur = miscNode2->prev;
3266
while (cur != NULL) {
3267
if (cur == miscNode1)
3268
return(1);
3269
if (cur->type == XML_ELEMENT_NODE)
3270
return(-1);
3271
cur = cur->prev;
3272
}
3273
return (-1);
3274
} else {
3275
/*
3276
* Evaluate based on higher precedence wrt to the element.
3277
* TODO: This assumes attributes are sorted before content.
3278
* Is this 100% correct?
3279
*/
3280
if (precedence1 < precedence2)
3281
return(1);
3282
else
3283
return(-1);
3284
}
3285
}
3286
/*
3287
* Special case: One of the helper-elements is contained by the other.
3288
* <foo>
3289
* <node2>
3290
* <node1>Text-1(precedence1 == 2)</node1>
3291
* </node2>
3292
* Text-6(precedence2 == 3)
3293
* </foo>
3294
*/
3295
if ((precedence2 == 3) && (precedence1 > 1)) {
3296
cur = node1->parent;
3297
while (cur) {
3298
if (cur == node2)
3299
return(1);
3300
cur = cur->parent;
3301
}
3302
}
3303
if ((precedence1 == 3) && (precedence2 > 1)) {
3304
cur = node2->parent;
3305
while (cur) {
3306
if (cur == node1)
3307
return(-1);
3308
cur = cur->parent;
3309
}
3310
}
3311
}
3312
3313
/*
3314
* Speedup using document order if availble.
3315
*/
3316
if ((node1->type == XML_ELEMENT_NODE) &&
3317
(node2->type == XML_ELEMENT_NODE) &&
3318
(0 > (long) node1->content) &&
3319
(0 > (long) node2->content) &&
3320
(node1->doc == node2->doc)) {
3321
3322
l1 = -((long) node1->content);
3323
l2 = -((long) node2->content);
3324
if (l1 < l2)
3325
return(1);
3326
if (l1 > l2)
3327
return(-1);
3328
}
3329
3330
turtle_comparison:
3331
3332
if (node1 == node2->prev)
3333
return(1);
3334
if (node1 == node2->next)
3335
return(-1);
3336
/*
3337
* compute depth to root
3338
*/
3339
for (depth2 = 0, cur = node2;cur->parent != NULL;cur = cur->parent) {
3340
if (cur == node1)
3341
return(1);
3342
depth2++;
3343
}
3344
root = cur;
3345
for (depth1 = 0, cur = node1;cur->parent != NULL;cur = cur->parent) {
3346
if (cur == node2)
3347
return(-1);
3348
depth1++;
3349
}
3350
/*
3351
* Distinct document (or distinct entities :-( ) case.
3352
*/
3353
if (root != cur) {
3354
return(-2);
3355
}
3356
/*
3357
* get the nearest common ancestor.
3358
*/
3359
while (depth1 > depth2) {
3360
depth1--;
3361
node1 = node1->parent;
3362
}
3363
while (depth2 > depth1) {
3364
depth2--;
3365
node2 = node2->parent;
3366
}
3367
while (node1->parent != node2->parent) {
3368
node1 = node1->parent;
3369
node2 = node2->parent;
3370
/* should not happen but just in case ... */
3371
if ((node1 == NULL) || (node2 == NULL))
3372
return(-2);
3373
}
3374
/*
3375
* Find who's first.
3376
*/
3377
if (node1 == node2->prev)
3378
return(1);
3379
if (node1 == node2->next)
3380
return(-1);
3381
/*
3382
* Speedup using document order if availble.
3383
*/
3384
if ((node1->type == XML_ELEMENT_NODE) &&
3385
(node2->type == XML_ELEMENT_NODE) &&
3386
(0 > (long) node1->content) &&
3387
(0 > (long) node2->content) &&
3388
(node1->doc == node2->doc)) {
3389
3390
l1 = -((long) node1->content);
3391
l2 = -((long) node2->content);
3392
if (l1 < l2)
3393
return(1);
3394
if (l1 > l2)
3395
return(-1);
3396
}
3397
3398
for (cur = node1->next;cur != NULL;cur = cur->next)
3399
if (cur == node2)
3400
return(1);
3401
return(-1); /* assume there is no sibling list corruption */
3402
}
3403
#endif /* XP_OPTIMIZED_NON_ELEM_COMPARISON */
3404
3405
/**
3406
* xmlXPathNodeSetSort:
3407
* @set: the node set
3408
*
3409
* Sort the node set in document order
3410
*/
3411
void
3412
xmlXPathNodeSetSort(xmlNodeSetPtr set) {
3413
#ifndef WITH_TIM_SORT
3414
int i, j, incr, len;
3415
xmlNodePtr tmp;
3416
#endif
3417
3418
if (set == NULL)
3419
return;
3420
3421
#ifndef WITH_TIM_SORT
3422
/*
3423
* Use the old Shell's sort implementation to sort the node-set
3424
* Timsort ought to be quite faster
3425
*/
3426
len = set->nodeNr;
3427
for (incr = len / 2; incr > 0; incr /= 2) {
3428
for (i = incr; i < len; i++) {
3429
j = i - incr;
3430
while (j >= 0) {
3431
#ifdef XP_OPTIMIZED_NON_ELEM_COMPARISON
3432
if (xmlXPathCmpNodesExt(set->nodeTab[j],
3433
set->nodeTab[j + incr]) == -1)
3434
#else
3435
if (xmlXPathCmpNodes(set->nodeTab[j],
3436
set->nodeTab[j + incr]) == -1)
3437
#endif
3438
{
3439
tmp = set->nodeTab[j];
3440
set->nodeTab[j] = set->nodeTab[j + incr];
3441
set->nodeTab[j + incr] = tmp;
3442
j -= incr;
3443
} else
3444
break;
3445
}
3446
}
3447
}
3448
#else /* WITH_TIM_SORT */
3449
libxml_domnode_tim_sort(set->nodeTab, set->nodeNr);
3450
#endif /* WITH_TIM_SORT */
3451
}
3452
3453
#define XML_NODESET_DEFAULT 10
3454
/**
3455
* xmlXPathNodeSetDupNs:
3456
* @node: the parent node of the namespace XPath node
3457
* @ns: the libxml namespace declaration node.
3458
*
3459
* Namespace node in libxml don't match the XPath semantic. In a node set
3460
* the namespace nodes are duplicated and the next pointer is set to the
3461
* parent node in the XPath semantic.
3462
*
3463
* Returns the newly created object.
3464
*/
3465
static xmlNodePtr
3466
xmlXPathNodeSetDupNs(xmlNodePtr node, xmlNsPtr ns) {
3467
xmlNsPtr cur;
3468
3469
if ((ns == NULL) || (ns->type != XML_NAMESPACE_DECL))
3470
return(NULL);
3471
if ((node == NULL) || (node->type == XML_NAMESPACE_DECL))
3472
return((xmlNodePtr) ns);
3473
3474
/*
3475
* Allocate a new Namespace and fill the fields.
3476
*/
3477
cur = (xmlNsPtr) xmlMalloc(sizeof(xmlNs));
3478
if (cur == NULL) {
3479
xmlXPathErrMemory(NULL, "duplicating namespace\n");
3480
return(NULL);
3481
}
3482
memset(cur, 0, sizeof(xmlNs));
3483
cur->type = XML_NAMESPACE_DECL;
3484
if (ns->href != NULL)
3485
cur->href = xmlStrdup(ns->href);
3486
if (ns->prefix != NULL)
3487
cur->prefix = xmlStrdup(ns->prefix);
3488
cur->next = (xmlNsPtr) node;
3489
return((xmlNodePtr) cur);
3490
}
3491
3492
/**
3493
* xmlXPathNodeSetFreeNs:
3494
* @ns: the XPath namespace node found in a nodeset.
3495
*
3496
* Namespace nodes in libxml don't match the XPath semantic. In a node set
3497
* the namespace nodes are duplicated and the next pointer is set to the
3498
* parent node in the XPath semantic. Check if such a node needs to be freed
3499
*/
3500
void
3501
xmlXPathNodeSetFreeNs(xmlNsPtr ns) {
3502
if ((ns == NULL) || (ns->type != XML_NAMESPACE_DECL))
3503
return;
3504
3505
if ((ns->next != NULL) && (ns->next->type != XML_NAMESPACE_DECL)) {
3506
if (ns->href != NULL)
3507
xmlFree((xmlChar *)ns->href);
3508
if (ns->prefix != NULL)
3509
xmlFree((xmlChar *)ns->prefix);
3510
xmlFree(ns);
3511
}
3512
}
3513
3514
/**
3515
* xmlXPathNodeSetCreate:
3516
* @val: an initial xmlNodePtr, or NULL
3517
*
3518
* Create a new xmlNodeSetPtr of type double and of value @val
3519
*
3520
* Returns the newly created object.
3521
*/
3522
xmlNodeSetPtr
3523
xmlXPathNodeSetCreate(xmlNodePtr val) {
3524
xmlNodeSetPtr ret;
3525
3526
ret = (xmlNodeSetPtr) xmlMalloc(sizeof(xmlNodeSet));
3527
if (ret == NULL) {
3528
xmlXPathErrMemory(NULL, "creating nodeset\n");
3529
return(NULL);
3530
}
3531
memset(ret, 0 , (size_t) sizeof(xmlNodeSet));
3532
if (val != NULL) {
3533
ret->nodeTab = (xmlNodePtr *) xmlMalloc(XML_NODESET_DEFAULT *
3534
sizeof(xmlNodePtr));
3535
if (ret->nodeTab == NULL) {
3536
xmlXPathErrMemory(NULL, "creating nodeset\n");
3537
xmlFree(ret);
3538
return(NULL);
3539
}
3540
memset(ret->nodeTab, 0 ,
3541
XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
3542
ret->nodeMax = XML_NODESET_DEFAULT;
3543
if (val->type == XML_NAMESPACE_DECL) {
3544
xmlNsPtr ns = (xmlNsPtr) val;
3545
3546
ret->nodeTab[ret->nodeNr++] =
3547
xmlXPathNodeSetDupNs((xmlNodePtr) ns->next, ns);
3548
} else
3549
ret->nodeTab[ret->nodeNr++] = val;
3550
}
3551
return(ret);
3552
}
3553
3554
/**
3555
* xmlXPathNodeSetCreateSize:
3556
* @size: the initial size of the set
3557
*
3558
* Create a new xmlNodeSetPtr of type double and of value @val
3559
*
3560
* Returns the newly created object.
3561
*/
3562
static xmlNodeSetPtr
3563
xmlXPathNodeSetCreateSize(int size) {
3564
xmlNodeSetPtr ret;
3565
3566
ret = (xmlNodeSetPtr) xmlMalloc(sizeof(xmlNodeSet));
3567
if (ret == NULL) {
3568
xmlXPathErrMemory(NULL, "creating nodeset\n");
3569
return(NULL);
3570
}
3571
memset(ret, 0 , (size_t) sizeof(xmlNodeSet));
3572
if (size < XML_NODESET_DEFAULT)
3573
size = XML_NODESET_DEFAULT;
3574
ret->nodeTab = (xmlNodePtr *) xmlMalloc(size * sizeof(xmlNodePtr));
3575
if (ret->nodeTab == NULL) {
3576
xmlXPathErrMemory(NULL, "creating nodeset\n");
3577
xmlFree(ret);
3578
return(NULL);
3579
}
3580
memset(ret->nodeTab, 0 , size * (size_t) sizeof(xmlNodePtr));
3581
ret->nodeMax = size;
3582
return(ret);
3583
}
3584
3585
/**
3586
* xmlXPathNodeSetContains:
3587
* @cur: the node-set
3588
* @val: the node
3589
*
3590
* checks whether @cur contains @val
3591
*
3592
* Returns true (1) if @cur contains @val, false (0) otherwise
3593
*/
3594
int
3595
xmlXPathNodeSetContains (xmlNodeSetPtr cur, xmlNodePtr val) {
3596
int i;
3597
3598
if ((cur == NULL) || (val == NULL)) return(0);
3599
if (val->type == XML_NAMESPACE_DECL) {
3600
for (i = 0; i < cur->nodeNr; i++) {
3601
if (cur->nodeTab[i]->type == XML_NAMESPACE_DECL) {
3602
xmlNsPtr ns1, ns2;
3603
3604
ns1 = (xmlNsPtr) val;
3605
ns2 = (xmlNsPtr) cur->nodeTab[i];
3606
if (ns1 == ns2)
3607
return(1);
3608
if ((ns1->next != NULL) && (ns2->next == ns1->next) &&
3609
(xmlStrEqual(ns1->prefix, ns2->prefix)))
3610
return(1);
3611
}
3612
}
3613
} else {
3614
for (i = 0; i < cur->nodeNr; i++) {
3615
if (cur->nodeTab[i] == val)
3616
return(1);
3617
}
3618
}
3619
return(0);
3620
}
3621
3622
/**
3623
* xmlXPathNodeSetAddNs:
3624
* @cur: the initial node set
3625
* @node: the hosting node
3626
* @ns: a the namespace node
3627
*
3628
* add a new namespace node to an existing NodeSet
3629
*
3630
* Returns 0 in case of success and -1 in case of error
3631
*/
3632
int
3633
xmlXPathNodeSetAddNs(xmlNodeSetPtr cur, xmlNodePtr node, xmlNsPtr ns) {
3634
int i;
3635
3636
3637
if ((cur == NULL) || (ns == NULL) || (node == NULL) ||
3638
(ns->type != XML_NAMESPACE_DECL) ||
3639
(node->type != XML_ELEMENT_NODE))
3640
return(-1);
3641
3642
/* @@ with_ns to check whether namespace nodes should be looked at @@ */
3643
/*
3644
* prevent duplicates
3645
*/
3646
for (i = 0;i < cur->nodeNr;i++) {
3647
if ((cur->nodeTab[i] != NULL) &&
3648
(cur->nodeTab[i]->type == XML_NAMESPACE_DECL) &&
3649
(((xmlNsPtr)cur->nodeTab[i])->next == (xmlNsPtr) node) &&
3650
(xmlStrEqual(ns->prefix, ((xmlNsPtr)cur->nodeTab[i])->prefix)))
3651
return(0);
3652
}
3653
3654
/*
3655
* grow the nodeTab if needed
3656
*/
3657
if (cur->nodeMax == 0) {
3658
cur->nodeTab = (xmlNodePtr *) xmlMalloc(XML_NODESET_DEFAULT *
3659
sizeof(xmlNodePtr));
3660
if (cur->nodeTab == NULL) {
3661
xmlXPathErrMemory(NULL, "growing nodeset\n");
3662
return(-1);
3663
}
3664
memset(cur->nodeTab, 0 ,
3665
XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
3666
cur->nodeMax = XML_NODESET_DEFAULT;
3667
} else if (cur->nodeNr == cur->nodeMax) {
3668
xmlNodePtr *temp;
3669
3670
if (cur->nodeMax >= XPATH_MAX_NODESET_LENGTH) {
3671
xmlXPathErrMemory(NULL, "growing nodeset hit limit\n");
3672
return(-1);
3673
}
3674
temp = (xmlNodePtr *) xmlRealloc(cur->nodeTab, cur->nodeMax * 2 *
3675
sizeof(xmlNodePtr));
3676
if (temp == NULL) {
3677
xmlXPathErrMemory(NULL, "growing nodeset\n");
3678
return(-1);
3679
}
3680
cur->nodeMax *= 2;
3681
cur->nodeTab = temp;
3682
}
3683
cur->nodeTab[cur->nodeNr++] = xmlXPathNodeSetDupNs(node, ns);
3684
return(0);
3685
}
3686
3687
/**
3688
* xmlXPathNodeSetAdd:
3689
* @cur: the initial node set
3690
* @val: a new xmlNodePtr
3691
*
3692
* add a new xmlNodePtr to an existing NodeSet
3693
*
3694
* Returns 0 in case of success, and -1 in case of error
3695
*/
3696
int
3697
xmlXPathNodeSetAdd(xmlNodeSetPtr cur, xmlNodePtr val) {
3698
int i;
3699
3700
if ((cur == NULL) || (val == NULL)) return(-1);
3701
3702
/* @@ with_ns to check whether namespace nodes should be looked at @@ */
3703
/*
3704
* prevent duplcates
3705
*/
3706
for (i = 0;i < cur->nodeNr;i++)
3707
if (cur->nodeTab[i] == val) return(0);
3708
3709
/*
3710
* grow the nodeTab if needed
3711
*/
3712
if (cur->nodeMax == 0) {
3713
cur->nodeTab = (xmlNodePtr *) xmlMalloc(XML_NODESET_DEFAULT *
3714
sizeof(xmlNodePtr));
3715
if (cur->nodeTab == NULL) {
3716
xmlXPathErrMemory(NULL, "growing nodeset\n");
3717
return(-1);
3718
}
3719
memset(cur->nodeTab, 0 ,
3720
XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
3721
cur->nodeMax = XML_NODESET_DEFAULT;
3722
} else if (cur->nodeNr == cur->nodeMax) {
3723
xmlNodePtr *temp;
3724
3725
if (cur->nodeMax >= XPATH_MAX_NODESET_LENGTH) {
3726
xmlXPathErrMemory(NULL, "growing nodeset hit limit\n");
3727
return(-1);
3728
}
3729
temp = (xmlNodePtr *) xmlRealloc(cur->nodeTab, cur->nodeMax * 2 *
3730
sizeof(xmlNodePtr));
3731
if (temp == NULL) {
3732
xmlXPathErrMemory(NULL, "growing nodeset\n");
3733
return(-1);
3734
}
3735
cur->nodeMax *= 2;
3736
cur->nodeTab = temp;
3737
}
3738
if (val->type == XML_NAMESPACE_DECL) {
3739
xmlNsPtr ns = (xmlNsPtr) val;
3740
3741
cur->nodeTab[cur->nodeNr++] =
3742
xmlXPathNodeSetDupNs((xmlNodePtr) ns->next, ns);
3743
} else
3744
cur->nodeTab[cur->nodeNr++] = val;
3745
return(0);
3746
}
3747
3748
/**
3749
* xmlXPathNodeSetAddUnique:
3750
* @cur: the initial node set
3751
* @val: a new xmlNodePtr
3752
*
3753
* add a new xmlNodePtr to an existing NodeSet, optimized version
3754
* when we are sure the node is not already in the set.
3755
*
3756
* Returns 0 in case of success and -1 in case of failure
3757
*/
3758
int
3759
xmlXPathNodeSetAddUnique(xmlNodeSetPtr cur, xmlNodePtr val) {
3760
if ((cur == NULL) || (val == NULL)) return(-1);
3761
3762
/* @@ with_ns to check whether namespace nodes should be looked at @@ */
3763
/*
3764
* grow the nodeTab if needed
3765
*/
3766
if (cur->nodeMax == 0) {
3767
cur->nodeTab = (xmlNodePtr *) xmlMalloc(XML_NODESET_DEFAULT *
3768
sizeof(xmlNodePtr));
3769
if (cur->nodeTab == NULL) {
3770
xmlXPathErrMemory(NULL, "growing nodeset\n");
3771
return(-1);
3772
}
3773
memset(cur->nodeTab, 0 ,
3774
XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
3775
cur->nodeMax = XML_NODESET_DEFAULT;
3776
} else if (cur->nodeNr == cur->nodeMax) {
3777
xmlNodePtr *temp;
3778
3779
if (cur->nodeMax >= XPATH_MAX_NODESET_LENGTH) {
3780
xmlXPathErrMemory(NULL, "growing nodeset hit limit\n");
3781
return(-1);
3782
}
3783
temp = (xmlNodePtr *) xmlRealloc(cur->nodeTab, cur->nodeMax * 2 *
3784
sizeof(xmlNodePtr));
3785
if (temp == NULL) {
3786
xmlXPathErrMemory(NULL, "growing nodeset\n");
3787
return(-1);
3788
}
3789
cur->nodeTab = temp;
3790
cur->nodeMax *= 2;
3791
}
3792
if (val->type == XML_NAMESPACE_DECL) {
3793
xmlNsPtr ns = (xmlNsPtr) val;
3794
3795
cur->nodeTab[cur->nodeNr++] =
3796
xmlXPathNodeSetDupNs((xmlNodePtr) ns->next, ns);
3797
} else
3798
cur->nodeTab[cur->nodeNr++] = val;
3799
return(0);
3800
}
3801
3802
/**
3803
* xmlXPathNodeSetMerge:
3804
* @val1: the first NodeSet or NULL
3805
* @val2: the second NodeSet
3806
*
3807
* Merges two nodesets, all nodes from @val2 are added to @val1
3808
* if @val1 is NULL, a new set is created and copied from @val2
3809
*
3810
* Returns @val1 once extended or NULL in case of error.
3811
*/
3812
xmlNodeSetPtr
3813
xmlXPathNodeSetMerge(xmlNodeSetPtr val1, xmlNodeSetPtr val2) {
3814
int i, j, initNr, skip;
3815
xmlNodePtr n1, n2;
3816
3817
if (val2 == NULL) return(val1);
3818
if (val1 == NULL) {
3819
val1 = xmlXPathNodeSetCreate(NULL);
3820
if (val1 == NULL)
3821
return (NULL);
3822
#if 0
3823
/*
3824
* TODO: The optimization won't work in every case, since
3825
* those nasty namespace nodes need to be added with
3826
* xmlXPathNodeSetDupNs() to the set; thus a pure
3827
* memcpy is not possible.
3828
* If there was a flag on the nodesetval, indicating that
3829
* some temporary nodes are in, that would be helpfull.
3830
*/
3831
/*
3832
* Optimization: Create an equally sized node-set
3833
* and memcpy the content.
3834
*/
3835
val1 = xmlXPathNodeSetCreateSize(val2->nodeNr);
3836
if (val1 == NULL)
3837
return(NULL);
3838
if (val2->nodeNr != 0) {
3839
if (val2->nodeNr == 1)
3840
*(val1->nodeTab) = *(val2->nodeTab);
3841
else {
3842
memcpy(val1->nodeTab, val2->nodeTab,
3843
val2->nodeNr * sizeof(xmlNodePtr));
3844
}
3845
val1->nodeNr = val2->nodeNr;
3846
}
3847
return(val1);
3848
#endif
3849
}
3850
3851
/* @@ with_ns to check whether namespace nodes should be looked at @@ */
3852
initNr = val1->nodeNr;
3853
3854
for (i = 0;i < val2->nodeNr;i++) {
3855
n2 = val2->nodeTab[i];
3856
/*
3857
* check against duplicates
3858
*/
3859
skip = 0;
3860
for (j = 0; j < initNr; j++) {
3861
n1 = val1->nodeTab[j];
3862
if (n1 == n2) {
3863
skip = 1;
3864
break;
3865
} else if ((n1->type == XML_NAMESPACE_DECL) &&
3866
(n2->type == XML_NAMESPACE_DECL)) {
3867
if ((((xmlNsPtr) n1)->next == ((xmlNsPtr) n2)->next) &&
3868
(xmlStrEqual(((xmlNsPtr) n1)->prefix,
3869
((xmlNsPtr) n2)->prefix)))
3870
{
3871
skip = 1;
3872
break;
3873
}
3874
}
3875
}
3876
if (skip)
3877
continue;
3878
3879
/*
3880
* grow the nodeTab if needed
3881
*/
3882
if (val1->nodeMax == 0) {
3883
val1->nodeTab = (xmlNodePtr *) xmlMalloc(XML_NODESET_DEFAULT *
3884
sizeof(xmlNodePtr));
3885
if (val1->nodeTab == NULL) {
3886
xmlXPathErrMemory(NULL, "merging nodeset\n");
3887
return(NULL);
3888
}
3889
memset(val1->nodeTab, 0 ,
3890
XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
3891
val1->nodeMax = XML_NODESET_DEFAULT;
3892
} else if (val1->nodeNr == val1->nodeMax) {
3893
xmlNodePtr *temp;
3894
3895
if (val1->nodeMax >= XPATH_MAX_NODESET_LENGTH) {
3896
xmlXPathErrMemory(NULL, "merging nodeset hit limit\n");
3897
return(NULL);
3898
}
3899
temp = (xmlNodePtr *) xmlRealloc(val1->nodeTab, val1->nodeMax * 2 *
3900
sizeof(xmlNodePtr));
3901
if (temp == NULL) {
3902
xmlXPathErrMemory(NULL, "merging nodeset\n");
3903
return(NULL);
3904
}
3905
val1->nodeTab = temp;
3906
val1->nodeMax *= 2;
3907
}
3908
if (n2->type == XML_NAMESPACE_DECL) {
3909
xmlNsPtr ns = (xmlNsPtr) n2;
3910
3911
val1->nodeTab[val1->nodeNr++] =
3912
xmlXPathNodeSetDupNs((xmlNodePtr) ns->next, ns);
3913
} else
3914
val1->nodeTab[val1->nodeNr++] = n2;
3915
}
3916
3917
return(val1);
3918
}
3919
3920
3921
/**
3922
* xmlXPathNodeSetMergeAndClear:
3923
* @set1: the first NodeSet or NULL
3924
* @set2: the second NodeSet
3925
* @hasSet2NsNodes: 1 if set2 contains namespaces nodes
3926
*
3927
* Merges two nodesets, all nodes from @set2 are added to @set1
3928
* if @set1 is NULL, a new set is created and copied from @set2.
3929
* Checks for duplicate nodes. Clears set2.
3930
*
3931
* Returns @set1 once extended or NULL in case of error.
3932
*/
3933
static xmlNodeSetPtr
3934
xmlXPathNodeSetMergeAndClear(xmlNodeSetPtr set1, xmlNodeSetPtr set2,
3935
int hasNullEntries)
3936
{
3937
if ((set1 == NULL) && (hasNullEntries == 0)) {
3938
/*
3939
* Note that doing a memcpy of the list, namespace nodes are
3940
* just assigned to set1, since set2 is cleared anyway.
3941
*/
3942
set1 = xmlXPathNodeSetCreateSize(set2->nodeNr);
3943
if (set1 == NULL)
3944
return(NULL);
3945
if (set2->nodeNr != 0) {
3946
memcpy(set1->nodeTab, set2->nodeTab,
3947
set2->nodeNr * sizeof(xmlNodePtr));
3948
set1->nodeNr = set2->nodeNr;
3949
}
3950
} else {
3951
int i, j, initNbSet1;
3952
xmlNodePtr n1, n2;
3953
3954
if (set1 == NULL)
3955
set1 = xmlXPathNodeSetCreate(NULL);
3956
if (set1 == NULL)
3957
return (NULL);
3958
3959
initNbSet1 = set1->nodeNr;
3960
for (i = 0;i < set2->nodeNr;i++) {
3961
n2 = set2->nodeTab[i];
3962
/*
3963
* Skip NULLed entries.
3964
*/
3965
if (n2 == NULL)
3966
continue;
3967
/*
3968
* Skip duplicates.
3969
*/
3970
for (j = 0; j < initNbSet1; j++) {
3971
n1 = set1->nodeTab[j];
3972
if (n1 == n2) {
3973
goto skip_node;
3974
} else if ((n1->type == XML_NAMESPACE_DECL) &&
3975
(n2->type == XML_NAMESPACE_DECL))
3976
{
3977
if ((((xmlNsPtr) n1)->next == ((xmlNsPtr) n2)->next) &&
3978
(xmlStrEqual(((xmlNsPtr) n1)->prefix,
3979
((xmlNsPtr) n2)->prefix)))
3980
{
3981
/*
3982
* Free the namespace node.
3983
*/
3984
set2->nodeTab[i] = NULL;
3985
xmlXPathNodeSetFreeNs((xmlNsPtr) n2);
3986
goto skip_node;
3987
}
3988
}
3989
}
3990
/*
3991
* grow the nodeTab if needed
3992
*/
3993
if (set1->nodeMax == 0) {
3994
set1->nodeTab = (xmlNodePtr *) xmlMalloc(
3995
XML_NODESET_DEFAULT * sizeof(xmlNodePtr));
3996
if (set1->nodeTab == NULL) {
3997
xmlXPathErrMemory(NULL, "merging nodeset\n");
3998
return(NULL);
3999
}
4000
memset(set1->nodeTab, 0,
4001
XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
4002
set1->nodeMax = XML_NODESET_DEFAULT;
4003
} else if (set1->nodeNr >= set1->nodeMax) {
4004
xmlNodePtr *temp;
4005
4006
if (set1->nodeMax >= XPATH_MAX_NODESET_LENGTH) {
4007
xmlXPathErrMemory(NULL, "merging nodeset hit limit\n");
4008
return(NULL);
4009
}
4010
temp = (xmlNodePtr *) xmlRealloc(
4011
set1->nodeTab, set1->nodeMax * 2 * sizeof(xmlNodePtr));
4012
if (temp == NULL) {
4013
xmlXPathErrMemory(NULL, "merging nodeset\n");
4014
return(NULL);
4015
}
4016
set1->nodeTab = temp;
4017
set1->nodeMax *= 2;
4018
}
4019
if (n2->type == XML_NAMESPACE_DECL) {
4020
xmlNsPtr ns = (xmlNsPtr) n2;
4021
4022
set1->nodeTab[set1->nodeNr++] =
4023
xmlXPathNodeSetDupNs((xmlNodePtr) ns->next, ns);
4024
} else
4025
set1->nodeTab[set1->nodeNr++] = n2;
4026
skip_node:
4027
{}
4028
}
4029
}
4030
set2->nodeNr = 0;
4031
return(set1);
4032
}
4033
4034
/**
4035
* xmlXPathNodeSetMergeAndClearNoDupls:
4036
* @set1: the first NodeSet or NULL
4037
* @set2: the second NodeSet
4038
* @hasSet2NsNodes: 1 if set2 contains namespaces nodes
4039
*
4040
* Merges two nodesets, all nodes from @set2 are added to @set1
4041
* if @set1 is NULL, a new set is created and copied from @set2.
4042
* Doesn't chack for duplicate nodes. Clears set2.
4043
*
4044
* Returns @set1 once extended or NULL in case of error.
4045
*/
4046
static xmlNodeSetPtr
4047
xmlXPathNodeSetMergeAndClearNoDupls(xmlNodeSetPtr set1, xmlNodeSetPtr set2,
4048
int hasNullEntries)
4049
{
4050
if (set2 == NULL)
4051
return(set1);
4052
if ((set1 == NULL) && (hasNullEntries == 0)) {
4053
/*
4054
* Note that doing a memcpy of the list, namespace nodes are
4055
* just assigned to set1, since set2 is cleared anyway.
4056
*/
4057
set1 = xmlXPathNodeSetCreateSize(set2->nodeNr);
4058
if (set1 == NULL)
4059
return(NULL);
4060
if (set2->nodeNr != 0) {
4061
memcpy(set1->nodeTab, set2->nodeTab,
4062
set2->nodeNr * sizeof(xmlNodePtr));
4063
set1->nodeNr = set2->nodeNr;
4064
}
4065
} else {
4066
int i;
4067
xmlNodePtr n2;
4068
4069
if (set1 == NULL)
4070
set1 = xmlXPathNodeSetCreate(NULL);
4071
if (set1 == NULL)
4072
return (NULL);
4073
4074
for (i = 0;i < set2->nodeNr;i++) {
4075
n2 = set2->nodeTab[i];
4076
/*
4077
* Skip NULLed entries.
4078
*/
4079
if (n2 == NULL)
4080
continue;
4081
if (set1->nodeMax == 0) {
4082
set1->nodeTab = (xmlNodePtr *) xmlMalloc(
4083
XML_NODESET_DEFAULT * sizeof(xmlNodePtr));
4084
if (set1->nodeTab == NULL) {
4085
xmlXPathErrMemory(NULL, "merging nodeset\n");
4086
return(NULL);
4087
}
4088
memset(set1->nodeTab, 0,
4089
XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
4090
set1->nodeMax = XML_NODESET_DEFAULT;
4091
} else if (set1->nodeNr >= set1->nodeMax) {
4092
xmlNodePtr *temp;
4093
4094
if (set1->nodeMax >= XPATH_MAX_NODESET_LENGTH) {
4095
xmlXPathErrMemory(NULL, "merging nodeset hit limit\n");
4096
return(NULL);
4097
}
4098
temp = (xmlNodePtr *) xmlRealloc(
4099
set1->nodeTab, set1->nodeMax * 2 * sizeof(xmlNodePtr));
4100
if (temp == NULL) {
4101
xmlXPathErrMemory(NULL, "merging nodeset\n");
4102
return(NULL);
4103
}
4104
set1->nodeTab = temp;
4105
set1->nodeMax *= 2;
4106
}
4107
set1->nodeTab[set1->nodeNr++] = n2;
4108
}
4109
}
4110
set2->nodeNr = 0;
4111
return(set1);
4112
}
4113
4114
/**
4115
* xmlXPathNodeSetDel:
4116
* @cur: the initial node set
4117
* @val: an xmlNodePtr
4118
*
4119
* Removes an xmlNodePtr from an existing NodeSet
4120
*/
4121
void
4122
xmlXPathNodeSetDel(xmlNodeSetPtr cur, xmlNodePtr val) {
4123
int i;
4124
4125
if (cur == NULL) return;
4126
if (val == NULL) return;
4127
4128
/*
4129
* find node in nodeTab
4130
*/
4131
for (i = 0;i < cur->nodeNr;i++)
4132
if (cur->nodeTab[i] == val) break;
4133
4134
if (i >= cur->nodeNr) { /* not found */
4135
#ifdef DEBUG
4136
xmlGenericError(xmlGenericErrorContext,
4137
"xmlXPathNodeSetDel: Node %s wasn't found in NodeList\n",
4138
val->name);
4139
#endif
4140
return;
4141
}
4142
if ((cur->nodeTab[i] != NULL) &&
4143
(cur->nodeTab[i]->type == XML_NAMESPACE_DECL))
4144
xmlXPathNodeSetFreeNs((xmlNsPtr) cur->nodeTab[i]);
4145
cur->nodeNr--;
4146
for (;i < cur->nodeNr;i++)
4147
cur->nodeTab[i] = cur->nodeTab[i + 1];
4148
cur->nodeTab[cur->nodeNr] = NULL;
4149
}
4150
4151
/**
4152
* xmlXPathNodeSetRemove:
4153
* @cur: the initial node set
4154
* @val: the index to remove
4155
*
4156
* Removes an entry from an existing NodeSet list.
4157
*/
4158
void
4159
xmlXPathNodeSetRemove(xmlNodeSetPtr cur, int val) {
4160
if (cur == NULL) return;
4161
if (val >= cur->nodeNr) return;
4162
if ((cur->nodeTab[val] != NULL) &&
4163
(cur->nodeTab[val]->type == XML_NAMESPACE_DECL))
4164
xmlXPathNodeSetFreeNs((xmlNsPtr) cur->nodeTab[val]);
4165
cur->nodeNr--;
4166
for (;val < cur->nodeNr;val++)
4167
cur->nodeTab[val] = cur->nodeTab[val + 1];
4168
cur->nodeTab[cur->nodeNr] = NULL;
4169
}
4170
4171
/**
4172
* xmlXPathFreeNodeSet:
4173
* @obj: the xmlNodeSetPtr to free
4174
*
4175
* Free the NodeSet compound (not the actual nodes !).
4176
*/
4177
void
4178
xmlXPathFreeNodeSet(xmlNodeSetPtr obj) {
4179
if (obj == NULL) return;
4180
if (obj->nodeTab != NULL) {
4181
int i;
4182
4183
/* @@ with_ns to check whether namespace nodes should be looked at @@ */
4184
for (i = 0;i < obj->nodeNr;i++)
4185
if ((obj->nodeTab[i] != NULL) &&
4186
(obj->nodeTab[i]->type == XML_NAMESPACE_DECL))
4187
xmlXPathNodeSetFreeNs((xmlNsPtr) obj->nodeTab[i]);
4188
xmlFree(obj->nodeTab);
4189
}
4190
xmlFree(obj);
4191
}
4192
4193
/**
4194
* xmlXPathNodeSetClear:
4195
* @set: the node set to clear
4196
*
4197
* Clears the list from all temporary XPath objects (e.g. namespace nodes
4198
* are feed), but does *not* free the list itself. Sets the length of the
4199
* list to 0.
4200
*/
4201
static void
4202
xmlXPathNodeSetClear(xmlNodeSetPtr set, int hasNsNodes)
4203
{
4204
if ((set == NULL) || (set->nodeNr <= 0))
4205
return;
4206
else if (hasNsNodes) {
4207
int i;
4208
xmlNodePtr node;
4209
4210
for (i = 0; i < set->nodeNr; i++) {
4211
node = set->nodeTab[i];
4212
if ((node != NULL) &&
4213
(node->type == XML_NAMESPACE_DECL))
4214
xmlXPathNodeSetFreeNs((xmlNsPtr) node);
4215
}
4216
}
4217
set->nodeNr = 0;
4218
}
4219
4220
/**
4221
* xmlXPathNodeSetClearFromPos:
4222
* @set: the node set to be cleared
4223
* @pos: the start position to clear from
4224
*
4225
* Clears the list from temporary XPath objects (e.g. namespace nodes
4226
* are feed) starting with the entry at @pos, but does *not* free the list
4227
* itself. Sets the length of the list to @pos.
4228
*/
4229
static void
4230
xmlXPathNodeSetClearFromPos(xmlNodeSetPtr set, int pos, int hasNsNodes)
4231
{
4232
if ((set == NULL) || (set->nodeNr <= 0) || (pos >= set->nodeNr))
4233
return;
4234
else if ((hasNsNodes)) {
4235
int i;
4236
xmlNodePtr node;
4237
4238
for (i = pos; i < set->nodeNr; i++) {
4239
node = set->nodeTab[i];
4240
if ((node != NULL) &&
4241
(node->type == XML_NAMESPACE_DECL))
4242
xmlXPathNodeSetFreeNs((xmlNsPtr) node);
4243
}
4244
}
4245
set->nodeNr = pos;
4246
}
4247
4248
/**
4249
* xmlXPathFreeValueTree:
4250
* @obj: the xmlNodeSetPtr to free
4251
*
4252
* Free the NodeSet compound and the actual tree, this is different
4253
* from xmlXPathFreeNodeSet()
4254
*/
4255
static void
4256
xmlXPathFreeValueTree(xmlNodeSetPtr obj) {
4257
int i;
4258
4259
if (obj == NULL) return;
4260
4261
if (obj->nodeTab != NULL) {
4262
for (i = 0;i < obj->nodeNr;i++) {
4263
if (obj->nodeTab[i] != NULL) {
4264
if (obj->nodeTab[i]->type == XML_NAMESPACE_DECL) {
4265
xmlXPathNodeSetFreeNs((xmlNsPtr) obj->nodeTab[i]);
4266
} else {
4267
xmlFreeNodeList(obj->nodeTab[i]);
4268
}
4269
}
4270
}
4271
xmlFree(obj->nodeTab);
4272
}
4273
xmlFree(obj);
4274
}
4275
4276
#if defined(DEBUG) || defined(DEBUG_STEP)
4277
/**
4278
* xmlGenericErrorContextNodeSet:
4279
* @output: a FILE * for the output
4280
* @obj: the xmlNodeSetPtr to display
4281
*
4282
* Quick display of a NodeSet
4283
*/
4284
void
4285
xmlGenericErrorContextNodeSet(FILE *output, xmlNodeSetPtr obj) {
4286
int i;
4287
4288
if (output == NULL) output = xmlGenericErrorContext;
4289
if (obj == NULL) {
4290
fprintf(output, "NodeSet == NULL !\n");
4291
return;
4292
}
4293
if (obj->nodeNr == 0) {
4294
fprintf(output, "NodeSet is empty\n");
4295
return;
4296
}
4297
if (obj->nodeTab == NULL) {
4298
fprintf(output, " nodeTab == NULL !\n");
4299
return;
4300
}
4301
for (i = 0; i < obj->nodeNr; i++) {
4302
if (obj->nodeTab[i] == NULL) {
4303
fprintf(output, " NULL !\n");
4304
return;
4305
}
4306
if ((obj->nodeTab[i]->type == XML_DOCUMENT_NODE) ||
4307
(obj->nodeTab[i]->type == XML_HTML_DOCUMENT_NODE))
4308
fprintf(output, " /");
4309
else if (obj->nodeTab[i]->name == NULL)
4310
fprintf(output, " noname!");
4311
else fprintf(output, " %s", obj->nodeTab[i]->name);
4312
}
4313
fprintf(output, "\n");
4314
}
4315
#endif
4316
4317
/**
4318
* xmlXPathNewNodeSet:
4319
* @val: the NodePtr value
4320
*
4321
* Create a new xmlXPathObjectPtr of type NodeSet and initialize
4322
* it with the single Node @val
4323
*
4324
* Returns the newly created object.
4325
*/
4326
xmlXPathObjectPtr
4327
xmlXPathNewNodeSet(xmlNodePtr val) {
4328
xmlXPathObjectPtr ret;
4329
4330
ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
4331
if (ret == NULL) {
4332
xmlXPathErrMemory(NULL, "creating nodeset\n");
4333
return(NULL);
4334
}
4335
memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
4336
ret->type = XPATH_NODESET;
4337
ret->boolval = 0;
4338
ret->nodesetval = xmlXPathNodeSetCreate(val);
4339
/* @@ with_ns to check whether namespace nodes should be looked at @@ */
4340
#ifdef XP_DEBUG_OBJ_USAGE
4341
xmlXPathDebugObjUsageRequested(NULL, XPATH_NODESET);
4342
#endif
4343
return(ret);
4344
}
4345
4346
/**
4347
* xmlXPathNewValueTree:
4348
* @val: the NodePtr value
4349
*
4350
* Create a new xmlXPathObjectPtr of type Value Tree (XSLT) and initialize
4351
* it with the tree root @val
4352
*
4353
* Returns the newly created object.
4354
*/
4355
xmlXPathObjectPtr
4356
xmlXPathNewValueTree(xmlNodePtr val) {
4357
xmlXPathObjectPtr ret;
4358
4359
ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
4360
if (ret == NULL) {
4361
xmlXPathErrMemory(NULL, "creating result value tree\n");
4362
return(NULL);
4363
}
4364
memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
4365
ret->type = XPATH_XSLT_TREE;
4366
ret->boolval = 1;
4367
ret->user = (void *) val;
4368
ret->nodesetval = xmlXPathNodeSetCreate(val);
4369
#ifdef XP_DEBUG_OBJ_USAGE
4370
xmlXPathDebugObjUsageRequested(NULL, XPATH_XSLT_TREE);
4371
#endif
4372
return(ret);
4373
}
4374
4375
/**
4376
* xmlXPathNewNodeSetList:
4377
* @val: an existing NodeSet
4378
*
4379
* Create a new xmlXPathObjectPtr of type NodeSet and initialize
4380
* it with the Nodeset @val
4381
*
4382
* Returns the newly created object.
4383
*/
4384
xmlXPathObjectPtr
4385
xmlXPathNewNodeSetList(xmlNodeSetPtr val)
4386
{
4387
xmlXPathObjectPtr ret;
4388
int i;
4389
4390
if (val == NULL)
4391
ret = NULL;
4392
else if (val->nodeTab == NULL)
4393
ret = xmlXPathNewNodeSet(NULL);
4394
else {
4395
ret = xmlXPathNewNodeSet(val->nodeTab[0]);
4396
if (ret) {
4397
for (i = 1; i < val->nodeNr; ++i) {
4398
if (xmlXPathNodeSetAddUnique(ret->nodesetval, val->nodeTab[i])
4399
< 0) break;
4400
}
4401
}
4402
}
4403
4404
return (ret);
4405
}
4406
4407
/**
4408
* xmlXPathWrapNodeSet:
4409
* @val: the NodePtr value
4410
*
4411
* Wrap the Nodeset @val in a new xmlXPathObjectPtr
4412
*
4413
* Returns the newly created object.
4414
*/
4415
xmlXPathObjectPtr
4416
xmlXPathWrapNodeSet(xmlNodeSetPtr val) {
4417
xmlXPathObjectPtr ret;
4418
4419
ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
4420
if (ret == NULL) {
4421
xmlXPathErrMemory(NULL, "creating node set object\n");
4422
return(NULL);
4423
}
4424
memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
4425
ret->type = XPATH_NODESET;
4426
ret->nodesetval = val;
4427
#ifdef XP_DEBUG_OBJ_USAGE
4428
xmlXPathDebugObjUsageRequested(NULL, XPATH_NODESET);
4429
#endif
4430
return(ret);
4431
}
4432
4433
/**
4434
* xmlXPathFreeNodeSetList:
4435
* @obj: an existing NodeSetList object
4436
*
4437
* Free up the xmlXPathObjectPtr @obj but don't deallocate the objects in
4438
* the list contrary to xmlXPathFreeObject().
4439
*/
4440
void
4441
xmlXPathFreeNodeSetList(xmlXPathObjectPtr obj) {
4442
if (obj == NULL) return;
4443
#ifdef XP_DEBUG_OBJ_USAGE
4444
xmlXPathDebugObjUsageReleased(NULL, obj->type);
4445
#endif
4446
xmlFree(obj);
4447
}
4448
4449
/**
4450
* xmlXPathDifference:
4451
* @nodes1: a node-set
4452
* @nodes2: a node-set
4453
*
4454
* Implements the EXSLT - Sets difference() function:
4455
* node-set set:difference (node-set, node-set)
4456
*
4457
* Returns the difference between the two node sets, or nodes1 if
4458
* nodes2 is empty
4459
*/
4460
xmlNodeSetPtr
4461
xmlXPathDifference (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
4462
xmlNodeSetPtr ret;
4463
int i, l1;
4464
xmlNodePtr cur;
4465
4466
if (xmlXPathNodeSetIsEmpty(nodes2))
4467
return(nodes1);
4468
4469
ret = xmlXPathNodeSetCreate(NULL);
4470
if (xmlXPathNodeSetIsEmpty(nodes1))
4471
return(ret);
4472
4473
l1 = xmlXPathNodeSetGetLength(nodes1);
4474
4475
for (i = 0; i < l1; i++) {
4476
cur = xmlXPathNodeSetItem(nodes1, i);
4477
if (!xmlXPathNodeSetContains(nodes2, cur)) {
4478
if (xmlXPathNodeSetAddUnique(ret, cur) < 0)
4479
break;
4480
}
4481
}
4482
return(ret);
4483
}
4484
4485
/**
4486
* xmlXPathIntersection:
4487
* @nodes1: a node-set
4488
* @nodes2: a node-set
4489
*
4490
* Implements the EXSLT - Sets intersection() function:
4491
* node-set set:intersection (node-set, node-set)
4492
*
4493
* Returns a node set comprising the nodes that are within both the
4494
* node sets passed as arguments
4495
*/
4496
xmlNodeSetPtr
4497
xmlXPathIntersection (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
4498
xmlNodeSetPtr ret = xmlXPathNodeSetCreate(NULL);
4499
int i, l1;
4500
xmlNodePtr cur;
4501
4502
if (ret == NULL)
4503
return(ret);
4504
if (xmlXPathNodeSetIsEmpty(nodes1))
4505
return(ret);
4506
if (xmlXPathNodeSetIsEmpty(nodes2))
4507
return(ret);
4508
4509
l1 = xmlXPathNodeSetGetLength(nodes1);
4510
4511
for (i = 0; i < l1; i++) {
4512
cur = xmlXPathNodeSetItem(nodes1, i);
4513
if (xmlXPathNodeSetContains(nodes2, cur)) {
4514
if (xmlXPathNodeSetAddUnique(ret, cur) < 0)
4515
break;
4516
}
4517
}
4518
return(ret);
4519
}
4520
4521
/**
4522
* xmlXPathDistinctSorted:
4523
* @nodes: a node-set, sorted by document order
4524
*
4525
* Implements the EXSLT - Sets distinct() function:
4526
* node-set set:distinct (node-set)
4527
*
4528
* Returns a subset of the nodes contained in @nodes, or @nodes if
4529
* it is empty
4530
*/
4531
xmlNodeSetPtr
4532
xmlXPathDistinctSorted (xmlNodeSetPtr nodes) {
4533
xmlNodeSetPtr ret;
4534
xmlHashTablePtr hash;
4535
int i, l;
4536
xmlChar * strval;
4537
xmlNodePtr cur;
4538
4539
if (xmlXPathNodeSetIsEmpty(nodes))
4540
return(nodes);
4541
4542
ret = xmlXPathNodeSetCreate(NULL);
4543
if (ret == NULL)
4544
return(ret);
4545
l = xmlXPathNodeSetGetLength(nodes);
4546
hash = xmlHashCreate (l);
4547
for (i = 0; i < l; i++) {
4548
cur = xmlXPathNodeSetItem(nodes, i);
4549
strval = xmlXPathCastNodeToString(cur);
4550
if (xmlHashLookup(hash, strval) == NULL) {
4551
xmlHashAddEntry(hash, strval, strval);
4552
if (xmlXPathNodeSetAddUnique(ret, cur) < 0)
4553
break;
4554
} else {
4555
xmlFree(strval);
4556
}
4557
}
4558
xmlHashFree(hash, (xmlHashDeallocator) xmlFree);
4559
return(ret);
4560
}
4561
4562
/**
4563
* xmlXPathDistinct:
4564
* @nodes: a node-set
4565
*
4566
* Implements the EXSLT - Sets distinct() function:
4567
* node-set set:distinct (node-set)
4568
* @nodes is sorted by document order, then #exslSetsDistinctSorted
4569
* is called with the sorted node-set
4570
*
4571
* Returns a subset of the nodes contained in @nodes, or @nodes if
4572
* it is empty
4573
*/
4574
xmlNodeSetPtr
4575
xmlXPathDistinct (xmlNodeSetPtr nodes) {
4576
if (xmlXPathNodeSetIsEmpty(nodes))
4577
return(nodes);
4578
4579
xmlXPathNodeSetSort(nodes);
4580
return(xmlXPathDistinctSorted(nodes));
4581
}
4582
4583
/**
4584
* xmlXPathHasSameNodes:
4585
* @nodes1: a node-set
4586
* @nodes2: a node-set
4587
*
4588
* Implements the EXSLT - Sets has-same-nodes function:
4589
* boolean set:has-same-node(node-set, node-set)
4590
*
4591
* Returns true (1) if @nodes1 shares any node with @nodes2, false (0)
4592
* otherwise
4593
*/
4594
int
4595
xmlXPathHasSameNodes (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
4596
int i, l;
4597
xmlNodePtr cur;
4598
4599
if (xmlXPathNodeSetIsEmpty(nodes1) ||
4600
xmlXPathNodeSetIsEmpty(nodes2))
4601
return(0);
4602
4603
l = xmlXPathNodeSetGetLength(nodes1);
4604
for (i = 0; i < l; i++) {
4605
cur = xmlXPathNodeSetItem(nodes1, i);
4606
if (xmlXPathNodeSetContains(nodes2, cur))
4607
return(1);
4608
}
4609
return(0);
4610
}
4611
4612
/**
4613
* xmlXPathNodeLeadingSorted:
4614
* @nodes: a node-set, sorted by document order
4615
* @node: a node
4616
*
4617
* Implements the EXSLT - Sets leading() function:
4618
* node-set set:leading (node-set, node-set)
4619
*
4620
* Returns the nodes in @nodes that precede @node in document order,
4621
* @nodes if @node is NULL or an empty node-set if @nodes
4622
* doesn't contain @node
4623
*/
4624
xmlNodeSetPtr
4625
xmlXPathNodeLeadingSorted (xmlNodeSetPtr nodes, xmlNodePtr node) {
4626
int i, l;
4627
xmlNodePtr cur;
4628
xmlNodeSetPtr ret;
4629
4630
if (node == NULL)
4631
return(nodes);
4632
4633
ret = xmlXPathNodeSetCreate(NULL);
4634
if (ret == NULL)
4635
return(ret);
4636
if (xmlXPathNodeSetIsEmpty(nodes) ||
4637
(!xmlXPathNodeSetContains(nodes, node)))
4638
return(ret);
4639
4640
l = xmlXPathNodeSetGetLength(nodes);
4641
for (i = 0; i < l; i++) {
4642
cur = xmlXPathNodeSetItem(nodes, i);
4643
if (cur == node)
4644
break;
4645
if (xmlXPathNodeSetAddUnique(ret, cur) < 0)
4646
break;
4647
}
4648
return(ret);
4649
}
4650
4651
/**
4652
* xmlXPathNodeLeading:
4653
* @nodes: a node-set
4654
* @node: a node
4655
*
4656
* Implements the EXSLT - Sets leading() function:
4657
* node-set set:leading (node-set, node-set)
4658
* @nodes is sorted by document order, then #exslSetsNodeLeadingSorted
4659
* is called.
4660
*
4661
* Returns the nodes in @nodes that precede @node in document order,
4662
* @nodes if @node is NULL or an empty node-set if @nodes
4663
* doesn't contain @node
4664
*/
4665
xmlNodeSetPtr
4666
xmlXPathNodeLeading (xmlNodeSetPtr nodes, xmlNodePtr node) {
4667
xmlXPathNodeSetSort(nodes);
4668
return(xmlXPathNodeLeadingSorted(nodes, node));
4669
}
4670
4671
/**
4672
* xmlXPathLeadingSorted:
4673
* @nodes1: a node-set, sorted by document order
4674
* @nodes2: a node-set, sorted by document order
4675
*
4676
* Implements the EXSLT - Sets leading() function:
4677
* node-set set:leading (node-set, node-set)
4678
*
4679
* Returns the nodes in @nodes1 that precede the first node in @nodes2
4680
* in document order, @nodes1 if @nodes2 is NULL or empty or
4681
* an empty node-set if @nodes1 doesn't contain @nodes2
4682
*/
4683
xmlNodeSetPtr
4684
xmlXPathLeadingSorted (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
4685
if (xmlXPathNodeSetIsEmpty(nodes2))
4686
return(nodes1);
4687
return(xmlXPathNodeLeadingSorted(nodes1,
4688
xmlXPathNodeSetItem(nodes2, 1)));
4689
}
4690
4691
/**
4692
* xmlXPathLeading:
4693
* @nodes1: a node-set
4694
* @nodes2: a node-set
4695
*
4696
* Implements the EXSLT - Sets leading() function:
4697
* node-set set:leading (node-set, node-set)
4698
* @nodes1 and @nodes2 are sorted by document order, then
4699
* #exslSetsLeadingSorted is called.
4700
*
4701
* Returns the nodes in @nodes1 that precede the first node in @nodes2
4702
* in document order, @nodes1 if @nodes2 is NULL or empty or
4703
* an empty node-set if @nodes1 doesn't contain @nodes2
4704
*/
4705
xmlNodeSetPtr
4706
xmlXPathLeading (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
4707
if (xmlXPathNodeSetIsEmpty(nodes2))
4708
return(nodes1);
4709
if (xmlXPathNodeSetIsEmpty(nodes1))
4710
return(xmlXPathNodeSetCreate(NULL));
4711
xmlXPathNodeSetSort(nodes1);
4712
xmlXPathNodeSetSort(nodes2);
4713
return(xmlXPathNodeLeadingSorted(nodes1,
4714
xmlXPathNodeSetItem(nodes2, 1)));
4715
}
4716
4717
/**
4718
* xmlXPathNodeTrailingSorted:
4719
* @nodes: a node-set, sorted by document order
4720
* @node: a node
4721
*
4722
* Implements the EXSLT - Sets trailing() function:
4723
* node-set set:trailing (node-set, node-set)
4724
*
4725
* Returns the nodes in @nodes that follow @node in document order,
4726
* @nodes if @node is NULL or an empty node-set if @nodes
4727
* doesn't contain @node
4728
*/
4729
xmlNodeSetPtr
4730
xmlXPathNodeTrailingSorted (xmlNodeSetPtr nodes, xmlNodePtr node) {
4731
int i, l;
4732
xmlNodePtr cur;
4733
xmlNodeSetPtr ret;
4734
4735
if (node == NULL)
4736
return(nodes);
4737
4738
ret = xmlXPathNodeSetCreate(NULL);
4739
if (ret == NULL)
4740
return(ret);
4741
if (xmlXPathNodeSetIsEmpty(nodes) ||
4742
(!xmlXPathNodeSetContains(nodes, node)))
4743
return(ret);
4744
4745
l = xmlXPathNodeSetGetLength(nodes);
4746
for (i = l - 1; i >= 0; i--) {
4747
cur = xmlXPathNodeSetItem(nodes, i);
4748
if (cur == node)
4749
break;
4750
if (xmlXPathNodeSetAddUnique(ret, cur) < 0)
4751
break;
4752
}
4753
xmlXPathNodeSetSort(ret); /* bug 413451 */
4754
return(ret);
4755
}
4756
4757
/**
4758
* xmlXPathNodeTrailing:
4759
* @nodes: a node-set
4760
* @node: a node
4761
*
4762
* Implements the EXSLT - Sets trailing() function:
4763
* node-set set:trailing (node-set, node-set)
4764
* @nodes is sorted by document order, then #xmlXPathNodeTrailingSorted
4765
* is called.
4766
*
4767
* Returns the nodes in @nodes that follow @node in document order,
4768
* @nodes if @node is NULL or an empty node-set if @nodes
4769
* doesn't contain @node
4770
*/
4771
xmlNodeSetPtr
4772
xmlXPathNodeTrailing (xmlNodeSetPtr nodes, xmlNodePtr node) {
4773
xmlXPathNodeSetSort(nodes);
4774
return(xmlXPathNodeTrailingSorted(nodes, node));
4775
}
4776
4777
/**
4778
* xmlXPathTrailingSorted:
4779
* @nodes1: a node-set, sorted by document order
4780
* @nodes2: a node-set, sorted by document order
4781
*
4782
* Implements the EXSLT - Sets trailing() function:
4783
* node-set set:trailing (node-set, node-set)
4784
*
4785
* Returns the nodes in @nodes1 that follow the first node in @nodes2
4786
* in document order, @nodes1 if @nodes2 is NULL or empty or
4787
* an empty node-set if @nodes1 doesn't contain @nodes2
4788
*/
4789
xmlNodeSetPtr
4790
xmlXPathTrailingSorted (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
4791
if (xmlXPathNodeSetIsEmpty(nodes2))
4792
return(nodes1);
4793
return(xmlXPathNodeTrailingSorted(nodes1,
4794
xmlXPathNodeSetItem(nodes2, 0)));
4795
}
4796
4797
/**
4798
* xmlXPathTrailing:
4799
* @nodes1: a node-set
4800
* @nodes2: a node-set
4801
*
4802
* Implements the EXSLT - Sets trailing() function:
4803
* node-set set:trailing (node-set, node-set)
4804
* @nodes1 and @nodes2 are sorted by document order, then
4805
* #xmlXPathTrailingSorted is called.
4806
*
4807
* Returns the nodes in @nodes1 that follow the first node in @nodes2
4808
* in document order, @nodes1 if @nodes2 is NULL or empty or
4809
* an empty node-set if @nodes1 doesn't contain @nodes2
4810
*/
4811
xmlNodeSetPtr
4812
xmlXPathTrailing (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
4813
if (xmlXPathNodeSetIsEmpty(nodes2))
4814
return(nodes1);
4815
if (xmlXPathNodeSetIsEmpty(nodes1))
4816
return(xmlXPathNodeSetCreate(NULL));
4817
xmlXPathNodeSetSort(nodes1);
4818
xmlXPathNodeSetSort(nodes2);
4819
return(xmlXPathNodeTrailingSorted(nodes1,
4820
xmlXPathNodeSetItem(nodes2, 0)));
4821
}
4822
4823
/************************************************************************
4824
* *
4825
* Routines to handle extra functions *
4826
* *
4827
************************************************************************/
4828
4829
/**
4830
* xmlXPathRegisterFunc:
4831
* @ctxt: the XPath context
4832
* @name: the function name
4833
* @f: the function implementation or NULL
4834
*
4835
* Register a new function. If @f is NULL it unregisters the function
4836
*
4837
* Returns 0 in case of success, -1 in case of error
4838
*/
4839
int
4840
xmlXPathRegisterFunc(xmlXPathContextPtr ctxt, const xmlChar *name,
4841
xmlXPathFunction f) {
4842
return(xmlXPathRegisterFuncNS(ctxt, name, NULL, f));
4843
}
4844
4845
/**
4846
* xmlXPathRegisterFuncNS:
4847
* @ctxt: the XPath context
4848
* @name: the function name
4849
* @ns_uri: the function namespace URI
4850
* @f: the function implementation or NULL
4851
*
4852
* Register a new function. If @f is NULL it unregisters the function
4853
*
4854
* Returns 0 in case of success, -1 in case of error
4855
*/
4856
int
4857
xmlXPathRegisterFuncNS(xmlXPathContextPtr ctxt, const xmlChar *name,
4858
const xmlChar *ns_uri, xmlXPathFunction f) {
4859
if (ctxt == NULL)
4860
return(-1);
4861
if (name == NULL)
4862
return(-1);
4863
4864
if (ctxt->funcHash == NULL)
4865
ctxt->funcHash = xmlHashCreate(0);
4866
if (ctxt->funcHash == NULL)
4867
return(-1);
4868
if (f == NULL)
4869
return(xmlHashRemoveEntry2(ctxt->funcHash, name, ns_uri, NULL));
4870
return(xmlHashAddEntry2(ctxt->funcHash, name, ns_uri, XML_CAST_FPTR(f)));
4871
}
4872
4873
/**
4874
* xmlXPathRegisterFuncLookup:
4875
* @ctxt: the XPath context
4876
* @f: the lookup function
4877
* @funcCtxt: the lookup data
4878
*
4879
* Registers an external mechanism to do function lookup.
4880
*/
4881
void
4882
xmlXPathRegisterFuncLookup (xmlXPathContextPtr ctxt,
4883
xmlXPathFuncLookupFunc f,
4884
void *funcCtxt) {
4885
if (ctxt == NULL)
4886
return;
4887
ctxt->funcLookupFunc = f;
4888
ctxt->funcLookupData = funcCtxt;
4889
}
4890
4891
/**
4892
* xmlXPathFunctionLookup:
4893
* @ctxt: the XPath context
4894
* @name: the function name
4895
*
4896
* Search in the Function array of the context for the given
4897
* function.
4898
*
4899
* Returns the xmlXPathFunction or NULL if not found
4900
*/
4901
xmlXPathFunction
4902
xmlXPathFunctionLookup(xmlXPathContextPtr ctxt, const xmlChar *name) {
4903
if (ctxt == NULL)
4904
return (NULL);
4905
4906
if (ctxt->funcLookupFunc != NULL) {
4907
xmlXPathFunction ret;
4908
xmlXPathFuncLookupFunc f;
4909
4910
f = ctxt->funcLookupFunc;
4911
ret = f(ctxt->funcLookupData, name, NULL);
4912
if (ret != NULL)
4913
return(ret);
4914
}
4915
return(xmlXPathFunctionLookupNS(ctxt, name, NULL));
4916
}
4917
4918
/**
4919
* xmlXPathFunctionLookupNS:
4920
* @ctxt: the XPath context
4921
* @name: the function name
4922
* @ns_uri: the function namespace URI
4923
*
4924
* Search in the Function array of the context for the given
4925
* function.
4926
*
4927
* Returns the xmlXPathFunction or NULL if not found
4928
*/
4929
xmlXPathFunction
4930
xmlXPathFunctionLookupNS(xmlXPathContextPtr ctxt, const xmlChar *name,
4931
const xmlChar *ns_uri) {
4932
xmlXPathFunction ret;
4933
4934
if (ctxt == NULL)
4935
return(NULL);
4936
if (name == NULL)
4937
return(NULL);
4938
4939
if (ctxt->funcLookupFunc != NULL) {
4940
xmlXPathFuncLookupFunc f;
4941
4942
f = ctxt->funcLookupFunc;
4943
ret = f(ctxt->funcLookupData, name, ns_uri);
4944
if (ret != NULL)
4945
return(ret);
4946
}
4947
4948
if (ctxt->funcHash == NULL)
4949
return(NULL);
4950
4951
XML_CAST_FPTR(ret) = xmlHashLookup2(ctxt->funcHash, name, ns_uri);
4952
return(ret);
4953
}
4954
4955
/**
4956
* xmlXPathRegisteredFuncsCleanup:
4957
* @ctxt: the XPath context
4958
*
4959
* Cleanup the XPath context data associated to registered functions
4960
*/
4961
void
4962
xmlXPathRegisteredFuncsCleanup(xmlXPathContextPtr ctxt) {
4963
if (ctxt == NULL)
4964
return;
4965
4966
xmlHashFree(ctxt->funcHash, NULL);
4967
ctxt->funcHash = NULL;
4968
}
4969
4970
/************************************************************************
4971
* *
4972
* Routines to handle Variables *
4973
* *
4974
************************************************************************/
4975
4976
/**
4977
* xmlXPathRegisterVariable:
4978
* @ctxt: the XPath context
4979
* @name: the variable name
4980
* @value: the variable value or NULL
4981
*
4982
* Register a new variable value. If @value is NULL it unregisters
4983
* the variable
4984
*
4985
* Returns 0 in case of success, -1 in case of error
4986
*/
4987
int
4988
xmlXPathRegisterVariable(xmlXPathContextPtr ctxt, const xmlChar *name,
4989
xmlXPathObjectPtr value) {
4990
return(xmlXPathRegisterVariableNS(ctxt, name, NULL, value));
4991
}
4992
4993
/**
4994
* xmlXPathRegisterVariableNS:
4995
* @ctxt: the XPath context
4996
* @name: the variable name
4997
* @ns_uri: the variable namespace URI
4998
* @value: the variable value or NULL
4999
*
5000
* Register a new variable value. If @value is NULL it unregisters
5001
* the variable
5002
*
5003
* Returns 0 in case of success, -1 in case of error
5004
*/
5005
int
5006
xmlXPathRegisterVariableNS(xmlXPathContextPtr ctxt, const xmlChar *name,
5007
const xmlChar *ns_uri,
5008
xmlXPathObjectPtr value) {
5009
if (ctxt == NULL)
5010
return(-1);
5011
if (name == NULL)
5012
return(-1);
5013
5014
if (ctxt->varHash == NULL)
5015
ctxt->varHash = xmlHashCreate(0);
5016
if (ctxt->varHash == NULL)
5017
return(-1);
5018
if (value == NULL)
5019
return(xmlHashRemoveEntry2(ctxt->varHash, name, ns_uri,
5020
(xmlHashDeallocator)xmlXPathFreeObject));
5021
return(xmlHashUpdateEntry2(ctxt->varHash, name, ns_uri,
5022
(void *) value,
5023
(xmlHashDeallocator)xmlXPathFreeObject));
5024
}
5025
5026
/**
5027
* xmlXPathRegisterVariableLookup:
5028
* @ctxt: the XPath context
5029
* @f: the lookup function
5030
* @data: the lookup data
5031
*
5032
* register an external mechanism to do variable lookup
5033
*/
5034
void
5035
xmlXPathRegisterVariableLookup(xmlXPathContextPtr ctxt,
5036
xmlXPathVariableLookupFunc f, void *data) {
5037
if (ctxt == NULL)
5038
return;
5039
ctxt->varLookupFunc = f;
5040
ctxt->varLookupData = data;
5041
}
5042
5043
/**
5044
* xmlXPathVariableLookup:
5045
* @ctxt: the XPath context
5046
* @name: the variable name
5047
*
5048
* Search in the Variable array of the context for the given
5049
* variable value.
5050
*
5051
* Returns a copy of the value or NULL if not found
5052
*/
5053
xmlXPathObjectPtr
5054
xmlXPathVariableLookup(xmlXPathContextPtr ctxt, const xmlChar *name) {
5055
if (ctxt == NULL)
5056
return(NULL);
5057
5058
if (ctxt->varLookupFunc != NULL) {
5059
xmlXPathObjectPtr ret;
5060
5061
ret = ((xmlXPathVariableLookupFunc)ctxt->varLookupFunc)
5062
(ctxt->varLookupData, name, NULL);
5063
return(ret);
5064
}
5065
return(xmlXPathVariableLookupNS(ctxt, name, NULL));
5066
}
5067
5068
/**
5069
* xmlXPathVariableLookupNS:
5070
* @ctxt: the XPath context
5071
* @name: the variable name
5072
* @ns_uri: the variable namespace URI
5073
*
5074
* Search in the Variable array of the context for the given
5075
* variable value.
5076
*
5077
* Returns the a copy of the value or NULL if not found
5078
*/
5079
xmlXPathObjectPtr
5080
xmlXPathVariableLookupNS(xmlXPathContextPtr ctxt, const xmlChar *name,
5081
const xmlChar *ns_uri) {
5082
if (ctxt == NULL)
5083
return(NULL);
5084
5085
if (ctxt->varLookupFunc != NULL) {
5086
xmlXPathObjectPtr ret;
5087
5088
ret = ((xmlXPathVariableLookupFunc)ctxt->varLookupFunc)
5089
(ctxt->varLookupData, name, ns_uri);
5090
if (ret != NULL) return(ret);
5091
}
5092
5093
if (ctxt->varHash == NULL)
5094
return(NULL);
5095
if (name == NULL)
5096
return(NULL);
5097
5098
return(xmlXPathCacheObjectCopy(ctxt, (xmlXPathObjectPtr)
5099
xmlHashLookup2(ctxt->varHash, name, ns_uri)));
5100
}
5101
5102
/**
5103
* xmlXPathRegisteredVariablesCleanup:
5104
* @ctxt: the XPath context
5105
*
5106
* Cleanup the XPath context data associated to registered variables
5107
*/
5108
void
5109
xmlXPathRegisteredVariablesCleanup(xmlXPathContextPtr ctxt) {
5110
if (ctxt == NULL)
5111
return;
5112
5113
xmlHashFree(ctxt->varHash, (xmlHashDeallocator)xmlXPathFreeObject);
5114
ctxt->varHash = NULL;
5115
}
5116
5117
/**
5118
* xmlXPathRegisterNs:
5119
* @ctxt: the XPath context
5120
* @prefix: the namespace prefix cannot be NULL or empty string
5121
* @ns_uri: the namespace name
5122
*
5123
* Register a new namespace. If @ns_uri is NULL it unregisters
5124
* the namespace
5125
*
5126
* Returns 0 in case of success, -1 in case of error
5127
*/
5128
int
5129
xmlXPathRegisterNs(xmlXPathContextPtr ctxt, const xmlChar *prefix,
5130
const xmlChar *ns_uri) {
5131
if (ctxt == NULL)
5132
return(-1);
5133
if (prefix == NULL)
5134
return(-1);
5135
if (prefix[0] == 0)
5136
return(-1);
5137
5138
if (ctxt->nsHash == NULL)
5139
ctxt->nsHash = xmlHashCreate(10);
5140
if (ctxt->nsHash == NULL)
5141
return(-1);
5142
if (ns_uri == NULL)
5143
return(xmlHashRemoveEntry(ctxt->nsHash, prefix,
5144
(xmlHashDeallocator)xmlFree));
5145
return(xmlHashUpdateEntry(ctxt->nsHash, prefix, (void *) xmlStrdup(ns_uri),
5146
(xmlHashDeallocator)xmlFree));
5147
}
5148
5149
/**
5150
* xmlXPathNsLookup:
5151
* @ctxt: the XPath context
5152
* @prefix: the namespace prefix value
5153
*
5154
* Search in the namespace declaration array of the context for the given
5155
* namespace name associated to the given prefix
5156
*
5157
* Returns the value or NULL if not found
5158
*/
5159
const xmlChar *
5160
xmlXPathNsLookup(xmlXPathContextPtr ctxt, const xmlChar *prefix) {
5161
if (ctxt == NULL)
5162
return(NULL);
5163
if (prefix == NULL)
5164
return(NULL);
5165
5166
#ifdef XML_XML_NAMESPACE
5167
if (xmlStrEqual(prefix, (const xmlChar *) "xml"))
5168
return(XML_XML_NAMESPACE);
5169
#endif
5170
5171
if (ctxt->namespaces != NULL) {
5172
int i;
5173
5174
for (i = 0;i < ctxt->nsNr;i++) {
5175
if ((ctxt->namespaces[i] != NULL) &&
5176
(xmlStrEqual(ctxt->namespaces[i]->prefix, prefix)))
5177
return(ctxt->namespaces[i]->href);
5178
}
5179
}
5180
5181
return((const xmlChar *) xmlHashLookup(ctxt->nsHash, prefix));
5182
}
5183
5184
/**
5185
* xmlXPathRegisteredNsCleanup:
5186
* @ctxt: the XPath context
5187
*
5188
* Cleanup the XPath context data associated to registered variables
5189
*/
5190
void
5191
xmlXPathRegisteredNsCleanup(xmlXPathContextPtr ctxt) {
5192
if (ctxt == NULL)
5193
return;
5194
5195
xmlHashFree(ctxt->nsHash, (xmlHashDeallocator)xmlFree);
5196
ctxt->nsHash = NULL;
5197
}
5198
5199
/************************************************************************
5200
* *
5201
* Routines to handle Values *
5202
* *
5203
************************************************************************/
5204
5205
/* Allocations are terrible, one needs to optimize all this !!! */
5206
5207
/**
5208
* xmlXPathNewFloat:
5209
* @val: the double value
5210
*
5211
* Create a new xmlXPathObjectPtr of type double and of value @val
5212
*
5213
* Returns the newly created object.
5214
*/
5215
xmlXPathObjectPtr
5216
xmlXPathNewFloat(double val) {
5217
xmlXPathObjectPtr ret;
5218
5219
ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
5220
if (ret == NULL) {
5221
xmlXPathErrMemory(NULL, "creating float object\n");
5222
return(NULL);
5223
}
5224
memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
5225
ret->type = XPATH_NUMBER;
5226
ret->floatval = val;
5227
#ifdef XP_DEBUG_OBJ_USAGE
5228
xmlXPathDebugObjUsageRequested(NULL, XPATH_NUMBER);
5229
#endif
5230
return(ret);
5231
}
5232
5233
/**
5234
* xmlXPathNewBoolean:
5235
* @val: the boolean value
5236
*
5237
* Create a new xmlXPathObjectPtr of type boolean and of value @val
5238
*
5239
* Returns the newly created object.
5240
*/
5241
xmlXPathObjectPtr
5242
xmlXPathNewBoolean(int val) {
5243
xmlXPathObjectPtr ret;
5244
5245
ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
5246
if (ret == NULL) {
5247
xmlXPathErrMemory(NULL, "creating boolean object\n");
5248
return(NULL);
5249
}
5250
memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
5251
ret->type = XPATH_BOOLEAN;
5252
ret->boolval = (val != 0);
5253
#ifdef XP_DEBUG_OBJ_USAGE
5254
xmlXPathDebugObjUsageRequested(NULL, XPATH_BOOLEAN);
5255
#endif
5256
return(ret);
5257
}
5258
5259
/**
5260
* xmlXPathNewString:
5261
* @val: the xmlChar * value
5262
*
5263
* Create a new xmlXPathObjectPtr of type string and of value @val
5264
*
5265
* Returns the newly created object.
5266
*/
5267
xmlXPathObjectPtr
5268
xmlXPathNewString(const xmlChar *val) {
5269
xmlXPathObjectPtr ret;
5270
5271
ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
5272
if (ret == NULL) {
5273
xmlXPathErrMemory(NULL, "creating string object\n");
5274
return(NULL);
5275
}
5276
memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
5277
ret->type = XPATH_STRING;
5278
if (val != NULL)
5279
ret->stringval = xmlStrdup(val);
5280
else
5281
ret->stringval = xmlStrdup((const xmlChar *)"");
5282
#ifdef XP_DEBUG_OBJ_USAGE
5283
xmlXPathDebugObjUsageRequested(NULL, XPATH_STRING);
5284
#endif
5285
return(ret);
5286
}
5287
5288
/**
5289
* xmlXPathWrapString:
5290
* @val: the xmlChar * value
5291
*
5292
* Wraps the @val string into an XPath object.
5293
*
5294
* Returns the newly created object.
5295
*/
5296
xmlXPathObjectPtr
5297
xmlXPathWrapString (xmlChar *val) {
5298
xmlXPathObjectPtr ret;
5299
5300
ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
5301
if (ret == NULL) {
5302
xmlXPathErrMemory(NULL, "creating string object\n");
5303
return(NULL);
5304
}
5305
memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
5306
ret->type = XPATH_STRING;
5307
ret->stringval = val;
5308
#ifdef XP_DEBUG_OBJ_USAGE
5309
xmlXPathDebugObjUsageRequested(NULL, XPATH_STRING);
5310
#endif
5311
return(ret);
5312
}
5313
5314
/**
5315
* xmlXPathNewCString:
5316
* @val: the char * value
5317
*
5318
* Create a new xmlXPathObjectPtr of type string and of value @val
5319
*
5320
* Returns the newly created object.
5321
*/
5322
xmlXPathObjectPtr
5323
xmlXPathNewCString(const char *val) {
5324
xmlXPathObjectPtr ret;
5325
5326
ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
5327
if (ret == NULL) {
5328
xmlXPathErrMemory(NULL, "creating string object\n");
5329
return(NULL);
5330
}
5331
memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
5332
ret->type = XPATH_STRING;
5333
ret->stringval = xmlStrdup(BAD_CAST val);
5334
#ifdef XP_DEBUG_OBJ_USAGE
5335
xmlXPathDebugObjUsageRequested(NULL, XPATH_STRING);
5336
#endif
5337
return(ret);
5338
}
5339
5340
/**
5341
* xmlXPathWrapCString:
5342
* @val: the char * value
5343
*
5344
* Wraps a string into an XPath object.
5345
*
5346
* Returns the newly created object.
5347
*/
5348
xmlXPathObjectPtr
5349
xmlXPathWrapCString (char * val) {
5350
return(xmlXPathWrapString((xmlChar *)(val)));
5351
}
5352
5353
/**
5354
* xmlXPathWrapExternal:
5355
* @val: the user data
5356
*
5357
* Wraps the @val data into an XPath object.
5358
*
5359
* Returns the newly created object.
5360
*/
5361
xmlXPathObjectPtr
5362
xmlXPathWrapExternal (void *val) {
5363
xmlXPathObjectPtr ret;
5364
5365
ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
5366
if (ret == NULL) {
5367
xmlXPathErrMemory(NULL, "creating user object\n");
5368
return(NULL);
5369
}
5370
memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
5371
ret->type = XPATH_USERS;
5372
ret->user = val;
5373
#ifdef XP_DEBUG_OBJ_USAGE
5374
xmlXPathDebugObjUsageRequested(NULL, XPATH_USERS);
5375
#endif
5376
return(ret);
5377
}
5378
5379
/**
5380
* xmlXPathObjectCopy:
5381
* @val: the original object
5382
*
5383
* allocate a new copy of a given object
5384
*
5385
* Returns the newly created object.
5386
*/
5387
xmlXPathObjectPtr
5388
xmlXPathObjectCopy(xmlXPathObjectPtr val) {
5389
xmlXPathObjectPtr ret;
5390
5391
if (val == NULL)
5392
return(NULL);
5393
5394
ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
5395
if (ret == NULL) {
5396
xmlXPathErrMemory(NULL, "copying object\n");
5397
return(NULL);
5398
}
5399
memcpy(ret, val , (size_t) sizeof(xmlXPathObject));
5400
#ifdef XP_DEBUG_OBJ_USAGE
5401
xmlXPathDebugObjUsageRequested(NULL, val->type);
5402
#endif
5403
switch (val->type) {
5404
case XPATH_BOOLEAN:
5405
case XPATH_NUMBER:
5406
case XPATH_POINT:
5407
case XPATH_RANGE:
5408
break;
5409
case XPATH_STRING:
5410
ret->stringval = xmlStrdup(val->stringval);
5411
break;
5412
case XPATH_XSLT_TREE:
5413
#if 0
5414
/*
5415
Removed 11 July 2004 - the current handling of xslt tmpRVT nodes means that
5416
this previous handling is no longer correct, and can cause some serious
5417
problems (ref. bug 145547)
5418
*/
5419
if ((val->nodesetval != NULL) &&
5420
(val->nodesetval->nodeTab != NULL)) {
5421
xmlNodePtr cur, tmp;
5422
xmlDocPtr top;
5423
5424
ret->boolval = 1;
5425
top = xmlNewDoc(NULL);
5426
top->name = (char *)
5427
xmlStrdup(val->nodesetval->nodeTab[0]->name);
5428
ret->user = top;
5429
if (top != NULL) {
5430
top->doc = top;
5431
cur = val->nodesetval->nodeTab[0]->children;
5432
while (cur != NULL) {
5433
tmp = xmlDocCopyNode(cur, top, 1);
5434
xmlAddChild((xmlNodePtr) top, tmp);
5435
cur = cur->next;
5436
}
5437
}
5438
5439
ret->nodesetval = xmlXPathNodeSetCreate((xmlNodePtr) top);
5440
} else
5441
ret->nodesetval = xmlXPathNodeSetCreate(NULL);
5442
/* Deallocate the copied tree value */
5443
break;
5444
#endif
5445
case XPATH_NODESET:
5446
ret->nodesetval = xmlXPathNodeSetMerge(NULL, val->nodesetval);
5447
/* Do not deallocate the copied tree value */
5448
ret->boolval = 0;
5449
break;
5450
case XPATH_LOCATIONSET:
5451
#ifdef LIBXML_XPTR_ENABLED
5452
{
5453
xmlLocationSetPtr loc = val->user;
5454
ret->user = (void *) xmlXPtrLocationSetMerge(NULL, loc);
5455
break;
5456
}
5457
#endif
5458
case XPATH_USERS:
5459
ret->user = val->user;
5460
break;
5461
case XPATH_UNDEFINED:
5462
xmlGenericError(xmlGenericErrorContext,
5463
"xmlXPathObjectCopy: unsupported type %d\n",
5464
val->type);
5465
break;
5466
}
5467
return(ret);
5468
}
5469
5470
/**
5471
* xmlXPathFreeObject:
5472
* @obj: the object to free
5473
*
5474
* Free up an xmlXPathObjectPtr object.
5475
*/
5476
void
5477
xmlXPathFreeObject(xmlXPathObjectPtr obj) {
5478
if (obj == NULL) return;
5479
if ((obj->type == XPATH_NODESET) || (obj->type == XPATH_XSLT_TREE)) {
5480
if (obj->boolval) {
5481
#if 0
5482
if (obj->user != NULL) {
5483
xmlXPathFreeNodeSet(obj->nodesetval);
5484
xmlFreeNodeList((xmlNodePtr) obj->user);
5485
} else
5486
#endif
5487
obj->type = XPATH_XSLT_TREE; /* TODO: Just for debugging. */
5488
if (obj->nodesetval != NULL)
5489
xmlXPathFreeValueTree(obj->nodesetval);
5490
} else {
5491
if (obj->nodesetval != NULL)
5492
xmlXPathFreeNodeSet(obj->nodesetval);
5493
}
5494
#ifdef LIBXML_XPTR_ENABLED
5495
} else if (obj->type == XPATH_LOCATIONSET) {
5496
if (obj->user != NULL)
5497
xmlXPtrFreeLocationSet(obj->user);
5498
#endif
5499
} else if (obj->type == XPATH_STRING) {
5500
if (obj->stringval != NULL)
5501
xmlFree(obj->stringval);
5502
}
5503
#ifdef XP_DEBUG_OBJ_USAGE
5504
xmlXPathDebugObjUsageReleased(NULL, obj->type);
5505
#endif
5506
xmlFree(obj);
5507
}
5508
5509
/**
5510
* xmlXPathReleaseObject:
5511
* @obj: the xmlXPathObjectPtr to free or to cache
5512
*
5513
* Depending on the state of the cache this frees the given
5514
* XPath object or stores it in the cache.
5515
*/
5516
static void
5517
xmlXPathReleaseObject(xmlXPathContextPtr ctxt, xmlXPathObjectPtr obj)
5518
{
5519
#define XP_CACHE_ADD(sl, o) if (sl == NULL) { \
5520
sl = xmlPointerListCreate(10); if (sl == NULL) goto free_obj; } \
5521
if (xmlPointerListAddSize(sl, obj, 0) == -1) goto free_obj;
5522
5523
#define XP_CACHE_WANTS(sl, n) ((sl == NULL) || ((sl)->number < n))
5524
5525
if (obj == NULL)
5526
return;
5527
if ((ctxt == NULL) || (ctxt->cache == NULL)) {
5528
xmlXPathFreeObject(obj);
5529
} else {
5530
xmlXPathContextCachePtr cache =
5531
(xmlXPathContextCachePtr) ctxt->cache;
5532
5533
switch (obj->type) {
5534
case XPATH_NODESET:
5535
case XPATH_XSLT_TREE:
5536
if (obj->nodesetval != NULL) {
5537
if (obj->boolval) {
5538
/*
5539
* It looks like the @boolval is used for
5540
* evaluation if this an XSLT Result Tree Fragment.
5541
* TODO: Check if this assumption is correct.
5542
*/
5543
obj->type = XPATH_XSLT_TREE; /* just for debugging */
5544
xmlXPathFreeValueTree(obj->nodesetval);
5545
obj->nodesetval = NULL;
5546
} else if ((obj->nodesetval->nodeMax <= 40) &&
5547
(XP_CACHE_WANTS(cache->nodesetObjs,
5548
cache->maxNodeset)))
5549
{
5550
XP_CACHE_ADD(cache->nodesetObjs, obj);
5551
goto obj_cached;
5552
} else {
5553
xmlXPathFreeNodeSet(obj->nodesetval);
5554
obj->nodesetval = NULL;
5555
}
5556
}
5557
break;
5558
case XPATH_STRING:
5559
if (obj->stringval != NULL)
5560
xmlFree(obj->stringval);
5561
5562
if (XP_CACHE_WANTS(cache->stringObjs, cache->maxString)) {
5563
XP_CACHE_ADD(cache->stringObjs, obj);
5564
goto obj_cached;
5565
}
5566
break;
5567
case XPATH_BOOLEAN:
5568
if (XP_CACHE_WANTS(cache->booleanObjs, cache->maxBoolean)) {
5569
XP_CACHE_ADD(cache->booleanObjs, obj);
5570
goto obj_cached;
5571
}
5572
break;
5573
case XPATH_NUMBER:
5574
if (XP_CACHE_WANTS(cache->numberObjs, cache->maxNumber)) {
5575
XP_CACHE_ADD(cache->numberObjs, obj);
5576
goto obj_cached;
5577
}
5578
break;
5579
#ifdef LIBXML_XPTR_ENABLED
5580
case XPATH_LOCATIONSET:
5581
if (obj->user != NULL) {
5582
xmlXPtrFreeLocationSet(obj->user);
5583
}
5584
goto free_obj;
5585
#endif
5586
default:
5587
goto free_obj;
5588
}
5589
5590
/*
5591
* Fallback to adding to the misc-objects slot.
5592
*/
5593
if (XP_CACHE_WANTS(cache->miscObjs, cache->maxMisc)) {
5594
XP_CACHE_ADD(cache->miscObjs, obj);
5595
} else
5596
goto free_obj;
5597
5598
obj_cached:
5599
5600
#ifdef XP_DEBUG_OBJ_USAGE
5601
xmlXPathDebugObjUsageReleased(ctxt, obj->type);
5602
#endif
5603
5604
if (obj->nodesetval != NULL) {
5605
xmlNodeSetPtr tmpset = obj->nodesetval;
5606
5607
/*
5608
* TODO: Due to those nasty ns-nodes, we need to traverse
5609
* the list and free the ns-nodes.
5610
* URGENT TODO: Check if it's actually slowing things down.
5611
* Maybe we shouldn't try to preserve the list.
5612
*/
5613
if (tmpset->nodeNr > 1) {
5614
int i;
5615
xmlNodePtr node;
5616
5617
for (i = 0; i < tmpset->nodeNr; i++) {
5618
node = tmpset->nodeTab[i];
5619
if ((node != NULL) &&
5620
(node->type == XML_NAMESPACE_DECL))
5621
{
5622
xmlXPathNodeSetFreeNs((xmlNsPtr) node);
5623
}
5624
}
5625
} else if (tmpset->nodeNr == 1) {
5626
if ((tmpset->nodeTab[0] != NULL) &&
5627
(tmpset->nodeTab[0]->type == XML_NAMESPACE_DECL))
5628
xmlXPathNodeSetFreeNs((xmlNsPtr) tmpset->nodeTab[0]);
5629
}
5630
tmpset->nodeNr = 0;
5631
memset(obj, 0, sizeof(xmlXPathObject));
5632
obj->nodesetval = tmpset;
5633
} else
5634
memset(obj, 0, sizeof(xmlXPathObject));
5635
5636
return;
5637
5638
free_obj:
5639
/*
5640
* Cache is full; free the object.
5641
*/
5642
if (obj->nodesetval != NULL)
5643
xmlXPathFreeNodeSet(obj->nodesetval);
5644
#ifdef XP_DEBUG_OBJ_USAGE
5645
xmlXPathDebugObjUsageReleased(NULL, obj->type);
5646
#endif
5647
xmlFree(obj);
5648
}
5649
return;
5650
}
5651
5652
5653
/************************************************************************
5654
* *
5655
* Type Casting Routines *
5656
* *
5657
************************************************************************/
5658
5659
/**
5660
* xmlXPathCastBooleanToString:
5661
* @val: a boolean
5662
*
5663
* Converts a boolean to its string value.
5664
*
5665
* Returns a newly allocated string.
5666
*/
5667
xmlChar *
5668
xmlXPathCastBooleanToString (int val) {
5669
xmlChar *ret;
5670
if (val)
5671
ret = xmlStrdup((const xmlChar *) "true");
5672
else
5673
ret = xmlStrdup((const xmlChar *) "false");
5674
return(ret);
5675
}
5676
5677
/**
5678
* xmlXPathCastNumberToString:
5679
* @val: a number
5680
*
5681
* Converts a number to its string value.
5682
*
5683
* Returns a newly allocated string.
5684
*/
5685
xmlChar *
5686
xmlXPathCastNumberToString (double val) {
5687
xmlChar *ret;
5688
switch (xmlXPathIsInf(val)) {
5689
case 1:
5690
ret = xmlStrdup((const xmlChar *) "Infinity");
5691
break;
5692
case -1:
5693
ret = xmlStrdup((const xmlChar *) "-Infinity");
5694
break;
5695
default:
5696
if (xmlXPathIsNaN(val)) {
5697
ret = xmlStrdup((const xmlChar *) "NaN");
5698
} else if (val == 0 && xmlXPathGetSign(val) != 0) {
5699
ret = xmlStrdup((const xmlChar *) "0");
5700
} else {
5701
/* could be improved */
5702
char buf[100];
5703
xmlXPathFormatNumber(val, buf, 99);
5704
buf[99] = 0;
5705
ret = xmlStrdup((const xmlChar *) buf);
5706
}
5707
}
5708
return(ret);
5709
}
5710
5711
/**
5712
* xmlXPathCastNodeToString:
5713
* @node: a node
5714
*
5715
* Converts a node to its string value.
5716
*
5717
* Returns a newly allocated string.
5718
*/
5719
xmlChar *
5720
xmlXPathCastNodeToString (xmlNodePtr node) {
5721
xmlChar *ret;
5722
if ((ret = xmlNodeGetContent(node)) == NULL)
5723
ret = xmlStrdup((const xmlChar *) "");
5724
return(ret);
5725
}
5726
5727
/**
5728
* xmlXPathCastNodeSetToString:
5729
* @ns: a node-set
5730
*
5731
* Converts a node-set to its string value.
5732
*
5733
* Returns a newly allocated string.
5734
*/
5735
xmlChar *
5736
xmlXPathCastNodeSetToString (xmlNodeSetPtr ns) {
5737
if ((ns == NULL) || (ns->nodeNr == 0) || (ns->nodeTab == NULL))
5738
return(xmlStrdup((const xmlChar *) ""));
5739
5740
if (ns->nodeNr > 1)
5741
xmlXPathNodeSetSort(ns);
5742
return(xmlXPathCastNodeToString(ns->nodeTab[0]));
5743
}
5744
5745
/**
5746
* xmlXPathCastToString:
5747
* @val: an XPath object
5748
*
5749
* Converts an existing object to its string() equivalent
5750
*
5751
* Returns the allocated string value of the object, NULL in case of error.
5752
* It's up to the caller to free the string memory with xmlFree().
5753
*/
5754
xmlChar *
5755
xmlXPathCastToString(xmlXPathObjectPtr val) {
5756
xmlChar *ret = NULL;
5757
5758
if (val == NULL)
5759
return(xmlStrdup((const xmlChar *) ""));
5760
switch (val->type) {
5761
case XPATH_UNDEFINED:
5762
#ifdef DEBUG_EXPR
5763
xmlGenericError(xmlGenericErrorContext, "String: undefined\n");
5764
#endif
5765
ret = xmlStrdup((const xmlChar *) "");
5766
break;
5767
case XPATH_NODESET:
5768
case XPATH_XSLT_TREE:
5769
ret = xmlXPathCastNodeSetToString(val->nodesetval);
5770
break;
5771
case XPATH_STRING:
5772
return(xmlStrdup(val->stringval));
5773
case XPATH_BOOLEAN:
5774
ret = xmlXPathCastBooleanToString(val->boolval);
5775
break;
5776
case XPATH_NUMBER: {
5777
ret = xmlXPathCastNumberToString(val->floatval);
5778
break;
5779
}
5780
case XPATH_USERS:
5781
case XPATH_POINT:
5782
case XPATH_RANGE:
5783
case XPATH_LOCATIONSET:
5784
TODO
5785
ret = xmlStrdup((const xmlChar *) "");
5786
break;
5787
}
5788
return(ret);
5789
}
5790
5791
/**
5792
* xmlXPathConvertString:
5793
* @val: an XPath object
5794
*
5795
* Converts an existing object to its string() equivalent
5796
*
5797
* Returns the new object, the old one is freed (or the operation
5798
* is done directly on @val)
5799
*/
5800
xmlXPathObjectPtr
5801
xmlXPathConvertString(xmlXPathObjectPtr val) {
5802
xmlChar *res = NULL;
5803
5804
if (val == NULL)
5805
return(xmlXPathNewCString(""));
5806
5807
switch (val->type) {
5808
case XPATH_UNDEFINED:
5809
#ifdef DEBUG_EXPR
5810
xmlGenericError(xmlGenericErrorContext, "STRING: undefined\n");
5811
#endif
5812
break;
5813
case XPATH_NODESET:
5814
case XPATH_XSLT_TREE:
5815
res = xmlXPathCastNodeSetToString(val->nodesetval);
5816
break;
5817
case XPATH_STRING:
5818
return(val);
5819
case XPATH_BOOLEAN:
5820
res = xmlXPathCastBooleanToString(val->boolval);
5821
break;
5822
case XPATH_NUMBER:
5823
res = xmlXPathCastNumberToString(val->floatval);
5824
break;
5825
case XPATH_USERS:
5826
case XPATH_POINT:
5827
case XPATH_RANGE:
5828
case XPATH_LOCATIONSET:
5829
TODO;
5830
break;
5831
}
5832
xmlXPathFreeObject(val);
5833
if (res == NULL)
5834
return(xmlXPathNewCString(""));
5835
return(xmlXPathWrapString(res));
5836
}
5837
5838
/**
5839
* xmlXPathCastBooleanToNumber:
5840
* @val: a boolean
5841
*
5842
* Converts a boolean to its number value
5843
*
5844
* Returns the number value
5845
*/
5846
double
5847
xmlXPathCastBooleanToNumber(int val) {
5848
if (val)
5849
return(1.0);
5850
return(0.0);
5851
}
5852
5853
/**
5854
* xmlXPathCastStringToNumber:
5855
* @val: a string
5856
*
5857
* Converts a string to its number value
5858
*
5859
* Returns the number value
5860
*/
5861
double
5862
xmlXPathCastStringToNumber(const xmlChar * val) {
5863
return(xmlXPathStringEvalNumber(val));
5864
}
5865
5866
/**
5867
* xmlXPathCastNodeToNumber:
5868
* @node: a node
5869
*
5870
* Converts a node to its number value
5871
*
5872
* Returns the number value
5873
*/
5874
double
5875
xmlXPathCastNodeToNumber (xmlNodePtr node) {
5876
xmlChar *strval;
5877
double ret;
5878
5879
if (node == NULL)
5880
return(xmlXPathNAN);
5881
strval = xmlXPathCastNodeToString(node);
5882
if (strval == NULL)
5883
return(xmlXPathNAN);
5884
ret = xmlXPathCastStringToNumber(strval);
5885
xmlFree(strval);
5886
5887
return(ret);
5888
}
5889
5890
/**
5891
* xmlXPathCastNodeSetToNumber:
5892
* @ns: a node-set
5893
*
5894
* Converts a node-set to its number value
5895
*
5896
* Returns the number value
5897
*/
5898
double
5899
xmlXPathCastNodeSetToNumber (xmlNodeSetPtr ns) {
5900
xmlChar *str;
5901
double ret;
5902
5903
if (ns == NULL)
5904
return(xmlXPathNAN);
5905
str = xmlXPathCastNodeSetToString(ns);
5906
ret = xmlXPathCastStringToNumber(str);
5907
xmlFree(str);
5908
return(ret);
5909
}
5910
5911
/**
5912
* xmlXPathCastToNumber:
5913
* @val: an XPath object
5914
*
5915
* Converts an XPath object to its number value
5916
*
5917
* Returns the number value
5918
*/
5919
double
5920
xmlXPathCastToNumber(xmlXPathObjectPtr val) {
5921
double ret = 0.0;
5922
5923
if (val == NULL)
5924
return(xmlXPathNAN);
5925
switch (val->type) {
5926
case XPATH_UNDEFINED:
5927
#ifdef DEGUB_EXPR
5928
xmlGenericError(xmlGenericErrorContext, "NUMBER: undefined\n");
5929
#endif
5930
ret = xmlXPathNAN;
5931
break;
5932
case XPATH_NODESET:
5933
case XPATH_XSLT_TREE:
5934
ret = xmlXPathCastNodeSetToNumber(val->nodesetval);
5935
break;
5936
case XPATH_STRING:
5937
ret = xmlXPathCastStringToNumber(val->stringval);
5938
break;
5939
case XPATH_NUMBER:
5940
ret = val->floatval;
5941
break;
5942
case XPATH_BOOLEAN:
5943
ret = xmlXPathCastBooleanToNumber(val->boolval);
5944
break;
5945
case XPATH_USERS:
5946
case XPATH_POINT:
5947
case XPATH_RANGE:
5948
case XPATH_LOCATIONSET:
5949
TODO;
5950
ret = xmlXPathNAN;
5951
break;
5952
}
5953
return(ret);
5954
}
5955
5956
/**
5957
* xmlXPathConvertNumber:
5958
* @val: an XPath object
5959
*
5960
* Converts an existing object to its number() equivalent
5961
*
5962
* Returns the new object, the old one is freed (or the operation
5963
* is done directly on @val)
5964
*/
5965
xmlXPathObjectPtr
5966
xmlXPathConvertNumber(xmlXPathObjectPtr val) {
5967
xmlXPathObjectPtr ret;
5968
5969
if (val == NULL)
5970
return(xmlXPathNewFloat(0.0));
5971
if (val->type == XPATH_NUMBER)
5972
return(val);
5973
ret = xmlXPathNewFloat(xmlXPathCastToNumber(val));
5974
xmlXPathFreeObject(val);
5975
return(ret);
5976
}
5977
5978
/**
5979
* xmlXPathCastNumberToBoolean:
5980
* @val: a number
5981
*
5982
* Converts a number to its boolean value
5983
*
5984
* Returns the boolean value
5985
*/
5986
int
5987
xmlXPathCastNumberToBoolean (double val) {
5988
if (xmlXPathIsNaN(val) || (val == 0.0))
5989
return(0);
5990
return(1);
5991
}
5992
5993
/**
5994
* xmlXPathCastStringToBoolean:
5995
* @val: a string
5996
*
5997
* Converts a string to its boolean value
5998
*
5999
* Returns the boolean value
6000
*/
6001
int
6002
xmlXPathCastStringToBoolean (const xmlChar *val) {
6003
if ((val == NULL) || (xmlStrlen(val) == 0))
6004
return(0);
6005
return(1);
6006
}
6007
6008
/**
6009
* xmlXPathCastNodeSetToBoolean:
6010
* @ns: a node-set
6011
*
6012
* Converts a node-set to its boolean value
6013
*
6014
* Returns the boolean value
6015
*/
6016
int
6017
xmlXPathCastNodeSetToBoolean (xmlNodeSetPtr ns) {
6018
if ((ns == NULL) || (ns->nodeNr == 0))
6019
return(0);
6020
return(1);
6021
}
6022
6023
/**
6024
* xmlXPathCastToBoolean:
6025
* @val: an XPath object
6026
*
6027
* Converts an XPath object to its boolean value
6028
*
6029
* Returns the boolean value
6030
*/
6031
int
6032
xmlXPathCastToBoolean (xmlXPathObjectPtr val) {
6033
int ret = 0;
6034
6035
if (val == NULL)
6036
return(0);
6037
switch (val->type) {
6038
case XPATH_UNDEFINED:
6039
#ifdef DEBUG_EXPR
6040
xmlGenericError(xmlGenericErrorContext, "BOOLEAN: undefined\n");
6041
#endif
6042
ret = 0;
6043
break;
6044
case XPATH_NODESET:
6045
case XPATH_XSLT_TREE:
6046
ret = xmlXPathCastNodeSetToBoolean(val->nodesetval);
6047
break;
6048
case XPATH_STRING:
6049
ret = xmlXPathCastStringToBoolean(val->stringval);
6050
break;
6051
case XPATH_NUMBER:
6052
ret = xmlXPathCastNumberToBoolean(val->floatval);
6053
break;
6054
case XPATH_BOOLEAN:
6055
ret = val->boolval;
6056
break;
6057
case XPATH_USERS:
6058
case XPATH_POINT:
6059
case XPATH_RANGE:
6060
case XPATH_LOCATIONSET:
6061
TODO;
6062
ret = 0;
6063
break;
6064
}
6065
return(ret);
6066
}
6067
6068
6069
/**
6070
* xmlXPathConvertBoolean:
6071
* @val: an XPath object
6072
*
6073
* Converts an existing object to its boolean() equivalent
6074
*
6075
* Returns the new object, the old one is freed (or the operation
6076
* is done directly on @val)
6077
*/
6078
xmlXPathObjectPtr
6079
xmlXPathConvertBoolean(xmlXPathObjectPtr val) {
6080
xmlXPathObjectPtr ret;
6081
6082
if (val == NULL)
6083
return(xmlXPathNewBoolean(0));
6084
if (val->type == XPATH_BOOLEAN)
6085
return(val);
6086
ret = xmlXPathNewBoolean(xmlXPathCastToBoolean(val));
6087
xmlXPathFreeObject(val);
6088
return(ret);
6089
}
6090
6091
/************************************************************************
6092
* *
6093
* Routines to handle XPath contexts *
6094
* *
6095
************************************************************************/
6096
6097
/**
6098
* xmlXPathNewContext:
6099
* @doc: the XML document
6100
*
6101
* Create a new xmlXPathContext
6102
*
6103
* Returns the xmlXPathContext just allocated. The caller will need to free it.
6104
*/
6105
xmlXPathContextPtr
6106
xmlXPathNewContext(xmlDocPtr doc) {
6107
xmlXPathContextPtr ret;
6108
6109
ret = (xmlXPathContextPtr) xmlMalloc(sizeof(xmlXPathContext));
6110
if (ret == NULL) {
6111
xmlXPathErrMemory(NULL, "creating context\n");
6112
return(NULL);
6113
}
6114
memset(ret, 0 , (size_t) sizeof(xmlXPathContext));
6115
ret->doc = doc;
6116
ret->node = NULL;
6117
6118
ret->varHash = NULL;
6119
6120
ret->nb_types = 0;
6121
ret->max_types = 0;
6122
ret->types = NULL;
6123
6124
ret->funcHash = xmlHashCreate(0);
6125
6126
ret->nb_axis = 0;
6127
ret->max_axis = 0;
6128
ret->axis = NULL;
6129
6130
ret->nsHash = NULL;
6131
ret->user = NULL;
6132
6133
ret->contextSize = -1;
6134
ret->proximityPosition = -1;
6135
6136
#ifdef XP_DEFAULT_CACHE_ON
6137
if (xmlXPathContextSetCache(ret, 1, -1, 0) == -1) {
6138
xmlXPathFreeContext(ret);
6139
return(NULL);
6140
}
6141
#endif
6142
6143
xmlXPathRegisterAllFunctions(ret);
6144
6145
return(ret);
6146
}
6147
6148
/**
6149
* xmlXPathFreeContext:
6150
* @ctxt: the context to free
6151
*
6152
* Free up an xmlXPathContext
6153
*/
6154
void
6155
xmlXPathFreeContext(xmlXPathContextPtr ctxt) {
6156
if (ctxt == NULL) return;
6157
6158
if (ctxt->cache != NULL)
6159
xmlXPathFreeCache((xmlXPathContextCachePtr) ctxt->cache);
6160
xmlXPathRegisteredNsCleanup(ctxt);
6161
xmlXPathRegisteredFuncsCleanup(ctxt);
6162
xmlXPathRegisteredVariablesCleanup(ctxt);
6163
xmlResetError(&ctxt->lastError);
6164
xmlFree(ctxt);
6165
}
6166
6167
/************************************************************************
6168
* *
6169
* Routines to handle XPath parser contexts *
6170
* *
6171
************************************************************************/
6172
6173
#define CHECK_CTXT(ctxt) \
6174
if (ctxt == NULL) { \
6175
__xmlRaiseError(NULL, NULL, NULL, \
6176
NULL, NULL, XML_FROM_XPATH, \
6177
XML_ERR_INTERNAL_ERROR, XML_ERR_FATAL, \
6178
__FILE__, __LINE__, \
6179
NULL, NULL, NULL, 0, 0, \
6180
"NULL context pointer\n"); \
6181
return(NULL); \
6182
} \
6183
6184
#define CHECK_CTXT_NEG(ctxt) \
6185
if (ctxt == NULL) { \
6186
__xmlRaiseError(NULL, NULL, NULL, \
6187
NULL, NULL, XML_FROM_XPATH, \
6188
XML_ERR_INTERNAL_ERROR, XML_ERR_FATAL, \
6189
__FILE__, __LINE__, \
6190
NULL, NULL, NULL, 0, 0, \
6191
"NULL context pointer\n"); \
6192
return(-1); \
6193
} \
6194
6195
6196
#define CHECK_CONTEXT(ctxt) \
6197
if ((ctxt == NULL) || (ctxt->doc == NULL) || \
6198
(ctxt->doc->children == NULL)) { \
6199
xmlXPatherror(ctxt, __FILE__, __LINE__, XPATH_INVALID_CTXT); \
6200
return(NULL); \
6201
}
6202
6203
6204
/**
6205
* xmlXPathNewParserContext:
6206
* @str: the XPath expression
6207
* @ctxt: the XPath context
6208
*
6209
* Create a new xmlXPathParserContext
6210
*
6211
* Returns the xmlXPathParserContext just allocated.
6212
*/
6213
xmlXPathParserContextPtr
6214
xmlXPathNewParserContext(const xmlChar *str, xmlXPathContextPtr ctxt) {
6215
xmlXPathParserContextPtr ret;
6216
6217
ret = (xmlXPathParserContextPtr) xmlMalloc(sizeof(xmlXPathParserContext));
6218
if (ret == NULL) {
6219
xmlXPathErrMemory(ctxt, "creating parser context\n");
6220
return(NULL);
6221
}
6222
memset(ret, 0 , (size_t) sizeof(xmlXPathParserContext));
6223
ret->cur = ret->base = str;
6224
ret->context = ctxt;
6225
6226
ret->comp = xmlXPathNewCompExpr();
6227
if (ret->comp == NULL) {
6228
xmlFree(ret->valueTab);
6229
xmlFree(ret);
6230
return(NULL);
6231
}
6232
if ((ctxt != NULL) && (ctxt->dict != NULL)) {
6233
ret->comp->dict = ctxt->dict;
6234
xmlDictReference(ret->comp->dict);
6235
}
6236
6237
return(ret);
6238
}
6239
6240
/**
6241
* xmlXPathCompParserContext:
6242
* @comp: the XPath compiled expression
6243
* @ctxt: the XPath context
6244
*
6245
* Create a new xmlXPathParserContext when processing a compiled expression
6246
*
6247
* Returns the xmlXPathParserContext just allocated.
6248
*/
6249
static xmlXPathParserContextPtr
6250
xmlXPathCompParserContext(xmlXPathCompExprPtr comp, xmlXPathContextPtr ctxt) {
6251
xmlXPathParserContextPtr ret;
6252
6253
ret = (xmlXPathParserContextPtr) xmlMalloc(sizeof(xmlXPathParserContext));
6254
if (ret == NULL) {
6255
xmlXPathErrMemory(ctxt, "creating evaluation context\n");
6256
return(NULL);
6257
}
6258
memset(ret, 0 , (size_t) sizeof(xmlXPathParserContext));
6259
6260
/* Allocate the value stack */
6261
ret->valueTab = (xmlXPathObjectPtr *)
6262
xmlMalloc(10 * sizeof(xmlXPathObjectPtr));
6263
if (ret->valueTab == NULL) {
6264
xmlFree(ret);
6265
xmlXPathErrMemory(ctxt, "creating evaluation context\n");
6266
return(NULL);
6267
}
6268
ret->valueNr = 0;
6269
ret->valueMax = 10;
6270
ret->value = NULL;
6271
ret->valueFrame = 0;
6272
6273
ret->context = ctxt;
6274
ret->comp = comp;
6275
6276
return(ret);
6277
}
6278
6279
/**
6280
* xmlXPathFreeParserContext:
6281
* @ctxt: the context to free
6282
*
6283
* Free up an xmlXPathParserContext
6284
*/
6285
void
6286
xmlXPathFreeParserContext(xmlXPathParserContextPtr ctxt) {
6287
if (ctxt->valueTab != NULL) {
6288
xmlFree(ctxt->valueTab);
6289
}
6290
if (ctxt->comp != NULL) {
6291
#ifdef XPATH_STREAMING
6292
if (ctxt->comp->stream != NULL) {
6293
xmlFreePatternList(ctxt->comp->stream);
6294
ctxt->comp->stream = NULL;
6295
}
6296
#endif
6297
xmlXPathFreeCompExpr(ctxt->comp);
6298
}
6299
xmlFree(ctxt);
6300
}
6301
6302
/************************************************************************
6303
* *
6304
* The implicit core function library *
6305
* *
6306
************************************************************************/
6307
6308
/**
6309
* xmlXPathNodeValHash:
6310
* @node: a node pointer
6311
*
6312
* Function computing the beginning of the string value of the node,
6313
* used to speed up comparisons
6314
*
6315
* Returns an int usable as a hash
6316
*/
6317
static unsigned int
6318
xmlXPathNodeValHash(xmlNodePtr node) {
6319
int len = 2;
6320
const xmlChar * string = NULL;
6321
xmlNodePtr tmp = NULL;
6322
unsigned int ret = 0;
6323
6324
if (node == NULL)
6325
return(0);
6326
6327
if (node->type == XML_DOCUMENT_NODE) {
6328
tmp = xmlDocGetRootElement((xmlDocPtr) node);
6329
if (tmp == NULL)
6330
node = node->children;
6331
else
6332
node = tmp;
6333
6334
if (node == NULL)
6335
return(0);
6336
}
6337
6338
switch (node->type) {
6339
case XML_COMMENT_NODE:
6340
case XML_PI_NODE:
6341
case XML_CDATA_SECTION_NODE:
6342
case XML_TEXT_NODE:
6343
string = node->content;
6344
if (string == NULL)
6345
return(0);
6346
if (string[0] == 0)
6347
return(0);
6348
return(((unsigned int) string[0]) +
6349
(((unsigned int) string[1]) << 8));
6350
case XML_NAMESPACE_DECL:
6351
string = ((xmlNsPtr)node)->href;
6352
if (string == NULL)
6353
return(0);
6354
if (string[0] == 0)
6355
return(0);
6356
return(((unsigned int) string[0]) +
6357
(((unsigned int) string[1]) << 8));
6358
case XML_ATTRIBUTE_NODE:
6359
tmp = ((xmlAttrPtr) node)->children;
6360
break;
6361
case XML_ELEMENT_NODE:
6362
tmp = node->children;
6363
break;
6364
default:
6365
return(0);
6366
}
6367
while (tmp != NULL) {
6368
switch (tmp->type) {
6369
case XML_COMMENT_NODE:
6370
case XML_PI_NODE:
6371
case XML_CDATA_SECTION_NODE:
6372
case XML_TEXT_NODE:
6373
string = tmp->content;
6374
break;
6375
case XML_NAMESPACE_DECL:
6376
string = ((xmlNsPtr)tmp)->href;
6377
break;
6378
default:
6379
break;
6380
}
6381
if ((string != NULL) && (string[0] != 0)) {
6382
if (len == 1) {
6383
return(ret + (((unsigned int) string[0]) << 8));
6384
}
6385
if (string[1] == 0) {
6386
len = 1;
6387
ret = (unsigned int) string[0];
6388
} else {
6389
return(((unsigned int) string[0]) +
6390
(((unsigned int) string[1]) << 8));
6391
}
6392
}
6393
/*
6394
* Skip to next node
6395
*/
6396
if ((tmp->children != NULL) && (tmp->type != XML_DTD_NODE)) {
6397
if (tmp->children->type != XML_ENTITY_DECL) {
6398
tmp = tmp->children;
6399
continue;
6400
}
6401
}
6402
if (tmp == node)
6403
break;
6404
6405
if (tmp->next != NULL) {
6406
tmp = tmp->next;
6407
continue;
6408
}
6409
6410
do {
6411
tmp = tmp->parent;
6412
if (tmp == NULL)
6413
break;
6414
if (tmp == node) {
6415
tmp = NULL;
6416
break;
6417
}
6418
if (tmp->next != NULL) {
6419
tmp = tmp->next;
6420
break;
6421
}
6422
} while (tmp != NULL);
6423
}
6424
return(ret);
6425
}
6426
6427
/**
6428
* xmlXPathStringHash:
6429
* @string: a string
6430
*
6431
* Function computing the beginning of the string value of the node,
6432
* used to speed up comparisons
6433
*
6434
* Returns an int usable as a hash
6435
*/
6436
static unsigned int
6437
xmlXPathStringHash(const xmlChar * string) {
6438
if (string == NULL)
6439
return((unsigned int) 0);
6440
if (string[0] == 0)
6441
return(0);
6442
return(((unsigned int) string[0]) +
6443
(((unsigned int) string[1]) << 8));
6444
}
6445
6446
/**
6447
* xmlXPathCompareNodeSetFloat:
6448
* @ctxt: the XPath Parser context
6449
* @inf: less than (1) or greater than (0)
6450
* @strict: is the comparison strict
6451
* @arg: the node set
6452
* @f: the value
6453
*
6454
* Implement the compare operation between a nodeset and a number
6455
* @ns < @val (1, 1, ...
6456
* @ns <= @val (1, 0, ...
6457
* @ns > @val (0, 1, ...
6458
* @ns >= @val (0, 0, ...
6459
*
6460
* If one object to be compared is a node-set and the other is a number,
6461
* then the comparison will be true if and only if there is a node in the
6462
* node-set such that the result of performing the comparison on the number
6463
* to be compared and on the result of converting the string-value of that
6464
* node to a number using the number function is true.
6465
*
6466
* Returns 0 or 1 depending on the results of the test.
6467
*/
6468
static int
6469
xmlXPathCompareNodeSetFloat(xmlXPathParserContextPtr ctxt, int inf, int strict,
6470
xmlXPathObjectPtr arg, xmlXPathObjectPtr f) {
6471
int i, ret = 0;
6472
xmlNodeSetPtr ns;
6473
xmlChar *str2;
6474
6475
if ((f == NULL) || (arg == NULL) ||
6476
((arg->type != XPATH_NODESET) && (arg->type != XPATH_XSLT_TREE))) {
6477
xmlXPathReleaseObject(ctxt->context, arg);
6478
xmlXPathReleaseObject(ctxt->context, f);
6479
return(0);
6480
}
6481
ns = arg->nodesetval;
6482
if (ns != NULL) {
6483
for (i = 0;i < ns->nodeNr;i++) {
6484
str2 = xmlXPathCastNodeToString(ns->nodeTab[i]);
6485
if (str2 != NULL) {
6486
valuePush(ctxt,
6487
xmlXPathCacheNewString(ctxt->context, str2));
6488
xmlFree(str2);
6489
xmlXPathNumberFunction(ctxt, 1);
6490
valuePush(ctxt, xmlXPathCacheObjectCopy(ctxt->context, f));
6491
ret = xmlXPathCompareValues(ctxt, inf, strict);
6492
if (ret)
6493
break;
6494
}
6495
}
6496
}
6497
xmlXPathReleaseObject(ctxt->context, arg);
6498
xmlXPathReleaseObject(ctxt->context, f);
6499
return(ret);
6500
}
6501
6502
/**
6503
* xmlXPathCompareNodeSetString:
6504
* @ctxt: the XPath Parser context
6505
* @inf: less than (1) or greater than (0)
6506
* @strict: is the comparison strict
6507
* @arg: the node set
6508
* @s: the value
6509
*
6510
* Implement the compare operation between a nodeset and a string
6511
* @ns < @val (1, 1, ...
6512
* @ns <= @val (1, 0, ...
6513
* @ns > @val (0, 1, ...
6514
* @ns >= @val (0, 0, ...
6515
*
6516
* If one object to be compared is a node-set and the other is a string,
6517
* then the comparison will be true if and only if there is a node in
6518
* the node-set such that the result of performing the comparison on the
6519
* string-value of the node and the other string is true.
6520
*
6521
* Returns 0 or 1 depending on the results of the test.
6522
*/
6523
static int
6524
xmlXPathCompareNodeSetString(xmlXPathParserContextPtr ctxt, int inf, int strict,
6525
xmlXPathObjectPtr arg, xmlXPathObjectPtr s) {
6526
int i, ret = 0;
6527
xmlNodeSetPtr ns;
6528
xmlChar *str2;
6529
6530
if ((s == NULL) || (arg == NULL) ||
6531
((arg->type != XPATH_NODESET) && (arg->type != XPATH_XSLT_TREE))) {
6532
xmlXPathReleaseObject(ctxt->context, arg);
6533
xmlXPathReleaseObject(ctxt->context, s);
6534
return(0);
6535
}
6536
ns = arg->nodesetval;
6537
if (ns != NULL) {
6538
for (i = 0;i < ns->nodeNr;i++) {
6539
str2 = xmlXPathCastNodeToString(ns->nodeTab[i]);
6540
if (str2 != NULL) {
6541
valuePush(ctxt,
6542
xmlXPathCacheNewString(ctxt->context, str2));
6543
xmlFree(str2);
6544
valuePush(ctxt, xmlXPathCacheObjectCopy(ctxt->context, s));
6545
ret = xmlXPathCompareValues(ctxt, inf, strict);
6546
if (ret)
6547
break;
6548
}
6549
}
6550
}
6551
xmlXPathReleaseObject(ctxt->context, arg);
6552
xmlXPathReleaseObject(ctxt->context, s);
6553
return(ret);
6554
}
6555
6556
/**
6557
* xmlXPathCompareNodeSets:
6558
* @inf: less than (1) or greater than (0)
6559
* @strict: is the comparison strict
6560
* @arg1: the first node set object
6561
* @arg2: the second node set object
6562
*
6563
* Implement the compare operation on nodesets:
6564
*
6565
* If both objects to be compared are node-sets, then the comparison
6566
* will be true if and only if there is a node in the first node-set
6567
* and a node in the second node-set such that the result of performing
6568
* the comparison on the string-values of the two nodes is true.
6569
* ....
6570
* When neither object to be compared is a node-set and the operator
6571
* is <=, <, >= or >, then the objects are compared by converting both
6572
* objects to numbers and comparing the numbers according to IEEE 754.
6573
* ....
6574
* The number function converts its argument to a number as follows:
6575
* - a string that consists of optional whitespace followed by an
6576
* optional minus sign followed by a Number followed by whitespace
6577
* is converted to the IEEE 754 number that is nearest (according
6578
* to the IEEE 754 round-to-nearest rule) to the mathematical value
6579
* represented by the string; any other string is converted to NaN
6580
*
6581
* Conclusion all nodes need to be converted first to their string value
6582
* and then the comparison must be done when possible
6583
*/
6584
static int
6585
xmlXPathCompareNodeSets(int inf, int strict,
6586
xmlXPathObjectPtr arg1, xmlXPathObjectPtr arg2) {
6587
int i, j, init = 0;
6588
double val1;
6589
double *values2;
6590
int ret = 0;
6591
xmlNodeSetPtr ns1;
6592
xmlNodeSetPtr ns2;
6593
6594
if ((arg1 == NULL) ||
6595
((arg1->type != XPATH_NODESET) && (arg1->type != XPATH_XSLT_TREE))) {
6596
xmlXPathFreeObject(arg2);
6597
return(0);
6598
}
6599
if ((arg2 == NULL) ||
6600
((arg2->type != XPATH_NODESET) && (arg2->type != XPATH_XSLT_TREE))) {
6601
xmlXPathFreeObject(arg1);
6602
xmlXPathFreeObject(arg2);
6603
return(0);
6604
}
6605
6606
ns1 = arg1->nodesetval;
6607
ns2 = arg2->nodesetval;
6608
6609
if ((ns1 == NULL) || (ns1->nodeNr <= 0)) {
6610
xmlXPathFreeObject(arg1);
6611
xmlXPathFreeObject(arg2);
6612
return(0);
6613
}
6614
if ((ns2 == NULL) || (ns2->nodeNr <= 0)) {
6615
xmlXPathFreeObject(arg1);
6616
xmlXPathFreeObject(arg2);
6617
return(0);
6618
}
6619
6620
values2 = (double *) xmlMalloc(ns2->nodeNr * sizeof(double));
6621
if (values2 == NULL) {
6622
xmlXPathErrMemory(NULL, "comparing nodesets\n");
6623
xmlXPathFreeObject(arg1);
6624
xmlXPathFreeObject(arg2);
6625
return(0);
6626
}
6627
for (i = 0;i < ns1->nodeNr;i++) {
6628
val1 = xmlXPathCastNodeToNumber(ns1->nodeTab[i]);
6629
if (xmlXPathIsNaN(val1))
6630
continue;
6631
for (j = 0;j < ns2->nodeNr;j++) {
6632
if (init == 0) {
6633
values2[j] = xmlXPathCastNodeToNumber(ns2->nodeTab[j]);
6634
}
6635
if (xmlXPathIsNaN(values2[j]))
6636
continue;
6637
if (inf && strict)
6638
ret = (val1 < values2[j]);
6639
else if (inf && !strict)
6640
ret = (val1 <= values2[j]);
6641
else if (!inf && strict)
6642
ret = (val1 > values2[j]);
6643
else if (!inf && !strict)
6644
ret = (val1 >= values2[j]);
6645
if (ret)
6646
break;
6647
}
6648
if (ret)
6649
break;
6650
init = 1;
6651
}
6652
xmlFree(values2);
6653
xmlXPathFreeObject(arg1);
6654
xmlXPathFreeObject(arg2);
6655
return(ret);
6656
}
6657
6658
/**
6659
* xmlXPathCompareNodeSetValue:
6660
* @ctxt: the XPath Parser context
6661
* @inf: less than (1) or greater than (0)
6662
* @strict: is the comparison strict
6663
* @arg: the node set
6664
* @val: the value
6665
*
6666
* Implement the compare operation between a nodeset and a value
6667
* @ns < @val (1, 1, ...
6668
* @ns <= @val (1, 0, ...
6669
* @ns > @val (0, 1, ...
6670
* @ns >= @val (0, 0, ...
6671
*
6672
* If one object to be compared is a node-set and the other is a boolean,
6673
* then the comparison will be true if and only if the result of performing
6674
* the comparison on the boolean and on the result of converting
6675
* the node-set to a boolean using the boolean function is true.
6676
*
6677
* Returns 0 or 1 depending on the results of the test.
6678
*/
6679
static int
6680
xmlXPathCompareNodeSetValue(xmlXPathParserContextPtr ctxt, int inf, int strict,
6681
xmlXPathObjectPtr arg, xmlXPathObjectPtr val) {
6682
if ((val == NULL) || (arg == NULL) ||
6683
((arg->type != XPATH_NODESET) && (arg->type != XPATH_XSLT_TREE)))
6684
return(0);
6685
6686
switch(val->type) {
6687
case XPATH_NUMBER:
6688
return(xmlXPathCompareNodeSetFloat(ctxt, inf, strict, arg, val));
6689
case XPATH_NODESET:
6690
case XPATH_XSLT_TREE:
6691
return(xmlXPathCompareNodeSets(inf, strict, arg, val));
6692
case XPATH_STRING:
6693
return(xmlXPathCompareNodeSetString(ctxt, inf, strict, arg, val));
6694
case XPATH_BOOLEAN:
6695
valuePush(ctxt, arg);
6696
xmlXPathBooleanFunction(ctxt, 1);
6697
valuePush(ctxt, val);
6698
return(xmlXPathCompareValues(ctxt, inf, strict));
6699
default:
6700
TODO
6701
}
6702
return(0);
6703
}
6704
6705
/**
6706
* xmlXPathEqualNodeSetString:
6707
* @arg: the nodeset object argument
6708
* @str: the string to compare to.
6709
* @neq: flag to show whether for '=' (0) or '!=' (1)
6710
*
6711
* Implement the equal operation on XPath objects content: @arg1 == @arg2
6712
* If one object to be compared is a node-set and the other is a string,
6713
* then the comparison will be true if and only if there is a node in
6714
* the node-set such that the result of performing the comparison on the
6715
* string-value of the node and the other string is true.
6716
*
6717
* Returns 0 or 1 depending on the results of the test.
6718
*/
6719
static int
6720
xmlXPathEqualNodeSetString(xmlXPathObjectPtr arg, const xmlChar * str, int neq)
6721
{
6722
int i;
6723
xmlNodeSetPtr ns;
6724
xmlChar *str2;
6725
unsigned int hash;
6726
6727
if ((str == NULL) || (arg == NULL) ||
6728
((arg->type != XPATH_NODESET) && (arg->type != XPATH_XSLT_TREE)))
6729
return (0);
6730
ns = arg->nodesetval;
6731
/*
6732
* A NULL nodeset compared with a string is always false
6733
* (since there is no node equal, and no node not equal)
6734
*/
6735
if ((ns == NULL) || (ns->nodeNr <= 0) )
6736
return (0);
6737
hash = xmlXPathStringHash(str);
6738
for (i = 0; i < ns->nodeNr; i++) {
6739
if (xmlXPathNodeValHash(ns->nodeTab[i]) == hash) {
6740
str2 = xmlNodeGetContent(ns->nodeTab[i]);
6741
if ((str2 != NULL) && (xmlStrEqual(str, str2))) {
6742
xmlFree(str2);
6743
if (neq)
6744
continue;
6745
return (1);
6746
} else if ((str2 == NULL) && (xmlStrEqual(str, BAD_CAST ""))) {
6747
if (neq)
6748
continue;
6749
return (1);
6750
} else if (neq) {
6751
if (str2 != NULL)
6752
xmlFree(str2);
6753
return (1);
6754
}
6755
if (str2 != NULL)
6756
xmlFree(str2);
6757
} else if (neq)
6758
return (1);
6759
}
6760
return (0);
6761
}
6762
6763
/**
6764
* xmlXPathEqualNodeSetFloat:
6765
* @arg: the nodeset object argument
6766
* @f: the float to compare to
6767
* @neq: flag to show whether to compare '=' (0) or '!=' (1)
6768
*
6769
* Implement the equal operation on XPath objects content: @arg1 == @arg2
6770
* If one object to be compared is a node-set and the other is a number,
6771
* then the comparison will be true if and only if there is a node in
6772
* the node-set such that the result of performing the comparison on the
6773
* number to be compared and on the result of converting the string-value
6774
* of that node to a number using the number function is true.
6775
*
6776
* Returns 0 or 1 depending on the results of the test.
6777
*/
6778
static int
6779
xmlXPathEqualNodeSetFloat(xmlXPathParserContextPtr ctxt,
6780
xmlXPathObjectPtr arg, double f, int neq) {
6781
int i, ret=0;
6782
xmlNodeSetPtr ns;
6783
xmlChar *str2;
6784
xmlXPathObjectPtr val;
6785
double v;
6786
6787
if ((arg == NULL) ||
6788
((arg->type != XPATH_NODESET) && (arg->type != XPATH_XSLT_TREE)))
6789
return(0);
6790
6791
ns = arg->nodesetval;
6792
if (ns != NULL) {
6793
for (i=0;i<ns->nodeNr;i++) {
6794
str2 = xmlXPathCastNodeToString(ns->nodeTab[i]);
6795
if (str2 != NULL) {
6796
valuePush(ctxt, xmlXPathCacheNewString(ctxt->context, str2));
6797
xmlFree(str2);
6798
xmlXPathNumberFunction(ctxt, 1);
6799
val = valuePop(ctxt);
6800
v = val->floatval;
6801
xmlXPathReleaseObject(ctxt->context, val);
6802
if (!xmlXPathIsNaN(v)) {
6803
if ((!neq) && (v==f)) {
6804
ret = 1;
6805
break;
6806
} else if ((neq) && (v!=f)) {
6807
ret = 1;
6808
break;
6809
}
6810
} else { /* NaN is unequal to any value */
6811
if (neq)
6812
ret = 1;
6813
}
6814
}
6815
}
6816
}
6817
6818
return(ret);
6819
}
6820
6821
6822
/**
6823
* xmlXPathEqualNodeSets:
6824
* @arg1: first nodeset object argument
6825
* @arg2: second nodeset object argument
6826
* @neq: flag to show whether to test '=' (0) or '!=' (1)
6827
*
6828
* Implement the equal / not equal operation on XPath nodesets:
6829
* @arg1 == @arg2 or @arg1 != @arg2
6830
* If both objects to be compared are node-sets, then the comparison
6831
* will be true if and only if there is a node in the first node-set and
6832
* a node in the second node-set such that the result of performing the
6833
* comparison on the string-values of the two nodes is true.
6834
*
6835
* (needless to say, this is a costly operation)
6836
*
6837
* Returns 0 or 1 depending on the results of the test.
6838
*/
6839
static int
6840
xmlXPathEqualNodeSets(xmlXPathObjectPtr arg1, xmlXPathObjectPtr arg2, int neq) {
6841
int i, j;
6842
unsigned int *hashs1;
6843
unsigned int *hashs2;
6844
xmlChar **values1;
6845
xmlChar **values2;
6846
int ret = 0;
6847
xmlNodeSetPtr ns1;
6848
xmlNodeSetPtr ns2;
6849
6850
if ((arg1 == NULL) ||
6851
((arg1->type != XPATH_NODESET) && (arg1->type != XPATH_XSLT_TREE)))
6852
return(0);
6853
if ((arg2 == NULL) ||
6854
((arg2->type != XPATH_NODESET) && (arg2->type != XPATH_XSLT_TREE)))
6855
return(0);
6856
6857
ns1 = arg1->nodesetval;
6858
ns2 = arg2->nodesetval;
6859
6860
if ((ns1 == NULL) || (ns1->nodeNr <= 0))
6861
return(0);
6862
if ((ns2 == NULL) || (ns2->nodeNr <= 0))
6863
return(0);
6864
6865
/*
6866
* for equal, check if there is a node pertaining to both sets
6867
*/
6868
if (neq == 0)
6869
for (i = 0;i < ns1->nodeNr;i++)
6870
for (j = 0;j < ns2->nodeNr;j++)
6871
if (ns1->nodeTab[i] == ns2->nodeTab[j])
6872
return(1);
6873
6874
values1 = (xmlChar **) xmlMalloc(ns1->nodeNr * sizeof(xmlChar *));
6875
if (values1 == NULL) {
6876
xmlXPathErrMemory(NULL, "comparing nodesets\n");
6877
return(0);
6878
}
6879
hashs1 = (unsigned int *) xmlMalloc(ns1->nodeNr * sizeof(unsigned int));
6880
if (hashs1 == NULL) {
6881
xmlXPathErrMemory(NULL, "comparing nodesets\n");
6882
xmlFree(values1);
6883
return(0);
6884
}
6885
memset(values1, 0, ns1->nodeNr * sizeof(xmlChar *));
6886
values2 = (xmlChar **) xmlMalloc(ns2->nodeNr * sizeof(xmlChar *));
6887
if (values2 == NULL) {
6888
xmlXPathErrMemory(NULL, "comparing nodesets\n");
6889
xmlFree(hashs1);
6890
xmlFree(values1);
6891
return(0);
6892
}
6893
hashs2 = (unsigned int *) xmlMalloc(ns2->nodeNr * sizeof(unsigned int));
6894
if (hashs2 == NULL) {
6895
xmlXPathErrMemory(NULL, "comparing nodesets\n");
6896
xmlFree(hashs1);
6897
xmlFree(values1);
6898
xmlFree(values2);
6899
return(0);
6900
}
6901
memset(values2, 0, ns2->nodeNr * sizeof(xmlChar *));
6902
for (i = 0;i < ns1->nodeNr;i++) {
6903
hashs1[i] = xmlXPathNodeValHash(ns1->nodeTab[i]);
6904
for (j = 0;j < ns2->nodeNr;j++) {
6905
if (i == 0)
6906
hashs2[j] = xmlXPathNodeValHash(ns2->nodeTab[j]);
6907
if (hashs1[i] != hashs2[j]) {
6908
if (neq) {
6909
ret = 1;
6910
break;
6911
}
6912
}
6913
else {
6914
if (values1[i] == NULL)
6915
values1[i] = xmlNodeGetContent(ns1->nodeTab[i]);
6916
if (values2[j] == NULL)
6917
values2[j] = xmlNodeGetContent(ns2->nodeTab[j]);
6918
ret = xmlStrEqual(values1[i], values2[j]) ^ neq;
6919
if (ret)
6920
break;
6921
}
6922
}
6923
if (ret)
6924
break;
6925
}
6926
for (i = 0;i < ns1->nodeNr;i++)
6927
if (values1[i] != NULL)
6928
xmlFree(values1[i]);
6929
for (j = 0;j < ns2->nodeNr;j++)
6930
if (values2[j] != NULL)
6931
xmlFree(values2[j]);
6932
xmlFree(values1);
6933
xmlFree(values2);
6934
xmlFree(hashs1);
6935
xmlFree(hashs2);
6936
return(ret);
6937
}
6938
6939
static int
6940
xmlXPathEqualValuesCommon(xmlXPathParserContextPtr ctxt,
6941
xmlXPathObjectPtr arg1, xmlXPathObjectPtr arg2) {
6942
int ret = 0;
6943
/*
6944
*At this point we are assured neither arg1 nor arg2
6945
*is a nodeset, so we can just pick the appropriate routine.
6946
*/
6947
switch (arg1->type) {
6948
case XPATH_UNDEFINED:
6949
#ifdef DEBUG_EXPR
6950
xmlGenericError(xmlGenericErrorContext,
6951
"Equal: undefined\n");
6952
#endif
6953
break;
6954
case XPATH_BOOLEAN:
6955
switch (arg2->type) {
6956
case XPATH_UNDEFINED:
6957
#ifdef DEBUG_EXPR
6958
xmlGenericError(xmlGenericErrorContext,
6959
"Equal: undefined\n");
6960
#endif
6961
break;
6962
case XPATH_BOOLEAN:
6963
#ifdef DEBUG_EXPR
6964
xmlGenericError(xmlGenericErrorContext,
6965
"Equal: %d boolean %d \n",
6966
arg1->boolval, arg2->boolval);
6967
#endif
6968
ret = (arg1->boolval == arg2->boolval);
6969
break;
6970
case XPATH_NUMBER:
6971
ret = (arg1->boolval ==
6972
xmlXPathCastNumberToBoolean(arg2->floatval));
6973
break;
6974
case XPATH_STRING:
6975
if ((arg2->stringval == NULL) ||
6976
(arg2->stringval[0] == 0)) ret = 0;
6977
else
6978
ret = 1;
6979
ret = (arg1->boolval == ret);
6980
break;
6981
case XPATH_USERS:
6982
case XPATH_POINT:
6983
case XPATH_RANGE:
6984
case XPATH_LOCATIONSET:
6985
TODO
6986
break;
6987
case XPATH_NODESET:
6988
case XPATH_XSLT_TREE:
6989
break;
6990
}
6991
break;
6992
case XPATH_NUMBER:
6993
switch (arg2->type) {
6994
case XPATH_UNDEFINED:
6995
#ifdef DEBUG_EXPR
6996
xmlGenericError(xmlGenericErrorContext,
6997
"Equal: undefined\n");
6998
#endif
6999
break;
7000
case XPATH_BOOLEAN:
7001
ret = (arg2->boolval==
7002
xmlXPathCastNumberToBoolean(arg1->floatval));
7003
break;
7004
case XPATH_STRING:
7005
valuePush(ctxt, arg2);
7006
xmlXPathNumberFunction(ctxt, 1);
7007
arg2 = valuePop(ctxt);
7008
/* no break on purpose */
7009
case XPATH_NUMBER:
7010
/* Hand check NaN and Infinity equalities */
7011
if (xmlXPathIsNaN(arg1->floatval) ||
7012
xmlXPathIsNaN(arg2->floatval)) {
7013
ret = 0;
7014
} else if (xmlXPathIsInf(arg1->floatval) == 1) {
7015
if (xmlXPathIsInf(arg2->floatval) == 1)
7016
ret = 1;
7017
else
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(arg2->floatval) == 1) {
7025
if (xmlXPathIsInf(arg1->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 {
7035
ret = (arg1->floatval == arg2->floatval);
7036
}
7037
break;
7038
case XPATH_USERS:
7039
case XPATH_POINT:
7040
case XPATH_RANGE:
7041
case XPATH_LOCATIONSET:
7042
TODO
7043
break;
7044
case XPATH_NODESET:
7045
case XPATH_XSLT_TREE:
7046
break;
7047
}
7048
break;
7049
case XPATH_STRING:
7050
switch (arg2->type) {
7051
case XPATH_UNDEFINED:
7052
#ifdef DEBUG_EXPR
7053
xmlGenericError(xmlGenericErrorContext,
7054
"Equal: undefined\n");
7055
#endif
7056
break;
7057
case XPATH_BOOLEAN:
7058
if ((arg1->stringval == NULL) ||
7059
(arg1->stringval[0] == 0)) ret = 0;
7060
else
7061
ret = 1;
7062
ret = (arg2->boolval == ret);
7063
break;
7064
case XPATH_STRING:
7065
ret = xmlStrEqual(arg1->stringval, arg2->stringval);
7066
break;
7067
case XPATH_NUMBER:
7068
valuePush(ctxt, arg1);
7069
xmlXPathNumberFunction(ctxt, 1);
7070
arg1 = valuePop(ctxt);
7071
/* Hand check NaN and Infinity equalities */
7072
if (xmlXPathIsNaN(arg1->floatval) ||
7073
xmlXPathIsNaN(arg2->floatval)) {
7074
ret = 0;
7075
} else if (xmlXPathIsInf(arg1->floatval) == 1) {
7076
if (xmlXPathIsInf(arg2->floatval) == 1)
7077
ret = 1;
7078
else
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(arg2->floatval) == 1) {
7086
if (xmlXPathIsInf(arg1->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 {
7096
ret = (arg1->floatval == arg2->floatval);
7097
}
7098
break;
7099
case XPATH_USERS:
7100
case XPATH_POINT:
7101
case XPATH_RANGE:
7102
case XPATH_LOCATIONSET:
7103
TODO
7104
break;
7105
case XPATH_NODESET:
7106
case XPATH_XSLT_TREE:
7107
break;
7108
}
7109
break;
7110
case XPATH_USERS:
7111
case XPATH_POINT:
7112
case XPATH_RANGE:
7113
case XPATH_LOCATIONSET:
7114
TODO
7115
break;
7116
case XPATH_NODESET:
7117
case XPATH_XSLT_TREE:
7118
break;
7119
}
7120
xmlXPathReleaseObject(ctxt->context, arg1);
7121
xmlXPathReleaseObject(ctxt->context, arg2);
7122
return(ret);
7123
}
7124
7125
/**
7126
* xmlXPathEqualValues:
7127
* @ctxt: the XPath Parser context
7128
*
7129
* Implement the equal operation on XPath objects content: @arg1 == @arg2
7130
*
7131
* Returns 0 or 1 depending on the results of the test.
7132
*/
7133
int
7134
xmlXPathEqualValues(xmlXPathParserContextPtr ctxt) {
7135
xmlXPathObjectPtr arg1, arg2, argtmp;
7136
int ret = 0;
7137
7138
if ((ctxt == NULL) || (ctxt->context == NULL)) return(0);
7139
arg2 = valuePop(ctxt);
7140
arg1 = valuePop(ctxt);
7141
if ((arg1 == NULL) || (arg2 == NULL)) {
7142
if (arg1 != NULL)
7143
xmlXPathReleaseObject(ctxt->context, arg1);
7144
else
7145
xmlXPathReleaseObject(ctxt->context, arg2);
7146
XP_ERROR0(XPATH_INVALID_OPERAND);
7147
}
7148
7149
if (arg1 == arg2) {
7150
#ifdef DEBUG_EXPR
7151
xmlGenericError(xmlGenericErrorContext,
7152
"Equal: by pointer\n");
7153
#endif
7154
xmlXPathFreeObject(arg1);
7155
return(1);
7156
}
7157
7158
/*
7159
*If either argument is a nodeset, it's a 'special case'
7160
*/
7161
if ((arg2->type == XPATH_NODESET) || (arg2->type == XPATH_XSLT_TREE) ||
7162
(arg1->type == XPATH_NODESET) || (arg1->type == XPATH_XSLT_TREE)) {
7163
/*
7164
*Hack it to assure arg1 is the nodeset
7165
*/
7166
if ((arg1->type != XPATH_NODESET) && (arg1->type != XPATH_XSLT_TREE)) {
7167
argtmp = arg2;
7168
arg2 = arg1;
7169
arg1 = argtmp;
7170
}
7171
switch (arg2->type) {
7172
case XPATH_UNDEFINED:
7173
#ifdef DEBUG_EXPR
7174
xmlGenericError(xmlGenericErrorContext,
7175
"Equal: undefined\n");
7176
#endif
7177
break;
7178
case XPATH_NODESET:
7179
case XPATH_XSLT_TREE:
7180
ret = xmlXPathEqualNodeSets(arg1, arg2, 0);
7181
break;
7182
case XPATH_BOOLEAN:
7183
if ((arg1->nodesetval == NULL) ||
7184
(arg1->nodesetval->nodeNr == 0)) ret = 0;
7185
else
7186
ret = 1;
7187
ret = (ret == arg2->boolval);
7188
break;
7189
case XPATH_NUMBER:
7190
ret = xmlXPathEqualNodeSetFloat(ctxt, arg1, arg2->floatval, 0);
7191
break;
7192
case XPATH_STRING:
7193
ret = xmlXPathEqualNodeSetString(arg1, arg2->stringval, 0);
7194
break;
7195
case XPATH_USERS:
7196
case XPATH_POINT:
7197
case XPATH_RANGE:
7198
case XPATH_LOCATIONSET:
7199
TODO
7200
break;
7201
}
7202
xmlXPathReleaseObject(ctxt->context, arg1);
7203
xmlXPathReleaseObject(ctxt->context, arg2);
7204
return(ret);
7205
}
7206
7207
return (xmlXPathEqualValuesCommon(ctxt, arg1, arg2));
7208
}
7209
7210
/**
7211
* xmlXPathNotEqualValues:
7212
* @ctxt: the XPath Parser context
7213
*
7214
* Implement the equal operation on XPath objects content: @arg1 == @arg2
7215
*
7216
* Returns 0 or 1 depending on the results of the test.
7217
*/
7218
int
7219
xmlXPathNotEqualValues(xmlXPathParserContextPtr ctxt) {
7220
xmlXPathObjectPtr arg1, arg2, argtmp;
7221
int ret = 0;
7222
7223
if ((ctxt == NULL) || (ctxt->context == NULL)) return(0);
7224
arg2 = valuePop(ctxt);
7225
arg1 = valuePop(ctxt);
7226
if ((arg1 == NULL) || (arg2 == NULL)) {
7227
if (arg1 != NULL)
7228
xmlXPathReleaseObject(ctxt->context, arg1);
7229
else
7230
xmlXPathReleaseObject(ctxt->context, arg2);
7231
XP_ERROR0(XPATH_INVALID_OPERAND);
7232
}
7233
7234
if (arg1 == arg2) {
7235
#ifdef DEBUG_EXPR
7236
xmlGenericError(xmlGenericErrorContext,
7237
"NotEqual: by pointer\n");
7238
#endif
7239
xmlXPathReleaseObject(ctxt->context, arg1);
7240
return(0);
7241
}
7242
7243
/*
7244
*If either argument is a nodeset, it's a 'special case'
7245
*/
7246
if ((arg2->type == XPATH_NODESET) || (arg2->type == XPATH_XSLT_TREE) ||
7247
(arg1->type == XPATH_NODESET) || (arg1->type == XPATH_XSLT_TREE)) {
7248
/*
7249
*Hack it to assure arg1 is the nodeset
7250
*/
7251
if ((arg1->type != XPATH_NODESET) && (arg1->type != XPATH_XSLT_TREE)) {
7252
argtmp = arg2;
7253
arg2 = arg1;
7254
arg1 = argtmp;
7255
}
7256
switch (arg2->type) {
7257
case XPATH_UNDEFINED:
7258
#ifdef DEBUG_EXPR
7259
xmlGenericError(xmlGenericErrorContext,
7260
"NotEqual: undefined\n");
7261
#endif
7262
break;
7263
case XPATH_NODESET:
7264
case XPATH_XSLT_TREE:
7265
ret = xmlXPathEqualNodeSets(arg1, arg2, 1);
7266
break;
7267
case XPATH_BOOLEAN:
7268
if ((arg1->nodesetval == NULL) ||
7269
(arg1->nodesetval->nodeNr == 0)) ret = 0;
7270
else
7271
ret = 1;
7272
ret = (ret != arg2->boolval);
7273
break;
7274
case XPATH_NUMBER:
7275
ret = xmlXPathEqualNodeSetFloat(ctxt, arg1, arg2->floatval, 1);
7276
break;
7277
case XPATH_STRING:
7278
ret = xmlXPathEqualNodeSetString(arg1, arg2->stringval,1);
7279
break;
7280
case XPATH_USERS:
7281
case XPATH_POINT:
7282
case XPATH_RANGE:
7283
case XPATH_LOCATIONSET:
7284
TODO
7285
break;
7286
}
7287
xmlXPathReleaseObject(ctxt->context, arg1);
7288
xmlXPathReleaseObject(ctxt->context, arg2);
7289
return(ret);
7290
}
7291
7292
return (!xmlXPathEqualValuesCommon(ctxt, arg1, arg2));
7293
}
7294
7295
/**
7296
* xmlXPathCompareValues:
7297
* @ctxt: the XPath Parser context
7298
* @inf: less than (1) or greater than (0)
7299
* @strict: is the comparison strict
7300
*
7301
* Implement the compare operation on XPath objects:
7302
* @arg1 < @arg2 (1, 1, ...
7303
* @arg1 <= @arg2 (1, 0, ...
7304
* @arg1 > @arg2 (0, 1, ...
7305
* @arg1 >= @arg2 (0, 0, ...
7306
*
7307
* When neither object to be compared is a node-set and the operator is
7308
* <=, <, >=, >, then the objects are compared by converted both objects
7309
* to numbers and comparing the numbers according to IEEE 754. The <
7310
* comparison will be true if and only if the first number is less than the
7311
* second number. The <= comparison will be true if and only if the first
7312
* number is less than or equal to the second number. The > comparison
7313
* will be true if and only if the first number is greater than the second
7314
* number. The >= comparison will be true if and only if the first number
7315
* is greater than or equal to the second number.
7316
*
7317
* Returns 1 if the comparison succeeded, 0 if it failed
7318
*/
7319
int
7320
xmlXPathCompareValues(xmlXPathParserContextPtr ctxt, int inf, int strict) {
7321
int ret = 0, arg1i = 0, arg2i = 0;
7322
xmlXPathObjectPtr arg1, arg2;
7323
7324
if ((ctxt == NULL) || (ctxt->context == NULL)) return(0);
7325
arg2 = valuePop(ctxt);
7326
arg1 = valuePop(ctxt);
7327
if ((arg1 == NULL) || (arg2 == NULL)) {
7328
if (arg1 != NULL)
7329
xmlXPathReleaseObject(ctxt->context, arg1);
7330
else
7331
xmlXPathReleaseObject(ctxt->context, arg2);
7332
XP_ERROR0(XPATH_INVALID_OPERAND);
7333
}
7334
7335
if ((arg2->type == XPATH_NODESET) || (arg2->type == XPATH_XSLT_TREE) ||
7336
(arg1->type == XPATH_NODESET) || (arg1->type == XPATH_XSLT_TREE)) {
7337
/*
7338
* If either argument is a XPATH_NODESET or XPATH_XSLT_TREE the two arguments
7339
* are not freed from within this routine; they will be freed from the
7340
* called routine, e.g. xmlXPathCompareNodeSets or xmlXPathCompareNodeSetValue
7341
*/
7342
if (((arg2->type == XPATH_NODESET) || (arg2->type == XPATH_XSLT_TREE)) &&
7343
((arg1->type == XPATH_NODESET) || (arg1->type == XPATH_XSLT_TREE))){
7344
ret = xmlXPathCompareNodeSets(inf, strict, arg1, arg2);
7345
} else {
7346
if ((arg1->type == XPATH_NODESET) || (arg1->type == XPATH_XSLT_TREE)) {
7347
ret = xmlXPathCompareNodeSetValue(ctxt, inf, strict,
7348
arg1, arg2);
7349
} else {
7350
ret = xmlXPathCompareNodeSetValue(ctxt, !inf, strict,
7351
arg2, arg1);
7352
}
7353
}
7354
return(ret);
7355
}
7356
7357
if (arg1->type != XPATH_NUMBER) {
7358
valuePush(ctxt, arg1);
7359
xmlXPathNumberFunction(ctxt, 1);
7360
arg1 = valuePop(ctxt);
7361
}
7362
if (arg1->type != XPATH_NUMBER) {
7363
xmlXPathFreeObject(arg1);
7364
xmlXPathFreeObject(arg2);
7365
XP_ERROR0(XPATH_INVALID_OPERAND);
7366
}
7367
if (arg2->type != XPATH_NUMBER) {
7368
valuePush(ctxt, arg2);
7369
xmlXPathNumberFunction(ctxt, 1);
7370
arg2 = valuePop(ctxt);
7371
}
7372
if (arg2->type != XPATH_NUMBER) {
7373
xmlXPathReleaseObject(ctxt->context, arg1);
7374
xmlXPathReleaseObject(ctxt->context, arg2);
7375
XP_ERROR0(XPATH_INVALID_OPERAND);
7376
}
7377
/*
7378
* Add tests for infinity and nan
7379
* => feedback on 3.4 for Inf and NaN
7380
*/
7381
/* Hand check NaN and Infinity comparisons */
7382
if (xmlXPathIsNaN(arg1->floatval) || xmlXPathIsNaN(arg2->floatval)) {
7383
ret=0;
7384
} else {
7385
arg1i=xmlXPathIsInf(arg1->floatval);
7386
arg2i=xmlXPathIsInf(arg2->floatval);
7387
if (inf && strict) {
7388
if ((arg1i == -1 && arg2i != -1) ||
7389
(arg2i == 1 && arg1i != 1)) {
7390
ret = 1;
7391
} else if (arg1i == 0 && arg2i == 0) {
7392
ret = (arg1->floatval < arg2->floatval);
7393
} else {
7394
ret = 0;
7395
}
7396
}
7397
else if (inf && !strict) {
7398
if (arg1i == -1 || arg2i == 1) {
7399
ret = 1;
7400
} else if (arg1i == 0 && arg2i == 0) {
7401
ret = (arg1->floatval <= arg2->floatval);
7402
} else {
7403
ret = 0;
7404
}
7405
}
7406
else if (!inf && strict) {
7407
if ((arg1i == 1 && arg2i != 1) ||
7408
(arg2i == -1 && arg1i != -1)) {
7409
ret = 1;
7410
} else if (arg1i == 0 && arg2i == 0) {
7411
ret = (arg1->floatval > arg2->floatval);
7412
} else {
7413
ret = 0;
7414
}
7415
}
7416
else if (!inf && !strict) {
7417
if (arg1i == 1 || arg2i == -1) {
7418
ret = 1;
7419
} else if (arg1i == 0 && arg2i == 0) {
7420
ret = (arg1->floatval >= arg2->floatval);
7421
} else {
7422
ret = 0;
7423
}
7424
}
7425
}
7426
xmlXPathReleaseObject(ctxt->context, arg1);
7427
xmlXPathReleaseObject(ctxt->context, arg2);
7428
return(ret);
7429
}
7430
7431
/**
7432
* xmlXPathValueFlipSign:
7433
* @ctxt: the XPath Parser context
7434
*
7435
* Implement the unary - operation on an XPath object
7436
* The numeric operators convert their operands to numbers as if
7437
* by calling the number function.
7438
*/
7439
void
7440
xmlXPathValueFlipSign(xmlXPathParserContextPtr ctxt) {
7441
if ((ctxt == NULL) || (ctxt->context == NULL)) return;
7442
CAST_TO_NUMBER;
7443
CHECK_TYPE(XPATH_NUMBER);
7444
if (xmlXPathIsNaN(ctxt->value->floatval))
7445
ctxt->value->floatval=xmlXPathNAN;
7446
else if (xmlXPathIsInf(ctxt->value->floatval) == 1)
7447
ctxt->value->floatval=xmlXPathNINF;
7448
else if (xmlXPathIsInf(ctxt->value->floatval) == -1)
7449
ctxt->value->floatval=xmlXPathPINF;
7450
else if (ctxt->value->floatval == 0) {
7451
if (xmlXPathGetSign(ctxt->value->floatval) == 0)
7452
ctxt->value->floatval = xmlXPathNZERO;
7453
else
7454
ctxt->value->floatval = 0;
7455
}
7456
else
7457
ctxt->value->floatval = - ctxt->value->floatval;
7458
}
7459
7460
/**
7461
* xmlXPathAddValues:
7462
* @ctxt: the XPath Parser context
7463
*
7464
* Implement the add operation on XPath objects:
7465
* The numeric operators convert their operands to numbers as if
7466
* by calling the number function.
7467
*/
7468
void
7469
xmlXPathAddValues(xmlXPathParserContextPtr ctxt) {
7470
xmlXPathObjectPtr arg;
7471
double val;
7472
7473
arg = valuePop(ctxt);
7474
if (arg == NULL)
7475
XP_ERROR(XPATH_INVALID_OPERAND);
7476
val = xmlXPathCastToNumber(arg);
7477
xmlXPathReleaseObject(ctxt->context, arg);
7478
CAST_TO_NUMBER;
7479
CHECK_TYPE(XPATH_NUMBER);
7480
ctxt->value->floatval += val;
7481
}
7482
7483
/**
7484
* xmlXPathSubValues:
7485
* @ctxt: the XPath Parser context
7486
*
7487
* Implement the subtraction operation on XPath objects:
7488
* The numeric operators convert their operands to numbers as if
7489
* by calling the number function.
7490
*/
7491
void
7492
xmlXPathSubValues(xmlXPathParserContextPtr ctxt) {
7493
xmlXPathObjectPtr arg;
7494
double val;
7495
7496
arg = valuePop(ctxt);
7497
if (arg == NULL)
7498
XP_ERROR(XPATH_INVALID_OPERAND);
7499
val = xmlXPathCastToNumber(arg);
7500
xmlXPathReleaseObject(ctxt->context, arg);
7501
CAST_TO_NUMBER;
7502
CHECK_TYPE(XPATH_NUMBER);
7503
ctxt->value->floatval -= val;
7504
}
7505
7506
/**
7507
* xmlXPathMultValues:
7508
* @ctxt: the XPath Parser context
7509
*
7510
* Implement the multiply operation on XPath objects:
7511
* The numeric operators convert their operands to numbers as if
7512
* by calling the number function.
7513
*/
7514
void
7515
xmlXPathMultValues(xmlXPathParserContextPtr ctxt) {
7516
xmlXPathObjectPtr arg;
7517
double val;
7518
7519
arg = valuePop(ctxt);
7520
if (arg == NULL)
7521
XP_ERROR(XPATH_INVALID_OPERAND);
7522
val = xmlXPathCastToNumber(arg);
7523
xmlXPathReleaseObject(ctxt->context, arg);
7524
CAST_TO_NUMBER;
7525
CHECK_TYPE(XPATH_NUMBER);
7526
ctxt->value->floatval *= val;
7527
}
7528
7529
/**
7530
* xmlXPathDivValues:
7531
* @ctxt: the XPath Parser context
7532
*
7533
* Implement the div operation on XPath objects @arg1 / @arg2:
7534
* The numeric operators convert their operands to numbers as if
7535
* by calling the number function.
7536
*/
7537
void
7538
xmlXPathDivValues(xmlXPathParserContextPtr ctxt) {
7539
xmlXPathObjectPtr arg;
7540
double val;
7541
7542
arg = valuePop(ctxt);
7543
if (arg == NULL)
7544
XP_ERROR(XPATH_INVALID_OPERAND);
7545
val = xmlXPathCastToNumber(arg);
7546
xmlXPathReleaseObject(ctxt->context, arg);
7547
CAST_TO_NUMBER;
7548
CHECK_TYPE(XPATH_NUMBER);
7549
if (xmlXPathIsNaN(val) || xmlXPathIsNaN(ctxt->value->floatval))
7550
ctxt->value->floatval = xmlXPathNAN;
7551
else if (val == 0 && xmlXPathGetSign(val) != 0) {
7552
if (ctxt->value->floatval == 0)
7553
ctxt->value->floatval = xmlXPathNAN;
7554
else if (ctxt->value->floatval > 0)
7555
ctxt->value->floatval = xmlXPathNINF;
7556
else if (ctxt->value->floatval < 0)
7557
ctxt->value->floatval = xmlXPathPINF;
7558
}
7559
else if (val == 0) {
7560
if (ctxt->value->floatval == 0)
7561
ctxt->value->floatval = xmlXPathNAN;
7562
else if (ctxt->value->floatval > 0)
7563
ctxt->value->floatval = xmlXPathPINF;
7564
else if (ctxt->value->floatval < 0)
7565
ctxt->value->floatval = xmlXPathNINF;
7566
} else
7567
ctxt->value->floatval /= val;
7568
}
7569
7570
/**
7571
* xmlXPathModValues:
7572
* @ctxt: the XPath Parser context
7573
*
7574
* Implement the mod operation on XPath objects: @arg1 / @arg2
7575
* The numeric operators convert their operands to numbers as if
7576
* by calling the number function.
7577
*/
7578
void
7579
xmlXPathModValues(xmlXPathParserContextPtr ctxt) {
7580
xmlXPathObjectPtr arg;
7581
double arg1, arg2;
7582
7583
arg = valuePop(ctxt);
7584
if (arg == NULL)
7585
XP_ERROR(XPATH_INVALID_OPERAND);
7586
arg2 = xmlXPathCastToNumber(arg);
7587
xmlXPathReleaseObject(ctxt->context, arg);
7588
CAST_TO_NUMBER;
7589
CHECK_TYPE(XPATH_NUMBER);
7590
arg1 = ctxt->value->floatval;
7591
if (arg2 == 0)
7592
ctxt->value->floatval = xmlXPathNAN;
7593
else {
7594
ctxt->value->floatval = fmod(arg1, arg2);
7595
}
7596
}
7597
7598
/************************************************************************
7599
* *
7600
* The traversal functions *
7601
* *
7602
************************************************************************/
7603
7604
/*
7605
* A traversal function enumerates nodes along an axis.
7606
* Initially it must be called with NULL, and it indicates
7607
* termination on the axis by returning NULL.
7608
*/
7609
typedef xmlNodePtr (*xmlXPathTraversalFunction)
7610
(xmlXPathParserContextPtr ctxt, xmlNodePtr cur);
7611
7612
/*
7613
* xmlXPathTraversalFunctionExt:
7614
* A traversal function enumerates nodes along an axis.
7615
* Initially it must be called with NULL, and it indicates
7616
* termination on the axis by returning NULL.
7617
* The context node of the traversal is specified via @contextNode.
7618
*/
7619
typedef xmlNodePtr (*xmlXPathTraversalFunctionExt)
7620
(xmlNodePtr cur, xmlNodePtr contextNode);
7621
7622
/*
7623
* xmlXPathNodeSetMergeFunction:
7624
* Used for merging node sets in xmlXPathCollectAndTest().
7625
*/
7626
typedef xmlNodeSetPtr (*xmlXPathNodeSetMergeFunction)
7627
(xmlNodeSetPtr, xmlNodeSetPtr, int);
7628
7629
7630
/**
7631
* xmlXPathNextSelf:
7632
* @ctxt: the XPath Parser context
7633
* @cur: the current node in the traversal
7634
*
7635
* Traversal function for the "self" direction
7636
* The self axis contains just the context node itself
7637
*
7638
* Returns the next element following that axis
7639
*/
7640
xmlNodePtr
7641
xmlXPathNextSelf(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
7642
if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
7643
if (cur == NULL)
7644
return(ctxt->context->node);
7645
return(NULL);
7646
}
7647
7648
/**
7649
* xmlXPathNextChild:
7650
* @ctxt: the XPath Parser context
7651
* @cur: the current node in the traversal
7652
*
7653
* Traversal function for the "child" direction
7654
* The child axis contains the children of the context node in document order.
7655
*
7656
* Returns the next element following that axis
7657
*/
7658
xmlNodePtr
7659
xmlXPathNextChild(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
7660
if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
7661
if (cur == NULL) {
7662
if (ctxt->context->node == NULL) return(NULL);
7663
switch (ctxt->context->node->type) {
7664
case XML_ELEMENT_NODE:
7665
case XML_TEXT_NODE:
7666
case XML_CDATA_SECTION_NODE:
7667
case XML_ENTITY_REF_NODE:
7668
case XML_ENTITY_NODE:
7669
case XML_PI_NODE:
7670
case XML_COMMENT_NODE:
7671
case XML_NOTATION_NODE:
7672
case XML_DTD_NODE:
7673
return(ctxt->context->node->children);
7674
case XML_DOCUMENT_NODE:
7675
case XML_DOCUMENT_TYPE_NODE:
7676
case XML_DOCUMENT_FRAG_NODE:
7677
case XML_HTML_DOCUMENT_NODE:
7678
#ifdef LIBXML_DOCB_ENABLED
7679
case XML_DOCB_DOCUMENT_NODE:
7680
#endif
7681
return(((xmlDocPtr) ctxt->context->node)->children);
7682
case XML_ELEMENT_DECL:
7683
case XML_ATTRIBUTE_DECL:
7684
case XML_ENTITY_DECL:
7685
case XML_ATTRIBUTE_NODE:
7686
case XML_NAMESPACE_DECL:
7687
case XML_XINCLUDE_START:
7688
case XML_XINCLUDE_END:
7689
return(NULL);
7690
}
7691
return(NULL);
7692
}
7693
if ((cur->type == XML_DOCUMENT_NODE) ||
7694
(cur->type == XML_HTML_DOCUMENT_NODE))
7695
return(NULL);
7696
return(cur->next);
7697
}
7698
7699
/**
7700
* xmlXPathNextChildElement:
7701
* @ctxt: the XPath Parser context
7702
* @cur: the current node in the traversal
7703
*
7704
* Traversal function for the "child" direction and nodes of type element.
7705
* The child axis contains the children of the context node in document order.
7706
*
7707
* Returns the next element following that axis
7708
*/
7709
static xmlNodePtr
7710
xmlXPathNextChildElement(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
7711
if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
7712
if (cur == NULL) {
7713
cur = ctxt->context->node;
7714
if (cur == NULL) return(NULL);
7715
/*
7716
* Get the first element child.
7717
*/
7718
switch (cur->type) {
7719
case XML_ELEMENT_NODE:
7720
case XML_DOCUMENT_FRAG_NODE:
7721
case XML_ENTITY_REF_NODE: /* URGENT TODO: entify-refs as well? */
7722
case XML_ENTITY_NODE:
7723
cur = cur->children;
7724
if (cur != NULL) {
7725
if (cur->type == XML_ELEMENT_NODE)
7726
return(cur);
7727
do {
7728
cur = cur->next;
7729
} while ((cur != NULL) &&
7730
(cur->type != XML_ELEMENT_NODE));
7731
return(cur);
7732
}
7733
return(NULL);
7734
case XML_DOCUMENT_NODE:
7735
case XML_HTML_DOCUMENT_NODE:
7736
#ifdef LIBXML_DOCB_ENABLED
7737
case XML_DOCB_DOCUMENT_NODE:
7738
#endif
7739
return(xmlDocGetRootElement((xmlDocPtr) cur));
7740
default:
7741
return(NULL);
7742
}
7743
return(NULL);
7744
}
7745
/*
7746
* Get the next sibling element node.
7747
*/
7748
switch (cur->type) {
7749
case XML_ELEMENT_NODE:
7750
case XML_TEXT_NODE:
7751
case XML_ENTITY_REF_NODE:
7752
case XML_ENTITY_NODE:
7753
case XML_CDATA_SECTION_NODE:
7754
case XML_PI_NODE:
7755
case XML_COMMENT_NODE:
7756
case XML_XINCLUDE_END:
7757
break;
7758
/* case XML_DTD_NODE: */ /* URGENT TODO: DTD-node as well? */
7759
default:
7760
return(NULL);
7761
}
7762
if (cur->next != NULL) {
7763
if (cur->next->type == XML_ELEMENT_NODE)
7764
return(cur->next);
7765
cur = cur->next;
7766
do {
7767
cur = cur->next;
7768
} while ((cur != NULL) && (cur->type != XML_ELEMENT_NODE));
7769
return(cur);
7770
}
7771
return(NULL);
7772
}
7773
7774
#if 0
7775
/**
7776
* xmlXPathNextDescendantOrSelfElemParent:
7777
* @ctxt: the XPath Parser context
7778
* @cur: the current node in the traversal
7779
*
7780
* Traversal function for the "descendant-or-self" axis.
7781
* Additionally it returns only nodes which can be parents of
7782
* element nodes.
7783
*
7784
*
7785
* Returns the next element following that axis
7786
*/
7787
static xmlNodePtr
7788
xmlXPathNextDescendantOrSelfElemParent(xmlNodePtr cur,
7789
xmlNodePtr contextNode)
7790
{
7791
if (cur == NULL) {
7792
if (contextNode == NULL)
7793
return(NULL);
7794
switch (contextNode->type) {
7795
case XML_ELEMENT_NODE:
7796
case XML_XINCLUDE_START:
7797
case XML_DOCUMENT_FRAG_NODE:
7798
case XML_DOCUMENT_NODE:
7799
#ifdef LIBXML_DOCB_ENABLED
7800
case XML_DOCB_DOCUMENT_NODE:
7801
#endif
7802
case XML_HTML_DOCUMENT_NODE:
7803
return(contextNode);
7804
default:
7805
return(NULL);
7806
}
7807
return(NULL);
7808
} else {
7809
xmlNodePtr start = cur;
7810
7811
while (cur != NULL) {
7812
switch (cur->type) {
7813
case XML_ELEMENT_NODE:
7814
/* TODO: OK to have XInclude here? */
7815
case XML_XINCLUDE_START:
7816
case XML_DOCUMENT_FRAG_NODE:
7817
if (cur != start)
7818
return(cur);
7819
if (cur->children != NULL) {
7820
cur = cur->children;
7821
continue;
7822
}
7823
break;
7824
/* Not sure if we need those here. */
7825
case XML_DOCUMENT_NODE:
7826
#ifdef LIBXML_DOCB_ENABLED
7827
case XML_DOCB_DOCUMENT_NODE:
7828
#endif
7829
case XML_HTML_DOCUMENT_NODE:
7830
if (cur != start)
7831
return(cur);
7832
return(xmlDocGetRootElement((xmlDocPtr) cur));
7833
default:
7834
break;
7835
}
7836
7837
next_sibling:
7838
if ((cur == NULL) || (cur == contextNode))
7839
return(NULL);
7840
if (cur->next != NULL) {
7841
cur = cur->next;
7842
} else {
7843
cur = cur->parent;
7844
goto next_sibling;
7845
}
7846
}
7847
}
7848
return(NULL);
7849
}
7850
#endif
7851
7852
/**
7853
* xmlXPathNextDescendant:
7854
* @ctxt: the XPath Parser context
7855
* @cur: the current node in the traversal
7856
*
7857
* Traversal function for the "descendant" direction
7858
* the descendant axis contains the descendants of the context node in document
7859
* order; a descendant is a child or a child of a child and so on.
7860
*
7861
* Returns the next element following that axis
7862
*/
7863
xmlNodePtr
7864
xmlXPathNextDescendant(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
7865
if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
7866
if (cur == NULL) {
7867
if (ctxt->context->node == NULL)
7868
return(NULL);
7869
if ((ctxt->context->node->type == XML_ATTRIBUTE_NODE) ||
7870
(ctxt->context->node->type == XML_NAMESPACE_DECL))
7871
return(NULL);
7872
7873
if (ctxt->context->node == (xmlNodePtr) ctxt->context->doc)
7874
return(ctxt->context->doc->children);
7875
return(ctxt->context->node->children);
7876
}
7877
7878
if (cur->type == XML_NAMESPACE_DECL)
7879
return(NULL);
7880
if (cur->children != NULL) {
7881
/*
7882
* Do not descend on entities declarations
7883
*/
7884
if (cur->children->type != XML_ENTITY_DECL) {
7885
cur = cur->children;
7886
/*
7887
* Skip DTDs
7888
*/
7889
if (cur->type != XML_DTD_NODE)
7890
return(cur);
7891
}
7892
}
7893
7894
if (cur == ctxt->context->node) return(NULL);
7895
7896
while (cur->next != NULL) {
7897
cur = cur->next;
7898
if ((cur->type != XML_ENTITY_DECL) &&
7899
(cur->type != XML_DTD_NODE))
7900
return(cur);
7901
}
7902
7903
do {
7904
cur = cur->parent;
7905
if (cur == NULL) break;
7906
if (cur == ctxt->context->node) return(NULL);
7907
if (cur->next != NULL) {
7908
cur = cur->next;
7909
return(cur);
7910
}
7911
} while (cur != NULL);
7912
return(cur);
7913
}
7914
7915
/**
7916
* xmlXPathNextDescendantOrSelf:
7917
* @ctxt: the XPath Parser context
7918
* @cur: the current node in the traversal
7919
*
7920
* Traversal function for the "descendant-or-self" direction
7921
* the descendant-or-self axis contains the context node and the descendants
7922
* of the context node in document order; thus the context node is the first
7923
* node on the axis, and the first child of the context node is the second node
7924
* on the axis
7925
*
7926
* Returns the next element following that axis
7927
*/
7928
xmlNodePtr
7929
xmlXPathNextDescendantOrSelf(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
7930
if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
7931
if (cur == NULL) {
7932
if (ctxt->context->node == NULL)
7933
return(NULL);
7934
if ((ctxt->context->node->type == XML_ATTRIBUTE_NODE) ||
7935
(ctxt->context->node->type == XML_NAMESPACE_DECL))
7936
return(NULL);
7937
return(ctxt->context->node);
7938
}
7939
7940
return(xmlXPathNextDescendant(ctxt, cur));
7941
}
7942
7943
/**
7944
* xmlXPathNextParent:
7945
* @ctxt: the XPath Parser context
7946
* @cur: the current node in the traversal
7947
*
7948
* Traversal function for the "parent" direction
7949
* The parent axis contains the parent of the context node, if there is one.
7950
*
7951
* Returns the next element following that axis
7952
*/
7953
xmlNodePtr
7954
xmlXPathNextParent(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
7955
if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
7956
/*
7957
* the parent of an attribute or namespace node is the element
7958
* to which the attribute or namespace node is attached
7959
* Namespace handling !!!
7960
*/
7961
if (cur == NULL) {
7962
if (ctxt->context->node == NULL) return(NULL);
7963
switch (ctxt->context->node->type) {
7964
case XML_ELEMENT_NODE:
7965
case XML_TEXT_NODE:
7966
case XML_CDATA_SECTION_NODE:
7967
case XML_ENTITY_REF_NODE:
7968
case XML_ENTITY_NODE:
7969
case XML_PI_NODE:
7970
case XML_COMMENT_NODE:
7971
case XML_NOTATION_NODE:
7972
case XML_DTD_NODE:
7973
case XML_ELEMENT_DECL:
7974
case XML_ATTRIBUTE_DECL:
7975
case XML_XINCLUDE_START:
7976
case XML_XINCLUDE_END:
7977
case XML_ENTITY_DECL:
7978
if (ctxt->context->node->parent == NULL)
7979
return((xmlNodePtr) ctxt->context->doc);
7980
if ((ctxt->context->node->parent->type == XML_ELEMENT_NODE) &&
7981
((ctxt->context->node->parent->name[0] == ' ') ||
7982
(xmlStrEqual(ctxt->context->node->parent->name,
7983
BAD_CAST "fake node libxslt"))))
7984
return(NULL);
7985
return(ctxt->context->node->parent);
7986
case XML_ATTRIBUTE_NODE: {
7987
xmlAttrPtr att = (xmlAttrPtr) ctxt->context->node;
7988
7989
return(att->parent);
7990
}
7991
case XML_DOCUMENT_NODE:
7992
case XML_DOCUMENT_TYPE_NODE:
7993
case XML_DOCUMENT_FRAG_NODE:
7994
case XML_HTML_DOCUMENT_NODE:
7995
#ifdef LIBXML_DOCB_ENABLED
7996
case XML_DOCB_DOCUMENT_NODE:
7997
#endif
7998
return(NULL);
7999
case XML_NAMESPACE_DECL: {
8000
xmlNsPtr ns = (xmlNsPtr) ctxt->context->node;
8001
8002
if ((ns->next != NULL) &&
8003
(ns->next->type != XML_NAMESPACE_DECL))
8004
return((xmlNodePtr) ns->next);
8005
return(NULL);
8006
}
8007
}
8008
}
8009
return(NULL);
8010
}
8011
8012
/**
8013
* xmlXPathNextAncestor:
8014
* @ctxt: the XPath Parser context
8015
* @cur: the current node in the traversal
8016
*
8017
* Traversal function for the "ancestor" direction
8018
* the ancestor axis contains the ancestors of the context node; the ancestors
8019
* of the context node consist of the parent of context node and the parent's
8020
* parent and so on; the nodes are ordered in reverse document order; thus the
8021
* parent is the first node on the axis, and the parent's parent is the second
8022
* node on the axis
8023
*
8024
* Returns the next element following that axis
8025
*/
8026
xmlNodePtr
8027
xmlXPathNextAncestor(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
8028
if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
8029
/*
8030
* the parent of an attribute or namespace node is the element
8031
* to which the attribute or namespace node is attached
8032
* !!!!!!!!!!!!!
8033
*/
8034
if (cur == NULL) {
8035
if (ctxt->context->node == NULL) return(NULL);
8036
switch (ctxt->context->node->type) {
8037
case XML_ELEMENT_NODE:
8038
case XML_TEXT_NODE:
8039
case XML_CDATA_SECTION_NODE:
8040
case XML_ENTITY_REF_NODE:
8041
case XML_ENTITY_NODE:
8042
case XML_PI_NODE:
8043
case XML_COMMENT_NODE:
8044
case XML_DTD_NODE:
8045
case XML_ELEMENT_DECL:
8046
case XML_ATTRIBUTE_DECL:
8047
case XML_ENTITY_DECL:
8048
case XML_NOTATION_NODE:
8049
case XML_XINCLUDE_START:
8050
case XML_XINCLUDE_END:
8051
if (ctxt->context->node->parent == NULL)
8052
return((xmlNodePtr) ctxt->context->doc);
8053
if ((ctxt->context->node->parent->type == XML_ELEMENT_NODE) &&
8054
((ctxt->context->node->parent->name[0] == ' ') ||
8055
(xmlStrEqual(ctxt->context->node->parent->name,
8056
BAD_CAST "fake node libxslt"))))
8057
return(NULL);
8058
return(ctxt->context->node->parent);
8059
case XML_ATTRIBUTE_NODE: {
8060
xmlAttrPtr tmp = (xmlAttrPtr) ctxt->context->node;
8061
8062
return(tmp->parent);
8063
}
8064
case XML_DOCUMENT_NODE:
8065
case XML_DOCUMENT_TYPE_NODE:
8066
case XML_DOCUMENT_FRAG_NODE:
8067
case XML_HTML_DOCUMENT_NODE:
8068
#ifdef LIBXML_DOCB_ENABLED
8069
case XML_DOCB_DOCUMENT_NODE:
8070
#endif
8071
return(NULL);
8072
case XML_NAMESPACE_DECL: {
8073
xmlNsPtr ns = (xmlNsPtr) ctxt->context->node;
8074
8075
if ((ns->next != NULL) &&
8076
(ns->next->type != XML_NAMESPACE_DECL))
8077
return((xmlNodePtr) ns->next);
8078
/* Bad, how did that namespace end up here ? */
8079
return(NULL);
8080
}
8081
}
8082
return(NULL);
8083
}
8084
if (cur == ctxt->context->doc->children)
8085
return((xmlNodePtr) ctxt->context->doc);
8086
if (cur == (xmlNodePtr) ctxt->context->doc)
8087
return(NULL);
8088
switch (cur->type) {
8089
case XML_ELEMENT_NODE:
8090
case XML_TEXT_NODE:
8091
case XML_CDATA_SECTION_NODE:
8092
case XML_ENTITY_REF_NODE:
8093
case XML_ENTITY_NODE:
8094
case XML_PI_NODE:
8095
case XML_COMMENT_NODE:
8096
case XML_NOTATION_NODE:
8097
case XML_DTD_NODE:
8098
case XML_ELEMENT_DECL:
8099
case XML_ATTRIBUTE_DECL:
8100
case XML_ENTITY_DECL:
8101
case XML_XINCLUDE_START:
8102
case XML_XINCLUDE_END:
8103
if (cur->parent == NULL)
8104
return(NULL);
8105
if ((cur->parent->type == XML_ELEMENT_NODE) &&
8106
((cur->parent->name[0] == ' ') ||
8107
(xmlStrEqual(cur->parent->name,
8108
BAD_CAST "fake node libxslt"))))
8109
return(NULL);
8110
return(cur->parent);
8111
case XML_ATTRIBUTE_NODE: {
8112
xmlAttrPtr att = (xmlAttrPtr) ctxt->context->node;
8113
8114
return(att->parent);
8115
}
8116
case XML_NAMESPACE_DECL: {
8117
xmlNsPtr ns = (xmlNsPtr) ctxt->context->node;
8118
8119
if ((ns->next != NULL) &&
8120
(ns->next->type != XML_NAMESPACE_DECL))
8121
return((xmlNodePtr) ns->next);
8122
/* Bad, how did that namespace end up here ? */
8123
return(NULL);
8124
}
8125
case XML_DOCUMENT_NODE:
8126
case XML_DOCUMENT_TYPE_NODE:
8127
case XML_DOCUMENT_FRAG_NODE:
8128
case XML_HTML_DOCUMENT_NODE:
8129
#ifdef LIBXML_DOCB_ENABLED
8130
case XML_DOCB_DOCUMENT_NODE:
8131
#endif
8132
return(NULL);
8133
}
8134
return(NULL);
8135
}
8136
8137
/**
8138
* xmlXPathNextAncestorOrSelf:
8139
* @ctxt: the XPath Parser context
8140
* @cur: the current node in the traversal
8141
*
8142
* Traversal function for the "ancestor-or-self" direction
8143
* he ancestor-or-self axis contains the context node and ancestors of
8144
* the context node in reverse document order; thus the context node is
8145
* the first node on the axis, and the context node's parent the second;
8146
* parent here is defined the same as with the parent axis.
8147
*
8148
* Returns the next element following that axis
8149
*/
8150
xmlNodePtr
8151
xmlXPathNextAncestorOrSelf(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
8152
if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
8153
if (cur == NULL)
8154
return(ctxt->context->node);
8155
return(xmlXPathNextAncestor(ctxt, cur));
8156
}
8157
8158
/**
8159
* xmlXPathNextFollowingSibling:
8160
* @ctxt: the XPath Parser context
8161
* @cur: the current node in the traversal
8162
*
8163
* Traversal function for the "following-sibling" direction
8164
* The following-sibling axis contains the following siblings of the context
8165
* node in document order.
8166
*
8167
* Returns the next element following that axis
8168
*/
8169
xmlNodePtr
8170
xmlXPathNextFollowingSibling(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
8171
if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
8172
if ((ctxt->context->node->type == XML_ATTRIBUTE_NODE) ||
8173
(ctxt->context->node->type == XML_NAMESPACE_DECL))
8174
return(NULL);
8175
if (cur == (xmlNodePtr) ctxt->context->doc)
8176
return(NULL);
8177
if (cur == NULL)
8178
return(ctxt->context->node->next);
8179
return(cur->next);
8180
}
8181
8182
/**
8183
* xmlXPathNextPrecedingSibling:
8184
* @ctxt: the XPath Parser context
8185
* @cur: the current node in the traversal
8186
*
8187
* Traversal function for the "preceding-sibling" direction
8188
* The preceding-sibling axis contains the preceding siblings of the context
8189
* node in reverse document order; the first preceding sibling is first on the
8190
* axis; the sibling preceding that node is the second on the axis and so on.
8191
*
8192
* Returns the next element following that axis
8193
*/
8194
xmlNodePtr
8195
xmlXPathNextPrecedingSibling(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
8196
if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
8197
if ((ctxt->context->node->type == XML_ATTRIBUTE_NODE) ||
8198
(ctxt->context->node->type == XML_NAMESPACE_DECL))
8199
return(NULL);
8200
if (cur == (xmlNodePtr) ctxt->context->doc)
8201
return(NULL);
8202
if (cur == NULL)
8203
return(ctxt->context->node->prev);
8204
if ((cur->prev != NULL) && (cur->prev->type == XML_DTD_NODE)) {
8205
cur = cur->prev;
8206
if (cur == NULL)
8207
return(ctxt->context->node->prev);
8208
}
8209
return(cur->prev);
8210
}
8211
8212
/**
8213
* xmlXPathNextFollowing:
8214
* @ctxt: the XPath Parser context
8215
* @cur: the current node in the traversal
8216
*
8217
* Traversal function for the "following" direction
8218
* The following axis contains all nodes in the same document as the context
8219
* node that are after the context node in document order, excluding any
8220
* descendants and excluding attribute nodes and namespace nodes; the nodes
8221
* are ordered in document order
8222
*
8223
* Returns the next element following that axis
8224
*/
8225
xmlNodePtr
8226
xmlXPathNextFollowing(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
8227
if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
8228
if ((cur != NULL) && (cur->type != XML_ATTRIBUTE_NODE) &&
8229
(cur->type != XML_NAMESPACE_DECL) && (cur->children != NULL))
8230
return(cur->children);
8231
8232
if (cur == NULL) {
8233
cur = ctxt->context->node;
8234
if (cur->type == XML_NAMESPACE_DECL)
8235
return(NULL);
8236
if (cur->type == XML_ATTRIBUTE_NODE)
8237
cur = cur->parent;
8238
}
8239
if (cur == NULL) return(NULL) ; /* ERROR */
8240
if (cur->next != NULL) return(cur->next) ;
8241
do {
8242
cur = cur->parent;
8243
if (cur == NULL) break;
8244
if (cur == (xmlNodePtr) ctxt->context->doc) return(NULL);
8245
if (cur->next != NULL) return(cur->next);
8246
} while (cur != NULL);
8247
return(cur);
8248
}
8249
8250
/*
8251
* xmlXPathIsAncestor:
8252
* @ancestor: the ancestor node
8253
* @node: the current node
8254
*
8255
* Check that @ancestor is a @node's ancestor
8256
*
8257
* returns 1 if @ancestor is a @node's ancestor, 0 otherwise.
8258
*/
8259
static int
8260
xmlXPathIsAncestor(xmlNodePtr ancestor, xmlNodePtr node) {
8261
if ((ancestor == NULL) || (node == NULL)) return(0);
8262
if (node->type == XML_NAMESPACE_DECL)
8263
return(0);
8264
if (ancestor->type == XML_NAMESPACE_DECL)
8265
return(0);
8266
/* nodes need to be in the same document */
8267
if (ancestor->doc != node->doc) return(0);
8268
/* avoid searching if ancestor or node is the root node */
8269
if (ancestor == (xmlNodePtr) node->doc) return(1);
8270
if (node == (xmlNodePtr) ancestor->doc) return(0);
8271
while (node->parent != NULL) {
8272
if (node->parent == ancestor)
8273
return(1);
8274
node = node->parent;
8275
}
8276
return(0);
8277
}
8278
8279
/**
8280
* xmlXPathNextPreceding:
8281
* @ctxt: the XPath Parser context
8282
* @cur: the current node in the traversal
8283
*
8284
* Traversal function for the "preceding" direction
8285
* the preceding axis contains all nodes in the same document as the context
8286
* node that are before the context node in document order, excluding any
8287
* ancestors and excluding attribute nodes and namespace nodes; the nodes are
8288
* ordered in reverse document order
8289
*
8290
* Returns the next element following that axis
8291
*/
8292
xmlNodePtr
8293
xmlXPathNextPreceding(xmlXPathParserContextPtr ctxt, xmlNodePtr cur)
8294
{
8295
if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
8296
if (cur == NULL) {
8297
cur = ctxt->context->node;
8298
if (cur->type == XML_NAMESPACE_DECL)
8299
return(NULL);
8300
if (cur->type == XML_ATTRIBUTE_NODE)
8301
return(cur->parent);
8302
}
8303
if ((cur == NULL) || (cur->type == XML_NAMESPACE_DECL))
8304
return (NULL);
8305
if ((cur->prev != NULL) && (cur->prev->type == XML_DTD_NODE))
8306
cur = cur->prev;
8307
do {
8308
if (cur->prev != NULL) {
8309
for (cur = cur->prev; cur->last != NULL; cur = cur->last) ;
8310
return (cur);
8311
}
8312
8313
cur = cur->parent;
8314
if (cur == NULL)
8315
return (NULL);
8316
if (cur == ctxt->context->doc->children)
8317
return (NULL);
8318
} while (xmlXPathIsAncestor(cur, ctxt->context->node));
8319
return (cur);
8320
}
8321
8322
/**
8323
* xmlXPathNextPrecedingInternal:
8324
* @ctxt: the XPath Parser context
8325
* @cur: the current node in the traversal
8326
*
8327
* Traversal function for the "preceding" direction
8328
* the preceding axis contains all nodes in the same document as the context
8329
* node that are before the context node in document order, excluding any
8330
* ancestors and excluding attribute nodes and namespace nodes; the nodes are
8331
* ordered in reverse document order
8332
* This is a faster implementation but internal only since it requires a
8333
* state kept in the parser context: ctxt->ancestor.
8334
*
8335
* Returns the next element following that axis
8336
*/
8337
static xmlNodePtr
8338
xmlXPathNextPrecedingInternal(xmlXPathParserContextPtr ctxt,
8339
xmlNodePtr cur)
8340
{
8341
if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
8342
if (cur == NULL) {
8343
cur = ctxt->context->node;
8344
if (cur == NULL)
8345
return (NULL);
8346
if (cur->type == XML_NAMESPACE_DECL)
8347
return (NULL);
8348
ctxt->ancestor = cur->parent;
8349
}
8350
if (cur->type == XML_NAMESPACE_DECL)
8351
return(NULL);
8352
if ((cur->prev != NULL) && (cur->prev->type == XML_DTD_NODE))
8353
cur = cur->prev;
8354
while (cur->prev == NULL) {
8355
cur = cur->parent;
8356
if (cur == NULL)
8357
return (NULL);
8358
if (cur == ctxt->context->doc->children)
8359
return (NULL);
8360
if (cur != ctxt->ancestor)
8361
return (cur);
8362
ctxt->ancestor = cur->parent;
8363
}
8364
cur = cur->prev;
8365
while (cur->last != NULL)
8366
cur = cur->last;
8367
return (cur);
8368
}
8369
8370
/**
8371
* xmlXPathNextNamespace:
8372
* @ctxt: the XPath Parser context
8373
* @cur: the current attribute in the traversal
8374
*
8375
* Traversal function for the "namespace" direction
8376
* the namespace axis contains the namespace nodes of the context node;
8377
* the order of nodes on this axis is implementation-defined; the axis will
8378
* be empty unless the context node is an element
8379
*
8380
* We keep the XML namespace node at the end of the list.
8381
*
8382
* Returns the next element following that axis
8383
*/
8384
xmlNodePtr
8385
xmlXPathNextNamespace(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
8386
if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
8387
if (ctxt->context->node->type != XML_ELEMENT_NODE) return(NULL);
8388
if (ctxt->context->tmpNsList == NULL && cur != (xmlNodePtr) xmlXPathXMLNamespace) {
8389
if (ctxt->context->tmpNsList != NULL)
8390
xmlFree(ctxt->context->tmpNsList);
8391
ctxt->context->tmpNsList =
8392
xmlGetNsList(ctxt->context->doc, ctxt->context->node);
8393
ctxt->context->tmpNsNr = 0;
8394
if (ctxt->context->tmpNsList != NULL) {
8395
while (ctxt->context->tmpNsList[ctxt->context->tmpNsNr] != NULL) {
8396
ctxt->context->tmpNsNr++;
8397
}
8398
}
8399
return((xmlNodePtr) xmlXPathXMLNamespace);
8400
}
8401
if (ctxt->context->tmpNsNr > 0) {
8402
return (xmlNodePtr)ctxt->context->tmpNsList[--ctxt->context->tmpNsNr];
8403
} else {
8404
if (ctxt->context->tmpNsList != NULL)
8405
xmlFree(ctxt->context->tmpNsList);
8406
ctxt->context->tmpNsList = NULL;
8407
return(NULL);
8408
}
8409
}
8410
8411
/**
8412
* xmlXPathNextAttribute:
8413
* @ctxt: the XPath Parser context
8414
* @cur: the current attribute in the traversal
8415
*
8416
* Traversal function for the "attribute" direction
8417
* TODO: support DTD inherited default attributes
8418
*
8419
* Returns the next element following that axis
8420
*/
8421
xmlNodePtr
8422
xmlXPathNextAttribute(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
8423
if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
8424
if (ctxt->context->node == NULL)
8425
return(NULL);
8426
if (ctxt->context->node->type != XML_ELEMENT_NODE)
8427
return(NULL);
8428
if (cur == NULL) {
8429
if (ctxt->context->node == (xmlNodePtr) ctxt->context->doc)
8430
return(NULL);
8431
return((xmlNodePtr)ctxt->context->node->properties);
8432
}
8433
return((xmlNodePtr)cur->next);
8434
}
8435
8436
/************************************************************************
8437
* *
8438
* NodeTest Functions *
8439
* *
8440
************************************************************************/
8441
8442
#define IS_FUNCTION 200
8443
8444
8445
/************************************************************************
8446
* *
8447
* Implicit tree core function library *
8448
* *
8449
************************************************************************/
8450
8451
/**
8452
* xmlXPathRoot:
8453
* @ctxt: the XPath Parser context
8454
*
8455
* Initialize the context to the root of the document
8456
*/
8457
void
8458
xmlXPathRoot(xmlXPathParserContextPtr ctxt) {
8459
if ((ctxt == NULL) || (ctxt->context == NULL))
8460
return;
8461
ctxt->context->node = (xmlNodePtr) ctxt->context->doc;
8462
valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context,
8463
ctxt->context->node));
8464
}
8465
8466
/************************************************************************
8467
* *
8468
* The explicit core function library *
8469
*http://www.w3.org/Style/XSL/Group/1999/07/xpath-19990705.html#corelib *
8470
* *
8471
************************************************************************/
8472
8473
8474
/**
8475
* xmlXPathLastFunction:
8476
* @ctxt: the XPath Parser context
8477
* @nargs: the number of arguments
8478
*
8479
* Implement the last() XPath function
8480
* number last()
8481
* The last function returns the number of nodes in the context node list.
8482
*/
8483
void
8484
xmlXPathLastFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8485
CHECK_ARITY(0);
8486
if (ctxt->context->contextSize >= 0) {
8487
valuePush(ctxt,
8488
xmlXPathCacheNewFloat(ctxt->context,
8489
(double) ctxt->context->contextSize));
8490
#ifdef DEBUG_EXPR
8491
xmlGenericError(xmlGenericErrorContext,
8492
"last() : %d\n", ctxt->context->contextSize);
8493
#endif
8494
} else {
8495
XP_ERROR(XPATH_INVALID_CTXT_SIZE);
8496
}
8497
}
8498
8499
/**
8500
* xmlXPathPositionFunction:
8501
* @ctxt: the XPath Parser context
8502
* @nargs: the number of arguments
8503
*
8504
* Implement the position() XPath function
8505
* number position()
8506
* The position function returns the position of the context node in the
8507
* context node list. The first position is 1, and so the last position
8508
* will be equal to last().
8509
*/
8510
void
8511
xmlXPathPositionFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8512
CHECK_ARITY(0);
8513
if (ctxt->context->proximityPosition >= 0) {
8514
valuePush(ctxt,
8515
xmlXPathCacheNewFloat(ctxt->context,
8516
(double) ctxt->context->proximityPosition));
8517
#ifdef DEBUG_EXPR
8518
xmlGenericError(xmlGenericErrorContext, "position() : %d\n",
8519
ctxt->context->proximityPosition);
8520
#endif
8521
} else {
8522
XP_ERROR(XPATH_INVALID_CTXT_POSITION);
8523
}
8524
}
8525
8526
/**
8527
* xmlXPathCountFunction:
8528
* @ctxt: the XPath Parser context
8529
* @nargs: the number of arguments
8530
*
8531
* Implement the count() XPath function
8532
* number count(node-set)
8533
*/
8534
void
8535
xmlXPathCountFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8536
xmlXPathObjectPtr cur;
8537
8538
CHECK_ARITY(1);
8539
if ((ctxt->value == NULL) ||
8540
((ctxt->value->type != XPATH_NODESET) &&
8541
(ctxt->value->type != XPATH_XSLT_TREE)))
8542
XP_ERROR(XPATH_INVALID_TYPE);
8543
cur = valuePop(ctxt);
8544
8545
if ((cur == NULL) || (cur->nodesetval == NULL))
8546
valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, (double) 0));
8547
else if ((cur->type == XPATH_NODESET) || (cur->type == XPATH_XSLT_TREE)) {
8548
valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context,
8549
(double) cur->nodesetval->nodeNr));
8550
} else {
8551
if ((cur->nodesetval->nodeNr != 1) ||
8552
(cur->nodesetval->nodeTab == NULL)) {
8553
valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, (double) 0));
8554
} else {
8555
xmlNodePtr tmp;
8556
int i = 0;
8557
8558
tmp = cur->nodesetval->nodeTab[0];
8559
if ((tmp != NULL) && (tmp->type != XML_NAMESPACE_DECL)) {
8560
tmp = tmp->children;
8561
while (tmp != NULL) {
8562
tmp = tmp->next;
8563
i++;
8564
}
8565
}
8566
valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, (double) i));
8567
}
8568
}
8569
xmlXPathReleaseObject(ctxt->context, cur);
8570
}
8571
8572
/**
8573
* xmlXPathGetElementsByIds:
8574
* @doc: the document
8575
* @ids: a whitespace separated list of IDs
8576
*
8577
* Selects elements by their unique ID.
8578
*
8579
* Returns a node-set of selected elements.
8580
*/
8581
static xmlNodeSetPtr
8582
xmlXPathGetElementsByIds (xmlDocPtr doc, const xmlChar *ids) {
8583
xmlNodeSetPtr ret;
8584
const xmlChar *cur = ids;
8585
xmlChar *ID;
8586
xmlAttrPtr attr;
8587
xmlNodePtr elem = NULL;
8588
8589
if (ids == NULL) return(NULL);
8590
8591
ret = xmlXPathNodeSetCreate(NULL);
8592
if (ret == NULL)
8593
return(ret);
8594
8595
while (IS_BLANK_CH(*cur)) cur++;
8596
while (*cur != 0) {
8597
while ((!IS_BLANK_CH(*cur)) && (*cur != 0))
8598
cur++;
8599
8600
ID = xmlStrndup(ids, cur - ids);
8601
if (ID != NULL) {
8602
/*
8603
* We used to check the fact that the value passed
8604
* was an NCName, but this generated much troubles for
8605
* me and Aleksey Sanin, people blatantly violated that
8606
* constaint, like Visa3D spec.
8607
* if (xmlValidateNCName(ID, 1) == 0)
8608
*/
8609
attr = xmlGetID(doc, ID);
8610
if (attr != NULL) {
8611
if (attr->type == XML_ATTRIBUTE_NODE)
8612
elem = attr->parent;
8613
else if (attr->type == XML_ELEMENT_NODE)
8614
elem = (xmlNodePtr) attr;
8615
else
8616
elem = NULL;
8617
if (elem != NULL)
8618
xmlXPathNodeSetAdd(ret, elem);
8619
}
8620
xmlFree(ID);
8621
}
8622
8623
while (IS_BLANK_CH(*cur)) cur++;
8624
ids = cur;
8625
}
8626
return(ret);
8627
}
8628
8629
/**
8630
* xmlXPathIdFunction:
8631
* @ctxt: the XPath Parser context
8632
* @nargs: the number of arguments
8633
*
8634
* Implement the id() XPath function
8635
* node-set id(object)
8636
* The id function selects elements by their unique ID
8637
* (see [5.2.1 Unique IDs]). When the argument to id is of type node-set,
8638
* then the result is the union of the result of applying id to the
8639
* string value of each of the nodes in the argument node-set. When the
8640
* argument to id is of any other type, the argument is converted to a
8641
* string as if by a call to the string function; the string is split
8642
* into a whitespace-separated list of tokens (whitespace is any sequence
8643
* of characters matching the production S); the result is a node-set
8644
* containing the elements in the same document as the context node that
8645
* have a unique ID equal to any of the tokens in the list.
8646
*/
8647
void
8648
xmlXPathIdFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8649
xmlChar *tokens;
8650
xmlNodeSetPtr ret;
8651
xmlXPathObjectPtr obj;
8652
8653
CHECK_ARITY(1);
8654
obj = valuePop(ctxt);
8655
if (obj == NULL) XP_ERROR(XPATH_INVALID_OPERAND);
8656
if ((obj->type == XPATH_NODESET) || (obj->type == XPATH_XSLT_TREE)) {
8657
xmlNodeSetPtr ns;
8658
int i;
8659
8660
ret = xmlXPathNodeSetCreate(NULL);
8661
/*
8662
* FIXME -- in an out-of-memory condition this will behave badly.
8663
* The solution is not clear -- we already popped an item from
8664
* ctxt, so the object is in a corrupt state.
8665
*/
8666
8667
if (obj->nodesetval != NULL) {
8668
for (i = 0; i < obj->nodesetval->nodeNr; i++) {
8669
tokens =
8670
xmlXPathCastNodeToString(obj->nodesetval->nodeTab[i]);
8671
ns = xmlXPathGetElementsByIds(ctxt->context->doc, tokens);
8672
ret = xmlXPathNodeSetMerge(ret, ns);
8673
xmlXPathFreeNodeSet(ns);
8674
if (tokens != NULL)
8675
xmlFree(tokens);
8676
}
8677
}
8678
xmlXPathReleaseObject(ctxt->context, obj);
8679
valuePush(ctxt, xmlXPathCacheWrapNodeSet(ctxt->context, ret));
8680
return;
8681
}
8682
obj = xmlXPathCacheConvertString(ctxt->context, obj);
8683
ret = xmlXPathGetElementsByIds(ctxt->context->doc, obj->stringval);
8684
valuePush(ctxt, xmlXPathCacheWrapNodeSet(ctxt->context, ret));
8685
xmlXPathReleaseObject(ctxt->context, obj);
8686
return;
8687
}
8688
8689
/**
8690
* xmlXPathLocalNameFunction:
8691
* @ctxt: the XPath Parser context
8692
* @nargs: the number of arguments
8693
*
8694
* Implement the local-name() XPath function
8695
* string local-name(node-set?)
8696
* The local-name function returns a string containing the local part
8697
* of the name of the node in the argument node-set that is first in
8698
* document order. If the node-set is empty or the first node has no
8699
* name, an empty string is returned. If the argument is omitted it
8700
* defaults to the context node.
8701
*/
8702
void
8703
xmlXPathLocalNameFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8704
xmlXPathObjectPtr cur;
8705
8706
if (ctxt == NULL) return;
8707
8708
if (nargs == 0) {
8709
valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context,
8710
ctxt->context->node));
8711
nargs = 1;
8712
}
8713
8714
CHECK_ARITY(1);
8715
if ((ctxt->value == NULL) ||
8716
((ctxt->value->type != XPATH_NODESET) &&
8717
(ctxt->value->type != XPATH_XSLT_TREE)))
8718
XP_ERROR(XPATH_INVALID_TYPE);
8719
cur = valuePop(ctxt);
8720
8721
if ((cur->nodesetval == NULL) || (cur->nodesetval->nodeNr == 0)) {
8722
valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, ""));
8723
} else {
8724
int i = 0; /* Should be first in document order !!!!! */
8725
switch (cur->nodesetval->nodeTab[i]->type) {
8726
case XML_ELEMENT_NODE:
8727
case XML_ATTRIBUTE_NODE:
8728
case XML_PI_NODE:
8729
if (cur->nodesetval->nodeTab[i]->name[0] == ' ')
8730
valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, ""));
8731
else
8732
valuePush(ctxt,
8733
xmlXPathCacheNewString(ctxt->context,
8734
cur->nodesetval->nodeTab[i]->name));
8735
break;
8736
case XML_NAMESPACE_DECL:
8737
valuePush(ctxt, xmlXPathCacheNewString(ctxt->context,
8738
((xmlNsPtr)cur->nodesetval->nodeTab[i])->prefix));
8739
break;
8740
default:
8741
valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, ""));
8742
}
8743
}
8744
xmlXPathReleaseObject(ctxt->context, cur);
8745
}
8746
8747
/**
8748
* xmlXPathNamespaceURIFunction:
8749
* @ctxt: the XPath Parser context
8750
* @nargs: the number of arguments
8751
*
8752
* Implement the namespace-uri() XPath function
8753
* string namespace-uri(node-set?)
8754
* The namespace-uri function returns a string containing the
8755
* namespace URI of the expanded name of the node in the argument
8756
* node-set that is first in document order. If the node-set is empty,
8757
* the first node has no name, or the expanded name has no namespace
8758
* URI, an empty string is returned. If the argument is omitted it
8759
* defaults to the context node.
8760
*/
8761
void
8762
xmlXPathNamespaceURIFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8763
xmlXPathObjectPtr cur;
8764
8765
if (ctxt == NULL) return;
8766
8767
if (nargs == 0) {
8768
valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context,
8769
ctxt->context->node));
8770
nargs = 1;
8771
}
8772
CHECK_ARITY(1);
8773
if ((ctxt->value == NULL) ||
8774
((ctxt->value->type != XPATH_NODESET) &&
8775
(ctxt->value->type != XPATH_XSLT_TREE)))
8776
XP_ERROR(XPATH_INVALID_TYPE);
8777
cur = valuePop(ctxt);
8778
8779
if ((cur->nodesetval == NULL) || (cur->nodesetval->nodeNr == 0)) {
8780
valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, ""));
8781
} else {
8782
int i = 0; /* Should be first in document order !!!!! */
8783
switch (cur->nodesetval->nodeTab[i]->type) {
8784
case XML_ELEMENT_NODE:
8785
case XML_ATTRIBUTE_NODE:
8786
if (cur->nodesetval->nodeTab[i]->ns == NULL)
8787
valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, ""));
8788
else
8789
valuePush(ctxt, xmlXPathCacheNewString(ctxt->context,
8790
cur->nodesetval->nodeTab[i]->ns->href));
8791
break;
8792
default:
8793
valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, ""));
8794
}
8795
}
8796
xmlXPathReleaseObject(ctxt->context, cur);
8797
}
8798
8799
/**
8800
* xmlXPathNameFunction:
8801
* @ctxt: the XPath Parser context
8802
* @nargs: the number of arguments
8803
*
8804
* Implement the name() XPath function
8805
* string name(node-set?)
8806
* The name function returns a string containing a QName representing
8807
* the name of the node in the argument node-set that is first in document
8808
* order. The QName must represent the name with respect to the namespace
8809
* declarations in effect on the node whose name is being represented.
8810
* Typically, this will be the form in which the name occurred in the XML
8811
* source. This need not be the case if there are namespace declarations
8812
* in effect on the node that associate multiple prefixes with the same
8813
* namespace. However, an implementation may include information about
8814
* the original prefix in its representation of nodes; in this case, an
8815
* implementation can ensure that the returned string is always the same
8816
* as the QName used in the XML source. If the argument it omitted it
8817
* defaults to the context node.
8818
* Libxml keep the original prefix so the "real qualified name" used is
8819
* returned.
8820
*/
8821
static void
8822
xmlXPathNameFunction(xmlXPathParserContextPtr ctxt, int nargs)
8823
{
8824
xmlXPathObjectPtr cur;
8825
8826
if (nargs == 0) {
8827
valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context,
8828
ctxt->context->node));
8829
nargs = 1;
8830
}
8831
8832
CHECK_ARITY(1);
8833
if ((ctxt->value == NULL) ||
8834
((ctxt->value->type != XPATH_NODESET) &&
8835
(ctxt->value->type != XPATH_XSLT_TREE)))
8836
XP_ERROR(XPATH_INVALID_TYPE);
8837
cur = valuePop(ctxt);
8838
8839
if ((cur->nodesetval == NULL) || (cur->nodesetval->nodeNr == 0)) {
8840
valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, ""));
8841
} else {
8842
int i = 0; /* Should be first in document order !!!!! */
8843
8844
switch (cur->nodesetval->nodeTab[i]->type) {
8845
case XML_ELEMENT_NODE:
8846
case XML_ATTRIBUTE_NODE:
8847
if (cur->nodesetval->nodeTab[i]->name[0] == ' ')
8848
valuePush(ctxt,
8849
xmlXPathCacheNewCString(ctxt->context, ""));
8850
else if ((cur->nodesetval->nodeTab[i]->ns == NULL) ||
8851
(cur->nodesetval->nodeTab[i]->ns->prefix == NULL)) {
8852
valuePush(ctxt,
8853
xmlXPathCacheNewString(ctxt->context,
8854
cur->nodesetval->nodeTab[i]->name));
8855
} else {
8856
xmlChar *fullname;
8857
8858
fullname = xmlBuildQName(cur->nodesetval->nodeTab[i]->name,
8859
cur->nodesetval->nodeTab[i]->ns->prefix,
8860
NULL, 0);
8861
if (fullname == cur->nodesetval->nodeTab[i]->name)
8862
fullname = xmlStrdup(cur->nodesetval->nodeTab[i]->name);
8863
if (fullname == NULL) {
8864
XP_ERROR(XPATH_MEMORY_ERROR);
8865
}
8866
valuePush(ctxt, xmlXPathCacheWrapString(
8867
ctxt->context, fullname));
8868
}
8869
break;
8870
default:
8871
valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context,
8872
cur->nodesetval->nodeTab[i]));
8873
xmlXPathLocalNameFunction(ctxt, 1);
8874
}
8875
}
8876
xmlXPathReleaseObject(ctxt->context, cur);
8877
}
8878
8879
8880
/**
8881
* xmlXPathStringFunction:
8882
* @ctxt: the XPath Parser context
8883
* @nargs: the number of arguments
8884
*
8885
* Implement the string() XPath function
8886
* string string(object?)
8887
* The string function converts an object to a string as follows:
8888
* - A node-set is converted to a string by returning the value of
8889
* the node in the node-set that is first in document order.
8890
* If the node-set is empty, an empty string is returned.
8891
* - A number is converted to a string as follows
8892
* + NaN is converted to the string NaN
8893
* + positive zero is converted to the string 0
8894
* + negative zero is converted to the string 0
8895
* + positive infinity is converted to the string Infinity
8896
* + negative infinity is converted to the string -Infinity
8897
* + if the number is an integer, the number is represented in
8898
* decimal form as a Number with no decimal point and no leading
8899
* zeros, preceded by a minus sign (-) if the number is negative
8900
* + otherwise, the number is represented in decimal form as a
8901
* Number including a decimal point with at least one digit
8902
* before the decimal point and at least one digit after the
8903
* decimal point, preceded by a minus sign (-) if the number
8904
* is negative; there must be no leading zeros before the decimal
8905
* point apart possibly from the one required digit immediately
8906
* before the decimal point; beyond the one required digit
8907
* after the decimal point there must be as many, but only as
8908
* many, more digits as are needed to uniquely distinguish the
8909
* number from all other IEEE 754 numeric values.
8910
* - The boolean false value is converted to the string false.
8911
* The boolean true value is converted to the string true.
8912
*
8913
* If the argument is omitted, it defaults to a node-set with the
8914
* context node as its only member.
8915
*/
8916
void
8917
xmlXPathStringFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8918
xmlXPathObjectPtr cur;
8919
8920
if (ctxt == NULL) return;
8921
if (nargs == 0) {
8922
valuePush(ctxt,
8923
xmlXPathCacheWrapString(ctxt->context,
8924
xmlXPathCastNodeToString(ctxt->context->node)));
8925
return;
8926
}
8927
8928
CHECK_ARITY(1);
8929
cur = valuePop(ctxt);
8930
if (cur == NULL) XP_ERROR(XPATH_INVALID_OPERAND);
8931
valuePush(ctxt, xmlXPathCacheConvertString(ctxt->context, cur));
8932
}
8933
8934
/**
8935
* xmlXPathStringLengthFunction:
8936
* @ctxt: the XPath Parser context
8937
* @nargs: the number of arguments
8938
*
8939
* Implement the string-length() XPath function
8940
* number string-length(string?)
8941
* The string-length returns the number of characters in the string
8942
* (see [3.6 Strings]). If the argument is omitted, it defaults to
8943
* the context node converted to a string, in other words the value
8944
* of the context node.
8945
*/
8946
void
8947
xmlXPathStringLengthFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8948
xmlXPathObjectPtr cur;
8949
8950
if (nargs == 0) {
8951
if ((ctxt == NULL) || (ctxt->context == NULL))
8952
return;
8953
if (ctxt->context->node == NULL) {
8954
valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, 0));
8955
} else {
8956
xmlChar *content;
8957
8958
content = xmlXPathCastNodeToString(ctxt->context->node);
8959
valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context,
8960
xmlUTF8Strlen(content)));
8961
xmlFree(content);
8962
}
8963
return;
8964
}
8965
CHECK_ARITY(1);
8966
CAST_TO_STRING;
8967
CHECK_TYPE(XPATH_STRING);
8968
cur = valuePop(ctxt);
8969
valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context,
8970
xmlUTF8Strlen(cur->stringval)));
8971
xmlXPathReleaseObject(ctxt->context, cur);
8972
}
8973
8974
/**
8975
* xmlXPathConcatFunction:
8976
* @ctxt: the XPath Parser context
8977
* @nargs: the number of arguments
8978
*
8979
* Implement the concat() XPath function
8980
* string concat(string, string, string*)
8981
* The concat function returns the concatenation of its arguments.
8982
*/
8983
void
8984
xmlXPathConcatFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8985
xmlXPathObjectPtr cur, newobj;
8986
xmlChar *tmp;
8987
8988
if (ctxt == NULL) return;
8989
if (nargs < 2) {
8990
CHECK_ARITY(2);
8991
}
8992
8993
CAST_TO_STRING;
8994
cur = valuePop(ctxt);
8995
if ((cur == NULL) || (cur->type != XPATH_STRING)) {
8996
xmlXPathReleaseObject(ctxt->context, cur);
8997
return;
8998
}
8999
nargs--;
9000
9001
while (nargs > 0) {
9002
CAST_TO_STRING;
9003
newobj = valuePop(ctxt);
9004
if ((newobj == NULL) || (newobj->type != XPATH_STRING)) {
9005
xmlXPathReleaseObject(ctxt->context, newobj);
9006
xmlXPathReleaseObject(ctxt->context, cur);
9007
XP_ERROR(XPATH_INVALID_TYPE);
9008
}
9009
tmp = xmlStrcat(newobj->stringval, cur->stringval);
9010
newobj->stringval = cur->stringval;
9011
cur->stringval = tmp;
9012
xmlXPathReleaseObject(ctxt->context, newobj);
9013
nargs--;
9014
}
9015
valuePush(ctxt, cur);
9016
}
9017
9018
/**
9019
* xmlXPathContainsFunction:
9020
* @ctxt: the XPath Parser context
9021
* @nargs: the number of arguments
9022
*
9023
* Implement the contains() XPath function
9024
* boolean contains(string, string)
9025
* The contains function returns true if the first argument string
9026
* contains the second argument string, and otherwise returns false.
9027
*/
9028
void
9029
xmlXPathContainsFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9030
xmlXPathObjectPtr hay, needle;
9031
9032
CHECK_ARITY(2);
9033
CAST_TO_STRING;
9034
CHECK_TYPE(XPATH_STRING);
9035
needle = valuePop(ctxt);
9036
CAST_TO_STRING;
9037
hay = valuePop(ctxt);
9038
9039
if ((hay == NULL) || (hay->type != XPATH_STRING)) {
9040
xmlXPathReleaseObject(ctxt->context, hay);
9041
xmlXPathReleaseObject(ctxt->context, needle);
9042
XP_ERROR(XPATH_INVALID_TYPE);
9043
}
9044
if (xmlStrstr(hay->stringval, needle->stringval))
9045
valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, 1));
9046
else
9047
valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, 0));
9048
xmlXPathReleaseObject(ctxt->context, hay);
9049
xmlXPathReleaseObject(ctxt->context, needle);
9050
}
9051
9052
/**
9053
* xmlXPathStartsWithFunction:
9054
* @ctxt: the XPath Parser context
9055
* @nargs: the number of arguments
9056
*
9057
* Implement the starts-with() XPath function
9058
* boolean starts-with(string, string)
9059
* The starts-with function returns true if the first argument string
9060
* starts with the second argument string, and otherwise returns false.
9061
*/
9062
void
9063
xmlXPathStartsWithFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9064
xmlXPathObjectPtr hay, needle;
9065
int n;
9066
9067
CHECK_ARITY(2);
9068
CAST_TO_STRING;
9069
CHECK_TYPE(XPATH_STRING);
9070
needle = valuePop(ctxt);
9071
CAST_TO_STRING;
9072
hay = valuePop(ctxt);
9073
9074
if ((hay == NULL) || (hay->type != XPATH_STRING)) {
9075
xmlXPathReleaseObject(ctxt->context, hay);
9076
xmlXPathReleaseObject(ctxt->context, needle);
9077
XP_ERROR(XPATH_INVALID_TYPE);
9078
}
9079
n = xmlStrlen(needle->stringval);
9080
if (xmlStrncmp(hay->stringval, needle->stringval, n))
9081
valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, 0));
9082
else
9083
valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, 1));
9084
xmlXPathReleaseObject(ctxt->context, hay);
9085
xmlXPathReleaseObject(ctxt->context, needle);
9086
}
9087
9088
/**
9089
* xmlXPathSubstringFunction:
9090
* @ctxt: the XPath Parser context
9091
* @nargs: the number of arguments
9092
*
9093
* Implement the substring() XPath function
9094
* string substring(string, number, number?)
9095
* The substring function returns the substring of the first argument
9096
* starting at the position specified in the second argument with
9097
* length specified in the third argument. For example,
9098
* substring("12345",2,3) returns "234". If the third argument is not
9099
* specified, it returns the substring starting at the position specified
9100
* in the second argument and continuing to the end of the string. For
9101
* example, substring("12345",2) returns "2345". More precisely, each
9102
* character in the string (see [3.6 Strings]) is considered to have a
9103
* numeric position: the position of the first character is 1, the position
9104
* of the second character is 2 and so on. The returned substring contains
9105
* those characters for which the position of the character is greater than
9106
* or equal to the second argument and, if the third argument is specified,
9107
* less than the sum of the second and third arguments; the comparisons
9108
* and addition used for the above follow the standard IEEE 754 rules. Thus:
9109
* - substring("12345", 1.5, 2.6) returns "234"
9110
* - substring("12345", 0, 3) returns "12"
9111
* - substring("12345", 0 div 0, 3) returns ""
9112
* - substring("12345", 1, 0 div 0) returns ""
9113
* - substring("12345", -42, 1 div 0) returns "12345"
9114
* - substring("12345", -1 div 0, 1 div 0) returns ""
9115
*/
9116
void
9117
xmlXPathSubstringFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9118
xmlXPathObjectPtr str, start, len;
9119
double le=0, in;
9120
int i, l, m;
9121
xmlChar *ret;
9122
9123
if (nargs < 2) {
9124
CHECK_ARITY(2);
9125
}
9126
if (nargs > 3) {
9127
CHECK_ARITY(3);
9128
}
9129
/*
9130
* take care of possible last (position) argument
9131
*/
9132
if (nargs == 3) {
9133
CAST_TO_NUMBER;
9134
CHECK_TYPE(XPATH_NUMBER);
9135
len = valuePop(ctxt);
9136
le = len->floatval;
9137
xmlXPathReleaseObject(ctxt->context, len);
9138
}
9139
9140
CAST_TO_NUMBER;
9141
CHECK_TYPE(XPATH_NUMBER);
9142
start = valuePop(ctxt);
9143
in = start->floatval;
9144
xmlXPathReleaseObject(ctxt->context, start);
9145
CAST_TO_STRING;
9146
CHECK_TYPE(XPATH_STRING);
9147
str = valuePop(ctxt);
9148
m = xmlUTF8Strlen((const unsigned char *)str->stringval);
9149
9150
/*
9151
* If last pos not present, calculate last position
9152
*/
9153
if (nargs != 3) {
9154
le = (double)m;
9155
if (in < 1.0)
9156
in = 1.0;
9157
}
9158
9159
/* Need to check for the special cases where either
9160
* the index is NaN, the length is NaN, or both
9161
* arguments are infinity (relying on Inf + -Inf = NaN)
9162
*/
9163
if (!xmlXPathIsInf(in) && !xmlXPathIsNaN(in + le)) {
9164
/*
9165
* To meet the requirements of the spec, the arguments
9166
* must be converted to integer format before
9167
* initial index calculations are done
9168
*
9169
* First we go to integer form, rounding up
9170
* and checking for special cases
9171
*/
9172
i = (int) in;
9173
if (((double)i)+0.5 <= in) i++;
9174
9175
if (xmlXPathIsInf(le) == 1) {
9176
l = m;
9177
if (i < 1)
9178
i = 1;
9179
}
9180
else if (xmlXPathIsInf(le) == -1 || le < 0.0)
9181
l = 0;
9182
else {
9183
l = (int) le;
9184
if (((double)l)+0.5 <= le) l++;
9185
}
9186
9187
/* Now we normalize inidices */
9188
i -= 1;
9189
l += i;
9190
if (i < 0)
9191
i = 0;
9192
if (l > m)
9193
l = m;
9194
9195
/* number of chars to copy */
9196
l -= i;
9197
9198
ret = xmlUTF8Strsub(str->stringval, i, l);
9199
}
9200
else {
9201
ret = NULL;
9202
}
9203
if (ret == NULL)
9204
valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, ""));
9205
else {
9206
valuePush(ctxt, xmlXPathCacheNewString(ctxt->context, ret));
9207
xmlFree(ret);
9208
}
9209
xmlXPathReleaseObject(ctxt->context, str);
9210
}
9211
9212
/**
9213
* xmlXPathSubstringBeforeFunction:
9214
* @ctxt: the XPath Parser context
9215
* @nargs: the number of arguments
9216
*
9217
* Implement the substring-before() XPath function
9218
* string substring-before(string, string)
9219
* The substring-before function returns the substring of the first
9220
* argument string that precedes the first occurrence of the second
9221
* argument string in the first argument string, or the empty string
9222
* if the first argument string does not contain the second argument
9223
* string. For example, substring-before("1999/04/01","/") returns 1999.
9224
*/
9225
void
9226
xmlXPathSubstringBeforeFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9227
xmlXPathObjectPtr str;
9228
xmlXPathObjectPtr find;
9229
xmlBufPtr target;
9230
const xmlChar *point;
9231
int offset;
9232
9233
CHECK_ARITY(2);
9234
CAST_TO_STRING;
9235
find = valuePop(ctxt);
9236
CAST_TO_STRING;
9237
str = valuePop(ctxt);
9238
9239
target = xmlBufCreate();
9240
if (target) {
9241
point = xmlStrstr(str->stringval, find->stringval);
9242
if (point) {
9243
offset = (int)(point - str->stringval);
9244
xmlBufAdd(target, str->stringval, offset);
9245
}
9246
valuePush(ctxt, xmlXPathCacheNewString(ctxt->context,
9247
xmlBufContent(target)));
9248
xmlBufFree(target);
9249
}
9250
xmlXPathReleaseObject(ctxt->context, str);
9251
xmlXPathReleaseObject(ctxt->context, find);
9252
}
9253
9254
/**
9255
* xmlXPathSubstringAfterFunction:
9256
* @ctxt: the XPath Parser context
9257
* @nargs: the number of arguments
9258
*
9259
* Implement the substring-after() XPath function
9260
* string substring-after(string, string)
9261
* The substring-after function returns the substring of the first
9262
* argument string that follows the first occurrence of the second
9263
* argument string in the first argument string, or the empty stringi
9264
* if the first argument string does not contain the second argument
9265
* string. For example, substring-after("1999/04/01","/") returns 04/01,
9266
* and substring-after("1999/04/01","19") returns 99/04/01.
9267
*/
9268
void
9269
xmlXPathSubstringAfterFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9270
xmlXPathObjectPtr str;
9271
xmlXPathObjectPtr find;
9272
xmlBufPtr target;
9273
const xmlChar *point;
9274
int offset;
9275
9276
CHECK_ARITY(2);
9277
CAST_TO_STRING;
9278
find = valuePop(ctxt);
9279
CAST_TO_STRING;
9280
str = valuePop(ctxt);
9281
9282
target = xmlBufCreate();
9283
if (target) {
9284
point = xmlStrstr(str->stringval, find->stringval);
9285
if (point) {
9286
offset = (int)(point - str->stringval) + xmlStrlen(find->stringval);
9287
xmlBufAdd(target, &str->stringval[offset],
9288
xmlStrlen(str->stringval) - offset);
9289
}
9290
valuePush(ctxt, xmlXPathCacheNewString(ctxt->context,
9291
xmlBufContent(target)));
9292
xmlBufFree(target);
9293
}
9294
xmlXPathReleaseObject(ctxt->context, str);
9295
xmlXPathReleaseObject(ctxt->context, find);
9296
}
9297
9298
/**
9299
* xmlXPathNormalizeFunction:
9300
* @ctxt: the XPath Parser context
9301
* @nargs: the number of arguments
9302
*
9303
* Implement the normalize-space() XPath function
9304
* string normalize-space(string?)
9305
* The normalize-space function returns the argument string with white
9306
* space normalized by stripping leading and trailing whitespace
9307
* and replacing sequences of whitespace characters by a single
9308
* space. Whitespace characters are the same allowed by the S production
9309
* in XML. If the argument is omitted, it defaults to the context
9310
* node converted to a string, in other words the value of the context node.
9311
*/
9312
void
9313
xmlXPathNormalizeFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9314
xmlXPathObjectPtr obj = NULL;
9315
xmlChar *source = NULL;
9316
xmlBufPtr target;
9317
xmlChar blank;
9318
9319
if (ctxt == NULL) return;
9320
if (nargs == 0) {
9321
/* Use current context node */
9322
valuePush(ctxt,
9323
xmlXPathCacheWrapString(ctxt->context,
9324
xmlXPathCastNodeToString(ctxt->context->node)));
9325
nargs = 1;
9326
}
9327
9328
CHECK_ARITY(1);
9329
CAST_TO_STRING;
9330
CHECK_TYPE(XPATH_STRING);
9331
obj = valuePop(ctxt);
9332
source = obj->stringval;
9333
9334
target = xmlBufCreate();
9335
if (target && source) {
9336
9337
/* Skip leading whitespaces */
9338
while (IS_BLANK_CH(*source))
9339
source++;
9340
9341
/* Collapse intermediate whitespaces, and skip trailing whitespaces */
9342
blank = 0;
9343
while (*source) {
9344
if (IS_BLANK_CH(*source)) {
9345
blank = 0x20;
9346
} else {
9347
if (blank) {
9348
xmlBufAdd(target, &blank, 1);
9349
blank = 0;
9350
}
9351
xmlBufAdd(target, source, 1);
9352
}
9353
source++;
9354
}
9355
valuePush(ctxt, xmlXPathCacheNewString(ctxt->context,
9356
xmlBufContent(target)));
9357
xmlBufFree(target);
9358
}
9359
xmlXPathReleaseObject(ctxt->context, obj);
9360
}
9361
9362
/**
9363
* xmlXPathTranslateFunction:
9364
* @ctxt: the XPath Parser context
9365
* @nargs: the number of arguments
9366
*
9367
* Implement the translate() XPath function
9368
* string translate(string, string, string)
9369
* The translate function returns the first argument string with
9370
* occurrences of characters in the second argument string replaced
9371
* by the character at the corresponding position in the third argument
9372
* string. For example, translate("bar","abc","ABC") returns the string
9373
* BAr. If there is a character in the second argument string with no
9374
* character at a corresponding position in the third argument string
9375
* (because the second argument string is longer than the third argument
9376
* string), then occurrences of that character in the first argument
9377
* string are removed. For example, translate("--aaa--","abc-","ABC")
9378
* returns "AAA". If a character occurs more than once in second
9379
* argument string, then the first occurrence determines the replacement
9380
* character. If the third argument string is longer than the second
9381
* argument string, then excess characters are ignored.
9382
*/
9383
void
9384
xmlXPathTranslateFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9385
xmlXPathObjectPtr str;
9386
xmlXPathObjectPtr from;
9387
xmlXPathObjectPtr to;
9388
xmlBufPtr target;
9389
int offset, max;
9390
xmlChar ch;
9391
const xmlChar *point;
9392
xmlChar *cptr;
9393
9394
CHECK_ARITY(3);
9395
9396
CAST_TO_STRING;
9397
to = valuePop(ctxt);
9398
CAST_TO_STRING;
9399
from = valuePop(ctxt);
9400
CAST_TO_STRING;
9401
str = valuePop(ctxt);
9402
9403
target = xmlBufCreate();
9404
if (target) {
9405
max = xmlUTF8Strlen(to->stringval);
9406
for (cptr = str->stringval; (ch=*cptr); ) {
9407
offset = xmlUTF8Strloc(from->stringval, cptr);
9408
if (offset >= 0) {
9409
if (offset < max) {
9410
point = xmlUTF8Strpos(to->stringval, offset);
9411
if (point)
9412
xmlBufAdd(target, point, xmlUTF8Strsize(point, 1));
9413
}
9414
} else
9415
xmlBufAdd(target, cptr, xmlUTF8Strsize(cptr, 1));
9416
9417
/* Step to next character in input */
9418
cptr++;
9419
if ( ch & 0x80 ) {
9420
/* if not simple ascii, verify proper format */
9421
if ( (ch & 0xc0) != 0xc0 ) {
9422
xmlGenericError(xmlGenericErrorContext,
9423
"xmlXPathTranslateFunction: Invalid UTF8 string\n");
9424
/* not asserting an XPath error is probably better */
9425
break;
9426
}
9427
/* then skip over remaining bytes for this char */
9428
while ( (ch <<= 1) & 0x80 )
9429
if ( (*cptr++ & 0xc0) != 0x80 ) {
9430
xmlGenericError(xmlGenericErrorContext,
9431
"xmlXPathTranslateFunction: Invalid UTF8 string\n");
9432
/* not asserting an XPath error is probably better */
9433
break;
9434
}
9435
if (ch & 0x80) /* must have had error encountered */
9436
break;
9437
}
9438
}
9439
}
9440
valuePush(ctxt, xmlXPathCacheNewString(ctxt->context,
9441
xmlBufContent(target)));
9442
xmlBufFree(target);
9443
xmlXPathReleaseObject(ctxt->context, str);
9444
xmlXPathReleaseObject(ctxt->context, from);
9445
xmlXPathReleaseObject(ctxt->context, to);
9446
}
9447
9448
/**
9449
* xmlXPathBooleanFunction:
9450
* @ctxt: the XPath Parser context
9451
* @nargs: the number of arguments
9452
*
9453
* Implement the boolean() XPath function
9454
* boolean boolean(object)
9455
* The boolean function converts its argument to a boolean as follows:
9456
* - a number is true if and only if it is neither positive or
9457
* negative zero nor NaN
9458
* - a node-set is true if and only if it is non-empty
9459
* - a string is true if and only if its length is non-zero
9460
*/
9461
void
9462
xmlXPathBooleanFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9463
xmlXPathObjectPtr cur;
9464
9465
CHECK_ARITY(1);
9466
cur = valuePop(ctxt);
9467
if (cur == NULL) XP_ERROR(XPATH_INVALID_OPERAND);
9468
cur = xmlXPathCacheConvertBoolean(ctxt->context, cur);
9469
valuePush(ctxt, cur);
9470
}
9471
9472
/**
9473
* xmlXPathNotFunction:
9474
* @ctxt: the XPath Parser context
9475
* @nargs: the number of arguments
9476
*
9477
* Implement the not() XPath function
9478
* boolean not(boolean)
9479
* The not function returns true if its argument is false,
9480
* and false otherwise.
9481
*/
9482
void
9483
xmlXPathNotFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9484
CHECK_ARITY(1);
9485
CAST_TO_BOOLEAN;
9486
CHECK_TYPE(XPATH_BOOLEAN);
9487
ctxt->value->boolval = ! ctxt->value->boolval;
9488
}
9489
9490
/**
9491
* xmlXPathTrueFunction:
9492
* @ctxt: the XPath Parser context
9493
* @nargs: the number of arguments
9494
*
9495
* Implement the true() XPath function
9496
* boolean true()
9497
*/
9498
void
9499
xmlXPathTrueFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9500
CHECK_ARITY(0);
9501
valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, 1));
9502
}
9503
9504
/**
9505
* xmlXPathFalseFunction:
9506
* @ctxt: the XPath Parser context
9507
* @nargs: the number of arguments
9508
*
9509
* Implement the false() XPath function
9510
* boolean false()
9511
*/
9512
void
9513
xmlXPathFalseFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9514
CHECK_ARITY(0);
9515
valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, 0));
9516
}
9517
9518
/**
9519
* xmlXPathLangFunction:
9520
* @ctxt: the XPath Parser context
9521
* @nargs: the number of arguments
9522
*
9523
* Implement the lang() XPath function
9524
* boolean lang(string)
9525
* The lang function returns true or false depending on whether the
9526
* language of the context node as specified by xml:lang attributes
9527
* is the same as or is a sublanguage of the language specified by
9528
* the argument string. The language of the context node is determined
9529
* by the value of the xml:lang attribute on the context node, or, if
9530
* the context node has no xml:lang attribute, by the value of the
9531
* xml:lang attribute on the nearest ancestor of the context node that
9532
* has an xml:lang attribute. If there is no such attribute, then lang
9533
* returns false. If there is such an attribute, then lang returns
9534
* true if the attribute value is equal to the argument ignoring case,
9535
* or if there is some suffix starting with - such that the attribute
9536
* value is equal to the argument ignoring that suffix of the attribute
9537
* value and ignoring case.
9538
*/
9539
void
9540
xmlXPathLangFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9541
xmlXPathObjectPtr val = NULL;
9542
const xmlChar *theLang = NULL;
9543
const xmlChar *lang;
9544
int ret = 0;
9545
int i;
9546
9547
CHECK_ARITY(1);
9548
CAST_TO_STRING;
9549
CHECK_TYPE(XPATH_STRING);
9550
val = valuePop(ctxt);
9551
lang = val->stringval;
9552
theLang = xmlNodeGetLang(ctxt->context->node);
9553
if ((theLang != NULL) && (lang != NULL)) {
9554
for (i = 0;lang[i] != 0;i++)
9555
if (toupper(lang[i]) != toupper(theLang[i]))
9556
goto not_equal;
9557
if ((theLang[i] == 0) || (theLang[i] == '-'))
9558
ret = 1;
9559
}
9560
not_equal:
9561
if (theLang != NULL)
9562
xmlFree((void *)theLang);
9563
9564
xmlXPathReleaseObject(ctxt->context, val);
9565
valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, ret));
9566
}
9567
9568
/**
9569
* xmlXPathNumberFunction:
9570
* @ctxt: the XPath Parser context
9571
* @nargs: the number of arguments
9572
*
9573
* Implement the number() XPath function
9574
* number number(object?)
9575
*/
9576
void
9577
xmlXPathNumberFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9578
xmlXPathObjectPtr cur;
9579
double res;
9580
9581
if (ctxt == NULL) return;
9582
if (nargs == 0) {
9583
if (ctxt->context->node == NULL) {
9584
valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, 0.0));
9585
} else {
9586
xmlChar* content = xmlNodeGetContent(ctxt->context->node);
9587
9588
res = xmlXPathStringEvalNumber(content);
9589
valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, res));
9590
xmlFree(content);
9591
}
9592
return;
9593
}
9594
9595
CHECK_ARITY(1);
9596
cur = valuePop(ctxt);
9597
valuePush(ctxt, xmlXPathCacheConvertNumber(ctxt->context, cur));
9598
}
9599
9600
/**
9601
* xmlXPathSumFunction:
9602
* @ctxt: the XPath Parser context
9603
* @nargs: the number of arguments
9604
*
9605
* Implement the sum() XPath function
9606
* number sum(node-set)
9607
* The sum function returns the sum of the values of the nodes in
9608
* the argument node-set.
9609
*/
9610
void
9611
xmlXPathSumFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9612
xmlXPathObjectPtr cur;
9613
int i;
9614
double res = 0.0;
9615
9616
CHECK_ARITY(1);
9617
if ((ctxt->value == NULL) ||
9618
((ctxt->value->type != XPATH_NODESET) &&
9619
(ctxt->value->type != XPATH_XSLT_TREE)))
9620
XP_ERROR(XPATH_INVALID_TYPE);
9621
cur = valuePop(ctxt);
9622
9623
if ((cur->nodesetval != NULL) && (cur->nodesetval->nodeNr != 0)) {
9624
for (i = 0; i < cur->nodesetval->nodeNr; i++) {
9625
res += xmlXPathCastNodeToNumber(cur->nodesetval->nodeTab[i]);
9626
}
9627
}
9628
valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, res));
9629
xmlXPathReleaseObject(ctxt->context, cur);
9630
}
9631
9632
/*
9633
* To assure working code on multiple platforms, we want to only depend
9634
* upon the characteristic truncation of converting a floating point value
9635
* to an integer. Unfortunately, because of the different storage sizes
9636
* of our internal floating point value (double) and integer (int), we
9637
* can't directly convert (see bug 301162). This macro is a messy
9638
* 'workaround'
9639
*/
9640
#define XTRUNC(f, v) \
9641
f = fmod((v), INT_MAX); \
9642
f = (v) - (f) + (double)((int)(f));
9643
9644
/**
9645
* xmlXPathFloorFunction:
9646
* @ctxt: the XPath Parser context
9647
* @nargs: the number of arguments
9648
*
9649
* Implement the floor() XPath function
9650
* number floor(number)
9651
* The floor function returns the largest (closest to positive infinity)
9652
* number that is not greater than the argument and that is an integer.
9653
*/
9654
void
9655
xmlXPathFloorFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9656
double f;
9657
9658
CHECK_ARITY(1);
9659
CAST_TO_NUMBER;
9660
CHECK_TYPE(XPATH_NUMBER);
9661
9662
XTRUNC(f, ctxt->value->floatval);
9663
if (f != ctxt->value->floatval) {
9664
if (ctxt->value->floatval > 0)
9665
ctxt->value->floatval = f;
9666
else
9667
ctxt->value->floatval = f - 1;
9668
}
9669
}
9670
9671
/**
9672
* xmlXPathCeilingFunction:
9673
* @ctxt: the XPath Parser context
9674
* @nargs: the number of arguments
9675
*
9676
* Implement the ceiling() XPath function
9677
* number ceiling(number)
9678
* The ceiling function returns the smallest (closest to negative infinity)
9679
* number that is not less than the argument and that is an integer.
9680
*/
9681
void
9682
xmlXPathCeilingFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9683
double f;
9684
9685
CHECK_ARITY(1);
9686
CAST_TO_NUMBER;
9687
CHECK_TYPE(XPATH_NUMBER);
9688
9689
#if 0
9690
ctxt->value->floatval = ceil(ctxt->value->floatval);
9691
#else
9692
XTRUNC(f, ctxt->value->floatval);
9693
if (f != ctxt->value->floatval) {
9694
if (ctxt->value->floatval > 0)
9695
ctxt->value->floatval = f + 1;
9696
else {
9697
if (ctxt->value->floatval < 0 && f == 0)
9698
ctxt->value->floatval = xmlXPathNZERO;
9699
else
9700
ctxt->value->floatval = f;
9701
}
9702
9703
}
9704
#endif
9705
}
9706
9707
/**
9708
* xmlXPathRoundFunction:
9709
* @ctxt: the XPath Parser context
9710
* @nargs: the number of arguments
9711
*
9712
* Implement the round() XPath function
9713
* number round(number)
9714
* The round function returns the number that is closest to the
9715
* argument and that is an integer. If there are two such numbers,
9716
* then the one that is even is returned.
9717
*/
9718
void
9719
xmlXPathRoundFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9720
double f;
9721
9722
CHECK_ARITY(1);
9723
CAST_TO_NUMBER;
9724
CHECK_TYPE(XPATH_NUMBER);
9725
9726
if ((xmlXPathIsNaN(ctxt->value->floatval)) ||
9727
(xmlXPathIsInf(ctxt->value->floatval) == 1) ||
9728
(xmlXPathIsInf(ctxt->value->floatval) == -1) ||
9729
(ctxt->value->floatval == 0.0))
9730
return;
9731
9732
XTRUNC(f, ctxt->value->floatval);
9733
if (ctxt->value->floatval < 0) {
9734
if (ctxt->value->floatval < f - 0.5)
9735
ctxt->value->floatval = f - 1;
9736
else
9737
ctxt->value->floatval = f;
9738
if (ctxt->value->floatval == 0)
9739
ctxt->value->floatval = xmlXPathNZERO;
9740
} else {
9741
if (ctxt->value->floatval < f + 0.5)
9742
ctxt->value->floatval = f;
9743
else
9744
ctxt->value->floatval = f + 1;
9745
}
9746
}
9747
9748
/************************************************************************
9749
* *
9750
* The Parser *
9751
* *
9752
************************************************************************/
9753
9754
/*
9755
* a few forward declarations since we use a recursive call based
9756
* implementation.
9757
*/
9758
static void xmlXPathCompileExpr(xmlXPathParserContextPtr ctxt, int sort);
9759
static void xmlXPathCompPredicate(xmlXPathParserContextPtr ctxt, int filter);
9760
static void xmlXPathCompLocationPath(xmlXPathParserContextPtr ctxt);
9761
static void xmlXPathCompRelativeLocationPath(xmlXPathParserContextPtr ctxt);
9762
static xmlChar * xmlXPathParseNameComplex(xmlXPathParserContextPtr ctxt,
9763
int qualified);
9764
9765
/**
9766
* xmlXPathCurrentChar:
9767
* @ctxt: the XPath parser context
9768
* @cur: pointer to the beginning of the char
9769
* @len: pointer to the length of the char read
9770
*
9771
* The current char value, if using UTF-8 this may actually span multiple
9772
* bytes in the input buffer.
9773
*
9774
* Returns the current char value and its length
9775
*/
9776
9777
static int
9778
xmlXPathCurrentChar(xmlXPathParserContextPtr ctxt, int *len) {
9779
unsigned char c;
9780
unsigned int val;
9781
const xmlChar *cur;
9782
9783
if (ctxt == NULL)
9784
return(0);
9785
cur = ctxt->cur;
9786
9787
/*
9788
* We are supposed to handle UTF8, check it's valid
9789
* From rfc2044: encoding of the Unicode values on UTF-8:
9790
*
9791
* UCS-4 range (hex.) UTF-8 octet sequence (binary)
9792
* 0000 0000-0000 007F 0xxxxxxx
9793
* 0000 0080-0000 07FF 110xxxxx 10xxxxxx
9794
* 0000 0800-0000 FFFF 1110xxxx 10xxxxxx 10xxxxxx
9795
*
9796
* Check for the 0x110000 limit too
9797
*/
9798
c = *cur;
9799
if (c & 0x80) {
9800
if ((cur[1] & 0xc0) != 0x80)
9801
goto encoding_error;
9802
if ((c & 0xe0) == 0xe0) {
9803
9804
if ((cur[2] & 0xc0) != 0x80)
9805
goto encoding_error;
9806
if ((c & 0xf0) == 0xf0) {
9807
if (((c & 0xf8) != 0xf0) ||
9808
((cur[3] & 0xc0) != 0x80))
9809
goto encoding_error;
9810
/* 4-byte code */
9811
*len = 4;
9812
val = (cur[0] & 0x7) << 18;
9813
val |= (cur[1] & 0x3f) << 12;
9814
val |= (cur[2] & 0x3f) << 6;
9815
val |= cur[3] & 0x3f;
9816
} else {
9817
/* 3-byte code */
9818
*len = 3;
9819
val = (cur[0] & 0xf) << 12;
9820
val |= (cur[1] & 0x3f) << 6;
9821
val |= cur[2] & 0x3f;
9822
}
9823
} else {
9824
/* 2-byte code */
9825
*len = 2;
9826
val = (cur[0] & 0x1f) << 6;
9827
val |= cur[1] & 0x3f;
9828
}
9829
if (!IS_CHAR(val)) {
9830
XP_ERROR0(XPATH_INVALID_CHAR_ERROR);
9831
}
9832
return(val);
9833
} else {
9834
/* 1-byte code */
9835
*len = 1;
9836
return((int) *cur);
9837
}
9838
encoding_error:
9839
/*
9840
* If we detect an UTF8 error that probably means that the
9841
* input encoding didn't get properly advertised in the
9842
* declaration header. Report the error and switch the encoding
9843
* to ISO-Latin-1 (if you don't like this policy, just declare the
9844
* encoding !)
9845
*/
9846
*len = 0;
9847
XP_ERROR0(XPATH_ENCODING_ERROR);
9848
}
9849
9850
/**
9851
* xmlXPathParseNCName:
9852
* @ctxt: the XPath Parser context
9853
*
9854
* parse an XML namespace non qualified name.
9855
*
9856
* [NS 3] NCName ::= (Letter | '_') (NCNameChar)*
9857
*
9858
* [NS 4] NCNameChar ::= Letter | Digit | '.' | '-' | '_' |
9859
* CombiningChar | Extender
9860
*
9861
* Returns the namespace name or NULL
9862
*/
9863
9864
xmlChar *
9865
xmlXPathParseNCName(xmlXPathParserContextPtr ctxt) {
9866
const xmlChar *in;
9867
xmlChar *ret;
9868
int count = 0;
9869
9870
if ((ctxt == NULL) || (ctxt->cur == NULL)) return(NULL);
9871
/*
9872
* Accelerator for simple ASCII names
9873
*/
9874
in = ctxt->cur;
9875
if (((*in >= 0x61) && (*in <= 0x7A)) ||
9876
((*in >= 0x41) && (*in <= 0x5A)) ||
9877
(*in == '_')) {
9878
in++;
9879
while (((*in >= 0x61) && (*in <= 0x7A)) ||
9880
((*in >= 0x41) && (*in <= 0x5A)) ||
9881
((*in >= 0x30) && (*in <= 0x39)) ||
9882
(*in == '_') || (*in == '.') ||
9883
(*in == '-'))
9884
in++;
9885
if ((*in == ' ') || (*in == '>') || (*in == '/') ||
9886
(*in == '[') || (*in == ']') || (*in == ':') ||
9887
(*in == '@') || (*in == '*')) {
9888
count = in - ctxt->cur;
9889
if (count == 0)
9890
return(NULL);
9891
ret = xmlStrndup(ctxt->cur, count);
9892
ctxt->cur = in;
9893
return(ret);
9894
}
9895
}
9896
return(xmlXPathParseNameComplex(ctxt, 0));
9897
}
9898
9899
9900
/**
9901
* xmlXPathParseQName:
9902
* @ctxt: the XPath Parser context
9903
* @prefix: a xmlChar **
9904
*
9905
* parse an XML qualified name
9906
*
9907
* [NS 5] QName ::= (Prefix ':')? LocalPart
9908
*
9909
* [NS 6] Prefix ::= NCName
9910
*
9911
* [NS 7] LocalPart ::= NCName
9912
*
9913
* Returns the function returns the local part, and prefix is updated
9914
* to get the Prefix if any.
9915
*/
9916
9917
static xmlChar *
9918
xmlXPathParseQName(xmlXPathParserContextPtr ctxt, xmlChar **prefix) {
9919
xmlChar *ret = NULL;
9920
9921
*prefix = NULL;
9922
ret = xmlXPathParseNCName(ctxt);
9923
if (ret && CUR == ':') {
9924
*prefix = ret;
9925
NEXT;
9926
ret = xmlXPathParseNCName(ctxt);
9927
}
9928
return(ret);
9929
}
9930
9931
/**
9932
* xmlXPathParseName:
9933
* @ctxt: the XPath Parser context
9934
*
9935
* parse an XML name
9936
*
9937
* [4] NameChar ::= Letter | Digit | '.' | '-' | '_' | ':' |
9938
* CombiningChar | Extender
9939
*
9940
* [5] Name ::= (Letter | '_' | ':') (NameChar)*
9941
*
9942
* Returns the namespace name or NULL
9943
*/
9944
9945
xmlChar *
9946
xmlXPathParseName(xmlXPathParserContextPtr ctxt) {
9947
const xmlChar *in;
9948
xmlChar *ret;
9949
size_t count = 0;
9950
9951
if ((ctxt == NULL) || (ctxt->cur == NULL)) return(NULL);
9952
/*
9953
* Accelerator for simple ASCII names
9954
*/
9955
in = ctxt->cur;
9956
if (((*in >= 0x61) && (*in <= 0x7A)) ||
9957
((*in >= 0x41) && (*in <= 0x5A)) ||
9958
(*in == '_') || (*in == ':')) {
9959
in++;
9960
while (((*in >= 0x61) && (*in <= 0x7A)) ||
9961
((*in >= 0x41) && (*in <= 0x5A)) ||
9962
((*in >= 0x30) && (*in <= 0x39)) ||
9963
(*in == '_') || (*in == '-') ||
9964
(*in == ':') || (*in == '.'))
9965
in++;
9966
if ((*in > 0) && (*in < 0x80)) {
9967
count = in - ctxt->cur;
9968
if (count > XML_MAX_NAME_LENGTH) {
9969
ctxt->cur = in;
9970
XP_ERRORNULL(XPATH_EXPR_ERROR);
9971
}
9972
ret = xmlStrndup(ctxt->cur, count);
9973
ctxt->cur = in;
9974
return(ret);
9975
}
9976
}
9977
return(xmlXPathParseNameComplex(ctxt, 1));
9978
}
9979
9980
static xmlChar *
9981
xmlXPathParseNameComplex(xmlXPathParserContextPtr ctxt, int qualified) {
9982
xmlChar buf[XML_MAX_NAMELEN + 5];
9983
int len = 0, l;
9984
int c;
9985
9986
/*
9987
* Handler for more complex cases
9988
*/
9989
c = CUR_CHAR(l);
9990
if ((c == ' ') || (c == '>') || (c == '/') || /* accelerators */
9991
(c == '[') || (c == ']') || (c == '@') || /* accelerators */
9992
(c == '*') || /* accelerators */
9993
(!IS_LETTER(c) && (c != '_') &&
9994
((qualified) && (c != ':')))) {
9995
return(NULL);
9996
}
9997
9998
while ((c != ' ') && (c != '>') && (c != '/') && /* test bigname.xml */
9999
((IS_LETTER(c)) || (IS_DIGIT(c)) ||
10000
(c == '.') || (c == '-') ||
10001
(c == '_') || ((qualified) && (c == ':')) ||
10002
(IS_COMBINING(c)) ||
10003
(IS_EXTENDER(c)))) {
10004
COPY_BUF(l,buf,len,c);
10005
NEXTL(l);
10006
c = CUR_CHAR(l);
10007
if (len >= XML_MAX_NAMELEN) {
10008
/*
10009
* Okay someone managed to make a huge name, so he's ready to pay
10010
* for the processing speed.
10011
*/
10012
xmlChar *buffer;
10013
int max = len * 2;
10014
10015
if (len > XML_MAX_NAME_LENGTH) {
10016
XP_ERRORNULL(XPATH_EXPR_ERROR);
10017
}
10018
buffer = (xmlChar *) xmlMallocAtomic(max * sizeof(xmlChar));
10019
if (buffer == NULL) {
10020
XP_ERRORNULL(XPATH_MEMORY_ERROR);
10021
}
10022
memcpy(buffer, buf, len);
10023
while ((IS_LETTER(c)) || (IS_DIGIT(c)) || /* test bigname.xml */
10024
(c == '.') || (c == '-') ||
10025
(c == '_') || ((qualified) && (c == ':')) ||
10026
(IS_COMBINING(c)) ||
10027
(IS_EXTENDER(c))) {
10028
if (len + 10 > max) {
10029
if (max > XML_MAX_NAME_LENGTH) {
10030
XP_ERRORNULL(XPATH_EXPR_ERROR);
10031
}
10032
max *= 2;
10033
buffer = (xmlChar *) xmlRealloc(buffer,
10034
max * sizeof(xmlChar));
10035
if (buffer == NULL) {
10036
XP_ERRORNULL(XPATH_MEMORY_ERROR);
10037
}
10038
}
10039
COPY_BUF(l,buffer,len,c);
10040
NEXTL(l);
10041
c = CUR_CHAR(l);
10042
}
10043
buffer[len] = 0;
10044
return(buffer);
10045
}
10046
}
10047
if (len == 0)
10048
return(NULL);
10049
return(xmlStrndup(buf, len));
10050
}
10051
10052
#define MAX_FRAC 20
10053
10054
/*
10055
* These are used as divisors for the fractional part of a number.
10056
* Since the table includes 1.0 (representing '0' fractional digits),
10057
* it must be dimensioned at MAX_FRAC+1 (bug 133921)
10058
*/
10059
static double my_pow10[MAX_FRAC+1] = {
10060
1.0, 10.0, 100.0, 1000.0, 10000.0,
10061
100000.0, 1000000.0, 10000000.0, 100000000.0, 1000000000.0,
10062
10000000000.0, 100000000000.0, 1000000000000.0, 10000000000000.0,
10063
100000000000000.0,
10064
1000000000000000.0, 10000000000000000.0, 100000000000000000.0,
10065
1000000000000000000.0, 10000000000000000000.0, 100000000000000000000.0
10066
};
10067
10068
/**
10069
* xmlXPathStringEvalNumber:
10070
* @str: A string to scan
10071
*
10072
* [30a] Float ::= Number ('e' Digits?)?
10073
*
10074
* [30] Number ::= Digits ('.' Digits?)?
10075
* | '.' Digits
10076
* [31] Digits ::= [0-9]+
10077
*
10078
* Compile a Number in the string
10079
* In complement of the Number expression, this function also handles
10080
* negative values : '-' Number.
10081
*
10082
* Returns the double value.
10083
*/
10084
double
10085
xmlXPathStringEvalNumber(const xmlChar *str) {
10086
const xmlChar *cur = str;
10087
double ret;
10088
int ok = 0;
10089
int isneg = 0;
10090
int exponent = 0;
10091
int is_exponent_negative = 0;
10092
#ifdef __GNUC__
10093
unsigned long tmp = 0;
10094
double temp;
10095
#endif
10096
if (cur == NULL) return(0);
10097
while (IS_BLANK_CH(*cur)) cur++;
10098
if ((*cur != '.') && ((*cur < '0') || (*cur > '9')) && (*cur != '-')) {
10099
return(xmlXPathNAN);
10100
}
10101
if (*cur == '-') {
10102
isneg = 1;
10103
cur++;
10104
}
10105
10106
#ifdef __GNUC__
10107
/*
10108
* tmp/temp is a workaround against a gcc compiler bug
10109
* http://veillard.com/gcc.bug
10110
*/
10111
ret = 0;
10112
while ((*cur >= '0') && (*cur <= '9')) {
10113
ret = ret * 10;
10114
tmp = (*cur - '0');
10115
ok = 1;
10116
cur++;
10117
temp = (double) tmp;
10118
ret = ret + temp;
10119
}
10120
#else
10121
ret = 0;
10122
while ((*cur >= '0') && (*cur <= '9')) {
10123
ret = ret * 10 + (*cur - '0');
10124
ok = 1;
10125
cur++;
10126
}
10127
#endif
10128
10129
if (*cur == '.') {
10130
int v, frac = 0;
10131
double fraction = 0;
10132
10133
cur++;
10134
if (((*cur < '0') || (*cur > '9')) && (!ok)) {
10135
return(xmlXPathNAN);
10136
}
10137
while (((*cur >= '0') && (*cur <= '9')) && (frac < MAX_FRAC)) {
10138
v = (*cur - '0');
10139
fraction = fraction * 10 + v;
10140
frac = frac + 1;
10141
cur++;
10142
}
10143
fraction /= my_pow10[frac];
10144
ret = ret + fraction;
10145
while ((*cur >= '0') && (*cur <= '9'))
10146
cur++;
10147
}
10148
if ((*cur == 'e') || (*cur == 'E')) {
10149
cur++;
10150
if (*cur == '-') {
10151
is_exponent_negative = 1;
10152
cur++;
10153
} else if (*cur == '+') {
10154
cur++;
10155
}
10156
while ((*cur >= '0') && (*cur <= '9')) {
10157
exponent = exponent * 10 + (*cur - '0');
10158
cur++;
10159
}
10160
}
10161
while (IS_BLANK_CH(*cur)) cur++;
10162
if (*cur != 0) return(xmlXPathNAN);
10163
if (isneg) ret = -ret;
10164
if (is_exponent_negative) exponent = -exponent;
10165
ret *= pow(10.0, (double)exponent);
10166
return(ret);
10167
}
10168
10169
/**
10170
* xmlXPathCompNumber:
10171
* @ctxt: the XPath Parser context
10172
*
10173
* [30] Number ::= Digits ('.' Digits?)?
10174
* | '.' Digits
10175
* [31] Digits ::= [0-9]+
10176
*
10177
* Compile a Number, then push it on the stack
10178
*
10179
*/
10180
static void
10181
xmlXPathCompNumber(xmlXPathParserContextPtr ctxt)
10182
{
10183
double ret = 0.0;
10184
int ok = 0;
10185
int exponent = 0;
10186
int is_exponent_negative = 0;
10187
#ifdef __GNUC__
10188
unsigned long tmp = 0;
10189
double temp;
10190
#endif
10191
10192
CHECK_ERROR;
10193
if ((CUR != '.') && ((CUR < '0') || (CUR > '9'))) {
10194
XP_ERROR(XPATH_NUMBER_ERROR);
10195
}
10196
#ifdef __GNUC__
10197
/*
10198
* tmp/temp is a workaround against a gcc compiler bug
10199
* http://veillard.com/gcc.bug
10200
*/
10201
ret = 0;
10202
while ((CUR >= '0') && (CUR <= '9')) {
10203
ret = ret * 10;
10204
tmp = (CUR - '0');
10205
ok = 1;
10206
NEXT;
10207
temp = (double) tmp;
10208
ret = ret + temp;
10209
}
10210
#else
10211
ret = 0;
10212
while ((CUR >= '0') && (CUR <= '9')) {
10213
ret = ret * 10 + (CUR - '0');
10214
ok = 1;
10215
NEXT;
10216
}
10217
#endif
10218
if (CUR == '.') {
10219
int v, frac = 0;
10220
double fraction = 0;
10221
10222
NEXT;
10223
if (((CUR < '0') || (CUR > '9')) && (!ok)) {
10224
XP_ERROR(XPATH_NUMBER_ERROR);
10225
}
10226
while ((CUR >= '0') && (CUR <= '9') && (frac < MAX_FRAC)) {
10227
v = (CUR - '0');
10228
fraction = fraction * 10 + v;
10229
frac = frac + 1;
10230
NEXT;
10231
}
10232
fraction /= my_pow10[frac];
10233
ret = ret + fraction;
10234
while ((CUR >= '0') && (CUR <= '9'))
10235
NEXT;
10236
}
10237
if ((CUR == 'e') || (CUR == 'E')) {
10238
NEXT;
10239
if (CUR == '-') {
10240
is_exponent_negative = 1;
10241
NEXT;
10242
} else if (CUR == '+') {
10243
NEXT;
10244
}
10245
while ((CUR >= '0') && (CUR <= '9')) {
10246
exponent = exponent * 10 + (CUR - '0');
10247
NEXT;
10248
}
10249
if (is_exponent_negative)
10250
exponent = -exponent;
10251
ret *= pow(10.0, (double) exponent);
10252
}
10253
PUSH_LONG_EXPR(XPATH_OP_VALUE, XPATH_NUMBER, 0, 0,
10254
xmlXPathCacheNewFloat(ctxt->context, ret), NULL);
10255
}
10256
10257
/**
10258
* xmlXPathParseLiteral:
10259
* @ctxt: the XPath Parser context
10260
*
10261
* Parse a Literal
10262
*
10263
* [29] Literal ::= '"' [^"]* '"'
10264
* | "'" [^']* "'"
10265
*
10266
* Returns the value found or NULL in case of error
10267
*/
10268
static xmlChar *
10269
xmlXPathParseLiteral(xmlXPathParserContextPtr ctxt) {
10270
const xmlChar *q;
10271
xmlChar *ret = NULL;
10272
10273
if (CUR == '"') {
10274
NEXT;
10275
q = CUR_PTR;
10276
while ((IS_CHAR_CH(CUR)) && (CUR != '"'))
10277
NEXT;
10278
if (!IS_CHAR_CH(CUR)) {
10279
XP_ERRORNULL(XPATH_UNFINISHED_LITERAL_ERROR);
10280
} else {
10281
ret = xmlStrndup(q, CUR_PTR - q);
10282
NEXT;
10283
}
10284
} else if (CUR == '\'') {
10285
NEXT;
10286
q = CUR_PTR;
10287
while ((IS_CHAR_CH(CUR)) && (CUR != '\''))
10288
NEXT;
10289
if (!IS_CHAR_CH(CUR)) {
10290
XP_ERRORNULL(XPATH_UNFINISHED_LITERAL_ERROR);
10291
} else {
10292
ret = xmlStrndup(q, CUR_PTR - q);
10293
NEXT;
10294
}
10295
} else {
10296
XP_ERRORNULL(XPATH_START_LITERAL_ERROR);
10297
}
10298
return(ret);
10299
}
10300
10301
/**
10302
* xmlXPathCompLiteral:
10303
* @ctxt: the XPath Parser context
10304
*
10305
* Parse a Literal and push it on the stack.
10306
*
10307
* [29] Literal ::= '"' [^"]* '"'
10308
* | "'" [^']* "'"
10309
*
10310
* TODO: xmlXPathCompLiteral memory allocation could be improved.
10311
*/
10312
static void
10313
xmlXPathCompLiteral(xmlXPathParserContextPtr ctxt) {
10314
const xmlChar *q;
10315
xmlChar *ret = NULL;
10316
10317
if (CUR == '"') {
10318
NEXT;
10319
q = CUR_PTR;
10320
while ((IS_CHAR_CH(CUR)) && (CUR != '"'))
10321
NEXT;
10322
if (!IS_CHAR_CH(CUR)) {
10323
XP_ERROR(XPATH_UNFINISHED_LITERAL_ERROR);
10324
} else {
10325
ret = xmlStrndup(q, CUR_PTR - q);
10326
NEXT;
10327
}
10328
} else if (CUR == '\'') {
10329
NEXT;
10330
q = CUR_PTR;
10331
while ((IS_CHAR_CH(CUR)) && (CUR != '\''))
10332
NEXT;
10333
if (!IS_CHAR_CH(CUR)) {
10334
XP_ERROR(XPATH_UNFINISHED_LITERAL_ERROR);
10335
} else {
10336
ret = xmlStrndup(q, CUR_PTR - q);
10337
NEXT;
10338
}
10339
} else {
10340
XP_ERROR(XPATH_START_LITERAL_ERROR);
10341
}
10342
if (ret == NULL) return;
10343
PUSH_LONG_EXPR(XPATH_OP_VALUE, XPATH_STRING, 0, 0,
10344
xmlXPathCacheNewString(ctxt->context, ret), NULL);
10345
xmlFree(ret);
10346
}
10347
10348
/**
10349
* xmlXPathCompVariableReference:
10350
* @ctxt: the XPath Parser context
10351
*
10352
* Parse a VariableReference, evaluate it and push it on the stack.
10353
*
10354
* The variable bindings consist of a mapping from variable names
10355
* to variable values. The value of a variable is an object, which can be
10356
* of any of the types that are possible for the value of an expression,
10357
* and may also be of additional types not specified here.
10358
*
10359
* Early evaluation is possible since:
10360
* The variable bindings [...] used to evaluate a subexpression are
10361
* always the same as those used to evaluate the containing expression.
10362
*
10363
* [36] VariableReference ::= '$' QName
10364
*/
10365
static void
10366
xmlXPathCompVariableReference(xmlXPathParserContextPtr ctxt) {
10367
xmlChar *name;
10368
xmlChar *prefix;
10369
10370
SKIP_BLANKS;
10371
if (CUR != '$') {
10372
XP_ERROR(XPATH_VARIABLE_REF_ERROR);
10373
}
10374
NEXT;
10375
name = xmlXPathParseQName(ctxt, &prefix);
10376
if (name == NULL) {
10377
XP_ERROR(XPATH_VARIABLE_REF_ERROR);
10378
}
10379
ctxt->comp->last = -1;
10380
PUSH_LONG_EXPR(XPATH_OP_VARIABLE, 0, 0, 0,
10381
name, prefix);
10382
SKIP_BLANKS;
10383
if ((ctxt->context != NULL) && (ctxt->context->flags & XML_XPATH_NOVAR)) {
10384
XP_ERROR(XPATH_FORBID_VARIABLE_ERROR);
10385
}
10386
}
10387
10388
/**
10389
* xmlXPathIsNodeType:
10390
* @name: a name string
10391
*
10392
* Is the name given a NodeType one.
10393
*
10394
* [38] NodeType ::= 'comment'
10395
* | 'text'
10396
* | 'processing-instruction'
10397
* | 'node'
10398
*
10399
* Returns 1 if true 0 otherwise
10400
*/
10401
int
10402
xmlXPathIsNodeType(const xmlChar *name) {
10403
if (name == NULL)
10404
return(0);
10405
10406
if (xmlStrEqual(name, BAD_CAST "node"))
10407
return(1);
10408
if (xmlStrEqual(name, BAD_CAST "text"))
10409
return(1);
10410
if (xmlStrEqual(name, BAD_CAST "comment"))
10411
return(1);
10412
if (xmlStrEqual(name, BAD_CAST "processing-instruction"))
10413
return(1);
10414
return(0);
10415
}
10416
10417
/**
10418
* xmlXPathCompFunctionCall:
10419
* @ctxt: the XPath Parser context
10420
*
10421
* [16] FunctionCall ::= FunctionName '(' ( Argument ( ',' Argument)*)? ')'
10422
* [17] Argument ::= Expr
10423
*
10424
* Compile a function call, the evaluation of all arguments are
10425
* pushed on the stack
10426
*/
10427
static void
10428
xmlXPathCompFunctionCall(xmlXPathParserContextPtr ctxt) {
10429
xmlChar *name;
10430
xmlChar *prefix;
10431
int nbargs = 0;
10432
int sort = 1;
10433
10434
name = xmlXPathParseQName(ctxt, &prefix);
10435
if (name == NULL) {
10436
xmlFree(prefix);
10437
XP_ERROR(XPATH_EXPR_ERROR);
10438
}
10439
SKIP_BLANKS;
10440
#ifdef DEBUG_EXPR
10441
if (prefix == NULL)
10442
xmlGenericError(xmlGenericErrorContext, "Calling function %s\n",
10443
name);
10444
else
10445
xmlGenericError(xmlGenericErrorContext, "Calling function %s:%s\n",
10446
prefix, name);
10447
#endif
10448
10449
if (CUR != '(') {
10450
XP_ERROR(XPATH_EXPR_ERROR);
10451
}
10452
NEXT;
10453
SKIP_BLANKS;
10454
10455
/*
10456
* Optimization for count(): we don't need the node-set to be sorted.
10457
*/
10458
if ((prefix == NULL) && (name[0] == 'c') &&
10459
xmlStrEqual(name, BAD_CAST "count"))
10460
{
10461
sort = 0;
10462
}
10463
ctxt->comp->last = -1;
10464
if (CUR != ')') {
10465
while (CUR != 0) {
10466
int op1 = ctxt->comp->last;
10467
ctxt->comp->last = -1;
10468
xmlXPathCompileExpr(ctxt, sort);
10469
if (ctxt->error != XPATH_EXPRESSION_OK) {
10470
xmlFree(name);
10471
xmlFree(prefix);
10472
return;
10473
}
10474
PUSH_BINARY_EXPR(XPATH_OP_ARG, op1, ctxt->comp->last, 0, 0);
10475
nbargs++;
10476
if (CUR == ')') break;
10477
if (CUR != ',') {
10478
XP_ERROR(XPATH_EXPR_ERROR);
10479
}
10480
NEXT;
10481
SKIP_BLANKS;
10482
}
10483
}
10484
PUSH_LONG_EXPR(XPATH_OP_FUNCTION, nbargs, 0, 0,
10485
name, prefix);
10486
NEXT;
10487
SKIP_BLANKS;
10488
}
10489
10490
/**
10491
* xmlXPathCompPrimaryExpr:
10492
* @ctxt: the XPath Parser context
10493
*
10494
* [15] PrimaryExpr ::= VariableReference
10495
* | '(' Expr ')'
10496
* | Literal
10497
* | Number
10498
* | FunctionCall
10499
*
10500
* Compile a primary expression.
10501
*/
10502
static void
10503
xmlXPathCompPrimaryExpr(xmlXPathParserContextPtr ctxt) {
10504
SKIP_BLANKS;
10505
if (CUR == '$') xmlXPathCompVariableReference(ctxt);
10506
else if (CUR == '(') {
10507
NEXT;
10508
SKIP_BLANKS;
10509
xmlXPathCompileExpr(ctxt, 1);
10510
CHECK_ERROR;
10511
if (CUR != ')') {
10512
XP_ERROR(XPATH_EXPR_ERROR);
10513
}
10514
NEXT;
10515
SKIP_BLANKS;
10516
} else if (IS_ASCII_DIGIT(CUR) || (CUR == '.' && IS_ASCII_DIGIT(NXT(1)))) {
10517
xmlXPathCompNumber(ctxt);
10518
} else if ((CUR == '\'') || (CUR == '"')) {
10519
xmlXPathCompLiteral(ctxt);
10520
} else {
10521
xmlXPathCompFunctionCall(ctxt);
10522
}
10523
SKIP_BLANKS;
10524
}
10525
10526
/**
10527
* xmlXPathCompFilterExpr:
10528
* @ctxt: the XPath Parser context
10529
*
10530
* [20] FilterExpr ::= PrimaryExpr
10531
* | FilterExpr Predicate
10532
*
10533
* Compile a filter expression.
10534
* Square brackets are used to filter expressions in the same way that
10535
* they are used in location paths. It is an error if the expression to
10536
* be filtered does not evaluate to a node-set. The context node list
10537
* used for evaluating the expression in square brackets is the node-set
10538
* to be filtered listed in document order.
10539
*/
10540
10541
static void
10542
xmlXPathCompFilterExpr(xmlXPathParserContextPtr ctxt) {
10543
xmlXPathCompPrimaryExpr(ctxt);
10544
CHECK_ERROR;
10545
SKIP_BLANKS;
10546
10547
while (CUR == '[') {
10548
xmlXPathCompPredicate(ctxt, 1);
10549
SKIP_BLANKS;
10550
}
10551
10552
10553
}
10554
10555
/**
10556
* xmlXPathScanName:
10557
* @ctxt: the XPath Parser context
10558
*
10559
* Trickery: parse an XML name but without consuming the input flow
10560
* Needed to avoid insanity in the parser state.
10561
*
10562
* [4] NameChar ::= Letter | Digit | '.' | '-' | '_' | ':' |
10563
* CombiningChar | Extender
10564
*
10565
* [5] Name ::= (Letter | '_' | ':') (NameChar)*
10566
*
10567
* [6] Names ::= Name (S Name)*
10568
*
10569
* Returns the Name parsed or NULL
10570
*/
10571
10572
static xmlChar *
10573
xmlXPathScanName(xmlXPathParserContextPtr ctxt) {
10574
int len = 0, l;
10575
int c;
10576
const xmlChar *cur;
10577
xmlChar *ret;
10578
10579
cur = ctxt->cur;
10580
10581
c = CUR_CHAR(l);
10582
if ((c == ' ') || (c == '>') || (c == '/') || /* accelerators */
10583
(!IS_LETTER(c) && (c != '_') &&
10584
(c != ':'))) {
10585
return(NULL);
10586
}
10587
10588
while ((c != ' ') && (c != '>') && (c != '/') && /* test bigname.xml */
10589
((IS_LETTER(c)) || (IS_DIGIT(c)) ||
10590
(c == '.') || (c == '-') ||
10591
(c == '_') || (c == ':') ||
10592
(IS_COMBINING(c)) ||
10593
(IS_EXTENDER(c)))) {
10594
len += l;
10595
NEXTL(l);
10596
c = CUR_CHAR(l);
10597
}
10598
ret = xmlStrndup(cur, ctxt->cur - cur);
10599
ctxt->cur = cur;
10600
return(ret);
10601
}
10602
10603
/**
10604
* xmlXPathCompPathExpr:
10605
* @ctxt: the XPath Parser context
10606
*
10607
* [19] PathExpr ::= LocationPath
10608
* | FilterExpr
10609
* | FilterExpr '/' RelativeLocationPath
10610
* | FilterExpr '//' RelativeLocationPath
10611
*
10612
* Compile a path expression.
10613
* The / operator and // operators combine an arbitrary expression
10614
* and a relative location path. It is an error if the expression
10615
* does not evaluate to a node-set.
10616
* The / operator does composition in the same way as when / is
10617
* used in a location path. As in location paths, // is short for
10618
* /descendant-or-self::node()/.
10619
*/
10620
10621
static void
10622
xmlXPathCompPathExpr(xmlXPathParserContextPtr ctxt) {
10623
int lc = 1; /* Should we branch to LocationPath ? */
10624
xmlChar *name = NULL; /* we may have to preparse a name to find out */
10625
10626
SKIP_BLANKS;
10627
if ((CUR == '$') || (CUR == '(') ||
10628
(IS_ASCII_DIGIT(CUR)) ||
10629
(CUR == '\'') || (CUR == '"') ||
10630
(CUR == '.' && IS_ASCII_DIGIT(NXT(1)))) {
10631
lc = 0;
10632
} else if (CUR == '*') {
10633
/* relative or absolute location path */
10634
lc = 1;
10635
} else if (CUR == '/') {
10636
/* relative or absolute location path */
10637
lc = 1;
10638
} else if (CUR == '@') {
10639
/* relative abbreviated attribute location path */
10640
lc = 1;
10641
} else if (CUR == '.') {
10642
/* relative abbreviated attribute location path */
10643
lc = 1;
10644
} else {
10645
/*
10646
* Problem is finding if we have a name here whether it's:
10647
* - a nodetype
10648
* - a function call in which case it's followed by '('
10649
* - an axis in which case it's followed by ':'
10650
* - a element name
10651
* We do an a priori analysis here rather than having to
10652
* maintain parsed token content through the recursive function
10653
* calls. This looks uglier but makes the code easier to
10654
* read/write/debug.
10655
*/
10656
SKIP_BLANKS;
10657
name = xmlXPathScanName(ctxt);
10658
if ((name != NULL) && (xmlStrstr(name, (xmlChar *) "::") != NULL)) {
10659
#ifdef DEBUG_STEP
10660
xmlGenericError(xmlGenericErrorContext,
10661
"PathExpr: Axis\n");
10662
#endif
10663
lc = 1;
10664
xmlFree(name);
10665
} else if (name != NULL) {
10666
int len =xmlStrlen(name);
10667
10668
10669
while (NXT(len) != 0) {
10670
if (NXT(len) == '/') {
10671
/* element name */
10672
#ifdef DEBUG_STEP
10673
xmlGenericError(xmlGenericErrorContext,
10674
"PathExpr: AbbrRelLocation\n");
10675
#endif
10676
lc = 1;
10677
break;
10678
} else if (IS_BLANK_CH(NXT(len))) {
10679
/* ignore blanks */
10680
;
10681
} else if (NXT(len) == ':') {
10682
#ifdef DEBUG_STEP
10683
xmlGenericError(xmlGenericErrorContext,
10684
"PathExpr: AbbrRelLocation\n");
10685
#endif
10686
lc = 1;
10687
break;
10688
} else if ((NXT(len) == '(')) {
10689
/* Note Type or Function */
10690
if (xmlXPathIsNodeType(name)) {
10691
#ifdef DEBUG_STEP
10692
xmlGenericError(xmlGenericErrorContext,
10693
"PathExpr: Type search\n");
10694
#endif
10695
lc = 1;
10696
} else {
10697
#ifdef DEBUG_STEP
10698
xmlGenericError(xmlGenericErrorContext,
10699
"PathExpr: function call\n");
10700
#endif
10701
lc = 0;
10702
}
10703
break;
10704
} else if ((NXT(len) == '[')) {
10705
/* element name */
10706
#ifdef DEBUG_STEP
10707
xmlGenericError(xmlGenericErrorContext,
10708
"PathExpr: AbbrRelLocation\n");
10709
#endif
10710
lc = 1;
10711
break;
10712
} else if ((NXT(len) == '<') || (NXT(len) == '>') ||
10713
(NXT(len) == '=')) {
10714
lc = 1;
10715
break;
10716
} else {
10717
lc = 1;
10718
break;
10719
}
10720
len++;
10721
}
10722
if (NXT(len) == 0) {
10723
#ifdef DEBUG_STEP
10724
xmlGenericError(xmlGenericErrorContext,
10725
"PathExpr: AbbrRelLocation\n");
10726
#endif
10727
/* element name */
10728
lc = 1;
10729
}
10730
xmlFree(name);
10731
} else {
10732
/* make sure all cases are covered explicitly */
10733
XP_ERROR(XPATH_EXPR_ERROR);
10734
}
10735
}
10736
10737
if (lc) {
10738
if (CUR == '/') {
10739
PUSH_LEAVE_EXPR(XPATH_OP_ROOT, 0, 0);
10740
} else {
10741
PUSH_LEAVE_EXPR(XPATH_OP_NODE, 0, 0);
10742
}
10743
xmlXPathCompLocationPath(ctxt);
10744
} else {
10745
xmlXPathCompFilterExpr(ctxt);
10746
CHECK_ERROR;
10747
if ((CUR == '/') && (NXT(1) == '/')) {
10748
SKIP(2);
10749
SKIP_BLANKS;
10750
10751
PUSH_LONG_EXPR(XPATH_OP_COLLECT, AXIS_DESCENDANT_OR_SELF,
10752
NODE_TEST_TYPE, NODE_TYPE_NODE, NULL, NULL);
10753
PUSH_UNARY_EXPR(XPATH_OP_RESET, ctxt->comp->last, 1, 0);
10754
10755
xmlXPathCompRelativeLocationPath(ctxt);
10756
} else if (CUR == '/') {
10757
xmlXPathCompRelativeLocationPath(ctxt);
10758
}
10759
}
10760
SKIP_BLANKS;
10761
}
10762
10763
/**
10764
* xmlXPathCompUnionExpr:
10765
* @ctxt: the XPath Parser context
10766
*
10767
* [18] UnionExpr ::= PathExpr
10768
* | UnionExpr '|' PathExpr
10769
*
10770
* Compile an union expression.
10771
*/
10772
10773
static void
10774
xmlXPathCompUnionExpr(xmlXPathParserContextPtr ctxt) {
10775
xmlXPathCompPathExpr(ctxt);
10776
CHECK_ERROR;
10777
SKIP_BLANKS;
10778
while (CUR == '|') {
10779
int op1 = ctxt->comp->last;
10780
PUSH_LEAVE_EXPR(XPATH_OP_NODE, 0, 0);
10781
10782
NEXT;
10783
SKIP_BLANKS;
10784
xmlXPathCompPathExpr(ctxt);
10785
10786
PUSH_BINARY_EXPR(XPATH_OP_UNION, op1, ctxt->comp->last, 0, 0);
10787
10788
SKIP_BLANKS;
10789
}
10790
}
10791
10792
/**
10793
* xmlXPathCompUnaryExpr:
10794
* @ctxt: the XPath Parser context
10795
*
10796
* [27] UnaryExpr ::= UnionExpr
10797
* | '-' UnaryExpr
10798
*
10799
* Compile an unary expression.
10800
*/
10801
10802
static void
10803
xmlXPathCompUnaryExpr(xmlXPathParserContextPtr ctxt) {
10804
int minus = 0;
10805
int found = 0;
10806
10807
SKIP_BLANKS;
10808
while (CUR == '-') {
10809
minus = 1 - minus;
10810
found = 1;
10811
NEXT;
10812
SKIP_BLANKS;
10813
}
10814
10815
xmlXPathCompUnionExpr(ctxt);
10816
CHECK_ERROR;
10817
if (found) {
10818
if (minus)
10819
PUSH_UNARY_EXPR(XPATH_OP_PLUS, ctxt->comp->last, 2, 0);
10820
else
10821
PUSH_UNARY_EXPR(XPATH_OP_PLUS, ctxt->comp->last, 3, 0);
10822
}
10823
}
10824
10825
/**
10826
* xmlXPathCompMultiplicativeExpr:
10827
* @ctxt: the XPath Parser context
10828
*
10829
* [26] MultiplicativeExpr ::= UnaryExpr
10830
* | MultiplicativeExpr MultiplyOperator UnaryExpr
10831
* | MultiplicativeExpr 'div' UnaryExpr
10832
* | MultiplicativeExpr 'mod' UnaryExpr
10833
* [34] MultiplyOperator ::= '*'
10834
*
10835
* Compile an Additive expression.
10836
*/
10837
10838
static void
10839
xmlXPathCompMultiplicativeExpr(xmlXPathParserContextPtr ctxt) {
10840
xmlXPathCompUnaryExpr(ctxt);
10841
CHECK_ERROR;
10842
SKIP_BLANKS;
10843
while ((CUR == '*') ||
10844
((CUR == 'd') && (NXT(1) == 'i') && (NXT(2) == 'v')) ||
10845
((CUR == 'm') && (NXT(1) == 'o') && (NXT(2) == 'd'))) {
10846
int op = -1;
10847
int op1 = ctxt->comp->last;
10848
10849
if (CUR == '*') {
10850
op = 0;
10851
NEXT;
10852
} else if (CUR == 'd') {
10853
op = 1;
10854
SKIP(3);
10855
} else if (CUR == 'm') {
10856
op = 2;
10857
SKIP(3);
10858
}
10859
SKIP_BLANKS;
10860
xmlXPathCompUnaryExpr(ctxt);
10861
CHECK_ERROR;
10862
PUSH_BINARY_EXPR(XPATH_OP_MULT, op1, ctxt->comp->last, op, 0);
10863
SKIP_BLANKS;
10864
}
10865
}
10866
10867
/**
10868
* xmlXPathCompAdditiveExpr:
10869
* @ctxt: the XPath Parser context
10870
*
10871
* [25] AdditiveExpr ::= MultiplicativeExpr
10872
* | AdditiveExpr '+' MultiplicativeExpr
10873
* | AdditiveExpr '-' MultiplicativeExpr
10874
*
10875
* Compile an Additive expression.
10876
*/
10877
10878
static void
10879
xmlXPathCompAdditiveExpr(xmlXPathParserContextPtr ctxt) {
10880
10881
xmlXPathCompMultiplicativeExpr(ctxt);
10882
CHECK_ERROR;
10883
SKIP_BLANKS;
10884
while ((CUR == '+') || (CUR == '-')) {
10885
int plus;
10886
int op1 = ctxt->comp->last;
10887
10888
if (CUR == '+') plus = 1;
10889
else plus = 0;
10890
NEXT;
10891
SKIP_BLANKS;
10892
xmlXPathCompMultiplicativeExpr(ctxt);
10893
CHECK_ERROR;
10894
PUSH_BINARY_EXPR(XPATH_OP_PLUS, op1, ctxt->comp->last, plus, 0);
10895
SKIP_BLANKS;
10896
}
10897
}
10898
10899
/**
10900
* xmlXPathCompRelationalExpr:
10901
* @ctxt: the XPath Parser context
10902
*
10903
* [24] RelationalExpr ::= AdditiveExpr
10904
* | RelationalExpr '<' AdditiveExpr
10905
* | RelationalExpr '>' AdditiveExpr
10906
* | RelationalExpr '<=' AdditiveExpr
10907
* | RelationalExpr '>=' AdditiveExpr
10908
*
10909
* A <= B > C is allowed ? Answer from James, yes with
10910
* (AdditiveExpr <= AdditiveExpr) > AdditiveExpr
10911
* which is basically what got implemented.
10912
*
10913
* Compile a Relational expression, then push the result
10914
* on the stack
10915
*/
10916
10917
static void
10918
xmlXPathCompRelationalExpr(xmlXPathParserContextPtr ctxt) {
10919
xmlXPathCompAdditiveExpr(ctxt);
10920
CHECK_ERROR;
10921
SKIP_BLANKS;
10922
while ((CUR == '<') ||
10923
(CUR == '>') ||
10924
((CUR == '<') && (NXT(1) == '=')) ||
10925
((CUR == '>') && (NXT(1) == '='))) {
10926
int inf, strict;
10927
int op1 = ctxt->comp->last;
10928
10929
if (CUR == '<') inf = 1;
10930
else inf = 0;
10931
if (NXT(1) == '=') strict = 0;
10932
else strict = 1;
10933
NEXT;
10934
if (!strict) NEXT;
10935
SKIP_BLANKS;
10936
xmlXPathCompAdditiveExpr(ctxt);
10937
CHECK_ERROR;
10938
PUSH_BINARY_EXPR(XPATH_OP_CMP, op1, ctxt->comp->last, inf, strict);
10939
SKIP_BLANKS;
10940
}
10941
}
10942
10943
/**
10944
* xmlXPathCompEqualityExpr:
10945
* @ctxt: the XPath Parser context
10946
*
10947
* [23] EqualityExpr ::= RelationalExpr
10948
* | EqualityExpr '=' RelationalExpr
10949
* | EqualityExpr '!=' RelationalExpr
10950
*
10951
* A != B != C is allowed ? Answer from James, yes with
10952
* (RelationalExpr = RelationalExpr) = RelationalExpr
10953
* (RelationalExpr != RelationalExpr) != RelationalExpr
10954
* which is basically what got implemented.
10955
*
10956
* Compile an Equality expression.
10957
*
10958
*/
10959
static void
10960
xmlXPathCompEqualityExpr(xmlXPathParserContextPtr ctxt) {
10961
xmlXPathCompRelationalExpr(ctxt);
10962
CHECK_ERROR;
10963
SKIP_BLANKS;
10964
while ((CUR == '=') || ((CUR == '!') && (NXT(1) == '='))) {
10965
int eq;
10966
int op1 = ctxt->comp->last;
10967
10968
if (CUR == '=') eq = 1;
10969
else eq = 0;
10970
NEXT;
10971
if (!eq) NEXT;
10972
SKIP_BLANKS;
10973
xmlXPathCompRelationalExpr(ctxt);
10974
CHECK_ERROR;
10975
PUSH_BINARY_EXPR(XPATH_OP_EQUAL, op1, ctxt->comp->last, eq, 0);
10976
SKIP_BLANKS;
10977
}
10978
}
10979
10980
/**
10981
* xmlXPathCompAndExpr:
10982
* @ctxt: the XPath Parser context
10983
*
10984
* [22] AndExpr ::= EqualityExpr
10985
* | AndExpr 'and' EqualityExpr
10986
*
10987
* Compile an AND expression.
10988
*
10989
*/
10990
static void
10991
xmlXPathCompAndExpr(xmlXPathParserContextPtr ctxt) {
10992
xmlXPathCompEqualityExpr(ctxt);
10993
CHECK_ERROR;
10994
SKIP_BLANKS;
10995
while ((CUR == 'a') && (NXT(1) == 'n') && (NXT(2) == 'd')) {
10996
int op1 = ctxt->comp->last;
10997
SKIP(3);
10998
SKIP_BLANKS;
10999
xmlXPathCompEqualityExpr(ctxt);
11000
CHECK_ERROR;
11001
PUSH_BINARY_EXPR(XPATH_OP_AND, op1, ctxt->comp->last, 0, 0);
11002
SKIP_BLANKS;
11003
}
11004
}
11005
11006
/**
11007
* xmlXPathCompileExpr:
11008
* @ctxt: the XPath Parser context
11009
*
11010
* [14] Expr ::= OrExpr
11011
* [21] OrExpr ::= AndExpr
11012
* | OrExpr 'or' AndExpr
11013
*
11014
* Parse and compile an expression
11015
*/
11016
static void
11017
xmlXPathCompileExpr(xmlXPathParserContextPtr ctxt, int sort) {
11018
xmlXPathCompAndExpr(ctxt);
11019
CHECK_ERROR;
11020
SKIP_BLANKS;
11021
while ((CUR == 'o') && (NXT(1) == 'r')) {
11022
int op1 = ctxt->comp->last;
11023
SKIP(2);
11024
SKIP_BLANKS;
11025
xmlXPathCompAndExpr(ctxt);
11026
CHECK_ERROR;
11027
PUSH_BINARY_EXPR(XPATH_OP_OR, op1, ctxt->comp->last, 0, 0);
11028
SKIP_BLANKS;
11029
}
11030
if ((sort) && (ctxt->comp->steps[ctxt->comp->last].op != XPATH_OP_VALUE)) {
11031
/* more ops could be optimized too */
11032
/*
11033
* This is the main place to eliminate sorting for
11034
* operations which don't require a sorted node-set.
11035
* E.g. count().
11036
*/
11037
PUSH_UNARY_EXPR(XPATH_OP_SORT, ctxt->comp->last , 0, 0);
11038
}
11039
}
11040
11041
/**
11042
* xmlXPathCompPredicate:
11043
* @ctxt: the XPath Parser context
11044
* @filter: act as a filter
11045
*
11046
* [8] Predicate ::= '[' PredicateExpr ']'
11047
* [9] PredicateExpr ::= Expr
11048
*
11049
* Compile a predicate expression
11050
*/
11051
static void
11052
xmlXPathCompPredicate(xmlXPathParserContextPtr ctxt, int filter) {
11053
int op1 = ctxt->comp->last;
11054
11055
SKIP_BLANKS;
11056
if (CUR != '[') {
11057
XP_ERROR(XPATH_INVALID_PREDICATE_ERROR);
11058
}
11059
NEXT;
11060
SKIP_BLANKS;
11061
11062
ctxt->comp->last = -1;
11063
/*
11064
* This call to xmlXPathCompileExpr() will deactivate sorting
11065
* of the predicate result.
11066
* TODO: Sorting is still activated for filters, since I'm not
11067
* sure if needed. Normally sorting should not be needed, since
11068
* a filter can only diminish the number of items in a sequence,
11069
* but won't change its order; so if the initial sequence is sorted,
11070
* subsequent sorting is not needed.
11071
*/
11072
if (! filter)
11073
xmlXPathCompileExpr(ctxt, 0);
11074
else
11075
xmlXPathCompileExpr(ctxt, 1);
11076
CHECK_ERROR;
11077
11078
if (CUR != ']') {
11079
XP_ERROR(XPATH_INVALID_PREDICATE_ERROR);
11080
}
11081
11082
if (filter)
11083
PUSH_BINARY_EXPR(XPATH_OP_FILTER, op1, ctxt->comp->last, 0, 0);
11084
else
11085
PUSH_BINARY_EXPR(XPATH_OP_PREDICATE, op1, ctxt->comp->last, 0, 0);
11086
11087
NEXT;
11088
SKIP_BLANKS;
11089
}
11090
11091
/**
11092
* xmlXPathCompNodeTest:
11093
* @ctxt: the XPath Parser context
11094
* @test: pointer to a xmlXPathTestVal
11095
* @type: pointer to a xmlXPathTypeVal
11096
* @prefix: placeholder for a possible name prefix
11097
*
11098
* [7] NodeTest ::= NameTest
11099
* | NodeType '(' ')'
11100
* | 'processing-instruction' '(' Literal ')'
11101
*
11102
* [37] NameTest ::= '*'
11103
* | NCName ':' '*'
11104
* | QName
11105
* [38] NodeType ::= 'comment'
11106
* | 'text'
11107
* | 'processing-instruction'
11108
* | 'node'
11109
*
11110
* Returns the name found and updates @test, @type and @prefix appropriately
11111
*/
11112
static xmlChar *
11113
xmlXPathCompNodeTest(xmlXPathParserContextPtr ctxt, xmlXPathTestVal *test,
11114
xmlXPathTypeVal *type, const xmlChar **prefix,
11115
xmlChar *name) {
11116
int blanks;
11117
11118
if ((test == NULL) || (type == NULL) || (prefix == NULL)) {
11119
STRANGE;
11120
return(NULL);
11121
}
11122
*type = (xmlXPathTypeVal) 0;
11123
*test = (xmlXPathTestVal) 0;
11124
*prefix = NULL;
11125
SKIP_BLANKS;
11126
11127
if ((name == NULL) && (CUR == '*')) {
11128
/*
11129
* All elements
11130
*/
11131
NEXT;
11132
*test = NODE_TEST_ALL;
11133
return(NULL);
11134
}
11135
11136
if (name == NULL)
11137
name = xmlXPathParseNCName(ctxt);
11138
if (name == NULL) {
11139
XP_ERRORNULL(XPATH_EXPR_ERROR);
11140
}
11141
11142
blanks = IS_BLANK_CH(CUR);
11143
SKIP_BLANKS;
11144
if (CUR == '(') {
11145
NEXT;
11146
/*
11147
* NodeType or PI search
11148
*/
11149
if (xmlStrEqual(name, BAD_CAST "comment"))
11150
*type = NODE_TYPE_COMMENT;
11151
else if (xmlStrEqual(name, BAD_CAST "node"))
11152
*type = NODE_TYPE_NODE;
11153
else if (xmlStrEqual(name, BAD_CAST "processing-instruction"))
11154
*type = NODE_TYPE_PI;
11155
else if (xmlStrEqual(name, BAD_CAST "text"))
11156
*type = NODE_TYPE_TEXT;
11157
else {
11158
if (name != NULL)
11159
xmlFree(name);
11160
XP_ERRORNULL(XPATH_EXPR_ERROR);
11161
}
11162
11163
*test = NODE_TEST_TYPE;
11164
11165
SKIP_BLANKS;
11166
if (*type == NODE_TYPE_PI) {
11167
/*
11168
* Specific case: search a PI by name.
11169
*/
11170
if (name != NULL)
11171
xmlFree(name);
11172
name = NULL;
11173
if (CUR != ')') {
11174
name = xmlXPathParseLiteral(ctxt);
11175
CHECK_ERROR NULL;
11176
*test = NODE_TEST_PI;
11177
SKIP_BLANKS;
11178
}
11179
}
11180
if (CUR != ')') {
11181
if (name != NULL)
11182
xmlFree(name);
11183
XP_ERRORNULL(XPATH_UNCLOSED_ERROR);
11184
}
11185
NEXT;
11186
return(name);
11187
}
11188
*test = NODE_TEST_NAME;
11189
if ((!blanks) && (CUR == ':')) {
11190
NEXT;
11191
11192
/*
11193
* Since currently the parser context don't have a
11194
* namespace list associated:
11195
* The namespace name for this prefix can be computed
11196
* only at evaluation time. The compilation is done
11197
* outside of any context.
11198
*/
11199
#if 0
11200
*prefix = xmlXPathNsLookup(ctxt->context, name);
11201
if (name != NULL)
11202
xmlFree(name);
11203
if (*prefix == NULL) {
11204
XP_ERROR0(XPATH_UNDEF_PREFIX_ERROR);
11205
}
11206
#else
11207
*prefix = name;
11208
#endif
11209
11210
if (CUR == '*') {
11211
/*
11212
* All elements
11213
*/
11214
NEXT;
11215
*test = NODE_TEST_ALL;
11216
return(NULL);
11217
}
11218
11219
name = xmlXPathParseNCName(ctxt);
11220
if (name == NULL) {
11221
XP_ERRORNULL(XPATH_EXPR_ERROR);
11222
}
11223
}
11224
return(name);
11225
}
11226
11227
/**
11228
* xmlXPathIsAxisName:
11229
* @name: a preparsed name token
11230
*
11231
* [6] AxisName ::= 'ancestor'
11232
* | 'ancestor-or-self'
11233
* | 'attribute'
11234
* | 'child'
11235
* | 'descendant'
11236
* | 'descendant-or-self'
11237
* | 'following'
11238
* | 'following-sibling'
11239
* | 'namespace'
11240
* | 'parent'
11241
* | 'preceding'
11242
* | 'preceding-sibling'
11243
* | 'self'
11244
*
11245
* Returns the axis or 0
11246
*/
11247
static xmlXPathAxisVal
11248
xmlXPathIsAxisName(const xmlChar *name) {
11249
xmlXPathAxisVal ret = (xmlXPathAxisVal) 0;
11250
switch (name[0]) {
11251
case 'a':
11252
if (xmlStrEqual(name, BAD_CAST "ancestor"))
11253
ret = AXIS_ANCESTOR;
11254
if (xmlStrEqual(name, BAD_CAST "ancestor-or-self"))
11255
ret = AXIS_ANCESTOR_OR_SELF;
11256
if (xmlStrEqual(name, BAD_CAST "attribute"))
11257
ret = AXIS_ATTRIBUTE;
11258
break;
11259
case 'c':
11260
if (xmlStrEqual(name, BAD_CAST "child"))
11261
ret = AXIS_CHILD;
11262
break;
11263
case 'd':
11264
if (xmlStrEqual(name, BAD_CAST "descendant"))
11265
ret = AXIS_DESCENDANT;
11266
if (xmlStrEqual(name, BAD_CAST "descendant-or-self"))
11267
ret = AXIS_DESCENDANT_OR_SELF;
11268
break;
11269
case 'f':
11270
if (xmlStrEqual(name, BAD_CAST "following"))
11271
ret = AXIS_FOLLOWING;
11272
if (xmlStrEqual(name, BAD_CAST "following-sibling"))
11273
ret = AXIS_FOLLOWING_SIBLING;
11274
break;
11275
case 'n':
11276
if (xmlStrEqual(name, BAD_CAST "namespace"))
11277
ret = AXIS_NAMESPACE;
11278
break;
11279
case 'p':
11280
if (xmlStrEqual(name, BAD_CAST "parent"))
11281
ret = AXIS_PARENT;
11282
if (xmlStrEqual(name, BAD_CAST "preceding"))
11283
ret = AXIS_PRECEDING;
11284
if (xmlStrEqual(name, BAD_CAST "preceding-sibling"))
11285
ret = AXIS_PRECEDING_SIBLING;
11286
break;
11287
case 's':
11288
if (xmlStrEqual(name, BAD_CAST "self"))
11289
ret = AXIS_SELF;
11290
break;
11291
}
11292
return(ret);
11293
}
11294
11295
/**
11296
* xmlXPathCompStep:
11297
* @ctxt: the XPath Parser context
11298
*
11299
* [4] Step ::= AxisSpecifier NodeTest Predicate*
11300
* | AbbreviatedStep
11301
*
11302
* [12] AbbreviatedStep ::= '.' | '..'
11303
*
11304
* [5] AxisSpecifier ::= AxisName '::'
11305
* | AbbreviatedAxisSpecifier
11306
*
11307
* [13] AbbreviatedAxisSpecifier ::= '@'?
11308
*
11309
* Modified for XPtr range support as:
11310
*
11311
* [4xptr] Step ::= AxisSpecifier NodeTest Predicate*
11312
* | AbbreviatedStep
11313
* | 'range-to' '(' Expr ')' Predicate*
11314
*
11315
* Compile one step in a Location Path
11316
* A location step of . is short for self::node(). This is
11317
* particularly useful in conjunction with //. For example, the
11318
* location path .//para is short for
11319
* self::node()/descendant-or-self::node()/child::para
11320
* and so will select all para descendant elements of the context
11321
* node.
11322
* Similarly, a location step of .. is short for parent::node().
11323
* For example, ../title is short for parent::node()/child::title
11324
* and so will select the title children of the parent of the context
11325
* node.
11326
*/
11327
static void
11328
xmlXPathCompStep(xmlXPathParserContextPtr ctxt) {
11329
#ifdef LIBXML_XPTR_ENABLED
11330
int rangeto = 0;
11331
int op2 = -1;
11332
#endif
11333
11334
SKIP_BLANKS;
11335
if ((CUR == '.') && (NXT(1) == '.')) {
11336
SKIP(2);
11337
SKIP_BLANKS;
11338
PUSH_LONG_EXPR(XPATH_OP_COLLECT, AXIS_PARENT,
11339
NODE_TEST_TYPE, NODE_TYPE_NODE, NULL, NULL);
11340
} else if (CUR == '.') {
11341
NEXT;
11342
SKIP_BLANKS;
11343
} else {
11344
xmlChar *name = NULL;
11345
const xmlChar *prefix = NULL;
11346
xmlXPathTestVal test = (xmlXPathTestVal) 0;
11347
xmlXPathAxisVal axis = (xmlXPathAxisVal) 0;
11348
xmlXPathTypeVal type = (xmlXPathTypeVal) 0;
11349
int op1;
11350
11351
/*
11352
* The modification needed for XPointer change to the production
11353
*/
11354
#ifdef LIBXML_XPTR_ENABLED
11355
if (ctxt->xptr) {
11356
name = xmlXPathParseNCName(ctxt);
11357
if ((name != NULL) && (xmlStrEqual(name, BAD_CAST "range-to"))) {
11358
op2 = ctxt->comp->last;
11359
xmlFree(name);
11360
SKIP_BLANKS;
11361
if (CUR != '(') {
11362
XP_ERROR(XPATH_EXPR_ERROR);
11363
}
11364
NEXT;
11365
SKIP_BLANKS;
11366
11367
xmlXPathCompileExpr(ctxt, 1);
11368
/* PUSH_BINARY_EXPR(XPATH_OP_RANGETO, op2, ctxt->comp->last, 0, 0); */
11369
CHECK_ERROR;
11370
11371
SKIP_BLANKS;
11372
if (CUR != ')') {
11373
XP_ERROR(XPATH_EXPR_ERROR);
11374
}
11375
NEXT;
11376
rangeto = 1;
11377
goto eval_predicates;
11378
}
11379
}
11380
#endif
11381
if (CUR == '*') {
11382
axis = AXIS_CHILD;
11383
} else {
11384
if (name == NULL)
11385
name = xmlXPathParseNCName(ctxt);
11386
if (name != NULL) {
11387
axis = xmlXPathIsAxisName(name);
11388
if (axis != 0) {
11389
SKIP_BLANKS;
11390
if ((CUR == ':') && (NXT(1) == ':')) {
11391
SKIP(2);
11392
xmlFree(name);
11393
name = NULL;
11394
} else {
11395
/* an element name can conflict with an axis one :-\ */
11396
axis = AXIS_CHILD;
11397
}
11398
} else {
11399
axis = AXIS_CHILD;
11400
}
11401
} else if (CUR == '@') {
11402
NEXT;
11403
axis = AXIS_ATTRIBUTE;
11404
} else {
11405
axis = AXIS_CHILD;
11406
}
11407
}
11408
11409
if (ctxt->error != XPATH_EXPRESSION_OK) {
11410
xmlFree(name);
11411
return;
11412
}
11413
11414
name = xmlXPathCompNodeTest(ctxt, &test, &type, &prefix, name);
11415
if (test == 0)
11416
return;
11417
11418
if ((prefix != NULL) && (ctxt->context != NULL) &&
11419
(ctxt->context->flags & XML_XPATH_CHECKNS)) {
11420
if (xmlXPathNsLookup(ctxt->context, prefix) == NULL) {
11421
xmlXPathErr(ctxt, XPATH_UNDEF_PREFIX_ERROR);
11422
}
11423
}
11424
#ifdef DEBUG_STEP
11425
xmlGenericError(xmlGenericErrorContext,
11426
"Basis : computing new set\n");
11427
#endif
11428
11429
#ifdef DEBUG_STEP
11430
xmlGenericError(xmlGenericErrorContext, "Basis : ");
11431
if (ctxt->value == NULL)
11432
xmlGenericError(xmlGenericErrorContext, "no value\n");
11433
else if (ctxt->value->nodesetval == NULL)
11434
xmlGenericError(xmlGenericErrorContext, "Empty\n");
11435
else
11436
xmlGenericErrorContextNodeSet(stdout, ctxt->value->nodesetval);
11437
#endif
11438
11439
#ifdef LIBXML_XPTR_ENABLED
11440
eval_predicates:
11441
#endif
11442
op1 = ctxt->comp->last;
11443
ctxt->comp->last = -1;
11444
11445
SKIP_BLANKS;
11446
while (CUR == '[') {
11447
xmlXPathCompPredicate(ctxt, 0);
11448
}
11449
11450
#ifdef LIBXML_XPTR_ENABLED
11451
if (rangeto) {
11452
PUSH_BINARY_EXPR(XPATH_OP_RANGETO, op2, op1, 0, 0);
11453
} else
11454
#endif
11455
PUSH_FULL_EXPR(XPATH_OP_COLLECT, op1, ctxt->comp->last, axis,
11456
test, type, (void *)prefix, (void *)name);
11457
11458
}
11459
#ifdef DEBUG_STEP
11460
xmlGenericError(xmlGenericErrorContext, "Step : ");
11461
if (ctxt->value == NULL)
11462
xmlGenericError(xmlGenericErrorContext, "no value\n");
11463
else if (ctxt->value->nodesetval == NULL)
11464
xmlGenericError(xmlGenericErrorContext, "Empty\n");
11465
else
11466
xmlGenericErrorContextNodeSet(xmlGenericErrorContext,
11467
ctxt->value->nodesetval);
11468
#endif
11469
}
11470
11471
/**
11472
* xmlXPathCompRelativeLocationPath:
11473
* @ctxt: the XPath Parser context
11474
*
11475
* [3] RelativeLocationPath ::= Step
11476
* | RelativeLocationPath '/' Step
11477
* | AbbreviatedRelativeLocationPath
11478
* [11] AbbreviatedRelativeLocationPath ::= RelativeLocationPath '//' Step
11479
*
11480
* Compile a relative location path.
11481
*/
11482
static void
11483
xmlXPathCompRelativeLocationPath
11484
(xmlXPathParserContextPtr ctxt) {
11485
SKIP_BLANKS;
11486
if ((CUR == '/') && (NXT(1) == '/')) {
11487
SKIP(2);
11488
SKIP_BLANKS;
11489
PUSH_LONG_EXPR(XPATH_OP_COLLECT, AXIS_DESCENDANT_OR_SELF,
11490
NODE_TEST_TYPE, NODE_TYPE_NODE, NULL, NULL);
11491
} else if (CUR == '/') {
11492
NEXT;
11493
SKIP_BLANKS;
11494
}
11495
xmlXPathCompStep(ctxt);
11496
CHECK_ERROR;
11497
SKIP_BLANKS;
11498
while (CUR == '/') {
11499
if ((CUR == '/') && (NXT(1) == '/')) {
11500
SKIP(2);
11501
SKIP_BLANKS;
11502
PUSH_LONG_EXPR(XPATH_OP_COLLECT, AXIS_DESCENDANT_OR_SELF,
11503
NODE_TEST_TYPE, NODE_TYPE_NODE, NULL, NULL);
11504
xmlXPathCompStep(ctxt);
11505
} else if (CUR == '/') {
11506
NEXT;
11507
SKIP_BLANKS;
11508
xmlXPathCompStep(ctxt);
11509
}
11510
SKIP_BLANKS;
11511
}
11512
}
11513
11514
/**
11515
* xmlXPathCompLocationPath:
11516
* @ctxt: the XPath Parser context
11517
*
11518
* [1] LocationPath ::= RelativeLocationPath
11519
* | AbsoluteLocationPath
11520
* [2] AbsoluteLocationPath ::= '/' RelativeLocationPath?
11521
* | AbbreviatedAbsoluteLocationPath
11522
* [10] AbbreviatedAbsoluteLocationPath ::=
11523
* '//' RelativeLocationPath
11524
*
11525
* Compile a location path
11526
*
11527
* // is short for /descendant-or-self::node()/. For example,
11528
* //para is short for /descendant-or-self::node()/child::para and
11529
* so will select any para element in the document (even a para element
11530
* that is a document element will be selected by //para since the
11531
* document element node is a child of the root node); div//para is
11532
* short for div/descendant-or-self::node()/child::para and so will
11533
* select all para descendants of div children.
11534
*/
11535
static void
11536
xmlXPathCompLocationPath(xmlXPathParserContextPtr ctxt) {
11537
SKIP_BLANKS;
11538
if (CUR != '/') {
11539
xmlXPathCompRelativeLocationPath(ctxt);
11540
} else {
11541
while (CUR == '/') {
11542
if ((CUR == '/') && (NXT(1) == '/')) {
11543
SKIP(2);
11544
SKIP_BLANKS;
11545
PUSH_LONG_EXPR(XPATH_OP_COLLECT, AXIS_DESCENDANT_OR_SELF,
11546
NODE_TEST_TYPE, NODE_TYPE_NODE, NULL, NULL);
11547
xmlXPathCompRelativeLocationPath(ctxt);
11548
} else if (CUR == '/') {
11549
NEXT;
11550
SKIP_BLANKS;
11551
if ((CUR != 0 ) &&
11552
((IS_ASCII_LETTER(CUR)) || (CUR == '_') || (CUR == '.') ||
11553
(CUR == '@') || (CUR == '*')))
11554
xmlXPathCompRelativeLocationPath(ctxt);
11555
}
11556
CHECK_ERROR;
11557
}
11558
}
11559
}
11560
11561
/************************************************************************
11562
* *
11563
* XPath precompiled expression evaluation *
11564
* *
11565
************************************************************************/
11566
11567
static int
11568
xmlXPathCompOpEval(xmlXPathParserContextPtr ctxt, xmlXPathStepOpPtr op);
11569
11570
#ifdef DEBUG_STEP
11571
static void
11572
xmlXPathDebugDumpStepAxis(xmlXPathStepOpPtr op,
11573
int nbNodes)
11574
{
11575
xmlGenericError(xmlGenericErrorContext, "new step : ");
11576
switch (op->value) {
11577
case AXIS_ANCESTOR:
11578
xmlGenericError(xmlGenericErrorContext, "axis 'ancestors' ");
11579
break;
11580
case AXIS_ANCESTOR_OR_SELF:
11581
xmlGenericError(xmlGenericErrorContext,
11582
"axis 'ancestors-or-self' ");
11583
break;
11584
case AXIS_ATTRIBUTE:
11585
xmlGenericError(xmlGenericErrorContext, "axis 'attributes' ");
11586
break;
11587
case AXIS_CHILD:
11588
xmlGenericError(xmlGenericErrorContext, "axis 'child' ");
11589
break;
11590
case AXIS_DESCENDANT:
11591
xmlGenericError(xmlGenericErrorContext, "axis 'descendant' ");
11592
break;
11593
case AXIS_DESCENDANT_OR_SELF:
11594
xmlGenericError(xmlGenericErrorContext,
11595
"axis 'descendant-or-self' ");
11596
break;
11597
case AXIS_FOLLOWING:
11598
xmlGenericError(xmlGenericErrorContext, "axis 'following' ");
11599
break;
11600
case AXIS_FOLLOWING_SIBLING:
11601
xmlGenericError(xmlGenericErrorContext,
11602
"axis 'following-siblings' ");
11603
break;
11604
case AXIS_NAMESPACE:
11605
xmlGenericError(xmlGenericErrorContext, "axis 'namespace' ");
11606
break;
11607
case AXIS_PARENT:
11608
xmlGenericError(xmlGenericErrorContext, "axis 'parent' ");
11609
break;
11610
case AXIS_PRECEDING:
11611
xmlGenericError(xmlGenericErrorContext, "axis 'preceding' ");
11612
break;
11613
case AXIS_PRECEDING_SIBLING:
11614
xmlGenericError(xmlGenericErrorContext,
11615
"axis 'preceding-sibling' ");
11616
break;
11617
case AXIS_SELF:
11618
xmlGenericError(xmlGenericErrorContext, "axis 'self' ");
11619
break;
11620
}
11621
xmlGenericError(xmlGenericErrorContext,
11622
" context contains %d nodes\n", nbNodes);
11623
switch (op->value2) {
11624
case NODE_TEST_NONE:
11625
xmlGenericError(xmlGenericErrorContext,
11626
" searching for none !!!\n");
11627
break;
11628
case NODE_TEST_TYPE:
11629
xmlGenericError(xmlGenericErrorContext,
11630
" searching for type %d\n", op->value3);
11631
break;
11632
case NODE_TEST_PI:
11633
xmlGenericError(xmlGenericErrorContext,
11634
" searching for PI !!!\n");
11635
break;
11636
case NODE_TEST_ALL:
11637
xmlGenericError(xmlGenericErrorContext,
11638
" searching for *\n");
11639
break;
11640
case NODE_TEST_NS:
11641
xmlGenericError(xmlGenericErrorContext,
11642
" searching for namespace %s\n",
11643
op->value5);
11644
break;
11645
case NODE_TEST_NAME:
11646
xmlGenericError(xmlGenericErrorContext,
11647
" searching for name %s\n", op->value5);
11648
if (op->value4)
11649
xmlGenericError(xmlGenericErrorContext,
11650
" with namespace %s\n", op->value4);
11651
break;
11652
}
11653
xmlGenericError(xmlGenericErrorContext, "Testing : ");
11654
}
11655
#endif /* DEBUG_STEP */
11656
11657
static int
11658
xmlXPathCompOpEvalPredicate(xmlXPathParserContextPtr ctxt,
11659
xmlXPathStepOpPtr op,
11660
xmlNodeSetPtr set,
11661
int contextSize,
11662
int hasNsNodes)
11663
{
11664
if (op->ch1 != -1) {
11665
xmlXPathCompExprPtr comp = ctxt->comp;
11666
/*
11667
* Process inner predicates first.
11668
*/
11669
if (comp->steps[op->ch1].op != XPATH_OP_PREDICATE) {
11670
/*
11671
* TODO: raise an internal error.
11672
*/
11673
}
11674
contextSize = xmlXPathCompOpEvalPredicate(ctxt,
11675
&comp->steps[op->ch1], set, contextSize, hasNsNodes);
11676
CHECK_ERROR0;
11677
if (contextSize <= 0)
11678
return(0);
11679
}
11680
if (op->ch2 != -1) {
11681
xmlXPathContextPtr xpctxt = ctxt->context;
11682
xmlNodePtr contextNode, oldContextNode;
11683
xmlDocPtr oldContextDoc;
11684
int i, res, contextPos = 0, newContextSize;
11685
xmlXPathStepOpPtr exprOp;
11686
xmlXPathObjectPtr contextObj = NULL, exprRes = NULL;
11687
11688
#ifdef LIBXML_XPTR_ENABLED
11689
/*
11690
* URGENT TODO: Check the following:
11691
* We don't expect location sets if evaluating prediates, right?
11692
* Only filters should expect location sets, right?
11693
*/
11694
#endif
11695
/*
11696
* SPEC XPath 1.0:
11697
* "For each node in the node-set to be filtered, the
11698
* PredicateExpr is evaluated with that node as the
11699
* context node, with the number of nodes in the
11700
* node-set as the context size, and with the proximity
11701
* position of the node in the node-set with respect to
11702
* the axis as the context position;"
11703
* @oldset is the node-set" to be filtered.
11704
*
11705
* SPEC XPath 1.0:
11706
* "only predicates change the context position and
11707
* context size (see [2.4 Predicates])."
11708
* Example:
11709
* node-set context pos
11710
* nA 1
11711
* nB 2
11712
* nC 3
11713
* After applying predicate [position() > 1] :
11714
* node-set context pos
11715
* nB 1
11716
* nC 2
11717
*/
11718
oldContextNode = xpctxt->node;
11719
oldContextDoc = xpctxt->doc;
11720
/*
11721
* Get the expression of this predicate.
11722
*/
11723
exprOp = &ctxt->comp->steps[op->ch2];
11724
newContextSize = 0;
11725
for (i = 0; i < set->nodeNr; i++) {
11726
if (set->nodeTab[i] == NULL)
11727
continue;
11728
11729
contextNode = set->nodeTab[i];
11730
xpctxt->node = contextNode;
11731
xpctxt->contextSize = contextSize;
11732
xpctxt->proximityPosition = ++contextPos;
11733
11734
/*
11735
* Also set the xpath document in case things like
11736
* key() are evaluated in the predicate.
11737
*/
11738
if ((contextNode->type != XML_NAMESPACE_DECL) &&
11739
(contextNode->doc != NULL))
11740
xpctxt->doc = contextNode->doc;
11741
/*
11742
* Evaluate the predicate expression with 1 context node
11743
* at a time; this node is packaged into a node set; this
11744
* node set is handed over to the evaluation mechanism.
11745
*/
11746
if (contextObj == NULL)
11747
contextObj = xmlXPathCacheNewNodeSet(xpctxt, contextNode);
11748
else {
11749
if (xmlXPathNodeSetAddUnique(contextObj->nodesetval,
11750
contextNode) < 0) {
11751
ctxt->error = XPATH_MEMORY_ERROR;
11752
goto evaluation_exit;
11753
}
11754
}
11755
11756
valuePush(ctxt, contextObj);
11757
11758
res = xmlXPathCompOpEvalToBoolean(ctxt, exprOp, 1);
11759
11760
if ((ctxt->error != XPATH_EXPRESSION_OK) || (res == -1)) {
11761
xmlXPathNodeSetClear(set, hasNsNodes);
11762
newContextSize = 0;
11763
goto evaluation_exit;
11764
}
11765
11766
if (res != 0) {
11767
newContextSize++;
11768
} else {
11769
/*
11770
* Remove the entry from the initial node set.
11771
*/
11772
set->nodeTab[i] = NULL;
11773
if (contextNode->type == XML_NAMESPACE_DECL)
11774
xmlXPathNodeSetFreeNs((xmlNsPtr) contextNode);
11775
}
11776
if (ctxt->value == contextObj) {
11777
/*
11778
* Don't free the temporary XPath object holding the
11779
* context node, in order to avoid massive recreation
11780
* inside this loop.
11781
*/
11782
valuePop(ctxt);
11783
xmlXPathNodeSetClear(contextObj->nodesetval, hasNsNodes);
11784
} else {
11785
/*
11786
* TODO: The object was lost in the evaluation machinery.
11787
* Can this happen? Maybe in internal-error cases.
11788
*/
11789
contextObj = NULL;
11790
}
11791
}
11792
11793
if (contextObj != NULL) {
11794
if (ctxt->value == contextObj)
11795
valuePop(ctxt);
11796
xmlXPathReleaseObject(xpctxt, contextObj);
11797
}
11798
evaluation_exit:
11799
if (exprRes != NULL)
11800
xmlXPathReleaseObject(ctxt->context, exprRes);
11801
/*
11802
* Reset/invalidate the context.
11803
*/
11804
xpctxt->node = oldContextNode;
11805
xpctxt->doc = oldContextDoc;
11806
xpctxt->contextSize = -1;
11807
xpctxt->proximityPosition = -1;
11808
return(newContextSize);
11809
}
11810
return(contextSize);
11811
}
11812
11813
static int
11814
xmlXPathCompOpEvalPositionalPredicate(xmlXPathParserContextPtr ctxt,
11815
xmlXPathStepOpPtr op,
11816
xmlNodeSetPtr set,
11817
int contextSize,
11818
int minPos,
11819
int maxPos,
11820
int hasNsNodes)
11821
{
11822
if (op->ch1 != -1) {
11823
xmlXPathCompExprPtr comp = ctxt->comp;
11824
if (comp->steps[op->ch1].op != XPATH_OP_PREDICATE) {
11825
/*
11826
* TODO: raise an internal error.
11827
*/
11828
}
11829
contextSize = xmlXPathCompOpEvalPredicate(ctxt,
11830
&comp->steps[op->ch1], set, contextSize, hasNsNodes);
11831
CHECK_ERROR0;
11832
if (contextSize <= 0)
11833
return(0);
11834
}
11835
/*
11836
* Check if the node set contains a sufficient number of nodes for
11837
* the requested range.
11838
*/
11839
if (contextSize < minPos) {
11840
xmlXPathNodeSetClear(set, hasNsNodes);
11841
return(0);
11842
}
11843
if (op->ch2 == -1) {
11844
/*
11845
* TODO: Can this ever happen?
11846
*/
11847
return (contextSize);
11848
} else {
11849
xmlDocPtr oldContextDoc;
11850
int i, pos = 0, newContextSize = 0, contextPos = 0, res;
11851
xmlXPathStepOpPtr exprOp;
11852
xmlXPathObjectPtr contextObj = NULL, exprRes = NULL;
11853
xmlNodePtr oldContextNode, contextNode = NULL;
11854
xmlXPathContextPtr xpctxt = ctxt->context;
11855
int frame;
11856
11857
#ifdef LIBXML_XPTR_ENABLED
11858
/*
11859
* URGENT TODO: Check the following:
11860
* We don't expect location sets if evaluating prediates, right?
11861
* Only filters should expect location sets, right?
11862
*/
11863
#endif /* LIBXML_XPTR_ENABLED */
11864
11865
/*
11866
* Save old context.
11867
*/
11868
oldContextNode = xpctxt->node;
11869
oldContextDoc = xpctxt->doc;
11870
/*
11871
* Get the expression of this predicate.
11872
*/
11873
exprOp = &ctxt->comp->steps[op->ch2];
11874
for (i = 0; i < set->nodeNr; i++) {
11875
xmlXPathObjectPtr tmp;
11876
11877
if (set->nodeTab[i] == NULL)
11878
continue;
11879
11880
contextNode = set->nodeTab[i];
11881
xpctxt->node = contextNode;
11882
xpctxt->contextSize = contextSize;
11883
xpctxt->proximityPosition = ++contextPos;
11884
11885
/*
11886
* Initialize the new set.
11887
* Also set the xpath document in case things like
11888
* key() evaluation are attempted on the predicate
11889
*/
11890
if ((contextNode->type != XML_NAMESPACE_DECL) &&
11891
(contextNode->doc != NULL))
11892
xpctxt->doc = contextNode->doc;
11893
/*
11894
* Evaluate the predicate expression with 1 context node
11895
* at a time; this node is packaged into a node set; this
11896
* node set is handed over to the evaluation mechanism.
11897
*/
11898
if (contextObj == NULL)
11899
contextObj = xmlXPathCacheNewNodeSet(xpctxt, contextNode);
11900
else {
11901
if (xmlXPathNodeSetAddUnique(contextObj->nodesetval,
11902
contextNode) < 0) {
11903
ctxt->error = XPATH_MEMORY_ERROR;
11904
goto evaluation_exit;
11905
}
11906
}
11907
11908
frame = xmlXPathSetFrame(ctxt);
11909
valuePush(ctxt, contextObj);
11910
res = xmlXPathCompOpEvalToBoolean(ctxt, exprOp, 1);
11911
tmp = valuePop(ctxt);
11912
xmlXPathPopFrame(ctxt, frame);
11913
11914
if ((ctxt->error != XPATH_EXPRESSION_OK) || (res == -1)) {
11915
while (tmp != contextObj) {
11916
/*
11917
* Free up the result
11918
* then pop off contextObj, which will be freed later
11919
*/
11920
xmlXPathReleaseObject(xpctxt, tmp);
11921
tmp = valuePop(ctxt);
11922
}
11923
goto evaluation_error;
11924
}
11925
/* push the result back onto the stack */
11926
valuePush(ctxt, tmp);
11927
11928
if (res)
11929
pos++;
11930
11931
if (res && (pos >= minPos) && (pos <= maxPos)) {
11932
/*
11933
* Fits in the requested range.
11934
*/
11935
newContextSize++;
11936
if (minPos == maxPos) {
11937
/*
11938
* Only 1 node was requested.
11939
*/
11940
if (contextNode->type == XML_NAMESPACE_DECL) {
11941
/*
11942
* As always: take care of those nasty
11943
* namespace nodes.
11944
*/
11945
set->nodeTab[i] = NULL;
11946
}
11947
xmlXPathNodeSetClear(set, hasNsNodes);
11948
set->nodeNr = 1;
11949
set->nodeTab[0] = contextNode;
11950
goto evaluation_exit;
11951
}
11952
if (pos == maxPos) {
11953
/*
11954
* We are done.
11955
*/
11956
xmlXPathNodeSetClearFromPos(set, i +1, hasNsNodes);
11957
goto evaluation_exit;
11958
}
11959
} else {
11960
/*
11961
* Remove the entry from the initial node set.
11962
*/
11963
set->nodeTab[i] = NULL;
11964
if (contextNode->type == XML_NAMESPACE_DECL)
11965
xmlXPathNodeSetFreeNs((xmlNsPtr) contextNode);
11966
}
11967
if (exprRes != NULL) {
11968
xmlXPathReleaseObject(ctxt->context, exprRes);
11969
exprRes = NULL;
11970
}
11971
if (ctxt->value == contextObj) {
11972
/*
11973
* Don't free the temporary XPath object holding the
11974
* context node, in order to avoid massive recreation
11975
* inside this loop.
11976
*/
11977
valuePop(ctxt);
11978
xmlXPathNodeSetClear(contextObj->nodesetval, hasNsNodes);
11979
} else {
11980
/*
11981
* The object was lost in the evaluation machinery.
11982
* Can this happen? Maybe in case of internal-errors.
11983
*/
11984
contextObj = NULL;
11985
}
11986
}
11987
goto evaluation_exit;
11988
11989
evaluation_error:
11990
xmlXPathNodeSetClear(set, hasNsNodes);
11991
newContextSize = 0;
11992
11993
evaluation_exit:
11994
if (contextObj != NULL) {
11995
if (ctxt->value == contextObj)
11996
valuePop(ctxt);
11997
xmlXPathReleaseObject(xpctxt, contextObj);
11998
}
11999
if (exprRes != NULL)
12000
xmlXPathReleaseObject(ctxt->context, exprRes);
12001
/*
12002
* Reset/invalidate the context.
12003
*/
12004
xpctxt->node = oldContextNode;
12005
xpctxt->doc = oldContextDoc;
12006
xpctxt->contextSize = -1;
12007
xpctxt->proximityPosition = -1;
12008
return(newContextSize);
12009
}
12010
return(contextSize);
12011
}
12012
12013
static int
12014
xmlXPathIsPositionalPredicate(xmlXPathParserContextPtr ctxt,
12015
xmlXPathStepOpPtr op,
12016
int *maxPos)
12017
{
12018
12019
xmlXPathStepOpPtr exprOp;
12020
12021
/*
12022
* BIG NOTE: This is not intended for XPATH_OP_FILTER yet!
12023
*/
12024
12025
/*
12026
* If not -1, then ch1 will point to:
12027
* 1) For predicates (XPATH_OP_PREDICATE):
12028
* - an inner predicate operator
12029
* 2) For filters (XPATH_OP_FILTER):
12030
* - an inner filter operater OR
12031
* - an expression selecting the node set.
12032
* E.g. "key('a', 'b')" or "(//foo | //bar)".
12033
*/
12034
if ((op->op != XPATH_OP_PREDICATE) && (op->op != XPATH_OP_FILTER))
12035
return(0);
12036
12037
if (op->ch2 != -1) {
12038
exprOp = &ctxt->comp->steps[op->ch2];
12039
} else
12040
return(0);
12041
12042
if ((exprOp != NULL) &&
12043
(exprOp->op == XPATH_OP_VALUE) &&
12044
(exprOp->value4 != NULL) &&
12045
(((xmlXPathObjectPtr) exprOp->value4)->type == XPATH_NUMBER))
12046
{
12047
/*
12048
* We have a "[n]" predicate here.
12049
* TODO: Unfortunately this simplistic test here is not
12050
* able to detect a position() predicate in compound
12051
* expressions like "[@attr = 'a" and position() = 1],
12052
* and even not the usage of position() in
12053
* "[position() = 1]"; thus - obviously - a position-range,
12054
* like it "[position() < 5]", is also not detected.
12055
* Maybe we could rewrite the AST to ease the optimization.
12056
*/
12057
*maxPos = (int) ((xmlXPathObjectPtr) exprOp->value4)->floatval;
12058
12059
if (((xmlXPathObjectPtr) exprOp->value4)->floatval ==
12060
(float) *maxPos)
12061
{
12062
return(1);
12063
}
12064
}
12065
return(0);
12066
}
12067
12068
static int
12069
xmlXPathNodeCollectAndTest(xmlXPathParserContextPtr ctxt,
12070
xmlXPathStepOpPtr op,
12071
xmlNodePtr * first, xmlNodePtr * last,
12072
int toBool)
12073
{
12074
12075
#define XP_TEST_HIT \
12076
if (hasAxisRange != 0) { \
12077
if (++pos == maxPos) { \
12078
if (addNode(seq, cur) < 0) \
12079
ctxt->error = XPATH_MEMORY_ERROR; \
12080
goto axis_range_end; } \
12081
} else { \
12082
if (addNode(seq, cur) < 0) \
12083
ctxt->error = XPATH_MEMORY_ERROR; \
12084
if (breakOnFirstHit) goto first_hit; }
12085
12086
#define XP_TEST_HIT_NS \
12087
if (hasAxisRange != 0) { \
12088
if (++pos == maxPos) { \
12089
hasNsNodes = 1; \
12090
if (xmlXPathNodeSetAddNs(seq, xpctxt->node, (xmlNsPtr) cur) < 0) \
12091
ctxt->error = XPATH_MEMORY_ERROR; \
12092
goto axis_range_end; } \
12093
} else { \
12094
hasNsNodes = 1; \
12095
if (xmlXPathNodeSetAddNs(seq, xpctxt->node, (xmlNsPtr) cur) < 0) \
12096
ctxt->error = XPATH_MEMORY_ERROR; \
12097
if (breakOnFirstHit) goto first_hit; }
12098
12099
xmlXPathAxisVal axis = (xmlXPathAxisVal) op->value;
12100
xmlXPathTestVal test = (xmlXPathTestVal) op->value2;
12101
xmlXPathTypeVal type = (xmlXPathTypeVal) op->value3;
12102
const xmlChar *prefix = op->value4;
12103
const xmlChar *name = op->value5;
12104
const xmlChar *URI = NULL;
12105
12106
#ifdef DEBUG_STEP
12107
int nbMatches = 0, prevMatches = 0;
12108
#endif
12109
int total = 0, hasNsNodes = 0;
12110
/* The popped object holding the context nodes */
12111
xmlXPathObjectPtr obj;
12112
/* The set of context nodes for the node tests */
12113
xmlNodeSetPtr contextSeq;
12114
int contextIdx;
12115
xmlNodePtr contextNode;
12116
/* The final resulting node set wrt to all context nodes */
12117
xmlNodeSetPtr outSeq;
12118
/*
12119
* The temporary resulting node set wrt 1 context node.
12120
* Used to feed predicate evaluation.
12121
*/
12122
xmlNodeSetPtr seq;
12123
xmlNodePtr cur;
12124
/* First predicate operator */
12125
xmlXPathStepOpPtr predOp;
12126
int maxPos; /* The requested position() (when a "[n]" predicate) */
12127
int hasPredicateRange, hasAxisRange, pos, size, newSize;
12128
int breakOnFirstHit;
12129
12130
xmlXPathTraversalFunction next = NULL;
12131
int (*addNode) (xmlNodeSetPtr, xmlNodePtr);
12132
xmlXPathNodeSetMergeFunction mergeAndClear;
12133
xmlNodePtr oldContextNode;
12134
xmlXPathContextPtr xpctxt = ctxt->context;
12135
12136
12137
CHECK_TYPE0(XPATH_NODESET);
12138
obj = valuePop(ctxt);
12139
/*
12140
* Setup namespaces.
12141
*/
12142
if (prefix != NULL) {
12143
URI = xmlXPathNsLookup(xpctxt, prefix);
12144
if (URI == NULL) {
12145
xmlXPathReleaseObject(xpctxt, obj);
12146
XP_ERROR0(XPATH_UNDEF_PREFIX_ERROR);
12147
}
12148
}
12149
/*
12150
* Setup axis.
12151
*
12152
* MAYBE FUTURE TODO: merging optimizations:
12153
* - If the nodes to be traversed wrt to the initial nodes and
12154
* the current axis cannot overlap, then we could avoid searching
12155
* for duplicates during the merge.
12156
* But the question is how/when to evaluate if they cannot overlap.
12157
* Example: if we know that for two initial nodes, the one is
12158
* not in the ancestor-or-self axis of the other, then we could safely
12159
* avoid a duplicate-aware merge, if the axis to be traversed is e.g.
12160
* the descendant-or-self axis.
12161
*/
12162
mergeAndClear = xmlXPathNodeSetMergeAndClear;
12163
switch (axis) {
12164
case AXIS_ANCESTOR:
12165
first = NULL;
12166
next = xmlXPathNextAncestor;
12167
break;
12168
case AXIS_ANCESTOR_OR_SELF:
12169
first = NULL;
12170
next = xmlXPathNextAncestorOrSelf;
12171
break;
12172
case AXIS_ATTRIBUTE:
12173
first = NULL;
12174
last = NULL;
12175
next = xmlXPathNextAttribute;
12176
mergeAndClear = xmlXPathNodeSetMergeAndClearNoDupls;
12177
break;
12178
case AXIS_CHILD:
12179
last = NULL;
12180
if (((test == NODE_TEST_NAME) || (test == NODE_TEST_ALL)) &&
12181
(type == NODE_TYPE_NODE))
12182
{
12183
/*
12184
* Optimization if an element node type is 'element'.
12185
*/
12186
next = xmlXPathNextChildElement;
12187
} else
12188
next = xmlXPathNextChild;
12189
mergeAndClear = xmlXPathNodeSetMergeAndClearNoDupls;
12190
break;
12191
case AXIS_DESCENDANT:
12192
last = NULL;
12193
next = xmlXPathNextDescendant;
12194
break;
12195
case AXIS_DESCENDANT_OR_SELF:
12196
last = NULL;
12197
next = xmlXPathNextDescendantOrSelf;
12198
break;
12199
case AXIS_FOLLOWING:
12200
last = NULL;
12201
next = xmlXPathNextFollowing;
12202
break;
12203
case AXIS_FOLLOWING_SIBLING:
12204
last = NULL;
12205
next = xmlXPathNextFollowingSibling;
12206
break;
12207
case AXIS_NAMESPACE:
12208
first = NULL;
12209
last = NULL;
12210
next = (xmlXPathTraversalFunction) xmlXPathNextNamespace;
12211
mergeAndClear = xmlXPathNodeSetMergeAndClearNoDupls;
12212
break;
12213
case AXIS_PARENT:
12214
first = NULL;
12215
next = xmlXPathNextParent;
12216
break;
12217
case AXIS_PRECEDING:
12218
first = NULL;
12219
next = xmlXPathNextPrecedingInternal;
12220
break;
12221
case AXIS_PRECEDING_SIBLING:
12222
first = NULL;
12223
next = xmlXPathNextPrecedingSibling;
12224
break;
12225
case AXIS_SELF:
12226
first = NULL;
12227
last = NULL;
12228
next = xmlXPathNextSelf;
12229
mergeAndClear = xmlXPathNodeSetMergeAndClearNoDupls;
12230
break;
12231
}
12232
12233
#ifdef DEBUG_STEP
12234
xmlXPathDebugDumpStepAxis(op,
12235
(obj->nodesetval != NULL) ? obj->nodesetval->nodeNr : 0);
12236
#endif
12237
12238
if (next == NULL) {
12239
xmlXPathReleaseObject(xpctxt, obj);
12240
return(0);
12241
}
12242
contextSeq = obj->nodesetval;
12243
if ((contextSeq == NULL) || (contextSeq->nodeNr <= 0)) {
12244
xmlXPathReleaseObject(xpctxt, obj);
12245
valuePush(ctxt, xmlXPathCacheWrapNodeSet(xpctxt, NULL));
12246
return(0);
12247
}
12248
/*
12249
* Predicate optimization ---------------------------------------------
12250
* If this step has a last predicate, which contains a position(),
12251
* then we'll optimize (although not exactly "position()", but only
12252
* the short-hand form, i.e., "[n]".
12253
*
12254
* Example - expression "/foo[parent::bar][1]":
12255
*
12256
* COLLECT 'child' 'name' 'node' foo -- op (we are here)
12257
* ROOT -- op->ch1
12258
* PREDICATE -- op->ch2 (predOp)
12259
* PREDICATE -- predOp->ch1 = [parent::bar]
12260
* SORT
12261
* COLLECT 'parent' 'name' 'node' bar
12262
* NODE
12263
* ELEM Object is a number : 1 -- predOp->ch2 = [1]
12264
*
12265
*/
12266
maxPos = 0;
12267
predOp = NULL;
12268
hasPredicateRange = 0;
12269
hasAxisRange = 0;
12270
if (op->ch2 != -1) {
12271
/*
12272
* There's at least one predicate. 16 == XPATH_OP_PREDICATE
12273
*/
12274
predOp = &ctxt->comp->steps[op->ch2];
12275
if (xmlXPathIsPositionalPredicate(ctxt, predOp, &maxPos)) {
12276
if (predOp->ch1 != -1) {
12277
/*
12278
* Use the next inner predicate operator.
12279
*/
12280
predOp = &ctxt->comp->steps[predOp->ch1];
12281
hasPredicateRange = 1;
12282
} else {
12283
/*
12284
* There's no other predicate than the [n] predicate.
12285
*/
12286
predOp = NULL;
12287
hasAxisRange = 1;
12288
}
12289
}
12290
}
12291
breakOnFirstHit = ((toBool) && (predOp == NULL)) ? 1 : 0;
12292
/*
12293
* Axis traversal -----------------------------------------------------
12294
*/
12295
/*
12296
* 2.3 Node Tests
12297
* - For the attribute axis, the principal node type is attribute.
12298
* - For the namespace axis, the principal node type is namespace.
12299
* - For other axes, the principal node type is element.
12300
*
12301
* A node test * is true for any node of the
12302
* principal node type. For example, child::* will
12303
* select all element children of the context node
12304
*/
12305
oldContextNode = xpctxt->node;
12306
addNode = xmlXPathNodeSetAddUnique;
12307
outSeq = NULL;
12308
seq = NULL;
12309
contextNode = NULL;
12310
contextIdx = 0;
12311
12312
12313
while (((contextIdx < contextSeq->nodeNr) || (contextNode != NULL)) &&
12314
(ctxt->error == XPATH_EXPRESSION_OK)) {
12315
xpctxt->node = contextSeq->nodeTab[contextIdx++];
12316
12317
if (seq == NULL) {
12318
seq = xmlXPathNodeSetCreate(NULL);
12319
if (seq == NULL) {
12320
total = 0;
12321
goto error;
12322
}
12323
}
12324
/*
12325
* Traverse the axis and test the nodes.
12326
*/
12327
pos = 0;
12328
cur = NULL;
12329
hasNsNodes = 0;
12330
do {
12331
cur = next(ctxt, cur);
12332
if (cur == NULL)
12333
break;
12334
12335
/*
12336
* QUESTION TODO: What does the "first" and "last" stuff do?
12337
*/
12338
if ((first != NULL) && (*first != NULL)) {
12339
if (*first == cur)
12340
break;
12341
if (((total % 256) == 0) &&
12342
#ifdef XP_OPTIMIZED_NON_ELEM_COMPARISON
12343
(xmlXPathCmpNodesExt(*first, cur) >= 0))
12344
#else
12345
(xmlXPathCmpNodes(*first, cur) >= 0))
12346
#endif
12347
{
12348
break;
12349
}
12350
}
12351
if ((last != NULL) && (*last != NULL)) {
12352
if (*last == cur)
12353
break;
12354
if (((total % 256) == 0) &&
12355
#ifdef XP_OPTIMIZED_NON_ELEM_COMPARISON
12356
(xmlXPathCmpNodesExt(cur, *last) >= 0))
12357
#else
12358
(xmlXPathCmpNodes(cur, *last) >= 0))
12359
#endif
12360
{
12361
break;
12362
}
12363
}
12364
12365
total++;
12366
12367
#ifdef DEBUG_STEP
12368
xmlGenericError(xmlGenericErrorContext, " %s", cur->name);
12369
#endif
12370
12371
switch (test) {
12372
case NODE_TEST_NONE:
12373
total = 0;
12374
STRANGE
12375
goto error;
12376
case NODE_TEST_TYPE:
12377
/*
12378
* TODO: Don't we need to use
12379
* xmlXPathNodeSetAddNs() for namespace nodes here?
12380
* Surprisingly, some c14n tests fail, if we do this.
12381
*/
12382
if (type == NODE_TYPE_NODE) {
12383
switch (cur->type) {
12384
case XML_DOCUMENT_NODE:
12385
case XML_HTML_DOCUMENT_NODE:
12386
#ifdef LIBXML_DOCB_ENABLED
12387
case XML_DOCB_DOCUMENT_NODE:
12388
#endif
12389
case XML_ELEMENT_NODE:
12390
case XML_ATTRIBUTE_NODE:
12391
case XML_PI_NODE:
12392
case XML_COMMENT_NODE:
12393
case XML_CDATA_SECTION_NODE:
12394
case XML_TEXT_NODE:
12395
case XML_NAMESPACE_DECL:
12396
XP_TEST_HIT
12397
break;
12398
default:
12399
break;
12400
}
12401
} else if (cur->type == type) {
12402
if (cur->type == XML_NAMESPACE_DECL)
12403
XP_TEST_HIT_NS
12404
else
12405
XP_TEST_HIT
12406
} else if ((type == NODE_TYPE_TEXT) &&
12407
(cur->type == XML_CDATA_SECTION_NODE))
12408
{
12409
XP_TEST_HIT
12410
}
12411
break;
12412
case NODE_TEST_PI:
12413
if ((cur->type == XML_PI_NODE) &&
12414
((name == NULL) || xmlStrEqual(name, cur->name)))
12415
{
12416
XP_TEST_HIT
12417
}
12418
break;
12419
case NODE_TEST_ALL:
12420
if (axis == AXIS_ATTRIBUTE) {
12421
if (cur->type == XML_ATTRIBUTE_NODE)
12422
{
12423
XP_TEST_HIT
12424
}
12425
} else if (axis == AXIS_NAMESPACE) {
12426
if (cur->type == XML_NAMESPACE_DECL)
12427
{
12428
XP_TEST_HIT_NS
12429
}
12430
} else {
12431
if (cur->type == XML_ELEMENT_NODE) {
12432
if (prefix == NULL)
12433
{
12434
XP_TEST_HIT
12435
12436
} else if ((cur->ns != NULL) &&
12437
(xmlStrEqual(URI, cur->ns->href)))
12438
{
12439
XP_TEST_HIT
12440
}
12441
}
12442
}
12443
break;
12444
case NODE_TEST_NS:{
12445
TODO;
12446
break;
12447
}
12448
case NODE_TEST_NAME:
12449
if (axis == AXIS_ATTRIBUTE) {
12450
if (cur->type != XML_ATTRIBUTE_NODE)
12451
break;
12452
} else if (axis == AXIS_NAMESPACE) {
12453
if (cur->type != XML_NAMESPACE_DECL)
12454
break;
12455
} else {
12456
if (cur->type != XML_ELEMENT_NODE)
12457
break;
12458
}
12459
switch (cur->type) {
12460
case XML_ELEMENT_NODE:
12461
if (xmlStrEqual(name, cur->name)) {
12462
if (prefix == NULL) {
12463
if (cur->ns == NULL)
12464
{
12465
XP_TEST_HIT
12466
}
12467
} else {
12468
if ((cur->ns != NULL) &&
12469
(xmlStrEqual(URI, cur->ns->href)))
12470
{
12471
XP_TEST_HIT
12472
}
12473
}
12474
}
12475
break;
12476
case XML_ATTRIBUTE_NODE:{
12477
xmlAttrPtr attr = (xmlAttrPtr) cur;
12478
12479
if (xmlStrEqual(name, attr->name)) {
12480
if (prefix == NULL) {
12481
if ((attr->ns == NULL) ||
12482
(attr->ns->prefix == NULL))
12483
{
12484
XP_TEST_HIT
12485
}
12486
} else {
12487
if ((attr->ns != NULL) &&
12488
(xmlStrEqual(URI,
12489
attr->ns->href)))
12490
{
12491
XP_TEST_HIT
12492
}
12493
}
12494
}
12495
break;
12496
}
12497
case XML_NAMESPACE_DECL:
12498
if (cur->type == XML_NAMESPACE_DECL) {
12499
xmlNsPtr ns = (xmlNsPtr) cur;
12500
12501
if ((ns->prefix != NULL) && (name != NULL)
12502
&& (xmlStrEqual(ns->prefix, name)))
12503
{
12504
XP_TEST_HIT_NS
12505
}
12506
}
12507
break;
12508
default:
12509
break;
12510
}
12511
break;
12512
} /* switch(test) */
12513
} while ((cur != NULL) && (ctxt->error == XPATH_EXPRESSION_OK));
12514
12515
goto apply_predicates;
12516
12517
axis_range_end: /* ----------------------------------------------------- */
12518
/*
12519
* We have a "/foo[n]", and position() = n was reached.
12520
* Note that we can have as well "/foo/::parent::foo[1]", so
12521
* a duplicate-aware merge is still needed.
12522
* Merge with the result.
12523
*/
12524
if (outSeq == NULL) {
12525
outSeq = seq;
12526
seq = NULL;
12527
} else
12528
outSeq = mergeAndClear(outSeq, seq, 0);
12529
/*
12530
* Break if only a true/false result was requested.
12531
*/
12532
if (toBool)
12533
break;
12534
continue;
12535
12536
first_hit: /* ---------------------------------------------------------- */
12537
/*
12538
* Break if only a true/false result was requested and
12539
* no predicates existed and a node test succeeded.
12540
*/
12541
if (outSeq == NULL) {
12542
outSeq = seq;
12543
seq = NULL;
12544
} else
12545
outSeq = mergeAndClear(outSeq, seq, 0);
12546
break;
12547
12548
#ifdef DEBUG_STEP
12549
if (seq != NULL)
12550
nbMatches += seq->nodeNr;
12551
#endif
12552
12553
apply_predicates: /* --------------------------------------------------- */
12554
if (ctxt->error != XPATH_EXPRESSION_OK)
12555
goto error;
12556
12557
/*
12558
* Apply predicates.
12559
*/
12560
if ((predOp != NULL) && (seq->nodeNr > 0)) {
12561
/*
12562
* E.g. when we have a "/foo[some expression][n]".
12563
*/
12564
/*
12565
* QUESTION TODO: The old predicate evaluation took into
12566
* account location-sets.
12567
* (E.g. ctxt->value->type == XPATH_LOCATIONSET)
12568
* Do we expect such a set here?
12569
* All what I learned now from the evaluation semantics
12570
* does not indicate that a location-set will be processed
12571
* here, so this looks OK.
12572
*/
12573
/*
12574
* Iterate over all predicates, starting with the outermost
12575
* predicate.
12576
* TODO: Problem: we cannot execute the inner predicates first
12577
* since we cannot go back *up* the operator tree!
12578
* Options we have:
12579
* 1) Use of recursive functions (like is it currently done
12580
* via xmlXPathCompOpEval())
12581
* 2) Add a predicate evaluation information stack to the
12582
* context struct
12583
* 3) Change the way the operators are linked; we need a
12584
* "parent" field on xmlXPathStepOp
12585
*
12586
* For the moment, I'll try to solve this with a recursive
12587
* function: xmlXPathCompOpEvalPredicate().
12588
*/
12589
size = seq->nodeNr;
12590
if (hasPredicateRange != 0)
12591
newSize = xmlXPathCompOpEvalPositionalPredicate(ctxt,
12592
predOp, seq, size, maxPos, maxPos, hasNsNodes);
12593
else
12594
newSize = xmlXPathCompOpEvalPredicate(ctxt,
12595
predOp, seq, size, hasNsNodes);
12596
12597
if (ctxt->error != XPATH_EXPRESSION_OK) {
12598
total = 0;
12599
goto error;
12600
}
12601
/*
12602
* Add the filtered set of nodes to the result node set.
12603
*/
12604
if (newSize == 0) {
12605
/*
12606
* The predicates filtered all nodes out.
12607
*/
12608
xmlXPathNodeSetClear(seq, hasNsNodes);
12609
} else if (seq->nodeNr > 0) {
12610
/*
12611
* Add to result set.
12612
*/
12613
if (outSeq == NULL) {
12614
if (size != newSize) {
12615
/*
12616
* We need to merge and clear here, since
12617
* the sequence will contained NULLed entries.
12618
*/
12619
outSeq = mergeAndClear(NULL, seq, 1);
12620
} else {
12621
outSeq = seq;
12622
seq = NULL;
12623
}
12624
} else
12625
outSeq = mergeAndClear(outSeq, seq,
12626
(size != newSize) ? 1: 0);
12627
/*
12628
* Break if only a true/false result was requested.
12629
*/
12630
if (toBool)
12631
break;
12632
}
12633
} else if (seq->nodeNr > 0) {
12634
/*
12635
* Add to result set.
12636
*/
12637
if (outSeq == NULL) {
12638
outSeq = seq;
12639
seq = NULL;
12640
} else {
12641
outSeq = mergeAndClear(outSeq, seq, 0);
12642
}
12643
}
12644
}
12645
12646
error:
12647
if ((obj->boolval) && (obj->user != NULL)) {
12648
/*
12649
* QUESTION TODO: What does this do and why?
12650
* TODO: Do we have to do this also for the "error"
12651
* cleanup further down?
12652
*/
12653
ctxt->value->boolval = 1;
12654
ctxt->value->user = obj->user;
12655
obj->user = NULL;
12656
obj->boolval = 0;
12657
}
12658
xmlXPathReleaseObject(xpctxt, obj);
12659
12660
/*
12661
* Ensure we return at least an emtpy set.
12662
*/
12663
if (outSeq == NULL) {
12664
if ((seq != NULL) && (seq->nodeNr == 0))
12665
outSeq = seq;
12666
else
12667
outSeq = xmlXPathNodeSetCreate(NULL);
12668
/* XXX what if xmlXPathNodeSetCreate returned NULL here? */
12669
}
12670
if ((seq != NULL) && (seq != outSeq)) {
12671
xmlXPathFreeNodeSet(seq);
12672
}
12673
/*
12674
* Hand over the result. Better to push the set also in
12675
* case of errors.
12676
*/
12677
valuePush(ctxt, xmlXPathCacheWrapNodeSet(xpctxt, outSeq));
12678
/*
12679
* Reset the context node.
12680
*/
12681
xpctxt->node = oldContextNode;
12682
12683
#ifdef DEBUG_STEP
12684
xmlGenericError(xmlGenericErrorContext,
12685
"\nExamined %d nodes, found %d nodes at that step\n",
12686
total, nbMatches);
12687
#endif
12688
12689
return(total);
12690
}
12691
12692
static int
12693
xmlXPathCompOpEvalFilterFirst(xmlXPathParserContextPtr ctxt,
12694
xmlXPathStepOpPtr op, xmlNodePtr * first);
12695
12696
/**
12697
* xmlXPathCompOpEvalFirst:
12698
* @ctxt: the XPath parser context with the compiled expression
12699
* @op: an XPath compiled operation
12700
* @first: the first elem found so far
12701
*
12702
* Evaluate the Precompiled XPath operation searching only the first
12703
* element in document order
12704
*
12705
* Returns the number of examined objects.
12706
*/
12707
static int
12708
xmlXPathCompOpEvalFirst(xmlXPathParserContextPtr ctxt,
12709
xmlXPathStepOpPtr op, xmlNodePtr * first)
12710
{
12711
int total = 0, cur;
12712
xmlXPathCompExprPtr comp;
12713
xmlXPathObjectPtr arg1, arg2;
12714
12715
CHECK_ERROR0;
12716
comp = ctxt->comp;
12717
switch (op->op) {
12718
case XPATH_OP_END:
12719
return (0);
12720
case XPATH_OP_UNION:
12721
total =
12722
xmlXPathCompOpEvalFirst(ctxt, &comp->steps[op->ch1],
12723
first);
12724
CHECK_ERROR0;
12725
if ((ctxt->value != NULL)
12726
&& (ctxt->value->type == XPATH_NODESET)
12727
&& (ctxt->value->nodesetval != NULL)
12728
&& (ctxt->value->nodesetval->nodeNr >= 1)) {
12729
/*
12730
* limit tree traversing to first node in the result
12731
*/
12732
/*
12733
* OPTIMIZE TODO: This implicitely sorts
12734
* the result, even if not needed. E.g. if the argument
12735
* of the count() function, no sorting is needed.
12736
* OPTIMIZE TODO: How do we know if the node-list wasn't
12737
* aready sorted?
12738
*/
12739
if (ctxt->value->nodesetval->nodeNr > 1)
12740
xmlXPathNodeSetSort(ctxt->value->nodesetval);
12741
*first = ctxt->value->nodesetval->nodeTab[0];
12742
}
12743
cur =
12744
xmlXPathCompOpEvalFirst(ctxt, &comp->steps[op->ch2],
12745
first);
12746
CHECK_ERROR0;
12747
CHECK_TYPE0(XPATH_NODESET);
12748
arg2 = valuePop(ctxt);
12749
12750
CHECK_TYPE0(XPATH_NODESET);
12751
arg1 = valuePop(ctxt);
12752
12753
arg1->nodesetval = xmlXPathNodeSetMerge(arg1->nodesetval,
12754
arg2->nodesetval);
12755
valuePush(ctxt, arg1);
12756
xmlXPathReleaseObject(ctxt->context, arg2);
12757
/* optimizer */
12758
if (total > cur)
12759
xmlXPathCompSwap(op);
12760
return (total + cur);
12761
case XPATH_OP_ROOT:
12762
xmlXPathRoot(ctxt);
12763
return (0);
12764
case XPATH_OP_NODE:
12765
if (op->ch1 != -1)
12766
total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
12767
CHECK_ERROR0;
12768
if (op->ch2 != -1)
12769
total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
12770
CHECK_ERROR0;
12771
valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context,
12772
ctxt->context->node));
12773
return (total);
12774
case XPATH_OP_RESET:
12775
if (op->ch1 != -1)
12776
total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
12777
CHECK_ERROR0;
12778
if (op->ch2 != -1)
12779
total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
12780
CHECK_ERROR0;
12781
ctxt->context->node = NULL;
12782
return (total);
12783
case XPATH_OP_COLLECT:{
12784
if (op->ch1 == -1)
12785
return (total);
12786
12787
total = xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
12788
CHECK_ERROR0;
12789
12790
total += xmlXPathNodeCollectAndTest(ctxt, op, first, NULL, 0);
12791
return (total);
12792
}
12793
case XPATH_OP_VALUE:
12794
valuePush(ctxt,
12795
xmlXPathCacheObjectCopy(ctxt->context,
12796
(xmlXPathObjectPtr) op->value4));
12797
return (0);
12798
case XPATH_OP_SORT:
12799
if (op->ch1 != -1)
12800
total +=
12801
xmlXPathCompOpEvalFirst(ctxt, &comp->steps[op->ch1],
12802
first);
12803
CHECK_ERROR0;
12804
if ((ctxt->value != NULL)
12805
&& (ctxt->value->type == XPATH_NODESET)
12806
&& (ctxt->value->nodesetval != NULL)
12807
&& (ctxt->value->nodesetval->nodeNr > 1))
12808
xmlXPathNodeSetSort(ctxt->value->nodesetval);
12809
return (total);
12810
#ifdef XP_OPTIMIZED_FILTER_FIRST
12811
case XPATH_OP_FILTER:
12812
total += xmlXPathCompOpEvalFilterFirst(ctxt, op, first);
12813
return (total);
12814
#endif
12815
default:
12816
return (xmlXPathCompOpEval(ctxt, op));
12817
}
12818
}
12819
12820
/**
12821
* xmlXPathCompOpEvalLast:
12822
* @ctxt: the XPath parser context with the compiled expression
12823
* @op: an XPath compiled operation
12824
* @last: the last elem found so far
12825
*
12826
* Evaluate the Precompiled XPath operation searching only the last
12827
* element in document order
12828
*
12829
* Returns the number of nodes traversed
12830
*/
12831
static int
12832
xmlXPathCompOpEvalLast(xmlXPathParserContextPtr ctxt, xmlXPathStepOpPtr op,
12833
xmlNodePtr * last)
12834
{
12835
int total = 0, cur;
12836
xmlXPathCompExprPtr comp;
12837
xmlXPathObjectPtr arg1, arg2;
12838
xmlNodePtr bak;
12839
xmlDocPtr bakd;
12840
int pp;
12841
int cs;
12842
12843
CHECK_ERROR0;
12844
comp = ctxt->comp;
12845
switch (op->op) {
12846
case XPATH_OP_END:
12847
return (0);
12848
case XPATH_OP_UNION:
12849
bakd = ctxt->context->doc;
12850
bak = ctxt->context->node;
12851
pp = ctxt->context->proximityPosition;
12852
cs = ctxt->context->contextSize;
12853
total =
12854
xmlXPathCompOpEvalLast(ctxt, &comp->steps[op->ch1], last);
12855
CHECK_ERROR0;
12856
if ((ctxt->value != NULL)
12857
&& (ctxt->value->type == XPATH_NODESET)
12858
&& (ctxt->value->nodesetval != NULL)
12859
&& (ctxt->value->nodesetval->nodeNr >= 1)) {
12860
/*
12861
* limit tree traversing to first node in the result
12862
*/
12863
if (ctxt->value->nodesetval->nodeNr > 1)
12864
xmlXPathNodeSetSort(ctxt->value->nodesetval);
12865
*last =
12866
ctxt->value->nodesetval->nodeTab[ctxt->value->
12867
nodesetval->nodeNr -
12868
1];
12869
}
12870
ctxt->context->doc = bakd;
12871
ctxt->context->node = bak;
12872
ctxt->context->proximityPosition = pp;
12873
ctxt->context->contextSize = cs;
12874
cur =
12875
xmlXPathCompOpEvalLast(ctxt, &comp->steps[op->ch2], last);
12876
CHECK_ERROR0;
12877
if ((ctxt->value != NULL)
12878
&& (ctxt->value->type == XPATH_NODESET)
12879
&& (ctxt->value->nodesetval != NULL)
12880
&& (ctxt->value->nodesetval->nodeNr >= 1)) { /* TODO: NOP ? */
12881
}
12882
CHECK_TYPE0(XPATH_NODESET);
12883
arg2 = valuePop(ctxt);
12884
12885
CHECK_TYPE0(XPATH_NODESET);
12886
arg1 = valuePop(ctxt);
12887
12888
arg1->nodesetval = xmlXPathNodeSetMerge(arg1->nodesetval,
12889
arg2->nodesetval);
12890
valuePush(ctxt, arg1);
12891
xmlXPathReleaseObject(ctxt->context, arg2);
12892
/* optimizer */
12893
if (total > cur)
12894
xmlXPathCompSwap(op);
12895
return (total + cur);
12896
case XPATH_OP_ROOT:
12897
xmlXPathRoot(ctxt);
12898
return (0);
12899
case XPATH_OP_NODE:
12900
if (op->ch1 != -1)
12901
total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
12902
CHECK_ERROR0;
12903
if (op->ch2 != -1)
12904
total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
12905
CHECK_ERROR0;
12906
valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context,
12907
ctxt->context->node));
12908
return (total);
12909
case XPATH_OP_RESET:
12910
if (op->ch1 != -1)
12911
total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
12912
CHECK_ERROR0;
12913
if (op->ch2 != -1)
12914
total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
12915
CHECK_ERROR0;
12916
ctxt->context->node = NULL;
12917
return (total);
12918
case XPATH_OP_COLLECT:{
12919
if (op->ch1 == -1)
12920
return (0);
12921
12922
total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
12923
CHECK_ERROR0;
12924
12925
total += xmlXPathNodeCollectAndTest(ctxt, op, NULL, last, 0);
12926
return (total);
12927
}
12928
case XPATH_OP_VALUE:
12929
valuePush(ctxt,
12930
xmlXPathCacheObjectCopy(ctxt->context,
12931
(xmlXPathObjectPtr) op->value4));
12932
return (0);
12933
case XPATH_OP_SORT:
12934
if (op->ch1 != -1)
12935
total +=
12936
xmlXPathCompOpEvalLast(ctxt, &comp->steps[op->ch1],
12937
last);
12938
CHECK_ERROR0;
12939
if ((ctxt->value != NULL)
12940
&& (ctxt->value->type == XPATH_NODESET)
12941
&& (ctxt->value->nodesetval != NULL)
12942
&& (ctxt->value->nodesetval->nodeNr > 1))
12943
xmlXPathNodeSetSort(ctxt->value->nodesetval);
12944
return (total);
12945
default:
12946
return (xmlXPathCompOpEval(ctxt, op));
12947
}
12948
}
12949
12950
#ifdef XP_OPTIMIZED_FILTER_FIRST
12951
static int
12952
xmlXPathCompOpEvalFilterFirst(xmlXPathParserContextPtr ctxt,
12953
xmlXPathStepOpPtr op, xmlNodePtr * first)
12954
{
12955
int total = 0;
12956
xmlXPathCompExprPtr comp;
12957
xmlXPathObjectPtr res;
12958
xmlXPathObjectPtr obj;
12959
xmlNodeSetPtr oldset;
12960
xmlNodePtr oldnode;
12961
xmlDocPtr oldDoc;
12962
int i;
12963
12964
CHECK_ERROR0;
12965
comp = ctxt->comp;
12966
/*
12967
* Optimization for ()[last()] selection i.e. the last elem
12968
*/
12969
if ((op->ch1 != -1) && (op->ch2 != -1) &&
12970
(comp->steps[op->ch1].op == XPATH_OP_SORT) &&
12971
(comp->steps[op->ch2].op == XPATH_OP_SORT)) {
12972
int f = comp->steps[op->ch2].ch1;
12973
12974
if ((f != -1) &&
12975
(comp->steps[f].op == XPATH_OP_FUNCTION) &&
12976
(comp->steps[f].value5 == NULL) &&
12977
(comp->steps[f].value == 0) &&
12978
(comp->steps[f].value4 != NULL) &&
12979
(xmlStrEqual
12980
(comp->steps[f].value4, BAD_CAST "last"))) {
12981
xmlNodePtr last = NULL;
12982
12983
total +=
12984
xmlXPathCompOpEvalLast(ctxt,
12985
&comp->steps[op->ch1],
12986
&last);
12987
CHECK_ERROR0;
12988
/*
12989
* The nodeset should be in document order,
12990
* Keep only the last value
12991
*/
12992
if ((ctxt->value != NULL) &&
12993
(ctxt->value->type == XPATH_NODESET) &&
12994
(ctxt->value->nodesetval != NULL) &&
12995
(ctxt->value->nodesetval->nodeTab != NULL) &&
12996
(ctxt->value->nodesetval->nodeNr > 1)) {
12997
ctxt->value->nodesetval->nodeTab[0] =
12998
ctxt->value->nodesetval->nodeTab[ctxt->
12999
value->
13000
nodesetval->
13001
nodeNr -
13002
1];
13003
ctxt->value->nodesetval->nodeNr = 1;
13004
*first = *(ctxt->value->nodesetval->nodeTab);
13005
}
13006
return (total);
13007
}
13008
}
13009
13010
if (op->ch1 != -1)
13011
total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13012
CHECK_ERROR0;
13013
if (op->ch2 == -1)
13014
return (total);
13015
if (ctxt->value == NULL)
13016
return (total);
13017
13018
#ifdef LIBXML_XPTR_ENABLED
13019
oldnode = ctxt->context->node;
13020
/*
13021
* Hum are we filtering the result of an XPointer expression
13022
*/
13023
if (ctxt->value->type == XPATH_LOCATIONSET) {
13024
xmlXPathObjectPtr tmp = NULL;
13025
xmlLocationSetPtr newlocset = NULL;
13026
xmlLocationSetPtr oldlocset;
13027
13028
/*
13029
* Extract the old locset, and then evaluate the result of the
13030
* expression for all the element in the locset. use it to grow
13031
* up a new locset.
13032
*/
13033
CHECK_TYPE0(XPATH_LOCATIONSET);
13034
obj = valuePop(ctxt);
13035
oldlocset = obj->user;
13036
ctxt->context->node = NULL;
13037
13038
if ((oldlocset == NULL) || (oldlocset->locNr == 0)) {
13039
ctxt->context->contextSize = 0;
13040
ctxt->context->proximityPosition = 0;
13041
if (op->ch2 != -1)
13042
total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13043
res = valuePop(ctxt);
13044
if (res != NULL) {
13045
xmlXPathReleaseObject(ctxt->context, res);
13046
}
13047
valuePush(ctxt, obj);
13048
CHECK_ERROR0;
13049
return (total);
13050
}
13051
newlocset = xmlXPtrLocationSetCreate(NULL);
13052
13053
for (i = 0; i < oldlocset->locNr; i++) {
13054
/*
13055
* Run the evaluation with a node list made of a
13056
* single item in the nodelocset.
13057
*/
13058
ctxt->context->node = oldlocset->locTab[i]->user;
13059
ctxt->context->contextSize = oldlocset->locNr;
13060
ctxt->context->proximityPosition = i + 1;
13061
if (tmp == NULL) {
13062
tmp = xmlXPathCacheNewNodeSet(ctxt->context,
13063
ctxt->context->node);
13064
} else {
13065
if (xmlXPathNodeSetAddUnique(tmp->nodesetval,
13066
ctxt->context->node) < 0) {
13067
ctxt->error = XPATH_MEMORY_ERROR;
13068
}
13069
}
13070
valuePush(ctxt, tmp);
13071
if (op->ch2 != -1)
13072
total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13073
if (ctxt->error != XPATH_EXPRESSION_OK) {
13074
xmlXPathFreeObject(obj);
13075
return(0);
13076
}
13077
/*
13078
* The result of the evaluation need to be tested to
13079
* decided whether the filter succeeded or not
13080
*/
13081
res = valuePop(ctxt);
13082
if (xmlXPathEvaluatePredicateResult(ctxt, res)) {
13083
xmlXPtrLocationSetAdd(newlocset,
13084
xmlXPathCacheObjectCopy(ctxt->context,
13085
oldlocset->locTab[i]));
13086
}
13087
/*
13088
* Cleanup
13089
*/
13090
if (res != NULL) {
13091
xmlXPathReleaseObject(ctxt->context, res);
13092
}
13093
if (ctxt->value == tmp) {
13094
valuePop(ctxt);
13095
xmlXPathNodeSetClear(tmp->nodesetval, 1);
13096
/*
13097
* REVISIT TODO: Don't create a temporary nodeset
13098
* for everly iteration.
13099
*/
13100
/* OLD: xmlXPathFreeObject(res); */
13101
} else
13102
tmp = NULL;
13103
ctxt->context->node = NULL;
13104
/*
13105
* Only put the first node in the result, then leave.
13106
*/
13107
if (newlocset->locNr > 0) {
13108
*first = (xmlNodePtr) oldlocset->locTab[i]->user;
13109
break;
13110
}
13111
}
13112
if (tmp != NULL) {
13113
xmlXPathReleaseObject(ctxt->context, tmp);
13114
}
13115
/*
13116
* The result is used as the new evaluation locset.
13117
*/
13118
xmlXPathReleaseObject(ctxt->context, obj);
13119
ctxt->context->node = NULL;
13120
ctxt->context->contextSize = -1;
13121
ctxt->context->proximityPosition = -1;
13122
valuePush(ctxt, xmlXPtrWrapLocationSet(newlocset));
13123
ctxt->context->node = oldnode;
13124
return (total);
13125
}
13126
#endif /* LIBXML_XPTR_ENABLED */
13127
13128
/*
13129
* Extract the old set, and then evaluate the result of the
13130
* expression for all the element in the set. use it to grow
13131
* up a new set.
13132
*/
13133
CHECK_TYPE0(XPATH_NODESET);
13134
obj = valuePop(ctxt);
13135
oldset = obj->nodesetval;
13136
13137
oldnode = ctxt->context->node;
13138
oldDoc = ctxt->context->doc;
13139
ctxt->context->node = NULL;
13140
13141
if ((oldset == NULL) || (oldset->nodeNr == 0)) {
13142
ctxt->context->contextSize = 0;
13143
ctxt->context->proximityPosition = 0;
13144
/* QUESTION TODO: Why was this code commented out?
13145
if (op->ch2 != -1)
13146
total +=
13147
xmlXPathCompOpEval(ctxt,
13148
&comp->steps[op->ch2]);
13149
CHECK_ERROR0;
13150
res = valuePop(ctxt);
13151
if (res != NULL)
13152
xmlXPathFreeObject(res);
13153
*/
13154
valuePush(ctxt, obj);
13155
ctxt->context->node = oldnode;
13156
CHECK_ERROR0;
13157
} else {
13158
xmlNodeSetPtr newset;
13159
xmlXPathObjectPtr tmp = NULL;
13160
/*
13161
* Initialize the new set.
13162
* Also set the xpath document in case things like
13163
* key() evaluation are attempted on the predicate
13164
*/
13165
newset = xmlXPathNodeSetCreate(NULL);
13166
/* XXX what if xmlXPathNodeSetCreate returned NULL? */
13167
13168
for (i = 0; i < oldset->nodeNr; i++) {
13169
/*
13170
* Run the evaluation with a node list made of
13171
* a single item in the nodeset.
13172
*/
13173
ctxt->context->node = oldset->nodeTab[i];
13174
if ((oldset->nodeTab[i]->type != XML_NAMESPACE_DECL) &&
13175
(oldset->nodeTab[i]->doc != NULL))
13176
ctxt->context->doc = oldset->nodeTab[i]->doc;
13177
if (tmp == NULL) {
13178
tmp = xmlXPathCacheNewNodeSet(ctxt->context,
13179
ctxt->context->node);
13180
} else {
13181
if (xmlXPathNodeSetAddUnique(tmp->nodesetval,
13182
ctxt->context->node) < 0) {
13183
ctxt->error = XPATH_MEMORY_ERROR;
13184
}
13185
}
13186
valuePush(ctxt, tmp);
13187
ctxt->context->contextSize = oldset->nodeNr;
13188
ctxt->context->proximityPosition = i + 1;
13189
if (op->ch2 != -1)
13190
total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13191
if (ctxt->error != XPATH_EXPRESSION_OK) {
13192
xmlXPathFreeNodeSet(newset);
13193
xmlXPathFreeObject(obj);
13194
return(0);
13195
}
13196
/*
13197
* The result of the evaluation needs to be tested to
13198
* decide whether the filter succeeded or not
13199
*/
13200
res = valuePop(ctxt);
13201
if (xmlXPathEvaluatePredicateResult(ctxt, res)) {
13202
if (xmlXPathNodeSetAdd(newset, oldset->nodeTab[i]) < 0)
13203
ctxt->error = XPATH_MEMORY_ERROR;
13204
}
13205
/*
13206
* Cleanup
13207
*/
13208
if (res != NULL) {
13209
xmlXPathReleaseObject(ctxt->context, res);
13210
}
13211
if (ctxt->value == tmp) {
13212
valuePop(ctxt);
13213
/*
13214
* Don't free the temporary nodeset
13215
* in order to avoid massive recreation inside this
13216
* loop.
13217
*/
13218
xmlXPathNodeSetClear(tmp->nodesetval, 1);
13219
} else
13220
tmp = NULL;
13221
ctxt->context->node = NULL;
13222
/*
13223
* Only put the first node in the result, then leave.
13224
*/
13225
if (newset->nodeNr > 0) {
13226
*first = *(newset->nodeTab);
13227
break;
13228
}
13229
}
13230
if (tmp != NULL) {
13231
xmlXPathReleaseObject(ctxt->context, tmp);
13232
}
13233
/*
13234
* The result is used as the new evaluation set.
13235
*/
13236
xmlXPathReleaseObject(ctxt->context, obj);
13237
ctxt->context->node = NULL;
13238
ctxt->context->contextSize = -1;
13239
ctxt->context->proximityPosition = -1;
13240
/* may want to move this past the '}' later */
13241
ctxt->context->doc = oldDoc;
13242
valuePush(ctxt, xmlXPathCacheWrapNodeSet(ctxt->context, newset));
13243
}
13244
ctxt->context->node = oldnode;
13245
return(total);
13246
}
13247
#endif /* XP_OPTIMIZED_FILTER_FIRST */
13248
13249
/**
13250
* xmlXPathCompOpEval:
13251
* @ctxt: the XPath parser context with the compiled expression
13252
* @op: an XPath compiled operation
13253
*
13254
* Evaluate the Precompiled XPath operation
13255
* Returns the number of nodes traversed
13256
*/
13257
static int
13258
xmlXPathCompOpEval(xmlXPathParserContextPtr ctxt, xmlXPathStepOpPtr op)
13259
{
13260
int total = 0;
13261
int equal, ret;
13262
xmlXPathCompExprPtr comp;
13263
xmlXPathObjectPtr arg1, arg2;
13264
xmlNodePtr bak;
13265
xmlDocPtr bakd;
13266
int pp;
13267
int cs;
13268
13269
CHECK_ERROR0;
13270
comp = ctxt->comp;
13271
switch (op->op) {
13272
case XPATH_OP_END:
13273
return (0);
13274
case XPATH_OP_AND:
13275
bakd = ctxt->context->doc;
13276
bak = ctxt->context->node;
13277
pp = ctxt->context->proximityPosition;
13278
cs = ctxt->context->contextSize;
13279
total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13280
CHECK_ERROR0;
13281
xmlXPathBooleanFunction(ctxt, 1);
13282
if ((ctxt->value == NULL) || (ctxt->value->boolval == 0))
13283
return (total);
13284
arg2 = valuePop(ctxt);
13285
ctxt->context->doc = bakd;
13286
ctxt->context->node = bak;
13287
ctxt->context->proximityPosition = pp;
13288
ctxt->context->contextSize = cs;
13289
total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13290
if (ctxt->error) {
13291
xmlXPathFreeObject(arg2);
13292
return(0);
13293
}
13294
xmlXPathBooleanFunction(ctxt, 1);
13295
arg1 = valuePop(ctxt);
13296
arg1->boolval &= arg2->boolval;
13297
valuePush(ctxt, arg1);
13298
xmlXPathReleaseObject(ctxt->context, arg2);
13299
return (total);
13300
case XPATH_OP_OR:
13301
bakd = ctxt->context->doc;
13302
bak = ctxt->context->node;
13303
pp = ctxt->context->proximityPosition;
13304
cs = ctxt->context->contextSize;
13305
total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13306
CHECK_ERROR0;
13307
xmlXPathBooleanFunction(ctxt, 1);
13308
if ((ctxt->value == NULL) || (ctxt->value->boolval == 1))
13309
return (total);
13310
arg2 = valuePop(ctxt);
13311
ctxt->context->doc = bakd;
13312
ctxt->context->node = bak;
13313
ctxt->context->proximityPosition = pp;
13314
ctxt->context->contextSize = cs;
13315
total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13316
if (ctxt->error) {
13317
xmlXPathFreeObject(arg2);
13318
return(0);
13319
}
13320
xmlXPathBooleanFunction(ctxt, 1);
13321
arg1 = valuePop(ctxt);
13322
arg1->boolval |= arg2->boolval;
13323
valuePush(ctxt, arg1);
13324
xmlXPathReleaseObject(ctxt->context, arg2);
13325
return (total);
13326
case XPATH_OP_EQUAL:
13327
bakd = ctxt->context->doc;
13328
bak = ctxt->context->node;
13329
pp = ctxt->context->proximityPosition;
13330
cs = ctxt->context->contextSize;
13331
total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13332
CHECK_ERROR0;
13333
ctxt->context->doc = bakd;
13334
ctxt->context->node = bak;
13335
ctxt->context->proximityPosition = pp;
13336
ctxt->context->contextSize = cs;
13337
total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13338
CHECK_ERROR0;
13339
if (op->value)
13340
equal = xmlXPathEqualValues(ctxt);
13341
else
13342
equal = xmlXPathNotEqualValues(ctxt);
13343
valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, equal));
13344
return (total);
13345
case XPATH_OP_CMP:
13346
bakd = ctxt->context->doc;
13347
bak = ctxt->context->node;
13348
pp = ctxt->context->proximityPosition;
13349
cs = ctxt->context->contextSize;
13350
total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13351
CHECK_ERROR0;
13352
ctxt->context->doc = bakd;
13353
ctxt->context->node = bak;
13354
ctxt->context->proximityPosition = pp;
13355
ctxt->context->contextSize = cs;
13356
total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13357
CHECK_ERROR0;
13358
ret = xmlXPathCompareValues(ctxt, op->value, op->value2);
13359
valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, ret));
13360
return (total);
13361
case XPATH_OP_PLUS:
13362
bakd = ctxt->context->doc;
13363
bak = ctxt->context->node;
13364
pp = ctxt->context->proximityPosition;
13365
cs = ctxt->context->contextSize;
13366
total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13367
CHECK_ERROR0;
13368
if (op->ch2 != -1) {
13369
ctxt->context->doc = bakd;
13370
ctxt->context->node = bak;
13371
ctxt->context->proximityPosition = pp;
13372
ctxt->context->contextSize = cs;
13373
total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13374
}
13375
CHECK_ERROR0;
13376
if (op->value == 0)
13377
xmlXPathSubValues(ctxt);
13378
else if (op->value == 1)
13379
xmlXPathAddValues(ctxt);
13380
else if (op->value == 2)
13381
xmlXPathValueFlipSign(ctxt);
13382
else if (op->value == 3) {
13383
CAST_TO_NUMBER;
13384
CHECK_TYPE0(XPATH_NUMBER);
13385
}
13386
return (total);
13387
case XPATH_OP_MULT:
13388
bakd = ctxt->context->doc;
13389
bak = ctxt->context->node;
13390
pp = ctxt->context->proximityPosition;
13391
cs = ctxt->context->contextSize;
13392
total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13393
CHECK_ERROR0;
13394
ctxt->context->doc = bakd;
13395
ctxt->context->node = bak;
13396
ctxt->context->proximityPosition = pp;
13397
ctxt->context->contextSize = cs;
13398
total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13399
CHECK_ERROR0;
13400
if (op->value == 0)
13401
xmlXPathMultValues(ctxt);
13402
else if (op->value == 1)
13403
xmlXPathDivValues(ctxt);
13404
else if (op->value == 2)
13405
xmlXPathModValues(ctxt);
13406
return (total);
13407
case XPATH_OP_UNION:
13408
bakd = ctxt->context->doc;
13409
bak = ctxt->context->node;
13410
pp = ctxt->context->proximityPosition;
13411
cs = ctxt->context->contextSize;
13412
total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13413
CHECK_ERROR0;
13414
ctxt->context->doc = bakd;
13415
ctxt->context->node = bak;
13416
ctxt->context->proximityPosition = pp;
13417
ctxt->context->contextSize = cs;
13418
total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13419
CHECK_ERROR0;
13420
CHECK_TYPE0(XPATH_NODESET);
13421
arg2 = valuePop(ctxt);
13422
13423
CHECK_TYPE0(XPATH_NODESET);
13424
arg1 = valuePop(ctxt);
13425
13426
if ((arg1->nodesetval == NULL) ||
13427
((arg2->nodesetval != NULL) &&
13428
(arg2->nodesetval->nodeNr != 0)))
13429
{
13430
arg1->nodesetval = xmlXPathNodeSetMerge(arg1->nodesetval,
13431
arg2->nodesetval);
13432
}
13433
13434
valuePush(ctxt, arg1);
13435
xmlXPathReleaseObject(ctxt->context, arg2);
13436
return (total);
13437
case XPATH_OP_ROOT:
13438
xmlXPathRoot(ctxt);
13439
return (total);
13440
case XPATH_OP_NODE:
13441
if (op->ch1 != -1)
13442
total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13443
CHECK_ERROR0;
13444
if (op->ch2 != -1)
13445
total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13446
CHECK_ERROR0;
13447
valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context,
13448
ctxt->context->node));
13449
return (total);
13450
case XPATH_OP_RESET:
13451
if (op->ch1 != -1)
13452
total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13453
CHECK_ERROR0;
13454
if (op->ch2 != -1)
13455
total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13456
CHECK_ERROR0;
13457
ctxt->context->node = NULL;
13458
return (total);
13459
case XPATH_OP_COLLECT:{
13460
if (op->ch1 == -1)
13461
return (total);
13462
13463
total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13464
CHECK_ERROR0;
13465
13466
total += xmlXPathNodeCollectAndTest(ctxt, op, NULL, NULL, 0);
13467
return (total);
13468
}
13469
case XPATH_OP_VALUE:
13470
valuePush(ctxt,
13471
xmlXPathCacheObjectCopy(ctxt->context,
13472
(xmlXPathObjectPtr) op->value4));
13473
return (total);
13474
case XPATH_OP_VARIABLE:{
13475
xmlXPathObjectPtr val;
13476
13477
if (op->ch1 != -1)
13478
total +=
13479
xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13480
if (op->value5 == NULL) {
13481
val = xmlXPathVariableLookup(ctxt->context, op->value4);
13482
if (val == NULL) {
13483
ctxt->error = XPATH_UNDEF_VARIABLE_ERROR;
13484
return(0);
13485
}
13486
valuePush(ctxt, val);
13487
} else {
13488
const xmlChar *URI;
13489
13490
URI = xmlXPathNsLookup(ctxt->context, op->value5);
13491
if (URI == NULL) {
13492
xmlGenericError(xmlGenericErrorContext,
13493
"xmlXPathCompOpEval: variable %s bound to undefined prefix %s\n",
13494
(char *) op->value4, (char *)op->value5);
13495
ctxt->error = XPATH_UNDEF_PREFIX_ERROR;
13496
return (total);
13497
}
13498
val = xmlXPathVariableLookupNS(ctxt->context,
13499
op->value4, URI);
13500
if (val == NULL) {
13501
ctxt->error = XPATH_UNDEF_VARIABLE_ERROR;
13502
return(0);
13503
}
13504
valuePush(ctxt, val);
13505
}
13506
return (total);
13507
}
13508
case XPATH_OP_FUNCTION:{
13509
xmlXPathFunction func;
13510
const xmlChar *oldFunc, *oldFuncURI;
13511
int i;
13512
int frame;
13513
13514
frame = xmlXPathSetFrame(ctxt);
13515
if (op->ch1 != -1)
13516
total +=
13517
xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13518
if (ctxt->valueNr < op->value) {
13519
xmlGenericError(xmlGenericErrorContext,
13520
"xmlXPathCompOpEval: parameter error\n");
13521
ctxt->error = XPATH_INVALID_OPERAND;
13522
xmlXPathPopFrame(ctxt, frame);
13523
return (total);
13524
}
13525
for (i = 0; i < op->value; i++) {
13526
if (ctxt->valueTab[(ctxt->valueNr - 1) - i] == NULL) {
13527
xmlGenericError(xmlGenericErrorContext,
13528
"xmlXPathCompOpEval: parameter error\n");
13529
ctxt->error = XPATH_INVALID_OPERAND;
13530
xmlXPathPopFrame(ctxt, frame);
13531
return (total);
13532
}
13533
}
13534
if (op->cache != NULL)
13535
XML_CAST_FPTR(func) = op->cache;
13536
else {
13537
const xmlChar *URI = NULL;
13538
13539
if (op->value5 == NULL)
13540
func =
13541
xmlXPathFunctionLookup(ctxt->context,
13542
op->value4);
13543
else {
13544
URI = xmlXPathNsLookup(ctxt->context, op->value5);
13545
if (URI == NULL) {
13546
xmlGenericError(xmlGenericErrorContext,
13547
"xmlXPathCompOpEval: function %s bound to undefined prefix %s\n",
13548
(char *)op->value4, (char *)op->value5);
13549
xmlXPathPopFrame(ctxt, frame);
13550
ctxt->error = XPATH_UNDEF_PREFIX_ERROR;
13551
return (total);
13552
}
13553
func = xmlXPathFunctionLookupNS(ctxt->context,
13554
op->value4, URI);
13555
}
13556
if (func == NULL) {
13557
xmlGenericError(xmlGenericErrorContext,
13558
"xmlXPathCompOpEval: function %s not found\n",
13559
(char *)op->value4);
13560
XP_ERROR0(XPATH_UNKNOWN_FUNC_ERROR);
13561
}
13562
op->cache = XML_CAST_FPTR(func);
13563
op->cacheURI = (void *) URI;
13564
}
13565
oldFunc = ctxt->context->function;
13566
oldFuncURI = ctxt->context->functionURI;
13567
ctxt->context->function = op->value4;
13568
ctxt->context->functionURI = op->cacheURI;
13569
func(ctxt, op->value);
13570
ctxt->context->function = oldFunc;
13571
ctxt->context->functionURI = oldFuncURI;
13572
xmlXPathPopFrame(ctxt, frame);
13573
return (total);
13574
}
13575
case XPATH_OP_ARG:
13576
bakd = ctxt->context->doc;
13577
bak = ctxt->context->node;
13578
pp = ctxt->context->proximityPosition;
13579
cs = ctxt->context->contextSize;
13580
if (op->ch1 != -1)
13581
total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13582
ctxt->context->contextSize = cs;
13583
ctxt->context->proximityPosition = pp;
13584
ctxt->context->node = bak;
13585
ctxt->context->doc = bakd;
13586
CHECK_ERROR0;
13587
if (op->ch2 != -1) {
13588
total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13589
ctxt->context->doc = bakd;
13590
ctxt->context->node = bak;
13591
CHECK_ERROR0;
13592
}
13593
return (total);
13594
case XPATH_OP_PREDICATE:
13595
case XPATH_OP_FILTER:{
13596
xmlXPathObjectPtr res;
13597
xmlXPathObjectPtr obj, tmp;
13598
xmlNodeSetPtr newset = NULL;
13599
xmlNodeSetPtr oldset;
13600
xmlNodePtr oldnode;
13601
xmlDocPtr oldDoc;
13602
int i;
13603
13604
/*
13605
* Optimization for ()[1] selection i.e. the first elem
13606
*/
13607
if ((op->ch1 != -1) && (op->ch2 != -1) &&
13608
#ifdef XP_OPTIMIZED_FILTER_FIRST
13609
/*
13610
* FILTER TODO: Can we assume that the inner processing
13611
* will result in an ordered list if we have an
13612
* XPATH_OP_FILTER?
13613
* What about an additional field or flag on
13614
* xmlXPathObject like @sorted ? This way we wouln'd need
13615
* to assume anything, so it would be more robust and
13616
* easier to optimize.
13617
*/
13618
((comp->steps[op->ch1].op == XPATH_OP_SORT) || /* 18 */
13619
(comp->steps[op->ch1].op == XPATH_OP_FILTER)) && /* 17 */
13620
#else
13621
(comp->steps[op->ch1].op == XPATH_OP_SORT) &&
13622
#endif
13623
(comp->steps[op->ch2].op == XPATH_OP_VALUE)) { /* 12 */
13624
xmlXPathObjectPtr val;
13625
13626
val = comp->steps[op->ch2].value4;
13627
if ((val != NULL) && (val->type == XPATH_NUMBER) &&
13628
(val->floatval == 1.0)) {
13629
xmlNodePtr first = NULL;
13630
13631
total +=
13632
xmlXPathCompOpEvalFirst(ctxt,
13633
&comp->steps[op->ch1],
13634
&first);
13635
CHECK_ERROR0;
13636
/*
13637
* The nodeset should be in document order,
13638
* Keep only the first value
13639
*/
13640
if ((ctxt->value != NULL) &&
13641
(ctxt->value->type == XPATH_NODESET) &&
13642
(ctxt->value->nodesetval != NULL) &&
13643
(ctxt->value->nodesetval->nodeNr > 1))
13644
ctxt->value->nodesetval->nodeNr = 1;
13645
return (total);
13646
}
13647
}
13648
/*
13649
* Optimization for ()[last()] selection i.e. the last elem
13650
*/
13651
if ((op->ch1 != -1) && (op->ch2 != -1) &&
13652
(comp->steps[op->ch1].op == XPATH_OP_SORT) &&
13653
(comp->steps[op->ch2].op == XPATH_OP_SORT)) {
13654
int f = comp->steps[op->ch2].ch1;
13655
13656
if ((f != -1) &&
13657
(comp->steps[f].op == XPATH_OP_FUNCTION) &&
13658
(comp->steps[f].value5 == NULL) &&
13659
(comp->steps[f].value == 0) &&
13660
(comp->steps[f].value4 != NULL) &&
13661
(xmlStrEqual
13662
(comp->steps[f].value4, BAD_CAST "last"))) {
13663
xmlNodePtr last = NULL;
13664
13665
total +=
13666
xmlXPathCompOpEvalLast(ctxt,
13667
&comp->steps[op->ch1],
13668
&last);
13669
CHECK_ERROR0;
13670
/*
13671
* The nodeset should be in document order,
13672
* Keep only the last value
13673
*/
13674
if ((ctxt->value != NULL) &&
13675
(ctxt->value->type == XPATH_NODESET) &&
13676
(ctxt->value->nodesetval != NULL) &&
13677
(ctxt->value->nodesetval->nodeTab != NULL) &&
13678
(ctxt->value->nodesetval->nodeNr > 1)) {
13679
ctxt->value->nodesetval->nodeTab[0] =
13680
ctxt->value->nodesetval->nodeTab[ctxt->
13681
value->
13682
nodesetval->
13683
nodeNr -
13684
1];
13685
ctxt->value->nodesetval->nodeNr = 1;
13686
}
13687
return (total);
13688
}
13689
}
13690
/*
13691
* Process inner predicates first.
13692
* Example "index[parent::book][1]":
13693
* ...
13694
* PREDICATE <-- we are here "[1]"
13695
* PREDICATE <-- process "[parent::book]" first
13696
* SORT
13697
* COLLECT 'parent' 'name' 'node' book
13698
* NODE
13699
* ELEM Object is a number : 1
13700
*/
13701
if (op->ch1 != -1)
13702
total +=
13703
xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13704
CHECK_ERROR0;
13705
if (op->ch2 == -1)
13706
return (total);
13707
if (ctxt->value == NULL)
13708
return (total);
13709
13710
oldnode = ctxt->context->node;
13711
13712
#ifdef LIBXML_XPTR_ENABLED
13713
/*
13714
* Hum are we filtering the result of an XPointer expression
13715
*/
13716
if (ctxt->value->type == XPATH_LOCATIONSET) {
13717
xmlLocationSetPtr newlocset = NULL;
13718
xmlLocationSetPtr oldlocset;
13719
13720
/*
13721
* Extract the old locset, and then evaluate the result of the
13722
* expression for all the element in the locset. use it to grow
13723
* up a new locset.
13724
*/
13725
CHECK_TYPE0(XPATH_LOCATIONSET);
13726
obj = valuePop(ctxt);
13727
oldlocset = obj->user;
13728
ctxt->context->node = NULL;
13729
13730
if ((oldlocset == NULL) || (oldlocset->locNr == 0)) {
13731
ctxt->context->contextSize = 0;
13732
ctxt->context->proximityPosition = 0;
13733
if (op->ch2 != -1)
13734
total +=
13735
xmlXPathCompOpEval(ctxt,
13736
&comp->steps[op->ch2]);
13737
res = valuePop(ctxt);
13738
if (res != NULL) {
13739
xmlXPathReleaseObject(ctxt->context, res);
13740
}
13741
valuePush(ctxt, obj);
13742
CHECK_ERROR0;
13743
return (total);
13744
}
13745
newlocset = xmlXPtrLocationSetCreate(NULL);
13746
13747
for (i = 0; i < oldlocset->locNr; i++) {
13748
/*
13749
* Run the evaluation with a node list made of a
13750
* single item in the nodelocset.
13751
*/
13752
ctxt->context->node = oldlocset->locTab[i]->user;
13753
ctxt->context->contextSize = oldlocset->locNr;
13754
ctxt->context->proximityPosition = i + 1;
13755
tmp = xmlXPathCacheNewNodeSet(ctxt->context,
13756
ctxt->context->node);
13757
valuePush(ctxt, tmp);
13758
13759
if (op->ch2 != -1)
13760
total +=
13761
xmlXPathCompOpEval(ctxt,
13762
&comp->steps[op->ch2]);
13763
if (ctxt->error != XPATH_EXPRESSION_OK) {
13764
xmlXPathFreeObject(obj);
13765
return(0);
13766
}
13767
13768
/*
13769
* The result of the evaluation need to be tested to
13770
* decided whether the filter succeeded or not
13771
*/
13772
res = valuePop(ctxt);
13773
if (xmlXPathEvaluatePredicateResult(ctxt, res)) {
13774
xmlXPtrLocationSetAdd(newlocset,
13775
xmlXPathObjectCopy
13776
(oldlocset->locTab[i]));
13777
}
13778
13779
/*
13780
* Cleanup
13781
*/
13782
if (res != NULL) {
13783
xmlXPathReleaseObject(ctxt->context, res);
13784
}
13785
if (ctxt->value == tmp) {
13786
res = valuePop(ctxt);
13787
xmlXPathReleaseObject(ctxt->context, res);
13788
}
13789
13790
ctxt->context->node = NULL;
13791
}
13792
13793
/*
13794
* The result is used as the new evaluation locset.
13795
*/
13796
xmlXPathReleaseObject(ctxt->context, obj);
13797
ctxt->context->node = NULL;
13798
ctxt->context->contextSize = -1;
13799
ctxt->context->proximityPosition = -1;
13800
valuePush(ctxt, xmlXPtrWrapLocationSet(newlocset));
13801
ctxt->context->node = oldnode;
13802
return (total);
13803
}
13804
#endif /* LIBXML_XPTR_ENABLED */
13805
13806
/*
13807
* Extract the old set, and then evaluate the result of the
13808
* expression for all the element in the set. use it to grow
13809
* up a new set.
13810
*/
13811
CHECK_TYPE0(XPATH_NODESET);
13812
obj = valuePop(ctxt);
13813
oldset = obj->nodesetval;
13814
13815
oldnode = ctxt->context->node;
13816
oldDoc = ctxt->context->doc;
13817
ctxt->context->node = NULL;
13818
13819
if ((oldset == NULL) || (oldset->nodeNr == 0)) {
13820
ctxt->context->contextSize = 0;
13821
ctxt->context->proximityPosition = 0;
13822
/*
13823
if (op->ch2 != -1)
13824
total +=
13825
xmlXPathCompOpEval(ctxt,
13826
&comp->steps[op->ch2]);
13827
CHECK_ERROR0;
13828
res = valuePop(ctxt);
13829
if (res != NULL)
13830
xmlXPathFreeObject(res);
13831
*/
13832
valuePush(ctxt, obj);
13833
ctxt->context->node = oldnode;
13834
CHECK_ERROR0;
13835
} else {
13836
tmp = NULL;
13837
/*
13838
* Initialize the new set.
13839
* Also set the xpath document in case things like
13840
* key() evaluation are attempted on the predicate
13841
*/
13842
newset = xmlXPathNodeSetCreate(NULL);
13843
/*
13844
* SPEC XPath 1.0:
13845
* "For each node in the node-set to be filtered, the
13846
* PredicateExpr is evaluated with that node as the
13847
* context node, with the number of nodes in the
13848
* node-set as the context size, and with the proximity
13849
* position of the node in the node-set with respect to
13850
* the axis as the context position;"
13851
* @oldset is the node-set" to be filtered.
13852
*
13853
* SPEC XPath 1.0:
13854
* "only predicates change the context position and
13855
* context size (see [2.4 Predicates])."
13856
* Example:
13857
* node-set context pos
13858
* nA 1
13859
* nB 2
13860
* nC 3
13861
* After applying predicate [position() > 1] :
13862
* node-set context pos
13863
* nB 1
13864
* nC 2
13865
*
13866
* removed the first node in the node-set, then
13867
* the context position of the
13868
*/
13869
for (i = 0; i < oldset->nodeNr; i++) {
13870
/*
13871
* Run the evaluation with a node list made of
13872
* a single item in the nodeset.
13873
*/
13874
ctxt->context->node = oldset->nodeTab[i];
13875
if ((oldset->nodeTab[i]->type != XML_NAMESPACE_DECL) &&
13876
(oldset->nodeTab[i]->doc != NULL))
13877
ctxt->context->doc = oldset->nodeTab[i]->doc;
13878
if (tmp == NULL) {
13879
tmp = xmlXPathCacheNewNodeSet(ctxt->context,
13880
ctxt->context->node);
13881
} else {
13882
if (xmlXPathNodeSetAddUnique(tmp->nodesetval,
13883
ctxt->context->node) < 0) {
13884
ctxt->error = XPATH_MEMORY_ERROR;
13885
}
13886
}
13887
valuePush(ctxt, tmp);
13888
ctxt->context->contextSize = oldset->nodeNr;
13889
ctxt->context->proximityPosition = i + 1;
13890
/*
13891
* Evaluate the predicate against the context node.
13892
* Can/should we optimize position() predicates
13893
* here (e.g. "[1]")?
13894
*/
13895
if (op->ch2 != -1)
13896
total +=
13897
xmlXPathCompOpEval(ctxt,
13898
&comp->steps[op->ch2]);
13899
if (ctxt->error != XPATH_EXPRESSION_OK) {
13900
xmlXPathFreeNodeSet(newset);
13901
xmlXPathFreeObject(obj);
13902
return(0);
13903
}
13904
13905
/*
13906
* The result of the evaluation needs to be tested to
13907
* decide whether the filter succeeded or not
13908
*/
13909
/*
13910
* OPTIMIZE TODO: Can we use
13911
* xmlXPathNodeSetAdd*Unique()* instead?
13912
*/
13913
res = valuePop(ctxt);
13914
if (xmlXPathEvaluatePredicateResult(ctxt, res)) {
13915
if (xmlXPathNodeSetAdd(newset, oldset->nodeTab[i])
13916
< 0)
13917
ctxt->error = XPATH_MEMORY_ERROR;
13918
}
13919
13920
/*
13921
* Cleanup
13922
*/
13923
if (res != NULL) {
13924
xmlXPathReleaseObject(ctxt->context, res);
13925
}
13926
if (ctxt->value == tmp) {
13927
valuePop(ctxt);
13928
xmlXPathNodeSetClear(tmp->nodesetval, 1);
13929
/*
13930
* Don't free the temporary nodeset
13931
* in order to avoid massive recreation inside this
13932
* loop.
13933
*/
13934
} else
13935
tmp = NULL;
13936
ctxt->context->node = NULL;
13937
}
13938
if (tmp != NULL)
13939
xmlXPathReleaseObject(ctxt->context, tmp);
13940
/*
13941
* The result is used as the new evaluation set.
13942
*/
13943
xmlXPathReleaseObject(ctxt->context, obj);
13944
ctxt->context->node = NULL;
13945
ctxt->context->contextSize = -1;
13946
ctxt->context->proximityPosition = -1;
13947
/* may want to move this past the '}' later */
13948
ctxt->context->doc = oldDoc;
13949
valuePush(ctxt,
13950
xmlXPathCacheWrapNodeSet(ctxt->context, newset));
13951
}
13952
ctxt->context->node = oldnode;
13953
return (total);
13954
}
13955
case XPATH_OP_SORT:
13956
if (op->ch1 != -1)
13957
total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13958
CHECK_ERROR0;
13959
if ((ctxt->value != NULL) &&
13960
(ctxt->value->type == XPATH_NODESET) &&
13961
(ctxt->value->nodesetval != NULL) &&
13962
(ctxt->value->nodesetval->nodeNr > 1))
13963
{
13964
xmlXPathNodeSetSort(ctxt->value->nodesetval);
13965
}
13966
return (total);
13967
#ifdef LIBXML_XPTR_ENABLED
13968
case XPATH_OP_RANGETO:{
13969
xmlXPathObjectPtr range;
13970
xmlXPathObjectPtr res, obj;
13971
xmlXPathObjectPtr tmp;
13972
xmlLocationSetPtr newlocset = NULL;
13973
xmlLocationSetPtr oldlocset;
13974
xmlNodeSetPtr oldset;
13975
int i, j;
13976
13977
if (op->ch1 != -1)
13978
total +=
13979
xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13980
if (op->ch2 == -1)
13981
return (total);
13982
13983
if (ctxt->value->type == XPATH_LOCATIONSET) {
13984
/*
13985
* Extract the old locset, and then evaluate the result of the
13986
* expression for all the element in the locset. use it to grow
13987
* up a new locset.
13988
*/
13989
CHECK_TYPE0(XPATH_LOCATIONSET);
13990
obj = valuePop(ctxt);
13991
oldlocset = obj->user;
13992
13993
if ((oldlocset == NULL) || (oldlocset->locNr == 0)) {
13994
ctxt->context->node = NULL;
13995
ctxt->context->contextSize = 0;
13996
ctxt->context->proximityPosition = 0;
13997
total += xmlXPathCompOpEval(ctxt,&comp->steps[op->ch2]);
13998
res = valuePop(ctxt);
13999
if (res != NULL) {
14000
xmlXPathReleaseObject(ctxt->context, res);
14001
}
14002
valuePush(ctxt, obj);
14003
CHECK_ERROR0;
14004
return (total);
14005
}
14006
newlocset = xmlXPtrLocationSetCreate(NULL);
14007
14008
for (i = 0; i < oldlocset->locNr; i++) {
14009
/*
14010
* Run the evaluation with a node list made of a
14011
* single item in the nodelocset.
14012
*/
14013
ctxt->context->node = oldlocset->locTab[i]->user;
14014
ctxt->context->contextSize = oldlocset->locNr;
14015
ctxt->context->proximityPosition = i + 1;
14016
tmp = xmlXPathCacheNewNodeSet(ctxt->context,
14017
ctxt->context->node);
14018
valuePush(ctxt, tmp);
14019
14020
if (op->ch2 != -1)
14021
total +=
14022
xmlXPathCompOpEval(ctxt,
14023
&comp->steps[op->ch2]);
14024
if (ctxt->error != XPATH_EXPRESSION_OK) {
14025
xmlXPathFreeObject(obj);
14026
return(0);
14027
}
14028
14029
res = valuePop(ctxt);
14030
if (res->type == XPATH_LOCATIONSET) {
14031
xmlLocationSetPtr rloc =
14032
(xmlLocationSetPtr)res->user;
14033
for (j=0; j<rloc->locNr; j++) {
14034
range = xmlXPtrNewRange(
14035
oldlocset->locTab[i]->user,
14036
oldlocset->locTab[i]->index,
14037
rloc->locTab[j]->user2,
14038
rloc->locTab[j]->index2);
14039
if (range != NULL) {
14040
xmlXPtrLocationSetAdd(newlocset, range);
14041
}
14042
}
14043
} else {
14044
range = xmlXPtrNewRangeNodeObject(
14045
(xmlNodePtr)oldlocset->locTab[i]->user, res);
14046
if (range != NULL) {
14047
xmlXPtrLocationSetAdd(newlocset,range);
14048
}
14049
}
14050
14051
/*
14052
* Cleanup
14053
*/
14054
if (res != NULL) {
14055
xmlXPathReleaseObject(ctxt->context, res);
14056
}
14057
if (ctxt->value == tmp) {
14058
res = valuePop(ctxt);
14059
xmlXPathReleaseObject(ctxt->context, res);
14060
}
14061
14062
ctxt->context->node = NULL;
14063
}
14064
} else { /* Not a location set */
14065
CHECK_TYPE0(XPATH_NODESET);
14066
obj = valuePop(ctxt);
14067
oldset = obj->nodesetval;
14068
ctxt->context->node = NULL;
14069
14070
newlocset = xmlXPtrLocationSetCreate(NULL);
14071
14072
if (oldset != NULL) {
14073
for (i = 0; i < oldset->nodeNr; i++) {
14074
/*
14075
* Run the evaluation with a node list made of a single item
14076
* in the nodeset.
14077
*/
14078
ctxt->context->node = oldset->nodeTab[i];
14079
/*
14080
* OPTIMIZE TODO: Avoid recreation for every iteration.
14081
*/
14082
tmp = xmlXPathCacheNewNodeSet(ctxt->context,
14083
ctxt->context->node);
14084
valuePush(ctxt, tmp);
14085
14086
if (op->ch2 != -1)
14087
total +=
14088
xmlXPathCompOpEval(ctxt,
14089
&comp->steps[op->ch2]);
14090
if (ctxt->error != XPATH_EXPRESSION_OK) {
14091
xmlXPathFreeObject(obj);
14092
return(0);
14093
}
14094
14095
res = valuePop(ctxt);
14096
range =
14097
xmlXPtrNewRangeNodeObject(oldset->nodeTab[i],
14098
res);
14099
if (range != NULL) {
14100
xmlXPtrLocationSetAdd(newlocset, range);
14101
}
14102
14103
/*
14104
* Cleanup
14105
*/
14106
if (res != NULL) {
14107
xmlXPathReleaseObject(ctxt->context, res);
14108
}
14109
if (ctxt->value == tmp) {
14110
res = valuePop(ctxt);
14111
xmlXPathReleaseObject(ctxt->context, res);
14112
}
14113
14114
ctxt->context->node = NULL;
14115
}
14116
}
14117
}
14118
14119
/*
14120
* The result is used as the new evaluation set.
14121
*/
14122
xmlXPathReleaseObject(ctxt->context, obj);
14123
ctxt->context->node = NULL;
14124
ctxt->context->contextSize = -1;
14125
ctxt->context->proximityPosition = -1;
14126
valuePush(ctxt, xmlXPtrWrapLocationSet(newlocset));
14127
return (total);
14128
}
14129
#endif /* LIBXML_XPTR_ENABLED */
14130
}
14131
xmlGenericError(xmlGenericErrorContext,
14132
"XPath: unknown precompiled operation %d\n", op->op);
14133
ctxt->error = XPATH_INVALID_OPERAND;
14134
return (total);
14135
}
14136
14137
/**
14138
* xmlXPathCompOpEvalToBoolean:
14139
* @ctxt: the XPath parser context
14140
*
14141
* Evaluates if the expression evaluates to true.
14142
*
14143
* Returns 1 if true, 0 if false and -1 on API or internal errors.
14144
*/
14145
static int
14146
xmlXPathCompOpEvalToBoolean(xmlXPathParserContextPtr ctxt,
14147
xmlXPathStepOpPtr op,
14148
int isPredicate)
14149
{
14150
xmlXPathObjectPtr resObj = NULL;
14151
14152
start:
14153
/* comp = ctxt->comp; */
14154
switch (op->op) {
14155
case XPATH_OP_END:
14156
return (0);
14157
case XPATH_OP_VALUE:
14158
resObj = (xmlXPathObjectPtr) op->value4;
14159
if (isPredicate)
14160
return(xmlXPathEvaluatePredicateResult(ctxt, resObj));
14161
return(xmlXPathCastToBoolean(resObj));
14162
case XPATH_OP_SORT:
14163
/*
14164
* We don't need sorting for boolean results. Skip this one.
14165
*/
14166
if (op->ch1 != -1) {
14167
op = &ctxt->comp->steps[op->ch1];
14168
goto start;
14169
}
14170
return(0);
14171
case XPATH_OP_COLLECT:
14172
if (op->ch1 == -1)
14173
return(0);
14174
14175
xmlXPathCompOpEval(ctxt, &ctxt->comp->steps[op->ch1]);
14176
if (ctxt->error != XPATH_EXPRESSION_OK)
14177
return(-1);
14178
14179
xmlXPathNodeCollectAndTest(ctxt, op, NULL, NULL, 1);
14180
if (ctxt->error != XPATH_EXPRESSION_OK)
14181
return(-1);
14182
14183
resObj = valuePop(ctxt);
14184
if (resObj == NULL)
14185
return(-1);
14186
break;
14187
default:
14188
/*
14189
* Fallback to call xmlXPathCompOpEval().
14190
*/
14191
xmlXPathCompOpEval(ctxt, op);
14192
if (ctxt->error != XPATH_EXPRESSION_OK)
14193
return(-1);
14194
14195
resObj = valuePop(ctxt);
14196
if (resObj == NULL)
14197
return(-1);
14198
break;
14199
}
14200
14201
if (resObj) {
14202
int res;
14203
14204
if (resObj->type == XPATH_BOOLEAN) {
14205
res = resObj->boolval;
14206
} else if (isPredicate) {
14207
/*
14208
* For predicates a result of type "number" is handled
14209
* differently:
14210
* SPEC XPath 1.0:
14211
* "If the result is a number, the result will be converted
14212
* to true if the number is equal to the context position
14213
* and will be converted to false otherwise;"
14214
*/
14215
res = xmlXPathEvaluatePredicateResult(ctxt, resObj);
14216
} else {
14217
res = xmlXPathCastToBoolean(resObj);
14218
}
14219
xmlXPathReleaseObject(ctxt->context, resObj);
14220
return(res);
14221
}
14222
14223
return(0);
14224
}
14225
14226
#ifdef XPATH_STREAMING
14227
/**
14228
* xmlXPathRunStreamEval:
14229
* @ctxt: the XPath parser context with the compiled expression
14230
*
14231
* Evaluate the Precompiled Streamable XPath expression in the given context.
14232
*/
14233
static int
14234
xmlXPathRunStreamEval(xmlXPathContextPtr ctxt, xmlPatternPtr comp,
14235
xmlXPathObjectPtr *resultSeq, int toBool)
14236
{
14237
int max_depth, min_depth;
14238
int from_root;
14239
int ret, depth;
14240
int eval_all_nodes;
14241
xmlNodePtr cur = NULL, limit = NULL;
14242
xmlStreamCtxtPtr patstream = NULL;
14243
14244
int nb_nodes = 0;
14245
14246
if ((ctxt == NULL) || (comp == NULL))
14247
return(-1);
14248
max_depth = xmlPatternMaxDepth(comp);
14249
if (max_depth == -1)
14250
return(-1);
14251
if (max_depth == -2)
14252
max_depth = 10000;
14253
min_depth = xmlPatternMinDepth(comp);
14254
if (min_depth == -1)
14255
return(-1);
14256
from_root = xmlPatternFromRoot(comp);
14257
if (from_root < 0)
14258
return(-1);
14259
#if 0
14260
printf("stream eval: depth %d from root %d\n", max_depth, from_root);
14261
#endif
14262
14263
if (! toBool) {
14264
if (resultSeq == NULL)
14265
return(-1);
14266
*resultSeq = xmlXPathCacheNewNodeSet(ctxt, NULL);
14267
if (*resultSeq == NULL)
14268
return(-1);
14269
}
14270
14271
/*
14272
* handle the special cases of "/" amd "." being matched
14273
*/
14274
if (min_depth == 0) {
14275
if (from_root) {
14276
/* Select "/" */
14277
if (toBool)
14278
return(1);
14279
xmlXPathNodeSetAddUnique((*resultSeq)->nodesetval,
14280
(xmlNodePtr) ctxt->doc);
14281
} else {
14282
/* Select "self::node()" */
14283
if (toBool)
14284
return(1);
14285
xmlXPathNodeSetAddUnique((*resultSeq)->nodesetval, ctxt->node);
14286
}
14287
}
14288
if (max_depth == 0) {
14289
return(0);
14290
}
14291
14292
if (from_root) {
14293
cur = (xmlNodePtr)ctxt->doc;
14294
} else if (ctxt->node != NULL) {
14295
switch (ctxt->node->type) {
14296
case XML_ELEMENT_NODE:
14297
case XML_DOCUMENT_NODE:
14298
case XML_DOCUMENT_FRAG_NODE:
14299
case XML_HTML_DOCUMENT_NODE:
14300
#ifdef LIBXML_DOCB_ENABLED
14301
case XML_DOCB_DOCUMENT_NODE:
14302
#endif
14303
cur = ctxt->node;
14304
break;
14305
case XML_ATTRIBUTE_NODE:
14306
case XML_TEXT_NODE:
14307
case XML_CDATA_SECTION_NODE:
14308
case XML_ENTITY_REF_NODE:
14309
case XML_ENTITY_NODE:
14310
case XML_PI_NODE:
14311
case XML_COMMENT_NODE:
14312
case XML_NOTATION_NODE:
14313
case XML_DTD_NODE:
14314
case XML_DOCUMENT_TYPE_NODE:
14315
case XML_ELEMENT_DECL:
14316
case XML_ATTRIBUTE_DECL:
14317
case XML_ENTITY_DECL:
14318
case XML_NAMESPACE_DECL:
14319
case XML_XINCLUDE_START:
14320
case XML_XINCLUDE_END:
14321
break;
14322
}
14323
limit = cur;
14324
}
14325
if (cur == NULL) {
14326
return(0);
14327
}
14328
14329
patstream = xmlPatternGetStreamCtxt(comp);
14330
if (patstream == NULL) {
14331
/*
14332
* QUESTION TODO: Is this an error?
14333
*/
14334
return(0);
14335
}
14336
14337
eval_all_nodes = xmlStreamWantsAnyNode(patstream);
14338
14339
if (from_root) {
14340
ret = xmlStreamPush(patstream, NULL, NULL);
14341
if (ret < 0) {
14342
} else if (ret == 1) {
14343
if (toBool)
14344
goto return_1;
14345
xmlXPathNodeSetAddUnique((*resultSeq)->nodesetval, cur);
14346
}
14347
}
14348
depth = 0;
14349
goto scan_children;
14350
next_node:
14351
do {
14352
nb_nodes++;
14353
14354
switch (cur->type) {
14355
case XML_ELEMENT_NODE:
14356
case XML_TEXT_NODE:
14357
case XML_CDATA_SECTION_NODE:
14358
case XML_COMMENT_NODE:
14359
case XML_PI_NODE:
14360
if (cur->type == XML_ELEMENT_NODE) {
14361
ret = xmlStreamPush(patstream, cur->name,
14362
(cur->ns ? cur->ns->href : NULL));
14363
} else if (eval_all_nodes)
14364
ret = xmlStreamPushNode(patstream, NULL, NULL, cur->type);
14365
else
14366
break;
14367
14368
if (ret < 0) {
14369
/* NOP. */
14370
} else if (ret == 1) {
14371
if (toBool)
14372
goto return_1;
14373
if (xmlXPathNodeSetAddUnique((*resultSeq)->nodesetval, cur)
14374
< 0) {
14375
ctxt->lastError.domain = XML_FROM_XPATH;
14376
ctxt->lastError.code = XML_ERR_NO_MEMORY;
14377
}
14378
}
14379
if ((cur->children == NULL) || (depth >= max_depth)) {
14380
ret = xmlStreamPop(patstream);
14381
while (cur->next != NULL) {
14382
cur = cur->next;
14383
if ((cur->type != XML_ENTITY_DECL) &&
14384
(cur->type != XML_DTD_NODE))
14385
goto next_node;
14386
}
14387
}
14388
default:
14389
break;
14390
}
14391
14392
scan_children:
14393
if (cur->type == XML_NAMESPACE_DECL) break;
14394
if ((cur->children != NULL) && (depth < max_depth)) {
14395
/*
14396
* Do not descend on entities declarations
14397
*/
14398
if (cur->children->type != XML_ENTITY_DECL) {
14399
cur = cur->children;
14400
depth++;
14401
/*
14402
* Skip DTDs
14403
*/
14404
if (cur->type != XML_DTD_NODE)
14405
continue;
14406
}
14407
}
14408
14409
if (cur == limit)
14410
break;
14411
14412
while (cur->next != NULL) {
14413
cur = cur->next;
14414
if ((cur->type != XML_ENTITY_DECL) &&
14415
(cur->type != XML_DTD_NODE))
14416
goto next_node;
14417
}
14418
14419
do {
14420
cur = cur->parent;
14421
depth--;
14422
if ((cur == NULL) || (cur == limit))
14423
goto done;
14424
if (cur->type == XML_ELEMENT_NODE) {
14425
ret = xmlStreamPop(patstream);
14426
} else if ((eval_all_nodes) &&
14427
((cur->type == XML_TEXT_NODE) ||
14428
(cur->type == XML_CDATA_SECTION_NODE) ||
14429
(cur->type == XML_COMMENT_NODE) ||
14430
(cur->type == XML_PI_NODE)))
14431
{
14432
ret = xmlStreamPop(patstream);
14433
}
14434
if (cur->next != NULL) {
14435
cur = cur->next;
14436
break;
14437
}
14438
} while (cur != NULL);
14439
14440
} while ((cur != NULL) && (depth >= 0));
14441
14442
done:
14443
14444
#if 0
14445
printf("stream eval: checked %d nodes selected %d\n",
14446
nb_nodes, retObj->nodesetval->nodeNr);
14447
#endif
14448
14449
if (patstream)
14450
xmlFreeStreamCtxt(patstream);
14451
return(0);
14452
14453
return_1:
14454
if (patstream)
14455
xmlFreeStreamCtxt(patstream);
14456
return(1);
14457
}
14458
#endif /* XPATH_STREAMING */
14459
14460
/**
14461
* xmlXPathRunEval:
14462
* @ctxt: the XPath parser context with the compiled expression
14463
* @toBool: evaluate to a boolean result
14464
*
14465
* Evaluate the Precompiled XPath expression in the given context.
14466
*/
14467
static int
14468
xmlXPathRunEval(xmlXPathParserContextPtr ctxt, int toBool)
14469
{
14470
xmlXPathCompExprPtr comp;
14471
14472
if ((ctxt == NULL) || (ctxt->comp == NULL))
14473
return(-1);
14474
14475
if (ctxt->valueTab == NULL) {
14476
/* Allocate the value stack */
14477
ctxt->valueTab = (xmlXPathObjectPtr *)
14478
xmlMalloc(10 * sizeof(xmlXPathObjectPtr));
14479
if (ctxt->valueTab == NULL) {
14480
xmlXPathPErrMemory(ctxt, "creating evaluation context\n");
14481
xmlFree(ctxt);
14482
}
14483
ctxt->valueNr = 0;
14484
ctxt->valueMax = 10;
14485
ctxt->value = NULL;
14486
ctxt->valueFrame = 0;
14487
}
14488
#ifdef XPATH_STREAMING
14489
if (ctxt->comp->stream) {
14490
int res;
14491
14492
if (toBool) {
14493
/*
14494
* Evaluation to boolean result.
14495
*/
14496
res = xmlXPathRunStreamEval(ctxt->context,
14497
ctxt->comp->stream, NULL, 1);
14498
if (res != -1)
14499
return(res);
14500
} else {
14501
xmlXPathObjectPtr resObj = NULL;
14502
14503
/*
14504
* Evaluation to a sequence.
14505
*/
14506
res = xmlXPathRunStreamEval(ctxt->context,
14507
ctxt->comp->stream, &resObj, 0);
14508
14509
if ((res != -1) && (resObj != NULL)) {
14510
valuePush(ctxt, resObj);
14511
return(0);
14512
}
14513
if (resObj != NULL)
14514
xmlXPathReleaseObject(ctxt->context, resObj);
14515
}
14516
/*
14517
* QUESTION TODO: This falls back to normal XPath evaluation
14518
* if res == -1. Is this intended?
14519
*/
14520
}
14521
#endif
14522
comp = ctxt->comp;
14523
if (comp->last < 0) {
14524
xmlGenericError(xmlGenericErrorContext,
14525
"xmlXPathRunEval: last is less than zero\n");
14526
return(-1);
14527
}
14528
if (toBool)
14529
return(xmlXPathCompOpEvalToBoolean(ctxt,
14530
&comp->steps[comp->last], 0));
14531
else
14532
xmlXPathCompOpEval(ctxt, &comp->steps[comp->last]);
14533
14534
return(0);
14535
}
14536
14537
/************************************************************************
14538
* *
14539
* Public interfaces *
14540
* *
14541
************************************************************************/
14542
14543
/**
14544
* xmlXPathEvalPredicate:
14545
* @ctxt: the XPath context
14546
* @res: the Predicate Expression evaluation result
14547
*
14548
* Evaluate a predicate result for the current node.
14549
* A PredicateExpr is evaluated by evaluating the Expr and converting
14550
* the result to a boolean. If the result is a number, the result will
14551
* be converted to true if the number is equal to the position of the
14552
* context node in the context node list (as returned by the position
14553
* function) and will be converted to false otherwise; if the result
14554
* is not a number, then the result will be converted as if by a call
14555
* to the boolean function.
14556
*
14557
* Returns 1 if predicate is true, 0 otherwise
14558
*/
14559
int
14560
xmlXPathEvalPredicate(xmlXPathContextPtr ctxt, xmlXPathObjectPtr res) {
14561
if ((ctxt == NULL) || (res == NULL)) return(0);
14562
switch (res->type) {
14563
case XPATH_BOOLEAN:
14564
return(res->boolval);
14565
case XPATH_NUMBER:
14566
return(res->floatval == ctxt->proximityPosition);
14567
case XPATH_NODESET:
14568
case XPATH_XSLT_TREE:
14569
if (res->nodesetval == NULL)
14570
return(0);
14571
return(res->nodesetval->nodeNr != 0);
14572
case XPATH_STRING:
14573
return((res->stringval != NULL) &&
14574
(xmlStrlen(res->stringval) != 0));
14575
default:
14576
STRANGE
14577
}
14578
return(0);
14579
}
14580
14581
/**
14582
* xmlXPathEvaluatePredicateResult:
14583
* @ctxt: the XPath Parser context
14584
* @res: the Predicate Expression evaluation result
14585
*
14586
* Evaluate a predicate result for the current node.
14587
* A PredicateExpr is evaluated by evaluating the Expr and converting
14588
* the result to a boolean. If the result is a number, the result will
14589
* be converted to true if the number is equal to the position of the
14590
* context node in the context node list (as returned by the position
14591
* function) and will be converted to false otherwise; if the result
14592
* is not a number, then the result will be converted as if by a call
14593
* to the boolean function.
14594
*
14595
* Returns 1 if predicate is true, 0 otherwise
14596
*/
14597
int
14598
xmlXPathEvaluatePredicateResult(xmlXPathParserContextPtr ctxt,
14599
xmlXPathObjectPtr res) {
14600
if ((ctxt == NULL) || (res == NULL)) return(0);
14601
switch (res->type) {
14602
case XPATH_BOOLEAN:
14603
return(res->boolval);
14604
case XPATH_NUMBER:
14605
#if defined(__BORLANDC__) || (defined(_MSC_VER) && (_MSC_VER == 1200))
14606
return((res->floatval == ctxt->context->proximityPosition) &&
14607
(!xmlXPathIsNaN(res->floatval))); /* MSC pbm Mark Vakoc !*/
14608
#else
14609
return(res->floatval == ctxt->context->proximityPosition);
14610
#endif
14611
case XPATH_NODESET:
14612
case XPATH_XSLT_TREE:
14613
if (res->nodesetval == NULL)
14614
return(0);
14615
return(res->nodesetval->nodeNr != 0);
14616
case XPATH_STRING:
14617
return((res->stringval != NULL) && (res->stringval[0] != 0));
14618
#ifdef LIBXML_XPTR_ENABLED
14619
case XPATH_LOCATIONSET:{
14620
xmlLocationSetPtr ptr = res->user;
14621
if (ptr == NULL)
14622
return(0);
14623
return (ptr->locNr != 0);
14624
}
14625
#endif
14626
default:
14627
STRANGE
14628
}
14629
return(0);
14630
}
14631
14632
#ifdef XPATH_STREAMING
14633
/**
14634
* xmlXPathTryStreamCompile:
14635
* @ctxt: an XPath context
14636
* @str: the XPath expression
14637
*
14638
* Try to compile the XPath expression as a streamable subset.
14639
*
14640
* Returns the compiled expression or NULL if failed to compile.
14641
*/
14642
static xmlXPathCompExprPtr
14643
xmlXPathTryStreamCompile(xmlXPathContextPtr ctxt, const xmlChar *str) {
14644
/*
14645
* Optimization: use streaming patterns when the XPath expression can
14646
* be compiled to a stream lookup
14647
*/
14648
xmlPatternPtr stream;
14649
xmlXPathCompExprPtr comp;
14650
xmlDictPtr dict = NULL;
14651
const xmlChar **namespaces = NULL;
14652
xmlNsPtr ns;
14653
int i, j;
14654
14655
if ((!xmlStrchr(str, '[')) && (!xmlStrchr(str, '(')) &&
14656
(!xmlStrchr(str, '@'))) {
14657
const xmlChar *tmp;
14658
14659
/*
14660
* We don't try to handle expressions using the verbose axis
14661
* specifiers ("::"), just the simplied form at this point.
14662
* Additionally, if there is no list of namespaces available and
14663
* there's a ":" in the expression, indicating a prefixed QName,
14664
* then we won't try to compile either. xmlPatterncompile() needs
14665
* to have a list of namespaces at compilation time in order to
14666
* compile prefixed name tests.
14667
*/
14668
tmp = xmlStrchr(str, ':');
14669
if ((tmp != NULL) &&
14670
((ctxt == NULL) || (ctxt->nsNr == 0) || (tmp[1] == ':')))
14671
return(NULL);
14672
14673
if (ctxt != NULL) {
14674
dict = ctxt->dict;
14675
if (ctxt->nsNr > 0) {
14676
namespaces = xmlMalloc(2 * (ctxt->nsNr + 1) * sizeof(xmlChar*));
14677
if (namespaces == NULL) {
14678
xmlXPathErrMemory(ctxt, "allocating namespaces array\n");
14679
return(NULL);
14680
}
14681
for (i = 0, j = 0; (j < ctxt->nsNr); j++) {
14682
ns = ctxt->namespaces[j];
14683
namespaces[i++] = ns->href;
14684
namespaces[i++] = ns->prefix;
14685
}
14686
namespaces[i++] = NULL;
14687
namespaces[i] = NULL;
14688
}
14689
}
14690
14691
stream = xmlPatterncompile(str, dict, XML_PATTERN_XPATH,
14692
&namespaces[0]);
14693
if (namespaces != NULL) {
14694
xmlFree((xmlChar **)namespaces);
14695
}
14696
if ((stream != NULL) && (xmlPatternStreamable(stream) == 1)) {
14697
comp = xmlXPathNewCompExpr();
14698
if (comp == NULL) {
14699
xmlXPathErrMemory(ctxt, "allocating streamable expression\n");
14700
return(NULL);
14701
}
14702
comp->stream = stream;
14703
comp->dict = dict;
14704
if (comp->dict)
14705
xmlDictReference(comp->dict);
14706
return(comp);
14707
}
14708
xmlFreePattern(stream);
14709
}
14710
return(NULL);
14711
}
14712
#endif /* XPATH_STREAMING */
14713
14714
static void
14715
xmlXPathOptimizeExpression(xmlXPathCompExprPtr comp, xmlXPathStepOpPtr op)
14716
{
14717
/*
14718
* Try to rewrite "descendant-or-self::node()/foo" to an optimized
14719
* internal representation.
14720
*/
14721
14722
if ((op->ch1 != -1) &&
14723
(op->op == XPATH_OP_COLLECT /* 11 */))
14724
{
14725
xmlXPathStepOpPtr prevop = &comp->steps[op->ch1];
14726
14727
if ((prevop->op == XPATH_OP_COLLECT /* 11 */) &&
14728
((xmlXPathAxisVal) prevop->value ==
14729
AXIS_DESCENDANT_OR_SELF) &&
14730
(prevop->ch2 == -1) &&
14731
((xmlXPathTestVal) prevop->value2 == NODE_TEST_TYPE) &&
14732
((xmlXPathTypeVal) prevop->value3 == NODE_TYPE_NODE))
14733
{
14734
/*
14735
* This is a "descendant-or-self::node()" without predicates.
14736
* Try to eliminate it.
14737
*/
14738
14739
switch ((xmlXPathAxisVal) op->value) {
14740
case AXIS_CHILD:
14741
case AXIS_DESCENDANT:
14742
/*
14743
* Convert "descendant-or-self::node()/child::" or
14744
* "descendant-or-self::node()/descendant::" to
14745
* "descendant::"
14746
*/
14747
op->ch1 = prevop->ch1;
14748
op->value = AXIS_DESCENDANT;
14749
break;
14750
case AXIS_SELF:
14751
case AXIS_DESCENDANT_OR_SELF:
14752
/*
14753
* Convert "descendant-or-self::node()/self::" or
14754
* "descendant-or-self::node()/descendant-or-self::" to
14755
* to "descendant-or-self::"
14756
*/
14757
op->ch1 = prevop->ch1;
14758
op->value = AXIS_DESCENDANT_OR_SELF;
14759
break;
14760
default:
14761
break;
14762
}
14763
}
14764
}
14765
14766
/* Recurse */
14767
if (op->ch1 != -1)
14768
xmlXPathOptimizeExpression(comp, &comp->steps[op->ch1]);
14769
if (op->ch2 != -1)
14770
xmlXPathOptimizeExpression(comp, &comp->steps[op->ch2]);
14771
}
14772
14773
/**
14774
* xmlXPathCtxtCompile:
14775
* @ctxt: an XPath context
14776
* @str: the XPath expression
14777
*
14778
* Compile an XPath expression
14779
*
14780
* Returns the xmlXPathCompExprPtr resulting from the compilation or NULL.
14781
* the caller has to free the object.
14782
*/
14783
xmlXPathCompExprPtr
14784
xmlXPathCtxtCompile(xmlXPathContextPtr ctxt, const xmlChar *str) {
14785
xmlXPathParserContextPtr pctxt;
14786
xmlXPathCompExprPtr comp;
14787
14788
#ifdef XPATH_STREAMING
14789
comp = xmlXPathTryStreamCompile(ctxt, str);
14790
if (comp != NULL)
14791
return(comp);
14792
#endif
14793
14794
xmlXPathInit();
14795
14796
pctxt = xmlXPathNewParserContext(str, ctxt);
14797
if (pctxt == NULL)
14798
return NULL;
14799
xmlXPathCompileExpr(pctxt, 1);
14800
14801
if( pctxt->error != XPATH_EXPRESSION_OK )
14802
{
14803
xmlXPathFreeParserContext(pctxt);
14804
return(NULL);
14805
}
14806
14807
if (*pctxt->cur != 0) {
14808
/*
14809
* aleksey: in some cases this line prints *second* error message
14810
* (see bug #78858) and probably this should be fixed.
14811
* However, we are not sure that all error messages are printed
14812
* out in other places. It's not critical so we leave it as-is for now
14813
*/
14814
xmlXPatherror(pctxt, __FILE__, __LINE__, XPATH_EXPR_ERROR);
14815
comp = NULL;
14816
} else {
14817
comp = pctxt->comp;
14818
pctxt->comp = NULL;
14819
}
14820
xmlXPathFreeParserContext(pctxt);
14821
14822
if (comp != NULL) {
14823
comp->expr = xmlStrdup(str);
14824
#ifdef DEBUG_EVAL_COUNTS
14825
comp->string = xmlStrdup(str);
14826
comp->nb = 0;
14827
#endif
14828
if ((comp->nbStep > 1) && (comp->last >= 0)) {
14829
xmlXPathOptimizeExpression(comp, &comp->steps[comp->last]);
14830
}
14831
}
14832
return(comp);
14833
}
14834
14835
/**
14836
* xmlXPathCompile:
14837
* @str: the XPath expression
14838
*
14839
* Compile an XPath expression
14840
*
14841
* Returns the xmlXPathCompExprPtr resulting from the compilation or NULL.
14842
* the caller has to free the object.
14843
*/
14844
xmlXPathCompExprPtr
14845
xmlXPathCompile(const xmlChar *str) {
14846
return(xmlXPathCtxtCompile(NULL, str));
14847
}
14848
14849
/**
14850
* xmlXPathCompiledEvalInternal:
14851
* @comp: the compiled XPath expression
14852
* @ctxt: the XPath context
14853
* @resObj: the resulting XPath object or NULL
14854
* @toBool: 1 if only a boolean result is requested
14855
*
14856
* Evaluate the Precompiled XPath expression in the given context.
14857
* The caller has to free @resObj.
14858
*
14859
* Returns the xmlXPathObjectPtr resulting from the evaluation or NULL.
14860
* the caller has to free the object.
14861
*/
14862
static int
14863
xmlXPathCompiledEvalInternal(xmlXPathCompExprPtr comp,
14864
xmlXPathContextPtr ctxt,
14865
xmlXPathObjectPtr *resObj,
14866
int toBool)
14867
{
14868
xmlXPathParserContextPtr pctxt;
14869
#ifndef LIBXML_THREAD_ENABLED
14870
static int reentance = 0;
14871
#endif
14872
int res;
14873
14874
CHECK_CTXT_NEG(ctxt)
14875
14876
if (comp == NULL)
14877
return(-1);
14878
xmlXPathInit();
14879
14880
#ifndef LIBXML_THREAD_ENABLED
14881
reentance++;
14882
if (reentance > 1)
14883
xmlXPathDisableOptimizer = 1;
14884
#endif
14885
14886
#ifdef DEBUG_EVAL_COUNTS
14887
comp->nb++;
14888
if ((comp->string != NULL) && (comp->nb > 100)) {
14889
fprintf(stderr, "100 x %s\n", comp->string);
14890
comp->nb = 0;
14891
}
14892
#endif
14893
pctxt = xmlXPathCompParserContext(comp, ctxt);
14894
res = xmlXPathRunEval(pctxt, toBool);
14895
14896
if (resObj) {
14897
if (pctxt->value == NULL) {
14898
xmlGenericError(xmlGenericErrorContext,
14899
"xmlXPathCompiledEval: evaluation failed\n");
14900
*resObj = NULL;
14901
} else {
14902
*resObj = valuePop(pctxt);
14903
}
14904
}
14905
14906
/*
14907
* Pop all remaining objects from the stack.
14908
*/
14909
if (pctxt->valueNr > 0) {
14910
xmlXPathObjectPtr tmp;
14911
int stack = 0;
14912
14913
do {
14914
tmp = valuePop(pctxt);
14915
if (tmp != NULL) {
14916
stack++;
14917
xmlXPathReleaseObject(ctxt, tmp);
14918
}
14919
} while (tmp != NULL);
14920
if ((stack != 0) &&
14921
((toBool) || ((resObj) && (*resObj))))
14922
{
14923
xmlGenericError(xmlGenericErrorContext,
14924
"xmlXPathCompiledEval: %d objects left on the stack.\n",
14925
stack);
14926
}
14927
}
14928
14929
if ((pctxt->error != XPATH_EXPRESSION_OK) && (resObj) && (*resObj)) {
14930
xmlXPathFreeObject(*resObj);
14931
*resObj = NULL;
14932
}
14933
pctxt->comp = NULL;
14934
xmlXPathFreeParserContext(pctxt);
14935
#ifndef LIBXML_THREAD_ENABLED
14936
reentance--;
14937
#endif
14938
14939
return(res);
14940
}
14941
14942
/**
14943
* xmlXPathCompiledEval:
14944
* @comp: the compiled XPath expression
14945
* @ctx: the XPath context
14946
*
14947
* Evaluate the Precompiled XPath expression in the given context.
14948
*
14949
* Returns the xmlXPathObjectPtr resulting from the evaluation or NULL.
14950
* the caller has to free the object.
14951
*/
14952
xmlXPathObjectPtr
14953
xmlXPathCompiledEval(xmlXPathCompExprPtr comp, xmlXPathContextPtr ctx)
14954
{
14955
xmlXPathObjectPtr res = NULL;
14956
14957
xmlXPathCompiledEvalInternal(comp, ctx, &res, 0);
14958
return(res);
14959
}
14960
14961
/**
14962
* xmlXPathCompiledEvalToBoolean:
14963
* @comp: the compiled XPath expression
14964
* @ctxt: the XPath context
14965
*
14966
* Applies the XPath boolean() function on the result of the given
14967
* compiled expression.
14968
*
14969
* Returns 1 if the expression evaluated to true, 0 if to false and
14970
* -1 in API and internal errors.
14971
*/
14972
int
14973
xmlXPathCompiledEvalToBoolean(xmlXPathCompExprPtr comp,
14974
xmlXPathContextPtr ctxt)
14975
{
14976
return(xmlXPathCompiledEvalInternal(comp, ctxt, NULL, 1));
14977
}
14978
14979
/**
14980
* xmlXPathEvalExpr:
14981
* @ctxt: the XPath Parser context
14982
*
14983
* Parse and evaluate an XPath expression in the given context,
14984
* then push the result on the context stack
14985
*/
14986
void
14987
xmlXPathEvalExpr(xmlXPathParserContextPtr ctxt) {
14988
#ifdef XPATH_STREAMING
14989
xmlXPathCompExprPtr comp;
14990
#endif
14991
14992
if (ctxt == NULL) return;
14993
14994
#ifdef XPATH_STREAMING
14995
comp = xmlXPathTryStreamCompile(ctxt->context, ctxt->base);
14996
if (comp != NULL) {
14997
if (ctxt->comp != NULL)
14998
xmlXPathFreeCompExpr(ctxt->comp);
14999
ctxt->comp = comp;
15000
if (ctxt->cur != NULL)
15001
while (*ctxt->cur != 0) ctxt->cur++;
15002
} else
15003
#endif
15004
{
15005
xmlXPathCompileExpr(ctxt, 1);
15006
if ((ctxt->error == XPATH_EXPRESSION_OK) &&
15007
(ctxt->comp != NULL) &&
15008
(ctxt->comp->nbStep > 1) &&
15009
(ctxt->comp->last >= 0))
15010
{
15011
xmlXPathOptimizeExpression(ctxt->comp,
15012
&ctxt->comp->steps[ctxt->comp->last]);
15013
}
15014
}
15015
CHECK_ERROR;
15016
xmlXPathRunEval(ctxt, 0);
15017
}
15018
15019
/**
15020
* xmlXPathEval:
15021
* @str: the XPath expression
15022
* @ctx: the XPath context
15023
*
15024
* Evaluate the XPath Location Path in the given context.
15025
*
15026
* Returns the xmlXPathObjectPtr resulting from the evaluation or NULL.
15027
* the caller has to free the object.
15028
*/
15029
xmlXPathObjectPtr
15030
xmlXPathEval(const xmlChar *str, xmlXPathContextPtr ctx) {
15031
xmlXPathParserContextPtr ctxt;
15032
xmlXPathObjectPtr res, tmp, init = NULL;
15033
int stack = 0;
15034
15035
CHECK_CTXT(ctx)
15036
15037
xmlXPathInit();
15038
15039
ctxt = xmlXPathNewParserContext(str, ctx);
15040
if (ctxt == NULL)
15041
return NULL;
15042
xmlXPathEvalExpr(ctxt);
15043
15044
if (ctxt->value == NULL) {
15045
xmlGenericError(xmlGenericErrorContext,
15046
"xmlXPathEval: evaluation failed\n");
15047
res = NULL;
15048
} else if ((*ctxt->cur != 0) && (ctxt->comp != NULL)
15049
#ifdef XPATH_STREAMING
15050
&& (ctxt->comp->stream == NULL)
15051
#endif
15052
) {
15053
xmlXPatherror(ctxt, __FILE__, __LINE__, XPATH_EXPR_ERROR);
15054
res = NULL;
15055
} else {
15056
res = valuePop(ctxt);
15057
}
15058
15059
do {
15060
tmp = valuePop(ctxt);
15061
if (tmp != NULL) {
15062
if (tmp != init)
15063
stack++;
15064
xmlXPathReleaseObject(ctx, tmp);
15065
}
15066
} while (tmp != NULL);
15067
if ((stack != 0) && (res != NULL)) {
15068
xmlGenericError(xmlGenericErrorContext,
15069
"xmlXPathEval: %d object left on the stack\n",
15070
stack);
15071
}
15072
if (ctxt->error != XPATH_EXPRESSION_OK) {
15073
xmlXPathFreeObject(res);
15074
res = NULL;
15075
}
15076
15077
xmlXPathFreeParserContext(ctxt);
15078
return(res);
15079
}
15080
15081
/**
15082
* xmlXPathSetContextNode:
15083
* @node: the node to to use as the context node
15084
* @ctx: the XPath context
15085
*
15086
* Sets 'node' as the context node. The node must be in the same
15087
* document as that associated with the context.
15088
*
15089
* Returns -1 in case of error or 0 if successful
15090
*/
15091
int
15092
xmlXPathSetContextNode(xmlNodePtr node, xmlXPathContextPtr ctx) {
15093
if ((node == NULL) || (ctx == NULL))
15094
return(-1);
15095
15096
if (node->doc == ctx->doc) {
15097
ctx->node = node;
15098
return(0);
15099
}
15100
return(-1);
15101
}
15102
15103
/**
15104
* xmlXPathNodeEval:
15105
* @node: the node to to use as the context node
15106
* @str: the XPath expression
15107
* @ctx: the XPath context
15108
*
15109
* Evaluate the XPath Location Path in the given context. The node 'node'
15110
* is set as the context node. The context node is not restored.
15111
*
15112
* Returns the xmlXPathObjectPtr resulting from the evaluation or NULL.
15113
* the caller has to free the object.
15114
*/
15115
xmlXPathObjectPtr
15116
xmlXPathNodeEval(xmlNodePtr node, const xmlChar *str, xmlXPathContextPtr ctx) {
15117
if (str == NULL)
15118
return(NULL);
15119
if (xmlXPathSetContextNode(node, ctx) < 0)
15120
return(NULL);
15121
return(xmlXPathEval(str, ctx));
15122
}
15123
15124
/**
15125
* xmlXPathEvalExpression:
15126
* @str: the XPath expression
15127
* @ctxt: the XPath context
15128
*
15129
* Evaluate the XPath expression in the given context.
15130
*
15131
* Returns the xmlXPathObjectPtr resulting from the evaluation or NULL.
15132
* the caller has to free the object.
15133
*/
15134
xmlXPathObjectPtr
15135
xmlXPathEvalExpression(const xmlChar *str, xmlXPathContextPtr ctxt) {
15136
xmlXPathParserContextPtr pctxt;
15137
xmlXPathObjectPtr res, tmp;
15138
int stack = 0;
15139
15140
CHECK_CTXT(ctxt)
15141
15142
xmlXPathInit();
15143
15144
pctxt = xmlXPathNewParserContext(str, ctxt);
15145
if (pctxt == NULL)
15146
return NULL;
15147
xmlXPathEvalExpr(pctxt);
15148
15149
if ((*pctxt->cur != 0) || (pctxt->error != XPATH_EXPRESSION_OK)) {
15150
xmlXPatherror(pctxt, __FILE__, __LINE__, XPATH_EXPR_ERROR);
15151
res = NULL;
15152
} else {
15153
res = valuePop(pctxt);
15154
}
15155
do {
15156
tmp = valuePop(pctxt);
15157
if (tmp != NULL) {
15158
xmlXPathReleaseObject(ctxt, tmp);
15159
stack++;
15160
}
15161
} while (tmp != NULL);
15162
if ((stack != 0) && (res != NULL)) {
15163
xmlGenericError(xmlGenericErrorContext,
15164
"xmlXPathEvalExpression: %d object left on the stack\n",
15165
stack);
15166
}
15167
xmlXPathFreeParserContext(pctxt);
15168
return(res);
15169
}
15170
15171
/************************************************************************
15172
* *
15173
* Extra functions not pertaining to the XPath spec *
15174
* *
15175
************************************************************************/
15176
/**
15177
* xmlXPathEscapeUriFunction:
15178
* @ctxt: the XPath Parser context
15179
* @nargs: the number of arguments
15180
*
15181
* Implement the escape-uri() XPath function
15182
* string escape-uri(string $str, bool $escape-reserved)
15183
*
15184
* This function applies the URI escaping rules defined in section 2 of [RFC
15185
* 2396] to the string supplied as $uri-part, which typically represents all
15186
* or part of a URI. The effect of the function is to replace any special
15187
* character in the string by an escape sequence of the form %xx%yy...,
15188
* where xxyy... is the hexadecimal representation of the octets used to
15189
* represent the character in UTF-8.
15190
*
15191
* The set of characters that are escaped depends on the setting of the
15192
* boolean argument $escape-reserved.
15193
*
15194
* If $escape-reserved is true, all characters are escaped other than lower
15195
* case letters a-z, upper case letters A-Z, digits 0-9, and the characters
15196
* referred to in [RFC 2396] as "marks": specifically, "-" | "_" | "." | "!"
15197
* | "~" | "*" | "'" | "(" | ")". The "%" character itself is escaped only
15198
* if it is not followed by two hexadecimal digits (that is, 0-9, a-f, and
15199
* A-F).
15200
*
15201
* If $escape-reserved is false, the behavior differs in that characters
15202
* referred to in [RFC 2396] as reserved characters are not escaped. These
15203
* characters are ";" | "/" | "?" | ":" | "@" | "&" | "=" | "+" | "$" | ",".
15204
*
15205
* [RFC 2396] does not define whether escaped URIs should use lower case or
15206
* upper case for hexadecimal digits. To ensure that escaped URIs can be
15207
* compared using string comparison functions, this function must always use
15208
* the upper-case letters A-F.
15209
*
15210
* Generally, $escape-reserved should be set to true when escaping a string
15211
* that is to form a single part of a URI, and to false when escaping an
15212
* entire URI or URI reference.
15213
*
15214
* In the case of non-ascii characters, the string is encoded according to
15215
* utf-8 and then converted according to RFC 2396.
15216
*
15217
* Examples
15218
* xf:escape-uri ("gopher://spinaltap.micro.umn.edu/00/Weather/California/Los%20Angeles#ocean"), true())
15219
* returns "gopher%3A%2F%2Fspinaltap.micro.umn.edu%2F00%2FWeather%2FCalifornia%2FLos%20Angeles%23ocean"
15220
* xf:escape-uri ("gopher://spinaltap.micro.umn.edu/00/Weather/California/Los%20Angeles#ocean"), false())
15221
* returns "gopher://spinaltap.micro.umn.edu/00/Weather/California/Los%20Angeles%23ocean"
15222
*
15223
*/
15224
static void
15225
xmlXPathEscapeUriFunction(xmlXPathParserContextPtr ctxt, int nargs) {
15226
xmlXPathObjectPtr str;
15227
int escape_reserved;
15228
xmlBufPtr target;
15229
xmlChar *cptr;
15230
xmlChar escape[4];
15231
15232
CHECK_ARITY(2);
15233
15234
escape_reserved = xmlXPathPopBoolean(ctxt);
15235
15236
CAST_TO_STRING;
15237
str = valuePop(ctxt);
15238
15239
target = xmlBufCreate();
15240
15241
escape[0] = '%';
15242
escape[3] = 0;
15243
15244
if (target) {
15245
for (cptr = str->stringval; *cptr; cptr++) {
15246
if ((*cptr >= 'A' && *cptr <= 'Z') ||
15247
(*cptr >= 'a' && *cptr <= 'z') ||
15248
(*cptr >= '0' && *cptr <= '9') ||
15249
*cptr == '-' || *cptr == '_' || *cptr == '.' ||
15250
*cptr == '!' || *cptr == '~' || *cptr == '*' ||
15251
*cptr == '\''|| *cptr == '(' || *cptr == ')' ||
15252
(*cptr == '%' &&
15253
((cptr[1] >= 'A' && cptr[1] <= 'F') ||
15254
(cptr[1] >= 'a' && cptr[1] <= 'f') ||
15255
(cptr[1] >= '0' && cptr[1] <= '9')) &&
15256
((cptr[2] >= 'A' && cptr[2] <= 'F') ||
15257
(cptr[2] >= 'a' && cptr[2] <= 'f') ||
15258
(cptr[2] >= '0' && cptr[2] <= '9'))) ||
15259
(!escape_reserved &&
15260
(*cptr == ';' || *cptr == '/' || *cptr == '?' ||
15261
*cptr == ':' || *cptr == '@' || *cptr == '&' ||
15262
*cptr == '=' || *cptr == '+' || *cptr == '$' ||
15263
*cptr == ','))) {
15264
xmlBufAdd(target, cptr, 1);
15265
} else {
15266
if ((*cptr >> 4) < 10)
15267
escape[1] = '0' + (*cptr >> 4);
15268
else
15269
escape[1] = 'A' - 10 + (*cptr >> 4);
15270
if ((*cptr & 0xF) < 10)
15271
escape[2] = '0' + (*cptr & 0xF);
15272
else
15273
escape[2] = 'A' - 10 + (*cptr & 0xF);
15274
15275
xmlBufAdd(target, &escape[0], 3);
15276
}
15277
}
15278
}
15279
valuePush(ctxt, xmlXPathCacheNewString(ctxt->context,
15280
xmlBufContent(target)));
15281
xmlBufFree(target);
15282
xmlXPathReleaseObject(ctxt->context, str);
15283
}
15284
15285
/**
15286
* xmlXPathRegisterAllFunctions:
15287
* @ctxt: the XPath context
15288
*
15289
* Registers all default XPath functions in this context
15290
*/
15291
void
15292
xmlXPathRegisterAllFunctions(xmlXPathContextPtr ctxt)
15293
{
15294
xmlXPathRegisterFunc(ctxt, (const xmlChar *)"boolean",
15295
xmlXPathBooleanFunction);
15296
xmlXPathRegisterFunc(ctxt, (const xmlChar *)"ceiling",
15297
xmlXPathCeilingFunction);
15298
xmlXPathRegisterFunc(ctxt, (const xmlChar *)"count",
15299
xmlXPathCountFunction);
15300
xmlXPathRegisterFunc(ctxt, (const xmlChar *)"concat",
15301
xmlXPathConcatFunction);
15302
xmlXPathRegisterFunc(ctxt, (const xmlChar *)"contains",
15303
xmlXPathContainsFunction);
15304
xmlXPathRegisterFunc(ctxt, (const xmlChar *)"id",
15305
xmlXPathIdFunction);
15306
xmlXPathRegisterFunc(ctxt, (const xmlChar *)"false",
15307
xmlXPathFalseFunction);
15308
xmlXPathRegisterFunc(ctxt, (const xmlChar *)"floor",
15309
xmlXPathFloorFunction);
15310
xmlXPathRegisterFunc(ctxt, (const xmlChar *)"last",
15311
xmlXPathLastFunction);
15312
xmlXPathRegisterFunc(ctxt, (const xmlChar *)"lang",
15313
xmlXPathLangFunction);
15314
xmlXPathRegisterFunc(ctxt, (const xmlChar *)"local-name",
15315
xmlXPathLocalNameFunction);
15316
xmlXPathRegisterFunc(ctxt, (const xmlChar *)"not",
15317
xmlXPathNotFunction);
15318
xmlXPathRegisterFunc(ctxt, (const xmlChar *)"name",
15319
xmlXPathNameFunction);
15320
xmlXPathRegisterFunc(ctxt, (const xmlChar *)"namespace-uri",
15321
xmlXPathNamespaceURIFunction);
15322
xmlXPathRegisterFunc(ctxt, (const xmlChar *)"normalize-space",
15323
xmlXPathNormalizeFunction);
15324
xmlXPathRegisterFunc(ctxt, (const xmlChar *)"number",
15325
xmlXPathNumberFunction);
15326
xmlXPathRegisterFunc(ctxt, (const xmlChar *)"position",
15327
xmlXPathPositionFunction);
15328
xmlXPathRegisterFunc(ctxt, (const xmlChar *)"round",
15329
xmlXPathRoundFunction);
15330
xmlXPathRegisterFunc(ctxt, (const xmlChar *)"string",
15331
xmlXPathStringFunction);
15332
xmlXPathRegisterFunc(ctxt, (const xmlChar *)"string-length",
15333
xmlXPathStringLengthFunction);
15334
xmlXPathRegisterFunc(ctxt, (const xmlChar *)"starts-with",
15335
xmlXPathStartsWithFunction);
15336
xmlXPathRegisterFunc(ctxt, (const xmlChar *)"substring",
15337
xmlXPathSubstringFunction);
15338
xmlXPathRegisterFunc(ctxt, (const xmlChar *)"substring-before",
15339
xmlXPathSubstringBeforeFunction);
15340
xmlXPathRegisterFunc(ctxt, (const xmlChar *)"substring-after",
15341
xmlXPathSubstringAfterFunction);
15342
xmlXPathRegisterFunc(ctxt, (const xmlChar *)"sum",
15343
xmlXPathSumFunction);
15344
xmlXPathRegisterFunc(ctxt, (const xmlChar *)"true",
15345
xmlXPathTrueFunction);
15346
xmlXPathRegisterFunc(ctxt, (const xmlChar *)"translate",
15347
xmlXPathTranslateFunction);
15348
15349
xmlXPathRegisterFuncNS(ctxt, (const xmlChar *)"escape-uri",
15350
(const xmlChar *)"http://www.w3.org/2002/08/xquery-functions",
15351
xmlXPathEscapeUriFunction);
15352
}
15353
15354
#endif /* LIBXML_XPATH_ENABLED */
15355
#define bottom_xpath
15356
#include "elfgcchack.h"
Loggerhead is a web-based interface for Breezy
Version: 2.0.1