nokolexbor 0.2.0

data/vendor/lexbor/source/lexbor/css/syntax/tokenizer.c

@@ -0,0 +1,278 @@
+/*
+ * Copyright (C) 2018-2020 Alexander Borisov
+ *
+ * Author: Alexander Borisov <borisov@lexbor.com>
+ */
+
+#include "lexbor/css/syntax/tokenizer.h"
+#include "lexbor/css/syntax/tokenizer/error.h"
+#include "lexbor/css/syntax/state.h"
+#include "lexbor/css/syntax/state_res.h"
+
+#include "lexbor/core/array.h"
+
+
+const lxb_char_t *lxb_css_syntax_tokenizer_eof = (const lxb_char_t *) "\x00";
+
+
+static lxb_status_t
+lxb_css_syntax_tokenizer_blank(lxb_css_syntax_tokenizer_t *tkz,
+                               const lxb_char_t **data, const lxb_char_t **end,
+                               void *ctx);
+
+lxb_status_t
+lxb_css_syntax_tokenizer_next_chunk(lxb_css_syntax_tokenizer_t *tkz,
+                                    const lxb_char_t **data, const lxb_char_t **end);
+
+lxb_status_t
+lxb_css_syntax_state_tokens_realloc(lxb_css_syntax_tokenizer_t *tkz);
+
+
+lxb_css_syntax_tokenizer_t *
+lxb_css_syntax_tokenizer_create(void)
+{
+    return lexbor_calloc(1, sizeof(lxb_css_syntax_tokenizer_t));
+}
+
+lxb_status_t
+lxb_css_syntax_tokenizer_init(lxb_css_syntax_tokenizer_t *tkz)
+{
+    lxb_status_t status;
+
+    static const unsigned tmp_size = 1024;
+    static const unsigned tokens_length = 64;
+
+    if (tkz == NULL) {
+        return LXB_STATUS_ERROR_OBJECT_IS_NULL;
+    }
+
+    /* Init list for tokens. */
+    tkz->tokens_begin = lexbor_calloc(tokens_length,
+                                      sizeof(lxb_css_syntax_token_t));
+    if (tkz->tokens_begin == NULL) {
+        return LXB_STATUS_ERROR_MEMORY_ALLOCATION;
+    }
+
+    tkz->tokens_end = tkz->tokens_begin + tokens_length;
+
+    tkz->token = tkz->tokens_begin;
+    tkz->last = tkz->token;
+    tkz->prepared = NULL;
+
+    tkz->mraw = lexbor_mraw_create();
+    status = lexbor_mraw_init(tkz->mraw, 4096);
+    if (status != LXB_STATUS_OK) {
+        return status;
+    }
+
+    /* Temp */
+    tkz->start = lexbor_malloc(tmp_size);
+    if (tkz->start == NULL) {
+        return LXB_STATUS_ERROR_MEMORY_ALLOCATION;
+    }
+
+    tkz->pos = tkz->start;
+    tkz->end = tkz->start + tmp_size;
+
+    /* Parse errors */
+    tkz->parse_errors = lexbor_array_obj_create();
+    status = lexbor_array_obj_init(tkz->parse_errors, 16,
+                                   sizeof(lxb_css_syntax_tokenizer_error_t));
+    if (status != LXB_STATUS_OK) {
+        return status;
+    }
+
+    tkz->eof = false;
+    tkz->with_comment = false;
+    tkz->status = LXB_STATUS_OK;
+    tkz->opt = LXB_CSS_SYNTAX_TOKENIZER_OPT_UNDEF;
+    tkz->chunk_cb = lxb_css_syntax_tokenizer_blank;
+
+    return LXB_STATUS_OK;
+}
+
+lxb_status_t
+lxb_css_syntax_tokenizer_clean(lxb_css_syntax_tokenizer_t *tkz)
+{
+    lexbor_mraw_clean(tkz->mraw);
+    lexbor_array_obj_clean(tkz->parse_errors);
+
+    tkz->token = tkz->tokens_begin;
+    tkz->last = tkz->token;
+    tkz->prepared = NULL;
+
+    tkz->eof = false;
+    tkz->status = LXB_STATUS_OK;
+    tkz->in_begin = NULL;
+    tkz->in_end = NULL;
+    tkz->pos = tkz->start;
+
+    return LXB_STATUS_OK;
+}
+
+lxb_css_syntax_tokenizer_t *
+lxb_css_syntax_tokenizer_destroy(lxb_css_syntax_tokenizer_t *tkz)
+{
+    if (tkz == NULL) {
+        return NULL;
+    }
+
+    if (tkz->tokens_begin != NULL) {
+        tkz->tokens_begin = lexbor_free(tkz->tokens_begin);
+        tkz->tokens_end = NULL;
+    }
+
+    tkz->mraw = lexbor_mraw_destroy(tkz->mraw, true);
+    tkz->parse_errors = lexbor_array_obj_destroy(tkz->parse_errors, true);
+
+    if (tkz->start != NULL) {
+        tkz->start = lexbor_free(tkz->start);
+    }
+
+    return lexbor_free(tkz);
+}
+
+static lxb_status_t
+lxb_css_syntax_tokenizer_blank(lxb_css_syntax_tokenizer_t *tkz,
+                               const lxb_char_t **data, const lxb_char_t **end,
+                               void *ctx)
+{
+    return LXB_STATUS_OK;
+}
+
+lxb_status_t
+lxb_css_syntax_tokenizer_chunk(lxb_css_syntax_tokenizer_t *tkz,
+                               const lxb_char_t *data, size_t size)
+{
+    return tkz->status;
+}
+
+lxb_css_syntax_token_t *
+lxb_css_syntax_tokenizer_token(lxb_css_syntax_tokenizer_t *tkz)
+{
+    lxb_status_t status;
+    lxb_css_syntax_token_t *token;
+    const lxb_char_t *begin, *end;
+
+    begin = tkz->in_begin;
+    end = tkz->in_end;
+
+    if (tkz->prepared != NULL) {
+        token = tkz->prepared++;
+
+        if (tkz->prepared >= tkz->last) {
+            tkz->prepared = NULL;
+        }
+
+        if (lxb_css_syntax_token_base(token)->end != NULL) {
+            return token;
+        }
+
+        if (begin >= end) {
+            status = lxb_css_syntax_tokenizer_next_chunk(tkz, &begin, &end);
+            if (status != LXB_STATUS_OK) {
+                return NULL;
+            }
+
+            if (begin >= end) {
+                goto done;
+            }
+        }
+
+        if (lxb_css_syntax_token_delim(token)->character == '-') {
+            begin = lxb_css_syntax_state_minus_process(tkz, token, begin, end);
+        }
+        else {
+            begin = lxb_css_syntax_state_plus_process(tkz, token, begin, end);
+        }
+
+        goto done;
+    }
+
+    if (tkz->last >= tkz->tokens_end) {
+        tkz->status = lxb_css_syntax_state_tokens_realloc(tkz);
+        if (tkz->status != LXB_STATUS_OK) {
+            return NULL;
+        }
+    }
+
+    token = tkz->last++;
+
+again:
+
+    if (begin >= end) {
+        status = lxb_css_syntax_tokenizer_next_chunk(tkz, &begin, &end);
+        if (status != LXB_STATUS_OK) {
+            return NULL;
+        }
+
+        if (begin >= end) {
+            token->type = LXB_CSS_SYNTAX_TOKEN__EOF;
+
+            lxb_css_syntax_token_base(token)->begin = begin;
+            lxb_css_syntax_token_base(token)->end = end;
+
+            return token;
+        }
+    }
+
+    token->cloned = false;
+
+    begin = lxb_css_syntax_state_res_map[*begin](tkz, token, begin, end);
+
+done:
+
+    if (begin == NULL) {
+        return NULL;
+    }
+
+    tkz->in_begin = begin;
+
+    if (token->type == LXB_CSS_SYNTAX_TOKEN_COMMENT && tkz->with_comment) {
+        end = tkz->in_end;
+        goto again;
+    }
+
+    return token;
+}
+
+lxb_status_t
+lxb_css_syntax_tokenizer_next_chunk(lxb_css_syntax_tokenizer_t *tkz,
+                                    const lxb_char_t **data, const lxb_char_t **end)
+{
+    const lxb_char_t *begin;
+
+    if (tkz->eof == false) {
+        begin = *data;
+
+        tkz->status = tkz->chunk_cb(tkz, data, end, tkz->chunk_ctx);
+        if (tkz->status != LXB_STATUS_OK) {
+            return tkz->status;
+        }
+
+        if (*data >= *end) {
+            *data = begin;
+            *end = begin;
+
+            tkz->in_begin = begin;
+            tkz->in_end = begin;
+
+            tkz->eof = true;
+        }
+        else {
+            tkz->in_begin = *data;
+            tkz->in_end = *end;
+        }
+    }
+
+    return LXB_STATUS_OK;
+}
+
+/*
+ * No inline functions for ABI.
+ */
+lxb_status_t
+lxb_css_syntax_tokenizer_status_noi(lxb_css_syntax_tokenizer_t *tkz)
+{
+    return lxb_css_syntax_tokenizer_status(tkz);
+}

