Return to Document.c CVS log

Up to [Public] / DOM

Nearly completed Document interfaces, general cleanup, Daniel.

/*
 * Document.c : implementation of the Document interface as defined by
 *       Document Object Model (Core) Level 1
 *       http://www.w3.org/TR/WD-DOM/level-one-core.html
 * 
 * Daniel.Veillard@w3.org
 *
 * $Id: Document.c,v 1.3 1998/06/15 05:26:37 daniel Exp $
 */

#include "config.h"
#include <stdio.h>
#include <malloc.h>
#include <string.h>
#include "Document.h"
#include "Element.h"
#include "Text.h"
#include "Comment.h"
#include "PI.h"
#include "Attribute.h"
#include "AttributeList.h"
#include "TreeIterator.h"
#include "NodeIterator.h"

/*
 * create an element of a given type and associate the set of attributes.
 */
domElementPtr createElement(domDocumentPtr doc, char *tagName,
                            domAttributeListPtr attributes) {
    domElementPtr ret;

    if (doc == NULL) return(NULL);
    if (tagName == NULL) return(NULL);
    ret = (domElementPtr) malloc(sizeof(domElement));
    if (ret == NULL) {
        fprintf(stderr, "createElement : out of memory\n");
	return(NULL);
    }
    memset(ret, 0, sizeof(domElement));
    ret->doc = doc;
    ret->type = DOM_NODE_ELEMENT;
    ret->name = strdup(tagName);
    if (attributes != NULL) {
        domAttributePtr cur;

        if (attributes->doc != doc) {
	    fprintf(stderr, 
     "Trying to use attributes from different document in createElement\n");
            return(ret);
	}
        /*
	 * Prune the attribute list in the element attribute list.
	 */
        cur = attributes->list;
        ret->attributes = cur;
	while (cur != NULL) {
	    cur->parent = ret;
	    if (cur->next == NULL) break;
	    cur = cur->next;
	}
	ret->lastattribute = cur;
	attributes->elem = ret;
    }

    return(ret);
}

/*
 * Destroy a Element node.
 */
void destroyElement(domElementPtr old) {
    if (old == NULL) return;
    if (old->type != DOM_NODE_ELEMENT) {
        fprintf(stderr, "destroyElement: invalid object %d\n", old->type);
	return;
    }

    memset(old, 0, sizeof(domElement));
    old->name = (void *) 0xdeadbeef;
    old->value = (void *) 0xdeadbeef;
    old->parent = (void *) 0xdeadbeef;
    old->childs = (void *) 0xdeadbeef;
    old->prev = (void *) 0xdeadbeef;
    old->next = (void *) 0xdeadbeef;
    free(old);
}

/*
 * Create a Text node.
 */
domTextPtr createTextNode(domDocumentPtr doc, char *data) {
    domTextPtr ret;

    if (doc == NULL) return(NULL);
    if (data == NULL) return(NULL);
    ret = (domTextPtr) malloc(sizeof(domText));
    if (ret == NULL) {
        fprintf(stderr, "createText : out of memory\n");
	return(NULL);
    }
    memset(ret, 0, sizeof(domText));
    ret->doc = doc;
    ret->type = DOM_NODE_TEXT;
    ret->value = strdup(data);

    return(ret);
}

/*
 * Destroy a Text node.
 */
void destroyText(domTextPtr old) {
    if (old == NULL) return;
    if (old->type != DOM_NODE_TEXT) {
        fprintf(stderr, "destroyText: invalid object %d\n", old->type);
	return;
    }

    memset(old, 0, sizeof(domText));
    old->name = (void *) 0xdeadbeef;
    old->value = (void *) 0xdeadbeef;
    old->parent = (void *) 0xdeadbeef;
    old->childs = (void *) 0xdeadbeef;
    old->prev = (void *) 0xdeadbeef;
    old->next = (void *) 0xdeadbeef;
    free(old);
}

/*
 * Create a comment node.
 */
domCommentPtr createCommentNode(domDocumentPtr doc, char *data) {
    domCommentPtr ret;

    if (doc == NULL) return(NULL);
    if (data == NULL) return(NULL);
    ret = (domCommentPtr) malloc(sizeof(domComment));
    if (ret == NULL) {
        fprintf(stderr, "createComment : out of memory\n");
	return(NULL);
    }
    memset(ret, 0, sizeof(domComment));
    ret->doc = doc;
    ret->type = DOM_NODE_COMMENT;
    ret->value = strdup(data);

    return(ret);
}

/*
 * Destroy a Comment node.
 */
void destroyComment(domCommentPtr old) {
    if (old == NULL) return;
    if (old->type != DOM_NODE_COMMENT) {
        fprintf(stderr, "destroyComment: invalid object %d\n", old->type);
	return;
    }

    memset(old, 0, sizeof(domComment));
    old->name = (void *) 0xdeadbeef;
    old->value = (void *) 0xdeadbeef;
    old->parent = (void *) 0xdeadbeef;
    old->childs = (void *) 0xdeadbeef;
    old->prev = (void *) 0xdeadbeef;
    old->next = (void *) 0xdeadbeef;
    free(old);
}

