herb 0.7.4-aarch64-linux-gnu → 0.8.0-aarch64-linux-gnu

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);
 }

data/src/lexer.c

@@ -1,24 +1,21 @@
-#include "include/buffer.h"
 #include "include/lexer_peek_helpers.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 <string.h>
 
 #define LEXER_STALL_LIMIT 5
 
-static size_t lexer_sizeof(void) {
-  return sizeof(struct LEXER_STRUCT);
-}
-
 static bool lexer_eof(const lexer_T* lexer) {
   return lexer->current_character == '\0' || lexer->stalled;
 }
 
 static bool lexer_has_more_characters(const lexer_T* lexer) {
-  return lexer->current_position < lexer->source_length;
+  return lexer->current_position < lexer->source.length;
 }
 
 static bool lexer_stalled(lexer_T* lexer) {
@@ -34,17 +31,16 @@ static bool lexer_stalled(lexer_T* lexer) {
   return lexer->stalled;
 }
 
-lexer_T* lexer_init(const char* source) {
-  if (source == NULL) { source = ""; }
-
-  lexer_T* lexer = calloc(1, lexer_sizeof());
+void lexer_init(lexer_T* lexer, const char* source) {
+  if (source != NULL) {
+    lexer->source = hb_string(source);
+  } else {
+    lexer->source = hb_string("");
+  }
 
+  lexer->current_character = lexer->source.data[0];
   lexer->state = STATE_DATA;
 
-  lexer->source = source;
-  lexer->source_length = strlen(source);
-  lexer->current_character = source[0];
-
   lexer->current_line = 1;
   lexer->current_column = 0;
   lexer->current_position = 0;
@@ -56,8 +52,6 @@ lexer_T* lexer_init(const char* source) {
   lexer->stall_counter = 0;
   lexer->last_position = 0;
   lexer->stalled = false;
-
-  return lexer;
 }
 
 token_T* lexer_error(lexer_T* lexer, const char* message) {
@@ -66,14 +60,14 @@ token_T* lexer_error(lexer_T* lexer, const char* message) {
   snprintf(
     error_message,
     sizeof(error_message),
-    "[Lexer] Error: %s (character '%c', line %zu, col %zu)\n",
+    "[Lexer] Error: %s (character '%c', line %u, col %u)\n",
     message,
     lexer->current_character,
     lexer->current_line,
     lexer->current_column
   );
 
-  return token_init(error_message, TOKEN_ERROR, lexer);
+  return token_init(hb_string(error_message), TOKEN_ERROR, lexer);
 }
 
 static void lexer_advance(lexer_T* lexer) {
@@ -81,7 +75,7 @@ static void lexer_advance(lexer_T* lexer) {
     if (!is_newline(lexer->current_character)) { lexer->current_column++; }
 
     lexer->current_position++;
-    lexer->current_character = lexer->source[lexer->current_position];
+    lexer->current_character = lexer->source.data[lexer->current_position];
   }
 }
 
@@ -93,11 +87,11 @@ static void lexer_advance_utf8_bytes(lexer_T* lexer, int byte_count) {
 
     lexer->current_position += byte_count;
 
-    if (lexer->current_position >= lexer->source_length) {
-      lexer->current_position = lexer->source_length;
+    if (lexer->current_position >= lexer->source.length) {
+      lexer->current_position = lexer->source.length;
       lexer->current_character = '\0';
     } else {
-      lexer->current_character = lexer->source[lexer->current_position];
+      lexer->current_character = lexer->source.data[lexer->current_position];
     }
   }
 }
@@ -108,65 +102,50 @@ static void lexer_advance_by(lexer_T* lexer, const size_t count) {
   }
 }
 
-static token_T* lexer_advance_with(lexer_T* lexer, const char* value, const token_type_T type) {
-  lexer_advance_by(lexer, strlen(value));
+static token_T* lexer_advance_with(lexer_T* lexer, hb_string_T value, const token_type_T type) {
+  lexer_advance_by(lexer, value.length);
   return token_init(value, type, lexer);
 }
 
 static token_T* lexer_advance_with_next(lexer_T* lexer, size_t count, token_type_T type) {
-  char* collected = malloc(count + 1);
-  if (!collected) { return NULL; }
+  uint32_t start_position = lexer->current_position;
 
   for (size_t i = 0; i < count; i++) {
-    collected[i] = lexer->current_character;
     lexer_advance(lexer);
   }
 
-  collected[count] = '\0';
-
-  token_T* token = token_init(collected, type, lexer);
-  free(collected);
+  token_T* token = token_init(hb_string_range(lexer->source, start_position, lexer->current_position), type, lexer);
 
   return token;
 }
 
 static token_T* lexer_advance_current(lexer_T* lexer, const token_type_T type) {
-  return lexer_advance_with(lexer, (char[]) { lexer->current_character, '\0' }, type);
+  char buffer[2];
+  buffer[0] = lexer->current_character;
+  buffer[1] = '\0';
+
+  return lexer_advance_with(lexer, hb_string(buffer), 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, lexer->current_position, lexer->source_length);
-
+  int char_byte_length = utf8_sequence_length(lexer->source.data, lexer->current_position, lexer->source.length);
   if (char_byte_length <= 1) { return lexer_advance_current(lexer, type); }
-
-  char* utf8_char = malloc(char_byte_length + 1);
-
-  if (!utf8_char) { return lexer_advance_current(lexer, type); }
+  uint32_t start_position = lexer->current_position;
 
   for (int i = 0; i < char_byte_length; i++) {
-    if (lexer->current_position + i >= lexer->source_length) {
-      free(utf8_char);
-      return lexer_advance_current(lexer, type);
-    }
-
-    utf8_char[i] = lexer->source[lexer->current_position + i];
+    if (lexer->current_position + i >= lexer->source.length) { return lexer_advance_current(lexer, type); }
   }
 
-  utf8_char[char_byte_length] = '\0';
-
   lexer_advance_utf8_bytes(lexer, char_byte_length);
 
-  token_T* token = token_init(utf8_char, type, lexer);
-
-  free(utf8_char);
+  token_T* token = token_init(hb_string_range(lexer->source, start_position, lexer->current_position), type, lexer);
 
   return token;
 }
 
-static token_T* lexer_match_and_advance(lexer_T* lexer, const char* value, const token_type_T type) {
-  if (strncmp(lexer->source + lexer->current_position, value, strlen(value)) == 0) {
-    return lexer_advance_with(lexer, value, type);
-  }
+static token_T* lexer_match_and_advance(lexer_T* lexer, hb_string_T value, const token_type_T type) {
+  hb_string_T remaining_source = hb_string_slice(lexer->source, lexer->current_position);
+  if (hb_string_starts_with(remaining_source, value)) { return lexer_advance_with(lexer, value, type); }
 
   return NULL;
 }
@@ -174,35 +153,31 @@ static token_T* lexer_match_and_advance(lexer_T* lexer, const char* value, const
 // ===== Specialized Parsers
 
 static token_T* lexer_parse_whitespace(lexer_T* lexer) {
-  buffer_T buffer = buffer_new();
+  uint32_t start_position = lexer->current_position;
 
   while (isspace(lexer->current_character) && lexer->current_character != '\n' && lexer->current_character != '\r'
          && !lexer_eof(lexer)) {
-    buffer_append_char(&buffer, lexer->current_character);
     lexer_advance(lexer);
   }
 
-  token_T* token = token_init(buffer.value, TOKEN_WHITESPACE, lexer);
-
-  buffer_free(&buffer);
+  token_T* token =
+    token_init(hb_string_range(lexer->source, start_position, lexer->current_position), TOKEN_WHITESPACE, lexer);
 
   return token;
 }
 
 static token_T* lexer_parse_identifier(lexer_T* lexer) {
-  buffer_T buffer = buffer_new();
+  uint32_t start_position = lexer->current_position;
 
   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)) {
 
-    buffer_append_char(&buffer, lexer->current_character);
     lexer_advance(lexer);
   }
 
-  token_T* token = token_init(buffer.value, TOKEN_IDENTIFIER, lexer);
-
-  buffer_free(&buffer);
+  token_T* token =
+    token_init(hb_string_range(lexer->source, start_position, lexer->current_position), TOKEN_IDENTIFIER, lexer);
 
   return token;
 }
@@ -210,7 +185,8 @@ static token_T* lexer_parse_identifier(lexer_T* lexer) {
 // ===== ERB Parsing
 
 static token_T* lexer_parse_erb_open(lexer_T* lexer) {
-  const char* erb_patterns[] = { "<%==", "<%%=", "<%=", "<%#", "<%-", "<%%", "<%" };
+  hb_string_T erb_patterns[] = { hb_string("<%=="), hb_string("<%%="), hb_string("<%="), hb_string("<%#"),
+                                 hb_string("<%-"),  hb_string("<%%"),  hb_string("<%") };
 
   lexer->state = STATE_ERB_CONTENT;
 
@@ -223,14 +199,18 @@ static token_T* lexer_parse_erb_open(lexer_T* lexer) {
 }
 
 static token_T* lexer_parse_erb_content(lexer_T* lexer) {
-  buffer_T buffer = buffer_new();
+  uint32_t start_position = lexer->current_position;
 
   while (!lexer_peek_erb_end(lexer, 0)) {
     if (lexer_eof(lexer)) {
-      return token_init(buffer.value, TOKEN_ERROR, lexer); // Handle unexpected EOF
-    }
+      token_T* token = token_init(
+        hb_string_range(lexer->source, start_position, lexer->current_position),
+        TOKEN_ERROR,
+        lexer
+      ); // Handle unexpected EOF
 
-    buffer_append_char(&buffer, lexer->current_character);
+      return token;
+    }
 
     if (is_newline(lexer->current_character)) {
       lexer->current_line++;
@@ -240,14 +220,13 @@ static token_T* lexer_parse_erb_content(lexer_T* lexer) {
     }
 
     lexer->current_position++;
-    lexer->current_character = lexer->source[lexer->current_position];
+    lexer->current_character = lexer->source.data[lexer->current_position];
   }
 
   lexer->state = STATE_ERB_CLOSE;
 
-  token_T* token = token_init(buffer.value, TOKEN_ERB_CONTENT, lexer);
-
-  buffer_free(&buffer);
+  token_T* token =
+    token_init(hb_string_range(lexer->source, start_position, lexer->current_position), TOKEN_ERB_CONTENT, lexer);
 
   return token;
 }
@@ -255,16 +234,17 @@ static token_T* lexer_parse_erb_content(lexer_T* lexer) {
 static token_T* lexer_parse_erb_close(lexer_T* lexer) {
   lexer->state = STATE_DATA;
 
-  if (lexer_peek_erb_percent_close_tag(lexer, 0)) { return lexer_advance_with(lexer, "%%>", TOKEN_ERB_END); }
-  if (lexer_peek_erb_dash_close_tag(lexer, 0)) { return lexer_advance_with(lexer, "-%>", TOKEN_ERB_END); }
+  if (lexer_peek_erb_percent_close_tag(lexer, 0)) { return lexer_advance_with(lexer, hb_string("%%>"), TOKEN_ERB_END); }
+  if (lexer_peek_erb_equals_close_tag(lexer, 0)) { return lexer_advance_with(lexer, hb_string("=%>"), TOKEN_ERB_END); }
+  if (lexer_peek_erb_dash_close_tag(lexer, 0)) { return lexer_advance_with(lexer, hb_string("-%>"), TOKEN_ERB_END); }
 
-  return lexer_advance_with(lexer, "%>", TOKEN_ERB_END);
+  return lexer_advance_with(lexer, hb_string("%>"), TOKEN_ERB_END);
 }
 
 // ===== Tokenizing Function
 
 token_T* lexer_next_token(lexer_T* lexer) {
-  if (lexer_eof(lexer)) { return token_init("", TOKEN_EOF, lexer); }
+  if (lexer_eof(lexer)) { return token_init(hb_string(""), 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); }
@@ -301,33 +281,33 @@ token_T* lexer_next_token(lexer_T* lexer) {
       if (isalnum(lexer_peek(lexer, 1))) { return lexer_advance_current(lexer, TOKEN_HTML_TAG_START); }
 
       if (lexer_peek_for_html_comment_start(lexer, 0)) {
-        return lexer_advance_with(lexer, "<!--", TOKEN_HTML_COMMENT_START);
+        return lexer_advance_with(lexer, hb_string("<!--"), TOKEN_HTML_COMMENT_START);
       }
 
       if (lexer_peek_for_close_tag_start(lexer, 0)) {
-        return lexer_advance_with(lexer, "</", TOKEN_HTML_TAG_START_CLOSE);
+        return lexer_advance_with(lexer, hb_string("</"), TOKEN_HTML_TAG_START_CLOSE);
       }
 
       return lexer_advance_current(lexer, TOKEN_LT);
     }
 
     case '/': {
-      token_T* token = lexer_match_and_advance(lexer, "/>", TOKEN_HTML_TAG_SELF_CLOSE);
+      token_T* token = lexer_match_and_advance(lexer, hb_string("/>"), TOKEN_HTML_TAG_SELF_CLOSE);
       return token ? token : lexer_advance_current(lexer, TOKEN_SLASH);
     }
 
     case '?': {
-      token_T* token = lexer_match_and_advance(lexer, "?>", TOKEN_XML_DECLARATION_END);
+      token_T* token = lexer_match_and_advance(lexer, hb_string("?>"), TOKEN_XML_DECLARATION_END);
       return token ? token : lexer_advance_current(lexer, TOKEN_CHARACTER);
     }
 
     case '-': {
-      token_T* token = lexer_match_and_advance(lexer, "-->", TOKEN_HTML_COMMENT_END);
+      token_T* token = lexer_match_and_advance(lexer, hb_string("-->"), TOKEN_HTML_COMMENT_END);
       return token ? token : lexer_advance_current(lexer, TOKEN_DASH);
     }
 
     case ']': {
-      token_T* token = lexer_match_and_advance(lexer, "]]>", TOKEN_CDATA_END);
+      token_T* token = lexer_match_and_advance(lexer, hb_string("]]>"), TOKEN_CDATA_END);
       return token ? token : lexer_advance_current(lexer, TOKEN_CHARACTER);
     }
 
@@ -353,9 +333,3 @@ token_T* lexer_next_token(lexer_T* lexer) {
     }
   }
 }
-
-void lexer_free(lexer_T* lexer) {
-  if (lexer == NULL) { return; }
-
-  free(lexer);
-}

data/src/lexer_peek_helpers.c

@@ -3,80 +3,83 @@
 #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, const int offset) {
-  return lexer->source[MAX(lexer->current_position - offset, 0)];
+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, const int offset) {
-  return lexer->source[MIN(lexer->current_position + offset, lexer->source_length)];
+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, const int offset, const char* pattern, const bool case_insensitive) {
-  for (int index = 0; pattern[index]; index++) {
-    const char character = lexer_peek(lexer, offset + index);
+bool lexer_peek_for(const lexer_T* lexer, uint32_t offset, hb_string_T pattern, const 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);
 
-    if (case_insensitive) {
-      if (tolower(character) != tolower(pattern[index])) { return false; }
-    } else {
-      if (character != pattern[index]) { return false; }
-    }
+  if (case_insensitive) {
+    return hb_string_equals_case_insensitive(remaining_source, pattern);
+  } else {
+    return hb_string_equals(remaining_source, pattern);
   }
+}
 
-  return true;
+bool lexer_peek_for_doctype(const lexer_T* lexer, uint32_t offset) {
+  return lexer_peek_for(lexer, offset, hb_string("<!DOCTYPE"), true);
 }
 
-bool lexer_peek_for_doctype(const lexer_T* lexer, const int offset) {
-  return lexer_peek_for(lexer, offset, "<!DOCTYPE", true);
+bool lexer_peek_for_xml_declaration(const lexer_T* lexer, uint32_t offset) {
+  return lexer_peek_for(lexer, offset, hb_string("<?xml"), true);
 }
 
-bool lexer_peek_for_xml_declaration(const lexer_T* lexer, const int offset) {
-  return lexer_peek_for(lexer, offset, "<?xml", true);
+bool lexer_peek_for_cdata_start(const lexer_T* lexer, uint32_t offset) {
+  return lexer_peek_for(lexer, offset, hb_string("<![CDATA["), false);
 }
 
-bool lexer_peek_for_cdata_start(const lexer_T* lexer, const int offset) {
-  return lexer_peek_for(lexer, offset, "<![CDATA[", false);
+bool lexer_peek_for_cdata_end(const lexer_T* lexer, uint32_t offset) {
+  return lexer_peek_for(lexer, offset, hb_string("]]>"), false);
 }
 
-bool lexer_peek_for_cdata_end(const lexer_T* lexer, const int offset) {
-  return lexer_peek_for(lexer, offset, "]]>", false);
+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_start(const lexer_T* lexer, const int offset) {
-  return lexer_peek_for(lexer, offset, "<!--", 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_for_html_comment_end(const lexer_T* lexer, const int offset) {
-  return lexer_peek_for(lexer, offset, "-->", 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_erb_close_tag(const lexer_T* lexer, const int offset) {
-  return lexer_peek_for(lexer, offset, "%>", false);
+bool lexer_peek_erb_dash_close_tag(const lexer_T* lexer, uint32_t offset) {
+  return lexer_peek_for(lexer, offset, hb_string("-%>"), false);
 }
 
-bool lexer_peek_erb_dash_close_tag(const lexer_T* lexer, const int offset) {
-  return lexer_peek_for(lexer, offset, "-%>", false);
+bool lexer_peek_erb_percent_close_tag(const lexer_T* lexer, uint32_t offset) {
+  return lexer_peek_for(lexer, offset, hb_string("%%>"), false);
 }
 
-bool lexer_peek_erb_percent_close_tag(const lexer_T* lexer, const int offset) {
-  return lexer_peek_for(lexer, offset, "%%>", false);
+bool lexer_peek_erb_equals_close_tag(const lexer_T* lexer, uint32_t offset) {
+  return lexer_peek_for(lexer, offset, hb_string("=%>"), false);
 }
 
-bool lexer_peek_erb_end(const lexer_T* lexer, const int offset) {
+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_percent_close_tag(lexer, offset) || lexer_peek_erb_equals_close_tag(lexer, offset)
   );
 }
 
 bool lexer_peek_for_token_type_after_whitespace(lexer_T* lexer, token_type_T token_type) {
-  size_t saved_position = lexer->current_position;
-  size_t saved_line = lexer->current_line;
-  size_t saved_column = lexer->current_column;
+  uint32_t saved_position = lexer->current_position;
+  uint32_t saved_line = lexer->current_line;
+  uint32_t saved_column = lexer->current_column;
   char saved_character = lexer->current_character;
+  lexer_state_T saved_state = lexer->state;
 
   token_T* token = lexer_next_token(lexer);
 
@@ -93,14 +96,15 @@ bool lexer_peek_for_token_type_after_whitespace(lexer_T* lexer, token_type_T tok
   lexer->current_line = saved_line;
   lexer->current_column = saved_column;
   lexer->current_character = saved_character;
+  lexer->state = saved_state;
 
   return result;
 }
 
-bool lexer_peek_for_close_tag_start(const lexer_T* lexer, const int offset) {
+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; }
 
-  int pos = offset + 2;
+  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') {

data/src/location.c

@@ -1,41 +1,13 @@
 #include "include/location.h"
-#include "include/memory.h"
 #include "include/position.h"
 
-size_t location_sizeof(void) {
-  return sizeof(location_T);
-}
-
-location_T* location_init(position_T* start, position_T* end) {
-  location_T* location = safe_malloc(location_sizeof());
-
-  location->start = start;
-  location->end = end;
-
-  return location;
-}
-
-location_T* location_from(size_t start_line, size_t start_column, size_t end_line, size_t end_column) {
-  return location_init(position_init(start_line, start_column), position_init(end_line, end_column));
-}
-
-position_T* location_start(location_T* location) {
-  return location->start;
-}
-
-position_T* location_end(location_T* location) {
-  return location->end;
-}
-
-location_T* location_copy(location_T* location) {
-  if (location == NULL) { return NULL; }
-
-  return location_init(position_copy(location->start), position_copy(location->end));
-}
-
-void location_free(location_T* location) {
-  if (location->start != NULL) { position_free(location->start); }
-  if (location->end != NULL) { position_free(location->end); }
-
-  free(location);
+void location_from(
+  location_T* location,
+  uint32_t start_line,
+  uint32_t start_column,
+  uint32_t end_line,
+  uint32_t end_column
+) {
+  location->start = (position_T) { .line = start_line, .column = start_column };
+  location->end = (position_T) { .line = end_line, .column = end_column };
 }

data/src/main.c

@@ -4,11 +4,11 @@
 #include "include/ast_node.h"
 #include "include/ast_nodes.h"
 #include "include/ast_pretty_print.h"
-#include "include/buffer.h"
 #include "include/extract.h"
 #include "include/herb.h"
 #include "include/io.h"
 #include "include/ruby_parser.h"
+#include "include/util/hb_buffer.h"
 
 #include <stdio.h>
 #include <string.h>
@@ -39,7 +39,6 @@ int main(const int argc, char* argv[]) {
     printf("Herb 🌿 Powerful and seamless HTML-aware ERB parsing and tooling.\n\n");
 
     printf("./herb lex [file]      -  Lex a file\n");
-    printf("./herb lex_json [file] -  Lex a file and return the result as json.\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");
@@ -53,9 +52,9 @@ int main(const int argc, char* argv[]) {
     return 1;
   }
 
-  buffer_T output;
+  hb_buffer_T output;
 
-  if (!buffer_init(&output)) { return 1; }
+  if (!hb_buffer_init(&output, 4096)) { return 1; }
 
   char* source = herb_read_file(argv[2]);
 
@@ -74,7 +73,7 @@ int main(const int argc, char* argv[]) {
     print_time_diff(start, end, "visiting");
 
     ast_node_free((AST_NODE_T*) root);
-    buffer_free(&output);
+    free(output.value);
     free(source);
 
     return 0;
@@ -87,18 +86,7 @@ int main(const int argc, char* argv[]) {
     printf("%s\n", output.value);
     print_time_diff(start, end, "lexing");
 
-    buffer_free(&output);
-    free(source);
-
-    return 0;
-  }
-
-  if (strcmp(argv[1], "lex_json") == 0) {
-    herb_lex_json_to_buffer(source, &output);
-
-    printf("%s\n", output.value);
-
-    buffer_free(&output);
+    free(output.value);
     free(source);
 
     return 0;
@@ -106,15 +94,23 @@ int main(const int argc, char* argv[]) {
 
   if (strcmp(argv[1], "parse") == 0) {
     AST_DOCUMENT_NODE_T* root = herb_parse(source, NULL);
+
+    herb_analyze_parse_tree(root, source);
+
     clock_gettime(CLOCK_MONOTONIC, &end);
 
-    ast_pretty_print_node((AST_NODE_T*) root, 0, 0, &output);
-    printf("%s\n", output.value);
+    int silent = 0;
+    if (argc > 3 && strcmp(argv[3], "--silent") == 0) { silent = 1; }
+
+    if (!silent) {
+      ast_pretty_print_node((AST_NODE_T*) root, 0, 0, &output);
+      printf("%s\n", output.value);
 
-    print_time_diff(start, end, "parsing");
+      print_time_diff(start, end, "parsing");
+    }
 
     ast_node_free((AST_NODE_T*) root);
-    buffer_free(&output);
+    free(output.value);
     free(source);
 
     return 0;
@@ -127,7 +123,7 @@ int main(const int argc, char* argv[]) {
     printf("%s\n", output.value);
     print_time_diff(start, end, "extracting Ruby");
 
-    buffer_free(&output);
+    free(output.value);
     free(source);
 
     return 0;
@@ -140,7 +136,7 @@ int main(const int argc, char* argv[]) {
     printf("%s\n", output.value);
     print_time_diff(start, end, "extracting HTML");
 
-    buffer_free(&output);
+    free(output.value);
     free(source);
 
     return 0;