nokolexbor 0.2.0

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

@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2018 Alexander Borisov
+ *
+ * Author: Alexander Borisov <borisov@lexbor.com>
+ */
+
+#include "lexbor/html/tree/error.h"
+
+
+lxb_html_tree_error_t *
+lxb_html_tree_error_add(lexbor_array_obj_t *parse_errors,
+                        lxb_html_token_t *token, lxb_html_tree_error_id_t id)
+{
+    if (parse_errors == NULL) {
+        return NULL;
+    }
+
+    lxb_html_tree_error_t *entry = lexbor_array_obj_push(parse_errors);
+    if (entry == NULL) {
+        return NULL;
+    }
+
+    entry->id = id;
+
+    return entry;
+}

data/vendor/lexbor/source/lexbor/html/tree/error.h

@@ -0,0 +1,114 @@
+/*
+ * Copyright (C) 2018 Alexander Borisov
+ *
+ * Author: Alexander Borisov <borisov@lexbor.com>
+ */
+
+#ifndef LEXBOR_HTML_TREE_ERROR_H
+#define LEXBOR_HTML_TREE_ERROR_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "lexbor/core/base.h"
+#include "lexbor/core/array_obj.h"
+
+#include "lexbor/html/token.h"
+
+
+typedef enum {
+    /* unexpected-token */
+    LXB_HTML_RULES_ERROR_UNTO = 0x0000,
+    /* unexpected-closed-token */
+    LXB_HTML_RULES_ERROR_UNCLTO,
+    /* null-character */
+    LXB_HTML_RULES_ERROR_NUCH,
+    /* unexpected-character-token */
+    LXB_HTML_RULES_ERROR_UNCHTO,
+    /* unexpected-token-in-initial-mode */
+    LXB_HTML_RULES_ERROR_UNTOININMO,
+    /* bad-doctype-token-in-initial-mode */
+    LXB_HTML_RULES_ERROR_BADOTOININMO,
+    /* doctype-token-in-before-html-mode */
+    LXB_HTML_RULES_ERROR_DOTOINBEHTMO,
+    /* unexpected-closed-token-in-before-html-mode */
+    LXB_HTML_RULES_ERROR_UNCLTOINBEHTMO,
+    /* doctype-token-in-before-head-mode */
+    LXB_HTML_RULES_ERROR_DOTOINBEHEMO,
+    /* unexpected-closed_token-in-before-head-mode */
+    LXB_HTML_RULES_ERROR_UNCLTOINBEHEMO,
+    /* doctype-token-in-head-mode */
+    LXB_HTML_RULES_ERROR_DOTOINHEMO,
+    /* non-void-html-element-start-tag-with-trailing-solidus */
+    LXB_HTML_RULES_ERROR_NOVOHTELSTTAWITRSO,
+    /* head-token-in-head-mode */
+    LXB_HTML_RULES_ERROR_HETOINHEMO,
+    /* unexpected-closed-token-in-head-mode */
+    LXB_HTML_RULES_ERROR_UNCLTOINHEMO,
+    /* template-closed-token-without-opening-in-head-mode */
+    LXB_HTML_RULES_ERROR_TECLTOWIOPINHEMO,
+    /* template-element-is-not-current-in-head-mode */
+    LXB_HTML_RULES_ERROR_TEELISNOCUINHEMO,
+    /* doctype-token-in-head-noscript-mode */
+    LXB_HTML_RULES_ERROR_DOTOINHENOMO,
+    /* doctype-token-after-head-mode */
+    LXB_HTML_RULES_ERROR_DOTOAFHEMO,
+    /* head-token-after-head-mode */
+    LXB_HTML_RULES_ERROR_HETOAFHEMO,
+    /* doctype-token-in-body-mode */
+    LXB_HTML_RULES_ERROR_DOTOINBOMO,
+    /* bad-ending-open-elements-is-wrong */
+    LXB_HTML_RULES_ERROR_BAENOPELISWR,
+    /* open-elements-is-wrong */
+    LXB_HTML_RULES_ERROR_OPELISWR,
+    /* unexpected-element-in-open-elements-stack */
+    LXB_HTML_RULES_ERROR_UNELINOPELST,
+    /* missing-element-in-open-elements-stack */
+    LXB_HTML_RULES_ERROR_MIELINOPELST,
+    /* no-body-element-in-scope */
+    LXB_HTML_RULES_ERROR_NOBOELINSC,
+    /* missing-element-in-scope */
+    LXB_HTML_RULES_ERROR_MIELINSC,
+    /* unexpected-element-in-scope */
+    LXB_HTML_RULES_ERROR_UNELINSC,
+    /* unexpected-element-in-active-formatting-stack */
+    LXB_HTML_RULES_ERROR_UNELINACFOST,
+    /* unexpected-end-of-file */
+    LXB_HTML_RULES_ERROR_UNENOFFI,
+    /* characters-in-table-text */
+    LXB_HTML_RULES_ERROR_CHINTATE,
+    /* doctype-token-in-table-mode */
+    LXB_HTML_RULES_ERROR_DOTOINTAMO,
+    /* doctype-token-in-select-mode */
+    LXB_HTML_RULES_ERROR_DOTOINSEMO,
+    /* doctype-token-after-body-mode */
+    LXB_HTML_RULES_ERROR_DOTOAFBOMO,
+    /* doctype-token-in-frameset-mode */
+    LXB_HTML_RULES_ERROR_DOTOINFRMO,
+    /* doctype-token-after-frameset-mode */
+    LXB_HTML_RULES_ERROR_DOTOAFFRMO,
+    /* doctype-token-foreign-content-mode */
+    LXB_HTML_RULES_ERROR_DOTOFOCOMO,
+
+    LXB_HTML_RULES_ERROR_LAST_ENTRY
+}
+lxb_html_tree_error_id_t;
+
+typedef struct {
+    lxb_html_tree_error_id_t id;
+}
+lxb_html_tree_error_t;
+
+
+LXB_API lxb_html_tree_error_t *
+lxb_html_tree_error_add(lexbor_array_obj_t *parse_errors,
+                        lxb_html_token_t *token, lxb_html_tree_error_id_t id);
+
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* LEXBOR_HTML_TREE_ERROR_H */
+

