herb 0.7.5 → 0.8.0

data/src/include/parser_helpers.h

@@ -1,47 +1,57 @@
 #ifndef HERB_PARSER_HELPERS_H
 #define HERB_PARSER_HELPERS_H
 
-#include "array.h"
 #include "ast_nodes.h"
-#include "buffer.h"
 #include "errors.h"
 #include "parser.h"
 #include "token.h"
+#include "util/hb_array.h"
+#include "util/hb_buffer.h"
+#include "util/hb_string.h"
 
 void parser_push_open_tag(const parser_T* parser, token_T* tag_name);
-bool parser_check_matching_tag(const parser_T* parser, const char* tag_name);
+bool parser_check_matching_tag(const parser_T* parser, hb_string_T tag_name);
 token_T* parser_pop_open_tag(const parser_T* parser);
 
-void parser_append_unexpected_error(parser_T* parser, const char* description, const char* expected, array_T* errors);
-void parser_append_unexpected_token_error(parser_T* parser, token_type_T expected_type, array_T* errors);
+void parser_append_unexpected_error(
+  parser_T* parser,
+  const char* description,
+  const char* expected,
+  hb_array_T* errors
+);
+void parser_append_unexpected_token_error(parser_T* parser, token_type_T expected_type, hb_array_T* errors);
 
 void parser_append_literal_node_from_buffer(
   const parser_T* parser,
-  buffer_T* buffer,
-  array_T* children,
+  hb_buffer_T* buffer,
+  hb_array_T* children,
   position_T start
 );
 
 bool parser_in_svg_context(const parser_T* parser);
 
-foreign_content_type_T parser_get_foreign_content_type(const char* tag_name);
-bool parser_is_foreign_content_tag(const char* tag_name);
-const char* parser_get_foreign_content_closing_tag(foreign_content_type_T type);
+foreign_content_type_T parser_get_foreign_content_type(hb_string_T tag_name);
+bool parser_is_foreign_content_tag(hb_string_T tag_name);
+hb_string_T parser_get_foreign_content_closing_tag(foreign_content_type_T type);
 
 void parser_enter_foreign_content(parser_T* parser, foreign_content_type_T type);
 void parser_exit_foreign_content(parser_T* parser);
 
-bool parser_is_expected_closing_tag_name(const char* tag_name, foreign_content_type_T expected_type);
+bool parser_is_expected_closing_tag_name(hb_string_T tag_name, foreign_content_type_T expected_type);
 
 token_T* parser_advance(parser_T* parser);
 token_T* parser_consume_if_present(parser_T* parser, token_type_T type);
-token_T* parser_consume_expected(parser_T* parser, token_type_T type, array_T* array);
+token_T* parser_consume_expected(parser_T* parser, token_type_T type, hb_array_T* array);
 
 AST_HTML_ELEMENT_NODE_T* parser_handle_missing_close_tag(
   AST_HTML_OPEN_TAG_NODE_T* open_tag,
-  array_T* body,
-  array_T* errors
+  hb_array_T* body,
+  hb_array_T* errors
+);
+void parser_handle_mismatched_tags(
+  const parser_T* parser,
+  const AST_HTML_CLOSE_TAG_NODE_T* close_tag,
+  hb_array_T* errors
 );
-void parser_handle_mismatched_tags(const parser_T* parser, const AST_HTML_CLOSE_TAG_NODE_T* close_tag, array_T* errors);
 
 #endif

data/src/include/pretty_print.h

@@ -3,91 +3,101 @@
 
 #include "analyzed_ruby.h"
 #include "ast_nodes.h"
-#include "buffer.h"
 #include "location.h"
+#include "util/hb_buffer.h"
 
 #include <stdbool.h>
 
-void pretty_print_indent(buffer_T* buffer, size_t indent);
-void pretty_print_newline(size_t indent, size_t relative_indent, buffer_T* buffer);
-void pretty_print_label(const char* name, size_t indent, size_t relative_indent, bool last_property, buffer_T* buffer);
+void pretty_print_indent(hb_buffer_T* buffer, size_t indent);
+void pretty_print_newline(size_t indent, size_t relative_indent, hb_buffer_T* buffer);
+void pretty_print_label(
+  hb_string_T name,
+  size_t indent,
+  size_t relative_indent,
+  bool last_property,
+  hb_buffer_T* buffer
+);
 
 void pretty_print_position_property(
   position_T* position,
-  const char* name,
+  hb_string_T name,
   size_t indent,
   size_t relative_indent,
   bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 );
 
