nokolexbor 0.2.0

data/vendor/lexbor/source/lexbor/html/token.c

@@ -0,0 +1,386 @@
+/*
+ * Copyright (C) 2018-2020 Alexander Borisov
+ *
+ * Author: Alexander Borisov <borisov@lexbor.com>
+ */
+
+#include "lexbor/html/token.h"
+#include "lexbor/html/tokenizer.h"
+
+#define LEXBOR_STR_RES_MAP_LOWERCASE
+#define LEXBOR_STR_RES_ANSI_REPLACEMENT_CHARACTER
+#define LEXBOR_STR_RES_MAP_HEX
+#define LEXBOR_STR_RES_MAP_NUM
+#include "lexbor/core/str_res.h"
+
+#include "lexbor/dom/interfaces/document_type.h"
+
+
+const lxb_tag_data_t *
+lxb_tag_append_lower(lexbor_hash_t *hash,
+                     const lxb_char_t *name, size_t length);
+
+
+lxb_html_token_t *
+lxb_html_token_create(lexbor_dobject_t *dobj)
+{
+    return lexbor_dobject_calloc(dobj);
+}
+
+lxb_html_token_t *
+lxb_html_token_destroy(lxb_html_token_t *token, lexbor_dobject_t *dobj)
+{
+    return lexbor_dobject_free(dobj, token);
+}
+
+lxb_html_token_attr_t *
+lxb_html_token_attr_append(lxb_html_token_t *token, lexbor_dobject_t *dobj)
+{
+    lxb_html_token_attr_t *attr = lxb_html_token_attr_create(dobj);
+    if (attr == NULL) {
+        return NULL;
+    }
+
+    if (token->attr_last == NULL) {
+        token->attr_first = attr;
+        token->attr_last = attr;
+
+        return attr;
+    }
+
+    token->attr_last->next = attr;
+    attr->prev = token->attr_last;
+
+    token->attr_last = attr;
+
+    return attr;
+}
+
+void
+lxb_html_token_attr_remove(lxb_html_token_t *token, lxb_html_token_attr_t *attr)
+{
+    if (token->attr_first == attr) {
+        token->attr_first = attr->next;
+    }
+
+    if (token->attr_last == attr) {
+        token->attr_last = attr->prev;
+    }
+
+    if (attr->next != NULL) {
+        attr->next->prev = attr->prev;
+    }
+
+    if (attr->prev != NULL) {
+        attr->prev->next = attr->next;
+    }
+
+    attr->next = NULL;
+    attr->prev = NULL;
+}
+
+void
+lxb_html_token_attr_delete(lxb_html_token_t *token,
+                           lxb_html_token_attr_t *attr, lexbor_dobject_t *dobj)
+{
+    lxb_html_token_attr_remove(token, attr);
+    lxb_html_token_attr_destroy(attr, dobj);
+}
+
+lxb_status_t
+lxb_html_token_make_text(lxb_html_token_t *token, lexbor_str_t *str,
+                         lexbor_mraw_t *mraw)
+{
+    size_t len = token->text_end - token->text_start;
+
+    (void) lexbor_str_init(str, mraw, len);
+    if (str->data == NULL) {
+        return LXB_STATUS_ERROR_MEMORY_ALLOCATION;
+    }
+
+    memcpy(str->data, token->text_start, len);
+
+    str->data[len] = 0x00;
+    str->length = len;
+
+    return LXB_STATUS_OK;
+}
+
+lxb_status_t
+lxb_html_token_make_text_drop_null(lxb_html_token_t *token, lexbor_str_t *str,
+                                   lexbor_mraw_t *mraw)
+{
+    lxb_char_t *p, c;
+    const lxb_char_t *data = token->text_start;
+    const lxb_char_t *end = token->text_end;
+
+    size_t len = (end - data) - token->null_count;
+
+    (void) lexbor_str_init(str, mraw, len);
+    if (str->data == NULL) {
+        return LXB_STATUS_ERROR_MEMORY_ALLOCATION;
+    }
+
+    p = str->data;
+
+    while (data < end) {
+        c = *data++;
+
+        if (c != 0x00) {
+            *p++ = c;
+        }
+    }
+
+    str->data[len] = 0x00;
+    str->length = len;
+
+    return LXB_STATUS_OK;
+}
+
+lxb_status_t
+lxb_html_token_make_text_replace_null(lxb_html_token_t *token,
+                                      lexbor_str_t *str, lexbor_mraw_t *mraw)
+{
+    lxb_char_t *p, c;
+    const lxb_char_t *data = token->text_start;
+    const lxb_char_t *end = token->text_end;
+
+    static const unsigned rep_len = sizeof(lexbor_str_res_ansi_replacement_character) - 1;
+
+    size_t len = (end - data) + (token->null_count * rep_len) - token->null_count;
+
+    (void) lexbor_str_init(str, mraw, len);
+    if (str->data == NULL) {
+        return LXB_STATUS_ERROR_MEMORY_ALLOCATION;
+    }
+
+    p = str->data;
+
+    while (data < end) {
+        c = *data++;
+
+        if (c == 0x00) {
+            memcpy(p, lexbor_str_res_ansi_replacement_character, rep_len);
+            p += rep_len;
+
+            continue;
+        }
+
+        *p++ = c;
+    }
+
+    str->data[len] = 0x00;
+    str->length = len;
+
+    return LXB_STATUS_OK;
+}
+
+lxb_status_t
+lxb_html_token_data_skip_ws_begin(lxb_html_token_t *token)
+{
+    const lxb_char_t *data = token->text_start;
+    const lxb_char_t *end = token->text_end;
+
+    while (data < end) {
+        switch (*data) {
+            /*
+             * U+0009 CHARACTER TABULATION (tab)
+             * U+000A LINE FEED (LF)
+             * U+000C FORM FEED (FF)
+             * U+0020 SPACE
+             */
+            case 0x09:
+            case 0x0A:
+            case 0x0D:
+            case 0x20:
+                break;
+
+            default:
+                token->begin += data - token->text_start;
+                token->text_start = data;
+
+                return LXB_STATUS_OK;
+        }
+
+        data++;
+    }
+
+    token->begin += data - token->text_start;
+    token->text_start = data;
+
+    return LXB_STATUS_OK;
+}
+
+lxb_status_t
+lxb_html_token_data_skip_one_newline_begin(lxb_html_token_t *token)
+{
+    const lxb_char_t *data = token->text_start;
+    const lxb_char_t *end = token->text_end;
+
+    if (data < end) {
+        /* U+000A LINE FEED (LF) */
+        if (*data == 0x0A) {
+            token->begin++;
+            token->text_start++;
+        }
+    }
+
+    return LXB_STATUS_OK;
+}
+
+lxb_status_t
+lxb_html_token_data_split_ws_begin(lxb_html_token_t *token,
+                                   lxb_html_token_t *ws_token)
+{
+    *ws_token = *token;
+
+    lxb_status_t status = lxb_html_token_data_skip_ws_begin(token);
+    if (status != LXB_STATUS_OK) {
+        return status;
+    }
+
+    if (token->text_start == token->text_end) {
+        return LXB_STATUS_OK;
+    }
+
+    if (token->text_start == ws_token->text_start) {
+        memset(ws_token, 0, sizeof(lxb_html_token_t));
+
+        return LXB_STATUS_OK;
+    }
+
+    ws_token->end = token->begin;
+    ws_token->text_end = token->text_start;
+
+    return LXB_STATUS_OK;
+}
+
+lxb_status_t
+lxb_html_token_doctype_parse(lxb_html_token_t *token,
+                             lxb_dom_document_type_t *doc_type)
+{
+    lxb_html_token_attr_t *attr;
+    lexbor_mraw_t *mraw = doc_type->node.owner_document->mraw;
+
+    /* Set all to empty string if attr not exist */
+    if (token->attr_first == NULL) {
+        goto set_name_pub_sys_empty;
+    }
+
+    /* Name */
+    attr = token->attr_first;
+
+    doc_type->name = attr->name->attr_id;
+
+    /* PUBLIC or SYSTEM */
+    attr = attr->next;
+    if (attr == NULL) {
+        goto set_pub_sys_empty;
+    }
+
+    if (attr->name->attr_id == LXB_DOM_ATTR_PUBLIC) {
+        (void) lexbor_str_init(&doc_type->public_id, mraw, attr->value_size);
+        if (doc_type->public_id.data == NULL) {
+            return LXB_STATUS_ERROR_MEMORY_ALLOCATION;
+        }
+
+        if (attr->value_begin == NULL) {
+            return LXB_STATUS_OK;
+        }
+
+        (void) lexbor_str_append(&doc_type->public_id, mraw, attr->value,
+                                 attr->value_size);
+    }
+    else if (attr->name->attr_id == LXB_DOM_ATTR_SYSTEM) {
+        (void) lexbor_str_init(&doc_type->system_id, mraw, attr->value_size);
+        if (doc_type->system_id.data == NULL) {
+            return LXB_STATUS_ERROR_MEMORY_ALLOCATION;
+        }
+
+        if (attr->value_begin == NULL) {
+            return LXB_STATUS_OK;
+        }
+
+        (void) lexbor_str_append(&doc_type->system_id, mraw, attr->value,
+                                 attr->value_size);
+
+        return LXB_STATUS_OK;
+    }
+    else {
+        goto set_pub_sys_empty;
+    }
+
+    /* SUSTEM */
+    attr = attr->next;
+    if (attr == NULL) {
+        goto set_sys_empty;
+    }
+
+    (void) lexbor_str_init(&doc_type->system_id, mraw, attr->value_size);
+    if (doc_type->system_id.data == NULL) {
+        return LXB_STATUS_ERROR_MEMORY_ALLOCATION;
+    }
+
+    (void) lexbor_str_append(&doc_type->system_id, mraw, attr->value,
+                             attr->value_size);
+
+    return LXB_STATUS_OK;
+
+set_name_pub_sys_empty:
+
+    doc_type->name = LXB_DOM_ATTR__UNDEF;
+
+set_pub_sys_empty:
+
+    (void) lexbor_str_init(&doc_type->public_id, mraw, 0);
+    if (doc_type->public_id.data == NULL) {
+        return LXB_STATUS_ERROR_MEMORY_ALLOCATION;
+    }
+
+set_sys_empty:
+
+    (void) lexbor_str_init(&doc_type->system_id, mraw, 0);
+    if (doc_type->system_id.data == NULL) {
+        return LXB_STATUS_ERROR_MEMORY_ALLOCATION;
+    }
+
+    return LXB_HTML_STATUS_OK;
+}
+
+lxb_html_token_attr_t *
+lxb_html_token_find_attr(lxb_html_tokenizer_t *tkz, lxb_html_token_t *token,
+                         const lxb_char_t *name, size_t name_len)
+{
+    const lxb_dom_attr_data_t *data;
+    lxb_html_token_attr_t *attr = token->attr_first;
+
+    data = lxb_dom_attr_data_by_local_name(tkz->attrs, name, name_len);
+    if (data == NULL) {
+        return NULL;
+    }
+
+    while (attr != NULL) {
+        if (attr->name->attr_id == data->attr_id) {
+            return attr;
+        }
+
+        attr = attr->next;
+    }
+
+    return NULL;
+}
+
+/*
+ * No inline functions for ABI.
+ */
+void
+lxb_html_token_clean_noi(lxb_html_token_t *token)
+{
+    lxb_html_token_clean(token);
+}
+
+lxb_html_token_t *
+lxb_html_token_create_eof_noi(lexbor_dobject_t *dobj)
+{
+    return lxb_html_token_create_eof(dobj);
+}

