nokolexbor 0.2.0

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

@@ -0,0 +1,267 @@
+/*
+ * Copyright (C) 2018 Alexander Borisov
+ *
+ * Author: Alexander Borisov <borisov@lexbor.com>
+ */
+
+#include "lexbor/core/in.h"
+#include "lexbor/core/str_res.h"
+
+
+lexbor_in_t *
+lexbor_in_create(void)
+{
+    return lexbor_calloc(1, sizeof(lexbor_in_t));
+}
+
+lxb_status_t
+lexbor_in_init(lexbor_in_t *incoming, size_t chunk_size)
+{
+    if (incoming == NULL) {
+        return LXB_STATUS_ERROR_OBJECT_IS_NULL;
+    }
+
+    if (chunk_size == 0) {
+        return LXB_STATUS_ERROR_WRONG_ARGS;
+    }
+
+    incoming->nodes = lexbor_dobject_create();
+
+    return lexbor_dobject_init(incoming->nodes, chunk_size,
+                               sizeof(lexbor_in_node_t));
+}
+
+void
+lexbor_in_clean(lexbor_in_t *incoming)
+{
+    lexbor_dobject_clean(incoming->nodes);
+}
+
+lexbor_in_t *
+lexbor_in_destroy(lexbor_in_t *incoming, bool self_destroy)
+{
+    if (incoming == NULL) {
+        return NULL;
+    }
+
+    incoming->nodes = lexbor_dobject_destroy(incoming->nodes, true);
+
+    if (self_destroy == true) {
+        return lexbor_free(incoming);
+    }
+
+    return incoming;
+}
+
+lexbor_in_node_t *
+lexbor_in_node_make(lexbor_in_t *incoming, lexbor_in_node_t *last_node,
+                    const lxb_char_t *buf, size_t buf_size)
+{
+    lexbor_in_node_t *node = lexbor_dobject_alloc(incoming->nodes);
+
+    if (node == NULL) {
+        return NULL;
+    }
+
+    node->opt = LEXBOR_IN_OPT_UNDEF;
+    node->begin = buf;
+    node->end = buf + buf_size;
+    node->use = buf;
+
+    if (last_node != NULL) {
+        last_node->next = node;
+        node->offset = last_node->offset + (last_node->end - last_node->begin);
+    }
+    else {
+        node->offset = 0;
+    }
+
+    node->prev = last_node;
+    node->next = NULL;
+    node->incoming = incoming;
+
+    return node;
+}
+
+void
+lexbor_in_node_clean(lexbor_in_node_t *node)
+{
+    lexbor_in_t *incoming = node->incoming;
+
+    memset(node, 0, sizeof(lexbor_in_node_t));
+
+    node->incoming = incoming;
+}
+
+lexbor_in_node_t *
+lexbor_in_node_destroy(lexbor_in_t *incoming,
+                       lexbor_in_node_t *node, bool self_destroy)
+{
+    if (node == NULL) {
+        return NULL;
+    }
+
+    if (self_destroy) {
+        return lexbor_dobject_free(incoming->nodes, node);
+    }
+
+    return node;
+}
+
+lexbor_in_node_t *
+lexbor_in_node_split(lexbor_in_node_t *node, const lxb_char_t *pos)
+{
+    lexbor_in_node_t *new_node;
+
+    new_node = lexbor_dobject_alloc(node->incoming->nodes);
+
+    if (new_node == NULL) {
+        return NULL;
+    }
+
+    new_node->offset   = node->offset + (pos - node->begin);
+    new_node->opt      = LEXBOR_IN_OPT_UNDEF;
+    new_node->begin    = pos;
+    new_node->end      = node->end;
+    new_node->next     = NULL;
+    new_node->prev     = node;
+    new_node->incoming = node->incoming;
+
+    node->end  = pos;
+    node->next = new_node;
+
+    if (node->use > pos) {
+        new_node->use = node->use;
+        node->use = pos;
+    }
+    else {
+        new_node->use = pos;
+    }
+
+    return new_node;
+}
+
+lexbor_in_node_t *
+lexbor_in_node_find(lexbor_in_node_t *node, const lxb_char_t *pos)
+{
+    while (node->next) {
+        node = node->next;
+    }
+
+    while (node && (node->begin > pos || node->end < pos)) {
+        node = node->prev;
+    }
+
+    return node;
+}
+
+const lxb_char_t *
+lexbor_in_node_pos_up(lexbor_in_node_t *node, lexbor_in_node_t **return_node,
+                      const lxb_char_t *pos, size_t offset)
+{
+    do {
+        pos = pos + offset;
+
+        if (node->end >= pos) {
+            if (return_node != NULL && *return_node != node) {
+                *return_node = node;
+            }
+
+            return pos;
+        }
+
+        if (node->next == NULL) {
+            if (return_node != NULL && *return_node != node) {
+                *return_node = node;
+            }
+
+            return node->end;
+        }
+
+        offset = pos - node->end;
+        node = node->next;
+        pos = node->begin;
+
+    }
+    while (1);
+
+    return NULL;
+}
+
+const lxb_char_t *
+lexbor_in_node_pos_down(lexbor_in_node_t *node, lexbor_in_node_t **return_node,
+                        const lxb_char_t *pos, size_t offset)
+{
+    do {
+        pos = pos - offset;
+
+        if (node->begin <= pos) {
+            if (return_node != NULL && *return_node != node) {
+                *return_node = node;
+            }
+
+            return pos;
+        }
+
+        if (node->prev == NULL) {
+            if (return_node != NULL && *return_node != node) {
+                *return_node = node;
+            }
+
+            return node->begin;
+        }
+
+        offset = node->begin - pos;
+        node = node->prev;
+        pos = node->end;
+
+    }
+    while (1);
+
+    return NULL;
+}
+
+/*
+* No inline functions for ABI.
+*/
+const lxb_char_t *
+lexbor_in_node_begin_noi(const lexbor_in_node_t *node)
+{
+    return lexbor_in_node_begin(node);
+}
+
+const lxb_char_t *
+lexbor_in_node_end_noi(const lexbor_in_node_t *node)
+{
+    return lexbor_in_node_end(node);
+}
+
+size_t
+lexbor_in_node_offset_noi(const lexbor_in_node_t *node)
+{
+    return lexbor_in_node_offset(node);
+}
+
+lexbor_in_node_t *
+lexbor_in_node_next_noi(const lexbor_in_node_t *node)
+{
+    return lexbor_in_node_next(node);
+}
+
+lexbor_in_node_t *
+lexbor_in_node_prev_noi(const lexbor_in_node_t *node)
+{
+    return lexbor_in_node_prev(node);
+}
+
+lexbor_in_t *
+lexbor_in_node_in_noi(const lexbor_in_node_t *node)
+{
+    return lexbor_in_node_in(node);
+}
+
+bool
+lexbor_in_segment_noi(const lexbor_in_node_t *node, const lxb_char_t *data)
+{
+    return lexbor_in_segment(node, data);
+}

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

