nokolexbor 0.2.0

data/vendor/lexbor/source/lexbor/css/selectors/state.h

@@ -0,0 +1,79 @@
+/*
+ * Copyright (C) 2020 Alexander Borisov
+ *
+ * Author: Alexander Borisov <borisov@lexbor.com>
+ */
+
+#ifndef LEXBOR_CSS_SELECTORS_STATE_H
+#define LEXBOR_CSS_SELECTORS_STATE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "lexbor/css/parser.h"
+#include "lexbor/css/selectors/base.h"
+
+
+LXB_API bool
+lxb_css_selectors_state_complex_list(lxb_css_parser_t *parser,
+                                     lxb_css_syntax_token_t *token, void *ctx);
+
+LXB_API bool
+lxb_css_selectors_state_compound_list(lxb_css_parser_t *parser,
+                                      lxb_css_syntax_token_t *token, void *ctx);
+
+LXB_API bool
+lxb_css_selectors_state_simple_list(lxb_css_parser_t *parser,
+                                    lxb_css_syntax_token_t *token, void *ctx);
+
+LXB_API bool
+lxb_css_selectors_state_relative_list(lxb_css_parser_t *parser,
+                                      lxb_css_syntax_token_t *token, void *ctx);
+
+LXB_API bool
+lxb_css_selectors_state_relative(lxb_css_parser_t *parser,
+                                 lxb_css_syntax_token_t *token, void *ctx);
+
+LXB_API bool
+lxb_css_selectors_state_complex(lxb_css_parser_t *parser,
+                                lxb_css_syntax_token_t *token, void *ctx);
+
+LXB_API bool
+lxb_css_selectors_state_compound(lxb_css_parser_t *parser,
+                                 lxb_css_syntax_token_t *token, void *ctx);
+
+LXB_API bool
+lxb_css_selectors_state_simple(lxb_css_parser_t *parser,
+                               lxb_css_syntax_token_t *token, void *ctx);
+
+
+LXB_API bool
+lxb_css_selectors_state_success(lxb_css_parser_t *parser,
+                                lxb_css_syntax_token_t *token, void *ctx);
+
+LXB_API bool
+lxb_css_selectors_state_forgiving(lxb_css_parser_t *parser,
+                                  lxb_css_syntax_token_t *token, void *ctx);
+
+LXB_API bool
+lxb_css_selectors_state_forgiving_relative(lxb_css_parser_t *parser,
+                                           lxb_css_syntax_token_t *token, void *ctx);
+
+lxb_inline bool
+lxb_css_selectors_state_fail(lxb_css_parser_t *parser)
+{
+    parser->status = LXB_STATUS_ERROR_UNEXPECTED_DATA;
+    parser->selectors->list_last->invalid = true;
+
+    (void) lxb_css_parser_stack_pop(parser);
+
+    return false;
+}
+
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* LEXBOR_CSS_SELECTORS_STATE_H */

data/vendor/lexbor/source/lexbor/css/stylesheet.h

@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2020 Alexander Borisov
+ *
+ * Author: Alexander Borisov <borisov@lexbor.com>
+ */
+
+#ifndef LXB_CSS_STYLESHEET_H
+#define LXB_CSS_STYLESHEET_H
+
+#include "lexbor/css/node.h"
+#include "lexbor/core/mraw.h"
+
+
+typedef struct lxb_css_stylesheet lxb_css_stylesheet_t;
+
+struct lxb_css_stylesheet {
+    lxb_css_node_t node;
+
+    lexbor_mraw_t  *mraw;
+};
+
+
+/*
+ * Inline functions
+ */
+lxb_inline lxb_css_stylesheet_t *
+lxb_css_stylesheet_create(lexbor_mraw_t *mraw)
+{
+//    if (mraw == NULL) {
+//        mraw =
+//    }
+
+    return (lxb_css_stylesheet_t *) lexbor_mraw_calloc(mraw, sizeof(lxb_css_stylesheet_t));
+}
+
+
+#endif /* LXB_CSS_STYLESHEET_H */

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

