Annotation of DOM/Document.c, revision 1.3
1.1 daniel 1: /*
2: * Document.c : implementation of the Document interface as defined by
3: * Document Object Model (Core) Level 1
4: * http://www.w3.org/TR/WD-DOM/level-one-core.html
5: *
6: * Daniel.Veillard@w3.org
7: *
1.3 ! daniel 8: * $Id: Document.c,v 1.2 1998/06/14 03:20:14 daniel Exp $
1.1 daniel 9: */
10:
11: #include "config.h"
12: #include <stdio.h>
1.2 daniel 13: #include <malloc.h>
1.3 ! daniel 14: #include <string.h>
1.1 daniel 15: #include "Document.h"
1.3 ! daniel 16: #include "Element.h"
! 17: #include "Text.h"
! 18: #include "Comment.h"
! 19: #include "PI.h"
! 20: #include "Attribute.h"
! 21: #include "AttributeList.h"
! 22: #include "TreeIterator.h"
! 23: #include "NodeIterator.h"
1.2 daniel 24:
25: /*
1.3 ! daniel 26: * create an element of a given type and associate the set of attributes.
1.2 daniel 27: */
28: domElementPtr createElement(domDocumentPtr doc, char *tagName,
29: domAttributeListPtr attributes) {
1.3 ! daniel 30: domElementPtr ret;
! 31:
! 32: if (doc == NULL) return(NULL);
! 33: if (tagName == NULL) return(NULL);
! 34: ret = (domElementPtr) malloc(sizeof(domElement));
! 35: if (ret == NULL) {
! 36: fprintf(stderr, "createElement : out of memory\n");
! 37: return(NULL);
! 38: }
! 39: memset(ret, 0, sizeof(domElement));
! 40: ret->doc = doc;
! 41: ret->type = DOM_NODE_ELEMENT;
! 42: ret->name = strdup(tagName);
! 43: if (attributes != NULL) {
! 44: domAttributePtr cur;
! 45:
! 46: if (attributes->doc != doc) {
! 47: fprintf(stderr,
! 48: "Trying to use attributes from different document in createElement\n");
! 49: return(ret);
! 50: }
! 51: /*
! 52: * Prune the attribute list in the element attribute list.
! 53: */
! 54: cur = attributes->list;
! 55: ret->attributes = cur;
! 56: while (cur != NULL) {
! 57: cur->parent = ret;
! 58: if (cur->next == NULL) break;
! 59: cur = cur->next;
! 60: }
! 61: ret->lastattribute = cur;
! 62: attributes->elem = ret;
! 63: }
! 64:
! 65: return(ret);
! 66: }
! 67:
! 68: /*
! 69: * Destroy a Element node.
! 70: */
! 71: void destroyElement(domElementPtr old) {
! 72: if (old == NULL) return;
! 73: if (old->type != DOM_NODE_ELEMENT) {
! 74: fprintf(stderr, "destroyElement: invalid object %d\n", old->type);
! 75: return;
! 76: }
! 77:
! 78: memset(old, 0, sizeof(domElement));
! 79: old->name = (void *) 0xdeadbeef;
! 80: old->value = (void *) 0xdeadbeef;
! 81: old->parent = (void *) 0xdeadbeef;
! 82: old->childs = (void *) 0xdeadbeef;
! 83: old->prev = (void *) 0xdeadbeef;
! 84: old->next = (void *) 0xdeadbeef;
! 85: free(old);
1.2 daniel 86: }
87:
88: /*
1.3 ! daniel 89: * Create a Text node.
1.2 daniel 90: */
91: domTextPtr createTextNode(domDocumentPtr doc, char *data) {
1.3 ! daniel 92: domTextPtr ret;
! 93:
! 94: if (doc == NULL) return(NULL);
! 95: if (data == NULL) return(NULL);
! 96: ret = (domTextPtr) malloc(sizeof(domText));
! 97: if (ret == NULL) {
! 98: fprintf(stderr, "createText : out of memory\n");
! 99: return(NULL);
! 100: }
! 101: memset(ret, 0, sizeof(domText));
! 102: ret->doc = doc;
! 103: ret->type = DOM_NODE_TEXT;
! 104: ret->value = strdup(data);
! 105:
! 106: return(ret);
! 107: }
! 108:
! 109: /*
! 110: * Destroy a Text node.
! 111: */
! 112: void destroyText(domTextPtr old) {
! 113: if (old == NULL) return;
! 114: if (old->type != DOM_NODE_TEXT) {
! 115: fprintf(stderr, "destroyText: invalid object %d\n", old->type);
! 116: return;
! 117: }
! 118:
! 119: memset(old, 0, sizeof(domText));
! 120: old->name = (void *) 0xdeadbeef;
! 121: old->value = (void *) 0xdeadbeef;
! 122: old->parent = (void *) 0xdeadbeef;
! 123: old->childs = (void *) 0xdeadbeef;
! 124: old->prev = (void *) 0xdeadbeef;
! 125: old->next = (void *) 0xdeadbeef;
! 126: free(old);
1.2 daniel 127: }
128:
129: /*
1.3 ! daniel 130: * Create a comment node.
1.2 daniel 131: */
132: domCommentPtr createCommentNode(domDocumentPtr doc, char *data) {
1.3 ! daniel 133: domCommentPtr ret;
! 134:
! 135: if (doc == NULL) return(NULL);
! 136: if (data == NULL) return(NULL);
! 137: ret = (domCommentPtr) malloc(sizeof(domComment));
! 138: if (ret == NULL) {
! 139: fprintf(stderr, "createComment : out of memory\n");
! 140: return(NULL);
! 141: }
! 142: memset(ret, 0, sizeof(domComment));
! 143: ret->doc = doc;
! 144: ret->type = DOM_NODE_COMMENT;
! 145: ret->value = strdup(data);
! 146:
! 147: return(ret);
! 148: }
! 149:
! 150: /*
! 151: * Destroy a Comment node.
! 152: */
! 153: void destroyComment(domCommentPtr old) {
! 154: if (old == NULL) return;
! 155: if (old->type != DOM_NODE_COMMENT) {
! 156: fprintf(stderr, "destroyComment: invalid object %d\n", old->type);
! 157: return;
! 158: }
! 159:
! 160: memset(old, 0, sizeof(domComment));
! 161: old->name = (void *) 0xdeadbeef;
! 162: old->value = (void *) 0xdeadbeef;
! 163: old->parent = (void *) 0xdeadbeef;
! 164: old->childs = (void *) 0xdeadbeef;
! 165: old->prev = (void *) 0xdeadbeef;
! 166: old->next = (void *) 0xdeadbeef;
! 167: free(old);
1.2 daniel 168: }
169:
170: /*
1.3 ! daniel 171: * Create a PI node.
1.2 daniel 172: */
173: domPIPtr createPINode(domDocumentPtr doc, char *name, char *data) {
1.3 ! daniel 174: domPIPtr ret;
! 175:
! 176: if (doc == NULL) return(NULL);
! 177: if (name == NULL) return(NULL);
! 178: if (data == NULL) return(NULL);
! 179: ret = (domPIPtr) malloc(sizeof(domPI));
! 180: if (ret == NULL) {
! 181: fprintf(stderr, "createPI : out of memory\n");
! 182: return(NULL);
! 183: }
! 184: memset(ret, 0, sizeof(domPI));
! 185: ret->doc = doc;
! 186: ret->type = DOM_NODE_PI;
! 187: ret->name = strdup(name);
! 188: ret->value = strdup(data);
! 189:
! 190: return(ret);
! 191: }
! 192:
! 193: /*
! 194: * Destroy a PI node.
! 195: */
! 196: void destroyPI(domPIPtr old) {
! 197: if (old == NULL) return;
! 198: if (old->type != DOM_NODE_PI) {
! 199: fprintf(stderr, "destroyPI: invalid object %d\n", old->type);
! 200: return;
! 201: }
! 202:
! 203: memset(old, 0, sizeof(domPI));
! 204: old->name = (void *) 0xdeadbeef;
! 205: old->value = (void *) 0xdeadbeef;
! 206: old->parent = (void *) 0xdeadbeef;
! 207: old->childs = (void *) 0xdeadbeef;
! 208: old->prev = (void *) 0xdeadbeef;
! 209: old->next = (void *) 0xdeadbeef;
! 210: free(old);
1.2 daniel 211: }
212:
213: /*
1.3 ! daniel 214: * Create an Attribute, it's not yet linked to any element.
1.2 daniel 215: */
216: domAttributePtr createAttribute(domDocumentPtr doc, char *name,
217: char *value) {
1.3 ! daniel 218: domAttributePtr ret;
! 219:
! 220: if (doc == NULL) return(NULL);
! 221: if (name == NULL) return(NULL);
! 222: ret = (domAttributePtr) malloc(sizeof(domAttribute));
! 223: if (ret == NULL) {
! 224: fprintf(stderr, "createAttribute : out of memory\n");
! 225: return(NULL);
! 226: }
! 227: memset(ret, 0, sizeof(domAttribute));
! 228: ret->doc = doc;
! 229: ret->type = DOM_NODE_ATTRIBUTE;
! 230: ret->name = strdup(name);
! 231: if (value == NULL)
! 232: ret->value = NULL;
! 233: else
! 234: ret->value = strdup(value);
! 235:
1.2 daniel 236: return(NULL);
237: }
238:
239: /*
1.3 ! daniel 240: * Destroy an Attribute.
! 241: */
! 242: void destroyAttribute(domAttributePtr old) {
! 243: if (old == NULL) return;
! 244: if (old->type != DOM_NODE_ATTRIBUTE) {
! 245: fprintf(stderr, "destroyAttribute: invalid object %d\n", old->type);
! 246: return;
! 247: }
! 248:
! 249: memset(old, 0, sizeof(domAttribute));
! 250: old->name = (void *) 0xdeadbeef;
! 251: old->value = (void *) 0xdeadbeef;
! 252: old->parent = (void *) 0xdeadbeef;
! 253: old->childs = (void *) 0xdeadbeef;
! 254: old->prev = (void *) 0xdeadbeef;
! 255: old->next = (void *) 0xdeadbeef;
! 256: free(old);
! 257: }
! 258:
! 259: /*
! 260: * Create an Attribute List. At this moment the Element owning
! 261: * them probably hasn't being created.
1.2 daniel 262: */
263: domAttributeListPtr createAttributeList(domDocumentPtr doc) {
1.3 ! daniel 264: domAttributeListPtr ret;
! 265:
! 266: if (doc == NULL) return(NULL);
! 267: ret = (domAttributeListPtr) malloc(sizeof(domAttributeList));
! 268: if (ret == NULL) {
! 269: fprintf(stderr, "createAttributeList : out of memory\n");
! 270: return(NULL);
! 271: }
! 272: memset(ret, 0, sizeof(domAttributeList));
! 273: ret->doc = doc;
! 274: ret->elem = NULL;
! 275: ret->list = NULL;
! 276:
1.2 daniel 277: return(NULL);
278: }
279:
280: /*
1.3 ! daniel 281: * Destroy an AttributeList: we don't destroy the list itself, unless
! 282: * there is no Element attached to the list (e.g. the pasring of
! 283: * a block failed and the Element wasn't created).
! 284: */
! 285: void destroyAttributeList(domAttributeListPtr old) {
! 286: if (old == NULL) return;
! 287:
! 288: if (old->elem == NULL) {
! 289: domAttributePtr cur, next;
! 290: cur = old->list;
! 291: while (cur != NULL) {
! 292: next = cur->next;
! 293: destroyAttribute(cur);
! 294: cur = next;
! 295: }
! 296: }
! 297: old->doc = (void *) 0xdeadbeef;
! 298: old->elem = (void *) 0xdeadbeef;
! 299: old->list = (void *) 0xdeadbeef;
! 300: free(old);
! 301: }
! 302:
! 303: /*
! 304: * Create a TreeIterator, in this implementation, TreeIterator and NodeIterator
! 305: * share exactly the same structure (and most of the code too !).
1.2 daniel 306: */
307: domTreeIteratorPtr createTreeIterator(domDocumentPtr doc) {
1.3 ! daniel 308: domTreeIteratorPtr ret;
! 309:
! 310: if (doc == NULL) return(NULL);
! 311: if (doc->documentElement == NULL) return(NULL);
! 312: ret = domNodeIteratorCreate(doc->documentElement);
1.2 daniel 313: return(NULL);
1.3 ! daniel 314: }
! 315:
! 316: /*
! 317: * Destroy a TreeIterator.
! 318: */
! 319: void destroyTreeIterator(domTreeIteratorPtr old) {
! 320: if (old == NULL) return;
! 321: domNodeIteratorDestroy(old);
1.2 daniel 322: }
323:
324: /*
325: *
326: */
327: domNodeIteratorPtr getElementsByTagName(domDocumentPtr doc, char *tagname) {
328: /* TODO !!!! */
329: return(NULL);
330: }
1.1 daniel 331:
Webmaster
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to Document.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Public] / DOM