feat: json

CMakeLists.txt

@@ -11,6 +11,7 @@ add_subdirectory(libs/arena_allocator)
 add_subdirectory(libs/data)
 
 add_subdirectory(libs/progressbar)
+add_subdirectory(libs/json)
 add_subdirectory(libs/mover)
 add_subdirectory(examples)
 

Makefile

@@ -0,0 +1,14 @@
+compile_commands:
+	cmake -G Ninja -B build
+
+build: compile_commands
+	cmake --build build
+
+test: build
+ifdef T
+	cd build && ctest --output-on-failure -R $(T)
+else
+	cd build && ctest --output-on-failure
+endif
+
+.PHONY: compile_commands build test

docs/libs/containers/string.md

@@ -63,6 +63,12 @@ char *raw = string_to_primitive_underlying(s);
 printf("Raw: %s\n", raw);
 ```
 
+Note:
+Since inside, string is just an `array_list`, it is not null terminated. Caller must use `string_length` along with `string_to_primitive_underlying` for this to work correctly. Or else use `string_to_primitive` which incurs copy and allocation cost.
+
+For comparisons, use `string_cmp_cstr` instead.
+
+
 ## API Reference
 
 | Function / Macro | Description |

examples/CMakeLists.txt

@@ -1,6 +1,2 @@
 add_executable(progressbar progressbar.c)
 target_link_libraries(progressbar PRIVATE cisastor::progressbar m)
-add_executable(array_list array_list.c)
-target_link_libraries(array_list PRIVATE cisastor::utils)
-target_link_libraries(array_list PRIVATE cisastor::data::containers)
-target_link_libraries(array_list PRIVATE cisastor::arena)

libs/arena_allocator/arena.c

@@ -47,6 +47,10 @@ void *arena_alloc(size_t size) {
     // sizeof(char) == 1 byte most of the time;
     size_t required_size = size < ARENA_SIZ ? ARENA_SIZ : size * 2;
     arena.chunk = malloc(required_size);
+    if (arena.chunk == null) {
+      fprintf(stderr, "Failed to initialize Arena\n");
+      return null;
+    }
     arena.size = required_size;
     arena.ptr = arena.chunk;
     atexit(arena_free);
@@ -62,11 +66,16 @@ void *arena_alloc(size_t size) {
     current = new_arena;
     size_t new_size = size > ARENA_SIZ ? size * 2 : ARENA_SIZ;
     current->chunk = malloc(new_size);
+    if (current->chunk == null) {
+      perror("new_arena_chunk_allocation");
+      return null;
+    }
     current->ptr = current->chunk;
     current->size = new_size;
     current->next_arena = null;
   }
   if (null == current->chunk || null == current->ptr) {
+    perror("no_arena_region");
     return null;
   }
   void *allocated = current->ptr;

libs/data/CMakeLists.txt

@@ -6,6 +6,7 @@ add_library(cisastor_data_containers STATIC
 	containers/iterator.c
 	containers/string.c
 	containers/string_builder.c
+	containers/stack.c
 )
 
 target_include_directories(cisastor_data_containers INTERFACE
@@ -55,3 +56,11 @@ cisastor_add_test(
 	IMPLS containers/string_builder.c containers/string.c containers/array_list.c containers/iterator.c
 	LIBS cisastor::arena cisastor::utils
 )
+
+cisastor_add_test(
+	NAME stack_test
+	SRCS containers/stack_test.c
+	IMPLS containers/stack.c containers/array_list.c
+	LIBS cisastor::arena cisastor::utils
+)
+

libs/data/containers/iterator.h

@@ -121,3 +121,6 @@ void *iterator_mutating_end(struct iterator_mutating *itm);
 #define for_each(it, list)                                                     \
   for (struct iterator *it = iterator_begin(list);                             \
        iterator_end(it) != iterator_element(it); iterator_increment(it))
+
+#define for_each_it(it)                                                        \
+  for (; iterator_end(it) != iterator_element(it); iterator_increment(it))

libs/data/containers/stack.c

@@ -0,0 +1,28 @@
+#include "stack.h"
+#include "array_list.h"
+
+stack *stack_create(size_t size) { return array_list_create(size); }
+
+byte *stack_peek(stack *s) {
+  struct array_list *al = cast(struct array_list *, s);
+  void *element = array_list_get_element_at(al, al->length - 1);
+  if (element == null) {
+    return null;
+  }
+  return element;
+}
+
+byte *stack_pop(stack *s) {
+  void *element = stack_peek(s);
+  if (element == null) {
+    return null;
+  }
+  // array_list does not own anything, so this is fine, we aren't leaking memory
+  // by moving the cursor;
+  cast(struct array_list *, s)->length--;
+  return element;
+}
+
+void stack_push(stack *s, byte *data) { array_list_append(s, data); }
+
+size_t stack_size(stack *s) { return array_list_get_length(s); }

libs/data/containers/stack.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#include "array_list.h"
+#include "macros.h"
+
+typedef struct array_list stack;
+
+stack *stack_create(size_t size);
+
+byte *stack_pop(stack *);
+byte *stack_peek(stack *);
+void stack_push(stack *, byte *data);
+
+size_t stack_size(stack *);
+
+#define stack_init(type)                                                       \
+  typedef stack stack_##type;                                                  \
+  static inline stack_##type *stack_create_##type() {                          \
+    return stack_create(sizeof(type));                                         \
+  }                                                                            \
+  static inline void stack_push_##type(stack_##type *s, type data) {           \
+    stack_push(s, cast(byte *, &data));                                        \
+  }                                                                            \
+  static inline void stack_push_##type##_ptr(stack_##type *s, type *data) {    \
+    stack_push(s, cast(byte *, data));                                         \
+  }                                                                            \
+  static inline type *stack_pop_##type(stack_##type *s) {                      \
+    return cast(type *, stack_pop(s));                                         \
+  }                                                                            \
+  static inline type *stack_peek_##type(stack_##type *s) {                     \
+    return cast(type *, stack_peek(s));                                        \
+  }
+
+stack_init(int);
+stack_init(char);

libs/data/containers/stack_test.c

@@ -0,0 +1,41 @@
+#include "testing.h"
+
+#include "stack.h"
+
+IT(should_enstack_elements_and_pop) {
+  stack_int *q = stack_create_int();
+  for (int i = 1; i <= 10000; i++) {
+    stack_push_int(q, i);
+  }
+  cassert(stack_size(q) == 10000, "invalid stack size, should be 10000");
+  for (int i = 10000; i > 0; i--) {
+    int *_got = stack_pop_int(q);
+    cassertf(_got != null, "popped null data at index %d\n", i);
+    int got = *_got;
+    cassertf(got == i, "expected %d got %d\n", i, got);
+  }
+  cassert(stack_size(q) == 0, "size should be 0 now");
+}
+
+IT(should_peek_pop_correctly) {
+  stack_int *s = stack_create_int();
+  stack_push_int(s, 0);
+  int *i = null;
+  i = stack_peek_int(s);
+  cassert(i != null, "peek should not be null, value should be 0 at the "
+                     "beginning that is peeked into");
+  cassert(*i == 0, "should peek value 0");
+  stack_push_int(s, 1);
+  i = stack_peek_int(s);
+  cassert(i != null,
+          "peek should not be null, value should be 1 that is peeked into");
+  cassert(*i == 1, "peek should be 1");
+  i = stack_pop_int(s);
+  cassert(i != null,
+          "pop should not be null, value should be 1 that is popped");
+  cassert(*i == 1, "pop should be 1");
+  i = stack_peek_int(s);
+  cassert(i != null,
+          "peek should not be null, value should be 0 that is peeked into");
+  cassert(*i == 0, "peek should be 0");
+}

libs/data/containers/string.c

@@ -71,5 +71,15 @@ char *string_to_primitive(string *str) {
 }
 
 char *const string_to_primitive_underlying(string *str) {
+  // Since inside, string is just an array_list, it is not null terminated.
+  // Caller must use string_length along with _to_primitive_underlying for this
+  // to work correctly. Or else use string_to_primitive which incurs copy and
+  // allocation cost.
+  // For comparisons, use string_cmp_cstr instead.
   return cast(struct array_list *, str)->region;
 }
+
+// str[n]cmp for using string with cstrs
+uint8_t string_cmp_cstr(string *str, const char *const cstr) {
+  return strncmp(string_to_primitive_underlying(str), cstr, string_length(str));
+}

libs/data/containers/string.h

@@ -25,3 +25,5 @@ string *string_from_array_list(struct array_list_char *al);
 char *string_to_primitive(string *str);
 
 char *const string_to_primitive_underlying(string *str);
+
+uint8_t string_cmp_cstr(string *str, const char *const cstr);

libs/data/containers/string_builder.c

@@ -2,6 +2,7 @@
 #include "array_list.h"
 #include "string.h"
 
+#include <stdarg.h>
 #include <string.h>
 
 string_builder *string_builder_create() {
@@ -22,6 +23,10 @@ string *string_builder_build(string_builder *sb) {
     capacity += strlen(*array_list_get_const_char_ptr_at(sb, i));
   }
   string *str = cast(string *, array_list_create_char_with_capacity(capacity));
+  if (str == null) {
+    perror("string_builder_build_new_string");
+    return null;
+  }
   for (int i = 0; i < array_list_get_length(sb); i++) {
     const char *cstr = *array_list_get_const_char_ptr_at(sb, i);
     for (int j = 0; cstr[j] != '\0'; j++) {

libs/data/containers/string_builder_test.c

@@ -1,5 +1,5 @@
-#include "testing.h"
 #include "string_builder.h"
+#include "testing.h"
 
 IT(should_create_string_builder) {
   string_builder *sb = string_builder_create();
@@ -10,10 +10,10 @@ IT(should_join_strings) {
   string_builder *sb = string_builder_create();
   string_builder_join(sb, "hello ");
   string_builder_join(sb, "world");
-  
+
   string *str = string_builder_build(sb);
   cassert(string_length(str) == 11, "length should be 11");
-  
+
   string *expected = string_create("hello world");
   cassert(string_cmp(str, expected) == 0, "string mismatch");
 }
@@ -23,10 +23,11 @@ IT(should_handle_many_joins) {
   for (int i = 0; i < 1000; i++) {
     string_builder_join(sb, "a");
   }
-  
+
   string *str = string_builder_build(sb);
   cassert(string_length(str) == 1000, "length should be 1000");
-  for(int i = 0; i < 1000; i++) {
-      cassertf(string_char_at(str, i) == 'a', "mismatch at idx %d", i);
+  for (int i = 0; i < 1000; i++) {
+    cassertf(string_char_at(str, i) == 'a', "mismatch at idx %d", i);
   }
 }
+