nokolexbor 0.2.0

data/vendor/lexbor/source/lexbor/ns/ns.c

@@ -0,0 +1,154 @@
+/*
+ * Copyright (C) 2018-2019 Alexander Borisov
+ *
+ * Author: Alexander Borisov <borisov@lexbor.com>
+ */
+
+#include "lexbor/core/shs.h"
+
+#define LEXBOR_STR_RES_MAP_LOWERCASE
+#include "lexbor/core/str_res.h"
+
+#include "lexbor/ns/ns.h"
+#include "lexbor/ns/res.h"
+
+
+LXB_API const lxb_ns_data_t *
+lxb_ns_append(lexbor_hash_t *hash, const lxb_char_t *link, size_t length)
+{
+    lxb_ns_data_t *data;
+    const lexbor_shs_entry_t *entry;
+
+    if (link == NULL || length == 0) {
+        return NULL;
+    }
+
+    entry = lexbor_shs_entry_get_lower_static(lxb_ns_res_shs_link_data,
+                                              link, length);
+    if (entry != NULL) {
+        return entry->value;
+    }
+
+    data = lexbor_hash_insert(hash, lexbor_hash_insert_lower, link, length);
+    if ((lxb_ns_id_t) data <= LXB_NS__LAST_ENTRY) {
+        return NULL;
+    }
+
+    data->ns_id = (lxb_ns_id_t) data;
+
+    return data;
+}
+
+const lxb_char_t *
+lxb_ns_by_id(lexbor_hash_t *hash, lxb_ns_id_t ns_id, size_t *length)
+{
+    const lxb_ns_data_t *data;
+
+    data = lxb_ns_data_by_id(hash, ns_id);
+    if (data == NULL) {
+        if (length != NULL) {
+            *length = 0;
+        }
+
+        return NULL;
+    }
+
+    if (length != NULL) {
+        *length = data->entry.length;
+    }
+
+    return lexbor_hash_entry_str(&data->entry);
+}
+
+const lxb_ns_data_t *
+lxb_ns_data_by_id(lexbor_hash_t *hash, lxb_ns_id_t ns_id)
+{
+    if (ns_id >= LXB_NS__LAST_ENTRY) {
+        if (ns_id == LXB_NS__LAST_ENTRY) {
+            return NULL;
+        }
+
+        return (const lxb_ns_data_t *) ns_id;
+    }
+
+    return &lxb_ns_res_data[ns_id];
+}
+
+const lxb_ns_data_t *
+lxb_ns_data_by_link(lexbor_hash_t *hash, const lxb_char_t *link, size_t length)
+{
+    const lexbor_shs_entry_t *entry;
+
+    if (link == NULL || length == 0) {
+        return NULL;
+    }
+
+    entry = lexbor_shs_entry_get_lower_static(lxb_ns_res_shs_link_data,
+                                              link, length);
+    if (entry != NULL) {
+        return entry->value;
+    }
+
+    return lexbor_hash_search(hash, lexbor_hash_search_lower, link, length);
+}
+
+/* Prefix */
+const lxb_ns_prefix_data_t *
+lxb_ns_prefix_append(lexbor_hash_t *hash,
+                     const lxb_char_t *prefix, size_t length)
+{
+    lxb_ns_prefix_data_t *data;
+    const lexbor_shs_entry_t *entry;
+
+    if (prefix == NULL || length == 0) {
+        return NULL;
+    }
+
+    entry = lexbor_shs_entry_get_lower_static(lxb_ns_res_shs_data,
+                                              prefix, length);
+    if (entry != NULL) {
+        return entry->value;
+    }
+
+    data = lexbor_hash_insert(hash, lexbor_hash_insert_lower, prefix, length);
+    if ((lxb_ns_prefix_id_t) data <= LXB_NS__LAST_ENTRY) {
+        return NULL;
+    }
+
+    data->prefix_id = (lxb_ns_prefix_id_t) data;
+
+    return data;
+}
+
+const lxb_ns_prefix_data_t *
+lxb_ns_prefix_data_by_id(lexbor_hash_t *hash, lxb_ns_prefix_id_t prefix_id)
+{
+    if (prefix_id >= LXB_NS__LAST_ENTRY) {
+        if (prefix_id == LXB_NS__LAST_ENTRY) {
+            return NULL;
+        }
+
+        return (const lxb_ns_prefix_data_t *) prefix_id;
+    }
+
+    return &lxb_ns_prefix_res_data[prefix_id];
+}
+
+const lxb_ns_prefix_data_t *
+lxb_ns_prefix_data_by_name(lexbor_hash_t *hash,
+                           const lxb_char_t *prefix, size_t length)
+{
+    const lexbor_shs_entry_t *entry;
+
+    if (prefix == NULL || length == 0) {
+        return NULL;
+    }
+
+    entry = lexbor_shs_entry_get_lower_static(lxb_ns_res_shs_data,
+                                              prefix, length);
+    if (entry != NULL) {
+        return entry->value;
+    }
+
+    return lexbor_hash_search(hash, lexbor_hash_search_lower, prefix, length);
+}