data/vendor/lexbor/source/lexbor/css/syntax/tokenizer.h

@@ -0,0 +1,121 @@
+/*
+ * Copyright (C) 2018-2020 Alexander Borisov
+ *
+ * Author: Alexander Borisov <borisov@lexbor.com>
+ */
+
+#ifndef LEXBOR_CSS_SYNTAX_TOKENIZER_H
+#define LEXBOR_CSS_SYNTAX_TOKENIZER_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "lexbor/core/array_obj.h"
+
+#include "lexbor/css/syntax/base.h"
+#include "lexbor/css/syntax/token.h"
+
+
+/* State */
+typedef const lxb_char_t *
+(*lxb_css_syntax_tokenizer_state_f)(lxb_css_syntax_tokenizer_t *tkz,
+                                 lxb_css_syntax_token_t *token,
+                                 const lxb_char_t *data, const lxb_char_t *end);
+
+typedef lxb_status_t
+(*lxb_css_syntax_tokenizer_chunk_f)(lxb_css_syntax_tokenizer_t *tkz,
+                                    const lxb_char_t **data,
+                                    const lxb_char_t **end, void *ctx);
+
+
+enum lxb_css_syntax_tokenizer_opt {
+    LXB_CSS_SYNTAX_TOKENIZER_OPT_UNDEF = 0x00,
+};
+
+struct lxb_css_syntax_tokenizer {
+    /* Current process token */
+    lxb_css_syntax_token_t             *token;
+    lxb_css_syntax_token_t             *last;
+    lxb_css_syntax_token_t             *prepared;
+
+    lxb_css_syntax_token_t             *tokens_begin;
+    lxb_css_syntax_token_t             *tokens_end;
+
+    lexbor_array_obj_t                 *parse_errors;
+
+    const lxb_char_t                   *in_begin;
+    const lxb_char_t                   *in_end;
+
+    lexbor_mraw_t                      *mraw;
+
+    lxb_css_syntax_tokenizer_chunk_f   chunk_cb;
+    void                               *chunk_ctx;
+
+    /* Temp */
+    lxb_char_t                         *start;
+    lxb_char_t                         *pos;
+    const lxb_char_t                   *end;
+    lxb_char_t                         buffer[128];
+    lxb_css_syntax_token_data_t        token_data;
+
+    /* Process */
+    unsigned int                       opt;             /* bitmap */
+    lxb_status_t                       status;
+    bool                               eof;
+    bool                               with_comment;
+};
+
+
+LXB_API lxb_css_syntax_tokenizer_t *
+lxb_css_syntax_tokenizer_create(void);
+
+LXB_API lxb_status_t
+lxb_css_syntax_tokenizer_init(lxb_css_syntax_tokenizer_t *tkz);
+
+LXB_API lxb_status_t
+lxb_css_syntax_tokenizer_clean(lxb_css_syntax_tokenizer_t *tkz);
+
+LXB_API lxb_css_syntax_tokenizer_t *
+lxb_css_syntax_tokenizer_destroy(lxb_css_syntax_tokenizer_t *tkz);
+
+
+/*
+ * Inline functions
+ */
+lxb_inline lxb_status_t
+lxb_css_syntax_tokenizer_status(lxb_css_syntax_tokenizer_t *tkz)
+{
+    return tkz->status;
+}
+
+lxb_inline void
+lxb_css_syntax_tokenizer_chunk_cb_set(lxb_css_syntax_tokenizer_t *tkz,
+                                      lxb_css_syntax_tokenizer_chunk_f cb,
+                                      void *ctx)
+{
+    tkz->chunk_cb = cb;
+    tkz->chunk_ctx = ctx;
+}
+
+lxb_inline void
+lxb_css_syntax_tokenizer_buffer_set(lxb_css_syntax_tokenizer_t *tkz,
+                                    const lxb_char_t *data, size_t size)
+{
+    tkz->in_begin = data;
+    tkz->in_end = data + size;
+}
+
+
+/*
+ * No inline functions for ABI.
+ */
+LXB_API lxb_status_t
+lxb_css_syntax_tokenizer_status_noi(lxb_css_syntax_tokenizer_t *tkz);
+
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* LEXBOR_CSS_SYNTAX_TOKENIZER_H */

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