data/vendor/lexbor/source/lexbor/html/tree/insertion_mode/after_after_body.c

@@ -0,0 +1,62 @@
+/*
+ * Copyright (C) 2018-2020 Alexander Borisov
+ *
+ * Author: Alexander Borisov <borisov@lexbor.com>
+ */
+
+#include "lexbor/html/tree/insertion_mode.h"
+
+
+bool
+lxb_html_tree_insertion_mode_after_after_body(lxb_html_tree_t *tree,
+                                              lxb_html_token_t *token)
+{
+    switch (token->tag_id) {
+        case LXB_TAG__EM_COMMENT: {
+            lxb_dom_comment_t *comment;
+
+            comment = lxb_html_tree_insert_comment(tree, token,
+                                                   lxb_dom_interface_node(tree->document));
+            if (comment == NULL) {
+                return lxb_html_tree_process_abort(tree);
+            }
+
+            break;
+        }
+
+        case LXB_TAG__EM_DOCTYPE:
+        case LXB_TAG_HTML:
+            return lxb_html_tree_insertion_mode_in_body(tree, token);
+
+        case LXB_TAG__END_OF_FILE:
+            tree->status = lxb_html_tree_stop_parsing(tree);
+            if (tree->status != LXB_STATUS_OK) {
+                return lxb_html_tree_process_abort(tree);
+            }
+
+            break;
+
+        case LXB_TAG__TEXT: {
+            lxb_html_token_t ws_token = *token;
+
+            tree->status = lxb_html_token_data_skip_ws_begin(&ws_token);
+            if (tree->status != LXB_STATUS_OK) {
+                return lxb_html_tree_process_abort(tree);
+            }
+
+            if (ws_token.text_start == ws_token.text_end) {
+                return lxb_html_tree_insertion_mode_in_body(tree, token);
+            }
+        }
+        /* fall through */
+
+        default:
+            lxb_html_tree_parse_error(tree, token, LXB_HTML_RULES_ERROR_UNTO);
+
+            tree->mode = lxb_html_tree_insertion_mode_in_body;
+
+            return false;
+    }
+
+    return true;
+}

