herb 0.1.0-x86_64-linux-gnu

data/src/parser_helpers.c

@@ -0,0 +1,161 @@
+#include "include/parser_helpers.h"
+#include "include/array.h"
+#include "include/ast_node.h"
+#include "include/ast_nodes.h"
+#include "include/buffer.h"
+#include "include/errors.h"
+#include "include/html_util.h"
+#include "include/lexer.h"
+#include "include/parser.h"
+#include "include/token.h"
+
+#include <stdio.h>
+#include <strings.h>
+
+void parser_push_open_tag(const parser_T* parser, token_T* tag_name) {
+  token_T* copy = token_copy(tag_name);
+  array_push(parser->open_tags_stack, copy);
+}
+
+bool parser_check_matching_tag(const parser_T* parser, const char* tag_name) {
+  if (array_size(parser->open_tags_stack) == 0) { return false; }
+
+  token_T* top_token = array_last(parser->open_tags_stack);
+  if (top_token == NULL || top_token->value == NULL) { return false; };
+
+  return (strcasecmp(top_token->value, tag_name) == 0);
+}
+
+token_T* parser_pop_open_tag(const parser_T* parser) {
+  if (array_size(parser->open_tags_stack) == 0) { return NULL; }
+
+  return array_pop(parser->open_tags_stack);
+}
+
+/**
+ * Checks if any element in the open tags stack is an SVG element.
+ *
+ * @param parser The parser containing the open tags stack.
+ * @return true if an SVG tag is found in the stack, false otherwise.
+ */
+bool parser_in_svg_context(const parser_T* parser) {
+  if (!parser || !parser->open_tags_stack) { return false; }
+
+  size_t stack_size = array_size(parser->open_tags_stack);
+
+  for (size_t i = 0; i < stack_size; i++) {
+    token_T* tag = (token_T*) array_get(parser->open_tags_stack, i);
+
+    if (tag && tag->value) {
+      if (strcasecmp(tag->value, "svg") == 0) { return true; }
+    }
+  }
+
+  return false;
+}
+
+void parser_append_unexpected_error(parser_T* parser, const char* description, const char* expected, array_T* errors) {
+  token_T* token = parser_advance(parser);
+
+  append_unexpected_error(
+    description,
+    expected,
+    token_type_to_string(token->type),
+    token->location->start,
+    token->location->end,
+    errors
+  );
+
+  token_free(token);
+}
+
+void parser_append_unexpected_token_error(parser_T* parser, token_type_T expected_type, array_T* errors) {
+  append_unexpected_token_error(
+    expected_type,
+    parser->current_token,
+    parser->current_token->location->start,
+    parser->current_token->location->end,
+    errors
+  );
+}
+
+void parser_append_literal_node_from_buffer(
+  const parser_T* parser, buffer_T* buffer, array_T* children, position_T* start
+) {
+  if (buffer_length(buffer) == 0) { return; }
+
+  AST_LITERAL_NODE_T* literal =
+    ast_literal_node_init(buffer_value(buffer), start, parser->current_token->location->start, NULL);
+
+  if (children != NULL) { array_append(children, literal); }
+  buffer_clear(buffer);
+}
+
+token_T* parser_advance(parser_T* parser) {
+  token_T* token = parser->current_token;
+  parser->current_token = lexer_next_token(parser->lexer);
+  return token;
+}
+
+token_T* parser_consume_if_present(parser_T* parser, const token_type_T type) {
+  if (parser->current_token->type != type) { return NULL; }
+  return parser_advance(parser);
+}
+
+token_T* parser_consume_expected(parser_T* parser, const token_type_T expected_type, array_T* array) {
+  token_T* token = parser_consume_if_present(parser, expected_type);
+
+  if (token == NULL) {
+    token = parser_advance(parser);
+
+    append_unexpected_token_error(expected_type, token, token->location->start, token->location->end, array);
+  }
+
+  return token;
+}
+
+AST_HTML_ELEMENT_NODE_T* parser_handle_missing_close_tag(
+  AST_HTML_OPEN_TAG_NODE_T* open_tag, array_T* body, array_T* errors
+) {
+  append_missing_closing_tag_error(
+    open_tag->tag_name,
+    open_tag->tag_name->location->start,
+    open_tag->tag_name->location->end,
+    errors
+  );
+
+  return ast_html_element_node_init(
+    open_tag,
+    open_tag->tag_name,
+    body,
+    NULL,
+    false,
+    open_tag->base.location->start,
+    open_tag->base.location->end,
+    errors
+  );
+}
+
+void parser_handle_mismatched_tags(
+  const parser_T* parser, const AST_HTML_CLOSE_TAG_NODE_T* close_tag, array_T* errors
+) {
+  if (array_size(parser->open_tags_stack) > 0) {
+    token_T* expected_tag = array_last(parser->open_tags_stack);
+    token_T* actual_tag = close_tag->tag_name;
+
+    append_tag_names_mismatch_error(
+      expected_tag,
+      actual_tag,
+      actual_tag->location->start,
+      actual_tag->location->end,
+      errors
+    );
+  } else {
+    append_missing_opening_tag_error(
+      close_tag->tag_name,
+      close_tag->tag_name->location->start,
+      close_tag->tag_name->location->end,
+      errors
+    );
+  }
+}