@@ -0,0 +1,172 @@
+/*
+ * Copyright (C) 2018 Alexander Borisov
+ *
+ * Author: Alexander Borisov <borisov@lexbor.com>
+ */
+
+#ifndef LEXBOR_IN_H
+#define LEXBOR_IN_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "lexbor/core/base.h"
+#include "lexbor/core/dobject.h"
+
+
+typedef struct lexbor_in_node lexbor_in_node_t;
+typedef int lexbor_in_opt_t;
+
+enum lexbor_in_opt {
+    LEXBOR_IN_OPT_UNDEF    = 0x00,
+    LEXBOR_IN_OPT_READONLY = 0x01,
+    LEXBOR_IN_OPT_DONE     = 0x02,
+    LEXBOR_IN_OPT_FAKE     = 0x04,
+    LEXBOR_IN_OPT_ALLOC    = 0x08
+};
+
+typedef struct {
+    lexbor_dobject_t *nodes;
+}
+lexbor_in_t;
+
+struct lexbor_in_node {
+    size_t            offset;
+    lexbor_in_opt_t   opt;
+
+    const lxb_char_t  *begin;
+    const lxb_char_t  *end;
+    const lxb_char_t  *use;
+
+    lexbor_in_node_t  *next;
+    lexbor_in_node_t  *prev;
+
+    lexbor_in_t       *incoming;
+};
+
+
+LXB_API lexbor_in_t *
+lexbor_in_create(void);
+
+LXB_API lxb_status_t
+lexbor_in_init(lexbor_in_t *incoming, size_t chunk_size);
+
+LXB_API void
+lexbor_in_clean(lexbor_in_t *incoming);
+
+LXB_API lexbor_in_t *
+lexbor_in_destroy(lexbor_in_t *incoming, bool self_destroy);
+
+
+LXB_API lexbor_in_node_t *
+lexbor_in_node_make(lexbor_in_t *incoming, lexbor_in_node_t *last_node,
+                    const lxb_char_t *buf, size_t buf_size);
+
+LXB_API void
+lexbor_in_node_clean(lexbor_in_node_t *node);
+
+LXB_API lexbor_in_node_t *
+lexbor_in_node_destroy(lexbor_in_t *incoming,
+                       lexbor_in_node_t *node, bool self_destroy);
+
+
+LXB_API lexbor_in_node_t *
+lexbor_in_node_split(lexbor_in_node_t *node, const lxb_char_t *pos);
+
+LXB_API lexbor_in_node_t *
+lexbor_in_node_find(lexbor_in_node_t *node, const lxb_char_t *pos);
+
+/**
+ * Get position by `offset`.
+ * If position outside of nodes return `begin` position of first node
+ * in nodes chain.
+ */
+LXB_API const lxb_char_t *
+lexbor_in_node_pos_up(lexbor_in_node_t *node, lexbor_in_node_t **return_node,
+                      const lxb_char_t *pos, size_t offset);
+
+/**
+ * Get position by `offset`.
+ * If position outside of nodes return `end`
+ * position of last node in nodes chain.
+ */
+LXB_API const lxb_char_t *
+lexbor_in_node_pos_down(lexbor_in_node_t *node, lexbor_in_node_t **return_node,
+                        const lxb_char_t *pos, size_t offset);
+
+/*
+ * Inline functions
+ */
+lxb_inline const lxb_char_t *
+lexbor_in_node_begin(const lexbor_in_node_t *node)
+{
+    return node->begin;
+}
+
+lxb_inline const lxb_char_t *
+lexbor_in_node_end(const lexbor_in_node_t *node)
+{
+    return node->end;
+}
+
+lxb_inline size_t
+lexbor_in_node_offset(const lexbor_in_node_t *node)
+{
+    return node->offset;
+}
+
+lxb_inline lexbor_in_node_t *
+lexbor_in_node_next(const lexbor_in_node_t *node)
+{
+    return node->next;
+}
+
+lxb_inline lexbor_in_node_t *
+lexbor_in_node_prev(const lexbor_in_node_t *node)
+{
+    return node->prev;
+}
+
+lxb_inline lexbor_in_t *
+lexbor_in_node_in(const lexbor_in_node_t *node)
+{
+    return node->incoming;
+}
+
+lxb_inline bool
+lexbor_in_segment(const lexbor_in_node_t *node, const lxb_char_t *data)
+{
+    return node->begin <= data && node->end >= data;
+}
+
+/*
+ * No inline functions for ABI.
+ */
+LXB_API const lxb_char_t *
+lexbor_in_node_begin_noi(const lexbor_in_node_t *node);
+
+LXB_API const lxb_char_t *
+lexbor_in_node_end_noi(const lexbor_in_node_t *node);
+
+LXB_API size_t
+lexbor_in_node_offset_noi(const lexbor_in_node_t *node);
+
+LXB_API lexbor_in_node_t *
+lexbor_in_node_next_noi(const lexbor_in_node_t *node);
+
+LXB_API lexbor_in_node_t *
+lexbor_in_node_prev_noi(const lexbor_in_node_t *node);
+
+LXB_API lexbor_in_t *
+lexbor_in_node_in_noi(const lexbor_in_node_t *node);
+
+LXB_API bool
+lexbor_in_segment_noi(const lexbor_in_node_t *node, const lxb_char_t *data);
+
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* LEXBOR_IN_H */

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

