Lines Matching defs:cur
368 const xmlChar *cur = value;
378 while (IS_BLANK_CH(*cur)) cur++;
379 if (((*cur >= 'a') && (*cur <= 'z')) || ((*cur >= 'A') && (*cur <= 'Z')) ||
380 (*cur == '_'))
381 cur++;
384 while (((*cur >= 'a') && (*cur <= 'z')) ||
385 ((*cur >= 'A') && (*cur <= 'Z')) ||
386 ((*cur >= '0') && (*cur <= '9')) ||
387 (*cur == '_') || (*cur == '-') || (*cur == '.'))
388 cur++;
390 while (IS_BLANK_CH(*cur)) cur++;
391 if (*cur == 0)
398 cur = value;
399 c = CUR_SCHAR(cur, l);
402 cur += l;
403 c = CUR_SCHAR(cur, l);
408 cur += l;
409 c = CUR_SCHAR(cur, l);
413 cur += l;
414 c = CUR_SCHAR(cur, l);
418 cur += l;
419 c = CUR_SCHAR(cur, l);
442 const xmlChar *cur = value;
451 while (IS_BLANK_CH(*cur)) cur++;
452 if (((*cur >= 'a') && (*cur <= 'z')) || ((*cur >= 'A') && (*cur <= 'Z')) ||
453 (*cur == '_'))
454 cur++;
457 while (((*cur >= 'a') && (*cur <= 'z')) ||
458 ((*cur >= 'A') && (*cur <= 'Z')) ||
459 ((*cur >= '0') && (*cur <= '9')) ||
460 (*cur == '_') || (*cur == '-') || (*cur == '.'))
461 cur++;
462 if (*cur == ':') {
463 cur++;
464 if (((*cur >= 'a') && (*cur <= 'z')) ||
465 ((*cur >= 'A') && (*cur <= 'Z')) ||
466 (*cur == '_'))
467 cur++;
470 while (((*cur >= 'a') && (*cur <= 'z')) ||
471 ((*cur >= 'A') && (*cur <= 'Z')) ||
472 ((*cur >= '0') && (*cur <= '9')) ||
473 (*cur == '_') || (*cur == '-') || (*cur == '.'))
474 cur++;
477 while (IS_BLANK_CH(*cur)) cur++;
478 if (*cur == 0)
485 cur = value;
486 c = CUR_SCHAR(cur, l);
489 cur += l;
490 c = CUR_SCHAR(cur, l);
495 cur += l;
496 c = CUR_SCHAR(cur, l);
500 cur += l;
501 c = CUR_SCHAR(cur, l);
504 cur += l;
505 c = CUR_SCHAR(cur, l);
508 cur += l;
509 c = CUR_SCHAR(cur, l);
513 cur += l;
514 c = CUR_SCHAR(cur, l);
519 cur += l;
520 c = CUR_SCHAR(cur, l);
540 const xmlChar *cur = value;
549 while (IS_BLANK_CH(*cur)) cur++;
550 if (((*cur >= 'a') && (*cur <= 'z')) || ((*cur >= 'A') && (*cur <= 'Z')) ||
551 (*cur == '_') || (*cur == ':'))
552 cur++;
555 while (((*cur >= 'a') && (*cur <= 'z')) ||
556 ((*cur >= 'A') && (*cur <= 'Z')) ||
557 ((*cur >= '0') && (*cur <= '9')) ||
558 (*cur == '_') || (*cur == '-') || (*cur == '.') || (*cur == ':'))
559 cur++;
561 while (IS_BLANK_CH(*cur)) cur++;
562 if (*cur == 0)
569 cur = value;
570 c = CUR_SCHAR(cur, l);
573 cur += l;
574 c = CUR_SCHAR(cur, l);
579 cur += l;
580 c = CUR_SCHAR(cur, l);
583 cur += l;
584 c = CUR_SCHAR(cur, l);
588 cur += l;
589 c = CUR_SCHAR(cur, l);
609 const xmlChar *cur = value;
618 while (IS_BLANK_CH(*cur)) cur++;
619 if (((*cur >= 'a') && (*cur <= 'z')) ||
620 ((*cur >= 'A') && (*cur <= 'Z')) ||
621 ((*cur >= '0') && (*cur <= '9')) ||
622 (*cur == '_') || (*cur == '-') || (*cur == '.') || (*cur == ':'))
623 cur++;
626 while (((*cur >= 'a') && (*cur <= 'z')) ||
627 ((*cur >= 'A') && (*cur <= 'Z')) ||
628 ((*cur >= '0') && (*cur <= '9')) ||
629 (*cur == '_') || (*cur == '-') || (*cur == '.') || (*cur == ':'))
630 cur++;
632 while (IS_BLANK_CH(*cur)) cur++;
633 if (*cur == 0)
640 cur = value;
641 c = CUR_SCHAR(cur, l);
644 cur += l;
645 c = CUR_SCHAR(cur, l);
651 cur += l;
652 c = CUR_SCHAR(cur, l);
655 cur += l;
656 c = CUR_SCHAR(cur, l);
660 cur += l;
661 c = CUR_SCHAR(cur, l);
726 xmlNsPtr cur;
748 cur = (xmlNsPtr) xmlMalloc(sizeof(xmlNs));
749 if (cur == NULL) {
753 memset(cur, 0, sizeof(xmlNs));
754 cur->type = XML_LOCAL_NAMESPACE;
757 cur->href = xmlStrdup(href);
759 cur->prefix = xmlStrdup(prefix);
767 node->nsDef = cur;
771 if (((prev->prefix == NULL) && (cur->prefix == NULL)) ||
772 (xmlStrEqual(prev->prefix, cur->prefix))) {
773 xmlFreeNs(cur);
778 if (((prev->prefix == NULL) && (cur->prefix == NULL)) ||
779 (xmlStrEqual(prev->prefix, cur->prefix))) {
780 xmlFreeNs(cur);
784 prev->next = cur;
787 return(cur);
811 * @cur: the namespace pointer
816 xmlFreeNs(xmlNsPtr cur) {
817 if (cur == NULL) {
824 if (cur->href != NULL) xmlFree((char *) cur->href);
825 if (cur->prefix != NULL) xmlFree((char *) cur->prefix);
826 xmlFree(cur);
831 * @cur: the first namespace pointer
836 xmlFreeNsList(xmlNsPtr cur) {
838 if (cur == NULL) {
845 while (cur != NULL) {
846 next = cur->next;
847 xmlFreeNs(cur);
848 cur = next;
867 xmlDtdPtr cur;
882 cur = (xmlDtdPtr) xmlMalloc(sizeof(xmlDtd));
883 if (cur == NULL) {
887 memset(cur, 0 , sizeof(xmlDtd));
888 cur->type = XML_DTD_NODE;
891 cur->name = xmlStrdup(name);
893 cur->ExternalID = xmlStrdup(ExternalID);
895 cur->SystemID = xmlStrdup(SystemID);
897 doc->extSubset = cur;
898 cur->doc = doc;
901 xmlRegisterNodeDefaultValue((xmlNodePtr)cur);
902 return(cur);
915 xmlNodePtr cur;
919 cur = doc->children;
920 while (cur != NULL) {
921 if (cur->type == XML_DTD_NODE)
922 return((xmlDtdPtr) cur);
923 cur = cur->next;
941 xmlDtdPtr cur;
956 cur = (xmlDtdPtr) xmlMalloc(sizeof(xmlDtd));
957 if (cur == NULL) {
961 memset(cur, 0, sizeof(xmlDtd));
962 cur->type = XML_DTD_NODE;
965 cur->name = xmlStrdup(name);
966 if (cur->name == NULL) {
968 xmlFree(cur);
973 cur->ExternalID = xmlStrdup(ExternalID);
974 if (cur->ExternalID == NULL) {
976 if (cur->name != NULL)
977 xmlFree((char *)cur->name);
978 xmlFree(cur);
983 cur->SystemID = xmlStrdup(SystemID);
984 if (cur->SystemID == NULL) {
986 if (cur->name != NULL)
987 xmlFree((char *)cur->name);
988 if (cur->ExternalID != NULL)
989 xmlFree((char *)cur->ExternalID);
990 xmlFree(cur);
995 doc->intSubset = cur;
996 cur->parent = doc;
997 cur->doc = doc;
999 doc->children = (xmlNodePtr) cur;
1000 doc->last = (xmlNodePtr) cur;
1006 prev->prev = (xmlNodePtr) cur;
1007 cur->next = prev;
1008 doc->children = (xmlNodePtr) cur;
1016 cur->prev = doc->last;
1017 cur->prev->next = (xmlNodePtr) cur;
1018 cur->next = NULL;
1019 doc->last = (xmlNodePtr) cur;
1021 cur->next = next;
1022 cur->prev = next->prev;
1023 if (cur->prev == NULL)
1024 doc->children = (xmlNodePtr) cur;
1026 cur->prev->next = (xmlNodePtr) cur;
1027 next->prev = (xmlNodePtr) cur;
1034 xmlRegisterNodeDefaultValue((xmlNodePtr)cur);
1035 return(cur);
1088 * @cur: the DTD structure to free up
1093 xmlFreeDtd(xmlDtdPtr cur) {
1096 if (cur == NULL) {
1099 if (cur->doc != NULL) dict = cur->doc->dict;
1102 xmlDeregisterNodeDefaultValue((xmlNodePtr)cur);
1104 if (cur->children != NULL) {
1105 xmlNodePtr next, c = cur->children;
1123 DICT_FREE(cur->name)
1124 DICT_FREE(cur->SystemID)
1125 DICT_FREE(cur->ExternalID)
1127 if (cur->notations != NULL)
1128 xmlFreeNotationTable((xmlNotationTablePtr) cur->notations);
1130 if (cur->elements != NULL)
1131 xmlFreeElementTable((xmlElementTablePtr) cur->elements);
1132 if (cur->attributes != NULL)
1133 xmlFreeAttributeTable((xmlAttributeTablePtr) cur->attributes);
1134 if (cur->entities != NULL)
1135 xmlFreeEntitiesTable((xmlEntitiesTablePtr) cur->entities);
1136 if (cur->pentities != NULL)
1137 xmlFreeEntitiesTable((xmlEntitiesTablePtr) cur->pentities);
1139 xmlFree(cur);
1152 xmlDocPtr cur;
1160 cur = (xmlDocPtr) xmlMalloc(sizeof(xmlDoc));
1161 if (cur == NULL) {
1165 memset(cur, 0, sizeof(xmlDoc));
1166 cur->type = XML_DOCUMENT_NODE;
1168 cur->version = xmlStrdup(version);
1169 if (cur->version == NULL) {
1171 xmlFree(cur);
1174 cur->standalone = -1;
1175 cur->compression = -1; /* not initialized */
1176 cur->doc = cur;
1177 cur->parseFlags = 0;
1178 cur->properties = XML_DOC_USERBUILT;
1184 cur->charset = XML_CHAR_ENCODING_UTF8;
1187 xmlRegisterNodeDefaultValue((xmlNodePtr)cur);
1188 return(cur);
1193 * @cur: pointer to the document
1198 xmlFreeDoc(xmlDocPtr cur) {
1202 if (cur == NULL) {
1211 xmlDebugCheckDocument(stderr, cur);
1215 if (cur != NULL) dict = cur->dict;
1218 xmlDeregisterNodeDefaultValue((xmlNodePtr)cur);
1223 if (cur->ids != NULL) xmlFreeIDTable((xmlIDTablePtr) cur->ids);
1224 cur->ids = NULL;
1225 if (cur->refs != NULL) xmlFreeRefTable((xmlRefTablePtr) cur->refs);
1226 cur->refs = NULL;
1227 extSubset = cur->extSubset;
1228 intSubset = cur->intSubset;
1232 xmlUnlinkNode((xmlNodePtr) cur->extSubset);
1233 cur->extSubset = NULL;
1237 xmlUnlinkNode((xmlNodePtr) cur->intSubset);
1238 cur->intSubset = NULL;
1242 if (cur->children != NULL) xmlFreeNodeList(cur->children);
1243 if (cur->oldNs != NULL) xmlFreeNsList(cur->oldNs);
1245 DICT_FREE(cur->version)
1246 DICT_FREE(cur->name)
1247 DICT_FREE(cur->encoding)
1248 DICT_FREE(cur->URL)
1249 xmlFree(cur);
1268 const xmlChar *cur = value, *end = cur + len;
1279 q = cur;
1280 while ((cur < end) && (*cur != 0)) {
1281 if (cur[0] == '&') {
1288 if (cur != q) {
1289 if (xmlBufAdd(buf, q, cur - q))
1292 q = cur;
1293 if ((cur + 2 < end) && (cur[1] == '#') && (cur[2] == 'x')) {
1294 cur += 3;
1295 if (cur < end)
1296 tmp = *cur;
1312 cur++;
1313 if (cur < end)
1314 tmp = *cur;
1319 cur++;
1320 q = cur;
1321 } else if ((cur + 1 < end) && (cur[1] == '#')) {
1322 cur += 2;
1323 if (cur < end)
1324 tmp = *cur;
1336 cur++;
1337 if (cur < end)
1338 tmp = *cur;
1343 cur++;
1344 q = cur;
1349 cur++;
1350 q = cur;
1351 while ((cur < end) && (*cur != 0) && (*cur != ';')) cur++;
1352 if ((cur >= end) || (*cur == 0)) {
1357 if (cur != q) {
1361 val = xmlStrndup(q, cur - q);
1417 cur++;
1418 q = cur;
1432 cur++;
1435 if (cur != q) {
1439 if (xmlBufAdd(buf, q, cur - q))
1476 const xmlChar *cur = value;
1487 q = cur;
1488 while (*cur != 0) {
1489 if (cur[0] == '&') {
1496 if (cur != q) {
1497 if (xmlBufAdd(buf, q, cur - q))
1500 q = cur;
1501 if ((cur[1] == '#') && (cur[2] == 'x')) {
1502 cur += 3;
1503 tmp = *cur;
1517 cur++;
1518 tmp = *cur;
1521 cur++;
1522 q = cur;
1523 } else if (cur[1] == '#') {
1524 cur += 2;
1525 tmp = *cur;
1535 cur++;
1536 tmp = *cur;
1539 cur++;
1540 q = cur;
1545 cur++;
1546 q = cur;
1547 while ((*cur != 0) && (*cur != ';')) cur++;
1548 if (*cur == 0) {
1553 if (cur != q) {
1557 val = xmlStrndup(q, cur - q);
1608 cur++;
1609 q = cur;
1623 cur++;
1625 if ((cur != q) || (ret == NULL)) {
1629 xmlBufAdd(buf, q, cur - q);
1825 xmlAttrPtr cur;
1839 cur = (xmlAttrPtr) xmlMalloc(sizeof(xmlAttr));
1840 if (cur == NULL) {
1848 memset(cur, 0, sizeof(xmlAttr));
1849 cur->type = XML_ATTRIBUTE_NODE;
1851 cur->parent = node;
1854 cur->doc = doc;
1856 cur->ns = ns;
1860 cur->name = (xmlChar *) xmlDictLookup(doc->dict, name, -1);
1862 cur->name = xmlStrdup(name);
1864 cur->name = name;
1875 cur->children = xmlNewDocText(doc, value);
1876 cur->last = NULL;
1877 tmp = cur->children;
1879 tmp->parent = (xmlNodePtr) cur;
1881 cur->last = tmp;
1891 node->properties = cur;
1897 prev->next = cur;
1898 cur->prev = prev;
1903 (xmlIsID(node->doc, node, cur) == 1))
1904 xmlAddID(NULL, node->doc, value, cur);
1907 xmlRegisterNodeDefaultValue((xmlNodePtr) cur);
1908 return (cur);
1998 xmlAttrPtr cur;
2011 cur = (xmlAttrPtr) xmlMalloc(sizeof(xmlAttr));
2012 if (cur == NULL) {
2016 memset(cur, 0, sizeof(xmlAttr));
2017 cur->type = XML_ATTRIBUTE_NODE;
2020 cur->name = xmlDictLookup(doc->dict, name, -1);
2022 cur->name = xmlStrdup(name);
2023 cur->doc = doc;
2027 cur->children = xmlStringGetNodeList(doc, value);
2028 cur->last = NULL;
2030 tmp = cur->children;
2032 tmp->parent = (xmlNodePtr) cur;
2034 cur->last = tmp;
2040 xmlRegisterNodeDefaultValue((xmlNodePtr)cur);
2041 return(cur);
2046 * @cur: the first property in the list
2051 xmlFreePropList(xmlAttrPtr cur) {
2053 if (cur == NULL) return;
2054 while (cur != NULL) {
2055 next = cur->next;
2056 xmlFreeProp(cur);
2057 cur = next;
2063 * @cur: an attribute
2068 xmlFreeProp(xmlAttrPtr cur) {
2070 if (cur == NULL) return;
2072 if (cur->doc != NULL) dict = cur->doc->dict;
2075 xmlDeregisterNodeDefaultValue((xmlNodePtr)cur);
2078 if ((cur->doc != NULL) && (cur->atype == XML_ATTRIBUTE_ID)) {
2079 xmlRemoveID(cur->doc, cur);
2081 if (cur->children != NULL) xmlFreeNodeList(cur->children);
2082 DICT_FREE(cur->name)
2083 xmlFree(cur);
2088 * @cur: an attribute
2096 xmlRemoveProp(xmlAttrPtr cur) {
2098 if (cur == NULL) {
2101 "xmlRemoveProp : cur == NULL\n");
2105 if (cur->parent == NULL) {
2108 "xmlRemoveProp : cur->parent == NULL\n");
2112 tmp = cur->parent->properties;
2113 if (tmp == cur) {
2114 cur->parent->properties = cur->next;
2115 if (cur->next != NULL)
2116 cur->next->prev = NULL;
2117 xmlFreeProp(cur);
2121 if (tmp->next == cur) {
2122 tmp->next = cur->next;
2125 xmlFreeProp(cur);
2148 xmlNodePtr cur;
2161 cur = (xmlNodePtr) xmlMalloc(sizeof(xmlNode));
2162 if (cur == NULL) {
2166 memset(cur, 0, sizeof(xmlNode));
2167 cur->type = XML_PI_NODE;
2170 cur->name = xmlDictLookup(doc->dict, name, -1);
2172 cur->name = xmlStrdup(name);
2174 cur->content = xmlStrdup(content);
2176 cur->doc = doc;
2179 xmlRegisterNodeDefaultValue((xmlNodePtr)cur);
2180 return(cur);
2210 xmlNodePtr cur;
2223 cur = (xmlNodePtr) xmlMalloc(sizeof(xmlNode));
2224 if (cur == NULL) {
2228 memset(cur, 0, sizeof(xmlNode));
2229 cur->type = XML_ELEMENT_NODE;
2231 cur->name = xmlStrdup(name);
2232 cur->ns = ns;
2235 xmlRegisterNodeDefaultValue(cur);
2236 return(cur);
2252 xmlNodePtr cur;
2265 cur = (xmlNodePtr) xmlMalloc(sizeof(xmlNode));
2266 if (cur == NULL) {
2271 memset(cur, 0, sizeof(xmlNode));
2272 cur->type = XML_ELEMENT_NODE;
2274 cur->name = name;
2275 cur->ns = ns;
2278 xmlRegisterNodeDefaultValue((xmlNodePtr)cur);
2279 return(cur);
2301 xmlNodePtr cur;
2304 cur = xmlNewNodeEatName(ns, (xmlChar *)
2307 cur = xmlNewNode(ns, name);
2308 if (cur != NULL) {
2309 cur->doc = doc;
2311 cur->children = xmlStringGetNodeList(doc, content);
2312 UPDATE_LAST_CHILD_AND_PARENT(cur)
2316 return(cur);
2338 xmlNodePtr cur;
2340 cur = xmlNewNodeEatName(ns, name);
2341 if (cur != NULL) {
2342 cur->doc = doc;
2344 cur->children = xmlStringGetNodeList(doc, content);
2345 UPDATE_LAST_CHILD_AND_PARENT(cur)
2353 return(cur);
2372 xmlNodePtr cur;
2374 cur = xmlNewDocNode(doc, ns, name, NULL);
2375 if (cur != NULL) {
2376 cur->doc = doc;
2378 cur->children = xmlNewDocText(doc, content);
2379 UPDATE_LAST_CHILD_AND_PARENT(cur)
2382 return(cur);
2394 xmlNodePtr cur;
2399 cur = (xmlNodePtr) xmlMalloc(sizeof(xmlNode));
2400 if (cur == NULL) {
2404 memset(cur, 0, sizeof(xmlNode));
2405 cur->type = XML_DOCUMENT_FRAG_NODE;
2407 cur->doc = doc;
2410 xmlRegisterNodeDefaultValue(cur);
2411 return(cur);
2424 xmlNodePtr cur;
2429 cur = (xmlNodePtr) xmlMalloc(sizeof(xmlNode));
2430 if (cur == NULL) {
2434 memset(cur, 0, sizeof(xmlNode));
2435 cur->type = XML_TEXT_NODE;
2437 cur->name = xmlStringText;
2439 cur->content = xmlStrdup(content);
2443 xmlRegisterNodeDefaultValue(cur);
2444 return(cur);
2470 xmlNodePtr cur, prev;
2493 cur = xmlNewDocRawNode(parent->doc, parent->ns, name, content);
2495 cur = xmlNewDocRawNode(parent->doc, ns, name, content);
2499 cur = xmlNewDocRawNode((xmlDocPtr) parent, NULL, name, content);
2501 cur = xmlNewDocRawNode((xmlDocPtr) parent, ns, name, content);
2503 cur = xmlNewDocRawNode( parent->doc, ns, name, content);
2507 if (cur == NULL) return(NULL);
2512 cur->type = XML_ELEMENT_NODE;
2513 cur->parent = parent;
2514 cur->doc = parent->doc;
2516 parent->children = cur;
2517 parent->last = cur;
2520 prev->next = cur;
2521 cur->prev = prev;
2522 parent->last = cur;
2525 return(cur);
2539 xmlNodePtr cur;
2547 cur = (xmlNodePtr) xmlMalloc(sizeof(xmlNode));
2548 if (cur == NULL) {
2552 memset(cur, 0, sizeof(xmlNode));
2553 cur->type = XML_ENTITY_REF_NODE;
2555 cur->doc = doc;
2561 cur->name = xmlStrndup(name, len - 1);
2563 cur->name = xmlStrndup(name, len);
2565 cur->name = xmlStrdup(name);
2568 xmlRegisterNodeDefaultValue(cur);
2569 return(cur);
2582 xmlNodePtr cur;
2591 cur = (xmlNodePtr) xmlMalloc(sizeof(xmlNode));
2592 if (cur == NULL) {
2596 memset(cur, 0, sizeof(xmlNode));
2597 cur->type = XML_ENTITY_REF_NODE;
2599 cur->doc = doc;
2605 cur->name = xmlStrndup(name, len - 1);
2607 cur->name = xmlStrndup(name, len);
2609 cur->name = xmlStrdup(name);
2611 ent = xmlGetDocEntity(doc, cur->name);
2613 cur->content = ent->content;
2619 cur->children = (xmlNodePtr) ent;
2620 cur->last = (xmlNodePtr) ent;
2624 xmlRegisterNodeDefaultValue(cur);
2625 return(cur);
2638 xmlNodePtr cur;
2640 cur = xmlNewText(content);
2641 if (cur != NULL) cur->doc = doc;
2642 return(cur);
2655 xmlNodePtr cur;
2660 cur = (xmlNodePtr) xmlMalloc(sizeof(xmlNode));
2661 if (cur == NULL) {
2665 memset(cur, 0, sizeof(xmlNode));
2666 cur->type = XML_TEXT_NODE;
2668 cur->name = xmlStringText;
2670 cur->content = xmlStrndup(content, len);
2674 xmlRegisterNodeDefaultValue(cur);
2675 return(cur);
2690 xmlNodePtr cur;
2692 cur = xmlNewTextLen(content, len);
2693 if (cur != NULL) cur->doc = doc;
2694 return(cur);
2706 xmlNodePtr cur;
2711 cur = (xmlNodePtr) xmlMalloc(sizeof(xmlNode));
2712 if (cur == NULL) {
2716 memset(cur, 0, sizeof(xmlNode));
2717 cur->type = XML_COMMENT_NODE;
2719 cur->name = xmlStringComment;
2721 cur->content = xmlStrdup(content);
2725 xmlRegisterNodeDefaultValue(cur);
2726 return(cur);
2740 xmlNodePtr cur;
2745 cur = (xmlNodePtr) xmlMalloc(sizeof(xmlNode));
2746 if (cur == NULL) {
2750 memset(cur, 0, sizeof(xmlNode));
2751 cur->type = XML_CDATA_SECTION_NODE;
2752 cur->doc = doc;
2755 cur->content = xmlStrndup(content, len);
2759 xmlRegisterNodeDefaultValue(cur);
2760 return(cur);
2773 xmlNodePtr cur;
2775 cur = xmlNewComment(content);
2776 if (cur != NULL) cur->doc = doc;
2777 return(cur);
2817 xmlNodePtr cur;
2821 cur = list;
2822 while (cur != NULL) {
2823 if (cur->doc != doc)
2824 xmlSetTreeDoc(cur, doc);
2825 cur = cur->next;
2850 xmlNodePtr cur, prev;
2873 cur = xmlNewDocNode(parent->doc, parent->ns, name, content);
2875 cur = xmlNewDocNode(parent->doc, ns, name, content);
2879 cur = xmlNewDocNode((xmlDocPtr) parent, NULL, name, content);
2881 cur = xmlNewDocNode((xmlDocPtr) parent, ns, name, content);
2883 cur = xmlNewDocNode( parent->doc, ns, name, content);
2887 if (cur == NULL) return(NULL);
2892 cur->type = XML_ELEMENT_NODE;
2893 cur->parent = parent;
2894 cur->doc = parent->doc;
2896 parent->children = cur;
2897 parent->last = cur;
2900 prev->next = cur;
2901 cur->prev = prev;
2902 parent->last = cur;
2905 return(cur);
2912 * @cur: the base attribute passed to calling function
2915 * Add a new attribute after @prev using @cur as base attribute.
2916 * When inserting before @cur, @prev is passed as @cur->prev.
2917 * When inserting after @cur, @prev is passed as @cur.
2923 xmlAddPropSibling(xmlNodePtr prev, xmlNodePtr cur, xmlNodePtr prop) {
2926 if ((cur == NULL) || (cur->type != XML_ATTRIBUTE_NODE) ||
2933 attr = xmlHasNsProp(cur->parent, prop->name, NULL);
2935 attr = xmlHasNsProp(cur->parent, prop->name, prop->ns->href);
2937 if (prop->doc != cur->doc) {
2938 xmlSetTreeDoc(prop, cur->doc);
2940 prop->parent = cur->parent;
2948 prop->next = cur;
2949 cur->prev = prop;
2962 * @cur: the child node
2965 * Add a new node @elem as the next sibling of @cur
2975 xmlAddNextSibling(xmlNodePtr cur, xmlNodePtr elem) {
2976 if ((cur == NULL) || (cur->type == XML_NAMESPACE_DECL)) {
2979 "xmlAddNextSibling : cur == NULL\n");
2991 if (cur == elem) {
2994 "xmlAddNextSibling : cur == elem\n");
3002 if (cur->type == XML_TEXT_NODE) {
3003 xmlNodeAddContent(cur, elem->content);
3005 return(cur);
3007 if ((cur->next != NULL) && (cur->next->type == XML_TEXT_NODE) &&
3008 (cur->name == cur->next->name)) {
3012 tmp = xmlStrcat(tmp, cur->next->content);
3013 xmlNodeSetContent(cur->next, tmp);
3016 return(cur->next);
3019 return xmlAddPropSibling(cur, cur, elem);
3022 if (elem->doc != cur->doc) {
3023 xmlSetTreeDoc(elem, cur->doc);
3025 elem->parent = cur->parent;
3026 elem->prev = cur;
3027 elem->next = cur->next;
3028 cur->next = elem;
3031 if ((elem->parent != NULL) && (elem->parent->last == cur))
3040 * @cur: the child node
3043 * Add a new node @elem as the previous sibling of @cur
3053 xmlAddPrevSibling(xmlNodePtr cur, xmlNodePtr elem) {
3054 if ((cur == NULL) || (cur->type == XML_NAMESPACE_DECL)) {
3057 "xmlAddPrevSibling : cur == NULL\n");
3069 if (cur == elem) {
3072 "xmlAddPrevSibling : cur == elem\n");
3080 if (cur->type == XML_TEXT_NODE) {
3084 tmp = xmlStrcat(tmp, cur->content);
3085 xmlNodeSetContent(cur, tmp);
3088 return(cur);
3090 if ((cur->prev != NULL) && (cur->prev->type == XML_TEXT_NODE) &&
3091 (cur->name == cur->prev->name)) {
3092 xmlNodeAddContent(cur->prev, elem->content);
3094 return(cur->prev);
3097 return xmlAddPropSibling(cur->prev, cur, elem);
3100 if (elem->doc != cur->doc) {
3101 xmlSetTreeDoc(elem, cur->doc);
3103 elem->parent = cur->parent;
3104 elem->next = cur;
3105 elem->prev = cur->prev;
3106 cur->prev = elem;
3109 if ((elem->parent != NULL) && (elem->parent->children == cur)) {
3118 * @cur: the child node
3121 * Add a new element @elem to the list of siblings of @cur
3129 xmlAddSibling(xmlNodePtr cur, xmlNodePtr elem) {
3132 if ((cur == NULL) || (cur->type == XML_NAMESPACE_DECL)) {
3135 "xmlAddSibling : cur == NULL\n");
3148 if (cur == elem) {
3151 "xmlAddSibling : cur == elem\n");
3160 if ((cur->type != XML_ATTRIBUTE_NODE) && (cur->parent != NULL) &&
3161 (cur->parent->children != NULL) &&
3162 (cur->parent->last != NULL) &&
3163 (cur->parent->last->next == NULL)) {
3164 cur = cur->parent->last;
3166 while (cur->next != NULL) cur = cur->next;
3171 if ((cur->type == XML_TEXT_NODE) && (elem->type == XML_TEXT_NODE) &&
3172 (cur->name == elem->name)) {
3173 xmlNodeAddContent(cur, elem->content);
3175 return(cur);
3177 return xmlAddPropSibling(cur, cur, elem);
3180 if (elem->doc != cur->doc) {
3181 xmlSetTreeDoc(elem, cur->doc);
3183 parent = cur->parent;
3184 elem->prev = cur;
3187 cur->next = elem;
3197 * @cur: the first node in the list
3200 * merging adjacent TEXT nodes (@cur may be freed)
3205 xmlAddChildList(xmlNodePtr parent, xmlNodePtr cur) {
3216 if ((cur == NULL) || (cur->type == XML_NAMESPACE_DECL)) {
3224 if ((cur->doc != NULL) && (parent->doc != NULL) &&
3225 (cur->doc != parent->doc)) {
3237 parent->children = cur;
3240 * If cur and parent->last both are TEXT nodes, then merge them.
3242 if ((cur
3244 (cur->name == parent->last->name)) {
3245 xmlNodeAddContent(parent->last, cur->content);
3249 if (cur->next == NULL) {
3250 xmlFreeNode(cur);
3253 prev = cur;
3254 cur = cur->next;
3258 prev->next = cur;
3259 cur->prev = prev;
3261 while (cur->next != NULL) {
3262 cur->parent = parent;
3263 if (cur->doc != parent->doc) {
3264 xmlSetTreeDoc(cur, parent->doc);
3266 cur = cur->next;
3268 cur->parent = parent;
3270 if (cur->doc != parent->doc) {
3271 xmlSetTreeDoc(cur, parent->doc);
3273 parent->last = cur;
3275 return(cur);
3281 * @cur: the child node
3284 * merging adjacent TEXT nodes (in which case @cur is freed)
3291 xmlAddChild(xmlNodePtr parent, xmlNodePtr cur) {
3302 if ((cur == NULL) || (cur->type == XML_NAMESPACE_DECL)) {
3310 if (parent == cur) {
3313 "xmlAddChild : parent == cur\n");
3318 * If cur is a TEXT node, merge its content with adjacent TEXT nodes
3319 * cur is then freed.
3321 if (cur->type == XML_TEXT_NODE) {
3324 (parent->name == cur->name)) {
3325 xmlNodeAddContent(parent, cur->content);
3326 xmlFreeNode(cur);
3330 (parent->last->name == cur->name) &&
3331 (parent->last != cur)) {
3332 xmlNodeAddContent(parent->last, cur->content);
3333 xmlFreeNode(cur);
3341 prev = cur->parent;
3342 cur->parent = parent;
3343 if (cur->doc != parent->doc) {
3344 xmlSetTreeDoc(cur, parent->doc);
3350 return(cur);
3357 (parent != cur)) {
3358 xmlNodeAddContent(parent, cur->content);
3359 xmlFreeNode(cur);
3362 if (cur->type == XML_ATTRIBUTE_NODE) {
3369 if (cur->ns == NULL)
3370 lastattr = xmlHasNsProp(parent, cur->name, NULL);
3372 lastattr = xmlHasNsProp(parent, cur->name, cur->ns->href);
3373 if ((lastattr != NULL) && (lastattr != (xmlAttrPtr) cur) && (lastattr->type != XML_ATTRIBUTE_DECL)) {
3378 if (lastattr == (xmlAttrPtr) cur)
3379 return(cur);
3383 parent->properties = (xmlAttrPtr) cur;
3390 lastattr->next = (xmlAttrPtr) cur;
3391 ((xmlAttrPtr) cur)->prev = lastattr;
3395 parent->children = cur;
3396 parent->last = cur;
3399 prev->next = cur;
3400 cur->prev = prev;
3401 parent->last = cur;
3404 return(cur);
3446 xmlNodePtr cur = NULL;
3455 cur = parent->children;
3460 while (cur != NULL) {
3461 if (cur->type == XML_ELEMENT_NODE)
3463 cur = cur->next;
3481 xmlNodePtr cur = NULL;
3490 cur = parent->children;
3495 while (cur != NULL) {
3496 if (cur->type == XML_ELEMENT_NODE)
3497 return(cur);
3498 cur = cur->next;
3516 xmlNodePtr cur = NULL;
3525 cur = parent->last;
3530 while (cur != NULL) {
3531 if (cur->type == XML_ELEMENT_NODE)
3532 return(cur);
3533 cur = cur->prev;
3621 * @cur: the first node in the list
3627 xmlFreeNodeList(xmlNodePtr cur) {
3631 if (cur == NULL) return;
3632 if (cur->type == XML_NAMESPACE_DECL) {
3633 xmlFreeNsList((xmlNsPtr) cur);
3636 if ((cur->type == XML_DOCUMENT_NODE) ||
3638 (cur->type == XML_DOCB_DOCUMENT_NODE) ||
3640 (cur->type == XML_HTML_DOCUMENT_NODE)) {
3641 xmlFreeDoc((xmlDocPtr) cur);
3644 if (cur->doc != NULL) dict = cur->doc->dict;
3645 while (cur != NULL) {
3646 next = cur->next;
3647 if (cur->type != XML_DTD_NODE) {
3650 xmlDeregisterNodeDefaultValue(cur);
3652 if ((cur->children != NULL) &&
3653 (cur->type != XML_ENTITY_REF_NODE))
3654 xmlFreeNodeList(cur->children);
3655 if (((cur->type == XML_ELEMENT_NODE) ||
3656 (cur->type == XML_XINCLUDE_START) ||
3657 (cur->type == XML_XINCLUDE_END)) &&
3658 (cur->properties != NULL))
3659 xmlFreePropList(cur->properties);
3660 if ((cur->type != XML_ELEMENT_NODE) &&
3661 (cur->type != XML_XINCLUDE_START) &&
3662 (cur->type != XML_XINCLUDE_END) &&
3663 (cur->type != XML_ENTITY_REF_NODE) &&
3664 (cur->content != (xmlChar *) &(cur->properties))) {
3665 DICT_FREE(cur->content)
3667 if (((cur->type == XML_ELEMENT_NODE) ||
3668 (cur->type == XML_XINCLUDE_START) ||
3669 (cur->type == XML_XINCLUDE_END)) &&
3670 (cur->nsDef != NULL))
3671 xmlFreeNsList(cur->nsDef);
3679 if ((cur->name != NULL) &&
3680 (cur->type != XML_TEXT_NODE) &&
3681 (cur->type != XML_COMMENT_NODE))
3682 DICT_FREE(cur->name)
3683 xmlFree(cur);
3685 cur = next;
3691 * @cur: the node
3697 xmlFreeNode(xmlNodePtr cur) {
3700 if (cur == NULL) return;
3703 if (cur->type == XML_DTD_NODE) {
3704 xmlFreeDtd((xmlDtdPtr) cur);
3707 if (cur->type == XML_NAMESPACE_DECL) {
3708 xmlFreeNs((xmlNsPtr) cur);
3711 if (cur->type == XML_ATTRIBUTE_NODE) {
3712 xmlFreeProp((xmlAttrPtr) cur);
3717 xmlDeregisterNodeDefaultValue(cur);
3719 if (cur->doc != NULL) dict = cur->doc->dict;
3721 if (cur->type == XML_ENTITY_DECL) {
3722 xmlEntityPtr ent = (xmlEntityPtr) cur;
3726 if ((cur->children != NULL) &&
3727 (cur->type != XML_ENTITY_REF_NODE))
3728 xmlFreeNodeList(cur->children);
3729 if (((cur->type == XML_ELEMENT_NODE) ||
3730 (cur->type == XML_XINCLUDE_START) ||
3731 (cur->type == XML_XINCLUDE_END)) &&
3732 (cur->properties != NULL))
3733 xmlFreePropList(cur->properties);
3734 if ((cur->type != XML_ELEMENT_NODE) &&
3735 (cur->content != NULL) &&
3736 (cur->type != XML_ENTITY_REF_NODE) &&
3737 (cur->type != XML_XINCLUDE_END) &&
3738 (cur->type != XML_XINCLUDE_START) &&
3739 (cur->content != (xmlChar *) &(cur->properties))) {
3740 DICT_FREE(cur->content)
3748 if ((cur->name != NULL) &&
3749 (cur->type != XML_TEXT_NODE) &&
3750 (cur->type != XML_COMMENT_NODE))
3751 DICT_FREE(cur->name)
3753 if (((cur->type == XML_ELEMENT_NODE) ||
3754 (cur->type == XML_XINCLUDE_START) ||
3755 (cur->type == XML_XINCLUDE_END)) &&
3756 (cur->nsDef != NULL))
3757 xmlFreeNsList(cur->nsDef);
3758 xmlFree(cur);
3763 * @cur: the node
3772 xmlUnlinkNode(xmlNodePtr cur) {
3773 if (cur == NULL) {
3780 if (cur->type == XML_NAMESPACE_DECL)
3782 if (cur->type == XML_DTD_NODE) {
3784 doc = cur->doc;
3786 if (doc->intSubset == (xmlDtdPtr) cur)
3788 if (doc->extSubset == (xmlDtdPtr) cur)
3792 if (cur->type == XML_ENTITY_DECL) {
3794 doc = cur->doc;
3797 if (xmlHashLookup(doc->intSubset->entities, cur->name) == cur)
3798 xmlHashRemoveEntry(doc->intSubset->entities, cur->name,
3800 if (xmlHashLookup(doc->intSubset->pentities, cur->name) == cur)
3801 xmlHashRemoveEntry(doc->intSubset->pentities, cur->name,
3805 if (xmlHashLookup(doc->extSubset->entities, cur->name) == cur)
3806 xmlHashRemoveEntry(doc->extSubset->entities, cur->name,
3808 if (xmlHashLookup(doc->extSubset->pentities, cur->name) == cur)
3809 xmlHashRemoveEntry(doc->extSubset->pentities, cur->name,
3814 if (cur->parent != NULL) {
3816 parent = cur->parent;
3817 if (cur->type == XML_ATTRIBUTE_NODE) {
3818 if (parent->properties == (xmlAttrPtr) cur)
3819 parent->properties = ((xmlAttrPtr) cur)->next;
3821 if (parent->children == cur)
3822 parent->children = cur->next;
3823 if (parent->last == cur)
3824 parent->last = cur->prev;
3826 cur->parent = NULL;
3828 if (cur->next != NULL)
3829 cur->next->prev = cur->prev;
3830 if (cur->prev != NULL)
3831 cur->prev->next = cur->next;
3832 cur->next = cur->prev = NULL;
3839 * @cur: the node
3842 * at the same place. If @cur was already inserted in a document it is
3848 xmlReplaceNode(xmlNodePtr old, xmlNodePtr cur) {
3849 if (old == cur) return(NULL);
3858 if ((cur == NULL) || (cur->type == XML_NAMESPACE_DECL)) {
3862 if (cur == old) {
3865 if ((old->type==XML_ATTRIBUTE_NODE) && (cur->type!=XML_ATTRIBUTE_NODE)) {
3872 if ((cur->type==XML_ATTRIBUTE_NODE) && (old->type!=XML_ATTRIBUTE_NODE)) {
3879 xmlUnlinkNode(cur);
3880 xmlSetTreeDoc(cur, old->doc);
3881 cur->parent = old->parent;
3882 cur->next = old->next;
3883 if (cur->next != NULL)
3884 cur->next->prev = cur;
3885 cur->prev = old->prev;
3886 if (cur->prev != NULL)
3887 cur->prev->next = cur;
3888 if (cur->parent != NULL) {
3889 if (cur->type == XML_ATTRIBUTE_NODE) {
3890 if (cur->parent->properties == (xmlAttrPtr)old)
3891 cur->parent->properties = ((xmlAttrPtr) cur);
3893 if (cur->parent->children == old)
3894 cur->parent->children = cur;
3895 if (cur->parent->last == old)
3896 cur->parent->last = cur;
3913 * @cur: the namespace
3920 xmlCopyNamespace(xmlNsPtr cur) {
3923 if (cur == NULL) return(NULL);
3924 switch (cur->type) {
3926 ret = xmlNewNs(NULL, cur->href, cur->prefix);
3931 "xmlCopyNamespace: invalid type %d\n", cur->type);
3940 * @cur: the first namespace
3947 xmlCopyNamespaceList(xmlNsPtr cur) {
3951 while (cur != NULL) {
3952 q = xmlCopyNamespace(cur);
3959 cur = cur->next;
3968 xmlCopyPropInternal(xmlDocPtr doc, xmlNodePtr target, xmlAttrPtr cur) {
3971 if (cur == NULL) return(NULL);
3975 ret = xmlNewDocProp(target->doc, cur->name, NULL);
3977 ret = xmlNewDocProp(doc, cur->name, NULL);
3978 else if (cur->parent != NULL)
3979 ret = xmlNewDocProp(cur->parent->doc, cur->name, NULL);
3980 else if (cur->children != NULL)
3981 ret = xmlNewDocProp(cur->children->doc, cur->name, NULL);
3983 ret = xmlNewDocProp(NULL, cur->name, NULL);
3987 if ((cur->ns != NULL) && (target != NULL)) {
3990 ns = xmlSearchNs(target->doc, target, cur->ns->prefix);
3997 ns = xmlSearchNs(cur->doc, cur->parent, cur->ns->prefix);
4018 if (xmlStrEqual(ns->href, cur->ns->href)) {
4026 ret->ns = xmlNewReconciliedNs(target->doc, target, cur->ns);
4033 if (cur->children != NULL) {
4036 ret->children = xmlStaticCopyNodeList(cur->children, ret->doc, (xmlNodePtr) ret);
4049 if ((target!= NULL) && (cur!= NULL) &&
4050 (target->doc != NULL) && (cur->doc != NULL) &&
4051 (cur->doc->ids != NULL) && (cur->parent != NULL)) {
4052 if (xmlIsID(cur->doc, cur->parent, cur)) {
4055 id = xmlNodeListGetString(cur->doc, cur->children, 1);
4068 * @cur: the attribute
4075 xmlCopyProp(xmlNodePtr target, xmlAttrPtr cur) {
4076 return xmlCopyPropInternal(NULL, target, cur);
4082 * @cur: the first attribute
4089 xmlCopyPropList(xmlNodePtr target, xmlAttrPtr cur) {
4095 while (cur != NULL) {
4096 q = xmlCopyProp(target, cur);
4106 cur = cur->next;
4401 xmlNodePtr cur, p = NULL, q;
4422 cur = dtd->children;
4423 while (cur != NULL) {
4426 if (cur->type == XML_ENTITY_DECL) {
4427 xmlEntityPtr tmp = (xmlEntityPtr) cur;
4442 } else if (cur->type == XML_ELEMENT_DECL) {
4443 xmlElementPtr tmp = (xmlElementPtr) cur;
4446 } else if (cur->type == XML_ATTRIBUTE_DECL) {
4447 xmlAttributePtr tmp = (xmlAttributePtr) cur;
4450 } else if (cur->type == XML_COMMENT_NODE) {
4451 q = xmlCopyNode(cur, 0);
4455 cur = cur->next;
4469 cur = cur->next;
4618 xmlNodePtr cur, tmp, next;
4644 cur = node;
4649 if ((cur->type == XML_DOCUMENT_NODE) ||
4650 (cur->type == XML_HTML_DOCUMENT_NODE)) {
4655 } else if (cur->type == XML_ELEMENT_NODE) {
4658 name = (const char *) cur->name;
4659 if (cur->ns) {
4660 if (cur->ns->prefix != NULL) {
4662 (char *)cur->ns->prefix, (char *)cur->name);
4674 next = cur->parent;
4680 tmp = cur->prev;
4684 (xmlStrEqual(cur->name, tmp->name) &&
4685 ((tmp->ns == cur->ns) ||
4686 ((tmp->ns != NULL) && (cur->ns != NULL) &&
4687 (xmlStrEqual(cur->ns->prefix, tmp->ns->prefix)))))))
4692 tmp = cur->next;
4696 (xmlStrEqual(cur->name, tmp->name) &&
4697 ((tmp->ns == cur->ns) ||
4698 ((tmp->ns != NULL) && (cur->ns != NULL) &&
4699 (xmlStrEqual(cur->ns->prefix, tmp->ns->prefix)))))))
4707 } else if (cur->type == XML_COMMENT_NODE) {
4710 next = cur->parent;
4715 tmp = cur->prev;
4722 tmp = cur->next;
4732 } else if ((cur->type == XML_TEXT_NODE) ||
4733 (cur->type == XML_CDATA_SECTION_NODE)) {
4736 next = cur->parent;
4741 tmp = cur->prev;
4753 tmp = cur->next;
4765 } else if (cur->type == XML_PI_NODE) {
4768 "processing-instruction('%s')", (char *)cur->name);
4772 next = cur->parent;
4777 tmp = cur->prev;
4780 (xmlStrEqual(cur->name, tmp->name)))
4785 tmp = cur->next;
4788 (xmlStrEqual(cur->name, tmp->name)))
4797 } else if (cur->type == XML_ATTRIBUTE_NODE) {
4799 name = (const char *) (((xmlAttrPtr) cur)->name);
4800 if (cur->ns) {
4801 if (cur->ns->prefix != NULL)
4803 (char *)cur->ns->prefix, (char *)cur->name);
4806 (char *)cur->name);
4810 next = ((xmlAttrPtr) cur)->parent;
4812 next = cur->parent;
4845 cur = next;
4846 } while (cur != NULL);
4920 * @cur: the node being changed
4927 xmlNodeSetLang(xmlNodePtr cur, const xmlChar *lang) {
4930 if (cur == NULL) return;
4931 switch(cur->type) {
4958 ns = xmlSearchNsByHref(cur->doc, cur, XML_XML_NAMESPACE);
4961 xmlSetNsProp(cur, ns, BAD_CAST "lang", lang);
4967 * @cur: the node being checked
4976 xmlNodeGetLang(xmlNodePtr cur) {
4979 if ((cur == NULL) || (cur->type == XML_NAMESPACE_DECL))
4981 while (cur != NULL) {
4982 lang = xmlGetNsProp(cur, BAD_CAST "lang", XML_XML_NAMESPACE);
4985 cur = cur->parent;
4994 * @cur: the node being changed
5001 xmlNodeSetSpacePreserve(xmlNodePtr cur, int val) {
5004 if (cur == NULL) return;
5005 switch(cur->type) {
5032 ns = xmlSearchNsByHref(cur->doc, cur, XML_XML_NAMESPACE);
5037 xmlSetNsProp(cur, ns, BAD_CAST "space", BAD_CAST "default");
5040 xmlSetNsProp(cur, ns, BAD_CAST "space", BAD_CAST "preserve");
5048 * @cur: the node being checked
5057 xmlNodeGetSpacePreserve(xmlNodePtr cur) {
5060 if ((cur == NULL) || (cur->type != XML_ELEMENT_NODE))
5062 while (cur != NULL) {
5063 space = xmlGetNsProp(cur, BAD_CAST "space", XML_XML_NAMESPACE);
5075 cur = cur->parent;
5083 * @cur: the node being changed
5089 xmlNodeSetName(xmlNodePtr cur, const xmlChar *name) {
5093 if (cur == NULL) return;
5095 switch(cur->type) {
5122 doc = cur->doc;
5128 if ((cur->name != NULL) && (!xmlDictOwns(dict, cur->name)))
5129 xmlFree((xmlChar *) cur->name);
5130 cur->name = xmlDictLookup(dict, name, -1);
5132 if (cur->name != NULL) xmlFree((xmlChar *) cur->name);
5133 cur->name = xmlStrdup(name);
5141 * @cur: the node being changed
5148 xmlNodeSetBase(xmlNodePtr cur, const xmlChar* uri) {
5152 if (cur == NULL) return;
5153 switch(cur->type) {
5179 xmlDocPtr doc = (xmlDocPtr) cur;
5191 ns = xmlSearchNsByHref(cur->doc, cur, XML_XML_NAMESPACE);
5196 xmlSetNsProp(cur, ns, BAD_CAST "base", fixed);
5199 xmlSetNsProp(cur, ns, BAD_CAST "base", uri);
5207 * @cur: the node being checked
5222 xmlNodeGetBase(xmlDocPtr doc, xmlNodePtr cur) {
5226 if ((cur == NULL) && (doc == NULL))
5228 if ((cur != NULL) && (cur->type == XML_NAMESPACE_DECL))
5230 if (doc == NULL) doc = cur->doc;
5232 cur = doc->children;
5233 while ((cur != NULL) && (cur->name != NULL)) {
5234 if (cur->type != XML_ELEMENT_NODE) {
5235 cur = cur->next;
5238 if (!xmlStrcasecmp(cur->name, BAD_CAST "html")) {
5239 cur = cur->children;
5242 if (!xmlStrcasecmp(cur->name, BAD_CAST "head")) {
5243 cur = cur->children;
5246 if (!xmlStrcasecmp(cur->name, BAD_CAST "base")) {
5247 return(xmlGetProp(cur, BAD_CAST "href"));
5249 cur = cur->next;
5253 while (cur != NULL) {
5254 if (cur->type == XML_ENTITY_DECL) {
5255 xmlEntityPtr ent = (xmlEntityPtr) cur;
5258 if (cur->type == XML_ELEMENT_NODE) {
5259 base = xmlGetNsProp(cur, BAD_CAST "base", XML_XML_NAMESPACE);
5281 cur = cur->parent;
5296 * @cur: the node being read
5298 * Read the value of a node @cur, this can be either the text carried
5307 xmlNodeBufGetContent(xmlBufferPtr buffer, xmlNodePtr cur)
5312 if ((cur == NULL) || (buffer == NULL)) return(-1);
5314 ret = xmlBufGetNodeContent(buf, cur);
5324 * @cur: the node being read
5326 * Read the value of a node @cur, this can be either the text carried
5335 xmlBufGetNodeContent(xmlBufPtr buf, xmlNodePtr cur)
5337 if ((cur == NULL) || (buf == NULL)) return(-1);
5338 switch (cur->type) {
5341 xmlBufCat(buf, cur->content);
5345 xmlNodePtr tmp = cur;
5369 if (tmp == cur)
5381 if (tmp == cur) {
5394 xmlAttrPtr attr = (xmlAttrPtr) cur;
5408 xmlBufCat(buf, cur->content);
5415 ent = xmlGetDocEntity(cur->doc, cur->name);
5443 cur = cur->children;
5444 while (cur!= NULL) {
5445 if ((cur->type == XML_ELEMENT_NODE) ||
5446 (cur->type == XML_TEXT_NODE) ||
5447 (cur->type == XML_CDATA_SECTION_NODE)) {
5448 xmlBufGetNodeContent(buf, cur);
5450 cur = cur->next;
5454 xmlBufCat(buf, ((xmlNsPtr) cur)->href);
5466 * @cur: the node being read
5476 xmlNodeGetContent(xmlNodePtr cur)
5478 if (cur == NULL)
5480 switch (cur->type) {
5489 xmlBufGetNodeContent(buf, cur);
5495 return(xmlGetPropNodeValueInternal((xmlAttrPtr) cur));
5498 if (cur->content != NULL)
5499 return (xmlStrdup(cur->content));
5507 ent = xmlGetDocEntity(cur->doc, cur->name);
5515 xmlBufGetNodeContent(buf, cur);
5540 xmlBufGetNodeContent(buf, (xmlNodePtr) cur);
5549 tmp = xmlStrdup(((xmlNsPtr) cur)->href);
5563 if (cur->content != NULL)
5564 return (xmlStrdup(cur->content));
5572 * @cur: the node being modified
5581 xmlNodeSetContent(xmlNodePtr cur, const xmlChar *content) {
5582 if (cur == NULL) {
5589 switch (cur->type) {
5593 if (cur->children != NULL) xmlFreeNodeList(cur->children);
5594 cur->children = xmlStringGetNodeList(cur->doc, content);
5595 UPDATE_LAST_CHILD_AND_PARENT(cur)
5603 if ((cur->content != NULL) &&
5604 (cur->content != (xmlChar *) &(cur->properties))) {
5605 if (!((curcur->doc->dict != NULL) &&
5606 (xmlDictOwns(cur->doc->dict, cur->content))))
5607 xmlFree(cur->content);
5609 if (cur->children != NULL) xmlFreeNodeList(cur->children);
5610 cur->last = cur->children = NULL;
5612 cur->content = xmlStrdup(content);
5614 cur->content = NULL;
5615 cur->properties = NULL;
5616 cur->nsDef = NULL;
5648 * @cur: the node being modified
5658 xmlNodeSetContentLen(xmlNodePtr cur, const xmlChar *content, int len) {
5659 if (cur == NULL) {
5666 switch (cur->type) {
5670 if (cur->children != NULL) xmlFreeNodeList(cur->children);
5671 cur->children = xmlStringLenGetNodeList(cur->doc, content, len);
5672 UPDATE_LAST_CHILD_AND_PARENT(cur)
5681 if ((cur->content != NULL) &&
5682 (cur->content != (xmlChar *) &(cur->properties))) {
5683 if (!((cur->doc != NULL) && (cur->doc->dict != NULL) &&
5684 (xmlDictOwns(cur->doc->dict, cur->content))))
5685 xmlFree(cur->content);
5687 if (cur->children != NULL) xmlFreeNodeList(cur->children);
5688 cur->children = cur->last = NULL;
5690 cur->content = xmlStrndup(content, len);
5692 cur->content = NULL;
5693 cur->properties = NULL;
5694 cur->nsDef = NULL;
5722 * @cur: the node being modified
5732 xmlNodeAddContentLen(xmlNodePtr cur, const xmlChar *content, int len) {
5733 if (cur == NULL) {
5741 switch (cur->type) {
5746 last = cur->last;
5749 tmp = xmlAddChild(cur, newNode);
5768 if ((cur->content == (xmlChar *) &(cur->properties)) ||
5769 ((cur->doc != NULL) && (cur->doc->dict != NULL) &&
5770 xmlDictOwns(cur->doc->dict, cur->content))) {
5771 cur->content = xmlStrncatNew(cur->content, content, len);
5772 cur->properties = NULL;
5773 cur->nsDef = NULL;
5776 cur->content = xmlStrncat(cur->content, content, len);
5798 * @cur: the node being modified
5807 xmlNodeAddContent(xmlNodePtr cur, const xmlChar *content) {
5810 if (cur == NULL) {
5819 xmlNodeAddContentLen(cur, content, len);
5858 xmlNsPtr cur;
5869 cur = node->nsDef;
5870 while (cur != NULL) {
5882 if ((cur->prefix == ret[i]->prefix) ||
5883 (xmlStrEqual(cur->prefix, ret[i]->prefix)))
5898 ret[nbns++] = cur;
5902 cur = cur->next;
5962 xmlNsPtr cur;
5974 cur = (xmlNsPtr) xmlMalloc(sizeof(xmlNs));
5975 if (cur == NULL) {
5979 memset(cur, 0, sizeof(xmlNs));
5980 cur->type = XML_LOCAL_NAMESPACE;
5981 cur->href = xmlStrdup(XML_XML_NAMESPACE);
5982 cur->prefix = xmlStrdup((const xmlChar *)"xml");
5983 cur->next = node->nsDef;
5984 node->nsDef = cur;
5985 return(cur);
6006 cur = node->nsDef;
6007 while (cur != NULL) {
6008 if ((cur->prefix == NULL) && (nameSpace == NULL) &&
6009 (cur->href != NULL))
6010 return(cur);
6011 if ((cur->prefix != NULL) && (nameSpace != NULL) &&
6012 (cur->href != NULL) &&
6013 (xmlStrEqual(cur->prefix, nameSpace)))
6014 return(cur);
6015 cur = cur->next;
6018 cur = node->ns;
6019 if (cur != NULL) {
6020 if ((cur->prefix == NULL) && (nameSpace == NULL) &&
6021 (cur->href != NULL))
6022 return(cur);
6023 if ((cur->prefix != NULL) && (nameSpace != NULL) &&
6024 (cur->href != NULL) &&
6025 (xmlStrEqual(cur->prefix, nameSpace)))
6026 return(cur);
6091 xmlNsPtr cur;
6107 cur = (xmlNsPtr) xmlMalloc(sizeof(xmlNs));
6108 if (cur == NULL) {
6112 memset(cur, 0, sizeof(xmlNs));
6113 cur->type = XML_LOCAL_NAMESPACE;
6114 cur->href = xmlStrdup(XML_XML_NAMESPACE);
6115 cur->prefix = xmlStrdup((const xmlChar *) "xml");
6116 cur->next = node->nsDef;
6117 node->nsDef = cur;
6118 return (cur);
6140 cur = node->nsDef;
6141 while (cur != NULL) {
6142 if ((cur->href != NULL) && (href != NULL) &&
6143 (xmlStrEqual(cur->href, href))) {
6144 if (((!is_attr) || (cur->prefix != NULL)) &&
6145 (xmlNsInScope(doc, orig, node, cur->prefix) == 1))
6146 return (cur);
6148 cur = cur->next;
6151 cur = node->ns;
6152 if (cur != NULL) {
6153 if ((cur->href != NULL) && (href != NULL) &&
6154 (xmlStrEqual(cur->href, href))) {
6155 if (((!is_attr) || (cur->prefix != NULL)) &&
6156 (xmlNsInScope(doc, orig, node, cur->prefix) == 1))
6157 return (cur);
6503 xmlNsPtr *nsList, *cur;
6515 cur = nsList;
6516 while (*cur != NULL) {
6517 if (xmlStrEqual((*cur)->href, nsName)) {
6519 name, (*cur)->prefix);
6524 name, (*cur)->prefix);
6529 cur++;
6902 const xmlChar *cur;
6909 cur = node->content;
6910 while (*cur != 0) {
6911 if (!IS_BLANK_CH(*cur)) return(0);
6912 cur++;
7588 const char *cur;
7600 for (cur = str;*cur != 0;cur++) {
7607 buf->content[buf->use++] = *cur;
7657 const xmlChar *cur, *base;
7668 base = cur = string;
7669 while(*cur != 0){
7670 if(*cur == '"'){
7671 if (base != cur)
7672 xmlBufferAdd(buf, base, cur - base);
7674 cur++;
7675 base = cur;
7678 cur++;
7681 if (base != cur)
7682 xmlBufferAdd(buf, base, cur - base);
7804 xmlNsMapItemPtr cur, tmp;
7808 cur = nsmap->pool;
7809 while (cur != NULL) {
7810 tmp = cur;
7811 cur = cur->next;
7814 cur = nsmap->first;
7815 while (cur != NULL) {
7816 tmp = cur;
7817 cur = cur->next;
8036 xmlNodePtr cur;
8048 cur = node;
8049 while ((cur != NULL) && (cur != (xmlNodePtr) cur->doc)) {
8050 if (cur->type == XML_ELEMENT_NODE) {
8051 if (cur->nsDef != NULL) {
8052 ns = cur->nsDef;
8080 cur = cur->parent;
8110 xmlDictOwns(sourceDoc->dict, cur->content)) { \
8112 cur->content = (xmlChar *) \
8113 xmlDictLookup(destDoc->dict, cur->content, -1); \
8115 cur->content = xmlStrdup(BAD_CAST cur->content); \
8307 xmlNodePtr cur, prev = NULL, out = NULL;
8322 cur = node;
8324 if (cur->type == XML_ELEMENT_NODE) {
8325 if (cur->nsDef != NULL) {
8326 for (ns = cur->nsDef; ns != NULL; ns = ns->next) {
8381 prev = cur;
8383 } else if ((cur->type == XML_ENTITY_NODE) ||
8384 (cur->type == XML_ENTITY_DECL))
8386 cur = cur->parent;
8387 } while ((cur != NULL) && (cur->doc != (xmlDocPtr) cur));
8409 xmlNodePtr cur;
8425 cur = node;
8427 if (cur->type == XML_ELEMENT_NODE) {
8428 if (cur->nsDef != NULL) {
8429 ns = cur->nsDef;
8446 } else if ((cur->type == XML_ENTITY_NODE) ||
8447 (cur->type == XML_ENTITY_DECL))
8449 cur = cur->parent;
8450 } while ((cur != NULL) && (cur->doc != (xmlDocPtr) cur));
8698 xmlNodePtr cur, curElem = NULL;
8713 cur = elem;
8715 switch (cur->type) {
8718 curElem = cur;
8723 if (cur->nsDef != NULL) {
8725 ns = cur->nsDef;
8765 cur->nsDef = ns->next;
8775 if ((cur->ns != NULL) && adoptns && (cur->ns == ns))
8808 if (cur->ns == NULL)
8825 if (cur->ns == listRedund[j]) {
8826 cur->ns = listRedund[++j];
8840 (cur->ns == mi->oldNs)) {
8842 cur->ns = mi->newNs;
8851 cur->ns, &ns,
8854 (cur->type == XML_ATTRIBUTE_NODE) ? 1 : 0) == -1)
8856 cur->ns = ns;
8859 if ((cur->type == XML_ELEMENT_NODE) &&
8860 (cur->properties != NULL)) {
8864 cur = (xmlNodePtr) cur->properties;
8872 if ((cur->type == XML_ELEMENT_NODE) &&
8873 (cur->children != NULL)) {
8877 cur = cur->children;
8881 if (cur == elem)
8883 if (cur->type == XML_ELEMENT_NODE) {
8903 if (cur->next != NULL)
8904 cur = cur->next;
8906 if (cur->type == XML_ATTRIBUTE_NODE) {
8907 cur = cur->parent;
8910 cur = cur->parent;
8913 } while (cur != NULL);
8962 xmlNodePtr cur, curElem = NULL;
8999 cur = node;
9000 if ((cur != NULL) && (cur->type == XML_NAMESPACE_DECL))
9003 while (cur != NULL) {
9007 if (cur->doc != sourceDoc) {
9014 if (cur->next == NULL)
9017 cur = cur->next;
9018 if ((cur->type == XML_XINCLUDE_END) ||
9019 (cur->doc == node->doc))
9021 } while (cur->next != NULL);
9023 if (cur->doc != node->doc)
9026 cur->doc = destDoc;
9027 switch (cur->type) {
9035 curElem = cur;
9045 if ((cur->nsDef) &&
9057 for (ns = cur->nsDef; ns != NULL; ns = ns->next) {
9089 if (cur->ns == NULL)
9107 (cur->ns == mi->oldNs)) {
9109 cur->ns = mi->newNs;
9121 ns = ctxt->getNsForNodeFunc(ctxt, cur,
9122 cur->ns->href, cur->ns->prefix);
9128 cur->ns, ns, XML_TREE_NSMAP_CUSTOM) == NULL)
9130 cur->ns = ns;
9138 cur->ns, &ns,
9142 (cur->type == XML_ATTRIBUTE_NODE) ? 1 : 0) == -1)
9144 cur->ns = ns;
9151 XML_TREE_ADOPT_STR(cur->name)
9152 if (cur->type == XML_ELEMENT_NODE) {
9153 cur->psvi = NULL;
9154 cur->line = 0;
9155 cur->extra = 0;
9159 if (cur->properties != NULL) {
9163 cur = (xmlNodePtr) cur->properties;
9171 (((xmlAttrPtr) cur)->atype == XML_ATTRIBUTE_ID))
9173 xmlRemoveID(sourceDoc, (xmlAttrPtr) cur);
9175 ((xmlAttrPtr) cur)->atype = 0;
9176 ((xmlAttrPtr) cur)->psvi = NULL;
9185 XML_TREE_ADOPT_STR_2(cur->content)
9191 cur->content = NULL;
9192 cur->children = NULL;
9193 cur->last = NULL;
9199 ent = xmlGetDocEntity(destDoc, cur->name);
9201 cur->content = ent->content;
9202 cur->children = (xmlNodePtr) ent;
9203 cur->last = (xmlNodePtr) ent;
9208 XML_TREE_ADOPT_STR(cur->name)
9209 XML_TREE_ADOPT_STR_2(cur->content)
9219 if (cur->children != NULL) {
9220 cur = cur->children;
9225 if (cur == node)
9227 if ((cur->type == XML_ELEMENT_NODE) ||
9228 (cur->type == XML_XINCLUDE_START) ||
9229 (cur->type == XML_XINCLUDE_END))
9253 if (cur->next != NULL)
9254 cur = cur->next;
9255 else if ((cur->type == XML_ATTRIBUTE_NODE) &&
9256 (cur->parent->children != NULL))
9258 cur = cur->parent->children;
9260 cur = cur->parent;
9332 xmlNodePtr cur, curElem = NULL;
9381 cur = node;
9382 if ((cur != NULL) && (cur->type == XML_NAMESPACE_DECL))
9385 while (cur != NULL) {
9386 if (cur->doc != sourceDoc) {
9397 switch (cur->type) {
9467 clone->type = cur->type;
9473 if (cur->name == xmlStringText)
9475 else if (cur->name == xmlStringTextNoenc)
9482 else if (cur->name == xmlStringComment)
9484 else if (cur->name != NULL) {
9485 DICT_CONST_COPY(cur->name, clone->name);
9488 switch (cur->type) {
9496 curElem = cur;
9501 if (cur->nsDef != NULL) {
9517 for (ns = cur->nsDef; ns != NULL; ns = ns->next) {
9573 /* cur->ns will be processed further down. */
9577 /* cur->ns will be processed further down. */
9584 DICT_COPY(cur->content, clone->content);
9596 ent = xmlGetDocEntity(destDoc, cur->name);
9608 clone->content = cur->content;
9609 clone->children = cur->children;
9610 clone->last = cur->last;
9614 DICT_COPY(cur->content, clone->content);
9617 DICT_COPY(cur->content, clone->content);
9623 if (cur->ns == NULL)
9648 (cur->ns == mi->oldNs)) {
9664 ns = ctxt->getNsForNodeFunc(ctxt, cur,
9665 cur->ns->href, cur->ns->prefix);
9670 cur->ns, ns, XML_TREE_NSMAP_CUSTOM) == NULL)
9680 cur->ns, &ns,
9685 (cur->type == XML_ATTRIBUTE_NODE) ? 1 : 0) == -1)
9704 idVal = xmlNodeListGetString(cur->doc, cur->children, 1);
9706 if (xmlAddID(NULL, destDoc, idVal, (xmlAttrPtr) cur) == NULL) {
9722 if ((cur->type == XML_ELEMENT_NODE) && (cur->properties != NULL)) {
9725 cur = (xmlNodePtr) cur->properties;
9732 if (cur->children != NULL) {
9733 if (deep || (cur->type == XML_ATTRIBUTE_NODE)) {
9736 cur = cur->children;
9746 if (cur == node)
9748 if ((cur->type == XML_ELEMENT_NODE) ||
9749 (cur->type == XML_XINCLUDE_START) ||
9750 (cur->type == XML_XINCLUDE_END)) {
9773 if (cur->next != NULL) {
9775 cur = cur->next;
9776 } else if (cur->type != XML_ATTRIBUTE_NODE) {
9787 cur = cur->parent;
9796 cur = cur->parent;
9855 xmlNodePtr cur;
9901 cur = attr->children;
9902 if ((cur != NULL) && (cur->type == XML_NAMESPACE_DECL))
9904 while (cur != NULL) {
9905 cur->doc = destDoc;
9906 switch (cur->type) {
9909 XML_TREE_ADOPT_STR_2(cur->content)
9915 cur->content = NULL;
9916 cur->children = NULL;
9917 cur->last = NULL;
9923 ent = xmlGetDocEntity(destDoc, cur->name);
9925 cur->content = ent->content;
9926 cur->children = (xmlNodePtr) ent;
9927 cur->last = (xmlNodePtr) ent;
9934 if (cur->children != NULL) {
9935 cur = cur->children;
9939 if (cur == (xmlNodePtr) attr)
9941 if (cur->next != NULL)
9942 cur = cur->next;
9944 cur = cur->parent;
10034 xmlNodePtr cur = node;
10037 cur->doc = destDoc;
