fix sanitizer errors

Author: standardloop

.gitignore

@@ -55,7 +55,7 @@ dkms.conf
 main
 main-optimize
 main-debug
-lab-private
+private
 .vscode
 test
 notes.txt
@@ -65,3 +65,5 @@ json-sanitize
 test.c
 .task
 lab
+lab-sanitize
+hold.c

Taskfile.yml

@@ -12,11 +12,11 @@ vars:
     - hashmap.c
     - dynamicarray.c
   DYN_LIBS_USED_PATH: -L/usr/local/lib/standardloop
-  DYN_LIBS_USED: -lstandardloop-util
+  DYN_LIBS_USED: "-lstandardloop-util"
   DYLIB_NAME: libstandardloop-json.dylib
   DYLIB_PATH: /usr/local/lib/standardloop/
   DYLIB_INCLUDE_PATH: /usr/local/include/standardloop/
-  RELEASE_VERSION: 0.0.1
+  RELEASE_VERSION: 0.0.2
 
 # Inputs
 # - REPO_NAME
@@ -43,7 +43,7 @@ tasks:
       - cat json.h | grep -q {{.RELEASE_VERSION}}
       - cat json.h | grep -q "MAJOR_VERSION 0"
       - cat json.h | grep -q "MINOR_VERSION 0"
-      - cat json.h | grep -q "PATCH_VERSION 1"
+      - cat json.h | grep -q "PATCH_VERSION 2"
 
   dependencies:
     deps:
@@ -52,7 +52,7 @@ tasks:
   dependencies:util:
     vars:
       REPO_NAME: c-util
-      DYLIB_VERSION: 0.0.1
+      DYLIB_VERSION: 0.0.3
       DYLIB_NAME: util
     cmds:
       - sudo -v
@@ -84,7 +84,7 @@ tasks:
         -compatibility_version {{.RELEASE_VERSION}} \
         -o {{.DYLIB_NAME}}
     sources:
-      - ./json.c
+      - "*.c"
     generates:
       - "{{.DYLIB_NAME}}"
 
@@ -93,7 +93,7 @@ tasks:
       - release:build
     cmds:
       - sudo -v
-      - sudo cp {{.DYLIB_NAME}} {{.DYLIB_PATH}}
+      - sudo mv {{.DYLIB_NAME}} {{.DYLIB_PATH}}
       - sudo cp json.h {{.DYLIB_INCLUDE_PATH}}
 
   release:clean:
@@ -137,28 +137,57 @@ tasks:
         {{range .SOURCE_FILES}} {{.}} {{end}} \
         {{.DYN_LIBS_USED_PATH}} \
         {{.DYN_LIBS_USED}} \
-        -L/usr/local/lib/standardloop \
-        -fno-omit-frame-pointer \
+        -O0 \
+        -lstandardloop-json \
         -o {{.LAB_EXECUTABLE_NAME}}
     sources:
       - "*.c"
     generates:
       - "{{.LAB_EXECUTABLE_NAME}}"
+  
+  lab:sanitize:
+    deps:
+      - lab:run-sanitize
+
+  lab:build-sanitize:
+    run: once
+    cmds:
+      - |
+        {{.CC}} {{.CC_FLAGS}} \
+        lab.c \
+        {{range .SOURCE_FILES}} {{.}} {{end}} \
+        {{.DYN_LIBS_USED_PATH}} \
+        {{.DYN_LIBS_USED}} \
+        -O0 \
+        -lstandardloop-json \
+        -fno-omit-frame-pointer \
+        -fsanitize=address \
+        -o {{.LAB_EXECUTABLE_NAME}}-sanitize
+    sources:
+      - "*.c"
+    generates:
+      - "{{.LAB_EXECUTABLE_NAME}}-sanitize"
 
   lab:run:
     deps:
       - lab:build
     cmds:
       - ./{{.LAB_EXECUTABLE_NAME}}
+  
+  lab:run-sanitize:
+    deps:
+      - lab:build-sanitize
+    cmds:
+      - ./{{.LAB_EXECUTABLE_NAME}}-sanitize
 
   lab:leaks:
     deps:
       - lab:build
     cmds:
