@herb-tools/node 0.1.1 → 0.3.0

package/extension/libherb/errors.h

@@ -0,0 +1,125 @@
+// NOTE: This file is generated by the templates/template.rb script and should not
+// be modified manually. See /Users/marcoroth/Development/herb-release/templates/src/include/errors.h.erb
+
+#ifndef HERB_ERRORS_H
+#define HERB_ERRORS_H
+
+#include "array.h"
+#include "buffer.h"
+#include "errors.h"
+#include "location.h"
+#include "position.h"
+#include "token.h"
+
+typedef enum {
+  UNEXPECTED_ERROR,
+  UNEXPECTED_TOKEN_ERROR,
+  MISSING_OPENING_TAG_ERROR,
+  MISSING_CLOSING_TAG_ERROR,
+  TAG_NAMES_MISMATCH_ERROR,
+  QUOTES_MISMATCH_ERROR,
+  VOID_ELEMENT_CLOSING_TAG_ERROR,
+  UNCLOSED_ELEMENT_ERROR,
+  RUBY_PARSE_ERROR,
+} error_type_T;
+
+typedef struct ERROR_STRUCT {
+  error_type_T type;
+  location_T* location;
+  char* message;
+} ERROR_T;
+
+
+typedef struct {
+  ERROR_T base;
+  const char* description;
+  const char* expected;
+  const char* found;
+} UNEXPECTED_ERROR_T;
+
+typedef struct {
+  ERROR_T base;
+  token_type_T expected_type;
+  token_T* found;
+} UNEXPECTED_TOKEN_ERROR_T;
+
+typedef struct {
+  ERROR_T base;
+  token_T* closing_tag;
+} MISSING_OPENING_TAG_ERROR_T;
+
+typedef struct {
+  ERROR_T base;
+  token_T* opening_tag;
+} MISSING_CLOSING_TAG_ERROR_T;
+
+typedef struct {
+  ERROR_T base;
+  token_T* opening_tag;
+  token_T* closing_tag;
+} TAG_NAMES_MISMATCH_ERROR_T;
+
+typedef struct {
+  ERROR_T base;
+  token_T* opening_quote;
+  token_T* closing_quote;
+} QUOTES_MISMATCH_ERROR_T;
+
+typedef struct {
+  ERROR_T base;
+  token_T* tag_name;
+  const char* expected;
+  const char* found;
+} VOID_ELEMENT_CLOSING_TAG_ERROR_T;
+
+typedef struct {
+  ERROR_T base;
+  token_T* opening_tag;
+} UNCLOSED_ELEMENT_ERROR_T;
+
+typedef struct {
+  ERROR_T base;
+  const char* error_message;
+  const char* diagnostic_id;
+  const char* level;
+} RUBY_PARSE_ERROR_T;
+
+UNEXPECTED_ERROR_T* unexpected_error_init(const char* description, const char* expected, const char* found, position_T* start, position_T* end);
+void append_unexpected_error(const char* description, const char* expected, const char* found, position_T* start, position_T* end, array_T* errors);
+UNEXPECTED_TOKEN_ERROR_T* unexpected_token_error_init(token_type_T expected_type, token_T* found, position_T* start, position_T* end);
+void append_unexpected_token_error(token_type_T expected_type, token_T* found, position_T* start, position_T* end, array_T* errors);
+MISSING_OPENING_TAG_ERROR_T* missing_opening_tag_error_init(token_T* closing_tag, position_T* start, position_T* end);
+void append_missing_opening_tag_error(token_T* closing_tag, position_T* start, position_T* end, array_T* errors);
+MISSING_CLOSING_TAG_ERROR_T* missing_closing_tag_error_init(token_T* opening_tag, position_T* start, position_T* end);
+void append_missing_closing_tag_error(token_T* opening_tag, position_T* start, position_T* end, array_T* errors);
+TAG_NAMES_MISMATCH_ERROR_T* tag_names_mismatch_error_init(token_T* opening_tag, token_T* closing_tag, position_T* start, position_T* end);
+void append_tag_names_mismatch_error(token_T* opening_tag, token_T* closing_tag, position_T* start, position_T* end, array_T* errors);
+QUOTES_MISMATCH_ERROR_T* quotes_mismatch_error_init(token_T* opening_quote, token_T* closing_quote, position_T* start, position_T* end);
+void append_quotes_mismatch_error(token_T* opening_quote, token_T* closing_quote, position_T* start, position_T* end, array_T* errors);
+VOID_ELEMENT_CLOSING_TAG_ERROR_T* void_element_closing_tag_error_init(token_T* tag_name, const char* expected, const char* found, position_T* start, position_T* end);
+void append_void_element_closing_tag_error(token_T* tag_name, const char* expected, const char* found, position_T* start, position_T* end, array_T* errors);
+UNCLOSED_ELEMENT_ERROR_T* unclosed_element_error_init(token_T* opening_tag, position_T* start, position_T* end);
+void append_unclosed_element_error(token_T* opening_tag, position_T* start, position_T* end, array_T* errors);
+RUBY_PARSE_ERROR_T* ruby_parse_error_init(const char* error_message, const char* diagnostic_id, const char* level, position_T* start, position_T* end);
+void append_ruby_parse_error(const char* error_message, const char* diagnostic_id, const char* level, position_T* start, position_T* end, array_T* errors);
+
+void error_init(ERROR_T* error, error_type_T type, position_T* start, position_T* end);
+
+size_t error_sizeof(void);
+error_type_T error_type(ERROR_T* error);
+
+char* error_message(ERROR_T* error);
+
+const char* error_type_to_string(ERROR_T* error);
+const char* error_human_type(ERROR_T* error);
+
+void error_free(ERROR_T* error);
+
+void error_pretty_print(ERROR_T* error, size_t indent, size_t relative_indent, buffer_T* buffer);
+
+void error_pretty_print_array(
+  const char* name, array_T* array, size_t indent, size_t relative_indent, bool last_property,
+  buffer_T* buffer
+);
+
+#endif

