nokolexbor 0.2.0

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

@@ -0,0 +1,617 @@
+/*
+ * Copyright (C) 2018 Alexander Borisov
+ *
+ * Author: Alexander Borisov <borisov@lexbor.com>
+ */
+
+#include "lexbor/core/str.h"
+
+#define LEXBOR_STR_RES_ANSI_REPLACEMENT_CHARACTER
+#define LEXBOR_STR_RES_MAP_LOWERCASE
+#define LEXBOR_STR_RES_MAP_UPPERCASE
+#include "lexbor/core/str_res.h"
+
+
+lexbor_str_t *
+lexbor_str_create(void)
+{
+    return lexbor_calloc(1, sizeof(lexbor_str_t));
+}
+
+lxb_char_t *
+lexbor_str_init(lexbor_str_t *str, lexbor_mraw_t *mraw, size_t size)
+{
+    if (str == NULL) {
+        return NULL;
+    }
+
+    str->data = lexbor_mraw_alloc(mraw, (size + 1));
+    str->length = 0;
+
+    if (str->data != NULL) {
+        *str->data = '\0';
+    }
+
+    return str->data;
+}
+
+void
+lexbor_str_clean(lexbor_str_t *str)
+{
+    str->length = 0;
+}
+
+void
+lexbor_str_clean_all(lexbor_str_t *str)
+{
+    memset(str, 0, sizeof(lexbor_str_t));
+}
+
+lexbor_str_t *
+lexbor_str_destroy(lexbor_str_t *str, lexbor_mraw_t *mraw, bool destroy_obj)
+{
+    if (str == NULL) {
+        return NULL;
+    }
+
+    if (str->data != NULL) {
+        str->data = lexbor_mraw_free(mraw, str->data);
+    }
+
+    if (destroy_obj) {
+        return lexbor_free(str);
+    }
+
+    return str;
+}
+
+lxb_char_t *
+lexbor_str_realloc(lexbor_str_t *str, lexbor_mraw_t *mraw, size_t new_size)
+{
+    lxb_char_t *tmp = lexbor_mraw_realloc(mraw, str->data, new_size);
+    if (tmp == NULL) {
+        return NULL;
+    }
+
+    str->data = tmp;
+
+    return tmp;
+}
+
+lxb_char_t *
+lexbor_str_check_size(lexbor_str_t *str, lexbor_mraw_t *mraw, size_t plus_len)
+{
+    lxb_char_t *tmp;
+
+    if (str->length > (SIZE_MAX - plus_len)) {
+        return NULL;
+    }
+
+    if ((str->length + plus_len) <= lexbor_str_size(str)) {
+        return str->data;
+    }
+
+    tmp = lexbor_mraw_realloc(mraw, str->data, (str->length + plus_len));
+    if (tmp == NULL) {
+        return NULL;
+    }
+
+    str->data = tmp;
+
+    return tmp;
+}
+
+/* Append API */
+lxb_char_t *
+lexbor_str_append(lexbor_str_t *str, lexbor_mraw_t *mraw,
+                  const lxb_char_t *buff, size_t length)
+{
+    lxb_char_t *data_begin;
+
+    lexbor_str_check_size_arg_m(str, lexbor_str_size(str),
+                                mraw, (length + 1), NULL);
+
+    data_begin = &str->data[str->length];
+    memcpy(data_begin, buff, sizeof(lxb_char_t) * length);
+
+    str->length += length;
+    str->data[str->length] = '\0';
+
+    return data_begin;
+}
+
+lxb_char_t *
+lexbor_str_append_before(lexbor_str_t *str, lexbor_mraw_t *mraw,
+                         const lxb_char_t *buff, size_t length)
+{
+    lxb_char_t *data_begin;
+
+    lexbor_str_check_size_arg_m(str, lexbor_str_size(str),
+                                mraw, (length + 1), NULL);
+
+    data_begin = &str->data[str->length];
+
+    memmove(&str->data[length], str->data, sizeof(lxb_char_t) * str->length);
+    memcpy(str->data, buff, sizeof(lxb_char_t) * length);
+
+    str->length += length;
+    str->data[str->length] = '\0';
+
+    return data_begin;
+}
+
+lxb_char_t *
+lexbor_str_append_one(lexbor_str_t *str, lexbor_mraw_t *mraw,
+                      const lxb_char_t data)
+{
+    lexbor_str_check_size_arg_m(str, lexbor_str_size(str), mraw, 2, NULL);
+
+    str->data[str->length] = data;
+
+    str->length += 1;
+    str->data[str->length] = '\0';
+
+    return &str->data[(str->length - 1)];
+}
+
+lxb_char_t *
+lexbor_str_append_lowercase(lexbor_str_t *str, lexbor_mraw_t *mraw,
+                            const lxb_char_t *data, size_t length)
+{
+    size_t i;
+    lxb_char_t *data_begin;
+
+    lexbor_str_check_size_arg_m(str, lexbor_str_size(str),
+                                mraw, (length + 1), NULL);
+
+    data_begin = &str->data[str->length];
+
+    for (i = 0; i < length; i++) {
+        data_begin[i] = lexbor_str_res_map_lowercase[ data[i] ];
+    }
+
+    data_begin[i] = '\0';
+    str->length += length;
+
+    return data_begin;
+}
+
+lxb_char_t *
+lexbor_str_append_with_rep_null_chars(lexbor_str_t *str, lexbor_mraw_t *mraw,
+                                      const lxb_char_t *buff, size_t length)
+{
+    const lxb_char_t *pos, *res, *end;
+    size_t current_len = str->length;
+
+    lexbor_str_check_size_arg_m(str, lexbor_str_size(str),
+                                mraw, (length + 1), NULL);
+    end = buff + length;
+
+    while (buff != end) {
+        pos = memchr(buff, '\0', sizeof(lxb_char_t) * (end - buff));
+        if (pos == NULL) {
+            break;
+        }
+
+        res = lexbor_str_append(str, mraw, buff, (pos - buff));
+        if (res == NULL) {
+            return NULL;
+        }
+
+        res = lexbor_str_append(str, mraw,
+                         lexbor_str_res_ansi_replacement_character,
+                         sizeof(lexbor_str_res_ansi_replacement_character) - 1);
+        if (res == NULL) {
+            return NULL;
+        }
+
+        buff = pos + 1;
+    }
+
+    if (buff != end) {
+        res = lexbor_str_append(str, mraw, buff, (end - buff));
+        if (res == NULL) {
+            return NULL;
+        }
+    }
+
+    return &str->data[current_len];
+}
+
+lxb_char_t *
+lexbor_str_copy(lexbor_str_t *dest, const lexbor_str_t *target,
+                lexbor_mraw_t *mraw)
+{
+    if (target->data == NULL) {
+        return NULL;
+    }
+
+    if (dest->data == NULL) {
+        lexbor_str_init(dest, mraw, target->length);
+
+        if (dest->data == NULL) {
+            return NULL;
+        }
+    }
+
+    return lexbor_str_append(dest, mraw, target->data, target->length);
+}
+
+void
+lexbor_str_stay_only_whitespace(lexbor_str_t *target)
+{
+    size_t i, pos = 0;
+    lxb_char_t *data = target->data;
+
+    for (i = 0; i < target->length; i++) {
+        if (lexbor_utils_whitespace(data[i], ==, ||)) {
+            data[pos] = data[i];
+            pos++;
+        }
+    }
+
+    target->length = pos;
+}
+
+void
+lexbor_str_strip_collapse_whitespace(lexbor_str_t *target)
+{
+    size_t i, offset, ws_i;
+    lxb_char_t *data = target->data;
+
+    if (target->length == 0) {
+        return;
+    }
+
+    if (lexbor_utils_whitespace(*data, ==, ||)) {
+        *data = 0x20;
+    }
+
+    for (i = 0, offset = 0, ws_i = 0; i < target->length; i++)
+    {
+        if (lexbor_utils_whitespace(data[i], ==, ||)) {
+            if (data[ws_i] != 0x20) {
+                data[offset] = 0x20;
+
+                ws_i = offset;
+                offset++;
+            }
+        }
+        else {
+            if (data[ws_i] == 0x20) {
+                ws_i = offset;
+            }
+
+            data[offset] = data[i];
+            offset++;
+        }
+    }
+
+    if (offset != i) {
+        if (offset != 0) {
+            if (data[offset - 1] == 0x20) {
+                offset--;
+            }
+        }
+
+        data[offset] = 0x00;
+        target->length = offset;
+    }
+}
+
+size_t
+lexbor_str_crop_whitespace_from_begin(lexbor_str_t *target)
+{
+    size_t i;
+    lxb_char_t *data = target->data;
+
+    for (i = 0; i < target->length; i++) {
+        if (lexbor_utils_whitespace(data[i], !=, &&)) {
+            break;
+        }
+    }
+
+    if (i != 0 && i != target->length) {
+        memmove(target->data, &target->data[i], (target->length - i));
+    }
+
+    target->length -= i;
+    return i;
+}
+
+size_t
+lexbor_str_whitespace_from_begin(lexbor_str_t *target)
+{
+    size_t i;
+    lxb_char_t *data = target->data;
+
+    for (i = 0; i < target->length; i++) {
+        if (lexbor_utils_whitespace(data[i], !=, &&)) {
+            break;
+        }
+    }
+
+    return i;
+}
+
+size_t
+lexbor_str_whitespace_from_end(lexbor_str_t *target)
+{
+    size_t i = target->length;
+    lxb_char_t *data = target->data;
+
+    while (i) {
+        i--;
+
+        if (lexbor_utils_whitespace(data[i], !=, &&)) {
+            return target->length - (i + 1);
+        }
+    }
+
+    return 0;
+}
+
+/*
+ * Data utils
+ * TODO: All functions need optimization.
+ */
+const lxb_char_t *
+lexbor_str_data_ncasecmp_first(const lxb_char_t *first, const lxb_char_t *sec,
+                               size_t sec_size)
+{
+    size_t i;
+
+    for (i = 0; i < sec_size; i++) {
+        if (first[i] == '\0') {
+            return &first[i];
+        }
+
+        if (lexbor_str_res_map_lowercase[ first[i] ]
+            != lexbor_str_res_map_lowercase[ sec[i] ])
+        {
+            return NULL;
+        }
+    }
+
+    return &first[i];
+}
+
+bool
+lexbor_str_data_ncasecmp_end(const lxb_char_t *first, const lxb_char_t *sec,
+                             size_t size)
+{
+    while (size != 0) {
+        size--;
+
+        if (lexbor_str_res_map_lowercase[ first[size] ]
+            != lexbor_str_res_map_lowercase[ sec[size] ])
+        {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+bool
+lexbor_str_data_ncasecmp_contain(const lxb_char_t *where, size_t where_size,
+                                 const lxb_char_t *what, size_t what_size)
+{
+    for (size_t i = 0; what_size <= (where_size - i); i++) {
+        if(lexbor_str_data_ncasecmp(&where[i], what, what_size)) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+bool
+lexbor_str_data_ncasecmp(const lxb_char_t *first, const lxb_char_t *sec,
+                         size_t size)
+{
+    for (size_t i = 0; i < size; i++) {
+        if (lexbor_str_res_map_lowercase[ first[i] ]
+            != lexbor_str_res_map_lowercase[ sec[i] ])
+        {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+bool
+lexbor_str_data_nlocmp_right(const lxb_char_t *first, const lxb_char_t *sec,
+                             size_t size)
+{
+    for (size_t i = 0; i < size; i++) {
+        if (first[i] != lexbor_str_res_map_lowercase[ sec[i] ]) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+bool
+lexbor_str_data_nupcmp_right(const lxb_char_t *first, const lxb_char_t *sec,
+                             size_t size)
+{
+    for (size_t i = 0; i < size; i++) {
+        if (first[i] != lexbor_str_res_map_uppercase[ sec[i] ]) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+bool
+lexbor_str_data_casecmp(const lxb_char_t *first, const lxb_char_t *sec)
+{
+    for (;;) {
+        if (lexbor_str_res_map_lowercase[*first]
+            != lexbor_str_res_map_lowercase[*sec])
+        {
+            return false;
+        }
+
+        if (*first == '\0') {
+            return true;
+        }
+
+        first++;
+        sec++;
+    }
+}
+
+bool
+lexbor_str_data_ncmp_end(const lxb_char_t *first, const lxb_char_t *sec,
+                         size_t size)
+{
+    while (size != 0) {
+        size--;
+
+        if (first[size] != sec[size]) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+bool
+lexbor_str_data_ncmp_contain(const lxb_char_t *where, size_t where_size,
+                             const lxb_char_t *what, size_t what_size)
+{
+    for (size_t i = 0; what_size <= (where_size - i); i++) {
+        if(memcmp(&where[i], what, sizeof(lxb_char_t) * what_size) == 0) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+bool
+lexbor_str_data_ncmp(const lxb_char_t *first, const lxb_char_t *sec,
+                     size_t size)
+{
+    return memcmp(first, sec, sizeof(lxb_char_t) * size) == 0;
+}
+
+bool
+lexbor_str_data_cmp(const lxb_char_t *first, const lxb_char_t *sec)
+{
+    for (;;) {
+        if (*first != *sec) {
+            return false;
+        }
+
+        if (*first == '\0') {
+            return true;
+        }
+
+        first++;
+        sec++;
+    }
+}
+
+bool
+lexbor_str_data_cmp_ws(const lxb_char_t *first, const lxb_char_t *sec)
+{
+    for (;;) {
+        if (*first != *sec) {
+            return false;
+        }
+
+        if (lexbor_utils_whitespace(*first, ==, ||) || *first == '\0') {
+            return true;
+        }
+
+        first++;
+        sec++;
+    }
+}
+
+void
+lexbor_str_data_to_lowercase(lxb_char_t *to, const lxb_char_t *from, size_t len)
+{
+    while (len) {
+        len--;
+
+        to[len] = lexbor_str_res_map_lowercase[ from[len] ];
+    }
+}
+
+void
+lexbor_str_data_to_uppercase(lxb_char_t *to, const lxb_char_t *from, size_t len)
+{
+    while (len) {
+        len--;
+
+        to[len] = lexbor_str_res_map_uppercase[ from[len] ];
+    }
+}
+
+const lxb_char_t *
+lexbor_str_data_find_lowercase(const lxb_char_t *data, size_t len)
+{
+    while (len) {
+        len--;
+
+        if (data[len] == lexbor_str_res_map_lowercase[ data[len] ]) {
+            return &data[len];
+        }
+    }
+
+    return NULL;
+}
+
+const lxb_char_t *
+lexbor_str_data_find_uppercase(const lxb_char_t *data, size_t len)
+{
+    while (len) {
+        len--;
+
+        if (data[len] == lexbor_str_res_map_uppercase[ data[len] ]) {
+            return &data[len];
+        }
+    }
+
+    return NULL;
+}
+
+/*
+ * No inline functions for ABI.
+ */
+lxb_char_t *
+lexbor_str_data_noi(lexbor_str_t *str)
+{
+    return lexbor_str_data(str);
+}
+
+size_t
+lexbor_str_length_noi(lexbor_str_t *str)
+{
+    return lexbor_str_length(str);
+}
+
+size_t
+lexbor_str_size_noi(lexbor_str_t *str)
+{
+    return lexbor_str_size(str);
+}
+
+void
+lexbor_str_data_set_noi(lexbor_str_t *str, lxb_char_t *data)
+{
+    lexbor_str_data_set(str, data);
+}
+
+lxb_char_t *
+lexbor_str_length_set_noi(lexbor_str_t *str, lexbor_mraw_t *mraw, size_t length)
+{
+    return lexbor_str_length_set(str, mraw, length);
+}