data/vendor/lexbor/source/lexbor/html/tree/insertion_mode/after_after_frameset.c

@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2018-2020 Alexander Borisov
+ *
+ * Author: Alexander Borisov <borisov@lexbor.com>
+ */
+
+#include "lexbor/html/tree/insertion_mode.h"
+
+
+bool
+lxb_html_tree_insertion_mode_after_after_frameset(lxb_html_tree_t *tree,
+                                                  lxb_html_token_t *token)
+{
+    switch (token->tag_id) {
+        case LXB_TAG__EM_COMMENT: {
+            lxb_dom_comment_t *comment;
+
+            comment = lxb_html_tree_insert_comment(tree, token,
+                                                   lxb_dom_interface_node(tree->document));
+            if (comment == NULL) {
+                return lxb_html_tree_process_abort(tree);
+            }
+
+            break;
+        }
+
+        case LXB_TAG__EM_DOCTYPE:
+        case LXB_TAG_HTML:
+            return lxb_html_tree_insertion_mode_in_body(tree, token);
+
+        case LXB_TAG__END_OF_FILE:
+            tree->status = lxb_html_tree_stop_parsing(tree);
+            if (tree->status != LXB_STATUS_OK) {
+                return lxb_html_tree_process_abort(tree);
+            }
+
+            break;
+
+        case LXB_TAG_NOFRAMES:
+            return lxb_html_tree_insertion_mode_in_head(tree, token);
+
+        case LXB_TAG__TEXT: {
+            lxb_html_token_t ws_token = *token;
+
+            tree->status = lxb_html_token_data_skip_ws_begin(&ws_token);
+            if (tree->status != LXB_STATUS_OK) {
+                return lxb_html_tree_process_abort(tree);
+            }
+
+            if (ws_token.text_start == ws_token.text_end) {
+                return lxb_html_tree_insertion_mode_in_body(tree, token);
+            }
+        }
+        /* fall through */
+
+        default:
+            lxb_html_tree_parse_error(tree, token, LXB_HTML_RULES_ERROR_UNTO);
+
+            break;
+    }
+
+    return true;
+}

data/vendor/lexbor/source/lexbor/html/tree/insertion_mode/after_body.c

