herb 0.8.9-arm-linux-gnu → 0.9.0-arm-linux-gnu

data/src/include/util/hb_string.h

@@ -4,26 +4,73 @@
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h>
+#include <string.h>
+#include <strings.h>
 
-#include "hb_arena.h"
+#include "hb_allocator.h"
+#include "hb_foreach.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);
+#define HB_STRING_EMPTY ((hb_string_T) { .data = "", .length = 0 })
+#define HB_STRING_NULL ((hb_string_T) { .data = NULL, .length = 0 })
+
+#define HB_STRING_LITERAL(string) { .data = (char*) (string), .length = (uint32_t) (sizeof(string) - 1) }
+
+#define HB_STRING_LIST(...) { HB_FOR_EACH(HB_STRING_LITERAL, __VA_ARGS__) }
+
+#define hb_string(string)                                                                                              \
+  (__builtin_constant_p(string)                                                                                        \
+     ? ((hb_string_T) { .data = (char*) (string), .length = (uint32_t) __builtin_strlen(string) })                     \
+     : hb_string_from_c_string(string))
+
+hb_string_T hb_string_from_c_string(const char* null_terminated_c_string);
+
+static inline bool hb_string_is_null(hb_string_T string) {
+  return string.data == NULL;
+}
+
+static inline bool hb_string_is_empty(hb_string_T string) {
+  return string.data == NULL || string.length == 0;
+}
+
+static inline hb_string_T hb_string_slice(hb_string_T string, uint32_t offset) {
+  if (string.length < offset) { return HB_STRING_NULL; }
+
+  return (hb_string_T) { .data = string.data + offset, .length = string.length - offset };
+}
 
+static inline 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;
+}
+
+static inline bool hb_string_equals_case_insensitive(hb_string_T a, hb_string_T b) {
+  if (a.length != b.length) { return false; }
+
+  return strncasecmp(a.data, b.data, a.length) == 0;
+}
+
+static inline 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; }
+
+  return strncmp(string.data, expected_prefix.data, expected_prefix.length) == 0;
+}
+
+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);
+hb_string_T hb_string_trim_start(hb_string_T string);
+hb_string_T hb_string_trim_end(hb_string_T string);
+hb_string_T hb_string_trim(hb_string_T string);
+bool hb_string_is_blank(hb_string_T string);
+hb_string_T hb_string_copy(hb_string_T string, hb_allocator_T* allocator);
 
 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/string.h

@@ -0,0 +1,11 @@
+#ifndef HERB_UTILS_STRING_H
+#define HERB_UTILS_STRING_H
+
+#include <stdbool.h>
+#include <string.h>
+
+static inline bool string_equals(const char* a, const char* b) {
+  return strcmp(a, b) == 0;
+}
+
+#endif

data/src/include/util.h

@@ -5,10 +5,13 @@
 #include <stdbool.h>
 #include <stdlib.h>
 
+struct hb_allocator;
+
 int is_newline(int character);
