herb 0.0.1 → 0.1.0

data/src/include/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

data/src/include/memory.h

@@ -0,0 +1,12 @@
+#ifndef HERB_MEMORY_H
+#define HERB_MEMORY_H
+
+#include <stddef.h>
+
+void* safe_malloc(size_t size);
+void* safe_realloc(void* pointer, size_t new_size);
+
+void* nullable_safe_malloc(size_t size);
+void* nullable_safe_realloc(void* pointer, size_t new_size);
+
+#endif

data/src/include/parser.h

@@ -0,0 +1,22 @@
+#ifndef HERB_PARSER_H
+#define HERB_PARSER_H
+
+#include "array.h"
+#include "ast_node.h"
+#include "lexer.h"
+
+typedef struct PARSER_STRUCT {
+  lexer_T* lexer;
+  token_T* current_token;
+  array_T* open_tags_stack;
+} parser_T;
+
+parser_T* parser_init(lexer_T* lexer);
+
+AST_DOCUMENT_NODE_T* parser_parse(parser_T* parser);
+
+size_t parser_sizeof(void);
+
+void parser_free(parser_T* parser);
+
+#endif

data/src/include/parser_helpers.h

@@ -0,0 +1,33 @@
+#ifndef HERB_PARSER_HELPERS_H
+#define HERB_PARSER_HELPERS_H
+
+#include "array.h"
+#include "ast_nodes.h"
+#include "buffer.h"
+#include "errors.h"
+#include "parser.h"
+#include "token.h"
+
+void parser_push_open_tag(const parser_T* parser, token_T* tag_name);
+bool parser_check_matching_tag(const parser_T* parser, const char* tag_name);
+token_T* parser_pop_open_tag(const parser_T* parser);
+
+void parser_append_unexpected_error(parser_T* parser, const char* description, const char* expected, array_T* errors);
+void parser_append_unexpected_token_error(parser_T* parser, token_type_T expected_type, array_T* errors);
+
+void parser_append_literal_node_from_buffer(
+  const parser_T* parser, buffer_T* buffer, array_T* children, position_T* start
+);
+
+bool parser_in_svg_context(const parser_T* parser);
+
+token_T* parser_advance(parser_T* parser);
+token_T* parser_consume_if_present(parser_T* parser, token_type_T type);
+token_T* parser_consume_expected(parser_T* parser, token_type_T type, array_T* array);
+
+AST_HTML_ELEMENT_NODE_T* parser_handle_missing_close_tag(
+  AST_HTML_OPEN_TAG_NODE_T* open_tag, array_T* body, array_T* errors
+);
+void parser_handle_mismatched_tags(const parser_T* parser, const AST_HTML_CLOSE_TAG_NODE_T* close_tag, array_T* errors);
+
+#endif

data/src/include/position.h