@@ -0,0 +1,82 @@
+/*
+ * Copyright (C) 2018-2020 Alexander Borisov
+ *
+ * Author: Alexander Borisov <borisov@lexbor.com>
+ */
+
+#include "lexbor/html/tree/insertion_mode.h"
+#include "lexbor/html/tree/open_elements.h"
+
+
+bool
+lxb_html_tree_insertion_mode_after_body(lxb_html_tree_t *tree,
+                                        lxb_html_token_t *token)
+{
+    switch (token->tag_id) {
+        case LXB_TAG__EM_COMMENT: {
+            lxb_dom_comment_t *comment;
+            lxb_dom_node_t *html_node;
+
+            html_node = lxb_html_tree_open_elements_first(tree);
+
+            comment = lxb_html_tree_insert_comment(tree, token, html_node);
+            if (comment == NULL) {
+                return lxb_html_tree_process_abort(tree);
+            }
+
+            break;
+        }
+
+        case LXB_TAG__EM_DOCTYPE:
+            lxb_html_tree_parse_error(tree, token,
+                                      LXB_HTML_RULES_ERROR_DOTOAFBOMO);
+            break;
+
+        case LXB_TAG_HTML:
+            if (token->type & LXB_HTML_TOKEN_TYPE_CLOSE)
+            {
+                if (tree->fragment != NULL) {
+                    lxb_html_tree_parse_error(tree, token,
+                                              LXB_HTML_RULES_ERROR_UNCLTO);
+                    return true;
+                }
+
+                tree->mode = lxb_html_tree_insertion_mode_after_after_body;
+
+                return true;
+            }
+
+            return lxb_html_tree_insertion_mode_in_body(tree, token);
+
+        case LXB_TAG__END_OF_FILE:
+            tree->status = lxb_html_tree_stop_parsing(tree);
+            if (tree->status != LXB_STATUS_OK) {
+                return lxb_html_tree_process_abort(tree);
+            }
+
+            break;
+
+        case LXB_TAG__TEXT: {
+            lxb_html_token_t ws_token = *token;
+
+            tree->status = lxb_html_token_data_skip_ws_begin(&ws_token);
+            if (tree->status != LXB_STATUS_OK) {
+                return lxb_html_tree_process_abort(tree);
+            }
+
+            if (ws_token.text_start == ws_token.text_end) {
+                return lxb_html_tree_insertion_mode_in_body(tree, token);
+            }
+        }
+        /* fall through */
+
+        default:
+            lxb_html_tree_parse_error(tree, token, LXB_HTML_RULES_ERROR_UNTO);
+
+            tree->mode = lxb_html_tree_insertion_mode_in_body;
+
+            return false;
+    }
+
+    return true;
+}

data/vendor/lexbor/source/lexbor/html/tree/insertion_mode/after_frameset.c

@@ -0,0 +1,88 @@
+/*
+ * Copyright (C) 2018-2020 Alexander Borisov
+ *
+ * Author: Alexander Borisov <borisov@lexbor.com>
+ */
+
+#include "lexbor/html/tree/insertion_mode.h"
+
+
+bool
+lxb_html_tree_insertion_mode_after_frameset(lxb_html_tree_t *tree,
+                                            lxb_html_token_t *token)
+{
+    switch (token->tag_id) {
+        case LXB_TAG__EM_COMMENT: {
+            lxb_dom_comment_t *comment;
+
+            comment = lxb_html_tree_insert_comment(tree, token, NULL);
+            if (comment == NULL) {
+                return lxb_html_tree_process_abort(tree);
+            }
+
+            break;
+        }
+
+        case LXB_TAG__EM_DOCTYPE:
+            lxb_html_tree_parse_error(tree, token,
+                                      LXB_HTML_RULES_ERROR_DOTOAFFRMO);
+            break;
+
+        case LXB_TAG_HTML:
+            if (token->type & LXB_HTML_TOKEN_TYPE_CLOSE) {
+                tree->mode = lxb_html_tree_insertion_mode_after_after_frameset;
+
+                return true;
+            }
+
+            return lxb_html_tree_insertion_mode_in_body(tree, token);
+
+        case LXB_TAG_NOFRAMES:
+            return lxb_html_tree_insertion_mode_in_head(tree, token);
+
+        case LXB_TAG__END_OF_FILE: {
+            tree->status = lxb_html_tree_stop_parsing(tree);
+            if (tree->status != LXB_STATUS_OK) {
+                return lxb_html_tree_process_abort(tree);
+            }
+
+            break;
+        }
+
+        case LXB_TAG__TEXT: {
+            size_t cur_len;
+            lexbor_str_t str;
+
+            tree->status = lxb_html_token_make_text(token, &str,
+                                                    tree->document->dom_document.text);
+            if (tree->status != LXB_STATUS_OK) {
+                return lxb_html_tree_process_abort(tree);
+            }
+
+            cur_len = str.length;
+
+            lexbor_str_stay_only_whitespace(&str);
+
+            if (str.length != 0) {
+                tree->status = lxb_html_tree_insert_character_for_data(tree,
+                                                                       &str,
+                                                                       NULL);
+                if (tree->status != LXB_STATUS_OK) {
+                    return lxb_html_tree_process_abort(tree);
+                }
+            }
+
+            if (str.length == cur_len) {
+                return true;
+            }
+        }
+        /* fall through */
+
+        default:
+            lxb_html_tree_parse_error(tree, token, LXB_HTML_RULES_ERROR_UNTO);
+
+            break;
+    }
+
+    return true;
+}