-void pretty_print_location(location_T location, buffer_T* buffer);
+void pretty_print_location(location_T location, hb_buffer_T* buffer);
 
 void pretty_print_property(
-  const char* name,
-  const char* value,
+  hb_string_T name,
+  hb_string_T value,
   size_t indent,
   size_t relative_indent,
   bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 );
 
 void pretty_print_size_t_property(
   size_t value,
-  const char* name,
+  hb_string_T name,
   size_t indent,
   size_t relative_indent,
   bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 );
 
 void pretty_print_string_property(
-  const char* string,
-  const char* name,
+  hb_string_T string,
+  hb_string_T name,
   size_t indent,
   size_t relative_indent,
   bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 );
 
 void pretty_print_quoted_property(
-  const char* name,
-  const char* value,
+  hb_string_T name,
+  hb_string_T value,
   size_t indent,
   size_t relative_indent,
   bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 );
 
 void pretty_print_boolean_property(
-  const char* name,
+  hb_string_T name,
   bool value,
   size_t indent,
   size_t relative_indent,
   bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 );
 
 void pretty_print_token_property(
   token_T* token,
-  const char* name,
+  hb_string_T name,
   size_t indent,
   size_t relative_indent,
   bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 );
 
 void pretty_print_array(
-  const char* name,
-  array_T* array,
+  hb_string_T name,
+  hb_array_T* array,
   size_t indent,
   size_t relative_indent,
   bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 );
 
-void pretty_print_errors(AST_NODE_T* node, size_t indent, size_t relative_indent, bool last_property, buffer_T* buffer);
-
-void pretty_print_analyzed_ruby(analyzed_ruby_T* analyzed, const char* source);
+void pretty_print_errors(
+  AST_NODE_T* node,
+  size_t indent,
+  size_t relative_indent,
+  bool last_property,
+  hb_buffer_T* buffer
+);
 
 #endif

data/src/include/token.h

@@ -4,19 +4,16 @@
 #include "lexer_struct.h"
 #include "position.h"
 #include "token_struct.h"
+#include "util/hb_string.h"
 
-token_T* token_init(const char* value, token_type_T type, lexer_T* lexer);
-char* token_to_string(const token_T* token);
-char* token_to_json(const token_T* token);
+token_T* token_init(hb_string_T value, token_type_T type, lexer_T* lexer);
+hb_string_T token_to_string(const token_T* token);
 const char* token_type_to_string(token_type_T type);
 
-char* token_value(const token_T* token);
-int token_type(const token_T* token);
-
-size_t token_sizeof(void);
-
 token_T* token_copy(token_T* token);
 
 void token_free(token_T* token);
 
+bool token_value_empty(const token_T* token);
+
 #endif

data/src/include/utf8.h

@@ -2,10 +2,11 @@
 #define HERB_UTF8_H
 
 #include <stdbool.h>
+#include <stdint.h>
 #include <stdlib.h>
 
-int utf8_char_byte_length(unsigned char first_byte);
-int utf8_sequence_length(const char* str, size_t position, size_t max_length);
+uint32_t utf8_char_byte_length(unsigned char first_byte);
+uint32_t utf8_sequence_length(const char* str, size_t position, size_t max_length);
 bool utf8_is_valid_continuation_byte(unsigned char byte);
 
 #endif

data/src/include/util/hb_arena.h