@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2019-2021 Alexander Borisov
+ *
+ * Author: Alexander Borisov <borisov@lexbor.com>
+ */
+
+#ifndef LEXBOR_DOM_BASE_H
+#define LEXBOR_DOM_BASE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#include "lexbor/core/base.h"
+
+
+#define LXB_DOM_VERSION_MAJOR 1
+#define LXB_DOM_VERSION_MINOR 4
+#define LXB_DOM_VERSION_PATCH 0
+
+#define LXB_DOM_VERSION_STRING                                                 \
+    LEXBOR_STRINGIZE(LXB_DOM_VERSION_MAJOR) "."                                \
+    LEXBOR_STRINGIZE(LXB_DOM_VERSION_MINOR) "."                                \
+    LEXBOR_STRINGIZE(LXB_DOM_VERSION_PATCH)
+
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* LEXBOR_DOM_BASE_H */

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

@@ -0,0 +1,97 @@
+/*
+ * Copyright (C) 2018-2022 Alexander Borisov
+ *
+ * Author: Alexander Borisov <borisov@lexbor.com>
+ */
+
+#include "lexbor/dom/collection.h"
+#include "lexbor/dom/interfaces/document.h"
+
+
+lxb_dom_collection_t *
+lxb_dom_collection_create(lxb_dom_document_t *document)
+{
+    lxb_dom_collection_t *col;
+
+    col = lexbor_calloc(1, sizeof(lxb_dom_collection_t));
+    if (col == NULL) {
+        return NULL;
+    }
+
+    col->document = document;
+
+    return col;
+}
+
+lxb_status_t
+lxb_dom_collection_init(lxb_dom_collection_t *col, size_t start_list_size)
+{
+    if (col == NULL) {
+        return LXB_STATUS_ERROR_WRONG_ARGS;
+    }
+
+    if (col->document == NULL) {
+        return LXB_STATUS_ERROR_INCOMPLETE_OBJECT;
+    }
+
+    return lexbor_array_init(&col->array, start_list_size);
+}
+
+lxb_dom_collection_t *
+lxb_dom_collection_destroy(lxb_dom_collection_t *col, bool self_destroy)
+{
+    if (col == NULL) {
+        return NULL;
+    }
+
+    if (col->array.list != NULL) {
+        lexbor_array_destroy(&col->array, false);
+
+        col->array.list = NULL;
+    }
+
+    if (self_destroy) {
+        return lexbor_free(col);
+    }
+
+    return col;
+}
+
+/*
+ * No inline functions for ABI.
+ */
+lxb_dom_collection_t *
+lxb_dom_collection_make_noi(lxb_dom_document_t *document, size_t start_list_size)
+{
+    return lxb_dom_collection_make(document, start_list_size);
+}
+
+void
+lxb_dom_collection_clean_noi(lxb_dom_collection_t *col)
+{
+    lxb_dom_collection_clean(col);
+}
+
+lxb_status_t
+lxb_dom_collection_append_noi(lxb_dom_collection_t *col, void *value)
+{
+    return lxb_dom_collection_append(col, value);
+}
+
+lxb_dom_element_t *
+lxb_dom_collection_element_noi(lxb_dom_collection_t *col, size_t idx)
+{
+    return lxb_dom_collection_element(col, idx);
+}
+
+lxb_dom_node_t *
+lxb_dom_collection_node_noi(lxb_dom_collection_t *col, size_t idx)
+{
+    return lxb_dom_collection_node(col, idx);
+}
+
+size_t
+lxb_dom_collection_length_noi(lxb_dom_collection_t *col)
+{
+    return lxb_dom_collection_length(col);
+}

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