@@ -0,0 +1,443 @@
+/*
+ * Copyright (C) 2021 Alexander Borisov
+ *
+ * Author: Alexander Borisov <borisov@lexbor.com>
+ */
+
+#include "lexbor/core/conv.h"
+#include "lexbor/core/serialize.h"
+#include "lexbor/css/parser.h"
+#include "lexbor/css/syntax/anb.h"
+
+
+static lxb_css_log_message_t *
+lxb_css_syntax_anb_fail(lxb_css_parser_t *parser, lxb_css_syntax_token_t *token);
+
+static lxb_status_t
+lxb_css_syntax_anb_state_ident(lxb_css_parser_t *parser,
+                               lxb_css_syntax_token_t *token,
+                               lxb_css_syntax_anb_t *anb);
+
+static lxb_status_t
+lxb_css_syntax_anb_state_ident_data(lxb_css_parser_t *parser,
+                                    lxb_css_syntax_anb_t *anb,
+                                    lxb_css_syntax_token_t *token,
+                                    const lxb_char_t *data,
+                                    const lxb_char_t *end);
+
+
+lxb_css_syntax_anb_t
+lxb_css_syntax_anb_parse(lxb_css_parser_t *parser,
+                         const lxb_char_t *data, size_t length)
+{
+    lxb_css_syntax_anb_t anb;
+    lxb_css_syntax_token_t *token;
+
+    memset(&anb, 0, sizeof(lxb_css_syntax_anb_t));
+
+    if (parser->stage != LXB_CSS_PARSER_CLEAN) {
+        if (parser->stage == LXB_CSS_PARSER_RUN) {
+            parser->status = LXB_STATUS_ERROR_WRONG_ARGS;
+            return anb;
+        }
+
+        lxb_css_parser_clean(parser);
+    }
+
+    lxb_css_parser_stack_clean(parser);
+    lxb_css_parser_buffer_set(parser, data, length);
+
+    token = lxb_css_syntax_token(parser->tkz);
+    if (token == NULL) {
+        parser->status = parser->tkz->status;
+        return anb;
+    }
+
+    parser->stage = LXB_CSS_PARSER_RUN;
+    parser->status = lxb_css_syntax_anb_handler(parser, token, &anb);
+    parser->stage = LXB_CSS_PARSER_END;
+
+    token = lxb_css_syntax_token(parser->tkz);
+    if (token == NULL) {
+        parser->status = parser->tkz->status;
+        return anb;
+    }
+
+    if (parser->status != LXB_STATUS_OK
+        || token->type != LXB_CSS_SYNTAX_TOKEN__EOF)
+    {
+        (void) lxb_css_syntax_anb_fail(parser, parser->tkz->token);
+    }
+
+    return anb;
+}
+
+static lxb_css_log_message_t *
+lxb_css_syntax_anb_fail(lxb_css_parser_t *parser, lxb_css_syntax_token_t *token)
+{
+    parser->status = LXB_STATUS_ERROR_UNEXPECTED_DATA;
+
+    static const char anb[] = "An+B";
+
+    return lxb_css_syntax_token_error(parser, token, anb);
+}
+
+lxb_status_t
+lxb_css_syntax_anb_handler(lxb_css_parser_t *parser, lxb_css_syntax_token_t *token,
+                           lxb_css_syntax_anb_t *anb)
+{
+    const lxb_char_t *data, *end;
+    lxb_css_syntax_token_ident_t *ident;
+
+again:
+
+    switch (token->type) {
+        case LXB_CSS_SYNTAX_TOKEN_DIMENSION:
+            if (lxb_css_syntax_token_dimension(token)->num.is_float) {
+                return LXB_STATUS_ERROR_UNEXPECTED_DATA;
+            }
+
+            anb->a = lexbor_conv_double_to_long(lxb_css_syntax_token_dimension(token)->num.num);
+
+            ident = lxb_css_syntax_token_dimension_string(token);
+
+            goto ident;
+
+        case LXB_CSS_SYNTAX_TOKEN_IDENT:
+            return lxb_css_syntax_anb_state_ident(parser, token, anb);
+
+        case LXB_CSS_SYNTAX_TOKEN_NUMBER:
+            if (lxb_css_syntax_token_number(token)->is_float) {
+                return LXB_STATUS_ERROR_UNEXPECTED_DATA;
+            }
+
+            anb->a = 0;
+            anb->b = lexbor_conv_double_to_long(lxb_css_syntax_token_number(token)->num);
+            break;
+
+        case LXB_CSS_SYNTAX_TOKEN_DELIM:
+            if (lxb_css_syntax_token_delim(token)->character != '+') {
+                return LXB_STATUS_ERROR_UNEXPECTED_DATA;
+            }
+
+            lxb_css_syntax_token_consume(parser->tkz);
+            lxb_css_parser_token_status_m(parser, token);
+
+            if (token->type != LXB_CSS_SYNTAX_TOKEN_IDENT) {
+                return LXB_STATUS_ERROR_UNEXPECTED_DATA;
+            }
+
+            anb->a = 1;
+
+            ident = lxb_css_syntax_token_ident(token);
+
+            goto ident;
+
+        case LXB_CSS_SYNTAX_TOKEN_WHITESPACE:
+            lxb_css_syntax_token_consume(parser->tkz);
+            lxb_css_parser_token_status_m(parser, token);
+            goto again;
+
+        default:
+            return LXB_STATUS_ERROR_UNEXPECTED_DATA;
+    }
+
+    lxb_css_syntax_token_consume(parser->tkz);
+
+    return LXB_STATUS_OK;
+
+ident:
+
+    data = ident->data;
+    end = ident->data + ident->length;
+
+    if (*data != 'n' && *data != 'N') {
+        return LXB_STATUS_ERROR_UNEXPECTED_DATA;
+    }
+
+    data++;
+
+    return lxb_css_syntax_anb_state_ident_data(parser, anb, token, data, end);
+}
+
+static lxb_status_t
+lxb_css_syntax_anb_state_ident(lxb_css_parser_t *parser,
+                               lxb_css_syntax_token_t *token,
+                               lxb_css_syntax_anb_t *anb)
+{
+    size_t length;
+    lxb_char_t c;
+    const lxb_char_t *data, *end;
+    lxb_css_syntax_token_ident_t *ident;
+
+    static const lxb_char_t odd[] = "odd";
+    static const lxb_char_t even[] = "even";
+
+    ident = lxb_css_syntax_token_ident(token);
+
+    length = ident->length;
+    data = ident->data;
+    end = data + length;
+
+    c = *data++;
+
+    /* 'n' or '-n' */
+
+    if (c == 'n' || c == 'N') {
+        anb->a = 1;
+    }
+    else if (c == '-') {
+        if (data >= end) {
+            return LXB_STATUS_ERROR_UNEXPECTED_DATA;
+        }
+
+        c = *data++;
+
+        if (c != 'n' && c != 'N') {
+            return LXB_STATUS_ERROR_UNEXPECTED_DATA;
+        }
+
+        anb->a = -1;
+    }
+    else if (length == sizeof(odd) - 1
+             && lexbor_str_data_ncasecmp(ident->data, odd, sizeof(odd) - 1))
+    {
+        anb->a = 2;
+        anb->b = 1;
+
+        lxb_css_syntax_token_consume(parser->tkz);
+        return LXB_STATUS_OK;
+    }
+    else if (length == sizeof(even) - 1
+             && lexbor_str_data_ncasecmp(ident->data, even, sizeof(even) - 1))
+    {
+        anb->a = 2;
+        anb->b = 0;
+
+        lxb_css_syntax_token_consume(parser->tkz);
+        return LXB_STATUS_OK;
+    }
+    else {
+        return LXB_STATUS_ERROR_UNEXPECTED_DATA;
+    }
+
+    return lxb_css_syntax_anb_state_ident_data(parser, anb, token, data, end);
+}
+
+static lxb_status_t
+lxb_css_syntax_anb_state_ident_data(lxb_css_parser_t *parser,
+                                    lxb_css_syntax_anb_t *anb,
+                                    lxb_css_syntax_token_t *token,
+                                    const lxb_char_t *data,
+                                    const lxb_char_t *end)
+{
+    unsigned sign;
+    lxb_char_t c;
+    const lxb_char_t *p;
+
+    sign = 0;
+
+    if (data >= end) {
+        lxb_css_syntax_token_consume(parser->tkz);
+        lxb_css_parser_token_status_wo_ws_m(parser, token);
+
+        switch (token->type) {
+            case LXB_CSS_SYNTAX_TOKEN_NUMBER:
+                if (!lxb_css_syntax_token_number(token)->have_sign) {
+                    anb->b = 0;
+                    return LXB_STATUS_OK;
+                }
+
+                break;
+
+            case LXB_CSS_SYNTAX_TOKEN_DELIM:
+                c = lxb_css_syntax_token_delim(token)->character;
+
+                switch (c) {
+                    case '-':
+                        sign = 1;
+                        break;
+
+                    case '+':
+                        sign = 2;
+                        break;
+
+                    default:
+                        anb->b = 0;
+                        return LXB_STATUS_OK;
+                }
+
+                lxb_css_syntax_token_consume(parser->tkz);
+                lxb_css_parser_token_status_wo_ws_m(parser, token);
+
+                break;
+
+            case LXB_CSS_SYNTAX_TOKEN__EOF:
+                anb->b = 0;
+                return LXB_STATUS_OK;
+
+            default:
+                anb->b = 0;
+                return LXB_STATUS_OK;
+        }
+
+        goto number;
+    }
+
+    c = *data++;
+
+    if (c != '-') {
+        return LXB_STATUS_ERROR_UNEXPECTED_DATA;
+    }
+
+    if (data < end) {
+        p = data;
+        anb->b = -lexbor_conv_data_to_long(&data, end - data);
+
+        if (data == p || data < end) {
+            return LXB_STATUS_ERROR_UNEXPECTED_DATA;
+        }
+
+        goto done;
+    }
+
+    sign = 1;
+
+    lxb_css_syntax_token_consume(parser->tkz);
+    lxb_css_parser_token_status_wo_ws_m(parser, token);
+
+number:
+
+    if (token->type != LXB_CSS_SYNTAX_TOKEN_NUMBER) {
+        return LXB_STATUS_ERROR_UNEXPECTED_DATA;
+    }
+
+    if (lxb_css_syntax_token_number(token)->is_float
+        || (sign > 0 && lxb_css_syntax_token_number(token)->have_sign))
+    {
+        return LXB_STATUS_ERROR_UNEXPECTED_DATA;
+    }
+
+    anb->b = lexbor_conv_double_to_long(lxb_css_syntax_token_number(token)->num);
+
+    if (sign == 1) {
+        anb->b = -anb->b;
+    }
+
+done:
+
+    lxb_css_syntax_token_consume(parser->tkz);
+
+    return LXB_STATUS_OK;
+}
+
+lxb_status_t
+lxb_css_syntax_anb_serialize(lxb_css_syntax_anb_t *anb,
+                             lexbor_serialize_cb_f cb, void *ctx)
+{
+    lxb_char_t buf[128];
+    lxb_char_t *p, *end;
+
+    if (anb == NULL) {
+        return LXB_STATUS_OK;
+    }
+
+    static const lxb_char_t odd[] = "odd";
+    static const lxb_char_t even[] = "even";
+
+    if (anb->a == 2) {
+        if (anb->b == 1) {
+            return cb(odd, sizeof(odd) - 1, ctx);
+        }
+
+        if (anb->b == 0) {
+            return cb(even, sizeof(even) - 1, ctx);
+        }
+    }
+
+    p = buf;
+    end = p + sizeof(buf);
+
+    if (anb->a == 1) {
+        *p = '+';
+        p++;
+    }
+    else if (anb->a == -1) {
+        *p = '-';
+        p++;
+    }
+    else {
+        p += lexbor_conv_float_to_data((double) anb->a, p, end - p);
+        if (p >= end) {
+            return LXB_STATUS_ERROR_SMALL_BUFFER;
+        }
+    }
+
+    *p = 'n';
+    p++;
+
+    if (p >= end) {
+        return cb(buf, p - buf, ctx);
+    }
+
+    if (anb->b == 0) {
+        return cb(buf, p - buf, ctx);
+    }
+
+    if (anb->b > 0) {
+        *p = '+';
+        p++;
+
+        if (p >= end) {
+            return LXB_STATUS_ERROR_SMALL_BUFFER;
+        }
+    }
+
+    p += lexbor_conv_float_to_data((double) anb->b, p, end - p);
+
+    return cb(buf, p - buf, ctx);
+}
+
+lxb_char_t *
+lxb_css_syntax_anb_serialize_char(lxb_css_syntax_anb_t *anb, size_t *out_length)
+{
+    size_t length = 0;
+    lxb_status_t status;
+    lexbor_str_t str;
+
+    status = lxb_css_syntax_anb_serialize(anb, lexbor_serialize_length_cb,
+                                          &length);
+    if (status != LXB_STATUS_OK) {
+        goto failed;
+    }
+
+    /* + 1 == '\0' */
+    str.data = lexbor_malloc(length + 1);
+    if (str.data == NULL) {
+        goto failed;
+    }
+
+    str.length = 0;
+
+    status = lxb_css_syntax_anb_serialize(anb, lexbor_serialize_copy_cb, &str);
+    if (status != LXB_STATUS_OK) {
+        lexbor_free(str.data);
+        goto failed;
+    }
+
+    str.data[str.length] = '\0';
+
+    if (out_length != NULL) {
+        *out_length = str.length;
+    }
+
+    return str.data;
+
+failed:
+
+    if (out_length != NULL) {
+        *out_length = 0;
+    }
+
+    return NULL;
+}

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

