72 * xmlXPathOrderDocElems() was called in order to index the elements of
73 * a tree in document order; Libxslt does such an indexing, thus it will
81 * in a way, that it stop evaluation at the first node.
256     "?? Unknown error ??\n"	/* Must be last in the list! */
412 * TODO: Since such a list-handling is used in xmlschemas.c and libxslt
452  * Returns a xsltPointerList structure or NULL in case of an error.
575     int nbStep;			/* Number of steps in this expression */
578     int last;			/* index of last step in expression */
618  * Returns the newly allocated xmlXPathCompExprPtr or NULL in case of error
717  * Returns -1 in case of failure, the index otherwise
772  * Swaps 2 operations in the compiled expression
781      * disabled if one detects that the library is used in a multithreaded
1059 	    fprintf(output, "Object is a point : index %d in node", cur->index);
1069 		    fprintf(output, "index %d in ", cur->index);
1078 		    fprintf(output, "index %d in ", cur->index);
1085 		    fprintf(output, "index %d in ", cur->index2);
1823 	* look out for namespace nodes in the node-set.
1917  * Wrap the Nodeset @val in a new xmlXPathObjectPtr
2652  *           in ISO-Latin or UTF-8.
2663  *           in UTF-8 mode. It also pop-up unfinished entities on the fly.
2754 		  LOWER_DOUBLE_EXP is max number of leading zeroes in fraction
2769 	     * In either case, result is in work, and after_fraction points
2832  * Like for line information, the order is kept in the element->content
2836  * Returns the number of elements found in the document or -1 in case
2883  * Returns -2 in case of error 1 if first point < second point, 0 if
2896      * a couple of optimizations which will avoid computations in most cases
2912 	    /* not required, but we keep attributes in order */
2988 	/* should not happen but just in case ... */
3032  * Returns -2 in case of error 1 if first point < second point, 0 if
3050      * a couple of optimizations which will avoid computations in most cases
3087 			precedence1 = 3; /* element in prev-sibl axis */
3141 			precedence2 = 3; /* element in prev-sibl axis */
3280 	/* should not happen but just in case ... */
3319  * Sort the node set in document order
3360  * Namespace node in libxml don't match the XPath semantic. In a node set
3362  * parent node in the XPath semantic.
3395  * @ns:  the XPath namespace node found in a nodeset.
3397  * Namespace nodes in libxml don't match the XPath semantic. In a node set
3399  * parent node in the XPath semantic. Check if such a node needs to be freed
3646  * when we are sure the node is not already in the set.
3700  * Returns @val1 once extended or NULL in case of error.
3712 	* TODO: The optimization won't work in every case, since
3717 	*  some temporary nodes are in, that would be helpfull.
3813  * Returns @val1 once extended or NULL in case of error.
3875  * Returns @set1 once extended or NULL in case of error.
3982  * Returns @set1 once extended or NULL in case of error.
4061      * find node in nodeTab
4069 	        "xmlXPathNodeSetDel: Node %s wasn't found in NodeList\n",
4339  * Wrap the Nodeset @val in a new xmlXPathObjectPtr
4365  * Free up the xmlXPathObjectPtr @obj but don't deallocate the objects in
4450  * Returns a subset of the nodes contained in @nodes, or @nodes if
4490  * Returns a subset of the nodes contained in @nodes, or @nodes if
4539  * Returns the nodes in @nodes that precede @node in document order,
4577  * Returns the nodes in @nodes that precede @node in document order,
4595  * Returns the nodes in @nodes1 that precede the first node in @nodes2
4596  *         in document order, @nodes1 if @nodes2 is NULL or empty or
4617  * Returns the nodes in @nodes1 that precede the first node in @nodes2
4618  *         in document order, @nodes1 if @nodes2 is NULL or empty or
4641  * Returns the nodes in @nodes that follow @node in document order,
4680  * Returns the nodes in @nodes that follow @node in document order,
4698  * Returns the nodes in @nodes1 that follow the first node in @nodes2
4699  *         in document order, @nodes1 if @nodes2 is NULL or empty or
4720  * Returns the nodes in @nodes1 that follow the first node in @nodes2
4721  *         in document order, @nodes1 if @nodes2 is NULL or empty or
4750  * Returns 0 in case of success, -1 in case of error
4767  * Returns 0 in case of success, -1 in case of error
4809  * Search in the Function array of the context for the given
4837  * Search in the Function array of the context for the given
4898  * Returns 0 in case of success, -1 in case of error
4916  * Returns 0 in case of success, -1 in case of error
4961  * Search in the Variable array of the context for the given
4987  * Search in the Variable array of the context for the given
5039  * Returns 0 in case of success, -1 in case of error
5065  * Search in the namespace declaration array of the context for the given
5425  * XPath object or stores it in the cache.
5662  * Returns the allocated string value of the object, NULL in case of error.
6372  * then the comparison will be true if and only if there is a node in the
6428  * then the comparison will be true if and only if there is a node in
6477  * will be true if and only if there is a node in the first node-set
6478  * and a node in the second node-set such that the result of performing
6624  * then the comparison will be true if and only if there is a node in
6682  * then the comparison will be true if and only if there is a node in
6742  * will be true if and only if there is a node in the first node-set and
6743  * a node in the second node-set such that the result of performing the
7535  * Used for merging node sets in xmlXPathCollectAndTest().
7544  * @cur:  the current node in the traversal
7562  * @cur:  the current node in the traversal
7565  * The child axis contains the children of the context node in document order.
7613  * @cur:  the current node in the traversal
7616  * The child axis contains the children of the context node in document order.
7688  * @cur:  the current node in the traversal
7764  * @cur:  the current node in the traversal
7767  * the descendant axis contains the descendants of the context node in document
7825  * @cur:  the current node in the traversal
7829  * of the context node in document order; thus the context node is the first
7853  * @cur:  the current node in the traversal
7922  * @cur:  the current node in the traversal
7927  * parent and so on; the nodes are ordered in reverse document order; thus the
8047  * @cur:  the current node in the traversal
8051  * the context node in reverse document order; thus the context node is
8068  * @cur:  the current node in the traversal
8072  * node in document order.
8092  * @cur:  the current node in the traversal
8096  * node in reverse document order; the first preceding sibling is first on the
8122  * @cur:  the current node in the traversal
8125  * The following axis contains all nodes in the same document as the context
8126  * node that are after the context node in document order, excluding any
8128  * are ordered in document order
8169     /* nodes need to be in the same document */
8185  * @cur:  the current node in the traversal
8188  * the preceding axis contains all nodes in the same document as the context
8189  * node that are before the context node in document order, excluding any
8191  * ordered in reverse document order
8228  * @cur:  the current node in the traversal
8231  * the preceding axis contains all nodes in the same document as the context
8232  * node that are before the context node in document order, excluding any
8234  * ordered in reverse document order
8236  * state kept in the parser context: ctxt->ancestor.
8274  * @cur:  the current attribute in the traversal
8315  * @cur:  the current attribute in the traversal
8382  * The last function returns the number of nodes in the context node list.
8407  * The position function returns the position of the context node in the
8538  * string value of each of the nodes in the argument node-set. When the
8543  * containing the elements in the same document as the context node that
8544  * have a unique ID equal to any of the tokens in the list.
8591  * of the name of the node in the argument node-set that is first in
8618 	int i = 0; /* Should be first in document order !!!!! */
8649  * namespace URI of the expanded name of the node in the argument
8650  * node-set that is first in document order. If the node-set is empty,
8676 	int i = 0; /* Should be first in document order !!!!! */
8701  * the name of the node in the argument node-set that is first in document
8703  * declarations in effect on the node whose name is being represented.
8704  * Typically, this will be the form in which the name occurred in the XML
8706  * in effect on the node that associate multiple prefixes with the same
8708  * the original prefix in its representation of nodes; in this case, an
8710  * as the QName used in the XML source. If the argument it omitted it
8736         int i = 0;              /* Should be first in document order !!!!! */
8783  *      the node in the node-set that is first in document order.
8791  *      + if the number is an integer, the number is represented in
8794  *      + otherwise, the number is represented in decimal form as a
8835  * The string-length returns the number of characters in the string
8837  * the context node converted to a string, in other words the value
8990  * starting at the position specified in the second argument with
8991  * length specified in the third argument. For example,
8994  * in the second argument and continuing to the end of the string. For
8996  * character in the string (see [3.6 Strings]) is considered to have a
9013     double le=0, in;
9037     in = start->floatval;
9049 	if (in < 1.0) 
9050 	    in = 1.0;
9057     if (!xmlXPathIsNaN(in + le) && !xmlXPathIsInf(in)) {
9066         i = (int) in;
9067         if (((double)i)+0.5 <= in) i++;
9115  * argument string in the first argument string, or the empty string
9157  * argument string in the first argument string, or the empty stringi
9203  * in XML. If the argument is omitted, it defaults to the context
9204  * node converted to a string, in other words the value of the context node.
9264  * occurrences of characters in the second argument string replaced
9265  * by the character at the corresponding position in the third argument
9267  * BAr. If there is a character in the second argument string with no
9268  * character at a corresponding position in the third argument string
9270  * string), then occurrences of that character in the first argument
9272  * returns "AAA". If a character occurs more than once in second
9311 	    /* Step to next character in input */
9501  * The sum function returns the sum of the values of the nodes in
9666  * bytes in the input buffer.
9735      * input encoding didn't get properly advertised in the
9760     const xmlChar *in;
9768     in = ctxt->cur;
9769     if (((*in >= 0x61) && (*in <= 0x7A)) ||
9770 	((*in >= 0x41) && (*in <= 0x5A)) ||
9771 	(*in == '_')) {
9772 	in++;
9773 	while (((*in >= 0x61) && (*in <= 0x7A)) ||
9774 	       ((*in >= 0x41) && (*in <= 0x5A)) ||
9775 	       ((*in >= 0x30) && (*in <= 0x39)) ||
9776 	       (*in == '_') || (*in == '.') ||
9777 	       (*in == '-'))
9778 	    in++;
9779 	if ((*in == ' ') || (*in == '>') || (*in == '/') ||
9780             (*in == '[') || (*in == ']') || (*in == ':') ||
9781             (*in == '@') || (*in == '*')) {
9782 	    count = in - ctxt->cur;
9786 	    ctxt->cur = in;
9841     const xmlChar *in;
9849     in = ctxt->cur;
9850     if (((*in >= 0x61) && (*in <= 0x7A)) ||
9851 	((*in >= 0x41) && (*in <= 0x5A)) ||
9852 	(*in == '_') || (*in == ':')) {
9853 	in++;
9854 	while (((*in >= 0x61) && (*in <= 0x7A)) ||
9855 	       ((*in >= 0x41) && (*in <= 0x5A)) ||
9856 	       ((*in >= 0x30) && (*in <= 0x39)) ||
9857 	       (*in == '_') || (*in == '-') ||
9858 	       (*in == ':') || (*in == '.'))
9859 	    in++;
9860 	if ((*in > 0) && (*in < 0x80)) {
9861 	    count = in - ctxt->cur;
9863 	    ctxt->cur = in;
9962  * Compile a Number in the string
10143  * Returns the value found or NULL in case of error
10406  * Square brackets are used to filter expressions in the same way that
10407  * they are used in location paths. It is an error if the expression to
10409  * used for evaluating the expression in square brackets is the node-set
10410  * to be filtered listed in document order.
10432  * Needed to avoid insanity in the parser state.
10488  * The / operator does composition in the same way as when / is
10489  * used in a location path. As in location paths, // is short for
10520 	 *   - a function call in which case it's followed by '('
10521 	 *   - an axis in which case it's followed by ':'
10941     *  a filter can only diminish the number of items in a sequence,
11188  * Compile one step in a Location Path
11190  * particularly useful in conjunction with //. For example, the
11398  * so will select any para element in the document (even a para element
11566 	*  "For each node in the node-set to be filtered, the
11568 	*  context node, with the number of nodes in the
11570 	*  position of the node in the node-set with respect to
11604 	    * Also set the xpath document in case things like
11605 	    * key() are evaluated in the predicate.
11644 		* context node, in order to avoid massive recreation
11651 		* TODO: The object was lost in the evaluation machinery.
11652 		*  Can this happen? Maybe in internal-error cases.
11752 	    * Also set the xpath document in case things like
11794 		* Fits in the requested range.
11835 		* context node, in order to avoid massive recreation
11842 		* The object was lost in the evaluation machinery.
11843 		* Can this happen? Maybe in case of internal-errors.
11911 	* able to detect a position() predicate in compound
11913 	* and even not the usage of position() in
12020     *   not in the ancestor-or-self axis of the other, then we could safely
12559     * Hand over the result. Better to push the set also in
12588  * element in document order
12615                  * limit tree traversing to first node in the result
12712  * element in document order
12746                  * limit tree traversing to first node in the result
12874 	    * The nodeset should be in document order,
12915 	* expression for all the element in the locset. use it to grow
12941 	    * single item in the nodelocset.
12988 	    * Only put the first node in the result, then leave.
13013     * expression for all the element in the set. use it to grow
13045 	* Also set the xpath document in case things like
13053 	    * a single item in the nodeset.
13094 		* in order to avoid massive recreation inside this
13102 	    * Only put the first node in the result, then leave.
13489 		    *  will result in an ordered list if we have an
13515                          * The nodeset should be in document order,
13549                          * The nodeset should be in document order,
13600                      * expression for all the element in the locset. use it to grow
13628                          * single item in the nodelocset.
13686                  * expression for all the element in the set. use it to grow
13717 		     * Also set the xpath document in case things like
13723 		    *  "For each node in the node-set to be filtered, the
13725 		    *  context node, with the number of nodes in the
13727 		    *  position of the node in the node-set with respect to
13744 		    * removed the first node in the node-set, then
13750                          * a single item in the nodeset.
13805 			    * in order to avoid massive recreation inside this
13860                      * expression for all the element in the locset. use it to grow
13885                          * single item in the nodelocset.
13950                              * in the nodeset.
14105  * Evaluate the Precompiled Streamable XPath expression in the given context.
14334  * Evaluate the Precompiled XPath expression in the given context.
14421  * context node in the context node list (as returned by the position
14459  * context node in the context node list (as returned by the position
14532 	 *  there's a ":" in the expression, indicating a prefixed QName,
14534 	 *  to have a list of namespaces at compilation time in order to
14672 	 * aleksey: in some cases this line prints *second* error message
14675 	 * out in other places. It's not critical so we leave it as-is for now
14723  * Evaluate the Precompiled XPath expression in the given context.
14814  * Evaluate the Precompiled XPath expression in the given context.
14837  *         -1 in API and internal errors.
14850  * Parse and evaluate an XPath expression in the given context,
14874 	* In this scenario the expression string will sit in ctxt->base.
14896  * Evaluate the XPath Location Path in the given context.
14958  * Evaluate the XPath expression in the given context.
15013  * This function applies the URI escaping rules defined in section 2 of [RFC
15016  * character in the string by an escape sequence of the form %xx%yy...,
15018  * represent the character in UTF-8.
15025  * referred to in [RFC 2396] as "marks": specifically, "-" | "_" | "." | "!"
15030  * If $escape-reserved is false, the behavior differs in that characters
15031  * referred to in [RFC 2396] as reserved characters are not escaped. These
15118  * Registers all default XPath functions in this context

Indexes created Tue Jul 24 14:28:13 CEST 2018