data/vendor/lexbor/source/lexbor/html/token.h

@@ -0,0 +1,130 @@
+/*
+ * Copyright (C) 2018-2020 Alexander Borisov
+ *
+ * Author: Alexander Borisov <borisov@lexbor.com>
+ */
+
+#ifndef LEXBOR_HTML_TOKEN_H
+#define LEXBOR_HTML_TOKEN_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "lexbor/core/dobject.h"
+#include "lexbor/core/str.h"
+
+#include "lexbor/html/base.h"
+#include "lexbor/html/token_attr.h"
+#include "lexbor/tag/tag.h"
+
+
+typedef int lxb_html_token_type_t;
+
+
+enum lxb_html_token_type {
+    LXB_HTML_TOKEN_TYPE_OPEN         = 0x0000,
+    LXB_HTML_TOKEN_TYPE_CLOSE        = 0x0001,
+    LXB_HTML_TOKEN_TYPE_CLOSE_SELF   = 0x0002,
+    LXB_HTML_TOKEN_TYPE_FORCE_QUIRKS = 0x0004,
+    LXB_HTML_TOKEN_TYPE_DONE         = 0x0008
+};
+
+typedef struct {
+    const lxb_char_t      *begin;
+    const lxb_char_t      *end;
+
+    const lxb_char_t      *text_start;
+    const lxb_char_t      *text_end;
+
+    lxb_html_token_attr_t *attr_first;
+    lxb_html_token_attr_t *attr_last;
+
+    void                  *base_element;
+
+    size_t                null_count;
+    lxb_tag_id_t          tag_id;
+    lxb_html_token_type_t type;
+}
+lxb_html_token_t;
+
+
+LXB_API lxb_html_token_t *
+lxb_html_token_create(lexbor_dobject_t *dobj);
+
+LXB_API lxb_html_token_t *
+lxb_html_token_destroy(lxb_html_token_t *token, lexbor_dobject_t *dobj);
+
+LXB_API lxb_html_token_attr_t *
+lxb_html_token_attr_append(lxb_html_token_t *token, lexbor_dobject_t *dobj);
+
+LXB_API void
+lxb_html_token_attr_remove(lxb_html_token_t *token,
+                           lxb_html_token_attr_t *attr);
+
+LXB_API void
+lxb_html_token_attr_delete(lxb_html_token_t *token,
+                           lxb_html_token_attr_t *attr, lexbor_dobject_t *dobj);
+
+LXB_API lxb_status_t
+lxb_html_token_make_text(lxb_html_token_t *token, lexbor_str_t *str,
+                         lexbor_mraw_t *mraw);
+
+LXB_API lxb_status_t
+lxb_html_token_make_text_drop_null(lxb_html_token_t *token, lexbor_str_t *str,
+                                   lexbor_mraw_t *mraw);
+
+LXB_API lxb_status_t
+lxb_html_token_make_text_replace_null(lxb_html_token_t *token,
+                                      lexbor_str_t *str, lexbor_mraw_t *mraw);
+
+LXB_API lxb_status_t
+lxb_html_token_data_skip_ws_begin(lxb_html_token_t *token);
+
+LXB_API lxb_status_t
+lxb_html_token_data_skip_one_newline_begin(lxb_html_token_t *token);
+
+LXB_API lxb_status_t
+lxb_html_token_data_split_ws_begin(lxb_html_token_t *token,
+                                   lxb_html_token_t *ws_token);
+
+LXB_API lxb_status_t
+lxb_html_token_doctype_parse(lxb_html_token_t *token,
+                             lxb_dom_document_type_t *doc_type);
+
+LXB_API lxb_html_token_attr_t *
+lxb_html_token_find_attr(lxb_html_tokenizer_t *tkz, lxb_html_token_t *token,
+                         const lxb_char_t *name, size_t name_len);
+
+
+/*
+ * Inline functions
+ */
+lxb_inline void
+lxb_html_token_clean(lxb_html_token_t *token)
+{
+    memset(token, 0, sizeof(lxb_html_token_t));
+}
+
+lxb_inline lxb_html_token_t *
+lxb_html_token_create_eof(lexbor_dobject_t *dobj)
+{
+    return (lxb_html_token_t *) lexbor_dobject_calloc(dobj);
+}
+
+/*
+ * No inline functions for ABI.
+ */
+LXB_API void
+lxb_html_token_clean_noi(lxb_html_token_t *token);
+
+LXB_API lxb_html_token_t *
+lxb_html_token_create_eof_noi(lexbor_dobject_t *dobj);
+
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* LEXBOR_HTML_TOKEN_H */
+

