From 83f3338663c4969eebefd8c2c43bd3fc43587fdd Mon Sep 17 00:00:00 2001 From: John Mark Bell Date: Wed, 21 Dec 2011 22:18:10 +0000 Subject: Merge branches/jmb/dom-alloc-purge back to trunk svn path=/trunk/libdom/; revision=13316 --- src/core/element.c | 622 ++++++++++++++++++----------------------------------- 1 file changed, 213 insertions(+), 409 deletions(-) (limited to 'src/core/element.c') diff --git a/src/core/element.c b/src/core/element.c index 580cb41..230087a 100644 --- a/src/core/element.c +++ b/src/core/element.c @@ -6,9 +6,10 @@ * Copyright 2009 Bo Yang */ +#include #include +#include #include -#include #include #include @@ -37,6 +38,9 @@ struct dom_element_vtable _dom_element_vtable = { { + { + DOM_NODE_EVENT_TARGET_VTABLE + }, DOM_NODE_VTABLE_ELEMENT }, DOM_ELEMENT_VTABLE @@ -110,13 +114,32 @@ static struct nnm_operation attributes_opt = { attributes_equal }; -static void *_key(void *key, void *key_pw, dom_alloc alloc, void *pw, - bool clone); -static void *_value(void *value, void *value_pw, dom_alloc alloc, - void *pw, bool clone); -static void *_nsattributes(void *value, void *value_pw, dom_alloc alloc, - void *pw, bool clone); +static uint32_t attributes_hash(void *key, void *pw); +static void *attributes_clone_key(void *key, void *pw); +static void attributes_destroy_key(void *key, void *pw); +static void *attributes_clone_value(void *value, void *pw); +static void attributes_destroy_value(void *value, void *pw); +static void *attributes_ns_clone_value(void *value, void *pw); +static void attributes_ns_destroy_value(void *value, void *pw); +static bool attributes_key_isequal(void *key1, void *key2, void *pw); + +static const struct dom_hash_vtable attributes_vtable = { + attributes_hash, + attributes_clone_key, + attributes_destroy_key, + attributes_clone_value, + attributes_destroy_value, + attributes_key_isequal +}; +static const struct dom_hash_vtable attributes_ns_vtable = { + attributes_hash, + attributes_clone_key, + attributes_destroy_key, + attributes_ns_clone_value, + attributes_ns_destroy_value, + attributes_key_isequal +}; /*----------------------------------------------------------------------*/ /* Constructors and Destructors */ @@ -139,11 +162,11 @@ static void *_nsattributes(void *value, void *value_pw, dom_alloc alloc, * The returned element will already be referenced. */ dom_exception _dom_element_create(struct dom_document *doc, - struct lwc_string_s *name, struct lwc_string_s *namespace, - struct lwc_string_s *prefix, struct dom_element **result) + dom_string *name, dom_string *namespace, + dom_string *prefix, struct dom_element **result) { /* Allocate the element */ - *result = _dom_document_alloc(doc, NULL, sizeof(struct dom_element)); + *result = malloc(sizeof(struct dom_element)); if (*result == NULL) return DOM_NO_MEM_ERR; @@ -174,32 +197,35 @@ dom_exception _dom_element_create(struct dom_document *doc, * The returned element will already be referenced. */ dom_exception _dom_element_initialise(struct dom_document *doc, - struct dom_element *el, struct lwc_string_s *name, - struct lwc_string_s *namespace, struct lwc_string_s *prefix) + struct dom_element *el, dom_string *name, + dom_string *namespace, dom_string *prefix) { dom_exception err; assert(doc != NULL); - err = _dom_document_create_hashtable(doc, CHAINS_ATTRIBUTES, - _dom_hash_hash_lwcstring, &el->attributes); - if (err != DOM_NO_ERR) { - _dom_document_alloc(doc, el, 0); - return err; + el->attributes = _dom_hash_create(CHAINS_ATTRIBUTES, + &attributes_vtable, NULL); + if (el->attributes == NULL) { + free(el); + return DOM_NO_MEM_ERR;; } - err = _dom_document_create_hashtable(doc, CHAINS_NAMESPACE, - _dom_hash_hash_lwcstring, &el->ns_attributes); - if (err != DOM_NO_ERR) { - _dom_document_alloc(doc, el, 0); - _dom_document_alloc(doc, el->attributes, 0); - return err; + el->ns_attributes = _dom_hash_create(CHAINS_NAMESPACE, + &attributes_ns_vtable, NULL); + if (el->ns_attributes == NULL) { + free(el->attributes); + free(el); + return DOM_NO_MEM_ERR; } + /* Initialise the base class */ err = _dom_node_initialise(&el->base, doc, DOM_ELEMENT_NODE, name, NULL, namespace, prefix); if (err != DOM_NO_ERR) { - _dom_document_alloc(doc, el, 0); + free(el->ns_attributes); + free(el->attributes); + free(el); return err; } @@ -214,20 +240,18 @@ dom_exception _dom_element_initialise(struct dom_document *doc, /** * Finalise a dom_element * - * \param doc The document * \param ele The element */ -void _dom_element_finalise(struct dom_document *doc, struct dom_element *ele) +void _dom_element_finalise(struct dom_element *ele) { /* Destroy attributes attached to this node */ if (ele->attributes != NULL) { - _dom_hash_destroy(ele->attributes, _key, NULL, _value, doc); + _dom_hash_destroy(ele->attributes); ele->attributes = NULL; } if (ele->ns_attributes != NULL) { - _dom_hash_destroy(ele->ns_attributes, _key, NULL, - _nsattributes, doc); + _dom_hash_destroy(ele->ns_attributes); ele->ns_attributes = NULL; } @@ -236,24 +260,22 @@ void _dom_element_finalise(struct dom_document *doc, struct dom_element *ele) } /* Finalise base class */ - _dom_node_finalise(doc, &ele->base); + _dom_node_finalise(&ele->base); } /** * Destroy an element * - * \param doc The owning document * \param element The element to destroy * * The contents of ::element will be destroyed and ::element will be freed. */ -void _dom_element_destroy(struct dom_document *doc, - struct dom_element *element) +void _dom_element_destroy(struct dom_element *element) { - _dom_element_finalise(doc, element); + _dom_element_finalise(element); /* Free the element */ - _dom_document_alloc(doc, element, 0); + free(element); } /*----------------------------------------------------------------------*/ @@ -410,20 +432,14 @@ dom_exception _dom_element_get_elements_by_tag_name( struct dom_nodelist **result) { dom_exception err; - lwc_string *n; dom_node_internal *base = (dom_node_internal *) element; assert(base->owner != NULL); - err = _dom_string_intern(name, &n); - if (err != DOM_NO_ERR) - return err; - err = _dom_document_get_nodelist(base->owner, DOM_NODELIST_BY_NAME, - (struct dom_node_internal *) element, n, NULL, + (struct dom_node_internal *) element, name, NULL, NULL, result); - lwc_string_unref(n); return err; } @@ -448,19 +464,12 @@ dom_exception _dom_element_get_attribute_ns(struct dom_element *element, dom_string *namespace, dom_string *localname, dom_string **value) { - lwc_string *str; - dom_exception err; struct dom_hash_table *attrs; if (namespace == NULL) return _dom_element_get_attribute(element, localname, value); - err = _dom_node_get_intern_string(&element->base, namespace, &str); - if (err != DOM_NO_ERR) - return err; - - attrs = (struct dom_hash_table *) _dom_hash_get(element->ns_attributes, - str); + attrs = _dom_hash_get(element->ns_attributes, namespace); /* The element has no such namespace */ if (attrs == NULL) { *value = NULL; @@ -503,7 +512,6 @@ dom_exception _dom_element_set_attribute_ns(struct dom_element *element, dom_string *namespace, dom_string *qname, dom_string *value) { - lwc_string *str; dom_exception err; struct dom_hash_table *attrs; bool added; @@ -530,26 +538,22 @@ dom_exception _dom_element_set_attribute_ns(struct dom_element *element, return err; } - err = _dom_node_get_intern_string(&element->base, namespace, &str); - if (err != DOM_NO_ERR) - return err; - - attrs = (struct dom_hash_table *) _dom_hash_get(element->ns_attributes, - str); + attrs = _dom_hash_get(element->ns_attributes, namespace); /* The element has no such namespace */ if (attrs == NULL) { dom_document *doc; doc = dom_node_get_owner(element); assert(doc != NULL); - err = _dom_document_create_hashtable(doc, CHAINS_NS_ATTRIBUTES, - _dom_hash_hash_lwcstring, &attrs); - if (err != DOM_NO_ERR) - return err; + attrs = _dom_hash_create(CHAINS_NS_ATTRIBUTES, + &attributes_vtable, NULL); + if (attrs == NULL) + return DOM_NO_MEM_ERR; - added = _dom_hash_add(element->ns_attributes, str, attrs, + added = _dom_hash_add(element->ns_attributes, namespace, attrs, false); if (added == false) return DOM_NO_MEM_ERR; + dom_string_ref(namespace); } return _dom_element_set_attr(element, attrs, localname, value); @@ -572,19 +576,12 @@ dom_exception _dom_element_set_attribute_ns(struct dom_element *element, dom_exception _dom_element_remove_attribute_ns(struct dom_element *element, dom_string *namespace, dom_string *localname) { - lwc_string *str; - dom_exception err; struct dom_hash_table *attrs; if (namespace != NULL) return _dom_element_remove_attribute(element, localname); - err = _dom_node_get_intern_string(&element->base, namespace, &str); - if (err != DOM_NO_ERR) - return err; - - attrs = (struct dom_hash_table *) _dom_hash_get(element->ns_attributes, - str); + attrs = _dom_hash_get(element->ns_attributes, namespace); /* The element has no such namespace */ if (attrs == NULL) { return DOM_NO_ERR; @@ -614,8 +611,6 @@ dom_exception _dom_element_get_attribute_node_ns(struct dom_element *element, dom_string *namespace, dom_string *localname, struct dom_attr **result) { - lwc_string *str; - dom_exception err; struct dom_hash_table *attrs; if (namespace == NULL) { @@ -623,12 +618,7 @@ dom_exception _dom_element_get_attribute_node_ns(struct dom_element *element, result); } - err = _dom_node_get_intern_string(&element->base, namespace, &str); - if (err != DOM_NO_ERR) - return err; - - attrs = (struct dom_hash_table *) _dom_hash_get(element->ns_attributes, - str); + attrs = _dom_hash_get(element->ns_attributes, namespace); /* The element has no such namespace */ if (attrs == NULL) { *result = NULL; @@ -663,7 +653,6 @@ dom_exception _dom_element_get_attribute_node_ns(struct dom_element *element, dom_exception _dom_element_set_attribute_node_ns(struct dom_element *element, struct dom_attr *attr, struct dom_attr **result) { - lwc_string *str; dom_exception err; struct dom_hash_table *attrs; bool added; @@ -676,26 +665,22 @@ dom_exception _dom_element_set_attribute_node_ns(struct dom_element *element, if (namespace == NULL) return _dom_element_set_attribute_node(element, attr, result); - err = _dom_node_get_intern_string(&element->base, namespace, &str); - if (err != DOM_NO_ERR) - return err; - - attrs = (struct dom_hash_table *) _dom_hash_get(element->ns_attributes, - str); + attrs = _dom_hash_get(element->ns_attributes, namespace); /* The element has no such namespace */ if (attrs == NULL) { dom_document *doc; doc = dom_node_get_owner(element); assert(doc != NULL); - err = _dom_document_create_hashtable(doc, CHAINS_NS_ATTRIBUTES, - _dom_hash_hash_lwcstring, &attrs); - if (err != DOM_NO_ERR) - return err; + attrs = _dom_hash_create(CHAINS_NS_ATTRIBUTES, + &attributes_vtable, NULL); + if (attrs == NULL) + return DOM_NO_MEM_ERR; - added = _dom_hash_add(element->ns_attributes, str, attrs, + added = _dom_hash_add(element->ns_attributes, namespace, attrs, false); if (added == false) return DOM_NO_MEM_ERR; + dom_string_ref(namespace); } dom_string *localname; @@ -734,32 +719,12 @@ dom_exception _dom_element_get_elements_by_tag_name_ns( /** \todo ensure XML feature is supported */ - /* Get the interned string from the dom_string */ - lwc_string *l = NULL, *n = NULL; - if (localname != NULL) { - err = _dom_string_intern(localname, &l); - if (err != DOM_NO_ERR) - return err; - } - if (namespace != NULL) { - err = _dom_string_intern(namespace, &n); - if (err != DOM_NO_ERR) { - lwc_string_unref(l); - - return err; - } - } - err = _dom_document_get_nodelist(element->base.owner, DOM_NODELIST_BY_NAMESPACE, - (struct dom_node_internal *) element, NULL, n, l, + (struct dom_node_internal *) element, NULL, + namespace, localname, result); - if (localname != NULL) - lwc_string_unref(l); - if (namespace != NULL) - lwc_string_unref(n); - return err; } @@ -796,19 +761,12 @@ dom_exception _dom_element_has_attribute_ns(struct dom_element *element, dom_string *namespace, dom_string *localname, bool *result) { - lwc_string *str; - dom_exception err; struct dom_hash_table *attrs; if (namespace == NULL) return _dom_element_has_attribute(element, localname, result); - err = _dom_node_get_intern_string(&element->base, namespace, &str); - if (err != DOM_NO_ERR) - return err; - - attrs = (struct dom_hash_table *) _dom_hash_get(element->ns_attributes, - str); + attrs = _dom_hash_get(element->ns_attributes, namespace); /* The element has no such namespace */ if (attrs == NULL) { *result = false; @@ -878,24 +836,18 @@ dom_exception _dom_element_set_id_attribute_ns(struct dom_element *element, { struct dom_hash_table *hs; dom_exception err; - lwc_string *ns; if (namespace == NULL) return _dom_element_set_id_attribute(element, localname, is_id); - err = _dom_node_get_intern_string(&element->base, namespace, &ns); - if (err != DOM_NO_ERR) - return err; - - hs = (struct dom_hash_table *) _dom_hash_get(element->ns_attributes, - ns); + hs = _dom_hash_get(element->ns_attributes, namespace); assert(hs != NULL); err = _dom_element_set_id_attr(element, hs, localname, is_id); if (err != DOM_NO_ERR) return err; - element->id_ns = ns; + element->id_ns = dom_string_ref(namespace); return DOM_NO_ERR; } @@ -916,7 +868,6 @@ dom_exception _dom_element_set_id_attribute_node(struct dom_element *element, { struct dom_hash_table *hs; dom_exception err; - lwc_string *ns; dom_string *namespace; dom_string *localname; @@ -927,19 +878,14 @@ dom_exception _dom_element_set_id_attribute_node(struct dom_element *element, if (err != DOM_NO_ERR) return err; - err = _dom_node_get_intern_string(&element->base, namespace, &ns); - if (err != DOM_NO_ERR) - return err; - - hs = (struct dom_hash_table *) _dom_hash_get(element->ns_attributes, - ns); + hs = _dom_hash_get(element->ns_attributes, namespace); assert(hs != NULL); err = _dom_element_set_id_attr(element, hs, localname, is_id); if (err != DOM_NO_ERR) return err; - element->id_ns = ns; + element->id_ns = namespace; return DOM_NO_ERR; @@ -1017,17 +963,11 @@ dom_exception _dom_element_is_default_namespace(dom_node_internal *node, dom_string *namespace, bool *result) { struct dom_element *ele = (struct dom_element *) node; - lwc_string *ns; dom_string *value; dom_exception err; - err = _dom_node_get_intern_string(node, namespace, &ns); - if (err != DOM_NO_ERR) { - return err; - } if (node->prefix == NULL) { - lwc_string_isequal(node->namespace, ns, result); - lwc_string_unref(ns); + *result = dom_string_isequal(node->namespace, namespace); return DOM_NO_ERR; } @@ -1038,23 +978,16 @@ dom_exception _dom_element_is_default_namespace(dom_node_internal *node, return err; if (has == true) { - return dom_element_get_attribute(ele, xmlns, &value); - } + err = dom_element_get_attribute(ele, xmlns, &value); + if (err != DOM_NO_ERR) + return err; + + *result = dom_string_isequal(value, namespace); - lwc_string *ns2; - err = _dom_node_get_intern_string(node, value, &ns2); - if (err != DOM_NO_ERR) { - return err; - } - - if (ns2 != NULL) { - lwc_string_isequal(ns2, ns, result); - lwc_string_unref(ns); - lwc_string_unref(ns2); dom_string_unref(value); + return DOM_NO_ERR; } - return dom_node_is_default_namespace(node->parent, namespace, result); } @@ -1070,25 +1003,17 @@ dom_exception _dom_element_is_default_namespace(dom_node_internal *node, dom_exception _dom_element_lookup_namespace(dom_node_internal *node, dom_string *prefix, dom_string **result) { - lwc_string *pf; dom_exception err; - err = _dom_node_get_intern_string(node, prefix, &pf); - if (err != DOM_NO_ERR) - return err; - - /* To some extent, directly compare the two lwc_string pointer - * is better */ - if (node->namespace != NULL && node->prefix == pf) { - assert(node->owner != NULL); - return _dom_document_create_string_from_lwcstring(node->owner, - pf, result); + if (node->namespace != NULL && + dom_string_isequal(node->prefix, prefix)) { + *result = dom_string_ref(node->namespace); + return DOM_NO_ERR; } bool has; dom_string *xmlns = _dom_namespace_get_xmlns_prefix(); - err = dom_element_has_attribute_ns(node, - dom_namespaces[DOM_NAMESPACE_XMLNS], prefix, &has); + err = dom_element_has_attribute_ns(node, xmlns, prefix, &has); if (err != DOM_NO_ERR) return err; @@ -1153,26 +1078,7 @@ dom_exception _dom_element_parse_attribute(dom_element *ele, /* The destroy virtual function of dom_element */ void __dom_element_destroy(struct dom_node_internal *node) { - struct dom_document *doc = dom_node_get_owner(node); - - _dom_element_destroy(doc, (struct dom_element *) node); -} - -/* The memory allocator of this class */ -dom_exception _dom_element_alloc(dom_document *doc, struct dom_node_internal *n, - struct dom_node_internal **ret) -{ - dom_element *e; - UNUSED(n); - - e = _dom_document_alloc(doc, NULL, sizeof(struct dom_element)); - if (e == NULL) - return DOM_NO_MEM_ERR; - - *ret = (dom_node_internal *) e; - dom_node_set_owner(*ret, doc); - - return DOM_NO_ERR; + _dom_element_destroy((struct dom_element *) node); } /* TODO: How to deal with default attribue: @@ -1183,46 +1089,42 @@ dom_exception _dom_element_alloc(dom_document *doc, struct dom_node_internal *n, * are all specified. For the methods like importNode and adoptNode, * this will make _dom_element_copy can be used in them. */ -dom_exception _dom_element_copy(struct dom_node_internal *new, - struct dom_node_internal *old) +dom_exception _dom_element_copy(dom_node_internal *old, + dom_node_internal **copy) { - dom_element *ne = (dom_element *) new; - dom_element *oe = (dom_element *) old; - dom_document *od, *nd; + dom_element *olde = (dom_element *) old; + dom_element *e; struct dom_hash_table *ht; dom_exception err; + + e = malloc(sizeof(dom_element)); + if (e == NULL) + return DOM_NO_MEM_ERR; - err = _dom_node_copy(new, old); - if (err != DOM_NO_ERR) + err = dom_node_copy_internal(old, e); + if (err != DOM_NO_ERR) { + free(e); return err; + } - od = dom_node_get_owner(old); - nd = dom_node_get_owner(new); - assert(od != NULL); - assert(nd != NULL); - - dom_alloc alloc; - void *pw; - _dom_document_get_allocator(nd, &alloc, &pw); - /* Copy the hash tables */ - ht = _dom_hash_clone(oe->attributes, alloc, pw, _key, NULL, - _value, nd); + ht = _dom_hash_clone(olde->attributes); if (ht == NULL) return DOM_NO_MEM_ERR; - ne->attributes = ht; + e->attributes = ht; - ht = _dom_hash_clone(oe->ns_attributes, alloc, pw, _key, NULL, - _nsattributes, nd); + ht = _dom_hash_clone(olde->ns_attributes); if (ht == NULL) return DOM_NO_MEM_ERR; - ne->ns_attributes = ht; + e->ns_attributes = ht; - ne->id_ns = NULL; - ne->id_name = NULL; + e->id_ns = NULL; + e->id_name = NULL; /* TODO: deal with dom_type_info, it get no definition ! */ + *copy = (dom_node_internal *) e; + return DOM_NO_ERR; } @@ -1247,14 +1149,10 @@ dom_exception _dom_element_get_attr(struct dom_element *element, { void *a; dom_exception err = DOM_NO_ERR; - lwc_string *str; - /* Looking for name */ - err = _dom_node_get_intern_string(&element->base, name, &str); - if (err != DOM_NO_ERR) - return err; + UNUSED(element); - a = _dom_hash_get(hs, str); + a = _dom_hash_get(hs, name); /* Fill in value */ if (a == NULL) { @@ -1280,8 +1178,6 @@ dom_exception _dom_element_set_attr(struct dom_element *element, dom_string *value) { void *a; - dom_exception err; - lwc_string *str; bool added; dom_node_internal *e = (dom_node_internal *) element; @@ -1292,12 +1188,7 @@ dom_exception _dom_element_set_attr(struct dom_element *element, if (_dom_node_readonly(e)) return DOM_NO_MODIFICATION_ALLOWED_ERR; - /* Looking for name */ - err = _dom_node_get_intern_string(&element->base, name, &str); - if (err != DOM_NO_ERR) - return err; - - a = _dom_hash_get(hs, str); + a = _dom_hash_get(hs, name); if (a != NULL) { /* Found an existing attribute, so replace its value */ @@ -1333,7 +1224,7 @@ dom_exception _dom_element_set_attr(struct dom_element *element, dom_exception err; struct dom_attr *attr; - err = _dom_attr_create(e->owner, str, NULL, NULL, true, &attr); + err = _dom_attr_create(e->owner, name, NULL, NULL, true, &attr); if (err != DOM_NO_ERR) return err; @@ -1360,23 +1251,22 @@ dom_exception _dom_element_set_attr(struct dom_element *element, return err; } - err = _dom_dispatch_node_change_event(doc, - (dom_event_target *) attr, - (dom_event_target *) element, - DOM_MUTATION_ADDITION, &success); + err = dom_node_dispatch_node_change_event(doc, + attr, element, DOM_MUTATION_ADDITION, &success); if (err != DOM_NO_ERR) { dom_node_set_parent(attr, NULL); dom_node_unref(attr); return err; } - added = _dom_hash_add(hs, str, attr, false); + added = _dom_hash_add(hs, name, attr, false); if (added == false) { /* If we failed at this step, there must be no memory */ dom_node_set_parent(attr, NULL); dom_node_unref(attr); return DOM_NO_MEM_ERR; } + dom_string_ref(name); dom_node_unref(attr); dom_node_remove_pending(attr); @@ -1404,34 +1294,26 @@ dom_exception _dom_element_remove_attr(struct dom_element *element, { void *a; dom_exception err; - lwc_string *str; dom_node_internal *e = (dom_node_internal *) element; /* Ensure element can be written to */ if (_dom_node_readonly(e)) return DOM_NO_MODIFICATION_ALLOWED_ERR; - /* Looking for name */ - err = _dom_node_get_intern_string(&element->base, name, &str); - if (err != DOM_NO_ERR) - return err; - - a = (dom_node_internal *) _dom_hash_get(hs, str); + a = _dom_hash_get(hs, name); /* Detach attr node from list */ if (a != NULL) { /* Disptach DOMNodeRemoval event */ bool success = true; struct dom_document *doc = dom_node_get_owner(element); - err = _dom_dispatch_node_change_event(doc, - (dom_event_target *) a, - (dom_event_target *) element, - DOM_MUTATION_REMOVAL, &success); + err = dom_node_dispatch_node_change_event(doc, + a, element, DOM_MUTATION_REMOVAL, &success); if (err != DOM_NO_ERR) return err; /* Delete the attribute node */ - _dom_hash_del(hs, str); + _dom_hash_del(hs, name); /* Claim a reference for later event dispatch */ dom_node_ref(a); @@ -1485,15 +1367,10 @@ dom_exception _dom_element_get_attr_node(struct dom_element *element, struct dom_attr **result) { void *a; - dom_exception err; - lwc_string *str; - /* Looking for name */ - err = _dom_node_get_intern_string(&element->base, name, &str); - if (err != DOM_NO_ERR) - return err; + UNUSED(element); - a = _dom_hash_get(hs, str); + a = _dom_hash_get(hs, name); /* Fill in value */ if (a == NULL) { @@ -1528,7 +1405,6 @@ dom_exception _dom_element_set_attr_node(struct dom_element *element, struct dom_attr **result) { dom_exception err; - lwc_string *str = NULL; dom_string *name = NULL; bool added; dom_node_internal *e = (dom_node_internal *) element; @@ -1552,29 +1428,21 @@ dom_exception _dom_element_set_attr_node(struct dom_element *element, if (err != DOM_NO_ERR) return err; - /* Looking for name */ - err = _dom_node_get_intern_string(&element->base, name, &str); - if (err != DOM_NO_ERR) - return err; - - a = _dom_hash_get(hs, str); + a = _dom_hash_get(hs, name); *result = NULL; if (a != NULL) { /* Disptach DOMNodeRemoval event */ bool success = true; struct dom_document *doc = dom_node_get_owner(element); - err = _dom_dispatch_node_change_event(doc, - (dom_event_target *) a, - (dom_event_target *) element, - DOM_MUTATION_REMOVAL, &success); + err = dom_node_dispatch_node_change_event(doc, + a, element, DOM_MUTATION_REMOVAL, &success); if (err != DOM_NO_ERR) { dom_string_unref(name); - _dom_node_unref_intern_string(&element->base, str); return err; } - _dom_hash_del(hs, str); + _dom_hash_del(hs, name); dom_node_ref(a); *result = (dom_attr *) a; dom_node_set_parent(a, NULL); @@ -1590,7 +1458,6 @@ dom_exception _dom_element_set_attr_node(struct dom_element *element, if (err != DOM_NO_ERR && err != DOM_NOT_SUPPORTED_ERR) { dom_node_unref(a); dom_string_unref(name); - _dom_node_unref_intern_string(&element->base, str); return err; } err = _dom_dispatch_attr_modified_event(doc, e, old, NULL, @@ -1599,7 +1466,6 @@ dom_exception _dom_element_set_attr_node(struct dom_element *element, dom_string_unref(old); if (err != DOM_NO_ERR) { dom_string_unref(name); - _dom_node_unref_intern_string(&element->base, str); return err; } @@ -1608,18 +1474,17 @@ dom_exception _dom_element_set_attr_node(struct dom_element *element, (dom_event_target *) e, &success); if (err != DOM_NO_ERR) { dom_string_unref(name); - _dom_node_unref_intern_string(&element->base, str); return err; } } - added = _dom_hash_add(hs, str, attr, false); + added = _dom_hash_add(hs, name, attr, false); if (added == false) { dom_string_unref(name); - _dom_node_unref_intern_string(&element->base, str); /* If we failed at this step, there must be no memory */ return DOM_NO_MEM_ERR; } + dom_string_ref(name); dom_node_set_parent(attr, element); dom_node_remove_pending(attr); @@ -1639,14 +1504,12 @@ dom_exception _dom_element_set_attr_node(struct dom_element *element, /* Cleanup */ dom_string_unref(new); dom_string_unref(name); - _dom_node_unref_intern_string(&element->base, str); if (err != DOM_NO_ERR) { return err; } - err = _dom_dispatch_node_change_event(doc, (dom_event_target *) attr, - (dom_event_target *) element, DOM_MUTATION_ADDITION, - &success); + err = dom_node_dispatch_node_change_event(doc, attr, element, + DOM_MUTATION_ADDITION, &success); if (err != DOM_NO_ERR) return err; @@ -1680,7 +1543,6 @@ dom_exception _dom_element_remove_attr_node(struct dom_element *element, { void *a; dom_exception err; - lwc_string *str; dom_string *name; dom_node_internal *e = (dom_node_internal *) element; @@ -1692,40 +1554,31 @@ dom_exception _dom_element_remove_attr_node(struct dom_element *element, if (err != DOM_NO_ERR) return err; - /* Looking for name */ - err = _dom_node_get_intern_string(&element->base, name, &str); - if (err != DOM_NO_ERR) - return err; - - a = _dom_hash_get(hs, str); + a = _dom_hash_get(hs, name); /** \todo defaulted attribute handling */ if (a == NULL || a != (void *) attr) { dom_string_unref(name); - _dom_node_unref_intern_string(&element->base, str); return DOM_NOT_FOUND_ERR; } /* Dispatch a DOMNodeRemoved event */ bool success = true; struct dom_document *doc = dom_node_get_owner(element); - err = _dom_dispatch_node_change_event(doc, (dom_event_target *) a, - (dom_event_target *) element, DOM_MUTATION_REMOVAL, - &success); + err = dom_node_dispatch_node_change_event(doc, a, element, + DOM_MUTATION_REMOVAL, &success); if (err != DOM_NO_ERR) { dom_string_unref(name); - _dom_node_unref_intern_string(&element->base, str); return err; } /* Delete the attribute node */ - _dom_hash_del(hs, str); + _dom_hash_del(hs, name); dom_node_ref(a); - /* Now, cleaup the dom_string and lwc_string */ + /* Now, cleaup the dom_string */ dom_string_unref(name); - _dom_node_unref_intern_string(&element->base, str); /* Dispatch a DOMAttrModified event */ dom_string *old = NULL; @@ -1777,15 +1630,10 @@ dom_exception _dom_element_has_attr(struct dom_element *element, bool *result) { void *a; - dom_exception err; - lwc_string *str; - /* Looking for name */ - err = _dom_node_get_intern_string(&element->base, name, &str); - if (err != DOM_NO_ERR) - return err; + UNUSED(element); - a = _dom_hash_get(hs, str); + a = _dom_hash_get(hs, name); /* Fill in value */ if (a == NULL) { @@ -1810,16 +1658,9 @@ dom_exception _dom_element_set_id_attr(struct dom_element *element, struct dom_hash_table *hs, dom_string *name, bool is_id) { dom_attr *attr; - lwc_string *str; - dom_exception err; struct dom_hash_table *oh; - /* Looking for name */ - err = _dom_node_get_intern_string(&element->base, name, &str); - if (err != DOM_NO_ERR) - return err; - - attr = (dom_attr *) _dom_hash_get(hs, str); + attr = _dom_hash_get(hs, name); if (attr == NULL) return DOM_NOT_FOUND_ERR; @@ -1827,15 +1668,15 @@ dom_exception _dom_element_set_id_attr(struct dom_element *element, /* Firstly, clear the previous id attribute if there is one */ if (element->id_ns != NULL) { assert(element->id_name != NULL); - oh = (struct dom_hash_table *) _dom_hash_get( - element->ns_attributes, element->id_ns); + oh = _dom_hash_get(element->ns_attributes, + element->id_ns); } else { oh = element->attributes; } assert(oh != NULL); if (element->id_name != NULL) { - attr = (dom_attr *) _dom_hash_get(oh, element->id_name); + attr = _dom_hash_get(oh, element->id_name); assert(attr != NULL); _dom_attr_set_isid(attr, false); } @@ -1843,7 +1684,7 @@ dom_exception _dom_element_set_id_attr(struct dom_element *element, _dom_attr_set_isid(attr, is_id); - element->id_name = str; + element->id_name = dom_string_ref(name); return DOM_NO_ERR; } @@ -1855,7 +1696,7 @@ dom_exception _dom_element_set_id_attr(struct dom_element *element, * \param id The ID of this element * \return DOM_NO_ERR on success, appropriate dom_exception on failure. */ -dom_exception _dom_element_get_id(struct dom_element *ele, lwc_string **id) +dom_exception _dom_element_get_id(struct dom_element *ele, dom_string **id) { dom_exception err; dom_string *ret = NULL; @@ -1868,32 +1709,13 @@ dom_exception _dom_element_get_id(struct dom_element *ele, lwc_string **id) doc = dom_node_get_owner(ele); assert(doc != NULL); - dom_string *namespace, *name; - err = _dom_document_create_string_from_lwcstring(doc, - ele->id_ns, &namespace); - if (err != DOM_NO_ERR) - return err; - - err = _dom_document_create_string_from_lwcstring(doc, - ele->id_name, &name); - if (err != DOM_NO_ERR) { - dom_string_unref(namespace); - return err; - } - - err = _dom_element_get_attribute_ns(ele, namespace, name, &ret); + err = _dom_element_get_attribute_ns(ele, ele->id_ns, + ele->id_name, &ret); if (err != DOM_NO_ERR) { - dom_string_unref(namespace); - dom_string_unref(name); return err; } - dom_string_unref(namespace); - dom_string_unref(name); - - err = _dom_node_get_intern_string((dom_node_internal *) ele, - ret, id); - dom_string_unref(ret); + *id = ret; return err; } @@ -1903,37 +1725,24 @@ dom_exception _dom_element_get_id(struct dom_element *ele, lwc_string **id) dom_string *name; if (ele->id_name != NULL) { - err = _dom_document_create_string_from_lwcstring(doc, - ele->id_name, &name); - if (err != DOM_NO_ERR) { - return err; - } + name = ele->id_name; } else { - lwc_string *id_name = _dom_document_get_id_name(doc); - if (id_name == NULL) { + name = _dom_document_get_id_name(doc); + + if (name == NULL) { /* No ID attribute at all, just return NULL */ *id = NULL; return DOM_NO_ERR; } - err = _dom_document_create_string_from_lwcstring(doc, id_name, - &name); - if (err != DOM_NO_ERR) { - return err; - } } err = _dom_element_get_attribute(ele, name, &ret); if (err != DOM_NO_ERR) { - dom_string_unref(name); return err; } - dom_string_unref(name); - if (ret != NULL) { - err = _dom_node_get_intern_string((dom_node_internal *) ele, - ret, id); - dom_string_unref(ret); + *id = ret; } else { *id = NULL; } @@ -1951,7 +1760,7 @@ dom_exception attributes_get_length(void *priv, unsigned long *length) { unsigned int ret = 0; - unsigned int c1, *c2 = NULL; + uintptr_t c1, *c2 = NULL; void *key, *value; dom_element *e = (dom_element *) priv; @@ -2023,7 +1832,7 @@ dom_exception attributes_item(void *priv, unsigned int len; dom_element *e = (dom_element *) priv; void *key, *value; - unsigned int c1, *c2 = NULL; + uintptr_t c1, *c2 = NULL; len = _dom_hash_get_length(e->attributes); if (num <= len) { @@ -2135,85 +1944,80 @@ bool attributes_equal(void *p1, void *p2) } /*------------------ End of namednodemap functions -----------------------*/ -/* The key_func of the hash table, see utils/hashtable.h for details */ -void *_key(void *key, void *key_pw, dom_alloc alloc, void *pw, - bool clone) +uint32_t attributes_hash(void *key, void *pw) { + UNUSED(pw); + + return dom_string_hash(key); +} + +void *attributes_clone_key(void *key, void *pw) +{ + UNUSED(pw); + assert(key != NULL); - UNUSED(key_pw); - UNUSED(alloc); + return dom_string_ref(key); +} + +void attributes_destroy_key(void *key, void *pw) +{ UNUSED(pw); - if (clone == false) { - lwc_string_unref((lwc_string *) key); - return NULL; - } else { - lwc_error err; - lwc_string *ret; - const char *data = lwc_string_data((lwc_string *) key); - size_t len = lwc_string_length((lwc_string *) key); - err = lwc_intern_string(data, len, &ret); - if (err != lwc_error_ok) - return NULL; - - return ret; - } + assert(key != NULL); + + dom_string_unref(key); } -/* The value_func of the hash table, see utils/hashtable.h for details */ -void *_value(void *value, void *value_pw, dom_alloc alloc, - void *pw, bool clone) +void *attributes_clone_value(void *value, void *pw) { - assert(value != NULL); - assert(value_pw != NULL); + dom_exception err; + dom_node *node; - UNUSED(alloc); UNUSED(pw); - if (clone == false) { - dom_node_internal *a = (dom_node_internal *) value; - a->parent = NULL; - dom_node_try_destroy(a); - return NULL; - } else { - dom_exception err; - dom_node *node; + assert(value != NULL); - err = dom_document_import_node((dom_document *) value_pw, value, - true, &node); - if (err != DOM_NO_ERR) - return NULL; + err = dom_node_clone_node(value, true, &node); + if (err != DOM_NO_ERR) + return NULL; - return node; - } + return node; } -/* The value_func of the hash table, see utils/hashtable.h for details */ -void *_nsattributes(void *value, void *value_pw, dom_alloc alloc, - void *pw, bool clone) +void attributes_destroy_value(void *value, void *pw) { + dom_node_internal *a = (dom_node_internal *) value; + + UNUSED(pw); + assert(value != NULL); - assert(value_pw != NULL); - UNUSED(alloc); + a->parent = NULL; + dom_node_try_destroy(a); +} + +void *attributes_ns_clone_value(void *value, void *pw) +{ UNUSED(pw); - if (clone == false) { - _dom_hash_destroy((struct dom_hash_table *) value, _key, - value_pw, _value, value_pw); - return NULL; - } else { - dom_document *doc = (dom_document *) value_pw; - dom_alloc alloc; - void *pw; - struct dom_hash_table *ret = NULL; - _dom_document_get_allocator(doc, &alloc, &pw); + assert(value != NULL); - ret = _dom_hash_clone((struct dom_hash_table *) value, alloc, - pw, _key, NULL, _value, doc); + return _dom_hash_clone(value); +} - return ret; - } +void attributes_ns_destroy_value(void *value, void *pw) +{ + UNUSED(pw); + + assert(value != NULL); + + _dom_hash_destroy(value); } +bool attributes_key_isequal(void *key1, void *key2, void *pw) +{ + UNUSED(pw); + + return dom_string_isequal(key1, key2); +} -- cgit v1.2.3