@@ -0,0 +1,22 @@
+#ifndef HERB_POSITION_H
+#define HERB_POSITION_H
+
+#include <stdlib.h>
+
+typedef struct POSITION_STRUCT {
+  size_t line;
+  size_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

@@ -0,0 +1,53 @@
+#ifndef HERB_PRETTY_PRINT_H
+#define HERB_PRETTY_PRINT_H
+
+#include "analyzed_ruby.h"
+#include "ast_nodes.h"
+#include "buffer.h"
+#include "location.h"
+
+#include <stdbool.h>
+
+void pretty_print_indent(buffer_T* buffer, size_t indent);
+void pretty_print_newline(size_t indent, size_t relative_indent, buffer_T* buffer);
+void pretty_print_label(const char* name, size_t indent, size_t relative_indent, bool last_property, buffer_T* buffer);
+
+void pretty_print_position_property(
+  position_T* position, const char* name, size_t indent, size_t relative_indent, bool last_property, buffer_T* buffer
+);
+
+void pretty_print_location(location_T* location, buffer_T* buffer);
+
+void pretty_print_property(
+  const char* name, const char* value, size_t indent, size_t relative_indent, bool last_property, buffer_T* buffer
+);
+
+void pretty_print_size_t_property(
+  size_t value, const char* name, size_t indent, size_t relative_indent, bool last_property, buffer_T* buffer
+);
+
+void pretty_print_string_property(
+  const char* string, const char* name, size_t indent, size_t relative_indent, bool last_property, buffer_T* buffer
+);
+
+void pretty_print_quoted_property(
+  const char* name, const char* value, size_t indent, size_t relative_indent, bool last_property, buffer_T* buffer
+);
+
+void pretty_print_boolean_property(
+  const char* name, bool value, size_t indent, size_t relative_indent, bool last_property, buffer_T* buffer
+);
+
+void pretty_print_token_property(
+  token_T* token, const char* name, size_t indent, size_t relative_indent, bool last_property, buffer_T* buffer
+);
+
+void pretty_print_array(
+  const char* name, array_T* array, size_t indent, size_t relative_indent, bool last_property, buffer_T* buffer
+);
+
+void pretty_print_errors(AST_NODE_T* node, size_t indent, size_t relative_indent, bool last_property, buffer_T* buffer);
+
+void pretty_print_analyed_ruby(analyzed_ruby_T* analyzed, const char* source);
+
+#endif

data/src/include/prism_helpers.h

@@ -0,0 +1,18 @@
+#ifndef HERB_PRISM_HELPERS_H
+#define HERB_PRISM_HELPERS_H
+
+#include "ast_nodes.h"
+#include "errors.h"
+#include "position.h"
+
+#include <prism.h>
+
+const char* pm_error_level_to_string(pm_error_level_t level);
+
+RUBY_PARSE_ERROR_T* ruby_parse_error_from_prism_error(
+  const pm_diagnostic_t* error, const AST_NODE_T* node, const char* source, pm_parser_t* parser
+);
+
+position_T* position_from_source_with_offset(const char* source, size_t offset);
+
+#endif

data/src/include/range.h

@@ -0,0 +1,23 @@
+#ifndef HERB_RANGE_H
+#define HERB_RANGE_H
+
+#include <stdlib.h>
+
+typedef struct RANGE_STRUCT {
+  size_t from;
+  size_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);
+
+#endif

data/src/include/ruby_parser.h

@@ -0,0 +1,6 @@
+#ifndef HERB_RUBY_PARSER_H
+#define HERB_RUBY_PARSER_H
+
+void herb_parse_ruby_to_stdout(char* source);
+
+#endif

data/src/include/token.h

@@ -0,0 +1,25 @@
+#ifndef HERB_TOKEN_H
+#define HERB_TOKEN_H
+
+#include "lexer_struct.h"
+#include "position.h"
+#include "token_struct.h"
+
+token_T* token_init(const char* value, token_type_T type, lexer_T* lexer);
+char* token_to_string(const token_T* token);
+char* token_to_json(const token_T* token);
+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);
+
+void token_free(token_T* token);
+
+#endif

data/src/include/token_matchers.h

@@ -0,0 +1,21 @@
+#ifndef HERB_TOKEN_MATCHERS_H
+#define HERB_TOKEN_MATCHERS_H
+
+#include "parser.h"
+#include "token.h"
+
+#include <stdarg.h>
+#include <stdbool.h>
+
+// This "TOKEN" is used to terminate the va_list arguments in the token_matches_any function
+#define TOKEN_SENTINEL 99999999
+
+bool token_is(parser_T* parser, token_type_T expected_type);
+bool token_is_not(parser_T* parser, token_type_T type);
+
+bool token_matches_any(token_type_T current_token, token_type_T first_token, ...);
+
+#define token_is_any_of(parser, ...) (token_matches_any((parser)->current_token->type, __VA_ARGS__, TOKEN_SENTINEL))
+#define token_is_none_of(parser, ...) (!token_matches_any((parser)->current_token->type, __VA_ARGS__, TOKEN_SENTINEL))
+
+#endif

data/src/include/token_struct.h

