Coverage Report

Created: 2025-08-29 06:41

/src/libxml2/xpath.c
Line
Count
Source (jump to first uncovered line)
1
/*
2
 * xpath.c: XML Path Language implementation
3
 *          XPath is a language for addressing parts of an XML document,
4
 *          designed to be used by both XSLT and XPointer
5
 *
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
/* To avoid EBCDIC trouble when parsing on zOS */
18
#if defined(__MVS__)
19
#pragma convert("ISO8859-1")
20
#endif
21
22
#define IN_LIBXML
23
#include "libxml.h"
24
25
#include <limits.h>
26
#include <string.h>
27
#include <stddef.h>
28
#include <math.h>
29
#include <float.h>
30
#include <ctype.h>
31
32
#include <libxml/xmlmemory.h>
33
#include <libxml/tree.h>
34
#include <libxml/xpath.h>
35
#include <libxml/xpathInternals.h>
36
#include <libxml/parserInternals.h>
37
#include <libxml/hash.h>
38
#ifdef LIBXML_DEBUG_ENABLED
39
#include <libxml/debugXML.h>
40
#endif
41
#include <libxml/xmlerror.h>
42
#include <libxml/threads.h>
43
#ifdef LIBXML_PATTERN_ENABLED
44
#include <libxml/pattern.h>
45
#endif
46
47
#include "private/buf.h"
48
#include "private/error.h"
49
#include "private/memory.h"
50
#include "private/xpath.h"
51
52
/* Disabled for now */
53
#if 0
54
#ifdef LIBXML_PATTERN_ENABLED
55
#define XPATH_STREAMING
56
#endif
57
#endif
58
59
/**
60
 * WITH_TIM_SORT:
61
 *
62
 * Use the Timsort algorithm provided in timsort.h to sort
63
 * nodeset as this is a great improvement over the old Shell sort
64
 * used in xmlXPathNodeSetSort()
65
 */
66
#define WITH_TIM_SORT
67
68
/*
69
* XP_OPTIMIZED_NON_ELEM_COMPARISON:
70
* If defined, this will use xmlXPathCmpNodesExt() instead of
71
* xmlXPathCmpNodes(). The new function is optimized comparison of
72
* non-element nodes; actually it will speed up comparison only if
73
* xmlXPathOrderDocElems() was called in order to index the elements of
74
* a tree in document order; Libxslt does such an indexing, thus it will
75
* benefit from this optimization.
76
*/
77
#define XP_OPTIMIZED_NON_ELEM_COMPARISON
78
79
/*
80
* XP_OPTIMIZED_FILTER_FIRST:
81
* If defined, this will optimize expressions like "key('foo', 'val')[b][1]"
82
* in a way, that it stop evaluation at the first node.
83
*/
84
#define XP_OPTIMIZED_FILTER_FIRST
85
86
/*
87
 * XPATH_MAX_STEPS:
88
 * when compiling an XPath expression we arbitrary limit the maximum
89
 * number of step operation in the compiled expression. 1000000 is
90
 * an insanely large value which should never be reached under normal
91
 * circumstances
92
 */
93
23.1k
#define XPATH_MAX_STEPS 1000000
94
95
/*
96
 * XPATH_MAX_STACK_DEPTH:
97
 * when evaluating an XPath expression we arbitrary limit the maximum
98
 * number of object allowed to be pushed on the stack. 1000000 is
99
 * an insanely large value which should never be reached under normal
100
 * circumstances
101
 */
102
2.95k
#define XPATH_MAX_STACK_DEPTH 1000000
103
104
/*
105
 * XPATH_MAX_NODESET_LENGTH:
106
 * when evaluating an XPath expression nodesets are created and we
107
 * arbitrary limit the maximum length of those node set. 10000000 is
108
 * an insanely large value which should never be reached under normal
109
 * circumstances, one would first need to construct an in memory tree
110
 * with more than 10 millions nodes.
111
 */
112
496k
#define XPATH_MAX_NODESET_LENGTH 10000000
113
114
/*
115
 * XPATH_MAX_RECRUSION_DEPTH:
116
 * Maximum amount of nested functions calls when parsing or evaluating
117
 * expressions
118
 */
119
#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
120
2.17M
#define XPATH_MAX_RECURSION_DEPTH 500
121
#elif defined(_WIN32)
122
/* Windows typically limits stack size to 1MB. */
123
#define XPATH_MAX_RECURSION_DEPTH 1000
124
#else
125
#define XPATH_MAX_RECURSION_DEPTH 5000
126
#endif
127
128
/*
129
 * TODO:
130
 * There are a few spots where some tests are done which depend upon ascii
131
 * data.  These should be enhanced for full UTF8 support (see particularly
132
 * any use of the macros IS_ASCII_CHARACTER and IS_ASCII_DIGIT)
133
 */
134
135
#if defined(LIBXML_XPATH_ENABLED)
136
137
static void
138
xmlXPathNameFunction(xmlXPathParserContextPtr ctxt, int nargs);
139
140
static const struct {
141
    const char *name;
142
    xmlXPathFunction func;
143
} xmlXPathStandardFunctions[] = {
144
    { "boolean", xmlXPathBooleanFunction },
145
    { "ceiling", xmlXPathCeilingFunction },
146
    { "count", xmlXPathCountFunction },
147
    { "concat", xmlXPathConcatFunction },
148
    { "contains", xmlXPathContainsFunction },
149
    { "id", xmlXPathIdFunction },
150
    { "false", xmlXPathFalseFunction },
151
    { "floor", xmlXPathFloorFunction },
152
    { "last", xmlXPathLastFunction },
153
    { "lang", xmlXPathLangFunction },
154
    { "local-name", xmlXPathLocalNameFunction },
155
    { "not", xmlXPathNotFunction },
156
    { "name", xmlXPathNameFunction },
157
    { "namespace-uri", xmlXPathNamespaceURIFunction },
158
    { "normalize-space", xmlXPathNormalizeFunction },
159
    { "number", xmlXPathNumberFunction },
160
    { "position", xmlXPathPositionFunction },
161
    { "round", xmlXPathRoundFunction },
162
    { "string", xmlXPathStringFunction },
163
    { "string-length", xmlXPathStringLengthFunction },
164
    { "starts-with", xmlXPathStartsWithFunction },
165
    { "substring", xmlXPathSubstringFunction },
166
    { "substring-before", xmlXPathSubstringBeforeFunction },
167
    { "substring-after", xmlXPathSubstringAfterFunction },
168
    { "sum", xmlXPathSumFunction },
169
    { "true", xmlXPathTrueFunction },
170
    { "translate", xmlXPathTranslateFunction }
171
};
172
173
#define NUM_STANDARD_FUNCTIONS \
174
56
    (sizeof(xmlXPathStandardFunctions) / sizeof(xmlXPathStandardFunctions[0]))
175
176
3.11k
#define SF_HASH_SIZE 64
177
178
static unsigned char xmlXPathSFHash[SF_HASH_SIZE];
179
180
double xmlXPathNAN = 0.0;
181
double xmlXPathPINF = 0.0;
182
double xmlXPathNINF = 0.0;
183
184
/**
185
 * xmlXPathInit:
186
 *
187
 * DEPRECATED: Alias for xmlInitParser.
188
 */
189
void
190
0
xmlXPathInit(void) {
191
0
    xmlInitParser();
192
0
}
193
194
ATTRIBUTE_NO_SANITIZE_INTEGER
195
static unsigned
196
2.56k
xmlXPathSFComputeHash(const xmlChar *name) {
197
2.56k
    unsigned hashValue = 5381;
198
2.56k
    const xmlChar *ptr;
199
200
18.8k
    for (ptr = name; *ptr; ptr++)
201
16.2k
        hashValue = hashValue * 33 + *ptr;
202
203
2.56k
    return(hashValue);
204
2.56k
}
205
206
/**
207
 * xmlInitXPathInternal:
208
 *
209
 * Initialize the XPath environment
210
 */
211
ATTRIBUTE_NO_SANITIZE("float-divide-by-zero")
212
void
213
2
xmlInitXPathInternal(void) {
214
2
    size_t i;
215
216
2
#if defined(NAN) && defined(INFINITY)
217
2
    xmlXPathNAN = NAN;
218
2
    xmlXPathPINF = INFINITY;
219
2
    xmlXPathNINF = -INFINITY;
220
#else
221
    /* MSVC doesn't allow division by zero in constant expressions. */
222
    double zero = 0.0;
223
    xmlXPathNAN = 0.0 / zero;
224
    xmlXPathPINF = 1.0 / zero;
225
    xmlXPathNINF = -xmlXPathPINF;
226
#endif
227
228
    /*
229
     * Initialize hash table for standard functions
230
     */
231
232
130
    for (i = 0; i < SF_HASH_SIZE; i++)
233
128
        xmlXPathSFHash[i] = UCHAR_MAX;
234
235
56
    for (i = 0; i < NUM_STANDARD_FUNCTIONS; i++) {
236
54
        const char *name = xmlXPathStandardFunctions[i].name;
237
54
        int bucketIndex = xmlXPathSFComputeHash(BAD_CAST name) % SF_HASH_SIZE;
238
239
68
        while (xmlXPathSFHash[bucketIndex] != UCHAR_MAX) {
240
14
            bucketIndex += 1;
241
14
            if (bucketIndex >= SF_HASH_SIZE)
242
0
                bucketIndex = 0;
243
14
        }
244
245
54
        xmlXPathSFHash[bucketIndex] = i;
246
54
    }
247
2
}
248
249
/************************************************************************
250
 *                  *
251
 *      Floating point stuff        *
252
 *                  *
253
 ************************************************************************/
254
255
/**
256
 * xmlXPathIsNaN:
257
 * @val:  a double value
258
 *
259
 * Checks whether a double is a NaN.
260
 *
261
 * Returns 1 if the value is a NaN, 0 otherwise
262
 */
263
int
264
16.6k
xmlXPathIsNaN(double val) {
265
16.6k
#ifdef isnan
266
16.6k
    return isnan(val);
267
#else
268
    return !(val == val);
269
#endif
270
16.6k
}
271
272
/**
273
 * xmlXPathIsInf:
274
 * @val:  a double value
275
 *
276
 * Checks whether a double is an infinity.
277
 *
278
 * Returns 1 if the value is +Infinite, -1 if -Infinite, 0 otherwise
279
 */
280
int
281
12.3k
xmlXPathIsInf(double val) {
282
12.3k
#ifdef isinf
283
12.3k
    return isinf(val) ? (val > 0 ? 1 : -1) : 0;
284
#else
285
    if (val >= xmlXPathPINF)
286
        return 1;
287
    if (val <= -xmlXPathPINF)
288
        return -1;
289
    return 0;
290
#endif
291
12.3k
}
292
293
/*
294
 * TODO: when compatibility allows remove all "fake node libxslt" strings
295
 *       the test should just be name[0] = ' '
296
 */
297
298
static const xmlNs xmlXPathXMLNamespaceStruct = {
299
    NULL,
300
    XML_NAMESPACE_DECL,
301
    XML_XML_NAMESPACE,
302
    BAD_CAST "xml",
303
    NULL,
304
    NULL
305
};
306
static const xmlNs *const xmlXPathXMLNamespace = &xmlXPathXMLNamespaceStruct;
307
308
static void
309
xmlXPathNodeSetClear(xmlNodeSetPtr set, int hasNsNodes);
310
311
194M
#define XML_NODE_SORT_VALUE(n) XML_PTR_TO_INT((n)->content)
312
313
#ifdef XP_OPTIMIZED_NON_ELEM_COMPARISON
314
315
/**
316
 * xmlXPathCmpNodesExt:
317
 * @node1:  the first node
318
 * @node2:  the second node
319
 *
320
 * Compare two nodes w.r.t document order.
321
 * This one is optimized for handling of non-element nodes.
322
 *
323
 * Returns -2 in case of error 1 if first point < second point, 0 if
324
 *         it's the same node, -1 otherwise
325
 */
326
static int
327
47.8M
xmlXPathCmpNodesExt(xmlNodePtr node1, xmlNodePtr node2) {
328
47.8M
    int depth1, depth2;
329
47.8M
    int misc = 0, precedence1 = 0, precedence2 = 0;
330
47.8M
    xmlNodePtr miscNode1 = NULL, miscNode2 = NULL;
331
47.8M
    xmlNodePtr cur, root;
332
47.8M
    XML_INTPTR_T l1, l2;
333
334
47.8M
    if ((node1 == NULL) || (node2 == NULL))
335
0
  return(-2);
336
337
47.8M
    if (node1 == node2)
338
0
  return(0);
339
340
    /*
341
     * a couple of optimizations which will avoid computations in most cases
342
     */
343
47.8M
    switch (node1->type) {
344
38.3M
  case XML_ELEMENT_NODE:
345
38.3M
      if (node2->type == XML_ELEMENT_NODE) {
346
27.3M
    if ((0 > XML_NODE_SORT_VALUE(node1)) &&
347
27.3M
        (0 > XML_NODE_SORT_VALUE(node2)) &&
348
27.3M
        (node1->doc == node2->doc))
349
25.9M
    {
350
25.9M
        l1 = -XML_NODE_SORT_VALUE(node1);
351
25.9M
        l2 = -XML_NODE_SORT_VALUE(node2);
352
25.9M
        if (l1 < l2)
353
22.1M
      return(1);
354
3.79M
        if (l1 > l2)
355
3.79M
      return(-1);
356
3.79M
    } else
357
1.43M
        goto turtle_comparison;
358
27.3M
      }
359
10.9M
      break;
360
10.9M
  case XML_ATTRIBUTE_NODE:
361
0
      precedence1 = 1; /* element is owner */
362
0
      miscNode1 = node1;
363
0
      node1 = node1->parent;
364
0
      misc = 1;
365
0
      break;
366
8.87M
  case XML_TEXT_NODE:
367
9.06M
  case XML_CDATA_SECTION_NODE:
368
9.08M
  case XML_COMMENT_NODE:
369
9.36M
  case XML_PI_NODE: {
370
9.36M
      miscNode1 = node1;
371
      /*
372
      * Find nearest element node.
373
      */
374
9.36M
      if (node1->prev != NULL) {
375
14.5M
    do {
376
14.5M
        node1 = node1->prev;
377
14.5M
        if (node1->type == XML_ELEMENT_NODE) {
378
7.57M
      precedence1 = 3; /* element in prev-sibl axis */
379
7.57M
      break;
380
7.57M
        }
381
7.02M
        if (node1->prev == NULL) {
382
545k
      precedence1 = 2; /* element is parent */
383
      /*
384
      * URGENT TODO: Are there any cases, where the
385
      * parent of such a node is not an element node?
386
      */
387
545k
      node1 = node1->parent;
388
545k
      break;
389
545k
        }
390
7.02M
    } while (1);
391
8.12M
      } else {
392
1.24M
    precedence1 = 2; /* element is parent */
393
1.24M
    node1 = node1->parent;
394
1.24M
      }
395
9.36M
      if ((node1 == NULL) || (node1->type != XML_ELEMENT_NODE) ||
396
9.36M
    (0 <= XML_NODE_SORT_VALUE(node1))) {
397
    /*
398
    * Fallback for whatever case.
399
    */
400
178
    node1 = miscNode1;
401
178
    precedence1 = 0;
402
178
      } else
403
9.36M
    misc = 1;
404
9.36M
  }
405
0
      break;
406
66.3k
  case XML_NAMESPACE_DECL:
407
      /*
408
      * TODO: why do we return 1 for namespace nodes?
409
      */
410
66.3k
      return(1);
411
8.67k
  default:
412
8.67k
      break;
413
47.8M
    }
414
20.3M
    switch (node2->type) {
415
6.58M
  case XML_ELEMENT_NODE:
416
6.58M
      break;
417
0
  case XML_ATTRIBUTE_NODE:
418
0
      precedence2 = 1; /* element is owner */
419
0
      miscNode2 = node2;
420
0
      node2 = node2->parent;
421
0
      misc = 1;
422
0
      break;
423
12.9M
  case XML_TEXT_NODE:
424
13.1M
  case XML_CDATA_SECTION_NODE:
425
13.1M
  case XML_COMMENT_NODE:
426
13.4M
  case XML_PI_NODE: {
427
13.4M
      miscNode2 = node2;
428
13.4M
      if (node2->prev != NULL) {
429
18.4M
    do {
430
18.4M
        node2 = node2->prev;
431
18.4M
        if (node2->type == XML_ELEMENT_NODE) {
432
11.4M
      precedence2 = 3; /* element in prev-sibl axis */
433
11.4M
      break;
434
11.4M
        }
435
7.00M
        if (node2->prev == NULL) {
436
550k
      precedence2 = 2; /* element is parent */
437
550k
      node2 = node2->parent;
438
550k
      break;
439
550k
        }
440
7.00M
    } while (1);
441
12.0M
      } else {
442
1.44M
    precedence2 = 2; /* element is parent */
443
1.44M
    node2 = node2->parent;
444
1.44M
      }
445
13.4M
      if ((node2 == NULL) || (node2->type != XML_ELEMENT_NODE) ||
446
13.4M
    (0 <= XML_NODE_SORT_VALUE(node2)))
447
47
      {
448
47
    node2 = miscNode2;
449
47
    precedence2 = 0;
450
47
      } else
451
13.4M
    misc = 1;
452
13.4M
  }
453
0
      break;
454
1.82k
  case XML_NAMESPACE_DECL:
455
1.82k
      return(1);
456
319k
  default:
457
319k
      break;
458
20.3M
    }
459
20.3M
    if (misc) {
460
20.0M
  if (node1 == node2) {
461
3.39M
      if (precedence1 == precedence2) {
462
    /*
463
    * The ugly case; but normally there aren't many
464
    * adjacent non-element nodes around.
465
    */
466
911k
    cur = miscNode2->prev;
467
932k
    while (cur != NULL) {
468
932k
        if (cur == miscNode1)
469
911k
      return(1);
470
21.0k
        if (cur->type == XML_ELEMENT_NODE)
471
218
      return(-1);
472
20.7k
        cur = cur->prev;
473
20.7k
    }
474
10
    return (-1);
475
2.47M
      } else {
476
    /*
477
    * Evaluate based on higher precedence wrt to the element.
478
    * TODO: This assumes attributes are sorted before content.
479
    *   Is this 100% correct?
480
    */
481
2.47M
    if (precedence1 < precedence2)
482
2.16M
        return(1);
483
314k
    else
484
314k
        return(-1);
485
2.47M
      }
486
3.39M
  }
487
  /*
488
  * Special case: One of the helper-elements is contained by the other.
489
  * <foo>
490
  *   <node2>
491
  *     <node1>Text-1(precedence1 == 2)</node1>
492
  *   </node2>
493
  *   Text-6(precedence2 == 3)
494
  * </foo>
495
  */
496
16.6M
  if ((precedence2 == 3) && (precedence1 > 1)) {
497
1.62M
      cur = node1->parent;
498
106M
      while (cur) {
499
104M
    if (cur == node2)
500
140k
        return(1);
501
104M
    cur = cur->parent;
502
104M
      }
503
1.62M
  }
504
16.5M
  if ((precedence1 == 3) && (precedence2 > 1)) {
505
1.42M
      cur = node2->parent;
506
96.1M
      while (cur) {
507
94.8M
    if (cur == node1)
508
99.3k
        return(-1);
509
94.7M
    cur = cur->parent;
510
94.7M
      }
511
1.42M
  }
512
16.5M
    }
513
514
    /*
515
     * Speedup using document order if available.
516
     */
517
16.7M
    if ((node1->type == XML_ELEMENT_NODE) &&
518
16.7M
  (node2->type == XML_ELEMENT_NODE) &&
519
16.7M
  (0 > XML_NODE_SORT_VALUE(node1)) &&
520
16.7M
  (0 > XML_NODE_SORT_VALUE(node2)) &&
521
16.7M
  (node1->doc == node2->doc)) {
522
523
16.4M
  l1 = -XML_NODE_SORT_VALUE(node1);
524
16.4M
  l2 = -XML_NODE_SORT_VALUE(node2);
525
16.4M
  if (l1 < l2)
526
14.4M
      return(1);
527
1.93M
  if (l1 > l2)
528
1.93M
      return(-1);
529
1.93M
    }
530
531
1.75M
turtle_comparison:
532
533
1.75M
    if (node1 == node2->prev)
534
1.43M
  return(1);
535
327k
    if (node1 == node2->next)
536
0
  return(-1);
537
    /*
538
     * compute depth to root
539
     */
540
366k
    for (depth2 = 0, cur = node2; cur->parent != NULL; cur = cur->parent) {
541
47.5k
  if (cur->parent == node1)
542
8.61k
      return(1);
543
38.9k
  depth2++;
544
38.9k
    }
545
319k
    root = cur;
546
16.5M
    for (depth1 = 0, cur = node1; cur->parent != NULL; cur = cur->parent) {
547
16.5M
  if (cur->parent == node2)
548
319k
      return(-1);
549
16.1M
  depth1++;
550
16.1M
    }
551
    /*
552
     * Distinct document (or distinct entities :-( ) case.
553
     */
554
131
    if (root != cur) {
555
16
  return(-2);
556
16
    }
557
    /*
558
     * get the nearest common ancestor.
559
     */
560
184
    while (depth1 > depth2) {
561
69
  depth1--;
562
69
  node1 = node1->parent;
563
69
    }
564
2.74k
    while (depth2 > depth1) {
565
2.62k
  depth2--;
566
2.62k
  node2 = node2->parent;
567
2.62k
    }
568
115
    while (node1->parent != node2->parent) {
569
0
  node1 = node1->parent;
570
0
  node2 = node2->parent;
571
  /* should not happen but just in case ... */
572
0
  if ((node1 == NULL) || (node2 == NULL))
573
0
      return(-2);
574
0
    }
575
    /*
576
     * Find who's first.
577
     */
578
115
    if (node1 == node2->prev)
579
84
  return(1);
580
31
    if (node1 == node2->next)
581
8
  return(-1);
582
    /*
583
     * Speedup using document order if available.
584
     */
585
23
    if ((node1->type == XML_ELEMENT_NODE) &&
586
23
  (node2->type == XML_ELEMENT_NODE) &&
587
23
  (0 > XML_NODE_SORT_VALUE(node1)) &&
588
23
  (0 > XML_NODE_SORT_VALUE(node2)) &&
589
23
  (node1->doc == node2->doc)) {
590
591
0
  l1 = -XML_NODE_SORT_VALUE(node1);
592
0
  l2 = -XML_NODE_SORT_VALUE(node2);
593
0
  if (l1 < l2)
594
0
      return(1);
595
0
  if (l1 > l2)
596
0
      return(-1);
597
0
    }
598
599
46
    for (cur = node1->next;cur != NULL;cur = cur->next)
600
46
  if (cur == node2)
601
23
      return(1);
602
0
    return(-1); /* assume there is no sibling list corruption */
603
23
}
604
#endif /* XP_OPTIMIZED_NON_ELEM_COMPARISON */
605
606
/*
607
 * Wrapper for the Timsort algorithm from timsort.h
608
 */
609
#ifdef WITH_TIM_SORT
610
#define SORT_NAME libxml_domnode
611
3.47M
#define SORT_TYPE xmlNodePtr
612
/**
613
 * wrap_cmp:
614
 * @x: a node
615
 * @y: another node
616
 *
617
 * Comparison function for the Timsort implementation
618
 *
619
 * Returns -2 in case of error -1 if first point < second point, 0 if
620
 *         it's the same node, +1 otherwise
621
 */
622
static
623
int wrap_cmp( xmlNodePtr x, xmlNodePtr y );
624
#ifdef XP_OPTIMIZED_NON_ELEM_COMPARISON
625
    static int wrap_cmp( xmlNodePtr x, xmlNodePtr y )
626
47.8M
    {
627
47.8M
        int res = xmlXPathCmpNodesExt(x, y);
628
47.8M
        return res == -2 ? res : -res;
629
47.8M
    }
630
#else
631
    static int wrap_cmp( xmlNodePtr x, xmlNodePtr y )
632
    {
633
        int res = xmlXPathCmpNodes(x, y);
634
        return res == -2 ? res : -res;
635
    }
636
#endif
637
47.8M
#define SORT_CMP(x, y)  (wrap_cmp(x, y))
638
#include "timsort.h"
639
#endif /* WITH_TIM_SORT */
640
641
/************************************************************************
642
 *                  *
643
 *      Error handling routines       *
644
 *                  *
645
 ************************************************************************/
646
647
/**
648
 * XP_ERRORNULL:
649
 * @X:  the error code
650
 *
651
 * Macro to raise an XPath error and return NULL.
652
 */
653
#define XP_ERRORNULL(X)             \
654
670
    { xmlXPathErr(ctxt, X); return(NULL); }
655
656
/*
657
 * The array xmlXPathErrorMessages corresponds to the enum xmlXPathError
658
 */
659
static const char* const xmlXPathErrorMessages[] = {
660
    "Ok\n",
661
    "Number encoding\n",
662
    "Unfinished literal\n",
663
    "Start of literal\n",
664
    "Expected $ for variable reference\n",
665
    "Undefined variable\n",
666
    "Invalid predicate\n",
667
    "Invalid expression\n",
668
    "Missing closing curly brace\n",
669
    "Unregistered function\n",
670
    "Invalid operand\n",
671
    "Invalid type\n",
672
    "Invalid number of arguments\n",
673
    "Invalid context size\n",
674
    "Invalid context position\n",
675
    "Memory allocation error\n",
676
    "Syntax error\n",
677
    "Resource error\n",
678
    "Sub resource error\n",
679
    "Undefined namespace prefix\n",
680
    "Encoding error\n",
681
    "Char out of XML range\n",
682
    "Invalid or incomplete context\n",
683
    "Stack usage error\n",
684
    "Forbidden variable\n",
685
    "Operation limit exceeded\n",
686
    "Recursion limit exceeded\n",
687
    "?? Unknown error ??\n" /* Must be last in the list! */
688
};
689
15.1k
#define MAXERRNO ((int)(sizeof(xmlXPathErrorMessages) /  \
690
15.1k
       sizeof(xmlXPathErrorMessages[0])) - 1)
691
/**
692
 * xmlXPathErrMemory:
693
 * @ctxt:  an XPath context
694
 *
695
 * Handle a memory allocation failure.
696
 */
697
void
698
xmlXPathErrMemory(xmlXPathContextPtr ctxt)
699
2.83k
{
700
2.83k
    if (ctxt == NULL)
701
0
        return;
702
2.83k
    xmlRaiseMemoryError(ctxt->error, NULL, ctxt->userData, XML_FROM_XPATH,
703
2.83k
                        &ctxt->lastError);
704
2.83k
}
705
706
/**
707
 * xmlXPathPErrMemory:
708
 * @ctxt:  an XPath parser context
709
 *
710
 * Handle a memory allocation failure.
711
 */
712
void
713
xmlXPathPErrMemory(xmlXPathParserContextPtr ctxt)
714
446
{
715
446
    if (ctxt == NULL)
716
0
        return;
717
446
    ctxt->error = XPATH_MEMORY_ERROR;
718
446
    xmlXPathErrMemory(ctxt->context);
719
446
}
720
721
/**
722
 * xmlXPathErr:
723
 * @ctxt:  a XPath parser context
724
 * @code:  the error code
725
 *
726
 * Handle an XPath error
727
 */
728
void
729
xmlXPathErr(xmlXPathParserContextPtr ctxt, int code)
730
15.1k
{
731
15.1k
    xmlStructuredErrorFunc schannel = NULL;
732
15.1k
    xmlGenericErrorFunc channel = NULL;
733
15.1k
    void *data = NULL;
734
15.1k
    xmlNodePtr node = NULL;
735
15.1k
    int res;
736
737
15.1k
    if (ctxt == NULL)
738
0
        return;
739
15.1k
    if ((code < 0) || (code > MAXERRNO))
740
0
  code = MAXERRNO;
741
    /* Only report the first error */
742
15.1k
    if (ctxt->error != 0)
743
340
        return;
744
745
14.7k
    ctxt->error = code;
746
747
14.7k
    if (ctxt->context != NULL) {
748
14.7k
        xmlErrorPtr err = &ctxt->context->lastError;
749
750
        /* Don't overwrite memory error. */
751
14.7k
        if (err->code == XML_ERR_NO_MEMORY)
752
0
            return;
753
754
        /* cleanup current last error */
755
14.7k
        xmlResetError(err);
756
757
14.7k
        err->domain = XML_FROM_XPATH;
758
14.7k
        err->code = code + XML_XPATH_EXPRESSION_OK - XPATH_EXPRESSION_OK;
759
14.7k
        err->level = XML_ERR_ERROR;
760
14.7k
        if (ctxt->base != NULL) {
761
11.9k
            err->str1 = (char *) xmlStrdup(ctxt->base);
762
11.9k
            if (err->str1 == NULL) {
763
1
                xmlXPathPErrMemory(ctxt);
764
1
                return;
765
1
            }
766
11.9k
        }
767
14.7k
        err->int1 = ctxt->cur - ctxt->base;
768
14.7k
        err->node = ctxt->context->debugNode;
769
770
14.7k
        schannel = ctxt->context->error;
771
14.7k
        data = ctxt->context->userData;
772
14.7k
        node = ctxt->context->debugNode;
773
14.7k
    }
774
775
14.7k
    if (schannel == NULL) {
776
14.7k
        channel = xmlGenericError;
777
14.7k
        data = xmlGenericErrorContext;
778
14.7k
    }
779
780
14.7k
    res = xmlRaiseError(schannel, channel, data, NULL, node, XML_FROM_XPATH,
781
14.7k
                        code + XML_XPATH_EXPRESSION_OK - XPATH_EXPRESSION_OK,
782
14.7k
                        XML_ERR_ERROR, NULL, 0,
783
14.7k
                        (const char *) ctxt->base, NULL, NULL,
784
14.7k
                        ctxt->cur - ctxt->base, 0,
785
14.7k
                        "%s", xmlXPathErrorMessages[code]);
786
14.7k
    if (res < 0)
787
1
        xmlXPathPErrMemory(ctxt);
788
14.7k
}
789
790
/**
791
 * xmlXPatherror:
792
 * @ctxt:  the XPath Parser context
793
 * @file:  the file name
794
 * @line:  the line number
795
 * @no:  the error number
796
 *
797
 * Formats an error message.
798
 */
799
void
800
xmlXPatherror(xmlXPathParserContextPtr ctxt, const char *file ATTRIBUTE_UNUSED,
801
3.70k
              int line ATTRIBUTE_UNUSED, int no) {
802
3.70k
    xmlXPathErr(ctxt, no);
803
3.70k
}
804
805
/**
806
 * xmlXPathCheckOpLimit:
807
 * @ctxt:  the XPath Parser context
808
 * @opCount:  the number of operations to be added
809
 *
810
 * Adds opCount to the running total of operations and returns -1 if the
811
 * operation limit is exceeded. Returns 0 otherwise.
812
 */
813
static int
814
34.4M
xmlXPathCheckOpLimit(xmlXPathParserContextPtr ctxt, unsigned long opCount) {
815
34.4M
    xmlXPathContextPtr xpctxt = ctxt->context;
816
817
34.4M
    if ((opCount > xpctxt->opLimit) ||
818
34.4M
        (xpctxt->opCount > xpctxt->opLimit - opCount)) {
819
186
        xpctxt->opCount = xpctxt->opLimit;
820
186
        xmlXPathErr(ctxt, XPATH_OP_LIMIT_EXCEEDED);
821
186
        return(-1);
822
186
    }
823
824
34.4M
    xpctxt->opCount += opCount;
825
34.4M
    return(0);
826
34.4M
}
827
828
#define OP_LIMIT_EXCEEDED(ctxt, n) \
829
34.2M
    ((ctxt->context->opLimit != 0) && (xmlXPathCheckOpLimit(ctxt, n) < 0))
830
831
/************************************************************************
832
 *                  *
833
 *      Parser Types          *
834
 *                  *
835
 ************************************************************************/
836
837
/*
838
 * Types are private:
839
 */
840
841
typedef enum {
842
    XPATH_OP_END=0,
843
    XPATH_OP_AND,
844
    XPATH_OP_OR,
845
    XPATH_OP_EQUAL,
846
    XPATH_OP_CMP,
847
    XPATH_OP_PLUS,
848
    XPATH_OP_MULT,
849
    XPATH_OP_UNION,
850
    XPATH_OP_ROOT,
851
    XPATH_OP_NODE,
852
    XPATH_OP_COLLECT,
853
    XPATH_OP_VALUE, /* 11 */
854
    XPATH_OP_VARIABLE,
855
    XPATH_OP_FUNCTION,
856
    XPATH_OP_ARG,
857
    XPATH_OP_PREDICATE,
858
    XPATH_OP_FILTER, /* 16 */
859
    XPATH_OP_SORT /* 17 */
860
} xmlXPathOp;
861
862
typedef enum {
863
    AXIS_ANCESTOR = 1,
864
    AXIS_ANCESTOR_OR_SELF,
865
    AXIS_ATTRIBUTE,
866
    AXIS_CHILD,
867
    AXIS_DESCENDANT,
868
    AXIS_DESCENDANT_OR_SELF,
869
    AXIS_FOLLOWING,
870
    AXIS_FOLLOWING_SIBLING,
871
    AXIS_NAMESPACE,
872
    AXIS_PARENT,
873
    AXIS_PRECEDING,
874
    AXIS_PRECEDING_SIBLING,
875
    AXIS_SELF
876
} xmlXPathAxisVal;
877
878
typedef enum {
879
    NODE_TEST_NONE = 0,
880
    NODE_TEST_TYPE = 1,
881
    NODE_TEST_PI = 2,
882
    NODE_TEST_ALL = 3,
883
    NODE_TEST_NS = 4,
884
    NODE_TEST_NAME = 5
885
} xmlXPathTestVal;
886
887
typedef enum {
888
    NODE_TYPE_NODE = 0,
889
    NODE_TYPE_COMMENT = XML_COMMENT_NODE,
890
    NODE_TYPE_TEXT = XML_TEXT_NODE,
891
    NODE_TYPE_PI = XML_PI_NODE
892
} xmlXPathTypeVal;
893
894
typedef struct _xmlXPathStepOp xmlXPathStepOp;
895
typedef xmlXPathStepOp *xmlXPathStepOpPtr;
896
struct _xmlXPathStepOp {
897
    xmlXPathOp op;    /* The identifier of the operation */
898
    int ch1;      /* First child */
899
    int ch2;      /* Second child */
900
    int value;
901
    int value2;
902
    int value3;
903
    void *value4;
904
    void *value5;
905
    xmlXPathFunction cache;
906
    void *cacheURI;
907
};
908
909
struct _xmlXPathCompExpr {
910
    int nbStep;     /* Number of steps in this expression */
911
    int maxStep;    /* Maximum number of steps allocated */
912
    xmlXPathStepOp *steps;  /* ops for computation of this expression */
913
    int last;     /* index of last step in expression */
914
    xmlChar *expr;    /* the expression being computed */
915
    xmlDictPtr dict;    /* the dictionary to use if any */
916
#ifdef XPATH_STREAMING
917
    xmlPatternPtr stream;
918
#endif
919
};
920
921
/************************************************************************
922
 *                  *
923
 *      Forward declarations        *
924
 *                  *
925
 ************************************************************************/
926
927
static void
928
xmlXPathReleaseObject(xmlXPathContextPtr ctxt, xmlXPathObjectPtr obj);
929
static int
930
xmlXPathCompOpEvalFirst(xmlXPathParserContextPtr ctxt,
931
                        xmlXPathStepOpPtr op, xmlNodePtr *first);
932
static int
933
xmlXPathCompOpEvalToBoolean(xmlXPathParserContextPtr ctxt,
934
          xmlXPathStepOpPtr op,
935
          int isPredicate);
936
static void
937
xmlXPathFreeObjectEntry(void *obj, const xmlChar *name);
938
939
/************************************************************************
940
 *                  *
941
 *      Parser Type functions       *
942
 *                  *
943
 ************************************************************************/
944
945
/**
946
 * xmlXPathNewCompExpr:
947
 *
948
 * Create a new Xpath component
949
 *
950
 * Returns the newly allocated xmlXPathCompExprPtr or NULL in case of error
951
 */
952
static xmlXPathCompExprPtr
953
15.8k
xmlXPathNewCompExpr(void) {
954
15.8k
    xmlXPathCompExprPtr cur;
955
956
15.8k
    cur = (xmlXPathCompExprPtr) xmlMalloc(sizeof(xmlXPathCompExpr));
957
15.8k
    if (cur == NULL)
958
0
  return(NULL);
959
15.8k
    memset(cur, 0, sizeof(xmlXPathCompExpr));
960
15.8k
#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
961
15.8k
    cur->maxStep = 1;
962
#else
963
    cur->maxStep = 10;
964
#endif
965
15.8k
    cur->nbStep = 0;
966
15.8k
    cur->steps = (xmlXPathStepOp *) xmlMalloc(cur->maxStep *
967
15.8k
                                     sizeof(xmlXPathStepOp));
968
15.8k
    if (cur->steps == NULL) {
969
0
  xmlFree(cur);
970
0
  return(NULL);
971
0
    }
972
15.8k
    memset(cur->steps, 0, cur->maxStep * sizeof(xmlXPathStepOp));
973
15.8k
    cur->last = -1;
974
15.8k
    return(cur);
975
15.8k
}
976
977
/**
978
 * xmlXPathFreeCompExpr:
979
 * @comp:  an XPATH comp
980
 *
981
 * Free up the memory allocated by @comp
982
 */
983
void
984
xmlXPathFreeCompExpr(xmlXPathCompExprPtr comp)
985
15.8k
{
986
15.8k
    xmlXPathStepOpPtr op;
987
15.8k
    int i;
988
989
15.8k
    if (comp == NULL)
990
0
        return;
991
15.8k
    if (comp->dict == NULL) {
992
943k
  for (i = 0; i < comp->nbStep; i++) {
993
927k
      op = &comp->steps[i];
994
927k
      if (op->value4 != NULL) {
995
2.71k
    if (op->op == XPATH_OP_VALUE)
996
1.59k
        xmlXPathFreeObject(op->value4);
997
1.12k
    else
998
1.12k
        xmlFree(op->value4);
999
2.71k
      }
1000
927k
      if (op->value5 != NULL)
1001
596k
    xmlFree(op->value5);
1002
927k
  }
1003
15.8k
    } else {
1004
0
  for (i = 0; i < comp->nbStep; i++) {
1005
0
      op = &comp->steps[i];
1006
0
      if (op->value4 != NULL) {
1007
0
    if (op->op == XPATH_OP_VALUE)
1008
0
        xmlXPathFreeObject(op->value4);
1009
0
      }
1010
0
  }
1011
0
        xmlDictFree(comp->dict);
1012
0
    }
1013
15.8k
    if (comp->steps != NULL) {
1014
15.8k
        xmlFree(comp->steps);
1015
15.8k
    }
1016
#ifdef XPATH_STREAMING
1017
    if (comp->stream != NULL) {
1018
        xmlFreePatternList(comp->stream);
1019
    }
1020
#endif
1021
15.8k
    if (comp->expr != NULL) {
1022
3.04k
        xmlFree(comp->expr);
1023
3.04k
    }
1024
1025
15.8k
    xmlFree(comp);
1026
15.8k
}
1027
1028
/**
1029
 * xmlXPathCompExprAdd:
1030
 * @comp:  the compiled expression
1031
 * @ch1: first child index
1032
 * @ch2: second child index
1033
 * @op:  an op
1034
 * @value:  the first int value
1035
 * @value2:  the second int value
1036
 * @value3:  the third int value
1037
 * @value4:  the first string value
1038
 * @value5:  the second string value
1039
 *
1040
 * Add a step to an XPath Compiled Expression
1041
 *
1042
 * Returns -1 in case of failure, the index otherwise
1043
 */
1044
static int
1045
xmlXPathCompExprAdd(xmlXPathParserContextPtr ctxt, int ch1, int ch2,
1046
   xmlXPathOp op, int value,
1047
927k
   int value2, int value3, void *value4, void *value5) {
1048
927k
    xmlXPathCompExprPtr comp = ctxt->comp;
1049
927k
    if (comp->nbStep >= comp->maxStep) {
1050
23.1k
  xmlXPathStepOp *real;
1051
23.1k
        int newSize;
1052
1053
23.1k
        newSize = xmlGrowCapacity(comp->maxStep, sizeof(real[0]),
1054
23.1k
                                  10, XPATH_MAX_STEPS);
1055
23.1k
        if (newSize < 0) {
1056
0
      xmlXPathPErrMemory(ctxt);
1057
0
      return(-1);
1058
0
        }
1059
23.1k
  real = xmlRealloc(comp->steps, newSize * sizeof(real[0]));
1060
23.1k
  if (real == NULL) {
1061
0
      xmlXPathPErrMemory(ctxt);
1062
0
      return(-1);
1063
0
  }
1064
23.1k
  comp->steps = real;
1065
23.1k
  comp->maxStep = newSize;
1066
23.1k
    }
1067
927k
    comp->last = comp->nbStep;
1068
927k
    comp->steps[comp->nbStep].ch1 = ch1;
1069
927k
    comp->steps[comp->nbStep].ch2 = ch2;
1070
927k
    comp->steps[comp->nbStep].op = op;
1071
927k
    comp->steps[comp->nbStep].value = value;
1072
927k
    comp->steps[comp->nbStep].value2 = value2;
1073
927k
    comp->steps[comp->nbStep].value3 = value3;
1074
927k
    if ((comp->dict != NULL) &&
1075
927k
        ((op == XPATH_OP_FUNCTION) || (op == XPATH_OP_VARIABLE) ||
1076
0
   (op == XPATH_OP_COLLECT))) {
1077
0
        if (value4 != NULL) {
1078
0
      comp->steps[comp->nbStep].value4 = (xmlChar *)
1079
0
          (void *)xmlDictLookup(comp->dict, value4, -1);
1080
0
      xmlFree(value4);
1081
0
  } else
1082
0
      comp->steps[comp->nbStep].value4 = NULL;
1083
0
        if (value5 != NULL) {
1084
0
      comp->steps[comp->nbStep].value5 = (xmlChar *)
1085
0
          (void *)xmlDictLookup(comp->dict, value5, -1);
1086
0
      xmlFree(value5);
1087
0
  } else
1088
0
      comp->steps[comp->nbStep].value5 = NULL;
1089
927k
    } else {
1090
927k
  comp->steps[comp->nbStep].value4 = value4;
1091
927k
  comp->steps[comp->nbStep].value5 = value5;
1092
927k
    }
1093
927k
    comp->steps[comp->nbStep].cache = NULL;
1094
927k
    return(comp->nbStep++);
1095
927k
}
1096
1097
#define PUSH_FULL_EXPR(op, op1, op2, val, val2, val3, val4, val5) \
1098
678k
    xmlXPathCompExprAdd(ctxt, (op1), (op2),     \
1099
678k
                  (op), (val), (val2), (val3), (val4), (val5))
1100
#define PUSH_LONG_EXPR(op, val, val2, val3, val4, val5)     \
1101
71.1k
    xmlXPathCompExprAdd(ctxt, ctxt->comp->last, -1,   \
1102
71.1k
                  (op), (val), (val2), (val3), (val4), (val5))
1103
1104
88.5k
#define PUSH_LEAVE_EXPR(op, val, val2)          \
1105
88.5k
xmlXPathCompExprAdd(ctxt, -1, -1, (op), (val), (val2), 0 ,NULL ,NULL)
1106
1107
9.57k
#define PUSH_UNARY_EXPR(op, ch, val, val2)        \
1108
9.57k
xmlXPathCompExprAdd(ctxt, (ch), -1, (op), (val), (val2), 0 ,NULL ,NULL)
1109
1110
79.8k
#define PUSH_BINARY_EXPR(op, ch1, ch2, val, val2)     \
1111
79.8k
xmlXPathCompExprAdd(ctxt, (ch1), (ch2), (op),     \
1112
79.8k
      (val), (val2), 0 ,NULL ,NULL)
1113
1114
/************************************************************************
1115
 *                  *
1116
 *    XPath object cache structures       *
1117
 *                  *
1118
 ************************************************************************/
1119
1120
/* #define XP_DEFAULT_CACHE_ON */
1121
1122
typedef struct _xmlXPathContextCache xmlXPathContextCache;
1123
typedef xmlXPathContextCache *xmlXPathContextCachePtr;
1124
struct _xmlXPathContextCache {
1125
    xmlXPathObjectPtr nodesetObjs;  /* stringval points to next */
1126
    xmlXPathObjectPtr miscObjs;     /* stringval points to next */
1127
    int numNodeset;
1128
    int maxNodeset;
1129
    int numMisc;
1130
    int maxMisc;
1131
};
1132
1133
/************************************************************************
1134
 *                  *
1135
 *    Debugging related functions       *
1136
 *                  *
1137
 ************************************************************************/
1138
1139
#ifdef LIBXML_DEBUG_ENABLED
1140
static void
1141
0
xmlXPathDebugDumpNode(FILE *output, xmlNodePtr cur, int depth) {
1142
0
    int i;
1143
0
    char shift[100];
1144
1145
0
    for (i = 0;((i < depth) && (i < 25));i++)
1146
0
        shift[2 * i] = shift[2 * i + 1] = ' ';
1147
0
    shift[2 * i] = shift[2 * i + 1] = 0;
1148
0
    if (cur == NULL) {
1149
0
  fprintf(output, "%s", shift);
1150
0
  fprintf(output, "Node is NULL !\n");
1151
0
  return;
1152
1153
0
    }
1154
1155
0
    if ((cur->type == XML_DOCUMENT_NODE) ||
1156
0
       (cur->type == XML_HTML_DOCUMENT_NODE)) {
1157
0
  fprintf(output, "%s", shift);
1158
0
  fprintf(output, " /\n");
1159
0
    } else if (cur->type == XML_ATTRIBUTE_NODE)
1160
0
  xmlDebugDumpAttr(output, (xmlAttrPtr)cur, depth);
1161
0
    else
1162
0
  xmlDebugDumpOneNode(output, cur, depth);
1163
0
}
1164
static void
1165
0
xmlXPathDebugDumpNodeList(FILE *output, xmlNodePtr cur, int depth) {
1166
0
    xmlNodePtr tmp;
1167
0
    int i;
1168
0
    char shift[100];
1169
1170
0
    for (i = 0;((i < depth) && (i < 25));i++)
1171
0
        shift[2 * i] = shift[2 * i + 1] = ' ';
1172
0
    shift[2 * i] = shift[2 * i + 1] = 0;
1173
0
    if (cur == NULL) {
1174
0
  fprintf(output, "%s", shift);
1175
0
  fprintf(output, "Node is NULL !\n");
1176
0
  return;
1177
1178
0
    }
1179
1180
0
    while (cur != NULL) {
1181
0
  tmp = cur;
1182
0
  cur = cur->next;
1183
0
  xmlDebugDumpOneNode(output, tmp, depth);
1184
0
    }
1185
0
}
1186
1187
static void
1188
0
xmlXPathDebugDumpNodeSet(FILE *output, xmlNodeSetPtr cur, int depth) {
1189
0
    int i;
1190
0
    char shift[100];
1191
1192
0
    for (i = 0;((i < depth) && (i < 25));i++)
1193
0
        shift[2 * i] = shift[2 * i + 1] = ' ';
1194
0
    shift[2 * i] = shift[2 * i + 1] = 0;
1195
1196
0
    if (cur == NULL) {
1197
0
  fprintf(output, "%s", shift);
1198
0
  fprintf(output, "NodeSet is NULL !\n");
1199
0
  return;
1200
1201
0
    }
1202
1203
0
    if (cur != NULL) {
1204
0
  fprintf(output, "Set contains %d nodes:\n", cur->nodeNr);
1205
0
  for (i = 0;i < cur->nodeNr;i++) {
1206
0
      fprintf(output, "%s", shift);
1207
0
      fprintf(output, "%d", i + 1);
1208
0
      xmlXPathDebugDumpNode(output, cur->nodeTab[i], depth + 1);
1209
0
  }
1210
0
    }
1211
0
}
1212
1213
static void
1214
0
xmlXPathDebugDumpValueTree(FILE *output, xmlNodeSetPtr cur, int depth) {
1215
0
    int i;
1216
0
    char shift[100];
1217
1218
0
    for (i = 0;((i < depth) && (i < 25));i++)
1219
0
        shift[2 * i] = shift[2 * i + 1] = ' ';
1220
0
    shift[2 * i] = shift[2 * i + 1] = 0;
1221
1222
0
    if ((cur == NULL) || (cur->nodeNr == 0) || (cur->nodeTab[0] == NULL)) {
1223
0
  fprintf(output, "%s", shift);
1224
0
  fprintf(output, "Value Tree is NULL !\n");
1225
0
  return;
1226
1227
0
    }
1228
1229
0
    fprintf(output, "%s", shift);
1230
0
    fprintf(output, "%d", i + 1);
1231
0
    xmlXPathDebugDumpNodeList(output, cur->nodeTab[0]->children, depth + 1);
1232
0
}
1233
1234
/**
1235
 * xmlXPathDebugDumpObject:
1236
 * @output:  the FILE * to dump the output
1237
 * @cur:  the object to inspect
1238
 * @depth:  indentation level
1239
 *
1240
 * Dump the content of the object for debugging purposes
1241
 */
1242
void
1243
0
xmlXPathDebugDumpObject(FILE *output, xmlXPathObjectPtr cur, int depth) {
1244
0
    int i;
1245
0
    char shift[100];
1246
1247
0
    if (output == NULL) return;
1248
1249
0
    for (i = 0;((i < depth) && (i < 25));i++)
1250
0
        shift[2 * i] = shift[2 * i + 1] = ' ';
1251
0
    shift[2 * i] = shift[2 * i + 1] = 0;
1252
1253
1254
0
    fprintf(output, "%s", shift);
1255
1256
0
    if (cur == NULL) {
1257
0
        fprintf(output, "Object is empty (NULL)\n");
1258
0
  return;
1259
0
    }
1260
0
    switch(cur->type) {
1261
0
        case XPATH_UNDEFINED:
1262
0
      fprintf(output, "Object is uninitialized\n");
1263
0
      break;
1264
0
        case XPATH_NODESET:
1265
0
      fprintf(output, "Object is a Node Set :\n");
1266
0
      xmlXPathDebugDumpNodeSet(output, cur->nodesetval, depth);
1267
0
      break;
1268
0
  case XPATH_XSLT_TREE:
1269
0
      fprintf(output, "Object is an XSLT value tree :\n");
1270
0
      xmlXPathDebugDumpValueTree(output, cur->nodesetval, depth);
1271
0
      break;
1272
0
        case XPATH_BOOLEAN:
1273
0
      fprintf(output, "Object is a Boolean : ");
1274
0
      if (cur->boolval) fprintf(output, "true\n");
1275
0
      else fprintf(output, "false\n");
1276
0
      break;
1277
0
        case XPATH_NUMBER:
1278
0
      switch (xmlXPathIsInf(cur->floatval)) {
1279
0
      case 1:
1280
0
    fprintf(output, "Object is a number : Infinity\n");
1281
0
    break;
1282
0
      case -1:
1283
0
    fprintf(output, "Object is a number : -Infinity\n");
1284
0
    break;
1285
0
      default:
1286
0
    if (xmlXPathIsNaN(cur->floatval)) {
1287
0
        fprintf(output, "Object is a number : NaN\n");
1288
0
    } else if (cur->floatval == 0) {
1289
                    /* Omit sign for negative zero. */
1290
0
        fprintf(output, "Object is a number : 0\n");
1291
0
    } else {
1292
0
        fprintf(output, "Object is a number : %0g\n", cur->floatval);
1293
0
    }
1294
0
      }
1295
0
      break;
1296
0
        case XPATH_STRING:
1297
0
      fprintf(output, "Object is a string : ");
1298
0
      xmlDebugDumpString(output, cur->stringval);
1299
0
      fprintf(output, "\n");
1300
0
      break;
1301
0
  case XPATH_USERS:
1302
0
      fprintf(output, "Object is user defined\n");
1303
0
      break;
1304
0
    }
1305
0
}
1306
1307
static void
1308
xmlXPathDebugDumpStepOp(FILE *output, xmlXPathCompExprPtr comp,
1309
0
                       xmlXPathStepOpPtr op, int depth) {
1310
0
    int i;
1311
0
    char shift[100];
1312
1313
0
    for (i = 0;((i < depth) && (i < 25));i++)
1314
0
        shift[2 * i] = shift[2 * i + 1] = ' ';
1315
0
    shift[2 * i] = shift[2 * i + 1] = 0;
1316
1317
0
    fprintf(output, "%s", shift);
1318
0
    if (op == NULL) {
1319
0
  fprintf(output, "Step is NULL\n");
1320
0
  return;
1321
0
    }
1322
0
    switch (op->op) {
1323
0
        case XPATH_OP_END:
1324
0
      fprintf(output, "END"); break;
1325
0
        case XPATH_OP_AND:
1326
0
      fprintf(output, "AND"); break;
1327
0
        case XPATH_OP_OR:
1328
0
      fprintf(output, "OR"); break;
1329
0
        case XPATH_OP_EQUAL:
1330
0
       if (op->value)
1331
0
     fprintf(output, "EQUAL =");
1332
0
       else
1333
0
     fprintf(output, "EQUAL !=");
1334
0
       break;
1335
0
        case XPATH_OP_CMP:
1336
0
       if (op->value)
1337
0
     fprintf(output, "CMP <");
1338
0
       else
1339
0
     fprintf(output, "CMP >");
1340
0
       if (!op->value2)
1341
0
     fprintf(output, "=");
1342
0
       break;
1343
0
        case XPATH_OP_PLUS:
1344
0
       if (op->value == 0)
1345
0
     fprintf(output, "PLUS -");
1346
0
       else if (op->value == 1)
1347
0
     fprintf(output, "PLUS +");
1348
0
       else if (op->value == 2)
1349
0
     fprintf(output, "PLUS unary -");
1350
0
       else if (op->value == 3)
1351
0
     fprintf(output, "PLUS unary - -");
1352
0
       break;
1353
0
        case XPATH_OP_MULT:
1354
0
       if (op->value == 0)
1355
0
     fprintf(output, "MULT *");
1356
0
       else if (op->value == 1)
1357
0
     fprintf(output, "MULT div");
1358
0
       else
1359
0
     fprintf(output, "MULT mod");
1360
0
       break;
1361
0
        case XPATH_OP_UNION:
1362
0
       fprintf(output, "UNION"); break;
1363
0
        case XPATH_OP_ROOT:
1364
0
       fprintf(output, "ROOT"); break;
1365
0
        case XPATH_OP_NODE:
1366
0
       fprintf(output, "NODE"); break;
1367
0
        case XPATH_OP_SORT:
1368
0
       fprintf(output, "SORT"); break;
1369
0
        case XPATH_OP_COLLECT: {
1370
0
      xmlXPathAxisVal axis = (xmlXPathAxisVal)op->value;
1371
0
      xmlXPathTestVal test = (xmlXPathTestVal)op->value2;
1372
0
      xmlXPathTypeVal type = (xmlXPathTypeVal)op->value3;
1373
0
      const xmlChar *prefix = op->value4;
1374
0
      const xmlChar *name = op->value5;
1375
1376
0
      fprintf(output, "COLLECT ");
1377
0
      switch (axis) {
1378
0
    case AXIS_ANCESTOR:
1379
0
        fprintf(output, " 'ancestors' "); break;
1380
0
    case AXIS_ANCESTOR_OR_SELF:
1381
0
        fprintf(output, " 'ancestors-or-self' "); break;
1382
0
    case AXIS_ATTRIBUTE:
1383
0
        fprintf(output, " 'attributes' "); break;
1384
0
    case AXIS_CHILD:
1385
0
        fprintf(output, " 'child' "); break;
1386
0
    case AXIS_DESCENDANT:
1387
0
        fprintf(output, " 'descendant' "); break;
1388
0
    case AXIS_DESCENDANT_OR_SELF:
1389
0
        fprintf(output, " 'descendant-or-self' "); break;
1390
0
    case AXIS_FOLLOWING:
1391
0
        fprintf(output, " 'following' "); break;
1392
0
    case AXIS_FOLLOWING_SIBLING:
1393
0
        fprintf(output, " 'following-siblings' "); break;
1394
0
    case AXIS_NAMESPACE:
1395
0
        fprintf(output, " 'namespace' "); break;
1396
0
    case AXIS_PARENT:
1397
0
        fprintf(output, " 'parent' "); break;
1398
0
    case AXIS_PRECEDING:
1399
0
        fprintf(output, " 'preceding' "); break;
1400
0
    case AXIS_PRECEDING_SIBLING:
1401
0
        fprintf(output, " 'preceding-sibling' "); break;
1402
0
    case AXIS_SELF:
1403
0
        fprintf(output, " 'self' "); break;
1404
0
      }
1405
0
      switch (test) {
1406
0
                case NODE_TEST_NONE:
1407
0
        fprintf(output, "'none' "); break;
1408
0
                case NODE_TEST_TYPE:
1409
0
        fprintf(output, "'type' "); break;
1410
0
                case NODE_TEST_PI:
1411
0
        fprintf(output, "'PI' "); break;
1412
0
                case NODE_TEST_ALL:
1413
0
        fprintf(output, "'all' "); break;
1414
0
                case NODE_TEST_NS:
1415
0
        fprintf(output, "'namespace' "); break;
1416
0
                case NODE_TEST_NAME:
1417
0
        fprintf(output, "'name' "); break;
1418
0
      }
1419
0
      switch (type) {
1420
0
                case NODE_TYPE_NODE:
1421
0
        fprintf(output, "'node' "); break;
1422
0
                case NODE_TYPE_COMMENT:
1423
0
        fprintf(output, "'comment' "); break;
1424
0
                case NODE_TYPE_TEXT:
1425
0
        fprintf(output, "'text' "); break;
1426
0
                case NODE_TYPE_PI:
1427
0
        fprintf(output, "'PI' "); break;
1428
0
      }
1429
0
      if (prefix != NULL)
1430
0
    fprintf(output, "%s:", prefix);
1431
0
      if (name != NULL)
1432
0
    fprintf(output, "%s", (const char *) name);
1433
0
      break;
1434
1435
0
        }
1436
0
  case XPATH_OP_VALUE: {
1437
0
      xmlXPathObjectPtr object = (xmlXPathObjectPtr) op->value4;
1438
1439
0
      fprintf(output, "ELEM ");
1440
0
      xmlXPathDebugDumpObject(output, object, 0);
1441
0
      goto finish;
1442
0
  }
1443
0
  case XPATH_OP_VARIABLE: {
1444
0
      const xmlChar *prefix = op->value5;
1445
0
      const xmlChar *name = op->value4;
1446
1447
0
      if (prefix != NULL)
1448
0
    fprintf(output, "VARIABLE %s:%s", prefix, name);
1449
0
      else
1450
0
    fprintf(output, "VARIABLE %s", name);
1451
0
      break;
1452
0
  }
1453
0
  case XPATH_OP_FUNCTION: {
1454
0
      int nbargs = op->value;
1455
0
      const xmlChar *prefix = op->value5;
1456
0
      const xmlChar *name = op->value4;
1457
1458
0
      if (prefix != NULL)
1459
0
    fprintf(output, "FUNCTION %s:%s(%d args)",
1460
0
      prefix, name, nbargs);
1461
0
      else
1462
0
    fprintf(output, "FUNCTION %s(%d args)", name, nbargs);
1463
0
      break;
1464
0
  }
1465
0
        case XPATH_OP_ARG: fprintf(output, "ARG"); break;
1466
0
        case XPATH_OP_PREDICATE: fprintf(output, "PREDICATE"); break;
1467
0
        case XPATH_OP_FILTER: fprintf(output, "FILTER"); break;
1468
0
  default:
1469
0
        fprintf(output, "UNKNOWN %d\n", op->op); return;
1470
0
    }
1471
0
    fprintf(output, "\n");
1472
0
finish:
1473
    /* OP_VALUE has invalid ch1. */
1474
0
    if (op->op == XPATH_OP_VALUE)
1475
0
        return;
1476
1477
0
    if (op->ch1 >= 0)
1478
0
  xmlXPathDebugDumpStepOp(output, comp, &comp->steps[op->ch1], depth + 1);
1479
0
    if (op->ch2 >= 0)
1480
0
  xmlXPathDebugDumpStepOp(output, comp, &comp->steps[op->ch2], depth + 1);
1481
0
}
1482
1483
/**
1484
 * xmlXPathDebugDumpCompExpr:
1485
 * @output:  the FILE * for the output
1486
 * @comp:  the precompiled XPath expression
1487
 * @depth:  the indentation level.
1488
 *
1489
 * Dumps the tree of the compiled XPath expression.
1490
 */
1491
void
1492
xmlXPathDebugDumpCompExpr(FILE *output, xmlXPathCompExprPtr comp,
1493
0
                    int depth) {
1494
0
    int i;
1495
0
    char shift[100];
1496
1497
0
    if ((output == NULL) || (comp == NULL)) return;
1498
1499
0
    for (i = 0;((i < depth) && (i < 25));i++)
1500
0
        shift[2 * i] = shift[2 * i + 1] = ' ';
1501
0
    shift[2 * i] = shift[2 * i + 1] = 0;
1502
1503
0
    fprintf(output, "%s", shift);
1504
1505
#ifdef XPATH_STREAMING
1506
    if (comp->stream) {
1507
        fprintf(output, "Streaming Expression\n");
1508
    } else
1509
#endif
1510
0
    {
1511
0
        fprintf(output, "Compiled Expression : %d elements\n",
1512
0
                comp->nbStep);
1513
0
        i = comp->last;
1514
0
        xmlXPathDebugDumpStepOp(output, comp, &comp->steps[i], depth + 1);
1515
0
    }
1516
0
}
1517
1518
#endif /* LIBXML_DEBUG_ENABLED */
1519
1520
/************************************************************************
1521
 *                  *
1522
 *      XPath object caching        *
1523
 *                  *
1524
 ************************************************************************/
1525
1526
/**
1527
 * xmlXPathNewCache:
1528
 *
1529
 * Create a new object cache
1530
 *
1531
 * Returns the xmlXPathCache just allocated.
1532
 */
1533
static xmlXPathContextCachePtr
1534
xmlXPathNewCache(void)
1535
794
{
1536
794
    xmlXPathContextCachePtr ret;
1537
1538
794
    ret = (xmlXPathContextCachePtr) xmlMalloc(sizeof(xmlXPathContextCache));
1539
794
    if (ret == NULL)
1540
0
  return(NULL);
1541
794
    memset(ret, 0 , sizeof(xmlXPathContextCache));
1542
794
    ret->maxNodeset = 100;
1543
794
    ret->maxMisc = 100;
1544
794
    return(ret);
1545
794
}
1546
1547
static void
1548
xmlXPathCacheFreeObjectList(xmlXPathObjectPtr list)
1549
1.07k
{
1550
25.1k
    while (list != NULL) {
1551
24.0k
        xmlXPathObjectPtr next;
1552
1553
24.0k
        next = (void *) list->stringval;
1554
1555
24.0k
  if (list->nodesetval != NULL) {
1556
15.6k
      if (list->nodesetval->nodeTab != NULL)
1557
14.7k
    xmlFree(list->nodesetval->nodeTab);
1558
15.6k
      xmlFree(list->nodesetval);
1559
15.6k
  }
1560
24.0k
  xmlFree(list);
1561
1562
24.0k
        list = next;
1563
24.0k
    }
1564
1.07k
}
1565
1566
static void
1567
xmlXPathFreeCache(xmlXPathContextCachePtr cache)
1568
792
{
1569
792
    if (cache == NULL)
1570
0
  return;
1571
792
    if (cache->nodesetObjs)
1572
792
  xmlXPathCacheFreeObjectList(cache->nodesetObjs);
1573
792
    if (cache->miscObjs)
1574
280
  xmlXPathCacheFreeObjectList(cache->miscObjs);
1575
792
    xmlFree(cache);
1576
792
}
1577
1578
/**
1579
 * xmlXPathContextSetCache:
1580
 *
1581
 * @ctxt:  the XPath context
1582
 * @active: enables/disables (creates/frees) the cache
1583
 * @value: a value with semantics dependent on @options
1584
 * @options: options (currently only the value 0 is used)
1585
 *
1586
 * Creates/frees an object cache on the XPath context.
1587
 * If activates XPath objects (xmlXPathObject) will be cached internally
1588
 * to be reused.
1589
 * @options:
1590
 *   0: This will set the XPath object caching:
1591
 *      @value:
1592
 *        This will set the maximum number of XPath objects
1593
 *        to be cached per slot
1594
 *        There are two slots for node-set and misc objects.
1595
 *        Use <0 for the default number (100).
1596
 *   Other values for @options have currently no effect.
1597
 *
1598
 * Returns 0 if the setting succeeded, and -1 on API or internal errors.
1599
 */
1600
int
1601
xmlXPathContextSetCache(xmlXPathContextPtr ctxt,
1602
      int active,
1603
      int value,
1604
      int options)
1605
794
{
1606
794
    if (ctxt == NULL)
1607
0
  return(-1);
1608
794
    if (active) {
1609
794
  xmlXPathContextCachePtr cache;
1610
1611
794
  if (ctxt->cache == NULL) {
1612
794
      ctxt->cache = xmlXPathNewCache();
1613
794
      if (ctxt->cache == NULL) {
1614
0
                xmlXPathErrMemory(ctxt);
1615
0
    return(-1);
1616
0
            }
1617
794
  }
1618
794
  cache = (xmlXPathContextCachePtr) ctxt->cache;
1619
794
  if (options == 0) {
1620
794
      if (value < 0)
1621
794
    value = 100;
1622
794
      cache->maxNodeset = value;
1623
794
      cache->maxMisc = value;
1624
794
  }
1625
794
    } else if (ctxt->cache != NULL) {
1626
0
  xmlXPathFreeCache((xmlXPathContextCachePtr) ctxt->cache);
1627
0
  ctxt->cache = NULL;
1628
0
    }
1629
794
    return(0);
1630
794
}
1631
1632
/**
1633
 * xmlXPathCacheWrapNodeSet:
1634
 * @pctxt: the XPath context
1635
 * @val:  the NodePtr value
1636
 *
1637
 * This is the cached version of xmlXPathWrapNodeSet().
1638
 * Wrap the Nodeset @val in a new xmlXPathObjectPtr
1639
 *
1640
 * Returns the created or reused object.
1641
 *
1642
 * In case of error the node set is destroyed and NULL is returned.
1643
 */
1644
static xmlXPathObjectPtr
1645
xmlXPathCacheWrapNodeSet(xmlXPathParserContextPtr pctxt, xmlNodeSetPtr val)
1646
364k
{
1647
364k
    xmlXPathObjectPtr ret;
1648
364k
    xmlXPathContextPtr ctxt = pctxt->context;
1649
1650
364k
    if ((ctxt != NULL) && (ctxt->cache != NULL)) {
1651
364k
  xmlXPathContextCachePtr cache =
1652
364k
      (xmlXPathContextCachePtr) ctxt->cache;
1653
1654
364k
  if (cache->miscObjs != NULL) {
1655
238k
      ret = cache->miscObjs;
1656
238k
            cache->miscObjs = (void *) ret->stringval;
1657
238k
            cache->numMisc -= 1;
1658
238k
            ret->stringval = NULL;
1659
238k
      ret->type = XPATH_NODESET;
1660
238k
      ret->nodesetval = val;
1661
238k
      return(ret);
1662
238k
  }
1663
364k
    }
1664
1665
126k
    ret = xmlXPathWrapNodeSet(val);
1666
126k
    if (ret == NULL)
1667
30
        xmlXPathPErrMemory(pctxt);
1668
126k
    return(ret);
1669
364k
}
1670
1671
/**
1672
 * xmlXPathCacheWrapString:
1673
 * @pctxt the XPath context
1674
 * @val:  the xmlChar * value
1675
 *
1676
 * This is the cached version of xmlXPathWrapString().
1677
 * Wraps the @val string into an XPath object.
1678
 *
1679
 * Returns the created or reused object.
1680
 */
1681
static xmlXPathObjectPtr
1682
xmlXPathCacheWrapString(xmlXPathParserContextPtr pctxt, xmlChar *val)
1683
80.4k
{
1684
80.4k
    xmlXPathObjectPtr ret;
1685
80.4k
    xmlXPathContextPtr ctxt = pctxt->context;
1686
1687
80.4k
    if ((ctxt != NULL) && (ctxt->cache != NULL)) {
1688
80.4k
  xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache;
1689
1690
80.4k
  if (cache->miscObjs != NULL) {
1691
74.4k
      ret = cache->miscObjs;
1692
74.4k
            cache->miscObjs = (void *) ret->stringval;
1693
74.4k
            cache->numMisc -= 1;
1694
74.4k
      ret->type = XPATH_STRING;
1695
74.4k
      ret->stringval = val;
1696
74.4k
      return(ret);
1697
74.4k
  }
1698
80.4k
    }
1699
1700
5.91k
    ret = xmlXPathWrapString(val);
1701
5.91k
    if (ret == NULL)
1702
2
        xmlXPathPErrMemory(pctxt);
1703
5.91k
    return(ret);
1704
80.4k
}
1705
1706
/**
1707
 * xmlXPathCacheNewNodeSet:
1708
 * @pctxt the XPath context
1709
 * @val:  the NodePtr value
1710
 *
1711
 * This is the cached version of xmlXPathNewNodeSet().
1712
 * Acquire an xmlXPathObjectPtr of type NodeSet and initialize
1713
 * it with the single Node @val
1714
 *
1715
 * Returns the created or reused object.
1716
 */
1717
static xmlXPathObjectPtr
1718
xmlXPathCacheNewNodeSet(xmlXPathParserContextPtr pctxt, xmlNodePtr val)
1719
389k
{
1720
389k
    xmlXPathObjectPtr ret;
1721
389k
    xmlXPathContextPtr ctxt = pctxt->context;
1722
1723
389k
    if ((ctxt != NULL) && (ctxt->cache != NULL)) {
1724
389k
  xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache;
1725
1726
389k
  if (cache->nodesetObjs != NULL) {
1727
      /*
1728
      * Use the nodeset-cache.
1729
      */
1730
387k
      ret = cache->nodesetObjs;
1731
387k
            cache->nodesetObjs = (void *) ret->stringval;
1732
387k
            cache->numNodeset -= 1;
1733
387k
            ret->stringval = NULL;
1734
387k
      ret->type = XPATH_NODESET;
1735
387k
      ret->boolval = 0;
1736
387k
      if (val) {
1737
387k
    if ((ret->nodesetval->nodeMax == 0) ||
1738
387k
        (val->type == XML_NAMESPACE_DECL))
1739
13.5k
    {
1740
13.5k
        if (xmlXPathNodeSetAddUnique(ret->nodesetval, val) < 0)
1741
6
                        xmlXPathPErrMemory(pctxt);
1742
374k
    } else {
1743
374k
        ret->nodesetval->nodeTab[0] = val;
1744
374k
        ret->nodesetval->nodeNr = 1;
1745
374k
    }
1746
387k
      }
1747
387k
      return(ret);
1748
387k
  } else if (cache->miscObjs != NULL) {
1749
11
            xmlNodeSetPtr set;
1750
      /*
1751
      * Fallback to misc-cache.
1752
      */
1753
1754
11
      set = xmlXPathNodeSetCreate(val);
1755
11
      if (set == NULL) {
1756
0
                xmlXPathPErrMemory(pctxt);
1757
0
    return(NULL);
1758
0
      }
1759
1760
11
      ret = cache->miscObjs;
1761
11
            cache->miscObjs = (void *) ret->stringval;
1762
11
            cache->numMisc -= 1;
1763
11
            ret->stringval = NULL;
1764
11
      ret->type = XPATH_NODESET;
1765
11
      ret->boolval = 0;
1766
11
      ret->nodesetval = set;
1767
11
      return(ret);
1768
11
  }
1769
389k
    }
1770
1.24k
    ret = xmlXPathNewNodeSet(val);
1771
1.24k
    if (ret == NULL)
1772
0
        xmlXPathPErrMemory(pctxt);
1773
1.24k
    return(ret);
1774
389k
}
1775
1776
/**
1777
 * xmlXPathCacheNewString:
1778
 * @pctxt the XPath context
1779
 * @val:  the xmlChar * value
1780
 *
1781
 * This is the cached version of xmlXPathNewString().
1782
 * Acquire an xmlXPathObjectPtr of type string and of value @val
1783
 *
1784
 * Returns the created or reused object.
1785
 */
1786
static xmlXPathObjectPtr
1787
xmlXPathCacheNewString(xmlXPathParserContextPtr pctxt, const xmlChar *val)
1788
11.2k
{
1789
11.2k
    xmlXPathObjectPtr ret;
1790
11.2k
    xmlXPathContextPtr ctxt = pctxt->context;
1791
1792
11.2k
    if ((ctxt != NULL) && (ctxt->cache != NULL)) {
1793
11.2k
  xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache;
1794
1795
11.2k
  if (cache->miscObjs != NULL) {
1796
8.94k
            xmlChar *copy;
1797
1798
8.94k
            if (val == NULL)
1799
0
                val = BAD_CAST "";
1800
8.94k
            copy = xmlStrdup(val);
1801
8.94k
            if (copy == NULL) {
1802
1
                xmlXPathPErrMemory(pctxt);
1803
1
                return(NULL);
1804
1
            }
1805
1806
8.94k
      ret = cache->miscObjs;
1807
8.94k
            cache->miscObjs = (void *) ret->stringval;
1808
8.94k
            cache->numMisc -= 1;
1809
8.94k
      ret->type = XPATH_STRING;
1810
8.94k
            ret->stringval = copy;
1811
8.94k
      return(ret);
1812
8.94k
  }
1813
11.2k
    }
1814
1815
2.34k
    ret = xmlXPathNewString(val);
1816
2.34k
    if (ret == NULL)
1817
0
        xmlXPathPErrMemory(pctxt);
1818
2.34k
    return(ret);
1819
11.2k
}
1820
1821
/**
1822
 * xmlXPathCacheNewCString:
1823
 * @pctxt the XPath context
1824
 * @val:  the char * value
1825
 *
1826
 * This is the cached version of xmlXPathNewCString().
1827
 * Acquire an xmlXPathObjectPtr of type string and of value @val
1828
 *
1829
 * Returns the created or reused object.
1830
 */
1831
static xmlXPathObjectPtr
1832
xmlXPathCacheNewCString(xmlXPathParserContextPtr pctxt, const char *val)
1833
0
{
1834
0
    return xmlXPathCacheNewString(pctxt, BAD_CAST val);
1835
0
}
1836
1837
/**
1838
 * xmlXPathCacheNewBoolean:
1839
 * @pctxt the XPath context
1840
 * @val:  the boolean value
1841
 *
1842
 * This is the cached version of xmlXPathNewBoolean().
1843
 * Acquires an xmlXPathObjectPtr of type boolean and of value @val
1844
 *
1845
 * Returns the created or reused object.
1846
 */
1847
static xmlXPathObjectPtr
1848
xmlXPathCacheNewBoolean(xmlXPathParserContextPtr pctxt, int val)
1849
12.5k
{
1850
12.5k
    xmlXPathObjectPtr ret;
1851
12.5k
    xmlXPathContextPtr ctxt = pctxt->context;
1852
1853
12.5k
    if ((ctxt != NULL) && (ctxt->cache != NULL)) {
1854
12.5k
  xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache;
1855
1856
12.5k
  if (cache->miscObjs != NULL) {
1857
11.3k
      ret = cache->miscObjs;
1858
11.3k
            cache->miscObjs = (void *) ret->stringval;
1859
11.3k
            cache->numMisc -= 1;
1860
11.3k
            ret->stringval = NULL;
1861
11.3k
      ret->type = XPATH_BOOLEAN;
1862
11.3k
      ret->boolval = (val != 0);
1863
11.3k
      return(ret);
1864
11.3k
  }
1865
12.5k
    }
1866
1867
1.17k
    ret = xmlXPathNewBoolean(val);
1868
1.17k
    if (ret == NULL)
1869
0
        xmlXPathPErrMemory(pctxt);
1870
1.17k
    return(ret);
1871
12.5k
}
1872
1873
/**
1874
 * xmlXPathCacheNewFloat:
1875
 * @pctxt the XPath context
1876
 * @val:  the double value
1877
 *
1878
 * This is the cached version of xmlXPathNewFloat().
1879
 * Acquires an xmlXPathObjectPtr of type double and of value @val
1880
 *
1881
 * Returns the created or reused object.
1882
 */
1883
static xmlXPathObjectPtr
1884
xmlXPathCacheNewFloat(xmlXPathParserContextPtr pctxt, double val)
1885
181k
{
1886
181k
    xmlXPathObjectPtr ret;
1887
181k
    xmlXPathContextPtr ctxt = pctxt->context;
1888
1889
181k
    if ((ctxt != NULL) && (ctxt->cache != NULL)) {
1890
181k
  xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache;
1891
1892
181k
  if (cache->miscObjs != NULL) {
1893
180k
      ret = cache->miscObjs;
1894
180k
            cache->miscObjs = (void *) ret->stringval;
1895
180k
            cache->numMisc -= 1;
1896
180k
            ret->stringval = NULL;
1897
180k
      ret->type = XPATH_NUMBER;
1898
180k
      ret->floatval = val;
1899
180k
      return(ret);
1900
180k
  }
1901
181k
    }
1902
1903
444
    ret = xmlXPathNewFloat(val);
1904
444
    if (ret == NULL)
1905
0
        xmlXPathPErrMemory(pctxt);
1906
444
    return(ret);
1907
181k
}
1908
1909
/**
1910
 * xmlXPathCacheObjectCopy:
1911
 * @pctxt the XPath context
1912
 * @val:  the original object
1913
 *
1914
 * This is the cached version of xmlXPathObjectCopy().
1915
 * Acquire a copy of a given object
1916
 *
1917
 * Returns a created or reused created object.
1918
 */
1919
static xmlXPathObjectPtr
1920
xmlXPathCacheObjectCopy(xmlXPathParserContextPtr pctxt, xmlXPathObjectPtr val)
1921
22.0k
{
1922
22.0k
    xmlXPathObjectPtr ret;
1923
22.0k
    xmlXPathContextPtr ctxt = pctxt->context;
1924
1925
22.0k
    if (val == NULL)
1926
0
  return(NULL);
1927
1928
22.0k
    if ((ctxt != NULL) && (ctxt->cache != NULL)) {
1929
22.0k
  switch (val->type) {
1930
0
            case XPATH_NODESET: {
1931
0
                xmlNodeSetPtr set;
1932
1933
0
                set = xmlXPathNodeSetMerge(NULL, val->nodesetval);
1934
0
                if (set == NULL) {
1935
0
                    xmlXPathPErrMemory(pctxt);
1936
0
                    return(NULL);
1937
0
                }
1938
0
                return(xmlXPathCacheWrapNodeSet(pctxt, set));
1939
0
            }
1940
10.2k
      case XPATH_STRING:
1941
10.2k
    return(xmlXPathCacheNewString(pctxt, val->stringval));
1942
0
      case XPATH_BOOLEAN:
1943
0
    return(xmlXPathCacheNewBoolean(pctxt, val->boolval));
1944
11.7k
      case XPATH_NUMBER:
1945
11.7k
    return(xmlXPathCacheNewFloat(pctxt, val->floatval));
1946
0
      default:
1947
0
    break;
1948
22.0k
  }
1949
22.0k
    }
1950
0
    ret = xmlXPathObjectCopy(val);
1951
0
    if (ret == NULL)
1952
0
        xmlXPathPErrMemory(pctxt);
1953
0
    return(ret);
1954
22.0k
}
1955
1956
/************************************************************************
1957
 *                  *
1958
 *    Parser stacks related functions and macros    *
1959
 *                  *
1960
 ************************************************************************/
1961
1962
/**
1963
 * xmlXPathCastToNumberInternal:
1964
 * @ctxt:  parser context
1965
 * @val:  an XPath object
1966
 *
1967
 * Converts an XPath object to its number value
1968
 *
1969
 * Returns the number value
1970
 */
1971
static double
1972
xmlXPathCastToNumberInternal(xmlXPathParserContextPtr ctxt,
1973
168k
                             xmlXPathObjectPtr val) {
1974
168k
    double ret = 0.0;
1975
1976
168k
    if (val == NULL)
1977
0
  return(xmlXPathNAN);
1978
168k
    switch (val->type) {
1979
0
    case XPATH_UNDEFINED:
1980
0
  ret = xmlXPathNAN;
1981
0
  break;
1982
1.00k
    case XPATH_NODESET:
1983
1.00k
    case XPATH_XSLT_TREE: {
1984
1.00k
        xmlChar *str;
1985
1986
1.00k
  str = xmlXPathCastNodeSetToString(val->nodesetval);
1987
1.00k
        if (str == NULL) {
1988
0
            xmlXPathPErrMemory(ctxt);
1989
0
            ret = xmlXPathNAN;
1990
1.00k
        } else {
1991
1.00k
      ret = xmlXPathCastStringToNumber(str);
1992
1.00k
            xmlFree(str);
1993
1.00k
        }
1994
1.00k
  break;
1995
1.00k
    }
1996
164k
    case XPATH_STRING:
1997
164k
  ret = xmlXPathCastStringToNumber(val->stringval);
1998
164k
  break;
1999
314
    case XPATH_NUMBER:
2000
314
  ret = val->floatval;
2001
314
  break;
2002
2.50k
    case XPATH_BOOLEAN:
2003
2.50k
  ret = xmlXPathCastBooleanToNumber(val->boolval);
2004
2.50k
  break;
2005
0
    case XPATH_USERS:
2006
  /* TODO */
2007
0
  ret = xmlXPathNAN;
2008
0
  break;
2009
168k
    }
2010
168k
    return(ret);
2011
168k
}
2012
2013
/**
2014
 * xmlXPathValuePop:
2015
 * @ctxt: an XPath evaluation context
2016
 *
2017
 * Pops the top XPath object from the value stack
2018
 *
2019
 * Returns the XPath object just removed
2020
 */
2021
xmlXPathObjectPtr
2022
xmlXPathValuePop(xmlXPathParserContextPtr ctxt)
2023
1.82M
{
2024
1.82M
    xmlXPathObjectPtr ret;
2025
2026
1.82M
    if ((ctxt == NULL) || (ctxt->valueNr <= 0))
2027
44
        return (NULL);
2028
2029
1.82M
    ctxt->valueNr--;
2030
1.82M
    if (ctxt->valueNr > 0)
2031
634k
        ctxt->value = ctxt->valueTab[ctxt->valueNr - 1];
2032
1.19M
    else
2033
1.19M
        ctxt->value = NULL;
2034
1.82M
    ret = ctxt->valueTab[ctxt->valueNr];
2035
1.82M
    ctxt->valueTab[ctxt->valueNr] = NULL;
2036
1.82M
    return (ret);
2037
1.82M
}
2038
2039
/**
2040
 * xmlXPathValuePush:
2041
 * @ctxt:  an XPath evaluation context
2042
 * @value:  the XPath object
2043
 *
2044
 * Pushes a new XPath object on top of the value stack. If value is NULL,
2045
 * a memory error is recorded in the parser context.
2046
 *
2047
 * Returns the number of items on the value stack, or -1 in case of error.
2048
 *
2049
 * The object is destroyed in case of error.
2050
 */
2051
int
2052
xmlXPathValuePush(xmlXPathParserContextPtr ctxt, xmlXPathObjectPtr value)
2053
1.82M
{
2054
1.82M
    if (ctxt == NULL) return(-1);
2055
1.82M
    if (value == NULL) {
2056
        /*
2057
         * A NULL value typically indicates that a memory allocation failed.
2058
         */
2059
142
        xmlXPathPErrMemory(ctxt);
2060
142
        return(-1);
2061
142
    }
2062
1.82M
    if (ctxt->valueNr >= ctxt->valueMax) {
2063
2.95k
        xmlXPathObjectPtr *tmp;
2064
2.95k
        int newSize;
2065
2066
2.95k
        newSize = xmlGrowCapacity(ctxt->valueMax, sizeof(tmp[0]),
2067
2.95k
                                  10, XPATH_MAX_STACK_DEPTH);
2068
2.95k
        if (newSize < 0) {
2069
0
            xmlXPathPErrMemory(ctxt);
2070
0
            xmlXPathFreeObject(value);
2071
0
            return (-1);
2072
0
        }
2073
2.95k
        tmp = xmlRealloc(ctxt->valueTab, newSize * sizeof(tmp[0]));
2074
2.95k
        if (tmp == NULL) {
2075
28
            xmlXPathPErrMemory(ctxt);
2076
28
            xmlXPathFreeObject(value);
2077
28
            return (-1);
2078
28
        }
2079
2.93k
  ctxt->valueTab = tmp;
2080
2.93k
        ctxt->valueMax = newSize;
2081
2.93k
    }
2082
1.82M
    ctxt->valueTab[ctxt->valueNr] = value;
2083
1.82M
    ctxt->value = value;
2084
1.82M
    return (ctxt->valueNr++);
2085
1.82M
}
2086
2087
/**
2088
 * xmlXPathPopBoolean:
2089
 * @ctxt:  an XPath parser context
2090
 *
2091
 * Pops a boolean from the stack, handling conversion if needed.
2092
 * Check error with #xmlXPathCheckError.
2093
 *
2094
 * Returns the boolean
2095
 */
2096
int
2097
1.03k
xmlXPathPopBoolean (xmlXPathParserContextPtr ctxt) {
2098
1.03k
    xmlXPathObjectPtr obj;
2099
1.03k
    int ret;
2100
2101
1.03k
    obj = xmlXPathValuePop(ctxt);
2102
1.03k
    if (obj == NULL) {
2103
0
  xmlXPathSetError(ctxt, XPATH_INVALID_OPERAND);
2104
0
  return(0);
2105
0
    }
2106
1.03k
    if (obj->type != XPATH_BOOLEAN)
2107
1.03k
  ret = xmlXPathCastToBoolean(obj);
2108
0
    else
2109
0
        ret = obj->boolval;
2110
1.03k
    xmlXPathReleaseObject(ctxt->context, obj);
2111
1.03k
    return(ret);
2112
1.03k
}
2113
2114
/**
2115
 * xmlXPathPopNumber:
2116
 * @ctxt:  an XPath parser context
2117
 *
2118
 * Pops a number from the stack, handling conversion if needed.
2119
 * Check error with #xmlXPathCheckError.
2120
 *
2121
 * Returns the number
2122
 */
2123
double
2124
181
xmlXPathPopNumber (xmlXPathParserContextPtr ctxt) {
2125
181
    xmlXPathObjectPtr obj;
2126
181
    double ret;
2127
2128
181
    obj = xmlXPathValuePop(ctxt);
2129
181
    if (obj == NULL) {
2130
0
  xmlXPathSetError(ctxt, XPATH_INVALID_OPERAND);
2131
0
  return(0);
2132
0
    }
2133
181
    if (obj->type != XPATH_NUMBER)
2134
0
  ret = xmlXPathCastToNumberInternal(ctxt, obj);
2135
181
    else
2136
181
        ret = obj->floatval;
2137
181
    xmlXPathReleaseObject(ctxt->context, obj);
2138
181
    return(ret);
2139
181
}
2140
2141
/**
2142
 * xmlXPathPopString:
2143
 * @ctxt:  an XPath parser context
2144
 *
2145
 * Pops a string from the stack, handling conversion if needed.
2146
 * Check error with #xmlXPathCheckError.
2147
 *
2148
 * Returns the string
2149
 */
2150
xmlChar *
2151
33.3k
xmlXPathPopString (xmlXPathParserContextPtr ctxt) {
2152
33.3k
    xmlXPathObjectPtr obj;
2153
33.3k
    xmlChar * ret;
2154
2155
33.3k
    obj = xmlXPathValuePop(ctxt);
2156
33.3k
    if (obj == NULL) {
2157
0
  xmlXPathSetError(ctxt, XPATH_INVALID_OPERAND);
2158
0
  return(NULL);
2159
0
    }
2160
33.3k
    ret = xmlXPathCastToString(obj);
2161
33.3k
    if (ret == NULL)
2162
4
        xmlXPathPErrMemory(ctxt);
2163
33.3k
    xmlXPathReleaseObject(ctxt->context, obj);
2164
33.3k
    return(ret);
2165
33.3k
}
2166
2167
/**
2168
 * xmlXPathPopNodeSet:
2169
 * @ctxt:  an XPath parser context
2170
 *
2171
 * Pops a node-set from the stack, handling conversion if needed.
2172
 * Check error with #xmlXPathCheckError.
2173
 *
2174
 * Returns the node-set
2175
 */
2176
xmlNodeSetPtr
2177
17.9k
xmlXPathPopNodeSet (xmlXPathParserContextPtr ctxt) {
2178
17.9k
    xmlXPathObjectPtr obj;
2179
17.9k
    xmlNodeSetPtr ret;
2180
2181
17.9k
    if (ctxt == NULL) return(NULL);
2182
17.9k
    if (ctxt->value == NULL) {
2183
0
  xmlXPathSetError(ctxt, XPATH_INVALID_OPERAND);
2184
0
  return(NULL);
2185
0
    }
2186
17.9k
    if (!xmlXPathStackIsNodeSet(ctxt)) {
2187
0
  xmlXPathSetTypeError(ctxt);
2188
0
  return(NULL);
2189
0
    }
2190
17.9k
    obj = xmlXPathValuePop(ctxt);
2191
17.9k
    ret = obj->nodesetval;
2192
17.9k
    obj->nodesetval = NULL;
2193
17.9k
    xmlXPathReleaseObject(ctxt->context, obj);
2194
17.9k
    return(ret);
2195
17.9k
}
2196
2197
/**
2198
 * xmlXPathPopExternal:
2199
 * @ctxt:  an XPath parser context
2200
 *
2201
 * Pops an external object from the stack, handling conversion if needed.
2202
 * Check error with #xmlXPathCheckError.
2203
 *
2204
 * Returns the object
2205
 */
2206
void *
2207
0
xmlXPathPopExternal (xmlXPathParserContextPtr ctxt) {
2208
0
    xmlXPathObjectPtr obj;
2209
0
    void * ret;
2210
2211
0
    if ((ctxt == NULL) || (ctxt->value == NULL)) {
2212
0
  xmlXPathSetError(ctxt, XPATH_INVALID_OPERAND);
2213
0
  return(NULL);
2214
0
    }
2215
0
    if (ctxt->value->type != XPATH_USERS) {
2216
0
  xmlXPathSetTypeError(ctxt);
2217
0
  return(NULL);
2218
0
    }
2219
0
    obj = xmlXPathValuePop(ctxt);
2220
0
    ret = obj->user;
2221
0
    obj->user = NULL;
2222
0
    xmlXPathReleaseObject(ctxt->context, obj);
2223
0
    return(ret);
2224
0
}
2225
2226
/*
2227
 * Macros for accessing the content. Those should be used only by the parser,
2228
 * and not exported.
2229
 *
2230
 * Dirty macros, i.e. one need to make assumption on the context to use them
2231
 *
2232
 *   CUR_PTR return the current pointer to the xmlChar to be parsed.
2233
 *   CUR     returns the current xmlChar value, i.e. a 8 bit value
2234
 *           in ISO-Latin or UTF-8.
2235
 *           This should be used internally by the parser
2236
 *           only to compare to ASCII values otherwise it would break when
2237
 *           running with UTF-8 encoding.
2238
 *   NXT(n)  returns the n'th next xmlChar. Same as CUR is should be used only
2239
 *           to compare on ASCII based substring.
2240
 *   SKIP(n) Skip n xmlChar, and must also be used only to skip ASCII defined
2241
 *           strings within the parser.
2242
 *   CURRENT Returns the current char value, with the full decoding of
2243
 *           UTF-8 if we are using this mode. It returns an int.
2244
 *   NEXT    Skip to the next character, this does the proper decoding
2245
 *           in UTF-8 mode. It also pop-up unfinished entities on the fly.
2246
 *           It returns the pointer to the current xmlChar.
2247
 */
2248
2249
12.0M
#define CUR (*ctxt->cur)
2250
69.9k
#define SKIP(val) ctxt->cur += (val)
2251
656k
#define NXT(val) ctxt->cur[(val)]
2252
4.75M
#define CUR_PTR ctxt->cur
2253
9.46M
#define CUR_CHAR(l) xmlXPathCurrentChar(ctxt, &l)
2254
2255
#define COPY_BUF(b, i, v)           \
2256
5.67M
    if (v < 0x80) b[i++] = v;           \
2257
5.67M
    else i += xmlCopyCharMultiByte(&b[i],v)
2258
2259
9.44M
#define NEXTL(l)  ctxt->cur += l
2260
2261
#define SKIP_BLANKS             \
2262
4.71M
    while (IS_BLANK_CH(*(ctxt->cur))) NEXT
2263
2264
#define CURRENT (*ctxt->cur)
2265
3.85M
#define NEXT ((*ctxt->cur) ?  ctxt->cur++: ctxt->cur)
2266
2267
2268
#ifndef DBL_DIG
2269
#define DBL_DIG 16
2270
#endif
2271
#ifndef DBL_EPSILON
2272
#define DBL_EPSILON 1E-9
2273
#endif
2274
2275
790
#define UPPER_DOUBLE 1E9
2276
601
#define LOWER_DOUBLE 1E-5
2277
#define LOWER_DOUBLE_EXP 5
2278
2279
#define INTEGER_DIGITS DBL_DIG
2280
#define FRACTION_DIGITS (DBL_DIG + 1 + (LOWER_DOUBLE_EXP))
2281
189
#define EXPONENT_DIGITS (3 + 2)
2282
2283
/**
2284
 * xmlXPathFormatNumber:
2285
 * @number:     number to format
2286
 * @buffer:     output buffer
2287
 * @buffersize: size of output buffer
2288
 *
2289
 * Convert the number into a string representation.
2290
 */
2291
static void
2292
xmlXPathFormatNumber(double number, char buffer[], int buffersize)
2293
835
{
2294
835
    switch (xmlXPathIsInf(number)) {
2295
0
    case 1:
2296
0
  if (buffersize > (int)sizeof("Infinity"))
2297
0
      snprintf(buffer, buffersize, "Infinity");
2298
0
  break;
2299
0
    case -1:
2300
0
  if (buffersize > (int)sizeof("-Infinity"))
2301
0
      snprintf(buffer, buffersize, "-Infinity");
2302
0
  break;
2303
835
    default:
2304
835
  if (xmlXPathIsNaN(number)) {
2305
0
      if (buffersize > (int)sizeof("NaN"))
2306
0
    snprintf(buffer, buffersize, "NaN");
2307
835
  } else if (number == 0) {
2308
            /* Omit sign for negative zero. */
2309
0
      snprintf(buffer, buffersize, "0");
2310
835
  } else if ((number > INT_MIN) && (number < INT_MAX) &&
2311
835
                   (number == (int) number)) {
2312
45
      char work[30];
2313
45
      char *ptr, *cur;
2314
45
      int value = (int) number;
2315
2316
45
            ptr = &buffer[0];
2317
45
      if (value == 0) {
2318
0
    *ptr++ = '0';
2319
45
      } else {
2320
45
    snprintf(work, 29, "%d", value);
2321
45
    cur = &work[0];
2322
90
    while ((*cur) && (ptr - buffer < buffersize)) {
2323
45
        *ptr++ = *cur++;
2324
45
    }
2325
45
      }
2326
45
      if (ptr - buffer < buffersize) {
2327
45
    *ptr = 0;
2328
45
      } else if (buffersize > 0) {
2329
0
    ptr--;
2330
0
    *ptr = 0;
2331
0
      }
2332
790
  } else {
2333
      /*
2334
        For the dimension of work,
2335
            DBL_DIG is number of significant digits
2336
      EXPONENT is only needed for "scientific notation"
2337
            3 is sign, decimal point, and terminating zero
2338
      LOWER_DOUBLE_EXP is max number of leading zeroes in fraction
2339
        Note that this dimension is slightly (a few characters)
2340
        larger than actually necessary.
2341
      */
2342
790
      char work[DBL_DIG + EXPONENT_DIGITS + 3 + LOWER_DOUBLE_EXP];
2343
790
      int integer_place, fraction_place;
2344
790
      char *ptr;
2345
790
      char *after_fraction;
2346
790
      double absolute_value;
2347
790
      int size;
2348
2349
790
      absolute_value = fabs(number);
2350
2351
      /*
2352
       * First choose format - scientific or regular floating point.
2353
       * In either case, result is in work, and after_fraction points
2354
       * just past the fractional part.
2355
      */
2356
790
      if ( ((absolute_value > UPPER_DOUBLE) ||
2357
790
      (absolute_value < LOWER_DOUBLE)) &&
2358
790
     (absolute_value != 0.0) ) {
2359
    /* Use scientific notation */
2360
189
    integer_place = DBL_DIG + EXPONENT_DIGITS + 1;
2361
189
    fraction_place = DBL_DIG - 1;
2362
189
    size = snprintf(work, sizeof(work),"%*.*e",
2363
189
       integer_place, fraction_place, number);
2364
945
    while ((size > 0) && (work[size] != 'e')) size--;
2365
2366
189
      }
2367
601
      else {
2368
    /* Use regular notation */
2369
601
    if (absolute_value > 0.0) {
2370
601
        integer_place = (int)log10(absolute_value);
2371
601
        if (integer_place > 0)
2372
0
            fraction_place = DBL_DIG - integer_place - 1;
2373
601
        else
2374
601
            fraction_place = DBL_DIG - integer_place;
2375
601
    } else {
2376
0
        fraction_place = 1;
2377
0
    }
2378
601
    size = snprintf(work, sizeof(work), "%0.*f",
2379
601
        fraction_place, number);
2380
601
      }
2381
2382
      /* Remove leading spaces sometimes inserted by snprintf */
2383
979
      while (work[0] == ' ') {
2384
3.96k
          for (ptr = &work[0];(ptr[0] = ptr[1]);ptr++);
2385
189
    size--;
2386
189
      }
2387
2388
      /* Remove fractional trailing zeroes */
2389
790
      after_fraction = work + size;
2390
790
      ptr = after_fraction;
2391
9.20k
      while (*(--ptr) == '0')
2392
8.41k
    ;
2393
790
      if (*ptr != '.')
2394
790
          ptr++;
2395
1.54k
      while ((*ptr++ = *after_fraction++) != 0);
2396
2397
      /* Finally copy result back to caller */
2398
790
      size = strlen(work) + 1;
2399
790
      if (size > buffersize) {
2400
0
    work[buffersize - 1] = 0;
2401
0
    size = buffersize;
2402
0
      }
2403
790
      memmove(buffer, work, size);
2404
790
  }
2405
835
  break;
2406
835
    }
2407
835
}
2408
2409
2410
/************************************************************************
2411
 *                  *
2412
 *      Routines to handle NodeSets     *
2413
 *                  *
2414
 ************************************************************************/
2415
2416
/**
2417
 * xmlXPathOrderDocElems:
2418
 * @doc:  an input document
2419
 *
2420
 * Call this routine to speed up XPath computation on static documents.
2421
 * This stamps all the element nodes with the document order
2422
 * Like for line information, the order is kept in the element->content
2423
 * field, the value stored is actually - the node number (starting at -1)
2424
 * to be able to differentiate from line numbers.
2425
 *
2426
 * Returns the number of elements found in the document or -1 in case
2427
 *    of error.
2428
 */
2429
long
2430
792
xmlXPathOrderDocElems(xmlDocPtr doc) {
2431
792
    XML_INTPTR_T count = 0;
2432
792
    xmlNodePtr cur;
2433
2434
792
    if (doc == NULL)
2435
0
  return(-1);
2436
792
    cur = doc->children;
2437
4.60M
    while (cur != NULL) {
2438
4.60M
  if (cur->type == XML_ELEMENT_NODE) {
2439
4.07M
            count += 1;
2440
4.07M
            cur->content = XML_INT_TO_PTR(-count);
2441
4.07M
      if (cur->children != NULL) {
2442
68.1k
    cur = cur->children;
2443
68.1k
    continue;
2444
68.1k
      }
2445
4.07M
  }
2446
4.53M
  if (cur->next != NULL) {
2447
4.49M
      cur = cur->next;
2448
4.49M
      continue;
2449
4.49M
  }
2450
68.9k
  do {
2451
68.9k
      cur = cur->parent;
2452
68.9k
      if (cur == NULL)
2453
0
    break;
2454
68.9k
      if (cur == (xmlNodePtr) doc) {
2455
789
    cur = NULL;
2456
789
    break;
2457
789
      }
2458
68.1k
      if (cur->next != NULL) {
2459
38.3k
    cur = cur->next;
2460
38.3k
    break;
2461
38.3k
      }
2462
68.1k
  } while (cur != NULL);
2463
39.1k
    }
2464
792
    return(count);
2465
792
}
2466
2467
/**
2468
 * xmlXPathCmpNodes:
2469
 * @node1:  the first node
2470
 * @node2:  the second node
2471
 *
2472
 * Compare two nodes w.r.t document order
2473
 *
2474
 * Returns -2 in case of error 1 if first point < second point, 0 if
2475
 *         it's the same node, -1 otherwise
2476
 */
2477
int
2478
1.89M
xmlXPathCmpNodes(xmlNodePtr node1, xmlNodePtr node2) {
2479
1.89M
    int depth1, depth2;
2480
1.89M
    int attr1 = 0, attr2 = 0;
2481
1.89M
    xmlNodePtr attrNode1 = NULL, attrNode2 = NULL;
2482
1.89M
    xmlNodePtr cur, root;
2483
2484
1.89M
    if ((node1 == NULL) || (node2 == NULL))
2485
0
  return(-2);
2486
    /*
2487
     * a couple of optimizations which will avoid computations in most cases
2488
     */
2489
1.89M
    if (node1 == node2)    /* trivial case */
2490
0
  return(0);
2491
1.89M
    if (node1->type == XML_ATTRIBUTE_NODE) {
2492
0
  attr1 = 1;
2493
0
  attrNode1 = node1;
2494
0
  node1 = node1->parent;
2495
0
    }
2496
1.89M
    if (node2->type == XML_ATTRIBUTE_NODE) {
2497
0
  attr2 = 1;
2498
0
  attrNode2 = node2;
2499
0
  node2 = node2->parent;
2500
0
    }
2501
1.89M
    if (node1 == node2) {
2502
0
  if (attr1 == attr2) {
2503
      /* not required, but we keep attributes in order */
2504
0
      if (attr1 != 0) {
2505
0
          cur = attrNode2->prev;
2506
0
    while (cur != NULL) {
2507
0
        if (cur == attrNode1)
2508
0
            return (1);
2509
0
        cur = cur->prev;
2510
0
    }
2511
0
    return (-1);
2512
0
      }
2513
0
      return(0);
2514
0
  }
2515
0
  if (attr2 == 1)
2516
0
      return(1);
2517
0
  return(-1);
2518
0
    }
2519
1.89M
    if ((node1->type == XML_NAMESPACE_DECL) ||
2520
1.89M
        (node2->type == XML_NAMESPACE_DECL))
2521
0
  return(1);
2522
1.89M
    if (node1 == node2->prev)
2523
14.9k
  return(1);
2524
1.88M
    if (node1 == node2->next)
2525
0
  return(-1);
2526
2527
    /*
2528
     * Speedup using document order if available.
2529
     */
2530
1.88M
    if ((node1->type == XML_ELEMENT_NODE) &&
2531
1.88M
  (node2->type == XML_ELEMENT_NODE) &&
2532
1.88M
  (0 > XML_NODE_SORT_VALUE(node1)) &&
2533
1.88M
  (0 > XML_NODE_SORT_VALUE(node2)) &&
2534
1.88M
  (node1->doc == node2->doc)) {
2535
268k
  XML_INTPTR_T l1, l2;
2536
2537
268k
  l1 = -XML_NODE_SORT_VALUE(node1);
2538
268k
  l2 = -XML_NODE_SORT_VALUE(node2);
2539
268k
  if (l1 < l2)
2540
268k
      return(1);
2541
0
  if (l1 > l2)
2542
0
      return(-1);
2543
0
    }
2544
2545
    /*
2546
     * compute depth to root
2547
     */
2548
105M
    for (depth2 = 0, cur = node2;cur->parent != NULL;cur = cur->parent) {
2549
103M
  if (cur->parent == node1)
2550
320k
      return(1);
2551
103M
  depth2++;
2552
103M
    }
2553
1.29M
    root = cur;
2554
46.9M
    for (depth1 = 0, cur = node1;cur->parent != NULL;cur = cur->parent) {
2555
45.6M
  if (cur->parent == node2)
2556
0
      return(-1);
2557
45.6M
  depth1++;
2558
45.6M
    }
2559
    /*
2560
     * Distinct document (or distinct entities :-( ) case.
2561
     */
2562
1.29M
    if (root != cur) {
2563
0
  return(-2);
2564
0
    }
2565
    /*
2566
     * get the nearest common ancestor.
2567
     */
2568
1.29M
    while (depth1 > depth2) {
2569
0
  depth1--;
2570
0
  node1 = node1->parent;
2571
0
    }
2572
47.5M
    while (depth2 > depth1) {
2573
46.3M
  depth2--;
2574
46.3M
  node2 = node2->parent;
2575
46.3M
    }
2576
1.32M
    while (node1->parent != node2->parent) {
2577
26.3k
  node1 = node1->parent;
2578
26.3k
  node2 = node2->parent;
2579
  /* should not happen but just in case ... */
2580
26.3k
  if ((node1 == NULL) || (node2 == NULL))
2581
0
      return(-2);
2582
26.3k
    }
2583
    /*
2584
     * Find who's first.
2585
     */
2586
1.29M
    if (node1 == node2->prev)
2587
586k
  return(1);
2588
707k
    if (node1 == node2->next)
2589
0
  return(-1);
2590
    /*
2591
     * Speedup using document order if available.
2592
     */
2593
707k
    if ((node1->type == XML_ELEMENT_NODE) &&
2594
707k
  (node2->type == XML_ELEMENT_NODE) &&
2595
707k
  (0 > XML_NODE_SORT_VALUE(node1)) &&
2596
707k
  (0 > XML_NODE_SORT_VALUE(node2)) &&
2597
707k
  (node1->doc == node2->doc)) {
2598
34.9k
  XML_INTPTR_T l1, l2;
2599
2600
34.9k
  l1 = -XML_NODE_SORT_VALUE(node1);
2601
34.9k
  l2 = -XML_NODE_SORT_VALUE(node2);
2602
34.9k
  if (l1 < l2)
2603
34.9k
      return(1);
2604
0
  if (l1 > l2)
2605
0
      return(-1);
2606
0
    }
2607
2608
22.9M
    for (cur = node1->next;cur != NULL;cur = cur->next)
2609
22.9M
  if (cur == node2)
2610
672k
      return(1);
2611
0
    return(-1); /* assume there is no sibling list corruption */
2612
672k
}
2613
2614
/**
2615
 * xmlXPathNodeSetSort:
2616
 * @set:  the node set
2617
 *
2618
 * Sort the node set in document order
2619
 */
2620
void
2621
35.7k
xmlXPathNodeSetSort(xmlNodeSetPtr set) {
2622
#ifndef WITH_TIM_SORT
2623
    int i, j, incr, len;
2624
    xmlNodePtr tmp;
2625
#endif
2626
2627
35.7k
    if (set == NULL)
2628
0
  return;
2629
2630
#ifndef WITH_TIM_SORT
2631
    /*
2632
     * Use the old Shell's sort implementation to sort the node-set
2633
     * Timsort ought to be quite faster
2634
     */
2635
    len = set->nodeNr;
2636
    for (incr = len / 2; incr > 0; incr /= 2) {
2637
  for (i = incr; i < len; i++) {
2638
      j = i - incr;
2639
      while (j >= 0) {
2640
#ifdef XP_OPTIMIZED_NON_ELEM_COMPARISON
2641
    if (xmlXPathCmpNodesExt(set->nodeTab[j],
2642
      set->nodeTab[j + incr]) == -1)
2643
#else
2644
    if (xmlXPathCmpNodes(set->nodeTab[j],
2645
      set->nodeTab[j + incr]) == -1)
2646
#endif
2647
    {
2648
        tmp = set->nodeTab[j];
2649
        set->nodeTab[j] = set->nodeTab[j + incr];
2650
        set->nodeTab[j + incr] = tmp;
2651
        j -= incr;
2652
    } else
2653
        break;
2654
      }
2655
  }
2656
    }
2657
#else /* WITH_TIM_SORT */
2658
35.7k
    libxml_domnode_tim_sort(set->nodeTab, set->nodeNr);
2659
35.7k
#endif /* WITH_TIM_SORT */
2660
35.7k
}
2661
2662
974k
#define XML_NODESET_DEFAULT 10
2663
/**
2664
 * xmlXPathNodeSetDupNs:
2665
 * @node:  the parent node of the namespace XPath node
2666
 * @ns:  the libxml namespace declaration node.
2667
 *
2668
 * Namespace node in libxml don't match the XPath semantic. In a node set
2669
 * the namespace nodes are duplicated and the next pointer is set to the
2670
 * parent node in the XPath semantic.
2671
 *
2672
 * Returns the newly created object.
2673
 */
2674
static xmlNodePtr
2675
291k
xmlXPathNodeSetDupNs(xmlNodePtr node, xmlNsPtr ns) {
2676
291k
    xmlNsPtr cur;
2677
2678
291k
    if ((ns == NULL) || (ns->type != XML_NAMESPACE_DECL))
2679
0
  return(NULL);
2680
291k
    if ((node == NULL) || (node->type == XML_NAMESPACE_DECL))
2681
0
  return((xmlNodePtr) ns);
2682
2683
    /*
2684
     * Allocate a new Namespace and fill the fields.
2685
     */
2686
291k
    cur = (xmlNsPtr) xmlMalloc(sizeof(xmlNs));
2687
291k
    if (cur == NULL)
2688
0
  return(NULL);
2689
291k
    memset(cur, 0, sizeof(xmlNs));
2690
291k
    cur->type = XML_NAMESPACE_DECL;
2691
291k
    if (ns->href != NULL) {
2692
291k
  cur->href = xmlStrdup(ns->href);
2693
291k
        if (cur->href == NULL) {
2694
1
            xmlFree(cur);
2695
1
            return(NULL);
2696
1
        }
2697
291k
    }
2698
291k
    if (ns->prefix != NULL) {
2699
291k
  cur->prefix = xmlStrdup(ns->prefix);
2700
291k
        if (cur->prefix == NULL) {
2701
0
            xmlFree((xmlChar *) cur->href);
2702
0
            xmlFree(cur);
2703
0
            return(NULL);
2704
0
        }
2705
291k
    }
2706
291k
    cur->next = (xmlNsPtr) node;
2707
291k
    return((xmlNodePtr) cur);
2708
291k
}
2709
2710
/**
2711
 * xmlXPathNodeSetFreeNs:
2712
 * @ns:  the XPath namespace node found in a nodeset.
2713
 *
2714
 * Namespace nodes in libxml don't match the XPath semantic. In a node set
2715
 * the namespace nodes are duplicated and the next pointer is set to the
2716
 * parent node in the XPath semantic. Check if such a node needs to be freed
2717
 */
2718
void
2719
291k
xmlXPathNodeSetFreeNs(xmlNsPtr ns) {
2720
291k
    if ((ns == NULL) || (ns->type != XML_NAMESPACE_DECL))
2721
0
  return;
2722
2723
291k
    if ((ns->next != NULL) && (ns->next->type != XML_NAMESPACE_DECL)) {
2724
291k
  if (ns->href != NULL)
2725
291k
      xmlFree((xmlChar *)ns->href);
2726
291k
  if (ns->prefix != NULL)
2727
291k
      xmlFree((xmlChar *)ns->prefix);
2728
291k
  xmlFree(ns);
2729
291k
    }
2730
291k
}
2731
2732
/**
2733
 * xmlXPathNodeSetCreate:
2734
 * @val:  an initial xmlNodePtr, or NULL
2735
 *
2736
 * Create a new xmlNodeSetPtr of type double and of value @val
2737
 *
2738
 * Returns the newly created object.
2739
 */
2740
xmlNodeSetPtr
2741
610k
xmlXPathNodeSetCreate(xmlNodePtr val) {
2742
610k
    xmlNodeSetPtr ret;
2743
2744
610k
    ret = (xmlNodeSetPtr) xmlMalloc(sizeof(xmlNodeSet));
2745
610k
    if (ret == NULL)
2746
13
  return(NULL);
2747
610k
    memset(ret, 0 , sizeof(xmlNodeSet));
2748
610k
    if (val != NULL) {
2749
150k
        ret->nodeTab = (xmlNodePtr *) xmlMalloc(XML_NODESET_DEFAULT *
2750
150k
               sizeof(xmlNodePtr));
2751
150k
  if (ret->nodeTab == NULL) {
2752
4
      xmlFree(ret);
2753
4
      return(NULL);
2754
4
  }
2755
150k
  memset(ret->nodeTab, 0 ,
2756
150k
         XML_NODESET_DEFAULT * sizeof(xmlNodePtr));
2757
150k
        ret->nodeMax = XML_NODESET_DEFAULT;
2758
150k
  if (val->type == XML_NAMESPACE_DECL) {
2759
0
      xmlNsPtr ns = (xmlNsPtr) val;
2760
0
            xmlNodePtr nsNode = xmlXPathNodeSetDupNs((xmlNodePtr) ns->next, ns);
2761
2762
0
            if (nsNode == NULL) {
2763
0
                xmlXPathFreeNodeSet(ret);
2764
0
                return(NULL);
2765
0
            }
2766
0
      ret->nodeTab[ret->nodeNr++] = nsNode;
2767
0
  } else
2768
150k
      ret->nodeTab[ret->nodeNr++] = val;
2769
150k
    }
2770
610k
    return(ret);
2771
610k
}
2772
2773
/**
2774
 * xmlXPathNodeSetContains:
2775
 * @cur:  the node-set
2776
 * @val:  the node
2777
 *
2778
 * checks whether @cur contains @val
2779
 *
2780
 * Returns true (1) if @cur contains @val, false (0) otherwise
2781
 */
2782
int
2783
39.8k
xmlXPathNodeSetContains (xmlNodeSetPtr cur, xmlNodePtr val) {
2784
39.8k
    int i;
2785
2786
39.8k
    if ((cur == NULL) || (val == NULL)) return(0);
2787
39.8k
    if (val->type == XML_NAMESPACE_DECL) {
2788
5.04M
  for (i = 0; i < cur->nodeNr; i++) {
2789
5.01M
      if (cur->nodeTab[i]->type == XML_NAMESPACE_DECL) {
2790
5.01M
    xmlNsPtr ns1, ns2;
2791
2792
5.01M
    ns1 = (xmlNsPtr) val;
2793
5.01M
    ns2 = (xmlNsPtr) cur->nodeTab[i];
2794
5.01M
    if (ns1 == ns2)
2795
0
        return(1);
2796
5.01M
    if ((ns1->next != NULL) && (ns2->next == ns1->next) &&
2797
5.01M
              (xmlStrEqual(ns1->prefix, ns2->prefix)))
2798
9.42k
        return(1);
2799
5.01M
      }
2800
5.01M
  }
2801
37.6k
    } else {
2802
258k
  for (i = 0; i < cur->nodeNr; i++) {
2803
256k
      if (cur->nodeTab[i] == val)
2804
623
    return(1);
2805
256k
  }
2806
2.16k
    }
2807
29.8k
    return(0);
2808
39.8k
}
2809
2810
static int
2811
496k
xmlXPathNodeSetGrow(xmlNodeSetPtr cur) {
2812
496k
    xmlNodePtr *temp;
2813
496k
    int newSize;
2814
2815
496k
    newSize = xmlGrowCapacity(cur->nodeMax, sizeof(temp[0]),
2816
496k
                              XML_NODESET_DEFAULT, XPATH_MAX_NODESET_LENGTH);
2817
496k
    if (newSize < 0)
2818
0
        return(-1);
2819
496k
    temp = xmlRealloc(cur->nodeTab, newSize * sizeof(temp[0]));
2820
496k
    if (temp == NULL)
2821
12
        return(-1);
2822
496k
    cur->nodeMax = newSize;
2823
496k
    cur->nodeTab = temp;
2824
2825
496k
    return(0);
2826
496k
}
2827
2828
/**
2829
 * xmlXPathNodeSetAddNs:
2830
 * @cur:  the initial node set
2831
 * @node:  the hosting node
2832
 * @ns:  a the namespace node
2833
 *
2834
 * add a new namespace node to an existing NodeSet
2835
 *
2836
 * Returns 0 in case of success and -1 in case of error
2837
 */
2838
int
2839
263k
xmlXPathNodeSetAddNs(xmlNodeSetPtr cur, xmlNodePtr node, xmlNsPtr ns) {
2840
263k
    int i;
2841
263k
    xmlNodePtr nsNode;
2842
2843
263k
    if ((cur == NULL) || (ns == NULL) || (node == NULL) ||
2844
263k
        (ns->type != XML_NAMESPACE_DECL) ||
2845
263k
  (node->type != XML_ELEMENT_NODE))
2846
0
  return(-1);
2847
2848
    /* @@ with_ns to check whether namespace nodes should be looked at @@ */
2849
    /*
2850
     * prevent duplicates
2851
     */
2852
643k
    for (i = 0;i < cur->nodeNr;i++) {
2853
380k
        if ((cur->nodeTab[i] != NULL) &&
2854
380k
      (cur->nodeTab[i]->type == XML_NAMESPACE_DECL) &&
2855
380k
      (((xmlNsPtr)cur->nodeTab[i])->next == (xmlNsPtr) node) &&
2856
380k
      (xmlStrEqual(ns->prefix, ((xmlNsPtr)cur->nodeTab[i])->prefix)))
2857
0
      return(0);
2858
380k
    }
2859
2860
    /*
2861
     * grow the nodeTab if needed
2862
     */
2863
263k
    if (cur->nodeNr >= cur->nodeMax) {
2864
3.47k
        if (xmlXPathNodeSetGrow(cur) < 0)
2865
0
            return(-1);
2866
3.47k
    }
2867
263k
    nsNode = xmlXPathNodeSetDupNs(node, ns);
2868
263k
    if(nsNode == NULL)
2869
1
        return(-1);
2870
263k
    cur->nodeTab[cur->nodeNr++] = nsNode;
2871
263k
    return(0);
2872
263k
}
2873
2874
/**
2875
 * xmlXPathNodeSetAdd:
2876
 * @cur:  the initial node set
2877
 * @val:  a new xmlNodePtr
2878
 *
2879
 * add a new xmlNodePtr to an existing NodeSet
2880
 *
2881
 * Returns 0 in case of success, and -1 in case of error
2882
 */
2883
int
2884
213
xmlXPathNodeSetAdd(xmlNodeSetPtr cur, xmlNodePtr val) {
2885
213
    int i;
2886
2887
213
    if ((cur == NULL) || (val == NULL)) return(-1);
2888
2889
    /* @@ with_ns to check whether namespace nodes should be looked at @@ */
2890
    /*
2891
     * prevent duplicates
2892
     */
2893
5.08k
    for (i = 0;i < cur->nodeNr;i++)
2894
4.87k
        if (cur->nodeTab[i] == val) return(0);
2895
2896
    /*
2897
     * grow the nodeTab if needed
2898
     */
2899
213
    if (cur->nodeNr >= cur->nodeMax) {
2900
58
        if (xmlXPathNodeSetGrow(cur) < 0)
2901
0
            return(-1);
2902
58
    }
2903
2904
213
    if (val->type == XML_NAMESPACE_DECL) {
2905
0
  xmlNsPtr ns = (xmlNsPtr) val;
2906
0
        xmlNodePtr nsNode = xmlXPathNodeSetDupNs((xmlNodePtr) ns->next, ns);
2907
2908
0
        if (nsNode == NULL)
2909
0
            return(-1);
2910
0
  cur->nodeTab[cur->nodeNr++] = nsNode;
2911
0
    } else
2912
213
  cur->nodeTab[cur->nodeNr++] = val;
2913
213
    return(0);
2914
213
}
2915
2916
/**
2917
 * xmlXPathNodeSetAddUnique:
2918
 * @cur:  the initial node set
2919
 * @val:  a new xmlNodePtr
2920
 *
2921
 * add a new xmlNodePtr to an existing NodeSet, optimized version
2922
 * when we are sure the node is not already in the set.
2923
 *
2924
 * Returns 0 in case of success and -1 in case of failure
2925
 */
2926
int
2927
31.1M
xmlXPathNodeSetAddUnique(xmlNodeSetPtr cur, xmlNodePtr val) {
2928
31.1M
    if ((cur == NULL) || (val == NULL)) return(-1);
2929
2930
    /* @@ with_ns to check whether namespace nodes should be looked at @@ */
2931
    /*
2932
     * grow the nodeTab if needed
2933
     */
2934
31.1M
    if (cur->nodeNr >= cur->nodeMax) {
2935
350k
        if (xmlXPathNodeSetGrow(cur) < 0)
2936
9
            return(-1);
2937
350k
    }
2938
2939
31.1M
    if (val->type == XML_NAMESPACE_DECL) {
2940
9.45k
  xmlNsPtr ns = (xmlNsPtr) val;
2941
9.45k
        xmlNodePtr nsNode = xmlXPathNodeSetDupNs((xmlNodePtr) ns->next, ns);
2942
2943
9.45k
        if (nsNode == NULL)
2944
0
            return(-1);
2945
9.45k
  cur->nodeTab[cur->nodeNr++] = nsNode;
2946
9.45k
    } else
2947
31.1M
  cur->nodeTab[cur->nodeNr++] = val;
2948
31.1M
    return(0);
2949
31.1M
}
2950
2951
/**
2952
 * xmlXPathNodeSetMerge:
2953
 * @val1:  the first NodeSet or NULL
2954
 * @val2:  the second NodeSet
2955
 *
2956
 * Merges two nodesets, all nodes from @val2 are added to @val1
2957
 * if @val1 is NULL, a new set is created and copied from @val2
2958
 *
2959
 * Returns @val1 once extended or NULL in case of error.
2960
 *
2961
 * Frees @val1 in case of error.
2962
 */
2963
xmlNodeSetPtr
2964
90.0k
xmlXPathNodeSetMerge(xmlNodeSetPtr val1, xmlNodeSetPtr val2) {
2965
90.0k
    int i, j, initNr, skip;
2966
90.0k
    xmlNodePtr n1, n2;
2967
2968
90.0k
    if (val1 == NULL) {
2969
280
  val1 = xmlXPathNodeSetCreate(NULL);
2970
280
        if (val1 == NULL)
2971
0
            return (NULL);
2972
280
    }
2973
90.0k
    if (val2 == NULL)
2974
280
        return(val1);
2975
2976
    /* @@ with_ns to check whether namespace nodes should be looked at @@ */
2977
89.7k
    initNr = val1->nodeNr;
2978
2979
5.83M
    for (i = 0;i < val2->nodeNr;i++) {
2980
5.74M
  n2 = val2->nodeTab[i];
2981
  /*
2982
   * check against duplicates
2983
   */
2984
5.74M
  skip = 0;
2985
32.0M
  for (j = 0; j < initNr; j++) {
2986
26.3M
      n1 = val1->nodeTab[j];
2987
26.3M
      if (n1 == n2) {
2988
5
    skip = 1;
2989
5
    break;
2990
26.3M
      } else if ((n1->type == XML_NAMESPACE_DECL) &&
2991
26.3M
           (n2->type == XML_NAMESPACE_DECL)) {
2992
0
    if ((((xmlNsPtr) n1)->next == ((xmlNsPtr) n2)->next) &&
2993
0
        (xmlStrEqual(((xmlNsPtr) n1)->prefix,
2994
0
      ((xmlNsPtr) n2)->prefix)))
2995
0
    {
2996
0
        skip = 1;
2997
0
        break;
2998
0
    }
2999
0
      }
3000
26.3M
  }
3001
5.74M
  if (skip)
3002
5
      continue;
3003
3004
  /*
3005
   * grow the nodeTab if needed
3006
   */
3007
5.74M
        if (val1->nodeNr >= val1->nodeMax) {
3008
107k
            if (xmlXPathNodeSetGrow(val1) < 0)
3009
3
                goto error;
3010
107k
        }
3011
5.74M
  if (n2->type == XML_NAMESPACE_DECL) {
3012
19.3k
      xmlNsPtr ns = (xmlNsPtr) n2;
3013
19.3k
            xmlNodePtr nsNode = xmlXPathNodeSetDupNs((xmlNodePtr) ns->next, ns);
3014
3015
19.3k
            if (nsNode == NULL)
3016
0
                goto error;
3017
19.3k
      val1->nodeTab[val1->nodeNr++] = nsNode;
3018
19.3k
  } else
3019
5.72M
      val1->nodeTab[val1->nodeNr++] = n2;
3020
5.74M
    }
3021
3022
89.7k
    return(val1);
3023
3024
3
error:
3025
3
    xmlXPathFreeNodeSet(val1);
3026
3
    return(NULL);
3027
89.7k
}
3028
3029
3030
/**
3031
 * xmlXPathNodeSetMergeAndClear:
3032
 * @set1:  the first NodeSet or NULL
3033
 * @set2:  the second NodeSet
3034
 *
3035
 * Merges two nodesets, all nodes from @set2 are added to @set1.
3036
 * Checks for duplicate nodes. Clears set2.
3037
 *
3038
 * Returns @set1 once extended or NULL in case of error.
3039
 *
3040
 * Frees @set1 in case of error.
3041
 */
3042
static xmlNodeSetPtr
3043
xmlXPathNodeSetMergeAndClear(xmlNodeSetPtr set1, xmlNodeSetPtr set2)
3044
1.63M
{
3045
1.63M
    {
3046
1.63M
  int i, j, initNbSet1;
3047
1.63M
  xmlNodePtr n1, n2;
3048
3049
1.63M
  initNbSet1 = set1->nodeNr;
3050
4.09M
  for (i = 0;i < set2->nodeNr;i++) {
3051
2.45M
      n2 = set2->nodeTab[i];
3052
      /*
3053
      * Skip duplicates.
3054
      */
3055
394M
      for (j = 0; j < initNbSet1; j++) {
3056
394M
    n1 = set1->nodeTab[j];
3057
394M
    if (n1 == n2) {
3058
1.71M
        goto skip_node;
3059
392M
    } else if ((n1->type == XML_NAMESPACE_DECL) &&
3060
392M
        (n2->type == XML_NAMESPACE_DECL))
3061
0
    {
3062
0
        if ((((xmlNsPtr) n1)->next == ((xmlNsPtr) n2)->next) &&
3063
0
      (xmlStrEqual(((xmlNsPtr) n1)->prefix,
3064
0
      ((xmlNsPtr) n2)->prefix)))
3065
0
        {
3066
      /*
3067
      * Free the namespace node.
3068
      */
3069
0
      xmlXPathNodeSetFreeNs((xmlNsPtr) n2);
3070
0
      goto skip_node;
3071
0
        }
3072
0
    }
3073
394M
      }
3074
      /*
3075
      * grow the nodeTab if needed
3076
      */
3077
745k
            if (set1->nodeNr >= set1->nodeMax) {
3078
31.6k
                if (xmlXPathNodeSetGrow(set1) < 0)
3079
0
                    goto error;
3080
31.6k
            }
3081
745k
      set1->nodeTab[set1->nodeNr++] = n2;
3082
2.45M
skip_node:
3083
2.45M
            set2->nodeTab[i] = NULL;
3084
2.45M
  }
3085
1.63M
    }
3086
1.63M
    set2->nodeNr = 0;
3087
1.63M
    return(set1);
3088
3089
0
error:
3090
0
    xmlXPathFreeNodeSet(set1);
3091
0
    xmlXPathNodeSetClear(set2, 1);
3092
0
    return(NULL);
3093
1.63M
}
3094
3095
/**
3096
 * xmlXPathNodeSetMergeAndClearNoDupls:
3097
 * @set1:  the first NodeSet or NULL
3098
 * @set2:  the second NodeSet
3099
 *
3100
 * Merges two nodesets, all nodes from @set2 are added to @set1.
3101
 * Doesn't check for duplicate nodes. Clears set2.
3102
 *
3103
 * Returns @set1 once extended or NULL in case of error.
3104
 *
3105
 * Frees @set1 in case of error.
3106
 */
3107
static xmlNodeSetPtr
3108
xmlXPathNodeSetMergeAndClearNoDupls(xmlNodeSetPtr set1, xmlNodeSetPtr set2)
3109
75.6k
{
3110
75.6k
    {
3111
75.6k
  int i;
3112
75.6k
  xmlNodePtr n2;
3113
3114
924k
  for (i = 0;i < set2->nodeNr;i++) {
3115
849k
      n2 = set2->nodeTab[i];
3116
849k
            if (set1->nodeNr >= set1->nodeMax) {
3117
3.19k
                if (xmlXPathNodeSetGrow(set1) < 0)
3118
0
                    goto error;
3119
3.19k
            }
3120
849k
      set1->nodeTab[set1->nodeNr++] = n2;
3121
849k
            set2->nodeTab[i] = NULL;
3122
849k
  }
3123
75.6k
    }
3124
75.6k
    set2->nodeNr = 0;
3125
75.6k
    return(set1);
3126
3127
0
error:
3128
0
    xmlXPathFreeNodeSet(set1);
3129
0
    xmlXPathNodeSetClear(set2, 1);
3130
0
    return(NULL);
3131
75.6k
}
3132
3133
/**
3134
 * xmlXPathNodeSetDel:
3135
 * @cur:  the initial node set
3136
 * @val:  an xmlNodePtr
3137
 *
3138
 * Removes an xmlNodePtr from an existing NodeSet
3139
 */
3140
void
3141
0
xmlXPathNodeSetDel(xmlNodeSetPtr cur, xmlNodePtr val) {
3142
0
    int i;
3143
3144
0
    if (cur == NULL) return;
3145
0
    if (val == NULL) return;
3146
3147
    /*
3148
     * find node in nodeTab
3149
     */
3150
0
    for (i = 0;i < cur->nodeNr;i++)
3151
0
        if (cur->nodeTab[i] == val) break;
3152
3153
0
    if (i >= cur->nodeNr) { /* not found */
3154
0
        return;
3155
0
    }
3156
0
    if ((cur->nodeTab[i] != NULL) &&
3157
0
  (cur->nodeTab[i]->type == XML_NAMESPACE_DECL))
3158
0
  xmlXPathNodeSetFreeNs((xmlNsPtr) cur->nodeTab[i]);
3159
0
    cur->nodeNr--;
3160
0
    for (;i < cur->nodeNr;i++)
3161
0
        cur->nodeTab[i] = cur->nodeTab[i + 1];
3162
0
    cur->nodeTab[cur->nodeNr] = NULL;
3163
0
}
3164
3165
/**
3166
 * xmlXPathNodeSetRemove:
3167
 * @cur:  the initial node set
3168
 * @val:  the index to remove
3169
 *
3170
 * Removes an entry from an existing NodeSet list.
3171
 */
3172
void
3173
0
xmlXPathNodeSetRemove(xmlNodeSetPtr cur, int val) {
3174
0
    if (cur == NULL) return;
3175
0
    if (val >= cur->nodeNr) return;
3176
0
    if ((cur->nodeTab[val] != NULL) &&
3177
0
  (cur->nodeTab[val]->type == XML_NAMESPACE_DECL))
3178
0
  xmlXPathNodeSetFreeNs((xmlNsPtr) cur->nodeTab[val]);
3179
0
    cur->nodeNr--;
3180
0
    for (;val < cur->nodeNr;val++)
3181
0
        cur->nodeTab[val] = cur->nodeTab[val + 1];
3182
0
    cur->nodeTab[cur->nodeNr] = NULL;
3183
0
}
3184
3185
/**
3186
 * xmlXPathFreeNodeSet:
3187
 * @obj:  the xmlNodeSetPtr to free
3188
 *
3189
 * Free the NodeSet compound (not the actual nodes !).
3190
 */
3191
void
3192
595k
xmlXPathFreeNodeSet(xmlNodeSetPtr obj) {
3193
595k
    if (obj == NULL) return;
3194
595k
    if (obj->nodeTab != NULL) {
3195
221k
  int i;
3196
3197
  /* @@ with_ns to check whether namespace nodes should be looked at @@ */
3198
32.5M
  for (i = 0;i < obj->nodeNr;i++)
3199
32.3M
      if ((obj->nodeTab[i] != NULL) &&
3200
32.3M
    (obj->nodeTab[i]->type == XML_NAMESPACE_DECL))
3201
288k
    xmlXPathNodeSetFreeNs((xmlNsPtr) obj->nodeTab[i]);
3202
221k
  xmlFree(obj->nodeTab);
3203
221k
    }
3204
595k
    xmlFree(obj);
3205
595k
}
3206
3207
/**
3208
 * xmlXPathNodeSetClearFromPos:
3209
 * @set: the node set to be cleared
3210
 * @pos: the start position to clear from
3211
 *
3212
 * Clears the list from temporary XPath objects (e.g. namespace nodes
3213
 * are feed) starting with the entry at @pos, but does *not* free the list
3214
 * itself. Sets the length of the list to @pos.
3215
 */
3216
static void
3217
xmlXPathNodeSetClearFromPos(xmlNodeSetPtr set, int pos, int hasNsNodes)
3218
9
{
3219
9
    if ((set == NULL) || (pos >= set->nodeNr))
3220
0
  return;
3221
9
    else if ((hasNsNodes)) {
3222
9
  int i;
3223
9
  xmlNodePtr node;
3224
3225
395k
  for (i = pos; i < set->nodeNr; i++) {
3226
395k
      node = set->nodeTab[i];
3227
395k
      if ((node != NULL) &&
3228
395k
    (node->type == XML_NAMESPACE_DECL))
3229
0
    xmlXPathNodeSetFreeNs((xmlNsPtr) node);
3230
395k
  }
3231
9
    }
3232
9
    set->nodeNr = pos;
3233
9
}
3234
3235
/**
3236
 * xmlXPathNodeSetClear:
3237
 * @set:  the node set to clear
3238
 *
3239
 * Clears the list from all temporary XPath objects (e.g. namespace nodes
3240
 * are feed), but does *not* free the list itself. Sets the length of the
3241
 * list to 0.
3242
 */
3243
static void
3244
xmlXPathNodeSetClear(xmlNodeSetPtr set, int hasNsNodes)
3245
0
{
3246
0
    xmlXPathNodeSetClearFromPos(set, 0, hasNsNodes);
3247
0
}
3248
3249
/**
3250
 * xmlXPathNodeSetKeepLast:
3251
 * @set: the node set to be cleared
3252
 *
3253
 * Move the last node to the first position and clear temporary XPath objects
3254
 * (e.g. namespace nodes) from all other nodes. Sets the length of the list
3255
 * to 1.
3256
 */
3257
static void
3258
xmlXPathNodeSetKeepLast(xmlNodeSetPtr set)
3259
0
{
3260
0
    int i;
3261
0
    xmlNodePtr node;
3262
3263
0
    if ((set == NULL) || (set->nodeNr <= 1))
3264
0
  return;
3265
0
    for (i = 0; i < set->nodeNr - 1; i++) {
3266
0
        node = set->nodeTab[i];
3267
0
        if ((node != NULL) &&
3268
0
            (node->type == XML_NAMESPACE_DECL))
3269
0
            xmlXPathNodeSetFreeNs((xmlNsPtr) node);
3270
0
    }
3271
0
    set->nodeTab[0] = set->nodeTab[set->nodeNr-1];
3272
0
    set->nodeNr = 1;
3273
0
}
3274
3275
/**
3276
 * xmlXPathNewNodeSet:
3277
 * @val:  the NodePtr value
3278
 *
3279
 * Create a new xmlXPathObjectPtr of type NodeSet and initialize
3280
 * it with the single Node @val
3281
 *
3282
 * Returns the newly created object.
3283
 */
3284
xmlXPathObjectPtr
3285
242k
xmlXPathNewNodeSet(xmlNodePtr val) {
3286
242k
    xmlXPathObjectPtr ret;
3287
3288
242k
    ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
3289
242k
    if (ret == NULL)
3290
89
  return(NULL);
3291
242k
    memset(ret, 0 , sizeof(xmlXPathObject));
3292
242k
    ret->type = XPATH_NODESET;
3293
242k
    ret->boolval = 0;
3294
242k
    ret->nodesetval = xmlXPathNodeSetCreate(val);
3295
242k
    if (ret->nodesetval == NULL) {
3296
10
        xmlFree(ret);
3297
10
        return(NULL);
3298
10
    }
3299
    /* @@ with_ns to check whether namespace nodes should be looked at @@ */
3300
242k
    return(ret);
3301
242k
}
3302
3303
/**
3304
 * xmlXPathNewValueTree:
3305
 * @val:  the NodePtr value
3306
 *
3307
 * Create a new xmlXPathObjectPtr of type Value Tree (XSLT) and initialize
3308
 * it with the tree root @val
3309
 *
3310
 * Returns the newly created object.
3311
 */
3312
xmlXPathObjectPtr
3313
0
xmlXPathNewValueTree(xmlNodePtr val) {
3314
0
    xmlXPathObjectPtr ret;
3315
3316
0
    ret = xmlXPathNewNodeSet(val);
3317
0
    if (ret == NULL)
3318
0
  return(NULL);
3319
0
    ret->type = XPATH_XSLT_TREE;
3320
3321
0
    return(ret);
3322
0
}
3323
3324
/**
3325
 * xmlXPathNewNodeSetList:
3326
 * @val:  an existing NodeSet
3327
 *
3328
 * Create a new xmlXPathObjectPtr of type NodeSet and initialize
3329
 * it with the Nodeset @val
3330
 *
3331
 * Returns the newly created object.
3332
 */
3333
xmlXPathObjectPtr
3334
xmlXPathNewNodeSetList(xmlNodeSetPtr val)
3335
0
{
3336
0
    xmlXPathObjectPtr ret;
3337
3338
0
    if (val == NULL)
3339
0
        ret = NULL;
3340
0
    else if (val->nodeTab == NULL)
3341
0
        ret = xmlXPathNewNodeSet(NULL);
3342
0
    else {
3343
0
        ret = xmlXPathNewNodeSet(val->nodeTab[0]);
3344
0
        if (ret) {
3345
0
            ret->nodesetval = xmlXPathNodeSetMerge(NULL, val);
3346
0
            if (ret->nodesetval == NULL) {
3347
0
                xmlFree(ret);
3348
0
                return(NULL);
3349
0
            }
3350
0
        }
3351
0
    }
3352
3353
0
    return (ret);
3354
0
}
3355
3356
/**
3357
 * xmlXPathWrapNodeSet:
3358
 * @val:  the NodePtr value
3359
 *
3360
 * Wrap the Nodeset @val in a new xmlXPathObjectPtr
3361
 *
3362
 * Returns the newly created object.
3363
 *
3364
 * In case of error the node set is destroyed and NULL is returned.
3365
 */
3366
xmlXPathObjectPtr
3367
126k
xmlXPathWrapNodeSet(xmlNodeSetPtr val) {
3368
126k
    xmlXPathObjectPtr ret;
3369
3370
126k
    ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
3371
126k
    if (ret == NULL) {
3372
32
        xmlXPathFreeNodeSet(val);
3373
32
  return(NULL);
3374
32
    }
3375
126k
    memset(ret, 0 , sizeof(xmlXPathObject));
3376
126k
    ret->type = XPATH_NODESET;
3377
126k
    ret->nodesetval = val;
3378
126k
    return(ret);
3379
126k
}
3380
3381
/**
3382
 * xmlXPathFreeNodeSetList:
3383
 * @obj:  an existing NodeSetList object
3384
 *
3385
 * Free up the xmlXPathObjectPtr @obj but don't deallocate the objects in
3386
 * the list contrary to xmlXPathFreeObject().
3387
 */
3388
void
3389
0
xmlXPathFreeNodeSetList(xmlXPathObjectPtr obj) {
3390
0
    if (obj == NULL) return;
3391
0
    xmlFree(obj);
3392
0
}
3393
3394
/**
3395
 * xmlXPathDifference:
3396
 * @nodes1:  a node-set
3397
 * @nodes2:  a node-set
3398
 *
3399
 * Implements the EXSLT - Sets difference() function:
3400
 *    node-set set:difference (node-set, node-set)
3401
 *
3402
 * Returns the difference between the two node sets, or nodes1 if
3403
 *         nodes2 is empty
3404
 */
3405
xmlNodeSetPtr
3406
208
xmlXPathDifference (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
3407
208
    xmlNodeSetPtr ret;
3408
208
    int i, l1;
3409
208
    xmlNodePtr cur;
3410
3411
208
    if (xmlXPathNodeSetIsEmpty(nodes2))
3412
177
  return(nodes1);
3413
3414
31
    ret = xmlXPathNodeSetCreate(NULL);
3415
31
    if (ret == NULL)
3416
0
        return(NULL);
3417
31
    if (xmlXPathNodeSetIsEmpty(nodes1))
3418
0
  return(ret);
3419
3420
31
    l1 = xmlXPathNodeSetGetLength(nodes1);
3421
3422
2.13k
    for (i = 0; i < l1; i++) {
3423
2.10k
  cur = xmlXPathNodeSetItem(nodes1, i);
3424
2.10k
  if (!xmlXPathNodeSetContains(nodes2, cur)) {
3425
1.53k
      if (xmlXPathNodeSetAddUnique(ret, cur) < 0) {
3426
0
                xmlXPathFreeNodeSet(ret);
3427
0
          return(NULL);
3428
0
            }
3429
1.53k
  }
3430
2.10k
    }
3431
31
    return(ret);
3432
31
}
3433
3434
/**
3435
 * xmlXPathIntersection:
3436
 * @nodes1:  a node-set
3437
 * @nodes2:  a node-set
3438
 *
3439
 * Implements the EXSLT - Sets intersection() function:
3440
 *    node-set set:intersection (node-set, node-set)
3441
 *
3442
 * Returns a node set comprising the nodes that are within both the
3443
 *         node sets passed as arguments
3444
 */
3445
xmlNodeSetPtr
3446
62
xmlXPathIntersection (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
3447
62
    xmlNodeSetPtr ret = xmlXPathNodeSetCreate(NULL);
3448
62
    int i, l1;
3449
62
    xmlNodePtr cur;
3450
3451
62
    if (ret == NULL)
3452
0
        return(ret);
3453
62
    if (xmlXPathNodeSetIsEmpty(nodes1))
3454
0
  return(ret);
3455
62
    if (xmlXPathNodeSetIsEmpty(nodes2))
3456
0
  return(ret);
3457
3458
62
    l1 = xmlXPathNodeSetGetLength(nodes1);
3459
3460
37.7k
    for (i = 0; i < l1; i++) {
3461
37.6k
  cur = xmlXPathNodeSetItem(nodes1, i);
3462
37.6k
  if (xmlXPathNodeSetContains(nodes2, cur)) {
3463
9.42k
      if (xmlXPathNodeSetAddUnique(ret, cur) < 0) {
3464
0
                xmlXPathFreeNodeSet(ret);
3465
0
          return(NULL);
3466
0
            }
3467
9.42k
  }
3468
37.6k
    }
3469
62
    return(ret);
3470
62
}
3471
3472
/**
3473
 * xmlXPathDistinctSorted:
3474
 * @nodes:  a node-set, sorted by document order
3475
 *
3476
 * Implements the EXSLT - Sets distinct() function:
3477
 *    node-set set:distinct (node-set)
3478
 *
3479
 * Returns a subset of the nodes contained in @nodes, or @nodes if
3480
 *         it is empty
3481
 */
3482
xmlNodeSetPtr
3483
173
xmlXPathDistinctSorted (xmlNodeSetPtr nodes) {
3484
173
    xmlNodeSetPtr ret;
3485
173
    xmlHashTablePtr hash;
3486
173
    int i, l;
3487
173
    xmlChar * strval;
3488
173
    xmlNodePtr cur;
3489
3490
173
    if (xmlXPathNodeSetIsEmpty(nodes))
3491
0
  return(nodes);
3492
3493
173
    ret = xmlXPathNodeSetCreate(NULL);
3494
173
    if (ret == NULL)
3495
0
        return(ret);
3496
173
    l = xmlXPathNodeSetGetLength(nodes);
3497
173
    hash = xmlHashCreate (l);
3498
52.5k
    for (i = 0; i < l; i++) {
3499
52.3k
  cur = xmlXPathNodeSetItem(nodes, i);
3500
52.3k
  strval = xmlXPathCastNodeToString(cur);
3501
52.3k
  if (xmlHashLookup(hash, strval) == NULL) {
3502
6.96k
      if (xmlHashAddEntry(hash, strval, strval) < 0) {
3503
2
                xmlFree(strval);
3504
2
                goto error;
3505
2
            }
3506
6.96k
      if (xmlXPathNodeSetAddUnique(ret, cur) < 0)
3507
0
          goto error;
3508
45.4k
  } else {
3509
45.4k
      xmlFree(strval);
3510
45.4k
  }
3511
52.3k
    }
3512
171
    xmlHashFree(hash, xmlHashDefaultDeallocator);
3513
171
    return(ret);
3514
3515
2
error:
3516
2
    xmlHashFree(hash, xmlHashDefaultDeallocator);
3517
2
    xmlXPathFreeNodeSet(ret);
3518
2
    return(NULL);
3519
173
}
3520
3521
/**
3522
 * xmlXPathDistinct:
3523
 * @nodes:  a node-set
3524
 *
3525
 * Implements the EXSLT - Sets distinct() function:
3526
 *    node-set set:distinct (node-set)
3527
 * @nodes is sorted by document order, then #exslSetsDistinctSorted
3528
 * is called with the sorted node-set
3529
 *
3530
 * Returns a subset of the nodes contained in @nodes, or @nodes if
3531
 *         it is empty
3532
 */
3533
xmlNodeSetPtr
3534
0
xmlXPathDistinct (xmlNodeSetPtr nodes) {
3535
0
    if (xmlXPathNodeSetIsEmpty(nodes))
3536
0
  return(nodes);
3537
3538
0
    xmlXPathNodeSetSort(nodes);
3539
0
    return(xmlXPathDistinctSorted(nodes));
3540
0
}
3541
3542
/**
3543
 * xmlXPathHasSameNodes:
3544
 * @nodes1:  a node-set
3545
 * @nodes2:  a node-set
3546
 *
3547
 * Implements the EXSLT - Sets has-same-nodes function:
3548
 *    boolean set:has-same-node(node-set, node-set)
3549
 *
3550
 * Returns true (1) if @nodes1 shares any node with @nodes2, false (0)
3551
 *         otherwise
3552
 */
3553
int
3554
0
xmlXPathHasSameNodes (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
3555
0
    int i, l;
3556
0
    xmlNodePtr cur;
3557
3558
0
    if (xmlXPathNodeSetIsEmpty(nodes1) ||
3559
0
  xmlXPathNodeSetIsEmpty(nodes2))
3560
0
  return(0);
3561
3562
0
    l = xmlXPathNodeSetGetLength(nodes1);
3563
0
    for (i = 0; i < l; i++) {
3564
0
  cur = xmlXPathNodeSetItem(nodes1, i);
3565
0
  if (xmlXPathNodeSetContains(nodes2, cur))
3566
0
      return(1);
3567
0
    }
3568
0
    return(0);
3569
0
}
3570
3571
/**
3572
 * xmlXPathNodeLeadingSorted:
3573
 * @nodes: a node-set, sorted by document order
3574
 * @node: a node
3575
 *
3576
 * Implements the EXSLT - Sets leading() function:
3577
 *    node-set set:leading (node-set, node-set)
3578
 *
3579
 * Returns the nodes in @nodes that precede @node in document order,
3580
 *         @nodes if @node is NULL or an empty node-set if @nodes
3581
 *         doesn't contain @node
3582
 */
3583
xmlNodeSetPtr
3584
0
xmlXPathNodeLeadingSorted (xmlNodeSetPtr nodes, xmlNodePtr node) {
3585
0
    int i, l;
3586
0
    xmlNodePtr cur;
3587
0
    xmlNodeSetPtr ret;
3588
3589
0
    if (node == NULL)
3590
0
  return(nodes);
3591
3592
0
    ret = xmlXPathNodeSetCreate(NULL);
3593
0
    if (ret == NULL)
3594
0
        return(ret);
3595
0
    if (xmlXPathNodeSetIsEmpty(nodes) ||
3596
0
  (!xmlXPathNodeSetContains(nodes, node)))
3597
0
  return(ret);
3598
3599
0
    l = xmlXPathNodeSetGetLength(nodes);
3600
0
    for (i = 0; i < l; i++) {
3601
0
  cur = xmlXPathNodeSetItem(nodes, i);
3602
0
  if (cur == node)
3603
0
      break;
3604
0
  if (xmlXPathNodeSetAddUnique(ret, cur) < 0) {
3605
0
            xmlXPathFreeNodeSet(ret);
3606
0
      return(NULL);
3607
0
        }
3608
0
    }
3609
0
    return(ret);
3610
0
}
3611
3612
/**
3613
 * xmlXPathNodeLeading:
3614
 * @nodes:  a node-set
3615
 * @node:  a node
3616
 *
3617
 * Implements the EXSLT - Sets leading() function:
3618
 *    node-set set:leading (node-set, node-set)
3619
 * @nodes is sorted by document order, then #exslSetsNodeLeadingSorted
3620
 * is called.
3621
 *
3622
 * Returns the nodes in @nodes that precede @node in document order,
3623
 *         @nodes if @node is NULL or an empty node-set if @nodes
3624
 *         doesn't contain @node
3625
 */
3626
xmlNodeSetPtr
3627
0
xmlXPathNodeLeading (xmlNodeSetPtr nodes, xmlNodePtr node) {
3628
0
    xmlXPathNodeSetSort(nodes);
3629
0
    return(xmlXPathNodeLeadingSorted(nodes, node));
3630
0
}
3631
3632
/**
3633
 * xmlXPathLeadingSorted:
3634
 * @nodes1:  a node-set, sorted by document order
3635
 * @nodes2:  a node-set, sorted by document order
3636
 *
3637
 * Implements the EXSLT - Sets leading() function:
3638
 *    node-set set:leading (node-set, node-set)
3639
 *
3640
 * Returns the nodes in @nodes1 that precede the first node in @nodes2
3641
 *         in document order, @nodes1 if @nodes2 is NULL or empty or
3642
 *         an empty node-set if @nodes1 doesn't contain @nodes2
3643
 */
3644
xmlNodeSetPtr
3645
0
xmlXPathLeadingSorted (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
3646
0
    if (xmlXPathNodeSetIsEmpty(nodes2))
3647
0
  return(nodes1);
3648
0
    return(xmlXPathNodeLeadingSorted(nodes1,
3649
0
             xmlXPathNodeSetItem(nodes2, 1)));
3650
0
}
3651
3652
/**
3653
 * xmlXPathLeading:
3654
 * @nodes1:  a node-set
3655
 * @nodes2:  a node-set
3656
 *
3657
 * Implements the EXSLT - Sets leading() function:
3658
 *    node-set set:leading (node-set, node-set)
3659
 * @nodes1 and @nodes2 are sorted by document order, then
3660
 * #exslSetsLeadingSorted is called.
3661
 *
3662
 * Returns the nodes in @nodes1 that precede the first node in @nodes2
3663
 *         in document order, @nodes1 if @nodes2 is NULL or empty or
3664
 *         an empty node-set if @nodes1 doesn't contain @nodes2
3665
 */
3666
xmlNodeSetPtr
3667
0
xmlXPathLeading (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
3668
0
    if (xmlXPathNodeSetIsEmpty(nodes2))
3669
0
  return(nodes1);
3670
0
    if (xmlXPathNodeSetIsEmpty(nodes1))
3671
0
  return(xmlXPathNodeSetCreate(NULL));
3672
0
    xmlXPathNodeSetSort(nodes1);
3673
0
    xmlXPathNodeSetSort(nodes2);
3674
0
    return(xmlXPathNodeLeadingSorted(nodes1,
3675
0
             xmlXPathNodeSetItem(nodes2, 1)));
3676
0
}
3677
3678
/**
3679
 * xmlXPathNodeTrailingSorted:
3680
 * @nodes: a node-set, sorted by document order
3681
 * @node: a node
3682
 *
3683
 * Implements the EXSLT - Sets trailing() function:
3684
 *    node-set set:trailing (node-set, node-set)
3685
 *
3686
 * Returns the nodes in @nodes that follow @node in document order,
3687
 *         @nodes if @node is NULL or an empty node-set if @nodes
3688
 *         doesn't contain @node
3689
 */
3690
xmlNodeSetPtr
3691
54
xmlXPathNodeTrailingSorted (xmlNodeSetPtr nodes, xmlNodePtr node) {
3692
54
    int i, l;
3693
54
    xmlNodePtr cur;
3694
54
    xmlNodeSetPtr ret;
3695
3696
54
    if (node == NULL)
3697
0
  return(nodes);
3698
3699
54
    ret = xmlXPathNodeSetCreate(NULL);
3700
54
    if (ret == NULL)
3701
0
        return(ret);
3702
54
    if (xmlXPathNodeSetIsEmpty(nodes) ||
3703
54
  (!xmlXPathNodeSetContains(nodes, node)))
3704
0
  return(ret);
3705
3706
54
    l = xmlXPathNodeSetGetLength(nodes);
3707
2.47M
    for (i = l - 1; i >= 0; i--) {
3708
2.47M
  cur = xmlXPathNodeSetItem(nodes, i);
3709
2.47M
  if (cur == node)
3710
54
      break;
3711
2.47M
  if (xmlXPathNodeSetAddUnique(ret, cur) < 0) {
3712
0
            xmlXPathFreeNodeSet(ret);
3713
0
      return(NULL);
3714
0
        }
3715
2.47M
    }
3716
54
    xmlXPathNodeSetSort(ret); /* bug 413451 */
3717
54
    return(ret);
3718
54
}
3719
3720
/**
3721
 * xmlXPathNodeTrailing:
3722
 * @nodes:  a node-set
3723
 * @node:  a node
3724
 *
3725
 * Implements the EXSLT - Sets trailing() function:
3726
 *    node-set set:trailing (node-set, node-set)
3727
 * @nodes is sorted by document order, then #xmlXPathNodeTrailingSorted
3728
 * is called.
3729
 *
3730
 * Returns the nodes in @nodes that follow @node in document order,
3731
 *         @nodes if @node is NULL or an empty node-set if @nodes
3732
 *         doesn't contain @node
3733
 */
3734
xmlNodeSetPtr
3735
0
xmlXPathNodeTrailing (xmlNodeSetPtr nodes, xmlNodePtr node) {
3736
0
    xmlXPathNodeSetSort(nodes);
3737
0
    return(xmlXPathNodeTrailingSorted(nodes, node));
3738
0
}
3739
3740
/**
3741
 * xmlXPathTrailingSorted:
3742
 * @nodes1:  a node-set, sorted by document order
3743
 * @nodes2:  a node-set, sorted by document order
3744
 *
3745
 * Implements the EXSLT - Sets trailing() function:
3746
 *    node-set set:trailing (node-set, node-set)
3747
 *
3748
 * Returns the nodes in @nodes1 that follow the first node in @nodes2
3749
 *         in document order, @nodes1 if @nodes2 is NULL or empty or
3750
 *         an empty node-set if @nodes1 doesn't contain @nodes2
3751
 */
3752
xmlNodeSetPtr
3753
0
xmlXPathTrailingSorted (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
3754
0
    if (xmlXPathNodeSetIsEmpty(nodes2))
3755
0
  return(nodes1);
3756
0
    return(xmlXPathNodeTrailingSorted(nodes1,
3757
0
              xmlXPathNodeSetItem(nodes2, 0)));
3758
0
}
3759
3760
/**
3761
 * xmlXPathTrailing:
3762
 * @nodes1:  a node-set
3763
 * @nodes2:  a node-set
3764
 *
3765
 * Implements the EXSLT - Sets trailing() function:
3766
 *    node-set set:trailing (node-set, node-set)
3767
 * @nodes1 and @nodes2 are sorted by document order, then
3768
 * #xmlXPathTrailingSorted is called.
3769
 *
3770
 * Returns the nodes in @nodes1 that follow the first node in @nodes2
3771
 *         in document order, @nodes1 if @nodes2 is NULL or empty or
3772
 *         an empty node-set if @nodes1 doesn't contain @nodes2
3773
 */
3774
xmlNodeSetPtr
3775
0
xmlXPathTrailing (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
3776
0
    if (xmlXPathNodeSetIsEmpty(nodes2))
3777
0
  return(nodes1);
3778
0
    if (xmlXPathNodeSetIsEmpty(nodes1))
3779
0
  return(xmlXPathNodeSetCreate(NULL));
3780
0
    xmlXPathNodeSetSort(nodes1);
3781
0
    xmlXPathNodeSetSort(nodes2);
3782
0
    return(xmlXPathNodeTrailingSorted(nodes1,
3783
0
              xmlXPathNodeSetItem(nodes2, 0)));
3784
0
}
3785
3786
/************************************************************************
3787
 *                  *
3788
 *    Routines to handle extra functions      *
3789
 *                  *
3790
 ************************************************************************/
3791
3792
/**
3793
 * xmlXPathRegisterFunc:
3794
 * @ctxt:  the XPath context
3795
 * @name:  the function name
3796
 * @f:  the function implementation or NULL
3797
 *
3798
 * Register a new function. If @f is NULL it unregisters the function
3799
 *
3800
 * Returns 0 in case of success, -1 in case of error
3801
 */
3802
int
3803
xmlXPathRegisterFunc(xmlXPathContextPtr ctxt, const xmlChar *name,
3804
7.12k
         xmlXPathFunction f) {
3805
7.12k
    return(xmlXPathRegisterFuncNS(ctxt, name, NULL, f));
3806
7.12k
}
3807
3808
/**
3809
 * xmlXPathRegisterFuncNS:
3810
 * @ctxt:  the XPath context
3811
 * @name:  the function name
3812
 * @ns_uri:  the function namespace URI
3813
 * @f:  the function implementation or NULL
3814
 *
3815
 * Register a new function. If @f is NULL it unregisters the function
3816
 *
3817
 * Returns 0 in case of success, -1 in case of error
3818
 */
3819
int
3820
xmlXPathRegisterFuncNS(xmlXPathContextPtr ctxt, const xmlChar *name,
3821
7.12k
           const xmlChar *ns_uri, xmlXPathFunction f) {
3822
7.12k
    int ret;
3823
7.12k
    void *payload;
3824
3825
7.12k
    if (ctxt == NULL)
3826
0
  return(-1);
3827
7.12k
    if (name == NULL)
3828
0
  return(-1);
3829
3830
7.12k
    if (ctxt->funcHash == NULL)
3831
792
  ctxt->funcHash = xmlHashCreate(0);
3832
7.12k
    if (ctxt->funcHash == NULL) {
3833
0
        xmlXPathErrMemory(ctxt);
3834
0
  return(-1);
3835
0
    }
3836
7.12k
    if (f == NULL)
3837
0
        return(xmlHashRemoveEntry2(ctxt->funcHash, name, ns_uri, NULL));
3838
7.12k
    memcpy(&payload, &f, sizeof(f));
3839
7.12k
    ret = xmlHashAddEntry2(ctxt->funcHash, name, ns_uri, payload);
3840
7.12k
    if (ret < 0) {
3841
0
        xmlXPathErrMemory(ctxt);
3842
0
        return(-1);
3843
0
    }
3844
3845
7.12k
    return(0);
3846
7.12k
}
3847
3848
/**
3849
 * xmlXPathRegisterFuncLookup:
3850
 * @ctxt:  the XPath context
3851
 * @f:  the lookup function
3852
 * @funcCtxt:  the lookup data
3853
 *
3854
 * Registers an external mechanism to do function lookup.
3855
 */
3856
void
3857
xmlXPathRegisterFuncLookup (xmlXPathContextPtr ctxt,
3858
          xmlXPathFuncLookupFunc f,
3859
792
          void *funcCtxt) {
3860
792
    if (ctxt == NULL)
3861
0
  return;
3862
792
    ctxt->funcLookupFunc = f;
3863
792
    ctxt->funcLookupData = funcCtxt;
3864
792
}
3865
3866
/**
3867
 * xmlXPathFunctionLookup:
3868
 * @ctxt:  the XPath context
3869
 * @name:  the function name
3870
 *
3871
 * Search in the Function array of the context for the given
3872
 * function.
3873
 *
3874
 * Returns the xmlXPathFunction or NULL if not found
3875
 */
3876
xmlXPathFunction
3877
2.51k
xmlXPathFunctionLookup(xmlXPathContextPtr ctxt, const xmlChar *name) {
3878
2.51k
    return(xmlXPathFunctionLookupNS(ctxt, name, NULL));
3879
2.51k
}
3880
3881
/**
3882
 * xmlXPathFunctionLookupNS:
3883
 * @ctxt:  the XPath context
3884
 * @name:  the function name
3885
 * @ns_uri:  the function namespace URI
3886
 *
3887
 * Search in the Function array of the context for the given
3888
 * function.
3889
 *
3890
 * Returns the xmlXPathFunction or NULL if not found
3891
 */
3892
xmlXPathFunction
3893
xmlXPathFunctionLookupNS(xmlXPathContextPtr ctxt, const xmlChar *name,
3894
2.72k
       const xmlChar *ns_uri) {
3895
2.72k
    xmlXPathFunction ret;
3896
2.72k
    void *payload;
3897
3898
2.72k
    if (ctxt == NULL)
3899
0
  return(NULL);
3900
2.72k
    if (name == NULL)
3901
0
  return(NULL);
3902
3903
2.72k
    if (ns_uri == NULL) {
3904
2.51k
        int bucketIndex = xmlXPathSFComputeHash(name) % SF_HASH_SIZE;
3905
3906
2.91k
        while (xmlXPathSFHash[bucketIndex] != UCHAR_MAX) {
3907
440
            int funcIndex = xmlXPathSFHash[bucketIndex];
3908
3909
440
            if (strcmp(xmlXPathStandardFunctions[funcIndex].name,
3910
440
                       (char *) name) == 0)
3911
37
                return(xmlXPathStandardFunctions[funcIndex].func);
3912
3913
403
            bucketIndex += 1;
3914
403
            if (bucketIndex >= SF_HASH_SIZE)
3915
0
                bucketIndex = 0;
3916
403
        }
3917
2.51k
    }
3918
3919
2.69k
    if (ctxt->funcLookupFunc != NULL) {
3920
2.69k
  xmlXPathFuncLookupFunc f;
3921
3922
2.69k
  f = ctxt->funcLookupFunc;
3923
2.69k
  ret = f(ctxt->funcLookupData, name, ns_uri);
3924
2.69k
  if (ret != NULL)
3925
217
      return(ret);
3926
2.69k
    }
3927
3928
2.47k
    if (ctxt->funcHash == NULL)
3929
0
  return(NULL);
3930
3931
2.47k
    payload = xmlHashLookup2(ctxt->funcHash, name, ns_uri);
3932
2.47k
    memcpy(&ret, &payload, sizeof(payload));
3933
3934
2.47k
    return(ret);
3935
2.47k
}
3936
3937
/**
3938
 * xmlXPathRegisteredFuncsCleanup:
3939
 * @ctxt:  the XPath context
3940
 *
3941
 * Cleanup the XPath context data associated to registered functions
3942
 */
3943
void
3944
941
xmlXPathRegisteredFuncsCleanup(xmlXPathContextPtr ctxt) {
3945
941
    if (ctxt == NULL)
3946
0
  return;
3947
3948
941
    xmlHashFree(ctxt->funcHash, NULL);
3949
941
    ctxt->funcHash = NULL;
3950
941
}
3951
3952
/************************************************************************
3953
 *                  *
3954
 *      Routines to handle Variables      *
3955
 *                  *
3956
 ************************************************************************/
3957
3958
/**
3959
 * xmlXPathRegisterVariable:
3960
 * @ctxt:  the XPath context
3961
 * @name:  the variable name
3962
 * @value:  the variable value or NULL
3963
 *
3964
 * Register a new variable value. If @value is NULL it unregisters
3965
 * the variable
3966
 *
3967
 * Returns 0 in case of success, -1 in case of error
3968
 */
3969
int
3970
xmlXPathRegisterVariable(xmlXPathContextPtr ctxt, const xmlChar *name,
3971
3.16k
       xmlXPathObjectPtr value) {
3972
3.16k
    return(xmlXPathRegisterVariableNS(ctxt, name, NULL, value));
3973
3.16k
}
3974
3975
/**
3976
 * xmlXPathRegisterVariableNS:
3977
 * @ctxt:  the XPath context
3978
 * @name:  the variable name
3979
 * @ns_uri:  the variable namespace URI
3980
 * @value:  the variable value or NULL
3981
 *
3982
 * Register a new variable value. If @value is NULL it unregisters
3983
 * the variable
3984
 *
3985
 * Returns 0 in case of success, -1 in case of error
3986
 */
3987
int
3988
xmlXPathRegisterVariableNS(xmlXPathContextPtr ctxt, const xmlChar *name,
3989
         const xmlChar *ns_uri,
3990
3.16k
         xmlXPathObjectPtr value) {
3991
3.16k
    if (ctxt == NULL)
3992
0
  return(-1);
3993
3.16k
    if (name == NULL)
3994
0
  return(-1);
3995
3996
3.16k
    if (ctxt->varHash == NULL)
3997
792
  ctxt->varHash = xmlHashCreate(0);
3998
3.16k
    if (ctxt->varHash == NULL)
3999
0
  return(-1);
4000
3.16k
    if (value == NULL)
4001
7
        return(xmlHashRemoveEntry2(ctxt->varHash, name, ns_uri,
4002
7
                             xmlXPathFreeObjectEntry));
4003
3.16k
    return(xmlHashUpdateEntry2(ctxt->varHash, name, ns_uri,
4004
3.16k
             (void *) value, xmlXPathFreeObjectEntry));
4005
3.16k
}
4006
4007
/**
4008
 * xmlXPathRegisterVariableLookup:
4009
 * @ctxt:  the XPath context
4010
 * @f:  the lookup function
4011
 * @data:  the lookup data
4012
 *
4013
 * register an external mechanism to do variable lookup
4014
 */
4015
void
4016
xmlXPathRegisterVariableLookup(xmlXPathContextPtr ctxt,
4017
792
   xmlXPathVariableLookupFunc f, void *data) {
4018
792
    if (ctxt == NULL)
4019
0
  return;
4020
792
    ctxt->varLookupFunc = f;
4021
792
    ctxt->varLookupData = data;
4022
792
}
4023
4024
/**
4025
 * xmlXPathVariableLookup:
4026
 * @ctxt:  the XPath context
4027
 * @name:  the variable name
4028
 *
4029
 * Search in the Variable array of the context for the given
4030
 * variable value.
4031
 *
4032
 * Returns a copy of the value or NULL if not found
4033
 */
4034
xmlXPathObjectPtr
4035
0
xmlXPathVariableLookup(xmlXPathContextPtr ctxt, const xmlChar *name) {
4036
0
    if (ctxt == NULL)
4037
0
  return(NULL);
4038
4039
0
    if (ctxt->varLookupFunc != NULL) {
4040
0
  xmlXPathObjectPtr ret;
4041
4042
0
  ret = ((xmlXPathVariableLookupFunc)ctxt->varLookupFunc)
4043
0
          (ctxt->varLookupData, name, NULL);
4044
0
  return(ret);
4045
0
    }
4046
0
    return(xmlXPathVariableLookupNS(ctxt, name, NULL));
4047
0
}
4048
4049
/**
4050
 * xmlXPathVariableLookupNS:
4051
 * @ctxt:  the XPath context
4052
 * @name:  the variable name
4053
 * @ns_uri:  the variable namespace URI
4054
 *
4055
 * Search in the Variable array of the context for the given
4056
 * variable value.
4057
 *
4058
 * Returns the a copy of the value or NULL if not found
4059
 */
4060
xmlXPathObjectPtr
4061
xmlXPathVariableLookupNS(xmlXPathContextPtr ctxt, const xmlChar *name,
4062
0
       const xmlChar *ns_uri) {
4063
0
    if (ctxt == NULL)
4064
0
  return(NULL);
4065
4066
0
    if (ctxt->varLookupFunc != NULL) {
4067
0
  xmlXPathObjectPtr ret;
4068
4069
0
  ret = ((xmlXPathVariableLookupFunc)ctxt->varLookupFunc)
4070
0
          (ctxt->varLookupData, name, ns_uri);
4071
0
  if (ret != NULL) return(ret);
4072
0
    }
4073
4074
0
    if (ctxt->varHash == NULL)
4075
0
  return(NULL);
4076
0
    if (name == NULL)
4077
0
  return(NULL);
4078
4079
0
    return(xmlXPathObjectCopy(xmlHashLookup2(ctxt->varHash, name, ns_uri)));
4080
0
}
4081
4082
/**
4083
 * xmlXPathRegisteredVariablesCleanup:
4084
 * @ctxt:  the XPath context
4085
 *
4086
 * Cleanup the XPath context data associated to registered variables
4087
 */
4088
void
4089
941
xmlXPathRegisteredVariablesCleanup(xmlXPathContextPtr ctxt) {
4090
941
    if (ctxt == NULL)
4091
0
  return;
4092
4093
941
    xmlHashFree(ctxt->varHash, xmlXPathFreeObjectEntry);
4094
941
    ctxt->varHash = NULL;
4095
941
}
4096
4097
/**
4098
 * xmlXPathRegisterNs:
4099
 * @ctxt:  the XPath context
4100
 * @prefix:  the namespace prefix cannot be NULL or empty string
4101
 * @ns_uri:  the namespace name
4102
 *
4103
 * Register a new namespace. If @ns_uri is NULL it unregisters
4104
 * the namespace
4105
 *
4106
 * Returns 0 in case of success, -1 in case of error
4107
 */
4108
int
4109
xmlXPathRegisterNs(xmlXPathContextPtr ctxt, const xmlChar *prefix,
4110
8.71k
         const xmlChar *ns_uri) {
4111
8.71k
    xmlChar *copy;
4112
4113
8.71k
    if (ctxt == NULL)
4114
0
  return(-1);
4115
8.71k
    if (prefix == NULL)
4116
0
  return(-1);
4117
8.71k
    if (prefix[0] == 0)
4118
0
  return(-1);
4119
4120
8.71k
    if (ctxt->nsHash == NULL)
4121
792
  ctxt->nsHash = xmlHashCreate(10);
4122
8.71k
    if (ctxt->nsHash == NULL) {
4123
0
        xmlXPathErrMemory(ctxt);
4124
0
  return(-1);
4125
0
    }
4126
8.71k
    if (ns_uri == NULL)
4127
0
        return(xmlHashRemoveEntry(ctxt->nsHash, prefix,
4128
0
                            xmlHashDefaultDeallocator));
4129
4130
8.71k
    copy = xmlStrdup(ns_uri);
4131
8.71k
    if (copy == NULL) {
4132
0
        xmlXPathErrMemory(ctxt);
4133
0
        return(-1);
4134
0
    }
4135
8.71k
    if (xmlHashUpdateEntry(ctxt->nsHash, prefix, copy,
4136
8.71k
                           xmlHashDefaultDeallocator) < 0) {
4137
0
        xmlXPathErrMemory(ctxt);
4138
0
        xmlFree(copy);
4139
0
        return(-1);
4140
0
    }
4141
4142
8.71k
    return(0);
4143
8.71k
}
4144
4145
/**
4146
 * xmlXPathNsLookup:
4147
 * @ctxt:  the XPath context
4148
 * @prefix:  the namespace prefix value
4149
 *
4150
 * Search in the namespace declaration array of the context for the given
4151
 * namespace name associated to the given prefix
4152
 *
4153
 * Returns the value or NULL if not found
4154
 */
4155
const xmlChar *
4156
558
xmlXPathNsLookup(xmlXPathContextPtr ctxt, const xmlChar *prefix) {
4157
558
    if (ctxt == NULL)
4158
0
  return(NULL);
4159
558
    if (prefix == NULL)
4160
0
  return(NULL);
4161
4162
558
    if (xmlStrEqual(prefix, (const xmlChar *) "xml"))
4163
0
  return(XML_XML_NAMESPACE);
4164
4165
558
    if (ctxt->namespaces != NULL) {
4166
0
  int i;
4167
4168
0
  for (i = 0;i < ctxt->nsNr;i++) {
4169
0
      if ((ctxt->namespaces[i] != NULL) &&
4170
0
    (xmlStrEqual(ctxt->namespaces[i]->prefix, prefix)))
4171
0
    return(ctxt->namespaces[i]->href);
4172
0
  }
4173
0
    }
4174
4175
558
    return((const xmlChar *) xmlHashLookup(ctxt->nsHash, prefix));
4176
558
}
4177
4178
/**
4179
 * xmlXPathRegisteredNsCleanup:
4180
 * @ctxt:  the XPath context
4181
 *
4182
 * Cleanup the XPath context data associated to registered variables
4183
 */
4184
void
4185
1.73k
xmlXPathRegisteredNsCleanup(xmlXPathContextPtr ctxt) {
4186
1.73k
    if (ctxt == NULL)
4187
3
  return;
4188
4189
1.73k
    xmlHashFree(ctxt->nsHash, xmlHashDefaultDeallocator);
4190
1.73k
    ctxt->nsHash = NULL;
4191
1.73k
}
4192
4193
/************************************************************************
4194
 *                  *
4195
 *      Routines to handle Values     *
4196
 *                  *
4197
 ************************************************************************/
4198
4199
/* Allocations are terrible, one needs to optimize all this !!! */
4200
4201
/**
4202
 * xmlXPathNewFloat:
4203
 * @val:  the double value
4204
 *
4205
 * Create a new xmlXPathObjectPtr of type double and of value @val
4206
 *
4207
 * Returns the newly created object.
4208
 */
4209
xmlXPathObjectPtr
4210
152k
xmlXPathNewFloat(double val) {
4211
152k
    xmlXPathObjectPtr ret;
4212
4213
152k
    ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
4214
152k
    if (ret == NULL)
4215
1
  return(NULL);
4216
152k
    memset(ret, 0 , sizeof(xmlXPathObject));
4217
152k
    ret->type = XPATH_NUMBER;
4218
152k
    ret->floatval = val;
4219
152k
    return(ret);
4220
152k
}
4221
4222
/**
4223
 * xmlXPathNewBoolean:
4224
 * @val:  the boolean value
4225
 *
4226
 * Create a new xmlXPathObjectPtr of type boolean and of value @val
4227
 *
4228
 * Returns the newly created object.
4229
 */
4230
xmlXPathObjectPtr
4231
1.96k
xmlXPathNewBoolean(int val) {
4232
1.96k
    xmlXPathObjectPtr ret;
4233
4234
1.96k
    ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
4235
1.96k
    if (ret == NULL)
4236
0
  return(NULL);
4237
1.96k
    memset(ret, 0 , sizeof(xmlXPathObject));
4238
1.96k
    ret->type = XPATH_BOOLEAN;
4239
1.96k
    ret->boolval = (val != 0);
4240
1.96k
    return(ret);
4241
1.96k
}
4242
4243
/**
4244
 * xmlXPathNewString:
4245
 * @val:  the xmlChar * value
4246
 *
4247
 * Create a new xmlXPathObjectPtr of type string and of value @val
4248
 *
4249
 * Returns the newly created object.
4250
 */
4251
xmlXPathObjectPtr
4252
58.7k
xmlXPathNewString(const xmlChar *val) {
4253
58.7k
    xmlXPathObjectPtr ret;
4254
4255
58.7k
    ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
4256
58.7k
    if (ret == NULL)
4257
4
  return(NULL);
4258
58.7k
    memset(ret, 0 , sizeof(xmlXPathObject));
4259
58.7k
    ret->type = XPATH_STRING;
4260
58.7k
    if (val == NULL)
4261
0
        val = BAD_CAST "";
4262
58.7k
    ret->stringval = xmlStrdup(val);
4263
58.7k
    if (ret->stringval == NULL) {
4264
0
        xmlFree(ret);
4265
0
        return(NULL);
4266
0
    }
4267
58.7k
    return(ret);
4268
58.7k
}
4269
4270
/**
4271
 * xmlXPathWrapString:
4272
 * @val:  the xmlChar * value
4273
 *
4274
 * Wraps the @val string into an XPath object.
4275
 *
4276
 * Returns the newly created object.
4277
 *
4278
 * Frees @val in case of error.
4279
 */
4280
xmlXPathObjectPtr
4281
121k
xmlXPathWrapString (xmlChar *val) {
4282
121k
    xmlXPathObjectPtr ret;
4283
4284
121k
    ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
4285
121k
    if (ret == NULL) {
4286
5
        xmlFree(val);
4287
5
  return(NULL);
4288
5
    }
4289
121k
    memset(ret, 0 , sizeof(xmlXPathObject));
4290
121k
    ret->type = XPATH_STRING;
4291
121k
    ret->stringval = val;
4292
121k
    return(ret);
4293
121k
}
4294
4295
/**
4296
 * xmlXPathNewCString:
4297
 * @val:  the char * value
4298
 *
4299
 * Create a new xmlXPathObjectPtr of type string and of value @val
4300
 *
4301
 * Returns the newly created object.
4302
 */
4303
xmlXPathObjectPtr
4304
55.1k
xmlXPathNewCString(const char *val) {
4305
55.1k
    return(xmlXPathNewString(BAD_CAST val));
4306
55.1k
}
4307
4308
/**
4309
 * xmlXPathWrapCString:
4310
 * @val:  the char * value
4311
 *
4312
 * Wraps a string into an XPath object.
4313
 *
4314
 * Returns the newly created object.
4315
 */
4316
xmlXPathObjectPtr
4317
0
xmlXPathWrapCString (char * val) {
4318
0
    return(xmlXPathWrapString((xmlChar *)(val)));
4319
0
}
4320
4321
/**
4322
 * xmlXPathWrapExternal:
4323
 * @val:  the user data
4324
 *
4325
 * Wraps the @val data into an XPath object.
4326
 *
4327
 * Returns the newly created object.
4328
 */
4329
xmlXPathObjectPtr
4330
0
xmlXPathWrapExternal (void *val) {
4331
0
    xmlXPathObjectPtr ret;
4332
4333
0
    ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
4334
0
    if (ret == NULL)
4335
0
  return(NULL);
4336
0
    memset(ret, 0 , sizeof(xmlXPathObject));
4337
0
    ret->type = XPATH_USERS;
4338
0
    ret->user = val;
4339
0
    return(ret);
4340
0
}
4341
4342
/**
4343
 * xmlXPathObjectCopy:
4344
 * @val:  the original object
4345
 *
4346
 * allocate a new copy of a given object
4347
 *
4348
 * Returns the newly created object.
4349
 */
4350
xmlXPathObjectPtr
4351
280
xmlXPathObjectCopy(xmlXPathObjectPtr val) {
4352
280
    xmlXPathObjectPtr ret;
4353
4354
280
    if (val == NULL)
4355
0
  return(NULL);
4356
4357
280
    ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
4358
280
    if (ret == NULL)
4359
0
  return(NULL);
4360
280
    memcpy(ret, val , sizeof(xmlXPathObject));
4361
280
    switch (val->type) {
4362
0
  case XPATH_BOOLEAN:
4363
0
  case XPATH_NUMBER:
4364
0
      break;
4365
280
  case XPATH_STRING:
4366
280
      ret->stringval = xmlStrdup(val->stringval);
4367
280
            if (ret->stringval == NULL) {
4368
0
                xmlFree(ret);
4369
0
                return(NULL);
4370
0
            }
4371
280
      break;
4372
280
  case XPATH_XSLT_TREE:
4373
0
  case XPATH_NODESET:
4374
0
      ret->nodesetval = xmlXPathNodeSetMerge(NULL, val->nodesetval);
4375
0
            if (ret->nodesetval == NULL) {
4376
0
                xmlFree(ret);
4377
0
                return(NULL);
4378
0
            }
4379
      /* Do not deallocate the copied tree value */
4380
0
      ret->boolval = 0;
4381
0
      break;
4382
0
        case XPATH_USERS:
4383
0
      ret->user = val->user;
4384
0
      break;
4385
0
        default:
4386
0
            xmlFree(ret);
4387
0
            ret = NULL;
4388
0
      break;
4389
280
    }
4390
280
    return(ret);
4391
280
}
4392
4393
/**
4394
 * xmlXPathFreeObject:
4395
 * @obj:  the object to free
4396
 *
4397
 * Free up an xmlXPathObjectPtr object.
4398
 */
4399
void
4400
675k
xmlXPathFreeObject(xmlXPathObjectPtr obj) {
4401
675k
    if (obj == NULL) return;
4402
485k
    if ((obj->type == XPATH_NODESET) || (obj->type == XPATH_XSLT_TREE)) {
4403
401k
        if (obj->nodesetval != NULL)
4404
401k
            xmlXPathFreeNodeSet(obj->nodesetval);
4405
401k
    } else if (obj->type == XPATH_STRING) {
4406
79.4k
  if (obj->stringval != NULL)
4407
79.4k
      xmlFree(obj->stringval);
4408
79.4k
    }
4409
485k
    xmlFree(obj);
4410
485k
}
4411
4412
static void
4413
3.16k
xmlXPathFreeObjectEntry(void *obj, const xmlChar *name ATTRIBUTE_UNUSED) {
4414
3.16k
    xmlXPathFreeObject((xmlXPathObjectPtr) obj);
4415
3.16k
}
4416
4417
/**
4418
 * xmlXPathReleaseObject:
4419
 * @obj:  the xmlXPathObjectPtr to free or to cache
4420
 *
4421
 * Depending on the state of the cache this frees the given
4422
 * XPath object or stores it in the cache.
4423
 */
4424
static void
4425
xmlXPathReleaseObject(xmlXPathContextPtr ctxt, xmlXPathObjectPtr obj)
4426
1.12M
{
4427
1.12M
    if (obj == NULL)
4428
0
  return;
4429
1.12M
    if ((ctxt == NULL) || (ctxt->cache == NULL)) {
4430
57
   xmlXPathFreeObject(obj);
4431
1.12M
    } else {
4432
1.12M
  xmlXPathContextCachePtr cache =
4433
1.12M
      (xmlXPathContextCachePtr) ctxt->cache;
4434
4435
1.12M
  switch (obj->type) {
4436
593k
      case XPATH_NODESET:
4437
593k
      case XPATH_XSLT_TREE:
4438
593k
    if (obj->nodesetval != NULL) {
4439
575k
        if ((obj->nodesetval->nodeMax <= 40) &&
4440
575k
      (cache->numNodeset < cache->maxNodeset)) {
4441
403k
                        obj->stringval = (void *) cache->nodesetObjs;
4442
403k
                        cache->nodesetObjs = obj;
4443
403k
                        cache->numNodeset += 1;
4444
403k
      goto obj_cached;
4445
403k
        } else {
4446
172k
      xmlXPathFreeNodeSet(obj->nodesetval);
4447
172k
      obj->nodesetval = NULL;
4448
172k
        }
4449
575k
    }
4450
190k
    break;
4451
190k
      case XPATH_STRING:
4452
184k
    if (obj->stringval != NULL)
4453
184k
        xmlFree(obj->stringval);
4454
184k
                obj->stringval = NULL;
4455
184k
    break;
4456
11.6k
      case XPATH_BOOLEAN:
4457
341k
      case XPATH_NUMBER:
4458
341k
    break;
4459
0
      default:
4460
0
    goto free_obj;
4461
1.12M
  }
4462
4463
  /*
4464
  * Fallback to adding to the misc-objects slot.
4465
  */
4466
716k
        if (cache->numMisc >= cache->maxMisc)
4467
194k
      goto free_obj;
4468
522k
        obj->stringval = (void *) cache->miscObjs;
4469
522k
        cache->miscObjs = obj;
4470
522k
        cache->numMisc += 1;
4471
4472
925k
obj_cached:
4473
925k
        obj->boolval = 0;
4474
925k
  if (obj->nodesetval != NULL) {
4475
403k
      xmlNodeSetPtr tmpset = obj->nodesetval;
4476
4477
      /*
4478
      * Due to those nasty ns-nodes, we need to traverse
4479
      * the list and free the ns-nodes.
4480
      */
4481
403k
      if (tmpset->nodeNr > 0) {
4482
388k
    int i;
4483
388k
    xmlNodePtr node;
4484
4485
784k
    for (i = 0; i < tmpset->nodeNr; i++) {
4486
395k
        node = tmpset->nodeTab[i];
4487
395k
        if ((node != NULL) &&
4488
395k
      (node->type == XML_NAMESPACE_DECL))
4489
3.01k
        {
4490
3.01k
      xmlXPathNodeSetFreeNs((xmlNsPtr) node);
4491
3.01k
        }
4492
395k
    }
4493
388k
      }
4494
403k
      tmpset->nodeNr = 0;
4495
403k
        }
4496
4497
925k
  return;
4498
4499
194k
free_obj:
4500
  /*
4501
  * Cache is full; free the object.
4502
  */
4503
194k
  if (obj->nodesetval != NULL)
4504
0
      xmlXPathFreeNodeSet(obj->nodesetval);
4505
194k
  xmlFree(obj);
4506
194k
    }
4507
1.12M
}
4508
4509
4510
/************************************************************************
4511
 *                  *
4512
 *      Type Casting Routines       *
4513
 *                  *
4514
 ************************************************************************/
4515
4516
/**
4517
 * xmlXPathCastBooleanToString:
4518
 * @val:  a boolean
4519
 *
4520
 * Converts a boolean to its string value.
4521
 *
4522
 * Returns a newly allocated string.
4523
 */
4524
xmlChar *
4525
455
xmlXPathCastBooleanToString (int val) {
4526
455
    xmlChar *ret;
4527
455
    if (val)
4528
0
  ret = xmlStrdup((const xmlChar *) "true");
4529
455
    else
4530
455
  ret = xmlStrdup((const xmlChar *) "false");
4531
455
    return(ret);
4532
455
}
4533
4534
/**
4535
 * xmlXPathCastNumberToString:
4536
 * @val:  a number
4537
 *
4538
 * Converts a number to its string value.
4539
 *
4540
 * Returns a newly allocated string.
4541
 */
4542
xmlChar *
4543
1.04k
xmlXPathCastNumberToString (double val) {
4544
1.04k
    xmlChar *ret;
4545
1.04k
    switch (xmlXPathIsInf(val)) {
4546
0
    case 1:
4547
0
  ret = xmlStrdup((const xmlChar *) "Infinity");
4548
0
  break;
4549
0
    case -1:
4550
0
  ret = xmlStrdup((const xmlChar *) "-Infinity");
4551
0
  break;
4552
1.04k
    default:
4553
1.04k
  if (xmlXPathIsNaN(val)) {
4554
210
      ret = xmlStrdup((const xmlChar *) "NaN");
4555
835
  } else if (val == 0) {
4556
            /* Omit sign for negative zero. */
4557
0
      ret = xmlStrdup((const xmlChar *) "0");
4558
835
  } else {
4559
      /* could be improved */
4560
835
      char buf[100];
4561
835
      xmlXPathFormatNumber(val, buf, 99);
4562
835
      buf[99] = 0;
4563
835
      ret = xmlStrdup((const xmlChar *) buf);
4564
835
  }
4565
1.04k
    }
4566
1.04k
    return(ret);
4567
1.04k
}
4568
4569
/**
4570
 * xmlXPathCastNodeToString:
4571
 * @node:  a node
4572
 *
4573
 * Converts a node to its string value.
4574
 *
4575
 * Returns a newly allocated string.
4576
 */
4577
xmlChar *
4578
2.41M
xmlXPathCastNodeToString (xmlNodePtr node) {
4579
2.41M
    return(xmlNodeGetContent(node));
4580
2.41M
}
4581
4582
/**
4583
 * xmlXPathCastNodeSetToString:
4584
 * @ns:  a node-set
4585
 *
4586
 * Converts a node-set to its string value.
4587
 *
4588
 * Returns a newly allocated string.
4589
 */
4590
xmlChar *
4591
106k
xmlXPathCastNodeSetToString (xmlNodeSetPtr ns) {
4592
106k
    if ((ns == NULL) || (ns->nodeNr == 0) || (ns->nodeTab == NULL))
4593
4.14k
  return(xmlStrdup((const xmlChar *) ""));
4594
4595
102k
    if (ns->nodeNr > 1)
4596
1.04k
  xmlXPathNodeSetSort(ns);
4597
102k
    return(xmlXPathCastNodeToString(ns->nodeTab[0]));
4598
106k
}
4599
4600
/**
4601
 * xmlXPathCastToString:
4602
 * @val:  an XPath object
4603
 *
4604
 * Converts an existing object to its string() equivalent
4605
 *
4606
 * Returns the allocated string value of the object, NULL in case of error.
4607
 *         It's up to the caller to free the string memory with xmlFree().
4608
 */
4609
xmlChar *
4610
112k
xmlXPathCastToString(xmlXPathObjectPtr val) {
4611
112k
    xmlChar *ret = NULL;
4612
4613
112k
    if (val == NULL)
4614
0
  return(xmlStrdup((const xmlChar *) ""));
4615
112k
    switch (val->type) {
4616
0
  case XPATH_UNDEFINED:
4617
0
      ret = xmlStrdup((const xmlChar *) "");
4618
0
      break;
4619
105k
        case XPATH_NODESET:
4620
105k
        case XPATH_XSLT_TREE:
4621
105k
      ret = xmlXPathCastNodeSetToString(val->nodesetval);
4622
105k
      break;
4623
5.97k
  case XPATH_STRING:
4624
5.97k
      return(xmlStrdup(val->stringval));
4625
455
        case XPATH_BOOLEAN:
4626
455
      ret = xmlXPathCastBooleanToString(val->boolval);
4627
455
      break;
4628
811
  case XPATH_NUMBER: {
4629
811
      ret = xmlXPathCastNumberToString(val->floatval);
4630
811
      break;
4631
105k
  }
4632
0
  case XPATH_USERS:
4633
      /* TODO */
4634
0
      ret = xmlStrdup((const xmlChar *) "");
4635
0
      break;
4636
112k
    }
4637
107k
    return(ret);
4638
112k
}
4639
4640
/**
4641
 * xmlXPathConvertString:
4642
 * @val:  an XPath object
4643
 *
4644
 * Converts an existing object to its string() equivalent
4645
 *
4646
 * Returns the new object, the old one is freed (or the operation
4647
 *         is done directly on @val)
4648
 */
4649
xmlXPathObjectPtr
4650
0
xmlXPathConvertString(xmlXPathObjectPtr val) {
4651
0
    xmlChar *res = NULL;
4652
4653
0
    if (val == NULL)
4654
0
  return(xmlXPathNewCString(""));
4655
4656
0
    switch (val->type) {
4657
0
    case XPATH_UNDEFINED:
4658
0
  break;
4659
0
    case XPATH_NODESET:
4660
0
    case XPATH_XSLT_TREE:
4661
0
  res = xmlXPathCastNodeSetToString(val->nodesetval);
4662
0
  break;
4663
0
    case XPATH_STRING:
4664
0
  return(val);
4665
0
    case XPATH_BOOLEAN:
4666
0
  res = xmlXPathCastBooleanToString(val->boolval);
4667
0
  break;
4668
0
    case XPATH_NUMBER:
4669
0
  res = xmlXPathCastNumberToString(val->floatval);
4670
0
  break;
4671
0
    case XPATH_USERS:
4672
  /* TODO */
4673
0
  break;
4674
0
    }
4675
0
    xmlXPathFreeObject(val);
4676
0
    if (res == NULL)
4677
0
  return(xmlXPathNewCString(""));
4678
0
    return(xmlXPathWrapString(res));
4679
0
}
4680
4681
/**
4682
 * xmlXPathCastBooleanToNumber:
4683
 * @val:  a boolean
4684
 *
4685
 * Converts a boolean to its number value
4686
 *
4687
 * Returns the number value
4688
 */
4689
double
4690
2.50k
xmlXPathCastBooleanToNumber(int val) {
4691
2.50k
    if (val)
4692
2.50k
  return(1.0);
4693
0
    return(0.0);
4694
2.50k
}
4695
4696
/**
4697
 * xmlXPathCastStringToNumber:
4698
 * @val:  a string
4699
 *
4700
 * Converts a string to its number value
4701
 *
4702
 * Returns the number value
4703
 */
4704
double
4705
166k
xmlXPathCastStringToNumber(const xmlChar * val) {
4706
166k
    return(xmlXPathStringEvalNumber(val));
4707
166k
}
4708
4709
/**
4710
 * xmlXPathNodeToNumberInternal:
4711
 * @node:  a node
4712
 *
4713
 * Converts a node to its number value
4714
 *
4715
 * Returns the number value
4716
 */
4717
static double
4718
455
xmlXPathNodeToNumberInternal(xmlXPathParserContextPtr ctxt, xmlNodePtr node) {
4719
455
    xmlChar *strval;
4720
455
    double ret;
4721
4722
455
    if (node == NULL)
4723
0
  return(xmlXPathNAN);
4724
455
    strval = xmlXPathCastNodeToString(node);
4725
455
    if (strval == NULL) {
4726
0
        xmlXPathPErrMemory(ctxt);
4727
0
  return(xmlXPathNAN);
4728
0
    }
4729
455
    ret = xmlXPathCastStringToNumber(strval);
4730
455
    xmlFree(strval);
4731
4732
455
    return(ret);
4733
455
}
4734
4735
/**
4736
 * xmlXPathCastNodeToNumber:
4737
 * @node:  a node
4738
 *
4739
 * Converts a node to its number value
4740
 *
4741
 * Returns the number value
4742
 */
4743
double
4744
0
xmlXPathCastNodeToNumber (xmlNodePtr node) {
4745
0
    return(xmlXPathNodeToNumberInternal(NULL, node));
4746
0
}
4747
4748
/**
4749
 * xmlXPathCastNodeSetToNumber:
4750
 * @ns:  a node-set
4751
 *
4752
 * Converts a node-set to its number value
4753
 *
4754
 * Returns the number value
4755
 */
4756
double
4757
0
xmlXPathCastNodeSetToNumber (xmlNodeSetPtr ns) {
4758
0
    xmlChar *str;
4759
0
    double ret;
4760
4761
0
    if (ns == NULL)
4762
0
  return(xmlXPathNAN);
4763
0
    str = xmlXPathCastNodeSetToString(ns);
4764
0
    ret = xmlXPathCastStringToNumber(str);
4765
0
    xmlFree(str);
4766
0
    return(ret);
4767
0
}
4768
4769
/**
4770
 * xmlXPathCastToNumber:
4771
 * @val:  an XPath object
4772
 *
4773
 * Converts an XPath object to its number value
4774
 *
4775
 * Returns the number value
4776
 */
4777
double
4778
0
xmlXPathCastToNumber(xmlXPathObjectPtr val) {
4779
0
    return(xmlXPathCastToNumberInternal(NULL, val));
4780
0
}
4781
4782
/**
4783
 * xmlXPathConvertNumber:
4784
 * @val:  an XPath object
4785
 *
4786
 * Converts an existing object to its number() equivalent
4787
 *
4788
 * Returns the new object, the old one is freed (or the operation
4789
 *         is done directly on @val)
4790
 */
4791
xmlXPathObjectPtr
4792
0
xmlXPathConvertNumber(xmlXPathObjectPtr val) {
4793
0
    xmlXPathObjectPtr ret;
4794
4795
0
    if (val == NULL)
4796
0
  return(xmlXPathNewFloat(0.0));
4797
0
    if (val->type == XPATH_NUMBER)
4798
0
  return(val);
4799
0
    ret = xmlXPathNewFloat(xmlXPathCastToNumber(val));
4800
0
    xmlXPathFreeObject(val);
4801
0
    return(ret);
4802
0
}
4803
4804
/**
4805
 * xmlXPathCastNumberToBoolean:
4806
 * @val:  a number
4807
 *
4808
 * Converts a number to its boolean value
4809
 *
4810
 * Returns the boolean value
4811
 */
4812
int
4813
2.61k
xmlXPathCastNumberToBoolean (double val) {
4814
2.61k
     if (xmlXPathIsNaN(val) || (val == 0.0))
4815
0
   return(0);
4816
2.61k
     return(1);
4817
2.61k
}
4818
4819
/**
4820
 * xmlXPathCastStringToBoolean:
4821
 * @val:  a string
4822
 *
4823
 * Converts a string to its boolean value
4824
 *
4825
 * Returns the boolean value
4826
 */
4827
int
4828
915
xmlXPathCastStringToBoolean (const xmlChar *val) {
4829
915
    if ((val == NULL) || (xmlStrlen(val) == 0))
4830
915
  return(0);
4831
0
    return(1);
4832
915
}
4833
4834
/**
4835
 * xmlXPathCastNodeSetToBoolean:
4836
 * @ns:  a node-set
4837
 *
4838
 * Converts a node-set to its boolean value
4839
 *
4840
 * Returns the boolean value
4841
 */
4842
int
4843
0
xmlXPathCastNodeSetToBoolean (xmlNodeSetPtr ns) {
4844
0
    if ((ns == NULL) || (ns->nodeNr == 0))
4845
0
  return(0);
4846
0
    return(1);
4847
0
}
4848
4849
/**
4850
 * xmlXPathCastToBoolean:
4851
 * @val:  an XPath object
4852
 *
4853
 * Converts an XPath object to its boolean value
4854
 *
4855
 * Returns the boolean value
4856
 */
4857
int
4858
1.03k
xmlXPathCastToBoolean (xmlXPathObjectPtr val) {
4859
1.03k
    int ret = 0;
4860
4861
1.03k
    if (val == NULL)
4862
0
  return(0);
4863
1.03k
    switch (val->type) {
4864
0
    case XPATH_UNDEFINED:
4865
0
  ret = 0;
4866
0
  break;
4867
0
    case XPATH_NODESET:
4868
0
    case XPATH_XSLT_TREE:
4869
0
  ret = xmlXPathCastNodeSetToBoolean(val->nodesetval);
4870
0
  break;
4871
915
    case XPATH_STRING:
4872
915
  ret = xmlXPathCastStringToBoolean(val->stringval);
4873
915
  break;
4874
117
    case XPATH_NUMBER:
4875
117
  ret = xmlXPathCastNumberToBoolean(val->floatval);
4876
117
  break;
4877
0
    case XPATH_BOOLEAN:
4878
0
  ret = val->boolval;
4879
0
  break;
4880
0
    case XPATH_USERS:
4881
  /* TODO */
4882
0
  ret = 0;
4883
0
  break;
4884
1.03k
    }
4885
1.03k
    return(ret);
4886
1.03k
}
4887
4888
4889
/**
4890
 * xmlXPathConvertBoolean:
4891
 * @val:  an XPath object
4892
 *
4893
 * Converts an existing object to its boolean() equivalent
4894
 *
4895
 * Returns the new object, the old one is freed (or the operation
4896
 *         is done directly on @val)
4897
 */
4898
xmlXPathObjectPtr
4899
0
xmlXPathConvertBoolean(xmlXPathObjectPtr val) {
4900
0
    xmlXPathObjectPtr ret;
4901
4902
0
    if (val == NULL)
4903
0
  return(xmlXPathNewBoolean(0));
4904
0
    if (val->type == XPATH_BOOLEAN)
4905
0
  return(val);
4906
0
    ret = xmlXPathNewBoolean(xmlXPathCastToBoolean(val));
4907
0
    xmlXPathFreeObject(val);
4908
0
    return(ret);
4909
0
}
4910
4911
/************************************************************************
4912
 *                  *
4913
 *    Routines to handle XPath contexts     *
4914
 *                  *
4915
 ************************************************************************/
4916
4917
/**
4918
 * xmlXPathNewContext:
4919
 * @doc:  the XML document
4920
 *
4921
 * Create a new xmlXPathContext
4922
 *
4923
 * Returns the xmlXPathContext just allocated. The caller will need to free it.
4924
 */
4925
xmlXPathContextPtr
4926
944
xmlXPathNewContext(xmlDocPtr doc) {
4927
944
    xmlXPathContextPtr ret;
4928
4929
944
    ret = (xmlXPathContextPtr) xmlMalloc(sizeof(xmlXPathContext));
4930
944
    if (ret == NULL)
4931
1
  return(NULL);
4932
943
    memset(ret, 0 , sizeof(xmlXPathContext));
4933
943
    ret->doc = doc;
4934
943
    ret->node = NULL;
4935
4936
943
    ret->varHash = NULL;
4937
4938
943
    ret->nb_types = 0;
4939
943
    ret->max_types = 0;
4940
943
    ret->types = NULL;
4941
4942
943
    ret->nb_axis = 0;
4943
943
    ret->max_axis = 0;
4944
943
    ret->axis = NULL;
4945
4946
943
    ret->nsHash = NULL;
4947
943
    ret->user = NULL;
4948
4949
943
    ret->contextSize = -1;
4950
943
    ret->proximityPosition = -1;
4951
4952
#ifdef XP_DEFAULT_CACHE_ON
4953
    if (xmlXPathContextSetCache(ret, 1, -1, 0) == -1) {
4954
  xmlXPathFreeContext(ret);
4955
  return(NULL);
4956
    }
4957
#endif
4958
4959
943
    return(ret);
4960
944
}
4961
4962
/**
4963
 * xmlXPathFreeContext:
4964
 * @ctxt:  the context to free
4965
 *
4966
 * Free up an xmlXPathContext
4967
 */
4968
void
4969
941
xmlXPathFreeContext(xmlXPathContextPtr ctxt) {
4970
941
    if (ctxt == NULL) return;
4971
4972
941
    if (ctxt->cache != NULL)
4973
792
  xmlXPathFreeCache((xmlXPathContextCachePtr) ctxt->cache);
4974
941
    xmlXPathRegisteredNsCleanup(ctxt);
4975
941
    xmlXPathRegisteredFuncsCleanup(ctxt);
4976
941
    xmlXPathRegisteredVariablesCleanup(ctxt);
4977
941
    xmlResetError(&ctxt->lastError);
4978
941
    xmlFree(ctxt);
4979
941
}
4980
4981
/**
4982
 * xmlXPathSetErrorHandler:
4983
 * @ctxt:  the XPath context
4984
 * @handler:  error handler
4985
 * @data:  user data which will be passed to the handler
4986
 *
4987
 * Register a callback function that will be called on errors and
4988
 * warnings. If handler is NULL, the error handler will be deactivated.
4989
 *
4990
 * Available since 2.13.0.
4991
 */
4992
void
4993
xmlXPathSetErrorHandler(xmlXPathContextPtr ctxt,
4994
0
                        xmlStructuredErrorFunc handler, void *data) {
4995
0
    if (ctxt == NULL)
4996
0
        return;
4997
4998
0
    ctxt->error = handler;
4999
0
    ctxt->userData = data;
5000
0
}
5001
5002
/************************************************************************
5003
 *                  *
5004
 *    Routines to handle XPath parser contexts    *
5005
 *                  *
5006
 ************************************************************************/
5007
5008
/**
5009
 * xmlXPathNewParserContext:
5010
 * @str:  the XPath expression
5011
 * @ctxt:  the XPath context
5012
 *
5013
 * Create a new xmlXPathParserContext
5014
 *
5015
 * Returns the xmlXPathParserContext just allocated.
5016
 */
5017
xmlXPathParserContextPtr
5018
15.8k
xmlXPathNewParserContext(const xmlChar *str, xmlXPathContextPtr ctxt) {
5019
15.8k
    xmlXPathParserContextPtr ret;
5020
5021
15.8k
    ret = (xmlXPathParserContextPtr) xmlMalloc(sizeof(xmlXPathParserContext));
5022
15.8k
    if (ret == NULL) {
5023
0
        xmlXPathErrMemory(ctxt);
5024
0
  return(NULL);
5025
0
    }
5026
15.8k
    memset(ret, 0 , sizeof(xmlXPathParserContext));
5027
15.8k
    ret->cur = ret->base = str;
5028
15.8k
    ret->context = ctxt;
5029
5030
15.8k
    ret->comp = xmlXPathNewCompExpr();
5031
15.8k
    if (ret->comp == NULL) {
5032
0
        xmlXPathErrMemory(ctxt);
5033
0
  xmlFree(ret->valueTab);
5034
0
  xmlFree(ret);
5035
0
  return(NULL);
5036
0
    }
5037
15.8k
    if ((ctxt != NULL) && (ctxt->dict != NULL)) {
5038
0
        ret->comp->dict = ctxt->dict;
5039
0
  xmlDictReference(ret->comp->dict);
5040
0
    }
5041
5042
15.8k
    return(ret);
5043
15.8k
}
5044
5045
/**
5046
 * xmlXPathCompParserContext:
5047
 * @comp:  the XPath compiled expression
5048
 * @ctxt:  the XPath context
5049
 *
5050
 * Create a new xmlXPathParserContext when processing a compiled expression
5051
 *
5052
 * Returns the xmlXPathParserContext just allocated.
5053
 */
5054
static xmlXPathParserContextPtr
5055
134k
xmlXPathCompParserContext(xmlXPathCompExprPtr comp, xmlXPathContextPtr ctxt) {
5056
134k
    xmlXPathParserContextPtr ret;
5057
5058
134k
    ret = (xmlXPathParserContextPtr) xmlMalloc(sizeof(xmlXPathParserContext));
5059
134k
    if (ret == NULL) {
5060
2.38k
        xmlXPathErrMemory(ctxt);
5061
2.38k
  return(NULL);
5062
2.38k
    }
5063
132k
    memset(ret, 0 , sizeof(xmlXPathParserContext));
5064
5065
    /* Allocate the value stack */
5066
132k
#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
5067
132k
    ret->valueMax = 1;
5068
#else
5069
    ret->valueMax = 10;
5070
#endif
5071
132k
    ret->valueTab = xmlMalloc(ret->valueMax * sizeof(xmlXPathObjectPtr));
5072
132k
    if (ret->valueTab == NULL) {
5073
0
  xmlFree(ret);
5074
0
  xmlXPathErrMemory(ctxt);
5075
0
  return(NULL);
5076
0
    }
5077
132k
    ret->valueNr = 0;
5078
132k
    ret->value = NULL;
5079
5080
132k
    ret->context = ctxt;
5081
132k
    ret->comp = comp;
5082
5083
132k
    return(ret);
5084
132k
}
5085
5086
/**
5087
 * xmlXPathFreeParserContext:
5088
 * @ctxt:  the context to free
5089
 *
5090
 * Free up an xmlXPathParserContext
5091
 */
5092
void
5093
148k
xmlXPathFreeParserContext(xmlXPathParserContextPtr ctxt) {
5094
148k
    int i;
5095
5096
148k
    if (ctxt->valueTab != NULL) {
5097
134k
        for (i = 0; i < ctxt->valueNr; i++) {
5098
878
            if (ctxt->context)
5099
878
                xmlXPathReleaseObject(ctxt->context, ctxt->valueTab[i]);
5100
0
            else
5101
0
                xmlXPathFreeObject(ctxt->valueTab[i]);
5102
878
        }
5103
133k
        xmlFree(ctxt->valueTab);
5104
133k
    }
5105
148k
    if (ctxt->comp != NULL) {
5106
#ifdef XPATH_STREAMING
5107
  if (ctxt->comp->stream != NULL) {
5108
      xmlFreePatternList(ctxt->comp->stream);
5109
      ctxt->comp->stream = NULL;
5110
  }
5111
#endif
5112
12.7k
  xmlXPathFreeCompExpr(ctxt->comp);
5113
12.7k
    }
5114
148k
    xmlFree(ctxt);
5115
148k
}
5116
5117
/************************************************************************
5118
 *                  *
5119
 *    The implicit core function library      *
5120
 *                  *
5121
 ************************************************************************/
5122
5123
/**
5124
 * xmlXPathNodeValHash:
5125
 * @node:  a node pointer
5126
 *
5127
 * Function computing the beginning of the string value of the node,
5128
 * used to speed up comparisons
5129
 *
5130
 * Returns an int usable as a hash
5131
 */
5132
static unsigned int
5133
354k
xmlXPathNodeValHash(xmlNodePtr node) {
5134
354k
    int len = 2;
5135
354k
    const xmlChar * string = NULL;
5136
354k
    xmlNodePtr tmp = NULL;
5137
354k
    unsigned int ret = 0;
5138
5139
354k
    if (node == NULL)
5140
0
  return(0);
5141
5142
354k
    if (node->type == XML_DOCUMENT_NODE) {
5143
7
  tmp = xmlDocGetRootElement((xmlDocPtr) node);
5144
7
  if (tmp == NULL)
5145
0
      node = node->children;
5146
7
  else
5147
7
      node = tmp;
5148
5149
7
  if (node == NULL)
5150
0
      return(0);
5151
7
    }
5152
5153
354k
    switch (node->type) {
5154
170
  case XML_COMMENT_NODE:
5155
202
  case XML_PI_NODE:
5156
239
  case XML_CDATA_SECTION_NODE:
5157
48.1k
  case XML_TEXT_NODE:
5158
48.1k
      string = node->content;
5159
48.1k
      if (string == NULL)
5160
32
    return(0);
5161
48.1k
      if (string[0] == 0)
5162
0
    return(0);
5163
48.1k
      return(string[0] + (string[1] << 8));
5164
0
  case XML_NAMESPACE_DECL:
5165
0
      string = ((xmlNsPtr)node)->href;
5166
0
      if (string == NULL)
5167
0
    return(0);
5168
0
      if (string[0] == 0)
5169
0
    return(0);
5170
0
      return(string[0] + (string[1] << 8));
5171
0
  case XML_ATTRIBUTE_NODE:
5172
0
      tmp = ((xmlAttrPtr) node)->children;
5173
0
      break;
5174
306k
  case XML_ELEMENT_NODE:
5175
306k
      tmp = node->children;
5176
306k
      break;
5177
0
  default:
5178
0
      return(0);
5179
354k
    }
5180
397k
    while (tmp != NULL) {
5181
103k
  switch (tmp->type) {
5182
11
      case XML_CDATA_SECTION_NODE:
5183
15.0k
      case XML_TEXT_NODE:
5184
15.0k
    string = tmp->content;
5185
15.0k
    break;
5186
88.4k
      default:
5187
88.4k
                string = NULL;
5188
88.4k
    break;
5189
103k
  }
5190
103k
  if ((string != NULL) && (string[0] != 0)) {
5191
15.0k
      if (len == 1) {
5192
908
    return(ret + (string[0] << 8));
5193
908
      }
5194
14.1k
      if (string[1] == 0) {
5195
3.06k
    len = 1;
5196
3.06k
    ret = string[0];
5197
11.0k
      } else {
5198
11.0k
    return(string[0] + (string[1] << 8));
5199
11.0k
      }
5200
14.1k
  }
5201
  /*
5202
   * Skip to next node
5203
   */
5204
91.5k
        if ((tmp->children != NULL) &&
5205
91.5k
            (tmp->type != XML_DTD_NODE) &&
5206
91.5k
            (tmp->type != XML_ENTITY_REF_NODE) &&
5207
91.5k
            (tmp->children->type != XML_ENTITY_DECL)) {
5208
10.3k
            tmp = tmp->children;
5209
10.3k
            continue;
5210
10.3k
  }
5211
81.1k
  if (tmp == node)
5212
0
      break;
5213
5214
81.1k
  if (tmp->next != NULL) {
5215
78.0k
      tmp = tmp->next;
5216
78.0k
      continue;
5217
78.0k
  }
5218
5219
3.18k
  do {
5220
3.18k
      tmp = tmp->parent;
5221
3.18k
      if (tmp == NULL)
5222
0
    break;
5223
3.18k
      if (tmp == node) {
5224
2.29k
    tmp = NULL;
5225
2.29k
    break;
5226
2.29k
      }
5227
888
      if (tmp->next != NULL) {
5228
837
    tmp = tmp->next;
5229
837
    break;
5230
837
      }
5231
888
  } while (tmp != NULL);
5232
3.13k
    }
5233
294k
    return(ret);
5234
306k
}
5235
5236
/**
5237
 * xmlXPathStringHash:
5238
 * @string:  a string
5239
 *
5240
 * Function computing the beginning of the string value of the node,
5241
 * used to speed up comparisons
5242
 *
5243
 * Returns an int usable as a hash
5244
 */
5245
static unsigned int
5246
0
xmlXPathStringHash(const xmlChar * string) {
5247
0
    if (string == NULL)
5248
0
  return(0);
5249
0
    if (string[0] == 0)
5250
0
  return(0);
5251
0
    return(string[0] + (string[1] << 8));
5252
0
}
5253
5254
/**
5255
 * xmlXPathCompareNodeSetFloat:
5256
 * @ctxt:  the XPath Parser context
5257
 * @inf:  less than (1) or greater than (0)
5258
 * @strict:  is the comparison strict
5259
 * @arg:  the node set
5260
 * @f:  the value
5261
 *
5262
 * Implement the compare operation between a nodeset and a number
5263
 *     @ns < @val    (1, 1, ...
5264
 *     @ns <= @val   (1, 0, ...
5265
 *     @ns > @val    (0, 1, ...
5266
 *     @ns >= @val   (0, 0, ...
5267
 *
5268
 * If one object to be compared is a node-set and the other is a number,
5269
 * then the comparison will be true if and only if there is a node in the
5270
 * node-set such that the result of performing the comparison on the number
5271
 * to be compared and on the result of converting the string-value of that
5272
 * node to a number using the number function is true.
5273
 *
5274
 * Returns 0 or 1 depending on the results of the test.
5275
 */
5276
static int
5277
xmlXPathCompareNodeSetFloat(xmlXPathParserContextPtr ctxt, int inf, int strict,
5278
0
                      xmlXPathObjectPtr arg, xmlXPathObjectPtr f) {
5279
0
    int i, ret = 0;
5280
0
    xmlNodeSetPtr ns;
5281
0
    xmlChar *str2;
5282
5283
0
    if ((f == NULL) || (arg == NULL) ||
5284
0
  ((arg->type != XPATH_NODESET) && (arg->type != XPATH_XSLT_TREE))) {
5285
0
  xmlXPathReleaseObject(ctxt->context, arg);
5286
0
  xmlXPathReleaseObject(ctxt->context, f);
5287
0
        return(0);
5288
0
    }
5289
0
    ns = arg->nodesetval;
5290
0
    if (ns != NULL) {
5291
0
  for (i = 0;i < ns->nodeNr;i++) {
5292
0
       str2 = xmlXPathCastNodeToString(ns->nodeTab[i]);
5293
0
       if (str2 != NULL) {
5294
0
     xmlXPathValuePush(ctxt, xmlXPathCacheNewString(ctxt, str2));
5295
0
     xmlFree(str2);
5296
0
     xmlXPathNumberFunction(ctxt, 1);
5297
0
     xmlXPathValuePush(ctxt, xmlXPathCacheObjectCopy(ctxt, f));
5298
0
     ret = xmlXPathCompareValues(ctxt, inf, strict);
5299
0
     if (ret)
5300
0
         break;
5301
0
       } else {
5302
0
                 xmlXPathPErrMemory(ctxt);
5303
0
             }
5304
0
  }
5305
0
    }
5306
0
    xmlXPathReleaseObject(ctxt->context, arg);
5307
0
    xmlXPathReleaseObject(ctxt->context, f);
5308
0
    return(ret);
5309
0
}
5310
5311
/**
5312
 * xmlXPathCompareNodeSetString:
5313
 * @ctxt:  the XPath Parser context
5314
 * @inf:  less than (1) or greater than (0)
5315
 * @strict:  is the comparison strict
5316
 * @arg:  the node set
5317
 * @s:  the value
5318
 *
5319
 * Implement the compare operation between a nodeset and a string
5320
 *     @ns < @val    (1, 1, ...
5321
 *     @ns <= @val   (1, 0, ...
5322
 *     @ns > @val    (0, 1, ...
5323
 *     @ns >= @val   (0, 0, ...
5324
 *
5325
 * If one object to be compared is a node-set and the other is a string,
5326
 * then the comparison will be true if and only if there is a node in
5327
 * the node-set such that the result of performing the comparison on the
5328
 * string-value of the node and the other string is true.
5329
 *
5330
 * Returns 0 or 1 depending on the results of the test.
5331
 */
5332
static int
5333
xmlXPathCompareNodeSetString(xmlXPathParserContextPtr ctxt, int inf, int strict,
5334
148
                      xmlXPathObjectPtr arg, xmlXPathObjectPtr s) {
5335
148
    int i, ret = 0;
5336
148
    xmlNodeSetPtr ns;
5337
148
    xmlChar *str2;
5338
5339
148
    if ((s == NULL) || (arg == NULL) ||
5340
148
  ((arg->type != XPATH_NODESET) && (arg->type != XPATH_XSLT_TREE))) {
5341
0
  xmlXPathReleaseObject(ctxt->context, arg);
5342
0
  xmlXPathReleaseObject(ctxt->context, s);
5343
0
        return(0);
5344
0
    }
5345
148
    ns = arg->nodesetval;
5346
148
    if (ns != NULL) {
5347
620
  for (i = 0;i < ns->nodeNr;i++) {
5348
472
       str2 = xmlXPathCastNodeToString(ns->nodeTab[i]);
5349
472
       if (str2 != NULL) {
5350
472
     xmlXPathValuePush(ctxt,
5351
472
         xmlXPathCacheNewString(ctxt, str2));
5352
472
     xmlFree(str2);
5353
472
     xmlXPathValuePush(ctxt, xmlXPathCacheObjectCopy(ctxt, s));
5354
472
     ret = xmlXPathCompareValues(ctxt, inf, strict);
5355
472
     if (ret)
5356
0
         break;
5357
472
       } else {
5358
0
                 xmlXPathPErrMemory(ctxt);
5359
0
             }
5360
472
  }
5361
148
    }
5362
148
    xmlXPathReleaseObject(ctxt->context, arg);
5363
148
    xmlXPathReleaseObject(ctxt->context, s);
5364
148
    return(ret);
5365
148
}
5366
5367
/**
5368
 * xmlXPathCompareNodeSets:
5369
 * @inf:  less than (1) or greater than (0)
5370
 * @strict:  is the comparison strict
5371
 * @arg1:  the first node set object
5372
 * @arg2:  the second node set object
5373
 *
5374
 * Implement the compare operation on nodesets:
5375
 *
5376
 * If both objects to be compared are node-sets, then the comparison
5377
 * will be true if and only if there is a node in the first node-set
5378
 * and a node in the second node-set such that the result of performing
5379
 * the comparison on the string-values of the two nodes is true.
5380
 * ....
5381
 * When neither object to be compared is a node-set and the operator
5382
 * is <=, <, >= or >, then the objects are compared by converting both
5383
 * objects to numbers and comparing the numbers according to IEEE 754.
5384
 * ....
5385
 * The number function converts its argument to a number as follows:
5386
 *  - a string that consists of optional whitespace followed by an
5387
 *    optional minus sign followed by a Number followed by whitespace
5388
 *    is converted to the IEEE 754 number that is nearest (according
5389
 *    to the IEEE 754 round-to-nearest rule) to the mathematical value
5390
 *    represented by the string; any other string is converted to NaN
5391
 *
5392
 * Conclusion all nodes need to be converted first to their string value
5393
 * and then the comparison must be done when possible
5394
 */
5395
static int
5396
xmlXPathCompareNodeSets(xmlXPathParserContextPtr ctxt, int inf, int strict,
5397
545
                  xmlXPathObjectPtr arg1, xmlXPathObjectPtr arg2) {
5398
545
    int i, j, init = 0;
5399
545
    double val1;
5400
545
    double *values2;
5401
545
    int ret = 0;
5402
545
    xmlNodeSetPtr ns1;
5403
545
    xmlNodeSetPtr ns2;
5404
5405
545
    if ((arg1 == NULL) ||
5406
545
  ((arg1->type != XPATH_NODESET) && (arg1->type != XPATH_XSLT_TREE))) {
5407
0
  xmlXPathFreeObject(arg2);
5408
0
        return(0);
5409
0
    }
5410
545
    if ((arg2 == NULL) ||
5411
545
  ((arg2->type != XPATH_NODESET) && (arg2->type != XPATH_XSLT_TREE))) {
5412
0
  xmlXPathFreeObject(arg1);
5413
0
  xmlXPathFreeObject(arg2);
5414
0
        return(0);
5415
0
    }
5416
5417
545
    ns1 = arg1->nodesetval;
5418
545
    ns2 = arg2->nodesetval;
5419
5420
545
    if ((ns1 == NULL) || (ns1->nodeNr <= 0)) {
5421
4
  xmlXPathFreeObject(arg1);
5422
4
  xmlXPathFreeObject(arg2);
5423
4
  return(0);
5424
4
    }
5425
541
    if ((ns2 == NULL) || (ns2->nodeNr <= 0)) {
5426
86
  xmlXPathFreeObject(arg1);
5427
86
  xmlXPathFreeObject(arg2);
5428
86
  return(0);
5429
86
    }
5430
5431
455
    values2 = (double *) xmlMalloc(ns2->nodeNr * sizeof(double));
5432
455
    if (values2 == NULL) {
5433
0
        xmlXPathPErrMemory(ctxt);
5434
0
  xmlXPathFreeObject(arg1);
5435
0
  xmlXPathFreeObject(arg2);
5436
0
  return(0);
5437
0
    }
5438
910
    for (i = 0;i < ns1->nodeNr;i++) {
5439
455
  val1 = xmlXPathNodeToNumberInternal(ctxt, ns1->nodeTab[i]);
5440
455
  if (xmlXPathIsNaN(val1))
5441
455
      continue;
5442
0
  for (j = 0;j < ns2->nodeNr;j++) {
5443
0
      if (init == 0) {
5444
0
    values2[j] = xmlXPathNodeToNumberInternal(ctxt,
5445
0
                                                          ns2->nodeTab[j]);
5446
0
      }
5447
0
      if (xmlXPathIsNaN(values2[j]))
5448
0
    continue;
5449
0
      if (inf && strict)
5450
0
    ret = (val1 < values2[j]);
5451
0
      else if (inf && !strict)
5452
0
    ret = (val1 <= values2[j]);
5453
0
      else if (!inf && strict)
5454
0
    ret = (val1 > values2[j]);
5455
0
      else if (!inf && !strict)
5456
0
    ret = (val1 >= values2[j]);
5457
0
      if (ret)
5458
0
    break;
5459
0
  }
5460
0
  if (ret)
5461
0
      break;
5462
0
  init = 1;
5463
0
    }
5464
455
    xmlFree(values2);
5465
455
    xmlXPathFreeObject(arg1);
5466
455
    xmlXPathFreeObject(arg2);
5467
455
    return(ret);
5468
455
}
5469
5470
/**
5471
 * xmlXPathCompareNodeSetValue:
5472
 * @ctxt:  the XPath Parser context
5473
 * @inf:  less than (1) or greater than (0)
5474
 * @strict:  is the comparison strict
5475
 * @arg:  the node set
5476
 * @val:  the value
5477
 *
5478
 * Implement the compare operation between a nodeset and a value
5479
 *     @ns < @val    (1, 1, ...
5480
 *     @ns <= @val   (1, 0, ...
5481
 *     @ns > @val    (0, 1, ...
5482
 *     @ns >= @val   (0, 0, ...
5483
 *
5484
 * If one object to be compared is a node-set and the other is a boolean,
5485
 * then the comparison will be true if and only if the result of performing
5486
 * the comparison on the boolean and on the result of converting
5487
 * the node-set to a boolean using the boolean function is true.
5488
 *
5489
 * Returns 0 or 1 depending on the results of the test.
5490
 */
5491
static int
5492
xmlXPathCompareNodeSetValue(xmlXPathParserContextPtr ctxt, int inf, int strict,
5493
148
                      xmlXPathObjectPtr arg, xmlXPathObjectPtr val) {
5494
148
    if ((val == NULL) || (arg == NULL) ||
5495
148
  ((arg->type != XPATH_NODESET) && (arg->type != XPATH_XSLT_TREE)))
5496
0
        return(0);
5497
5498
148
    switch(val->type) {
5499
0
        case XPATH_NUMBER:
5500
0
      return(xmlXPathCompareNodeSetFloat(ctxt, inf, strict, arg, val));
5501
0
        case XPATH_NODESET:
5502
0
        case XPATH_XSLT_TREE:
5503
0
      return(xmlXPathCompareNodeSets(ctxt, inf, strict, arg, val));
5504
148
        case XPATH_STRING:
5505
148
      return(xmlXPathCompareNodeSetString(ctxt, inf, strict, arg, val));
5506
0
        case XPATH_BOOLEAN:
5507
0
      xmlXPathValuePush(ctxt, arg);
5508
0
      xmlXPathBooleanFunction(ctxt, 1);
5509
0
      xmlXPathValuePush(ctxt, val);
5510
0
      return(xmlXPathCompareValues(ctxt, inf, strict));
5511
0
  default:
5512
0
            xmlXPathReleaseObject(ctxt->context, arg);
5513
0
            xmlXPathReleaseObject(ctxt->context, val);
5514
0
            XP_ERROR0(XPATH_INVALID_TYPE);
5515
148
    }
5516
0
    return(0);
5517
148
}
5518
5519
/**
5520
 * xmlXPathEqualNodeSetString:
5521
 * @arg:  the nodeset object argument
5522
 * @str:  the string to compare to.
5523
 * @neq:  flag to show whether for '=' (0) or '!=' (1)
5524
 *
5525
 * Implement the equal operation on XPath objects content: @arg1 == @arg2
5526
 * If one object to be compared is a node-set and the other is a string,
5527
 * then the comparison will be true if and only if there is a node in
5528
 * the node-set such that the result of performing the comparison on the
5529
 * string-value of the node and the other string is true.
5530
 *
5531
 * Returns 0 or 1 depending on the results of the test.
5532
 */
5533
static int
5534
xmlXPathEqualNodeSetString(xmlXPathParserContextPtr ctxt,
5535
                           xmlXPathObjectPtr arg, const xmlChar * str, int neq)
5536
0
{
5537
0
    int i;
5538
0
    xmlNodeSetPtr ns;
5539
0
    xmlChar *str2;
5540
0
    unsigned int hash;
5541
5542
0
    if ((str == NULL) || (arg == NULL) ||
5543
0
        ((arg->type != XPATH_NODESET) && (arg->type != XPATH_XSLT_TREE)))
5544
0
        return (0);
5545
0
    ns = arg->nodesetval;
5546
    /*
5547
     * A NULL nodeset compared with a string is always false
5548
     * (since there is no node equal, and no node not equal)
5549
     */
5550
0
    if ((ns == NULL) || (ns->nodeNr <= 0) )
5551
0
        return (0);
5552
0
    hash = xmlXPathStringHash(str);
5553
0
    for (i = 0; i < ns->nodeNr; i++) {
5554
0
        if (xmlXPathNodeValHash(ns->nodeTab[i]) == hash) {
5555
0
            str2 = xmlNodeGetContent(ns->nodeTab[i]);
5556
0
            if (str2 == NULL) {
5557
0
                xmlXPathPErrMemory(ctxt);
5558
0
                return(0);
5559
0
            }
5560
0
            if (xmlStrEqual(str, str2)) {
5561
0
                xmlFree(str2);
5562
0
    if (neq)
5563
0
        continue;
5564
0
                return (1);
5565
0
            } else if (neq) {
5566
0
    xmlFree(str2);
5567
0
    return (1);
5568
0
      }
5569
0
            xmlFree(str2);
5570
0
        } else if (neq)
5571
0
      return (1);
5572
0
    }
5573
0
    return (0);
5574
0
}
5575
5576
/**
5577
 * xmlXPathEqualNodeSetFloat:
5578
 * @arg:  the nodeset object argument
5579
 * @f:  the float to compare to
5580
 * @neq:  flag to show whether to compare '=' (0) or '!=' (1)
5581
 *
5582
 * Implement the equal operation on XPath objects content: @arg1 == @arg2
5583
 * If one object to be compared is a node-set and the other is a number,
5584
 * then the comparison will be true if and only if there is a node in
5585
 * the node-set such that the result of performing the comparison on the
5586
 * number to be compared and on the result of converting the string-value
5587
 * of that node to a number using the number function is true.
5588
 *
5589
 * Returns 0 or 1 depending on the results of the test.
5590
 */
5591
static int
5592
xmlXPathEqualNodeSetFloat(xmlXPathParserContextPtr ctxt,
5593
0
    xmlXPathObjectPtr arg, double f, int neq) {
5594
0
  int i, ret=0;
5595
0
  xmlNodeSetPtr ns;
5596
0
  xmlChar *str2;
5597
0
  xmlXPathObjectPtr val;
5598
0
  double v;
5599
5600
0
    if ((arg == NULL) ||
5601
0
  ((arg->type != XPATH_NODESET) && (arg->type != XPATH_XSLT_TREE)))
5602
0
        return(0);
5603
5604
0
    ns = arg->nodesetval;
5605
0
    if (ns != NULL) {
5606
0
  for (i=0;i<ns->nodeNr;i++) {
5607
0
      str2 = xmlXPathCastNodeToString(ns->nodeTab[i]);
5608
0
      if (str2 != NULL) {
5609
0
    xmlXPathValuePush(ctxt, xmlXPathCacheNewString(ctxt, str2));
5610
0
    xmlFree(str2);
5611
0
    xmlXPathNumberFunction(ctxt, 1);
5612
0
                CHECK_ERROR0;
5613
0
    val = xmlXPathValuePop(ctxt);
5614
0
    v = val->floatval;
5615
0
    xmlXPathReleaseObject(ctxt->context, val);
5616
0
    if (!xmlXPathIsNaN(v)) {
5617
0
        if ((!neq) && (v==f)) {
5618
0
      ret = 1;
5619
0
      break;
5620
0
        } else if ((neq) && (v!=f)) {
5621
0
      ret = 1;
5622
0
      break;
5623
0
        }
5624
0
    } else { /* NaN is unequal to any value */
5625
0
        if (neq)
5626
0
      ret = 1;
5627
0
    }
5628
0
      } else {
5629
0
                xmlXPathPErrMemory(ctxt);
5630
0
            }
5631
0
  }
5632
0
    }
5633
5634
0
    return(ret);
5635
0
}
5636
5637
5638
/**
5639
 * xmlXPathEqualNodeSets:
5640
 * @arg1:  first nodeset object argument
5641
 * @arg2:  second nodeset object argument
5642
 * @neq:   flag to show whether to test '=' (0) or '!=' (1)
5643
 *
5644
 * Implement the equal / not equal operation on XPath nodesets:
5645
 * @arg1 == @arg2  or  @arg1 != @arg2
5646
 * If both objects to be compared are node-sets, then the comparison
5647
 * will be true if and only if there is a node in the first node-set and
5648
 * a node in the second node-set such that the result of performing the
5649
 * comparison on the string-values of the two nodes is true.
5650
 *
5651
 * (needless to say, this is a costly operation)
5652
 *
5653
 * Returns 0 or 1 depending on the results of the test.
5654
 */
5655
static int
5656
xmlXPathEqualNodeSets(xmlXPathParserContextPtr ctxt, xmlXPathObjectPtr arg1,
5657
3.36k
                      xmlXPathObjectPtr arg2, int neq) {
5658
3.36k
    int i, j;
5659
3.36k
    unsigned int *hashs1;
5660
3.36k
    unsigned int *hashs2;
5661
3.36k
    xmlChar **values1;
5662
3.36k
    xmlChar **values2;
5663
3.36k
    int ret = 0;
5664
3.36k
    xmlNodeSetPtr ns1;
5665
3.36k
    xmlNodeSetPtr ns2;
5666
5667
3.36k
    if ((arg1 == NULL) ||
5668
3.36k
  ((arg1->type != XPATH_NODESET) && (arg1->type != XPATH_XSLT_TREE)))
5669
0
        return(0);
5670
3.36k
    if ((arg2 == NULL) ||
5671
3.36k
  ((arg2->type != XPATH_NODESET) && (arg2->type != XPATH_XSLT_TREE)))
5672
0
        return(0);
5673
5674
3.36k
    ns1 = arg1->nodesetval;
5675
3.36k
    ns2 = arg2->nodesetval;
5676
5677
3.36k
    if ((ns1 == NULL) || (ns1->nodeNr <= 0))
5678
3.23k
  return(0);
5679
133
    if ((ns2 == NULL) || (ns2->nodeNr <= 0))
5680
0
  return(0);
5681
5682
    /*
5683
     * for equal, check if there is a node pertaining to both sets
5684
     */
5685
133
    if (neq == 0)
5686
633k
  for (i = 0;i < ns1->nodeNr;i++)
5687
1.26M
      for (j = 0;j < ns2->nodeNr;j++)
5688
633k
    if (ns1->nodeTab[i] == ns2->nodeTab[j])
5689
0
        return(1);
5690
5691
133
    values1 = (xmlChar **) xmlMalloc(ns1->nodeNr * sizeof(xmlChar *));
5692
133
    if (values1 == NULL) {
5693
0
        xmlXPathPErrMemory(ctxt);
5694
0
  return(0);
5695
0
    }
5696
133
    hashs1 = (unsigned int *) xmlMalloc(ns1->nodeNr * sizeof(unsigned int));
5697
133
    if (hashs1 == NULL) {
5698
0
        xmlXPathPErrMemory(ctxt);
5699
0
  xmlFree(values1);
5700
0
  return(0);
5701
0
    }
5702
133
    memset(values1, 0, ns1->nodeNr * sizeof(xmlChar *));
5703
133
    values2 = (xmlChar **) xmlMalloc(ns2->nodeNr * sizeof(xmlChar *));
5704
133
    if (values2 == NULL) {
5705
0
        xmlXPathPErrMemory(ctxt);
5706
0
  xmlFree(hashs1);
5707
0
  xmlFree(values1);
5708
0
  return(0);
5709
0
    }
5710
133
    hashs2 = (unsigned int *) xmlMalloc(ns2->nodeNr * sizeof(unsigned int));
5711
133
    if (hashs2 == NULL) {
5712
0
        xmlXPathPErrMemory(ctxt);
5713
0
  xmlFree(hashs1);
5714
0
  xmlFree(values1);
5715
0
  xmlFree(values2);
5716
0
  return(0);
5717
0
    }
5718
133
    memset(values2, 0, ns2->nodeNr * sizeof(xmlChar *));
5719
354k
    for (i = 0;i < ns1->nodeNr;i++) {
5720
354k
  hashs1[i] = xmlXPathNodeValHash(ns1->nodeTab[i]);
5721
708k
  for (j = 0;j < ns2->nodeNr;j++) {
5722
354k
      if (i == 0)
5723
197
    hashs2[j] = xmlXPathNodeValHash(ns2->nodeTab[j]);
5724
354k
      if (hashs1[i] != hashs2[j]) {
5725
350k
    if (neq) {
5726
0
        ret = 1;
5727
0
        break;
5728
0
    }
5729
350k
      }
5730
3.91k
      else {
5731
3.91k
    if (values1[i] == NULL) {
5732
3.89k
        values1[i] = xmlNodeGetContent(ns1->nodeTab[i]);
5733
3.89k
                    if (values1[i] == NULL)
5734
0
                        xmlXPathPErrMemory(ctxt);
5735
3.89k
                }
5736
3.91k
    if (values2[j] == NULL) {
5737
81
        values2[j] = xmlNodeGetContent(ns2->nodeTab[j]);
5738
81
                    if (values2[j] == NULL)
5739
0
                        xmlXPathPErrMemory(ctxt);
5740
81
                }
5741
3.91k
    ret = xmlStrEqual(values1[i], values2[j]) ^ neq;
5742
3.91k
    if (ret)
5743
20
        break;
5744
3.91k
      }
5745
354k
  }
5746
354k
  if (ret)
5747
20
      break;
5748
354k
    }
5749
633k
    for (i = 0;i < ns1->nodeNr;i++)
5750
633k
  if (values1[i] != NULL)
5751
3.89k
      xmlFree(values1[i]);
5752
330
    for (j = 0;j < ns2->nodeNr;j++)
5753
197
  if (values2[j] != NULL)
5754
81
      xmlFree(values2[j]);
5755
133
    xmlFree(values1);
5756
133
    xmlFree(values2);
5757
133
    xmlFree(hashs1);
5758
133
    xmlFree(hashs2);
5759
133
    return(ret);
5760
133
}
5761
5762
static int
5763
xmlXPathEqualValuesCommon(xmlXPathParserContextPtr ctxt,
5764
2.79k
  xmlXPathObjectPtr arg1, xmlXPathObjectPtr arg2) {
5765
2.79k
    int ret = 0;
5766
    /*
5767
     *At this point we are assured neither arg1 nor arg2
5768
     *is a nodeset, so we can just pick the appropriate routine.
5769
     */
5770
2.79k
    switch (arg1->type) {
5771
0
        case XPATH_UNDEFINED:
5772
0
      break;
5773
30
        case XPATH_BOOLEAN:
5774
30
      switch (arg2->type) {
5775
0
          case XPATH_UNDEFINED:
5776
0
        break;
5777
0
    case XPATH_BOOLEAN:
5778
0
        ret = (arg1->boolval == arg2->boolval);
5779
0
        break;
5780
0
    case XPATH_NUMBER:
5781
0
        ret = (arg1->boolval ==
5782
0
         xmlXPathCastNumberToBoolean(arg2->floatval));
5783
0
        break;
5784
30
    case XPATH_STRING:
5785
30
        if ((arg2->stringval == NULL) ||
5786
30
      (arg2->stringval[0] == 0)) ret = 0;
5787
30
        else
5788
30
      ret = 1;
5789
30
        ret = (arg1->boolval == ret);
5790
30
        break;
5791
0
    case XPATH_USERS:
5792
        /* TODO */
5793
0
        break;
5794
0
    case XPATH_NODESET:
5795
0
    case XPATH_XSLT_TREE:
5796
0
        break;
5797
30
      }
5798
30
      break;
5799
2.50k
        case XPATH_NUMBER:
5800
2.50k
      switch (arg2->type) {
5801
0
          case XPATH_UNDEFINED:
5802
0
        break;
5803
2.50k
    case XPATH_BOOLEAN:
5804
2.50k
        ret = (arg2->boolval==
5805
2.50k
         xmlXPathCastNumberToBoolean(arg1->floatval));
5806
2.50k
        break;
5807
0
    case XPATH_STRING:
5808
0
        xmlXPathValuePush(ctxt, arg2);
5809
0
        xmlXPathNumberFunction(ctxt, 1);
5810
0
        arg2 = xmlXPathValuePop(ctxt);
5811
0
                    if (ctxt->error)
5812
0
                        break;
5813
                    /* Falls through. */
5814
1
    case XPATH_NUMBER:
5815
        /* Hand check NaN and Infinity equalities */
5816
1
        if (xmlXPathIsNaN(arg1->floatval) ||
5817
1
          xmlXPathIsNaN(arg2->floatval)) {
5818
0
            ret = 0;
5819
1
        } else if (xmlXPathIsInf(arg1->floatval) == 1) {
5820
1
            if (xmlXPathIsInf(arg2->floatval) == 1)
5821
0
          ret = 1;
5822
1
      else
5823
1
          ret = 0;
5824
1
        } else if (xmlXPathIsInf(arg1->floatval) == -1) {
5825
0
      if (xmlXPathIsInf(arg2->floatval) == -1)
5826
0
          ret = 1;
5827
0
      else
5828
0
          ret = 0;
5829
0
        } else if (xmlXPathIsInf(arg2->floatval) == 1) {
5830
0
      if (xmlXPathIsInf(arg1->floatval) == 1)
5831
0
          ret = 1;
5832
0
      else
5833
0
          ret = 0;
5834
0
        } else if (xmlXPathIsInf(arg2->floatval) == -1) {
5835
0
      if (xmlXPathIsInf(arg1->floatval) == -1)
5836
0
          ret = 1;
5837
0
      else
5838
0
          ret = 0;
5839
0
        } else {
5840
0
            ret = (arg1->floatval == arg2->floatval);
5841
0
        }
5842
1
        break;
5843
0
    case XPATH_USERS:
5844
        /* TODO */
5845
0
        break;
5846
0
    case XPATH_NODESET:
5847
0
    case XPATH_XSLT_TREE:
5848
0
        break;
5849
2.50k
      }
5850
2.50k
      break;
5851
2.50k
        case XPATH_STRING:
5852
262
      switch (arg2->type) {
5853
0
          case XPATH_UNDEFINED:
5854
0
        break;
5855
0
    case XPATH_BOOLEAN:
5856
0
        if ((arg1->stringval == NULL) ||
5857
0
      (arg1->stringval[0] == 0)) ret = 0;
5858
0
        else
5859
0
      ret = 1;
5860
0
        ret = (arg2->boolval == ret);
5861
0
        break;
5862
262
    case XPATH_STRING:
5863
262
        ret = xmlStrEqual(arg1->stringval, arg2->stringval);
5864
262
        break;
5865
0
    case XPATH_NUMBER:
5866
0
        xmlXPathValuePush(ctxt, arg1);
5867
0
        xmlXPathNumberFunction(ctxt, 1);
5868
0
        arg1 = xmlXPathValuePop(ctxt);
5869
0
                    if (ctxt->error)
5870
0
                        break;
5871
        /* Hand check NaN and Infinity equalities */
5872
0
        if (xmlXPathIsNaN(arg1->floatval) ||
5873
0
          xmlXPathIsNaN(arg2->floatval)) {
5874
0
            ret = 0;
5875
0
        } else if (xmlXPathIsInf(arg1->floatval) == 1) {
5876
0
      if (xmlXPathIsInf(arg2->floatval) == 1)
5877
0
          ret = 1;
5878
0
      else
5879
0
          ret = 0;
5880
0
        } else if (xmlXPathIsInf(arg1->floatval) == -1) {
5881
0
      if (xmlXPathIsInf(arg2->floatval) == -1)
5882
0
          ret = 1;
5883
0
      else
5884
0
          ret = 0;
5885
0
        } else if (xmlXPathIsInf(arg2->floatval) == 1) {
5886
0
      if (xmlXPathIsInf(arg1->floatval) == 1)
5887
0
          ret = 1;
5888
0
      else
5889
0
          ret = 0;
5890
0
        } else if (xmlXPathIsInf(arg2->floatval) == -1) {
5891
0
      if (xmlXPathIsInf(arg1->floatval) == -1)
5892
0
          ret = 1;
5893
0
      else
5894
0
          ret = 0;
5895
0
        } else {
5896
0
            ret = (arg1->floatval == arg2->floatval);
5897
0
        }
5898
0
        break;
5899
0
    case XPATH_USERS:
5900
        /* TODO */
5901
0
        break;
5902
0
    case XPATH_NODESET:
5903
0
    case XPATH_XSLT_TREE:
5904
0
        break;
5905
262
      }
5906
262
      break;
5907
262
        case XPATH_USERS:
5908
      /* TODO */
5909
0
      break;
5910
0
  case XPATH_NODESET:
5911
0
  case XPATH_XSLT_TREE:
5912
0
      break;
5913
2.79k
    }
5914
2.79k
    xmlXPathReleaseObject(ctxt->context, arg1);
5915
2.79k
    xmlXPathReleaseObject(ctxt->context, arg2);
5916
2.79k
    return(ret);
5917
2.79k
}
5918
5919
/**
5920
 * xmlXPathEqualValues:
5921
 * @ctxt:  the XPath Parser context
5922
 *
5923
 * Implement the equal operation on XPath objects content: @arg1 == @arg2
5924
 *
5925
 * Returns 0 or 1 depending on the results of the test.
5926
 */
5927
int
5928
6.15k
xmlXPathEqualValues(xmlXPathParserContextPtr ctxt) {
5929
6.15k
    xmlXPathObjectPtr arg1, arg2, argtmp;
5930
6.15k
    int ret = 0;
5931
5932
6.15k
    if ((ctxt == NULL) || (ctxt->context == NULL)) return(0);
5933
6.15k
    arg2 = xmlXPathValuePop(ctxt);
5934
6.15k
    arg1 = xmlXPathValuePop(ctxt);
5935
6.15k
    if ((arg1 == NULL) || (arg2 == NULL)) {
5936
0
  if (arg1 != NULL)
5937
0
      xmlXPathReleaseObject(ctxt->context, arg1);
5938
0
  else
5939
0
      xmlXPathReleaseObject(ctxt->context, arg2);
5940
0
  XP_ERROR0(XPATH_INVALID_OPERAND);
5941
0
    }
5942
5943
6.15k
    if (arg1 == arg2) {
5944
0
  xmlXPathFreeObject(arg1);
5945
0
        return(1);
5946
0
    }
5947
5948
    /*
5949
     *If either argument is a nodeset, it's a 'special case'
5950
     */
5951
6.15k
    if ((arg2->type == XPATH_NODESET) || (arg2->type == XPATH_XSLT_TREE) ||
5952
6.15k
      (arg1->type == XPATH_NODESET) || (arg1->type == XPATH_XSLT_TREE)) {
5953
  /*
5954
   *Hack it to assure arg1 is the nodeset
5955
   */
5956
3.36k
  if ((arg1->type != XPATH_NODESET) && (arg1->type != XPATH_XSLT_TREE)) {
5957
0
    argtmp = arg2;
5958
0
    arg2 = arg1;
5959
0
    arg1 = argtmp;
5960
0
  }
5961
3.36k
  switch (arg2->type) {
5962
0
      case XPATH_UNDEFINED:
5963
0
    break;
5964
3.36k
      case XPATH_NODESET:
5965
3.36k
      case XPATH_XSLT_TREE:
5966
3.36k
    ret = xmlXPathEqualNodeSets(ctxt, arg1, arg2, 0);
5967
3.36k
    break;
5968
0
      case XPATH_BOOLEAN:
5969
0
    if ((arg1->nodesetval == NULL) ||
5970
0
      (arg1->nodesetval->nodeNr == 0)) ret = 0;
5971
0
    else
5972
0
        ret = 1;
5973
0
    ret = (ret == arg2->boolval);
5974
0
    break;
5975
0
      case XPATH_NUMBER:
5976
0
    ret = xmlXPathEqualNodeSetFloat(ctxt, arg1, arg2->floatval, 0);
5977
0
    break;
5978
0
      case XPATH_STRING:
5979
0
    ret = xmlXPathEqualNodeSetString(ctxt, arg1,
5980
0
                                                 arg2->stringval, 0);
5981
0
    break;
5982
0
      case XPATH_USERS:
5983
    /* TODO */
5984
0
    break;
5985
3.36k
  }
5986
3.36k
  xmlXPathReleaseObject(ctxt->context, arg1);
5987
3.36k
  xmlXPathReleaseObject(ctxt->context, arg2);
5988
3.36k
  return(ret);
5989
3.36k
    }
5990
5991
2.79k
    return (xmlXPathEqualValuesCommon(ctxt, arg1, arg2));
5992
6.15k
}
5993
5994
/**
5995
 * xmlXPathNotEqualValues:
5996
 * @ctxt:  the XPath Parser context
5997
 *
5998
 * Implement the equal operation on XPath objects content: @arg1 == @arg2
5999
 *
6000
 * Returns 0 or 1 depending on the results of the test.
6001
 */
6002
int
6003
0
xmlXPathNotEqualValues(xmlXPathParserContextPtr ctxt) {
6004
0
    xmlXPathObjectPtr arg1, arg2, argtmp;
6005
0
    int ret = 0;
6006
6007
0
    if ((ctxt == NULL) || (ctxt->context == NULL)) return(0);
6008
0
    arg2 = xmlXPathValuePop(ctxt);
6009
0
    arg1 = xmlXPathValuePop(ctxt);
6010
0
    if ((arg1 == NULL) || (arg2 == NULL)) {
6011
0
  if (arg1 != NULL)
6012
0
      xmlXPathReleaseObject(ctxt->context, arg1);
6013
0
  else
6014
0
      xmlXPathReleaseObject(ctxt->context, arg2);
6015
0
  XP_ERROR0(XPATH_INVALID_OPERAND);
6016
0
    }
6017
6018
0
    if (arg1 == arg2) {
6019
0
  xmlXPathReleaseObject(ctxt->context, arg1);
6020
0
        return(0);
6021
0
    }
6022
6023
    /*
6024
     *If either argument is a nodeset, it's a 'special case'
6025
     */
6026
0
    if ((arg2->type == XPATH_NODESET) || (arg2->type == XPATH_XSLT_TREE) ||
6027
0
      (arg1->type == XPATH_NODESET) || (arg1->type == XPATH_XSLT_TREE)) {
6028
  /*
6029
   *Hack it to assure arg1 is the nodeset
6030
   */
6031
0
  if ((arg1->type != XPATH_NODESET) && (arg1->type != XPATH_XSLT_TREE)) {
6032
0
    argtmp = arg2;
6033
0
    arg2 = arg1;
6034
0
    arg1 = argtmp;
6035
0
  }
6036
0
  switch (arg2->type) {
6037
0
      case XPATH_UNDEFINED:
6038
0
    break;
6039
0
      case XPATH_NODESET:
6040
0
      case XPATH_XSLT_TREE:
6041
0
    ret = xmlXPathEqualNodeSets(ctxt, arg1, arg2, 1);
6042
0
    break;
6043
0
      case XPATH_BOOLEAN:
6044
0
    if ((arg1->nodesetval == NULL) ||
6045
0
      (arg1->nodesetval->nodeNr == 0)) ret = 0;
6046
0
    else
6047
0
        ret = 1;
6048
0
    ret = (ret != arg2->boolval);
6049
0
    break;
6050
0
      case XPATH_NUMBER:
6051
0
    ret = xmlXPathEqualNodeSetFloat(ctxt, arg1, arg2->floatval, 1);
6052
0
    break;
6053
0
      case XPATH_STRING:
6054
0
    ret = xmlXPathEqualNodeSetString(ctxt, arg1,
6055
0
                                                 arg2->stringval, 1);
6056
0
    break;
6057
0
      case XPATH_USERS:
6058
    /* TODO */
6059
0
    break;
6060
0
  }
6061
0
  xmlXPathReleaseObject(ctxt->context, arg1);
6062
0
  xmlXPathReleaseObject(ctxt->context, arg2);
6063
0
  return(ret);
6064
0
    }
6065
6066
0
    return (!xmlXPathEqualValuesCommon(ctxt, arg1, arg2));
6067
0
}
6068
6069
/**
6070
 * xmlXPathCompareValues:
6071
 * @ctxt:  the XPath Parser context
6072
 * @inf:  less than (1) or greater than (0)
6073
 * @strict:  is the comparison strict
6074
 *
6075
 * Implement the compare operation on XPath objects:
6076
 *     @arg1 < @arg2    (1, 1, ...
6077
 *     @arg1 <= @arg2   (1, 0, ...
6078
 *     @arg1 > @arg2    (0, 1, ...
6079
 *     @arg1 >= @arg2   (0, 0, ...
6080
 *
6081
 * When neither object to be compared is a node-set and the operator is
6082
 * <=, <, >=, >, then the objects are compared by converted both objects
6083
 * to numbers and comparing the numbers according to IEEE 754. The <
6084
 * comparison will be true if and only if the first number is less than the
6085
 * second number. The <= comparison will be true if and only if the first
6086
 * number is less than or equal to the second number. The > comparison
6087
 * will be true if and only if the first number is greater than the second
6088
 * number. The >= comparison will be true if and only if the first number
6089
 * is greater than or equal to the second number.
6090
 *
6091
 * Returns 1 if the comparison succeeded, 0 if it failed
6092
 */
6093
int
6094
6.16k
xmlXPathCompareValues(xmlXPathParserContextPtr ctxt, int inf, int strict) {
6095
6.16k
    int ret = 0, arg1i = 0, arg2i = 0;
6096
6.16k
    xmlXPathObjectPtr arg1, arg2;
6097
6098
6.16k
    if ((ctxt == NULL) || (ctxt->context == NULL)) return(0);
6099
6.16k
    arg2 = xmlXPathValuePop(ctxt);
6100
6.16k
    arg1 = xmlXPathValuePop(ctxt);
6101
6.16k
    if ((arg1 == NULL) || (arg2 == NULL)) {
6102
0
  if (arg1 != NULL)
6103
0
      xmlXPathReleaseObject(ctxt->context, arg1);
6104
0
  else
6105
0
      xmlXPathReleaseObject(ctxt->context, arg2);
6106
0
  XP_ERROR0(XPATH_INVALID_OPERAND);
6107
0
    }
6108
6109
6.16k
    if ((arg2->type == XPATH_NODESET) || (arg2->type == XPATH_XSLT_TREE) ||
6110
6.16k
      (arg1->type == XPATH_NODESET) || (arg1->type == XPATH_XSLT_TREE)) {
6111
  /*
6112
   * If either argument is a XPATH_NODESET or XPATH_XSLT_TREE the two arguments
6113
   * are not freed from within this routine; they will be freed from the
6114
   * called routine, e.g. xmlXPathCompareNodeSets or xmlXPathCompareNodeSetValue
6115
   */
6116
693
  if (((arg2->type == XPATH_NODESET) || (arg2->type == XPATH_XSLT_TREE)) &&
6117
693
    ((arg1->type == XPATH_NODESET) || (arg1->type == XPATH_XSLT_TREE))){
6118
545
      ret = xmlXPathCompareNodeSets(ctxt, inf, strict, arg1, arg2);
6119
545
  } else {
6120
148
      if ((arg1->type == XPATH_NODESET) || (arg1->type == XPATH_XSLT_TREE)) {
6121
148
    ret = xmlXPathCompareNodeSetValue(ctxt, inf, strict,
6122
148
                                arg1, arg2);
6123
148
      } else {
6124
0
    ret = xmlXPathCompareNodeSetValue(ctxt, !inf, strict,
6125
0
                                arg2, arg1);
6126
0
      }
6127
148
  }
6128
693
  return(ret);
6129
693
    }
6130
6131
5.47k
    if (arg1->type != XPATH_NUMBER) {
6132
2.97k
  xmlXPathValuePush(ctxt, arg1);
6133
2.97k
  xmlXPathNumberFunction(ctxt, 1);
6134
2.97k
  arg1 = xmlXPathValuePop(ctxt);
6135
2.97k
    }
6136
5.47k
    if (arg2->type != XPATH_NUMBER) {
6137
472
  xmlXPathValuePush(ctxt, arg2);
6138
472
  xmlXPathNumberFunction(ctxt, 1);
6139
472
  arg2 = xmlXPathValuePop(ctxt);
6140
472
    }
6141
5.47k
    if (ctxt->error)
6142
0
        goto error;
6143
    /*
6144
     * Add tests for infinity and nan
6145
     * => feedback on 3.4 for Inf and NaN
6146
     */
6147
    /* Hand check NaN and Infinity comparisons */
6148
5.47k
    if (xmlXPathIsNaN(arg1->floatval) || xmlXPathIsNaN(arg2->floatval)) {
6149
472
  ret=0;
6150
5.00k
    } else {
6151
5.00k
  arg1i=xmlXPathIsInf(arg1->floatval);
6152
5.00k
  arg2i=xmlXPathIsInf(arg2->floatval);
6153
5.00k
  if (inf && strict) {
6154
2.50k
      if ((arg1i == -1 && arg2i != -1) ||
6155
2.50k
    (arg2i == 1 && arg1i != 1)) {
6156
2.50k
    ret = 1;
6157
2.50k
      } else if (arg1i == 0 && arg2i == 0) {
6158
0
    ret = (arg1->floatval < arg2->floatval);
6159
0
      } else {
6160
0
    ret = 0;
6161
0
      }
6162
2.50k
  }
6163
2.50k
  else if (inf && !strict) {
6164
2.50k
      if (arg1i == -1 || arg2i == 1) {
6165
2.50k
    ret = 1;
6166
2.50k
      } else if (arg1i == 0 && arg2i == 0) {
6167
0
    ret = (arg1->floatval <= arg2->floatval);
6168
0
      } else {
6169
0
    ret = 0;
6170
0
      }
6171
2.50k
  }
6172
0
  else if (!inf && strict) {
6173
0
      if ((arg1i == 1 && arg2i != 1) ||
6174
0
    (arg2i == -1 && arg1i != -1)) {
6175
0
    ret = 1;
6176
0
      } else if (arg1i == 0 && arg2i == 0) {
6177
0
    ret = (arg1->floatval > arg2->floatval);
6178
0
      } else {
6179
0
    ret = 0;
6180
0
      }
6181
0
  }
6182
0
  else if (!inf && !strict) {
6183
0
      if (arg1i == 1 || arg2i == -1) {
6184
0
    ret = 1;
6185
0
      } else if (arg1i == 0 && arg2i == 0) {
6186
0
    ret = (arg1->floatval >= arg2->floatval);
6187
0
      } else {
6188
0
    ret = 0;
6189
0
      }
6190
0
  }
6191
5.00k
    }
6192
5.47k
error:
6193
5.47k
    xmlXPathReleaseObject(ctxt->context, arg1);
6194
5.47k
    xmlXPathReleaseObject(ctxt->context, arg2);
6195
5.47k
    return(ret);
6196
5.47k
}
6197
6198
/**
6199
 * xmlXPathValueFlipSign:
6200
 * @ctxt:  the XPath Parser context
6201
 *
6202
 * Implement the unary - operation on an XPath object
6203
 * The numeric operators convert their operands to numbers as if
6204
 * by calling the number function.
6205
 */
6206
void
6207
164k
xmlXPathValueFlipSign(xmlXPathParserContextPtr ctxt) {
6208
164k
    if ((ctxt == NULL) || (ctxt->context == NULL)) return;
6209
164k
    CAST_TO_NUMBER;
6210
164k
    CHECK_TYPE(XPATH_NUMBER);
6211
164k
    ctxt->value->floatval = -ctxt->value->floatval;
6212
164k
}
6213
6214
/**
6215
 * xmlXPathAddValues:
6216
 * @ctxt:  the XPath Parser context
6217
 *
6218
 * Implement the add operation on XPath objects:
6219
 * The numeric operators convert their operands to numbers as if
6220
 * by calling the number function.
6221
 */
6222
void
6223
21
xmlXPathAddValues(xmlXPathParserContextPtr ctxt) {
6224
21
    xmlXPathObjectPtr arg;
6225
21
    double val;
6226
6227
21
    arg = xmlXPathValuePop(ctxt);
6228
21
    if (arg == NULL)
6229
21
  XP_ERROR(XPATH_INVALID_OPERAND);
6230
21
    val = xmlXPathCastToNumberInternal(ctxt, arg);
6231
21
    xmlXPathReleaseObject(ctxt->context, arg);
6232
21
    CAST_TO_NUMBER;
6233
21
    CHECK_TYPE(XPATH_NUMBER);
6234
21
    ctxt->value->floatval += val;
6235
21
}
6236
6237
/**
6238
 * xmlXPathSubValues:
6239
 * @ctxt:  the XPath Parser context
6240
 *
6241
 * Implement the subtraction operation on XPath objects:
6242
 * The numeric operators convert their operands to numbers as if
6243
 * by calling the number function.
6244
 */
6245
void
6246
2
xmlXPathSubValues(xmlXPathParserContextPtr ctxt) {
6247
2
    xmlXPathObjectPtr arg;
6248
2
    double val;
6249
6250
2
    arg = xmlXPathValuePop(ctxt);
6251
2
    if (arg == NULL)
6252
2
  XP_ERROR(XPATH_INVALID_OPERAND);
6253
2
    val = xmlXPathCastToNumberInternal(ctxt, arg);
6254
2
    xmlXPathReleaseObject(ctxt->context, arg);
6255
2
    CAST_TO_NUMBER;
6256
2
    CHECK_TYPE(XPATH_NUMBER);
6257
2
    ctxt->value->floatval -= val;
6258
2
}
6259
6260
/**
6261
 * xmlXPathMultValues:
6262
 * @ctxt:  the XPath Parser context
6263
 *
6264
 * Implement the multiply operation on XPath objects:
6265
 * The numeric operators convert their operands to numbers as if
6266
 * by calling the number function.
6267
 */
6268
void
6269
438
xmlXPathMultValues(xmlXPathParserContextPtr ctxt) {
6270
438
    xmlXPathObjectPtr arg;
6271
438
    double val;
6272
6273
438
    arg = xmlXPathValuePop(ctxt);
6274
438
    if (arg == NULL)
6275
438
  XP_ERROR(XPATH_INVALID_OPERAND);
6276
438
    val = xmlXPathCastToNumberInternal(ctxt, arg);
6277
438
    xmlXPathReleaseObject(ctxt->context, arg);
6278
438
    CAST_TO_NUMBER;
6279
438
    CHECK_TYPE(XPATH_NUMBER);
6280
438
    ctxt->value->floatval *= val;
6281
438
}
6282
6283
/**
6284
 * xmlXPathDivValues:
6285
 * @ctxt:  the XPath Parser context
6286
 *
6287
 * Implement the div operation on XPath objects @arg1 / @arg2:
6288
 * The numeric operators convert their operands to numbers as if
6289
 * by calling the number function.
6290
 */
6291
ATTRIBUTE_NO_SANITIZE("float-divide-by-zero")
6292
void
6293
0
xmlXPathDivValues(xmlXPathParserContextPtr ctxt) {
6294
0
    xmlXPathObjectPtr arg;
6295
0
    double val;
6296
6297
0
    arg = xmlXPathValuePop(ctxt);
6298
0
    if (arg == NULL)
6299
0
  XP_ERROR(XPATH_INVALID_OPERAND);
6300
0
    val = xmlXPathCastToNumberInternal(ctxt, arg);
6301
0
    xmlXPathReleaseObject(ctxt->context, arg);
6302
0
    CAST_TO_NUMBER;
6303
0
    CHECK_TYPE(XPATH_NUMBER);
6304
0
    ctxt->value->floatval /= val;
6305
0
}
6306
6307
/**
6308
 * xmlXPathModValues:
6309
 * @ctxt:  the XPath Parser context
6310
 *
6311
 * Implement the mod operation on XPath objects: @arg1 / @arg2
6312
 * The numeric operators convert their operands to numbers as if
6313
 * by calling the number function.
6314
 */
6315
void
6316
71
xmlXPathModValues(xmlXPathParserContextPtr ctxt) {
6317
71
    xmlXPathObjectPtr arg;
6318
71
    double arg1, arg2;
6319
6320
71
    arg = xmlXPathValuePop(ctxt);
6321
71
    if (arg == NULL)
6322
71
  XP_ERROR(XPATH_INVALID_OPERAND);
6323
71
    arg2 = xmlXPathCastToNumberInternal(ctxt, arg);
6324
71
    xmlXPathReleaseObject(ctxt->context, arg);
6325
71
    CAST_TO_NUMBER;
6326
71
    CHECK_TYPE(XPATH_NUMBER);
6327
71
    arg1 = ctxt->value->floatval;
6328
71
    if (arg2 == 0)
6329
0
  ctxt->value->floatval = xmlXPathNAN;
6330
71
    else {
6331
71
  ctxt->value->floatval = fmod(arg1, arg2);
6332
71
    }
6333
71
}
6334
6335
/************************************************************************
6336
 *                  *
6337
 *    The traversal functions         *
6338
 *                  *
6339
 ************************************************************************/
6340
6341
/*
6342
 * A traversal function enumerates nodes along an axis.
6343
 * Initially it must be called with NULL, and it indicates
6344
 * termination on the axis by returning NULL.
6345
 */
6346
typedef xmlNodePtr (*xmlXPathTraversalFunction)
6347
                    (xmlXPathParserContextPtr ctxt, xmlNodePtr cur);
6348
6349
/*
6350
 * xmlXPathTraversalFunctionExt:
6351
 * A traversal function enumerates nodes along an axis.
6352
 * Initially it must be called with NULL, and it indicates
6353
 * termination on the axis by returning NULL.
6354
 * The context node of the traversal is specified via @contextNode.
6355
 */
6356
typedef xmlNodePtr (*xmlXPathTraversalFunctionExt)
6357
                    (xmlNodePtr cur, xmlNodePtr contextNode);
6358
6359
/*
6360
 * xmlXPathNodeSetMergeFunction:
6361
 * Used for merging node sets in xmlXPathCollectAndTest().
6362
 */
6363
typedef xmlNodeSetPtr (*xmlXPathNodeSetMergeFunction)
6364
        (xmlNodeSetPtr, xmlNodeSetPtr);
6365
6366
6367
/**
6368
 * xmlXPathNextSelf:
6369
 * @ctxt:  the XPath Parser context
6370
 * @cur:  the current node in the traversal
6371
 *
6372
 * Traversal function for the "self" direction
6373
 * The self axis contains just the context node itself
6374
 *
6375
 * Returns the next element following that axis
6376
 */
6377
xmlNodePtr
6378
0
xmlXPathNextSelf(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
6379
0
    if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
6380
0
    if (cur == NULL)
6381
0
        return(ctxt->context->node);
6382
0
    return(NULL);
6383
0
}
6384
6385
/**
6386
 * xmlXPathNextChild:
6387
 * @ctxt:  the XPath Parser context
6388
 * @cur:  the current node in the traversal
6389
 *
6390
 * Traversal function for the "child" direction
6391
 * The child axis contains the children of the context node in document order.
6392
 *
6393
 * Returns the next element following that axis
6394
 */
6395
xmlNodePtr
6396
1.27M
xmlXPathNextChild(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
6397
1.27M
    if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
6398
1.27M
    if (cur == NULL) {
6399
635k
  if (ctxt->context->node == NULL) return(NULL);
6400
635k
  switch (ctxt->context->node->type) {
6401
549k
            case XML_ELEMENT_NODE:
6402
625k
            case XML_TEXT_NODE:
6403
635k
            case XML_CDATA_SECTION_NODE:
6404
635k
            case XML_ENTITY_REF_NODE:
6405
635k
            case XML_ENTITY_NODE:
6406
635k
            case XML_PI_NODE:
6407
635k
            case XML_COMMENT_NODE:
6408
635k
            case XML_NOTATION_NODE:
6409
635k
            case XML_DTD_NODE:
6410
635k
    return(ctxt->context->node->children);
6411
76
            case XML_DOCUMENT_NODE:
6412
76
            case XML_DOCUMENT_TYPE_NODE:
6413
76
            case XML_DOCUMENT_FRAG_NODE:
6414
76
            case XML_HTML_DOCUMENT_NODE:
6415
76
    return(((xmlDocPtr) ctxt->context->node)->children);
6416
0
      case XML_ELEMENT_DECL:
6417
0
      case XML_ATTRIBUTE_DECL:
6418
0
      case XML_ENTITY_DECL:
6419
0
            case XML_ATTRIBUTE_NODE:
6420
0
      case XML_NAMESPACE_DECL:
6421
0
      case XML_XINCLUDE_START:
6422
0
      case XML_XINCLUDE_END:
6423
0
    return(NULL);
6424
635k
  }
6425
0
  return(NULL);
6426
635k
    }
6427
637k
    if ((cur->type == XML_DOCUMENT_NODE) ||
6428
637k
        (cur->type == XML_HTML_DOCUMENT_NODE))
6429
0
  return(NULL);
6430
637k
    return(cur->next);
6431
637k
}
6432
6433
/**
6434
 * xmlXPathNextChildElement:
6435
 * @ctxt:  the XPath Parser context
6436
 * @cur:  the current node in the traversal
6437
 *
6438
 * Traversal function for the "child" direction and nodes of type element.
6439
 * The child axis contains the children of the context node in document order.
6440
 *
6441
 * Returns the next element following that axis
6442
 */
6443
static xmlNodePtr
6444
588k
xmlXPathNextChildElement(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
6445
588k
    if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
6446
588k
    if (cur == NULL) {
6447
232k
  cur = ctxt->context->node;
6448
232k
  if (cur == NULL) return(NULL);
6449
  /*
6450
  * Get the first element child.
6451
  */
6452
232k
  switch (cur->type) {
6453
142k
            case XML_ELEMENT_NODE:
6454
142k
      case XML_DOCUMENT_FRAG_NODE:
6455
142k
      case XML_ENTITY_REF_NODE: /* URGENT TODO: entify-refs as well? */
6456
142k
            case XML_ENTITY_NODE:
6457
142k
    cur = cur->children;
6458
142k
    if (cur != NULL) {
6459
81.8k
        if (cur->type == XML_ELEMENT_NODE)
6460
26.3k
      return(cur);
6461
94.7k
        do {
6462
94.7k
      cur = cur->next;
6463
94.7k
        } while ((cur != NULL) &&
6464
94.7k
      (cur->type != XML_ELEMENT_NODE));
6465
55.4k
        return(cur);
6466
81.8k
    }
6467
60.9k
    return(NULL);
6468
6.80k
            case XML_DOCUMENT_NODE:
6469
6.80k
            case XML_HTML_DOCUMENT_NODE:
6470
6.80k
    return(xmlDocGetRootElement((xmlDocPtr) cur));
6471
83.0k
      default:
6472
83.0k
    return(NULL);
6473
232k
  }
6474
0
  return(NULL);
6475
232k
    }
6476
    /*
6477
    * Get the next sibling element node.
6478
    */
6479
355k
    switch (cur->type) {
6480
355k
  case XML_ELEMENT_NODE:
6481
355k
  case XML_TEXT_NODE:
6482
355k
  case XML_ENTITY_REF_NODE:
6483
355k
  case XML_ENTITY_NODE:
6484
355k
  case XML_CDATA_SECTION_NODE:
6485
355k
  case XML_PI_NODE:
6486
355k
  case XML_COMMENT_NODE:
6487
355k
  case XML_XINCLUDE_END:
6488
355k
      break;
6489
  /* case XML_DTD_NODE: */ /* URGENT TODO: DTD-node as well? */
6490
0
  default:
6491
0
      return(NULL);
6492
355k
    }
6493
355k
    if (cur->next != NULL) {
6494
310k
  if (cur->next->type == XML_ELEMENT_NODE)
6495
216k
      return(cur->next);
6496
93.6k
  cur = cur->next;
6497
157k
  do {
6498
157k
      cur = cur->next;
6499
157k
  } while ((cur != NULL) && (cur->type != XML_ELEMENT_NODE));
6500
93.6k
  return(cur);
6501
310k
    }
6502
44.9k
    return(NULL);
6503
355k
}
6504
6505
/**
6506
 * xmlXPathNextDescendant:
6507
 * @ctxt:  the XPath Parser context
6508
 * @cur:  the current node in the traversal
6509
 *
6510
 * Traversal function for the "descendant" direction
6511
 * the descendant axis contains the descendants of the context node in document
6512
 * order; a descendant is a child or a child of a child and so on.
6513
 *
6514
 * Returns the next element following that axis
6515
 */
6516
xmlNodePtr
6517
24.6M
xmlXPathNextDescendant(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
6518
24.6M
    if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
6519
24.6M
    if (cur == NULL) {
6520
37.1k
  if (ctxt->context->node == NULL)
6521
0
      return(NULL);
6522
37.1k
  if ((ctxt->context->node->type == XML_ATTRIBUTE_NODE) ||
6523
37.1k
      (ctxt->context->node->type == XML_NAMESPACE_DECL))
6524
0
      return(NULL);
6525
6526
37.1k
        if (ctxt->context->node == (xmlNodePtr) ctxt->context->doc)
6527
5.35k
      return(ctxt->context->doc->children);
6528
31.7k
        return(ctxt->context->node->children);
6529
37.1k
    }
6530
6531
24.6M
    if (cur->type == XML_NAMESPACE_DECL)
6532
0
        return(NULL);
6533
24.6M
    if (cur->children != NULL) {
6534
  /*
6535
   * Do not descend on entities declarations
6536
   */
6537
1.51M
  if (cur->children->type != XML_ENTITY_DECL) {
6538
1.51M
      cur = cur->children;
6539
      /*
6540
       * Skip DTDs
6541
       */
6542
1.51M
      if (cur->type != XML_DTD_NODE)
6543
1.51M
    return(cur);
6544
1.51M
  }
6545
1.51M
    }
6546
6547
23.1M
    if (cur == ctxt->context->node) return(NULL);
6548
6549
23.1M
    while (cur->next != NULL) {
6550
22.6M
  cur = cur->next;
6551
22.6M
  if ((cur->type != XML_ENTITY_DECL) &&
6552
22.6M
      (cur->type != XML_DTD_NODE))
6553
22.6M
      return(cur);
6554
22.6M
    }
6555
6556
1.53M
    do {
6557
1.53M
        cur = cur->parent;
6558
1.53M
  if (cur == NULL) break;
6559
1.53M
  if (cur == ctxt->context->node) return(NULL);
6560
1.50M
  if (cur->next != NULL) {
6561
470k
      cur = cur->next;
6562
470k
      return(cur);
6563
470k
  }
6564
1.50M
    } while (cur != NULL);
6565
0
    return(cur);
6566
494k
}
6567
6568
/**
6569
 * xmlXPathNextDescendantOrSelf:
6570
 * @ctxt:  the XPath Parser context
6571
 * @cur:  the current node in the traversal
6572
 *
6573
 * Traversal function for the "descendant-or-self" direction
6574
 * the descendant-or-self axis contains the context node and the descendants
6575
 * of the context node in document order; thus the context node is the first
6576
 * node on the axis, and the first child of the context node is the second node
6577
 * on the axis
6578
 *
6579
 * Returns the next element following that axis
6580
 */
6581
xmlNodePtr
6582
17.2M
xmlXPathNextDescendantOrSelf(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
6583
17.2M
    if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
6584
17.2M
    if (cur == NULL)
6585
11.4k
        return(ctxt->context->node);
6586
6587
17.2M
    if (ctxt->context->node == NULL)
6588
0
        return(NULL);
6589
17.2M
    if ((ctxt->context->node->type == XML_ATTRIBUTE_NODE) ||
6590
17.2M
        (ctxt->context->node->type == XML_NAMESPACE_DECL))
6591
0
        return(NULL);
6592
6593
17.2M
    return(xmlXPathNextDescendant(ctxt, cur));
6594
17.2M
}
6595
6596
/**
6597
 * xmlXPathNextParent:
6598
 * @ctxt:  the XPath Parser context
6599
 * @cur:  the current node in the traversal
6600
 *
6601
 * Traversal function for the "parent" direction
6602
 * The parent axis contains the parent of the context node, if there is one.
6603
 *
6604
 * Returns the next element following that axis
6605
 */
6606
xmlNodePtr
6607
3.27M
xmlXPathNextParent(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
6608
3.27M
    if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
6609
    /*
6610
     * the parent of an attribute or namespace node is the element
6611
     * to which the attribute or namespace node is attached
6612
     * Namespace handling !!!
6613
     */
6614
3.27M
    if (cur == NULL) {
6615
1.63M
  if (ctxt->context->node == NULL) return(NULL);
6616
1.63M
  switch (ctxt->context->node->type) {
6617
878k
            case XML_ELEMENT_NODE:
6618
1.57M
            case XML_TEXT_NODE:
6619
1.61M
            case XML_CDATA_SECTION_NODE:
6620
1.61M
            case XML_ENTITY_REF_NODE:
6621
1.61M
            case XML_ENTITY_NODE:
6622
1.63M
            case XML_PI_NODE:
6623
1.63M
            case XML_COMMENT_NODE:
6624
1.63M
            case XML_NOTATION_NODE:
6625
1.63M
            case XML_DTD_NODE:
6626
1.63M
      case XML_ELEMENT_DECL:
6627
1.63M
      case XML_ATTRIBUTE_DECL:
6628
1.63M
      case XML_XINCLUDE_START:
6629
1.63M
      case XML_XINCLUDE_END:
6630
1.63M
      case XML_ENTITY_DECL:
6631
1.63M
    if (ctxt->context->node->parent == NULL)
6632
0
        return((xmlNodePtr) ctxt->context->doc);
6633
1.63M
    if ((ctxt->context->node->parent->type == XML_ELEMENT_NODE) &&
6634
1.63M
        ((ctxt->context->node->parent->name[0] == ' ') ||
6635
1.63M
         (xmlStrEqual(ctxt->context->node->parent->name,
6636
1.63M
         BAD_CAST "fake node libxslt"))))
6637
0
        return(NULL);
6638
1.63M
    return(ctxt->context->node->parent);
6639
0
            case XML_ATTRIBUTE_NODE: {
6640
0
    xmlAttrPtr att = (xmlAttrPtr) ctxt->context->node;
6641
6642
0
    return(att->parent);
6643
1.63M
      }
6644
2.67k
            case XML_DOCUMENT_NODE:
6645
2.67k
            case XML_DOCUMENT_TYPE_NODE:
6646
2.67k
            case XML_DOCUMENT_FRAG_NODE:
6647
2.67k
            case XML_HTML_DOCUMENT_NODE:
6648
2.67k
                return(NULL);
6649
0
      case XML_NAMESPACE_DECL: {
6650
0
    xmlNsPtr ns = (xmlNsPtr) ctxt->context->node;
6651
6652
0
    if ((ns->next != NULL) &&
6653
0
        (ns->next->type != XML_NAMESPACE_DECL))
6654
0
        return((xmlNodePtr) ns->next);
6655
0
                return(NULL);
6656
0
      }
6657
1.63M
  }
6658
1.63M
    }
6659
1.63M
    return(NULL);
6660
3.27M
}
6661
6662
/**
6663
 * xmlXPathNextAncestor:
6664
 * @ctxt:  the XPath Parser context
6665
 * @cur:  the current node in the traversal
6666
 *
6667
 * Traversal function for the "ancestor" direction
6668
 * the ancestor axis contains the ancestors of the context node; the ancestors
6669
 * of the context node consist of the parent of context node and the parent's
6670
 * parent and so on; the nodes are ordered in reverse document order; thus the
6671
 * parent is the first node on the axis, and the parent's parent is the second
6672
 * node on the axis
6673
 *
6674
 * Returns the next element following that axis
6675
 */
6676
xmlNodePtr
6677
55
xmlXPathNextAncestor(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
6678
55
    if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
6679
    /*
6680
     * the parent of an attribute or namespace node is the element
6681
     * to which the attribute or namespace node is attached
6682
     * !!!!!!!!!!!!!
6683
     */
6684
55
    if (cur == NULL) {
6685
17
  if (ctxt->context->node == NULL) return(NULL);
6686
17
  switch (ctxt->context->node->type) {
6687
12
            case XML_ELEMENT_NODE:
6688
14
            case XML_TEXT_NODE:
6689
14
            case XML_CDATA_SECTION_NODE:
6690
14
            case XML_ENTITY_REF_NODE:
6691
14
            case XML_ENTITY_NODE:
6692
14
            case XML_PI_NODE:
6693
14
            case XML_COMMENT_NODE:
6694
14
      case XML_DTD_NODE:
6695
14
      case XML_ELEMENT_DECL:
6696
14
      case XML_ATTRIBUTE_DECL:
6697
14
      case XML_ENTITY_DECL:
6698
14
            case XML_NOTATION_NODE:
6699
14
      case XML_XINCLUDE_START:
6700
14
      case XML_XINCLUDE_END:
6701
14
    if (ctxt->context->node->parent == NULL)
6702
0
        return((xmlNodePtr) ctxt->context->doc);
6703
14
    if ((ctxt->context->node->parent->type == XML_ELEMENT_NODE) &&
6704
14
        ((ctxt->context->node->parent->name[0] == ' ') ||
6705
11
         (xmlStrEqual(ctxt->context->node->parent->name,
6706
11
         BAD_CAST "fake node libxslt"))))
6707
0
        return(NULL);
6708
14
    return(ctxt->context->node->parent);
6709
0
            case XML_ATTRIBUTE_NODE: {
6710
0
    xmlAttrPtr tmp = (xmlAttrPtr) ctxt->context->node;
6711
6712
0
    return(tmp->parent);
6713
14
      }
6714
3
            case XML_DOCUMENT_NODE:
6715
3
            case XML_DOCUMENT_TYPE_NODE:
6716
3
            case XML_DOCUMENT_FRAG_NODE:
6717
3
            case XML_HTML_DOCUMENT_NODE:
6718
3
                return(NULL);
6719
0
      case XML_NAMESPACE_DECL: {
6720
0
    xmlNsPtr ns = (xmlNsPtr) ctxt->context->node;
6721
6722
0
    if ((ns->next != NULL) &&
6723
0
        (ns->next->type != XML_NAMESPACE_DECL))
6724
0
        return((xmlNodePtr) ns->next);
6725
    /* Bad, how did that namespace end up here ? */
6726
0
                return(NULL);
6727
0
      }
6728
17
  }
6729
0
  return(NULL);
6730
17
    }
6731
38
    if (cur == ctxt->context->doc->children)
6732
11
  return((xmlNodePtr) ctxt->context->doc);
6733
27
    if (cur == (xmlNodePtr) ctxt->context->doc)
6734
14
  return(NULL);
6735
13
    switch (cur->type) {
6736
13
  case XML_ELEMENT_NODE:
6737
13
  case XML_TEXT_NODE:
6738
13
  case XML_CDATA_SECTION_NODE:
6739
13
  case XML_ENTITY_REF_NODE:
6740
13
  case XML_ENTITY_NODE:
6741
13
  case XML_PI_NODE:
6742
13
  case XML_COMMENT_NODE:
6743
13
  case XML_NOTATION_NODE:
6744
13
  case XML_DTD_NODE:
6745
13
        case XML_ELEMENT_DECL:
6746
13
        case XML_ATTRIBUTE_DECL:
6747
13
        case XML_ENTITY_DECL:
6748
13
  case XML_XINCLUDE_START:
6749
13
  case XML_XINCLUDE_END:
6750
13
      if (cur->parent == NULL)
6751
0
    return(NULL);
6752
13
      if ((cur->parent->type == XML_ELEMENT_NODE) &&
6753
13
    ((cur->parent->name[0] == ' ') ||
6754
13
     (xmlStrEqual(cur->parent->name,
6755
13
            BAD_CAST "fake node libxslt"))))
6756
0
    return(NULL);
6757
13
      return(cur->parent);
6758
0
  case XML_ATTRIBUTE_NODE: {
6759
0
      xmlAttrPtr att = (xmlAttrPtr) cur;
6760
6761
0
      return(att->parent);
6762
13
  }
6763
0
  case XML_NAMESPACE_DECL: {
6764
0
      xmlNsPtr ns = (xmlNsPtr) cur;
6765
6766
0
      if ((ns->next != NULL) &&
6767
0
          (ns->next->type != XML_NAMESPACE_DECL))
6768
0
          return((xmlNodePtr) ns->next);
6769
      /* Bad, how did that namespace end up here ? */
6770
0
            return(NULL);
6771
0
  }
6772
0
  case XML_DOCUMENT_NODE:
6773
0
  case XML_DOCUMENT_TYPE_NODE:
6774
0
  case XML_DOCUMENT_FRAG_NODE:
6775
0
  case XML_HTML_DOCUMENT_NODE:
6776
0
      return(NULL);
6777
13
    }
6778
0
    return(NULL);
6779
13
}
6780
6781
/**
6782
 * xmlXPathNextAncestorOrSelf:
6783
 * @ctxt:  the XPath Parser context
6784
 * @cur:  the current node in the traversal
6785
 *
6786
 * Traversal function for the "ancestor-or-self" direction
6787
 * he ancestor-or-self axis contains the context node and ancestors of
6788
 * the context node in reverse document order; thus the context node is
6789
 * the first node on the axis, and the context node's parent the second;
6790
 * parent here is defined the same as with the parent axis.
6791
 *
6792
 * Returns the next element following that axis
6793
 */
6794
xmlNodePtr
6795
0
xmlXPathNextAncestorOrSelf(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
6796
0
    if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
6797
0
    if (cur == NULL)
6798
0
        return(ctxt->context->node);
6799
0
    return(xmlXPathNextAncestor(ctxt, cur));
6800
0
}
6801
6802
/**
6803
 * xmlXPathNextFollowingSibling:
6804
 * @ctxt:  the XPath Parser context
6805
 * @cur:  the current node in the traversal
6806
 *
6807
 * Traversal function for the "following-sibling" direction
6808
 * The following-sibling axis contains the following siblings of the context
6809
 * node in document order.
6810
 *
6811
 * Returns the next element following that axis
6812
 */
6813
xmlNodePtr
6814
0
xmlXPathNextFollowingSibling(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
6815
0
    if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
6816
0
    if ((ctxt->context->node->type == XML_ATTRIBUTE_NODE) ||
6817
0
  (ctxt->context->node->type == XML_NAMESPACE_DECL))
6818
0
  return(NULL);
6819
0
    if (cur == (xmlNodePtr) ctxt->context->doc)
6820
0
        return(NULL);
6821
0
    if (cur == NULL)
6822
0
        return(ctxt->context->node->next);
6823
0
    return(cur->next);
6824
0
}
6825
6826
/**
6827
 * xmlXPathNextPrecedingSibling:
6828
 * @ctxt:  the XPath Parser context
6829
 * @cur:  the current node in the traversal
6830
 *
6831
 * Traversal function for the "preceding-sibling" direction
6832
 * The preceding-sibling axis contains the preceding siblings of the context
6833
 * node in reverse document order; the first preceding sibling is first on the
6834
 * axis; the sibling preceding that node is the second on the axis and so on.
6835
 *
6836
 * Returns the next element following that axis
6837
 */
6838
xmlNodePtr
6839
110k
xmlXPathNextPrecedingSibling(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
6840
110k
    if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
6841
110k
    if ((ctxt->context->node->type == XML_ATTRIBUTE_NODE) ||
6842
110k
  (ctxt->context->node->type == XML_NAMESPACE_DECL))
6843
0
  return(NULL);
6844
110k
    if (cur == (xmlNodePtr) ctxt->context->doc)
6845
0
        return(NULL);
6846
110k
    if (cur == NULL)
6847
16.7k
        return(ctxt->context->node->prev);
6848
93.2k
    if ((cur->prev != NULL) && (cur->prev->type == XML_DTD_NODE)) {
6849
0
  cur = cur->prev;
6850
0
  if (cur == NULL)
6851
0
      return(ctxt->context->node->prev);
6852
0
    }
6853
93.2k
    return(cur->prev);
6854
93.2k
}
6855
6856
/**
6857
 * xmlXPathNextFollowing:
6858
 * @ctxt:  the XPath Parser context
6859
 * @cur:  the current node in the traversal
6860
 *
6861
 * Traversal function for the "following" direction
6862
 * The following axis contains all nodes in the same document as the context
6863
 * node that are after the context node in document order, excluding any
6864
 * descendants and excluding attribute nodes and namespace nodes; the nodes
6865
 * are ordered in document order
6866
 *
6867
 * Returns the next element following that axis
6868
 */
6869
xmlNodePtr
6870
0
xmlXPathNextFollowing(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
6871
0
    if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
6872
0
    if ((cur != NULL) && (cur->type  != XML_ATTRIBUTE_NODE) &&
6873
0
        (cur->type != XML_NAMESPACE_DECL) && (cur->children != NULL))
6874
0
        return(cur->children);
6875
6876
0
    if (cur == NULL) {
6877
0
        cur = ctxt->context->node;
6878
0
        if (cur->type == XML_ATTRIBUTE_NODE) {
6879
0
            cur = cur->parent;
6880
0
        } else if (cur->type == XML_NAMESPACE_DECL) {
6881
0
            xmlNsPtr ns = (xmlNsPtr) cur;
6882
6883
0
            if ((ns->next == NULL) ||
6884
0
                (ns->next->type == XML_NAMESPACE_DECL))
6885
0
                return (NULL);
6886
0
            cur = (xmlNodePtr) ns->next;
6887
0
        }
6888
0
    }
6889
0
    if (cur == NULL) return(NULL) ; /* ERROR */
6890
0
    if (cur->next != NULL) return(cur->next) ;
6891
0
    do {
6892
0
        cur = cur->parent;
6893
0
        if (cur == NULL) break;
6894
0
        if (cur == (xmlNodePtr) ctxt->context->doc) return(NULL);
6895
0
        if (cur->next != NULL) return(cur->next);
6896
0
    } while (cur != NULL);
6897
0
    return(cur);
6898
0
}
6899
6900
/*
6901
 * xmlXPathIsAncestor:
6902
 * @ancestor:  the ancestor node
6903
 * @node:  the current node
6904
 *
6905
 * Check that @ancestor is a @node's ancestor
6906
 *
6907
 * returns 1 if @ancestor is a @node's ancestor, 0 otherwise.
6908
 */
6909
static int
6910
0
xmlXPathIsAncestor(xmlNodePtr ancestor, xmlNodePtr node) {
6911
0
    if ((ancestor == NULL) || (node == NULL)) return(0);
6912
0
    if (node->type == XML_NAMESPACE_DECL)
6913
0
        return(0);
6914
0
    if (ancestor->type == XML_NAMESPACE_DECL)
6915
0
        return(0);
6916
    /* nodes need to be in the same document */
6917
0
    if (ancestor->doc != node->doc) return(0);
6918
    /* avoid searching if ancestor or node is the root node */
6919
0
    if (ancestor == (xmlNodePtr) node->doc) return(1);
6920
0
    if (node == (xmlNodePtr) ancestor->doc) return(0);
6921
0
    while (node->parent != NULL) {
6922
0
        if (node->parent == ancestor)
6923
0
            return(1);
6924
0
  node = node->parent;
6925
0
    }
6926
0
    return(0);
6927
0
}
6928
6929
/**
6930
 * xmlXPathNextPreceding:
6931
 * @ctxt:  the XPath Parser context
6932
 * @cur:  the current node in the traversal
6933
 *
6934
 * Traversal function for the "preceding" direction
6935
 * the preceding axis contains all nodes in the same document as the context
6936
 * node that are before the context node in document order, excluding any
6937
 * ancestors and excluding attribute nodes and namespace nodes; the nodes are
6938
 * ordered in reverse document order
6939
 *
6940
 * Returns the next element following that axis
6941
 */
6942
xmlNodePtr
6943
xmlXPathNextPreceding(xmlXPathParserContextPtr ctxt, xmlNodePtr cur)
6944
0
{
6945
0
    if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
6946
0
    if (cur == NULL) {
6947
0
        cur = ctxt->context->node;
6948
0
        if (cur->type == XML_ATTRIBUTE_NODE) {
6949
0
            cur = cur->parent;
6950
0
        } else if (cur->type == XML_NAMESPACE_DECL) {
6951
0
            xmlNsPtr ns = (xmlNsPtr) cur;
6952
6953
0
            if ((ns->next == NULL) ||
6954
0
                (ns->next->type == XML_NAMESPACE_DECL))
6955
0
                return (NULL);
6956
0
            cur = (xmlNodePtr) ns->next;
6957
0
        }
6958
0
    }
6959
0
    if ((cur == NULL) || (cur->type == XML_NAMESPACE_DECL))
6960
0
  return (NULL);
6961
0
    if ((cur->prev != NULL) && (cur->prev->type == XML_DTD_NODE))
6962
0
  cur = cur->prev;
6963
0
    do {
6964
0
        if (cur->prev != NULL) {
6965
0
            for (cur = cur->prev; cur->last != NULL; cur = cur->last) ;
6966
0
            return (cur);
6967
0
        }
6968
6969
0
        cur = cur->parent;
6970
0
        if (cur == NULL)
6971
0
            return (NULL);
6972
0
        if (cur == ctxt->context->doc->children)
6973
0
            return (NULL);
6974
0
    } while (xmlXPathIsAncestor(cur, ctxt->context->node));
6975
0
    return (cur);
6976
0
}
6977
6978
/**
6979
 * xmlXPathNextPrecedingInternal:
6980
 * @ctxt:  the XPath Parser context
6981
 * @cur:  the current node in the traversal
6982
 *
6983
 * Traversal function for the "preceding" direction
6984
 * the preceding axis contains all nodes in the same document as the context
6985
 * node that are before the context node in document order, excluding any
6986
 * ancestors and excluding attribute nodes and namespace nodes; the nodes are
6987
 * ordered in reverse document order
6988
 * This is a faster implementation but internal only since it requires a
6989
 * state kept in the parser context: ctxt->ancestor.
6990
 *
6991
 * Returns the next element following that axis
6992
 */
6993
static xmlNodePtr
6994
xmlXPathNextPrecedingInternal(xmlXPathParserContextPtr ctxt,
6995
                              xmlNodePtr cur)
6996
532k
{
6997
532k
    if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
6998
532k
    if (cur == NULL) {
6999
1.49k
        cur = ctxt->context->node;
7000
1.49k
        if (cur == NULL)
7001
0
            return (NULL);
7002
1.49k
        if (cur->type == XML_ATTRIBUTE_NODE) {
7003
0
            cur = cur->parent;
7004
1.49k
        } else if (cur->type == XML_NAMESPACE_DECL) {
7005
0
            xmlNsPtr ns = (xmlNsPtr) cur;
7006
7007
0
            if ((ns->next == NULL) ||
7008
0
                (ns->next->type == XML_NAMESPACE_DECL))
7009
0
                return (NULL);
7010
0
            cur = (xmlNodePtr) ns->next;
7011
0
        }
7012
1.49k
        ctxt->ancestor = cur->parent;
7013
1.49k
    }
7014
532k
    if (cur->type == XML_NAMESPACE_DECL)
7015
0
        return(NULL);
7016
532k
    if ((cur->prev != NULL) && (cur->prev->type == XML_DTD_NODE))
7017
0
  cur = cur->prev;
7018
541k
    while (cur->prev == NULL) {
7019
266k
        cur = cur->parent;
7020
266k
        if (cur == NULL)
7021
6
            return (NULL);
7022
266k
        if (cur == ctxt->context->doc->children)
7023
1.48k
            return (NULL);
7024
265k
        if (cur != ctxt->ancestor)
7025
256k
            return (cur);
7026
8.32k
        ctxt->ancestor = cur->parent;
7027
8.32k
    }
7028
274k
    cur = cur->prev;
7029
532k
    while (cur->last != NULL)
7030
257k
        cur = cur->last;
7031
274k
    return (cur);
7032
532k
}
7033
7034
/**
7035
 * xmlXPathNextNamespace:
7036
 * @ctxt:  the XPath Parser context
7037
 * @cur:  the current attribute in the traversal
7038
 *
7039
 * Traversal function for the "namespace" direction
7040
 * the namespace axis contains the namespace nodes of the context node;
7041
 * the order of nodes on this axis is implementation-defined; the axis will
7042
 * be empty unless the context node is an element
7043
 *
7044
 * We keep the XML namespace node at the end of the list.
7045
 *
7046
 * Returns the next element following that axis
7047
 */
7048
xmlNodePtr
7049
378k
xmlXPathNextNamespace(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
7050
378k
    if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
7051
378k
    if (ctxt->context->node->type != XML_ELEMENT_NODE) return(NULL);
7052
364k
    if (cur == NULL) {
7053
72.9k
        if (ctxt->context->tmpNsList != NULL)
7054
0
      xmlFree(ctxt->context->tmpNsList);
7055
72.9k
  ctxt->context->tmpNsNr = 0;
7056
72.9k
        if (xmlGetNsListSafe(ctxt->context->doc, ctxt->context->node,
7057
72.9k
                             &ctxt->context->tmpNsList) < 0) {
7058
30
            xmlXPathPErrMemory(ctxt);
7059
30
            return(NULL);
7060
30
        }
7061
72.9k
        if (ctxt->context->tmpNsList != NULL) {
7062
291k
            while (ctxt->context->tmpNsList[ctxt->context->tmpNsNr] != NULL) {
7063
218k
                ctxt->context->tmpNsNr++;
7064
218k
            }
7065
72.9k
        }
7066
72.9k
  return((xmlNodePtr) xmlXPathXMLNamespace);
7067
72.9k
    }
7068
291k
    if (ctxt->context->tmpNsNr > 0) {
7069
218k
  return (xmlNodePtr)ctxt->context->tmpNsList[--ctxt->context->tmpNsNr];
7070
218k
    } else {
7071
72.9k
  if (ctxt->context->tmpNsList != NULL)
7072
72.9k
      xmlFree(ctxt->context->tmpNsList);
7073
72.9k
  ctxt->context->tmpNsList = NULL;
7074
72.9k
  return(NULL);
7075
72.9k
    }
7076
291k
}
7077
7078
/**
7079
 * xmlXPathNextAttribute:
7080
 * @ctxt:  the XPath Parser context
7081
 * @cur:  the current attribute in the traversal
7082
 *
7083
 * Traversal function for the "attribute" direction
7084
 * TODO: support DTD inherited default attributes
7085
 *
7086
 * Returns the next element following that axis
7087
 */
7088
xmlNodePtr
7089
111k
xmlXPathNextAttribute(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
7090
111k
    if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
7091
111k
    if (ctxt->context->node == NULL)
7092
0
  return(NULL);
7093
111k
    if (ctxt->context->node->type != XML_ELEMENT_NODE)
7094
38.1k
  return(NULL);
7095
73.4k
    if (cur == NULL) {
7096
31.5k
        if (ctxt->context->node == (xmlNodePtr) ctxt->context->doc)
7097
0
      return(NULL);
7098
31.5k
        return((xmlNodePtr)ctxt->context->node->properties);
7099
31.5k
    }
7100
41.8k
    return((xmlNodePtr)cur->next);
7101
73.4k
}
7102
7103
/************************************************************************
7104
 *                  *
7105
 *    NodeTest Functions          *
7106
 *                  *
7107
 ************************************************************************/
7108
7109
#define IS_FUNCTION     200
7110
7111
7112
/************************************************************************
7113
 *                  *
7114
 *    Implicit tree core function library     *
7115
 *                  *
7116
 ************************************************************************/
7117
7118
/**
7119
 * xmlXPathRoot:
7120
 * @ctxt:  the XPath Parser context
7121
 *
7122
 * Initialize the context to the root of the document
7123
 */
7124
void
7125
30.5k
xmlXPathRoot(xmlXPathParserContextPtr ctxt) {
7126
30.5k
    if ((ctxt == NULL) || (ctxt->context == NULL))
7127
0
  return;
7128
30.5k
    xmlXPathValuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt,
7129
30.5k
                                            (xmlNodePtr) ctxt->context->doc));
7130
30.5k
}
7131
7132
/************************************************************************
7133
 *                  *
7134
 *    The explicit core function library      *
7135
 *http://www.w3.org/Style/XSL/Group/1999/07/xpath-19990705.html#corelib *
7136
 *                  *
7137
 ************************************************************************/
7138
7139
7140
/**
7141
 * xmlXPathLastFunction:
7142
 * @ctxt:  the XPath Parser context
7143
 * @nargs:  the number of arguments
7144
 *
7145
 * Implement the last() XPath function
7146
 *    number last()
7147
 * The last function returns the number of nodes in the context node list.
7148
 */
7149
void
7150
0
xmlXPathLastFunction(xmlXPathParserContextPtr ctxt, int nargs) {
7151
0
    CHECK_ARITY(0);
7152
0
    if (ctxt->context->contextSize >= 0) {
7153
0
  xmlXPathValuePush(ctxt,
7154
0
      xmlXPathCacheNewFloat(ctxt, (double) ctxt->context->contextSize));
7155
0
    } else {
7156
0
  XP_ERROR(XPATH_INVALID_CTXT_SIZE);
7157
0
    }
7158
0
}
7159
7160
/**
7161
 * xmlXPathPositionFunction:
7162
 * @ctxt:  the XPath Parser context
7163
 * @nargs:  the number of arguments
7164
 *
7165
 * Implement the position() XPath function
7166
 *    number position()
7167
 * The position function returns the position of the context node in the
7168
 * context node list. The first position is 1, and so the last position
7169
 * will be equal to last().
7170
 */
7171
void
7172
0
xmlXPathPositionFunction(xmlXPathParserContextPtr ctxt, int nargs) {
7173
0
    CHECK_ARITY(0);
7174
0
    if (ctxt->context->proximityPosition >= 0) {
7175
0
  xmlXPathValuePush(ctxt, xmlXPathCacheNewFloat(ctxt,
7176
0
            (double) ctxt->context->proximityPosition));
7177
0
    } else {
7178
0
  XP_ERROR(XPATH_INVALID_CTXT_POSITION);
7179
0
    }
7180
0
}
7181
7182
/**
7183
 * xmlXPathCountFunction:
7184
 * @ctxt:  the XPath Parser context
7185
 * @nargs:  the number of arguments
7186
 *
7187
 * Implement the count() XPath function
7188
 *    number count(node-set)
7189
 */
7190
void
7191
0
xmlXPathCountFunction(xmlXPathParserContextPtr ctxt, int nargs) {
7192
0
    xmlXPathObjectPtr cur;
7193
7194
0
    CHECK_ARITY(1);
7195
0
    if ((ctxt->value == NULL) ||
7196
0
  ((ctxt->value->type != XPATH_NODESET) &&
7197
0
   (ctxt->value->type != XPATH_XSLT_TREE)))
7198
0
  XP_ERROR(XPATH_INVALID_TYPE);
7199
0
    cur = xmlXPathValuePop(ctxt);
7200
7201
0
    if ((cur == NULL) || (cur->nodesetval == NULL))
7202
0
  xmlXPathValuePush(ctxt, xmlXPathCacheNewFloat(ctxt, 0.0));
7203
0
    else
7204
0
  xmlXPathValuePush(ctxt, xmlXPathCacheNewFloat(ctxt,
7205
0
      (double) cur->nodesetval->nodeNr));
7206
0
    xmlXPathReleaseObject(ctxt->context, cur);
7207
0
}
7208
7209
/**
7210
 * xmlXPathGetElementsByIds:
7211
 * @doc:  the document
7212
 * @ids:  a whitespace separated list of IDs
7213
 *
7214
 * Selects elements by their unique ID.
7215
 *
7216
 * Returns a node-set of selected elements.
7217
 */
7218
static xmlNodeSetPtr
7219
39
xmlXPathGetElementsByIds (xmlDocPtr doc, const xmlChar *ids) {
7220
39
    xmlNodeSetPtr ret;
7221
39
    const xmlChar *cur = ids;
7222
39
    xmlChar *ID;
7223
39
    xmlAttrPtr attr;
7224
39
    xmlNodePtr elem = NULL;
7225
7226
39
    if (ids == NULL) return(NULL);
7227
7228
39
    ret = xmlXPathNodeSetCreate(NULL);
7229
39
    if (ret == NULL)
7230
0
        return(ret);
7231
7232
39
    while (IS_BLANK_CH(*cur)) cur++;
7233
78
    while (*cur != 0) {
7234
1.47M
  while ((!IS_BLANK_CH(*cur)) && (*cur != 0))
7235
1.47M
      cur++;
7236
7237
39
        ID = xmlStrndup(ids, cur - ids);
7238
39
  if (ID == NULL) {
7239
0
            xmlXPathFreeNodeSet(ret);
7240
0
            return(NULL);
7241
0
        }
7242
        /*
7243
         * We used to check the fact that the value passed
7244
         * was an NCName, but this generated much troubles for
7245
         * me and Aleksey Sanin, people blatantly violated that
7246
         * constraint, like Visa3D spec.
7247
         * if (xmlValidateNCName(ID, 1) == 0)
7248
         */
7249
39
        attr = xmlGetID(doc, ID);
7250
39
        xmlFree(ID);
7251
39
        if (attr != NULL) {
7252
0
            if (attr->type == XML_ATTRIBUTE_NODE)
7253
0
                elem = attr->parent;
7254
0
            else if (attr->type == XML_ELEMENT_NODE)
7255
0
                elem = (xmlNodePtr) attr;
7256
0
            else
7257
0
                elem = NULL;
7258
0
            if (elem != NULL) {
7259
0
                if (xmlXPathNodeSetAdd(ret, elem) < 0) {
7260
0
                    xmlXPathFreeNodeSet(ret);
7261
0
                    return(NULL);
7262
0
                }
7263
0
            }
7264
0
        }
7265
7266
39
  while (IS_BLANK_CH(*cur)) cur++;
7267
39
  ids = cur;
7268
39
    }
7269
39
    return(ret);
7270
39
}
7271
7272
/**
7273
 * xmlXPathIdFunction:
7274
 * @ctxt:  the XPath Parser context
7275
 * @nargs:  the number of arguments
7276
 *
7277
 * Implement the id() XPath function
7278
 *    node-set id(object)
7279
 * The id function selects elements by their unique ID
7280
 * (see [5.2.1 Unique IDs]). When the argument to id is of type node-set,
7281
 * then the result is the union of the result of applying id to the
7282
 * string value of each of the nodes in the argument node-set. When the
7283
 * argument to id is of any other type, the argument is converted to a
7284
 * string as if by a call to the string function; the string is split
7285
 * into a whitespace-separated list of tokens (whitespace is any sequence
7286
 * of characters matching the production S); the result is a node-set
7287
 * containing the elements in the same document as the context node that
7288
 * have a unique ID equal to any of the tokens in the list.
7289
 */
7290
void
7291
39
xmlXPathIdFunction(xmlXPathParserContextPtr ctxt, int nargs) {
7292
39
    xmlChar *tokens;
7293
39
    xmlNodeSetPtr ret;
7294
39
    xmlXPathObjectPtr obj;
7295
7296
117
    CHECK_ARITY(1);
7297
117
    obj = xmlXPathValuePop(ctxt);
7298
117
    if (obj == NULL) XP_ERROR(XPATH_INVALID_OPERAND);
7299
39
    if ((obj->type == XPATH_NODESET) || (obj->type == XPATH_XSLT_TREE)) {
7300
0
  xmlNodeSetPtr ns;
7301
0
  int i;
7302
7303
0
  ret = xmlXPathNodeSetCreate(NULL);
7304
0
        if (ret == NULL)
7305
0
            xmlXPathPErrMemory(ctxt);
7306
7307
0
  if (obj->nodesetval != NULL) {
7308
0
      for (i = 0; i < obj->nodesetval->nodeNr; i++) {
7309
0
    tokens =
7310
0
        xmlXPathCastNodeToString(obj->nodesetval->nodeTab[i]);
7311
0
                if (tokens == NULL)
7312
0
                    xmlXPathPErrMemory(ctxt);
7313
0
    ns = xmlXPathGetElementsByIds(ctxt->context->doc, tokens);
7314
0
                if (ns == NULL)
7315
0
                    xmlXPathPErrMemory(ctxt);
7316
0
    ret = xmlXPathNodeSetMerge(ret, ns);
7317
0
                if (ret == NULL)
7318
0
                    xmlXPathPErrMemory(ctxt);
7319
0
    xmlXPathFreeNodeSet(ns);
7320
0
    if (tokens != NULL)
7321
0
        xmlFree(tokens);
7322
0
      }
7323
0
  }
7324
0
  xmlXPathReleaseObject(ctxt->context, obj);
7325
0
  xmlXPathValuePush(ctxt, xmlXPathCacheWrapNodeSet(ctxt, ret));
7326
0
  return;
7327
0
    }
7328
39
    tokens = xmlXPathCastToString(obj);
7329
39
    if (tokens == NULL)
7330
0
        xmlXPathPErrMemory(ctxt);
7331
39
    xmlXPathReleaseObject(ctxt->context, obj);
7332
39
    ret = xmlXPathGetElementsByIds(ctxt->context->doc, tokens);
7333
39
    if (ret == NULL)
7334
0
        xmlXPathPErrMemory(ctxt);
7335
39
    xmlFree(tokens);
7336
39
    xmlXPathValuePush(ctxt, xmlXPathCacheWrapNodeSet(ctxt, ret));
7337
39
}
7338
7339
/**
7340
 * xmlXPathLocalNameFunction:
7341
 * @ctxt:  the XPath Parser context
7342
 * @nargs:  the number of arguments
7343
 *
7344
 * Implement the local-name() XPath function
7345
 *    string local-name(node-set?)
7346
 * The local-name function returns a string containing the local part
7347
 * of the name of the node in the argument node-set that is first in
7348
 * document order. If the node-set is empty or the first node has no
7349
 * name, an empty string is returned. If the argument is omitted it
7350
 * defaults to the context node.
7351
 */
7352
void
7353
0
xmlXPathLocalNameFunction(xmlXPathParserContextPtr ctxt, int nargs) {
7354
0
    xmlXPathObjectPtr cur;
7355
7356
0
    if (ctxt == NULL) return;
7357
7358
0
    if (nargs == 0) {
7359
0
  xmlXPathValuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt, ctxt->context->node));
7360
0
  nargs = 1;
7361
0
    }
7362
7363
0
    CHECK_ARITY(1);
7364
0
    if ((ctxt->value == NULL) ||
7365
0
  ((ctxt->value->type != XPATH_NODESET) &&
7366
0
   (ctxt->value->type != XPATH_XSLT_TREE)))
7367
0
  XP_ERROR(XPATH_INVALID_TYPE);
7368
0
    cur = xmlXPathValuePop(ctxt);
7369
7370
0
    if ((cur->nodesetval == NULL) || (cur->nodesetval->nodeNr == 0)) {
7371
0
  xmlXPathValuePush(ctxt, xmlXPathCacheNewCString(ctxt, ""));
7372
0
    } else {
7373
0
  int i = 0; /* Should be first in document order !!!!! */
7374
0
  switch (cur->nodesetval->nodeTab[i]->type) {
7375
0
  case XML_ELEMENT_NODE:
7376
0
  case XML_ATTRIBUTE_NODE:
7377
0
  case XML_PI_NODE:
7378
0
      if (cur->nodesetval->nodeTab[i]->name[0] == ' ')
7379
0
    xmlXPathValuePush(ctxt, xmlXPathCacheNewCString(ctxt, ""));
7380
0
      else
7381
0
    xmlXPathValuePush(ctxt, xmlXPathCacheNewString(ctxt,
7382
0
      cur->nodesetval->nodeTab[i]->name));
7383
0
      break;
7384
0
  case XML_NAMESPACE_DECL:
7385
0
      xmlXPathValuePush(ctxt, xmlXPathCacheNewString(ctxt,
7386
0
      ((xmlNsPtr)cur->nodesetval->nodeTab[i])->prefix));
7387
0
      break;
7388
0
  default:
7389
0
      xmlXPathValuePush(ctxt, xmlXPathCacheNewCString(ctxt, ""));
7390
0
  }
7391
0
    }
7392
0
    xmlXPathReleaseObject(ctxt->context, cur);
7393
0
}
7394
7395
/**
7396
 * xmlXPathNamespaceURIFunction:
7397
 * @ctxt:  the XPath Parser context
7398
 * @nargs:  the number of arguments
7399
 *
7400
 * Implement the namespace-uri() XPath function
7401
 *    string namespace-uri(node-set?)
7402
 * The namespace-uri function returns a string containing the
7403
 * namespace URI of the expanded name of the node in the argument
7404
 * node-set that is first in document order. If the node-set is empty,
7405
 * the first node has no name, or the expanded name has no namespace
7406
 * URI, an empty string is returned. If the argument is omitted it
7407
 * defaults to the context node.
7408
 */
7409
void
7410
0
xmlXPathNamespaceURIFunction(xmlXPathParserContextPtr ctxt, int nargs) {
7411
0
    xmlXPathObjectPtr cur;
7412
7413
0
    if (ctxt == NULL) return;
7414
7415
0
    if (nargs == 0) {
7416
0
  xmlXPathValuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt, ctxt->context->node));
7417
0
  nargs = 1;
7418
0
    }
7419
0
    CHECK_ARITY(1);
7420
0
    if ((ctxt->value == NULL) ||
7421
0
  ((ctxt->value->type != XPATH_NODESET) &&
7422
0
   (ctxt->value->type != XPATH_XSLT_TREE)))
7423
0
  XP_ERROR(XPATH_INVALID_TYPE);
7424
0
    cur = xmlXPathValuePop(ctxt);
7425
7426
0
    if ((cur->nodesetval == NULL) || (cur->nodesetval->nodeNr == 0)) {
7427
0
  xmlXPathValuePush(ctxt, xmlXPathCacheNewCString(ctxt, ""));
7428
0
    } else {
7429
0
  int i = 0; /* Should be first in document order !!!!! */
7430
0
  switch (cur->nodesetval->nodeTab[i]->type) {
7431
0
  case XML_ELEMENT_NODE:
7432
0
  case XML_ATTRIBUTE_NODE:
7433
0
      if (cur->nodesetval->nodeTab[i]->ns == NULL)
7434
0
    xmlXPathValuePush(ctxt, xmlXPathCacheNewCString(ctxt, ""));
7435
0
      else
7436
0
    xmlXPathValuePush(ctxt, xmlXPathCacheNewString(ctxt,
7437
0
        cur->nodesetval->nodeTab[i]->ns->href));
7438
0
      break;
7439
0
  default:
7440
0
      xmlXPathValuePush(ctxt, xmlXPathCacheNewCString(ctxt, ""));
7441
0
  }
7442
0
    }
7443
0
    xmlXPathReleaseObject(ctxt->context, cur);
7444
0
}
7445
7446
/**
7447
 * xmlXPathNameFunction:
7448
 * @ctxt:  the XPath Parser context
7449
 * @nargs:  the number of arguments
7450
 *
7451
 * Implement the name() XPath function
7452
 *    string name(node-set?)
7453
 * The name function returns a string containing a QName representing
7454
 * the name of the node in the argument node-set that is first in document
7455
 * order. The QName must represent the name with respect to the namespace
7456
 * declarations in effect on the node whose name is being represented.
7457
 * Typically, this will be the form in which the name occurred in the XML
7458
 * source. This need not be the case if there are namespace declarations
7459
 * in effect on the node that associate multiple prefixes with the same
7460
 * namespace. However, an implementation may include information about
7461
 * the original prefix in its representation of nodes; in this case, an
7462
 * implementation can ensure that the returned string is always the same
7463
 * as the QName used in the XML source. If the argument it omitted it
7464
 * defaults to the context node.
7465
 * Libxml keep the original prefix so the "real qualified name" used is
7466
 * returned.
7467
 */
7468
static void
7469
xmlXPathNameFunction(xmlXPathParserContextPtr ctxt, int nargs)
7470
0
{
7471
0
    xmlXPathObjectPtr cur;
7472
7473
0
    if (nargs == 0) {
7474
0
  xmlXPathValuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt, ctxt->context->node));
7475
0
        nargs = 1;
7476
0
    }
7477
7478
0
    CHECK_ARITY(1);
7479
0
    if ((ctxt->value == NULL) ||
7480
0
        ((ctxt->value->type != XPATH_NODESET) &&
7481
0
         (ctxt->value->type != XPATH_XSLT_TREE)))
7482
0
        XP_ERROR(XPATH_INVALID_TYPE);
7483
0
    cur = xmlXPathValuePop(ctxt);
7484
7485
0
    if ((cur->nodesetval == NULL) || (cur->nodesetval->nodeNr == 0)) {
7486
0
        xmlXPathValuePush(ctxt, xmlXPathCacheNewCString(ctxt, ""));
7487
0
    } else {
7488
0
        int i = 0;              /* Should be first in document order !!!!! */
7489
7490
0
        switch (cur->nodesetval->nodeTab[i]->type) {
7491
0
            case XML_ELEMENT_NODE:
7492
0
            case XML_ATTRIBUTE_NODE:
7493
0
    if (cur->nodesetval->nodeTab[i]->name[0] == ' ')
7494
0
        xmlXPathValuePush(ctxt,
7495
0
      xmlXPathCacheNewCString(ctxt, ""));
7496
0
    else if ((cur->nodesetval->nodeTab[i]->ns == NULL) ||
7497
0
                         (cur->nodesetval->nodeTab[i]->ns->prefix == NULL)) {
7498
0
        xmlXPathValuePush(ctxt, xmlXPathCacheNewString(ctxt,
7499
0
          cur->nodesetval->nodeTab[i]->name));
7500
0
    } else {
7501
0
        xmlChar *fullname;
7502
7503
0
        fullname = xmlBuildQName(cur->nodesetval->nodeTab[i]->name,
7504
0
             cur->nodesetval->nodeTab[i]->ns->prefix,
7505
0
             NULL, 0);
7506
0
        if (fullname == cur->nodesetval->nodeTab[i]->name)
7507
0
      fullname = xmlStrdup(cur->nodesetval->nodeTab[i]->name);
7508
0
        if (fullname == NULL)
7509
0
                        xmlXPathPErrMemory(ctxt);
7510
0
        xmlXPathValuePush(ctxt, xmlXPathCacheWrapString(ctxt, fullname));
7511
0
                }
7512
0
                break;
7513
0
            default:
7514
0
    xmlXPathValuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt,
7515
0
        cur->nodesetval->nodeTab[i]));
7516
0
                xmlXPathLocalNameFunction(ctxt, 1);
7517
0
        }
7518
0
    }
7519
0
    xmlXPathReleaseObject(ctxt->context, cur);
7520
0
}
7521
7522
7523
/**
7524
 * xmlXPathStringFunction:
7525
 * @ctxt:  the XPath Parser context
7526
 * @nargs:  the number of arguments
7527
 *
7528
 * Implement the string() XPath function
7529
 *    string string(object?)
7530
 * The string function converts an object to a string as follows:
7531
 *    - A node-set is converted to a string by returning the value of
7532
 *      the node in the node-set that is first in document order.
7533
 *      If the node-set is empty, an empty string is returned.
7534
 *    - A number is converted to a string as follows
7535
 *      + NaN is converted to the string NaN
7536
 *      + positive zero is converted to the string 0
7537
 *      + negative zero is converted to the string 0
7538
 *      + positive infinity is converted to the string Infinity
7539
 *      + negative infinity is converted to the string -Infinity
7540
 *      + if the number is an integer, the number is represented in
7541
 *        decimal form as a Number with no decimal point and no leading
7542
 *        zeros, preceded by a minus sign (-) if the number is negative
7543
 *      + otherwise, the number is represented in decimal form as a
7544
 *        Number including a decimal point with at least one digit
7545
 *        before the decimal point and at least one digit after the
7546
 *        decimal point, preceded by a minus sign (-) if the number
7547
 *        is negative; there must be no leading zeros before the decimal
7548
 *        point apart possibly from the one required digit immediately
7549
 *        before the decimal point; beyond the one required digit
7550
 *        after the decimal point there must be as many, but only as
7551
 *        many, more digits as are needed to uniquely distinguish the
7552
 *        number from all other IEEE 754 numeric values.
7553
 *    - The boolean false value is converted to the string false.
7554
 *      The boolean true value is converted to the string true.
7555
 *
7556
 * If the argument is omitted, it defaults to a node-set with the
7557
 * context node as its only member.
7558
 */
7559
void
7560
154k
xmlXPathStringFunction(xmlXPathParserContextPtr ctxt, int nargs) {
7561
154k
    xmlXPathObjectPtr cur;
7562
154k
    xmlChar *stringval;
7563
7564
154k
    if (ctxt == NULL) return;
7565
154k
    if (nargs == 0) {
7566
0
        stringval = xmlXPathCastNodeToString(ctxt->context->node);
7567
0
        if (stringval == NULL)
7568
0
            xmlXPathPErrMemory(ctxt);
7569
0
        xmlXPathValuePush(ctxt, xmlXPathCacheWrapString(ctxt, stringval));
7570
0
  return;
7571
0
    }
7572
7573
617k
    CHECK_ARITY(1);
7574
617k
    cur = xmlXPathValuePop(ctxt);
7575
617k
    if (cur == NULL) XP_ERROR(XPATH_INVALID_OPERAND);
7576
154k
    if (cur->type != XPATH_STRING) {
7577
79.6k
        stringval = xmlXPathCastToString(cur);
7578
79.6k
        if (stringval == NULL)
7579
3
            xmlXPathPErrMemory(ctxt);
7580
79.6k
        xmlXPathReleaseObject(ctxt->context, cur);
7581
79.6k
        cur = xmlXPathCacheWrapString(ctxt, stringval);
7582
79.6k
    }
7583
154k
    xmlXPathValuePush(ctxt, cur);
7584
154k
}
7585
7586
/**
7587
 * xmlXPathStringLengthFunction:
7588
 * @ctxt:  the XPath Parser context
7589
 * @nargs:  the number of arguments
7590
 *
7591
 * Implement the string-length() XPath function
7592
 *    number string-length(string?)
7593
 * The string-length returns the number of characters in the string
7594
 * (see [3.6 Strings]). If the argument is omitted, it defaults to
7595
 * the context node converted to a string, in other words the value
7596
 * of the context node.
7597
 */
7598
void
7599
0
xmlXPathStringLengthFunction(xmlXPathParserContextPtr ctxt, int nargs) {
7600
0
    xmlXPathObjectPtr cur;
7601
7602
0
    if (nargs == 0) {
7603
0
        if ((ctxt == NULL) || (ctxt->context == NULL))
7604
0
      return;
7605
0
  if (ctxt->context->node == NULL) {
7606
0
      xmlXPathValuePush(ctxt, xmlXPathCacheNewFloat(ctxt, 0));
7607
0
  } else {
7608
0
      xmlChar *content;
7609
7610
0
      content = xmlXPathCastNodeToString(ctxt->context->node);
7611
0
            if (content == NULL)
7612
0
                xmlXPathPErrMemory(ctxt);
7613
0
      xmlXPathValuePush(ctxt, xmlXPathCacheNewFloat(ctxt,
7614
0
    xmlUTF8Strlen(content)));
7615
0
      xmlFree(content);
7616
0
  }
7617
0
  return;
7618
0
    }
7619
0
    CHECK_ARITY(1);
7620
0
    CAST_TO_STRING;
7621
0
    CHECK_TYPE(XPATH_STRING);
7622
0
    cur = xmlXPathValuePop(ctxt);
7623
0
    xmlXPathValuePush(ctxt, xmlXPathCacheNewFloat(ctxt,
7624
0
  xmlUTF8Strlen(cur->stringval)));
7625
0
    xmlXPathReleaseObject(ctxt->context, cur);
7626
0
}
7627
7628
/**
7629
 * xmlXPathConcatFunction:
7630
 * @ctxt:  the XPath Parser context
7631
 * @nargs:  the number of arguments
7632
 *
7633
 * Implement the concat() XPath function
7634
 *    string concat(string, string, string*)
7635
 * The concat function returns the concatenation of its arguments.
7636
 */
7637
void
7638
210
xmlXPathConcatFunction(xmlXPathParserContextPtr ctxt, int nargs) {
7639
210
    xmlXPathObjectPtr cur, newobj;
7640
210
    xmlChar *tmp;
7641
7642
210
    if (ctxt == NULL) return;
7643
210
    if (nargs < 2) {
7644
0
  CHECK_ARITY(2);
7645
0
    }
7646
7647
210
    CAST_TO_STRING;
7648
210
    cur = xmlXPathValuePop(ctxt);
7649
210
    if ((cur == NULL) || (cur->type != XPATH_STRING)) {
7650
0
  xmlXPathReleaseObject(ctxt->context, cur);
7651
0
  return;
7652
0
    }
7653
210
    nargs--;
7654
7655
1.05k
    while (nargs > 0) {
7656
840
  CAST_TO_STRING;
7657
840
  newobj = xmlXPathValuePop(ctxt);
7658
840
  if ((newobj == NULL) || (newobj->type != XPATH_STRING)) {
7659
0
      xmlXPathReleaseObject(ctxt->context, newobj);
7660
0
      xmlXPathReleaseObject(ctxt->context, cur);
7661
0
      XP_ERROR(XPATH_INVALID_TYPE);
7662
0
  }
7663
840
  tmp = xmlStrcat(newobj->stringval, cur->stringval);
7664
840
        if (tmp == NULL)
7665
0
            xmlXPathPErrMemory(ctxt);
7666
840
  newobj->stringval = cur->stringval;
7667
840
  cur->stringval = tmp;
7668
840
  xmlXPathReleaseObject(ctxt->context, newobj);
7669
840
  nargs--;
7670
840
    }
7671
210
    xmlXPathValuePush(ctxt, cur);
7672
210
}
7673
7674
/**
7675
 * xmlXPathContainsFunction:
7676
 * @ctxt:  the XPath Parser context
7677
 * @nargs:  the number of arguments
7678
 *
7679
 * Implement the contains() XPath function
7680
 *    boolean contains(string, string)
7681
 * The contains function returns true if the first argument string
7682
 * contains the second argument string, and otherwise returns false.
7683
 */
7684
void
7685
0
xmlXPathContainsFunction(xmlXPathParserContextPtr ctxt, int nargs) {
7686
0
    xmlXPathObjectPtr hay, needle;
7687
7688
0
    CHECK_ARITY(2);
7689
0
    CAST_TO_STRING;
7690
0
    CHECK_TYPE(XPATH_STRING);
7691
0
    needle = xmlXPathValuePop(ctxt);
7692
0
    CAST_TO_STRING;
7693
0
    hay = xmlXPathValuePop(ctxt);
7694
7695
0
    if ((hay == NULL) || (hay->type != XPATH_STRING)) {
7696
0
  xmlXPathReleaseObject(ctxt->context, hay);
7697
0
  xmlXPathReleaseObject(ctxt->context, needle);
7698
0
  XP_ERROR(XPATH_INVALID_TYPE);
7699
0
    }
7700
0
    if (xmlStrstr(hay->stringval, needle->stringval))
7701
0
  xmlXPathValuePush(ctxt, xmlXPathCacheNewBoolean(ctxt, 1));
7702
0
    else
7703
0
  xmlXPathValuePush(ctxt, xmlXPathCacheNewBoolean(ctxt, 0));
7704
0
    xmlXPathReleaseObject(ctxt->context, hay);
7705
0
    xmlXPathReleaseObject(ctxt->context, needle);
7706
0
}
7707
7708
/**
7709
 * xmlXPathStartsWithFunction:
7710
 * @ctxt:  the XPath Parser context
7711
 * @nargs:  the number of arguments
7712
 *
7713
 * Implement the starts-with() XPath function
7714
 *    boolean starts-with(string, string)
7715
 * The starts-with function returns true if the first argument string
7716
 * starts with the second argument string, and otherwise returns false.
7717
 */
7718
void
7719
709
xmlXPathStartsWithFunction(xmlXPathParserContextPtr ctxt, int nargs) {
7720
709
    xmlXPathObjectPtr hay, needle;
7721
709
    int n;
7722
7723
2.12k
    CHECK_ARITY(2);
7724
2.12k
    CAST_TO_STRING;
7725
2.12k
    CHECK_TYPE(XPATH_STRING);
7726
709
    needle = xmlXPathValuePop(ctxt);
7727
709
    CAST_TO_STRING;
7728
709
    hay = xmlXPathValuePop(ctxt);
7729
7730
709
    if ((hay == NULL) || (hay->type != XPATH_STRING)) {
7731
0
  xmlXPathReleaseObject(ctxt->context, hay);
7732
0
  xmlXPathReleaseObject(ctxt->context, needle);
7733
0
  XP_ERROR(XPATH_INVALID_TYPE);
7734
0
    }
7735
709
    n = xmlStrlen(needle->stringval);
7736
709
    if (xmlStrncmp(hay->stringval, needle->stringval, n))
7737
0
        xmlXPathValuePush(ctxt, xmlXPathCacheNewBoolean(ctxt, 0));
7738
709
    else
7739
709
        xmlXPathValuePush(ctxt, xmlXPathCacheNewBoolean(ctxt, 1));
7740
709
    xmlXPathReleaseObject(ctxt->context, hay);
7741
709
    xmlXPathReleaseObject(ctxt->context, needle);
7742
709
}
7743
7744
/**
7745
 * xmlXPathSubstringFunction:
7746
 * @ctxt:  the XPath Parser context
7747
 * @nargs:  the number of arguments
7748
 *
7749
 * Implement the substring() XPath function
7750
 *    string substring(string, number, number?)
7751
 * The substring function returns the substring of the first argument
7752
 * starting at the position specified in the second argument with
7753
 * length specified in the third argument. For example,
7754
 * substring("12345",2,3) returns "234". If the third argument is not
7755
 * specified, it returns the substring starting at the position specified
7756
 * in the second argument and continuing to the end of the string. For
7757
 * example, substring("12345",2) returns "2345".  More precisely, each
7758
 * character in the string (see [3.6 Strings]) is considered to have a
7759
 * numeric position: the position of the first character is 1, the position
7760
 * of the second character is 2 and so on. The returned substring contains
7761
 * those characters for which the position of the character is greater than
7762
 * or equal to the second argument and, if the third argument is specified,
7763
 * less than the sum of the second and third arguments; the comparisons
7764
 * and addition used for the above follow the standard IEEE 754 rules. Thus:
7765
 *  - substring("12345", 1.5, 2.6) returns "234"
7766
 *  - substring("12345", 0, 3) returns "12"
7767
 *  - substring("12345", 0 div 0, 3) returns ""
7768
 *  - substring("12345", 1, 0 div 0) returns ""
7769
 *  - substring("12345", -42, 1 div 0) returns "12345"
7770
 *  - substring("12345", -1 div 0, 1 div 0) returns ""
7771
 */
7772
void
7773
0
xmlXPathSubstringFunction(xmlXPathParserContextPtr ctxt, int nargs) {
7774
0
    xmlXPathObjectPtr str, start, len;
7775
0
    double le=0, in;
7776
0
    int i = 1, j = INT_MAX;
7777
7778
0
    if (nargs < 2) {
7779
0
  CHECK_ARITY(2);
7780
0
    }
7781
0
    if (nargs > 3) {
7782
0
  CHECK_ARITY(3);
7783
0
    }
7784
    /*
7785
     * take care of possible last (position) argument
7786
    */
7787
0
    if (nargs == 3) {
7788
0
  CAST_TO_NUMBER;
7789
0
  CHECK_TYPE(XPATH_NUMBER);
7790
0
  len = xmlXPathValuePop(ctxt);
7791
0
  le = len->floatval;
7792
0
  xmlXPathReleaseObject(ctxt->context, len);
7793
0
    }
7794
7795
0
    CAST_TO_NUMBER;
7796
0
    CHECK_TYPE(XPATH_NUMBER);
7797
0
    start = xmlXPathValuePop(ctxt);
7798
0
    in = start->floatval;
7799
0
    xmlXPathReleaseObject(ctxt->context, start);
7800
0
    CAST_TO_STRING;
7801
0
    CHECK_TYPE(XPATH_STRING);
7802
0
    str = xmlXPathValuePop(ctxt);
7803
7804
0
    if (!(in < INT_MAX)) { /* Logical NOT to handle NaNs */
7805
0
        i = INT_MAX;
7806
0
    } else if (in >= 1.0) {
7807
0
        i = (int)in;
7808
0
        if (in - floor(in) >= 0.5)
7809
0
            i += 1;
7810
0
    }
7811
7812
0
    if (nargs == 3) {
7813
0
        double rin, rle, end;
7814
7815
0
        rin = floor(in);
7816
0
        if (in - rin >= 0.5)
7817
0
            rin += 1.0;
7818
7819
0
        rle = floor(le);
7820
0
        if (le - rle >= 0.5)
7821
0
            rle += 1.0;
7822
7823
0
        end = rin + rle;
7824
0
        if (!(end >= 1.0)) { /* Logical NOT to handle NaNs */
7825
0
            j = 1;
7826
0
        } else if (end < INT_MAX) {
7827
0
            j = (int)end;
7828
0
        }
7829
0
    }
7830
7831
0
    i -= 1;
7832
0
    j -= 1;
7833
7834
0
    if ((i < j) && (i < xmlUTF8Strlen(str->stringval))) {
7835
0
        xmlChar *ret = xmlUTF8Strsub(str->stringval, i, j - i);
7836
0
        if (ret == NULL)
7837
0
            xmlXPathPErrMemory(ctxt);
7838
0
  xmlXPathValuePush(ctxt, xmlXPathCacheNewString(ctxt, ret));
7839
0
  xmlFree(ret);
7840
0
    } else {
7841
0
  xmlXPathValuePush(ctxt, xmlXPathCacheNewCString(ctxt, ""));
7842
0
    }
7843
7844
0
    xmlXPathReleaseObject(ctxt->context, str);
7845
0
}
7846
7847
/**
7848
 * xmlXPathSubstringBeforeFunction:
7849
 * @ctxt:  the XPath Parser context
7850
 * @nargs:  the number of arguments
7851
 *
7852
 * Implement the substring-before() XPath function
7853
 *    string substring-before(string, string)
7854
 * The substring-before function returns the substring of the first
7855
 * argument string that precedes the first occurrence of the second
7856
 * argument string in the first argument string, or the empty string
7857
 * if the first argument string does not contain the second argument
7858
 * string. For example, substring-before("1999/04/01","/") returns 1999.
7859
 */
7860
void
7861
32
xmlXPathSubstringBeforeFunction(xmlXPathParserContextPtr ctxt, int nargs) {
7862
32
    xmlXPathObjectPtr str = NULL;
7863
32
    xmlXPathObjectPtr find = NULL;
7864
32
    const xmlChar *point;
7865
32
    xmlChar *result;
7866
7867
96
    CHECK_ARITY(2);
7868
96
    CAST_TO_STRING;
7869
96
    find = xmlXPathValuePop(ctxt);
7870
96
    CAST_TO_STRING;
7871
96
    str = xmlXPathValuePop(ctxt);
7872
96
    if (ctxt->error != 0)
7873
0
        goto error;
7874
7875
32
    point = xmlStrstr(str->stringval, find->stringval);
7876
32
    if (point == NULL) {
7877
0
        result = xmlStrdup(BAD_CAST "");
7878
32
    } else {
7879
32
        result = xmlStrndup(str->stringval, point - str->stringval);
7880
32
    }
7881
32
    if (result == NULL) {
7882
0
        xmlXPathPErrMemory(ctxt);
7883
0
        goto error;
7884
0
    }
7885
32
    xmlXPathValuePush(ctxt, xmlXPathCacheWrapString(ctxt, result));
7886
7887
32
error:
7888
32
    xmlXPathReleaseObject(ctxt->context, str);
7889
32
    xmlXPathReleaseObject(ctxt->context, find);
7890
32
}
7891
7892
/**
7893
 * xmlXPathSubstringAfterFunction:
7894
 * @ctxt:  the XPath Parser context
7895
 * @nargs:  the number of arguments
7896
 *
7897
 * Implement the substring-after() XPath function
7898
 *    string substring-after(string, string)
7899
 * The substring-after function returns the substring of the first
7900
 * argument string that follows the first occurrence of the second
7901
 * argument string in the first argument string, or the empty string
7902
 * if the first argument string does not contain the second argument
7903
 * string. For example, substring-after("1999/04/01","/") returns 04/01,
7904
 * and substring-after("1999/04/01","19") returns 99/04/01.
7905
 */
7906
void
7907
183
xmlXPathSubstringAfterFunction(xmlXPathParserContextPtr ctxt, int nargs) {
7908
183
    xmlXPathObjectPtr str = NULL;
7909
183
    xmlXPathObjectPtr find = NULL;
7910
183
    const xmlChar *point;
7911
183
    xmlChar *result;
7912
7913
549
    CHECK_ARITY(2);
7914
549
    CAST_TO_STRING;
7915
549
    find = xmlXPathValuePop(ctxt);
7916
549
    CAST_TO_STRING;
7917
549
    str = xmlXPathValuePop(ctxt);
7918
549
    if (ctxt->error != 0)
7919
0
        goto error;
7920
7921
183
    point = xmlStrstr(str->stringval, find->stringval);
7922
183
    if (point == NULL) {
7923
181
        result = xmlStrdup(BAD_CAST "");
7924
181
    } else {
7925
2
        result = xmlStrdup(point + xmlStrlen(find->stringval));
7926
2
    }
7927
183
    if (result == NULL) {
7928
0
        xmlXPathPErrMemory(ctxt);
7929
0
        goto error;
7930
0
    }
7931
183
    xmlXPathValuePush(ctxt, xmlXPathCacheWrapString(ctxt, result));
7932
7933
183
error:
7934
183
    xmlXPathReleaseObject(ctxt->context, str);
7935
183
    xmlXPathReleaseObject(ctxt->context, find);
7936
183
}
7937
7938
/**
7939
 * xmlXPathNormalizeFunction:
7940
 * @ctxt:  the XPath Parser context
7941
 * @nargs:  the number of arguments
7942
 *
7943
 * Implement the normalize-space() XPath function
7944
 *    string normalize-space(string?)
7945
 * The normalize-space function returns the argument string with white
7946
 * space normalized by stripping leading and trailing whitespace
7947
 * and replacing sequences of whitespace characters by a single
7948
 * space. Whitespace characters are the same allowed by the S production
7949
 * in XML. If the argument is omitted, it defaults to the context
7950
 * node converted to a string, in other words the value of the context node.
7951
 */
7952
void
7953
0
xmlXPathNormalizeFunction(xmlXPathParserContextPtr ctxt, int nargs) {
7954
0
    xmlChar *source, *target;
7955
0
    int blank;
7956
7957
0
    if (ctxt == NULL) return;
7958
0
    if (nargs == 0) {
7959
        /* Use current context node */
7960
0
        source = xmlXPathCastNodeToString(ctxt->context->node);
7961
0
        if (source == NULL)
7962
0
            xmlXPathPErrMemory(ctxt);
7963
0
        xmlXPathValuePush(ctxt, xmlXPathCacheWrapString(ctxt, source));
7964
0
        nargs = 1;
7965
0
    }
7966
7967
0
    CHECK_ARITY(1);
7968
0
    CAST_TO_STRING;
7969
0
    CHECK_TYPE(XPATH_STRING);
7970
0
    source = ctxt->value->stringval;
7971
0
    if (source == NULL)
7972
0
        return;
7973
0
    target = source;
7974
7975
    /* Skip leading whitespaces */
7976
0
    while (IS_BLANK_CH(*source))
7977
0
        source++;
7978
7979
    /* Collapse intermediate whitespaces, and skip trailing whitespaces */
7980
0
    blank = 0;
7981
0
    while (*source) {
7982
0
        if (IS_BLANK_CH(*source)) {
7983
0
      blank = 1;
7984
0
        } else {
7985
0
            if (blank) {
7986
0
                *target++ = 0x20;
7987
0
                blank = 0;
7988
0
            }
7989
0
            *target++ = *source;
7990
0
        }
7991
0
        source++;
7992
0
    }
7993
0
    *target = 0;
7994
0
}
7995
7996
/**
7997
 * xmlXPathTranslateFunction:
7998
 * @ctxt:  the XPath Parser context
7999
 * @nargs:  the number of arguments
8000
 *
8001
 * Implement the translate() XPath function
8002
 *    string translate(string, string, string)
8003
 * The translate function returns the first argument string with
8004
 * occurrences of characters in the second argument string replaced
8005
 * by the character at the corresponding position in the third argument
8006
 * string. For example, translate("bar","abc","ABC") returns the string
8007
 * BAr. If there is a character in the second argument string with no
8008
 * character at a corresponding position in the third argument string
8009
 * (because the second argument string is longer than the third argument
8010
 * string), then occurrences of that character in the first argument
8011
 * string are removed. For example, translate("--aaa--","abc-","ABC")
8012
 * returns "AAA". If a character occurs more than once in second
8013
 * argument string, then the first occurrence determines the replacement
8014
 * character. If the third argument string is longer than the second
8015
 * argument string, then excess characters are ignored.
8016
 */
8017
void
8018
605
xmlXPathTranslateFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8019
605
    xmlXPathObjectPtr str = NULL;
8020
605
    xmlXPathObjectPtr from = NULL;
8021
605
    xmlXPathObjectPtr to = NULL;
8022
605
    xmlBufPtr target;
8023
605
    int offset, max;
8024
605
    int ch;
8025
605
    const xmlChar *point;
8026
605
    xmlChar *cptr, *content;
8027
8028
1.81k
    CHECK_ARITY(3);
8029
8030
1.81k
    CAST_TO_STRING;
8031
1.81k
    to = xmlXPathValuePop(ctxt);
8032
1.81k
    CAST_TO_STRING;
8033
1.81k
    from = xmlXPathValuePop(ctxt);
8034
1.81k
    CAST_TO_STRING;
8035
1.81k
    str = xmlXPathValuePop(ctxt);
8036
1.81k
    if (ctxt->error != 0)
8037
0
        goto error;
8038
8039
    /*
8040
     * Account for quadratic runtime
8041
     */
8042
605
    if (ctxt->context->opLimit != 0) {
8043
605
        unsigned long f1 = xmlStrlen(from->stringval);
8044
605
        unsigned long f2 = xmlStrlen(str->stringval);
8045
8046
605
        if ((f1 > 0) && (f2 > 0)) {
8047
605
            unsigned long p;
8048
8049
605
            f1 = f1 / 10 + 1;
8050
605
            f2 = f2 / 10 + 1;
8051
605
            p = f1 > ULONG_MAX / f2 ? ULONG_MAX : f1 * f2;
8052
605
            if (xmlXPathCheckOpLimit(ctxt, p) < 0)
8053
17
                goto error;
8054
605
        }
8055
605
    }
8056
8057
588
    target = xmlBufCreate(50);
8058
588
    if (target == NULL) {
8059
0
        xmlXPathPErrMemory(ctxt);
8060
0
        goto error;
8061
0
    }
8062
8063
588
    max = xmlUTF8Strlen(to->stringval);
8064
2.35k
    for (cptr = str->stringval; (ch=*cptr); ) {
8065
1.76k
        offset = xmlUTF8Strloc(from->stringval, cptr);
8066
1.76k
        if (offset >= 0) {
8067
1.71k
            if (offset < max) {
8068
1.65k
                point = xmlUTF8Strpos(to->stringval, offset);
8069
1.65k
                if (point)
8070
1.65k
                    xmlBufAdd(target, point, xmlUTF8Strsize(point, 1));
8071
1.65k
            }
8072
1.71k
        } else
8073
54
            xmlBufAdd(target, cptr, xmlUTF8Strsize(cptr, 1));
8074
8075
        /* Step to next character in input */
8076
1.76k
        cptr++;
8077
1.76k
        if ( ch & 0x80 ) {
8078
            /* if not simple ascii, verify proper format */
8079
0
            if ( (ch & 0xc0) != 0xc0 ) {
8080
0
                xmlXPathErr(ctxt, XPATH_INVALID_CHAR_ERROR);
8081
0
                break;
8082
0
            }
8083
            /* then skip over remaining bytes for this char */
8084
0
            while ( (ch <<= 1) & 0x80 )
8085
0
                if ( (*cptr++ & 0xc0) != 0x80 ) {
8086
0
                    xmlXPathErr(ctxt, XPATH_INVALID_CHAR_ERROR);
8087
0
                    break;
8088
0
                }
8089
0
            if (ch & 0x80) /* must have had error encountered */
8090
0
                break;
8091
0
        }
8092
1.76k
    }
8093
8094
588
    content = xmlBufDetach(target);
8095
588
    if (content == NULL)
8096
0
        xmlXPathPErrMemory(ctxt);
8097
588
    else
8098
588
        xmlXPathValuePush(ctxt, xmlXPathCacheWrapString(ctxt, content));
8099
588
    xmlBufFree(target);
8100
605
error:
8101
605
    xmlXPathReleaseObject(ctxt->context, str);
8102
605
    xmlXPathReleaseObject(ctxt->context, from);
8103
605
    xmlXPathReleaseObject(ctxt->context, to);
8104
605
}
8105
8106
/**
8107
 * xmlXPathBooleanFunction:
8108
 * @ctxt:  the XPath Parser context
8109
 * @nargs:  the number of arguments
8110
 *
8111
 * Implement the boolean() XPath function
8112
 *    boolean boolean(object)
8113
 * The boolean function converts its argument to a boolean as follows:
8114
 *    - a number is true if and only if it is neither positive or
8115
 *      negative zero nor NaN
8116
 *    - a node-set is true if and only if it is non-empty
8117
 *    - a string is true if and only if its length is non-zero
8118
 */
8119
void
8120
30
xmlXPathBooleanFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8121
30
    xmlXPathObjectPtr cur;
8122
8123
90
    CHECK_ARITY(1);
8124
90
    cur = xmlXPathValuePop(ctxt);
8125
90
    if (cur == NULL) XP_ERROR(XPATH_INVALID_OPERAND);
8126
30
    if (cur->type != XPATH_BOOLEAN) {
8127
0
        int boolval = xmlXPathCastToBoolean(cur);
8128
8129
0
        xmlXPathReleaseObject(ctxt->context, cur);
8130
0
        cur = xmlXPathCacheNewBoolean(ctxt, boolval);
8131
0
    }
8132
30
    xmlXPathValuePush(ctxt, cur);
8133
30
}
8134
8135
/**
8136
 * xmlXPathNotFunction:
8137
 * @ctxt:  the XPath Parser context
8138
 * @nargs:  the number of arguments
8139
 *
8140
 * Implement the not() XPath function
8141
 *    boolean not(boolean)
8142
 * The not function returns true if its argument is false,
8143
 * and false otherwise.
8144
 */
8145
void
8146
0
xmlXPathNotFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8147
0
    CHECK_ARITY(1);
8148
0
    CAST_TO_BOOLEAN;
8149
0
    CHECK_TYPE(XPATH_BOOLEAN);
8150
0
    ctxt->value->boolval = ! ctxt->value->boolval;
8151
0
}
8152
8153
/**
8154
 * xmlXPathTrueFunction:
8155
 * @ctxt:  the XPath Parser context
8156
 * @nargs:  the number of arguments
8157
 *
8158
 * Implement the true() XPath function
8159
 *    boolean true()
8160
 */
8161
void
8162
0
xmlXPathTrueFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8163
0
    CHECK_ARITY(0);
8164
0
    xmlXPathValuePush(ctxt, xmlXPathCacheNewBoolean(ctxt, 1));
8165
0
}
8166
8167
/**
8168
 * xmlXPathFalseFunction:
8169
 * @ctxt:  the XPath Parser context
8170
 * @nargs:  the number of arguments
8171
 *
8172
 * Implement the false() XPath function
8173
 *    boolean false()
8174
 */
8175
void
8176
0
xmlXPathFalseFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8177
0
    CHECK_ARITY(0);
8178
0
    xmlXPathValuePush(ctxt, xmlXPathCacheNewBoolean(ctxt, 0));
8179
0
}
8180
8181
/**
8182
 * xmlXPathLangFunction:
8183
 * @ctxt:  the XPath Parser context
8184
 * @nargs:  the number of arguments
8185
 *
8186
 * Implement the lang() XPath function
8187
 *    boolean lang(string)
8188
 * The lang function returns true or false depending on whether the
8189
 * language of the context node as specified by xml:lang attributes
8190
 * is the same as or is a sublanguage of the language specified by
8191
 * the argument string. The language of the context node is determined
8192
 * by the value of the xml:lang attribute on the context node, or, if
8193
 * the context node has no xml:lang attribute, by the value of the
8194
 * xml:lang attribute on the nearest ancestor of the context node that
8195
 * has an xml:lang attribute. If there is no such attribute, then lang
8196
 * returns false. If there is such an attribute, then lang returns
8197
 * true if the attribute value is equal to the argument ignoring case,
8198
 * or if there is some suffix starting with - such that the attribute
8199
 * value is equal to the argument ignoring that suffix of the attribute
8200
 * value and ignoring case.
8201
 */
8202
void
8203
0
xmlXPathLangFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8204
0
    xmlXPathObjectPtr val;
8205
0
    xmlNodePtr cur;
8206
0
    xmlChar *theLang;
8207
0
    const xmlChar *lang;
8208
0
    int ret = 0;
8209
0
    int i;
8210
8211
0
    CHECK_ARITY(1);
8212
0
    CAST_TO_STRING;
8213
0
    CHECK_TYPE(XPATH_STRING);
8214
0
    val = xmlXPathValuePop(ctxt);
8215
0
    lang = val->stringval;
8216
0
    cur = ctxt->context->node;
8217
0
    while (cur != NULL) {
8218
0
        if (xmlNodeGetAttrValue(cur, BAD_CAST "lang", XML_XML_NAMESPACE,
8219
0
                                &theLang) < 0)
8220
0
            xmlXPathPErrMemory(ctxt);
8221
0
        if (theLang != NULL)
8222
0
            break;
8223
0
        cur = cur->parent;
8224
0
    }
8225
0
    if ((theLang != NULL) && (lang != NULL)) {
8226
0
        for (i = 0;lang[i] != 0;i++)
8227
0
            if (toupper(lang[i]) != toupper(theLang[i]))
8228
0
                goto not_equal;
8229
0
        if ((theLang[i] == 0) || (theLang[i] == '-'))
8230
0
            ret = 1;
8231
0
    }
8232
0
not_equal:
8233
0
    if (theLang != NULL)
8234
0
  xmlFree((void *)theLang);
8235
8236
0
    xmlXPathReleaseObject(ctxt->context, val);
8237
0
    xmlXPathValuePush(ctxt, xmlXPathCacheNewBoolean(ctxt, ret));
8238
0
}
8239
8240
/**
8241
 * xmlXPathNumberFunction:
8242
 * @ctxt:  the XPath Parser context
8243
 * @nargs:  the number of arguments
8244
 *
8245
 * Implement the number() XPath function
8246
 *    number number(object?)
8247
 */
8248
void
8249
168k
xmlXPathNumberFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8250
168k
    xmlXPathObjectPtr cur;
8251
168k
    double res;
8252
8253
168k
    if (ctxt == NULL) return;
8254
168k
    if (nargs == 0) {
8255
0
  if (ctxt->context->node == NULL) {
8256
0
      xmlXPathValuePush(ctxt, xmlXPathCacheNewFloat(ctxt, 0.0));
8257
0
  } else {
8258
0
      xmlChar* content = xmlNodeGetContent(ctxt->context->node);
8259
0
            if (content == NULL)
8260
0
                xmlXPathPErrMemory(ctxt);
8261
8262
0
      res = xmlXPathStringEvalNumber(content);
8263
0
      xmlXPathValuePush(ctxt, xmlXPathCacheNewFloat(ctxt, res));
8264
0
      xmlFree(content);
8265
0
  }
8266
0
  return;
8267
0
    }
8268
8269
672k
    CHECK_ARITY(1);
8270
672k
    cur = xmlXPathValuePop(ctxt);
8271
672k
    if (cur->type != XPATH_NUMBER) {
8272
168k
        double floatval;
8273
8274
168k
        floatval = xmlXPathCastToNumberInternal(ctxt, cur);
8275
168k
        xmlXPathReleaseObject(ctxt->context, cur);
8276
168k
        cur = xmlXPathCacheNewFloat(ctxt, floatval);
8277
168k
    }
8278
672k
    xmlXPathValuePush(ctxt, cur);
8279
672k
}
8280
8281
/**
8282
 * xmlXPathSumFunction:
8283
 * @ctxt:  the XPath Parser context
8284
 * @nargs:  the number of arguments
8285
 *
8286
 * Implement the sum() XPath function
8287
 *    number sum(node-set)
8288
 * The sum function returns the sum of the values of the nodes in
8289
 * the argument node-set.
8290
 */
8291
void
8292
0
xmlXPathSumFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8293
0
    xmlXPathObjectPtr cur;
8294
0
    int i;
8295
0
    double res = 0.0;
8296
8297
0
    CHECK_ARITY(1);
8298
0
    if ((ctxt->value == NULL) ||
8299
0
  ((ctxt->value->type != XPATH_NODESET) &&
8300
0
   (ctxt->value->type != XPATH_XSLT_TREE)))
8301
0
  XP_ERROR(XPATH_INVALID_TYPE);
8302
0
    cur = xmlXPathValuePop(ctxt);
8303
8304
0
    if ((cur->nodesetval != NULL) && (cur->nodesetval->nodeNr != 0)) {
8305
0
  for (i = 0; i < cur->nodesetval->nodeNr; i++) {
8306
0
      res += xmlXPathNodeToNumberInternal(ctxt,
8307
0
                                                cur->nodesetval->nodeTab[i]);
8308
0
  }
8309
0
    }
8310
0
    xmlXPathValuePush(ctxt, xmlXPathCacheNewFloat(ctxt, res));
8311
0
    xmlXPathReleaseObject(ctxt->context, cur);
8312
0
}
8313
8314
/**
8315
 * xmlXPathFloorFunction:
8316
 * @ctxt:  the XPath Parser context
8317
 * @nargs:  the number of arguments
8318
 *
8319
 * Implement the floor() XPath function
8320
 *    number floor(number)
8321
 * The floor function returns the largest (closest to positive infinity)
8322
 * number that is not greater than the argument and that is an integer.
8323
 */
8324
void
8325
0
xmlXPathFloorFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8326
0
    CHECK_ARITY(1);
8327
0
    CAST_TO_NUMBER;
8328
0
    CHECK_TYPE(XPATH_NUMBER);
8329
8330
0
    ctxt->value->floatval = floor(ctxt->value->floatval);
8331
0
}
8332
8333
/**
8334
 * xmlXPathCeilingFunction:
8335
 * @ctxt:  the XPath Parser context
8336
 * @nargs:  the number of arguments
8337
 *
8338
 * Implement the ceiling() XPath function
8339
 *    number ceiling(number)
8340
 * The ceiling function returns the smallest (closest to negative infinity)
8341
 * number that is not less than the argument and that is an integer.
8342
 */
8343
void
8344
0
xmlXPathCeilingFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8345
0
    CHECK_ARITY(1);
8346
0
    CAST_TO_NUMBER;
8347
0
    CHECK_TYPE(XPATH_NUMBER);
8348
8349
#ifdef _AIX
8350
    /* Work around buggy ceil() function on AIX */
8351
    ctxt->value->floatval = copysign(ceil(ctxt->value->floatval), ctxt->value->floatval);
8352
#else
8353
0
    ctxt->value->floatval = ceil(ctxt->value->floatval);
8354
0
#endif
8355
0
}
8356
8357
/**
8358
 * xmlXPathRoundFunction:
8359
 * @ctxt:  the XPath Parser context
8360
 * @nargs:  the number of arguments
8361
 *
8362
 * Implement the round() XPath function
8363
 *    number round(number)
8364
 * The round function returns the number that is closest to the
8365
 * argument and that is an integer. If there are two such numbers,
8366
 * then the one that is closest to positive infinity is returned.
8367
 */
8368
void
8369
0
xmlXPathRoundFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8370
0
    double f;
8371
8372
0
    CHECK_ARITY(1);
8373
0
    CAST_TO_NUMBER;
8374
0
    CHECK_TYPE(XPATH_NUMBER);
8375
8376
0
    f = ctxt->value->floatval;
8377
8378
0
    if ((f >= -0.5) && (f < 0.5)) {
8379
        /* Handles negative zero. */
8380
0
        ctxt->value->floatval *= 0.0;
8381
0
    }
8382
0
    else {
8383
0
        double rounded = floor(f);
8384
0
        if (f - rounded >= 0.5)
8385
0
            rounded += 1.0;
8386
0
        ctxt->value->floatval = rounded;
8387
0
    }
8388
0
}
8389
8390
/************************************************************************
8391
 *                  *
8392
 *      The Parser          *
8393
 *                  *
8394
 ************************************************************************/
8395
8396
/*
8397
 * a few forward declarations since we use a recursive call based
8398
 * implementation.
8399
 */
8400
static void xmlXPathCompileExpr(xmlXPathParserContextPtr ctxt, int sort);
8401
static void xmlXPathCompPredicate(xmlXPathParserContextPtr ctxt, int filter);
8402
static void xmlXPathCompLocationPath(xmlXPathParserContextPtr ctxt);
8403
static void xmlXPathCompRelativeLocationPath(xmlXPathParserContextPtr ctxt);
8404
static xmlChar * xmlXPathParseNameComplex(xmlXPathParserContextPtr ctxt,
8405
                                    int qualified);
8406
8407
/**
8408
 * xmlXPathCurrentChar:
8409
 * @ctxt:  the XPath parser context
8410
 * @cur:  pointer to the beginning of the char
8411
 * @len:  pointer to the length of the char read
8412
 *
8413
 * The current char value, if using UTF-8 this may actually span multiple
8414
 * bytes in the input buffer.
8415
 *
8416
 * Returns the current char value and its length
8417
 */
8418
8419
static int
8420
9.46M
xmlXPathCurrentChar(xmlXPathParserContextPtr ctxt, int *len) {
8421
9.46M
    unsigned char c;
8422
9.46M
    unsigned int val;
8423
9.46M
    const xmlChar *cur;
8424
8425
9.46M
    if (ctxt == NULL)
8426
0
  return(0);
8427
9.46M
    cur = ctxt->cur;
8428
8429
    /*
8430
     * We are supposed to handle UTF8, check it's valid
8431
     * From rfc2044: encoding of the Unicode values on UTF-8:
8432
     *
8433
     * UCS-4 range (hex.)           UTF-8 octet sequence (binary)
8434
     * 0000 0000-0000 007F   0xxxxxxx
8435
     * 0000 0080-0000 07FF   110xxxxx 10xxxxxx
8436
     * 0000 0800-0000 FFFF   1110xxxx 10xxxxxx 10xxxxxx
8437
     *
8438
     * Check for the 0x110000 limit too
8439
     */
8440
9.46M
    c = *cur;
8441
9.46M
    if (c & 0x80) {
8442
7.37M
  if ((cur[1] & 0xc0) != 0x80)
8443
396
      goto encoding_error;
8444
7.37M
  if ((c & 0xe0) == 0xe0) {
8445
8446
3.27k
      if ((cur[2] & 0xc0) != 0x80)
8447
6
    goto encoding_error;
8448
3.27k
      if ((c & 0xf0) == 0xf0) {
8449
750
    if (((c & 0xf8) != 0xf0) ||
8450
750
        ((cur[3] & 0xc0) != 0x80))
8451
0
        goto encoding_error;
8452
    /* 4-byte code */
8453
750
    *len = 4;
8454
750
    val = (cur[0] & 0x7) << 18;
8455
750
    val |= (cur[1] & 0x3f) << 12;
8456
750
    val |= (cur[2] & 0x3f) << 6;
8457
750
    val |= cur[3] & 0x3f;
8458
2.52k
      } else {
8459
        /* 3-byte code */
8460
2.52k
    *len = 3;
8461
2.52k
    val = (cur[0] & 0xf) << 12;
8462
2.52k
    val |= (cur[1] & 0x3f) << 6;
8463
2.52k
    val |= cur[2] & 0x3f;
8464
2.52k
      }
8465
7.37M
  } else {
8466
    /* 2-byte code */
8467
7.37M
      *len = 2;
8468
7.37M
      val = (cur[0] & 0x1f) << 6;
8469
7.37M
      val |= cur[1] & 0x3f;
8470
7.37M
  }
8471
7.37M
  if (!IS_CHAR(val)) {
8472
0
      XP_ERROR0(XPATH_INVALID_CHAR_ERROR);
8473
0
  }
8474
7.37M
  return(val);
8475
7.37M
    } else {
8476
  /* 1-byte code */
8477
2.09M
  *len = 1;
8478
2.09M
  return(*cur);
8479
2.09M
    }
8480
402
encoding_error:
8481
    /*
8482
     * If we detect an UTF8 error that probably means that the
8483
     * input encoding didn't get properly advertised in the
8484
     * declaration header. Report the error and switch the encoding
8485
     * to ISO-Latin-1 (if you don't like this policy, just declare the
8486
     * encoding !)
8487
     */
8488
402
    *len = 0;
8489
402
    XP_ERROR0(XPATH_ENCODING_ERROR);
8490
0
}
8491
8492
/**
8493
 * xmlXPathParseNCName:
8494
 * @ctxt:  the XPath Parser context
8495
 *
8496
 * parse an XML namespace non qualified name.
8497
 *
8498
 * [NS 3] NCName ::= (Letter | '_') (NCNameChar)*
8499
 *
8500
 * [NS 4] NCNameChar ::= Letter | Digit | '.' | '-' | '_' |
8501
 *                       CombiningChar | Extender
8502
 *
8503
 * Returns the namespace name or NULL
8504
 */
8505
8506
xmlChar *
8507
599k
xmlXPathParseNCName(xmlXPathParserContextPtr ctxt) {
8508
599k
    const xmlChar *in;
8509
599k
    xmlChar *ret;
8510
599k
    int count = 0;
8511
8512
599k
    if ((ctxt == NULL) || (ctxt->cur == NULL)) return(NULL);
8513
    /*
8514
     * Accelerator for simple ASCII names
8515
     */
8516
599k
    in = ctxt->cur;
8517
599k
    if (((*in >= 0x61) && (*in <= 0x7A)) ||
8518
599k
  ((*in >= 0x41) && (*in <= 0x5A)) ||
8519
599k
  (*in == '_')) {
8520
596k
  in++;
8521
824k
  while (((*in >= 0x61) && (*in <= 0x7A)) ||
8522
824k
         ((*in >= 0x41) && (*in <= 0x5A)) ||
8523
824k
         ((*in >= 0x30) && (*in <= 0x39)) ||
8524
824k
         (*in == '_') || (*in == '.') ||
8525
824k
         (*in == '-'))
8526
228k
      in++;
8527
596k
  if ((*in == ' ') || (*in == '>') || (*in == '/') ||
8528
596k
            (*in == '[') || (*in == ']') || (*in == ':') ||
8529
596k
            (*in == '@') || (*in == '*')) {
8530
591k
      count = in - ctxt->cur;
8531
591k
      if (count == 0)
8532
0
    return(NULL);
8533
591k
      ret = xmlStrndup(ctxt->cur, count);
8534
591k
            if (ret == NULL)
8535
112
                xmlXPathPErrMemory(ctxt);
8536
591k
      ctxt->cur = in;
8537
591k
      return(ret);
8538
591k
  }
8539
596k
    }
8540
8.73k
    return(xmlXPathParseNameComplex(ctxt, 0));
8541
599k
}
8542
8543
8544
/**
8545
 * xmlXPathParseQName:
8546
 * @ctxt:  the XPath Parser context
8547
 * @prefix:  a xmlChar **
8548
 *
8549
 * parse an XML qualified name
8550
 *
8551
 * [NS 5] QName ::= (Prefix ':')? LocalPart
8552
 *
8553
 * [NS 6] Prefix ::= NCName
8554
 *
8555
 * [NS 7] LocalPart ::= NCName
8556
 *
8557
 * Returns the function returns the local part, and prefix is updated
8558
 *   to get the Prefix if any.
8559
 */
8560
8561
static xmlChar *
8562
1.04k
xmlXPathParseQName(xmlXPathParserContextPtr ctxt, xmlChar **prefix) {
8563
1.04k
    xmlChar *ret = NULL;
8564
8565
1.04k
    *prefix = NULL;
8566
1.04k
    ret = xmlXPathParseNCName(ctxt);
8567
1.04k
    if (ret && CUR == ':') {
8568
573
        *prefix = ret;
8569
573
  NEXT;
8570
573
  ret = xmlXPathParseNCName(ctxt);
8571
573
    }
8572
1.04k
    return(ret);
8573
1.04k
}
8574
8575
/**
8576
 * xmlXPathParseName:
8577
 * @ctxt:  the XPath Parser context
8578
 *
8579
 * parse an XML name
8580
 *
8581
 * [4] NameChar ::= Letter | Digit | '.' | '-' | '_' | ':' |
8582
 *                  CombiningChar | Extender
8583
 *
8584
 * [5] Name ::= (Letter | '_' | ':') (NameChar)*
8585
 *
8586
 * Returns the namespace name or NULL
8587
 */
8588
8589
xmlChar *
8590
149
xmlXPathParseName(xmlXPathParserContextPtr ctxt) {
8591
149
    const xmlChar *in;
8592
149
    xmlChar *ret;
8593
149
    size_t count = 0;
8594
8595
149
    if ((ctxt == NULL) || (ctxt->cur == NULL)) return(NULL);
8596
    /*
8597
     * Accelerator for simple ASCII names
8598
     */
8599
149
    in = ctxt->cur;
8600
149
    if (((*in >= 0x61) && (*in <= 0x7A)) ||
8601
149
  ((*in >= 0x41) && (*in <= 0x5A)) ||
8602
149
  (*in == '_') || (*in == ':')) {
8603
149
  in++;
8604
7.22M
  while (((*in >= 0x61) && (*in <= 0x7A)) ||
8605
7.22M
         ((*in >= 0x41) && (*in <= 0x5A)) ||
8606
7.22M
         ((*in >= 0x30) && (*in <= 0x39)) ||
8607
7.22M
         (*in == '_') || (*in == '-') ||
8608
7.22M
         (*in == ':') || (*in == '.'))
8609
7.22M
      in++;
8610
149
  if ((*in > 0) && (*in < 0x80)) {
8611
101
      count = in - ctxt->cur;
8612
101
            if (count > XML_MAX_NAME_LENGTH) {
8613
41
                ctxt->cur = in;
8614
41
                XP_ERRORNULL(XPATH_EXPR_ERROR);
8615
0
            }
8616
60
      ret = xmlStrndup(ctxt->cur, count);
8617
60
            if (ret == NULL)
8618
0
                xmlXPathPErrMemory(ctxt);
8619
60
      ctxt->cur = in;
8620
60
      return(ret);
8621
101
  }
8622
149
    }
8623
48
    return(xmlXPathParseNameComplex(ctxt, 1));
8624
149
}
8625
8626
static xmlChar *
8627
8.78k
xmlXPathParseNameComplex(xmlXPathParserContextPtr ctxt, int qualified) {
8628
8.78k
    xmlChar *ret;
8629
8.78k
    xmlChar buf[XML_MAX_NAMELEN + 5];
8630
8.78k
    int len = 0, l;
8631
8.78k
    int c;
8632
8633
    /*
8634
     * Handler for more complex cases
8635
     */
8636
8.78k
    c = CUR_CHAR(l);
8637
8.78k
    if ((c == ' ') || (c == '>') || (c == '/') || /* accelerators */
8638
8.78k
        (c == '[') || (c == ']') || (c == '@') || /* accelerators */
8639
8.78k
        (c == '*') || /* accelerators */
8640
8.78k
  (!IS_LETTER(c) && (c != '_') &&
8641
8.53k
         ((!qualified) || (c != ':')))) {
8642
676
  return(NULL);
8643
676
    }
8644
8645
119k
    while ((c != ' ') && (c != '>') && (c != '/') && /* test bigname.xml */
8646
119k
     ((IS_LETTER(c)) || (IS_DIGIT(c)) ||
8647
119k
            (c == '.') || (c == '-') ||
8648
119k
      (c == '_') || ((qualified) && (c == ':')) ||
8649
119k
      (IS_COMBINING(c)) ||
8650
119k
      (IS_EXTENDER(c)))) {
8651
112k
  COPY_BUF(buf,len,c);
8652
112k
  NEXTL(l);
8653
112k
  c = CUR_CHAR(l);
8654
112k
  if (len >= XML_MAX_NAMELEN) {
8655
      /*
8656
       * Okay someone managed to make a huge name, so he's ready to pay
8657
       * for the processing speed.
8658
       */
8659
1.59k
      xmlChar *buffer;
8660
1.59k
      int max = len * 2;
8661
8662
1.59k
            if (len > XML_MAX_NAME_LENGTH) {
8663
0
                XP_ERRORNULL(XPATH_EXPR_ERROR);
8664
0
            }
8665
1.59k
      buffer = xmlMalloc(max);
8666
1.59k
      if (buffer == NULL) {
8667
0
                xmlXPathPErrMemory(ctxt);
8668
0
                return(NULL);
8669
0
      }
8670
1.59k
      memcpy(buffer, buf, len);
8671
5.56M
      while ((IS_LETTER(c)) || (IS_DIGIT(c)) || /* test bigname.xml */
8672
5.56M
       (c == '.') || (c == '-') ||
8673
5.56M
       (c == '_') || ((qualified) && (c == ':')) ||
8674
5.56M
       (IS_COMBINING(c)) ||
8675
5.56M
       (IS_EXTENDER(c))) {
8676
5.56M
    if (len + 10 > max) {
8677
10.2k
                    xmlChar *tmp;
8678
10.2k
                    int newSize;
8679
8680
10.2k
                    newSize = xmlGrowCapacity(max, 1, 1, XML_MAX_NAME_LENGTH);
8681
10.2k
                    if (newSize < 0) {
8682
29
                        xmlFree(buffer);
8683
29
                        xmlXPathErr(ctxt, XPATH_EXPR_ERROR);
8684
29
                        return(NULL);
8685
29
                    }
8686
10.2k
        tmp = xmlRealloc(buffer, newSize);
8687
10.2k
        if (tmp == NULL) {
8688
0
                        xmlFree(buffer);
8689
0
                        xmlXPathPErrMemory(ctxt);
8690
0
                        return(NULL);
8691
0
        }
8692
10.2k
                    buffer = tmp;
8693
10.2k
        max = newSize;
8694
10.2k
    }
8695
5.56M
    COPY_BUF(buffer,len,c);
8696
5.56M
    NEXTL(l);
8697
5.56M
    c = CUR_CHAR(l);
8698
5.56M
      }
8699
1.56k
      buffer[len] = 0;
8700
1.56k
      return(buffer);
8701
1.59k
  }
8702
112k
    }
8703
6.51k
    if (len == 0)
8704
0
  return(NULL);
8705
6.51k
    ret = xmlStrndup(buf, len);
8706
6.51k
    if (ret == NULL)
8707
1
        xmlXPathPErrMemory(ctxt);
8708
6.51k
    return(ret);
8709
6.51k
}
8710
8711
250
#define MAX_FRAC 20
8712
8713
/**
8714
 * xmlXPathStringEvalNumber:
8715
 * @str:  A string to scan
8716
 *
8717
 *  [30a]  Float  ::= Number ('e' Digits?)?
8718
 *
8719
 *  [30]   Number ::=   Digits ('.' Digits?)?
8720
 *                    | '.' Digits
8721
 *  [31]   Digits ::=   [0-9]+
8722
 *
8723
 * Compile a Number in the string
8724
 * In complement of the Number expression, this function also handles
8725
 * negative values : '-' Number.
8726
 *
8727
 * Returns the double value.
8728
 */
8729
double
8730
166k
xmlXPathStringEvalNumber(const xmlChar *str) {
8731
166k
    const xmlChar *cur = str;
8732
166k
    double ret;
8733
166k
    int ok = 0;
8734
166k
    int isneg = 0;
8735
166k
    int exponent = 0;
8736
166k
    int is_exponent_negative = 0;
8737
166k
#ifdef __GNUC__
8738
166k
    unsigned long tmp = 0;
8739
166k
    double temp;
8740
166k
#endif
8741
166k
    if (cur == NULL) return(0);
8742
166k
    while (IS_BLANK_CH(*cur)) cur++;
8743
166k
    if (*cur == '-') {
8744
3
  isneg = 1;
8745
3
  cur++;
8746
3
    }
8747
166k
    if ((*cur != '.') && ((*cur < '0') || (*cur > '9'))) {
8748
165k
        return(xmlXPathNAN);
8749
165k
    }
8750
8751
1.13k
#ifdef __GNUC__
8752
    /*
8753
     * tmp/temp is a workaround against a gcc compiler bug
8754
     * http://veillard.com/gcc.bug
8755
     */
8756
1.13k
    ret = 0;
8757
3.14k
    while ((*cur >= '0') && (*cur <= '9')) {
8758
2.00k
  ret = ret * 10;
8759
2.00k
  tmp = (*cur - '0');
8760
2.00k
  ok = 1;
8761
2.00k
  cur++;
8762
2.00k
  temp = (double) tmp;
8763
2.00k
  ret = ret + temp;
8764
2.00k
    }
8765
#else
8766
    ret = 0;
8767
    while ((*cur >= '0') && (*cur <= '9')) {
8768
  ret = ret * 10 + (*cur - '0');
8769
  ok = 1;
8770
  cur++;
8771
    }
8772
#endif
8773
8774
1.13k
    if (*cur == '.') {
8775
233
  int v, frac = 0, max;
8776
233
  double fraction = 0;
8777
8778
233
        cur++;
8779
233
  if (((*cur < '0') || (*cur > '9')) && (!ok)) {
8780
0
      return(xmlXPathNAN);
8781
0
  }
8782
233
        while (*cur == '0') {
8783
0
      frac = frac + 1;
8784
0
      cur++;
8785
0
        }
8786
233
        max = frac + MAX_FRAC;
8787
3.90k
  while (((*cur >= '0') && (*cur <= '9')) && (frac < max)) {
8788
3.67k
      v = (*cur - '0');
8789
3.67k
      fraction = fraction * 10 + v;
8790
3.67k
      frac = frac + 1;
8791
3.67k
      cur++;
8792
3.67k
  }
8793
233
  fraction /= pow(10.0, frac);
8794
233
  ret = ret + fraction;
8795
5.48k
  while ((*cur >= '0') && (*cur <= '9'))
8796
5.24k
      cur++;
8797
233
    }
8798
1.13k
    if ((*cur == 'e') || (*cur == 'E')) {
8799
0
      cur++;
8800
0
      if (*cur == '-') {
8801
0
  is_exponent_negative = 1;
8802
0
  cur++;
8803
0
      } else if (*cur == '+') {
8804
0
        cur++;
8805
0
      }
8806
0
      while ((*cur >= '0') && (*cur <= '9')) {
8807
0
        if (exponent < 1000000)
8808
0
    exponent = exponent * 10 + (*cur - '0');
8809
0
  cur++;
8810
0
      }
8811
0
    }
8812
1.13k
    while (IS_BLANK_CH(*cur)) cur++;
8813
1.13k
    if (*cur != 0) return(xmlXPathNAN);
8814
698
    if (isneg) ret = -ret;
8815
698
    if (is_exponent_negative) exponent = -exponent;
8816
698
    ret *= pow(10.0, (double)exponent);
8817
698
    return(ret);
8818
1.13k
}
8819
8820
/**
8821
 * xmlXPathCompNumber:
8822
 * @ctxt:  the XPath Parser context
8823
 *
8824
 *  [30]   Number ::=   Digits ('.' Digits?)?
8825
 *                    | '.' Digits
8826
 *  [31]   Digits ::=   [0-9]+
8827
 *
8828
 * Compile a Number, then push it on the stack
8829
 *
8830
 */
8831
static void
8832
xmlXPathCompNumber(xmlXPathParserContextPtr ctxt)
8833
1.06k
{
8834
1.06k
    double ret = 0.0;
8835
1.06k
    int ok = 0;
8836
1.06k
    int exponent = 0;
8837
1.06k
    int is_exponent_negative = 0;
8838
1.06k
    xmlXPathObjectPtr num;
8839
1.06k
#ifdef __GNUC__
8840
1.06k
    unsigned long tmp = 0;
8841
1.06k
    double temp;
8842
1.06k
#endif
8843
8844
1.06k
    CHECK_ERROR;
8845
1.06k
    if ((CUR != '.') && ((CUR < '0') || (CUR > '9'))) {
8846
0
        XP_ERROR(XPATH_NUMBER_ERROR);
8847
0
    }
8848
1.06k
#ifdef __GNUC__
8849
    /*
8850
     * tmp/temp is a workaround against a gcc compiler bug
8851
     * http://veillard.com/gcc.bug
8852
     */
8853
1.06k
    ret = 0;
8854
2.62k
    while ((CUR >= '0') && (CUR <= '9')) {
8855
1.56k
  ret = ret * 10;
8856
1.56k
  tmp = (CUR - '0');
8857
1.56k
        ok = 1;
8858
1.56k
        NEXT;
8859
1.56k
  temp = (double) tmp;
8860
1.56k
  ret = ret + temp;
8861
1.56k
    }
8862
#else
8863
    ret = 0;
8864
    while ((CUR >= '0') && (CUR <= '9')) {
8865
  ret = ret * 10 + (CUR - '0');
8866
  ok = 1;
8867
  NEXT;
8868
    }
8869
#endif
8870
1.06k
    if (CUR == '.') {
8871
17
  int v, frac = 0, max;
8872
17
  double fraction = 0;
8873
8874
17
        NEXT;
8875
17
        if (((CUR < '0') || (CUR > '9')) && (!ok)) {
8876
0
            XP_ERROR(XPATH_NUMBER_ERROR);
8877
0
        }
8878
17
        while (CUR == '0') {
8879
0
            frac = frac + 1;
8880
0
            NEXT;
8881
0
        }
8882
17
        max = frac + MAX_FRAC;
8883
32
        while ((CUR >= '0') && (CUR <= '9') && (frac < max)) {
8884
15
      v = (CUR - '0');
8885
15
      fraction = fraction * 10 + v;
8886
15
      frac = frac + 1;
8887
15
            NEXT;
8888
15
        }
8889
17
        fraction /= pow(10.0, frac);
8890
17
        ret = ret + fraction;
8891
17
        while ((CUR >= '0') && (CUR <= '9'))
8892
0
            NEXT;
8893
17
    }
8894
1.06k
    if ((CUR == 'e') || (CUR == 'E')) {
8895
10
        NEXT;
8896
10
        if (CUR == '-') {
8897
0
            is_exponent_negative = 1;
8898
0
            NEXT;
8899
10
        } else if (CUR == '+') {
8900
0
      NEXT;
8901
0
  }
8902
20
        while ((CUR >= '0') && (CUR <= '9')) {
8903
10
            if (exponent < 1000000)
8904
10
                exponent = exponent * 10 + (CUR - '0');
8905
10
            NEXT;
8906
10
        }
8907
10
        if (is_exponent_negative)
8908
0
            exponent = -exponent;
8909
10
        ret *= pow(10.0, (double) exponent);
8910
10
    }
8911
1.06k
    num = xmlXPathCacheNewFloat(ctxt, ret);
8912
1.06k
    if (num == NULL) {
8913
0
  ctxt->error = XPATH_MEMORY_ERROR;
8914
1.06k
    } else if (PUSH_LONG_EXPR(XPATH_OP_VALUE, XPATH_NUMBER, 0, 0, num,
8915
1.06k
                              NULL) == -1) {
8916
0
        xmlXPathReleaseObject(ctxt->context, num);
8917
0
    }
8918
1.06k
}
8919
8920
/**
8921
 * xmlXPathParseLiteral:
8922
 * @ctxt:  the XPath Parser context
8923
 *
8924
 * Parse a Literal
8925
 *
8926
 *  [29]   Literal ::=   '"' [^"]* '"'
8927
 *                    | "'" [^']* "'"
8928
 *
8929
 * Returns the value found or NULL in case of error
8930
 */
8931
static xmlChar *
8932
736
xmlXPathParseLiteral(xmlXPathParserContextPtr ctxt) {
8933
736
    const xmlChar *q;
8934
736
    xmlChar *ret = NULL;
8935
736
    int quote;
8936
8937
736
    if (CUR == '"') {
8938
258
        quote = '"';
8939
478
    } else if (CUR == '\'') {
8940
478
        quote = '\'';
8941
478
    } else {
8942
0
  XP_ERRORNULL(XPATH_START_LITERAL_ERROR);
8943
0
    }
8944
8945
736
    NEXT;
8946
736
    q = CUR_PTR;
8947
2.37M
    while (CUR != quote) {
8948
2.37M
        int ch;
8949
2.37M
        int len = 4;
8950
8951
2.37M
        if (CUR == 0)
8952
2.37M
            XP_ERRORNULL(XPATH_UNFINISHED_LITERAL_ERROR);
8953
2.37M
        ch = xmlGetUTF8Char(CUR_PTR, &len);
8954
2.37M
        if ((ch < 0) || (IS_CHAR(ch) == 0))
8955
2.37M
            XP_ERRORNULL(XPATH_INVALID_CHAR_ERROR);
8956
2.37M
        CUR_PTR += len;
8957
2.37M
    }
8958
530
    ret = xmlStrndup(q, CUR_PTR - q);
8959
530
    if (ret == NULL)
8960
0
        xmlXPathPErrMemory(ctxt);
8961
530
    NEXT;
8962
530
    return(ret);
8963
736
}
8964
8965
/**
8966
 * xmlXPathCompLiteral:
8967
 * @ctxt:  the XPath Parser context
8968
 *
8969
 * Parse a Literal and push it on the stack.
8970
 *
8971
 *  [29]   Literal ::=   '"' [^"]* '"'
8972
 *                    | "'" [^']* "'"
8973
 *
8974
 * TODO: xmlXPathCompLiteral memory allocation could be improved.
8975
 */
8976
static void
8977
736
xmlXPathCompLiteral(xmlXPathParserContextPtr ctxt) {
8978
736
    xmlChar *ret = NULL;
8979
736
    xmlXPathObjectPtr lit;
8980
8981
736
    ret = xmlXPathParseLiteral(ctxt);
8982
736
    if (ret == NULL)
8983
206
        return;
8984
530
    lit = xmlXPathCacheNewString(ctxt, ret);
8985
530
    if (lit == NULL) {
8986
0
        ctxt->error = XPATH_MEMORY_ERROR;
8987
530
    } else if (PUSH_LONG_EXPR(XPATH_OP_VALUE, XPATH_STRING, 0, 0, lit,
8988
530
                              NULL) == -1) {
8989
0
        xmlXPathReleaseObject(ctxt->context, lit);
8990
0
    }
8991
530
    xmlFree(ret);
8992
530
}
8993
8994
/**
8995
 * xmlXPathCompVariableReference:
8996
 * @ctxt:  the XPath Parser context
8997
 *
8998
 * Parse a VariableReference, evaluate it and push it on the stack.
8999
 *
9000
 * The variable bindings consist of a mapping from variable names
9001
 * to variable values. The value of a variable is an object, which can be
9002
 * of any of the types that are possible for the value of an expression,
9003
 * and may also be of additional types not specified here.
9004
 *
9005
 * Early evaluation is possible since:
9006
 * The variable bindings [...] used to evaluate a subexpression are
9007
 * always the same as those used to evaluate the containing expression.
9008
 *
9009
 *  [36]   VariableReference ::=   '$' QName
9010
 */
9011
static void
9012
55
xmlXPathCompVariableReference(xmlXPathParserContextPtr ctxt) {
9013
55
    xmlChar *name;
9014
55
    xmlChar *prefix;
9015
9016
55
    SKIP_BLANKS;
9017
55
    if (CUR != '$') {
9018
0
  XP_ERROR(XPATH_VARIABLE_REF_ERROR);
9019
0
    }
9020
55
    NEXT;
9021
55
    name = xmlXPathParseQName(ctxt, &prefix);
9022
55
    if (name == NULL) {
9023
1
        xmlFree(prefix);
9024
1
  XP_ERROR(XPATH_VARIABLE_REF_ERROR);
9025
0
    }
9026
54
    ctxt->comp->last = -1;
9027
54
    if (PUSH_LONG_EXPR(XPATH_OP_VARIABLE, 0, 0, 0, name, prefix) == -1) {
9028
0
        xmlFree(prefix);
9029
0
        xmlFree(name);
9030
0
    }
9031
54
    SKIP_BLANKS;
9032
54
    if ((ctxt->context != NULL) && (ctxt->context->flags & XML_XPATH_NOVAR)) {
9033
0
  XP_ERROR(XPATH_FORBID_VARIABLE_ERROR);
9034
0
    }
9035
54
}
9036
9037
/**
9038
 * xmlXPathIsNodeType:
9039
 * @name:  a name string
9040
 *
9041
 * Is the name given a NodeType one.
9042
 *
9043
 *  [38]   NodeType ::=   'comment'
9044
 *                    | 'text'
9045
 *                    | 'processing-instruction'
9046
 *                    | 'node'
9047
 *
9048
 * Returns 1 if true 0 otherwise
9049
 */
9050
int
9051
1.04k
xmlXPathIsNodeType(const xmlChar *name) {
9052
1.04k
    if (name == NULL)
9053
0
  return(0);
9054
9055
1.04k
    if (xmlStrEqual(name, BAD_CAST "node"))
9056
44
  return(1);
9057
996
    if (xmlStrEqual(name, BAD_CAST "text"))
9058
2
  return(1);
9059
994
    if (xmlStrEqual(name, BAD_CAST "comment"))
9060
0
  return(1);
9061
994
    if (xmlStrEqual(name, BAD_CAST "processing-instruction"))
9062
0
  return(1);
9063
994
    return(0);
9064
994
}
9065
9066
/**
9067
 * xmlXPathCompFunctionCall:
9068
 * @ctxt:  the XPath Parser context
9069
 *
9070
 *  [16]   FunctionCall ::=   FunctionName '(' ( Argument ( ',' Argument)*)? ')'
9071
 *  [17]   Argument ::=   Expr
9072
 *
9073
 * Compile a function call, the evaluation of all arguments are
9074
 * pushed on the stack
9075
 */
9076
static void
9077
994
xmlXPathCompFunctionCall(xmlXPathParserContextPtr ctxt) {
9078
994
    xmlChar *name;
9079
994
    xmlChar *prefix;
9080
994
    int nbargs = 0;
9081
994
    int sort = 1;
9082
9083
994
    name = xmlXPathParseQName(ctxt, &prefix);
9084
994
    if (name == NULL) {
9085
1
  xmlFree(prefix);
9086
1
  XP_ERROR(XPATH_EXPR_ERROR);
9087
0
    }
9088
993
    SKIP_BLANKS;
9089
9090
993
    if (CUR != '(') {
9091
0
  xmlFree(name);
9092
0
  xmlFree(prefix);
9093
0
  XP_ERROR(XPATH_EXPR_ERROR);
9094
0
    }
9095
993
    NEXT;
9096
993
    SKIP_BLANKS;
9097
9098
    /*
9099
    * Optimization for count(): we don't need the node-set to be sorted.
9100
    */
9101
993
    if ((prefix == NULL) && (name[0] == 'c') &&
9102
993
  xmlStrEqual(name, BAD_CAST "count"))
9103
0
    {
9104
0
  sort = 0;
9105
0
    }
9106
993
    ctxt->comp->last = -1;
9107
993
    if (CUR != ')') {
9108
1.25k
  while (CUR != 0) {
9109
1.23k
      int op1 = ctxt->comp->last;
9110
1.23k
      ctxt->comp->last = -1;
9111
1.23k
      xmlXPathCompileExpr(ctxt, sort);
9112
1.23k
      if (ctxt->error != XPATH_EXPRESSION_OK) {
9113
146
    xmlFree(name);
9114
146
    xmlFree(prefix);
9115
146
    return;
9116
146
      }
9117
1.09k
      PUSH_BINARY_EXPR(XPATH_OP_ARG, op1, ctxt->comp->last, 0, 0);
9118
1.09k
      nbargs++;
9119
1.09k
      if (CUR == ')') break;
9120
602
      if (CUR != ',') {
9121
238
    xmlFree(name);
9122
238
    xmlFree(prefix);
9123
238
    XP_ERROR(XPATH_EXPR_ERROR);
9124
0
      }
9125
364
      NEXT;
9126
364
      SKIP_BLANKS;
9127
364
  }
9128
887
    }
9129
609
    if (PUSH_LONG_EXPR(XPATH_OP_FUNCTION, nbargs, 0, 0, name, prefix) == -1) {
9130
0
        xmlFree(prefix);
9131
0
        xmlFree(name);
9132
0
    }
9133
609
    NEXT;
9134
609
    SKIP_BLANKS;
9135
609
}
9136
9137
/**
9138
 * xmlXPathCompPrimaryExpr:
9139
 * @ctxt:  the XPath Parser context
9140
 *
9141
 *  [15]   PrimaryExpr ::=   VariableReference
9142
 *                | '(' Expr ')'
9143
 *                | Literal
9144
 *                | Number
9145
 *                | FunctionCall
9146
 *
9147
 * Compile a primary expression.
9148
 */
9149
static void
9150
3.93k
xmlXPathCompPrimaryExpr(xmlXPathParserContextPtr ctxt) {
9151
3.93k
    SKIP_BLANKS;
9152
3.93k
    if (CUR == '$') xmlXPathCompVariableReference(ctxt);
9153
3.88k
    else if (CUR == '(') {
9154
1.09k
  NEXT;
9155
1.09k
  SKIP_BLANKS;
9156
1.09k
  xmlXPathCompileExpr(ctxt, 1);
9157
1.09k
  CHECK_ERROR;
9158
869
  if (CUR != ')') {
9159
120
      XP_ERROR(XPATH_EXPR_ERROR);
9160
0
  }
9161
749
  NEXT;
9162
749
  SKIP_BLANKS;
9163
2.79k
    } else if (IS_ASCII_DIGIT(CUR) || (CUR == '.' && IS_ASCII_DIGIT(NXT(1)))) {
9164
1.06k
  xmlXPathCompNumber(ctxt);
9165
1.73k
    } else if ((CUR == '\'') || (CUR == '"')) {
9166
736
  xmlXPathCompLiteral(ctxt);
9167
994
    } else {
9168
994
  xmlXPathCompFunctionCall(ctxt);
9169
994
    }
9170
3.59k
    SKIP_BLANKS;
9171
3.59k
}
9172
9173
/**
9174
 * xmlXPathCompFilterExpr:
9175
 * @ctxt:  the XPath Parser context
9176
 *
9177
 *  [20]   FilterExpr ::=   PrimaryExpr
9178
 *               | FilterExpr Predicate
9179
 *
9180
 * Compile a filter expression.
9181
 * Square brackets are used to filter expressions in the same way that
9182
 * they are used in location paths. It is an error if the expression to
9183
 * be filtered does not evaluate to a node-set. The context node list
9184
 * used for evaluating the expression in square brackets is the node-set
9185
 * to be filtered listed in document order.
9186
 */
9187
9188
static void
9189
3.93k
xmlXPathCompFilterExpr(xmlXPathParserContextPtr ctxt) {
9190
3.93k
    xmlXPathCompPrimaryExpr(ctxt);
9191
3.93k
    CHECK_ERROR;
9192
3.00k
    SKIP_BLANKS;
9193
9194
3.75k
    while (CUR == '[') {
9195
752
  xmlXPathCompPredicate(ctxt, 1);
9196
752
  SKIP_BLANKS;
9197
752
    }
9198
9199
9200
3.00k
}
9201
9202
/**
9203
 * xmlXPathScanName:
9204
 * @ctxt:  the XPath Parser context
9205
 *
9206
 * Trickery: parse an XML name but without consuming the input flow
9207
 * Needed to avoid insanity in the parser state.
9208
 *
9209
 * [4] NameChar ::= Letter | Digit | '.' | '-' | '_' | ':' |
9210
 *                  CombiningChar | Extender
9211
 *
9212
 * [5] Name ::= (Letter | '_' | ':') (NameChar)*
9213
 *
9214
 * [6] Names ::= Name (S Name)*
9215
 *
9216
 * Returns the Name parsed or NULL
9217
 */
9218
9219
static xmlChar *
9220
14.4k
xmlXPathScanName(xmlXPathParserContextPtr ctxt) {
9221
14.4k
    int l;
9222
14.4k
    int c;
9223
14.4k
    const xmlChar *cur;
9224
14.4k
    xmlChar *ret;
9225
9226
14.4k
    cur = ctxt->cur;
9227
9228
14.4k
    c = CUR_CHAR(l);
9229
14.4k
    if ((c == ' ') || (c == '>') || (c == '/') || /* accelerators */
9230
14.4k
  (!IS_LETTER(c) && (c != '_') &&
9231
13.8k
         (c != ':'))) {
9232
6.82k
  return(NULL);
9233
6.82k
    }
9234
9235
3.77M
    while ((c != ' ') && (c != '>') && (c != '/') && /* test bigname.xml */
9236
3.77M
     ((IS_LETTER(c)) || (IS_DIGIT(c)) ||
9237
3.77M
            (c == '.') || (c == '-') ||
9238
3.77M
      (c == '_') || (c == ':') ||
9239
3.77M
      (IS_COMBINING(c)) ||
9240
3.77M
      (IS_EXTENDER(c)))) {
9241
3.76M
  NEXTL(l);
9242
3.76M
  c = CUR_CHAR(l);
9243
3.76M
    }
9244
7.59k
    ret = xmlStrndup(cur, ctxt->cur - cur);
9245
7.59k
    if (ret == NULL)
9246
0
        xmlXPathPErrMemory(ctxt);
9247
7.59k
    ctxt->cur = cur;
9248
7.59k
    return(ret);
9249
14.4k
}
9250
9251
/**
9252
 * xmlXPathCompPathExpr:
9253
 * @ctxt:  the XPath Parser context
9254
 *
9255
 *  [19]   PathExpr ::=   LocationPath
9256
 *               | FilterExpr
9257
 *               | FilterExpr '/' RelativeLocationPath
9258
 *               | FilterExpr '//' RelativeLocationPath
9259
 *
9260
 * Compile a path expression.
9261
 * The / operator and // operators combine an arbitrary expression
9262
 * and a relative location path. It is an error if the expression
9263
 * does not evaluate to a node-set.
9264
 * The / operator does composition in the same way as when / is
9265
 * used in a location path. As in location paths, // is short for
9266
 * /descendant-or-self::node()/.
9267
 */
9268
9269
static void
9270
98.0k
xmlXPathCompPathExpr(xmlXPathParserContextPtr ctxt) {
9271
98.0k
    int lc = 1;           /* Should we branch to LocationPath ?         */
9272
98.0k
    xmlChar *name = NULL; /* we may have to preparse a name to find out */
9273
9274
98.0k
    SKIP_BLANKS;
9275
98.0k
    if ((CUR == '$') || (CUR == '(') ||
9276
98.0k
  (IS_ASCII_DIGIT(CUR)) ||
9277
98.0k
        (CUR == '\'') || (CUR == '"') ||
9278
98.0k
  (CUR == '.' && IS_ASCII_DIGIT(NXT(1)))) {
9279
2.94k
  lc = 0;
9280
95.0k
    } else if (CUR == '*') {
9281
  /* relative or absolute location path */
9282
75.8k
  lc = 1;
9283
75.8k
    } else if (CUR == '/') {
9284
  /* relative or absolute location path */
9285
4.47k
  lc = 1;
9286
14.7k
    } else if (CUR == '@') {
9287
  /* relative abbreviated attribute location path */
9288
35
  lc = 1;
9289
14.7k
    } else if (CUR == '.') {
9290
  /* relative abbreviated attribute location path */
9291
327
  lc = 1;
9292
14.4k
    } else {
9293
  /*
9294
   * Problem is finding if we have a name here whether it's:
9295
   *   - a nodetype
9296
   *   - a function call in which case it's followed by '('
9297
   *   - an axis in which case it's followed by ':'
9298
   *   - a element name
9299
   * We do an a priori analysis here rather than having to
9300
   * maintain parsed token content through the recursive function
9301
   * calls. This looks uglier but makes the code easier to
9302
   * read/write/debug.
9303
   */
9304
14.4k
  SKIP_BLANKS;
9305
14.4k
  name = xmlXPathScanName(ctxt);
9306
14.4k
  if ((name != NULL) && (xmlStrstr(name, (xmlChar *) "::") != NULL)) {
9307
193
      lc = 1;
9308
193
      xmlFree(name);
9309
14.2k
  } else if (name != NULL) {
9310
7.40k
      int len =xmlStrlen(name);
9311
9312
9313
13.4k
      while (NXT(len) != 0) {
9314
10.9k
    if (NXT(len) == '/') {
9315
        /* element name */
9316
293
        lc = 1;
9317
293
        break;
9318
10.6k
    } else if (IS_BLANK_CH(NXT(len))) {
9319
        /* ignore blanks */
9320
6.07k
        ;
9321
6.07k
    } else if (NXT(len) == ':') {
9322
0
        lc = 1;
9323
0
        break;
9324
4.53k
    } else if ((NXT(len) == '(')) {
9325
        /* Node Type or Function */
9326
1.04k
        if (xmlXPathIsNodeType(name)) {
9327
46
      lc = 1;
9328
994
        } else {
9329
994
      lc = 0;
9330
994
        }
9331
1.04k
                    break;
9332
3.49k
    } else if ((NXT(len) == '[')) {
9333
        /* element name */
9334
3
        lc = 1;
9335
3
        break;
9336
3.49k
    } else if ((NXT(len) == '<') || (NXT(len) == '>') ||
9337
3.49k
         (NXT(len) == '=')) {
9338
867
        lc = 1;
9339
867
        break;
9340
2.62k
    } else {
9341
2.62k
        lc = 1;
9342
2.62k
        break;
9343
2.62k
    }
9344
6.07k
    len++;
9345
6.07k
      }
9346
7.40k
      if (NXT(len) == 0) {
9347
    /* element name */
9348
2.57k
    lc = 1;
9349
2.57k
      }
9350
7.40k
      xmlFree(name);
9351
7.40k
  } else {
9352
      /* make sure all cases are covered explicitly */
9353
6.82k
      XP_ERROR(XPATH_EXPR_ERROR);
9354
0
  }
9355
14.4k
    }
9356
9357
91.2k
    if (lc) {
9358
87.2k
  if (CUR == '/') {
9359
4.47k
      PUSH_LEAVE_EXPR(XPATH_OP_ROOT, 0, 0);
9360
82.7k
  } else {
9361
82.7k
      PUSH_LEAVE_EXPR(XPATH_OP_NODE, 0, 0);
9362
82.7k
  }
9363
87.2k
  xmlXPathCompLocationPath(ctxt);
9364
87.2k
    } else {
9365
3.93k
  xmlXPathCompFilterExpr(ctxt);
9366
3.93k
  CHECK_ERROR;
9367
2.53k
  if ((CUR == '/') && (NXT(1) == '/')) {
9368
57
      SKIP(2);
9369
57
      SKIP_BLANKS;
9370
9371
57
      PUSH_LONG_EXPR(XPATH_OP_COLLECT, AXIS_DESCENDANT_OR_SELF,
9372
57
        NODE_TEST_TYPE, NODE_TYPE_NODE, NULL, NULL);
9373
9374
57
      xmlXPathCompRelativeLocationPath(ctxt);
9375
2.48k
  } else if (CUR == '/') {
9376
145
      xmlXPathCompRelativeLocationPath(ctxt);
9377
145
  }
9378
2.53k
    }
9379
89.8k
    SKIP_BLANKS;
9380
89.8k
}
9381
9382
/**
9383
 * xmlXPathCompUnionExpr:
9384
 * @ctxt:  the XPath Parser context
9385
 *
9386
 *  [18]   UnionExpr ::=   PathExpr
9387
 *               | UnionExpr '|' PathExpr
9388
 *
9389
 * Compile an union expression.
9390
 */
9391
9392
static void
9393
96.8k
xmlXPathCompUnionExpr(xmlXPathParserContextPtr ctxt) {
9394
96.8k
    xmlXPathCompPathExpr(ctxt);
9395
96.8k
    CHECK_ERROR;
9396
87.9k
    SKIP_BLANKS;
9397
89.1k
    while (CUR == '|') {
9398
1.23k
  int op1 = ctxt->comp->last;
9399
1.23k
  PUSH_LEAVE_EXPR(XPATH_OP_NODE, 0, 0);
9400
9401
1.23k
  NEXT;
9402
1.23k
  SKIP_BLANKS;
9403
1.23k
  xmlXPathCompPathExpr(ctxt);
9404
9405
1.23k
  PUSH_BINARY_EXPR(XPATH_OP_UNION, op1, ctxt->comp->last, 0, 0);
9406
9407
1.23k
  SKIP_BLANKS;
9408
1.23k
    }
9409
87.9k
}
9410
9411
/**
9412
 * xmlXPathCompUnaryExpr:
9413
 * @ctxt:  the XPath Parser context
9414
 *
9415
 *  [27]   UnaryExpr ::=   UnionExpr
9416
 *                   | '-' UnaryExpr
9417
 *
9418
 * Compile an unary expression.
9419
 */
9420
9421
static void
9422
96.8k
xmlXPathCompUnaryExpr(xmlXPathParserContextPtr ctxt) {
9423
96.8k
    int minus = 0;
9424
96.8k
    int found = 0;
9425
9426
96.8k
    SKIP_BLANKS;
9427
97.2k
    while (CUR == '-') {
9428
457
        minus = 1 - minus;
9429
457
  found = 1;
9430
457
  NEXT;
9431
457
  SKIP_BLANKS;
9432
457
    }
9433
9434
96.8k
    xmlXPathCompUnionExpr(ctxt);
9435
96.8k
    CHECK_ERROR;
9436
87.9k
    if (found) {
9437
334
  if (minus)
9438
333
      PUSH_UNARY_EXPR(XPATH_OP_PLUS, ctxt->comp->last, 2, 0);
9439
1
  else
9440
1
      PUSH_UNARY_EXPR(XPATH_OP_PLUS, ctxt->comp->last, 3, 0);
9441
334
    }
9442
87.9k
}
9443
9444
/**
9445
 * xmlXPathCompMultiplicativeExpr:
9446
 * @ctxt:  the XPath Parser context
9447
 *
9448
 *  [26]   MultiplicativeExpr ::=   UnaryExpr
9449
 *                   | MultiplicativeExpr MultiplyOperator UnaryExpr
9450
 *                   | MultiplicativeExpr 'div' UnaryExpr
9451
 *                   | MultiplicativeExpr 'mod' UnaryExpr
9452
 *  [34]   MultiplyOperator ::=   '*'
9453
 *
9454
 * Compile an Additive expression.
9455
 */
9456
9457
static void
9458
20.8k
xmlXPathCompMultiplicativeExpr(xmlXPathParserContextPtr ctxt) {
9459
20.8k
    xmlXPathCompUnaryExpr(ctxt);
9460
20.8k
    CHECK_ERROR;
9461
12.0k
    SKIP_BLANKS;
9462
87.9k
    while ((CUR == '*') ||
9463
87.9k
           ((CUR == 'd') && (NXT(1) == 'i') && (NXT(2) == 'v')) ||
9464
87.9k
           ((CUR == 'm') && (NXT(1) == 'o') && (NXT(2) == 'd'))) {
9465
76.0k
  int op = -1;
9466
76.0k
  int op1 = ctxt->comp->last;
9467
9468
76.0k
        if (CUR == '*') {
9469
75.9k
      op = 0;
9470
75.9k
      NEXT;
9471
75.9k
  } else if (CUR == 'd') {
9472
8
      op = 1;
9473
8
      SKIP(3);
9474
21
  } else if (CUR == 'm') {
9475
21
      op = 2;
9476
21
      SKIP(3);
9477
21
  }
9478
76.0k
  SKIP_BLANKS;
9479
76.0k
        xmlXPathCompUnaryExpr(ctxt);
9480
76.0k
  CHECK_ERROR;
9481
75.8k
  PUSH_BINARY_EXPR(XPATH_OP_MULT, op1, ctxt->comp->last, op, 0);
9482
75.8k
  SKIP_BLANKS;
9483
75.8k
    }
9484
12.0k
}
9485
9486
/**
9487
 * xmlXPathCompAdditiveExpr:
9488
 * @ctxt:  the XPath Parser context
9489
 *
9490
 *  [25]   AdditiveExpr ::=   MultiplicativeExpr
9491
 *                   | AdditiveExpr '+' MultiplicativeExpr
9492
 *                   | AdditiveExpr '-' MultiplicativeExpr
9493
 *
9494
 * Compile an Additive expression.
9495
 */
9496
9497
static void
9498
20.7k
xmlXPathCompAdditiveExpr(xmlXPathParserContextPtr ctxt) {
9499
9500
20.7k
    xmlXPathCompMultiplicativeExpr(ctxt);
9501
20.7k
    CHECK_ERROR;
9502
11.8k
    SKIP_BLANKS;
9503
11.9k
    while ((CUR == '+') || (CUR == '-')) {
9504
93
  int plus;
9505
93
  int op1 = ctxt->comp->last;
9506
9507
93
        if (CUR == '+') plus = 1;
9508
25
  else plus = 0;
9509
93
  NEXT;
9510
93
  SKIP_BLANKS;
9511
93
        xmlXPathCompMultiplicativeExpr(ctxt);
9512
93
  CHECK_ERROR;
9513
77
  PUSH_BINARY_EXPR(XPATH_OP_PLUS, op1, ctxt->comp->last, plus, 0);
9514
77
  SKIP_BLANKS;
9515
77
    }
9516
11.8k
}
9517
9518
/**
9519
 * xmlXPathCompRelationalExpr:
9520
 * @ctxt:  the XPath Parser context
9521
 *
9522
 *  [24]   RelationalExpr ::=   AdditiveExpr
9523
 *                 | RelationalExpr '<' AdditiveExpr
9524
 *                 | RelationalExpr '>' AdditiveExpr
9525
 *                 | RelationalExpr '<=' AdditiveExpr
9526
 *                 | RelationalExpr '>=' AdditiveExpr
9527
 *
9528
 *  A <= B > C is allowed ? Answer from James, yes with
9529
 *  (AdditiveExpr <= AdditiveExpr) > AdditiveExpr
9530
 *  which is basically what got implemented.
9531
 *
9532
 * Compile a Relational expression, then push the result
9533
 * on the stack
9534
 */
9535
9536
static void
9537
19.8k
xmlXPathCompRelationalExpr(xmlXPathParserContextPtr ctxt) {
9538
19.8k
    xmlXPathCompAdditiveExpr(ctxt);
9539
19.8k
    CHECK_ERROR;
9540
11.4k
    SKIP_BLANKS;
9541
11.8k
    while ((CUR == '<') || (CUR == '>')) {
9542
854
  int inf, strict;
9543
854
  int op1 = ctxt->comp->last;
9544
9545
854
        if (CUR == '<') inf = 1;
9546
849
  else inf = 0;
9547
854
  if (NXT(1) == '=') strict = 0;
9548
853
  else strict = 1;
9549
854
  NEXT;
9550
854
  if (!strict) NEXT;
9551
854
  SKIP_BLANKS;
9552
854
        xmlXPathCompAdditiveExpr(ctxt);
9553
854
  CHECK_ERROR;
9554
331
  PUSH_BINARY_EXPR(XPATH_OP_CMP, op1, ctxt->comp->last, inf, strict);
9555
331
  SKIP_BLANKS;
9556
331
    }
9557
11.4k
}
9558
9559
/**
9560
 * xmlXPathCompEqualityExpr:
9561
 * @ctxt:  the XPath Parser context
9562
 *
9563
 *  [23]   EqualityExpr ::=   RelationalExpr
9564
 *                 | EqualityExpr '=' RelationalExpr
9565
 *                 | EqualityExpr '!=' RelationalExpr
9566
 *
9567
 *  A != B != C is allowed ? Answer from James, yes with
9568
 *  (RelationalExpr = RelationalExpr) = RelationalExpr
9569
 *  (RelationalExpr != RelationalExpr) != RelationalExpr
9570
 *  which is basically what got implemented.
9571
 *
9572
 * Compile an Equality expression.
9573
 *
9574
 */
9575
static void
9576
19.2k
xmlXPathCompEqualityExpr(xmlXPathParserContextPtr ctxt) {
9577
19.2k
    xmlXPathCompRelationalExpr(ctxt);
9578
19.2k
    CHECK_ERROR;
9579
10.4k
    SKIP_BLANKS;
9580
10.9k
    while ((CUR == '=') || ((CUR == '!') && (NXT(1) == '='))) {
9581
623
  int eq;
9582
623
  int op1 = ctxt->comp->last;
9583
9584
623
        if (CUR == '=') eq = 1;
9585
10
  else eq = 0;
9586
623
  NEXT;
9587
623
  if (!eq) NEXT;
9588
623
  SKIP_BLANKS;
9589
623
        xmlXPathCompRelationalExpr(ctxt);
9590
623
  CHECK_ERROR;
9591
526
  PUSH_BINARY_EXPR(XPATH_OP_EQUAL, op1, ctxt->comp->last, eq, 0);
9592
526
  SKIP_BLANKS;
9593
526
    }
9594
10.4k
}
9595
9596
/**
9597
 * xmlXPathCompAndExpr:
9598
 * @ctxt:  the XPath Parser context
9599
 *
9600
 *  [22]   AndExpr ::=   EqualityExpr
9601
 *                 | AndExpr 'and' EqualityExpr
9602
 *
9603
 * Compile an AND expression.
9604
 *
9605
 */
9606
static void
9607
19.2k
xmlXPathCompAndExpr(xmlXPathParserContextPtr ctxt) {
9608
19.2k
    xmlXPathCompEqualityExpr(ctxt);
9609
19.2k
    CHECK_ERROR;
9610
10.3k
    SKIP_BLANKS;
9611
10.3k
    while ((CUR == 'a') && (NXT(1) == 'n') && (NXT(2) == 'd')) {
9612
0
  int op1 = ctxt->comp->last;
9613
0
        SKIP(3);
9614
0
  SKIP_BLANKS;
9615
0
        xmlXPathCompEqualityExpr(ctxt);
9616
0
  CHECK_ERROR;
9617
0
  PUSH_BINARY_EXPR(XPATH_OP_AND, op1, ctxt->comp->last, 0, 0);
9618
0
  SKIP_BLANKS;
9619
0
    }
9620
10.3k
}
9621
9622
/**
9623
 * xmlXPathCompileExpr:
9624
 * @ctxt:  the XPath Parser context
9625
 *
9626
 *  [14]   Expr ::=   OrExpr
9627
 *  [21]   OrExpr ::=   AndExpr
9628
 *                 | OrExpr 'or' AndExpr
9629
 *
9630
 * Parse and compile an expression
9631
 */
9632
static void
9633
19.1k
xmlXPathCompileExpr(xmlXPathParserContextPtr ctxt, int sort) {
9634
19.1k
    xmlXPathContextPtr xpctxt = ctxt->context;
9635
9636
19.1k
    if (xpctxt != NULL) {
9637
19.1k
        if (xpctxt->depth >= XPATH_MAX_RECURSION_DEPTH)
9638
19.1k
            XP_ERROR(XPATH_RECURSION_LIMIT_EXCEEDED);
9639
        /*
9640
         * Parsing a single '(' pushes about 10 functions on the call stack
9641
         * before recursing!
9642
         */
9643
19.1k
        xpctxt->depth += 10;
9644
19.1k
    }
9645
9646
19.1k
    xmlXPathCompAndExpr(ctxt);
9647
19.1k
    CHECK_ERROR;
9648
10.2k
    SKIP_BLANKS;
9649
10.3k
    while ((CUR == 'o') && (NXT(1) == 'r')) {
9650
55
  int op1 = ctxt->comp->last;
9651
55
        SKIP(2);
9652
55
  SKIP_BLANKS;
9653
55
        xmlXPathCompAndExpr(ctxt);
9654
55
  CHECK_ERROR;
9655
46
  PUSH_BINARY_EXPR(XPATH_OP_OR, op1, ctxt->comp->last, 0, 0);
9656
46
  SKIP_BLANKS;
9657
46
    }
9658
10.2k
    if ((sort) && (ctxt->comp->steps[ctxt->comp->last].op != XPATH_OP_VALUE)) {
9659
  /* more ops could be optimized too */
9660
  /*
9661
  * This is the main place to eliminate sorting for
9662
  * operations which don't require a sorted node-set.
9663
  * E.g. count().
9664
  */
9665
9.23k
  PUSH_UNARY_EXPR(XPATH_OP_SORT, ctxt->comp->last , 0, 0);
9666
9.23k
    }
9667
9668
10.2k
    if (xpctxt != NULL)
9669
10.2k
        xpctxt->depth -= 10;
9670
10.2k
}
9671
9672
/**
9673
 * xmlXPathCompPredicate:
9674
 * @ctxt:  the XPath Parser context
9675
 * @filter:  act as a filter
9676
 *
9677
 *  [8]   Predicate ::=   '[' PredicateExpr ']'
9678
 *  [9]   PredicateExpr ::=   Expr
9679
 *
9680
 * Compile a predicate expression
9681
 */
9682
static void
9683
1.19k
xmlXPathCompPredicate(xmlXPathParserContextPtr ctxt, int filter) {
9684
1.19k
    int op1 = ctxt->comp->last;
9685
9686
1.19k
    SKIP_BLANKS;
9687
1.19k
    if (CUR != '[') {
9688
0
  XP_ERROR(XPATH_INVALID_PREDICATE_ERROR);
9689
0
    }
9690
1.19k
    NEXT;
9691
1.19k
    SKIP_BLANKS;
9692
9693
1.19k
    ctxt->comp->last = -1;
9694
    /*
9695
    * This call to xmlXPathCompileExpr() will deactivate sorting
9696
    * of the predicate result.
9697
    * TODO: Sorting is still activated for filters, since I'm not
9698
    *  sure if needed. Normally sorting should not be needed, since
9699
    *  a filter can only diminish the number of items in a sequence,
9700
    *  but won't change its order; so if the initial sequence is sorted,
9701
    *  subsequent sorting is not needed.
9702
    */
9703
1.19k
    if (! filter)
9704
439
  xmlXPathCompileExpr(ctxt, 0);
9705
752
    else
9706
752
  xmlXPathCompileExpr(ctxt, 1);
9707
1.19k
    CHECK_ERROR;
9708
9709
926
    if (CUR != ']') {
9710
271
  XP_ERROR(XPATH_INVALID_PREDICATE_ERROR);
9711
0
    }
9712
9713
655
    if (filter)
9714
288
  PUSH_BINARY_EXPR(XPATH_OP_FILTER, op1, ctxt->comp->last, 0, 0);
9715
367
    else
9716
367
  PUSH_BINARY_EXPR(XPATH_OP_PREDICATE, op1, ctxt->comp->last, 0, 0);
9717
9718
655
    NEXT;
9719
655
    SKIP_BLANKS;
9720
655
}
9721
9722
/**
9723
 * xmlXPathCompNodeTest:
9724
 * @ctxt:  the XPath Parser context
9725
 * @test:  pointer to a xmlXPathTestVal
9726
 * @type:  pointer to a xmlXPathTypeVal
9727
 * @prefix:  placeholder for a possible name prefix
9728
 *
9729
 * [7] NodeTest ::=   NameTest
9730
 *        | NodeType '(' ')'
9731
 *        | 'processing-instruction' '(' Literal ')'
9732
 *
9733
 * [37] NameTest ::=  '*'
9734
 *        | NCName ':' '*'
9735
 *        | QName
9736
 * [38] NodeType ::= 'comment'
9737
 *       | 'text'
9738
 *       | 'processing-instruction'
9739
 *       | 'node'
9740
 *
9741
 * Returns the name found and updates @test, @type and @prefix appropriately
9742
 */
9743
static xmlChar *
9744
xmlXPathCompNodeTest(xmlXPathParserContextPtr ctxt, xmlXPathTestVal *test,
9745
               xmlXPathTypeVal *type, xmlChar **prefix,
9746
678k
         xmlChar *name) {
9747
678k
    int blanks;
9748
9749
678k
    if ((test == NULL) || (type == NULL) || (prefix == NULL)) {
9750
0
  return(NULL);
9751
0
    }
9752
678k
    *type = (xmlXPathTypeVal) 0;
9753
678k
    *test = (xmlXPathTestVal) 0;
9754
678k
    *prefix = NULL;
9755
678k
    SKIP_BLANKS;
9756
9757
678k
    if ((name == NULL) && (CUR == '*')) {
9758
  /*
9759
   * All elements
9760
   */
9761
82.2k
  NEXT;
9762
82.2k
  *test = NODE_TEST_ALL;
9763
82.2k
  return(NULL);
9764
82.2k
    }
9765
9766
596k
    if (name == NULL)
9767
381
  name = xmlXPathParseNCName(ctxt);
9768
596k
    if (name == NULL) {
9769
219
  XP_ERRORNULL(XPATH_EXPR_ERROR);
9770
0
    }
9771
9772
595k
    blanks = IS_BLANK_CH(CUR);
9773
595k
    SKIP_BLANKS;
9774
595k
    if (CUR == '(') {
9775
1.07k
  NEXT;
9776
  /*
9777
   * NodeType or PI search
9778
   */
9779
1.07k
  if (xmlStrEqual(name, BAD_CAST "comment"))
9780
40
      *type = NODE_TYPE_COMMENT;
9781
1.03k
  else if (xmlStrEqual(name, BAD_CAST "node"))
9782
988
      *type = NODE_TYPE_NODE;
9783
45
  else if (xmlStrEqual(name, BAD_CAST "processing-instruction"))
9784
17
      *type = NODE_TYPE_PI;
9785
28
  else if (xmlStrEqual(name, BAD_CAST "text"))
9786
23
      *type = NODE_TYPE_TEXT;
9787
5
  else {
9788
5
      if (name != NULL)
9789
5
    xmlFree(name);
9790
5
      XP_ERRORNULL(XPATH_EXPR_ERROR);
9791
0
  }
9792
9793
1.06k
  *test = NODE_TEST_TYPE;
9794
9795
1.06k
  SKIP_BLANKS;
9796
1.06k
  if (*type == NODE_TYPE_PI) {
9797
      /*
9798
       * Specific case: search a PI by name.
9799
       */
9800
17
      if (name != NULL)
9801
17
    xmlFree(name);
9802
17
      name = NULL;
9803
17
      if (CUR != ')') {
9804
0
    name = xmlXPathParseLiteral(ctxt);
9805
0
    *test = NODE_TEST_PI;
9806
0
    SKIP_BLANKS;
9807
0
      }
9808
17
  }
9809
1.06k
  if (CUR != ')') {
9810
0
      if (name != NULL)
9811
0
    xmlFree(name);
9812
0
      XP_ERRORNULL(XPATH_UNCLOSED_ERROR);
9813
0
  }
9814
1.06k
  NEXT;
9815
1.06k
  return(name);
9816
1.06k
    }
9817
594k
    *test = NODE_TEST_NAME;
9818
594k
    if ((!blanks) && (CUR == ':')) {
9819
464
  NEXT;
9820
9821
  /*
9822
   * Since currently the parser context don't have a
9823
   * namespace list associated:
9824
   * The namespace name for this prefix can be computed
9825
   * only at evaluation time. The compilation is done
9826
   * outside of any context.
9827
   */
9828
464
  *prefix = name;
9829
9830
464
  if (CUR == '*') {
9831
      /*
9832
       * All elements
9833
       */
9834
0
      NEXT;
9835
0
      *test = NODE_TEST_ALL;
9836
0
      return(NULL);
9837
0
  }
9838
9839
464
  name = xmlXPathParseNCName(ctxt);
9840
464
  if (name == NULL) {
9841
199
      XP_ERRORNULL(XPATH_EXPR_ERROR);
9842
0
  }
9843
464
    }
9844
594k
    return(name);
9845
594k
}
9846
9847
/**
9848
 * xmlXPathIsAxisName:
9849
 * @name:  a preparsed name token
9850
 *
9851
 * [6] AxisName ::=   'ancestor'
9852
 *                  | 'ancestor-or-self'
9853
 *                  | 'attribute'
9854
 *                  | 'child'
9855
 *                  | 'descendant'
9856
 *                  | 'descendant-or-self'
9857
 *                  | 'following'
9858
 *                  | 'following-sibling'
9859
 *                  | 'namespace'
9860
 *                  | 'parent'
9861
 *                  | 'preceding'
9862
 *                  | 'preceding-sibling'
9863
 *                  | 'self'
9864
 *
9865
 * Returns the axis or 0
9866
 */
9867
static xmlXPathAxisVal
9868
596k
xmlXPathIsAxisName(const xmlChar *name) {
9869
596k
    xmlXPathAxisVal ret = (xmlXPathAxisVal) 0;
9870
596k
    switch (name[0]) {
9871
73.8k
  case 'a':
9872
73.8k
      if (xmlStrEqual(name, BAD_CAST "ancestor"))
9873
3
    ret = AXIS_ANCESTOR;
9874
73.8k
      if (xmlStrEqual(name, BAD_CAST "ancestor-or-self"))
9875
0
    ret = AXIS_ANCESTOR_OR_SELF;
9876
73.8k
      if (xmlStrEqual(name, BAD_CAST "attribute"))
9877
0
    ret = AXIS_ATTRIBUTE;
9878
73.8k
      break;
9879
737
  case 'c':
9880
737
      if (xmlStrEqual(name, BAD_CAST "child"))
9881
1
    ret = AXIS_CHILD;
9882
737
      break;
9883
271
  case 'd':
9884
271
      if (xmlStrEqual(name, BAD_CAST "descendant"))
9885
11
    ret = AXIS_DESCENDANT;
9886
271
      if (xmlStrEqual(name, BAD_CAST "descendant-or-self"))
9887
24
    ret = AXIS_DESCENDANT_OR_SELF;
9888
271
      break;
9889
46
  case 'f':
9890
46
      if (xmlStrEqual(name, BAD_CAST "following"))
9891
43
    ret = AXIS_FOLLOWING;
9892
46
      if (xmlStrEqual(name, BAD_CAST "following-sibling"))
9893
3
    ret = AXIS_FOLLOWING_SIBLING;
9894
46
      break;
9895
2.03k
  case 'n':
9896
2.03k
      if (xmlStrEqual(name, BAD_CAST "namespace"))
9897
834
    ret = AXIS_NAMESPACE;
9898
2.03k
      break;
9899
115
  case 'p':
9900
115
      if (xmlStrEqual(name, BAD_CAST "parent"))
9901
1
    ret = AXIS_PARENT;
9902
115
      if (xmlStrEqual(name, BAD_CAST "preceding"))
9903
4
    ret = AXIS_PRECEDING;
9904
115
      if (xmlStrEqual(name, BAD_CAST "preceding-sibling"))
9905
43
    ret = AXIS_PRECEDING_SIBLING;
9906
115
      break;
9907
98
  case 's':
9908
98
      if (xmlStrEqual(name, BAD_CAST "self"))
9909
0
    ret = AXIS_SELF;
9910
98
      break;
9911
596k
    }
9912
596k
    return(ret);
9913
596k
}
9914
9915
/**
9916
 * xmlXPathCompStep:
9917
 * @ctxt:  the XPath Parser context
9918
 *
9919
 * [4] Step ::=   AxisSpecifier NodeTest Predicate*
9920
 *                  | AbbreviatedStep
9921
 *
9922
 * [12] AbbreviatedStep ::=   '.' | '..'
9923
 *
9924
 * [5] AxisSpecifier ::= AxisName '::'
9925
 *                  | AbbreviatedAxisSpecifier
9926
 *
9927
 * [13] AbbreviatedAxisSpecifier ::= '@'?
9928
 *
9929
 * Modified for XPtr range support as:
9930
 *
9931
 *  [4xptr] Step ::= AxisSpecifier NodeTest Predicate*
9932
 *                     | AbbreviatedStep
9933
 *                     | 'range-to' '(' Expr ')' Predicate*
9934
 *
9935
 * Compile one step in a Location Path
9936
 * A location step of . is short for self::node(). This is
9937
 * particularly useful in conjunction with //. For example, the
9938
 * location path .//para is short for
9939
 * self::node()/descendant-or-self::node()/child::para
9940
 * and so will select all para descendant elements of the context
9941
 * node.
9942
 * Similarly, a location step of .. is short for parent::node().
9943
 * For example, ../title is short for parent::node()/child::title
9944
 * and so will select the title children of the parent of the context
9945
 * node.
9946
 */
9947
static void
9948
680k
xmlXPathCompStep(xmlXPathParserContextPtr ctxt) {
9949
680k
    SKIP_BLANKS;
9950
680k
    if ((CUR == '.') && (NXT(1) == '.')) {
9951
56
  SKIP(2);
9952
56
  SKIP_BLANKS;
9953
56
  PUSH_LONG_EXPR(XPATH_OP_COLLECT, AXIS_PARENT,
9954
56
        NODE_TEST_TYPE, NODE_TYPE_NODE, NULL, NULL);
9955
680k
    } else if (CUR == '.') {
9956
1.33k
  NEXT;
9957
1.33k
  SKIP_BLANKS;
9958
678k
    } else {
9959
678k
  xmlChar *name = NULL;
9960
678k
  xmlChar *prefix = NULL;
9961
678k
  xmlXPathTestVal test = (xmlXPathTestVal) 0;
9962
678k
  xmlXPathAxisVal axis = (xmlXPathAxisVal) 0;
9963
678k
  xmlXPathTypeVal type = (xmlXPathTypeVal) 0;
9964
678k
  int op1;
9965
9966
678k
  if (CUR == '*') {
9967
81.4k
      axis = AXIS_CHILD;
9968
597k
  } else {
9969
597k
      if (name == NULL)
9970
597k
    name = xmlXPathParseNCName(ctxt);
9971
597k
      if (name != NULL) {
9972
596k
    axis = xmlXPathIsAxisName(name);
9973
596k
    if (axis != 0) {
9974
967
        SKIP_BLANKS;
9975
967
        if ((CUR == ':') && (NXT(1) == ':')) {
9976
967
      SKIP(2);
9977
967
      xmlFree(name);
9978
967
      name = NULL;
9979
967
        } else {
9980
      /* an element name can conflict with an axis one :-\ */
9981
0
      axis = AXIS_CHILD;
9982
0
        }
9983
596k
    } else {
9984
596k
        axis = AXIS_CHILD;
9985
596k
    }
9986
596k
      } else if (CUR == '@') {
9987
46
    NEXT;
9988
46
    axis = AXIS_ATTRIBUTE;
9989
325
      } else {
9990
325
    axis = AXIS_CHILD;
9991
325
      }
9992
597k
  }
9993
9994
678k
        if (ctxt->error != XPATH_EXPRESSION_OK) {
9995
413
            xmlFree(name);
9996
413
            return;
9997
413
        }
9998
9999
678k
  name = xmlXPathCompNodeTest(ctxt, &test, &type, &prefix, name);
10000
678k
  if (test == 0)
10001
224
      return;
10002
10003
678k
        if ((prefix != NULL) && (ctxt->context != NULL) &&
10004
678k
      (ctxt->context->flags & XML_XPATH_CHECKNS)) {
10005
0
      if (xmlXPathNsLookup(ctxt->context, prefix) == NULL) {
10006
0
    xmlXPathErr(ctxt, XPATH_UNDEF_PREFIX_ERROR);
10007
0
      }
10008
0
  }
10009
10010
678k
  op1 = ctxt->comp->last;
10011
678k
  ctxt->comp->last = -1;
10012
10013
678k
  SKIP_BLANKS;
10014
678k
  while (CUR == '[') {
10015
439
      xmlXPathCompPredicate(ctxt, 0);
10016
439
  }
10017
10018
678k
        if (PUSH_FULL_EXPR(XPATH_OP_COLLECT, op1, ctxt->comp->last, axis,
10019
678k
                           test, type, (void *)prefix, (void *)name) == -1) {
10020
0
            xmlFree(prefix);
10021
0
            xmlFree(name);
10022
0
        }
10023
678k
    }
10024
680k
}
10025
10026
/**
10027
 * xmlXPathCompRelativeLocationPath:
10028
 * @ctxt:  the XPath Parser context
10029
 *
10030
 *  [3]   RelativeLocationPath ::=   Step
10031
 *                     | RelativeLocationPath '/' Step
10032
 *                     | AbbreviatedRelativeLocationPath
10033
 *  [11]  AbbreviatedRelativeLocationPath ::=   RelativeLocationPath '//' Step
10034
 *
10035
 * Compile a relative location path.
10036
 */
10037
static void
10038
xmlXPathCompRelativeLocationPath
10039
86.9k
(xmlXPathParserContextPtr ctxt) {
10040
86.9k
    SKIP_BLANKS;
10041
86.9k
    if ((CUR == '/') && (NXT(1) == '/')) {
10042
14
  SKIP(2);
10043
14
  SKIP_BLANKS;
10044
14
  PUSH_LONG_EXPR(XPATH_OP_COLLECT, AXIS_DESCENDANT_OR_SELF,
10045
14
             NODE_TEST_TYPE, NODE_TYPE_NODE, NULL, NULL);
10046
86.9k
    } else if (CUR == '/') {
10047
251
      NEXT;
10048
251
  SKIP_BLANKS;
10049
251
    }
10050
86.9k
    xmlXPathCompStep(ctxt);
10051
86.9k
    CHECK_ERROR;
10052
86.3k
    SKIP_BLANKS;
10053
679k
    while (CUR == '/') {
10054
593k
  if ((CUR == '/') && (NXT(1) == '/')) {
10055
66.4k
      SKIP(2);
10056
66.4k
      SKIP_BLANKS;
10057
66.4k
      PUSH_LONG_EXPR(XPATH_OP_COLLECT, AXIS_DESCENDANT_OR_SELF,
10058
66.4k
           NODE_TEST_TYPE, NODE_TYPE_NODE, NULL, NULL);
10059
66.4k
      xmlXPathCompStep(ctxt);
10060
526k
  } else if (CUR == '/') {
10061
526k
      NEXT;
10062
526k
      SKIP_BLANKS;
10063
526k
      xmlXPathCompStep(ctxt);
10064
526k
  }
10065
593k
  SKIP_BLANKS;
10066
593k
    }
10067
86.3k
}
10068
10069
/**
10070
 * xmlXPathCompLocationPath:
10071
 * @ctxt:  the XPath Parser context
10072
 *
10073
 *  [1]   LocationPath ::=   RelativeLocationPath
10074
 *                     | AbsoluteLocationPath
10075
 *  [2]   AbsoluteLocationPath ::=   '/' RelativeLocationPath?
10076
 *                     | AbbreviatedAbsoluteLocationPath
10077
 *  [10]   AbbreviatedAbsoluteLocationPath ::=
10078
 *                           '//' RelativeLocationPath
10079
 *
10080
 * Compile a location path
10081
 *
10082
 * // is short for /descendant-or-self::node()/. For example,
10083
 * //para is short for /descendant-or-self::node()/child::para and
10084
 * so will select any para element in the document (even a para element
10085
 * that is a document element will be selected by //para since the
10086
 * document element node is a child of the root node); div//para is
10087
 * short for div/descendant-or-self::node()/child::para and so will
10088
 * select all para descendants of div children.
10089
 */
10090
static void
10091
87.2k
xmlXPathCompLocationPath(xmlXPathParserContextPtr ctxt) {
10092
87.2k
    SKIP_BLANKS;
10093
87.2k
    if (CUR != '/') {
10094
82.7k
        xmlXPathCompRelativeLocationPath(ctxt);
10095
82.7k
    } else {
10096
8.80k
  while (CUR == '/') {
10097
4.47k
      if ((CUR == '/') && (NXT(1) == '/')) {
10098
2.30k
    SKIP(2);
10099
2.30k
    SKIP_BLANKS;
10100
2.30k
    PUSH_LONG_EXPR(XPATH_OP_COLLECT, AXIS_DESCENDANT_OR_SELF,
10101
2.30k
           NODE_TEST_TYPE, NODE_TYPE_NODE, NULL, NULL);
10102
2.30k
    xmlXPathCompRelativeLocationPath(ctxt);
10103
2.30k
      } else if (CUR == '/') {
10104
2.17k
    NEXT;
10105
2.17k
    SKIP_BLANKS;
10106
2.17k
    if ((CUR != 0) &&
10107
2.17k
        ((IS_ASCII_LETTER(CUR)) || (CUR >= 0x80) ||
10108
2.16k
                     (CUR == '_') || (CUR == '.') ||
10109
2.16k
         (CUR == '@') || (CUR == '*')))
10110
1.63k
        xmlXPathCompRelativeLocationPath(ctxt);
10111
2.17k
      }
10112
4.47k
      CHECK_ERROR;
10113
4.47k
  }
10114
4.47k
    }
10115
87.2k
}
10116
10117
/************************************************************************
10118
 *                  *
10119
 *    XPath precompiled expression evaluation     *
10120
 *                  *
10121
 ************************************************************************/
10122
10123
static int
10124
xmlXPathCompOpEval(xmlXPathParserContextPtr ctxt, xmlXPathStepOpPtr op);
10125
10126
/**
10127
 * xmlXPathNodeSetFilter:
10128
 * @ctxt:  the XPath Parser context
10129
 * @set: the node set to filter
10130
 * @filterOpIndex: the index of the predicate/filter op
10131
 * @minPos: minimum position in the filtered set (1-based)
10132
 * @maxPos: maximum position in the filtered set (1-based)
10133
 * @hasNsNodes: true if the node set may contain namespace nodes
10134
 *
10135
 * Filter a node set, keeping only nodes for which the predicate expression
10136
 * matches. Afterwards, keep only nodes between minPos and maxPos in the
10137
 * filtered result.
10138
 */
10139
static void
10140
xmlXPathNodeSetFilter(xmlXPathParserContextPtr ctxt,
10141
          xmlNodeSetPtr set,
10142
          int filterOpIndex,
10143
                      int minPos, int maxPos,
10144
          int hasNsNodes)
10145
19.4k
{
10146
19.4k
    xmlXPathContextPtr xpctxt;
10147
19.4k
    xmlNodePtr oldnode;
10148
19.4k
    xmlDocPtr olddoc;
10149
19.4k
    xmlXPathStepOpPtr filterOp;
10150
19.4k
    int oldcs, oldpp;
10151
19.4k
    int i, j, pos;
10152
10153
19.4k
    if ((set == NULL) || (set->nodeNr == 0))
10154
0
        return;
10155
10156
    /*
10157
    * Check if the node set contains a sufficient number of nodes for
10158
    * the requested range.
10159
    */
10160
19.4k
    if (set->nodeNr < minPos) {
10161
0
        xmlXPathNodeSetClear(set, hasNsNodes);
10162
0
        return;
10163
0
    }
10164
10165
19.4k
    xpctxt = ctxt->context;
10166
19.4k
    oldnode = xpctxt->node;
10167
19.4k
    olddoc = xpctxt->doc;
10168
19.4k
    oldcs = xpctxt->contextSize;
10169
19.4k
    oldpp = xpctxt->proximityPosition;
10170
19.4k
    filterOp = &ctxt->comp->steps[filterOpIndex];
10171
10172
19.4k
    xpctxt->contextSize = set->nodeNr;
10173
10174
1.01M
    for (i = 0, j = 0, pos = 1; i < set->nodeNr; i++) {
10175
1.00M
        xmlNodePtr node = set->nodeTab[i];
10176
1.00M
        int res;
10177
10178
1.00M
        xpctxt->node = node;
10179
1.00M
        xpctxt->proximityPosition = i + 1;
10180
10181
        /*
10182
        * Also set the xpath document in case things like
10183
        * key() are evaluated in the predicate.
10184
        *
10185
        * TODO: Get real doc for namespace nodes.
10186
        */
10187
1.00M
        if ((node->type != XML_NAMESPACE_DECL) &&
10188
1.00M
            (node->doc != NULL))
10189
1.00M
            xpctxt->doc = node->doc;
10190
10191
1.00M
        res = xmlXPathCompOpEvalToBoolean(ctxt, filterOp, 1);
10192
10193
1.00M
        if (ctxt->error != XPATH_EXPRESSION_OK)
10194
180
            break;
10195
1.00M
        if (res < 0) {
10196
            /* Shouldn't happen */
10197
0
            xmlXPathErr(ctxt, XPATH_EXPR_ERROR);
10198
0
            break;
10199
0
        }
10200
10201
1.00M
        if ((res != 0) && ((pos >= minPos) && (pos <= maxPos))) {
10202
662k
            if (i != j) {
10203
1.53k
                set->nodeTab[j] = node;
10204
1.53k
                set->nodeTab[i] = NULL;
10205
1.53k
            }
10206
10207
662k
            j += 1;
10208
662k
        } else {
10209
            /* Remove the entry from the initial node set. */
10210
340k
            set->nodeTab[i] = NULL;
10211
340k
            if (node->type == XML_NAMESPACE_DECL)
10212
30
                xmlXPathNodeSetFreeNs((xmlNsPtr) node);
10213
340k
        }
10214
10215
1.00M
        if (res != 0) {
10216
662k
            if (pos == maxPos) {
10217
2.91k
                i += 1;
10218
2.91k
                break;
10219
2.91k
            }
10220
10221
660k
            pos += 1;
10222
660k
        }
10223
1.00M
    }
10224
10225
    /* Free remaining nodes. */
10226
19.4k
    if (hasNsNodes) {
10227
2.53M
        for (; i < set->nodeNr; i++) {
10228
2.53M
            xmlNodePtr node = set->nodeTab[i];
10229
2.53M
            if ((node != NULL) && (node->type == XML_NAMESPACE_DECL))
10230
1
                xmlXPathNodeSetFreeNs((xmlNsPtr) node);
10231
2.53M
        }
10232
731
    }
10233
10234
19.4k
    set->nodeNr = j;
10235
10236
    /* If too many elements were removed, shrink table to preserve memory. */
10237
19.4k
    if ((set->nodeMax > XML_NODESET_DEFAULT) &&
10238
19.4k
        (set->nodeNr < set->nodeMax / 2)) {
10239
4.30k
        xmlNodePtr *tmp;
10240
4.30k
        int nodeMax = set->nodeNr;
10241
10242
4.30k
        if (nodeMax < XML_NODESET_DEFAULT)
10243
4.27k
            nodeMax = XML_NODESET_DEFAULT;
10244
4.30k
        tmp = (xmlNodePtr *) xmlRealloc(set->nodeTab,
10245
4.30k
                nodeMax * sizeof(xmlNodePtr));
10246
4.30k
        if (tmp == NULL) {
10247
71
            xmlXPathPErrMemory(ctxt);
10248
4.23k
        } else {
10249
4.23k
            set->nodeTab = tmp;
10250
4.23k
            set->nodeMax = nodeMax;
10251
4.23k
        }
10252
4.30k
    }
10253
10254
19.4k
    xpctxt->node = oldnode;
10255
19.4k
    xpctxt->doc = olddoc;
10256
19.4k
    xpctxt->contextSize = oldcs;
10257
19.4k
    xpctxt->proximityPosition = oldpp;
10258
19.4k
}
10259
10260
/**
10261
 * xmlXPathCompOpEvalPredicate:
10262
 * @ctxt:  the XPath Parser context
10263
 * @op: the predicate op
10264
 * @set: the node set to filter
10265
 * @minPos: minimum position in the filtered set (1-based)
10266
 * @maxPos: maximum position in the filtered set (1-based)
10267
 * @hasNsNodes: true if the node set may contain namespace nodes
10268
 *
10269
 * Filter a node set, keeping only nodes for which the sequence of predicate
10270
 * expressions matches. Afterwards, keep only nodes between minPos and maxPos
10271
 * in the filtered result.
10272
 */
10273
static void
10274
xmlXPathCompOpEvalPredicate(xmlXPathParserContextPtr ctxt,
10275
          xmlXPathStepOpPtr op,
10276
          xmlNodeSetPtr set,
10277
                            int minPos, int maxPos,
10278
          int hasNsNodes)
10279
18.7k
{
10280
18.7k
    if (op->ch1 != -1) {
10281
268
  xmlXPathCompExprPtr comp = ctxt->comp;
10282
  /*
10283
  * Process inner predicates first.
10284
  */
10285
268
  if (comp->steps[op->ch1].op != XPATH_OP_PREDICATE) {
10286
0
            XP_ERROR(XPATH_INVALID_OPERAND);
10287
0
  }
10288
268
        if (ctxt->context->depth >= XPATH_MAX_RECURSION_DEPTH)
10289
268
            XP_ERROR(XPATH_RECURSION_LIMIT_EXCEEDED);
10290
268
        ctxt->context->depth += 1;
10291
268
  xmlXPathCompOpEvalPredicate(ctxt, &comp->steps[op->ch1], set,
10292
268
                                    1, set->nodeNr, hasNsNodes);
10293
268
        ctxt->context->depth -= 1;
10294
268
  CHECK_ERROR;
10295
268
    }
10296
10297
18.7k
    if (op->ch2 != -1)
10298
18.7k
        xmlXPathNodeSetFilter(ctxt, set, op->ch2, minPos, maxPos, hasNsNodes);
10299
18.7k
}
10300
10301
static int
10302
xmlXPathIsPositionalPredicate(xmlXPathParserContextPtr ctxt,
10303
          xmlXPathStepOpPtr op,
10304
          int *maxPos)
10305
219
{
10306
10307
219
    xmlXPathStepOpPtr exprOp;
10308
10309
    /*
10310
    * BIG NOTE: This is not intended for XPATH_OP_FILTER yet!
10311
    */
10312
10313
    /*
10314
    * If not -1, then ch1 will point to:
10315
    * 1) For predicates (XPATH_OP_PREDICATE):
10316
    *    - an inner predicate operator
10317
    * 2) For filters (XPATH_OP_FILTER):
10318
    *    - an inner filter operator OR
10319
    *    - an expression selecting the node set.
10320
    *      E.g. "key('a', 'b')" or "(//foo | //bar)".
10321
    */
10322
219
    if ((op->op != XPATH_OP_PREDICATE) && (op->op != XPATH_OP_FILTER))
10323
0
  return(0);
10324
10325
219
    if (op->ch2 != -1) {
10326
219
  exprOp = &ctxt->comp->steps[op->ch2];
10327
219
    } else
10328
0
  return(0);
10329
10330
219
    if ((exprOp != NULL) &&
10331
219
  (exprOp->op == XPATH_OP_VALUE) &&
10332
219
  (exprOp->value4 != NULL) &&
10333
219
  (((xmlXPathObjectPtr) exprOp->value4)->type == XPATH_NUMBER))
10334
2
    {
10335
2
        double floatval = ((xmlXPathObjectPtr) exprOp->value4)->floatval;
10336
10337
  /*
10338
  * We have a "[n]" predicate here.
10339
  * TODO: Unfortunately this simplistic test here is not
10340
  * able to detect a position() predicate in compound
10341
  * expressions like "[@attr = 'a" and position() = 1],
10342
  * and even not the usage of position() in
10343
  * "[position() = 1]"; thus - obviously - a position-range,
10344
  * like it "[position() < 5]", is also not detected.
10345
  * Maybe we could rewrite the AST to ease the optimization.
10346
  */
10347
10348
2
        if ((floatval > INT_MIN) && (floatval < INT_MAX)) {
10349
2
      *maxPos = (int) floatval;
10350
2
            if (floatval == (double) *maxPos)
10351
2
                return(1);
10352
2
        }
10353
2
    }
10354
217
    return(0);
10355
219
}
10356
10357
static int
10358
xmlXPathNodeCollectAndTest(xmlXPathParserContextPtr ctxt,
10359
                           xmlXPathStepOpPtr op,
10360
         xmlNodePtr * first, xmlNodePtr * last,
10361
         int toBool)
10362
432k
{
10363
10364
432k
#define XP_TEST_HIT \
10365
26.9M
    if (hasAxisRange != 0) { \
10366
0
  if (++pos == maxPos) { \
10367
0
      if (addNode(seq, cur) < 0) \
10368
0
          xmlXPathPErrMemory(ctxt); \
10369
0
      goto axis_range_end; } \
10370
26.9M
    } else { \
10371
26.9M
  if (addNode(seq, cur) < 0) \
10372
26.9M
      xmlXPathPErrMemory(ctxt); \
10373
26.9M
  if (breakOnFirstHit) goto first_hit; }
10374
10375
432k
#define XP_TEST_HIT_NS \
10376
432k
    if (hasAxisRange != 0) { \
10377
0
  if (++pos == maxPos) { \
10378
0
      hasNsNodes = 1; \
10379
0
      if (xmlXPathNodeSetAddNs(seq, xpctxt->node, (xmlNsPtr) cur) < 0) \
10380
0
          xmlXPathPErrMemory(ctxt); \
10381
0
  goto axis_range_end; } \
10382
263k
    } else { \
10383
263k
  hasNsNodes = 1; \
10384
263k
  if (xmlXPathNodeSetAddNs(seq, xpctxt->node, (xmlNsPtr) cur) < 0) \
10385
263k
      xmlXPathPErrMemory(ctxt); \
10386
263k
  if (breakOnFirstHit) goto first_hit; }
10387
10388
432k
    xmlXPathAxisVal axis = (xmlXPathAxisVal) op->value;
10389
432k
    xmlXPathTestVal test = (xmlXPathTestVal) op->value2;
10390
432k
    xmlXPathTypeVal type = (xmlXPathTypeVal) op->value3;
10391
432k
    const xmlChar *prefix = op->value4;
10392
432k
    const xmlChar *name = op->value5;
10393
432k
    const xmlChar *URI = NULL;
10394
10395
432k
    int total = 0, hasNsNodes = 0;
10396
    /* The popped object holding the context nodes */
10397
432k
    xmlXPathObjectPtr obj;
10398
    /* The set of context nodes for the node tests */
10399
432k
    xmlNodeSetPtr contextSeq;
10400
432k
    int contextIdx;
10401
432k
    xmlNodePtr contextNode;
10402
    /* The final resulting node set wrt to all context nodes */
10403
432k
    xmlNodeSetPtr outSeq;
10404
    /*
10405
    * The temporary resulting node set wrt 1 context node.
10406
    * Used to feed predicate evaluation.
10407
    */
10408
432k
    xmlNodeSetPtr seq;
10409
432k
    xmlNodePtr cur;
10410
    /* First predicate operator */
10411
432k
    xmlXPathStepOpPtr predOp;
10412
432k
    int maxPos; /* The requested position() (when a "[n]" predicate) */
10413
432k
    int hasPredicateRange, hasAxisRange, pos;
10414
432k
    int breakOnFirstHit;
10415
10416
432k
    xmlXPathTraversalFunction next = NULL;
10417
432k
    int (*addNode) (xmlNodeSetPtr, xmlNodePtr);
10418
432k
    xmlXPathNodeSetMergeFunction mergeAndClear;
10419
432k
    xmlNodePtr oldContextNode;
10420
432k
    xmlXPathContextPtr xpctxt = ctxt->context;
10421
10422
10423
432k
    CHECK_TYPE0(XPATH_NODESET);
10424
432k
    obj = xmlXPathValuePop(ctxt);
10425
    /*
10426
    * Setup namespaces.
10427
    */
10428
432k
    if (prefix != NULL) {
10429
18
        URI = xmlXPathNsLookup(xpctxt, prefix);
10430
18
        if (URI == NULL) {
10431
3
      xmlXPathReleaseObject(xpctxt, obj);
10432
3
            XP_ERROR0(XPATH_UNDEF_PREFIX_ERROR);
10433
0
  }
10434
18
    }
10435
    /*
10436
    * Setup axis.
10437
    *
10438
    * MAYBE FUTURE TODO: merging optimizations:
10439
    * - If the nodes to be traversed wrt to the initial nodes and
10440
    *   the current axis cannot overlap, then we could avoid searching
10441
    *   for duplicates during the merge.
10442
    *   But the question is how/when to evaluate if they cannot overlap.
10443
    *   Example: if we know that for two initial nodes, the one is
10444
    *   not in the ancestor-or-self axis of the other, then we could safely
10445
    *   avoid a duplicate-aware merge, if the axis to be traversed is e.g.
10446
    *   the descendant-or-self axis.
10447
    */
10448
432k
    mergeAndClear = xmlXPathNodeSetMergeAndClear;
10449
432k
    switch (axis) {
10450
17
        case AXIS_ANCESTOR:
10451
17
            first = NULL;
10452
17
            next = xmlXPathNextAncestor;
10453
17
            break;
10454
0
        case AXIS_ANCESTOR_OR_SELF:
10455
0
            first = NULL;
10456
0
            next = xmlXPathNextAncestorOrSelf;
10457
0
            break;
10458
66.4k
        case AXIS_ATTRIBUTE:
10459
66.4k
            first = NULL;
10460
66.4k
      last = NULL;
10461
66.4k
            next = xmlXPathNextAttribute;
10462
66.4k
      mergeAndClear = xmlXPathNodeSetMergeAndClearNoDupls;
10463
66.4k
            break;
10464
274k
        case AXIS_CHILD:
10465
274k
      last = NULL;
10466
274k
      if (((test == NODE_TEST_NAME) || (test == NODE_TEST_ALL)) &&
10467
274k
    (type == NODE_TYPE_NODE))
10468
216k
      {
10469
    /*
10470
    * Optimization if an element node type is 'element'.
10471
    */
10472
216k
    next = xmlXPathNextChildElement;
10473
216k
      } else
10474
58.1k
    next = xmlXPathNextChild;
10475
274k
      mergeAndClear = xmlXPathNodeSetMergeAndClearNoDupls;
10476
274k
            break;
10477
75.1k
        case AXIS_DESCENDANT:
10478
75.1k
      last = NULL;
10479
75.1k
            next = xmlXPathNextDescendant;
10480
75.1k
            break;
10481
12.0k
        case AXIS_DESCENDANT_OR_SELF:
10482
12.0k
      last = NULL;
10483
12.0k
            next = xmlXPathNextDescendantOrSelf;
10484
12.0k
            break;
10485
0
        case AXIS_FOLLOWING:
10486
0
      last = NULL;
10487
0
            next = xmlXPathNextFollowing;
10488
0
            break;
10489
0
        case AXIS_FOLLOWING_SIBLING:
10490
0
      last = NULL;
10491
0
            next = xmlXPathNextFollowingSibling;
10492
0
            break;
10493
949
        case AXIS_NAMESPACE:
10494
949
            first = NULL;
10495
949
      last = NULL;
10496
949
            next = (xmlXPathTraversalFunction) xmlXPathNextNamespace;
10497
949
      mergeAndClear = xmlXPathNodeSetMergeAndClearNoDupls;
10498
949
            break;
10499
3.38k
        case AXIS_PARENT:
10500
3.38k
            first = NULL;
10501
3.38k
            next = xmlXPathNextParent;
10502
3.38k
            break;
10503
3
        case AXIS_PRECEDING:
10504
3
            first = NULL;
10505
3
            next = xmlXPathNextPrecedingInternal;
10506
3
            break;
10507
43
        case AXIS_PRECEDING_SIBLING:
10508
43
            first = NULL;
10509
43
            next = xmlXPathNextPrecedingSibling;
10510
43
            break;
10511
0
        case AXIS_SELF:
10512
0
            first = NULL;
10513
0
      last = NULL;
10514
0
            next = xmlXPathNextSelf;
10515
0
      mergeAndClear = xmlXPathNodeSetMergeAndClearNoDupls;
10516
0
            break;
10517
432k
    }
10518
10519
432k
    if (next == NULL) {
10520
0
  xmlXPathReleaseObject(xpctxt, obj);
10521
0
        return(0);
10522
0
    }
10523
432k
    contextSeq = obj->nodesetval;
10524
432k
    if ((contextSeq == NULL) || (contextSeq->nodeNr <= 0)) {
10525
68.1k
        xmlXPathValuePush(ctxt, obj);
10526
68.1k
        return(0);
10527
68.1k
    }
10528
    /*
10529
    * Predicate optimization ---------------------------------------------
10530
    * If this step has a last predicate, which contains a position(),
10531
    * then we'll optimize (although not exactly "position()", but only
10532
    * the  short-hand form, i.e., "[n]".
10533
    *
10534
    * Example - expression "/foo[parent::bar][1]":
10535
    *
10536
    * COLLECT 'child' 'name' 'node' foo    -- op (we are here)
10537
    *   ROOT                               -- op->ch1
10538
    *   PREDICATE                          -- op->ch2 (predOp)
10539
    *     PREDICATE                          -- predOp->ch1 = [parent::bar]
10540
    *       SORT
10541
    *         COLLECT  'parent' 'name' 'node' bar
10542
    *           NODE
10543
    *     ELEM Object is a number : 1        -- predOp->ch2 = [1]
10544
    *
10545
    */
10546
364k
    maxPos = 0;
10547
364k
    predOp = NULL;
10548
364k
    hasPredicateRange = 0;
10549
364k
    hasAxisRange = 0;
10550
364k
    if (op->ch2 != -1) {
10551
  /*
10552
  * There's at least one predicate. 16 == XPATH_OP_PREDICATE
10553
  */
10554
219
  predOp = &ctxt->comp->steps[op->ch2];
10555
219
  if (xmlXPathIsPositionalPredicate(ctxt, predOp, &maxPos)) {
10556
2
      if (predOp->ch1 != -1) {
10557
    /*
10558
    * Use the next inner predicate operator.
10559
    */
10560
2
    predOp = &ctxt->comp->steps[predOp->ch1];
10561
2
    hasPredicateRange = 1;
10562
2
      } else {
10563
    /*
10564
    * There's no other predicate than the [n] predicate.
10565
    */
10566
0
    predOp = NULL;
10567
0
    hasAxisRange = 1;
10568
0
      }
10569
2
  }
10570
219
    }
10571
364k
    breakOnFirstHit = ((toBool) && (predOp == NULL)) ? 1 : 0;
10572
    /*
10573
    * Axis traversal -----------------------------------------------------
10574
    */
10575
    /*
10576
     * 2.3 Node Tests
10577
     *  - For the attribute axis, the principal node type is attribute.
10578
     *  - For the namespace axis, the principal node type is namespace.
10579
     *  - For other axes, the principal node type is element.
10580
     *
10581
     * A node test * is true for any node of the
10582
     * principal node type. For example, child::* will
10583
     * select all element children of the context node
10584
     */
10585
364k
    oldContextNode = xpctxt->node;
10586
364k
    addNode = xmlXPathNodeSetAddUnique;
10587
364k
    outSeq = NULL;
10588
364k
    seq = NULL;
10589
364k
    contextNode = NULL;
10590
364k
    contextIdx = 0;
10591
10592
10593
3.09M
    while (((contextIdx < contextSeq->nodeNr) || (contextNode != NULL)) &&
10594
3.09M
           (ctxt->error == XPATH_EXPRESSION_OK)) {
10595
2.72M
  xpctxt->node = contextSeq->nodeTab[contextIdx++];
10596
10597
2.72M
  if (seq == NULL) {
10598
367k
      seq = xmlXPathNodeSetCreate(NULL);
10599
367k
      if (seq == NULL) {
10600
3
                xmlXPathPErrMemory(ctxt);
10601
3
    total = 0;
10602
3
    goto error;
10603
3
      }
10604
367k
  }
10605
  /*
10606
  * Traverse the axis and test the nodes.
10607
  */
10608
2.72M
  pos = 0;
10609
2.72M
  cur = NULL;
10610
2.72M
  hasNsNodes = 0;
10611
30.9M
        do {
10612
30.9M
            if (OP_LIMIT_EXCEEDED(ctxt, 1))
10613
40
                goto error;
10614
10615
30.9M
            cur = next(ctxt, cur);
10616
30.9M
            if (cur == NULL)
10617
2.72M
                break;
10618
10619
      /*
10620
      * QUESTION TODO: What does the "first" and "last" stuff do?
10621
      */
10622
28.2M
            if ((first != NULL) && (*first != NULL)) {
10623
0
    if (*first == cur)
10624
0
        break;
10625
0
    if (((total % 256) == 0) &&
10626
0
#ifdef XP_OPTIMIZED_NON_ELEM_COMPARISON
10627
0
        (xmlXPathCmpNodesExt(*first, cur) >= 0))
10628
#else
10629
        (xmlXPathCmpNodes(*first, cur) >= 0))
10630
#endif
10631
0
    {
10632
0
        break;
10633
0
    }
10634
0
      }
10635
28.2M
      if ((last != NULL) && (*last != NULL)) {
10636
0
    if (*last == cur)
10637
0
        break;
10638
0
    if (((total % 256) == 0) &&
10639
0
#ifdef XP_OPTIMIZED_NON_ELEM_COMPARISON
10640
0
        (xmlXPathCmpNodesExt(cur, *last) >= 0))
10641
#else
10642
        (xmlXPathCmpNodes(cur, *last) >= 0))
10643
#endif
10644
0
    {
10645
0
        break;
10646
0
    }
10647
0
      }
10648
10649
28.2M
            total++;
10650
10651
28.2M
      switch (test) {
10652
0
                case NODE_TEST_NONE:
10653
0
        total = 0;
10654
0
        goto error;
10655
26.7M
                case NODE_TEST_TYPE:
10656
26.7M
        if (type == NODE_TYPE_NODE) {
10657
26.6M
      switch (cur->type) {
10658
9.72k
          case XML_DOCUMENT_NODE:
10659
9.72k
          case XML_HTML_DOCUMENT_NODE:
10660
21.4M
          case XML_ELEMENT_NODE:
10661
21.4M
          case XML_ATTRIBUTE_NODE:
10662
21.7M
          case XML_PI_NODE:
10663
21.8M
          case XML_COMMENT_NODE:
10664
22.0M
          case XML_CDATA_SECTION_NODE:
10665
26.4M
          case XML_TEXT_NODE:
10666
26.4M
        XP_TEST_HIT
10667
26.4M
        break;
10668
26.4M
          case XML_NAMESPACE_DECL: {
10669
1
        if (axis == AXIS_NAMESPACE) {
10670
1
            XP_TEST_HIT_NS
10671
1
        } else {
10672
0
                              hasNsNodes = 1;
10673
0
            XP_TEST_HIT
10674
0
        }
10675
1
        break;
10676
1
                            }
10677
172k
          default:
10678
172k
        break;
10679
26.6M
      }
10680
26.6M
        } else if (cur->type == (xmlElementType) type) {
10681
23.2k
      if (cur->type == XML_NAMESPACE_DECL)
10682
0
          XP_TEST_HIT_NS
10683
23.2k
      else
10684
23.2k
          XP_TEST_HIT
10685
35.7k
        } else if ((type == NODE_TYPE_TEXT) &&
10686
35.7k
       (cur->type == XML_CDATA_SECTION_NODE))
10687
9.02k
        {
10688
9.02k
      XP_TEST_HIT
10689
9.02k
        }
10690
26.7M
        break;
10691
26.7M
                case NODE_TEST_PI:
10692
0
                    if ((cur->type == XML_PI_NODE) &&
10693
0
                        ((name == NULL) || xmlStrEqual(name, cur->name)))
10694
0
        {
10695
0
      XP_TEST_HIT
10696
0
                    }
10697
0
                    break;
10698
1.19M
                case NODE_TEST_ALL:
10699
1.19M
                    if (axis == AXIS_ATTRIBUTE) {
10700
436
                        if (cur->type == XML_ATTRIBUTE_NODE)
10701
436
      {
10702
436
                            if (prefix == NULL)
10703
436
          {
10704
436
        XP_TEST_HIT
10705
436
                            } else if ((cur->ns != NULL) &&
10706
0
        (xmlStrEqual(URI, cur->ns->href)))
10707
0
          {
10708
0
        XP_TEST_HIT
10709
0
                            }
10710
436
                        }
10711
1.19M
                    } else if (axis == AXIS_NAMESPACE) {
10712
253k
                        if (cur->type == XML_NAMESPACE_DECL)
10713
253k
      {
10714
253k
          XP_TEST_HIT_NS
10715
253k
                        }
10716
938k
                    } else {
10717
938k
                        if (cur->type == XML_ELEMENT_NODE) {
10718
386k
                            if (prefix == NULL)
10719
386k
          {
10720
386k
        XP_TEST_HIT
10721
10722
386k
                            } else if ((cur->ns != NULL) &&
10723
0
        (xmlStrEqual(URI, cur->ns->href)))
10724
0
          {
10725
0
        XP_TEST_HIT
10726
0
                            }
10727
386k
                        }
10728
938k
                    }
10729
1.19M
                    break;
10730
1.19M
                case NODE_TEST_NS:{
10731
                        /* TODO */
10732
0
                        break;
10733
1.19M
                    }
10734
335k
                case NODE_TEST_NAME:
10735
335k
                    if (axis == AXIS_ATTRIBUTE) {
10736
41.4k
                        if (cur->type != XML_ATTRIBUTE_NODE)
10737
0
          break;
10738
294k
        } else if (axis == AXIS_NAMESPACE) {
10739
38.4k
                        if (cur->type != XML_NAMESPACE_DECL)
10740
0
          break;
10741
256k
        } else {
10742
256k
            if (cur->type != XML_ELEMENT_NODE)
10743
3.19k
          break;
10744
256k
        }
10745
332k
                    switch (cur->type) {
10746
252k
                        case XML_ELEMENT_NODE:
10747
252k
                            if (xmlStrEqual(name, cur->name)) {
10748
329
                                if (prefix == NULL) {
10749
329
                                    if (cur->ns == NULL)
10750
329
            {
10751
329
          XP_TEST_HIT
10752
329
                                    }
10753
329
                                } else {
10754
0
                                    if ((cur->ns != NULL) &&
10755
0
                                        (xmlStrEqual(URI, cur->ns->href)))
10756
0
            {
10757
0
          XP_TEST_HIT
10758
0
                                    }
10759
0
                                }
10760
329
                            }
10761
252k
                            break;
10762
252k
                        case XML_ATTRIBUTE_NODE:{
10763
41.4k
                                xmlAttrPtr attr = (xmlAttrPtr) cur;
10764
10765
41.4k
                                if (xmlStrEqual(name, attr->name)) {
10766
3.05k
                                    if (prefix == NULL) {
10767
3.05k
                                        if ((attr->ns == NULL) ||
10768
3.05k
                                            (attr->ns->prefix == NULL))
10769
3.05k
          {
10770
3.05k
              XP_TEST_HIT
10771
3.05k
                                        }
10772
3.05k
                                    } else {
10773
0
                                        if ((attr->ns != NULL) &&
10774
0
                                            (xmlStrEqual(URI,
10775
0
                attr->ns->href)))
10776
0
          {
10777
0
              XP_TEST_HIT
10778
0
                                        }
10779
0
                                    }
10780
3.05k
                                }
10781
41.4k
                                break;
10782
41.4k
                            }
10783
41.4k
                        case XML_NAMESPACE_DECL:
10784
38.4k
                            if (cur->type == XML_NAMESPACE_DECL) {
10785
38.4k
                                xmlNsPtr ns = (xmlNsPtr) cur;
10786
10787
38.4k
                                if ((ns->prefix != NULL) && (name != NULL)
10788
38.4k
                                    && (xmlStrEqual(ns->prefix, name)))
10789
9.60k
        {
10790
9.60k
            XP_TEST_HIT_NS
10791
9.60k
                                }
10792
38.4k
                            }
10793
38.4k
                            break;
10794
38.4k
                        default:
10795
0
                            break;
10796
332k
                    }
10797
332k
                    break;
10798
28.2M
      } /* switch(test) */
10799
28.2M
        } while ((cur != NULL) && (ctxt->error == XPATH_EXPRESSION_OK));
10800
10801
2.72M
  goto apply_predicates;
10802
10803
2.72M
axis_range_end: /* ----------------------------------------------------- */
10804
  /*
10805
  * We have a "/foo[n]", and position() = n was reached.
10806
  * Note that we can have as well "/foo/::parent::foo[1]", so
10807
  * a duplicate-aware merge is still needed.
10808
  * Merge with the result.
10809
  */
10810
0
  if (outSeq == NULL) {
10811
0
      outSeq = seq;
10812
0
      seq = NULL;
10813
0
  } else {
10814
0
      outSeq = mergeAndClear(outSeq, seq);
10815
0
            if (outSeq == NULL)
10816
0
                xmlXPathPErrMemory(ctxt);
10817
0
        }
10818
  /*
10819
  * Break if only a true/false result was requested.
10820
  */
10821
0
  if (toBool)
10822
0
      break;
10823
0
  continue;
10824
10825
0
first_hit: /* ---------------------------------------------------------- */
10826
  /*
10827
  * Break if only a true/false result was requested and
10828
  * no predicates existed and a node test succeeded.
10829
  */
10830
0
  if (outSeq == NULL) {
10831
0
      outSeq = seq;
10832
0
      seq = NULL;
10833
0
  } else {
10834
0
      outSeq = mergeAndClear(outSeq, seq);
10835
0
            if (outSeq == NULL)
10836
0
                xmlXPathPErrMemory(ctxt);
10837
0
        }
10838
0
  break;
10839
10840
2.72M
apply_predicates: /* --------------------------------------------------- */
10841
2.72M
        if (ctxt->error != XPATH_EXPRESSION_OK)
10842
34
      goto error;
10843
10844
        /*
10845
  * Apply predicates.
10846
  */
10847
2.72M
        if ((predOp != NULL) && (seq->nodeNr > 0)) {
10848
      /*
10849
      * E.g. when we have a "/foo[some expression][n]".
10850
      */
10851
      /*
10852
      * QUESTION TODO: The old predicate evaluation took into
10853
      *  account location-sets.
10854
      *  (E.g. ctxt->value->type == XPATH_LOCATIONSET)
10855
      *  Do we expect such a set here?
10856
      *  All what I learned now from the evaluation semantics
10857
      *  does not indicate that a location-set will be processed
10858
      *  here, so this looks OK.
10859
      */
10860
      /*
10861
      * Iterate over all predicates, starting with the outermost
10862
      * predicate.
10863
      * TODO: Problem: we cannot execute the inner predicates first
10864
      *  since we cannot go back *up* the operator tree!
10865
      *  Options we have:
10866
      *  1) Use of recursive functions (like is it currently done
10867
      *     via xmlXPathCompOpEval())
10868
      *  2) Add a predicate evaluation information stack to the
10869
      *     context struct
10870
      *  3) Change the way the operators are linked; we need a
10871
      *     "parent" field on xmlXPathStepOp
10872
      *
10873
      * For the moment, I'll try to solve this with a recursive
10874
      * function: xmlXPathCompOpEvalPredicate().
10875
      */
10876
18.4k
      if (hasPredicateRange != 0)
10877
2
    xmlXPathCompOpEvalPredicate(ctxt, predOp, seq, maxPos, maxPos,
10878
2
              hasNsNodes);
10879
18.4k
      else
10880
18.4k
    xmlXPathCompOpEvalPredicate(ctxt, predOp, seq, 1, seq->nodeNr,
10881
18.4k
              hasNsNodes);
10882
10883
18.4k
      if (ctxt->error != XPATH_EXPRESSION_OK) {
10884
52
    total = 0;
10885
52
    goto error;
10886
52
      }
10887
18.4k
        }
10888
10889
2.72M
        if (seq->nodeNr > 0) {
10890
      /*
10891
      * Add to result set.
10892
      */
10893
1.76M
      if (outSeq == NULL) {
10894
54.3k
    outSeq = seq;
10895
54.3k
    seq = NULL;
10896
1.71M
      } else {
10897
1.71M
    outSeq = mergeAndClear(outSeq, seq);
10898
1.71M
                if (outSeq == NULL)
10899
0
                    xmlXPathPErrMemory(ctxt);
10900
1.71M
      }
10901
10902
1.76M
            if (toBool)
10903
0
                break;
10904
1.76M
  }
10905
2.72M
    }
10906
10907
364k
error:
10908
364k
    if ((obj->boolval) && (obj->user != NULL)) {
10909
  /*
10910
  * QUESTION TODO: What does this do and why?
10911
  * TODO: Do we have to do this also for the "error"
10912
  * cleanup further down?
10913
  */
10914
0
  ctxt->value->boolval = 1;
10915
0
  ctxt->value->user = obj->user;
10916
0
  obj->user = NULL;
10917
0
  obj->boolval = 0;
10918
0
    }
10919
364k
    xmlXPathReleaseObject(xpctxt, obj);
10920
10921
    /*
10922
    * Ensure we return at least an empty set.
10923
    */
10924
364k
    if (outSeq == NULL) {
10925
310k
  if ((seq != NULL) && (seq->nodeNr == 0)) {
10926
310k
      outSeq = seq;
10927
310k
        } else {
10928
35
      outSeq = xmlXPathNodeSetCreate(NULL);
10929
35
            if (outSeq == NULL)
10930
4
                xmlXPathPErrMemory(ctxt);
10931
35
        }
10932
310k
    }
10933
364k
    if ((seq != NULL) && (seq != outSeq)) {
10934
3.51k
   xmlXPathFreeNodeSet(seq);
10935
3.51k
    }
10936
    /*
10937
    * Hand over the result. Better to push the set also in
10938
    * case of errors.
10939
    */
10940
364k
    xmlXPathValuePush(ctxt, xmlXPathCacheWrapNodeSet(ctxt, outSeq));
10941
    /*
10942
    * Reset the context node.
10943
    */
10944
364k
    xpctxt->node = oldContextNode;
10945
    /*
10946
    * When traversing the namespace axis in "toBool" mode, it's
10947
    * possible that tmpNsList wasn't freed.
10948
    */
10949
364k
    if (xpctxt->tmpNsList != NULL) {
10950
1
        xmlFree(xpctxt->tmpNsList);
10951
1
        xpctxt->tmpNsList = NULL;
10952
1
    }
10953
10954
364k
    return(total);
10955
364k
}
10956
10957
static int
10958
xmlXPathCompOpEvalFilterFirst(xmlXPathParserContextPtr ctxt,
10959
            xmlXPathStepOpPtr op, xmlNodePtr * first);
10960
10961
/**
10962
 * xmlXPathCompOpEvalFirst:
10963
 * @ctxt:  the XPath parser context with the compiled expression
10964
 * @op:  an XPath compiled operation
10965
 * @first:  the first elem found so far
10966
 *
10967
 * Evaluate the Precompiled XPath operation searching only the first
10968
 * element in document order
10969
 *
10970
 * Returns the number of examined objects.
10971
 */
10972
static int
10973
xmlXPathCompOpEvalFirst(xmlXPathParserContextPtr ctxt,
10974
                        xmlXPathStepOpPtr op, xmlNodePtr * first)
10975
6.84k
{
10976
6.84k
    int total = 0, cur;
10977
6.84k
    xmlXPathCompExprPtr comp;
10978
6.84k
    xmlXPathObjectPtr arg1, arg2;
10979
10980
6.84k
    CHECK_ERROR0;
10981
6.84k
    if (OP_LIMIT_EXCEEDED(ctxt, 1))
10982
0
        return(0);
10983
6.84k
    if (ctxt->context->depth >= XPATH_MAX_RECURSION_DEPTH)
10984
6.84k
        XP_ERROR0(XPATH_RECURSION_LIMIT_EXCEEDED);
10985
6.84k
    ctxt->context->depth += 1;
10986
6.84k
    comp = ctxt->comp;
10987
6.84k
    switch (op->op) {
10988
0
        case XPATH_OP_END:
10989
0
            break;
10990
40
        case XPATH_OP_UNION:
10991
40
            total =
10992
40
                xmlXPathCompOpEvalFirst(ctxt, &comp->steps[op->ch1],
10993
40
                                        first);
10994
40
      CHECK_ERROR0;
10995
31
            if ((ctxt->value != NULL)
10996
31
                && (ctxt->value->type == XPATH_NODESET)
10997
31
                && (ctxt->value->nodesetval != NULL)
10998
31
                && (ctxt->value->nodesetval->nodeNr >= 1)) {
10999
                /*
11000
                 * limit tree traversing to first node in the result
11001
                 */
11002
    /*
11003
    * OPTIMIZE TODO: This implicitly sorts
11004
    *  the result, even if not needed. E.g. if the argument
11005
    *  of the count() function, no sorting is needed.
11006
    * OPTIMIZE TODO: How do we know if the node-list wasn't
11007
    *  already sorted?
11008
    */
11009
11
    if (ctxt->value->nodesetval->nodeNr > 1)
11010
11
        xmlXPathNodeSetSort(ctxt->value->nodesetval);
11011
11
                *first = ctxt->value->nodesetval->nodeTab[0];
11012
11
            }
11013
31
            cur =
11014
31
                xmlXPathCompOpEvalFirst(ctxt, &comp->steps[op->ch2],
11015
31
                                        first);
11016
31
      CHECK_ERROR0;
11017
11018
22
            arg2 = xmlXPathValuePop(ctxt);
11019
22
            arg1 = xmlXPathValuePop(ctxt);
11020
22
            if ((arg1 == NULL) || (arg1->type != XPATH_NODESET) ||
11021
22
                (arg2 == NULL) || (arg2->type != XPATH_NODESET)) {
11022
0
          xmlXPathReleaseObject(ctxt->context, arg1);
11023
0
          xmlXPathReleaseObject(ctxt->context, arg2);
11024
0
                XP_ERROR0(XPATH_INVALID_TYPE);
11025
0
            }
11026
22
            if ((ctxt->context->opLimit != 0) &&
11027
22
                (((arg1->nodesetval != NULL) &&
11028
22
                  (xmlXPathCheckOpLimit(ctxt,
11029
22
                                        arg1->nodesetval->nodeNr) < 0)) ||
11030
22
                 ((arg2->nodesetval != NULL) &&
11031
20
                  (xmlXPathCheckOpLimit(ctxt,
11032
20
                                        arg2->nodesetval->nodeNr) < 0)))) {
11033
2
          xmlXPathReleaseObject(ctxt->context, arg1);
11034
2
          xmlXPathReleaseObject(ctxt->context, arg2);
11035
2
                break;
11036
2
            }
11037
11038
20
            if ((arg2->nodesetval != NULL) &&
11039
20
                (arg2->nodesetval->nodeNr != 0)) {
11040
20
                arg1->nodesetval = xmlXPathNodeSetMerge(arg1->nodesetval,
11041
20
                                                        arg2->nodesetval);
11042
20
                if (arg1->nodesetval == NULL)
11043
0
                    xmlXPathPErrMemory(ctxt);
11044
20
            }
11045
20
            xmlXPathValuePush(ctxt, arg1);
11046
20
      xmlXPathReleaseObject(ctxt->context, arg2);
11047
20
            total += cur;
11048
20
            break;
11049
0
        case XPATH_OP_ROOT:
11050
0
            xmlXPathRoot(ctxt);
11051
0
            break;
11052
11
        case XPATH_OP_NODE:
11053
11
            if (op->ch1 != -1)
11054
0
                total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
11055
11
      CHECK_ERROR0;
11056
11
            if (op->ch2 != -1)
11057
0
                total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
11058
11
      CHECK_ERROR0;
11059
11
      xmlXPathValuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt,
11060
11
    ctxt->context->node));
11061
11
            break;
11062
42
        case XPATH_OP_COLLECT:{
11063
42
                if (op->ch1 == -1)
11064
0
                    break;
11065
11066
42
                total = xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
11067
42
    CHECK_ERROR0;
11068
11069
38
                total += xmlXPathNodeCollectAndTest(ctxt, op, first, NULL, 0);
11070
38
                break;
11071
42
            }
11072
0
        case XPATH_OP_VALUE:
11073
0
            xmlXPathValuePush(ctxt, xmlXPathCacheObjectCopy(ctxt, op->value4));
11074
0
            break;
11075
3.38k
        case XPATH_OP_SORT:
11076
3.38k
            if (op->ch1 != -1)
11077
3.38k
                total +=
11078
3.38k
                    xmlXPathCompOpEvalFirst(ctxt, &comp->steps[op->ch1],
11079
3.38k
                                            first);
11080
3.38k
      CHECK_ERROR0;
11081
3.36k
            if ((ctxt->value != NULL)
11082
3.36k
                && (ctxt->value->type == XPATH_NODESET)
11083
3.36k
                && (ctxt->value->nodesetval != NULL)
11084
3.36k
    && (ctxt->value->nodesetval->nodeNr > 1))
11085
9
                xmlXPathNodeSetSort(ctxt->value->nodesetval);
11086
3.36k
            break;
11087
0
#ifdef XP_OPTIMIZED_FILTER_FIRST
11088
0
  case XPATH_OP_FILTER:
11089
0
                total += xmlXPathCompOpEvalFilterFirst(ctxt, op, first);
11090
0
            break;
11091
0
#endif
11092
3.36k
        default:
11093
3.36k
            total += xmlXPathCompOpEval(ctxt, op);
11094
3.36k
            break;
11095
6.84k
    }
11096
11097
6.80k
    ctxt->context->depth -= 1;
11098
6.80k
    return(total);
11099
6.84k
}
11100
11101
/**
11102
 * xmlXPathCompOpEvalLast:
11103
 * @ctxt:  the XPath parser context with the compiled expression
11104
 * @op:  an XPath compiled operation
11105
 * @last:  the last elem found so far
11106
 *
11107
 * Evaluate the Precompiled XPath operation searching only the last
11108
 * element in document order
11109
 *
11110
 * Returns the number of nodes traversed
11111
 */
11112
static int
11113
xmlXPathCompOpEvalLast(xmlXPathParserContextPtr ctxt, xmlXPathStepOpPtr op,
11114
                       xmlNodePtr * last)
11115
0
{
11116
0
    int total = 0, cur;
11117
0
    xmlXPathCompExprPtr comp;
11118
0
    xmlXPathObjectPtr arg1, arg2;
11119
11120
0
    CHECK_ERROR0;
11121
0
    if (OP_LIMIT_EXCEEDED(ctxt, 1))
11122
0
        return(0);
11123
0
    if (ctxt->context->depth >= XPATH_MAX_RECURSION_DEPTH)
11124
0
        XP_ERROR0(XPATH_RECURSION_LIMIT_EXCEEDED);
11125
0
    ctxt->context->depth += 1;
11126
0
    comp = ctxt->comp;
11127
0
    switch (op->op) {
11128
0
        case XPATH_OP_END:
11129
0
            break;
11130
0
        case XPATH_OP_UNION:
11131
0
            total =
11132
0
                xmlXPathCompOpEvalLast(ctxt, &comp->steps[op->ch1], last);
11133
0
      CHECK_ERROR0;
11134
0
            if ((ctxt->value != NULL)
11135
0
                && (ctxt->value->type == XPATH_NODESET)
11136
0
                && (ctxt->value->nodesetval != NULL)
11137
0
                && (ctxt->value->nodesetval->nodeNr >= 1)) {
11138
                /*
11139
                 * limit tree traversing to first node in the result
11140
                 */
11141
0
    if (ctxt->value->nodesetval->nodeNr > 1)
11142
0
        xmlXPathNodeSetSort(ctxt->value->nodesetval);
11143
0
                *last =
11144
0
                    ctxt->value->nodesetval->nodeTab[ctxt->value->
11145
0
                                                     nodesetval->nodeNr -
11146
0
                                                     1];
11147
0
            }
11148
0
            cur =
11149
0
                xmlXPathCompOpEvalLast(ctxt, &comp->steps[op->ch2], last);
11150
0
      CHECK_ERROR0;
11151
0
            if ((ctxt->value != NULL)
11152
0
                && (ctxt->value->type == XPATH_NODESET)
11153
0
                && (ctxt->value->nodesetval != NULL)
11154
0
                && (ctxt->value->nodesetval->nodeNr >= 1)) { /* TODO: NOP ? */
11155
0
            }
11156
11157
0
            arg2 = xmlXPathValuePop(ctxt);
11158
0
            arg1 = xmlXPathValuePop(ctxt);
11159
0
            if ((arg1 == NULL) || (arg1->type != XPATH_NODESET) ||
11160
0
                (arg2 == NULL) || (arg2->type != XPATH_NODESET)) {
11161
0
          xmlXPathReleaseObject(ctxt->context, arg1);
11162
0
          xmlXPathReleaseObject(ctxt->context, arg2);
11163
0
                XP_ERROR0(XPATH_INVALID_TYPE);
11164
0
            }
11165
0
            if ((ctxt->context->opLimit != 0) &&
11166
0
                (((arg1->nodesetval != NULL) &&
11167
0
                  (xmlXPathCheckOpLimit(ctxt,
11168
0
                                        arg1->nodesetval->nodeNr) < 0)) ||
11169
0
                 ((arg2->nodesetval != NULL) &&
11170
0
                  (xmlXPathCheckOpLimit(ctxt,
11171
0
                                        arg2->nodesetval->nodeNr) < 0)))) {
11172
0
          xmlXPathReleaseObject(ctxt->context, arg1);
11173
0
          xmlXPathReleaseObject(ctxt->context, arg2);
11174
0
                break;
11175
0
            }
11176
11177
0
            if ((arg2->nodesetval != NULL) &&
11178
0
                (arg2->nodesetval->nodeNr != 0)) {
11179
0
                arg1->nodesetval = xmlXPathNodeSetMerge(arg1->nodesetval,
11180
0
                                                        arg2->nodesetval);
11181
0
                if (arg1->nodesetval == NULL)
11182
0
                    xmlXPathPErrMemory(ctxt);
11183
0
            }
11184
0
            xmlXPathValuePush(ctxt, arg1);
11185
0
      xmlXPathReleaseObject(ctxt->context, arg2);
11186
0
            total += cur;
11187
0
            break;
11188
0
        case XPATH_OP_ROOT:
11189
0
            xmlXPathRoot(ctxt);
11190
0
            break;
11191
0
        case XPATH_OP_NODE:
11192
0
            if (op->ch1 != -1)
11193
0
                total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
11194
0
      CHECK_ERROR0;
11195
0
            if (op->ch2 != -1)
11196
0
                total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
11197
0
      CHECK_ERROR0;
11198
0
      xmlXPathValuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt,
11199
0
    ctxt->context->node));
11200
0
            break;
11201
0
        case XPATH_OP_COLLECT:{
11202
0
                if (op->ch1 == -1)
11203
0
                    break;
11204
11205
0
                total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
11206
0
    CHECK_ERROR0;
11207
11208
0
                total += xmlXPathNodeCollectAndTest(ctxt, op, NULL, last, 0);
11209
0
                break;
11210
0
            }
11211
0
        case XPATH_OP_VALUE:
11212
0
            xmlXPathValuePush(ctxt, xmlXPathCacheObjectCopy(ctxt, op->value4));
11213
0
            break;
11214
0
        case XPATH_OP_SORT:
11215
0
            if (op->ch1 != -1)
11216
0
                total +=
11217
0
                    xmlXPathCompOpEvalLast(ctxt, &comp->steps[op->ch1],
11218
0
                                           last);
11219
0
      CHECK_ERROR0;
11220
0
            if ((ctxt->value != NULL)
11221
0
                && (ctxt->value->type == XPATH_NODESET)
11222
0
                && (ctxt->value->nodesetval != NULL)
11223
0
    && (ctxt->value->nodesetval->nodeNr > 1))
11224
0
                xmlXPathNodeSetSort(ctxt->value->nodesetval);
11225
0
            break;
11226
0
        default:
11227
0
            total += xmlXPathCompOpEval(ctxt, op);
11228
0
            break;
11229
0
    }
11230
11231
0
    ctxt->context->depth -= 1;
11232
0
    return (total);
11233
0
}
11234
11235
#ifdef XP_OPTIMIZED_FILTER_FIRST
11236
static int
11237
xmlXPathCompOpEvalFilterFirst(xmlXPathParserContextPtr ctxt,
11238
            xmlXPathStepOpPtr op, xmlNodePtr * first)
11239
0
{
11240
0
    int total = 0;
11241
0
    xmlXPathCompExprPtr comp;
11242
0
    xmlXPathObjectPtr obj;
11243
0
    xmlNodeSetPtr set;
11244
11245
0
    CHECK_ERROR0;
11246
0
    comp = ctxt->comp;
11247
    /*
11248
    * Optimization for ()[last()] selection i.e. the last elem
11249
    */
11250
0
    if ((op->ch1 != -1) && (op->ch2 != -1) &&
11251
0
  (comp->steps[op->ch1].op == XPATH_OP_SORT) &&
11252
0
  (comp->steps[op->ch2].op == XPATH_OP_SORT)) {
11253
0
  int f = comp->steps[op->ch2].ch1;
11254
11255
0
  if ((f != -1) &&
11256
0
      (comp->steps[f].op == XPATH_OP_FUNCTION) &&
11257
0
      (comp->steps[f].value5 == NULL) &&
11258
0
      (comp->steps[f].value == 0) &&
11259
0
      (comp->steps[f].value4 != NULL) &&
11260
0
      (xmlStrEqual
11261
0
      (comp->steps[f].value4, BAD_CAST "last"))) {
11262
0
      xmlNodePtr last = NULL;
11263
11264
0
      total +=
11265
0
    xmlXPathCompOpEvalLast(ctxt,
11266
0
        &comp->steps[op->ch1],
11267
0
        &last);
11268
0
      CHECK_ERROR0;
11269
      /*
11270
      * The nodeset should be in document order,
11271
      * Keep only the last value
11272
      */
11273
0
      if ((ctxt->value != NULL) &&
11274
0
    (ctxt->value->type == XPATH_NODESET) &&
11275
0
    (ctxt->value->nodesetval != NULL) &&
11276
0
    (ctxt->value->nodesetval->nodeTab != NULL) &&
11277
0
    (ctxt->value->nodesetval->nodeNr > 1)) {
11278
0
                xmlXPathNodeSetKeepLast(ctxt->value->nodesetval);
11279
0
    *first = *(ctxt->value->nodesetval->nodeTab);
11280
0
      }
11281
0
      return (total);
11282
0
  }
11283
0
    }
11284
11285
0
    if (op->ch1 != -1)
11286
0
  total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
11287
0
    CHECK_ERROR0;
11288
0
    if (op->ch2 == -1)
11289
0
  return (total);
11290
0
    if (ctxt->value == NULL)
11291
0
  return (total);
11292
11293
    /*
11294
     * In case of errors, xmlXPathNodeSetFilter can pop additional nodes from
11295
     * the stack. We have to temporarily remove the nodeset object from the
11296
     * stack to avoid freeing it prematurely.
11297
     */
11298
0
    CHECK_TYPE0(XPATH_NODESET);
11299
0
    obj = xmlXPathValuePop(ctxt);
11300
0
    set = obj->nodesetval;
11301
0
    if (set != NULL) {
11302
0
        xmlXPathNodeSetFilter(ctxt, set, op->ch2, 1, 1, 1);
11303
0
        if (set->nodeNr > 0)
11304
0
            *first = set->nodeTab[0];
11305
0
    }
11306
0
    xmlXPathValuePush(ctxt, obj);
11307
11308
0
    return (total);
11309
0
}
11310
#endif /* XP_OPTIMIZED_FILTER_FIRST */
11311
11312
/**
11313
 * xmlXPathCompOpEval:
11314
 * @ctxt:  the XPath parser context with the compiled expression
11315
 * @op:  an XPath compiled operation
11316
 *
11317
 * Evaluate the Precompiled XPath operation
11318
 * Returns the number of nodes traversed
11319
 */
11320
static int
11321
xmlXPathCompOpEval(xmlXPathParserContextPtr ctxt, xmlXPathStepOpPtr op)
11322
2.10M
{
11323
2.10M
    int total = 0;
11324
2.10M
    int equal, ret;
11325
2.10M
    xmlXPathCompExprPtr comp;
11326
2.10M
    xmlXPathObjectPtr arg1, arg2;
11327
11328
2.10M
    CHECK_ERROR0;
11329
2.10M
    if (OP_LIMIT_EXCEEDED(ctxt, 1))
11330
98
        return(0);
11331
2.10M
    if (ctxt->context->depth >= XPATH_MAX_RECURSION_DEPTH)
11332
2.10M
        XP_ERROR0(XPATH_RECURSION_LIMIT_EXCEEDED);
11333
2.10M
    ctxt->context->depth += 1;
11334
2.10M
    comp = ctxt->comp;
11335
2.10M
    switch (op->op) {
11336
0
        case XPATH_OP_END:
11337
0
            break;
11338
0
        case XPATH_OP_AND:
11339
0
            total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
11340
0
      CHECK_ERROR0;
11341
0
            xmlXPathBooleanFunction(ctxt, 1);
11342
0
            if ((ctxt->value == NULL) || (ctxt->value->boolval == 0))
11343
0
                break;
11344
0
            arg2 = xmlXPathValuePop(ctxt);
11345
0
            total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
11346
0
      if (ctxt->error) {
11347
0
    xmlXPathFreeObject(arg2);
11348
0
    break;
11349
0
      }
11350
0
            xmlXPathBooleanFunction(ctxt, 1);
11351
0
            if (ctxt->value != NULL)
11352
0
                ctxt->value->boolval &= arg2->boolval;
11353
0
      xmlXPathReleaseObject(ctxt->context, arg2);
11354
0
            break;
11355
30
        case XPATH_OP_OR:
11356
30
            total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
11357
30
      CHECK_ERROR0;
11358
30
            xmlXPathBooleanFunction(ctxt, 1);
11359
30
            if ((ctxt->value == NULL) || (ctxt->value->boolval == 1))
11360
0
                break;
11361
30
            arg2 = xmlXPathValuePop(ctxt);
11362
30
            total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
11363
30
      if (ctxt->error) {
11364
30
    xmlXPathFreeObject(arg2);
11365
30
    break;
11366
30
      }
11367
0
            xmlXPathBooleanFunction(ctxt, 1);
11368
0
            if (ctxt->value != NULL)
11369
0
                ctxt->value->boolval |= arg2->boolval;
11370
0
      xmlXPathReleaseObject(ctxt->context, arg2);
11371
0
            break;
11372
6.30k
        case XPATH_OP_EQUAL:
11373
6.30k
            total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
11374
6.30k
      CHECK_ERROR0;
11375
6.16k
            total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
11376
6.16k
      CHECK_ERROR0;
11377
6.15k
      if (op->value)
11378
6.15k
    equal = xmlXPathEqualValues(ctxt);
11379
0
      else
11380
0
    equal = xmlXPathNotEqualValues(ctxt);
11381
6.15k
      xmlXPathValuePush(ctxt, xmlXPathCacheNewBoolean(ctxt, equal));
11382
6.15k
            break;
11383
5.69k
        case XPATH_OP_CMP:
11384
5.69k
            total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
11385
5.69k
      CHECK_ERROR0;
11386
5.69k
            total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
11387
5.69k
      CHECK_ERROR0;
11388
5.69k
            ret = xmlXPathCompareValues(ctxt, op->value, op->value2);
11389
5.69k
      xmlXPathValuePush(ctxt, xmlXPathCacheNewBoolean(ctxt, ret));
11390
5.69k
            break;
11391
164k
        case XPATH_OP_PLUS:
11392
164k
            total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
11393
164k
      CHECK_ERROR0;
11394
164k
            if (op->ch2 != -1) {
11395
25
                total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
11396
25
      }
11397
164k
      CHECK_ERROR0;
11398
164k
            if (op->value == 0)
11399
2
                xmlXPathSubValues(ctxt);
11400
164k
            else if (op->value == 1)
11401
21
                xmlXPathAddValues(ctxt);
11402
164k
            else if (op->value == 2)
11403
164k
                xmlXPathValueFlipSign(ctxt);
11404
0
            else if (op->value == 3) {
11405
0
                CAST_TO_NUMBER;
11406
0
                CHECK_TYPE0(XPATH_NUMBER);
11407
0
            }
11408
164k
            break;
11409
164k
        case XPATH_OP_MULT:
11410
1.59k
            total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
11411
1.59k
      CHECK_ERROR0;
11412
601
            total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
11413
601
      CHECK_ERROR0;
11414
509
            if (op->value == 0)
11415
438
                xmlXPathMultValues(ctxt);
11416
71
            else if (op->value == 1)
11417
0
                xmlXPathDivValues(ctxt);
11418
71
            else if (op->value == 2)
11419
71
                xmlXPathModValues(ctxt);
11420
509
            break;
11421
77.1k
        case XPATH_OP_UNION:
11422
77.1k
            total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
11423
77.1k
      CHECK_ERROR0;
11424
77.1k
            total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
11425
77.1k
      CHECK_ERROR0;
11426
11427
77.1k
            arg2 = xmlXPathValuePop(ctxt);
11428
77.1k
            arg1 = xmlXPathValuePop(ctxt);
11429
77.1k
            if ((arg1 == NULL) || (arg1->type != XPATH_NODESET) ||
11430
77.1k
                (arg2 == NULL) || (arg2->type != XPATH_NODESET)) {
11431
3
          xmlXPathReleaseObject(ctxt->context, arg1);
11432
3
          xmlXPathReleaseObject(ctxt->context, arg2);
11433
3
                XP_ERROR0(XPATH_INVALID_TYPE);
11434
0
            }
11435
77.1k
            if ((ctxt->context->opLimit != 0) &&
11436
77.1k
                (((arg1->nodesetval != NULL) &&
11437
77.1k
                  (xmlXPathCheckOpLimit(ctxt,
11438
77.1k
                                        arg1->nodesetval->nodeNr) < 0)) ||
11439
77.1k
                 ((arg2->nodesetval != NULL) &&
11440
77.1k
                  (xmlXPathCheckOpLimit(ctxt,
11441
77.1k
                                        arg2->nodesetval->nodeNr) < 0)))) {
11442
22
          xmlXPathReleaseObject(ctxt->context, arg1);
11443
22
          xmlXPathReleaseObject(ctxt->context, arg2);
11444
22
                break;
11445
22
            }
11446
11447
77.0k
      if (((arg2->nodesetval != NULL) &&
11448
77.0k
     (arg2->nodesetval->nodeNr != 0)))
11449
15.2k
      {
11450
15.2k
    arg1->nodesetval = xmlXPathNodeSetMerge(arg1->nodesetval,
11451
15.2k
              arg2->nodesetval);
11452
15.2k
                if (arg1->nodesetval == NULL)
11453
3
                    xmlXPathPErrMemory(ctxt);
11454
15.2k
      }
11455
11456
77.0k
            xmlXPathValuePush(ctxt, arg1);
11457
77.0k
      xmlXPathReleaseObject(ctxt->context, arg2);
11458
77.0k
            break;
11459
30.5k
        case XPATH_OP_ROOT:
11460
30.5k
            xmlXPathRoot(ctxt);
11461
30.5k
            break;
11462
358k
        case XPATH_OP_NODE:
11463
358k
            if (op->ch1 != -1)
11464
0
                total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
11465
358k
      CHECK_ERROR0;
11466
358k
            if (op->ch2 != -1)
11467
0
                total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
11468
358k
      CHECK_ERROR0;
11469
358k
      xmlXPathValuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt,
11470
358k
                                                    ctxt->context->node));
11471
358k
            break;
11472
432k
        case XPATH_OP_COLLECT:{
11473
432k
                if (op->ch1 == -1)
11474
0
                    break;
11475
11476
432k
                total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
11477
432k
    CHECK_ERROR0;
11478
11479
432k
                total += xmlXPathNodeCollectAndTest(ctxt, op, NULL, NULL, 0);
11480
432k
                break;
11481
432k
            }
11482
21.5k
        case XPATH_OP_VALUE:
11483
21.5k
            xmlXPathValuePush(ctxt, xmlXPathCacheObjectCopy(ctxt, op->value4));
11484
21.5k
            break;
11485
0
        case XPATH_OP_VARIABLE:{
11486
0
    xmlXPathObjectPtr val;
11487
11488
0
                if (op->ch1 != -1)
11489
0
                    total +=
11490
0
                        xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
11491
0
                if (op->value5 == NULL) {
11492
0
        val = xmlXPathVariableLookup(ctxt->context, op->value4);
11493
0
        if (val == NULL)
11494
0
      XP_ERROR0(XPATH_UNDEF_VARIABLE_ERROR);
11495
0
                    xmlXPathValuePush(ctxt, val);
11496
0
    } else {
11497
0
                    const xmlChar *URI;
11498
11499
0
                    URI = xmlXPathNsLookup(ctxt->context, op->value5);
11500
0
                    if (URI == NULL) {
11501
0
                        XP_ERROR0(XPATH_UNDEF_PREFIX_ERROR);
11502
0
                        break;
11503
0
                    }
11504
0
        val = xmlXPathVariableLookupNS(ctxt->context,
11505
0
                                                       op->value4, URI);
11506
0
        if (val == NULL)
11507
0
      XP_ERROR0(XPATH_UNDEF_VARIABLE_ERROR);
11508
0
                    xmlXPathValuePush(ctxt, val);
11509
0
                }
11510
0
                break;
11511
0
            }
11512
345k
        case XPATH_OP_FUNCTION:{
11513
345k
                xmlXPathFunction func;
11514
345k
                const xmlChar *oldFunc, *oldFuncURI;
11515
345k
    int i;
11516
345k
                int frame;
11517
11518
345k
                frame = ctxt->valueNr;
11519
345k
                if (op->ch1 != -1) {
11520
154k
                    total +=
11521
154k
                        xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
11522
154k
                    if (ctxt->error != XPATH_EXPRESSION_OK)
11523
56
                        break;
11524
154k
                }
11525
345k
    if (ctxt->valueNr < frame + op->value)
11526
345k
        XP_ERROR0(XPATH_INVALID_OPERAND);
11527
530k
    for (i = 0; i < op->value; i++) {
11528
184k
        if (ctxt->valueTab[(ctxt->valueNr - 1) - i] == NULL)
11529
184k
      XP_ERROR0(XPATH_INVALID_OPERAND);
11530
184k
                }
11531
345k
                if (op->cache != NULL)
11532
342k
                    func = op->cache;
11533
2.77k
                else {
11534
2.77k
                    const xmlChar *URI = NULL;
11535
11536
2.77k
                    if (op->value5 == NULL)
11537
2.51k
                        func =
11538
2.51k
                            xmlXPathFunctionLookup(ctxt->context,
11539
2.51k
                                                   op->value4);
11540
260
                    else {
11541
260
                        URI = xmlXPathNsLookup(ctxt->context, op->value5);
11542
260
                        if (URI == NULL)
11543
218
                            XP_ERROR0(XPATH_UNDEF_PREFIX_ERROR);
11544
218
                        func = xmlXPathFunctionLookupNS(ctxt->context,
11545
218
                                                        op->value4, URI);
11546
218
                    }
11547
2.72k
                    if (func == NULL)
11548
2.38k
                        XP_ERROR0(XPATH_UNKNOWN_FUNC_ERROR);
11549
341
                    op->cache = func;
11550
341
                    op->cacheURI = (void *) URI;
11551
341
                }
11552
343k
                oldFunc = ctxt->context->function;
11553
343k
                oldFuncURI = ctxt->context->functionURI;
11554
343k
                ctxt->context->function = op->value4;
11555
343k
                ctxt->context->functionURI = op->cacheURI;
11556
343k
                func(ctxt, op->value);
11557
343k
                ctxt->context->function = oldFunc;
11558
343k
                ctxt->context->functionURI = oldFuncURI;
11559
343k
                if ((ctxt->error == XPATH_EXPRESSION_OK) &&
11560
343k
                    (ctxt->valueNr != frame + 1))
11561
343k
                    XP_ERROR0(XPATH_STACK_ERROR);
11562
343k
                break;
11563
343k
            }
11564
184k
        case XPATH_OP_ARG:
11565
184k
            if (op->ch1 != -1) {
11566
29.6k
                total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
11567
29.6k
          CHECK_ERROR0;
11568
29.6k
            }
11569
184k
            if (op->ch2 != -1) {
11570
184k
                total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
11571
184k
          CHECK_ERROR0;
11572
184k
      }
11573
184k
            break;
11574
184k
        case XPATH_OP_PREDICATE:
11575
4.20k
        case XPATH_OP_FILTER:{
11576
4.20k
                xmlXPathObjectPtr obj;
11577
4.20k
                xmlNodeSetPtr set;
11578
11579
                /*
11580
                 * Optimization for ()[1] selection i.e. the first elem
11581
                 */
11582
4.20k
                if ((op->ch1 != -1) && (op->ch2 != -1) &&
11583
4.20k
#ifdef XP_OPTIMIZED_FILTER_FIRST
11584
        /*
11585
        * FILTER TODO: Can we assume that the inner processing
11586
        *  will result in an ordered list if we have an
11587
        *  XPATH_OP_FILTER?
11588
        *  What about an additional field or flag on
11589
        *  xmlXPathObject like @sorted ? This way we wouldn't need
11590
        *  to assume anything, so it would be more robust and
11591
        *  easier to optimize.
11592
        */
11593
4.20k
                    ((comp->steps[op->ch1].op == XPATH_OP_SORT) || /* 18 */
11594
4.20k
         (comp->steps[op->ch1].op == XPATH_OP_FILTER)) && /* 17 */
11595
#else
11596
        (comp->steps[op->ch1].op == XPATH_OP_SORT) &&
11597
#endif
11598
4.20k
                    (comp->steps[op->ch2].op == XPATH_OP_VALUE)) { /* 12 */
11599
3.38k
                    xmlXPathObjectPtr val;
11600
11601
3.38k
                    val = comp->steps[op->ch2].value4;
11602
3.38k
                    if ((val != NULL) && (val->type == XPATH_NUMBER) &&
11603
3.38k
                        (val->floatval == 1.0)) {
11604
3.38k
                        xmlNodePtr first = NULL;
11605
11606
3.38k
                        total +=
11607
3.38k
                            xmlXPathCompOpEvalFirst(ctxt,
11608
3.38k
                                                    &comp->steps[op->ch1],
11609
3.38k
                                                    &first);
11610
3.38k
      CHECK_ERROR0;
11611
                        /*
11612
                         * The nodeset should be in document order,
11613
                         * Keep only the first value
11614
                         */
11615
3.36k
                        if ((ctxt->value != NULL) &&
11616
3.36k
                            (ctxt->value->type == XPATH_NODESET) &&
11617
3.36k
                            (ctxt->value->nodesetval != NULL) &&
11618
3.36k
                            (ctxt->value->nodesetval->nodeNr > 1))
11619
9
                            xmlXPathNodeSetClearFromPos(ctxt->value->nodesetval,
11620
9
                                                        1, 1);
11621
3.36k
                        break;
11622
3.38k
                    }
11623
3.38k
                }
11624
                /*
11625
                 * Optimization for ()[last()] selection i.e. the last elem
11626
                 */
11627
815
                if ((op->ch1 != -1) && (op->ch2 != -1) &&
11628
815
                    (comp->steps[op->ch1].op == XPATH_OP_SORT) &&
11629
815
                    (comp->steps[op->ch2].op == XPATH_OP_SORT)) {
11630
655
                    int f = comp->steps[op->ch2].ch1;
11631
11632
655
                    if ((f != -1) &&
11633
655
                        (comp->steps[f].op == XPATH_OP_FUNCTION) &&
11634
655
                        (comp->steps[f].value5 == NULL) &&
11635
655
                        (comp->steps[f].value == 0) &&
11636
655
                        (comp->steps[f].value4 != NULL) &&
11637
655
                        (xmlStrEqual
11638
0
                         (comp->steps[f].value4, BAD_CAST "last"))) {
11639
0
                        xmlNodePtr last = NULL;
11640
11641
0
                        total +=
11642
0
                            xmlXPathCompOpEvalLast(ctxt,
11643
0
                                                   &comp->steps[op->ch1],
11644
0
                                                   &last);
11645
0
      CHECK_ERROR0;
11646
                        /*
11647
                         * The nodeset should be in document order,
11648
                         * Keep only the last value
11649
                         */
11650
0
                        if ((ctxt->value != NULL) &&
11651
0
                            (ctxt->value->type == XPATH_NODESET) &&
11652
0
                            (ctxt->value->nodesetval != NULL) &&
11653
0
                            (ctxt->value->nodesetval->nodeTab != NULL) &&
11654
0
                            (ctxt->value->nodesetval->nodeNr > 1))
11655
0
                            xmlXPathNodeSetKeepLast(ctxt->value->nodesetval);
11656
0
                        break;
11657
0
                    }
11658
655
                }
11659
    /*
11660
    * Process inner predicates first.
11661
    * Example "index[parent::book][1]":
11662
    * ...
11663
    *   PREDICATE   <-- we are here "[1]"
11664
    *     PREDICATE <-- process "[parent::book]" first
11665
    *       SORT
11666
    *         COLLECT  'parent' 'name' 'node' book
11667
    *           NODE
11668
    *     ELEM Object is a number : 1
11669
    */
11670
815
                if (op->ch1 != -1)
11671
815
                    total +=
11672
815
                        xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
11673
815
    CHECK_ERROR0;
11674
774
                if (op->ch2 == -1)
11675
0
                    break;
11676
774
                if (ctxt->value == NULL)
11677
0
                    break;
11678
11679
                /*
11680
                 * In case of errors, xmlXPathNodeSetFilter can pop additional
11681
                 * nodes from the stack. We have to temporarily remove the
11682
                 * nodeset object from the stack to avoid freeing it
11683
                 * prematurely.
11684
                 */
11685
774
                CHECK_TYPE0(XPATH_NODESET);
11686
700
                obj = xmlXPathValuePop(ctxt);
11687
700
                set = obj->nodesetval;
11688
700
                if (set != NULL)
11689
700
                    xmlXPathNodeSetFilter(ctxt, set, op->ch2,
11690
700
                                          1, set->nodeNr, 1);
11691
700
                xmlXPathValuePush(ctxt, obj);
11692
700
                break;
11693
774
            }
11694
474k
        case XPATH_OP_SORT:
11695
474k
            if (op->ch1 != -1)
11696
474k
                total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
11697
474k
      CHECK_ERROR0;
11698
471k
            if ((ctxt->value != NULL) &&
11699
471k
                (ctxt->value->type == XPATH_NODESET) &&
11700
471k
                (ctxt->value->nodesetval != NULL) &&
11701
471k
    (ctxt->value->nodesetval->nodeNr > 1))
11702
31.8k
      {
11703
31.8k
                xmlXPathNodeSetSort(ctxt->value->nodesetval);
11704
31.8k
      }
11705
471k
            break;
11706
0
        default:
11707
0
            XP_ERROR0(XPATH_INVALID_OPERAND);
11708
0
            break;
11709
2.10M
    }
11710
11711
2.10M
    ctxt->context->depth -= 1;
11712
2.10M
    return (total);
11713
2.10M
}
11714
11715
/**
11716
 * xmlXPathCompOpEvalToBoolean:
11717
 * @ctxt:  the XPath parser context
11718
 *
11719
 * Evaluates if the expression evaluates to true.
11720
 *
11721
 * Returns 1 if true, 0 if false and -1 on API or internal errors.
11722
 */
11723
static int
11724
xmlXPathCompOpEvalToBoolean(xmlXPathParserContextPtr ctxt,
11725
          xmlXPathStepOpPtr op,
11726
          int isPredicate)
11727
1.00M
{
11728
1.00M
    xmlXPathObjectPtr resObj = NULL;
11729
11730
1.18M
start:
11731
1.18M
    if (OP_LIMIT_EXCEEDED(ctxt, 1))
11732
7
        return(0);
11733
    /* comp = ctxt->comp; */
11734
1.18M
    switch (op->op) {
11735
0
        case XPATH_OP_END:
11736
0
            return (0);
11737
654k
  case XPATH_OP_VALUE:
11738
654k
      resObj = (xmlXPathObjectPtr) op->value4;
11739
654k
      if (isPredicate)
11740
654k
    return(xmlXPathEvaluatePredicateResult(ctxt, resObj));
11741
0
      return(xmlXPathCastToBoolean(resObj));
11742
186k
  case XPATH_OP_SORT:
11743
      /*
11744
      * We don't need sorting for boolean results. Skip this one.
11745
      */
11746
186k
            if (op->ch1 != -1) {
11747
186k
    op = &ctxt->comp->steps[op->ch1];
11748
186k
    goto start;
11749
186k
      }
11750
0
      return(0);
11751
3
  case XPATH_OP_COLLECT:
11752
3
      if (op->ch1 == -1)
11753
0
    return(0);
11754
11755
3
            xmlXPathCompOpEval(ctxt, &ctxt->comp->steps[op->ch1]);
11756
3
      if (ctxt->error != XPATH_EXPRESSION_OK)
11757
0
    return(-1);
11758
11759
3
            xmlXPathNodeCollectAndTest(ctxt, op, NULL, NULL, 1);
11760
3
      if (ctxt->error != XPATH_EXPRESSION_OK)
11761
0
    return(-1);
11762
11763
3
      resObj = xmlXPathValuePop(ctxt);
11764
3
      if (resObj == NULL)
11765
0
    return(-1);
11766
3
      break;
11767
349k
  default:
11768
      /*
11769
      * Fallback to call xmlXPathCompOpEval().
11770
      */
11771
349k
      xmlXPathCompOpEval(ctxt, op);
11772
349k
      if (ctxt->error != XPATH_EXPRESSION_OK)
11773
173
    return(-1);
11774
11775
349k
      resObj = xmlXPathValuePop(ctxt);
11776
349k
      if (resObj == NULL)
11777
0
    return(-1);
11778
349k
      break;
11779
1.18M
    }
11780
11781
349k
    if (resObj) {
11782
349k
  int res;
11783
11784
349k
  if (resObj->type == XPATH_BOOLEAN) {
11785
6.12k
      res = resObj->boolval;
11786
342k
  } else if (isPredicate) {
11787
      /*
11788
      * For predicates a result of type "number" is handled
11789
      * differently:
11790
      * SPEC XPath 1.0:
11791
      * "If the result is a number, the result will be converted
11792
      *  to true if the number is equal to the context position
11793
      *  and will be converted to false otherwise;"
11794
      */
11795
342k
      res = xmlXPathEvaluatePredicateResult(ctxt, resObj);
11796
342k
  } else {
11797
0
      res = xmlXPathCastToBoolean(resObj);
11798
0
  }
11799
349k
  xmlXPathReleaseObject(ctxt->context, resObj);
11800
349k
  return(res);
11801
349k
    }
11802
11803
0
    return(0);
11804
349k
}
11805
11806
#ifdef XPATH_STREAMING
11807
/**
11808
 * xmlXPathRunStreamEval:
11809
 * @pctxt:  the XPath parser context with the compiled expression
11810
 *
11811
 * Evaluate the Precompiled Streamable XPath expression in the given context.
11812
 */
11813
static int
11814
xmlXPathRunStreamEval(xmlXPathParserContextPtr pctxt, xmlPatternPtr comp,
11815
          xmlXPathObjectPtr *resultSeq, int toBool)
11816
{
11817
    int max_depth, min_depth;
11818
    int from_root;
11819
    int ret, depth;
11820
    int eval_all_nodes;
11821
    xmlNodePtr cur = NULL, limit = NULL;
11822
    xmlStreamCtxtPtr patstream = NULL;
11823
    xmlXPathContextPtr ctxt = pctxt->context;
11824
11825
    if ((ctxt == NULL) || (comp == NULL))
11826
        return(-1);
11827
    max_depth = xmlPatternMaxDepth(comp);
11828
    if (max_depth == -1)
11829
        return(-1);
11830
    if (max_depth == -2)
11831
        max_depth = 10000;
11832
    min_depth = xmlPatternMinDepth(comp);
11833
    if (min_depth == -1)
11834
        return(-1);
11835
    from_root = xmlPatternFromRoot(comp);
11836
    if (from_root < 0)
11837
        return(-1);
11838
11839
    if (! toBool) {
11840
  if (resultSeq == NULL)
11841
      return(-1);
11842
  *resultSeq = xmlXPathCacheNewNodeSet(pctxt, NULL);
11843
  if (*resultSeq == NULL)
11844
      return(-1);
11845
    }
11846
11847
    /*
11848
     * handle the special cases of "/" amd "." being matched
11849
     */
11850
    if (min_depth == 0) {
11851
        int res;
11852
11853
  if (from_root) {
11854
      /* Select "/" */
11855
      if (toBool)
11856
    return(1);
11857
            res = xmlXPathNodeSetAddUnique((*resultSeq)->nodesetval,
11858
                                           (xmlNodePtr) ctxt->doc);
11859
  } else {
11860
      /* Select "self::node()" */
11861
      if (toBool)
11862
    return(1);
11863
            res = xmlXPathNodeSetAddUnique((*resultSeq)->nodesetval,
11864
                                           ctxt->node);
11865
  }
11866
11867
        if (res < 0)
11868
            xmlXPathPErrMemory(pctxt);
11869
    }
11870
    if (max_depth == 0) {
11871
  return(0);
11872
    }
11873
11874
    if (from_root) {
11875
        cur = (xmlNodePtr)ctxt->doc;
11876
    } else if (ctxt->node != NULL) {
11877
        switch (ctxt->node->type) {
11878
            case XML_ELEMENT_NODE:
11879
            case XML_DOCUMENT_NODE:
11880
            case XML_DOCUMENT_FRAG_NODE:
11881
            case XML_HTML_DOCUMENT_NODE:
11882
          cur = ctxt->node;
11883
    break;
11884
            case XML_ATTRIBUTE_NODE:
11885
            case XML_TEXT_NODE:
11886
            case XML_CDATA_SECTION_NODE:
11887
            case XML_ENTITY_REF_NODE:
11888
            case XML_ENTITY_NODE:
11889
            case XML_PI_NODE:
11890
            case XML_COMMENT_NODE:
11891
            case XML_NOTATION_NODE:
11892
            case XML_DTD_NODE:
11893
            case XML_DOCUMENT_TYPE_NODE:
11894
            case XML_ELEMENT_DECL:
11895
            case XML_ATTRIBUTE_DECL:
11896
            case XML_ENTITY_DECL:
11897
            case XML_NAMESPACE_DECL:
11898
            case XML_XINCLUDE_START:
11899
            case XML_XINCLUDE_END:
11900
    break;
11901
  }
11902
  limit = cur;
11903
    }
11904
    if (cur == NULL) {
11905
        return(0);
11906
    }
11907
11908
    patstream = xmlPatternGetStreamCtxt(comp);
11909
    if (patstream == NULL) {
11910
        xmlXPathPErrMemory(pctxt);
11911
  return(-1);
11912
    }
11913
11914
    eval_all_nodes = xmlStreamWantsAnyNode(patstream);
11915
11916
    if (from_root) {
11917
  ret = xmlStreamPush(patstream, NULL, NULL);
11918
  if (ret < 0) {
11919
  } else if (ret == 1) {
11920
      if (toBool)
11921
    goto return_1;
11922
      if (xmlXPathNodeSetAddUnique((*resultSeq)->nodesetval, cur) < 0)
11923
                xmlXPathPErrMemory(pctxt);
11924
  }
11925
    }
11926
    depth = 0;
11927
    goto scan_children;
11928
next_node:
11929
    do {
11930
        if (ctxt->opLimit != 0) {
11931
            if (ctxt->opCount >= ctxt->opLimit) {
11932
                xmlXPathErr(ctxt, XPATH_RECURSION_LIMIT_EXCEEDED);
11933
                xmlFreeStreamCtxt(patstream);
11934
                return(-1);
11935
            }
11936
            ctxt->opCount++;
11937
        }
11938
11939
  switch (cur->type) {
11940
      case XML_ELEMENT_NODE:
11941
      case XML_TEXT_NODE:
11942
      case XML_CDATA_SECTION_NODE:
11943
      case XML_COMMENT_NODE:
11944
      case XML_PI_NODE:
11945
    if (cur->type == XML_ELEMENT_NODE) {
11946
        ret = xmlStreamPush(patstream, cur->name,
11947
        (cur->ns ? cur->ns->href : NULL));
11948
    } else if (eval_all_nodes)
11949
        ret = xmlStreamPushNode(patstream, NULL, NULL, cur->type);
11950
    else
11951
        break;
11952
11953
    if (ret < 0) {
11954
        xmlXPathPErrMemory(pctxt);
11955
    } else if (ret == 1) {
11956
        if (toBool)
11957
      goto return_1;
11958
        if (xmlXPathNodeSetAddUnique((*resultSeq)->nodesetval,
11959
                                                 cur) < 0)
11960
                        xmlXPathPErrMemory(pctxt);
11961
    }
11962
    if ((cur->children == NULL) || (depth >= max_depth)) {
11963
        ret = xmlStreamPop(patstream);
11964
        while (cur->next != NULL) {
11965
      cur = cur->next;
11966
      if ((cur->type != XML_ENTITY_DECL) &&
11967
          (cur->type != XML_DTD_NODE))
11968
          goto next_node;
11969
        }
11970
    }
11971
      default:
11972
    break;
11973
  }
11974
11975
scan_children:
11976
  if (cur->type == XML_NAMESPACE_DECL) break;
11977
  if ((cur->children != NULL) && (depth < max_depth)) {
11978
      /*
11979
       * Do not descend on entities declarations
11980
       */
11981
      if (cur->children->type != XML_ENTITY_DECL) {
11982
    cur = cur->children;
11983
    depth++;
11984
    /*
11985
     * Skip DTDs
11986
     */
11987
    if (cur->type != XML_DTD_NODE)
11988
        continue;
11989
      }
11990
  }
11991
11992
  if (cur == limit)
11993
      break;
11994
11995
  while (cur->next != NULL) {
11996
      cur = cur->next;
11997
      if ((cur->type != XML_ENTITY_DECL) &&
11998
    (cur->type != XML_DTD_NODE))
11999
    goto next_node;
12000
  }
12001
12002
  do {
12003
      cur = cur->parent;
12004
      depth--;
12005
      if ((cur == NULL) || (cur == limit) ||
12006
                (cur->type == XML_DOCUMENT_NODE))
12007
          goto done;
12008
      if (cur->type == XML_ELEMENT_NODE) {
12009
    ret = xmlStreamPop(patstream);
12010
      } else if ((eval_all_nodes) &&
12011
    ((cur->type == XML_TEXT_NODE) ||
12012
     (cur->type == XML_CDATA_SECTION_NODE) ||
12013
     (cur->type == XML_COMMENT_NODE) ||
12014
     (cur->type == XML_PI_NODE)))
12015
      {
12016
    ret = xmlStreamPop(patstream);
12017
      }
12018
      if (cur->next != NULL) {
12019
    cur = cur->next;
12020
    break;
12021
      }
12022
  } while (cur != NULL);
12023
12024
    } while ((cur != NULL) && (depth >= 0));
12025
12026
done:
12027
12028
    if (patstream)
12029
  xmlFreeStreamCtxt(patstream);
12030
    return(0);
12031
12032
return_1:
12033
    if (patstream)
12034
  xmlFreeStreamCtxt(patstream);
12035
    return(1);
12036
}
12037
#endif /* XPATH_STREAMING */
12038
12039
/**
12040
 * xmlXPathRunEval:
12041
 * @ctxt:  the XPath parser context with the compiled expression
12042
 * @toBool:  evaluate to a boolean result
12043
 *
12044
 * Evaluate the Precompiled XPath expression in the given context.
12045
 */
12046
static int
12047
xmlXPathRunEval(xmlXPathParserContextPtr ctxt, int toBool)
12048
133k
{
12049
133k
    xmlXPathCompExprPtr comp;
12050
133k
    int oldDepth;
12051
12052
133k
    if ((ctxt == NULL) || (ctxt->comp == NULL))
12053
0
  return(-1);
12054
12055
133k
    if (ctxt->valueTab == NULL) {
12056
792
#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
12057
792
        int valueMax = 1;
12058
#else
12059
        int valueMax = 10;
12060
#endif
12061
12062
  /* Allocate the value stack */
12063
792
  ctxt->valueTab = xmlMalloc(valueMax * sizeof(xmlXPathObjectPtr));
12064
792
  if (ctxt->valueTab == NULL) {
12065
0
      xmlXPathPErrMemory(ctxt);
12066
0
      return(-1);
12067
0
  }
12068
792
  ctxt->valueNr = 0;
12069
792
  ctxt->valueMax = valueMax;
12070
792
  ctxt->value = NULL;
12071
792
    }
12072
#ifdef XPATH_STREAMING
12073
    if (ctxt->comp->stream) {
12074
  int res;
12075
12076
  if (toBool) {
12077
      /*
12078
      * Evaluation to boolean result.
12079
      */
12080
      res = xmlXPathRunStreamEval(ctxt, ctxt->comp->stream, NULL, 1);
12081
      if (res != -1)
12082
    return(res);
12083
  } else {
12084
      xmlXPathObjectPtr resObj = NULL;
12085
12086
      /*
12087
      * Evaluation to a sequence.
12088
      */
12089
      res = xmlXPathRunStreamEval(ctxt, ctxt->comp->stream, &resObj, 0);
12090
12091
      if ((res != -1) && (resObj != NULL)) {
12092
    xmlXPathValuePush(ctxt, resObj);
12093
    return(0);
12094
      }
12095
      if (resObj != NULL)
12096
    xmlXPathReleaseObject(ctxt->context, resObj);
12097
  }
12098
  /*
12099
  * QUESTION TODO: This falls back to normal XPath evaluation
12100
  * if res == -1. Is this intended?
12101
  */
12102
    }
12103
#endif
12104
133k
    comp = ctxt->comp;
12105
133k
    if (comp->last < 0) {
12106
0
        xmlXPathErr(ctxt, XPATH_STACK_ERROR);
12107
0
  return(-1);
12108
0
    }
12109
133k
    oldDepth = ctxt->context->depth;
12110
133k
    if (toBool)
12111
0
  return(xmlXPathCompOpEvalToBoolean(ctxt,
12112
0
      &comp->steps[comp->last], 0));
12113
133k
    else
12114
133k
  xmlXPathCompOpEval(ctxt, &comp->steps[comp->last]);
12115
133k
    ctxt->context->depth = oldDepth;
12116
12117
133k
    return(0);
12118
133k
}
12119
12120
/************************************************************************
12121
 *                  *
12122
 *      Public interfaces       *
12123
 *                  *
12124
 ************************************************************************/
12125
12126
/**
12127
 * xmlXPathEvalPredicate:
12128
 * @ctxt:  the XPath context
12129
 * @res:  the Predicate Expression evaluation result
12130
 *
12131
 * Evaluate a predicate result for the current node.
12132
 * A PredicateExpr is evaluated by evaluating the Expr and converting
12133
 * the result to a boolean. If the result is a number, the result will
12134
 * be converted to true if the number is equal to the position of the
12135
 * context node in the context node list (as returned by the position
12136
 * function) and will be converted to false otherwise; if the result
12137
 * is not a number, then the result will be converted as if by a call
12138
 * to the boolean function.
12139
 *
12140
 * Returns 1 if predicate is true, 0 otherwise
12141
 */
12142
int
12143
0
xmlXPathEvalPredicate(xmlXPathContextPtr ctxt, xmlXPathObjectPtr res) {
12144
0
    if ((ctxt == NULL) || (res == NULL)) return(0);
12145
0
    switch (res->type) {
12146
0
        case XPATH_BOOLEAN:
12147
0
      return(res->boolval);
12148
0
        case XPATH_NUMBER:
12149
0
      return(res->floatval == ctxt->proximityPosition);
12150
0
        case XPATH_NODESET:
12151
0
        case XPATH_XSLT_TREE:
12152
0
      if (res->nodesetval == NULL)
12153
0
    return(0);
12154
0
      return(res->nodesetval->nodeNr != 0);
12155
0
        case XPATH_STRING:
12156
0
      return((res->stringval != NULL) &&
12157
0
             (xmlStrlen(res->stringval) != 0));
12158
0
        default:
12159
0
      break;
12160
0
    }
12161
0
    return(0);
12162
0
}
12163
12164
/**
12165
 * xmlXPathEvaluatePredicateResult:
12166
 * @ctxt:  the XPath Parser context
12167
 * @res:  the Predicate Expression evaluation result
12168
 *
12169
 * Evaluate a predicate result for the current node.
12170
 * A PredicateExpr is evaluated by evaluating the Expr and converting
12171
 * the result to a boolean. If the result is a number, the result will
12172
 * be converted to true if the number is equal to the position of the
12173
 * context node in the context node list (as returned by the position
12174
 * function) and will be converted to false otherwise; if the result
12175
 * is not a number, then the result will be converted as if by a call
12176
 * to the boolean function.
12177
 *
12178
 * Returns 1 if predicate is true, 0 otherwise
12179
 */
12180
int
12181
xmlXPathEvaluatePredicateResult(xmlXPathParserContextPtr ctxt,
12182
996k
                                xmlXPathObjectPtr res) {
12183
996k
    if ((ctxt == NULL) || (res == NULL)) return(0);
12184
996k
    switch (res->type) {
12185
0
        case XPATH_BOOLEAN:
12186
0
      return(res->boolval);
12187
315k
        case XPATH_NUMBER:
12188
#if defined(__BORLANDC__) || (defined(_MSC_VER) && (_MSC_VER == 1200))
12189
      return((res->floatval == ctxt->context->proximityPosition) &&
12190
             (!xmlXPathIsNaN(res->floatval))); /* MSC pbm Mark Vakoc !*/
12191
#else
12192
315k
      return(res->floatval == ctxt->context->proximityPosition);
12193
0
#endif
12194
19.8k
        case XPATH_NODESET:
12195
19.8k
        case XPATH_XSLT_TREE:
12196
19.8k
      if (res->nodesetval == NULL)
12197
0
    return(0);
12198
19.8k
      return(res->nodesetval->nodeNr != 0);
12199
661k
        case XPATH_STRING:
12200
661k
      return((res->stringval != NULL) && (res->stringval[0] != 0));
12201
0
        default:
12202
0
      break;
12203
996k
    }
12204
0
    return(0);
12205
996k
}
12206
12207
#ifdef XPATH_STREAMING
12208
/**
12209
 * xmlXPathTryStreamCompile:
12210
 * @ctxt: an XPath context
12211
 * @str:  the XPath expression
12212
 *
12213
 * Try to compile the XPath expression as a streamable subset.
12214
 *
12215
 * Returns the compiled expression or NULL if failed to compile.
12216
 */
12217
static xmlXPathCompExprPtr
12218
xmlXPathTryStreamCompile(xmlXPathContextPtr ctxt, const xmlChar *str) {
12219
    /*
12220
     * Optimization: use streaming patterns when the XPath expression can
12221
     * be compiled to a stream lookup
12222
     */
12223
    xmlPatternPtr stream;
12224
    xmlXPathCompExprPtr comp;
12225
    xmlDictPtr dict = NULL;
12226
    const xmlChar **namespaces = NULL;
12227
    xmlNsPtr ns;
12228
    int i, j;
12229
12230
    if ((!xmlStrchr(str, '[')) && (!xmlStrchr(str, '(')) &&
12231
        (!xmlStrchr(str, '@'))) {
12232
  const xmlChar *tmp;
12233
        int res;
12234
12235
  /*
12236
   * We don't try to handle expressions using the verbose axis
12237
   * specifiers ("::"), just the simplified form at this point.
12238
   * Additionally, if there is no list of namespaces available and
12239
   *  there's a ":" in the expression, indicating a prefixed QName,
12240
   *  then we won't try to compile either. xmlPatterncompile() needs
12241
   *  to have a list of namespaces at compilation time in order to
12242
   *  compile prefixed name tests.
12243
   */
12244
  tmp = xmlStrchr(str, ':');
12245
  if ((tmp != NULL) &&
12246
      ((ctxt == NULL) || (ctxt->nsNr == 0) || (tmp[1] == ':')))
12247
      return(NULL);
12248
12249
  if (ctxt != NULL) {
12250
      dict = ctxt->dict;
12251
      if (ctxt->nsNr > 0) {
12252
    namespaces = xmlMalloc(2 * (ctxt->nsNr + 1) * sizeof(xmlChar*));
12253
    if (namespaces == NULL) {
12254
        xmlXPathErrMemory(ctxt);
12255
        return(NULL);
12256
    }
12257
    for (i = 0, j = 0; (j < ctxt->nsNr); j++) {
12258
        ns = ctxt->namespaces[j];
12259
        namespaces[i++] = ns->href;
12260
        namespaces[i++] = ns->prefix;
12261
    }
12262
    namespaces[i++] = NULL;
12263
    namespaces[i] = NULL;
12264
      }
12265
  }
12266
12267
  res = xmlPatternCompileSafe(str, dict, XML_PATTERN_XPATH, namespaces,
12268
                                    &stream);
12269
  if (namespaces != NULL) {
12270
      xmlFree((xmlChar **)namespaces);
12271
  }
12272
        if (res < 0) {
12273
            xmlXPathErrMemory(ctxt);
12274
            return(NULL);
12275
        }
12276
  if ((stream != NULL) && (xmlPatternStreamable(stream) == 1)) {
12277
      comp = xmlXPathNewCompExpr();
12278
      if (comp == NULL) {
12279
    xmlXPathErrMemory(ctxt);
12280
          xmlFreePattern(stream);
12281
    return(NULL);
12282
      }
12283
      comp->stream = stream;
12284
      comp->dict = dict;
12285
      if (comp->dict)
12286
    xmlDictReference(comp->dict);
12287
      return(comp);
12288
  }
12289
  xmlFreePattern(stream);
12290
    }
12291
    return(NULL);
12292
}
12293
#endif /* XPATH_STREAMING */
12294
12295
static void
12296
xmlXPathOptimizeExpression(xmlXPathParserContextPtr pctxt,
12297
                           xmlXPathStepOpPtr op)
12298
37.3k
{
12299
37.3k
    xmlXPathCompExprPtr comp = pctxt->comp;
12300
37.3k
    xmlXPathContextPtr ctxt;
12301
12302
    /*
12303
    * Try to rewrite "descendant-or-self::node()/foo" to an optimized
12304
    * internal representation.
12305
    */
12306
12307
37.3k
    if ((op->op == XPATH_OP_COLLECT /* 11 */) &&
12308
37.3k
        (op->ch1 != -1) &&
12309
37.3k
        (op->ch2 == -1 /* no predicate */))
12310
12.6k
    {
12311
12.6k
        xmlXPathStepOpPtr prevop = &comp->steps[op->ch1];
12312
12313
12.6k
        if ((prevop->op == XPATH_OP_COLLECT /* 11 */) &&
12314
12.6k
            ((xmlXPathAxisVal) prevop->value ==
12315
2.84k
                AXIS_DESCENDANT_OR_SELF) &&
12316
12.6k
            (prevop->ch2 == -1) &&
12317
12.6k
            ((xmlXPathTestVal) prevop->value2 == NODE_TEST_TYPE) &&
12318
12.6k
            ((xmlXPathTypeVal) prevop->value3 == NODE_TYPE_NODE))
12319
905
        {
12320
            /*
12321
            * This is a "descendant-or-self::node()" without predicates.
12322
            * Try to eliminate it.
12323
            */
12324
12325
905
            switch ((xmlXPathAxisVal) op->value) {
12326
851
                case AXIS_CHILD:
12327
851
                case AXIS_DESCENDANT:
12328
                    /*
12329
                    * Convert "descendant-or-self::node()/child::" or
12330
                    * "descendant-or-self::node()/descendant::" to
12331
                    * "descendant::"
12332
                    */
12333
851
                    op->ch1   = prevop->ch1;
12334
851
                    op->value = AXIS_DESCENDANT;
12335
851
                    break;
12336
0
                case AXIS_SELF:
12337
22
                case AXIS_DESCENDANT_OR_SELF:
12338
                    /*
12339
                    * Convert "descendant-or-self::node()/self::" or
12340
                    * "descendant-or-self::node()/descendant-or-self::" to
12341
                    * to "descendant-or-self::"
12342
                    */
12343
22
                    op->ch1   = prevop->ch1;
12344
22
                    op->value = AXIS_DESCENDANT_OR_SELF;
12345
22
                    break;
12346
32
                default:
12347
32
                    break;
12348
905
            }
12349
905
  }
12350
12.6k
    }
12351
12352
    /* OP_VALUE has invalid ch1. */
12353
37.3k
    if (op->op == XPATH_OP_VALUE)
12354
150
        return;
12355
12356
    /* Recurse */
12357
37.1k
    ctxt = pctxt->context;
12358
37.1k
    if (ctxt != NULL) {
12359
37.1k
        if (ctxt->depth >= XPATH_MAX_RECURSION_DEPTH)
12360
33
            return;
12361
37.1k
        ctxt->depth += 1;
12362
37.1k
    }
12363
37.1k
    if (op->ch1 != -1)
12364
25.5k
        xmlXPathOptimizeExpression(pctxt, &comp->steps[op->ch1]);
12365
37.1k
    if (op->ch2 != -1)
12366
8.06k
  xmlXPathOptimizeExpression(pctxt, &comp->steps[op->ch2]);
12367
37.1k
    if (ctxt != NULL)
12368
37.1k
        ctxt->depth -= 1;
12369
37.1k
}
12370
12371
/**
12372
 * xmlXPathCtxtCompile:
12373
 * @ctxt: an XPath context
12374
 * @str:  the XPath expression
12375
 *
12376
 * Compile an XPath expression
12377
 *
12378
 * Returns the xmlXPathCompExprPtr resulting from the compilation or NULL.
12379
 *         the caller has to free the object.
12380
 */
12381
xmlXPathCompExprPtr
12382
14.8k
xmlXPathCtxtCompile(xmlXPathContextPtr ctxt, const xmlChar *str) {
12383
14.8k
    xmlXPathParserContextPtr pctxt;
12384
14.8k
    xmlXPathContextPtr tmpctxt = NULL;
12385
14.8k
    xmlXPathCompExprPtr comp;
12386
14.8k
    int oldDepth = 0;
12387
12388
#ifdef XPATH_STREAMING
12389
    comp = xmlXPathTryStreamCompile(ctxt, str);
12390
    if (comp != NULL)
12391
        return(comp);
12392
#endif
12393
12394
14.8k
    xmlInitParser();
12395
12396
    /*
12397
     * We need an xmlXPathContext for the depth check.
12398
     */
12399
14.8k
    if (ctxt == NULL) {
12400
0
        tmpctxt = xmlXPathNewContext(NULL);
12401
0
        if (tmpctxt == NULL)
12402
0
            return(NULL);
12403
0
        ctxt = tmpctxt;
12404
0
    }
12405
12406
14.8k
    pctxt = xmlXPathNewParserContext(str, ctxt);
12407
14.8k
    if (pctxt == NULL) {
12408
0
        if (tmpctxt != NULL)
12409
0
            xmlXPathFreeContext(tmpctxt);
12410
0
        return NULL;
12411
0
    }
12412
12413
14.8k
    oldDepth = ctxt->depth;
12414
14.8k
    xmlXPathCompileExpr(pctxt, 1);
12415
14.8k
    ctxt->depth = oldDepth;
12416
12417
14.8k
    if( pctxt->error != XPATH_EXPRESSION_OK )
12418
8.25k
    {
12419
8.25k
        xmlXPathFreeParserContext(pctxt);
12420
8.25k
        if (tmpctxt != NULL)
12421
0
            xmlXPathFreeContext(tmpctxt);
12422
8.25k
        return(NULL);
12423
8.25k
    }
12424
12425
6.60k
    if (*pctxt->cur != 0) {
12426
  /*
12427
   * aleksey: in some cases this line prints *second* error message
12428
   * (see bug #78858) and probably this should be fixed.
12429
   * However, we are not sure that all error messages are printed
12430
   * out in other places. It's not critical so we leave it as-is for now
12431
   */
12432
3.56k
  xmlXPatherror(pctxt, __FILE__, __LINE__, XPATH_EXPR_ERROR);
12433
3.56k
  comp = NULL;
12434
3.56k
    } else {
12435
3.04k
  comp = pctxt->comp;
12436
3.04k
  if ((comp->nbStep > 1) && (comp->last >= 0)) {
12437
2.96k
            if (ctxt != NULL)
12438
2.96k
                oldDepth = ctxt->depth;
12439
2.96k
      xmlXPathOptimizeExpression(pctxt, &comp->steps[comp->last]);
12440
2.96k
            if (ctxt != NULL)
12441
2.96k
                ctxt->depth = oldDepth;
12442
2.96k
  }
12443
3.04k
  pctxt->comp = NULL;
12444
3.04k
    }
12445
6.60k
    xmlXPathFreeParserContext(pctxt);
12446
6.60k
    if (tmpctxt != NULL)
12447
0
        xmlXPathFreeContext(tmpctxt);
12448
12449
6.60k
    if (comp != NULL) {
12450
3.04k
  comp->expr = xmlStrdup(str);
12451
3.04k
    }
12452
6.60k
    return(comp);
12453
14.8k
}
12454
12455
/**
12456
 * xmlXPathCompile:
12457
 * @str:  the XPath expression
12458
 *
12459
 * Compile an XPath expression
12460
 *
12461
 * Returns the xmlXPathCompExprPtr resulting from the compilation or NULL.
12462
 *         the caller has to free the object.
12463
 */
12464
xmlXPathCompExprPtr
12465
0
xmlXPathCompile(const xmlChar *str) {
12466
0
    return(xmlXPathCtxtCompile(NULL, str));
12467
0
}
12468
12469
/**
12470
 * xmlXPathCompiledEvalInternal:
12471
 * @comp:  the compiled XPath expression
12472
 * @ctxt:  the XPath context
12473
 * @resObj: the resulting XPath object or NULL
12474
 * @toBool: 1 if only a boolean result is requested
12475
 *
12476
 * Evaluate the Precompiled XPath expression in the given context.
12477
 * The caller has to free @resObj.
12478
 *
12479
 * Returns the xmlXPathObjectPtr resulting from the evaluation or NULL.
12480
 *         the caller has to free the object.
12481
 */
12482
static int
12483
xmlXPathCompiledEvalInternal(xmlXPathCompExprPtr comp,
12484
           xmlXPathContextPtr ctxt,
12485
           xmlXPathObjectPtr *resObjPtr,
12486
           int toBool)
12487
134k
{
12488
134k
    xmlXPathParserContextPtr pctxt;
12489
134k
    xmlXPathObjectPtr resObj = NULL;
12490
134k
    int res;
12491
12492
134k
    if (comp == NULL)
12493
0
  return(-1);
12494
134k
    xmlInitParser();
12495
12496
134k
    xmlResetError(&ctxt->lastError);
12497
12498
134k
    pctxt = xmlXPathCompParserContext(comp, ctxt);
12499
134k
    if (pctxt == NULL)
12500
2.38k
        return(-1);
12501
132k
    res = xmlXPathRunEval(pctxt, toBool);
12502
12503
132k
    if (pctxt->error == XPATH_EXPRESSION_OK) {
12504
129k
        if (pctxt->valueNr != ((toBool) ? 0 : 1))
12505
0
            xmlXPathErr(pctxt, XPATH_STACK_ERROR);
12506
129k
        else if (!toBool)
12507
129k
            resObj = xmlXPathValuePop(pctxt);
12508
129k
    }
12509
12510
132k
    if (resObjPtr)
12511
132k
        *resObjPtr = resObj;
12512
0
    else
12513
0
        xmlXPathReleaseObject(ctxt, resObj);
12514
12515
132k
    pctxt->comp = NULL;
12516
132k
    xmlXPathFreeParserContext(pctxt);
12517
12518
132k
    return(res);
12519
134k
}
12520
12521
/**
12522
 * xmlXPathCompiledEval:
12523
 * @comp:  the compiled XPath expression
12524
 * @ctx:  the XPath context
12525
 *
12526
 * Evaluate the Precompiled XPath expression in the given context.
12527
 *
12528
 * Returns the xmlXPathObjectPtr resulting from the evaluation or NULL.
12529
 *         the caller has to free the object.
12530
 */
12531
xmlXPathObjectPtr
12532
xmlXPathCompiledEval(xmlXPathCompExprPtr comp, xmlXPathContextPtr ctx)
12533
134k
{
12534
134k
    xmlXPathObjectPtr res = NULL;
12535
12536
134k
    xmlXPathCompiledEvalInternal(comp, ctx, &res, 0);
12537
134k
    return(res);
12538
134k
}
12539
12540
/**
12541
 * xmlXPathCompiledEvalToBoolean:
12542
 * @comp:  the compiled XPath expression
12543
 * @ctxt:  the XPath context
12544
 *
12545
 * Applies the XPath boolean() function on the result of the given
12546
 * compiled expression.
12547
 *
12548
 * Returns 1 if the expression evaluated to true, 0 if to false and
12549
 *         -1 in API and internal errors.
12550
 */
12551
int
12552
xmlXPathCompiledEvalToBoolean(xmlXPathCompExprPtr comp,
12553
            xmlXPathContextPtr ctxt)
12554
0
{
12555
0
    return(xmlXPathCompiledEvalInternal(comp, ctxt, NULL, 1));
12556
0
}
12557
12558
/**
12559
 * xmlXPathEvalExpr:
12560
 * @ctxt:  the XPath Parser context
12561
 *
12562
 * DEPRECATED: Internal function, don't use.
12563
 *
12564
 * Parse and evaluate an XPath expression in the given context,
12565
 * then push the result on the context stack
12566
 */
12567
void
12568
792
xmlXPathEvalExpr(xmlXPathParserContextPtr ctxt) {
12569
#ifdef XPATH_STREAMING
12570
    xmlXPathCompExprPtr comp;
12571
#endif
12572
792
    int oldDepth = 0;
12573
12574
792
    if ((ctxt == NULL) || (ctxt->context == NULL))
12575
0
        return;
12576
792
    if (ctxt->context->lastError.code != 0)
12577
0
        return;
12578
12579
#ifdef XPATH_STREAMING
12580
    comp = xmlXPathTryStreamCompile(ctxt->context, ctxt->base);
12581
    if ((comp == NULL) &&
12582
        (ctxt->context->lastError.code == XML_ERR_NO_MEMORY)) {
12583
        xmlXPathPErrMemory(ctxt);
12584
        return;
12585
    }
12586
    if (comp != NULL) {
12587
        if (ctxt->comp != NULL)
12588
      xmlXPathFreeCompExpr(ctxt->comp);
12589
        ctxt->comp = comp;
12590
    } else
12591
#endif
12592
792
    {
12593
792
        if (ctxt->context != NULL)
12594
792
            oldDepth = ctxt->context->depth;
12595
792
  xmlXPathCompileExpr(ctxt, 1);
12596
792
        if (ctxt->context != NULL)
12597
792
            ctxt->context->depth = oldDepth;
12598
792
        CHECK_ERROR;
12599
12600
        /* Check for trailing characters. */
12601
792
        if (*ctxt->cur != 0)
12602
792
            XP_ERROR(XPATH_EXPR_ERROR);
12603
12604
792
  if ((ctxt->comp->nbStep > 1) && (ctxt->comp->last >= 0)) {
12605
792
            if (ctxt->context != NULL)
12606
792
                oldDepth = ctxt->context->depth;
12607
792
      xmlXPathOptimizeExpression(ctxt,
12608
792
    &ctxt->comp->steps[ctxt->comp->last]);
12609
792
            if (ctxt->context != NULL)
12610
792
                ctxt->context->depth = oldDepth;
12611
792
        }
12612
792
    }
12613
12614
0
    xmlXPathRunEval(ctxt, 0);
12615
792
}
12616
12617
/**
12618
 * xmlXPathEval:
12619
 * @str:  the XPath expression
12620
 * @ctx:  the XPath context
12621
 *
12622
 * Evaluate the XPath Location Path in the given context.
12623
 *
12624
 * Returns the xmlXPathObjectPtr resulting from the evaluation or NULL.
12625
 *         the caller has to free the object.
12626
 */
12627
xmlXPathObjectPtr
12628
792
xmlXPathEval(const xmlChar *str, xmlXPathContextPtr ctx) {
12629
792
    xmlXPathParserContextPtr ctxt;
12630
792
    xmlXPathObjectPtr res;
12631
12632
792
    if (ctx == NULL)
12633
0
        return(NULL);
12634
12635
792
    xmlInitParser();
12636
12637
792
    xmlResetError(&ctx->lastError);
12638
12639
792
    ctxt = xmlXPathNewParserContext(str, ctx);
12640
792
    if (ctxt == NULL)
12641
0
        return NULL;
12642
792
    xmlXPathEvalExpr(ctxt);
12643
12644
792
    if (ctxt->error != XPATH_EXPRESSION_OK) {
12645
7
  res = NULL;
12646
785
    } else if (ctxt->valueNr != 1) {
12647
0
        xmlXPathErr(ctxt, XPATH_STACK_ERROR);
12648
0
  res = NULL;
12649
785
    } else {
12650
785
  res = xmlXPathValuePop(ctxt);
12651
785
    }
12652
12653
792
    xmlXPathFreeParserContext(ctxt);
12654
792
    return(res);
12655
792
}
12656
12657
/**
12658
 * xmlXPathSetContextNode:
12659
 * @node: the node to to use as the context node
12660
 * @ctx:  the XPath context
12661
 *
12662
 * Sets 'node' as the context node. The node must be in the same
12663
 * document as that associated with the context.
12664
 *
12665
 * Returns -1 in case of error or 0 if successful
12666
 */
12667
int
12668
0
xmlXPathSetContextNode(xmlNodePtr node, xmlXPathContextPtr ctx) {
12669
0
    if ((node == NULL) || (ctx == NULL))
12670
0
        return(-1);
12671
12672
0
    if (node->doc == ctx->doc) {
12673
0
        ctx->node = node;
12674
0
  return(0);
12675
0
    }
12676
0
    return(-1);
12677
0
}
12678
12679
/**
12680
 * xmlXPathNodeEval:
12681
 * @node: the node to to use as the context node
12682
 * @str:  the XPath expression
12683
 * @ctx:  the XPath context
12684
 *
12685
 * Evaluate the XPath Location Path in the given context. The node 'node'
12686
 * is set as the context node. The context node is not restored.
12687
 *
12688
 * Returns the xmlXPathObjectPtr resulting from the evaluation or NULL.
12689
 *         the caller has to free the object.
12690
 */
12691
xmlXPathObjectPtr
12692
0
xmlXPathNodeEval(xmlNodePtr node, const xmlChar *str, xmlXPathContextPtr ctx) {
12693
0
    if (str == NULL)
12694
0
        return(NULL);
12695
0
    if (xmlXPathSetContextNode(node, ctx) < 0)
12696
0
        return(NULL);
12697
0
    return(xmlXPathEval(str, ctx));
12698
0
}
12699
12700
/**
12701
 * xmlXPathEvalExpression:
12702
 * @str:  the XPath expression
12703
 * @ctxt:  the XPath context
12704
 *
12705
 * Alias for xmlXPathEval().
12706
 *
12707
 * Returns the xmlXPathObjectPtr resulting from the evaluation or NULL.
12708
 *         the caller has to free the object.
12709
 */
12710
xmlXPathObjectPtr
12711
0
xmlXPathEvalExpression(const xmlChar *str, xmlXPathContextPtr ctxt) {
12712
0
    return(xmlXPathEval(str, ctxt));
12713
0
}
12714
12715
/**
12716
 * xmlXPathRegisterAllFunctions:
12717
 * @ctxt:  the XPath context
12718
 *
12719
 * DEPRECATED: No-op since 2.14.0.
12720
 *
12721
 * Registers all default XPath functions in this context
12722
 */
12723
void
12724
xmlXPathRegisterAllFunctions(xmlXPathContextPtr ctxt ATTRIBUTE_UNUSED)
12725
0
{
12726
0
}
12727
12728
#endif /* LIBXML_XPATH_ENABLED */