nokolexbor 0.2.0

data/vendor/lexbor/source/lexbor/dom/interfaces/document.h

@@ -0,0 +1,243 @@
+/*
+ * Copyright (C) 2018-2021 Alexander Borisov
+ *
+ * Author: Alexander Borisov <borisov@lexbor.com>
+ */
+
+#ifndef LEXBOR_DOM_DOCUMENT_H
+#define LEXBOR_DOM_DOCUMENT_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "lexbor/core/mraw.h"
+#include "lexbor/core/hash.h"
+
+#include "lexbor/dom/interface.h"
+#include "lexbor/dom/interfaces/node.h"
+
+
+typedef enum {
+    LXB_DOM_DOCUMENT_CMODE_NO_QUIRKS       = 0x00,
+    LXB_DOM_DOCUMENT_CMODE_QUIRKS          = 0x01,
+    LXB_DOM_DOCUMENT_CMODE_LIMITED_QUIRKS  = 0x02
+}
+lxb_dom_document_cmode_t;
+
+typedef enum {
+    LXB_DOM_DOCUMENT_DTYPE_UNDEF = 0x00,
+    LXB_DOM_DOCUMENT_DTYPE_HTML  = 0x01,
+    LXB_DOM_DOCUMENT_DTYPE_XML   = 0x02
+}
+lxb_dom_document_dtype_t;
+
+struct lxb_dom_document {
+    lxb_dom_node_t              node;
+
+    lxb_dom_document_cmode_t    compat_mode;
+    lxb_dom_document_dtype_t    type;
+
+    lxb_dom_document_type_t     *doctype;
+    lxb_dom_element_t           *element;
+
+    lxb_dom_interface_create_f  create_interface;
+    lxb_dom_interface_clone_f   clone_interface;
+    lxb_dom_interface_destroy_f destroy_interface;
+
+    lexbor_mraw_t               *mraw;
+    lexbor_mraw_t               *text;
+    lexbor_hash_t               *tags;
+    lexbor_hash_t               *attrs;
+    lexbor_hash_t               *prefix;
+    lexbor_hash_t               *ns;
+    void                        *parser;
+    void                        *user;
+
+    bool                        tags_inherited;
+    bool                        ns_inherited;
+
+    bool                        scripting;
+};
+
+
+LXB_API lxb_dom_document_t *
+lxb_dom_document_interface_create(lxb_dom_document_t *document);
+
+LXB_API lxb_dom_document_t *
+lxb_dom_document_interface_clone(lxb_dom_document_t *document,
+                                 const lxb_dom_document_t *doc);
+
+LXB_API lxb_dom_document_t *
+lxb_dom_document_interface_destroy(lxb_dom_document_t *document);
+
+LXB_API lxb_dom_document_t *
+lxb_dom_document_create(lxb_dom_document_t *owner);
+
+LXB_API lxb_status_t
+lxb_dom_document_init(lxb_dom_document_t *document, lxb_dom_document_t *owner,
+                      lxb_dom_interface_create_f create_interface,
+                      lxb_dom_interface_clone_f clone_interface,
+                      lxb_dom_interface_destroy_f destroy_interface,
+                      lxb_dom_document_dtype_t type, unsigned int ns);
+
+LXB_API lxb_status_t
+lxb_dom_document_clean(lxb_dom_document_t *document);
+
+LXB_API lxb_dom_document_t *
+lxb_dom_document_destroy(lxb_dom_document_t *document);
+
+LXB_API void
+lxb_dom_document_attach_doctype(lxb_dom_document_t *document,
+                                lxb_dom_document_type_t *doctype);
+
+LXB_API void
+lxb_dom_document_attach_element(lxb_dom_document_t *document,
+                                lxb_dom_element_t *element);
+
+LXB_API lxb_dom_element_t *
+lxb_dom_document_create_element(lxb_dom_document_t *document,
+                                const lxb_char_t *local_name, size_t lname_len,
+                                void *reserved_for_opt);
+
+LXB_API lxb_dom_element_t *
+lxb_dom_document_destroy_element(lxb_dom_element_t *element);
+
+LXB_API lxb_dom_document_fragment_t *
+lxb_dom_document_create_document_fragment(lxb_dom_document_t *document);
+
+LXB_API lxb_dom_text_t *
+lxb_dom_document_create_text_node(lxb_dom_document_t *document,
+                                  const lxb_char_t *data, size_t len);
+
+LXB_API lxb_dom_cdata_section_t *
+lxb_dom_document_create_cdata_section(lxb_dom_document_t *document,
+                                      const lxb_char_t *data, size_t len);
+
+LXB_API lxb_dom_processing_instruction_t *
+lxb_dom_document_create_processing_instruction(lxb_dom_document_t *document,
+                                               const lxb_char_t *target, size_t target_len,
+                                               const lxb_char_t *data, size_t data_len);
+
+LXB_API lxb_dom_comment_t *
+lxb_dom_document_create_comment(lxb_dom_document_t *document,
+                                const lxb_char_t *data, size_t len);
+
+LXB_API lxb_dom_node_t *
+lxb_dom_document_root(lxb_dom_document_t *document);
+
+LXB_API lxb_dom_node_t *
+lxb_dom_document_import_node(lxb_dom_document_t *doc, lxb_dom_node_t *node,
+                             bool deep);
+
+/*
+ * Inline functions
+ */
+lxb_inline lxb_dom_interface_t *
+lxb_dom_document_create_interface(lxb_dom_document_t *document,
+                                  lxb_tag_id_t tag_id, lxb_ns_id_t ns)
+{
+    return document->create_interface(document, tag_id, ns);
+}
+
+lxb_inline lxb_dom_interface_t *
+lxb_dom_document_destroy_interface(lxb_dom_interface_t *intrfc)
+{
+    return lxb_dom_interface_node(intrfc)->owner_document->destroy_interface(intrfc);
+}
+
+lxb_inline void *
+lxb_dom_document_create_struct(lxb_dom_document_t *document, size_t struct_size)
+{
+    return lexbor_mraw_calloc(document->mraw, struct_size);
+}
+
+lxb_inline void *
+lxb_dom_document_destroy_struct(lxb_dom_document_t *document, void *structure)
+{
+    return lexbor_mraw_free(document->mraw, structure);
+}
+
+lxb_inline lxb_char_t *
+lxb_dom_document_create_text(lxb_dom_document_t *document, size_t len)
+{
+    return (lxb_char_t *) lexbor_mraw_alloc(document->text,
+                                            sizeof(lxb_char_t) * len);
+}
+
+lxb_inline void *
+lxb_dom_document_destroy_text(lxb_dom_document_t *document, lxb_char_t *text)
+{
+    return lexbor_mraw_free(document->text, text);
+}
+
+lxb_inline lxb_dom_element_t *
+lxb_dom_document_element(lxb_dom_document_t *document)
+{
+    return document->element;
+}
+
+lxb_inline bool
+lxb_dom_document_scripting(lxb_dom_document_t *document)
+{
+    return document->scripting;
+}
+
+lxb_inline void
+lxb_dom_document_scripting_set(lxb_dom_document_t *document, bool scripting)
+{
+    document->scripting = scripting;
+}
+
+lxb_inline lxb_dom_document_t *
+lxb_dom_document_owner(lxb_dom_document_t *document)
+{
+    return lxb_dom_interface_node(document)->owner_document;
+}
+
+lxb_inline bool
+lxb_dom_document_is_original(lxb_dom_document_t *document)
+{
+    return lxb_dom_interface_node(document)->owner_document == document;
+}
+
+/*
+ * No inline functions for ABI.
+ */
+LXB_API lxb_dom_interface_t *
+lxb_dom_document_create_interface_noi(lxb_dom_document_t *document,
+                                      lxb_tag_id_t tag_id, lxb_ns_id_t ns);
+
+LXB_API lxb_dom_interface_t *
+lxb_dom_document_destroy_interface_noi(lxb_dom_interface_t *intrfc);
+
+LXB_API void *
+lxb_dom_document_create_struct_noi(lxb_dom_document_t *document,
+                                   size_t struct_size);
+
+LXB_API void *
+lxb_dom_document_destroy_struct_noi(lxb_dom_document_t *document,
+                                    void *structure);
+
+LXB_API lxb_char_t *
+lxb_dom_document_create_text_noi(lxb_dom_document_t *document, size_t len);
+
+LXB_API void *
+lxb_dom_document_destroy_text_noi(lxb_dom_document_t *document,
+                                  lxb_char_t *text);
+
+LXB_API lxb_dom_element_t *
+lxb_dom_document_element_noi(lxb_dom_document_t *document);
+
+LXB_API bool
+lxb_dom_document_scripting_noi(lxb_dom_document_t *document);
+
+LXB_API void
+lxb_dom_document_scripting_set_noi(lxb_dom_document_t *document,
+                                   bool scripting);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* LEXBOR_DOM_DOCUMENT_H */

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