@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2021 Alexander Borisov
+ *
+ * Author: Alexander Borisov <borisov@lexbor.com>
+ */
+
+#ifndef LEXBOR_CSS_SYNTAX_ANB_H
+#define LEXBOR_CSS_SYNTAX_ANB_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "lexbor/css/syntax/token.h"
+
+
+typedef struct {
+    long a;
+    long b;
+}
+lxb_css_syntax_anb_t;
+
+
+LXB_API lxb_css_syntax_anb_t
+lxb_css_syntax_anb_parse(lxb_css_parser_t *parser,
+                         const lxb_char_t *data, size_t length);
+
+LXB_API lxb_status_t
+lxb_css_syntax_anb_handler(lxb_css_parser_t *parser, lxb_css_syntax_token_t *token,
+                           lxb_css_syntax_anb_t *anb);
+
+LXB_API lxb_status_t
+lxb_css_syntax_anb_serialize(lxb_css_syntax_anb_t *anb,
+                             lexbor_serialize_cb_f cb, void *ctx);
+
+LXB_API lxb_char_t *
+lxb_css_syntax_anb_serialize_char(lxb_css_syntax_anb_t *anb,
+                                  size_t *out_length);
+
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* LEXBOR_CSS_SYNTAX_ANB_H */

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

@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2018-2020 Alexander Borisov
+ *
+ * Author: Alexander Borisov <borisov@lexbor.com>
+ */
+
+#ifndef LEXBOR_CSS_SYNTAX_BASE_H
+#define LEXBOR_CSS_SYNTAX_BASE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#include "lexbor/core/base.h"
+#include "lexbor/css/base.h"
+
+
+#define LXB_CSS_SYNTAX_VERSION_MAJOR 1
+#define LXB_CSS_SYNTAX_VERSION_MINOR 0
+#define LXB_CSS_SYNTAX_VERSION_PATCH 0
+
+#define LXB_CSS_SYNTAX_VERSION_STRING                                          \
+    LEXBOR_STRINGIZE(LXB_CSS_SYNTAX_VERSION_MAJOR) "."                         \
+    LEXBOR_STRINGIZE(LXB_CSS_SYNTAX_VERSION_MINOR) "."                         \
+    LEXBOR_STRINGIZE(LXB_CSS_SYNTAX_VERSION_PATCH)
+
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* LEXBOR_CSS_SYNTAX_BASE_H */

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

@@ -0,0 +1,9 @@
+/*
+ * Copyright (C) 2020-2021 Alexander Borisov
+ *
+ * Author: Alexander Borisov <borisov@lexbor.com>
+ */
+
+#include "lexbor/css/syntax/parser.h"
+#include "lexbor/css/parser.h"
+

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

@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2020-2021 Alexander Borisov
+ *
+ * Author: Alexander Borisov <borisov@lexbor.com>
+ */
+
+#ifndef LEXBOR_CSS_SYNTAX_PARSER_H
+#define LEXBOR_CSS_SYNTAX_PARSER_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#include "lexbor/core/dobject.h"
+#include "lexbor/core/plog.h"
+
+#include "lexbor/css/syntax/tokenizer.h"
+
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* LEXBOR_CSS_SYNTAX_PARSER_H */