data/vendor/lexbor/source/lexbor/ns/ns.h

@@ -0,0 +1,66 @@
+/*
+ * Copyright (C) 2018 Alexander Borisov
+ *
+ * Author: Alexander Borisov <borisov@lexbor.com>
+ */
+
+#ifndef LEXBOR_NS_H
+#define LEXBOR_NS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "lexbor/core/hash.h"
+#include "lexbor/core/shs.h"
+
+#include "lexbor/ns/const.h"
+
+
+typedef struct {
+    lexbor_hash_entry_t  entry;
+
+    lxb_ns_id_t          ns_id;
+    size_t               ref_count;
+    bool                 read_only;
+}
+lxb_ns_data_t;
+
+typedef struct {
+    lexbor_hash_entry_t  entry;
+
+    lxb_ns_prefix_id_t   prefix_id;
+    size_t               ref_count;
+    bool                 read_only;
+}
+lxb_ns_prefix_data_t;
+
+
+/* Link */
+LXB_API const lxb_char_t *
+lxb_ns_by_id(lexbor_hash_t *hash, lxb_ns_id_t ns_id, size_t *length);
+
+LXB_API const lxb_ns_data_t *
+lxb_ns_data_by_id(lexbor_hash_t *hash, lxb_ns_id_t ns_id);
+
+LXB_API const lxb_ns_data_t *
+lxb_ns_data_by_link(lexbor_hash_t *hash, const lxb_char_t *name, size_t length);
+
+/* Prefix */
+LXB_API const lxb_ns_prefix_data_t *
+lxb_ns_prefix_append(lexbor_hash_t *hash,
+                     const lxb_char_t *prefix, size_t length);
+
+LXB_API const lxb_ns_prefix_data_t *
+lxb_ns_prefix_data_by_id(lexbor_hash_t *hash, lxb_ns_prefix_id_t prefix_id);
+
+LXB_API const lxb_ns_prefix_data_t *
+lxb_ns_prefix_data_by_name(lexbor_hash_t *hash,
+                           const lxb_char_t *name, size_t length);
+
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* LEXBOR_NS_H */

data/vendor/lexbor/source/lexbor/ns/res.h