@@ -0,0 +1,51 @@
+#ifndef HERB_TOKEN_STRUCT_H
+#define HERB_TOKEN_STRUCT_H
+
+#include "location.h"
+#include "range.h"
+
+typedef enum {
+  TOKEN_WHITESPACE, // ' '
+  TOKEN_NBSP,       // \xC2\xA0
+  TOKEN_NEWLINE,    // \n
+  TOKEN_IDENTIFIER,
+
+  TOKEN_HTML_DOCTYPE, // <!DOCTYPE, <!doctype, <!DoCtYpE, <!dOcTyPe
+
+  TOKEN_HTML_TAG_START,       // <
+  TOKEN_HTML_TAG_START_CLOSE, // </
+  TOKEN_HTML_TAG_END,         // >
+  TOKEN_HTML_TAG_SELF_CLOSE,  // />
+
+  TOKEN_HTML_COMMENT_START, // <!--
+  TOKEN_HTML_COMMENT_END,   // -->
+
+  TOKEN_ERB_START,   // <%, <%=, <%#, <%-, <%==, <%%
+  TOKEN_ERB_CONTENT, // Ruby Code
+  TOKEN_ERB_END,     // %>, -%>, %%>
+
+  TOKEN_LT,          // <
+  TOKEN_SLASH,       // /
+  TOKEN_EQUALS,      // =
+  TOKEN_QUOTE,       // ", '
+  TOKEN_DASH,        // -
+  TOKEN_UNDERSCORE,  // _
+  TOKEN_EXCLAMATION, // !
+  TOKEN_SEMICOLON,   // ;
+  TOKEN_COLON,       // :
+  TOKEN_PERCENT,     // %
+  TOKEN_AMPERSAND,   // &
+
+  TOKEN_CHARACTER,
+  TOKEN_ERROR,
+  TOKEN_EOF,
+} token_type_T;
+
+typedef struct TOKEN_STRUCT {
+  char* value;
+  range_T* range;
+  location_T* location;
+  token_type_T type;
+} token_T;
+
+#endif

data/src/include/util.h

@@ -0,0 +1,25 @@
+#ifndef HERB_UTIL_H
+#define HERB_UTIL_H
+
+#include <stdbool.h>
+#include <stdlib.h>
+
+int is_whitespace(int character);
+int is_newline(int character);
+
+int count_in_string(const char* string, char character);
+int count_newlines(const char* string);
+
+char* replace_char(char* string, char find, char replace);
+char* escape_newlines(const char* input);
+char* quoted_string(const char* input);
+char* wrap_string(const char* input, char character);
+
+bool string_blank(const char* input);
+bool string_present(const char* input);
+
+char* herb_strdup(const char* s);
+
+char* size_t_to_string(size_t value);
+
+#endif

data/src/include/version.h

@@ -0,0 +1,6 @@
+#ifndef HERB_VERSION_H
+#define HERB_VERSION_H
+
+#define HERB_VERSION "0.1.0"
+
+#endif

data/src/include/visitor.h

@@ -0,0 +1,11 @@
+#ifndef HERB_VISITOR_H
+#define HERB_VISITOR_H
+
+#include "array.h"
+#include "ast_node.h"
+#include "ast_nodes.h"
+
+void herb_visit_node(const AST_NODE_T* node, bool (*visitor)(const AST_NODE_T*, void*), void* data);
+void herb_visit_child_nodes(const AST_NODE_T* node, bool (*visitor)(const AST_NODE_T* node, void* data), void* data);
+
+#endif

data/src/io.c

@@ -0,0 +1,30 @@
+#include "include/io.h"
+#include "include/buffer.h"
+
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#define FILE_READ_CHUNK 4096
+
+char* herb_read_file(const char* filename) {
+  FILE* fp = fopen(filename, "rb");
+
+  if (fp == NULL) {
+    fprintf(stderr, "Could not read file '%s'\n", filename);
+    exit(1);
+  }
+
+  buffer_T buffer = buffer_new();
+
+  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);
+  }
+
+  fclose(fp);
+
+  return buffer_value(&buffer);
+}

data/src/json.c

