docbook/libxml2/xpath.c

74 *   Disabling this #define will result in an incorrect evaluation to
84 * xmlXPathOrderDocElems() was called in order to index the elements of
85 * a tree in document order; Libxslt does such an indexing, thus it will
93 * in a way, that it stop evaluation at the first node.
275     "?? Unknown error ??\n"	/* Must be last in the list! */
431 * TODO: Since such a list-handling is used in xmlschemas.c and libxslt
471  * Returns a xsltPointerList structure or NULL in case of an error.
594     int nbStep;			/* Number of steps in this expression */
597     int last;			/* index of last step in expression */
620  * Returns the newly allocated xmlXPathCompExprPtr or NULL in case of error
719  * Returns -1 in case of failure, the index otherwise
773  * Swaps 2 operations in the compiled expression
782      * disabled if one detects that the library is used in a multithreaded
1060 	    fprintf(output, "Object is a point : index %d in node", cur->index);
1070 		    fprintf(output, "index %d in ", cur->index);
1079 		    fprintf(output, "index %d in ", cur->index);
1086 		    fprintf(output, "index %d in ", cur->index2);
1824 	* look out for namespace nodes in the node-set.
1918  * Wrap the Nodeset @val in a new xmlXPathObjectPtr
2612  *           in ISO-Latin or UTF-8.
2623  *           in UTF-8 mode. It also pop-up unfinished entities on the fly.
2720 	     * In either case, result is in work, and after_fraction points
2782  * Like for line information, the order is kept in the element->content
2786  * Returns the number of elements found in the document or -1 in case
2833  * Returns -2 in case of error 1 if first point < second point, 0 if
2846      * a couple of optimizations which will avoid computations in most cases
2860 	    /* not required, but we keep attributes in order */
2936 	/* should not happen but just in case ... */
2980  * Returns -2 in case of error 1 if first point < second point, 0 if
2998      * a couple of optimizations which will avoid computations in most cases
3035 			precedence1 = 3; /* element in prev-sibl axis */
3088 			precedence2 = 3; /* element in prev-sibl axis */
3227 	/* should not happen but just in case ... */
3266  * Sort the node set in document order
3307  * Namespace node in libxml don't match the XPath semantic. In a node set
3309  * parent node in the XPath semantic.
3342  * @ns:  the XPath namespace node found in a nodeset.
3344  * Namespace nodes in libxml don't match the XPath semantic. In a node set
3346  * parent node in the XPath semantic. Check if such a node needs to be freed
3562  * when we are sure the node is not already in the set.
3616  * Returns @val1 once extended or NULL in case of error.
3628 	* TODO: The optimization won't work in every case, since
3633 	*  some temporary nodes are in, that would be helpfull.
3728  * Returns @val1 once extended or NULL in case of error.
3794      * find node in nodeTab
3802 	        "xmlXPathNodeSetDel: Node %s wasn't found in NodeList\n",
4045  * Wrap the Nodeset @val in a new xmlXPathObjectPtr
4071  * Free up the xmlXPathObjectPtr @obj but don't deallocate the objects in
4156  * Returns a subset of the nodes contained in @nodes, or @nodes if
4196  * Returns a subset of the nodes contained in @nodes, or @nodes if
4245  * Returns the nodes in @nodes that precede @node in document order,
4283  * Returns the nodes in @nodes that precede @node in document order,
4301  * Returns the nodes in @nodes1 that precede the first node in @nodes2
4302  *         in document order, @nodes1 if @nodes2 is NULL or empty or
4323  * Returns the nodes in @nodes1 that precede the first node in @nodes2
4324  *         in document order, @nodes1 if @nodes2 is NULL or empty or
4347  * Returns the nodes in @nodes that follow @node in document order,
4385  * Returns the nodes in @nodes that follow @node in document order,
4403  * Returns the nodes in @nodes1 that follow the first node in @nodes2
4404  *         in document order, @nodes1 if @nodes2 is NULL or empty or
4425  * Returns the nodes in @nodes1 that follow the first node in @nodes2
4426  *         in document order, @nodes1 if @nodes2 is NULL or empty or
4455  * Returns 0 in case of success, -1 in case of error
4472  * Returns 0 in case of success, -1 in case of error
4514  * Search in the Function array of the context for the given
4542  * Search in the Function array of the context for the given
4603  * Returns 0 in case of success, -1 in case of error
4621  * Returns 0 in case of success, -1 in case of error
4666  * Search in the Variable array of the context for the given
4692  * Search in the Variable array of the context for the given
4744  * Returns 0 in case of success, -1 in case of error
4770  * Search in the namespace declaration array of the context for the given
5130  * XPath object or stores it in the cache.
5364  * Returns the string value of the object, NULL in case of error.
6063  * then the comparison will be true if and only if there is a node in the
6119  * then the comparison will be true if and only if there is a node in
6168  * will be true if and only if there is a node in the first node-set
6169  * and a node in the second node-set such that the result of performing
6315  * then the comparison will be true if and only if there is a node in
6373  * then the comparison will be true if and only if there is a node in
6433  * will be true if and only if there is a node in the first node-set and
6434  * a node in the second node-set such that the result of performing the
7228  * @cur:  the current node in the traversal
7246  * @cur:  the current node in the traversal
7249  * The child axis contains the children of the context node in document order.
7297  * @cur:  the current node in the traversal
7300  * The child axis contains the children of the context node in document order.
7372  * @cur:  the current node in the traversal
7448  * @cur:  the current node in the traversal
7451  * the descendant axis contains the descendants of the context node in document
7509  * @cur:  the current node in the traversal
7513  * of the context node in document order; thus the context node is the first
7537  * @cur:  the current node in the traversal
7606  * @cur:  the current node in the traversal
7611  * parent and so on; the nodes are ordered in reverse document order; thus the
7731  * @cur:  the current node in the traversal
7735  * the context node in reverse document order; thus the context node is
7752  * @cur:  the current node in the traversal
7756  * node in document order.
7776  * @cur:  the current node in the traversal
7780  * node in reverse document order; the first preceding sibling is first on the
7806  * @cur:  the current node in the traversal
7809  * The following axis contains all nodes in the same document as the context
7810  * node that are after the context node in document order, excluding any
7812  * are ordered in document order
7845     /* nodes need to be in the same document */
7861  * @cur:  the current node in the traversal
7864  * the preceding axis contains all nodes in the same document as the context
7865  * node that are before the context node in document order, excluding any
7867  * ordered in reverse document order
7899  * @cur:  the current node in the traversal
7902  * the preceding axis contains all nodes in the same document as the context
7903  * node that are before the context node in document order, excluding any
7905  * ordered in reverse document order
7907  * state kept in the parser context: ctxt->ancestor.
7945  * @cur:  the current attribute in the traversal
7986  * @cur:  the current attribute in the traversal
8053  * The last function returns the number of nodes in the context node list.
8078  * The position function returns the position of the context node in the
8209  * string value of each of the nodes in the argument node-set. When the
8214  * containing the elements in the same document as the context node that
8215  * have a unique ID equal to any of the tokens in the list.
8262  * of the name of the node in the argument node-set that is first in
8289 	int i = 0; /* Should be first in document order !!!!! */
8320  * namespace URI of the expanded name of the node in the argument
8321  * node-set that is first in document order. If the node-set is empty,
8347 	int i = 0; /* Should be first in document order !!!!! */
8372  * the name of the node in the argument node-set that is first in document
8374  * declarations in effect on the node whose name is being represented.
8375  * Typically, this will be the form in which the name occurred in the XML
8377  * in effect on the node that associate multiple prefixes with the same
8379  * the original prefix in its representation of nodes; in this case, an
8381  * as the QName used in the XML source. If the argument it omitted it
8407         int i = 0;              /* Should be first in document order !!!!! */
8454  *      the node in the node-set that is first in document order.
8462  *      + if the number is an integer, the number is represented in
8465  *      + otherwise, the number is represented in decimal form as a
8506  * The string-length returns the number of characters in the string
8508  * the context node converted to a string, in other words the value
8661  * starting at the position specified in the second argument with
8662  * length specified in the third argument. For example,
8665  * in the second argument and continuing to the end of the string. For
8667  * character in the string (see [3.6 Strings]) is considered to have a
8684     double le=0, in;
8708     in = start->floatval;
8720 	if (in < 1.0)
8721 	    in = 1.0;
8728     if (!xmlXPathIsNaN(in + le) && !xmlXPathIsInf(in)) {
8737         i = (int) in;
8738         if (((double)i)+0.5 <= in) i++;
8786  * argument string in the first argument string, or the empty string
8828  * argument string in the first argument string, or the empty stringi
8874  * in XML. If the argument is omitted, it defaults to the context
8875  * node converted to a string, in other words the value of the context node.
8935  * occurrences of characters in the second argument string replaced
8936  * by the character at the corresponding position in the third argument
8938  * BAr. If there is a character in the second argument string with no
8939  * character at a corresponding position in the third argument string
8941  * string), then occurrences of that character in the first argument
8943  * returns "AAA". If a character occurs more than once in second
8982 	    /* Step to next character in input */
9170  * The sum function returns the sum of the values of the nodes in
9335  * bytes in the input buffer.
9404      * input encoding didn't get properly advertised in the
9429     const xmlChar *in;
9437     in = ctxt->cur;
9438     if (((*in >= 0x61) && (*in <= 0x7A)) ||
9439 	((*in >= 0x41) && (*in <= 0x5A)) ||
9440 	(*in == '_')) {
9441 	in++;
9442 	while (((*in >= 0x61) && (*in <= 0x7A)) ||
9443 	       ((*in >= 0x41) && (*in <= 0x5A)) ||
9444 	       ((*in >= 0x30) && (*in <= 0x39)) ||
9445 	       (*in == '_') || (*in == '.') ||
9446 	       (*in == '-'))
9447 	    in++;
9448 	if ((*in == ' ') || (*in == '>') || (*in == '/') ||
9449             (*in == '[') || (*in == ']') || (*in == ':') ||
9450             (*in == '@') || (*in == '*')) {
9451 	    count = in - ctxt->cur;
9455 	    ctxt->cur = in;
9510     const xmlChar *in;
9518     in = ctxt->cur;
9519     if (((*in >= 0x61) && (*in <= 0x7A)) ||
9520 	((*in >= 0x41) && (*in <= 0x5A)) ||
9521 	(*in == '_') || (*in == ':')) {
9522 	in++;
9523 	while (((*in >= 0x61) && (*in <= 0x7A)) ||
9524 	       ((*in >= 0x41) && (*in <= 0x5A)) ||
9525 	       ((*in >= 0x30) && (*in <= 0x39)) ||
9526 	       (*in == '_') || (*in == '-') ||
9527 	       (*in == ':') || (*in == '.'))
9528 	    in++;
9529 	if ((*in > 0) && (*in < 0x80)) {
9530 	    count = in - ctxt->cur;
9532 	    ctxt->cur = in;
9631  * Compile a Number in the string
9812  * Returns the value found or NULL in case of error
10075  * Square brackets are used to filter expressions in the same way that
10076  * they are used in location paths. It is an error if the expression to
10078  * used for evaluating the expression in square brackets is the node-set
10079  * to be filtered listed in document order.
10101  * Needed to avoid insanity in the parser state.
10157  * The / operator does composition in the same way as when / is
10158  * used in a location path. As in location paths, // is short for
10189 	 *   - a function call in which case it's followed by '('
10190 	 *   - an axis in which case it's followed by ':'
10845  * Compile one step in a Location Path
10847  * particularly useful in conjunction with //. For example, the
11055  * so will select any para element in the document (even a para element
11099  * @first:  pointer to the first element in document order
11100  * @last:  pointer to the last element in document order
11649  * @first:  pointer to the first element in document order
11650  * @last:  pointer to the last element in document order
12118  * element in document order
12145                  * limit tree traversing to first node in the result
12264  * element in document order
12298                  * limit tree traversing to first node in the result
12450 	    * The nodeset should be in document order,
12491 	* expression for all the element in the locset. use it to grow
12517 	    * single item in the nodelocset.
12564 	    * Only put the first node in the result, then leave.
12589     * expression for all the element in the set. use it to grow
12621 	* Also set the xpath document in case things like
12629 	    * a single item in the nodeset.
12670 		* in order to avoid massive recreation inside this
12678 	    * Only put the first node in the result, then leave.
13081 		    *  will result in an ordered list if we have an
13107                          * The nodeset should be in document order,
13141                          * The nodeset should be in document order,
13192                      * expression for all the element in the locset. use it to grow
13220                          * single item in the nodelocset.
13278                  * expression for all the element in the set. use it to grow
13309 		     * Also set the xpath document in case things like
13315 		    *  "For each node in the node-set to be filtered, the
13317 		    *  context node, with the number of nodes in the
13319 		    *  position of the node in the node-set with respect to
13336 		    * removed the first node in the node-set, then
13342                          * a single item in the nodeset.
13397 			    * in order to avoid massive recreation inside this
13452                      * expression for all the element in the locset. use it to grow
13477                          * single item in the nodelocset.
13542                              * in the nodeset.
13607  * Evaluate the Precompiled Streamable XPath expression in the given context.
13818  * Evaluate the Precompiled XPath expression in the given context.
13873  * context node in the context node list (as returned by the position
13911  * context node in the context node list (as returned by the position
13985 	 *  there's a ":" in the expression, indicating a prefixed QName,
13987 	 *  to have a list of namespaces at compilation time in order to
14123 	 * aleksey: in some cases this line prints *second* error message
14126 	 * out in other places. It's not critical so we leave it as-is for now
14169  * Evaluate the Precompiled XPath expression in the given context.
14243  * Parse and evaluate an XPath expression in the given context,
14283  * Evaluate the XPath Location Path in the given context.
14343  * Evaluate the XPath expression in the given context.
14396  * This function applies the URI escaping rules defined in section 2 of [RFC
14399  * character in the string by an escape sequence of the form %xx%yy...,
14401  * represent the character in UTF-8.
14408  * referred to in [RFC 2396] as "marks": specifically, "-" | "_" | "." | "!"
14413  * If $escape-reserved is false, the behavior differs in that characters
14414  * referred to in [RFC 2396] as reserved characters are not escaped. These
14501  * Registers all default XPath functions in this context