/*
 * Create a PI node.
 */
domPIPtr createPINode(domDocumentPtr doc, char *name, char *data) {
    domPIPtr ret;

    if (doc == NULL) return(NULL);
    if (name == NULL) return(NULL);
    if (data == NULL) return(NULL);
    ret = (domPIPtr) malloc(sizeof(domPI));
    if (ret == NULL) {
        fprintf(stderr, "createPI : out of memory\n");
	return(NULL);
    }
    memset(ret, 0, sizeof(domPI));
    ret->doc = doc;
    ret->type = DOM_NODE_PI;
    ret->name = strdup(name);
    ret->value = strdup(data);

    return(ret);
}

/*
 * Destroy a PI node.
 */
void destroyPI(domPIPtr old) {
    if (old == NULL) return;
    if (old->type != DOM_NODE_PI) {
        fprintf(stderr, "destroyPI: invalid object %d\n", old->type);
	return;
    }

    memset(old, 0, sizeof(domPI));
    old->name = (void *) 0xdeadbeef;
    old->value = (void *) 0xdeadbeef;
    old->parent = (void *) 0xdeadbeef;
    old->childs = (void *) 0xdeadbeef;
    old->prev = (void *) 0xdeadbeef;
    old->next = (void *) 0xdeadbeef;
    free(old);
}

/*
 * Create an Attribute, it's not yet linked to any element.
 */
domAttributePtr createAttribute(domDocumentPtr doc, char *name,
                                        char *value) {
    domAttributePtr ret;

    if (doc == NULL) return(NULL);
    if (name == NULL) return(NULL);
    ret = (domAttributePtr) malloc(sizeof(domAttribute));
    if (ret == NULL) {
        fprintf(stderr, "createAttribute : out of memory\n");
	return(NULL);
    }
    memset(ret, 0, sizeof(domAttribute));
    ret->doc = doc;
    ret->type = DOM_NODE_ATTRIBUTE;
    ret->name = strdup(name);
    if (value == NULL)
        ret->value = NULL;
    else
	ret->value = strdup(value);

    return(NULL);
}

/*
 * Destroy an Attribute.
 */
void destroyAttribute(domAttributePtr old) {
    if (old == NULL) return;
    if (old->type != DOM_NODE_ATTRIBUTE) {
        fprintf(stderr, "destroyAttribute: invalid object %d\n", old->type);
	return;
    }

    memset(old, 0, sizeof(domAttribute));
    old->name = (void *) 0xdeadbeef;
    old->value = (void *) 0xdeadbeef;
    old->parent = (void *) 0xdeadbeef;
    old->childs = (void *) 0xdeadbeef;
    old->prev = (void *) 0xdeadbeef;
    old->next = (void *) 0xdeadbeef;
    free(old);
}

/*
 * Create an Attribute List. At this moment the Element owning
 * them probably hasn't being created.
 */
domAttributeListPtr createAttributeList(domDocumentPtr doc) {
    domAttributeListPtr ret;

    if (doc == NULL) return(NULL);
    ret = (domAttributeListPtr) malloc(sizeof(domAttributeList));
    if (ret == NULL) {
        fprintf(stderr, "createAttributeList : out of memory\n");
	return(NULL);
    }
    memset(ret, 0, sizeof(domAttributeList));
    ret->doc = doc;
    ret->elem = NULL;
    ret->list = NULL;

    return(NULL);
}

/*
 * Destroy an AttributeList: we don't destroy the list itself, unless
 *       there is no Element attached to the list (e.g. the pasring of
 *       a block failed and the Element wasn't created).
 */
void destroyAttributeList(domAttributeListPtr old) {
    if (old == NULL) return;

    if (old->elem == NULL) {
        domAttributePtr cur, next;
	cur = old->list;
	while (cur != NULL) {
	    next = cur->next;
            destroyAttribute(cur);
	    cur = next;
	}
    }
    old->doc = (void *) 0xdeadbeef;
    old->elem = (void *) 0xdeadbeef;
    old->list = (void *) 0xdeadbeef;
    free(old);
}

/*
 * Create a TreeIterator, in this implementation, TreeIterator and NodeIterator
 *        share exactly the same structure (and most of the code too !).
 */
domTreeIteratorPtr createTreeIterator(domDocumentPtr doc) {
    domTreeIteratorPtr ret;

    if (doc == NULL) return(NULL);
    if (doc->documentElement == NULL) return(NULL);
    ret = domNodeIteratorCreate(doc->documentElement);
    return(NULL);
}

/*
 * Destroy a TreeIterator.
 */
void destroyTreeIterator(domTreeIteratorPtr old) {
    if (old == NULL) return;
    domNodeIteratorDestroy(old);
}

/*
 * 
 */
domNodeIteratorPtr getElementsByTagName(domDocumentPtr doc, char *tagname) {
    /* TODO !!!! */
    return(NULL);
}