@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2018 Alexander Borisov
+ *
+ * Author: Alexander Borisov <borisov@lexbor.com>
+ */
+
+#ifndef LEXBOR_H
+#define LEXBOR_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "lexbor/core/def.h"
+
+
+LXB_API void *
+lexbor_malloc(size_t size);
+
+LXB_API void *
+lexbor_realloc(void *dst, size_t size);
+
+LXB_API void *
+lexbor_calloc(size_t num, size_t size);
+
+LXB_API void *
+lexbor_free(void *dst);
+
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* LEXBOR_H */
+

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

@@ -0,0 +1,228 @@
+/*
+ * Copyright (C) 2018 Alexander Borisov
+ *
+ * Author: Alexander Borisov <borisov@lexbor.com>
+ */
+
+#include "lexbor/core/mem.h"
+
+
+lexbor_mem_t *
+lexbor_mem_create(void)
+{
+    return lexbor_calloc(1, sizeof(lexbor_mem_t));
+}
+
+lxb_status_t
+lexbor_mem_init(lexbor_mem_t *mem, size_t min_chunk_size)
+{
+    if (mem == NULL) {
+        return LXB_STATUS_ERROR_OBJECT_IS_NULL;
+    }
+
+    if (min_chunk_size == 0) {
+        return LXB_STATUS_ERROR_WRONG_ARGS;
+    }
+
+    mem->chunk_min_size = lexbor_mem_align(min_chunk_size);
+
+    /* Create first chunk */
+    mem->chunk = lexbor_mem_chunk_make(mem, mem->chunk_min_size);
+    if (mem->chunk == NULL) {
+        return LXB_STATUS_ERROR_MEMORY_ALLOCATION;
+    }
+
+    mem->chunk_length = 1;
+    mem->chunk_first = mem->chunk;
+
+    return LXB_STATUS_OK;
+}
+
+void
+lexbor_mem_clean(lexbor_mem_t *mem)
+{
+    lexbor_mem_chunk_t *prev, *chunk;
+
+    if (mem == NULL) {
+        return;
+    }
+
+    chunk = mem->chunk;
+
+    while (chunk->prev) {
+        prev = chunk->prev;
+
+        chunk->data = lexbor_free(chunk->data);
+        lexbor_free(chunk);
+
+        chunk = prev;
+    }
+
+    chunk->next = NULL;
+    chunk->length = 0;
+
+    mem->chunk = mem->chunk_first;
+    mem->chunk_length = 1;
+}
+
+lexbor_mem_t *
+lexbor_mem_destroy(lexbor_mem_t *mem, bool destroy_self)
+{
+    lexbor_mem_chunk_t *chunk, *prev;
+
+    if (mem == NULL) {
+        return NULL;
+    }
+
+    /* Destroy all chunk */
+    if (mem->chunk) {
+        chunk = mem->chunk;
+
+        while (chunk) {
+            prev = chunk->prev;
+            lexbor_mem_chunk_destroy(mem, chunk, true);
+            chunk = prev;
+        }
+
+        mem->chunk = NULL;
+    }
+
+    if (destroy_self) {
+        return lexbor_free(mem);
+    }
+
+    return mem;
+}
+
+uint8_t *
+lexbor_mem_chunk_init(lexbor_mem_t *mem,
+                      lexbor_mem_chunk_t *chunk, size_t length)
+{
+    length = lexbor_mem_align(length);
+
+    if (length > mem->chunk_min_size) {
+        if (mem->chunk_min_size > (SIZE_MAX - length)) {
+            chunk->size = length;
+        }
+        else {
+            chunk->size = length + mem->chunk_min_size;
+        }
+    }
+    else {
+        chunk->size = mem->chunk_min_size;
+    }
+
+    chunk->length = 0;
+    chunk->data = lexbor_malloc(chunk->size * sizeof(uint8_t));
+
+    return chunk->data;
+}
+
+lexbor_mem_chunk_t *
+lexbor_mem_chunk_make(lexbor_mem_t *mem, size_t length)
+{
+    lexbor_mem_chunk_t *chunk = lexbor_calloc(1, sizeof(lexbor_mem_chunk_t));
+
+    if (chunk == NULL) {
+        return NULL;
+    }
+
+    if (lexbor_mem_chunk_init(mem, chunk, length) == NULL) {
+        return lexbor_free(chunk);
+    }
+
+    return chunk;
+}
+
+lexbor_mem_chunk_t *
+lexbor_mem_chunk_destroy(lexbor_mem_t *mem,
+                         lexbor_mem_chunk_t *chunk, bool self_destroy)
+{
+    if (chunk == NULL || mem == NULL) {
+        return NULL;
+    }
+
+    if (chunk->data) {
+        chunk->data = lexbor_free(chunk->data);
+    }
+
+    if (self_destroy) {
+        return lexbor_free(chunk);
+    }
+
+    return chunk;
+}
+
+void *
+lexbor_mem_alloc(lexbor_mem_t *mem, size_t length)
+{
+    if (length == 0) {
+        return NULL;
+    }
+
+    length = lexbor_mem_align(length);
+
+    if ((mem->chunk->length + length) > mem->chunk->size) {
+        if ((SIZE_MAX - mem->chunk_length) == 0) {
+            return NULL;
+        }
+
+        mem->chunk->next = lexbor_mem_chunk_make(mem, length);
+        if (mem->chunk->next == NULL) {
+            return NULL;
+        }
+
+        mem->chunk->next->prev = mem->chunk;
+        mem->chunk = mem->chunk->next;
+
+        mem->chunk_length++;
+    }
+
+    mem->chunk->length += length;
+
+    return &mem->chunk->data[(mem->chunk->length - length)];
+}
+
+void *
+lexbor_mem_calloc(lexbor_mem_t *mem, size_t length)
+{
+    void *data = lexbor_mem_alloc(mem, length);
+
+    if (data != NULL) {
+        memset(data, 0, length);
+    }
+
+    return data;
+}
+
+/*
+ * No inline functions for ABI.
+ */
+size_t
+lexbor_mem_current_length_noi(lexbor_mem_t *mem)
+{
+    return lexbor_mem_current_length(mem);
+}
+
+size_t
+lexbor_mem_current_size_noi(lexbor_mem_t *mem)
+{
+    return lexbor_mem_current_size(mem);
+}
+
+size_t
+lexbor_mem_chunk_length_noi(lexbor_mem_t *mem)
+{
+    return lexbor_mem_chunk_length(mem);
+}
+size_t
+lexbor_mem_align_noi(size_t size)
+{
+    return lexbor_mem_align(size);
+}
+
+size_t
+lexbor_mem_align_floor_noi(size_t size)
+{
+    return lexbor_mem_align_floor(size);
+}