data/src/position.c

@@ -0,0 +1,33 @@
+#include "include/position.h"
+#include "include/memory.h"
+
+size_t position_sizeof(void) {
+  return sizeof(position_T);
+}
+
+position_T* position_init(const size_t line, const size_t column) {
+  position_T* position = safe_malloc(position_sizeof());
+
+  position->line = line;
+  position->column = column;
+
+  return position;
+}
+
+size_t position_line(const position_T* position) {
+  return position->line;
+}
+
+size_t position_column(const position_T* position) {
+  return position->column;
+}
+
+position_T* position_copy(position_T* position) {
+  if (position == NULL) { return NULL; }
+
+  return position_init(position_line(position), position_column(position));
+}
+
+void position_free(position_T* position) {
+  free(position);
+}

data/src/pretty_print.c

@@ -0,0 +1,242 @@
+#include "include/pretty_print.h"
+#include "include/analyzed_ruby.h"
+#include "include/ast_node.h"
+#include "include/ast_nodes.h"
+#include "include/ast_pretty_print.h"
+#include "include/buffer.h"
+#include "include/errors.h"
+#include "include/token_struct.h"
+#include "include/util.h"
+
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+void pretty_print_indent(buffer_T* buffer, const size_t indent) {
+  for (size_t i = 0; i < indent; i++) {
+    buffer_append(buffer, "    ");
+  }
+}
+
+void pretty_print_newline(const size_t indent, const size_t relative_indent, buffer_T* buffer) {
+  pretty_print_indent(buffer, indent);
+  pretty_print_indent(buffer, relative_indent);
+  buffer_append(buffer, "\n");
+}
+
+void pretty_print_label(
+  const char* name, const size_t indent, const size_t relative_indent, const bool last_property, buffer_T* buffer
+) {
+  pretty_print_indent(buffer, indent);
+  pretty_print_indent(buffer, relative_indent);
+
+  if (last_property) {
+    buffer_append(buffer, "└── ");
+  } else {
+    buffer_append(buffer, "├── ");
+  }
+
+  buffer_append(buffer, name);
+  buffer_append(buffer, ": ");
+}
+
+void pretty_print_quoted_property(
+  const char* name, const char* value, const size_t indent, const size_t relative_indent, const bool last_property,
+  buffer_T* buffer
+) {
+  char* quoted = quoted_string(value);
+  pretty_print_property(name, quoted, indent, relative_indent, last_property, buffer);
+  free(quoted);
+}
+
+void pretty_print_boolean_property(
+  const char* name, bool value, const size_t indent, const size_t relative_indent, const bool last_property,
+  buffer_T* buffer
+) {
+  pretty_print_property(name, value ? "true" : "false", indent, relative_indent, last_property, buffer);
+}
+
+void pretty_print_property(
+  const char* name, const char* value, const size_t indent, const size_t relative_indent, const bool last_property,
+  buffer_T* buffer
+) {
+  pretty_print_label(name, indent, relative_indent, last_property, buffer);
+  buffer_append(buffer, value);
+  buffer_append(buffer, "\n");
+}
+
+void pretty_print_size_t_property(
+  size_t value, const char* name, const size_t indent, const size_t relative_indent, const bool last_property,
+  buffer_T* buffer
+) {
+  pretty_print_label(name, indent, relative_indent, last_property, buffer);
+  char* string = size_t_to_string(value);
+  buffer_append(buffer, string);
+  buffer_append(buffer, "\n");
+  free(string);
+}
+
+void pretty_print_array(
+  const char* name, array_T* array, const size_t indent, const size_t relative_indent, const bool last_property,
+  buffer_T* buffer
+) {
+  if (array == NULL) {
+    pretty_print_property(name, "∅", indent, relative_indent, last_property, buffer);
+
+    return;
+  }
+
+  if (array_size(array) == 0) {
+    pretty_print_property(name, "[]", indent, relative_indent, last_property, buffer);
+
+    return;
+  }
+
+  pretty_print_label(name, indent, relative_indent, last_property, buffer);
+
+  buffer_append(buffer, "(");
+
+  char count[16];
+  sprintf(count, "%zu", array_size(array));
+  buffer_append(buffer, count);
+  buffer_append(buffer, ")\n");
+
+  if (indent < 20) {
+    for (size_t i = 0; i < array_size(array); i++) {
+      AST_NODE_T* child = array_get(array, i);
+      pretty_print_indent(buffer, indent);
+      pretty_print_indent(buffer, relative_indent + 1);
+
+      if (i == array_size(array) - 1) {
+        buffer_append(buffer, "└── ");
+      } else {
+        buffer_append(buffer, "├── ");
+      }
+
+      ast_pretty_print_node(child, indent + 1, relative_indent + 1, buffer);
+
+      if (i != array_size(array) - 1) { pretty_print_newline(indent + 1, relative_indent, buffer); }
+    }
+  }
+  buffer_append(buffer, "\n");
+}
+
+void pretty_print_errors(
+  AST_NODE_T* node, const size_t indent, const size_t relative_indent, const bool last_property, buffer_T* buffer
+) {
+  if (node->errors != NULL && array_size(node->errors) > 0) {
+    error_pretty_print_array("errors", node->errors, indent, relative_indent, last_property, buffer);
+    buffer_append(buffer, "\n");
+  }
+}
+
+void pretty_print_location(location_T* location, buffer_T* buffer) {
+  buffer_append(buffer, "(location: (");
+  char location_string[128];
+  sprintf(
+    location_string,
+    "%zu,%zu)-(%zu,%zu",
+    (location->start && location->start->line) ? location->start->line : 0,
+    (location->start && location->start->column) ? location->start->column : 0,
+    (location->end && location->end->line) ? location->end->line : 0,
+    (location->end && location->end->column) ? location->end->column : 0
+  );
+  buffer_append(buffer, location_string);
+  buffer_append(buffer, "))");
+}
+
+void pretty_print_position_property(
+  position_T* position, const char* name, const size_t indent, const size_t relative_indent, const bool last_property,
+  buffer_T* buffer
+) {
+  pretty_print_label(name, indent, relative_indent, last_property, buffer);
+
+  if (position != NULL) {
+    buffer_append(buffer, "(");
+
+    char position_string[128];
+
+    sprintf(
+      position_string,
+      "%zu:%zu",
+      (position->line) ? position->line : 0,
+      (position->column) ? position->column : 0
+    );
+
+    buffer_append(buffer, position_string);
+    buffer_append(buffer, ")");
+  } else {
+    buffer_append(buffer, "∅");
+  }
+
+  buffer_append(buffer, "\n");
+}
+
+void pretty_print_token_property(
+  token_T* token, const char* name, const size_t indent, const size_t relative_indent, const bool last_property,
+  buffer_T* buffer
+) {
+  pretty_print_label(name, indent, relative_indent, last_property, buffer);
+
+  if (token != NULL && token->value != NULL) {
+    char* quoted = quoted_string(token->value);
+    buffer_append(buffer, quoted);
+    free(quoted);
+
+    buffer_append(buffer, " ");
+    pretty_print_location(token->location, buffer);
+  } else {
+    buffer_append(buffer, "∅");
+  }
+
+  buffer_append(buffer, "\n");
+}
+
+void pretty_print_string_property(
+  const char* string, const char* name, const size_t indent, const size_t relative_indent, const bool last_property,
+  buffer_T* buffer
+) {
+  const char* value = "∅";
+  char* escaped = NULL;
+  char* quoted = NULL;
+
+  if (string != NULL) {
+    escaped = escape_newlines(string);
+    quoted = quoted_string(escaped);
+    value = quoted;
+  }
+
+  pretty_print_property(name, value, indent, relative_indent, last_property, buffer);
+
+  if (string != NULL) {
+    if (escaped != NULL) { free(escaped); }
+    if (quoted != NULL) { free(quoted); }
+  }
+}
+
+void pretty_print_analyed_ruby(analyzed_ruby_T* analyzed, const char* source) {
+  printf(
+    "------------------------\nanalyzed (%p)\n------------------------\n%s\n------------------------\n  if:     %i\n "
+    " elsif:  %i\n  else:   %i\n  end:    %i\n  block:  %i\n  block_closing: %i\n  case:   %i\n  when:   %i\n  for:    "
+    "%i\n  while:  %i\n "
+    " until:  %i\n  begin:  %i\n  "
+    "rescue: %i\n  ensure: %i\n  unless: %i\n==================\n\n",
+    (void*) analyzed,
+    source,
+    analyzed->has_if_node,
+    analyzed->has_elsif_node,
+    analyzed->has_else_node,
+    analyzed->has_end,
+    analyzed->has_block_node,
+    analyzed->has_block_closing,
+    analyzed->has_case_node,
+    analyzed->has_when_node,
+    analyzed->has_for_node,
+    analyzed->has_while_node,
+    analyzed->has_until_node,
+    analyzed->has_begin_node,
+    analyzed->has_rescue_node,
+    analyzed->has_ensure_node,
+    analyzed->has_unless_node
+  );
+}

