herb 0.7.2-x86_64-darwin → 0.7.3-x86_64-darwin

data/templates/src/errors.c.erb

@@ -0,0 +1,245 @@
+#include "include/array.h"
+#include "include/errors.h"
+#include "include/location.h"
+#include "include/position.h"
+#include "include/pretty_print.h"
+#include "include/token.h"
+#include "include/util.h"
+
+#include <stdio.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define ERROR_MESSAGES_TRUNCATED_LENGTH <%= Herb::Template::PrintfMessageTemplate::MAX_STRING_SIZE %>
+
+size_t error_sizeof(void) {
+  return sizeof(struct ERROR_STRUCT);
+}
+
+void error_init(ERROR_T* error, const error_type_T type, position_T* start, position_T* end) {
+  if (!error) { return; }
+
+  error->type = type;
+  error->location = location_init(position_copy(start), position_copy(end));
+}
+<%- errors.each do |error| -%>
+<%- error_arguments = error.fields.any? ? error.fields.map { |field| [field.c_type, " ", field.name].join } : [] -%>
+<%- arguments = error_arguments + ["position_T* start", "position_T* end"] -%>
+
+<%= error.struct_type %>* <%= error.human %>_init(<%= arguments.join(", ") %>) {
+  <%= error.struct_type %>* <%= error.human %> = malloc(sizeof(<%= error.struct_type %>));
+
+  error_init(&<%= error.human %>->base, <%= error.type %>, start, end);
+
+  <%- if error.message_arguments.any? -%>
+  const char* message_template = "<%= error.message_template %>";
+
+  size_t message_size = <%= Herb::Template::PrintfMessageTemplate.estimate_buffer_size(error.message_template) %>;
+  char* message = (char*) malloc(message_size);
+
+  if (message) {
+    <%- error.message_arguments.each_with_index do |argument, i| -%>
+    <%- if error.message_template.scan(/%[sdulfz]/)[i] == "%s" -%>
+    char truncated_argument_<%= i %>[ERROR_MESSAGES_TRUNCATED_LENGTH + 1];
+    strncpy(truncated_argument_<%= i %>, <%= argument %>, ERROR_MESSAGES_TRUNCATED_LENGTH);
+    truncated_argument_<%= i %>[ERROR_MESSAGES_TRUNCATED_LENGTH] = '\0';
+
+    <%- end -%>
+    <%- end -%>
+    snprintf(
+      message,
+      message_size,
+      message_template,
+      <%- error.message_arguments.each_with_index do |argument, index| -%>
+      <%- if error.message_template.scan(/%[sdulfz]/)[index] == "%s" -%>
+      truncated_argument_<%= index %><% if index != error.message_arguments.length - 1 %>,<% end %>
+      <%- else -%>
+      <%= argument %><% if index != error.message_arguments.length - 1 %>,<% end %>
+      <%- end -%>
+      <%- end -%>
+    );
+
+    <%= error.human %>->base.message = herb_strdup(message);
+    free(message);
+  } else {
+    <%= error.human %>->base.message = herb_strdup("<%= error.message_template %>");
+  }
+  <%- else -%>
+  <%= error.human %>->base.message = herb_strdup("<%= error.message_template %>");
+  <%- end -%>
+
+  <%- error.fields.each do |field| -%>
+  <%- case field -%>
+  <%- when Herb::Template::PositionField -%>
+  <%= error.human %>-><%= field.name %> = position_copy(<%= field.name %>);
+  <%- when Herb::Template::TokenField -%>
+  <%= error.human %>-><%= field.name %> = token_copy(<%= field.name %>);
+  <%- when Herb::Template::TokenTypeField -%>
+  <%= error.human %>-><%= field.name %> = <%= field.name %>;
+  <%- when Herb::Template::SizeTField -%>
+  <%= error.human %>-><%= field.name %> = <%= field.name %>;
+  <%- when Herb::Template::StringField -%>
+  <%= error.human %>-><%= field.name %> = herb_strdup(<%= field.name %>);
+  <%- else -%>
+  <%= field.inspect %>
+  <%- end -%>
+  <%- end -%>
+  return <%= error.human %>;
+}
+
+void append_<%= error.human %>(<%= (arguments + ["array_T* errors"]).join(", ") %>) {
+  array_append(errors, <%= error.human %>_init(<%= arguments.map { |argument| argument.split(" ").last.strip }.join(", ") %>));
+}
+<%- end -%>
+
+const char* error_type_to_string(ERROR_T* error) {
+  switch (error->type) {
+    <%- errors.each do |error| -%>
+    case <%= error.type %>: return "<%= error.type %>";
+    <%- end -%>
+  }
+
+  return "Unknown error_type_T";
+}
+
+const char* error_human_type(ERROR_T* error) {
+  switch (error->type) {
+    <%- errors.each do |error| -%>
+    case <%= error.type %>: return "<%= error.name %>";
+    <%- end -%>
+  }
+
+  return "Unknown error_type_T";
+}
+
+void error_free_base_error(ERROR_T* error) {
+  if (error == NULL) { return; }
+
+  if (error->location != NULL) { location_free(error->location); }
+  if (error->message != NULL) { free(error->message); }
+
+  free(error);
+}
+<%- errors.each do |error| -%>
+<%- arguments = error.fields.any? ? error.fields.map { |field| [field.c_type, " ", field.name].join }.join(", ") : "void" -%>
+
+static void error_free_<%= error.human %>(<%= error.struct_type %>* <%= error.human %>) {
+  <%- if error.fields.none? -%>
+  /* no <%= error.struct_type %> specific fields to free up */
+  <%- end -%>
+  <%- error.fields.each do |field| -%>
+  <%- case field -%>
+  <%- when Herb::Template::PositionField -%>
+  if (<%= error.human %>-><%= field.name %> != NULL) { position_free(<%= error.human %>-><%= field.name %>); }
+  <%- when Herb::Template::TokenField -%>
+  if (<%= error.human %>-><%= field.name %> != NULL) { token_free(<%= error.human %>-><%= field.name %>); }
+  <%- when Herb::Template::TokenTypeField -%>
+  // token_type_T is part of struct
+  <%- when Herb::Template::SizeTField -%>
+  // size_t is part of struct
+  <%- when Herb::Template::StringField -%>
+  if (<%= error.human %>-><%= field.name %> != NULL) { free((char*) <%= error.human %>-><%= field.name %>); }
+  <%- else -%>
+  <%= field.inspect %>
+  <%- end -%>
+  <%- end -%>
+
+  error_free_base_error(&<%= error.human %>->base);
+}
+<%- end -%>
+
+void error_free(ERROR_T* error) {
+  if (!error) { return; }
+
+  switch (error->type) {
+    <%- errors.each do |error| -%>
+    case <%= error.type %>: error_free_<%= error.human %>((<%= error.struct_type %>*) error); break;
+    <%- end -%>
+  }
+}
+
+void error_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++) {
+      ERROR_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, "├── ");
+      }
+
+      error_pretty_print(child, indent + 1, relative_indent + 1, buffer);
+
+      if (i != array_size(array) - 1) { pretty_print_newline(indent + 1, relative_indent, buffer); }
+    }
+  }
+}
+
+<%- errors.each do |error| -%>
+static void error_pretty_print_<%= error.human %>(<%= error.struct_type %>* error, const size_t indent, const size_t relative_indent, buffer_T* buffer) {
+  if (!error) { return; }
+
+  buffer_append(buffer, "@ ");
+  buffer_append(buffer, error_human_type((ERROR_T*) error));
+  buffer_append(buffer, " ");
+
+  pretty_print_location(error->base.location, buffer);
+  buffer_append(buffer, "\n");
+
+  pretty_print_quoted_property("message", error->base.message, indent, relative_indent, <%= error.fields.none? %>, buffer);
+  <%- error.fields.each_with_index do |field, index| -%>
+  <%- case field -%>
+  <%- when Herb::Template::PositionField -%>
+  pretty_print_position_property(error-><%= field.name %>, "<%= field.name %>", indent, relative_indent, <%= error.fields.length - 1 == index %>, buffer);
+  <%- when Herb::Template::TokenField -%>
+  pretty_print_token_property(error-><%= field.name %>, "<%= field.name %>", indent, relative_indent, <%= error.fields.length - 1 == index %>, buffer);
+  <%- when Herb::Template::TokenTypeField -%>
+  pretty_print_property(token_type_to_string(error-><%= field.name %>), "<%= field.name %>", indent, relative_indent, <%= error.fields.length - 1 == index %>, buffer);
+  <%- when Herb::Template::SizeTField -%>
+  pretty_print_size_t_property(error-><%= field.name %>, "<%= field.name %>", indent, relative_indent, <%= error.fields.length - 1 == index %>, buffer);
+  <%- when Herb::Template::StringField -%>
+  pretty_print_quoted_property("<%= field.name %>", error-><%= field.name %>, indent, relative_indent, <%= error.fields.length - 1 == index %>, buffer);
+  <%- else -%>
+  <%= field.inspect %>
+  <%- end -%>
+  <%- end -%>
+}
+
+<%- end -%>
+void error_pretty_print(ERROR_T* error, const size_t indent, const size_t relative_indent, buffer_T* buffer) {
+  if (!error) { return; }
+
+  switch (error->type) {
+    <%- errors.each do |error| -%>
+    case <%= error.type %>: error_pretty_print_<%= error.human %>((<%= error.struct_type %>*) error, indent, relative_indent, buffer); break;
+    <%- end -%>
+  }
+}