data/vendor/lexbor/source/lexbor/html/token_attr.c

@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2018-2020 Alexander Borisov
+ *
+ * Author: Alexander Borisov <borisov@lexbor.com>
+ */
+
+#include "lexbor/html/token_attr.h"
+
+
+lxb_html_token_attr_t *
+lxb_html_token_attr_create(lexbor_dobject_t *dobj)
+{
+    return lexbor_dobject_calloc(dobj);
+}
+
+void
+lxb_html_token_attr_clean(lxb_html_token_attr_t *attr)
+{
+    memset(attr, 0, sizeof(lxb_html_token_attr_t));
+}
+
+lxb_html_token_attr_t *
+lxb_html_token_attr_destroy(lxb_html_token_attr_t *attr, lexbor_dobject_t *dobj)
+{
+    return lexbor_dobject_free(dobj, attr);
+}
+
+const lxb_char_t *
+lxb_html_token_attr_name(lxb_html_token_attr_t *attr, size_t *length)
+{
+    if (attr->name == NULL) {
+        if (length != NULL) {
+            *length = 0;
+        }
+
+        return NULL;
+    }
+
+    if (length != NULL) {
+        *length = attr->name->entry.length;
+    }
+
+    return lexbor_hash_entry_str(&attr->name->entry);
+}