data/src/prism_helpers.c

@@ -0,0 +1,50 @@
+#include "include/prism_helpers.h"
+#include "include/ast_nodes.h"
+#include "include/errors.h"
+#include "include/position.h"
+#include "include/util.h"
+
+#include <prism.h>
+
+const char* pm_error_level_to_string(pm_error_level_t level) {
+  switch (level) {
+    case PM_ERROR_LEVEL_SYNTAX: return "syntax";
+    case PM_ERROR_LEVEL_ARGUMENT: return "argument";
+    case PM_ERROR_LEVEL_LOAD: return "load";
+
+    default: return "Unknown pm_error_level_t";
+  }
+}
+
+position_T* position_from_source_with_offset(const char* source, size_t offset) {
+  position_T* position = position_init(1, 0);
+
+  for (size_t i = 0; i < offset; i++) {
+    if (is_newline(source[i])) {
+      position->line++;
+      position->column = 0;
+    } else {
+      position->column++;
+    }
+  }
+
+  return position;
+}
+
+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
+) {
+  size_t start_offset = (size_t) (error->location.start - parser->start);
+  size_t end_offset = (size_t) (error->location.end - parser->start);
+
+  position_T* start = position_from_source_with_offset(source, start_offset);
+  position_T* end = position_from_source_with_offset(source, end_offset);
+
+  return ruby_parse_error_init(
+    error->message,
+    pm_diagnostic_id_human(error->diag_id),
+    pm_error_level_to_string(error->level),
+    start,
+    end
+  );
+}

