Lines Matching refs:node
68 #define MutationEvent2(type,node)
69 #define MutationEvent3(type,node,relatioNode)
470 * This helper procedure returns if node precedes other with regard
476 * 1 if node precedes other in document order, 0 otherwise.
486 domNode *node,
493 if (node == other) {
497 if (node->nodeType == ATTRIBUTE_NODE) {
498 attrN = (domAttrNode*)node;
511 node = attrN->parentNode;
518 node = attrN->parentNode;
524 if (node == attrO->parentNode) {
531 if (node->ownerDocument != other->ownerDocument) {
537 return (node->ownerDocument->documentNumber <
542 if (node->ownerDocument->nodeFlags & NEEDS_RENUMBERING) {
543 domRenumberTree (node->ownerDocument->rootNode);
544 node->ownerDocument->nodeFlags &= ~NEEDS_RENUMBERING;
546 return (node->nodeNumber < other->nodeNumber);
548 if (!(node->ownerDocument->nodeFlags & NEEDS_RENUMBERING)) {
549 return (node->nodeNumber < other->nodeNumber);
556 if (otherAncestor == node) {
562 nodeAncestor = node;
590 if (node == node->ownerDocument->rootNode) {
602 domNode *node
605 while (node) {
606 node->nodeNumber = NODE_NO(node->ownerDocument);
607 if (node->nodeType == ELEMENT_NODE) {
608 domRenumberTree (node->firstChild);
610 node = node->nextSibling;
620 domNode *node,
637 ns = domLookupPrefix (node, prefix);
648 domNode *node,
653 domNode *orgNode = node;
657 while (node) {
658 if (node->firstAttr && !(node->firstAttr->nodeFlags & IS_NS_NODE)) {
659 node = node->parentNode;
662 NSattr = node->firstAttr;
679 return domGetNamespaceByIndex (node->ownerDocument,
682 node = node->parentNode;
728 domNode *node,
737 while (node) {
738 if (node->firstAttr && !(node->firstAttr->nodeFlags & IS_NS_NODE)) {
739 node = node->parentNode;
742 NSattr = node->firstAttr;
762 return domGetNamespaceByIndex (node->ownerDocument,
765 node = node->parentNode;
873 domNode *node
879 if (!node->namespace) return NULL;
880 if (node->nodeType == ATTRIBUTE_NODE) {
881 attr = (domAttrNode*)node;
885 if (node->nodeType == ELEMENT_NODE) {
886 ns = node->ownerDocument->namespaces[node->namespace-1];
900 domNode *node
906 if (!node->namespace) return NULL;
907 if (node->nodeType == ATTRIBUTE_NODE) {
908 attr = (domAttrNode*)node;
911 if (node->nodeType == ELEMENT_NODE) {
912 ns = node->ownerDocument->namespaces[node->namespace-1];
942 * Search a given node for an attribute with namespace "uri" and
957 domNode *node, /* The attributes of this node are searched for a
958 matching attribute; the node must exist */
972 attr = node->firstAttr;
984 ns = domGetNamespaceByIndex (node->ownerDocument,
1002 * Returns the previous node to the given node or NULL, if there
1003 * is no previous node. This function is needed in situations,
1004 * where the given node may also be an domAttrNode. Namespace
1010 * specific order of the attributes of a node.
1013 * A pointer to the previous node of the given one
1014 * or NULL, if there isn't a previous node.
1024 domNode *node /* The reference attribute */
1029 if (node->nodeType != ATTRIBUTE_NODE) {
1030 return node->previousSibling;
1033 attr = (domAttrNode*) node;
1063 domNode *node, *parentNode;
1099 node = (domNode*) domAlloc(sizeof(domNode)
1102 node = (domNode*) domAlloc(sizeof(domNode));
1104 memset(node, 0, sizeof(domNode));
1105 node->nodeType = ELEMENT_NODE;
1106 node->nodeFlags = 0;
1107 node->namespace = 0;
1108 node->nodeName = (char *)&(h->key);
1109 node->nodeNumber = NODE_NO(info->document);
1110 node->ownerDocument = info->document;
1115 (char*) node,
1118 node->nodeFlags |= HAS_BASEURI;
1134 info->document->rootNode->lastChild->nextSibling = node;
1135 node->previousSibling = info->document->rootNode->lastChild;
1137 info->document->rootNode->firstChild = node;
1139 info->document->rootNode->lastChild = node;
1142 node->parentNode = parentNode;
1144 parentNode->lastChild->nextSibling = node;
1145 node->previousSibling = parentNode->lastChild;
1146 parentNode->lastChild = node;
1148 parentNode->firstChild = parentNode->lastChild = node;
1151 info->currentNode = node;
1153 lc = (domLineColumn*) ( ((char*)node) + sizeof(domNode));
1154 node->nodeFlags |= HAS_LINE_COLUMN;
1204 attrnode->parentNode = node;
1212 if (node->firstAttr) {
1215 node->firstAttr = attrnode;
1240 node->namespace = info->activeNS[pos].namespace->index;
1242 node->nodeName,
1250 node->namespace = info->document->rootNode->firstAttr->namespace;
1280 Tcl_SetHashValue (h, node);
1307 attrnode->parentNode = node;
1316 if (node->firstAttr) {
1319 node->firstAttr = attrnode;
1423 domTextNode *node;
1443 /* normalize text node, i.e. there are no adjacent text nodes */
1444 node = (domTextNode*)parentNode->lastChild;
1445 node->nodeValue = REALLOC(node->nodeValue, node->valueLength + len);
1446 memmove(node->nodeValue + node->valueLength, s, len);
1447 node->valueLength += len;
1472 node = (domTextNode*) domAlloc(sizeof(domTextNode)
1475 node = (domTextNode*) domAlloc(sizeof(domTextNode));
1477 memset(node, 0, sizeof(domTextNode));
1478 node->nodeType = TEXT_NODE;
1479 node->nodeFlags = 0;
1480 node->namespace = 0;
1481 node->nodeNumber = NODE_NO(info->document);
1482 node->valueLength = len;
1483 node->nodeValue = (char*)MALLOC(len);
1484 memmove(node->nodeValue, s, len);
1486 node->ownerDocument = info->document;
1487 node->parentNode = parentNode;
1490 parentNode->lastChild->nextSibling = (domNode*)node;
1491 node->previousSibling = parentNode->lastChild;
1493 parentNode->firstChild = (domNode*)node;
1495 parentNode->lastChild = (domNode*)node;
1501 (char*) node,
1504 node->nodeFlags |= HAS_BASEURI;
1508 lc = (domLineColumn*) ( ((char*)node) + sizeof(domTextNode) );
1509 node->nodeFlags |= HAS_LINE_COLUMN;
1529 domTextNode *node;
1549 node = (domTextNode*) domAlloc(sizeof(domTextNode)
1552 node = (domTextNode*) domAlloc(sizeof(domTextNode));
1554 memset(node, 0, sizeof(domTextNode));
1555 node->nodeType = COMMENT_NODE;
1556 node->nodeFlags = 0;
1557 node->namespace = 0;
1558 node->nodeNumber = NODE_NO(info->document);
1559 node->valueLength = len;
1560 node->nodeValue = (char*)MALLOC(len);
1561 memmove(node->nodeValue, s, len);
1563 node->ownerDocument = info->document;
1564 node->parentNode = parentNode;
1567 info->document->rootNode->lastChild->nextSibling = (domNode*)node;
1568 node->previousSibling = info->document->rootNode->lastChild;
1570 info->document->rootNode->firstChild = (domNode*)node;
1572 info->document->rootNode->lastChild = (domNode*)node;
1575 parentNode->lastChild->nextSibling = (domNode*)node;
1576 node->previousSibling = parentNode->lastChild;
1577 parentNode->lastChild = (domNode*)node;
1579 parentNode->firstChild = parentNode->lastChild = (domNode*)node;
1586 (char*) node,
1589 node->nodeFlags |= HAS_BASEURI;
1593 lc = (domLineColumn*) ( ((char*)node) + sizeof(domTextNode) );
1594 node->nodeFlags |= HAS_LINE_COLUMN;
1612 domProcessingInstructionNode *node;
1630 node = (domProcessingInstructionNode*)
1634 node = (domProcessingInstructionNode*)
1637 memset(node, 0, sizeof(domProcessingInstructionNode));
1638 node->nodeType = PROCESSING_INSTRUCTION_NODE;
1639 node->nodeFlags = 0;
1640 node->namespace = 0;
1641 node->nodeNumber = NODE_NO(info->document);
1646 (char*) node,
1649 node->nodeFlags |= HAS_BASEURI;
1656 node->targetLength = len;
1657 node->targetValue = (char*)MALLOC(len);
1658 memmove(node->targetValue, target, len);
1664 node->dataLength = len;
1665 node->dataValue = (char*)MALLOC(len);
1666 memmove(node->dataValue, data, len);
1668 node->ownerDocument = info->document;
1669 node->parentNode = parentNode;
1672 info->document->rootNode->lastChild->nextSibling = (domNode*)node;
1673 node->previousSibling = info->document->rootNode->lastChild;
1675 info->document->rootNode->firstChild = (domNode*)node;
1677 info->document->rootNode->lastChild = (domNode*)node;
1680 parentNode->lastChild->nextSibling = (domNode*)node;
1681 node->previousSibling = parentNode->lastChild;
1682 parentNode->lastChild = (domNode*)node;
1684 parentNode->firstChild = parentNode->lastChild = (domNode*)node;
1688 lc = (domLineColumn*)(((char*)node)+sizeof(domProcessingInstructionNode));
1689 node->nodeFlags |= HAS_LINE_COLUMN;
2173 domNode *node,
2184 if (node->nodeFlags & HAS_LINE_COLUMN) {
2185 v = (char*)node;
2186 switch (node->nodeType) {
2251 * The domDocument node:
2339 domNode *node;
2379 node = (domNode*) domAlloc(sizeof(domNode));
2380 memset(node, 0, sizeof(domNode));
2381 node->nodeType = ELEMENT_NODE;
2382 node->nodeFlags = 0;
2383 node->nodeNumber = NODE_NO(doc);
2384 node->ownerDocument = doc;
2385 node->nodeName = (char *)&(h->key);
2386 doc->documentElement = node;
2389 node->namespace = ns->index;
2390 domAddNSToNode (node, ns);
2407 domNode *node;
2410 node = doc->rootNode->firstChild;
2411 while (node) {
2412 if (node->nodeType == ELEMENT_NODE) {
2413 doc->documentElement = node;
2416 node = node->nextSibling;
2429 domNode * node,
2440 if (node == NULL) {
2445 shared = node->ownerDocument && node->ownerDocument->refCount > 1;
2449 | dontfree instruct us to walk the node tree and apply the
2459 node->nodeFlags |= IS_DELETED;
2462 if (node->nodeType == ATTRIBUTE_NODE && !shared) {
2463 attr = ((domAttrNode*)node)->parentNode->firstAttr;
2465 while (attr && (attr != (domAttrNode*)node)) {
2473 ((domAttrNode*)node)->parentNode->firstAttr = attr->nextSibling;
2478 } else if (node->nodeType == ELEMENT_NODE) {
2479 child = node->lastChild;
2491 attr = node->firstAttr;
2498 if (node->nodeFlags & HAS_BASEURI) {
2499 entryPtr = Tcl_FindHashEntry (node->ownerDocument->baseURIs,
2500 (char*)node);
2506 domFree ((void*)node);
2508 } else if (node->nodeType == PROCESSING_INSTRUCTION_NODE && !shared) {
2509 FREE (((domProcessingInstructionNode*)node)->dataValue);
2510 FREE (((domProcessingInstructionNode*)node)->targetValue);
2511 domFree ((void*)node);
2514 FREE (((domTextNode*)node)->nodeValue);
2515 domFree ((void*)node);
2521 | domDeleteNode - unlinks node from tree and free all child nodes
2527 domNode * node,
2535 if (node->nodeType == ATTRIBUTE_NODE) {
2539 shared = node->ownerDocument->refCount > 1;
2541 doc = node->ownerDocument;
2544 | unlink node from child or fragment list
2546 if (node->previousSibling) {
2547 node->previousSibling->nextSibling = node->nextSibling;
2549 if (node->parentNode) {
2550 node->parentNode->firstChild = node->nextSibling;
2552 /* Node may be a top level node */
2553 if (doc->rootNode->firstChild == node) {
2554 doc->rootNode->firstChild = node->nextSibling;
2558 if (node->nextSibling) {
2559 node->nextSibling->previousSibling = node->previousSibling;
2561 if (node->parentNode) {
2562 node->parentNode->lastChild = node->previousSibling;
2564 /* Node may be a top level node */
2565 if (doc->rootNode->lastChild == node) {
2566 doc->rootNode->lastChild = node->previousSibling;
2570 if (doc->fragments == node) {
2571 doc->fragments = node->nextSibling;
2573 if (!node->parentNode) {
2578 | for shared docs, append node to the delete nodes list
2579 | otherwise delete the node physically
2582 freeCB(node, clientData);
2587 doc->deletedNodes->nextDeleted = node;
2589 doc->deletedNodes = node;
2591 node->nodeFlags |= IS_DELETED;
2592 node->nextDeleted = NULL;
2595 MutationEvent3(DOMNodeRemoved, childToRemove, node);
2596 MutationEvent2(DOMSubtreeModified, node);
2597 domFreeNode(node, freeCB, clientData, 0);
2614 domNode *node, *next;
2627 node = doc->rootNode;
2628 if (node) {
2630 freeCB(node, clientData);
2632 domFreeNode (node, freeCB, clientData, dontfree);
2638 node = doc->fragments;
2639 while (node) {
2640 next = node->nextSibling;
2642 freeCB(node, clientData);
2644 domFreeNode (node, freeCB, clientData, dontfree);
2645 node = next;
2761 node = doc->deletedNodes;
2762 while (node) {
2763 next = node->nextSibling;
2764 domFreeNode (node, freeCB, clientData, 0);
2765 node = next;
2779 domNode *node,
2788 if (!node || node->nodeType != ELEMENT_NODE) {
2795 attr = node->firstAttr;
2801 h = Tcl_FindHashEntry (node->ownerDocument->ids, attr->nodeValue);
2804 h = Tcl_CreateHashEntry (node->ownerDocument->ids,
2807 Tcl_SetHashValue (h, node);
2816 | add a complete new attribute node
2820 h = Tcl_CreateHashEntry(&HASHTAB(node->ownerDocument,tdom_attrNames),
2826 attr->parentNode = node;
2831 if (node->firstAttr) {
2832 lastAttr = node->firstAttr;
2837 node->firstAttr = attr;
2850 domNode *node,
2866 if (!node || node->nodeType != ELEMENT_NODE) {
2879 ns = domLookupPrefix (node, "");
2881 ns = domLookupPrefix (node, prefix);
2904 attr = node->firstAttr;
2915 ns = domGetNamespaceByIndex (node->ownerDocument,
2934 h = Tcl_FindHashEntry (node->ownerDocument->ids, attr->nodeValue);
2937 h = Tcl_CreateHashEntry (node->ownerDocument->ids,
2939 Tcl_SetHashValue (h, node);
2948 | add a complete new attribute node
2952 h = Tcl_CreateHashEntry(&HASHTAB(node->ownerDocument,tdom_attrNames),
2958 ns = domLookupNamespace (node->ownerDocument, "", uri);
2960 ns = domLookupNamespace (node->ownerDocument, localName, uri);
2963 ns = domLookupPrefix (node, prefix);
2969 ns = domNewNamespace (node->ownerDocument, "", uri);
2971 ns = domNewNamespace (node->ownerDocument, localName, uri);
2974 ns = domNewNamespace (node->ownerDocument, prefix, uri);
2977 domSetAttributeNS (node, "xmlns", uri, NULL, 0);
2982 domSetAttributeNS (node, Tcl_DStringValue (&dStr),
2994 attr->parentNode = node;
3000 if (node->firstAttr && (node->firstAttr->nodeFlags & IS_NS_NODE)) {
3001 lastAttr = node->firstAttr;
3009 attr->nextSibling = node->firstAttr;
3010 node->firstAttr = attr;
3013 if (node->firstAttr) {
3014 lastAttr = node->firstAttr;
3019 node->firstAttr = attr;
3034 domNode *node,
3041 if (!node || node->nodeType != ELEMENT_NODE) {
3048 attr = node->firstAttr;
3061 h = Tcl_FindHashEntry (node->ownerDocument->ids, attr->nodeValue);
3080 domNode *node,
3091 if (!node || node->nodeType != ELEMENT_NODE) {
3095 attr = node->firstAttr;
3099 ns = domGetNamespaceByIndex(node->ownerDocument, attr->namespace);
3108 h = Tcl_FindHashEntry (node->ownerDocument->ids,
3130 static void __dbgAttr (domAttrNode *node) {
3132 DBG(fprintf(stderr, " %s=%s", node->nodeName, node->nodeValue);)
3133 if (node->nextSibling) __dbgAttr(node->nextSibling);
3144 domNode *node,
3157 if (node->nodeFlags & HAS_BASEURI) {
3158 h = Tcl_FindHashEntry (node->ownerDocument->baseURIs, (char*)node);
3163 node->nodeFlags &= ~HAS_BASEURI;
3165 if (node->nodeType == ELEMENT_NODE) {
3166 origDoc = node->ownerDocument;
3167 node->ownerDocument = doc;
3168 for (attr = node->firstAttr; attr != NULL; attr = attr->nextSibling) {
3174 ns = domAddNSToNode (node,
3179 if (node->namespace) {
3180 ns = domAddNSToNode (node, origDoc->namespaces[node->namespace-1]);
3181 if (ns) node->namespace = ns->index;
3183 ns = domAddNSToNode (node, NULL);
3185 node->namespace = ns->index;
3188 DBG(fprintf(stderr, "domSetDocument node%s ", node->nodeName);
3189 __dbgAttr(node->firstAttr);
3197 h = Tcl_CreateHashEntry(&doc->tdom_tagNames, node->nodeName,
3199 node->nodeName = (domString) &(h->key);
3200 for (attr = node->firstAttr;
3209 child = node->firstChild;
3215 node->ownerDocument = doc;
3218 DBG(fprintf(stderr, "end domSetDocument node %s\n", node->nodeName);)
3228 domNode *node,
3235 if ((node->nodeType != TEXT_NODE) &&
3236 (node->nodeType != CDATA_SECTION_NODE) &&
3237 (node->nodeType != COMMENT_NODE)
3242 textnode = (domTextNode*) node;
3259 * child from the list of children of node.
3264 * NOT_FOUND_ERR: Raised if the node child is not a child of node.
3276 domNode *node,
3282 /* check, if node is in deed the parent of child */
3283 if (child->parentNode != node) {
3284 /* If node is the root node of a document and child
3285 is in deed a child of this node, then
3287 loop throu the childs of node, to see, if the child
3289 if (node->ownerDocument->rootNode == node) {
3290 n = node->firstChild;
3293 /* child is in deed a child of node */
3309 node->firstChild = child->nextSibling;
3314 node->lastChild = child->previousSibling;
3328 MutationEvent3(DOMNodeRemoved, child, node);
3329 MutationEvent2(DOMSubtreeModified, node);
3341 * node newChild to the end of the list of children of this
3342 * node. If the newChild is already in the tree, it is first
3348 * HIERARCHY_REQUEST_ERR: Raised if node is of a type that does
3349 * not allow children of the type of the childToAppend node, or
3350 * if the node to append is one of node's ancestors or the
3351 * rootNode of node's document.
3354 * of another document or if node is a rootNode.
3366 domNode *node,
3372 if (node->nodeType != ELEMENT_NODE) {
3376 /* check, whether childToAppend is node or one of node's ancestors */
3377 n = node;
3386 if (childToAppend == node->ownerDocument->rootNode) {
3428 if (node->lastChild) {
3429 node->lastChild->nextSibling = childToAppend;
3430 childToAppend->previousSibling = node->lastChild;
3432 node->firstChild = childToAppend;
3435 node->lastChild = childToAppend;
3442 if (node == node->ownerDocument->rootNode) {
3445 childToAppend->parentNode = node;
3448 if ((node->ownerDocument != childToAppend->ownerDocument)
3449 || node->ownerDocument->nsptr
3451 domSetDocument (childToAppend, node->ownerDocument);
3453 node->ownerDocument->nodeFlags |= NEEDS_RENUMBERING;
3466 * It inserts the node childToInsert before the existing child
3467 * node referenceChild. If referenceChild is null, insert
3468 * childToInsert at the end of the list of children of node. The
3469 * arguments node and childToInsert must be non NULL. The
3476 * HIERARCHY_REQUEST_ERR: Raised if node is of a type that does
3477 * not allow children of the type of the childToInsert node, or
3478 * if the node to insert is node or one of node's ancestors or the
3479 * rootNode of node's document.
3481 * NOT_FOUND_ERR: Raised if refChild is not a child of this node.
3484 * of another document or if node is a rootNode.
3496 domNode *node,
3504 if (node->nodeType != ELEMENT_NODE) {
3508 /* check, if node is in deed the parent of referenceChild */
3510 if (referenceChild->parentNode != node) {
3511 /* If node is the root node of a document and referenceChild
3512 is in deed a child of this node, then
3514 loop throu the childs of node, to see, if the referenceChild
3516 if (node->ownerDocument->rootNode == node) {
3517 n = node->firstChild;
3520 /* referenceChild is in deed a child of node */
3538 /* check, whether childToInsert is one of node's ancestors */
3539 n = node;
3548 if (childToInsert == node->ownerDocument->rootNode) {
3605 node->firstChild = childToInsert;
3610 if (node->lastChild) {
3611 node->lastChild->nextSibling = childToInsert;
3612 childToInsert->previousSibling = node->lastChild;
3614 node->firstChild = childToInsert;
3617 node->lastChild = childToInsert;
3624 if (node == node->ownerDocument->rootNode) {
3627 childToInsert->parentNode = node;
3629 if (node->ownerDocument != childToInsert->ownerDocument
3630 || node->ownerDocument->nsptr
3632 domSetDocument (childToInsert, node->ownerDocument);
3634 node->ownerDocument->nodeFlags |= NEEDS_RENUMBERING;
3635 MutationEvent3(DOMNodeInsert, childToInsert, node);
3636 MutationEvent2(DOMSubtreeModified, node);
3649 * Replaces the child node oldChild with newChild in the list of
3650 * children of node 'node'.
3655 * HIERARCHY_REQUEST_ERR: Raised if node is of a type that does
3656 * not allow children of the type of the newChild node, or
3657 * if newChild is node or one of node's ancestors or the
3658 * rootNode of node's document.
3660 * NOT_FOUND_ERR: Raised if oldChild is not a child of node.
3675 domNode *node,
3683 if (node->nodeType != ELEMENT_NODE) {
3687 /* check, if node is in deed the parent of oldChild */
3688 if (oldChild->parentNode != node) {
3689 /* If node is the root node of a document and oldChild
3690 is in deed a child of this node, then
3692 loop throu the childs of node, to see, if the oldChild
3694 if (node->ownerDocument->rootNode == node) {
3695 n = node->firstChild;
3698 /* oldChild is in deed a child of node */
3715 /* check, whether newChild is node or one of node's ancestors */
3716 n = node;
3725 if (newChild == node->ownerDocument->rootNode) {
3769 if (node == node->ownerDocument->rootNode) {
3772 newChild->parentNode = node;
3777 node->firstChild = newChild;
3782 node->lastChild = newChild;
3785 if (node->ownerDocument != newChild->ownerDocument
3786 || node->ownerDocument->nsptr
3788 domSetDocument (newChild, node->ownerDocument);
3801 node->ownerDocument->nodeFlags |= NEEDS_RENUMBERING;
3819 domTextNode *node;
3821 node = (domTextNode*) domAlloc(sizeof(domTextNode));
3822 memset(node, 0, sizeof(domTextNode));
3823 node->nodeType = nodeType;
3824 node->nodeFlags = 0;
3825 node->namespace = 0;
3826 node->nodeNumber = NODE_NO(doc);
3827 node->ownerDocument = doc;
3828 node->valueLength = length;
3829 node->nodeValue = (char*)MALLOC(length);
3830 memmove(node->nodeValue, value, length);
3833 node->nextSibling = doc->fragments;
3834 doc->fragments->previousSibling = (domNode*)node;
3835 doc->fragments = (domNode*)node;
3837 doc->fragments = (domNode*)node;
3840 return node;
3894 domTextNode *node;
3905 | append to already existing text node
3912 node = (domTextNode*) domAlloc(sizeof(domTextNode));
3913 memset(node, 0, sizeof(domTextNode));
3914 node->nodeType = nodeType;
3915 node->nodeFlags = 0;
3917 node->nodeFlags |= DISABLE_OUTPUT_ESCAPING;
3919 node->namespace = 0;
3920 node->nodeNumber = NODE_NO(parent->ownerDocument);
3921 node->ownerDocument = parent->ownerDocument;
3922 node->valueLength = length;
3923 node->nodeValue = (char*)MALLOC(length);
3924 memmove(node->nodeValue, value, length);
3927 parent->lastChild->nextSibling = (domNode*)node;
3928 node->previousSibling = parent->lastChild;
3930 parent->firstChild = (domNode*)node;
3931 node->previousSibling = NULL;
3933 parent->lastChild = (domNode*)node;
3934 node->nextSibling = NULL;
3936 node->parentNode = parent;
3940 return node;
3956 domNode *node;
3971 node = (domNode*) domAlloc(sizeof(domNode));
3972 memset(node, 0, sizeof(domNode));
3973 node->nodeType = ELEMENT_NODE;
3974 node->nodeNumber = NODE_NO(parent->ownerDocument);
3975 node->ownerDocument = parent->ownerDocument;
3976 node->nodeName = (char *)&(h->key);
3979 parent->lastChild->nextSibling = node;
3980 node->previousSibling = parent->lastChild;
3982 parent->firstChild = node;
3983 node->previousSibling = NULL;
3985 parent->lastChild = node;
3986 node->nextSibling = NULL;
3988 node->parentNode = parent;
3997 ns = domLookupPrefix (node, prefix);
3999 ns = domNewNamespace(node->ownerDocument, prefix, uri);
4001 domSetAttributeNS (node, "xmlns", uri, NULL, 1);
4006 domSetAttributeNS (node, Tcl_DStringValue (&dStr), uri, NULL,
4010 node->namespace = ns->index;
4012 ns = domLookupPrefix (node, "");
4015 NSattr = domSetAttributeNS (node, "xmlns", "", NULL, 1);
4017 node->namespace = NSattr->namespace;
4020 node->namespace = ns->index;
4025 return node;
4042 * Appends the data to node.
4049 domTextNode *node, /* The node, to append value to. Must be
4055 escaping on the node */
4060 if (node->nodeFlags & DISABLE_OUTPUT_ESCAPING) {
4062 node->nodeValue = REALLOC (node->nodeValue,
4063 node->valueLength + length);
4064 memmove (node->nodeValue + node->valueLength, value, length);
4065 node->valueLength += length;
4069 node->nodeValue = REALLOC (node->nodeValue,
4070 node->valueLength +
4072 memmove (node->nodeValue + node->valueLength,
4075 node->valueLength += Tcl_DStringLength (&escData);
4077 node->nodeValue = REALLOC (node->nodeValue,
4078 node->valueLength+length);
4079 memmove (node->nodeValue + node->valueLength,
4081 node->valueLength += length;
4087 node->nodeFlags |= DISABLE_OUTPUT_ESCAPING;
4088 domEscapeCData (node->nodeValue, node->valueLength,
4091 FREE (node->nodeValue);
4092 node->nodeValue =
4094 memmove (node->nodeValue, Tcl_DStringValue (&escData),
4096 node->valueLength = Tcl_DStringLength (&escData);
4098 node->nodeValue = REALLOC (node->nodeValue,
4099 node->valueLength+length);
4103 node->nodeValue = REALLOC (node->nodeValue,
4104 node->valueLength + length);
4106 memmove (node->nodeValue + node->valueLength, value, length);
4107 node->valueLength += length;
4121 * Text nodes in the full depth of the sub-tree underneath node,
4141 domNode *node, /* root of the sub-tree to normalize */
4144 domFreeCallback freeCB, /* Function to call, if a node must be freed */
4152 if (node->nodeType != ELEMENT_NODE) return;
4154 child = node->firstChild;
4213 domNode *node,
4229 DBG(fprintf (stderr, "domAddNSToNode to node '%s': prefix: %s, uri: %s\n", node->nodeName, nsToAdd->prefix, nsToAdd->uri);)
4231 ns = domLookupPrefix (node, nsToAdd->prefix);
4242 ns = domNewNamespace (node->ownerDocument, nsToAdd->prefix, nsToAdd->uri);
4253 h = Tcl_CreateHashEntry(&HASHTAB(node->ownerDocument,tdom_attrNames),
4259 attr->parentNode = node;
4265 if (node->firstAttr && (node->firstAttr->nodeFlags & IS_NS_NODE)) {
4266 lastNSAttr = node->firstAttr;
4276 attr->nextSibling = node->firstAttr;
4277 node->firstAttr = attr;
4294 domNode *node;
4304 node = (domNode*) domAlloc(sizeof(domNode));
4305 memset(node, 0, sizeof(domNode));
4306 node->nodeType = ELEMENT_NODE;
4307 node->nodeNumber = NODE_NO(parent->ownerDocument);
4308 node->ownerDocument = parent->ownerDocument;
4309 node->nodeName = (char *)&(h->key);
4312 parent->lastChild->nextSibling = node;
4313 node->previousSibling = parent->lastChild;
4315 parent->firstChild = node;
4316 node->previousSibling = NULL;
4318 parent->lastChild = node;
4319 node->nextSibling = NULL;
4321 node->parentNode = parent;
4325 return node;
4342 domProcessingInstructionNode *node;
4344 node = (domProcessingInstructionNode*) domAlloc(sizeof(domProcessingInstructionNode));
4345 memset(node, 0, sizeof(domProcessingInstructionNode));
4346 node->nodeType = PROCESSING_INSTRUCTION_NODE;
4347 node->nodeFlags = 0;
4348 node->namespace = 0;
4349 node->nodeNumber = NODE_NO(doc);
4350 node->ownerDocument = doc;
4351 node->targetLength = targetLength;
4352 node->targetValue = (char*)MALLOC(targetLength);
4353 memmove(node->targetValue, targetValue, targetLength);
4355 node->dataLength = dataLength;
4356 node->dataValue = (char*)MALLOC(dataLength);
4357 memmove(node->dataValue, dataValue, dataLength);
4360 node->nextSibling = doc->fragments;
4361 doc->fragments->previousSibling = (domNode*)node;
4362 doc->fragments = (domNode*)node;
4364 doc->fragments = (domNode*)node;
4368 return node;
4383 domNode *node;
4388 node = (domNode*) domAlloc(sizeof(domNode));
4389 memset(node, 0, sizeof(domNode));
4390 node->nodeType = nodeType;
4391 node->nodeFlags = 0;
4392 node->namespace = 0;
4393 node->nodeNumber = NODE_NO(doc);
4394 node->ownerDocument = doc;
4395 node->nodeName = (char *)&(h->key);
4398 node->nextSibling = doc->fragments;
4399 doc->fragments->previousSibling = node;
4400 doc->fragments = node;
4402 doc->fragments = node;
4405 return node;
4421 domNode *node;
4429 node = (domNode*) domAlloc(sizeof(domNode));
4430 memset(node, 0, sizeof(domNode));
4431 node->nodeType = nodeType;
4432 node->nodeFlags = 0;
4433 node->namespace = 0;
4434 node->nodeNumber = NODE_NO(doc);
4435 node->ownerDocument = doc;
4436 node->nodeName = (char *)&(h->key);
4440 node->namespace = ns->index;
4443 node->nextSibling = doc->fragments;
4444 doc->fragments->previousSibling = node;
4445 doc->fragments = node;
4447 doc->fragments = node;
4450 return node;
4459 domNode *node,
4467 | create new node
4469 if (node->nodeType == PROCESSING_INSTRUCTION_NODE) {
4470 domProcessingInstructionNode *pinode = (domProcessingInstructionNode*)node;
4478 if (node->nodeType != ELEMENT_NODE) {
4479 domTextNode *tnode = (domTextNode*)node;
4485 n = domNewElementNode(node->ownerDocument, node->nodeName, node->nodeType);
4486 n->namespace = node->namespace;
4492 attr = node->firstAttr;
4503 child = node->firstChild;
4507 /* append new (cloned)child to cloned node, its new parent.
4591 domNode *node,
4601 | create new node
4603 if (node->nodeType == PROCESSING_INSTRUCTION_NODE) {
4604 domProcessingInstructionNode *pinode = (domProcessingInstructionNode*)node;
4614 if (node->nodeType != ELEMENT_NODE) {
4615 domTextNode *tnode = (domTextNode*)node;
4623 n = domAppendLiteralNode (parent, node);
4625 domCopyNS (node, n);
4631 attr = node->firstAttr;
4636 * (including the one declared with the node to copy)
4642 ns = node->ownerDocument->namespaces[attr->namespace-1];
4658 ns = node->ownerDocument->namespaces[attr->namespace-1];
4668 /* We have to set the node namespace index after copying the
4669 attribute nodes over, because the node may be in a namespace,
4670 which is declared just at the node. */
4671 if (node->namespace) {
4672 ns = node->ownerDocument->namespaces[node->namespace-1];
4677 child = node->firstChild;
4691 domNode * node,
4708 if (node->nodeType != ELEMENT_NODE) {
4713 child = node->lastChild;
4715 child = node->firstChild;
4769 domNode * node,
4789 endSibling = node;
4790 sibling = node;
4791 if (node->parentNode) {
4792 sibling = node->parentNode->lastChild;
4795 sibling = node->nextSibling;
4800 endSibling = node;
4801 sibling = node;
4802 if (node->parentNode) {
4803 sibling = node->parentNode->firstChild;
4806 sibling = node->previousSibling;
4864 domNode * node,
4882 if (node->nodeType != ELEMENT_NODE) {
4887 child = node->lastChild;
4889 child = node->firstChild;
4956 domNode * node,
4974 ancestor = node->parentNode;