nokolexbor 0.2.0

data/vendor/lexbor/source/lexbor/dom/exception.h

@@ -0,0 +1,73 @@
+/*
+ * Copyright (C) 2018 Alexander Borisov
+ *
+ * Author: Alexander Borisov <borisov@lexbor.com>
+ */
+
+#ifndef LEXBOR_DOM_EXCEPTION_H
+#define LEXBOR_DOM_EXCEPTION_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "lexbor/core/base.h"
+
+
+typedef enum {
+    LXB_DOM_INDEX_SIZE_ERR = 0x00,
+    LXB_DOM_DOMSTRING_SIZE_ERR,
+    LXB_DOM_HIERARCHY_REQUEST_ERR,
+    LXB_DOM_WRONG_DOCUMENT_ERR,
+    LXB_DOM_INVALID_CHARACTER_ERR,
+    LXB_DOM_NO_DATA_ALLOWED_ERR,
+    LXB_DOM_NO_MODIFICATION_ALLOWED_ERR,
+    LXB_DOM_NOT_FOUND_ERR,
+    LXB_DOM_NOT_SUPPORTED_ERR,
+    LXB_DOM_INUSE_ATTRIBUTE_ERR,
+    LXB_DOM_INVALID_STATE_ERR,
+    LXB_DOM_SYNTAX_ERR,
+    LXB_DOM_INVALID_MODIFICATION_ERR,
+    LXB_DOM_NAMESPACE_ERR,
+    LXB_DOM_INVALID_ACCESS_ERR,
+    LXB_DOM_VALIDATION_ERR,
+    LXB_DOM_TYPE_MISMATCH_ERR,
+    LXB_DOM_SECURITY_ERR,
+    LXB_DOM_NETWORK_ERR,
+    LXB_DOM_ABORT_ERR,
+    LXB_DOM_URL_MISMATCH_ERR,
+    LXB_DOM_QUOTA_EXCEEDED_ERR,
+    LXB_DOM_TIMEOUT_ERR,
+    LXB_DOM_INVALID_NODE_TYPE_ERR,
+    LXB_DOM_DATA_CLONE_ERR
+}
+lxb_dom_exception_code_t;
+
+
+/*
+ * Inline functions
+ */
+lxb_inline void *
+lxb_dom_exception_code_ref_set(lxb_dom_exception_code_t *var,
+                               lxb_dom_exception_code_t code)
+{
+    if (var != NULL) {
+        *var = code;
+    }
+
+    return NULL;
+}
+
+/*
+ * No inline functions for ABI.
+ */
+LXB_API void *
+lxb_dom_exception_code_ref_set_noi(lxb_dom_exception_code_t *var,
+                                   lxb_dom_exception_code_t code);
+
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* LEXBOR_DOM_EXCEPTION_H */

data/vendor/lexbor/source/lexbor/dom/interface.c

