herb 0.8.10-arm-linux-gnu → 0.9.1-arm-linux-gnu

data/src/util/hb_array.c

@@ -2,28 +2,39 @@
 #include <stdio.h>
 
 #include "../include/macros.h"
+#include "../include/util/hb_allocator.h"
 #include "../include/util/hb_array.h"
 
 size_t hb_array_sizeof(void) {
   return sizeof(hb_array_T);
 }
 
-hb_array_T* hb_array_init(const size_t capacity) {
-  hb_array_T* array = malloc(hb_array_sizeof());
+hb_array_T* hb_array_init(const size_t capacity, hb_allocator_T* allocator) {
+  hb_array_T* array = hb_allocator_alloc(allocator, hb_array_sizeof());
+
+  if (!array) { return NULL; }
 
   array->size = 0;
   array->capacity = capacity;
-  array->items = malloc(capacity * sizeof(void*));
+  array->allocator = allocator;
+
+  if (capacity == 0) {
+    array->items = NULL;
+  } else {
+    array->items = hb_allocator_alloc(allocator, capacity * sizeof(void*));
 
-  if (!array->items) {
-    free(array);
-    return NULL;
+    if (!array->items) {
+      hb_allocator_dealloc(allocator, array);
+      return NULL;
+    }
   }
 
   return array;
 }
 
-void hb_array_append(hb_array_T* array, void* item) {
+bool hb_array_append(hb_array_T* array, void* item) {
+  if (!array) { return false; }
+
   if (array->size >= array->capacity) {
     size_t new_capacity;
 
@@ -40,20 +51,23 @@ void hb_array_append(hb_array_T* array, void* item) {
 
     if (new_capacity > SIZE_MAX / sizeof(void*)) {
       fprintf(stderr, "Error: Array allocation would exceed system limits.\n");
-      return;
+      return false;
     }
 
+    size_t old_size_bytes = array->capacity * sizeof(void*);
     size_t new_size_bytes = new_capacity * sizeof(void*);
-    void* new_items = realloc(array->items, new_size_bytes);
+    void** new_items = hb_allocator_realloc(array->allocator, array->items, old_size_bytes, new_size_bytes);
 
-    if (unlikely(new_items == NULL)) { return; }
+    if (unlikely(new_items == NULL)) { return false; }
 
-    array->items = (void**) new_items;
+    array->items = new_items;
     array->capacity = new_capacity;
   }
 
   array->items[array->size] = item;
   array->size++;
+
+  return true;
 }
 
 void* hb_array_get(const hb_array_T* array, const size_t index) {
@@ -103,8 +117,8 @@ void hb_array_remove_item(hb_array_T* array, void* item) {
 }
 
 // Alias for hb_array_append
-void hb_array_push(hb_array_T* array, void* item) {
-  hb_array_append(array, item);
+bool hb_array_push(hb_array_T* array, void* item) {
+  return hb_array_append(array, item);
 }
 
 void* hb_array_pop(hb_array_T* array) {
@@ -130,8 +144,9 @@ size_t hb_array_capacity(const hb_array_T* array) {
 void hb_array_free(hb_array_T** array) {
   if (!array || !*array) { return; }
 
-  free((*array)->items);
-  free(*array);
+  hb_allocator_T* allocator = (*array)->allocator;
+  hb_allocator_dealloc(allocator, (*array)->items);
+  hb_allocator_dealloc(allocator, *array);
 
   *array = NULL;
 }

data/src/util/hb_buffer.c

@@ -3,7 +3,7 @@
 #include <string.h>
 
 #include "../include/macros.h"
-#include "../include/util.h"
+#include "../include/util/hb_allocator.h"
 #include "../include/util/hb_buffer.h"
 
 static bool hb_buffer_has_capacity(hb_buffer_T* buffer, const size_t required_length) {
@@ -22,14 +22,8 @@ static bool hb_buffer_resize(hb_buffer_T* buffer, const size_t new_capacity) {
     fprintf(stderr, "Error: Buffer capacity would overflow system limits.\n");
     exit(1);
   }
-  char* new_value = NULL;
 
-  if (buffer->allocator == NULL) {
-    new_value = realloc(buffer->value, new_capacity + 1);
-  } else {
-    new_value = hb_arena_alloc(buffer->allocator, new_capacity + 1);
-    memcpy(new_value, buffer->value, buffer->capacity + 1);
-  }
+  char* new_value = hb_allocator_realloc(buffer->allocator, buffer->value, buffer->capacity + 1, new_capacity + 1);
 
   if (unlikely(new_value == NULL)) {
     fprintf(stderr, "Error: Failed to resize buffer to %zu.\n", new_capacity);
@@ -66,11 +60,11 @@ static bool hb_buffer_expand_if_needed(hb_buffer_T* buffer, const size_t require
   return hb_buffer_resize(buffer, new_capacity);
 }
 
-bool hb_buffer_init(hb_buffer_T* buffer, const size_t capacity) {
-  buffer->allocator = NULL;
+bool hb_buffer_init(hb_buffer_T* buffer, const size_t capacity, struct hb_allocator* allocator) {
+  buffer->allocator = allocator;
   buffer->capacity = capacity;
   buffer->length = 0;
-  buffer->value = malloc(sizeof(char) * (buffer->capacity + 1));
+  buffer->value = hb_allocator_alloc(allocator, sizeof(char) * (buffer->capacity + 1));
 
   if (!buffer->value) {
     fprintf(stderr, "Error: Failed to initialize buffer with capacity of %zu.\n", buffer->capacity);
@@ -83,16 +77,6 @@ bool hb_buffer_init(hb_buffer_T* buffer, const size_t capacity) {
   return true;
 }
 
-bool hb_buffer_init_arena(hb_buffer_T* buffer, hb_arena_T* allocator, size_t capacity) {
-  buffer->allocator = allocator;
-  buffer->capacity = capacity;
-  buffer->length = 0;
-  buffer->value = hb_arena_alloc(allocator, sizeof(char) * (buffer->capacity + 1));
-  buffer->value[0] = '\0';
-
-  return true;
-}
-
 char* hb_buffer_value(const hb_buffer_T* buffer) {
   return buffer->value;
 }
@@ -101,6 +85,10 @@ size_t hb_buffer_length(const hb_buffer_T* buffer) {
   return buffer->length;
 }
 
+bool hb_buffer_is_empty(const hb_buffer_T* buffer) {
+  return buffer->length == 0;
+}
+
 size_t hb_buffer_capacity(const hb_buffer_T* buffer) {
   return buffer->capacity;
 }
@@ -205,6 +193,14 @@ void hb_buffer_concat(hb_buffer_T* destination, hb_buffer_T* source) {
   destination->value[destination->length] = '\0';
 }
 
+void hb_buffer_free(hb_buffer_T* buffer) {
+  if (!buffer) { return; }
+  hb_allocator_dealloc(buffer->allocator, buffer->value);
+  buffer->value = NULL;
+  buffer->length = 0;
+  buffer->capacity = 0;
+}
+
 void hb_buffer_clear(hb_buffer_T* buffer) {
   buffer->length = 0;
   buffer->value[0] = '\0';

data/src/util/hb_narray.c

@@ -4,25 +4,40 @@
 #include <stdbool.h>
 #include <string.h>
 
-void hb_narray_init(hb_narray_T* array, size_t item_size, size_t initial_capacity) {
+bool hb_narray_init(hb_narray_T* array, size_t item_size, size_t initial_capacity, hb_allocator_T* allocator) {
   assert(initial_capacity != 0);
 
+  array->allocator = allocator;
   array->item_size = item_size;
   array->capacity = initial_capacity;
   array->size = 0;
-  array->items = malloc(array->capacity * array->item_size);
+  array->items = hb_allocator_alloc(array->allocator, array->capacity * array->item_size);
+
+  if (!array->items) { return false; }
+
+  return true;
 }
 
-void hb_narray_append(hb_narray_T* array, void* item) {
+bool hb_narray_append(hb_narray_T* array, void* item) {
   if (array->size + 1 > array->capacity) {
-    array->capacity *= 2;
-    void* new_buffer = realloc(array->items, array->capacity * array->item_size);
-    assert(new_buffer != NULL);
+    size_t new_capacity = array->capacity * 2;
+    void* new_buffer = hb_allocator_realloc(
+      array->allocator,
+      array->items,
+      array->capacity * array->item_size,
+      new_capacity * array->item_size
+    );
+
+    if (!new_buffer) { return false; }
+
     array->items = new_buffer;
+    array->capacity = new_capacity;
   }
 
   memcpy(array->items + (array->size * array->item_size), item, array->item_size);
   array->size += 1;
+
+  return true;
 }
 
 static inline uint8_t* hb_narray_memory_position(const hb_narray_T* array, size_t index) {
@@ -71,7 +86,7 @@ void hb_narray_deinit(hb_narray_T* array) {
   array->item_size = 0;
   array->capacity = 0;
   array->size = 0;
-  free(array->items);
+  hb_allocator_dealloc(array->allocator, array->items);
 }
 
 size_t hb_narray_size(const hb_narray_T* array) {

data/src/util/hb_string.c

@@ -1,11 +1,14 @@
 #include "../include/util/hb_string.h"
 #include "../include/macros.h"
+#include "../include/util.h"
 
 #include <stdlib.h>
 #include <string.h>
 #include <strings.h>
 
-hb_string_T hb_string(const char* null_terminated_c_string) {
+hb_string_T hb_string_from_c_string(const char* null_terminated_c_string) {
+  if (null_terminated_c_string == NULL) { return HB_STRING_NULL; }
+
   hb_string_T string;
 
   string.data = (char*) null_terminated_c_string;
@@ -14,61 +17,72 @@ hb_string_T hb_string(const char* null_terminated_c_string) {
   return string;
 }
 
-hb_string_T hb_string_slice(hb_string_T string, uint32_t offset) {
-  hb_string_T slice;
-  if (string.length < offset) {
-    slice.data = NULL;
-    slice.length = 0;
-
-    return slice;
-  }
-
-  slice.data = string.data + offset;
-  slice.length = string.length - offset;
+hb_string_T hb_string_truncate(hb_string_T string, uint32_t max_length) {
+  hb_string_T truncated_string = { .data = string.data, .length = MIN(string.length, max_length) };
 
-  return slice;
+  return truncated_string;
 }
 
-bool hb_string_equals(hb_string_T a, hb_string_T b) {
-  if (a.length != b.length) { return false; }
-
-  return strncmp(a.data, b.data, a.length) == 0;
+hb_string_T hb_string_range(hb_string_T string, uint32_t from, uint32_t to) {
+  return hb_string_truncate(hb_string_slice(string, from), to - from);
 }
 
-bool hb_string_equals_case_insensitive(hb_string_T a, hb_string_T b) {
-  if (a.length != b.length) { return false; }
+hb_string_T hb_string_trim_start(hb_string_T string) {
+  if (hb_string_is_empty(string)) { return string; }
 
-  return strncasecmp(a.data, b.data, a.length) == 0;
+  uint32_t offset = 0;
+  while (offset < string.length && is_whitespace(string.data[offset])) {
+    offset++;
+  }
+
+  return hb_string_slice(string, offset);
 }
 
-bool hb_string_starts_with(hb_string_T string, hb_string_T expected_prefix) {
-  if (hb_string_is_empty(string) || hb_string_is_empty(expected_prefix)) { return false; }
-  if (string.length < expected_prefix.length) { return false; }
+hb_string_T hb_string_trim_end(hb_string_T string) {
+  if (hb_string_is_empty(string)) { return string; }
+
+  uint32_t length = string.length;
+  while (length > 0 && is_whitespace(string.data[length - 1])) {
+    length--;
+  }
 
-  return strncmp(string.data, expected_prefix.data, expected_prefix.length) == 0;
+  return hb_string_truncate(string, length);
 }
 
-bool hb_string_is_empty(hb_string_T string) {
-  return string.length == 0;
+hb_string_T hb_string_trim(hb_string_T string) {
+  return hb_string_trim_end(hb_string_trim_start(string));
 }
 
-hb_string_T hb_string_truncate(hb_string_T string, uint32_t max_length) {
-  hb_string_T truncated_string = { .data = string.data, .length = MIN(string.length, max_length) };
+bool hb_string_is_blank(hb_string_T string) {
+  if (hb_string_is_empty(string)) { return true; }
 
-  return truncated_string;
+  for (uint32_t i = 0; i < string.length; i++) {
+    if (!is_whitespace(string.data[i])) { return false; }
+  }
+
+  return true;
 }
 
-hb_string_T hb_string_range(hb_string_T string, uint32_t from, uint32_t to) {
-  return hb_string_truncate(hb_string_slice(string, from), to - from);
+hb_string_T hb_string_copy(hb_string_T string, hb_allocator_T* allocator) {
+  if (hb_string_is_null(string)) { return HB_STRING_NULL; }
+  if (hb_string_is_empty(string)) { return HB_STRING_EMPTY; }
+
+  char* copy = hb_allocator_strndup(allocator, string.data, string.length);
+
+  return (hb_string_T) { .data = copy, .length = string.length };
 }
 
 char* hb_string_to_c_string_using_malloc(hb_string_T string) {
-  size_t string_length_in_bytes = sizeof(char) * (string.length);
-  char* buffer = malloc(string_length_in_bytes + sizeof(char) * 1);
+  if (hb_string_is_null(string)) { return NULL; }
 
-  if (!hb_string_is_empty(string)) { memcpy(buffer, string.data, string_length_in_bytes); }
+  size_t length = string.length;
+  char* buffer = malloc(length + 1);
 
-  buffer[string_length_in_bytes] = '\0';
+  if (!buffer) { return NULL; }
+
+  if (length > 0) { memcpy(buffer, string.data, length); }
+
+  buffer[length] = '\0';
 
   return buffer;
 }

data/src/util.c

@@ -1,4 +1,5 @@
 #include "include/util.h"
+#include "include/util/hb_allocator.h"
 #include "include/util/hb_buffer.h"
 #include "include/util/hb_string.h"
 
@@ -10,10 +11,14 @@ int is_newline(int character) {
   return character == '\n' || character == '\r';
 }
 
-hb_string_T escape_newlines(hb_string_T input) {
+int is_whitespace(int character) {
+  return character == ' ' || character == '\t' || character == '\n' || character == '\r';
+}
+
+hb_string_T escape_newlines(hb_allocator_T* allocator, hb_string_T input) {
   hb_buffer_T buffer;
 
-  hb_buffer_init(&buffer, input.length);
+  hb_buffer_init(&buffer, input.length, allocator);
 
   for (size_t i = 0; i < input.length; ++i) {
     switch (input.data[i]) {
@@ -34,10 +39,10 @@ hb_string_T escape_newlines(hb_string_T input) {
   return hb_string(buffer.value);
 }
 
-static hb_string_T wrap_string(hb_string_T input, char character) {
+static hb_string_T wrap_string(hb_allocator_T* allocator, hb_string_T input, char character) {
   hb_buffer_T buffer;
 
-  hb_buffer_init(&buffer, input.length + 2);
+  hb_buffer_init(&buffer, input.length + 2, allocator);
 
   hb_buffer_append_char(&buffer, character);
   hb_buffer_append_string(&buffer, input);
@@ -46,15 +51,20 @@ static hb_string_T wrap_string(hb_string_T input, char character) {
   return hb_string(buffer.value);
 }
 
-hb_string_T quoted_string(hb_string_T input) {
-  return wrap_string(input, '"');
+hb_string_T quoted_string(hb_allocator_T* allocator, hb_string_T input) {
+  return wrap_string(allocator, input, '"');
 }
 
-char* herb_strdup(const char* s) {
-  size_t len = strlen(s) + 1;
-  char* copy = malloc(len);
+char* convert_underscores_to_dashes(const char* input) {
+  if (!input) { return NULL; }
 
-  if (copy) { memcpy(copy, s, len); }
+  size_t len = strlen(input);
+  char* output = calloc(len + 1, sizeof(char));
+  if (!output) { return NULL; }
+
+  for (size_t i = 0; i < len; i++) {
+    output[i] = (input[i] == '_') ? '-' : input[i];
+  }
 
-  return copy;
+  return output;
 }

data/src/visitor.c

@@ -42,6 +42,15 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
 
     } break;
 
+    case AST_HTML_CONDITIONAL_OPEN_TAG_NODE: {
+      const AST_HTML_CONDITIONAL_OPEN_TAG_NODE_T* html_conditional_open_tag_node = ((const AST_HTML_CONDITIONAL_OPEN_TAG_NODE_T *) node);
+
+      if (html_conditional_open_tag_node->conditional != NULL) {
+        herb_visit_node((AST_NODE_T *) html_conditional_open_tag_node->conditional, visitor, data);
+      }
+
+    } break;
+
     case AST_HTML_CLOSE_TAG_NODE: {
       const AST_HTML_CLOSE_TAG_NODE_T* html_close_tag_node = ((const AST_HTML_CLOSE_TAG_NODE_T *) node);
 
@@ -72,6 +81,33 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
 
     } break;
 
+    case AST_HTML_CONDITIONAL_ELEMENT_NODE: {
+      const AST_HTML_CONDITIONAL_ELEMENT_NODE_T* html_conditional_element_node = ((const AST_HTML_CONDITIONAL_ELEMENT_NODE_T *) node);
+
+      if (html_conditional_element_node->open_conditional != NULL) {
+        herb_visit_node((AST_NODE_T *) html_conditional_element_node->open_conditional, visitor, data);
+      }
+
+      if (html_conditional_element_node->open_tag != NULL) {
+        herb_visit_node((AST_NODE_T *) html_conditional_element_node->open_tag, visitor, data);
+      }
+
+      if (html_conditional_element_node->body != NULL) {
+        for (size_t index = 0; index < hb_array_size(html_conditional_element_node->body); index++) {
+          herb_visit_node(hb_array_get(html_conditional_element_node->body, index), visitor, data);
+        }
+      }
+
+      if (html_conditional_element_node->close_tag != NULL) {
+        herb_visit_node((AST_NODE_T *) html_conditional_element_node->close_tag, visitor, data);
+      }
+
+      if (html_conditional_element_node->close_conditional != NULL) {
+        herb_visit_node((AST_NODE_T *) html_conditional_element_node->close_conditional, visitor, data);
+      }
+
+    } break;
+
     case AST_HTML_ATTRIBUTE_VALUE_NODE: {
       const AST_HTML_ATTRIBUTE_VALUE_NODE_T* html_attribute_value_node = ((const AST_HTML_ATTRIBUTE_VALUE_NODE_T *) node);
 
@@ -107,6 +143,17 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
 
     } break;
 
+    case AST_ERB_OPEN_TAG_NODE: {
+      const AST_ERB_OPEN_TAG_NODE_T* erb_open_tag_node = ((const AST_ERB_OPEN_TAG_NODE_T *) node);
+
+      if (erb_open_tag_node->children != NULL) {
+        for (size_t index = 0; index < hb_array_size(erb_open_tag_node->children); index++) {
+          herb_visit_node(hb_array_get(erb_open_tag_node->children, index), visitor, data);
+        }
+      }
+
+    } break;
+
     case AST_HTML_COMMENT_NODE: {
       const AST_HTML_COMMENT_NODE_T* html_comment_node = ((const AST_HTML_COMMENT_NODE_T *) node);
 
@@ -374,6 +421,26 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
 
     } break;
 
+    case AST_RUBY_RENDER_LOCAL_NODE: {
+      const AST_RUBY_RENDER_LOCAL_NODE_T* ruby_render_local_node = ((const AST_RUBY_RENDER_LOCAL_NODE_T *) node);
+
+      if (ruby_render_local_node->value != NULL) {
+        herb_visit_node((AST_NODE_T *) ruby_render_local_node->value, visitor, data);
+      }
+
+    } break;
+
+    case AST_ERB_RENDER_NODE: {
+      const AST_ERB_RENDER_NODE_T* erb_render_node = ((const AST_ERB_RENDER_NODE_T *) node);
+
+      if (erb_render_node->locals != NULL) {
+        for (size_t index = 0; index < hb_array_size(erb_render_node->locals); index++) {
+          herb_visit_node(hb_array_get(erb_render_node->locals, index), visitor, data);
+        }
+      }
+
+    } break;
+
     case AST_ERB_IN_NODE: {
       const AST_ERB_IN_NODE_T* erb_in_node = ((const AST_ERB_IN_NODE_T *) node);
 

data/templates/ext/herb/error_helpers.c.erb

@@ -7,23 +7,33 @@
 #include "../../src/include/errors.h"
 #include "../../src/include/herb.h"
 #include "../../src/include/token.h"
+#include "../../src/include/util/hb_string.h"
 
 VALUE rb_error_from_c_struct(ERROR_T* error);
 
+static VALUE mErrors;
+static VALUE cError;
+<%- errors.each do |error| -%>
+static VALUE c<%= error.name %>;
+<%- end -%>
+
+void rb_init_error_classes(void) {
+  mErrors = rb_define_module_under(mHerb, "Errors");
+  cError = rb_define_class_under(mErrors, "Error", rb_cObject);
+  <%- errors.each do |error| -%>
+  c<%= error.name %> = rb_define_class_under(mErrors, "<%= error.name %>", cError);
+  <%- end -%>
+}
+
 <%- errors.each do |error| -%>
 static VALUE rb_<%= error.human %>_from_c_struct(<%= error.struct_type %>* <%= error.human %>) {
   if (<%= error.human %> == NULL) { return Qnil; }
 
   ERROR_T* error = &<%= error.human %>->base;
 
-  VALUE Herb = rb_define_module("Herb");
-  VALUE Errors = rb_define_module_under(Herb, "Errors");
-  VALUE Error = rb_define_class_under(Errors, "Error", rb_cObject);
-  VALUE <%= error.name %> = rb_define_class_under(Errors, "<%= error.name %>", Error);
-
-  VALUE type = rb_utf8_str_new_cstr(error_type_to_string(error));
+  VALUE type = rb_string_from_hb_string(error_type_to_string(error));
   VALUE location = rb_location_from_c_struct(error->location);
-  VALUE message = rb_utf8_str_new_cstr(error->message);
+  VALUE message = rb_string_from_hb_string(error->message);
 
   <%- error.fields.each do |field| -%>
   <%- case field -%>
@@ -32,11 +42,14 @@ static VALUE rb_<%= error.human %>_from_c_struct(<%= error.struct_type %>* <%= e
   <%- when Herb::Template::TokenField -%>
   VALUE <%= error.human %>_<%= field.name %> = rb_token_from_c_struct(<%= error.human %>-><%= field.name %>);
   <%- when Herb::Template::TokenTypeField -%>
-  VALUE <%= error.human %>_<%= field.name %> = rb_utf8_str_new_cstr(token_type_to_string(<%= error.human %>-><%= field.name %>));
+  hb_string_T _<%= field.name %>_string = token_type_to_string(<%= error.human %>-><%= field.name %>);
+  VALUE <%= error.human %>_<%= field.name %> = rb_utf8_str_new(_<%= field.name %>_string.data, _<%= field.name %>_string.length);
   <%- when Herb::Template::StringField -%>
-  VALUE <%= error.human %>_<%= field.name %> = rb_utf8_str_new_cstr(<%= error.human %>-><%= field.name %>);
+  VALUE <%= error.human %>_<%= field.name %> = rb_utf8_str_new(<%= error.human %>-><%= field.name %>.data, <%= error.human %>-><%= field.name %>.length);
+  <%- when Herb::Template::SizeTField -%>
+  VALUE <%= error.human %>_<%= field.name %> = ULONG2NUM(<%= error.human %>-><%= field.name %>);
   <%- else -%>
-  /* <%= field.inspect %> */
+  /* Unhandled field type: <%= field.class.name %> */
   VALUE <%= error.human %>_<%= field.name %> = Qnil;
   <%- end -%>
   <%- end -%>
@@ -50,7 +63,7 @@ static VALUE rb_<%= error.human %>_from_c_struct(<%= error.struct_type %>* <%= e
     <%- end -%>
   };
 
-  return rb_class_new_instance(<%= 3 + error.fields.count %>, args, <%= error.name %>);
+  return rb_class_new_instance(<%= 3 + error.fields.count %>, args, c<%= error.name %>);
 };
 
 <%- end -%>

data/templates/ext/herb/error_helpers.h.erb

@@ -6,6 +6,7 @@
 
 #include <ruby.h>
 
+void rb_init_error_classes(void);
 VALUE rb_error_from_c_struct(ERROR_T* error);
 VALUE rb_errors_array_from_c_array(hb_array_T* array);