+int is_whitespace(int character);
+hb_string_T escape_newlines(struct hb_allocator* allocator, hb_string_T input);
+hb_string_T quoted_string(struct hb_allocator* allocator, hb_string_T 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* convert_underscores_to_dashes(const char* input);
 
 #endif

data/src/include/version.h

@@ -1,6 +1,6 @@
 #ifndef HERB_VERSION_H
 #define HERB_VERSION_H
 
-#define HERB_VERSION "0.8.9"
+#define HERB_VERSION "0.9.0"
 
 #endif

data/src/io.c

@@ -1,4 +1,5 @@
 #include "include/io.h"
+#include "include/util/hb_allocator.h"
 #include "include/util/hb_buffer.h"
 
 #include <errno.h>
@@ -7,7 +8,7 @@
 
 #define FILE_READ_CHUNK 4096
 
-char* herb_read_file(const char* filename) {
+char* herb_read_file(const char* filename, struct hb_allocator* allocator) {
   if (!filename) { return NULL; }
 
   FILE* fp = fopen(filename, "rb");
@@ -18,7 +19,7 @@ char* herb_read_file(const char* filename) {
   }
 
   hb_buffer_T buffer;
-  hb_buffer_init(&buffer, 4096);
+  hb_buffer_init(&buffer, 4096, allocator);
 
   char chunk[FILE_READ_CHUNK];
   size_t bytes_read;

data/src/lexer.c

@@ -1,15 +1,18 @@
 #include "include/lexer_peek_helpers.h"
+#include "include/macros.h"
 #include "include/token.h"
 #include "include/utf8.h"
 #include "include/util.h"
-#include "include/util/hb_buffer.h"
 #include "include/util/hb_string.h"
 
 #include <ctype.h>
+#include <stdint.h>
 #include <string.h>
 
 #define LEXER_STALL_LIMIT 5
 
+static hb_string_T erb_open_patterns[] = HB_STRING_LIST("<%==", "<%%=", "<%graphql", "<%=", "<%#", "<%-", "<%%", "<%");
+
 static bool lexer_eof(const lexer_T* lexer) {
   return lexer->current_character == '\0' || lexer->stalled;
 }
@@ -31,11 +34,13 @@ static bool lexer_stalled(lexer_T* lexer) {
   return lexer->stalled;
 }
 
-void lexer_init(lexer_T* lexer, const char* source) {
+void lexer_init(lexer_T* lexer, const char* source, hb_allocator_T* allocator) {
+  lexer->allocator = allocator;
+
   if (source != NULL) {
     lexer->source = hb_string(source);
   } else {
-    lexer->source = hb_string("");
+    lexer->source = HB_STRING_EMPTY;
   }
 
   lexer->current_character = lexer->source.data[0];
@@ -55,11 +60,11 @@ void lexer_init(lexer_T* lexer, const char* source) {
 }
 
 token_T* lexer_error(lexer_T* lexer, const char* message) {
-  char error_message[128];
+  char buffer[128];
 
   snprintf(
-    error_message,
-    sizeof(error_message),
+    buffer,
+    sizeof(buffer),
     "[Lexer] Error: %s (character '%c', line %u, col %u)\n",
     message,
     lexer->current_character,
@@ -67,7 +72,10 @@ token_T* lexer_error(lexer_T* lexer, const char* message) {
     lexer->current_column
   );
 
-  return token_init(hb_string(error_message), TOKEN_ERROR, lexer);
+  size_t length = strlen(buffer);
+  char* error_message = hb_allocator_strndup(lexer->allocator, buffer, length);
+
+  return token_init((hb_string_T) { .data = error_message, .length = (uint32_t) length }, TOKEN_ERROR, lexer);
 }
 
 static void lexer_advance(lexer_T* lexer) {
@@ -79,8 +87,8 @@ static void lexer_advance(lexer_T* lexer) {
   }
 }
 
-static void lexer_advance_utf8_bytes(lexer_T* lexer, int byte_count) {
-  if (byte_count <= 0) { return; }
+static void lexer_advance_utf8_bytes(lexer_T* lexer, uint32_t byte_count) {
+  if (byte_count == 0) { return; }
 
   if (lexer_has_more_characters(lexer) && !lexer_eof(lexer)) {
     if (!is_newline(lexer->current_character)) { lexer->current_column++; }
@@ -120,19 +128,17 @@ static token_T* lexer_advance_with_next(lexer_T* lexer, size_t count, token_type
 }
 
 static token_T* lexer_advance_current(lexer_T* lexer, const token_type_T type) {
-  char buffer[2];
-  buffer[0] = lexer->current_character;
-  buffer[1] = '\0';
-
-  return lexer_advance_with(lexer, hb_string(buffer), type);
+  return lexer_advance_with_next(lexer, 1, type);
 }
 
 static token_T* lexer_advance_utf8_character(lexer_T* lexer, const token_type_T type) {
-  int char_byte_length = utf8_sequence_length(lexer->source.data, lexer->current_position, lexer->source.length);
+  uint32_t char_byte_length = utf8_sequence_length(hb_string_slice(lexer->source, lexer->current_position));
+
   if (char_byte_length <= 1) { return lexer_advance_current(lexer, type); }
+
   uint32_t start_position = lexer->current_position;
 
-  for (int i = 0; i < char_byte_length; i++) {
+  for (uint32_t i = 0; i < char_byte_length; i++) {
     if (lexer->current_position + i >= lexer->source.length) { return lexer_advance_current(lexer, type); }
   }
 
@@ -171,7 +177,8 @@ static token_T* lexer_parse_identifier(lexer_T* lexer) {
 
   while ((isalnum(lexer->current_character) || lexer->current_character == '-' || lexer->current_character == '_'
           || lexer->current_character == ':')
-         && !lexer_peek_for_html_comment_end(lexer, 0) && !lexer_eof(lexer)) {
+         && !lexer_peek_for_html_comment_end(lexer, 0) && !lexer_peek_for_html_comment_invalid_end(lexer, 0)
+         && !lexer_eof(lexer)) {
 
     lexer_advance(lexer);
   }
@@ -185,13 +192,9 @@ static token_T* lexer_parse_identifier(lexer_T* lexer) {
 // ===== ERB Parsing
 
 static token_T* lexer_parse_erb_open(lexer_T* lexer) {
-  hb_string_T erb_patterns[] = { hb_string("<%=="), hb_string("<%%="), hb_string("<%="),       hb_string("<%#"),
-                                 hb_string("<%-"),  hb_string("<%%"),  hb_string("<%graphql"), hb_string("<%") };
-
   lexer->state = STATE_ERB_CONTENT;
-
-  for (size_t i = 0; i < sizeof(erb_patterns) / sizeof(erb_patterns[0]); i++) {
-    token_T* match = lexer_match_and_advance(lexer, erb_patterns[i], TOKEN_ERB_START);
+  for (size_t i = 0; i < sizeof(erb_open_patterns) / sizeof(erb_open_patterns[0]); i++) {
+    token_T* match = lexer_match_and_advance(lexer, erb_open_patterns[i], TOKEN_ERB_START);
     if (match) { return match; }
   }
 
@@ -203,11 +206,17 @@ static token_T* lexer_parse_erb_content(lexer_T* lexer) {
 
   while (!lexer_peek_erb_end(lexer, 0)) {
     if (lexer_eof(lexer)) {
-      token_T* token = token_init(
-        hb_string_range(lexer->source, start_position, lexer->current_position),
-        TOKEN_ERROR,
-        lexer
-      ); // Handle unexpected EOF
+      token_T* token =
+        token_init(hb_string_range(lexer->source, start_position, lexer->current_position), TOKEN_ERB_CONTENT, lexer);
+
+      return token;
+    }
+
+    if (lexer_peek_erb_start(lexer, 0)) {
+      lexer->state = STATE_DATA;
+
+      token_T* token =
+        token_init(hb_string_range(lexer->source, start_position, lexer->current_position), TOKEN_ERB_CONTENT, lexer);
 
       return token;
     }
@@ -244,7 +253,7 @@ static token_T* lexer_parse_erb_close(lexer_T* lexer) {
 // ===== Tokenizing Function
 
 token_T* lexer_next_token(lexer_T* lexer) {
-  if (lexer_eof(lexer)) { return token_init(hb_string(""), TOKEN_EOF, lexer); }
+  if (lexer_eof(lexer)) { return token_init(HB_STRING_EMPTY, TOKEN_EOF, lexer); }
   if (lexer_stalled(lexer)) { return lexer_error(lexer, "Lexer stalled after 5 iterations"); }
 
   if (lexer->state == STATE_ERB_CONTENT) { return lexer_parse_erb_content(lexer); }
@@ -302,7 +311,10 @@ token_T* lexer_next_token(lexer_T* lexer) {
     }
 
     case '-': {
-      token_T* token = lexer_match_and_advance(lexer, hb_string("-->"), TOKEN_HTML_COMMENT_END);
+      token_T* token = lexer_match_and_advance(lexer, hb_string("--!>"), TOKEN_HTML_COMMENT_INVALID_END);
+      if (token) { return token; }
+
+      token = lexer_match_and_advance(lexer, hb_string("-->"), TOKEN_HTML_COMMENT_END);
       return token ? token : lexer_advance_current(lexer, TOKEN_DASH);
     }
 

data/src/lexer_peek_helpers.c

@@ -1,22 +1,10 @@
 #include "include/lexer_peek_helpers.h"
 #include "include/lexer.h"
-#include "include/lexer_struct.h"
-#include "include/macros.h"
 #include "include/token.h"
-#include "include/util/hb_string.h"
 
 #include <ctype.h>
-#include <stdbool.h>
 
-char lexer_backtrack(const lexer_T* lexer, uint32_t offset) {
-  return lexer->source.data[MAX(lexer->current_position - offset, 0)];
-}
-
-char lexer_peek(const lexer_T* lexer, uint32_t offset) {
-  return lexer->source.data[MIN(lexer->current_position + offset, lexer->source.length)];
-}
-
-bool lexer_peek_for(const lexer_T* lexer, uint32_t offset, hb_string_T pattern, const bool case_insensitive) {
+static bool lexer_peek_for(const lexer_T* lexer, uint32_t offset, hb_string_T pattern, bool case_insensitive) {
   hb_string_T remaining_source = hb_string_slice(lexer->source, lexer->current_position + offset);
   remaining_source.length = MIN(pattern.length, remaining_source.length);
 
@@ -47,31 +35,19 @@ bool lexer_peek_for_html_comment_start(const lexer_T* lexer, uint32_t offset) {
   return lexer_peek_for(lexer, offset, hb_string("<!--"), false);
 }
 
-bool lexer_peek_for_html_comment_end(const lexer_T* lexer, uint32_t offset) {
-  return lexer_peek_for(lexer, offset, hb_string("-->"), false);
-}
-
-bool lexer_peek_erb_close_tag(const lexer_T* lexer, uint32_t offset) {
-  return lexer_peek_for(lexer, offset, hb_string("%>"), false);
-}
+bool lexer_peek_for_close_tag_start(const lexer_T* lexer, uint32_t offset) {
+  if (lexer_peek(lexer, offset) != '<' || lexer_peek(lexer, offset + 1) != '/') { return false; }
 
-bool lexer_peek_erb_dash_close_tag(const lexer_T* lexer, uint32_t offset) {
-  return lexer_peek_for(lexer, offset, hb_string("-%>"), false);
-}
+  uint32_t position = offset + 2;
 
-bool lexer_peek_erb_percent_close_tag(const lexer_T* lexer, uint32_t offset) {
-  return lexer_peek_for(lexer, offset, hb_string("%%>"), false);
-}
+  while (lexer_peek(lexer, position) == ' ' || lexer_peek(lexer, position) == '\t'
+         || lexer_peek(lexer, position) == '\n' || lexer_peek(lexer, position) == '\r') {
+    position++;
+  }
 
-bool lexer_peek_erb_equals_close_tag(const lexer_T* lexer, uint32_t offset) {
-  return lexer_peek_for(lexer, offset, hb_string("=%>"), false);
-}
+  char character = lexer_peek(lexer, position);
 
-bool lexer_peek_erb_end(const lexer_T* lexer, uint32_t offset) {
-  return (
-    lexer_peek_erb_close_tag(lexer, offset) || lexer_peek_erb_dash_close_tag(lexer, offset)
-    || lexer_peek_erb_percent_close_tag(lexer, offset) || lexer_peek_erb_equals_close_tag(lexer, offset)
-  );
+  return isalpha(character) || character == '_';
 }
 
 bool lexer_peek_for_token_type_after_whitespace(lexer_T* lexer, token_type_T token_type) {
@@ -84,13 +60,13 @@ bool lexer_peek_for_token_type_after_whitespace(lexer_T* lexer, token_type_T tok
   token_T* token = lexer_next_token(lexer);
 
   while (token && (token->type == TOKEN_WHITESPACE || token->type == TOKEN_NEWLINE)) {
-    token_free(token);
+    token_free(token, lexer->allocator);
     token = lexer_next_token(lexer);
   }
 
   bool result = (token && token->type == token_type);
 
-  if (token) { token_free(token); }
+  if (token) { token_free(token, lexer->allocator); }
 
   lexer->current_position = saved_position;
   lexer->current_line = saved_line;
@@ -100,41 +76,3 @@ bool lexer_peek_for_token_type_after_whitespace(lexer_T* lexer, token_type_T tok
 
   return result;
 }
-
-bool lexer_peek_for_close_tag_start(const lexer_T* lexer, uint32_t offset) {
-  if (lexer_peek(lexer, offset) != '<' || lexer_peek(lexer, offset + 1) != '/') { return false; }
-
-  uint32_t pos = offset + 2;
-
-  while (lexer_peek(lexer, pos) == ' ' || lexer_peek(lexer, pos) == '\t' || lexer_peek(lexer, pos) == '\n'
-         || lexer_peek(lexer, pos) == '\r') {
-    pos++;
-  }
-
-  char c = lexer_peek(lexer, pos);
-
-  return isalpha(c) || c == '_';
-}
-
-lexer_state_snapshot_T lexer_save_state(lexer_T* lexer) {
-  lexer_state_snapshot_T snapshot = { .position = lexer->current_position,
-                                      .line = lexer->current_line,
-                                      .column = lexer->current_column,
-                                      .previous_position = lexer->previous_position,
-                                      .previous_line = lexer->previous_line,
-                                      .previous_column = lexer->previous_column,
-                                      .current_character = lexer->current_character,
-                                      .state = lexer->state };
-  return snapshot;
-}
-
-void lexer_restore_state(lexer_T* lexer, lexer_state_snapshot_T snapshot) {
-  lexer->current_position = snapshot.position;
-  lexer->current_line = snapshot.line;
-  lexer->current_column = snapshot.column;
-  lexer->previous_position = snapshot.previous_position;
-  lexer->previous_line = snapshot.previous_line;
-  lexer->previous_column = snapshot.previous_column;
-  lexer->current_character = snapshot.current_character;
-  lexer->state = snapshot.state;
-}

data/src/location.c

@@ -17,8 +17,8 @@ void location_from_positions(location_T* location, position_T start, position_T
   location->end = end;
 }
 
-location_T* location_create(position_T start, position_T end) {
-  location_T* location = malloc(sizeof(location_T));
+location_T* location_create(position_T start, position_T end, hb_allocator_T* allocator) {
+  location_T* location = hb_allocator_alloc(allocator, sizeof(location_T));
 
   if (location != NULL) {
     location->start = start;

data/src/main.c

@@ -1,16 +1,26 @@
 #define _POSIX_C_SOURCE 199309L // Enables `clock_gettime()`
 
-#include "include/analyze.h"
 #include "include/ast_node.h"
 #include "include/ast_nodes.h"
-#include "include/ast_pretty_print.h"
+
+#ifndef HERB_EXCLUDE_PRETTYPRINT
+#  include "include/ast_pretty_print.h"
+#endif
+
 #include "include/extract.h"
 #include "include/herb.h"
 #include "include/io.h"
+#include "include/lex_helpers.h"
+#include "include/macros.h"
 #include "include/ruby_parser.h"
+#include "include/util/hb_allocator.h"
+#include "include/util/hb_arena.h"
+#include "include/util/hb_arena_debug.h"
 #include "include/util/hb_buffer.h"
+#include "include/util/string.h"
 
 #include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
 #include <time.h>
 
@@ -34,125 +44,128 @@ void print_time_diff(const struct timespec start, const struct timespec end, con
 
 int main(const int argc, char* argv[]) {
   if (argc < 2) {
-    printf("./herb [command] [options]\n\n");
+    puts("./herb [command] [options]\n");
 
-    printf("Herb 🌿 Powerful and seamless HTML-aware ERB parsing and tooling.\n\n");
+    puts("Herb 🌿 Powerful and seamless HTML-aware ERB toolchain.\n");
 
-    printf("./herb lex [file]      -  Lex a file\n");
-    printf("./herb parse [file]    -  Parse a file\n");
-    printf("./herb ruby [file]     -  Extract Ruby from a file\n");
-    printf("./herb html [file]     -  Extract HTML from a file\n");
-    printf("./herb prism [file]    -  Extract Ruby from a file and parse the Ruby source with Prism\n");
+    puts("./herb lex [file]      -  Lex a file");
+    puts("./herb parse [file]    -  Parse a file");
+    puts("./herb ruby [file]     -  Extract Ruby from a file");
+    puts("./herb html [file]     -  Extract HTML from a file");
+    puts("./herb prism [file]    -  Extract Ruby from a file and parse the Ruby source with Prism");
 
-    return 1;
+    return EXIT_FAILURE;
   }
 
   if (argc < 3) {
-    printf("Please specify input file.\n");
-    return 1;
+    puts("Please specify input file.");
+    return EXIT_FAILURE;
   }
 
-  hb_buffer_T output;
+  hb_allocator_T malloc_allocator = hb_allocator_with_malloc();
+  char* source = herb_read_file(argv[2], &malloc_allocator);
 
-  if (!hb_buffer_init(&output, 4096)) { return 1; }
+  hb_allocator_T allocator;
+  if (!hb_allocator_init(&allocator, HB_ALLOCATOR_ARENA)) {
+    fprintf(stderr, "Failed to initialize allocator\n");
+    hb_allocator_dealloc(&malloc_allocator, source);
+    return EXIT_FAILURE;
+  }
 
-  char* source = herb_read_file(argv[2]);
+  hb_buffer_T output;
+  if (!hb_buffer_init(&output, 4096, &allocator)) { return 1; }
 
   struct timespec start, end;
   clock_gettime(CLOCK_MONOTONIC, &start);
 
-  if (strcmp(argv[1], "visit") == 0) {
-    AST_DOCUMENT_NODE_T* root = herb_parse(source, NULL);
-    clock_gettime(CLOCK_MONOTONIC, &end);
-
-    herb_analyze_parse_tree(root, source);
-
-    ast_pretty_print_node((AST_NODE_T*) root, 0, 0, &output);
-    printf("%s\n", output.value);
-
-    print_time_diff(start, end, "visiting");
+  int silent = 0;
+  if (argc > 3 && string_equals(argv[3], "--silent")) { silent = 1; }
 
-    ast_node_free((AST_NODE_T*) root);
-    free(output.value);
-    free(source);
-
-    return 0;
-  }
-
-  if (strcmp(argv[1], "lex") == 0) {
-    herb_lex_to_buffer(source, &output);
+  if (string_equals(argv[1], "lex")) {
+    herb_lex_to_buffer(source, &output, &allocator);
     clock_gettime(CLOCK_MONOTONIC, &end);
 
-    printf("%s\n", output.value);
+    if (!silent) { hb_arena_print_stats((hb_arena_T*) allocator.context); }
+
+    puts(output.value);
     print_time_diff(start, end, "lexing");
 
-    free(output.value);
-    free(source);
+    hb_buffer_free(&output);
+    hb_allocator_destroy(&allocator);
+    hb_allocator_dealloc(&malloc_allocator, source);
 
-    return 0;
+    return EXIT_SUCCESS;
   }
 
-  if (strcmp(argv[1], "parse") == 0) {
-    AST_DOCUMENT_NODE_T* root = herb_parse(source, NULL);
-
-    herb_analyze_parse_tree(root, source);
+  if (string_equals(argv[1], "parse")) {
+    AST_DOCUMENT_NODE_T* root = herb_parse(source, NULL, &allocator);
 
     clock_gettime(CLOCK_MONOTONIC, &end);
 
-    int silent = 0;
-    if (argc > 3 && strcmp(argv[3], "--silent") == 0) { silent = 1; }
-
     if (!silent) {
+      hb_arena_print_stats((hb_arena_T*) allocator.context);
+
+#ifndef HERB_EXCLUDE_PRETTYPRINT
       ast_pretty_print_node((AST_NODE_T*) root, 0, 0, &output);
-      printf("%s\n", output.value);
+      puts(output.value);
+#endif
 
       print_time_diff(start, end, "parsing");
     }
 
-    ast_node_free((AST_NODE_T*) root);
-    free(output.value);
-    free(source);
+    ast_node_free((AST_NODE_T*) root, &allocator);
 
-    return 0;
+    hb_buffer_free(&output);
+    hb_allocator_destroy(&allocator);
+    hb_allocator_dealloc(&malloc_allocator, source);
+
+    return EXIT_SUCCESS;
   }
 
-  if (strcmp(argv[1], "ruby") == 0) {
-    herb_extract_ruby_to_buffer(source, &output);
+  if (string_equals(argv[1], "ruby")) {
+    herb_extract_ruby_to_buffer(source, &output, &allocator);
     clock_gettime(CLOCK_MONOTONIC, &end);
 
-    printf("%s\n", output.value);
+    puts(output.value);
     print_time_diff(start, end, "extracting Ruby");
 
-    free(output.value);
-    free(source);
+    hb_buffer_free(&output);
+    hb_allocator_destroy(&allocator);
+    hb_allocator_dealloc(&malloc_allocator, source);
 
-    return 0;
+    return EXIT_SUCCESS;
   }
 
-  if (strcmp(argv[1], "html") == 0) {
-    herb_extract_html_to_buffer(source, &output);
+  if (string_equals(argv[1], "html")) {
+    herb_extract_html_to_buffer(source, &output, &allocator);
     clock_gettime(CLOCK_MONOTONIC, &end);
 
-    printf("%s\n", output.value);
+    puts(output.value);
     print_time_diff(start, end, "extracting HTML");
 
-    free(output.value);
-    free(source);
+    hb_buffer_free(&output);
+    hb_allocator_destroy(&allocator);
+    hb_allocator_dealloc(&malloc_allocator, source);
 
-    return 0;
+    return EXIT_SUCCESS;
   }
 
-  if (strcmp(argv[1], "prism") == 0) {
+  if (string_equals(argv[1], "prism")) {
     printf("HTML+ERB File: \n%s\n", source);
 
-    char* ruby_source = herb_extract(source, HERB_EXTRACT_LANGUAGE_RUBY);
+    char* ruby_source = herb_extract(source, HERB_EXTRACT_LANGUAGE_RUBY, &allocator);
     printf("Extracted Ruby: \n%s\n", ruby_source);
 
     herb_parse_ruby_to_stdout(ruby_source);
 
-    return 0;
+    hb_allocator_dealloc(&allocator, ruby_source);
+    hb_buffer_free(&output);
+    hb_allocator_destroy(&allocator);
+    hb_allocator_dealloc(&malloc_allocator, source);
+
+    return EXIT_SUCCESS;
   }
 
   printf("Unknown Command: %s\n", argv[1]);
-  return 1;
+  return EXIT_FAILURE;
 }