@@ -0,0 +1,110 @@
+/*
+ * Copyright (C) 2018-2021 Alexander Borisov
+ *
+ * Author: Alexander Borisov <borisov@lexbor.com>
+ */
+
+#include "lexbor/dom/interface.h"
+#include "lexbor/dom/interfaces/cdata_section.h"
+#include "lexbor/dom/interfaces/character_data.h"
+#include "lexbor/dom/interfaces/comment.h"
+#include "lexbor/dom/interfaces/document.h"
+#include "lexbor/dom/interfaces/document_fragment.h"
+#include "lexbor/dom/interfaces/document_type.h"
+#include "lexbor/dom/interfaces/element.h"
+#include "lexbor/dom/interfaces/event_target.h"
+#include "lexbor/dom/interfaces/node.h"
+#include "lexbor/dom/interfaces/processing_instruction.h"
+#include "lexbor/dom/interfaces/shadow_root.h"
+#include "lexbor/dom/interfaces/text.h"
+
+
+lxb_dom_interface_t *
+lxb_dom_interface_create(lxb_dom_document_t *document, lxb_tag_id_t tag_id,
+                         lxb_ns_id_t ns)
+{
+    lxb_dom_element_t *domel;
+
+    domel = lxb_dom_element_interface_create(document);
+    if (domel == NULL) {
+        return NULL;
+    }
+
+    domel->node.local_name = tag_id;
+    domel->node.ns = ns;
+
+    return domel;
+}
+
+lxb_dom_interface_t *
+lxb_dom_interface_clone(lxb_dom_document_t *document,
+                        const lxb_dom_interface_t *intrfc)
+{
+    const lxb_dom_node_t *node = intrfc;
+
+    if (document == NULL) {
+        document = node->owner_document;
+    }
+
+    switch (node->type) {
+        case LXB_DOM_NODE_TYPE_ELEMENT:
+            return lxb_dom_element_interface_clone(document, intrfc);
+
+        case LXB_DOM_NODE_TYPE_TEXT:
+            return lxb_dom_text_interface_clone(document, intrfc);
+
+        case LXB_DOM_NODE_TYPE_PROCESSING_INSTRUCTION:
+            return lxb_dom_processing_instruction_interface_clone(document,
+                                                                  intrfc);
+        case LXB_DOM_NODE_TYPE_COMMENT:
+            return lxb_dom_comment_interface_clone(document, intrfc);
+
+        case LXB_DOM_NODE_TYPE_DOCUMENT:
+            return lxb_dom_document_interface_clone(document, intrfc);
+
+        case LXB_DOM_NODE_TYPE_DOCUMENT_TYPE:
+            return lxb_dom_document_type_interface_clone(document, intrfc);
+
+        default:
+            return lxb_dom_node_interface_clone(document, node, false);
+    }
+}
+
+lxb_dom_interface_t *
+lxb_dom_interface_destroy(lxb_dom_interface_t *intrfc)
+{
+    if (intrfc == NULL) {
+        return NULL;
+    }
+
+    lxb_dom_node_t *node = intrfc;
+
+    switch (node->type) {
+        case LXB_DOM_NODE_TYPE_ELEMENT:
+            return lxb_dom_element_interface_destroy(intrfc);
+
+        case LXB_DOM_NODE_TYPE_TEXT:
+            return lxb_dom_text_interface_destroy(intrfc);
+
+        case LXB_DOM_NODE_TYPE_CDATA_SECTION:
+            return lxb_dom_cdata_section_interface_destroy(intrfc);
+
+        case LXB_DOM_NODE_TYPE_PROCESSING_INSTRUCTION:
+            return lxb_dom_processing_instruction_interface_destroy(intrfc);
+
+        case LXB_DOM_NODE_TYPE_COMMENT:
+            return lxb_dom_comment_interface_destroy(intrfc);
+
+        case LXB_DOM_NODE_TYPE_DOCUMENT:
+            return lxb_dom_document_interface_destroy(intrfc);
+
+        case LXB_DOM_NODE_TYPE_DOCUMENT_TYPE:
+            return lxb_dom_document_type_interface_destroy(intrfc);
+
+        case LXB_DOM_NODE_TYPE_DOCUMENT_FRAGMENT:
+            return lxb_dom_document_fragment_interface_destroy(intrfc);
+
+        default:
+            return lexbor_mraw_free(node->owner_document->mraw, intrfc);
+    }
+}

data/vendor/lexbor/source/lexbor/dom/interface.h