@@ -0,0 +1,112 @@
+/*
+ * Copyright (C) 2018 Alexander Borisov
+ *
+ * Author: Alexander Borisov <borisov@lexbor.com>
+ */
+
+#ifndef LEXBOR_DOM_COLLECTION_H
+#define LEXBOR_DOM_COLLECTION_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "lexbor/core/base.h"
+#include "lexbor/core/array.h"
+
+#include "lexbor/dom/interface.h"
+
+
+typedef struct {
+    lexbor_array_t     array;
+    lxb_dom_document_t *document;
+}
+lxb_dom_collection_t;
+
+
+LXB_API lxb_dom_collection_t *
+lxb_dom_collection_create(lxb_dom_document_t *document);
+
+LXB_API lxb_status_t
+lxb_dom_collection_init(lxb_dom_collection_t *col, size_t start_list_size);
+
+LXB_API lxb_dom_collection_t *
+lxb_dom_collection_destroy(lxb_dom_collection_t *col, bool self_destroy);
+
+
+/*
+ * Inline functions
+ */
+lxb_inline lxb_dom_collection_t *
+lxb_dom_collection_make(lxb_dom_document_t *document, size_t start_list_size)
+{
+    lxb_status_t status;
+    lxb_dom_collection_t *col;
+
+    col = lxb_dom_collection_create(document);
+    status = lxb_dom_collection_init(col, start_list_size);
+
+    if(status != LXB_STATUS_OK) {
+        return lxb_dom_collection_destroy(col, true);
+    }
+
+    return col;
+}
+
+lxb_inline void
+lxb_dom_collection_clean(lxb_dom_collection_t *col)
+{
+    lexbor_array_clean(&col->array);
+}
+
+lxb_inline lxb_status_t
+lxb_dom_collection_append(lxb_dom_collection_t *col, void *value)
+{
+    return lexbor_array_push(&col->array, value);
+}
+
+lxb_inline lxb_dom_element_t *
+lxb_dom_collection_element(lxb_dom_collection_t *col, size_t idx)
+{
+    return (lxb_dom_element_t *) lexbor_array_get(&col->array, idx);
+}
+
+lxb_inline lxb_dom_node_t *
+lxb_dom_collection_node(lxb_dom_collection_t *col, size_t idx)
+{
+    return (lxb_dom_node_t *) lexbor_array_get(&col->array, idx);
+}
+
+lxb_inline size_t
+lxb_dom_collection_length(lxb_dom_collection_t *col)
+{
+    return lexbor_array_length(&col->array);
+}
+
+/*
+ * No inline functions for ABI.
+ */
+LXB_API lxb_dom_collection_t *
+lxb_dom_collection_make_noi(lxb_dom_document_t *document, size_t start_list_size);
+
+LXB_API void
+lxb_dom_collection_clean_noi(lxb_dom_collection_t *col);
+
+LXB_API lxb_status_t
+lxb_dom_collection_append_noi(lxb_dom_collection_t *col, void *value);
+
+LXB_API lxb_dom_element_t *
+lxb_dom_collection_element_noi(lxb_dom_collection_t *col, size_t idx);
+
+LXB_API lxb_dom_node_t *
+lxb_dom_collection_node_noi(lxb_dom_collection_t *col, size_t idx);
+
+LXB_API size_t
+lxb_dom_collection_length_noi(lxb_dom_collection_t *col);
+
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* LEXBOR_DOM_COLLECTION_H */

