Implemented a destructor for JSON values.

The destructor recursively traverses the object tree releasing memory accordingly.
Since, key-value pairs are stored in a hash map, the key needs to persist longer
than the lifetime of a token, which is where we derive the key from. As of now,
tokens are not freed. In the future, we need to implement a recyclable token
that is destroyed along with the parser.

Author: itssamuelrowe

include/jtk/support/json.h

@@ -62,6 +62,7 @@ jtk_JsonValue_t* jtk_JsonValue_forString(const uint8_t* text, int32_t length);
 jtk_JsonValue_t* jtk_JsonValue_forNumber(const uint8_t* text, int32_t length);
 jtk_JsonValue_t* jtk_JsonValue_forTrue();
 jtk_JsonValue_t* jtk_JsonValue_forFalse();
+void jtk_JsonValue_delete(jtk_JsonValue_t* value);
 
 jtk_JsonValue_t* jtk_parseJson(const uint8_t* sequence, int32_t size, jtk_JsonError_t* error);
 

source/jtk/support/json.c

@@ -641,6 +641,7 @@ Token* nextToken(Parser* parser) {
     return newToken;
 }
 
+// TODO: Recycle the token object and delete it along with the parser.
 Token* consume(Parser* parser) {
     Token* temporary = parser->lt1;
     parser->lt1 = nextToken(parser);
@@ -688,9 +689,10 @@ jtk_JsonValue_t* parseObject(Parser* parser) {
 
     if (parser->lt1->type == TOKEN_STRING) {
         Token* key = consume(parser);
+        uint8_t* keyText = jtk_CString_newEx(key->text, key->length);
         match(parser, TOKEN_COLON);
         jtk_JsonValue_t* value = parseValue(parser);
-        jtk_HashMap_put(result->object, key->text, value);
+        jtk_HashMap_put(result->object, keyText, value);
 
         while (parser->lt1->type == TOKEN_COMMA) {
             consume(parser);
@@ -825,6 +827,36 @@ jtk_JsonValue_t* jtk_JsonValue_forTrue() {
     return value;
 }
 
+void jtk_JsonValue_delete(jtk_JsonValue_t* value) {
+    if (value != NULL) {
+        if (value->type == JTK_JSON_VALUE_STRING) {
+            jtk_CString_delete(value->string.bytes);
+        }
+        else if (value->type == JTK_JSON_VALUE_ARRAY) {
+            int32_t limit = jtk_ArrayList_getSize(value->array);
+            int32_t i;
+            for (i = 0; i < limit; i++) {
+                jtk_JsonValue_t* temporary =
+                    (jtk_JsonValue_t*)jtk_ArrayList_getValue(value->array, i);
+                jtk_JsonValue_delete(temporary);
+            }
+            jtk_ArrayList_delete(value->array);
+        }
+        else if (value->type == JTK_JSON_VALUE_OBJECT) {
+            jtk_Iterator_t* iterator = jtk_HashMap_getEntryIterator(value->object);
+            while (jtk_Iterator_hasNext(iterator)) {
+                jtk_HashMapEntry_t* entry =
+                    (jtk_HashMapEntry_t*)jtk_Iterator_getNext(iterator);
+                jtk_CString_delete((uint8_t*)entry->m_key);
+                jtk_JsonValue_delete((jtk_JsonValue_t*)entry->m_value);
+            }
+            jtk_Iterator_delete(iterator);
+            jtk_HashMap_delete(value->object);
+        }
+        deallocate(value);
+    }
+}
+
 void handleError() {
     printf("Errro!\n");
 }
@@ -852,6 +884,7 @@ void toString(jtk_StringBuilder_t* builder, jtk_JsonValue_t* value) {
 
             first = false;
         }
+        jtk_Iterator_delete(iterator);
         jtk_StringBuilder_appendCodePoint(builder, '}');
     }
     else if (value->type == JTK_JSON_VALUE_ARRAY) {
@@ -896,6 +929,7 @@ void toPrettyString(jtk_StringBuilder_t* builder, jtk_JsonValue_t* value,
 
             first = false;
         }
+        jtk_Iterator_delete(iterator);
         jtk_StringBuilder_appendCodePoint(builder, '\n');
         indent(builder, depth);
         jtk_StringBuilder_appendCodePoint(builder, '}');