@@ -0,0 +1,31 @@
+#ifndef HERB_ARENA_H
+#define HERB_ARENA_H
+
+#include <stdbool.h>
+#include <stddef.h>
+
+typedef struct HB_ARENA_PAGE_STRUCT hb_arena_page_T;
+
+struct HB_ARENA_PAGE_STRUCT {
+  hb_arena_page_T* next;
+  size_t capacity;
+  size_t position;
+  char memory[];
+};
+
+typedef struct HB_ARENA_STRUCT {
+  hb_arena_page_T* head;
+  hb_arena_page_T* tail;
+  size_t default_page_size;
+  size_t allocation_count;
+} hb_arena_T;
+
+bool hb_arena_init(hb_arena_T* allocator, size_t initial_size);
+void* hb_arena_alloc(hb_arena_T* allocator, size_t size);
+size_t hb_arena_position(hb_arena_T* allocator);
+size_t hb_arena_capacity(hb_arena_T* allocator);
+void hb_arena_reset(hb_arena_T* allocator);
+void hb_arena_reset_to(hb_arena_T* allocator, size_t new_position);
+void hb_arena_free(hb_arena_T* allocator);
+
+#endif

data/src/include/util/hb_arena_debug.h

@@ -0,0 +1,8 @@
+#ifndef HERB_ARENA_DEBUG_H
+#define HERB_ARENA_DEBUG_H
+
+#include "hb_arena.h"
+
+void hb_arena_print_stats(const hb_arena_T* allocator);
+
+#endif

data/src/include/util/hb_array.h

@@ -0,0 +1,33 @@
+#ifndef HERB_ARRAY_H
+#define HERB_ARRAY_H
+
+#include <stdlib.h>
+
+typedef struct HB_ARRAY_STRUCT {
+  void** items;
+  size_t size;
+  size_t capacity;
+} hb_array_T;
+
+hb_array_T* hb_array_init(size_t capacity);
+
+void* hb_array_get(const hb_array_T* array, size_t index);
+void* hb_array_first(hb_array_T* array);
+void* hb_array_last(hb_array_T* array);
+
+void hb_array_append(hb_array_T* array, void* item);
+void hb_array_set(const hb_array_T* array, size_t index, void* item);
+void hb_array_free(hb_array_T** array);
+void hb_array_remove(hb_array_T* array, size_t index);
+
+size_t hb_array_index_of(hb_array_T* array, void* item);
+void hb_array_remove_item(hb_array_T* array, void* item);
+
+void hb_array_push(hb_array_T* array, void* item);
+void* hb_array_pop(hb_array_T* array);
+
+size_t hb_array_capacity(const hb_array_T* array);
+size_t hb_array_size(const hb_array_T* array);
+size_t hb_array_sizeof(void);
+
+#endif

data/src/include/util/hb_buffer.h

@@ -0,0 +1,34 @@
+#ifndef HERB_BUFFER_H
+#define HERB_BUFFER_H
+
+#include "hb_string.h"
+
+#include <stdbool.h>
+#include <stdlib.h>
+
+typedef struct HB_BUFFER_STRUCT {
+  char* value;
+  size_t length;
+  size_t capacity;
+} hb_buffer_T;
+
+bool hb_buffer_init(hb_buffer_T* buffer, size_t capacity);
+
+void hb_buffer_append(hb_buffer_T* buffer, const char* text);
+void hb_buffer_append_with_length(hb_buffer_T* buffer, const char* text, size_t length);
+void hb_buffer_append_string(hb_buffer_T* buffer, hb_string_T string);
+void hb_buffer_append_char(hb_buffer_T* buffer, char character);
+void hb_buffer_append_whitespace(hb_buffer_T* buffer, size_t length);
+void hb_buffer_prepend(hb_buffer_T* buffer, const char* text);
+void hb_buffer_concat(hb_buffer_T* destination, hb_buffer_T* source);
+
+char* hb_buffer_value(const hb_buffer_T* buffer);
+
+size_t hb_buffer_length(const hb_buffer_T* buffer);
+size_t hb_buffer_capacity(const hb_buffer_T* buffer);
+size_t hb_buffer_sizeof(void);
+
+void hb_buffer_clear(hb_buffer_T* buffer);
+void hb_buffer_free(hb_buffer_T** buffer);
+
+#endif

data/src/include/util/hb_string.h