@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2018-2021 Alexander Borisov
+ *
+ * Author: Alexander Borisov <borisov@lexbor.com>
+ */
+
+#include "lexbor/dom/interfaces/document_fragment.h"
+#include "lexbor/dom/interfaces/document.h"
+
+
+lxb_dom_document_fragment_t *
+lxb_dom_document_fragment_interface_create(lxb_dom_document_t *document)
+{
+    lxb_dom_document_fragment_t *element;
+
+    element = lexbor_mraw_calloc(document->mraw,
+                                 sizeof(lxb_dom_document_fragment_t));
+    if (element == NULL) {
+        return NULL;
+    }
+
+    lxb_dom_node_t *node = lxb_dom_interface_node(element);
+
+    node->owner_document = lxb_dom_document_owner(document);
+    node->type = LXB_DOM_NODE_TYPE_DOCUMENT_FRAGMENT;
+
+    return element;
+}
+
+lxb_dom_document_fragment_t *
+lxb_dom_document_fragment_interface_destroy(lxb_dom_document_fragment_t *document_fragment)
+{
+    (void) lxb_dom_node_interface_destroy(lxb_dom_interface_node(document_fragment));
+
+    return NULL;
+}

data/vendor/lexbor/source/lexbor/dom/interfaces/document_fragment.h

