nokolexbor 0.2.0

data/vendor/lexbor/feature.cmake

@@ -0,0 +1,134 @@
+include(CheckFunctionExists)
+
+################
+## Check Math functions
+#########################
+MACRO(FEATURE_TRY_FUNCTION_EXISTS target fname lib_name)
+    CHECK_FUNCTION_EXISTS(${fname} test_result)
+
+    IF(NOT test_result)
+        unset(test_result CACHE)
+
+        list(APPEND CMAKE_REQUIRED_LIBRARIES ${lib_name})
+
+        CHECK_FUNCTION_EXISTS(${fname} test_result)
+
+        STRING(REGEX REPLACE "${lib_name}" "" CMAKE_REQUIRED_LIBRARIES
+               ${CMAKE_REQUIRED_LIBRARIES})
+
+        IF(test_result)
+            target_link_libraries(${target} ${lib_name})
+        ELSE()
+            message(FATAL_ERROR "checking for ${fname}() ... not found")
+        ENDIF()
+    ENDIF()
+
+    unset(test_result CACHE)
+ENDMACRO()
+
+MACRO(FEATURE_CHECK_ASAN out_result)
+    set(lexbor_asan_flags "-O0 -g -fsanitize=address -fno-omit-frame-pointer")
+
+    IF(LEXBOR_BUILD_WITH_ASAN)
+        set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${lexbor_asan_flags}")
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${lexbor_asan_flags}")
+    ENDIF()
+
+    set(feature_filename "${CMAKE_BINARY_DIR}/feature_check.c")
+
+    set(FEATUTE_CHECK_STRING "
+#include <sanitizer/asan_interface.h>
+
+int main(void) {
+    return
+    #ifdef __SANITIZE_ADDRESS__
+        #if defined(ASAN_POISON_MEMORY_REGION) && defined(ASAN_UNPOISON_MEMORY_REGION)
+            0;
+        #endif
+    #else
+        #if defined(__has_feature)
+            #if __has_feature(address_sanitizer)
+                #if defined(ASAN_POISON_MEMORY_REGION) && defined(ASAN_UNPOISON_MEMORY_REGION)
+                    0;
+                #endif
+            #endif
+        #endif
+    #endif
+}")
+
+    file(WRITE ${feature_filename} "${FEATUTE_CHECK_STRING}")
+
+    try_compile(${out_result} "${CMAKE_BINARY_DIR}" "${feature_filename}"
+        CMAKE_FLAGS "-DCMAKE_C_FLAGS=${CMAKE_C_FLAGS}"
+    )
+
+    IF(${${out_result}})
+        message(STATUS "Feature ASAN: enabled")
+    ELSE()
+        message(STATUS "Feature ASAN: disable")
+    ENDIF()
+
+    file(REMOVE ${feature_filename})
+
+    IF(LEXBOR_BUILD_WITH_ASAN)
+        IF(NOT ${${out_result}})
+            STRING(REGEX REPLACE " ${lexbor_asan_flags}" "" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
+            STRING(REGEX REPLACE " ${lexbor_asan_flags}" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+        ELSE()
+            message(STATUS "Updated CFLAGS: ${CMAKE_C_FLAGS}")
+            message(STATUS "Updated CXXFLAGS: ${CMAKE_CXX_FLAGS}")
+        ENDIF()
+    ENDIF()
+
+    unset(lexbor_asan_flags)
+    unset(FEATUTE_CHECK_STRING)
+    unset(feature_filename)
+ENDMACRO()
+
+MACRO(FEATURE_CHECK_FUZZER out_result)
+    set(lexbor_fuzzer_flags "-O0 -g -fsanitize=fuzzer")
+
+    IF(LEXBOR_BUILD_WITH_FUZZER)
+        set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${lexbor_fuzzer_flags}")
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${lexbor_fuzzer_flags}")
+    ENDIF()
+
+    set(feature_filename "${CMAKE_BINARY_DIR}/feature_check.c")
+
+    set(FEATUTE_CHECK_STRING "
+#include <sanitizer/asan_interface.h>
+
+int
+LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
+{
+    return 0;
+}")
+
+    file(WRITE ${feature_filename} "${FEATUTE_CHECK_STRING}")
+
+    try_compile(${out_result} "${CMAKE_BINARY_DIR}" "${feature_filename}"
+        CMAKE_FLAGS "-DCMAKE_C_FLAGS=${CMAKE_C_FLAGS}"
+    )
+
+    IF(${${out_result}})
+        message(STATUS "Feature Fuzzer: enabled")
+    ELSE()
+        message(STATUS "Feature Fuzzer: disable")
+    ENDIF()
+
+    file(REMOVE ${feature_filename})
+
+    IF(LEXBOR_BUILD_WITH_FUZZER)
+        IF(NOT ${${out_result}})
+            STRING(REGEX REPLACE " ${lexbor_fuzzer_flags}" "" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
+            STRING(REGEX REPLACE " ${lexbor_fuzzer_flags}" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+        ELSE()
+            message(STATUS "Updated CFLAGS: ${CMAKE_C_FLAGS}")
+            message(STATUS "Updated CXXFLAGS: ${CMAKE_CXX_FLAGS}")
+        ENDIF()
+    ENDIF()
+
+    unset(lexbor_fuzzer_flags)
+    unset(FEATUTE_CHECK_STRING)
+    unset(feature_filename)
+ENDMACRO()

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

@@ -0,0 +1,208 @@
+/*
+ * Copyright (C) 2018 Alexander Borisov
+ *
+ * Author: Alexander Borisov <borisov@lexbor.com>
+ */
+
+#include "lexbor/core/array.h"
+
+
+lexbor_array_t *
+lexbor_array_create(void)
+{
+    return lexbor_calloc(1, sizeof(lexbor_array_t));
+}
+
+lxb_status_t
+lexbor_array_init(lexbor_array_t *array, size_t size)
+{
+    if (array == NULL) {
+        return LXB_STATUS_ERROR_OBJECT_IS_NULL;
+    }
+
+    if (size == 0) {
+        return LXB_STATUS_ERROR_TOO_SMALL_SIZE;
+    }
+
+    array->length = 0;
+    array->size = size;
+
+    array->list = lexbor_malloc(sizeof(void *) * size);
+    if (array->list == NULL) {
+        return LXB_STATUS_ERROR_MEMORY_ALLOCATION;
+    }
+
+    return LXB_STATUS_OK;
+}
+
+void
+lexbor_array_clean(lexbor_array_t *array)
+{
+    if (array != NULL) {
+        array->length = 0;
+    }
+}
+
+lexbor_array_t *
+lexbor_array_destroy(lexbor_array_t *array, bool self_destroy)
+{
+    if (array == NULL)
+        return NULL;
+
+    if (array->list) {
+        array->length = 0;
+        array->size = 0;
+        array->list = lexbor_free(array->list);
+    }
+
+    if (self_destroy) {
+        return lexbor_free(array);
+    }
+
+    return array;
+}
+
+void **
+lexbor_array_expand(lexbor_array_t *array, size_t up_to)
+{
+    void **list;
+    size_t new_size;
+
+    if (array->length > (SIZE_MAX - up_to))
+        return NULL;
+
+    new_size = array->length + up_to;
+    list = lexbor_realloc(array->list, sizeof(void *) * new_size);
+
+    if (list == NULL)
+        return NULL;
+
+    array->list = list;
+    array->size = new_size;
+
+    return list;
+}
+
+lxb_status_t
+lexbor_array_push(lexbor_array_t *array, void *value)
+{
+    if (array->length >= array->size) {
+        if ((lexbor_array_expand(array, 128) == NULL)) {
+            return LXB_STATUS_ERROR_MEMORY_ALLOCATION;
+        }
+    }
+
+    array->list[ array->length ] = value;
+    array->length++;
+
+    return LXB_STATUS_OK;
+}
+
+void *
+lexbor_array_pop(lexbor_array_t *array)
+{
+    if (array->length == 0) {
+        return NULL;
+    }
+
+    array->length--;
+    return array->list[ array->length ];
+}
+
+lxb_status_t
+lexbor_array_insert(lexbor_array_t *array, size_t idx, void *value)
+{
+    if (idx >= array->length) {
+        size_t up_to = (idx - array->length) + 1;
+
+        if (idx >= array->size) {
+            if ((lexbor_array_expand(array, up_to) == NULL)) {
+                return LXB_STATUS_ERROR_MEMORY_ALLOCATION;
+            }
+        }
+
+        memset(&array->list[array->length], 0, sizeof(void *) * up_to);
+
+        array->list[ idx ] = value;
+        array->length += up_to;
+
+        return LXB_STATUS_OK;
+    }
+
+    if (array->length >= array->size) {
+        if ((lexbor_array_expand(array, 32) == NULL)) {
+            return LXB_STATUS_ERROR_MEMORY_ALLOCATION;
+        }
+    }
+
+    memmove(&array->list[idx + 1], &array->list[idx],
+            sizeof(void *) * (array->length - idx));
+
+    array->list[ idx ] = value;
+    array->length++;
+
+    return LXB_STATUS_OK;
+}
+
+lxb_status_t
+lexbor_array_set(lexbor_array_t *array, size_t idx, void *value)
+{
+    if (idx >= array->length) {
+        size_t up_to = (idx - array->length) + 1;
+
+        if (idx >= array->size) {
+            if ((lexbor_array_expand(array, up_to) == NULL)) {
+                return LXB_STATUS_ERROR_MEMORY_ALLOCATION;
+            }
+        }
+
+        memset(&array->list[array->length], 0, sizeof(void *) * up_to);
+
+        array->length += up_to;
+    }
+
+    array->list[idx] = value;
+
+    return LXB_STATUS_OK;
+}
+
+void
+lexbor_array_delete(lexbor_array_t *array, size_t begin, size_t length)
+{
+    if (begin >= array->length || length == 0) {
+        return;
+    }
+
+    size_t end_len = begin + length;
+
+    if (end_len >= array->length) {
+        array->length = begin;
+        return;
+    }
+
+    memmove(&array->list[begin], &array->list[end_len],
+            sizeof(void *) * (array->length - end_len));
+
+    array->length -= length;
+}
+
+/*
+ * No inline functions.
+ */
+void *
+lexbor_array_get_noi(lexbor_array_t *array, size_t idx)
+{
+    return lexbor_array_get(array, idx);
+}
+
+size_t
+lexbor_array_length_noi(lexbor_array_t *array)
+{
+    return lexbor_array_length(array);
+}
+
+size_t
+lexbor_array_size_noi(lexbor_array_t *array)
+{
+    return lexbor_array_size(array);
+}

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

@@ -0,0 +1,100 @@
+/*
+ * Copyright (C) 2018 Alexander Borisov
+ *
+ * Author: Alexander Borisov <borisov@lexbor.com>
+ */
+
+#ifndef LEXBOR_ARRAY_H
+#define LEXBOR_ARRAY_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "lexbor/core/base.h"
+
+
+typedef struct {
+    void   **list;
+    size_t size;
+    size_t length;
+}
+lexbor_array_t;
+
+
+LXB_API lexbor_array_t *
+lexbor_array_create(void);
+
+LXB_API lxb_status_t
+lexbor_array_init(lexbor_array_t *array, size_t size);
+
+LXB_API void
+lexbor_array_clean(lexbor_array_t *array);
+
+LXB_API lexbor_array_t *
+lexbor_array_destroy(lexbor_array_t *array, bool self_destroy);
+
+
+LXB_API void **
+lexbor_array_expand(lexbor_array_t *array, size_t up_to);
+
+
+LXB_API lxb_status_t
+lexbor_array_push(lexbor_array_t *array, void *value);
+
+LXB_API void *
+lexbor_array_pop(lexbor_array_t *array);
+
+LXB_API lxb_status_t
+lexbor_array_insert(lexbor_array_t *array, size_t idx, void *value);
+
+LXB_API lxb_status_t
+lexbor_array_set(lexbor_array_t *array, size_t idx, void *value);
+
+LXB_API void
+lexbor_array_delete(lexbor_array_t *array, size_t begin, size_t length);
+
+
+/*
+ * Inline functions
+ */
+lxb_inline void *
+lexbor_array_get(lexbor_array_t *array, size_t idx)
+{
+    if (idx >= array->length) {
+        return NULL;
+    }
+
+    return array->list[idx];
+}
+
+lxb_inline size_t
+lexbor_array_length(lexbor_array_t *array)
+{
+    return array->length;
+}
+
+lxb_inline size_t
+lexbor_array_size(lexbor_array_t *array)
+{
+    return array->size;
+}
+
+/*
+ * No inline functions for ABI.
+ */
+LXB_API void *
+lexbor_array_get_noi(lexbor_array_t *array, size_t idx);
+
+LXB_API size_t
+lexbor_array_length_noi(lexbor_array_t *array);
+
+LXB_API size_t
+lexbor_array_size_noi(lexbor_array_t *array);
+
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* LEXBOR_ARRAY_H */

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

@@ -0,0 +1,216 @@
+/*
+ * Copyright (C) 2018 Alexander Borisov
+ *
+ * Author: Alexander Borisov <borisov@lexbor.com>
+ */
+
+#include "lexbor/core/array_obj.h"
+
+
+lexbor_array_obj_t *
+lexbor_array_obj_create(void)
+{
+    return lexbor_calloc(1, sizeof(lexbor_array_obj_t));
+}
+
+lxb_status_t
+lexbor_array_obj_init(lexbor_array_obj_t *array,
+                      size_t size, size_t struct_size)
+{
+    if (array == NULL) {
+        return LXB_STATUS_ERROR_OBJECT_IS_NULL;
+    }
+
+    if (size == 0 || struct_size == 0) {
+        return LXB_STATUS_ERROR_TOO_SMALL_SIZE;
+    }
+
+    array->length = 0;
+    array->size = size;
+    array->struct_size = struct_size;
+
+    array->list = lexbor_malloc(sizeof(uint8_t *)
+                                * (array->size * struct_size));
+    if (array->list == NULL) {
+        return LXB_STATUS_ERROR_MEMORY_ALLOCATION;
+    }
+
+    return LXB_STATUS_OK;
+}
+
+void
+lexbor_array_obj_clean(lexbor_array_obj_t *array)
+{
+    if (array != NULL) {
+        array->length = 0;
+    }
+}
+
+lexbor_array_obj_t *
+lexbor_array_obj_destroy(lexbor_array_obj_t *array, bool self_destroy)
+{
+    if (array == NULL)
+        return NULL;
+
+    if (array->list) {
+        array->length = 0;
+        array->size = 0;
+        array->list = lexbor_free(array->list);
+    }
+
+    if (self_destroy) {
+        return lexbor_free(array);
+    }
+
+    return array;
+}
+
+uint8_t *
+lexbor_array_obj_expand(lexbor_array_obj_t *array, size_t up_to)
+{
+    uint8_t *list;
+    size_t new_size;
+
+    if (array->length > (SIZE_MAX - up_to)) {
+        return NULL;
+    }
+
+    new_size = array->length + up_to;
+
+    list = lexbor_realloc(array->list, sizeof(uint8_t *)
+                          * (new_size * array->struct_size));
+    if (list == NULL) {
+        return NULL;
+    }
+
+    array->list = list;
+    array->size = new_size;
+
+    return list;
+}
+
+void *
+lexbor_array_obj_push(lexbor_array_obj_t *array)
+{
+    void *entry;
+
+    if (array->length >= array->size)
+    {
+        if ((lexbor_array_obj_expand(array, 128) == NULL)) {
+            return NULL;
+        }
+    }
+
+    entry = array->list + (array->length * array->struct_size);
+    array->length++;
+
+    memset(entry, 0, sizeof(array->struct_size));
+
+    return entry;
+}
+
+void *
+lexbor_array_obj_push_wo_cls(lexbor_array_obj_t *array)
+{
+    void *entry;
+
+    if (array->length >= array->size) {
+        if ((lexbor_array_obj_expand(array, 128) == NULL)) {
+            return NULL;
+        }
+    }
+
+    entry = array->list + (array->length * array->struct_size);
+    array->length++;
+
+    return entry;
+}
+
+void *
+lexbor_array_obj_push_n(lexbor_array_obj_t *array, size_t count)
+{
+    void *entry;
+
+    if ((array->length + count) > array->size) {
+        if ((lexbor_array_obj_expand(array, count + 128) == NULL)) {
+            return NULL;
+        }
+    }
+
+    entry = array->list + (array->length * array->struct_size);
+    array->length += count;
+
+    return entry;
+}
+
+void *
+lexbor_array_obj_pop(lexbor_array_obj_t *array)
+{
+    if (array->length == 0) {
+        return NULL;
+    }
+
+    array->length--;
+    return array->list + (array->length * array->struct_size);
+}
+
+void
+lexbor_array_obj_delete(lexbor_array_obj_t *array, size_t begin, size_t length)
+{
+    if (begin >= array->length || length == 0) {
+        return;
+    }
+
+    size_t end_len = begin + length;
+
+    if (end_len >= array->length) {
+        array->length = begin;
+        return;
+    }
+
+    memmove(&array->list[ begin * array->struct_size ],
+            &array->list[ end_len * array->struct_size ],
+            sizeof(uint8_t *)
+            * ((array->length - end_len) * array->struct_size));
+
+    array->length -= length;
+}
+
+/*
+ * No inline functions.
+ */
+void
+lexbor_array_obj_erase_noi(lexbor_array_obj_t *array)
+{
+    lexbor_array_obj_erase(array);
+}
+
+void *
+lexbor_array_obj_get_noi(lexbor_array_obj_t *array, size_t idx)
+{
+    return lexbor_array_obj_get(array, idx);
+}
+
+size_t
+lexbor_array_obj_length_noi(lexbor_array_obj_t *array)
+{
+    return lexbor_array_obj_length(array);
+}
+
+size_t
+lexbor_array_obj_size_noi(lexbor_array_obj_t *array)
+{
+    return lexbor_array_obj_size(array);
+}
+
+size_t
+lexbor_array_obj_struct_size_noi(lexbor_array_obj_t *array)
+{
+    return lexbor_array_obj_struct_size(array);
+}
+
+void *
+lexbor_array_obj_last_noi(lexbor_array_obj_t *array)
+{
+    return lexbor_array_obj_last(array);
+}