Lines Matching defs:in
72 * Use the Timsort algorithm provided in timsort.h to sort
74 * used in xmlXPathNodeSetSort()
83 * xmlXPathOrderDocElems() was called in order to index the elements of
84 * a tree in document order; Libxslt does such an indexing, thus it will
92 * in a way, that it stop evaluation at the first node.
106 * number of step operation in the compiled expression. 1000000 is
126 * circumstances, one would first need to construct an in memory tree
151 * Returns -2 in case of error -1 if first point < second point, 0 if
332 "?? Unknown error ??\n" /* Must be last in the list! */
488 * TODO: Since such a list-handling is used in xmlschemas.c and libxslt
532 * Returns a xsltPointerList structure or NULL in case of an error.
652 int nbStep; /* Number of steps in this expression */
655 int last; /* index of last step in expression */
695 * Returns the newly allocated xmlXPathCompExprPtr or NULL in case of error
794 * Returns -1 in case of failure, the index otherwise
852 * Swaps 2 operations in the compiled expression
861 * disabled if one detects that the library is used in a multithreaded
1139 fprintf(output, "Object is a point : index %d in node", cur->index);
1149 fprintf(output, "index %d in ", cur->index);
1158 fprintf(output, "index %d in ", cur->index);
1165 fprintf(output, "index %d in ", cur->index2);
1903 * look out for namespace nodes in the node-set.
1997 * Wrap the Nodeset @val in a new xmlXPathObjectPtr
2742 * in ISO-Latin or UTF-8.
2753 * in UTF-8 mode. It also pop-up unfinished entities on the fly.
2844 LOWER_DOUBLE_EXP is max number of leading zeroes in fraction
2859 * In either case, result is in work, and after_fraction points
2922 * Like for line information, the order is kept in the element->content
2926 * Returns the number of elements found in the document or -1 in case
2973 * Returns -2 in case of error 1 if first point < second point, 0 if
2986 * a couple of optimizations which will avoid computations in most cases
3002 /* not required, but we keep attributes in order */
3078 /* should not happen but just in case ... */
3122 * Returns -2 in case of error 1 if first point < second point, 0 if
3140 * a couple of optimizations which will avoid computations in most cases
3177 precedence1 = 3; /* element in prev-sibl axis */
3231 precedence2 = 3; /* element in prev-sibl axis */
3370 /* should not happen but just in case ... */
3409 * Sort the node set in document order
3459 * Namespace node in libxml don't match the XPath semantic. In a node set
3461 * parent node in the XPath semantic.
3494 * @ns: the XPath namespace node found in a nodeset.
3496 * Namespace nodes in libxml don't match the XPath semantic. In a node set
3498 * parent node in the XPath semantic. Check if such a node needs to be freed
3630 * Returns 0 in case of success and -1 in case of error
3694 * Returns 0 in case of success, and -1 in case of error
3754 * when we are sure the node is not already in the set.
3756 * Returns 0 in case of success and -1 in case of failure
3810 * Returns @val1 once extended or NULL in case of error.
3824 * TODO: The optimization won't work in every case, since
3829 * some temporary nodes are in, that would be helpfull.
3931 * Returns @set1 once extended or NULL in case of error.
4044 * Returns @set1 once extended or NULL in case of error.
4129 * find node in nodeTab
4137 "xmlXPathNodeSetDel: Node %s wasn't found in NodeList\n",
4411 * Wrap the Nodeset @val in a new xmlXPathObjectPtr
4437 * Free up the xmlXPathObjectPtr @obj but don't deallocate the objects in
4528 * Returns a subset of the nodes contained in @nodes, or @nodes if
4571 * Returns a subset of the nodes contained in @nodes, or @nodes if
4620 * Returns the nodes in @nodes that precede @node in document order,
4661 * Returns the nodes in @nodes that precede @node in document order,
4679 * Returns the nodes in @nodes1 that precede the first node in @nodes2
4680 * in document order, @nodes1 if @nodes2 is NULL or empty or
4701 * Returns the nodes in @nodes1 that precede the first node in @nodes2
4702 * in document order, @nodes1 if @nodes2 is NULL or empty or
4725 * Returns the nodes in @nodes that follow @node in document order,
4767 * Returns the nodes in @nodes that follow @node in document order,
4785 * Returns the nodes in @nodes1 that follow the first node in @nodes2
4786 * in document order, @nodes1 if @nodes2 is NULL or empty or
4807 * Returns the nodes in @nodes1 that follow the first node in @nodes2
4808 * in document order, @nodes1 if @nodes2 is NULL or empty or
4837 * Returns 0 in case of success, -1 in case of error
4854 * Returns 0 in case of success, -1 in case of error
4896 * Search in the Function array of the context for the given
4924 * Search in the Function array of the context for the given
4985 * Returns 0 in case of success, -1 in case of error
5003 * Returns 0 in case of success, -1 in case of error
5048 * Search in the Variable array of the context for the given
5074 * Search in the Variable array of the context for the given
5126 * Returns 0 in case of success, -1 in case of error
5154 * Search in the namespace declaration array of the context for the given
5514 * XPath object or stores it in the cache.
5751 * Returns the allocated string value of the object, NULL in case of error.
6461 * then the comparison will be true if and only if there is a node in the
6517 * then the comparison will be true if and only if there is a node in
6566 * will be true if and only if there is a node in the first node-set
6567 * and a node in the second node-set such that the result of performing
6713 * then the comparison will be true if and only if there is a node in
6771 * then the comparison will be true if and only if there is a node in
6831 * will be true if and only if there is a node in the first node-set and
6832 * a node in the second node-set such that the result of performing the
7624 * Used for merging node sets in xmlXPathCollectAndTest().
7633 * @cur: the current node in the traversal
7651 * @cur: the current node in the traversal
7654 * The child axis contains the children of the context node in document order.
7702 * @cur: the current node in the traversal
7705 * The child axis contains the children of the context node in document order.
7778 * @cur: the current node in the traversal
7855 * @cur: the current node in the traversal
7858 * the descendant axis contains the descendants of the context node in document
7918 * @cur: the current node in the traversal
7922 * of the context node in document order; thus the context node is the first
7946 * @cur: the current node in the traversal
8015 * @cur: the current node in the traversal
8020 * parent and so on; the nodes are ordered in reverse document order; thus the
8140 * @cur: the current node in the traversal
8144 * the context node in reverse document order; thus the context node is
8161 * @cur: the current node in the traversal
8165 * node in document order.
8185 * @cur: the current node in the traversal
8189 * node in reverse document order; the first preceding sibling is first on the
8215 * @cur: the current node in the traversal
8218 * The following axis contains all nodes in the same document as the context
8219 * node that are after the context node in document order, excluding any
8221 * are ordered in document order
8266 /* nodes need to be in the same document */
8282 * @cur: the current node in the traversal
8285 * the preceding axis contains all nodes in the same document as the context
8286 * node that are before the context node in document order, excluding any
8288 * ordered in reverse document order
8325 * @cur: the current node in the traversal
8328 * the preceding axis contains all nodes in the same document as the context
8329 * node that are before the context node in document order, excluding any
8331 * ordered in reverse document order
8333 * state kept in the parser context: ctxt->ancestor.
8373 * @cur: the current attribute in the traversal
8414 * @cur: the current attribute in the traversal
8481 * The last function returns the number of nodes in the context node list.
8506 * The position function returns the position of the context node in the
8639 * string value of each of the nodes in the argument node-set. When the
8644 * containing the elements in the same document as the context node that
8645 * have a unique ID equal to any of the tokens in the list.
8662 * FIXME -- in an out-of-memory condition this will behave badly.
8664 * ctxt, so the object is in a corrupt state.
8697 * of the name of the node in the argument node-set that is first in
8724 int i = 0; /* Should be first in document order !!!!! */
8755 * namespace URI of the expanded name of the node in the argument
8756 * node-set that is first in document order. If the node-set is empty,
8782 int i = 0; /* Should be first in document order !!!!! */
8807 * the name of the node in the argument node-set that is first in document
8809 * declarations in effect on the node whose name is being represented.
8810 * Typically, this will be the form in which the name occurred in the XML
8812 * in effect on the node that associate multiple prefixes with the same
8814 * the original prefix in its representation of nodes; in this case, an
8816 * as the QName used in the XML source. If the argument it omitted it
8842 int i = 0; /* Should be first in document order !!!!! */
8889 * the node in the node-set that is first in document order.
8897 * + if the number is an integer, the number is represented in
8900 * + otherwise, the number is represented in decimal form as a
8941 * The string-length returns the number of characters in the string
8943 * the context node converted to a string, in other words the value
9096 * starting at the position specified in the second argument with
9097 * length specified in the third argument. For example,
9100 * in the second argument and continuing to the end of the string. For
9102 * character in the string (see [3.6 Strings]) is considered to have a
9119 double le=0, in;
9143 in = start->floatval;
9155 if (in < 1.0)
9156 in = 1.0;
9163 if (!xmlXPathIsInf(in) && !xmlXPathIsNaN(in + le)) {
9172 i = (int) in;
9173 if (((double)i)+0.5 <= in) i++;
9221 * argument string in the first argument string, or the empty string
9263 * argument string in the first argument string, or the empty stringi
9309 * in XML. If the argument is omitted, it defaults to the context
9310 * node converted to a string, in other words the value of the context node.
9370 * occurrences of characters in the second argument string replaced
9371 * by the character at the corresponding position in the third argument
9373 * BAr. If there is a character in the second argument string with no
9374 * character at a corresponding position in the third argument string
9376 * string), then occurrences of that character in the first argument
9378 * returns "AAA". If a character occurs more than once in second
9417 /* Step to next character in input */
9607 * The sum function returns the sum of the values of the nodes in
9772 * bytes in the input buffer.
9841 * input encoding didn't get properly advertised in the
9866 const xmlChar *in;
9874 in = ctxt->cur;
9875 if (((*in >= 0x61) && (*in <= 0x7A)) ||
9876 ((*in >= 0x41) && (*in <= 0x5A)) ||
9877 (*in == '_')) {
9878 in++;
9879 while (((*in >= 0x61) && (*in <= 0x7A)) ||
9880 ((*in >= 0x41) && (*in <= 0x5A)) ||
9881 ((*in >= 0x30) && (*in <= 0x39)) ||
9882 (*in == '_') || (*in == '.') ||
9883 (*in == '-'))
9884 in++;
9885 if ((*in == ' ') || (*in == '>') || (*in == '/') ||
9886 (*in == '[') || (*in == ']') || (*in == ':') ||
9887 (*in == '@') || (*in == '*')) {
9888 count = in - ctxt->cur;
9892 ctxt->cur = in;
9947 const xmlChar *in;
9955 in = ctxt->cur;
9956 if (((*in >= 0x61) && (*in <= 0x7A)) ||
9957 ((*in >= 0x41) && (*in <= 0x5A)) ||
9958 (*in == '_') || (*in == ':')) {
9959 in++;
9960 while (((*in >= 0x61) && (*in <= 0x7A)) ||
9961 ((*in >= 0x41) && (*in <= 0x5A)) ||
9962 ((*in >= 0x30) && (*in <= 0x39)) ||
9963 (*in == '_') || (*in == '-') ||
9964 (*in == ':') || (*in == '.'))
9965 in++;
9966 if ((*in > 0) && (*in < 0x80)) {
9967 count = in - ctxt->cur;
9969 ctxt->cur = in;
9973 ctxt->cur = in;
10078 * Compile a Number in the string
10079 * In complement of the Number expression, this function also handles
10266 * Returns the value found or NULL in case of error
10534 * Square brackets are used to filter expressions in the same way that
10535 * they are used in location paths. It is an error if the expression to
10537 * used for evaluating the expression in square brackets is the node-set
10538 * to be filtered listed in document order.
10560 * Needed to avoid insanity in the parser state.
10616 * The / operator does composition in the same way as when / is
10617 * used in a location path. As in location paths, // is short for
10648 * - a function call in which case it's followed by '('
10649 * - an axis in which case it's followed by ':'
11068 * a filter can only diminish the number of items in a sequence,
11315 * Compile one step in a Location Path
11317 * particularly useful in conjunction with //. For example, the
11529 * so will select any para element in the document (even a para element
11697 * "For each node in the node-set to be filtered, the
11699 * context node, with the number of nodes in the
11701 * position of the node in the node-set with respect to
11735 * Also set the xpath document in case things like
11736 * key() are evaluated in the predicate.
11779 * context node, in order to avoid massive recreation
11786 * TODO: The object was lost in the evaluation machinery.
11787 * Can this happen? Maybe in internal-error cases.
11887 * Also set the xpath document in case things like
11933 * Fits in the requested range.
11974 * context node, in order to avoid massive recreation
11981 * The object was lost in the evaluation machinery.
11982 * Can this happen? Maybe in case of internal-errors.
12050 * able to detect a position() predicate in compound
12052 * and even not the usage of position() in
12158 * not in the ancestor-or-self axis of the other, then we could safely
12674 * Hand over the result. Better to push the set also in
12703 * element in document order
12730 * limit tree traversing to first node in the result
12827 * element in document order
12861 * limit tree traversing to first node in the result
12989 * The nodeset should be in document order,
13030 * expression for all the element in the locset. use it to grow
13056 * single item in the nodelocset.
13105 * Only put the first node in the result, then leave.
13130 * expression for all the element in the set. use it to grow
13162 * Also set the xpath document in case things like
13171 * a single item in the nodeset.
13215 * in order to avoid massive recreation inside this
13223 * Only put the first node in the result, then leave.
13611 * will result in an ordered list if we have an
13637 * The nodeset should be in document order,
13671 * The nodeset should be in document order,
13722 * expression for all the element in the locset. use it to grow
13750 * single item in the nodelocset.
13808 * expression for all the element in the set. use it to grow
13839 * Also set the xpath document in case things like
13845 * "For each node in the node-set to be filtered, the
13847 * context node, with the number of nodes in the
13849 * position of the node in the node-set with respect to
13866 * removed the first node in the node-set, then
13872 * a single item in the nodeset.
13931 * in order to avoid massive recreation inside this
13986 * expression for all the element in the locset. use it to grow
14011 * single item in the nodelocset.
14076 * in the nodeset.
14231 * Evaluate the Precompiled Streamable XPath expression in the given context.
14465 * Evaluate the Precompiled XPath expression in the given context.
14552 * context node in the context node list (as returned by the position
14590 * context node in the context node list (as returned by the position
14663 * there's a ":" in the expression, indicating a prefixed QName,
14665 * to have a list of namespaces at compilation time in order to
14809 * aleksey: in some cases this line prints *second* error message
14812 * out in other places. It's not critical so we leave it as-is for now
14856 * Evaluate the Precompiled XPath expression in the given context.
14947 * Evaluate the Precompiled XPath expression in the given context.
14970 * -1 in API and internal errors.
14983 * Parse and evaluate an XPath expression in the given context,
15024 * Evaluate the XPath Location Path in the given context.
15086 * Sets 'node' as the context node. The node must be in the same
15089 * Returns -1 in case of error or 0 if successful
15109 * Evaluate the XPath Location Path in the given context. The node 'node'
15129 * Evaluate the XPath expression in the given context.
15184 * This function applies the URI escaping rules defined in section 2 of [RFC
15187 * character in the string by an escape sequence of the form %xx%yy...,
15189 * represent the character in UTF-8.
15196 * referred to in [RFC 2396] as "marks": specifically, "-" | "_" | "." | "!"
15201 * If $escape-reserved is false, the behavior differs in that characters
15202 * referred to in [RFC 2396] as reserved characters are not escaped. These
15214 * In the case of non-ascii characters, the string is encoded according to
15289 * Registers all default XPath functions in this context