data/src/range.c

@@ -0,0 +1,38 @@
+#include "include/range.h"
+
+size_t range_sizeof(void) {
+  return sizeof(range_T);
+}
+
+range_T* range_init(const size_t from, const size_t to) {
+  range_T* range = calloc(1, range_sizeof());
+
+  range->from = from;
+  range->to = to;
+
+  return range;
+}
+
+size_t range_from(const range_T* range) {
+  return range->from;
+}
+
+size_t range_to(const range_T* range) {
+  return range->to;
+}
+
+size_t range_length(range_T* range) {
+  return range_to(range) - range_from(range);
+}
+
+range_T* range_copy(range_T* range) {
+  if (!range) { return NULL; }
+
+  return range_init(range_from(range), range_to(range));
+}
+
+void range_free(range_T* range) {
+  if (range == NULL) { return; }
+
+  free(range);
+}

data/src/ruby_parser.c

@@ -0,0 +1,47 @@
+#include "include/ruby_parser.h"
+
+#include <prism.h>
+#include <stdbool.h>
+#include <string.h>
+
+static bool herb_prism_visit(const pm_node_t* node, void* data) {
+  const size_t* indent = (size_t*) data;
+
+  for (size_t i = 0; i < *indent * 2; i++) {
+    putc(' ', stdout);
+  }
+
+  printf("%s\n", pm_node_type_to_str(node->type));
+
+  size_t next_indent = *indent + 1;
+  size_t* next_data = &next_indent;
+  pm_visit_child_nodes(node, herb_prism_visit, next_data);
+
+  return false;
+}
+
+void herb_parse_ruby_to_stdout(char* source) {
+  size_t length = strlen(source);
+
+  pm_parser_t parser;
+  pm_parser_init(&parser, (const uint8_t*) source, length, NULL);
+
+  pm_buffer_t buffer;
+  pm_buffer_init(&buffer);
+
+  size_t indent = 0;
+  pm_node_t* root = pm_parse(&parser);
+  size_t* data = &indent;
+
+  const char* root_type = pm_node_type_to_str(root->type);
+  printf("Root Type: %s\n", root_type);
+
+  pm_visit_node(root, herb_prism_visit, data);
+
+  pm_prettyprint(&buffer, &parser, root);
+  printf("%s\n", buffer.value);
+
+  pm_buffer_free(&buffer);
+  pm_node_destroy(&parser, root);
+  pm_parser_free(&parser);
+}