@@ -0,0 +1,29 @@
+#ifndef HERB_STRING_H
+#define HERB_STRING_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#include "hb_arena.h"
+
+typedef struct HB_STRING_STRUCT {
+  char* data;
+  uint32_t length;
+} hb_string_T;
+
+hb_string_T hb_string(const char* null_terminated_c_string);
+hb_string_T hb_string_slice(hb_string_T string, uint32_t offset);
+bool hb_string_equals(hb_string_T a, hb_string_T b);
+bool hb_string_equals_case_insensitive(hb_string_T a, hb_string_T b);
+bool hb_string_starts_with(hb_string_T string, hb_string_T expected_prefix);
+bool hb_string_is_empty(hb_string_T string);
+hb_string_T hb_string_truncate(hb_string_T string, uint32_t max_length);
+
+hb_string_T hb_string_range(hb_string_T string, uint32_t from, uint32_t to);
+
+char* hb_string_to_c_string_using_malloc(hb_string_T string);
+
+char* hb_string_to_c_string(hb_arena_T* allocator, hb_string_T string);
+
+#endif

data/src/include/util/hb_system.h

@@ -0,0 +1,9 @@
+#ifndef HERB_SYSTEM_H
+#define HERB_SYSTEM_H
+
+#include <stddef.h>
+
+void* hb_system_allocate_memory(size_t size);
+void hb_system_free_memory(void* ptr, size_t size);
+
+#endif

data/src/include/util.h

@@ -1,25 +1,14 @@
 #ifndef HERB_UTIL_H
 #define HERB_UTIL_H
 
+#include "util/hb_string.h"
 #include <stdbool.h>
 #include <stdlib.h>
 
-int is_whitespace(int character);
 int is_newline(int character);
 
-int count_in_string(const char* string, char character);
-int count_newlines(const char* string);
-
-char* replace_char(char* string, char find, char replace);
-char* escape_newlines(const char* input);
-char* quoted_string(const char* input);
-char* wrap_string(const char* input, char character);
-
-bool string_blank(const char* input);
-bool string_present(const char* input);
-
+hb_string_T escape_newlines(hb_string_T input);
+hb_string_T quoted_string(hb_string_T input);
 char* herb_strdup(const char* s);
 
-char* size_t_to_string(size_t value);
-
 #endif

data/src/include/version.h

@@ -1,6 +1,6 @@
 #ifndef HERB_VERSION_H
 #define HERB_VERSION_H
 
-#define HERB_VERSION "0.7.5"
+#define HERB_VERSION "0.8.0"
 
 #endif

data/src/include/visitor.h

@@ -1,9 +1,9 @@
 #ifndef HERB_VISITOR_H
 #define HERB_VISITOR_H
 
-#include "array.h"
 #include "ast_node.h"
 #include "ast_nodes.h"
+#include "util/hb_array.h"
 
 void herb_visit_node(const AST_NODE_T* node, bool (*visitor)(const AST_NODE_T*, void*), void* data);
 void herb_visit_child_nodes(const AST_NODE_T* node, bool (*visitor)(const AST_NODE_T* node, void* data), void* data);

data/src/io.c

@@ -1,5 +1,5 @@
 #include "include/io.h"
-#include "include/buffer.h"
+#include "include/util/hb_buffer.h"
 
 #include <errno.h>
 #include <stdio.h>
@@ -8,6 +8,8 @@
 #define FILE_READ_CHUNK 4096
 
 char* herb_read_file(const char* filename) {
+  if (!filename) { return NULL; }
+
   FILE* fp = fopen(filename, "rb");
 
   if (fp == NULL) {
@@ -15,16 +17,17 @@ char* herb_read_file(const char* filename) {
     exit(1);
   }
 
-  buffer_T buffer = buffer_new();
+  hb_buffer_T buffer;
+  hb_buffer_init(&buffer, 4096);
 
   char chunk[FILE_READ_CHUNK];
   size_t bytes_read;
 
   while ((bytes_read = fread(chunk, 1, FILE_READ_CHUNK, fp)) > 0) {
-    buffer_append_with_length(&buffer, chunk, bytes_read);
+    hb_buffer_append_with_length(&buffer, chunk, bytes_read);
   }
 
   fclose(fp);
 
-  return buffer_value(&buffer);
+  return hb_buffer_value(&buffer);
 }