nokolexbor 0.2.0

data/vendor/lexbor/source/lexbor/core/bst_map.c

@@ -0,0 +1,238 @@
+/*
+ * Copyright (C) 2018 Alexander Borisov
+ *
+ * Author: Alexander Borisov <borisov@lexbor.com>
+ */
+
+#include "lexbor/core/bst_map.h"
+#include "lexbor/core/utils.h"
+
+
+lexbor_bst_map_t *
+lexbor_bst_map_create(void)
+{
+    return lexbor_calloc(1, sizeof(lexbor_bst_map_t));
+}
+
+lxb_status_t
+lexbor_bst_map_init(lexbor_bst_map_t *bst_map, size_t size)
+{
+    lxb_status_t status;
+
+    if (bst_map == NULL) {
+        return LXB_STATUS_ERROR_OBJECT_IS_NULL;
+    }
+
+    if (size == 0) {
+        return LXB_STATUS_ERROR_WRONG_ARGS;
+    }
+
+    /* bst */
+    bst_map->bst = lexbor_bst_create();
+    status = lexbor_bst_init(bst_map->bst, size);
+    if (status) {
+        return status;
+    }
+
+    /* dobject */
+    bst_map->entries = lexbor_dobject_create();
+    status = lexbor_dobject_init(bst_map->entries, size,
+                                 sizeof(lexbor_bst_map_entry_t));
+    if (status) {
+        return status;
+    }
+
+    /* mraw */
+    bst_map->mraw = lexbor_mraw_create();
+    status = lexbor_mraw_init(bst_map->mraw, (size * 6));
+    if (status) {
+        return status;
+    }
+
+    return LXB_STATUS_OK;
+}
+
+void
+lexbor_bst_map_clean(lexbor_bst_map_t *bst_map)
+{
+    lexbor_bst_clean(bst_map->bst);
+    lexbor_mraw_clean(bst_map->mraw);
+    lexbor_dobject_clean(bst_map->entries);
+}
+
+lexbor_bst_map_t *
+lexbor_bst_map_destroy(lexbor_bst_map_t *bst_map, bool self_destroy)
+{
+    if (bst_map == NULL) {
+        return NULL;
+    }
+
+    bst_map->bst = lexbor_bst_destroy(bst_map->bst, true);
+    bst_map->mraw = lexbor_mraw_destroy(bst_map->mraw, true);
+    bst_map->entries = lexbor_dobject_destroy(bst_map->entries, true);
+
+    if (self_destroy) {
+        return lexbor_free(bst_map);
+    }
+
+    return bst_map;
+}
+
+lexbor_bst_map_entry_t *
+lexbor_bst_map_search(lexbor_bst_map_t *bst_map, lexbor_bst_entry_t *scope,
+                      const lxb_char_t *key, size_t key_len)
+{
+    lexbor_bst_map_entry_t *entry;
+    lexbor_bst_entry_t *bst_entry;
+
+    size_t hash_id = lexbor_utils_hash_hash(key, key_len);
+
+    bst_entry = lexbor_bst_search(bst_map->bst, scope, hash_id);
+    if (bst_entry == NULL) {
+        return NULL;
+    }
+
+    do {
+        entry = bst_entry->value;
+
+        if (entry->str.length == key_len &&
+            lexbor_str_data_cmp(entry->str.data, key))
+        {
+            return entry;
+        }
+
+        bst_entry = bst_entry->next;
+    }
+    while (bst_entry != NULL);
+
+    return NULL;
+}
+
+lexbor_bst_map_entry_t *
+lexbor_bst_map_insert(lexbor_bst_map_t *bst_map,
+                      lexbor_bst_entry_t **scope,
+                      const lxb_char_t *key, size_t key_len, void *value)
+{
+    lexbor_bst_map_entry_t *entry;
+
+    entry = lexbor_bst_map_insert_not_exists(bst_map, scope, key, key_len);
+    if (entry == NULL) {
+        return NULL;
+    }
+
+    entry->value = value;
+
+    return entry;
+}
+
+lexbor_bst_map_entry_t *
+lexbor_bst_map_insert_not_exists(lexbor_bst_map_t *bst_map,
+                                 lexbor_bst_entry_t **scope,
+                                 const lxb_char_t *key, size_t key_len)
+{
+    lexbor_bst_map_entry_t *entry;
+    lexbor_bst_entry_t *bst_entry;
+
+    size_t hash_id = lexbor_utils_hash_hash(key, key_len);
+
+    bst_entry = lexbor_bst_insert_not_exists(bst_map->bst, scope, hash_id);
+    if (bst_entry == NULL) {
+        return NULL;
+    }
+
+    if (bst_entry->value == NULL) {
+        goto new_entry;
+    }
+
+    do {
+        entry = bst_entry->value;
+
+        if (entry->str.length == key_len &&
+            lexbor_str_data_cmp(entry->str.data, key))
+        {
+            return entry;
+        }
+
+        if (bst_entry->next == NULL) {
+            bst_entry->next = lexbor_bst_entry_make(bst_map->bst, hash_id);
+            bst_entry = bst_entry->next;
+
+            if (bst_entry == NULL) {
+                return NULL;
+            }
+
+            goto new_entry;
+        }
+
+        bst_entry = bst_entry->next;
+    }
+    while (1);
+
+    return NULL;
+
+new_entry:
+
+    entry = lexbor_dobject_calloc(bst_map->entries);
+    if (entry == NULL) {
+        return NULL;
+    }
+
+    lexbor_str_init(&entry->str, bst_map->mraw, key_len);
+    if (entry->str.data == NULL) {
+        lexbor_dobject_free(bst_map->entries, entry);
+
+        return NULL;
+    }
+
+    lexbor_str_append(&entry->str, bst_map->mraw, key, key_len);
+
+    bst_entry->value = entry;
+
+    return entry;
+}
+
+void *
+lexbor_bst_map_remove(lexbor_bst_map_t *bst_map, lexbor_bst_entry_t **scope,
+                      const lxb_char_t *key, size_t key_len)
+{
+    lexbor_bst_map_entry_t *entry;
+    lexbor_bst_entry_t *bst_entry;
+
+    size_t hash_id = lexbor_utils_hash_hash(key, key_len);
+
+    bst_entry = lexbor_bst_search(bst_map->bst, *scope, hash_id);
+    if (bst_entry == NULL) {
+        return NULL;
+    }
+
+    do {
+        entry = bst_entry->value;
+
+        if (entry->str.length == key_len &&
+            lexbor_str_data_cmp(entry->str.data, key))
+        {
+            void *value = entry->value;
+
+            lexbor_bst_remove_by_pointer(bst_map->bst, bst_entry, scope);
+
+            lexbor_str_destroy(&entry->str, bst_map->mraw, false);
+            lexbor_dobject_free(bst_map->entries, entry);
+
+            return value;
+        }
+
+        bst_entry = bst_entry->next;
+    }
+    while (bst_entry != NULL);
+
+    return NULL;
+}
+
+/*
+ * No inline functions.
+ */
+lexbor_mraw_t *
+lexbor_bst_map_mraw_noi(lexbor_bst_map_t *bst_map)
+{
+    return lexbor_bst_map_mraw(bst_map);
+}

