removed libtoml allocator

.vscode/launch.json

@@ -5,8 +5,8 @@
             "name": "gdb_debug",
             "type": "cppdbg",
             "request": "launch",
-            "program": "${workspaceFolder}/bin/tlibtoml",
-            "windows": { "program": "${workspaceFolder}/bin/tlibtoml.exe" },
+            "program": "${workspaceFolder}/bin/test",
+            "windows": { "program": "${workspaceFolder}/bin/test.exe" },
             "preLaunchTask": "build_exec_dbg",
             "stopAtEntry": false,
             "cwd": "${workspaceFolder}/bin",

dependencies/tlibc.config

@@ -9,7 +9,7 @@ if [[ "$TASK" = *_dbg ]]; then
 else
     dep_build_target="build_static_lib"
 fi
-DEP_PRE_BUILD_COMMAND="setup_user_config"
+DEP_PRE_BUILD_COMMAND=""
 DEP_BUILD_COMMAND="cbuild $dep_build_target"
 DEP_POST_BUILD_COMMAND=""
 DEP_CLEAN_COMMAND="cbuild clean"

include/tlibtoml/toml.h

@@ -8,21 +8,13 @@
 extern "C" {
 #endif
 
-#include "tlibc/std.h"
 #include <time.h>
+#include "tlibc/std.h"
+#include "tlibc/string/str.h"
+#include "tlibc/collections/HashMap.h"
 
-#if defined(__cplusplus) && __cplusplus >= 201103L
-#define ATTRIBUTE_THREAD_LOCAL thread_local
-#elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
-#define ATTRIBUTE_THREAD_LOCAL _Thread_local
-#elif defined(_MSC_VER)
-#define ATTRIBUTE_THREAD_LOCAL __declspec(thread)
-#else
-#define ATTRIBUTE_THREAD_LOCAL __thread
-#endif
-
-#define TOML_FALSE  0
-#define TOML_TRUE   1
+typedef struct tm TomlDateTime;
+typedef HashMap(TomlValue) TomlTable;
 
 typedef enum {
     TOML_OK,
@@ -35,38 +27,20 @@ typedef enum {
 
 typedef struct {
     TomlErrCode     code;
-    char*           message;
-    int             _is_literal;
+    NULLABLE(char*) message;
 } TomlErr;
 
-typedef struct {
-    char*   str;
-    size_t  len;
-    size_t  _capacity;
-} TomlString;
-
-typedef struct _TomlValue TomlValue;
+typedef struct TomlValue TomlValue;
 
 typedef struct {
-    TomlValue**     elements;
-    size_t          len;
-    size_t          _capacity;
+    TomlValue*  elements;
+    u64         len;
+    u64         _capacity;
 } TomlArray;
 
-typedef struct _TomlKeyValue TomlKeyValue;
-
-typedef struct {
-    size_t          _capacity;
-    size_t          len;
-    TomlKeyValue*   _keyvals;
-} TomlTable;
-
-typedef struct {
-    TomlTable*      _table;
-    TomlKeyValue*   _keyval;
-} TomlTableIter;
 
 typedef enum {
+    TOML_INVALID_TYPE,
     TOML_TABLE,
     TOML_ARRAY,
     TOML_STRING,
@@ -76,113 +50,58 @@ typedef enum {
     TOML_BOOLEAN,
 } TomlType;
 
-struct _TomlValue {
+struct TomlValue {
     TomlType  type;
     union {
         TomlTable*      table;
         TomlArray*      array;
-        TomlString*     string;
-#if defined(_MSC_VER) || defined(__APPLE__)
-        long long       integer;
-#else
-        long            integer;
-#endif
-        double          float_;
-        struct tm       datetime;
-        int             boolean;
+        str             s;
+        i64             i;
+        f64             f;
+        TomlDateTime*   dt;
+        bool            b;
     } value;
 };
 
-struct _TomlKeyValue {
-    TomlString*     key;
-    TomlValue*      value;
-};
-
-typedef struct {
-    void*   (*malloc)(void *context, size_t size);
-    void*   (*realloc)(void *context, void *p, size_t size);
-    void    (*free)(void *context, void *p);
-} TomlAllocFuncs;
-
-void toml_set_allocator(void *context, const TomlAllocFuncs *funcs);
-
-void* toml_malloc(size_t size);
-void* toml_realloc(void *p, size_t size);
-void toml_free(void *p);
-
-char* toml_strdup(const char *str);
-char* toml_strndup(const char *str, size_t n);
-int toml_vasprintf(char **str, const char *format, va_list args);
-int toml_asprintf(char **str, const char *format, ...);
-
 const TomlErr* toml_err(void);
 void toml_err_clear(void);
 
-TomlString* toml_string_new(void);
-TomlString* toml_string_from_str(const char *str);
-TomlString* toml_string_from_nstr(const char *str, size_t len);
-void toml_string_append_char(TomlString *self, char ch);
-void toml_string_append_str(TomlString *self, const char *str);
-void toml_string_append_nstr(TomlString *self, const char *str, size_t len);
-TomlString* toml_string_clone(const TomlString *self);
-void toml_string_free(TomlString *self);
-int toml_string_equals(const TomlString *self, const TomlString *other);
 
 TomlTable* toml_table_new(void);
-void toml_table_free(TomlTable *self);
+void toml_table_free(TomlTable* self);
 
-void toml_table_set_by_string(TomlTable *self, TomlString *key, TomlValue *value);
-TomlValue *toml_table_get_by_string(const TomlTable *self, const TomlString *key);
-void toml_table_set(TomlTable *self, const char *key, TomlValue *value);
-void toml_table_setn(TomlTable *self, const char *key, size_t key_len, TomlValue *value);
-TomlValue* toml_table_get(const TomlTable *self, const char *key);
-TomlTable* toml_table_get_as_table(const TomlTable *self, const char *key);
-TomlArray* toml_table_get_as_array(const TomlTable *self, const char *key);
-TomlString* toml_table_get_as_string(const TomlTable *self, const char *key);
-#if defined(_MSC_VER) || defined(__APPLE__)
-long long toml_table_get_as_integer(const TomlTable *self, const char *key);
-#else
-long toml_table_get_as_integer(const TomlTable *self, const char *key);
-#endif
-double toml_table_get_as_float(const TomlTable *self, const char *key);
-const struct tm* toml_table_get_as_datetime(const TomlTable *self, const char *key);
-int toml_table_get_as_boolean(const TomlTable *self, const char *key);
-TomlValue* toml_table_getn(const TomlTable *self, const char *key, size_t key_len);
-
-TomlTableIter toml_table_iter_new(TomlTable *table);
-TomlKeyValue* toml_table_iter_get(TomlTableIter *self);
-int toml_table_iter_has_next(TomlTableIter *self);
-void toml_table_iter_next(TomlTableIter *self);
+void toml_table_set(TomlTable* self, str key, TomlValue value);
+TomlValue* toml_table_get(const TomlTable* self, str key);
+TomlTable* toml_table_get_table(const TomlTable* self, str key);
+TomlArray* toml_table_get_array(const TomlTable* self, str key);
+str toml_table_get_str(const TomlTable* self, str key);
+i64 toml_table_get_integer(const TomlTable* self, str key);
+f64 toml_table_get_float(const TomlTable* self, str key);
+TomlDateTime* toml_table_get_datetime(const TomlTable* self, str key);
+bool toml_table_get_bool(const TomlTable* self, str key);
 
 TomlArray* toml_array_new(void);
-void toml_array_free(TomlArray *self);
-void toml_array_append(TomlArray *self, TomlValue *value);
+void toml_array_free(TomlArray* self);
+void toml_array_append(TomlArray* self, TomlValue value);
 
-TomlValue* toml_value_new(TomlType type);
-TomlValue* toml_value_new_string(TomlType type);
-TomlValue* toml_value_new_table(void);
-TomlValue* toml_value_new_array(void);
-#if defined(_MSC_VER) || defined(__APPLE__)
-TomlValue *toml_value_new_integer(long long integer);
-#else
-TomlValue *toml_value_new_integer(long integer);
-#endif
-TomlValue* toml_value_new_float(double flt);
-TomlValue* toml_value_new_datetime(void);
-TomlValue* toml_value_new_boolean(int boolean);
-TomlValue* toml_value_from_str(const char *str);
-TomlValue* toml_value_from_nstr(const char *str, size_t len);
-void toml_value_free(TomlValue *self);
+TomlValue TomlValue_new(TomlType type);
+TomlValue TomlValue_new_string(TomlType type);
+TomlValue TomlValue_new_table(void);
+TomlValue TomlValue_new_array(void);
+TomlValue TomlValue_new_integer(i64 integer);
+TomlValue TomlValue_new_float(f64 flt);
+TomlValue TomlValue_new_datetime(void);
+TomlValue TomlValue_new_bool(bool b);
+TomlValue TomlValue_from_str(str s);
+void TomlValue_destroy(TomlValue* self);
 
-TomlTable* toml_load_str(const char *str);
-TomlTable* toml_load_nstr(const char *str, size_t len);
-TomlTable* toml_load_file(FILE *file);
-TomlTable* toml_load_filename(const char *filename);
+TomlTable* toml_load_str(str s);
+TomlTable* toml_load_file(FILE* file);
+TomlTable* toml_load_filename(cstr filename);
 
 /* TODO: implement dump functions
-char *toml_dump_str(const TomlTable *self, TomlErr *err);
-TomlString *toml_dump_nstr(const TomlTable *self, TomlErr *err);
-void toml_dump_file(const TomlTable *self, FILE *file, TomlErr *err);
+str toml_dump_str(const TomlTable* self, TomlErr *err);
+void toml_dump_file(const TomlTable* self, FILE* file, TomlErr *err);
 */
 
 #ifdef __cplusplus

tests/main.c

@@ -3,30 +3,34 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include <inttypes.h>
+#include <assert.h>
 #include "tlibtoml/toml.h"
 
 #ifndef PROJECT_SOURCE_DIR
 #define PROJECT_SOURCE_DIR ".."
 #endif
 
-void print_table(const TomlTable *table);
-void print_value(const TomlValue *value);
+void print_table(const TomlTable* table);
+void print_value(const TomlValue* value);
 
 void print_array(const TomlArray *array)
 {
     printf("[");
-    for (size_t i = 0; i < array->len; i++) {
+    for (u64 i = 0; i < array->len; i++) {
         if (i > 0) {
             printf(", ");
         }
-        print_value(array->elements[i]);
+        print_value(&array->elements[i]);
     }
     printf("]");
 }
 
-void print_value(const TomlValue *value)
+void print_value(const TomlValue* value)
 {
     switch (value->type) {
+        default:
+            assert(false && "invalid type");
+            break;
         case TOML_TABLE:
             print_table(value->value.table);
             break;
@@ -34,53 +38,50 @@ void print_value(const TomlValue *value)
             print_array(value->value.array);
             break;
         case TOML_STRING:
-            printf("\"%s\"", value->value.string->str);
+            printf("\"%s\"", value->value.s.data);
             break;
         case TOML_INTEGER:
-            printf("%" PRId64, value->value.integer);
+            printf("%" PRId64, value->value.i);
             break;
         case TOML_FLOAT:
-            printf("%f", value->value.float_);
+            printf("%f", value->value.f);
             break;
         case TOML_DATETIME:
             printf("(datetime)");
             break;
         case TOML_BOOLEAN:
-            printf("%s", value->value.boolean ? "true" : "false");
+            printf("%s", value->value.b ? "true" : "false");
             break;
     }
 }
 
-void print_keyval(const TomlKeyValue *keyval)
+void print_keyval(HashMapKeyValue* keyval)
 {
-    printf("\"%s\": ", keyval->key->str);
+    printf("\"%s\": ", keyval->key.data);
     print_value(keyval->value);
 }
 
-void print_table(const TomlTable *table)
+void print_table(const TomlTable* table)
 {
-    TomlTableIter it = toml_table_iter_new((TomlTable *)table);
+    HashMapIter it = HashMapIter_create(table);
 
     printf("{");
-    size_t i = 0;
-    while (toml_table_iter_has_next(&it)) {
-        TomlKeyValue *keyval = toml_table_iter_get(&it);
-
-        if (i > 0) {
+    u64 i = 0;
+    HashMapKeyValue keyval;
+    while (HashMapIter_moveNext(&it)) {
+        assert(HashMapIter_getCurrent(&it, &keyval));
+        if (i > 0)
             printf(", ");
-        }
-        print_keyval(keyval);
-
-        toml_table_iter_next(&it);
+        print_keyval(&keyval);
         i++;
     }
     printf("}");
 }
 
-int test_run(const char *filename)
+i32 test_run(cstr filename)
 {
-    TomlTable *table = NULL;
-    int rc = 0;
+    TomlTable* table = NULL;
+    i32 rc = 0;
 
     table = toml_load_filename(filename);
     if (table == NULL)
@@ -94,15 +95,15 @@ cleanup:
 
     if (toml_err()->code != TOML_OK) {
         fprintf(stderr, "%s\n", toml_err()->message);
-        rc = (int)toml_err()->code;
+        rc = (i32)toml_err()->code;
     }
     toml_err_clear();
     return rc;
 }
 
-int main(void)
+i32 main(void)
 {
-    static const char *const filenames[] = {
+    static cstr const filenames[] = {
         /* should parse */
         PROJECT_SOURCE_DIR "/tests/key-values.toml",
         PROJECT_SOURCE_DIR "/tests/complex-structure.toml",
@@ -117,12 +118,12 @@ int main(void)
         PROJECT_SOURCE_DIR "/tests/hard_example_unicode.toml"
     };
 
-    int total_tests = sizeof(filenames) / sizeof(char *);
-    int num_passed = 0;
-    int num_failed = 0;
+    i32 total_tests = sizeof(filenames) / sizeof(char*);
+    i32 num_passed = 0;
+    i32 num_failed = 0;
 
-    for (int i = 0; i < total_tests; i++) {
-        int rc = test_run(filenames[i]);
+    for (i32 i = 0; i < total_tests; i++) {
+        i32 rc = test_run(filenames[i]);
         if (rc == 0) {
             printf("test %d success\n", i);
             num_passed++;