@herb-tools/node 0.7.4 → 0.7.5

package/extension/libherb/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

package/extension/libherb/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

package/extension/libherb/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);

package/extension/libherb/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;
 

package/extension/libherb/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

package/extension/libherb/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);

package/extension/libherb/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;
 }

package/extension/libherb/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);

package/extension/libherb/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;
 

package/extension/libherb/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 };
 }

package/extension/libherb/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