data/vendor/lexbor/source/lexbor/html/tree/insertion_mode/after_head.c

@@ -0,0 +1,222 @@
+/*
+ * Copyright (C) 2018-2020 Alexander Borisov
+ *
+ * Author: Alexander Borisov <borisov@lexbor.com>
+ */
+
+#include "lexbor/html/tree/insertion_mode.h"
+#include "lexbor/html/tree/open_elements.h"
+
+
+static bool
+lxb_html_tree_insertion_mode_after_head_open(lxb_html_tree_t *tree,
+                                             lxb_html_token_t *token);
+static bool
+lxb_html_tree_insertion_mode_after_head_closed(lxb_html_tree_t *tree,
+                                               lxb_html_token_t *token);
+
+lxb_inline bool
+lxb_html_tree_insertion_mode_after_head_anything_else(lxb_html_tree_t *tree);
+
+lxb_inline lxb_html_element_t *
+lxb_html_tree_insertion_mode_after_head_create_body(lxb_html_tree_t *tree,
+                                                    lxb_html_token_t *token);
+
+
+bool
+lxb_html_tree_insertion_mode_after_head(lxb_html_tree_t *tree,
+                                        lxb_html_token_t *token)
+{
+    if (token->type & LXB_HTML_TOKEN_TYPE_CLOSE) {
+        return lxb_html_tree_insertion_mode_after_head_closed(tree, token);
+    }
+
+    return lxb_html_tree_insertion_mode_after_head_open(tree, token);
+}
+
+static bool
+lxb_html_tree_insertion_mode_after_head_open(lxb_html_tree_t *tree,
+                                             lxb_html_token_t *token)
+{
+    switch (token->tag_id) {
+        case LXB_TAG__EM_COMMENT: {
+            lxb_dom_comment_t *comment;
+
+            comment = lxb_html_tree_insert_comment(tree, token, NULL);
+            if (comment == NULL) {
+                tree->status = LXB_STATUS_ERROR_MEMORY_ALLOCATION;
+
+                return lxb_html_tree_process_abort(tree);
+            }
+
+            break;
+        }
+
+        case LXB_TAG__EM_DOCTYPE:
+            lxb_html_tree_parse_error(tree, token,
+                                      LXB_HTML_RULES_ERROR_DOTOAFHEMO);
+            break;
+
+        case LXB_TAG_HTML:
+            return lxb_html_tree_insertion_mode_in_body(tree, token);
+
+        case LXB_TAG_BODY: {
+            lxb_html_element_t *element;
+
+            element = lxb_html_tree_insertion_mode_after_head_create_body(tree,
+                                                                          token);
+            if (element == NULL) {
+                tree->status = LXB_STATUS_ERROR_MEMORY_ALLOCATION;
+
+                return lxb_html_tree_process_abort(tree);
+            }
+
+            tree->frameset_ok = false;
+            tree->mode = lxb_html_tree_insertion_mode_in_body;
+
+            break;
+        }
+
+        case LXB_TAG_FRAMESET: {
+            lxb_html_element_t *element;
+
+            element = lxb_html_tree_insert_html_element(tree, token);
+            if (element == NULL) {
+                tree->status = LXB_STATUS_ERROR_MEMORY_ALLOCATION;
+
+                return lxb_html_tree_process_abort(tree);
+            }
+
+            tree->mode = lxb_html_tree_insertion_mode_in_frameset;
+
+            break;
+        }
+
+        case LXB_TAG_BASE:
+        case LXB_TAG_BASEFONT:
+        case LXB_TAG_BGSOUND:
+        case LXB_TAG_LINK:
+        case LXB_TAG_META:
+        case LXB_TAG_NOFRAMES:
+        case LXB_TAG_SCRIPT:
+        case LXB_TAG_STYLE:
+        case LXB_TAG_TEMPLATE:
+        case LXB_TAG_TITLE: {
+            lxb_dom_node_t *head_node;
+
+            head_node = lxb_dom_interface_node(tree->document->head);
+            if (head_node == NULL) {
+                tree->status = LXB_STATUS_ERROR;
+
+                return lxb_html_tree_process_abort(tree);
+            }
+
+            lxb_html_tree_parse_error(tree, token, LXB_HTML_RULES_ERROR_UNTO);
+
+            tree->status = lxb_html_tree_open_elements_push(tree, head_node);
+            if (tree->status != LXB_STATUS_OK) {
+                return lxb_html_tree_process_abort(tree);
+            }
+
+            lxb_html_tree_insertion_mode_in_head(tree, token);
+            if (tree->status != LXB_STATUS_OK) {
+                return lxb_html_tree_process_abort(tree);
+            }
+
+            lxb_html_tree_open_elements_remove_by_node(tree, head_node);
+
+            break;
+        }
+
+        case LXB_TAG_HEAD:
+            lxb_html_tree_parse_error(tree, token,
+                                      LXB_HTML_RULES_ERROR_HETOAFHEMO);
+            break;
+
+        case LXB_TAG__TEXT: {
+            lxb_html_token_t ws_token = {0};
+
+            tree->status = lxb_html_token_data_split_ws_begin(token, &ws_token);
+            if (tree->status != LXB_STATUS_OK) {
+                return lxb_html_tree_process_abort(tree);
+            }
+
+            if (ws_token.text_start != ws_token.text_end) {
+                tree->status = lxb_html_tree_insert_character(tree, &ws_token,
+                                                              NULL);
+                if (tree->status != LXB_STATUS_OK) {
+                    return lxb_html_tree_process_abort(tree);
+                }
+            }
+
+            if (token->text_start == token->text_end) {
+                return true;
+            }
+        }
+        /* fall through */
+
+        default:
+            return lxb_html_tree_insertion_mode_after_head_anything_else(tree);
+    }
+
+    return true;
+}
+
+static bool
+lxb_html_tree_insertion_mode_after_head_closed(lxb_html_tree_t *tree,
+                                               lxb_html_token_t *token)
+{
+    switch (token->tag_id) {
+        case LXB_TAG_TEMPLATE:
+            return lxb_html_tree_insertion_mode_in_head(tree, token);
+
+        case LXB_TAG_BODY:
+        case LXB_TAG_HTML:
+        case LXB_TAG_BR:
+            return lxb_html_tree_insertion_mode_after_head_anything_else(tree);
+
+        default:
+            lxb_html_tree_parse_error(tree, token, LXB_HTML_RULES_ERROR_UNCLTO);
+
+            break;
+    }
+
+    return true;
+}
+
+lxb_inline bool
+lxb_html_tree_insertion_mode_after_head_anything_else(lxb_html_tree_t *tree)
+{
+    lxb_html_element_t *element;
+    lxb_html_token_t fake_token = {0};
+
+    fake_token.tag_id = LXB_TAG_BODY;
+
+    element = lxb_html_tree_insertion_mode_after_head_create_body(tree,
+                                                                  &fake_token);
+    if (element == NULL) {
+        tree->status = LXB_STATUS_ERROR_MEMORY_ALLOCATION;
+
+        return lxb_html_tree_process_abort(tree);
+    }
+
+    tree->mode = lxb_html_tree_insertion_mode_in_body;
+
+    return false;
+}
+
+lxb_inline lxb_html_element_t *
+lxb_html_tree_insertion_mode_after_head_create_body(lxb_html_tree_t *tree,
+                                                    lxb_html_token_t *token)
+{
+    lxb_html_element_t *element;
+
+    element = lxb_html_tree_insert_html_element(tree, token);
+    if (element == NULL) {
+        return NULL;
+    }
+
+    tree->document->body = lxb_html_interface_body(element);
+
+    return element;
+}