data/vendor/lexbor/source/lexbor/core/bst_map.h

@@ -0,0 +1,87 @@
+/*
+ * Copyright (C) 2018 Alexander Borisov
+ *
+ * Author: Alexander Borisov <borisov@lexbor.com>
+ */
+
+#ifndef LEXBOR_BST_MAP_H
+#define LEXBOR_BST_MAP_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "lexbor/core/bst.h"
+#include "lexbor/core/str.h"
+#include "lexbor/core/mraw.h"
+#include "lexbor/core/dobject.h"
+
+
+typedef struct {
+    lexbor_str_t str;
+    void         *value;
+}
+lexbor_bst_map_entry_t;
+
+typedef struct {
+    lexbor_bst_t     *bst;
+    lexbor_mraw_t    *mraw;
+    lexbor_dobject_t *entries;
+
+}
+lexbor_bst_map_t;
+
+
+LXB_API lexbor_bst_map_t *
+lexbor_bst_map_create(void);
+
+LXB_API lxb_status_t
+lexbor_bst_map_init(lexbor_bst_map_t *bst_map, size_t size);
+
+LXB_API void
+lexbor_bst_map_clean(lexbor_bst_map_t *bst_map);
+
+LXB_API lexbor_bst_map_t *
+lexbor_bst_map_destroy(lexbor_bst_map_t *bst_map, bool self_destroy);
+
+
+LXB_API lexbor_bst_map_entry_t *
+lexbor_bst_map_search(lexbor_bst_map_t *bst_map, lexbor_bst_entry_t *scope,
+                      const lxb_char_t *key, size_t key_len);
+
+LXB_API lexbor_bst_map_entry_t *
+lexbor_bst_map_insert(lexbor_bst_map_t *bst_map, lexbor_bst_entry_t **scope,
+                      const lxb_char_t *key, size_t key_len, void *value);
+
+LXB_API lexbor_bst_map_entry_t *
+lexbor_bst_map_insert_not_exists(lexbor_bst_map_t *bst_map,
+                                 lexbor_bst_entry_t **scope,
+                                 const lxb_char_t *key, size_t key_len);
+
+LXB_API void *
+lexbor_bst_map_remove(lexbor_bst_map_t *bst_map, lexbor_bst_entry_t **scope,
+                      const lxb_char_t *key, size_t key_len);
+
+
+/*
+ * Inline functions
+ */
+lxb_inline lexbor_mraw_t *
+lexbor_bst_map_mraw(lexbor_bst_map_t *bst_map)
+{
+    return bst_map->mraw;
+}
+
+/*
+ * No inline functions for ABI.
+ */
+LXB_API lexbor_mraw_t *
+lexbor_bst_map_mraw_noi(lexbor_bst_map_t *bst_map);
+
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* LEXBOR_BST_MAP_H */
+

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