@@ -0,0 +1,97 @@
+/*
+ * Copyright (C) 2018-2019 Alexander Borisov
+ *
+ * Author: Alexander Borisov <borisov@lexbor.com>
+ */
+
+/*
+ * Caution!
+ * This file generated by the script "utils/lexbor/tag_ns/tags.py"!
+ * Do not change this file!
+ */
+
+
+#ifndef LXB_NS_RES_H
+#define LXB_NS_RES_H
+
+#endif /* LXB_NS_RES_H */
+
+
+#ifdef LXB_NS_CONST_VERSION
+#ifndef LXB_NS_CONST_VERSION_253D4AFDA959234B48A478B956C3C777
+#error Mismatched namespaces version! See "lexbor/ns/const.h".
+#endif /* LXB_NS_CONST_VERSION_253D4AFDA959234B48A478B956C3C777 */
+#else
+#error You need to include "lexbor/ns/const.h".
+#endif /* LXB_NS_CONST_VERSION */
+
+
+static const lxb_ns_data_t lxb_ns_res_data[LXB_NS__LAST_ENTRY] = 
+{
+    {{.u.short_str = "", .length = 0, .next = NULL}, LXB_NS__UNDEF, 1, true},
+    {{.u.short_str = "", .length = 0, .next = NULL}, LXB_NS__ANY, 1, true},
+    {{.u.long_str = (lxb_char_t *) "http://www.w3.org/1999/xhtml", .length = 28, .next = NULL}, LXB_NS_HTML, 1, true},
+    {{.u.long_str = (lxb_char_t *) "http://www.w3.org/1998/Math/MathML", .length = 34, .next = NULL}, LXB_NS_MATH, 1, true},
+    {{.u.long_str = (lxb_char_t *) "http://www.w3.org/2000/svg", .length = 26, .next = NULL}, LXB_NS_SVG, 1, true},
+    {{.u.long_str = (lxb_char_t *) "http://www.w3.org/1999/xlink", .length = 28, .next = NULL}, LXB_NS_XLINK, 1, true},
+    {{.u.long_str = (lxb_char_t *) "http://www.w3.org/XML/1998/namespace", .length = 36, .next = NULL}, LXB_NS_XML, 1, true},
+    {{.u.long_str = (lxb_char_t *) "http://www.w3.org/2000/xmlns/", .length = 29, .next = NULL}, LXB_NS_XMLNS, 1, true}
+};
+
+static const lxb_ns_prefix_data_t lxb_ns_prefix_res_data[LXB_NS__LAST_ENTRY] = 
+{
+    {{.u.short_str = "#undef", .length = 6, .next = NULL}, LXB_NS__UNDEF, 1, true},
+    {{.u.short_str = "#any", .length = 4, .next = NULL}, LXB_NS__ANY, 1, true},
+    {{.u.short_str = "html", .length = 4, .next = NULL}, LXB_NS_HTML, 1, true},
+    {{.u.short_str = "math", .length = 4, .next = NULL}, LXB_NS_MATH, 1, true},
+    {{.u.short_str = "svg", .length = 3, .next = NULL}, LXB_NS_SVG, 1, true},
+    {{.u.short_str = "xlink", .length = 5, .next = NULL}, LXB_NS_XLINK, 1, true},
+    {{.u.short_str = "xml", .length = 3, .next = NULL}, LXB_NS_XML, 1, true},
+    {{.u.short_str = "xmlns", .length = 5, .next = NULL}, LXB_NS_XMLNS, 1, true}
+};
+
+static const lexbor_shs_entry_t lxb_ns_res_shs_data[] = 
+{
+    {NULL, NULL, 28, 0}, {"html", (void *) &lxb_ns_prefix_res_data[2], 4, 0}, 
+    {"xmlns", (void *) &lxb_ns_prefix_res_data[7], 5, 0}, {NULL, NULL, 0, 0}, 
+    {NULL, NULL, 0, 0}, {NULL, NULL, 0, 0}, 
+    {NULL, NULL, 0, 0}, {"svg", (void *) &lxb_ns_prefix_res_data[4], 3, 0}, 
+    {NULL, NULL, 0, 0}, {NULL, NULL, 0, 0}, 
+    {NULL, NULL, 0, 0}, {NULL, NULL, 0, 0}, 
+    {NULL, NULL, 0, 0}, {NULL, NULL, 0, 0}, 
+    {NULL, NULL, 0, 0}, {NULL, NULL, 0, 0}, 
+    {NULL, NULL, 0, 0}, {"math", (void *) &lxb_ns_prefix_res_data[3], 4, 0}, 
+    {NULL, NULL, 0, 0}, {NULL, NULL, 0, 0}, 
+    {NULL, NULL, 0, 0}, {"#undef", (void *) &lxb_ns_prefix_res_data[0], 6, 0}, 
+    {"xlink", (void *) &lxb_ns_prefix_res_data[5], 5, 0}, {NULL, NULL, 0, 0}, 
+    {NULL, NULL, 0, 0}, {NULL, NULL, 0, 0}, 
+    {"#any", (void *) &lxb_ns_prefix_res_data[1], 4, 0}, {NULL, NULL, 0, 0}, 
+    {"xml", (void *) &lxb_ns_prefix_res_data[6], 3, 0}
+};
+
+static const lexbor_shs_entry_t lxb_ns_res_shs_link_data[] = 
+{
+    {NULL, NULL, 22, 0}, 
+    {"http://www.w3.org/1999/xhtml", (void *) &lxb_ns_res_data[2], 28, 0}, 
+    {NULL, NULL, 0, 0}, 
+    {NULL, NULL, 0, 0}, 
+    {NULL, NULL, 0, 0}, 
+    {NULL, NULL, 0, 0}, 
+    {"http://www.w3.org/2000/xmlns/", (void *) &lxb_ns_res_data[7], 29, 0}, 
+    {"http://www.w3.org/1998/math/mathml", (void *) &lxb_ns_res_data[3], 34, 0}, 
+    {NULL, NULL, 0, 0}, 
+    {"http://www.w3.org/1999/xlink", (void *) &lxb_ns_res_data[5], 28, 0}, 
+    {NULL, NULL, 0, 0}, 
+    {NULL, NULL, 0, 0}, 
+    {NULL, NULL, 0, 0}, 
+    {NULL, NULL, 0, 0}, 
+    {NULL, NULL, 0, 0}, 
+    {NULL, NULL, 0, 0}, 
+    {"#any", (void *) &lxb_ns_res_data[1], 4, 0}, 
+    {"http://www.w3.org/2000/svg", (void *) &lxb_ns_res_data[4], 26, 0}, 
+    {NULL, NULL, 0, 0}, 
+    {"#undef", (void *) &lxb_ns_res_data[0], 6, 0}, 
+    {NULL, NULL, 0, 0}, 
+    {"http://www.w3.org/xml/1998/namespace", (void *) &lxb_ns_res_data[6], 36, 0}, 
+    {NULL, NULL, 0, 0}
+};