+      - cp /usr/local/lib/standardloop/libstandardloop-util.dylib ./ # to get around sips we need to move dylibs to local dir :(
+      - cp /usr/local/lib/standardloop/libstandardloop-json.dylib ./
       - leaks --atExit -- ./{{.LAB_EXECUTABLE_NAME}}
-    env:
-      DYLD_FALLBACK_LIBRARY_PATH: /usr/local/lib/standardloop/
-      DYLD_LIBRARY_PATH: /usr/local/lib/standardloop/
-      # MallocStackLogging: YES
-      # -lstandardloop-json \
-      # -fsanitize=address \
+      - rm libstandardloop-util.dylib
+      - rm libstandardloop-json.dylib
+    # env:
+    #   MallocStackLogging: YES

hashmap.c

@@ -112,6 +112,8 @@ extern void HashMapInsert(HashMap *map, JSONValue *entry)
     bool collision = hashMapEntriesInsert(map->entries, index, entry);
     if (collision)
     {
+        // printf("COLLISION!\n");
+        // fflush(stdout);
         map->collision_count++;
     }
     else
@@ -137,30 +139,49 @@ static bool hashMapEntriesInsert(JSONValue **entries, u_int32_t index, JSONValue
         entries[index] = entry;
         return false;
     }
+    // printf("%s -> %s\n", collision->key, entry->key);
     // If duplicate key, update (in future could maybe make this a feature flag for the init function)
-    if (collision->key != NULL && strcmp(collision->key, entry->key) == 0)
+    if (collision->key != NULL)
     {
-        entry->next = collision->next;
-        collision->next = NULL;
-        freeHashMapEntrySingle(collision, true);
-        entries[index] = entry;
-        return true;
+        size_t collision_key_len = strlen(collision->key);
+        size_t entry_key_len = strlen(entry->key);
+        if (collision_key_len == entry_key_len)
+        {
+            if (strncmp(collision->key, entry->key, entry_key_len) == 0)
+            {
+                entry->next = collision->next;
+                collision->next = NULL;
+                freeHashMapEntrySingle(collision, true);
+                entries[index] = entry;
+                return true;
+            }
+        }
     }
     JSONValue *iterator_prev = collision;
     JSONValue *iterator = collision->next;
     while (iterator != NULL)
     {
-        if (iterator->key != NULL && entry->key != NULL && strcmp(iterator->key, entry->key) == 0)
+        if (iterator->key != NULL && entry->key != NULL)
         {
-            iterator_prev->next = entry;
-            entry->next = iterator->next;
-            iterator->next = NULL;
-            freeHashMapEntrySingle(iterator, true); // FIXME
-            return true;
+            size_t collision_key_len = strlen(collision->key);
+            size_t entry_key_len = strlen(entry->key);
+            if (collision_key_len == entry_key_len)
+            {
+                if (strncmp(iterator->key, entry->key, collision_key_len) == 0)
+                {
+                    iterator_prev->next = entry;
+                    entry->next = iterator->next;
+                    iterator->next = NULL;
+                    freeHashMapEntrySingle(iterator, true);
+                    return true;
+                }
+            }
         }
+
         iterator_prev = iterator;
         iterator = iterator->next;
     }
+    entry->next = NULL;
     iterator_prev->next = entry;
     return true;
 }
@@ -351,7 +372,6 @@ static void printHashMapEntry(JSONValue *entry)
             printf("\"%s\": ", iterator->key);
             PrintJSONValue(iterator);
         }