@@ -0,0 +1,88 @@
+/*
+ * Copyright (C) 2018-2021 Alexander Borisov
+ *
+ * Author: Alexander Borisov <borisov@lexbor.com>
+ */
+
+#ifndef LEXBOR_DOM_INTERFACES_H
+#define LEXBOR_DOM_INTERFACES_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "lexbor/core/base.h"
+
+#include "lexbor/tag/const.h"
+#include "lexbor/ns/const.h"
+
+#include "lexbor/dom/exception.h"
+
+
+#define lxb_dom_interface_cdata_section(obj) ((lxb_dom_cdata_section_t *) (obj))
+#define lxb_dom_interface_character_data(obj) ((lxb_dom_character_data_t *) (obj))
+#define lxb_dom_interface_comment(obj) ((lxb_dom_comment_t *) (obj))
+#define lxb_dom_interface_document(obj) ((lxb_dom_document_t *) (obj))
+#define lxb_dom_interface_document_fragment(obj) ((lxb_dom_document_fragment_t *) (obj))
+#define lxb_dom_interface_document_type(obj) ((lxb_dom_document_type_t *) (obj))
+#define lxb_dom_interface_element(obj) ((lxb_dom_element_t *) (obj))
+#define lxb_dom_interface_attr(obj) ((lxb_dom_attr_t *) (obj))
+#define lxb_dom_interface_event_target(obj) ((lxb_dom_event_target_t *) (obj))
+#define lxb_dom_interface_node(obj) ((lxb_dom_node_t *) (obj))
+#define lxb_dom_interface_processing_instruction(obj) ((lxb_dom_processing_instruction_t *) (obj))
+#define lxb_dom_interface_shadow_root(obj) ((lxb_dom_shadow_root_t *) (obj))
+#define lxb_dom_interface_text(obj) ((lxb_dom_text_t *) (obj))
+
+
+typedef struct lxb_dom_event_target lxb_dom_event_target_t;
+typedef struct lxb_dom_node lxb_dom_node_t;
+typedef struct lxb_dom_element lxb_dom_element_t;
+typedef struct lxb_dom_attr lxb_dom_attr_t;
+typedef struct lxb_dom_document lxb_dom_document_t;
+typedef struct lxb_dom_document_type lxb_dom_document_type_t;
+typedef struct lxb_dom_document_fragment lxb_dom_document_fragment_t;
+typedef struct lxb_dom_shadow_root lxb_dom_shadow_root_t;
+typedef struct lxb_dom_character_data lxb_dom_character_data_t;
+typedef struct lxb_dom_text lxb_dom_text_t;
+typedef struct lxb_dom_cdata_section lxb_dom_cdata_section_t;
+typedef struct lxb_dom_processing_instruction lxb_dom_processing_instruction_t;
+typedef struct lxb_dom_comment lxb_dom_comment_t;
+
+typedef void lxb_dom_interface_t;
+
+typedef void *
+(*lxb_dom_interface_constructor_f)(void *document);
+
+typedef void *
+(*lxb_dom_interface_destructor_f)(void *intrfc);
+
+
+typedef lxb_dom_interface_t *
+(*lxb_dom_interface_create_f)(lxb_dom_document_t *document, lxb_tag_id_t tag_id,
+                              lxb_ns_id_t ns);
+
+typedef lxb_dom_interface_t *
+(*lxb_dom_interface_clone_f)(lxb_dom_document_t *document,
+                             const lxb_dom_interface_t *intrfc);
+
+typedef lxb_dom_interface_t *
+(*lxb_dom_interface_destroy_f)(lxb_dom_interface_t *intrfc);
+
+
+LXB_API lxb_dom_interface_t *
+lxb_dom_interface_create(lxb_dom_document_t *document, lxb_tag_id_t tag_id,
+                         lxb_ns_id_t ns);
+
+LXB_API lxb_dom_interface_t *
+lxb_dom_interface_clone(lxb_dom_document_t *document,
+                        const lxb_dom_interface_t *intrfc);
+
+LXB_API lxb_dom_interface_t *
+lxb_dom_interface_destroy(lxb_dom_interface_t *intrfc);
+
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* LEXBOR_DOM_INTERFACES_H */

data/vendor/lexbor/source/lexbor/dom/interfaces/attr.c