package/extension/libherb/extract.c

@@ -7,25 +7,28 @@
 #include <stdlib.h>
 
 void herb_extract_ruby_to_buffer_with_semicolons(const char* source, buffer_T* output) {
-  const array_T* tokens = herb_lex(source);
+  array_T* tokens = herb_lex(source);
+  bool skip_erb_content = false;
 
   for (size_t i = 0; i < array_size(tokens); i++) {
     const token_T* token = array_get(tokens, i);
 
     switch (token->type) {
-      case TOKEN_NEWLINE:
-      case TOKEN_ERB_CONTENT: buffer_append(output, token->value); break;
-      case TOKEN_ERB_END: {
-        buffer_append_char(output, ';');
-        buffer_append_whitespace(output, range_length(token->range) - 1);
+      case TOKEN_NEWLINE: {
+        buffer_append(output, token->value);
         break;
       }
 
       case TOKEN_ERB_START: {
-        if (strcmp(token->value, "<%#") == 0) {
-          buffer_append_char(output, ' ');
-          buffer_append_char(output, ' ');
-          buffer_append_char(output, '#');
+        if (strcmp(token->value, "<%#") == 0) { skip_erb_content = true; }
+
+        buffer_append_whitespace(output, range_length(token->range));
+        break;
+      }
+
+      case TOKEN_ERB_CONTENT: {
+        if (skip_erb_content == false) {
+          buffer_append(output, token->value);
         } else {
           buffer_append_whitespace(output, range_length(token->range));
         }
@@ -33,25 +36,46 @@ void herb_extract_ruby_to_buffer_with_semicolons(const char* source, buffer_T* o
         break;
       }
 
-      default: buffer_append_whitespace(output, range_length(token->range));
+      case TOKEN_ERB_END: {
+        skip_erb_content = false;
+
+        buffer_append_char(output, ';');
+        buffer_append_whitespace(output, range_length(token->range) - 1);
+        break;
+      }
+
+      default: {
+        buffer_append_whitespace(output, range_length(token->range));
+      }
     }
   }
+
+  herb_free_tokens(&tokens);
 }
 
 void herb_extract_ruby_to_buffer(const char* source, buffer_T* output) {
-  const array_T* tokens = herb_lex(source);
+  array_T* tokens = herb_lex(source);
+  bool skip_erb_content = false;
 
   for (size_t i = 0; i < array_size(tokens); i++) {
     const token_T* token = array_get(tokens, i);
 
     switch (token->type) {
-      case TOKEN_NEWLINE:
-      case TOKEN_ERB_CONTENT: buffer_append(output, token->value); break;
+      case TOKEN_NEWLINE: {
+        buffer_append(output, token->value);
+        break;
+      }
+
       case TOKEN_ERB_START: {
-        if (strcmp(token->value, "<%#") == 0) {
-          buffer_append_char(output, ' ');
-          buffer_append_char(output, ' ');
-          buffer_append_char(output, '#');
+        if (strcmp(token->value, "<%#") == 0) { skip_erb_content = true; }
+
+        buffer_append_whitespace(output, range_length(token->range));
+        break;
+      }
+
+      case TOKEN_ERB_CONTENT: {
+        if (skip_erb_content == false) {
+          buffer_append(output, token->value);
         } else {
           buffer_append_whitespace(output, range_length(token->range));
         }
@@ -59,13 +83,24 @@ void herb_extract_ruby_to_buffer(const char* source, buffer_T* output) {
         break;
       }
 
-      default: buffer_append_whitespace(output, range_length(token->range));
+      case TOKEN_ERB_END: {
+        skip_erb_content = false;
+
+        buffer_append_whitespace(output, range_length(token->range));
+        break;
+      }
+
+      default: {
+        buffer_append_whitespace(output, range_length(token->range));
+      }
     }
   }
+
+  herb_free_tokens(&tokens);
 }
 
 void herb_extract_html_to_buffer(const char* source, buffer_T* output) {
-  const array_T* tokens = herb_lex(source);
+  array_T* tokens = herb_lex(source);
 
   for (size_t i = 0; i < array_size(tokens); i++) {
     const token_T* token = array_get(tokens, i);
@@ -77,6 +112,8 @@ void herb_extract_html_to_buffer(const char* source, buffer_T* output) {
       default: buffer_append(output, token->value);
     }
   }
+
+  herb_free_tokens(&tokens);
 }
 
 char* herb_extract_ruby_with_semicolons(const char* source) {

package/extension/libherb/extract.h

@@ -0,0 +1,20 @@
+#ifndef HERB_EXTRACT_H
+#define HERB_EXTRACT_H
+
+#include "buffer.h"
+
+typedef enum {
+  HERB_EXTRACT_LANGUAGE_RUBY,
+  HERB_EXTRACT_LANGUAGE_HTML,
+} herb_extract_language_T;
+
+void herb_extract_ruby_to_buffer(const char* source, buffer_T* output);
+void herb_extract_html_to_buffer(const char* source, buffer_T* output);
+
+char* herb_extract_ruby_with_semicolons(const char* source);
+void herb_extract_ruby_to_buffer_with_semicolons(const char* source, buffer_T* output);
+
+char* herb_extract(const char* source, herb_extract_language_T language);
+char* herb_extract_from_file(const char* path, herb_extract_language_T language);
+
+#endif

package/extension/libherb/herb.h

@@ -0,0 +1,32 @@
+#ifndef HERB_H
+#define HERB_H
+
+#include "array.h"
+#include "ast_node.h"
+#include "buffer.h"
+#include "extract.h"
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void herb_lex_to_buffer(const char* source, buffer_T* output);
+void herb_lex_json_to_buffer(const char* source, buffer_T* output);
+
+array_T* herb_lex(const char* source);
+array_T* herb_lex_file(const char* path);
+
+AST_DOCUMENT_NODE_T* herb_parse(const char* source);
+
+const char* herb_version(void);
+const char* herb_prism_version(void);
+
+void herb_free_tokens(array_T** tokens);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

package/extension/libherb/html_util.h

@@ -0,0 +1,13 @@
+#ifndef HERB_HTML_UTIL_H
+#define HERB_HTML_UTIL_H
+
+#include <stdbool.h>
+
+bool is_void_element(const char* tag_name);
+bool is_html4_void_element(const char* tag_name);
+
+char* html_opening_tag_string(const char* tag_name);
+char* html_closing_tag_string(const char* tag_name);
+char* html_self_closing_tag_string(const char* tag_name);
+
+#endif

package/extension/libherb/include/analyze.h

@@ -17,7 +17,9 @@ typedef enum {
   CONTROL_TYPE_ELSE,
   CONTROL_TYPE_END,
   CONTROL_TYPE_CASE,
+  CONTROL_TYPE_CASE_MATCH,
   CONTROL_TYPE_WHEN,
+  CONTROL_TYPE_IN,
   CONTROL_TYPE_BEGIN,
   CONTROL_TYPE_RESCUE,
   CONTROL_TYPE_ENSURE,
@@ -27,6 +29,7 @@ typedef enum {
   CONTROL_TYPE_FOR,
   CONTROL_TYPE_BLOCK,
   CONTROL_TYPE_BLOCK_CLOSE,
+  CONTROL_TYPE_YIELD,
   CONTROL_TYPE_UNKNOWN
 } control_type_t;
 

package/extension/libherb/include/analyze_helpers.h

@@ -13,7 +13,9 @@ bool has_end(analyzed_ruby_T* analyzed);
 bool has_block_node(analyzed_ruby_T* analyzed);
 bool has_block_closing(analyzed_ruby_T* analyzed);
 bool has_case_node(analyzed_ruby_T* analyzed);
+bool has_case_match_node(analyzed_ruby_T* analyzed);
 bool has_when_node(analyzed_ruby_T* analyzed);
+bool has_in_node(analyzed_ruby_T* analyzed);
 bool has_for_node(analyzed_ruby_T* analyzed);
 bool has_while_node(analyzed_ruby_T* analyzed);
 bool has_until_node(analyzed_ruby_T* analyzed);
@@ -21,12 +23,14 @@ bool has_begin_node(analyzed_ruby_T* analyzed);
 bool has_rescue_node(analyzed_ruby_T* analyzed);
 bool has_ensure_node(analyzed_ruby_T* analyzed);
 bool has_unless_node(analyzed_ruby_T* analyzed);
+bool has_yield_node(analyzed_ruby_T* analyzed);
 
 bool has_error_message(analyzed_ruby_T* anlayzed, const char* message);
 
 bool search_if_nodes(const pm_node_t* node, void* data);
 bool search_block_nodes(const pm_node_t* node, void* data);
 bool search_case_nodes(const pm_node_t* node, void* data);
+bool search_case_match_nodes(const pm_node_t* node, void* data);
 bool search_while_nodes(const pm_node_t* node, void* data);
 bool search_for_nodes(const pm_node_t* node, void* data);
 bool search_until_nodes(const pm_node_t* node, void* data);
@@ -37,7 +41,9 @@ bool search_else_nodes(analyzed_ruby_T* analyzed);
 bool search_end_nodes(analyzed_ruby_T* analyzed);
 bool search_block_closing_nodes(analyzed_ruby_T* analyzed);
 bool search_when_nodes(analyzed_ruby_T* analyzed);
+bool search_in_nodes(analyzed_ruby_T* analyzed);
 bool search_rescue_nodes(analyzed_ruby_T* analyzed);
 bool search_ensure_nodes(analyzed_ruby_T* analyzed);
+bool search_yield_nodes(analyzed_ruby_T* analyzed);
 
 #endif

package/extension/libherb/include/analyzed_ruby.h

@@ -17,7 +17,9 @@ typedef struct ANALYZED_RUBY_STRUCT {
   bool has_block_closing;
   bool has_block_node;
   bool has_case_node;
+  bool has_case_match_node;
   bool has_when_node;
+  bool has_in_node;
   bool has_for_node;
   bool has_while_node;
   bool has_until_node;
@@ -25,6 +27,7 @@ typedef struct ANALYZED_RUBY_STRUCT {
   bool has_rescue_node;
   bool has_ensure_node;
   bool has_unless_node;
+  bool has_yield_node;
 } analyzed_ruby_T;
 
 analyzed_ruby_T* init_analyzed_ruby(char* source);

package/extension/libherb/include/ast_nodes.h

@@ -35,6 +35,7 @@ typedef enum {
   AST_ERB_BLOCK_NODE,
   AST_ERB_WHEN_NODE,
   AST_ERB_CASE_NODE,
+  AST_ERB_CASE_MATCH_NODE,
   AST_ERB_WHILE_NODE,
   AST_ERB_UNTIL_NODE,
   AST_ERB_FOR_NODE,
@@ -42,6 +43,8 @@ typedef enum {
   AST_ERB_ENSURE_NODE,
   AST_ERB_BEGIN_NODE,
   AST_ERB_UNLESS_NODE,
+  AST_ERB_YIELD_NODE,
+  AST_ERB_IN_NODE,
 } ast_node_type_T;
 
 typedef struct AST_NODE_STRUCT {
@@ -203,6 +206,17 @@ typedef struct AST_ERB_CASE_NODE_STRUCT {
   struct AST_ERB_END_NODE_STRUCT* end_node;
 } AST_ERB_CASE_NODE_T;
 
+typedef struct AST_ERB_CASE_MATCH_NODE_STRUCT {
+  AST_NODE_T base;
+  token_T* tag_opening;
+  token_T* content;
+  token_T* tag_closing;
+  array_T* children;
+  array_T* conditions;
+  struct AST_ERB_ELSE_NODE_STRUCT* else_clause;
+  struct AST_ERB_END_NODE_STRUCT* end_node;
+} AST_ERB_CASE_MATCH_NODE_T;
+
 typedef struct AST_ERB_WHILE_NODE_STRUCT {
   AST_NODE_T base;
   token_T* tag_opening;
@@ -269,6 +283,21 @@ typedef struct AST_ERB_UNLESS_NODE_STRUCT {
   struct AST_ERB_END_NODE_STRUCT* end_node;
 } AST_ERB_UNLESS_NODE_T;
 
+typedef struct AST_ERB_YIELD_NODE_STRUCT {
+  AST_NODE_T base;
+  token_T* tag_opening;
+  token_T* content;
+  token_T* tag_closing;
+} AST_ERB_YIELD_NODE_T;
+
+typedef struct AST_ERB_IN_NODE_STRUCT {
+  AST_NODE_T base;
+  token_T* tag_opening;
+  token_T* content;
+  token_T* tag_closing;
+  array_T* statements;
+} AST_ERB_IN_NODE_T;
+
 AST_DOCUMENT_NODE_T* ast_document_node_init(array_T* children, position_T* start_position, position_T* end_position, array_T* errors);
 AST_LITERAL_NODE_T* ast_literal_node_init(const char* content, position_T* start_position, position_T* end_position, array_T* errors);
 AST_HTML_OPEN_TAG_NODE_T* ast_html_open_tag_node_init(token_T* tag_opening, token_T* tag_name, token_T* tag_closing, array_T* children, bool is_void, position_T* start_position, position_T* end_position, array_T* errors);
@@ -289,6 +318,7 @@ AST_ERB_IF_NODE_T* ast_erb_if_node_init(token_T* tag_opening, token_T* content,
 AST_ERB_BLOCK_NODE_T* ast_erb_block_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, array_T* body, struct AST_ERB_END_NODE_STRUCT* end_node, position_T* start_position, position_T* end_position, array_T* errors);
 AST_ERB_WHEN_NODE_T* ast_erb_when_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, array_T* statements, position_T* start_position, position_T* end_position, array_T* errors);
 AST_ERB_CASE_NODE_T* ast_erb_case_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, array_T* children, array_T* conditions, struct AST_ERB_ELSE_NODE_STRUCT* else_clause, struct AST_ERB_END_NODE_STRUCT* end_node, position_T* start_position, position_T* end_position, array_T* errors);
+AST_ERB_CASE_MATCH_NODE_T* ast_erb_case_match_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, array_T* children, array_T* conditions, struct AST_ERB_ELSE_NODE_STRUCT* else_clause, struct AST_ERB_END_NODE_STRUCT* end_node, position_T* start_position, position_T* end_position, array_T* errors);
 AST_ERB_WHILE_NODE_T* ast_erb_while_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, array_T* statements, struct AST_ERB_END_NODE_STRUCT* end_node, position_T* start_position, position_T* end_position, array_T* errors);
 AST_ERB_UNTIL_NODE_T* ast_erb_until_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, array_T* statements, struct AST_ERB_END_NODE_STRUCT* end_node, position_T* start_position, position_T* end_position, array_T* errors);
 AST_ERB_FOR_NODE_T* ast_erb_for_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, array_T* statements, struct AST_ERB_END_NODE_STRUCT* end_node, position_T* start_position, position_T* end_position, array_T* errors);
@@ -296,6 +326,8 @@ AST_ERB_RESCUE_NODE_T* ast_erb_rescue_node_init(token_T* tag_opening, token_T* c
 AST_ERB_ENSURE_NODE_T* ast_erb_ensure_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, array_T* statements, position_T* start_position, position_T* end_position, array_T* errors);
 AST_ERB_BEGIN_NODE_T* ast_erb_begin_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, array_T* statements, struct AST_ERB_RESCUE_NODE_STRUCT* rescue_clause, struct AST_ERB_ELSE_NODE_STRUCT* else_clause, struct AST_ERB_ENSURE_NODE_STRUCT* ensure_clause, struct AST_ERB_END_NODE_STRUCT* end_node, position_T* start_position, position_T* end_position, array_T* errors);
 AST_ERB_UNLESS_NODE_T* ast_erb_unless_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, array_T* statements, struct AST_ERB_ELSE_NODE_STRUCT* else_clause, struct AST_ERB_END_NODE_STRUCT* end_node, position_T* start_position, position_T* end_position, array_T* errors);
+AST_ERB_YIELD_NODE_T* ast_erb_yield_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, position_T* start_position, position_T* end_position, array_T* errors);
+AST_ERB_IN_NODE_T* ast_erb_in_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, array_T* statements, position_T* start_position, position_T* end_position, array_T* errors);
 
 const char* ast_node_type_to_string(AST_NODE_T* node);
 const char* ast_node_human_type(AST_NODE_T* node);

package/extension/libherb/include/buffer.h

@@ -13,8 +13,11 @@ typedef struct BUFFER_STRUCT {
 bool buffer_init(buffer_T* buffer);
 buffer_T buffer_new(void);
 
-bool buffer_increase_capacity(buffer_T* buffer, size_t required_length);
-bool buffer_reserve(buffer_T* buffer, size_t min_capacity);
+bool buffer_increase_capacity(buffer_T* buffer, size_t additional_capacity);
+bool buffer_has_capacity(buffer_T* buffer, size_t required_length);
+bool buffer_expand_capacity(buffer_T* buffer);
+bool buffer_expand_if_needed(buffer_T* buffer, size_t required_length);
+bool buffer_resize(buffer_T* buffer, size_t new_capacity);
 
 void buffer_append(buffer_T* buffer, const char* text);
 void buffer_append_with_length(buffer_T* buffer, const char* text, size_t length);

package/extension/libherb/include/lexer_peek_helpers.h

@@ -1,5 +1,5 @@
-#ifndef HERB_LEXER_PEEK_H
-#define HERB_LEXER_PEEK_H
+#ifndef HERB_LEXER_PEEK_HELPERS_H
+#define HERB_LEXER_PEEK_HELPERS_H
 
 #include "lexer_struct.h"
 

package/extension/libherb/include/macros.h

@@ -1,9 +1,9 @@
 #ifndef HERB_MACROS_H
 #define HERB_MACROS_H
 
-#define MAX(a, b) (a) > (b) ? (a) : (b)
+#define MAX(a, b) ((a) > (b) ? (a) : (b))
 
-#define MIN(a, b) (a) < (b) ? (a) : (b)
+#define MIN(a, b) ((a) < (b) ? (a) : (b))
 
 #define unlikely(x) __builtin_expect(!!(x), 0)
 

package/extension/libherb/include/version.h

@@ -1,6 +1,6 @@
 #ifndef HERB_VERSION_H
 #define HERB_VERSION_H
 
-#define HERB_VERSION "0.1.1"
+#define HERB_VERSION "0.3.0"
 
 #endif

package/extension/libherb/io.h

@@ -0,0 +1,9 @@
+#ifndef HERB_IO_H
+#define HERB_IO_H
+
+#include <stdio.h>
+#include <stdlib.h>
+
+char* herb_read_file(const char* filename);
+
+#endif

package/extension/libherb/json.h

@@ -0,0 +1,28 @@
+#ifndef HERB_JSON_H
+#define HERB_JSON_H
+
+#include "buffer.h"
+
+void json_start_root_object(buffer_T* json);
+void json_start_root_array(buffer_T* json);
+
+void json_escape_string(buffer_T* json, const char* string);
+
+void json_add_string(buffer_T* json, const char* key, const char* value);
+void json_add_int(buffer_T* json, const char* key, int value);
+void json_add_size_t(buffer_T* json, const char* key, size_t value);
+void json_add_double(buffer_T* json, const char* key, double value);
+void json_add_bool(buffer_T* json, const char* key, int value);
+
+void json_add_raw_string(buffer_T* json, const char* string);
+
+void json_start_object(buffer_T* json, const char* key);
+void json_end_object(buffer_T* json);
+
+void json_start_array(buffer_T* json, const char* key);
+void json_end_array(buffer_T* json);
+
+void json_double_to_string(double value, char* buffer);
+void json_int_to_string(int value, char* buffer);
+
+#endif

package/extension/libherb/lexer.c

@@ -72,7 +72,7 @@ token_T* lexer_error(lexer_T* lexer, const char* message) {
     lexer->current_column
   );
 
-  return token_init(herb_strdup(error_message), TOKEN_ERROR, lexer);
+  return token_init(error_message, TOKEN_ERROR, lexer);
 }
 
 static void lexer_advance(lexer_T* lexer) {

package/extension/libherb/lexer.h

@@ -0,0 +1,13 @@
+#ifndef HERB_LEXER_H
+#define HERB_LEXER_H
+
+#include "lexer_struct.h"
+#include "token_struct.h"
+
+lexer_T* lexer_init(const char* source);
+token_T* lexer_next_token(lexer_T* lexer);
+token_T* lexer_error(lexer_T* lexer, const char* message);
+
+void lexer_free(lexer_T* lexer);
+
+#endif

package/extension/libherb/lexer_peek_helpers.h

@@ -0,0 +1,23 @@
+#ifndef HERB_LEXER_PEEK_HELPERS_H
+#define HERB_LEXER_PEEK_HELPERS_H
+
+#include "lexer_struct.h"
+
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+char lexer_peek(const lexer_T* lexer, int offset);
+bool lexer_peek_for_doctype(const lexer_T* lexer, int offset);
+
+bool lexer_peek_for_html_comment_start(const lexer_T* lexer, int offset);
+bool lexer_peek_for_html_comment_end(const lexer_T* lexer, int offset);
+
+bool lexer_peek_erb_close_tag(const lexer_T* lexer, int offset);
+bool lexer_peek_erb_dash_close_tag(const lexer_T* lexer, int offset);
+bool lexer_peek_erb_percent_close_tag(const lexer_T* lexer, int offset);
+bool lexer_peek_erb_end(const lexer_T* lexer, int offset);
+
+char lexer_backtrack(const lexer_T* lexer, int offset);
+
+#endif

package/extension/libherb/lexer_struct.h

@@ -0,0 +1,32 @@
+#ifndef HERB_LEXER_STRUCT_H
+#define HERB_LEXER_STRUCT_H
+
+#include <stdbool.h>
+#include <stdlib.h>
+
+typedef enum {
+  STATE_DATA,
+  STATE_ERB_CONTENT,
+  STATE_ERB_CLOSE,
+} lexer_state_T;
+
+typedef struct LEXER_STRUCT {
+  const char* source;
+  size_t source_length;
+
+  size_t current_line;
+  size_t current_column;
+  size_t current_position;
+
+  size_t previous_line;
+  size_t previous_column;
+  size_t previous_position;
+
+  char current_character;
+  lexer_state_T state;
+  size_t stall_counter;
+  size_t last_position;
+  bool stalled;
+} lexer_T;
+
+#endif

package/extension/libherb/location.h

@@ -0,0 +1,25 @@
+#ifndef HERB_LOCATION_H
+#define HERB_LOCATION_H
+
+#include <stdlib.h>
+
+#include "position.h"
+
+typedef struct LOCATION_STRUCT {
+  position_T* start;
+  position_T* end;
+} location_T;
+
+location_T* location_init(position_T* start, position_T* end);
+location_T* location_from(size_t start_line, size_t start_column, size_t end_line, size_t end_column);
+
+position_T* location_start(location_T* location);
+position_T* location_end_(location_T* location);
+
+size_t location_sizeof(void);
+
+location_T* location_copy(location_T* location);
+
+void location_free(location_T* location);
+
+#endif

package/extension/libherb/macros.h

@@ -0,0 +1,10 @@
+#ifndef HERB_MACROS_H
+#define HERB_MACROS_H
+
+#define MAX(a, b) ((a) > (b) ? (a) : (b))
+
+#define MIN(a, b) ((a) < (b) ? (a) : (b))
+
+#define unlikely(x) __builtin_expect(!!(x), 0)
+
+#endif