Lines Matching refs:cur
162 xmlNodePtr cur, root;
297 cur = miscNode2->prev;
298 while (cur != NULL) {
299 if (cur == miscNode1)
301 if (cur->type == XML_ELEMENT_NODE)
303 cur = cur->prev;
328 cur = node1->parent;
329 while (cur) {
330 if (cur == node2)
332 cur = cur->parent;
336 cur = node2->parent;
337 while (cur) {
338 if (cur == node1)
340 cur = cur->parent;
371 for (depth2 = 0, cur = node2; cur->parent != NULL; cur = cur->parent) {
372 if (cur->parent == node1)
376 root = cur;
377 for (depth1 = 0, cur = node1; cur->parent != NULL; cur = cur->parent) {
378 if (cur->parent == node2)
385 if (root != cur) {
430 for (cur = node1->next;cur != NULL;cur = cur->next)
431 if (cur == node2)
704 ctxt->cur - ctxt->base, 0,
717 ctxt->context->lastError.int1 = ctxt->cur - ctxt->base;
728 ctxt->cur - ctxt->base, 0,
981 xmlXPathCompExprPtr cur;
983 cur = (xmlXPathCompExprPtr) xmlMalloc(sizeof(xmlXPathCompExpr));
984 if (cur == NULL) {
988 memset(cur, 0, sizeof(xmlXPathCompExpr));
989 cur->maxStep = 10;
990 cur->nbStep = 0;
991 cur->steps = (xmlXPathStepOp *) xmlMalloc(cur->maxStep *
993 if (cur->steps == NULL) {
995 xmlFree(cur);
998 memset(cur->steps, 0, cur->maxStep * sizeof(xmlXPathStepOp));
999 cur->last = -1;
1001 cur->nb = 0;
1003 return(cur);
1237 xmlXPathDebugDumpNode(FILE *output, xmlNodePtr cur, int depth) {
1244 if (cur == NULL) {
1251 if ((cur->type == XML_DOCUMENT_NODE) ||
1252 (cur->type == XML_HTML_DOCUMENT_NODE)) {
1255 } else if (cur->type == XML_ATTRIBUTE_NODE)
1256 xmlDebugDumpAttr(output, (xmlAttrPtr)cur, depth);
1258 xmlDebugDumpOneNode(output, cur, depth);
1261 xmlXPathDebugDumpNodeList(FILE *output, xmlNodePtr cur, int depth) {
1269 if (cur == NULL) {
1276 while (cur != NULL) {
1277 tmp = cur;
1278 cur = cur->next;
1284 xmlXPathDebugDumpNodeSet(FILE *output, xmlNodeSetPtr cur, int depth) {
1292 if (cur == NULL) {
1299 if (cur != NULL) {
1300 cur->nodeNr);
1301 for (i = 0;i < cur->nodeNr;i++) {
1304 xmlXPathDebugDumpNode(output, cur->nodeTab[i], depth + 1);
1310 xmlXPathDebugDumpValueTree(FILE *output, xmlNodeSetPtr cur, int depth) {
1318 if ((cur == NULL) || (cur->nodeNr == 0) || (cur->nodeTab[0] == NULL)) {
1327 xmlXPathDebugDumpNodeList(output, cur->nodeTab[0]->children, depth + 1);
1331 xmlXPathDebugDumpLocationSet(FILE *output, xmlLocationSetPtr cur, int depth) {
1339 if (cur == NULL) {
1346 for (i = 0;i < cur->locNr;i++) {
1349 xmlXPathDebugDumpObject(output, cur->locTab[i], depth + 1);
1357 * @cur: the object to inspect
1363 xmlXPathDebugDumpObject(FILE *output, xmlXPathObjectPtr cur, int depth) {
1376 if (cur == NULL) {
1380 switch(cur->type) {
1386 xmlXPathDebugDumpNodeSet(output, cur->nodesetval, depth);
1390 xmlXPathDebugDumpValueTree(output, cur->nodesetval, depth);
1394 if (cur->boolval) fprintf(output, "true\n");
1398 switch (xmlXPathIsInf(cur->floatval)) {
1406 if (xmlXPathIsNaN(cur->floatval)) {
1408 } else if (cur->floatval == 0) {
1412 fprintf(output, "Object is a number : %0g\n", cur->floatval);
1418 xmlDebugDumpString(output, cur->stringval);
1422 fprintf(output, "Object is a point : index %d in node", cur->index);
1423 xmlXPathDebugDumpNode(output, (xmlNodePtr) cur->user, depth + 1);
1427 if ((cur->user2 == NULL) ||
1428 ((cur->user2 == cur->user) && (cur->index == cur->index2))) {
1431 if (cur->index >= 0)
1432 fprintf(output, "index %d in ", cur->index);
1434 xmlXPathDebugDumpNode(output, (xmlNodePtr) cur->user,
1440 if (cur->index >= 0)
1441 fprintf(output, "index %d in ", cur->index);
1443 xmlXPathDebugDumpNode(output, (xmlNodePtr) cur->user,
1447 if (cur->index2 >= 0)
1448 fprintf(output, "index %d in ", cur->index2);
1450 xmlXPathDebugDumpNode(output, (xmlNodePtr) cur->user2,
1459 (xmlLocationSetPtr) cur->user, depth);
3031 * CUR returns the current xmlChar value, i.e. a 8 bit value
3036 * NXT(n) returns the n'th next xmlChar. Same as CUR is should be used only
3047 #define CUR (*ctxt->cur)
3048 #define SKIP(val) ctxt->cur += (val)
3049 #define NXT(val) ctxt->cur[(val)]
3050 #define CUR_PTR ctxt->cur
3057 #define NEXTL(l) ctxt->cur += l
3060 while (IS_BLANK_CH(*(ctxt->cur))) NEXT
3062 #define CURRENT (*ctxt->cur)
3063 #define NEXT ((*ctxt->cur) ? ctxt->cur++: ctxt->cur)
3111 char *ptr, *cur;
3119 cur = &work[0];
3120 while ((*cur) && (ptr - buffer < buffersize)) {
3121 *ptr++ = *cur++;
3230 xmlNodePtr cur;
3234 cur = doc->children;
3235 while (cur != NULL) {
3236 if (cur->type == XML_ELEMENT_NODE) {
3237 cur->content = (void *) (-(++count));
3238 if (cur->children != NULL) {
3239 cur = cur->children;
3243 if (cur->next != NULL) {
3244 cur = cur->next;
3248 cur = cur->parent;
3249 if (cur == NULL)
3251 if (cur == (xmlNodePtr) doc) {
3252 cur = NULL;
3255 if (cur->next != NULL) {
3256 cur = cur->next;
3259 } while (cur != NULL);
3279 xmlNodePtr cur, root;
3302 cur = attrNode2->prev;
3303 while (cur != NULL) {
3304 if (cur == attrNode1)
3306 cur = cur->prev;
3345 for (depth2 = 0, cur = node2;cur->parent != NULL;cur = cur->parent) {
3346 if (cur->parent == node1)
3350 root = cur;
3351 for (depth1 = 0, cur = node1;cur->parent != NULL;cur = cur->parent) {
3352 if (cur->parent == node2)
3359 if (root != cur) {
3405 for (cur = node1->next;cur != NULL;cur = cur->next)
3406 if (cur == node2)
3473 xmlNsPtr cur;
3483 cur = (xmlNsPtr) xmlMalloc(sizeof(xmlNs));
3484 if (cur == NULL) {
3488 memset(cur, 0, sizeof(xmlNs));
3489 cur->type = XML_NAMESPACE_DECL;
3491 cur->href = xmlStrdup(ns->href);
3493 cur->prefix = xmlStrdup(ns->prefix);
3494 cur->next = (xmlNsPtr) node;
3495 return((xmlNodePtr) cur);
3593 * @cur: the node-set
3596 * checks whether @cur contains @val
3598 * Returns true (1) if @cur contains @val, false (0) otherwise
3601 xmlXPathNodeSetContains (xmlNodeSetPtr cur, xmlNodePtr val) {
3604 if ((cur == NULL) || (val == NULL)) return(0);
3606 for (i = 0; i < cur->nodeNr; i++) {
3607 if (cur->nodeTab[i]->type == XML_NAMESPACE_DECL) {
3611 ns2 = (xmlNsPtr) cur->nodeTab[i];
3620 for (i = 0; i < cur->nodeNr; i++) {
3621 if (cur->nodeTab[i] == val)
3630 * @cur: the initial node set
3639 xmlXPathNodeSetAddNs(xmlNodeSetPtr cur, xmlNodePtr node, xmlNsPtr ns) {
3643 if ((cur == NULL) || (ns == NULL) || (node == NULL) ||
3652 for (i = 0;i < cur->nodeNr;i++) {
3653 if ((cur->nodeTab[i] != NULL) &&
3654 (cur->nodeTab[i]->type == XML_NAMESPACE_DECL) &&
3655 (((xmlNsPtr)cur->nodeTab[i])->next == (xmlNsPtr) node) &&
3656 (xmlStrEqual(ns->prefix, ((xmlNsPtr)cur->nodeTab[i])->prefix)))
3663 if (cur->nodeMax == 0) {
3664 cur->nodeTab = (xmlNodePtr *) xmlMalloc(XML_NODESET_DEFAULT *
3666 if (cur->nodeTab == NULL) {
3670 memset(cur->nodeTab, 0 ,
3672 cur->nodeMax = XML_NODESET_DEFAULT;
3673 } else if (cur->nodeNr == cur->nodeMax) {
3676 if (cur->nodeMax >= XPATH_MAX_NODESET_LENGTH) {
3680 temp = (xmlNodePtr *) xmlRealloc(cur->nodeTab, cur->nodeMax * 2 *
3686 cur->nodeMax *= 2;
3687 cur->nodeTab = temp;
3689 cur->nodeTab[cur->nodeNr++] = xmlXPathNodeSetDupNs(node, ns);
3695 * @cur: the initial node set
3703 xmlXPathNodeSetAdd(xmlNodeSetPtr cur, xmlNodePtr val) {
3706 if ((cur == NULL) || (val == NULL)) return(-1);
3712 for (i = 0;i < cur->nodeNr;i++)
3713 if (cur->nodeTab[i] == val) return(0);
3718 if (cur->nodeMax == 0) {
3719 cur->nodeTab = (xmlNodePtr *) xmlMalloc(XML_NODESET_DEFAULT *
3721 if (cur->nodeTab == NULL) {
3725 memset(cur->nodeTab, 0 ,
3727 cur->nodeMax = XML_NODESET_DEFAULT;
3728 } else if (cur->nodeNr == cur->nodeMax) {
3731 if (cur->nodeMax >= XPATH_MAX_NODESET_LENGTH) {
3735 temp = (xmlNodePtr *) xmlRealloc(curcur->nodeMax * 2 *
3741 cur->nodeMax *= 2;
3742 cur->nodeTab = temp;
3747 cur->nodeTab[cur->nodeNr++] =
3750 cur->nodeTab[cur->nodeNr++] = val;
3756 * @cur: the initial node set
3765 xmlXPathNodeSetAddUnique(xmlNodeSetPtr cur, xmlNodePtr val) {
3766 if ((cur == NULL) || (val == NULL)) return(-1);
3772 if (cur->nodeMax == 0) {
3773 cur->nodeTab = (xmlNodePtr *) xmlMalloc(XML_NODESET_DEFAULT *
3775 if (cur->nodeTab == NULL) {
3779 memset(cur->nodeTab, 0 ,
3781 cur->nodeMax = XML_NODESET_DEFAULT;
3782 } else if (cur->nodeNr == cur->nodeMax) {
3785 if (cur->nodeMax >= XPATH_MAX_NODESET_LENGTH) {
3789 temp = (xmlNodePtr *) xmlRealloc(cur->nodeTab, cur->nodeMax * 2 *
3795 cur->nodeTab = temp;
3796 cur->nodeMax *= 2;
3801 cur->nodeTab[cur->nodeNr++] =
3804 cur->nodeTab[cur->nodeNr++] = val;
4116 * @cur: the initial node set
4122 xmlXPathNodeSetDel(xmlNodeSetPtr cur, xmlNodePtr val) {
4125 if (cur == NULL) return;
4131 for (i = 0;i < cur->nodeNr;i++)
4132 if (cur->nodeTab[i] == val) break;
4134 if (i >= cur->nodeNr) { /* not found */
4142 if ((cur->nodeTab[i] != NULL) &&
4143 (cur->nodeTab[i]->type == XML_NAMESPACE_DECL))
4144 xmlXPathNodeSetFreeNs((xmlNsPtr) cur->nodeTab[i]);
4145 cur->nodeNr--;
4146 for (;i < cur->nodeNr;i++)
4147 cur->nodeTab[i] = cur->nodeTab[i + 1];
4148 cur->nodeTab[cur->nodeNr] = NULL;
4153 * @cur: the initial node set
4159 xmlXPathNodeSetRemove(xmlNodeSetPtr cur, int val) {
4160 if (cur == NULL) return;
4161 if (val >= cur->nodeNr) return;
4162 if ((cur->nodeTab[val] != NULL) &&
4163 (cur->nodeTab[val]->type == XML_NAMESPACE_DECL))
4164 xmlXPathNodeSetFreeNs((xmlNsPtr) cur->nodeTab[val]);
4165 cur->nodeNr--;
4166 for (;val < cur->nodeNr;val++)
4167 cur->nodeTab[val] = cur->nodeTab[val + 1];
4168 cur->nodeTab[cur->nodeNr] = NULL;
4477 xmlNodePtr cur;
4489 cur = xmlXPathNodeSetItem(nodes1, i);
4490 if (!xmlXPathNodeSetContains(nodes2, cur)) {
4491 if (xmlXPathNodeSetAddUnique(ret, cur) < 0)
4513 xmlNodePtr cur;
4525 cur = xmlXPathNodeSetItem(nodes1, i);
4526 if (xmlXPathNodeSetContains(nodes2, cur)) {
4527 if (xmlXPathNodeSetAddUnique(ret, cur) < 0)
4550 xmlNodePtr cur;
4561 cur = xmlXPathNodeSetItem(nodes, i);
4562 strval = xmlXPathCastNodeToString(cur);
4565 if (xmlXPathNodeSetAddUnique(ret, cur) < 0)
4610 xmlNodePtr cur;
4618 cur = xmlXPathNodeSetItem(nodes1, i);
4619 if (xmlXPathNodeSetContains(nodes2, cur))
4640 xmlNodePtr cur;
4655 cur = xmlXPathNodeSetItem(nodes, i);
4656 if (cur == node)
4658 if (xmlXPathNodeSetAddUnique(ret, cur) < 0)
4745 xmlNodePtr cur;
4760 cur = xmlXPathNodeSetItem(nodes, i);
4761 if (cur == node)
4763 if (xmlXPathNodeSetAddUnique(ret, cur) < 0)
5437 xmlNodePtr cur, tmp;
5447 cur = val->nodesetval->nodeTab[0]->children;
5448 while (cur != NULL) {
5449 tmp = xmlDocCopyNode(cur, top, 1);
5451 cur = cur->next;
6245 ret->cur = ret->base = str;
7611 (xmlXPathParserContextPtr ctxt, xmlNodePtr cur);
7621 (xmlNodePtr cur, xmlNodePtr contextNode);
7634 * @cur: the current node in the traversal
7642 xmlXPathNextSelf(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
7644 if (cur == NULL)
7652 * @cur: the current node in the traversal
7660 xmlXPathNextChild(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
7662 if (cur == NULL) {
7694 if ((cur->type == XML_DOCUMENT_NODE) ||
7695 (cur->type == XML_HTML_DOCUMENT_NODE))
7697 return(cur->next);
7703 * @cur: the current node in the traversal
7711 xmlXPathNextChildElement(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
7713 if (cur == NULL) {
7714 cur = ctxt->context->node;
7715 if (cur == NULL) return(NULL);
7719 switch (cur->type) {
7724 cur = cur->children;
7725 if (cur != NULL) {
7726 if (cur->type == XML_ELEMENT_NODE)
7727 return(cur);
7729 cur = cur->next;
7730 } while ((cur != NULL) &&
7731 (cur->type != XML_ELEMENT_NODE));
7732 return(cur);
7740 return(xmlDocGetRootElement((xmlDocPtr) cur));
7749 switch (cur->type) {
7763 if (cur->next != NULL) {
7764 if (cur->next->type == XML_ELEMENT_NODE)
7765 return(cur->next);
7766 cur = cur->next;
7768 cur = cur->next;
7769 } while ((cur != NULL) && (cur->type != XML_ELEMENT_NODE));
7770 return(cur);
7779 * @cur: the current node in the traversal
7789 xmlXPathNextDescendantOrSelfElemParent(xmlNodePtr cur,
7792 if (cur == NULL) {
7810 xmlNodePtr start = cur;
7812 while (cur != NULL) {
7813 switch (cur->type) {
7818 if (cur != start)
7819 return(cur);
7820 if (cur->children != NULL) {
7821 cur = cur->children;
7831 if (cur != start)
7832 return(cur);
7833 return(xmlDocGetRootElement((xmlDocPtr) cur));
7839 if ((cur == NULL) || (cur == contextNode))
7841 if (cur->next != NULL) {
7842 cur = cur->next;
7844 cur = cur->parent;
7856 * @cur: the current node in the traversal
7865 xmlXPathNextDescendant(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
7867 if (cur == NULL) {
7879 if (cur->type == XML_NAMESPACE_DECL)
7881 if (cur->children != NULL) {
7885 if (cur->children->type != XML_ENTITY_DECL) {
7886 cur = cur->children;
7890 if (cur->type != XML_DTD_NODE)
7891 return(cur);
7895 if (cur == ctxt->context->node) return(NULL);
7897 while (cur->next != NULL) {
7898 cur = cur->next;
7899 if ((cur->type != XML_ENTITY_DECL) &&
7900 (cur->type != XML_DTD_NODE))
7901 return(cur);
7905 cur = cur->parent;
7906 if (cur == NULL) break;
7907 if (cur == ctxt->context->node) return(NULL);
7908 if (cur->next != NULL) {
7909 cur = cur->next;
7910 return(cur);
7912 } while (cur != NULL);
7913 return(cur);
7919 * @cur: the current node in the traversal
7930 xmlXPathNextDescendantOrSelf(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
7932 if (cur == NULL)
7941 return(xmlXPathNextDescendant(ctxt, cur));
7947 * @cur: the current node in the traversal
7955 xmlXPathNextParent(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
7962 if (cur == NULL) {
8016 * @cur: the current node in the traversal
8028 xmlXPathNextAncestor(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
8035 if (cur == NULL) {
8085 if (cur == ctxt->context->doc->children)
8087 if (cur == (xmlNodePtr) ctxt->context->doc)
8089 switch (cur->type) {
8104 if (cur->parent == NULL)
8106 if ((cur->parent->type == XML_ELEMENT_NODE) &&
8107 ((cur->parent->name[0] == ' ') ||
8108 (xmlStrEqual(cur->parent->name,
8111 return(cur->parent);
8113 xmlAttrPtr att = (xmlAttrPtr) cur;
8118 xmlNsPtr ns = (xmlNsPtr) cur;
8141 * @cur: the current node in the traversal
8152 xmlXPathNextAncestorOrSelf(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
8154 if (cur == NULL)
8156 return(xmlXPathNextAncestor(ctxt, cur));
8162 * @cur: the current node in the traversal
8171 xmlXPathNextFollowingSibling(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
8176 if (cur == (xmlNodePtr) ctxt->context->doc)
8178 if (cur == NULL)
8180 return(cur->next);
8186 * @cur: the current node in the traversal
8196 xmlXPathNextPrecedingSibling(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
8201 if (cur == (xmlNodePtr) ctxt->context->doc)
8203 if (cur == NULL)
8205 if ((cur->prev != NULL) && (cur->prev->type == XML_DTD_NODE)) {
8206 cur = cur->prev;
8207 if (cur == NULL)
8210 return(cur->prev);
8216 * @cur: the current node in the traversal
8227 xmlXPathNextFollowing(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
8229 if ((cur != NULL) && (cur->type != XML_ATTRIBUTE_NODE) &&
8230 (cur->type != XML_NAMESPACE_DECL) && (cur->children != NULL))
8231 return(cur->children);
8233 if (cur == NULL) {
8234 cur = ctxt->context->node;
8235 if (cur->type == XML_ATTRIBUTE_NODE) {
8236 cur = cur->parent;
8237 } else if (cur->type == XML_NAMESPACE_DECL) {
8238 xmlNsPtr ns = (xmlNsPtr) cur;
8243 cur = (xmlNodePtr) ns->next;
8246 if (cur == NULL) return(NULL) ; /* ERROR */
8247 if (cur->next != NULL) return(cur->next) ;
8249 cur = cur->parent;
8250 if (cur == NULL) break;
8251 if (cur == (xmlNodePtr) ctxt->context->doc) return(NULL);
8252 if (cur->next != NULL) return(cur->next);
8253 } while (cur != NULL);
8254 return(cur);
8289 * @cur: the current node in the traversal
8300 xmlXPathNextPreceding(xmlXPathParserContextPtr ctxt, xmlNodePtr cur)
8303 if (cur == NULL) {
8304 cur = ctxt->context->node;
8305 if (cur->type == XML_ATTRIBUTE_NODE) {
8306 cur = cur->parent;
8307 } else if (cur->type == XML_NAMESPACE_DECL) {
8308 xmlNsPtr ns = (xmlNsPtr) cur;
8313 cur = (xmlNodePtr) ns->next;
8316 if ((cur == NULL) || (cur->type == XML_NAMESPACE_DECL))
8318 if ((cur->prev != NULL) && (cur->prev->type == XML_DTD_NODE))
8319 cur = cur->prev;
8321 if (cur->prev != NULL) {
8322 for (cur = cur->prev; cur->last != NULL; cur = cur->last) ;
8323 return (cur);
8326 cur = cur->parent;
8327 if (cur == NULL)
8329 if (cur == ctxt->context->doc->children)
8331 } while (xmlXPathIsAncestor(cur, ctxt->context->node));
8332 return (cur);
8338 * @cur: the current node in the traversal
8352 xmlNodePtr cur)
8355 if (cur == NULL) {
8356 cur = ctxt->context->node;
8357 if (cur == NULL)
8359 if (cur->type == XML_ATTRIBUTE_NODE) {
8360 cur = cur->parent;
8361 } else if (cur->type == XML_NAMESPACE_DECL) {
8362 xmlNsPtr ns = (xmlNsPtr) cur;
8367 cur = (xmlNodePtr) ns->next;
8369 ctxt->ancestor = cur->parent;
8371 if (cur->type == XML_NAMESPACE_DECL)
8373 if ((cur->prev != NULL) && (cur->prev->type == XML_DTD_NODE))
8374 cur = cur->prev;
8375 while (cur->prev == NULL) {
8376 cur = cur->parent;
8377 if (cur == NULL)
8379 if (cur == ctxt->context->doc->children)
8381 if (cur != ctxt->ancestor)
8382 return (cur);
8383 ctxt->ancestor = cur->parent;
8385 cur = cur->prev;
8386 while (cur->last != NULL)
8387 cur = cur->last;
8388 return (cur);
8394 * @cur: the current attribute in the traversal
8406 xmlXPathNextNamespace(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
8409 if (cur == NULL) {
8435 * @cur: the current attribute in the traversal
8443 xmlXPathNextAttribute(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
8449 if (cur == NULL) {
8454 return((xmlNodePtr)cur->next);
8557 xmlXPathObjectPtr cur;
8564 cur = valuePop(ctxt);
8566 if ((cur == NULL) || (cur->nodesetval == NULL))
8568 else if ((cur->type == XPATH_NODESET) || (cur->type == XPATH_XSLT_TREE)) {
8570 (double) cur->nodesetval->nodeNr));
8572 if ((cur->nodesetval->nodeNr != 1) ||
8573 (cur->nodesetval->nodeTab == NULL)) {
8579 tmp = cur->nodesetval->nodeTab[0];
8590 xmlXPathReleaseObject(ctxt->context, cur);
8605 const xmlChar *cur = ids;
8616 while (IS_BLANK_CH(*cur)) cur++;
8617 while (*cur != 0) {
8618 while ((!IS_BLANK_CH(*cur)) && (*cur != 0))
8619 cur++;
8621 ID = xmlStrndup(ids, cur - ids);
8644 while (IS_BLANK_CH(*cur)) cur++;
8645 ids = cur;
8725 xmlXPathObjectPtr cur;
8740 cur = valuePop(ctxt);
8742 if ((cur->nodesetval == NULL) || (cur->nodesetval->nodeNr == 0)) {
8746 switch (cur->nodesetval->nodeTab[i]->type) {
8750 if (cur->nodesetval->nodeTab[i]->name[0] == ' ')
8755 cur->nodesetval->nodeTab[i]->name));
8759 ((xmlNsPtr)cur->nodesetval->nodeTab[i])->prefix));
8765 xmlXPathReleaseObject(ctxt->context, cur);
8784 xmlXPathObjectPtr cur;
8798 cur = valuePop(ctxt);
8800 if ((cur->nodesetval == NULL) || (cur->nodesetval->nodeNr == 0)) {
8804 switch (cur->nodesetval->nodeTab[i]->type) {
8807 if (cur->nodesetval->nodeTab[i]->ns == NULL)
8811 cur->nodesetval->nodeTab[i]->ns->href));
8817 xmlXPathReleaseObject(ctxt->context, cur);
8845 xmlXPathObjectPtr cur;
8858 cur = valuePop(ctxt);
8860 if ((cur->nodesetval == NULL) || (cur->nodesetval->nodeNr == 0)) {
8865 switch (cur->nodesetval->nodeTab[i]->type) {
8868 if (cur->nodesetval->nodeTab[i]->name[0] == ' ')
8871 else if ((cur->nodesetval->nodeTab[i]->ns == NULL) ||
8872 (cur->nodesetval->nodeTab[i]->ns->prefix == NULL)) {
8875 cur->nodesetval->nodeTab[i]->name));
8879 fullname = xmlBuildQName(cur->nodesetval->nodeTab[i]->name,
8880 cur->nodesetval->nodeTab[i]->ns->prefix,
8882 if (fullname == cur->nodesetval->nodeTab[i]->name)
8883 fullname = xmlStrdup(cur->nodesetval->nodeTab[i]->name);
8893 cur->nodesetval->nodeTab[i]));
8897 xmlXPathReleaseObject(ctxt->context, cur);
8939 xmlXPathObjectPtr cur;
8950 cur = valuePop(ctxt);
8951 if (cur == NULL) XP_ERROR(XPATH_INVALID_OPERAND);
8952 valuePush(ctxt, xmlXPathCacheConvertString(ctxt->context, cur));
8969 xmlXPathObjectPtr cur;
8989 cur = valuePop(ctxt);
8991 xmlUTF8Strlen(cur->stringval)));
8992 xmlXPathReleaseObject(ctxt->context, cur);
9006 xmlXPathObjectPtr cur, newobj;
9015 cur = valuePop(ctxt);
9016 if ((cur == NULL) || (cur->type != XPATH_STRING)) {
9017 xmlXPathReleaseObject(ctxt->context, cur);
9027 xmlXPathReleaseObject(ctxt->context, cur);
9030 tmp = xmlStrcat(newobj->stringval, cur->stringval);
9031 newobj->stringval = cur->stringval;
9032 cur->stringval = tmp;
9036 valuePush(ctxt, cur);
9484 xmlXPathObjectPtr cur;
9487 cur = valuePop(ctxt);
9488 if (cur == NULL) XP_ERROR(XPATH_INVALID_OPERAND);
9489 cur = xmlXPathCacheConvertBoolean(ctxt->context, cur);
9490 valuePush(ctxt, cur);
9599 xmlXPathObjectPtr cur;
9617 cur = valuePop(ctxt);
9618 valuePush(ctxt, xmlXPathCacheConvertNumber(ctxt->context, cur));
9633 xmlXPathObjectPtr cur;
9642 cur = valuePop(ctxt);
9644 if ((cur->nodesetval != NULL) && (cur->nodesetval->nodeNr != 0)) {
9645 for (i = 0; i < cur->nodesetval->nodeNr; i++) {
9646 res += xmlXPathCastNodeToNumber(cur->nodesetval->nodeTab[i]);
9650 xmlXPathReleaseObject(ctxt->context, cur);
9744 * @cur: pointer to the beginning of the char
9757 const xmlChar *cur;
9761 cur = ctxt->cur;
9774 c = *cur;
9776 if ((cur[1] & 0xc0) != 0x80)
9780 if ((cur[2] & 0xc0) != 0x80)
9784 ((cur[3] & 0xc0) != 0x80))
9788 val = (cur[0] & 0x7) << 18;
9789 val |= (cur[1] & 0x3f) << 12;
9790 val |= (cur[2] & 0x3f) << 6;
9791 val |= cur[3] & 0x3f;
9795 val = (cur[0] & 0xf) << 12;
9796 val |= (cur[1] & 0x3f) << 6;
9797 val |= cur[2] & 0x3f;
9802 val = (cur[0] & 0x1f) << 6;
9803 val |= cur[1] & 0x3f;
9812 return((int) *cur);
9846 if ((ctxt == NULL) || (ctxt->cur == NULL)) return(NULL);
9850 in = ctxt->cur;
9864 count = in - ctxt->cur;
9867 ret = xmlStrndup(ctxt->cur, count);
9868 ctxt->cur = in;
9899 if (ret && CUR == ':') {
9927 if ((ctxt == NULL) || (ctxt->cur == NULL)) return(NULL);
9931 in = ctxt->cur;
9943 count = in - ctxt->cur;
9945 ctxt->cur = in;
9948 ret = xmlStrndup(ctxt->cur, count);
9949 ctxt->cur = in;
10048 const xmlChar *cur = str;
10058 if (cur == NULL) return(0);
10059 while (IS_BLANK_CH(*cur)) cur++;
10060 if ((*cur != '.') && ((*cur < '0') || (*cur > '9')) && (*cur != '-')) {
10063 if (*cur == '-') {
10065 cur++;
10074 while ((*cur >= '0') && (*cur <= '9')) {
10076 tmp = (*cur - '0');
10078 cur++;
10084 while ((*cur >= '0') && (*cur <= '9')) {
10085 ret = ret * 10 + (*cur - '0');
10087 cur++;
10091 if (*cur == '.') {
10095 cur++;
10096 if (((*cur < '0') || (*cur > '9')) && (!ok)) {
10099 while (*cur == '0') {
10101 cur++;
10104 while (((*cur >= '0') && (*cur <= '9')) && (frac < max)) {
10105 v = (*cur - '0');
10108 cur++;
10112 while ((*cur >= '0') && (*cur <= '9'))
10113 cur++;
10115 if ((*cur == 'e') || (*cur == 'E')) {
10116 cur++;
10117 if (*cur == '-') {
10119 cur++;
10120 } else if (*cur == '+') {
10121 cur++;
10123 while ((*cur >= '0') && (*cur <= '9')) {
10125 exponent = exponent * 10 + (*cur - '0');
10126 cur++;
10129 while (IS_BLANK_CH(*cur)) cur++;
10130 if (*cur != 0) return(NAN);
10161 if ((CUR != '.') && ((CUR < '0') || (CUR > '9'))) {
10170 while ((CUR >= '0') && (CUR <= '9')) {
10172 tmp = (CUR - '0');
10180 while ((CUR >= '0') && (CUR <= '9')) {
10181 ret = ret * 10 + (CUR - '0');
10186 if (CUR == '.') {
10191 if (((CUR < '0') || (CUR > '9')) && (!ok)) {
10194 while (CUR == '0') {
10199 while ((CUR >= '0') && (CUR <= '9') && (frac < max)) {
10200 v = (CUR - '0');
10207 while ((CUR >= '0') && (CUR <= '9'))
10210 if ((CUR == 'e') || (CUR == 'E')) {
10212 if (CUR == '-') {
10215 } else if (CUR == '+') {
10218 while ((CUR >= '0') && (CUR <= '9')) {
10220 exponent = exponent * 10 + (CUR - '0');
10247 if (CUR == '"') {
10250 while ((IS_CHAR_CH(CUR)) && (CUR != '"'))
10252 if (!IS_CHAR_CH(CUR)) {
10258 } else if (CUR == '\'') {
10261 while ((IS_CHAR_CH(CUR)) && (CUR != '\''))
10263 if (!IS_CHAR_CH(CUR)) {
10291 if (CUR == '"') {
10294 while ((IS_CHAR_CH(CUR)) && (CUR != '"'))
10296 if (!IS_CHAR_CH(CUR)) {
10302 } else if (CUR == '\'') {
10305 while ((IS_CHAR_CH(CUR)) && (CUR != '\''))
10307 if (!IS_CHAR_CH(CUR)) {
10345 if (CUR != '$') {
10424 if (CUR != '(') {
10441 if (CUR != ')') {
10442 while (CUR != 0) {
10453 if (CUR == ')') break;
10454 if (CUR != ',') {
10484 if (CUR == '$') xmlXPathCompVariableReference(ctxt);
10485 else if (CUR == '(') {
10490 if (CUR != ')') {
10495 } else if (IS_ASCII_DIGIT(CUR) || (CUR == '.' && IS_ASCII_DIGIT(NXT(1)))) {
10497 } else if ((CUR == '\'') || (CUR == '"')) {
10526 while (CUR == '[') {
10555 const xmlChar *cur;
10558 cur = ctxt->cur;
10577 ret = xmlStrndup(cur, ctxt->cur - cur);
10578 ctxt->cur = cur;
10606 if ((CUR == '$') || (CUR == '(') ||
10607 (IS_ASCII_DIGIT(CUR)) ||
10608 (CUR == '\'') || (CUR == '"') ||
10609 (CUR == '.' && IS_ASCII_DIGIT(NXT(1)))) {
10611 } else if (CUR == '*') {
10614 } else if (CUR == '/') {
10617 } else if (CUR == '@') {
10620 } else if (CUR == '.') {
10722 if (CUR == '/') {
10731 if ((CUR == '/') && (NXT(1) == '/')) {
10740 } else if (CUR == '/') {
10762 while (CUR == '|') {
10792 while (CUR == '-') {
10827 while ((CUR == '*') ||
10828 ((CUR == 'd') && (NXT(1) == 'i') && (NXT(2) == 'v')) ||
10829 ((CUR == 'm') && (NXT(1) == 'o') && (NXT(2) == 'd'))) {
10833 if (CUR == '*') {
10836 } else if (CUR == 'd') {
10839 } else if (CUR == 'm') {
10868 while ((CUR == '+') || (CUR == '-')) {
10872 if (CUR == '+') plus = 1;
10906 while ((CUR == '<') ||
10907 (CUR == '>') ||
10908 ((CUR == '<') && (NXT(1) == '=')) ||
10909 ((CUR == '>') && (NXT(1) == '='))) {
10913 if (CUR == '<') inf = 1;
10948 while ((CUR == '=') || ((CUR == '!') && (NXT(1) == '='))) {
10952 if (CUR == '=') eq = 1;
10979 while ((CUR == 'a') && (NXT(1) == 'n') && (NXT(2) == 'd')) {
11005 while ((CUR == 'o') && (NXT(1) == 'r')) {
11040 if (CUR != '[') {
11062 if (CUR != ']') {
11111 if ((name == NULL) && (CUR == '*')) {
11126 blanks = IS_BLANK_CH(CUR);
11128 if (CUR == '(') {
11157 if (CUR != ')') {
11164 if (CUR != ')') {
11173 if ((!blanks) && (CUR == ':')) {
11194 if (CUR == '*') {
11319 if ((CUR == '.') && (NXT(1) == '.')) {
11324 } else if (CUR == '.') {
11345 if (CUR != '(') {
11356 if (CUR != ')') {
11365 if (CUR == '*') {
11374 if ((CUR == ':') && (NXT(1) == ':')) {
11385 } else if (CUR == '@') {
11430 while (CUR == '[') {
11470 if ((CUR == '/') && (NXT(1) == '/')) {
11475 } else if (CUR == '/') {
11482 while (CUR == '/') {
11483 if ((CUR == '/') && (NXT(1) == '/')) {
11489 } else if (CUR == '/') {
11522 if (CUR != '/') {
11525 while (CUR == '/') {
11526 if ((CUR == '/') && (NXT(1) == '/')) {
11532 } else if (CUR == '/') {
11535 if ((CUR != 0 ) &&
11536 ((IS_ASCII_LETTER(CUR)) || (CUR == '_') || (CUR == '.') ||
11537 (CUR == '@') || (CUR == '*')))
12063 if (addNode(seq, cur) < 0) \
12067 if (addNode(seq, cur) < 0) \
12075 if (xmlXPathNodeSetAddNs(seq, xpctxt->node, (xmlNsPtr) cur) < 0) \
12080 if (xmlXPathNodeSetAddNs(seq, xpctxt->node, (xmlNsPtr) cur) < 0) \
12108 xmlNodePtr cur;
12313 cur = NULL;
12316 cur = next(ctxt, cur);
12317 if (cur == NULL)
12324 if (*first == cur)
12328 (xmlXPathCmpNodesExt(*first, cur) >= 0))
12330 (xmlXPathCmpNodes(*first, cur) >= 0))
12337 if (*last == cur)
12341 (xmlXPathCmpNodesExt(cur, *last) >= 0))
12343 (xmlXPathCmpNodes(cur, *last) >= 0))
12353 xmlGenericError(xmlGenericErrorContext, " %s", cur->name);
12363 switch (cur->type) {
12389 } else if (cur->type == (xmlElementType) type) {
12390 if (cur->type == XML_NAMESPACE_DECL)
12395 (cur->type == XML_CDATA_SECTION_NODE))
12401 if ((cur->type == XML_PI_NODE) &&
12402 ((name == NULL) || xmlStrEqual(name, cur->name)))
12409 if (cur->type == XML_ATTRIBUTE_NODE)
12414 } else if ((cur->ns != NULL) &&
12415 (xmlStrEqual(URI, cur->ns->href)))
12421 if (cur->type == XML_NAMESPACE_DECL)
12426 if (cur->type == XML_ELEMENT_NODE) {
12431 } else if ((cur->ns != NULL) &&
12432 (xmlStrEqual(URI, cur->ns->href)))
12445 if (cur->type != XML_ATTRIBUTE_NODE)
12448 if (cur->type != XML_NAMESPACE_DECL)
12451 if (cur->type != XML_ELEMENT_NODE)
12454 switch (cur->type) {
12456 if (xmlStrEqual(name, cur->name)) {
12458 if (cur->ns == NULL)
12463 if ((cur->ns != NULL) &&
12464 (xmlStrEqual(URI, cur->ns->href)))
12472 xmlAttrPtr attr = (xmlAttrPtr) cur;
12493 if (cur->type == XML_NAMESPACE_DECL) {
12494 xmlNsPtr ns = (xmlNsPtr) cur;
12508 } while ((cur != NULL) && (ctxt->error == XPATH_EXPRESSION_OK));
12714 int total = 0, cur;
12746 cur =
12765 if (total > cur)
12767 return (total + cur);
12842 int total = 0, cur;
12881 cur =
12904 if (total > cur)
12906 return (total + cur);
14253 xmlNodePtr cur = NULL, limit = NULL;
14305 cur = (xmlNodePtr)ctxt->doc;
14315 cur = ctxt->node;
14335 limit = cur;
14337 if (cur == NULL) {
14357 xmlXPathNodeSetAddUnique((*resultSeq)->nodesetval, cur);
14366 switch (cur->type) {
14372 if (cur->type == XML_ELEMENT_NODE) {
14373 ret = xmlStreamPush(patstream, cur->name,
14374 (cur->ns ? cur->ns->href : NULL));
14376 ret = xmlStreamPushNode(patstream, NULL, NULL, cur->type);
14385 if (xmlXPathNodeSetAddUnique((*resultSeq)->nodesetval, cur)
14391 if ((cur->children == NULL) || (depth >= max_depth)) {
14393 while (cur->next != NULL) {
14394 cur = cur->next;
14395 if ((cur->type != XML_ENTITY_DECL) &&
14396 (cur->type != XML_DTD_NODE))
14405 if (cur->type == XML_NAMESPACE_DECL) break;
14406 if ((cur->children != NULL) && (depth < max_depth)) {
14410 if (cur->children->type != XML_ENTITY_DECL) {
14411 cur = cur->children;
14416 if (cur->type != XML_DTD_NODE)
14421 if (cur == limit)
14424 while (cur->next != NULL) {
14425 cur = cur->next;
14426 if ((cur->type != XML_ENTITY_DECL) &&
14427 (cur->type != XML_DTD_NODE))
14432 cur = cur->parent;
14434 if ((cur == NULL) || (cur == limit))
14436 if (cur->type == XML_ELEMENT_NODE) {
14439 ((cur->type == XML_TEXT_NODE) ||
14440 (cur->type == XML_CDATA_SECTION_NODE) ||
14441 (cur->type == XML_COMMENT_NODE) ||
14442 (cur->type == XML_PI_NODE)))
14446 if (cur->next != NULL) {
14447 cur = cur->next;
14450 } while (cur != NULL);
14452 } while ((cur != NULL) && (depth >= 0));
14824 if (*pctxt->cur != 0) {
15008 if (*ctxt->cur != 0)
