Lines Matching defs:cur
361 const xmlChar *cur = value;
371 while (IS_BLANK_CH(*cur)) cur++;
372 if (((*cur >= 'a') && (*cur <= 'z')) || ((*cur >= 'A') && (*cur <= 'Z')) ||
373 (*cur == '_'))
374 cur++;
377 while (((*cur >= 'a') && (*cur <= 'z')) ||
378 ((*cur >= 'A') && (*cur <= 'Z')) ||
379 ((*cur >= '0') && (*cur <= '9')) ||
380 (*cur == '_') || (*cur == '-') || (*cur == '.'))
381 cur++;
383 while (IS_BLANK_CH(*cur)) cur++;
384 if (*cur == 0)
391 cur = value;
392 c = CUR_SCHAR(cur, l);
395 cur += l;
396 c = CUR_SCHAR(cur, l);
401 cur += l;
402 c = CUR_SCHAR(cur, l);
406 cur += l;
407 c = CUR_SCHAR(cur, l);
411 cur += l;
412 c = CUR_SCHAR(cur, l);
435 const xmlChar *cur = value;
444 while (IS_BLANK_CH(*cur)) cur++;
445 if (((*cur >= 'a') && (*cur <= 'z')) || ((*cur >= 'A') && (*cur <= 'Z')) ||
446 (*cur == '_'))
447 cur++;
450 while (((*cur >= 'a') && (*cur <= 'z')) ||
451 ((*cur >= 'A') && (*cur <= 'Z')) ||
452 ((*cur >= '0') && (*cur <= '9')) ||
453 (*cur == '_') || (*cur == '-') || (*cur == '.'))
454 cur++;
455 if (*cur == ':') {
456 cur++;
457 if (((*cur >= 'a') && (*cur <= 'z')) ||
458 ((*cur >= 'A') && (*cur <= 'Z')) ||
459 (*cur == '_'))
460 cur++;
463 while (((*cur >= 'a') && (*cur <= 'z')) ||
464 ((*cur >= 'A') && (*cur <= 'Z')) ||
465 ((*cur >= '0') && (*cur <= '9')) ||
466 (*cur == '_') || (*cur == '-') || (*cur == '.'))
467 cur++;
470 while (IS_BLANK_CH(*cur)) cur++;
471 if (*cur == 0)
478 cur = value;
479 c = CUR_SCHAR(cur, l);
482 cur += l;
483 c = CUR_SCHAR(cur, l);
488 cur += l;
489 c = CUR_SCHAR(cur, l);
493 cur += l;
494 c = CUR_SCHAR(cur, l);
497 cur += l;
498 c = CUR_SCHAR(cur, l);
501 cur += l;
502 c = CUR_SCHAR(cur, l);
506 cur += l;
507 c = CUR_SCHAR(cur, l);
512 cur += l;
513 c = CUR_SCHAR(cur, l);
533 const xmlChar *cur = value;
542 while (IS_BLANK_CH(*cur)) cur++;
543 if (((*cur >= 'a') && (*cur <= 'z')) || ((*cur >= 'A') && (*cur <= 'Z')) ||
544 (*cur == '_') || (*cur == ':'))
545 cur++;
548 while (((*cur >= 'a') && (*cur <= 'z')) ||
549 ((*cur >= 'A') && (*cur <= 'Z')) ||
550 ((*cur >= '0') && (*cur <= '9')) ||
551 (*cur == '_') || (*cur == '-') || (*cur == '.') || (*cur == ':'))
552 cur++;
554 while (IS_BLANK_CH(*cur)) cur++;
555 if (*cur == 0)
562 cur = value;
563 c = CUR_SCHAR(cur, l);
566 cur += l;
567 c = CUR_SCHAR(cur, l);
572 cur += l;
573 c = CUR_SCHAR(cur, l);
576 cur += l;
577 c = CUR_SCHAR(cur, l);
581 cur += l;
582 c = CUR_SCHAR(cur, l);
602 const xmlChar *cur = value;
611 while (IS_BLANK_CH(*cur)) cur++;
612 if (((*cur >= 'a') && (*cur <= 'z')) ||
613 ((*cur >= 'A') && (*cur <= 'Z')) ||
614 ((*cur >= '0') && (*cur <= '9')) ||
615 (*cur == '_') || (*cur == '-') || (*cur == '.') || (*cur == ':'))
616 cur++;
619 while (((*cur >= 'a') && (*cur <= 'z')) ||
620 ((*cur >= 'A') && (*cur <= 'Z')) ||
621 ((*cur >= '0') && (*cur <= '9')) ||
622 (*cur == '_') || (*cur == '-') || (*cur == '.') || (*cur == ':'))
623 cur++;
625 while (IS_BLANK_CH(*cur)) cur++;
626 if (*cur == 0)
633 cur = value;
634 c = CUR_SCHAR(cur, l);
637 cur += l;
638 c = CUR_SCHAR(cur, l);
644 cur += l;
645 c = CUR_SCHAR(cur, l);
648 cur += l;
649 c = CUR_SCHAR(cur, l);
653 cur += l;
654 c = CUR_SCHAR(cur, l);
713 xmlNsPtr cur;
724 cur = (xmlNsPtr) xmlMalloc(sizeof(xmlNs));
725 if (cur == NULL) {
729 memset(cur, 0, sizeof(xmlNs));
730 cur->type = XML_LOCAL_NAMESPACE;
733 cur->href = xmlStrdup(href);
735 cur->prefix = xmlStrdup(prefix);
743 node->nsDef = cur;
747 if (((prev->prefix == NULL) && (cur->prefix == NULL)) ||
748 (xmlStrEqual(prev->prefix, cur->prefix))) {
749 xmlFreeNs(cur);
754 if (((prev->prefix == NULL) && (cur->prefix == NULL)) ||
755 (xmlStrEqual(prev->prefix, cur->prefix))) {
756 xmlFreeNs(cur);
760 prev->next = cur;
763 return(cur);
787 * @cur: the namespace pointer
792 xmlFreeNs(xmlNsPtr cur) {
793 if (cur == NULL) {
800 if (cur->href != NULL) xmlFree((char *) cur->href);
801 if (cur->prefix != NULL) xmlFree((char *) cur->prefix);
802 xmlFree(cur);
807 * @cur: the first namespace pointer
812 xmlFreeNsList(xmlNsPtr cur) {
814 if (cur == NULL) {
821 while (cur != NULL) {
822 next = cur->next;
823 xmlFreeNs(cur);
824 cur = next;
843 xmlDtdPtr cur;
858 cur = (xmlDtdPtr) xmlMalloc(sizeof(xmlDtd));
859 if (cur == NULL) {
863 memset(cur, 0 , sizeof(xmlDtd));
864 cur->type = XML_DTD_NODE;
867 cur->name = xmlStrdup(name);
869 cur->ExternalID = xmlStrdup(ExternalID);
871 cur->SystemID = xmlStrdup(SystemID);
873 doc->extSubset = cur;
874 cur->doc = doc;
877 xmlRegisterNodeDefaultValue((xmlNodePtr)cur);
878 return(cur);
891 xmlNodePtr cur;
895 cur = doc->children;
896 while (cur != NULL) {
897 if (cur->type == XML_DTD_NODE)
898 return((xmlDtdPtr) cur);
899 cur = cur->next;
917 xmlDtdPtr cur;
932 cur = (xmlDtdPtr) xmlMalloc(sizeof(xmlDtd));
933 if (cur == NULL) {
937 memset(cur, 0, sizeof(xmlDtd));
938 cur->type = XML_DTD_NODE;
941 cur->name = xmlStrdup(name);
942 if (cur->name == NULL) {
944 xmlFree(cur);
949 cur->ExternalID = xmlStrdup(ExternalID);
950 if (cur->ExternalID == NULL) {
952 if (cur->name != NULL)
953 xmlFree((char *)cur->name);
954 xmlFree(cur);
959 cur->SystemID = xmlStrdup(SystemID);
960 if (cur->SystemID == NULL) {
962 if (cur->name != NULL)
963 xmlFree((char *)cur->name);
964 if (cur->ExternalID != NULL)
965 xmlFree((char *)cur->ExternalID);
966 xmlFree(cur);
971 doc->intSubset = cur;
972 cur->parent = doc;
973 cur->doc = doc;
975 doc->children = (xmlNodePtr) cur;
976 doc->last = (xmlNodePtr) cur;
982 prev->prev = (xmlNodePtr) cur;
983 cur->next = prev;
984 doc->children = (xmlNodePtr) cur;
992 cur->prev = doc->last;
993 cur->prev->next = (xmlNodePtr) cur;
994 cur->next = NULL;
995 doc->last = (xmlNodePtr) cur;
997 cur->next = next;
998 cur->prev = next->prev;
999 if (cur->prev == NULL)
1000 doc->children = (xmlNodePtr) cur;
1002 cur->prev->next = (xmlNodePtr) cur;
1003 next->prev = (xmlNodePtr) cur;
1010 xmlRegisterNodeDefaultValue((xmlNodePtr)cur);
1011 return(cur);
1064 * @cur: the DTD structure to free up
1069 xmlFreeDtd(xmlDtdPtr cur) {
1072 if (cur == NULL) {
1075 if (cur->doc != NULL) dict = cur->doc->dict;
1078 xmlDeregisterNodeDefaultValue((xmlNodePtr)cur);
1080 if (cur->children != NULL) {
1081 xmlNodePtr next, c = cur->children;
1099 DICT_FREE(cur->name)
1100 DICT_FREE(cur->SystemID)
1101 DICT_FREE(cur->ExternalID)
1103 if (cur->notations != NULL)
1104 xmlFreeNotationTable((xmlNotationTablePtr) cur->notations);
1106 if (cur->elements != NULL)
1107 xmlFreeElementTable((xmlElementTablePtr) cur->elements);
1108 if (cur->attributes != NULL)
1109 xmlFreeAttributeTable((xmlAttributeTablePtr) cur->attributes);
1110 if (cur->entities != NULL)
1111 xmlFreeEntitiesTable((xmlEntitiesTablePtr) cur->entities);
1112 if (cur->pentities != NULL)
1113 xmlFreeEntitiesTable((xmlEntitiesTablePtr) cur->pentities);
1115 xmlFree(cur);
1128 xmlDocPtr cur;
1136 cur = (xmlDocPtr) xmlMalloc(sizeof(xmlDoc));
1137 if (cur == NULL) {
1141 memset(cur, 0, sizeof(xmlDoc));
1142 cur->type = XML_DOCUMENT_NODE;
1144 cur->version = xmlStrdup(version);
1145 if (cur->version == NULL) {
1147 xmlFree(cur);
1150 cur->standalone = -1;
1151 cur->compression = -1; /* not initialized */
1152 cur->doc = cur;
1158 cur->charset = XML_CHAR_ENCODING_UTF8;
1161 xmlRegisterNodeDefaultValue((xmlNodePtr)cur);
1162 return(cur);
1167 * @cur: pointer to the document
1172 xmlFreeDoc(xmlDocPtr cur) {
1176 if (cur == NULL) {
1185 xmlDebugCheckDocument(stderr, cur);
1189 if (cur != NULL) dict = cur->dict;
1192 xmlDeregisterNodeDefaultValue((xmlNodePtr)cur);
1197 if (cur->ids != NULL) xmlFreeIDTable((xmlIDTablePtr) cur->ids);
1198 cur->ids = NULL;
1199 if (cur->refs != NULL) xmlFreeRefTable((xmlRefTablePtr) cur->refs);
1200 cur->refs = NULL;
1201 extSubset = cur->extSubset;
1202 intSubset = cur->intSubset;
1206 xmlUnlinkNode((xmlNodePtr) cur->extSubset);
1207 cur->extSubset = NULL;
1211 xmlUnlinkNode((xmlNodePtr) cur->intSubset);
1212 cur->intSubset = NULL;
1216 if (cur->children != NULL) xmlFreeNodeList(cur->children);
1217 if (cur->oldNs != NULL) xmlFreeNsList(cur->oldNs);
1219 DICT_FREE(cur->version)
1220 DICT_FREE(cur->name)
1221 DICT_FREE(cur->encoding)
1222 DICT_FREE(cur->URL)
1223 xmlFree(cur);
1242 const xmlChar *cur = value, *end = cur + len;
1248 q = cur;
1249 while ((cur < end) && (*cur != 0)) {
1250 if (cur[0] == '&') {
1257 if (cur != q) {
1259 xmlNodeAddContentLen(last, q, cur - q);
1261 node = xmlNewDocTextLen(doc, q, cur - q);
1272 q = cur;
1273 if ((cur + 2 < end) && (cur[1] == '#') && (cur[2] == 'x')) {
1274 cur += 3;
1275 if (cur < end)
1276 tmp = *cur;
1292 cur++;
1293 if (cur < end)
1294 tmp = *cur;
1299 cur++;
1300 q = cur;
1301 } else if ((cur + 1 < end) && (cur[1] == '#')) {
1302 cur += 2;
1303 if (cur < end)
1304 tmp = *cur;
1316 cur++;
1317 if (cur < end)
1318 tmp = *cur;
1323 cur++;
1324 q = cur;
1329 cur++;
1330 q = cur;
1331 while ((cur < end) && (*cur != 0) && (*cur != ';')) cur++;
1332 if ((cur >= end) || (*cur == 0)) {
1337 if (cur != q) {
1341 val = xmlStrndup(q, cur - q);
1384 cur++;
1385 q = cur;
1404 cur++;
1406 if ((cur != q) || (ret == NULL)) {
1411 xmlNodeAddContentLen(last, q, cur - q);
1413 node = xmlNewDocTextLen(doc, q, cur - q);
1439 const xmlChar *cur = value;
1445 q = cur;
1446 while (*cur != 0) {
1447 if (cur[0] == '&') {
1454 if (cur != q) {
1456 xmlNodeAddContentLen(last, q, cur - q);
1458 node = xmlNewDocTextLen(doc, q, cur - q);
1469 q = cur;
1470 if ((cur[1] == '#') && (cur[2] == 'x')) {
1471 cur += 3;
1472 tmp = *cur;
1486 cur++;
1487 tmp = *cur;
1490 cur++;
1491 q = cur;
1492 } else if (cur[1] == '#') {
1493 cur += 2;
1494 tmp = *cur;
1504 cur++;
1505 tmp = *cur;
1508 cur++;
1509 q = cur;
1514 cur++;
1515 q = cur;
1516 while ((*cur != 0) && (*cur != ';')) cur++;
1517 if (*cur == 0) {
1522 if (cur != q) {
1526 val = xmlStrndup(q, cur - q);
1568 cur++;
1569 q = cur;
1589 cur++;
1591 if ((cur != q) || (ret == NULL)) {
1596 xmlNodeAddContentLen(last, q, cur - q);
1598 node = xmlNewDocTextLen(doc, q, cur - q);
1779 xmlAttrPtr cur;
1791 cur = (xmlAttrPtr) xmlMalloc(sizeof(xmlAttr));
1792 if (cur == NULL) {
1798 memset(cur, 0, sizeof(xmlAttr));
1799 cur->type = XML_ATTRIBUTE_NODE;
1801 cur->parent = node;
1804 cur->doc = doc;
1806 cur->ns = ns;
1810 cur->name = (xmlChar *) xmlDictLookup(doc->dict, name, -1);
1812 cur->name = xmlStrdup(name);
1814 cur->name = name;
1821 cur->children = xmlStringGetNodeList(doc, buffer);
1822 cur->last = NULL;
1823 tmp = cur->children;
1825 tmp->parent = (xmlNodePtr) cur;
1827 cur->last = tmp;
1838 node->properties = cur;
1844 prev->next = cur;
1845 cur->prev = prev;
1849 if (xmlIsID((node == NULL) ? NULL : node->doc, node, cur) == 1)
1850 xmlAddID(NULL, node->doc, value, cur);
1853 xmlRegisterNodeDefaultValue((xmlNodePtr) cur);
1854 return (cur);
1944 xmlAttrPtr cur;
1957 cur = (xmlAttrPtr) xmlMalloc(sizeof(xmlAttr));
1958 if (cur == NULL) {
1962 memset(cur, 0, sizeof(xmlAttr));
1963 cur->type = XML_ATTRIBUTE_NODE;
1966 cur->name = xmlDictLookup(doc->dict, name, -1);
1968 cur->name = xmlStrdup(name);
1969 cur->doc = doc;
1973 cur->children = xmlStringGetNodeList(doc, value);
1974 cur->last = NULL;
1976 tmp = cur->children;
1978 tmp->parent = (xmlNodePtr) cur;
1980 cur->last = tmp;
1986 xmlRegisterNodeDefaultValue((xmlNodePtr)cur);
1987 return(cur);
1992 * @cur: the first property in the list
1997 xmlFreePropList(xmlAttrPtr cur) {
1999 if (cur == NULL) return;
2000 while (cur != NULL) {
2001 next = cur->next;
2002 xmlFreeProp(cur);
2003 cur = next;
2009 * @cur: an attribute
2014 xmlFreeProp(xmlAttrPtr cur) {
2016 if (cur == NULL) return;
2018 if (cur->doc != NULL) dict = cur->doc->dict;
2021 xmlDeregisterNodeDefaultValue((xmlNodePtr)cur);
2024 if ((cur->doc != NULL) && (cur->atype == XML_ATTRIBUTE_ID)) {
2025 xmlRemoveID(cur->doc, cur);
2027 if (cur->children != NULL) xmlFreeNodeList(cur->children);
2028 DICT_FREE(cur->name)
2029 xmlFree(cur);
2034 * @cur: an attribute
2042 xmlRemoveProp(xmlAttrPtr cur) {
2044 if (cur == NULL) {
2047 "xmlRemoveProp : cur == NULL\n");
2051 if (cur->parent == NULL) {
2054 "xmlRemoveProp : cur->parent == NULL\n");
2058 tmp = cur->parent->properties;
2059 if (tmp == cur) {
2060 cur->parent->properties = cur->next;
2061 if (cur->next != NULL)
2062 cur->next->prev = NULL;
2063 xmlFreeProp(cur);
2067 if (tmp->next == cur) {
2068 tmp->next = cur->next;
2071 xmlFreeProp(cur);
2094 xmlNodePtr cur;
2107 cur = (xmlNodePtr) xmlMalloc(sizeof(xmlNode));
2108 if (cur == NULL) {
2112 memset(cur, 0, sizeof(xmlNode));
2113 cur->type = XML_PI_NODE;
2116 cur->name = xmlDictLookup(doc->dict, name, -1);
2118 cur->name = xmlStrdup(name);
2120 cur->content = xmlStrdup(content);
2122 cur->doc = doc;
2125 xmlRegisterNodeDefaultValue((xmlNodePtr)cur);
2126 return(cur);
2156 xmlNodePtr cur;
2169 cur = (xmlNodePtr) xmlMalloc(sizeof(xmlNode));
2170 if (cur == NULL) {
2174 memset(cur, 0, sizeof(xmlNode));
2175 cur->type = XML_ELEMENT_NODE;
2177 cur->name = xmlStrdup(name);
2178 cur->ns = ns;
2181 xmlRegisterNodeDefaultValue(cur);
2182 return(cur);
2198 xmlNodePtr cur;
2211 cur = (xmlNodePtr) xmlMalloc(sizeof(xmlNode));
2212 if (cur == NULL) {
2217 memset(cur, 0, sizeof(xmlNode));
2218 cur->type = XML_ELEMENT_NODE;
2220 cur->name = name;
2221 cur->ns = ns;
2224 xmlRegisterNodeDefaultValue((xmlNodePtr)cur);
2225 return(cur);
2247 xmlNodePtr cur;
2250 cur = xmlNewNodeEatName(ns, (xmlChar *)
2253 cur = xmlNewNode(ns, name);
2254 if (cur != NULL) {
2255 cur->doc = doc;
2257 cur->children = xmlStringGetNodeList(doc, content);
2258 UPDATE_LAST_CHILD_AND_PARENT(cur)
2262 return(cur);
2284 xmlNodePtr cur;
2286 cur = xmlNewNodeEatName(ns, name);
2287 if (cur != NULL) {
2288 cur->doc = doc;
2290 cur->children = xmlStringGetNodeList(doc, content);
2291 UPDATE_LAST_CHILD_AND_PARENT(cur)
2294 return(cur);
2313 xmlNodePtr cur;
2315 cur = xmlNewDocNode(doc, ns, name, NULL);
2316 if (cur != NULL) {
2317 cur->doc = doc;
2319 cur->children = xmlNewDocText(doc, content);
2320 UPDATE_LAST_CHILD_AND_PARENT(cur)
2323 return(cur);
2335 xmlNodePtr cur;
2340 cur = (xmlNodePtr) xmlMalloc(sizeof(xmlNode));
2341 if (cur == NULL) {
2345 memset(cur, 0, sizeof(xmlNode));
2346 cur->type = XML_DOCUMENT_FRAG_NODE;
2348 cur->doc = doc;
2351 xmlRegisterNodeDefaultValue(cur);
2352 return(cur);
2365 xmlNodePtr cur;
2370 cur = (xmlNodePtr) xmlMalloc(sizeof(xmlNode));
2371 if (cur == NULL) {
2375 memset(cur, 0, sizeof(xmlNode));
2376 cur->type = XML_TEXT_NODE;
2378 cur->name = xmlStringText;
2380 cur->content = xmlStrdup(content);
2384 xmlRegisterNodeDefaultValue(cur);
2385 return(cur);
2411 xmlNodePtr cur, prev;
2434 cur = xmlNewDocRawNode(parent->doc, parent->ns, name, content);
2436 cur = xmlNewDocRawNode(parent->doc, ns, name, content);
2440 cur = xmlNewDocRawNode((xmlDocPtr) parent, NULL, name, content);
2442 cur = xmlNewDocRawNode((xmlDocPtr) parent, ns, name, content);
2444 cur = xmlNewDocRawNode( parent->doc, ns, name, content);
2448 if (cur == NULL) return(NULL);
2453 cur->type = XML_ELEMENT_NODE;
2454 cur->parent = parent;
2455 cur->doc = parent->doc;
2457 parent->children = cur;
2458 parent->last = cur;
2461 prev->next = cur;
2462 cur->prev = prev;
2463 parent->last = cur;
2466 return(cur);
2480 xmlNodePtr cur;
2488 cur = (xmlNodePtr) xmlMalloc(sizeof(xmlNode));
2489 if (cur == NULL) {
2493 memset(cur, 0, sizeof(xmlNode));
2494 cur->type = XML_ENTITY_REF_NODE;
2496 cur->doc = doc;
2502 cur->name = xmlStrndup(name, len - 1);
2504 cur->name = xmlStrndup(name, len);
2506 cur->name = xmlStrdup(name);
2509 xmlRegisterNodeDefaultValue(cur);
2510 return(cur);
2523 xmlNodePtr cur;
2532 cur = (xmlNodePtr) xmlMalloc(sizeof(xmlNode));
2533 if (cur == NULL) {
2537 memset(cur, 0, sizeof(xmlNode));
2538 cur->type = XML_ENTITY_REF_NODE;
2540 cur->doc = doc;
2546 cur->name = xmlStrndup(name, len - 1);
2548 cur->name = xmlStrndup(name, len);
2550 cur->name = xmlStrdup(name);
2552 ent = xmlGetDocEntity(doc, cur->name);
2554 cur->content = ent->content;
2560 cur->children = (xmlNodePtr) ent;
2561 cur->last = (xmlNodePtr) ent;
2565 xmlRegisterNodeDefaultValue(cur);
2566 return(cur);
2579 xmlNodePtr cur;
2581 cur = xmlNewText(content);
2582 if (cur != NULL) cur->doc = doc;
2583 return(cur);
2596 xmlNodePtr cur;
2601 cur = (xmlNodePtr) xmlMalloc(sizeof(xmlNode));
2602 if (cur == NULL) {
2606 memset(cur, 0, sizeof(xmlNode));
2607 cur->type = XML_TEXT_NODE;
2609 cur->name = xmlStringText;
2611 cur->content = xmlStrndup(content, len);
2615 xmlRegisterNodeDefaultValue(cur);
2616 return(cur);
2631 xmlNodePtr cur;
2633 cur = xmlNewTextLen(content, len);
2634 if (cur != NULL) cur->doc = doc;
2635 return(cur);
2647 xmlNodePtr cur;
2652 cur = (xmlNodePtr) xmlMalloc(sizeof(xmlNode));
2653 if (cur == NULL) {
2657 memset(cur, 0, sizeof(xmlNode));
2658 cur->type = XML_COMMENT_NODE;
2660 cur->name = xmlStringComment;
2662 cur->content = xmlStrdup(content);
2666 xmlRegisterNodeDefaultValue(cur);
2667 return(cur);
2681 xmlNodePtr cur;
2686 cur = (xmlNodePtr) xmlMalloc(sizeof(xmlNode));
2687 if (cur == NULL) {
2691 memset(cur, 0, sizeof(xmlNode));
2692 cur->type = XML_CDATA_SECTION_NODE;
2693 cur->doc = doc;
2696 cur->content = xmlStrndup(content, len);
2700 xmlRegisterNodeDefaultValue(cur);
2701 return(cur);
2714 xmlNodePtr cur;
2716 cur = xmlNewComment(content);
2717 if (cur != NULL) cur->doc = doc;
2718 return(cur);
2758 xmlNodePtr cur;
2762 cur = list;
2763 while (cur != NULL) {
2764 if (cur->doc != doc)
2765 xmlSetTreeDoc(cur, doc);
2766 cur = cur->next;
2791 xmlNodePtr cur, prev;
2814 cur = xmlNewDocNode(parent->doc, parent->ns, name, content);
2816 cur = xmlNewDocNode(parent->doc, ns, name, content);
2820 cur = xmlNewDocNode((xmlDocPtr) parent, NULL, name, content);
2822 cur = xmlNewDocNode((xmlDocPtr) parent, ns, name, content);
2824 cur = xmlNewDocNode( parent->doc, ns, name, content);
2828 if (cur == NULL) return(NULL);
2833 cur->type = XML_ELEMENT_NODE;
2834 cur->parent = parent;
2835 cur->doc = parent->doc;
2837 parent->children = cur;
2838 parent->last = cur;
2841 prev->next = cur;
2842 cur->prev = prev;
2843 parent->last = cur;
2846 return(cur);
2853 * @cur: the base attribute passed to calling function
2856 * Add a new attribute after @prev using @cur as base attribute.
2857 * When inserting before @cur, @prev is passed as @cur->prev.
2858 * When inserting after @cur, @prev is passed as @cur.
2864 xmlAddPropSibling(xmlNodePtr prev, xmlNodePtr cur, xmlNodePtr prop) {
2867 if (cur->type != XML_ATTRIBUTE_NODE)
2872 attr = xmlHasNsProp(cur->parent, prop->name, NULL);
2874 attr = xmlHasNsProp(cur->parent, prop->name, prop->ns->href);
2876 if (prop->doc != cur->doc) {
2877 xmlSetTreeDoc(prop, cur->doc);
2879 prop->parent = cur->parent;
2887 prop->next = cur;
2888 cur->prev = prop;
2901 * @cur: the child node
2904 * Add a new node @elem as the next sibling of @cur
2914 xmlAddNextSibling(xmlNodePtr cur, xmlNodePtr elem) {
2915 if (cur == NULL) {
2918 "xmlAddNextSibling : cur == NULL\n");
2930 if (cur == elem) {
2933 "xmlAddNextSibling : cur == elem\n");
2941 if (cur->type == XML_TEXT_NODE) {
2942 xmlNodeAddContent(cur, elem->content);
2944 return(cur);
2946 if ((cur->next != NULL) && (cur->next->type == XML_TEXT_NODE) &&
2947 (cur->name == cur->next->name)) {
2951 tmp = xmlStrcat(tmp, cur->next->content);
2952 xmlNodeSetContent(cur->next, tmp);
2955 return(cur->next);
2958 return xmlAddPropSibling(cur, cur, elem);
2961 if (elem->doc != cur->doc) {
2962 xmlSetTreeDoc(elem, cur->doc);
2964 elem->parent = cur->parent;
2965 elem->prev = cur;
2966 elem->next = cur->next;
2967 cur->next = elem;
2970 if ((elem->parent != NULL) && (elem->parent->last == cur))
2979 * @cur: the child node
2982 * Add a new node @elem as the previous sibling of @cur
2992 xmlAddPrevSibling(xmlNodePtr cur, xmlNodePtr elem) {
2993 if (cur == NULL) {
2996 "xmlAddPrevSibling : cur == NULL\n");
3008 if (cur == elem) {
3011 "xmlAddPrevSibling : cur == elem\n");
3019 if (cur->type == XML_TEXT_NODE) {
3023 tmp = xmlStrcat(tmp, cur->content);
3024 xmlNodeSetContent(cur, tmp);
3027 return(cur);
3029 if ((cur->prev != NULL) && (cur->prev->type == XML_TEXT_NODE) &&
3030 (cur->name == cur->prev->name)) {
3031 xmlNodeAddContent(cur->prev, elem->content);
3033 return(cur->prev);
3036 return xmlAddPropSibling(cur->prev, cur, elem);
3039 if (elem->doc != cur->doc) {
3040 xmlSetTreeDoc(elem, cur->doc);
3042 elem->parent = cur->parent;
3043 elem->next = cur;
3044 elem->prev = cur->prev;
3045 cur->prev = elem;
3048 if ((elem->parent != NULL) && (elem->parent->children == cur)) {
3057 * @cur: the child node
3060 * Add a new element @elem to the list of siblings of @cur
3068 xmlAddSibling(xmlNodePtr cur, xmlNodePtr elem) {
3071 if (cur == NULL) {
3074 "xmlAddSibling : cur == NULL\n");
3091 if ((cur->type != XML_ATTRIBUTE_NODE) && (cur->parent != NULL) &&
3092 (cur->parent->children != NULL) &&
3093 (cur->parent->last != NULL) &&
3094 (cur->parent->last->next == NULL)) {
3095 cur = cur->parent->last;
3097 while (cur->next != NULL) cur = cur->next;
3102 if ((cur->type == XML_TEXT_NODE) && (elem->type == XML_TEXT_NODE) &&
3103 (cur->name == elem->name)) {
3104 xmlNodeAddContent(cur, elem->content);
3106 return(cur);
3108 return xmlAddPropSibling(cur, cur, elem);
3111 if (elem->doc != cur->doc) {
3112 xmlSetTreeDoc(elem, cur->doc);
3114 parent = cur->parent;
3115 elem->prev = cur;
3118 cur->next = elem;
3128 * @cur: the first node in the list
3131 * merging adjacent TEXT nodes (@cur may be freed)
3136 xmlAddChildList(xmlNodePtr parent, xmlNodePtr cur) {
3147 if (cur == NULL) {
3155 if ((cur->doc != NULL) && (parent->doc != NULL) &&
3156 (cur->doc != parent->doc)) {
3168 parent->children = cur;
3171 * If cur and parent->last both are TEXT nodes, then merge them.
3173 if ((cur->type == XML_TEXT_NODE) &&
3175 (cur->name == parent->last->name)) {
3176 xmlNodeAddContent(parent->last, cur->content);
3180 if (cur->next == NULL) {
3181 xmlFreeNode(cur);
3184 prev = cur;
3185 cur = cur->next;
3189 prev->next = cur;
3190 cur->prev = prev;
3192 while (cur->next != NULL) {
3193 cur->parent = parent;
3194 if (cur->doc != parent->doc) {
3195 xmlSetTreeDoc(cur, parent->doc);
3197 cur = cur->next;
3199 cur->parent = parent;
3200 cur->doc = parent->doc; /* the parent may not be linked to a doc ! */
3201 parent->last = cur;
3203 return(cur);
3209 * @cur: the child node
3212 * merging adjacent TEXT nodes (in which case @cur is freed)
3219 xmlAddChild(xmlNodePtr parent, xmlNodePtr cur) {
3230 if (cur == NULL) {
3238 if (parent == cur) {
3241 "xmlAddChild : parent == cur\n");
3246 * If cur is a TEXT node, merge its content with adjacent TEXT nodes
3247 * cur is then freed.
3249 if (cur->type == XML_TEXT_NODE) {
3252 (parent->name == cur->name)) {
3253 xmlNodeAddContent(parent, cur->content);
3254 xmlFreeNode(cur);
3258 (parent->last->name == cur->name) &&
3259 (parent->last != cur)) {
3260 xmlNodeAddContent(parent->last, cur->content);
3261 xmlFreeNode(cur);
3269 prev = cur->parent;
3270 cur->parent = parent;
3271 if (cur->doc != parent->doc) {
3272 xmlSetTreeDoc(cur, parent->doc);
3278 return(cur);
3285 (parent != cur)) {
3286 xmlNodeAddContent(parent, cur->content);
3287 xmlFreeNode(cur);
3290 if (cur->type == XML_ATTRIBUTE_NODE) {
3294 parent->properties = (xmlAttrPtr) cur;
3299 if (cur->ns == NULL)
3300 lastattr = xmlHasNsProp(parent, cur->name, NULL);
3302 lastattr = xmlHasNsProp(parent, cur->name, cur->ns->href);
3303 if ((lastattr != NULL) && (lastattr != (xmlAttrPtr) cur) && (lastattr->type != XML_ATTRIBUTE_DECL)) {
3308 if (lastattr == (xmlAttrPtr) cur)
3309 return(cur);
3315 lastattr->next = (xmlAttrPtr) cur;
3316 ((xmlAttrPtr) cur)->prev = lastattr;
3320 parent->children = cur;
3321 parent->last = cur;
3324 prev->next = cur;
3325 cur->prev = prev;
3326 parent->last = cur;
3329 return(cur);
3353 * @cur: the first node in the list
3359 xmlFreeNodeList(xmlNodePtr cur) {
3363 if (cur == NULL) return;
3364 if (cur->type == XML_NAMESPACE_DECL) {
3365 xmlFreeNsList((xmlNsPtr) cur);
3368 if ((cur->type == XML_DOCUMENT_NODE) ||
3370 (cur->type == XML_DOCB_DOCUMENT_NODE) ||
3372 (cur->type == XML_HTML_DOCUMENT_NODE)) {
3373 xmlFreeDoc((xmlDocPtr) cur);
3376 if (cur->doc != NULL) dict = cur->doc->dict;
3377 while (cur != NULL) {
3378 next = cur->next;
3379 if (cur->type != XML_DTD_NODE) {
3382 xmlDeregisterNodeDefaultValue(cur);
3384 if ((cur->children != NULL) &&
3385 (cur->type != XML_ENTITY_REF_NODE))
3386 xmlFreeNodeList(cur->children);
3387 if (((cur->type == XML_ELEMENT_NODE) ||
3388 (cur->type == XML_XINCLUDE_START) ||
3389 (cur->type == XML_XINCLUDE_END)) &&
3390 (cur->properties != NULL))
3391 xmlFreePropList(cur->properties);
3392 if ((cur->type != XML_ELEMENT_NODE) &&
3393 (cur->type != XML_XINCLUDE_START) &&
3394 (cur->type != XML_XINCLUDE_END) &&
3395 (cur->type != XML_ENTITY_REF_NODE) &&
3396 (cur->content != (xmlChar *) &(cur->properties))) {
3397 DICT_FREE(cur->content)
3399 if (((cur->type == XML_ELEMENT_NODE) ||
3400 (cur->type == XML_XINCLUDE_START) ||
3401 (cur->type == XML_XINCLUDE_END)) &&
3402 (cur->nsDef != NULL))
3403 xmlFreeNsList(cur->nsDef);
3411 if ((cur->name != NULL) &&
3412 (cur->type != XML_TEXT_NODE) &&
3413 (cur->type != XML_COMMENT_NODE))
3414 DICT_FREE(cur->name)
3415 xmlFree(cur);
3417 cur = next;
3423 * @cur: the node
3429 xmlFreeNode(xmlNodePtr cur) {
3432 if (cur == NULL) return;
3435 if (cur->type == XML_DTD_NODE) {
3436 xmlFreeDtd((xmlDtdPtr) cur);
3439 if (cur->type == XML_NAMESPACE_DECL) {
3440 xmlFreeNs((xmlNsPtr) cur);
3443 if (cur->type == XML_ATTRIBUTE_NODE) {
3444 xmlFreeProp((xmlAttrPtr) cur);
3449 xmlDeregisterNodeDefaultValue(cur);
3451 if (cur->doc != NULL) dict = cur->doc->dict;
3453 if ((cur->children != NULL) &&
3454 (cur->type != XML_ENTITY_REF_NODE))
3455 xmlFreeNodeList(cur->children);
3456 if (((cur->type == XML_ELEMENT_NODE) ||
3457 (cur->type == XML_XINCLUDE_START) ||
3458 (cur->type == XML_XINCLUDE_END)) &&
3459 (cur->properties != NULL))
3460 xmlFreePropList(cur->properties);
3461 if ((cur->type != XML_ELEMENT_NODE) &&
3462 (cur->content != NULL) &&
3463 (cur->type != XML_ENTITY_REF_NODE) &&
3464 (cur->type != XML_XINCLUDE_END) &&
3465 (cur->type != XML_XINCLUDE_START) &&
3466 (cur->content != (xmlChar *) &(cur->properties))) {
3467 DICT_FREE(cur->content)
3475 if ((cur->name != NULL) &&
3476 (cur->type != XML_TEXT_NODE) &&
3477 (cur->type != XML_COMMENT_NODE))
3478 DICT_FREE(cur->name)
3480 if (((cur->type == XML_ELEMENT_NODE) ||
3481 (cur->type == XML_XINCLUDE_START) ||
3482 (cur->type == XML_XINCLUDE_END)) &&
3483 (cur->nsDef != NULL))
3484 xmlFreeNsList(cur->nsDef);
3485 xmlFree(cur);
3490 * @cur: the node
3495 xmlUnlinkNode(xmlNodePtr cur) {
3496 if (cur == NULL) {
3503 if (cur->type == XML_DTD_NODE) {
3505 doc = cur->doc;
3507 if (doc->intSubset == (xmlDtdPtr) cur)
3509 if (doc->extSubset == (xmlDtdPtr) cur)
3513 if (cur->parent != NULL) {
3515 parent = cur->parent;
3516 if (cur->type == XML_ATTRIBUTE_NODE) {
3517 if (parent->properties == (xmlAttrPtr) cur)
3518 parent->properties = ((xmlAttrPtr) cur)->next;
3520 if (parent->children == cur)
3521 parent->children = cur->next;
3522 if (parent->last == cur)
3523 parent->last = cur->prev;
3525 cur->parent = NULL;
3527 if (cur->next != NULL)
3528 cur->next->prev = cur->prev;
3529 if (cur->prev != NULL)
3530 cur->prev->next = cur->next;
3531 cur->next = cur->prev = NULL;
3538 * @cur: the node
3541 * at the same place. If @cur was already inserted in a document it is
3547 xmlReplaceNode(xmlNodePtr old, xmlNodePtr cur) {
3548 if (old == cur) return(NULL);
3556 if (cur == NULL) {
3560 if (cur == old) {
3563 if ((old->type==XML_ATTRIBUTE_NODE) && (cur->type!=XML_ATTRIBUTE_NODE)) {
3570 if ((cur->type==XML_ATTRIBUTE_NODE) && (old->type!=XML_ATTRIBUTE_NODE)) {
3577 xmlUnlinkNode(cur);
3578 xmlSetTreeDoc(cur, old->doc);
3579 cur->parent = old->parent;
3580 cur->next = old->next;
3581 if (cur->next != NULL)
3582 cur->next->prev = cur;
3583 cur->prev = old->prev;
3584 if (cur->prev != NULL)
3585 cur->prev->next = cur;
3586 if (cur->parent != NULL) {
3587 if (cur->type == XML_ATTRIBUTE_NODE) {
3588 if (cur->parent->properties == (xmlAttrPtr)old)
3589 cur->parent->properties = ((xmlAttrPtr) cur);
3591 if (cur->parent->children == old)
3592 cur->parent->children = cur;
3593 if (cur->parent->last == old)
3594 cur->parent->last = cur;
3611 * @cur: the namespace
3618 xmlCopyNamespace(xmlNsPtr cur) {
3621 if (cur == NULL) return(NULL);
3622 switch (cur->type) {
3624 ret = xmlNewNs(NULL, cur->href, cur->prefix);
3629 "xmlCopyNamespace: invalid type %d\n", cur->type);
3638 * @cur: the first namespace
3645 xmlCopyNamespaceList(xmlNsPtr cur) {
3649 while (cur != NULL) {
3650 q = xmlCopyNamespace(cur);
3657 cur = cur->next;
3666 xmlCopyPropInternal(xmlDocPtr doc, xmlNodePtr target, xmlAttrPtr cur) {
3669 if (cur == NULL) return(NULL);
3671 ret = xmlNewDocProp(target->doc, cur->name, NULL);
3673 ret = xmlNewDocProp(doc, cur->name, NULL);
3674 else if (cur->parent != NULL)
3675 ret = xmlNewDocProp(cur->parent->doc, cur->name, NULL);
3676 else if (cur->children != NULL)
3677 ret = xmlNewDocProp(cur->children->doc, cur->name, NULL);
3679 ret = xmlNewDocProp(NULL, cur->name, NULL);
3683 if ((cur->ns != NULL) && (target != NULL)) {
3686 ns = xmlSearchNs(target->doc, target, cur->ns->prefix);
3693 ns = xmlSearchNs(cur->doc, cur->parent, cur->ns->prefix);
3714 if (xmlStrEqual(ns->href, cur->ns->href)) {
3722 ret->ns = xmlNewReconciliedNs(target->doc, target, cur->ns);
3729 if (cur->children != NULL) {
3732 ret->children = xmlStaticCopyNodeList(cur->children, ret->doc, (xmlNodePtr) ret);
3745 if ((target!= NULL) && (cur!= NULL) &&
3746 (target->doc != NULL) && (cur->doc != NULL) &&
3747 (cur->doc->ids != NULL) && (cur->parent != NULL)) {
3748 if (xmlIsID(cur->doc, cur->parent, cur)) {
3751 id = xmlNodeListGetString(cur->doc, cur->children, 1);
3764 * @cur: the attribute
3771 xmlCopyProp(xmlNodePtr target, xmlAttrPtr cur) {
3772 return xmlCopyPropInternal(NULL, target, cur);
3778 * @cur: the first attribute
3785 xmlCopyPropList(xmlNodePtr target, xmlAttrPtr cur) {
3789 while (cur != NULL) {
3790 q = xmlCopyProp(target, cur);
3800 cur = cur->next;
4091 xmlNodePtr cur, p = NULL, q;
4112 cur = dtd->children;
4113 while (cur != NULL) {
4116 if (cur->type == XML_ENTITY_DECL) {
4117 xmlEntityPtr tmp = (xmlEntityPtr) cur;
4132 } else if (cur->type == XML_ELEMENT_DECL) {
4133 xmlElementPtr tmp = (xmlElementPtr) cur;
4136 } else if (cur->type == XML_ATTRIBUTE_DECL) {
4137 xmlAttributePtr tmp = (xmlAttributePtr) cur;
4140 } else if (cur->type == XML_COMMENT_NODE) {
4141 q = xmlCopyNode(cur, 0);
4145 cur = cur->next;
4159 cur = cur->next;
4276 xmlNodePtr cur, tmp, next;
4302 cur = node;
4307 if ((cur->type == XML_DOCUMENT_NODE) ||
4308 (cur->type == XML_HTML_DOCUMENT_NODE)) {
4313 } else if (cur->type == XML_ELEMENT_NODE) {
4316 name = (const char *) cur->name;
4317 if (cur->ns) {
4318 if (cur->ns->prefix != NULL) {
4320 (char *)cur->ns->prefix, (char *)cur->name);
4332 next = cur->parent;
4338 tmp = cur->prev;
4342 (xmlStrEqual(cur->name, tmp->name) &&
4343 ((tmp->ns == cur->ns) ||
4344 ((tmp->ns != NULL) && (cur->ns != NULL) &&
4345 (xmlStrEqual(cur->ns->prefix, tmp->ns->prefix)))))))
4350 tmp = cur->next;
4354 (xmlStrEqual(cur->name, tmp->name) &&
4355 ((tmp->ns == cur->ns) ||
4356 ((tmp->ns != NULL) && (cur->ns != NULL) &&
4357 (xmlStrEqual(cur->ns->prefix, tmp->ns->prefix)))))))
4365 } else if (cur->type == XML_COMMENT_NODE) {
4368 next = cur->parent;
4373 tmp = cur->prev;
4380 tmp = cur->next;
4390 } else if ((cur->type == XML_TEXT_NODE) ||
4391 (cur->type == XML_CDATA_SECTION_NODE)) {
4394 next = cur->parent;
4399 tmp = cur->prev;
4411 tmp = cur->next;
4423 } else if (cur->type == XML_PI_NODE) {
4426 "processing-instruction('%s')", (char *)cur->name);
4430 next = cur->parent;
4435 tmp = cur->prev;
4438 (xmlStrEqual(cur->name, tmp->name)))
4443 tmp = cur->next;
4446 (xmlStrEqual(cur->name, tmp->name)))
4455 } else if (cur->type == XML_ATTRIBUTE_NODE) {
4457 name = (const char *) (((xmlAttrPtr) cur)->name);
4458 if (cur->ns) {
4459 if (cur->ns->prefix != NULL)
4461 (char *)cur->ns->prefix, (char *)cur->name);
4464 (char *)cur->name);
4468 next = ((xmlAttrPtr) cur)->parent;
4470 next = cur->parent;
4503 cur = next;
4504 } while (cur != NULL);
4578 * @cur: the node being changed
4585 xmlNodeSetLang(xmlNodePtr cur, const xmlChar *lang) {
4588 if (cur == NULL) return;
4589 switch(cur->type) {
4616 ns = xmlSearchNsByHref(cur->doc, cur, XML_XML_NAMESPACE);
4619 xmlSetNsProp(cur, ns, BAD_CAST "lang", lang);
4625 * @cur: the node being checked
4634 xmlNodeGetLang(xmlNodePtr cur) {
4637 while (cur != NULL) {
4638 lang = xmlGetNsProp(cur, BAD_CAST "lang", XML_XML_NAMESPACE);
4641 cur = cur->parent;
4650 * @cur: the node being changed
4657 xmlNodeSetSpacePreserve(xmlNodePtr cur, int val) {
4660 if (cur == NULL) return;
4661 switch(cur->type) {
4688 ns = xmlSearchNsByHref(cur->doc, cur, XML_XML_NAMESPACE);
4693 xmlSetNsProp(cur, ns, BAD_CAST "space", BAD_CAST "default");
4696 xmlSetNsProp(cur, ns, BAD_CAST "space", BAD_CAST "preserve");
4704 * @cur: the node being checked
4713 xmlNodeGetSpacePreserve(xmlNodePtr cur) {
4716 while (cur != NULL) {
4717 space = xmlGetNsProp(cur, BAD_CAST "space", XML_XML_NAMESPACE);
4729 cur = cur->parent;
4737 * @cur: the node being changed
4743 xmlNodeSetName(xmlNodePtr cur, const xmlChar *name) {
4747 if (cur == NULL) return;
4749 switch(cur->type) {
4776 doc = cur->doc;
4782 if ((cur->name != NULL) && (!xmlDictOwns(dict, cur->name)))
4783 xmlFree((xmlChar *) cur->name);
4784 cur->name = xmlDictLookup(dict, name, -1);
4786 if (cur->name != NULL) xmlFree((xmlChar *) cur->name);
4787 cur->name = xmlStrdup(name);
4795 * @cur: the node being changed
4802 xmlNodeSetBase(xmlNodePtr cur, const xmlChar* uri) {
4806 if (cur == NULL) return;
4807 switch(cur->type) {
4833 xmlDocPtr doc = (xmlDocPtr) cur;
4845 ns = xmlSearchNsByHref(cur->doc, cur, XML_XML_NAMESPACE);
4850 xmlSetNsProp(cur, ns, BAD_CAST "base", fixed);
4853 xmlSetNsProp(cur, ns, BAD_CAST "base", uri);
4861 * @cur: the node being checked
4876 xmlNodeGetBase(xmlDocPtr doc, xmlNodePtr cur) {
4880 if ((cur == NULL) && (doc == NULL))
4882 if (doc == NULL) doc = cur->doc;
4884 cur = doc->children;
4885 while ((cur != NULL) && (cur->name != NULL)) {
4886 if (cur->type != XML_ELEMENT_NODE) {
4887 cur = cur->next;
4890 if (!xmlStrcasecmp(cur->name, BAD_CAST "html")) {
4891 cur = cur->children;
4894 if (!xmlStrcasecmp(cur->name, BAD_CAST "head")) {
4895 cur = cur->children;
4898 if (!xmlStrcasecmp(cur->name, BAD_CAST "base")) {
4899 return(xmlGetProp(cur, BAD_CAST "href"));
4901 cur = cur->next;
4905 while (cur != NULL) {
4906 if (cur->type == XML_ENTITY_DECL) {
4907 xmlEntityPtr ent = (xmlEntityPtr) cur;
4910 if (cur->type == XML_ELEMENT_NODE) {
4911 base = xmlGetNsProp(cur, BAD_CAST "base", XML_XML_NAMESPACE);
4933 cur = cur->parent;
4948 * @cur: the node being read
4950 * Read the value of a node @cur, this can be either the text carried
4959 xmlNodeBufGetContent(xmlBufferPtr buffer, xmlNodePtr cur)
4961 if ((cur == NULL) || (buffer == NULL)) return(-1);
4962 switch (cur->type) {
4965 xmlBufferCat(buffer, cur->content);
4969 xmlNodePtr tmp = cur;
4993 if (tmp == cur)
5005 if (tmp == cur) {
5018 xmlAttrPtr attr = (xmlAttrPtr) cur;
5032 xmlBufferCat(buffer, cur->content);
5039 ent = xmlGetDocEntity(cur->doc, cur->name);
5067 cur = cur->children;
5068 while (cur!= NULL) {
5069 if ((cur->type == XML_ELEMENT_NODE) ||
5070 (cur->type == XML_TEXT_NODE) ||
5071 (cur->type == XML_CDATA_SECTION_NODE)) {
5072 xmlNodeBufGetContent(buffer, cur);
5074 cur = cur->next;
5078 xmlBufferCat(buffer, ((xmlNsPtr) cur)->href);
5089 * @cur: the node being read
5099 xmlNodeGetContent(xmlNodePtr cur)
5101 if (cur == NULL)
5103 switch (cur->type) {
5112 xmlNodeBufGetContent(buffer, cur);
5119 return(xmlGetPropNodeValueInternal((xmlAttrPtr) cur));
5122 if (cur->content != NULL)
5123 return (xmlStrdup(cur->content));
5131 ent = xmlGetDocEntity(cur->doc, cur->name);
5139 xmlNodeBufGetContent(buffer, cur);
5165 xmlNodeBufGetContent(buffer, (xmlNodePtr) cur);
5175 tmp = xmlStrdup(((xmlNsPtr) cur)->href);
5189 if (cur->content != NULL)
5190 return (xmlStrdup(cur->content));
5198 * @cur: the node being modified
5207 xmlNodeSetContent(xmlNodePtr cur, const xmlChar *content) {
5208 if (cur == NULL) {
5215 switch (cur->type) {
5219 if (cur->children != NULL) xmlFreeNodeList(cur->children);
5220 cur->children = xmlStringGetNodeList(cur->doc, content);
5221 UPDATE_LAST_CHILD_AND_PARENT(cur)
5229 if ((cur->content != NULL) &&
5230 (cur->content != (xmlChar *) &(cur->properties))) {
5231 if (!((cur->doc != NULL) && (cur->doc->dict != NULL) &&
5232 (xmlDictOwns(cur->doc->dict, cur->content))))
5233 xmlFree(cur->content);
5235 if (cur->children != NULL) xmlFreeNodeList(cur->children);
5236 cur->last = cur->children = NULL;
5238 cur->content = xmlStrdup(content);
5240 cur->content = NULL;
5241 cur->properties = NULL;
5242 cur->nsDef = NULL;
5274 * @cur: the node being modified
5284 xmlNodeSetContentLen(xmlNodePtr cur, const xmlChar *content, int len) {
5285 if (cur == NULL) {
5292 switch (cur->type) {
5296 if (cur->children != NULL) xmlFreeNodeList(cur->children);
5297 cur->children = xmlStringLenGetNodeList(cur->doc, content, len);
5298 UPDATE_LAST_CHILD_AND_PARENT(cur)
5307 if ((cur->content != NULL) &&
5308 (cur->content != (xmlChar *) &(cur->properties))) {
5309 if (!((cur->doc != NULL) && (cur->doc->dict != NULL) &&
5310 (xmlDictOwns(cur->doc->dict, cur->content))))
5311 xmlFree(cur->content);
5313 if (cur->children != NULL) xmlFreeNodeList(cur->children);
5314 cur->children = cur->last = NULL;
5316 cur->content = xmlStrndup(content, len);
5318 cur->content = NULL;
5319 cur->properties = NULL;
5320 cur->nsDef = NULL;
5348 * @cur: the node being modified
5358 xmlNodeAddContentLen(xmlNodePtr cur, const xmlChar *content, int len) {
5359 if (cur == NULL) {
5367 switch (cur->type) {
5372 last = cur->last;
5375 tmp = xmlAddChild(cur, newNode);
5394 if ((cur->content == (xmlChar *) &(cur->properties)) ||
5395 ((cur->doc != NULL) && (cur->doc->dict != NULL) &&
5396 xmlDictOwns(cur->doc->dict, cur->content))) {
5397 cur->content = xmlStrncatNew(cur->content, content, len);
5398 cur->properties = NULL;
5399 cur->nsDef = NULL;
5402 cur->content = xmlStrncat(cur->content, content, len);
5424 * @cur: the node being modified
5433 xmlNodeAddContent(xmlNodePtr cur, const xmlChar *content) {
5436 if (cur == NULL) {
5445 xmlNodeAddContentLen(cur, content, len);
5484 xmlNsPtr cur;
5492 cur = node->nsDef;
5493 while (cur != NULL) {
5505 if ((cur->prefix == ret[i]->prefix) ||
5506 (xmlStrEqual(cur->prefix, ret[i]->prefix)))
5521 ret[nbns++] = cur;
5525 cur = cur->next;
5585 xmlNsPtr cur;
5597 cur = (xmlNsPtr) xmlMalloc(sizeof(xmlNs));
5598 if (cur == NULL) {
5602 memset(cur, 0, sizeof(xmlNs));
5603 cur->type = XML_LOCAL_NAMESPACE;
5604 cur->href = xmlStrdup(XML_XML_NAMESPACE);
5605 cur->prefix = xmlStrdup((const xmlChar *)"xml");
5606 cur->next = node->nsDef;
5607 node->nsDef = cur;
5608 return(cur);
5629 cur = node->nsDef;
5630 while (cur != NULL) {
5631 if ((cur->prefix == NULL) && (nameSpace == NULL) &&
5632 (cur->href != NULL))
5633 return(cur);
5634 if ((cur->prefix != NULL) && (nameSpace != NULL) &&
5635 (cur->href != NULL) &&
5636 (xmlStrEqual(cur->prefix, nameSpace)))
5637 return(cur);
5638 cur = cur->next;
5641 cur = node->ns;
5642 if (cur != NULL) {
5643 if ((cur->prefix == NULL) && (nameSpace == NULL) &&
5644 (cur->href != NULL))
5645 return(cur);
5646 if ((cur->prefix != NULL) && (nameSpace != NULL) &&
5647 (cur->href != NULL) &&
5648 (xmlStrEqual(cur->prefix, nameSpace)))
5649 return(cur);
5714 xmlNsPtr cur;
5730 cur = (xmlNsPtr) xmlMalloc(sizeof(xmlNs));
5731 if (cur == NULL) {
5735 memset(cur, 0, sizeof(xmlNs));
5736 cur->type = XML_LOCAL_NAMESPACE;
5737 cur->href = xmlStrdup(XML_XML_NAMESPACE);
5738 cur->prefix = xmlStrdup((const xmlChar *) "xml");
5739 cur->next = node->nsDef;
5740 node->nsDef = cur;
5741 return (cur);
5763 cur = node->nsDef;
5764 while (cur != NULL) {
5765 if ((cur->href != NULL) && (href != NULL) &&
5766 (xmlStrEqual(cur->href, href))) {
5767 if (((!is_attr) || (cur->prefix != NULL)) &&
5768 (xmlNsInScope(doc, orig, node, cur->prefix) == 1))
5769 return (cur);
5771 cur = cur->next;
5774 cur = node->ns;
5775 if (cur != NULL) {
5776 if ((cur->href != NULL) && (href != NULL) &&
5777 (xmlStrEqual(cur->href, href))) {
5778 if (((!is_attr) || (cur->prefix != NULL)) &&
5779 (xmlNsInScope(doc, orig, node, cur->prefix) == 1))
5780 return (cur);
6126 xmlNsPtr *nsList, *cur;
6138 cur = nsList;
6139 while (*cur != NULL) {
6140 if (xmlStrEqual((*cur)->href, nsName)) {
6142 name, (*cur)->prefix);
6147 name, (*cur)->prefix);
6152 cur++;
6522 const xmlChar *cur;
6529 cur = node->content;
6530 while (*cur != 0) {
6531 if (!IS_BLANK_CH(*cur)) return(0);
6532 cur++;
7080 const char *cur;
7092 for (cur = str;*cur != 0;cur++) {
7099 buf->content[buf->use++] = *cur;
7149 const xmlChar *cur, *base;
7160 base = cur = string;
7161 while(*cur != 0){
7162 if(*cur == '"'){
7163 if (base != cur)
7164 xmlBufferAdd(buf, base, cur - base);
7166 cur++;
7167 base = cur;
7170 cur++;
7173 if (base != cur)
7174 xmlBufferAdd(buf, base, cur - base);
7296 xmlNsMapItemPtr cur, tmp;
7300 cur = nsmap->pool;
7301 while (cur != NULL) {
7302 tmp = cur;
7303 cur = cur->next;
7306 cur = nsmap->first;
7307 while (cur != NULL) {
7308 tmp = cur;
7309 cur = cur->next;
7525 xmlNodePtr cur;
7535 cur = node;
7536 while ((cur != NULL) && (cur != (xmlNodePtr) cur->doc)) {
7537 if (cur->type == XML_ELEMENT_NODE) {
7538 if (cur->nsDef != NULL) {
7539 ns = cur->nsDef;
7567 cur = cur->parent;
7597 xmlDictOwns(sourceDoc->dict, cur->content)) { \
7599 cur->content = (xmlChar *) \
7600 xmlDictLookup(destDoc->dict, cur->content, -1); \
7602 cur->content = xmlStrdup(BAD_CAST cur->content); \
7794 xmlNodePtr cur, prev = NULL, out = NULL;
7807 cur = node;
7809 if (cur->type == XML_ELEMENT_NODE) {
7810 if (cur->nsDef != NULL) {
7811 for (ns = cur->nsDef; ns != NULL; ns = ns->next) {
7866 prev = cur;
7868 } else if ((cur->type == XML_ENTITY_NODE) ||
7869 (cur->type == XML_ENTITY_DECL))
7871 cur = cur->parent;
7872 } while ((cur != NULL) && (cur->doc != (xmlDocPtr) cur));
7894 xmlNodePtr cur;
7910 cur = node;
7912 if (cur->type == XML_ELEMENT_NODE) {
7913 if (cur->nsDef != NULL) {
7914 ns = cur->nsDef;
7931 } else if ((cur->type == XML_ENTITY_NODE) ||
7932 (cur->type == XML_ENTITY_DECL))
7934 cur = cur->parent;
7935 } while ((cur != NULL) && (cur->doc != (xmlDocPtr) cur));
8180 xmlNodePtr cur, curElem = NULL;
8195 cur = elem;
8197 switch (cur->type) {
8200 curElem = cur;
8205 if (cur->nsDef != NULL) {
8207 ns = cur->nsDef;
8247 cur->nsDef = ns->next;
8257 if ((cur->ns != NULL) && adoptns && (cur->ns == ns))
8290 if (cur->ns == NULL)
8307 if (cur->ns == listRedund[j]) {
8308 cur->ns = listRedund[++j];
8322 (cur->ns == mi->oldNs)) {
8324 cur->ns = mi->newNs;
8333 cur->ns, &ns,
8336 (cur->type == XML_ATTRIBUTE_NODE) ? 1 : 0) == -1)
8338 cur->ns = ns;
8341 if ((cur->type == XML_ELEMENT_NODE) &&
8342 (cur->properties != NULL)) {
8346 cur = (xmlNodePtr) cur->properties;
8354 if ((cur->type == XML_ELEMENT_NODE) &&
8355 (cur->children != NULL)) {
8359 cur = cur->children;
8363 if (cur == elem)
8365 if (cur->type == XML_ELEMENT_NODE) {
8385 if (cur->next != NULL)
8386 cur = cur->next;
8388 if (cur->type == XML_ATTRIBUTE_NODE) {
8389 cur = cur->parent;
8392 cur = cur->parent;
8395 } while (cur != NULL);
8444 xmlNodePtr cur, curElem = NULL;
8481 cur = node;
8482 while (cur != NULL) {
8486 if (cur->doc != sourceDoc) {
8493 if (cur->next == NULL)
8496 cur = cur->next;
8497 if ((cur->type == XML_XINCLUDE_END) ||
8498 (cur->doc == node->doc))
8500 } while (cur->next != NULL);
8502 if (cur->doc != node->doc)
8505 cur->doc = destDoc;
8506 switch (cur->type) {
8514 curElem = cur;
8524 if ((cur->nsDef) &&
8536 for (ns = cur->nsDef; ns != NULL; ns = ns->next) {
8568 if (cur->ns == NULL)
8586 (cur->ns == mi->oldNs)) {
8588 cur->ns = mi->newNs;
8600 ns = ctxt->getNsForNodeFunc(ctxt, cur,
8601 cur->ns->href, cur->ns->prefix);
8607 cur->ns, ns, XML_TREE_NSMAP_CUSTOM) == NULL)
8609 cur->ns = ns;
8617 cur->ns, &ns,
8621 (cur->type == XML_ATTRIBUTE_NODE) ? 1 : 0) == -1)
8623 cur->ns = ns;
8630 XML_TREE_ADOPT_STR(cur->name)
8631 if (cur->type == XML_ELEMENT_NODE) {
8632 cur->psvi = NULL;
8633 cur->line = 0;
8634 cur->extra = 0;
8638 if (cur->properties != NULL) {
8642 cur = (xmlNodePtr) cur->properties;
8650 (((xmlAttrPtr) cur)->atype == XML_ATTRIBUTE_ID))
8652 xmlRemoveID(sourceDoc, (xmlAttrPtr) cur);
8654 ((xmlAttrPtr) cur)->atype = 0;
8655 ((xmlAttrPtr) cur)->psvi = NULL;
8664 XML_TREE_ADOPT_STR_2(cur->content)
8670 cur->content = NULL;
8671 cur->children = NULL;
8672 cur->last = NULL;
8678 ent = xmlGetDocEntity(destDoc, cur->name);
8680 cur->content = ent->content;
8681 cur->children = (xmlNodePtr) ent;
8682 cur->last = (xmlNodePtr) ent;
8687 XML_TREE_ADOPT_STR(cur->name)
8688 XML_TREE_ADOPT_STR_2(cur->content)
8698 if (cur->children != NULL) {
8699 cur = cur->children;
8704 if (cur == node)
8706 if ((cur->type == XML_ELEMENT_NODE) ||
8707 (cur->type == XML_XINCLUDE_START) ||
8708 (cur->type == XML_XINCLUDE_END))
8732 if (cur->next != NULL)
8733 cur = cur->next;
8734 else if ((cur->type == XML_ATTRIBUTE_NODE) &&
8735 (cur->parent->children != NULL))
8737 cur = cur->parent->children;
8739 cur = cur->parent;
8811 xmlNodePtr cur, curElem = NULL;
8860 cur = node;
8861 while (cur != NULL) {
8862 if (cur->doc != sourceDoc) {
8873 switch (cur->type) {
8943 clone->type = cur->type;
8949 if (cur->name == xmlStringText)
8951 else if (cur->name == xmlStringTextNoenc)
8958 else if (cur->name == xmlStringComment)
8960 else if (cur->name != NULL) {
8961 DICT_CONST_COPY(cur->name, clone->name);
8964 switch (cur->type) {
8972 curElem = cur;
8977 if (cur->nsDef != NULL) {
8993 for (ns = cur->nsDef; ns != NULL; ns = ns->next) {
9049 /* cur->ns will be processed further down. */
9053 /* cur->ns will be processed further down. */
9060 DICT_COPY(cur->content, clone->content);
9072 ent = xmlGetDocEntity(destDoc, cur->name);
9084 clone->content = cur->content;
9085 clone->children = cur->children;
9086 clone->last = cur->last;
9090 DICT_COPY(cur->content, clone->content);
9093 DICT_COPY(cur->content, clone->content);
9099 if (cur->ns == NULL)
9124 (cur->ns == mi->oldNs)) {
9140 ns = ctxt->getNsForNodeFunc(ctxt, cur,
9141 cur->ns->href, cur->ns->prefix);
9146 cur->ns, ns, XML_TREE_NSMAP_CUSTOM) == NULL)
9156 cur->ns, &ns,
9161 (cur->type == XML_ATTRIBUTE_NODE) ? 1 : 0) == -1)
9180 idVal = xmlNodeListGetString(cur->doc, cur->children, 1);
9182 if (xmlAddID(NULL, destDoc, idVal, (xmlAttrPtr) cur) == NULL) {
9198 if ((cur->type == XML_ELEMENT_NODE) && (cur->properties != NULL)) {
9201 cur = (xmlNodePtr) cur->properties;
9208 if (cur->children != NULL) {
9209 if (deep || (cur->type == XML_ATTRIBUTE_NODE)) {
9212 cur = cur->children;
9222 if (cur == node)
9224 if ((cur->type == XML_ELEMENT_NODE) ||
9225 (cur->type == XML_XINCLUDE_START) ||
9226 (cur->type == XML_XINCLUDE_END)) {
9249 if (cur->next != NULL) {
9251 cur = cur->next;
9252 } else if (cur->type != XML_ATTRIBUTE_NODE) {
9263 cur = cur->parent;
9272 cur = cur->parent;
9331 xmlNodePtr cur;
9377 cur = attr->children;
9378 while (cur != NULL) {
9379 cur->doc = destDoc;
9380 switch (cur->type) {
9383 XML_TREE_ADOPT_STR_2(cur->content)
9389 cur->content = NULL;
9390 cur->children = NULL;
9391 cur->last = NULL;
9397 ent = xmlGetDocEntity(destDoc, cur->name);
9399 cur->content = ent->content;
9400 cur->children = (xmlNodePtr) ent;
9401 cur->last = (xmlNodePtr) ent;
9408 if (cur->children != NULL) {
9409 cur = cur->children;
9413 if (cur == (xmlNodePtr) attr)
9415 if (cur->next != NULL)
9416 cur = cur->next;
9418 cur = cur->parent;
9507 xmlNodePtr cur = node;
9510 cur->doc = destDoc;