data/vendor/lexbor/source/lexbor/ports/posix/config.cmake

@@ -0,0 +1,11 @@
+if(NOT DEFINED LEXBOR_OPTIMIZATION_LEVEL)
+	set(LEXBOR_OPTIMIZATION_LEVEL "-O2")
+endif()
+
+if(NOT DEFINED LEXBOR_C_FLAGS)
+	set(LEXBOR_C_FLAGS "-Wall -pedantic -pipe -std=c99 -fPIC")
+endif()
+
+if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
+	add_definitions(-D_POSIX_C_SOURCE=199309L)
+endif()

data/vendor/lexbor/source/lexbor/ports/posix/lexbor/core/fs.c

@@ -0,0 +1,236 @@
+/*
+ * Copyright (C) 2018 Alexander Borisov
+ *
+ * Author: Alexander Borisov <borisov@lexbor.com>
+ */
+
+#ifndef _DEFAULT_SOURCE
+#define _DEFAULT_SOURCE
+#endif
+
+#ifndef _BSD_SOURCE
+#define _BSD_SOURCE
+#endif
+
+#include <string.h>
+#include <dirent.h>
+
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#include "lexbor/core/fs.h"
+
+
+lxb_status_t
+lexbor_fs_dir_read(const lxb_char_t *dirpath, lexbor_fs_dir_opt_t opt,
+                   lexbor_fs_dir_file_f callback, void *ctx)
+{
+    DIR *dir;
+    size_t path_len, free_len, d_namlen;
+    struct dirent *entry;
+    lexbor_action_t action;
+    lexbor_fs_file_type_t f_type;
+
+    char *file_begin;
+    char full_path[4096];
+
+    path_len = strlen((const char *) dirpath);
+    if (path_len == 0 || path_len >= (sizeof(full_path) - 1)) {
+        return LXB_STATUS_ERROR;
+    }
+
+    dir = opendir((const char *) dirpath);
+    if (dir == NULL) {
+        return LXB_STATUS_ERROR;
+    }
+
+    memcpy(full_path, dirpath, path_len);
+
+    /* Check for a separating character at the end dirpath */
+    if (full_path[(path_len - 1)] != '/') {
+        path_len++;
+
+        if (path_len >= (sizeof(full_path) - 1)) {
+            goto error;
+        }
+
+        full_path[(path_len - 1)] = '/';
+    }
+
+    file_begin = &full_path[path_len];
+    free_len = (sizeof(full_path) - 1) - path_len;
+
+    if (opt == LEXBOR_FS_DIR_OPT_UNDEF)
+    {
+        while ((entry = readdir(dir)) != NULL) {
+            d_namlen = strlen(entry->d_name);
+
+            if (d_namlen >= free_len) {
+                goto error;
+            }
+
+            /* +1 copy terminating null byte '\0' */
+            memcpy(file_begin, entry->d_name, (d_namlen + 1));
+
+            action = callback((const lxb_char_t *) full_path,
+                              (path_len + d_namlen),
+                              (const lxb_char_t *) entry->d_name,
+                              d_namlen, ctx);
+            if (action == LEXBOR_ACTION_STOP) {
+                break;
+            }
+        }
+
+        goto done;
+    }
+
+    while ((entry = readdir(dir)) != NULL) {
+        if (opt & LEXBOR_FS_DIR_OPT_WITHOUT_HIDDEN
+            && *entry->d_name == '.')
+        {
+            continue;
+        }
+
+        d_namlen = strlen(entry->d_name);
+
+        if (d_namlen >= free_len) {
+            goto error;
+        }
+
+        f_type = lexbor_fs_file_type((const lxb_char_t *) entry->d_name);
+
+        if (opt & LEXBOR_FS_DIR_OPT_WITHOUT_DIR
+            && f_type == LEXBOR_FS_FILE_TYPE_DIRECTORY)
+        {
+            continue;
+        }
+
+        if (opt & LEXBOR_FS_DIR_OPT_WITHOUT_FILE
+            && f_type == LEXBOR_FS_FILE_TYPE_FILE)
+        {
+            continue;
+        }
+
+        /* +1 copy terminating null byte '\0' */
+        memcpy(file_begin, entry->d_name, (d_namlen + 1));
+
+        action = callback((const lxb_char_t *) full_path,
+                          (path_len + d_namlen),
+                          (const lxb_char_t *) entry->d_name,
+                          d_namlen, ctx);
+        if (action == LEXBOR_ACTION_STOP) {
+            break;
+        }
+    }
+
+done:
+
+    closedir(dir);
+
+    return LXB_STATUS_OK;
+
+error:
+
+    closedir(dir);
+
+    return LXB_STATUS_ERROR;
+}
+
+lexbor_fs_file_type_t
+lexbor_fs_file_type(const lxb_char_t *full_path)
+{
+    struct stat sb;
+
+    if (stat((const char *) full_path, &sb) == -1) {
+        return LEXBOR_FS_FILE_TYPE_UNDEF;
+    }
+
+    switch (sb.st_mode & S_IFMT) {
+        case S_IFBLK:
+            return LEXBOR_FS_FILE_TYPE_BLOCK_DEVICE;
+
+        case S_IFCHR:
+            return LEXBOR_FS_FILE_TYPE_CHARACTER_DEVICE;
+
+        case S_IFDIR:
+            return LEXBOR_FS_FILE_TYPE_DIRECTORY;
+
+        case S_IFIFO:
+            return LEXBOR_FS_FILE_TYPE_PIPE;
+
+        case S_IFLNK:
+            return LEXBOR_FS_FILE_TYPE_SYMLINK;
+
+        case S_IFREG:
+            return LEXBOR_FS_FILE_TYPE_FILE;
+
+        case S_IFSOCK:
+            return LEXBOR_FS_FILE_TYPE_SOCKET;
+
+        default:
+            return LEXBOR_FS_FILE_TYPE_UNDEF;
+    }
+
+    return LEXBOR_FS_FILE_TYPE_UNDEF;
+}
+
+lxb_char_t *
+lexbor_fs_file_easy_read(const lxb_char_t *full_path, size_t *len)
+{
+    FILE *fh;
+    long size;
+    size_t nread;
+    lxb_char_t *data;
+
+    fh = fopen((const char *) full_path, "rb");
+    if (fh == NULL) {
+        goto error;
+    }
+
+    if (fseek(fh, 0L, SEEK_END) != 0) {
+        goto error_close;
+    }
+
+    size = ftell(fh);
+    if (size < 0) {
+        goto error_close;
+    }
+
+    if (fseek(fh, 0L, SEEK_SET) != 0) {
+        goto error_close;
+    }
+
+    data = lexbor_malloc(size + 1);
+    if (data == NULL) {
+        goto error_close;
+    }
+
+    nread = fread(data, 1, size, fh);
+    if (nread != (size_t) size) {
+        lexbor_free(data);
+
+        goto error_close;
+    }
+
+    fclose(fh);
+
+    data[size] = '\0';
+
+    if (len != NULL) {
+        *len = nread;
+    }
+
+    return data;
+
+error_close:
+
+    fclose(fh);
+
+error:
+
+    if (len != NULL) {
+        *len = 0;
+    }
+
+    return NULL;
+}

data/vendor/lexbor/source/lexbor/ports/posix/lexbor/core/memory.c

@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2018 Alexander Borisov
+ *
+ * Author: Alexander Borisov <borisov@lexbor.com>
+ */
+
+#include "lexbor/core/base.h"
+
+
+void *
+lexbor_malloc(size_t size)
+{
+    return malloc(size);
+}
+
+void *
+lexbor_realloc(void *dst, size_t size)
+{
+    return realloc(dst, size);
+}
+
+void *
+lexbor_calloc(size_t num, size_t size)
+{
+    return calloc(num, size);
+}
+
+void *
+lexbor_free(void *dst)
+{
+    free(dst);
+    return NULL;
+}