@@ -0,0 +1,12 @@
+set(DEPENDENCIES "")
+set(DESCRIPTION "The main module of the Lexbor project.
+The module includes various algorithms and methods for working with memory:
+AVL Tree, Array, String, Memory Pool and so on.")
+
+IF(LEXBOR_BUILD_SEPARATELY)
+    FEATURE_TRY_FUNCTION_EXISTS("${CURRENT_LIB_NAME}" "ceil" "m")
+ENDIF()
+
+IF(TARGET ${LEXBOR_LIB_NAME})
+    FEATURE_TRY_FUNCTION_EXISTS("${LEXBOR_LIB_NAME}" "ceil" "m")
+ENDIF()

data/vendor/lexbor/source/lexbor/core/conv.c

@@ -0,0 +1,203 @@
+/*
+ * Copyright (C) 2018 Alexander Borisov
+ *
+ * Author: Alexander Borisov <borisov@lexbor.com>
+ */
+
+#include <math.h>
+#include <float.h>
+
+#include "lexbor/core/conv.h"
+#include "lexbor/core/dtoa.h"
+#include "lexbor/core/strtod.h"
+
+
+size_t
+lexbor_conv_float_to_data(double num, lxb_char_t *buf, size_t len)
+{
+    return lexbor_dtoa(num, buf, len);
+}
+
+double
+lexbor_conv_data_to_double(const lxb_char_t **start, size_t len)
+{
+    int exponent, exp, insignf;
+    lxb_char_t c, *pos;
+    bool minus;
+    const lxb_char_t  *e, *p, *last, *end;
+    lxb_char_t data[128];
+
+    end = *start + len;
+
+    exponent = 0;
+    insignf = 0;
+
+    pos = data;
+    last = data + sizeof(data);
+
+    for (p = *start; p < end; p++) {
+        /* Values less than '0' become >= 208. */
+        c = *p - '0';
+
+        if (c > 9) {
+            break;
+        }
+
+        if (pos < last) {
+            *pos++ = *p;
+        }
+        else {
+            insignf++;
+        }
+    }
+
+    /* Do not emit a '.', but adjust the exponent instead. */
+    if (p < end && *p == '.') {
+
+        for (p++; p < end; p++) {
+            /* Values less than '0' become >= 208. */
+            c = *p - '0';
+
+            if (c > 9) {
+                break;
+            }
+
+            if (pos < last) {
+                *pos++ = *p;
+                exponent--;
+            }
+            else {
+                /* Ignore insignificant digits in the fractional part. */
+            }
+        }
+    }
+
+    e = p + 1;
+
+    if (e < end && (*p == 'e' || *p == 'E')) {
+        minus = 0;
+
+        if (e + 1 < end) {
+            if (*e == '-') {
+                e++;
+                minus = 1;
+            }
+            else if (*e == '+') {
+                e++;
+            }
+        }
+
+        /* Values less than '0' become >= 208. */
+        c = *e - '0';
+
+        if (c <= 9) {
+            exp = c;
+
+            for (p = e + 1; p < end; p++) {
+                /* Values less than '0' become >= 208. */
+                c = *p - '0';
+
+                if (c > 9) {
+                    break;
+                }
+
+                exp = exp * 10 + c;
+            }
+
+            exponent += minus ? -exp : exp;
+        }
+    }
+
+    *start = p;
+
+    exponent += insignf;
+
+    return lexbor_strtod_internal(data, pos - data, exponent);
+}
+
+unsigned long
+lexbor_conv_data_to_ulong(const lxb_char_t **data, size_t length)
+{
+    const lxb_char_t *p = *data;
+    const lxb_char_t *end = p + length;
+    unsigned long last_number = 0, number = 0;
+
+    for (; p < end; p++) {
+        if (*p < '0' || *p > '9') {
+            goto done;
+        }
+
+        number = (*p - '0') + number * 10;
+
+        if (last_number > number) {
+            *data = p - 1;
+            return last_number;
+        }
+
+        last_number = number;
+    }
+
+done:
+
+    *data = p;
+
+    return number;
+}
+
+long
+lexbor_conv_data_to_long(const lxb_char_t **data, size_t length)
+{
+    const lxb_char_t *p = *data;
+    const lxb_char_t *end = p + length;
+    unsigned long n = 0, number = 0;
+
+    for (; p < end; p++) {
+        if (*p < '0' || *p > '9') {
+            goto done;
+        }
+
+        n = (*p - '0') + number * 10;
+
+        if (n > LONG_MAX) {
+            *data = p - 1;
+            return number;
+        }
+
+        number = n;
+    }
+
+done:
+
+    *data = p;
+
+    return number;
+}
+
+unsigned
+lexbor_conv_data_to_uint(const lxb_char_t **data, size_t length)
+{
+    const lxb_char_t *p = *data;
+    const lxb_char_t *end = p + length;
+    unsigned last_number = 0, number = 0;
+
+    for (; p < end; p++) {
+        if (*p < '0' || *p > '9') {
+            goto done;
+        }
+
+        number = (*p - '0') + number * 10;
+
+        if (last_number > number) {
+            *data = p - 1;
+            return last_number;
+        }
+
+        last_number = number;
+    }
+
+done:
+
+    *data = p;
+
+    return number;
+}

data/vendor/lexbor/source/lexbor/core/conv.h

@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2018 Alexander Borisov
+ *
+ * Author: Alexander Borisov <borisov@lexbor.com>
+ */
+
+#ifndef LEXBOR_CONV_H
+#define LEXBOR_CONV_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#include "lexbor/core/base.h"
+
+
+LXB_API size_t
+lexbor_conv_float_to_data(double num, lxb_char_t *buf, size_t len);
+
+LXB_API double
+lexbor_conv_data_to_double(const lxb_char_t **start, size_t len);
+
+LXB_API unsigned long
+lexbor_conv_data_to_ulong(const lxb_char_t **data, size_t length);
+
+LXB_API long
+lexbor_conv_data_to_long(const lxb_char_t **data, size_t length);
+
+LXB_API unsigned
+lexbor_conv_data_to_uint(const lxb_char_t **data, size_t length);
+
+
+lxb_inline long
+lexbor_conv_double_to_long(double number)
+{
+    if (number > (double) LONG_MAX) {
+        return LONG_MAX;
+    }
+
+    if (number < (double) LONG_MIN) {
+        return -LONG_MAX;
+    }
+
+    return (long) number;
+}
+
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* LEXBOR_CONV_H */

data/vendor/lexbor/source/lexbor/core/core.h

@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2020 Alexander Borisov
+ *
+ * Author: Alexander Borisov <borisov@lexbor.com>
+ */
+
+#ifndef LEXBOR_CORE_H
+#define LEXBOR_CORE_H
+
+#include "lexbor/core/base.h"
+#include "lexbor/core/def.h"
+#include "lexbor/core/types.h"
+#include "lexbor/core/array.h"
+#include "lexbor/core/array_obj.h"
+#include "lexbor/core/avl.h"
+#include "lexbor/core/bst.h"
+#include "lexbor/core/bst_map.h"
+#include "lexbor/core/dobject.h"
+#include "lexbor/core/fs.h"
+#include "lexbor/core/in.h"
+#include "lexbor/core/lexbor.h"
+#include "lexbor/core/mem.h"
+#include "lexbor/core/mraw.h"
+#include "lexbor/core/perf.h"
+#include "lexbor/core/sbst.h"
+#include "lexbor/core/shs.h"
+#include "lexbor/core/str.h"
+#include "lexbor/core/conv.h"
+#include "lexbor/core/utils.h"
+#include "lexbor/core/diyfp.h"
+#include "lexbor/core/dtoa.h"
+#include "lexbor/core/strtod.h"
+#include "lexbor/core/serialize.h"
+
+#endif /* LEXBOR_CORE_H */

data/vendor/lexbor/source/lexbor/core/def.h

@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2018 Alexander Borisov
+ *
+ * Author: Alexander Borisov <borisov@lexbor.com>
+ */
+
+#ifndef LEXBOR_DEF_H
+#define LEXBOR_DEF_H
+
+#define LEXBOR_STRINGIZE_HELPER(x) #x
+#define LEXBOR_STRINGIZE(x) LEXBOR_STRINGIZE_HELPER(x)
+
+/* Format */
+#ifdef _WIN32
+    #define LEXBOR_FORMAT_Z "%Iu"
+#else
+    #define LEXBOR_FORMAT_Z "%zu"
+#endif
+
+/* Deprecated */
+#ifdef _MSC_VER
+    #define LXB_DEPRECATED(func) __declspec(deprecated) func
+#elif defined(__GNUC__) || defined(__INTEL_COMPILER)
+    #define LXB_DEPRECATED(func) func __attribute__((deprecated))
+#else
+    #define LXB_DEPRECATED(func) func
+#endif
+
+/* Debug */
+//#define LEXBOR_DEBUG(...) do {} while (0)
+//#define LEXBOR_DEBUG_ERROR(...) do {} while (0)
+
+#define LEXBOR_MEM_ALIGN_STEP sizeof(void *)
+
+#ifndef LEXBOR_STATIC
+    #ifdef _WIN32
+        #ifdef LEXBOR_BUILDING
+            #define LXB_API __declspec(dllexport)
+        #else
+            #define LXB_API __declspec(dllimport)
+        #endif
+    #elif (defined(__SUNPRO_C)  || defined(__SUNPRO_CC))
+        #define LXB_API __global
+    #else
+        #if (defined(__GNUC__) && __GNUC__ >= 4) || defined(__INTEL_COMPILER)
+            #define LXB_API __attribute__ ((visibility("default")))
+        #else
+            #define LXB_API
+        #endif
+    #endif
+#else
+    #define LXB_API
+#endif
+
+#define LXB_EXTERN extern LXB_API
+
+#endif /* LEXBOR_DEF_H */