@@ -0,0 +1,445 @@
+/*
+ * Copyright (C) 2018-2021 Alexander Borisov
+ *
+ * Author: Alexander Borisov <borisov@lexbor.com>
+ */
+
+#include "lexbor/dom/interfaces/attr.h"
+#include "lexbor/dom/interfaces/attr_res.h"
+#include "lexbor/dom/interfaces/document.h"
+
+
+LXB_API lxb_dom_attr_data_t *
+lxb_dom_attr_local_name_append(lexbor_hash_t *hash,
+                               const lxb_char_t *name, size_t length);
+
+LXB_API lxb_dom_attr_data_t *
+lxb_dom_attr_qualified_name_append(lexbor_hash_t *hash, const lxb_char_t *name,
+                                   size_t length);
+
+const lxb_ns_data_t *
+lxb_ns_append(lexbor_hash_t *hash, const lxb_char_t *link, size_t length);
+
+
+lxb_dom_attr_t *
+lxb_dom_attr_interface_create(lxb_dom_document_t *document)
+{
+    lxb_dom_attr_t *attr;
+
+    attr = lexbor_mraw_calloc(document->mraw, sizeof(lxb_dom_attr_t));
+    if (attr == NULL) {
+        return NULL;
+    }
+
+    lxb_dom_node_t *node = lxb_dom_interface_node(attr);
+
+    node->owner_document = lxb_dom_document_owner(document);
+    node->type = LXB_DOM_NODE_TYPE_ATTRIBUTE;
+
+    return attr;
+}
+
+lxb_dom_attr_t *
+lxb_dom_attr_interface_clone(lxb_dom_document_t *document,
+                             const lxb_dom_attr_t *attr)
+{
+    lxb_dom_attr_t *new;
+    const lxb_dom_attr_data_t *data;
+
+    new = lxb_dom_attr_interface_create(document);
+    if (new == NULL) {
+        return NULL;
+    }
+
+    if (document == attr->node.owner_document) {
+        new->qualified_name = attr->qualified_name;
+    }
+    else {
+        data = lxb_dom_attr_data_by_id(attr->node.owner_document->attrs,
+                                       attr->qualified_name);
+        if (data == NULL) {
+            goto failed;
+        }
+
+        if (data->attr_id < LXB_DOM_ATTR__LAST_ENTRY) {
+            new->qualified_name = attr->qualified_name;
+        }
+        else {
+            data = lxb_dom_attr_qualified_name_append(document->attrs,
+                                                      lexbor_hash_entry_str(&data->entry),
+                                                      data->entry.length);
+            if (data == NULL) {
+                goto failed;
+            }
+
+            new->qualified_name = (lxb_dom_attr_id_t) data;
+        }
+    }
+
+    if (lxb_dom_node_interface_copy(&new->node, &attr->node, true)
+        != LXB_STATUS_OK)
+    {
+        goto failed;
+    }
+
+    if (attr->value == NULL) {
+        return new;
+    }
+
+    new->value = lexbor_mraw_calloc(document->mraw, sizeof(lexbor_str_t));
+    if (new->value == NULL) {
+        goto failed;
+    }
+
+    if (lexbor_str_copy(new->value, attr->value, document->text) == NULL) {
+        goto failed;
+    }
+
+    return new;
+
+failed:
+
+    return lxb_dom_attr_interface_destroy(new);
+}
+
+lxb_dom_attr_t *
+lxb_dom_attr_interface_destroy(lxb_dom_attr_t *attr)
+{
+    lxb_dom_document_t *doc = lxb_dom_interface_node(attr)->owner_document;
+
+    if (attr->value != NULL) {
+        if (attr->value->data != NULL) {
+            lexbor_mraw_free(doc->text, attr->value->data);
+        }
+
+        lexbor_mraw_free(doc->mraw, attr->value);
+    }
+
+    (void) lxb_dom_node_interface_destroy(lxb_dom_interface_node(attr));
+
+    return NULL;
+}
+
+lxb_status_t
+lxb_dom_attr_set_name(lxb_dom_attr_t *attr, const lxb_char_t *name,
+                      size_t length, bool to_lowercase)
+{
+    lxb_dom_attr_data_t *data;
+    lxb_dom_document_t *doc = lxb_dom_interface_node(attr)->owner_document;
+
+    data = lxb_dom_attr_local_name_append(doc->attrs, name, length);
+    if (data == NULL) {
+        return LXB_STATUS_ERROR_MEMORY_ALLOCATION;
+    }
+
+    attr->node.local_name = data->attr_id;
+
+    if (to_lowercase == false) {
+        data = lxb_dom_attr_qualified_name_append(doc->attrs, name, length);
+        if (data == NULL) {
+            return LXB_STATUS_ERROR_MEMORY_ALLOCATION;
+        }
+
+        attr->qualified_name = (lxb_dom_attr_id_t) data;
+    }
+
+    return LXB_STATUS_OK;
+}
+
+lxb_status_t
+lxb_dom_attr_set_name_ns(lxb_dom_attr_t *attr, const lxb_char_t *link,
+                         size_t link_length, const lxb_char_t *name,
+                         size_t name_length, bool to_lowercase)
+{
+    size_t length;
+    lxb_char_t *p;
+    const lxb_ns_data_t *ns_data;
+    lxb_dom_attr_data_t *data;
+    lxb_dom_document_t *doc = lxb_dom_interface_node(attr)->owner_document;
+
+    ns_data = lxb_ns_append(doc->ns, link, link_length);
+    if (ns_data == NULL || ns_data->ns_id == LXB_NS__UNDEF) {
+        return LXB_STATUS_ERROR;
+    }
+
+    attr->node.ns = ns_data->ns_id;
+
+    /* TODO: append check https://www.w3.org/TR/xml/#NT-Name */
+
+    p = (lxb_char_t *) memchr(name, ':', name_length);
+    if (p == NULL) {
+        return lxb_dom_attr_set_name(attr, name, name_length, to_lowercase);
+    }
+
+    length = p - name;
+
+    /* local name */
+    data = lxb_dom_attr_local_name_append(doc->attrs, &name[(length + 1)],
+                                          (name_length - (length + 1)));
+    if (data == NULL) {
+        return LXB_STATUS_ERROR_MEMORY_ALLOCATION;
+    }
+
+    attr->node.local_name = (lxb_dom_attr_id_t) data;
+
+    /* qualified name */
+    data = lxb_dom_attr_qualified_name_append(doc->attrs, name, name_length);
+    if (data == NULL) {
+        return LXB_STATUS_ERROR;
+    }
+
+    attr->qualified_name = (lxb_dom_attr_id_t) data;
+
+    /* prefix */
+    attr->node.prefix = (lxb_ns_prefix_id_t) lxb_ns_prefix_append(doc->ns, name,
+                                                                  length);
+    if (attr->node.prefix == 0) {
+        return LXB_STATUS_ERROR;
+    }
+
+    return LXB_STATUS_OK;
+}
+
+lxb_status_t
+lxb_dom_attr_set_value(lxb_dom_attr_t *attr,
+                       const lxb_char_t *value, size_t value_len)
+{
+    lxb_dom_document_t *doc = lxb_dom_interface_node(attr)->owner_document;
+
+    if (attr->value == NULL) {
+        attr->value = lexbor_mraw_calloc(doc->mraw, sizeof(lexbor_str_t));
+        if (attr->value == NULL) {
+            return LXB_STATUS_ERROR_MEMORY_ALLOCATION;
+        }
+    }
+
+    if (attr->value->data == NULL) {
+        lexbor_str_init(attr->value, doc->text, value_len);
+        if (attr->value->data == NULL) {
+            return LXB_STATUS_ERROR_MEMORY_ALLOCATION;
+        }
+    }
+    else {
+        attr->value->length = 0;
+
+        if (lexbor_str_size(attr->value) <= value_len) {
+            const lxb_char_t *tmp;
+
+            tmp = lexbor_str_realloc(attr->value, doc->text, (value_len + 1));
+            if (tmp == NULL) {
+                return LXB_STATUS_ERROR_MEMORY_ALLOCATION;
+            }
+        }
+    }
+
+    memcpy(attr->value->data, value, sizeof(lxb_char_t) * value_len);
+
+    attr->value->data[value_len] = 0x00;
+    attr->value->length = value_len;
+
+    return LXB_STATUS_OK;
+}
+
+lxb_status_t
+lxb_dom_attr_set_value_wo_copy(lxb_dom_attr_t *attr,
+                               lxb_char_t *value, size_t value_len)
+{
+    if (attr->value == NULL) {
+        lxb_dom_document_t *doc = lxb_dom_interface_node(attr)->owner_document;
+
+        attr->value = lexbor_mraw_alloc(doc->mraw, sizeof(lexbor_str_t));
+        if (attr->value == NULL) {
+            return LXB_STATUS_ERROR_MEMORY_ALLOCATION;
+        }
+    }
+
+    attr->value->data = value;
+    attr->value->length = value_len;
+
+    return LXB_STATUS_OK;
+}
+
+lxb_status_t
+lxb_dom_attr_set_existing_value(lxb_dom_attr_t *attr,
+                                const lxb_char_t *value, size_t value_len)
+{
+    return lxb_dom_attr_set_value(attr, value, value_len);
+}
+
+lxb_status_t
+lxb_dom_attr_clone_name_value(lxb_dom_attr_t *attr_from,
+                              lxb_dom_attr_t *attr_to)
+{
+    attr_to->node.local_name = attr_from->node.local_name;
+    attr_to->qualified_name = attr_from->qualified_name;
+
+    return LXB_STATUS_OK;
+}
+
+bool
+lxb_dom_attr_compare(lxb_dom_attr_t *first, lxb_dom_attr_t *second)
+{
+    if (first->node.local_name == second->node.local_name
+        && first->node.ns == second->node.ns
+        && first->qualified_name == second->qualified_name)
+    {
+        if (first->value == NULL) {
+            if (second->value == NULL) {
+                return true;
+            }
+
+            return false;
+        }
+
+        if (second->value != NULL
+            && first->value->length == second->value->length
+            && lexbor_str_data_ncmp(first->value->data, second->value->data,
+                                    first->value->length))
+        {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+lxb_dom_attr_data_t *
+lxb_dom_attr_local_name_append(lexbor_hash_t *hash,
+                               const lxb_char_t *name, size_t length)
+{
+    lxb_dom_attr_data_t *data;
+    const lexbor_shs_entry_t *entry;
+
+    if (name == NULL || length == 0) {
+        return NULL;
+    }
+
+    entry = lexbor_shs_entry_get_lower_static(lxb_dom_attr_res_shs_data,
+                                              name, length);
+    if (entry != NULL) {
+        return entry->value;
+    }
+
+    data = lexbor_hash_insert(hash, lexbor_hash_insert_lower, name, length);
+    if (data == NULL) {
+        return NULL;
+    }
+
+    data->attr_id = (uintptr_t) data;
+
+    return data;
+}
+
+lxb_dom_attr_data_t *
+lxb_dom_attr_qualified_name_append(lexbor_hash_t *hash, const lxb_char_t *name,
+                                   size_t length)
+{
+    lxb_dom_attr_data_t *data;
+
+    if (name == NULL || length == 0) {
+        return NULL;
+    }
+
+    data = lexbor_hash_insert(hash, lexbor_hash_insert_raw, name, length);
+    if (data == NULL) {
+        return NULL;
+    }
+
+    data->attr_id = (uintptr_t) data;
+
+    return data;
+}
+
+const lxb_dom_attr_data_t *
+lxb_dom_attr_data_undef(void)
+{
+    return &lxb_dom_attr_res_data_default[LXB_DOM_ATTR__UNDEF];
+}
+
+const lxb_dom_attr_data_t *
+lxb_dom_attr_data_by_id(lexbor_hash_t *hash, lxb_dom_attr_id_t attr_id)
+{
+    if (attr_id >= LXB_DOM_ATTR__LAST_ENTRY) {
+        if (attr_id == LXB_DOM_ATTR__LAST_ENTRY) {
+            return NULL;
+        }
+
+        return (const lxb_dom_attr_data_t *) attr_id;
+    }
+
+    return &lxb_dom_attr_res_data_default[attr_id];
+}
+
+const lxb_dom_attr_data_t *
+lxb_dom_attr_data_by_local_name(lexbor_hash_t *hash,
+                                const lxb_char_t *name, size_t length)
+{
+    const lexbor_shs_entry_t *entry;
+
+    if (name == NULL || length == 0) {
+        return NULL;
+    }
+
+    entry = lexbor_shs_entry_get_lower_static(lxb_dom_attr_res_shs_data,
+                                              name, length);
+    if (entry != NULL) {
+        return entry->value;
+    }
+
+    return lexbor_hash_search(hash, lexbor_hash_search_lower, name, length);
+}
+
+const lxb_dom_attr_data_t *
+lxb_dom_attr_data_by_qualified_name(lexbor_hash_t *hash,
+                                    const lxb_char_t *name, size_t length)
+{
+    const lexbor_shs_entry_t *entry;
+
+    if (name == NULL || length == 0) {
+        return NULL;
+    }
+
+    entry = lexbor_shs_entry_get_static(lxb_dom_attr_res_shs_data,
+                                        name, length);
+    if (entry != NULL) {
+        return entry->value;
+    }
+
+    return lexbor_hash_search(hash, lexbor_hash_search_raw, name, length);
+}
+
+const lxb_char_t *
+lxb_dom_attr_qualified_name(lxb_dom_attr_t *attr, size_t *len)
+{
+    const lxb_dom_attr_data_t *data;
+
+    if (attr->qualified_name != 0) {
+        data = lxb_dom_attr_data_by_id(attr->node.owner_document->attrs,
+                                       attr->qualified_name);
+    }
+    else {
+        data = lxb_dom_attr_data_by_id(attr->node.owner_document->attrs,
+                                       attr->node.local_name);
+    }
+
+    if (len != NULL) {
+        *len = data->entry.length;
+    }
+
+    return lexbor_hash_entry_str(&data->entry);
+}
+
+/*
+ * No inline functions for ABI.
+ */
+const lxb_char_t *
+lxb_dom_attr_local_name_noi(lxb_dom_attr_t *attr, size_t *len)
+{
+    return lxb_dom_attr_local_name(attr, len);
+}
+
+const lxb_char_t *
+lxb_dom_attr_value_noi(lxb_dom_attr_t *attr, size_t *len)
+{
+    return lxb_dom_attr_value(attr, len);
+}