@@ -0,0 +1,205 @@
+#include "include/json.h"
+#include "include/buffer.h"
+
+void json_escape_string(buffer_T* json, const char* string) {
+  if (!string) {
+    buffer_append(json, "null");
+    return;
+  }
+
+  buffer_append(json, "\"");
+
+  while (*string) {
+    switch (*string) {
+      case '\"': buffer_append(json, "\\\""); break;
+      case '\\': buffer_append(json, "\\\\"); break;
+      case '\n': buffer_append(json, "\\n"); break;
+      case '\t': buffer_append(json, "\\t"); break;
+      default: buffer_append_char(json, *string); break;
+    }
+    string++;
+  }
+
+  buffer_append(json, "\"");
+}
+
+void json_int_to_string(const int value, char* buffer) {
+  char string[20]; // Enough to hold all possible int values
+  int i = 0;
+
+  // Handle negative numbers
+  unsigned int abs_value = (unsigned int) abs(value);
+
+  do {
+    string[i++] = (char) ((abs_value % 10) + '0');
+    abs_value /= 10;
+  } while (abs_value > 0);
+
+  if (value < 0) { string[i++] = '-'; }
+
+  int j = 0;
+
+  while (i > 0) {
+    buffer[j++] = string[--i];
+  }
+
+  buffer[j] = '\0';
+}
+
+void json_double_to_string(const double value, char* buffer) {
+  const int int_part = (int) value;
+  const double frac_part = value - (double) int_part;
+  const int frac_as_int = (int) (frac_part * 100); // Keep 2 decimal places
+
+  char int_buffer[20];
+  char frac_buffer[5];
+
+  json_int_to_string(int_part, int_buffer);
+  json_int_to_string(frac_as_int < 0 ? -frac_as_int : frac_as_int, frac_buffer);
+
+  char* pointer = buffer;
+  for (const char* source = int_buffer; *source != '\0'; ++source) {
+    *pointer++ = *source;
+  }
+
+  *pointer++ = '.';
+
+  for (const char* source = frac_buffer; *source != '\0'; ++source) {
+    *pointer++ = *source;
+  }
+
+  *pointer = '\0';
+}
+
+void json_add_string(buffer_T* json, const char* key, const char* value) {
+  if (!json) { return; }
+
+  if (json->length > 1) { buffer_append(json, ", "); }
+
+  if (key) {
+    json_escape_string(json, key);
+    buffer_append(json, ": ");
+  }
+
+  json_escape_string(json, value);
+}
+
+void json_add_double(buffer_T* json, const char* key, const double value) {
+  if (!json) { return; }
+
+  char number[32];
+  json_double_to_string(value, number);
+
+  if (json->length > 1) { buffer_append(json, ", "); }
+
+  if (key) {
+    json_escape_string(json, key);
+    buffer_append(json, ": ");
+  }
+
+  buffer_append(json, number);
+}
+
+void json_add_int(buffer_T* json, const char* key, const int value) {
+  if (!json) { return; }
+
+  char number[20];
+  json_int_to_string(value, number);
+
+  if (json->length > 1) { buffer_append(json, ", "); }
+
+  if (key) {
+    json_escape_string(json, key);
+    buffer_append(json, ": ");
+  }
+
+  buffer_append(json, number);
+  if (json->length == 1) { buffer_append(json, " "); }
+}
+
+void json_add_size_t(buffer_T* json, const char* key, size_t value) {
+  if (!json) { return; }
+
+  char number[32];
+  char temp[32];
+  int i = 0;
+
+  do {
+    temp[i++] = (char) ((value % 10) + '0');
+    value /= 10;
+  } while (value > 0);
+
+  int j = 0;
+  while (i > 0) {
+    number[j++] = temp[--i];
+  }
+  number[j] = '\0';
+
+  if (json->length > 1) { buffer_append(json, ", "); }
+
+  if (key) {
+    json_escape_string(json, key);
+    buffer_append(json, ": ");
+  }
+
+  buffer_append(json, number);
+  if (json->length == 1) { buffer_append(json, " "); }
+}
+
+void json_add_bool(buffer_T* json, const char* key, const int value) {
+  if (!json) { return; }
+
+  if (json->length > 1) { buffer_append(json, ", "); }
+
+  if (key) {
+    json_escape_string(json, key);
+    buffer_append(json, ": ");
+  }
+
+  buffer_append(json, value ? "true" : "false");
+}
+
+void json_add_raw_string(buffer_T* json, const char* string) {
+  if (!json) { return; }
+
+  if (json->length > 1) { buffer_append(json, ", "); }
+
+  buffer_append(json, string);
+}
+
+void json_start_root_object(buffer_T* json) {
+  if (json) { buffer_append(json, "{"); }
+}
+
+void json_start_object(buffer_T* json, const char* key) {
+  if (!json) { return; }
+
+  if (json->length > 1) { buffer_append(json, ", "); }
+
+  if (key) {
+    json_escape_string(json, key);
+    buffer_append(json, ": ");
+  }
+
+  buffer_append(json, "{");
+}
+
+void json_end_object(buffer_T* json) {
+  if (json) { buffer_append(json, "}"); }
+}
+
+void json_start_root_array(buffer_T* json) {
+  if (json) { buffer_append(json, "["); }
+}
+
+void json_start_array(buffer_T* json, const char* key) {
+  if (!json) { return; }
+
+  if (json->length > 1) { buffer_append(json, ", "); }
+  json_escape_string(json, key);
+  buffer_append(json, ": [");
+}
+
+void json_end_array(buffer_T* json) {
+  if (json) { buffer_append(json, "]"); }
+}