@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2018-2021 Alexander Borisov
+ *
+ * Author: Alexander Borisov <borisov@lexbor.com>
+ */
+
+#ifndef LEXBOR_DOM_DOCUMENT_FRAGMENT_H
+#define LEXBOR_DOM_DOCUMENT_FRAGMENT_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "lexbor/dom/interfaces/document.h"
+#include "lexbor/dom/interfaces/node.h"
+
+
+struct lxb_dom_document_fragment {
+    lxb_dom_node_t    node;
+
+    lxb_dom_element_t *host;
+};
+
+
+LXB_API lxb_dom_document_fragment_t *
+lxb_dom_document_fragment_interface_create(lxb_dom_document_t *document);
+
+LXB_API lxb_dom_document_fragment_t *
+lxb_dom_document_fragment_interface_destroy(lxb_dom_document_fragment_t *document_fragment);
+
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* LEXBOR_DOM_DOCUMENT_FRAGMENT_H */

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

@@ -0,0 +1,125 @@
+/*
+ * Copyright (C) 2018-2021 Alexander Borisov
+ *
+ * Author: Alexander Borisov <borisov@lexbor.com>
+ */
+
+#include "lexbor/dom/interfaces/document_type.h"
+#include "lexbor/dom/interfaces/document.h"
+
+
+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);
+
+
+lxb_dom_document_type_t *
+lxb_dom_document_type_interface_create(lxb_dom_document_t *document)
+{
+    lxb_dom_document_type_t *element;
+
+    element = lexbor_mraw_calloc(document->mraw,
+                                 sizeof(lxb_dom_document_type_t));
+    if (element == NULL) {
+        return NULL;
+    }
+
+    lxb_dom_node_t *node = lxb_dom_interface_node(element);
+
+    node->owner_document = lxb_dom_document_owner(document);
+    node->type = LXB_DOM_NODE_TYPE_DOCUMENT_TYPE;
+
+    return element;
+}
+
+lxb_dom_document_type_t *
+lxb_dom_document_type_interface_clone(lxb_dom_document_t *document,
+                                      const lxb_dom_document_type_t *dtype)
+{
+    lxb_status_t status;
+    lxb_dom_document_type_t *new;
+    const lxb_dom_attr_data_t *data;
+
+    new = lxb_dom_document_type_interface_create(document);
+    if (new == NULL) {
+        return NULL;
+    }
+
+    status = lxb_dom_node_interface_copy(&new->node, &dtype->node, false);
+    if (status != LXB_STATUS_OK) {
+        return lxb_dom_document_type_interface_destroy(new);
+    }
+
+    if (document == dtype->node.owner_document) {
+        new->name = dtype->name;
+    }
+    else {
+        data = lxb_dom_attr_data_by_id(dtype->node.owner_document->attrs,
+                                       dtype->name);
+        if (data == NULL) {
+            return lxb_dom_document_type_interface_destroy(new);
+        }
+
+        data = lxb_dom_attr_qualified_name_append(document->attrs,
+                                                  lexbor_hash_entry_str(&data->entry),
+                                                  data->entry.length);
+        if (data == NULL) {
+            return lxb_dom_document_type_interface_destroy(new);
+        }
+
+        new->name = (lxb_dom_attr_id_t) data;
+    }
+
+    if (lexbor_str_copy(&new->public_id,
+                        &dtype->public_id, document->text) == NULL)
+    {
+        return lxb_dom_document_type_interface_destroy(new);
+    }
+
+    if (lexbor_str_copy(&new->system_id,
+                        &dtype->system_id, document->text) == NULL)
+    {
+        return lxb_dom_document_type_interface_destroy(new);
+    }
+
+    return new;
+}
+
+
+lxb_dom_document_type_t *
+lxb_dom_document_type_interface_destroy(lxb_dom_document_type_t *document_type)
+{
+    lexbor_mraw_t *text;
+
+    text = lxb_dom_interface_node(document_type)->owner_document->text;
+
+    (void) lexbor_str_destroy(&document_type->public_id, text, false);
+    (void) lexbor_str_destroy(&document_type->system_id, text, false);
+
+    (void) lxb_dom_node_interface_destroy(lxb_dom_interface_node(document_type));
+
+    return NULL;
+}
+
+/*
+ * No inline functions for ABI.
+ */
+const lxb_char_t *
+lxb_dom_document_type_name_noi(lxb_dom_document_type_t *doc_type, size_t *len)
+{
+    return lxb_dom_document_type_name(doc_type, len);
+}
+
+const lxb_char_t *
+lxb_dom_document_type_public_id_noi(lxb_dom_document_type_t *doc_type,
+                                    size_t *len)
+{
+    return lxb_dom_document_type_public_id(doc_type, len);
+}
+
+const lxb_char_t *
+lxb_dom_document_type_system_id_noi(lxb_dom_document_type_t *doc_type,
+                                    size_t *len)
+{
+    return lxb_dom_document_type_system_id(doc_type, len);
+}