data/templates/src/include/ast_nodes.h.erb

@@ -0,0 +1,46 @@
+#ifndef HERB_AST_NODES_H
+#define HERB_AST_NODES_H
+
+#include <stdbool.h>
+#include <prism.h>
+
+#include "array.h"
+#include "buffer.h"
+#include "position.h"
+#include "location.h"
+#include "token_struct.h"
+#include "analyzed_ruby.h"
+#include "element_source.h"
+
+typedef enum {
+<%- nodes.each do |node| -%>
+  <%= node.type.upcase %>,
+<%- end -%>
+} ast_node_type_T;
+
+typedef struct AST_NODE_STRUCT {
+  ast_node_type_T type;
+  location_T* location;
+  // maybe a range too?
+  array_T* errors;
+} AST_NODE_T;
+
+<%- nodes.each do |node| -%>
+<%- arguments = node.fields.any? ? node.fields.map { |field| [field.c_type, " ", field.name, ";"].join }.join("\n  ") : "/* no additional fields */" -%>
+
+typedef struct <%= node.struct_name %> {
+  AST_NODE_T base;
+  <%= arguments %>
+} <%= node.struct_type %>;
+<%- end -%>
+
+<%- nodes.each do |node| -%>
+<%- node_arguments = node.fields.any? ? node.fields.map { |field| [field.c_type, " ", field.name].join } : [] -%>
+<%- arguments = node_arguments + ["position_T* start_position", "position_T* end_position", "array_T* errors"] -%>
+<%= node.struct_type %>* ast_<%= node.human %>_init(<%= arguments.join(", ") %>);
+<%- end -%>
+
+const char* ast_node_type_to_string(AST_NODE_T* node);
+const char* ast_node_human_type(AST_NODE_T* node);
+
+#endif