data/vendor/lexbor/source/lexbor/dom/config.cmake

@@ -0,0 +1,3 @@
+set(DEPENDENCIES "core tag ns")
+set(DESCRIPTION "The module implemented by DOM specification.
+Includes functions for manipulating DOM tree: nodes, attributes, events.")

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

@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2020 Alexander Borisov
+ *
+ * Author: Alexander Borisov <borisov@lexbor.com>
+ */
+
+#ifndef LXB_DOM_H
+#define LXB_DOM_H
+
+#include "lexbor/dom/base.h"
+#include "lexbor/dom/interface.h"
+#include "lexbor/dom/collection.h"
+#include "lexbor/dom/exception.h"
+#include "lexbor/dom/interfaces/shadow_root.h"
+#include "lexbor/dom/interfaces/attr.h"
+#include "lexbor/dom/interfaces/cdata_section.h"
+#include "lexbor/dom/interfaces/text.h"
+#include "lexbor/dom/interfaces/event_target.h"
+#include "lexbor/dom/interfaces/comment.h"
+#include "lexbor/dom/interfaces/attr_const.h"
+#include "lexbor/dom/interfaces/node.h"
+#include "lexbor/dom/interfaces/document_type.h"
+#include "lexbor/dom/interfaces/element.h"
+#include "lexbor/dom/interfaces/document_fragment.h"
+#include "lexbor/dom/interfaces/document.h"
+#include "lexbor/dom/interfaces/character_data.h"
+#include "lexbor/dom/interfaces/processing_instruction.h"
+
+#endif /* LXB_DOM_H */

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

@@ -0,0 +1,18 @@
+/*
+ * Copyright (C) 2018 Alexander Borisov
+ *
+ * Author: Alexander Borisov <borisov@lexbor.com>
+ */
+
+#include "lexbor/dom/exception.h"
+
+
+/*
+ * No inline functions for ABI.
+ */
+void *
+lxb_dom_exception_code_ref_set_noi(lxb_dom_exception_code_t *var,
+                                   lxb_dom_exception_code_t code)
+{
+    return lxb_dom_exception_code_ref_set(var, code);
+}