data/vendor/lexbor/source/lexbor/html/token_attr.h

@@ -0,0 +1,67 @@
+/*
+ * Copyright (C) 2018-2020 Alexander Borisov
+ *
+ * Author: Alexander Borisov <borisov@lexbor.com>
+ */
+
+#ifndef LEXBOR_HTML_TOKEN_ATTR_H
+#define LEXBOR_HTML_TOKEN_ATTR_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "lexbor/core/str.h"
+#include "lexbor/core/dobject.h"
+
+#include "lexbor/dom/interfaces/attr.h"
+
+#include "lexbor/html/base.h"
+
+
+typedef struct lxb_html_token_attr lxb_html_token_attr_t;
+typedef int lxb_html_token_attr_type_t;
+
+enum lxb_html_token_attr_type {
+    LXB_HTML_TOKEN_ATTR_TYPE_UNDEF      = 0x0000,
+    LXB_HTML_TOKEN_ATTR_TYPE_NAME_NULL  = 0x0001,
+    LXB_HTML_TOKEN_ATTR_TYPE_VALUE_NULL = 0x0002
+};
+
+struct lxb_html_token_attr {
+    const lxb_char_t           *name_begin;
+    const lxb_char_t           *name_end;
+
+    const lxb_char_t           *value_begin;
+    const lxb_char_t           *value_end;
+
+    const lxb_dom_attr_data_t  *name;
+    lxb_char_t                 *value;
+    size_t                     value_size;
+
+    lxb_html_token_attr_t      *next;
+    lxb_html_token_attr_t      *prev;
+
+    lxb_html_token_attr_type_t type;
+};
+
+
+LXB_API lxb_html_token_attr_t *
+lxb_html_token_attr_create(lexbor_dobject_t *dobj);
+
+LXB_API void
+lxb_html_token_attr_clean(lxb_html_token_attr_t *attr);
+
+LXB_API lxb_html_token_attr_t *
+lxb_html_token_attr_destroy(lxb_html_token_attr_t *attr,
+                            lexbor_dobject_t *dobj);
+
+LXB_API const lxb_char_t *
+lxb_html_token_attr_name(lxb_html_token_attr_t *attr, size_t *length);
+
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* LEXBOR_HTML_TOKEN_ATTR_H */

data/vendor/lexbor/source/lexbor/html/tokenizer/error.c

@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2018 Alexander Borisov
+ *
+ * Author: Alexander Borisov <borisov@lexbor.com>
+ */
+
+#include "lexbor/html/tokenizer/error.h"
+
+
+lxb_html_tokenizer_error_t *
+lxb_html_tokenizer_error_add(lexbor_array_obj_t *parse_errors,
+                             const lxb_char_t *pos,
+                             lxb_html_tokenizer_error_id_t id)
+{
+    if (parse_errors == NULL) {
+        return NULL;
+    }
+
+    lxb_html_tokenizer_error_t *entry = lexbor_array_obj_push(parse_errors);
+    if (entry == NULL) {
+        return NULL;
+    }
+
+    entry->id = id;
+    entry->pos = pos;
+
+    return entry;
+}