data/vendor/lexbor/source/lexbor/dom/interfaces/document_type.h

@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2018-2021 Alexander Borisov
+ *
+ * Author: Alexander Borisov <borisov@lexbor.com>
+ */
+
+#ifndef LEXBOR_DOM_DOCUMENT_TYPE_H
+#define LEXBOR_DOM_DOCUMENT_TYPE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "lexbor/core/str.h"
+
+#include "lexbor/dom/interfaces/document.h"
+#include "lexbor/dom/interfaces/node.h"
+#include "lexbor/dom/interfaces/attr.h"
+#include "lexbor/dom/interfaces/document_type.h"
+
+
+struct lxb_dom_document_type {
+    lxb_dom_node_t    node;
+
+    lxb_dom_attr_id_t name;
+    lexbor_str_t      public_id;
+    lexbor_str_t      system_id;
+};
+
+
+LXB_API lxb_dom_document_type_t *
+lxb_dom_document_type_interface_create(lxb_dom_document_t *document);
+
+LXB_API lxb_dom_document_type_t *
+lxb_dom_document_type_interface_clone(lxb_dom_document_t *document,
+                                      const lxb_dom_document_type_t *dtype);
+
+LXB_API lxb_dom_document_type_t *
+lxb_dom_document_type_interface_destroy(lxb_dom_document_type_t *document_type);
+
+
+/*
+ * Inline functions
+ */
+lxb_inline const lxb_char_t *
+lxb_dom_document_type_name(lxb_dom_document_type_t *doc_type, size_t *len)
+{
+    const lxb_dom_attr_data_t *data;
+
+    static const lxb_char_t lxb_empty[] = "";
+
+    data = lxb_dom_attr_data_by_id(doc_type->node.owner_document->attrs,
+                                   doc_type->name);
+    if (data == NULL || doc_type->name == LXB_DOM_ATTR__UNDEF) {
+        if (len != NULL) {
+            *len = 0;
+        }
+
+        return lxb_empty;
+    }
+
+    if (len != NULL) {
+        *len = data->entry.length;
+    }
+
+    return lexbor_hash_entry_str(&data->entry);
+}
+
+lxb_inline const lxb_char_t *
+lxb_dom_document_type_public_id(lxb_dom_document_type_t *doc_type, size_t *len)
+{
+    if (len != NULL) {
+        *len = doc_type->public_id.length;
+    }
+
+    return doc_type->public_id.data;
+}
+
+lxb_inline const lxb_char_t *
+lxb_dom_document_type_system_id(lxb_dom_document_type_t *doc_type, size_t *len)
+{
+    if (len != NULL) {
+        *len = doc_type->system_id.length;
+    }
+
+    return doc_type->system_id.data;
+}
+
+/*
+ * No inline functions for ABI.
+ */
+LXB_API const lxb_char_t *
+lxb_dom_document_type_name_noi(lxb_dom_document_type_t *doc_type, size_t *len);
+
+LXB_API const lxb_char_t *
+lxb_dom_document_type_public_id_noi(lxb_dom_document_type_t *doc_type,
+                                    size_t *len);
+
+LXB_API const lxb_char_t *
+lxb_dom_document_type_system_id_noi(lxb_dom_document_type_t *doc_type,
+                                    size_t *len);
+
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* LEXBOR_DOM_DOCUMENT_TYPE_H */