-
         iterator = iterator->next;
         if (iterator != NULL)
         {
@@ -363,6 +383,8 @@ static void printHashMapEntry(JSONValue *entry)
 // JOSH
 static void hashMapResize(HashMap *map)
 {
+    // printf("hashMapResize\n");
+    // fflush(stdout);
     if (map == NULL)
     {
         return;

json.c

@@ -120,9 +120,9 @@ static char *doubleToString(double num)
     // double fractional = modf(num, &integral);
     // int64_t integral_as_int64 = (int64_t)integral;
     // printf("%lld %lf\n", integral_as_int64, fractional);
-    char *double_as_string = malloc(sizeof(char) * FLOAT_CHAR_MAX);
+    char *double_as_string = malloc((sizeof(char) * FLOAT_CHAR_MAX) + sizeof(char));
     (void)gcvt(num, FLOAT_CHAR_MAX, double_as_string);
-
+    double_as_string[FLOAT_CHAR_MAX] = NULL_CHAR;
     return double_as_string;
 }
 

json.h

@@ -3,8 +3,8 @@
 
 #define STANDARDLOOP_JSON_H_MAJOR_VERSION 0
 #define STANDARDLOOP_JSON_H_MINOR_VERSION 0
-#define STANDARDLOOP_JSON_H_PATCH_VERSION 1
-#define STANDARDLOOP_JSON_H_VERSION "0.0.1"
+#define STANDARDLOOP_JSON_H_PATCH_VERSION 2
+#define STANDARDLOOP_JSON_H_VERSION "0.0.2"
 
 #include <stdio.h>
 #include <stdlib.h>

lab.c

@@ -2,25 +2,30 @@
 #include <stdlib.h>
 #include <string.h>
 
+// #include <standardloop/json.h>
 #include "./json.h"
 
 int main(void)
 {
     // JSON *json = StringToJSON("[{\"guid\": \"\", \"about\": \"\"}]");
-    JSON *json = StringToJSON("{\"guid\": \"\", \"about\": \"\"}");
+    // JSON *json = StringToJSON("{\"foo\": \"\"}");
+    // JSON *json = StringToJSON("{\"guid\": \"foo\", \"about\": \"bar\"}");
+
+    JSON *json = JSONFromFile("./private/lab/1mil.json");
+
     if (json == NULL)
     {
         return EXIT_FAILURE;
     }
     // PrintJSON(json);
-    FreeJSON(json);
+    // FreeJSON(json);
 
-    // char *json_string = JSONToString(json);
-    // if (json_string == NULL)
-    // {
-    //     return EXIT_FAILURE;
-    // }
-    // // printf("%s", json_string);
-    // free(json_string);
+    char *json_string = JSONToString(json);
+    if (json_string == NULL)
+    {
+        return EXIT_FAILURE;
+    }
+    // printf("%s", json_string);
+    free(json_string);
     return EXIT_SUCCESS;
 }

lexer.c

@@ -394,13 +394,13 @@ static char *makeNumberLiteral(Lexer *lexer)
 
 static char *makeStringLiteral(Lexer *lexer)
 {
-    u_int32_t start_position = lexer->position + 1;
+    u_int32_t start_position = lexer->position + 1; // move pass quotes
     char prev_char = lexer->current_char;
     advanceChar(lexer);
     bool is_error = false;
     while (ALWAYS)
     {
-        // printf("%d\n", lexer->current_char);
+        // printf("%c\n", lexer->current_char);
         if (lexer->current_char == BACKSLASH_CHAR)
         {
             prev_char = lexer->current_char;
@@ -473,7 +473,8 @@ static char *makeStringLiteral(Lexer *lexer)
     }
     copyString(lexer->input, string_literal, string_literal_size, start_position);
     string_literal[string_literal_size - 1] = NULL_CHAR;
-    // printf("[JOSH]\n", string_literal);
+    // printf("[JOSH]: %s\n", string_literal);
+    // printf("[JOSH]: %d\n", (int)strlen(string_literal));
     return string_literal;
 }
 

parser.c

@@ -500,7 +500,8 @@ static JSONValue *parse(Parser *parser)
     {
         return NULL;
     }
-    // printf("[JOSH]: %u\n", (unsigned int)parser->list_nested);
+    // printf("[JOSH]: %d\n", parser->peek_token->type);
+    // printf("[JOSH]: %s\n", parser->peek_token->literal);
 
     nextToken(parser);
     // PrintToken(parser->current_token, false);