herb 0.7.4-x86-linux-gnu → 0.7.5-x86-linux-gnu

data/src/include/errors.h

@@ -25,7 +25,7 @@ typedef enum {
 
 typedef struct ERROR_STRUCT {
   error_type_T type;
-  location_T* location;
+  location_T location;
   char* message;
 } ERROR_T;
 
@@ -84,26 +84,26 @@ typedef struct {
   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);
+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);

data/src/include/lexer_peek_helpers.h

@@ -5,16 +5,17 @@
 #include "token_struct.h"
 
 #include <stdbool.h>
+#include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 
 typedef struct {
-  size_t position;
-  size_t line;
-  size_t column;
-  size_t previous_position;
-  size_t previous_line;
-  size_t previous_column;
+  uint32_t position;
+  uint32_t line;
+  uint32_t column;
+  uint32_t previous_position;
+  uint32_t previous_line;
+  uint32_t previous_column;
   char current_character;
   lexer_state_T state;
 } lexer_state_snapshot_T;
@@ -31,6 +32,7 @@ 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_equals_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);

data/src/include/lexer_struct.h

@@ -2,6 +2,7 @@
 #define HERB_LEXER_STRUCT_H
 
 #include <stdbool.h>
+#include <stdint.h>
 #include <stdlib.h>
 
 typedef enum {
@@ -12,20 +13,20 @@ typedef enum {
 
 typedef struct LEXER_STRUCT {
   const char* source;
-  size_t source_length;
+  uint32_t source_length;
 
-  size_t current_line;
-  size_t current_column;
-  size_t current_position;
+  uint32_t current_line;
+  uint32_t current_column;
+  uint32_t current_position;
 
-  size_t previous_line;
-  size_t previous_column;
-  size_t previous_position;
+  uint32_t previous_line;
+  uint32_t previous_column;
+  uint32_t previous_position;
 
   char current_character;
   lexer_state_T state;
-  size_t stall_counter;
-  size_t last_position;
+  uint32_t stall_counter;
+  uint32_t last_position;
   bool stalled;
 } lexer_T;
 

data/src/include/location.h

@@ -1,25 +1,22 @@
 #ifndef HERB_LOCATION_H
 #define HERB_LOCATION_H
 
+#include <stdint.h>
 #include <stdlib.h>
 
 #include "position.h"
 
 typedef struct LOCATION_STRUCT {
-  position_T* start;
-  position_T* end;
+  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);
+void location_from(
+  location_T* location,
+  uint32_t start_line,
+  uint32_t start_column,
+  uint32_t end_line,
+  uint32_t end_column
+);
 
 #endif

data/src/include/parser_helpers.h

@@ -19,7 +19,7 @@ void parser_append_literal_node_from_buffer(
   const parser_T* parser,
   buffer_T* buffer,
   array_T* children,
-  position_T* start
+  position_T start
 );
 
 bool parser_in_svg_context(const parser_T* parser);

data/src/include/position.h

@@ -1,22 +1,11 @@
 #ifndef HERB_POSITION_H
 #define HERB_POSITION_H
 
-#include <stdlib.h>
+#include <stdint.h>
 
 typedef struct POSITION_STRUCT {
-  size_t line;
-  size_t column;
+  uint32_t line;
+  uint32_t column;
 } position_T;
 
-position_T* position_init(size_t line, size_t column);
-
-size_t position_line(const position_T* position);
-size_t position_column(const position_T* position);
-
-size_t position_sizeof(void);
-
-position_T* position_copy(position_T* position);
-
-void position_free(position_T* position);
-
 #endif

data/src/include/pretty_print.h

@@ -21,7 +21,7 @@ void pretty_print_position_property(
   buffer_T* buffer
 );
 
-void pretty_print_location(location_T* location, buffer_T* buffer);
+void pretty_print_location(location_T location, buffer_T* buffer);
 
 void pretty_print_property(
   const char* name,

data/src/include/prism_helpers.h

@@ -16,6 +16,6 @@ RUBY_PARSE_ERROR_T* ruby_parse_error_from_prism_error(
   pm_parser_t* parser
 );
 
-position_T* position_from_source_with_offset(const char* source, size_t offset);
+position_T position_from_source_with_offset(const char* source, size_t offset);
 
 #endif

data/src/include/range.h

@@ -1,23 +1,14 @@
 #ifndef HERB_RANGE_H
 #define HERB_RANGE_H
 
+#include <stdint.h>
 #include <stdlib.h>
 
 typedef struct RANGE_STRUCT {
-  size_t from;
-  size_t to;
+  uint32_t from;
+  uint32_t to;
 } range_T;
 
-range_T* range_init(size_t from, size_t to);
-
-size_t range_from(const range_T* range);
-size_t range_to(const range_T* range);
-size_t range_length(range_T* range);
-
-range_T* range_copy(range_T* range);
-
-size_t range_sizeof(void);
-
-void range_free(range_T* range);
+uint32_t range_length(range_T range);
 
 #endif

data/src/include/token.h

@@ -13,9 +13,6 @@ const char* token_type_to_string(token_type_T type);
 char* token_value(const token_T* token);
 int token_type(const token_T* token);
 
-position_T* token_start_position(token_T* token);
-position_T* token_end_position(token_T* token);
-
 size_t token_sizeof(void);
 
 token_T* token_copy(token_T* token);

data/src/include/token_struct.h

@@ -50,8 +50,8 @@ typedef enum {
 
 typedef struct TOKEN_STRUCT {
   char* value;
-  range_T* range;
-  location_T* location;
+  range_T range;
+  location_T location;
   token_type_T type;
 } token_T;
 

data/src/include/version.h

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

data/src/lexer.c

@@ -42,7 +42,7 @@ lexer_T* lexer_init(const char* source) {
   lexer->state = STATE_DATA;
 
   lexer->source = source;
-  lexer->source_length = strlen(source);
+  lexer->source_length = (uint32_t) strlen(source);
   lexer->current_character = source[0];
 
   lexer->current_line = 1;
@@ -66,7 +66,7 @@ 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,
@@ -256,6 +256,7 @@ 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_equals_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); }
 
   return lexer_advance_with(lexer, "%>", TOKEN_ERB_END);

data/src/lexer_peek_helpers.c

@@ -65,18 +65,23 @@ 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, const int offset) {
+  return lexer_peek_for(lexer, offset, "=%>", false);
+}
+
 bool lexer_peek_erb_end(const lexer_T* lexer, const int 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,6 +98,7 @@ 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;
 }

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