data/templates/src/include/ast_pretty_print.h.erb

@@ -0,0 +1,14 @@
+#ifndef HERB_AST_PRETTY_PRINT_H
+#define HERB_AST_PRETTY_PRINT_H
+
+#include "ast_nodes.h"
+#include "buffer.h"
+
+void ast_pretty_print_node(
+  AST_NODE_T* node,
+  size_t indent,
+  size_t relative_indent,
+  buffer_T* buffer
+);
+
+#endif

data/templates/src/include/errors.h.erb

@@ -0,0 +1,58 @@
+#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 {
+<%- errors.each do |error| -%>
+  <%= error.type.upcase %>,
+<%- end -%>
+} error_type_T;
+
+typedef struct ERROR_STRUCT {
+  error_type_T type;
+  location_T* location;
+  char* message;
+} ERROR_T;
+
+<%- errors.each do |error| -%>
+<%- arguments = error.fields.any? ? error.fields.map { |field| [field.c_type, " ", field.name, ";"].join }.join("\n  ") : "/* no additional fields */" -%>
+
+typedef struct {
+  ERROR_T base;
+  <%= arguments %>
+} <%= error.struct_type %>;
+<%- end -%>
+
+<%- errors.each do |error| -%>
+<%- error_arguments = error.fields.any? ? error.fields.map { |field| [field.c_type, " ", field.name].join } : [] -%>
+<%- arguments = error_arguments + ["position_T* start", "position_T* end"] -%>
+<%= error.struct_type %>* <%= error.human %>_init(<%= arguments.join(", ") %>);
+void append_<%= error.human %>(<%= (arguments << "array_T* errors").join(", ") %>);
+<%- end -%>
+
+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

data/templates/src/visitor.c.erb

@@ -0,0 +1,47 @@
+#include <stdio.h>
+
+#include "include/array.h"
+#include "include/visitor.h"
+#include "include/ast_node.h"
+#include "include/ast_nodes.h"
+
+void herb_visit_node(const AST_NODE_T* node, bool (*visitor)(const AST_NODE_T*, void*), void* data) {
+  if (visitor(node, data) && node != NULL) {
+    herb_visit_child_nodes(node, visitor, data);
+  }
+}
+
+void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NODE_T *node, void *data), void *data) {
+  if (node == NULL) {
+    return;
+  }
+
+  switch (node->type) {
+    <%- nodes.each do |node| -%>
+    <%- if node.fields.count { |field| [Herb::Template::NodeField, Herb::Template::ArrayField].include?(field.class) }.positive? -%>
+    case <%= node.type %>: {
+      const <%= node.struct_type %>* <%= node.human %> = ((const <%= node.struct_type %> *) node);
+
+      <%- node.fields.each do |field| -%>
+      <%- case field -%>
+      <%- when Herb::Template::NodeField -%>
+      if (<%= node.human %>-><%= field.name %> != NULL) {
+        herb_visit_node((AST_NODE_T *) <%= node.human %>-><%= field.name %>, visitor, data);
+      }
+
+      <%- when Herb::Template::ArrayField -%>
+      if (<%= node.human %>-><%= field.name %> != NULL) {
+        for (size_t index = 0; index < array_size(<%= node.human %>-><%= field.name %>); index++) {
+          herb_visit_node(array_get(<%= node.human %>-><%= field.name %>, index), visitor, data);
+        }
+      }
+
+      <%- end -%>
+      <%- end -%>
+    } break;
+
+    <%- end -%>
+    <%- end -%>
+    default: break;
+  }
+}