herb 0.0.1 → 0.1.0

data/src/analyze_helpers.c

@@ -0,0 +1,241 @@
+#include <prism.h>
+#include <stdbool.h>
+#include <string.h>
+
+#include "include/analyzed_ruby.h"
+
+bool has_if_node(analyzed_ruby_T* analyzed) {
+  return analyzed->has_if_node;
+}
+
+bool has_elsif_node(analyzed_ruby_T* analyzed) {
+  return analyzed->has_elsif_node;
+}
+
+bool has_else_node(analyzed_ruby_T* analyzed) {
+  return analyzed->has_else_node;
+}
+
+bool has_end(analyzed_ruby_T* analyzed) {
+  return analyzed->has_end;
+}
+
+bool has_block_node(analyzed_ruby_T* analyzed) {
+  return analyzed->has_block_node;
+}
+
+bool has_block_closing(analyzed_ruby_T* analyzed) {
+  return analyzed->has_block_closing;
+}
+
+bool has_case_node(analyzed_ruby_T* analyzed) {
+  return analyzed->has_case_node;
+}
+
+bool has_when_node(analyzed_ruby_T* analyzed) {
+  return analyzed->has_when_node;
+}
+
+bool has_for_node(analyzed_ruby_T* analyzed) {
+  return analyzed->has_for_node;
+}
+
+bool has_while_node(analyzed_ruby_T* analyzed) {
+  return analyzed->has_while_node;
+}
+
+bool has_until_node(analyzed_ruby_T* analyzed) {
+  return analyzed->has_until_node;
+}
+
+bool has_begin_node(analyzed_ruby_T* analyzed) {
+  return analyzed->has_begin_node;
+}
+
+bool has_rescue_node(analyzed_ruby_T* analyzed) {
+  return analyzed->has_rescue_node;
+}
+
+bool has_ensure_node(analyzed_ruby_T* analyzed) {
+  return analyzed->has_ensure_node;
+}
+
+bool has_unless_node(analyzed_ruby_T* analyzed) {
+  return analyzed->has_unless_node;
+}
+
+bool has_error_message(analyzed_ruby_T* anlayzed, const char* message) {
+  for (const pm_diagnostic_t* error = (const pm_diagnostic_t*) anlayzed->parser.error_list.head; error != NULL;
+       error = (const pm_diagnostic_t*) error->node.next) {
+    if (strcmp(error->message, message) == 0) { return true; }
+  }
+
+  return false;
+}
+
+bool search_if_nodes(const pm_node_t* node, void* data) {
+  analyzed_ruby_T* analyzed = (analyzed_ruby_T*) data;
+
+  if (node->type == PM_IF_NODE) {
+    analyzed->has_if_node = true;
+    return true;
+  } else {
+    pm_visit_child_nodes(node, search_if_nodes, analyzed);
+  }
+
+  return false;
+}
+
+bool search_block_nodes(const pm_node_t* node, void* data) {
+  analyzed_ruby_T* analyzed = (analyzed_ruby_T*) data;
+
+  if (node->type == PM_BLOCK_NODE) {
+    analyzed->has_block_node = true;
+    return true;
+  } else {
+    pm_visit_child_nodes(node, search_block_nodes, analyzed);
+  }
+
+  return false;
+}
+
+bool search_case_nodes(const pm_node_t* node, void* data) {
+  analyzed_ruby_T* analyzed = (analyzed_ruby_T*) data;
+
+  if (node->type == PM_CASE_MATCH_NODE) {
+    analyzed->has_case_node = true;
+    return true;
+  } else {
+    pm_visit_child_nodes(node, search_case_nodes, analyzed);
+  }
+
+  return false;
+}
+
+bool search_while_nodes(const pm_node_t* node, void* data) {
+  analyzed_ruby_T* analyzed = (analyzed_ruby_T*) data;
+
+  if (node->type == PM_WHILE_NODE) {
+    analyzed->has_while_node = true;
+    return true;
+  } else {
+    pm_visit_child_nodes(node, search_while_nodes, analyzed);
+  }
+
+  return false;
+}
+
+bool search_for_nodes(const pm_node_t* node, void* data) {
+  analyzed_ruby_T* analyzed = (analyzed_ruby_T*) data;
+
+  if (node->type == PM_FOR_NODE) {
+    analyzed->has_for_node = true;
+    return true;
+  } else {
+    pm_visit_child_nodes(node, search_for_nodes, analyzed);
+  }
+
+  return false;
+}
+
+bool search_until_nodes(const pm_node_t* node, void* data) {
+  analyzed_ruby_T* analyzed = (analyzed_ruby_T*) data;
+
+  if (node->type == PM_UNTIL_NODE) {
+    analyzed->has_until_node = true;
+    return true;
+  } else {
+    pm_visit_child_nodes(node, search_until_nodes, analyzed);
+  }
+
+  return false;
+}
+
+bool search_begin_nodes(const pm_node_t* node, void* data) {
+  analyzed_ruby_T* analyzed = (analyzed_ruby_T*) data;
+
+  if (node->type == PM_BEGIN_NODE) {
+    analyzed->has_begin_node = true;
+    return true;
+  } else {
+    pm_visit_child_nodes(node, search_begin_nodes, analyzed);
+  }
+
+  return false;
+}
+
+bool search_unless_nodes(const pm_node_t* node, void* data) {
+  analyzed_ruby_T* analyzed = (analyzed_ruby_T*) data;
+
+  if (node->type == PM_UNLESS_NODE) {
+    analyzed->has_unless_node = true;
+    return true;
+  } else {
+    pm_visit_child_nodes(node, search_unless_nodes, analyzed);
+  }
+
+  return false;
+}
+
+bool search_elsif_nodes(analyzed_ruby_T* analyzed) {
+  if (has_error_message(analyzed, "unexpected 'elsif', ignoring it")) {
+    analyzed->has_elsif_node = true;
+    return true;
+  }
+
+  return false;
+}
+
+bool search_else_nodes(analyzed_ruby_T* analyzed) {
+  if (has_error_message(analyzed, "unexpected 'else', ignoring it")) {
+    analyzed->has_else_node = true;
+    return true;
+  }
+
+  return false;
+}
+
+bool search_end_nodes(analyzed_ruby_T* analyzed) {
+  if (has_error_message(analyzed, "unexpected 'end', ignoring it")) {
+    analyzed->has_end = true;
+    return true;
+  }
+
+  return false;
+}
+
+bool search_block_closing_nodes(analyzed_ruby_T* analyzed) {
+  if (has_error_message(analyzed, "unexpected '}', ignoring it")) {
+    analyzed->has_block_closing = true;
+    return true;
+  }
+
+  return false;
+}
+
+bool search_when_nodes(analyzed_ruby_T* analyzed) {
+  if (has_error_message(analyzed, "unexpected 'when', ignoring it")) {
+    analyzed->has_when_node = true;
+    return true;
+  }
+
+  return false;
+}
+
+bool search_rescue_nodes(analyzed_ruby_T* analyzed) {
+  if (has_error_message(analyzed, "unexpected 'rescue', ignoring it")) {
+    analyzed->has_rescue_node = true;
+    return true;
+  }
+
+  return false;
+}
+
+bool search_ensure_nodes(analyzed_ruby_T* analyzed) {
+  if (has_error_message(analyzed, "unexpected 'ensure', ignoring it")) {
+    analyzed->has_ensure_node = true;
+    return true;
+  }
+
+  return false;
+}

data/src/analyzed_ruby.c

@@ -0,0 +1,35 @@
+#include "include/analyzed_ruby.h"
+
+#include <prism.h>
+#include <string.h>
+
+analyzed_ruby_T* init_analyzed_ruby(char* source) {
+  analyzed_ruby_T* analyzed = malloc(sizeof(analyzed_ruby_T));
+
+  pm_parser_init(&analyzed->parser, (const uint8_t*) source, strlen(source), NULL);
+
+  analyzed->root = pm_parse(&analyzed->parser);
+  analyzed->valid = (analyzed->parser.error_list.size == 0);
+  analyzed->parsed = true;
+  analyzed->has_if_node = false;
+  analyzed->has_elsif_node = false;
+  analyzed->has_else_node = false;
+  analyzed->has_end = false;
+  analyzed->has_block_node = false;
+  analyzed->has_block_closing = false;
+  analyzed->has_case_node = false;
+  analyzed->has_when_node = false;
+  analyzed->has_for_node = false;
+  analyzed->has_while_node = false;
+  analyzed->has_until_node = false;
+  analyzed->has_begin_node = false;
+  analyzed->has_rescue_node = false;
+  analyzed->has_ensure_node = false;
+  analyzed->has_unless_node = false;
+
+  return analyzed;
+}
+
+void free_analyzed_ruby(analyzed_ruby_T* analyzed) {
+  // TODO
+}

data/src/array.c

@@ -0,0 +1,137 @@
+#include <stdint.h>
+#include <stdio.h>
+
+#include "include/array.h"
+#include "include/macros.h"
+#include "include/memory.h"
+
+size_t array_sizeof(void) {
+  return sizeof(array_T);
+}
+
+array_T* array_init(const size_t capacity) {
+  array_T* array = safe_malloc(array_sizeof());
+
+  array->size = 0;
+  array->capacity = capacity;
+  array->items = nullable_safe_malloc(sizeof(void*) * capacity);
+
+  if (!array->items) {
+    free(array);
+    return NULL;
+  }
+
+  return array;
+}
+
+void array_append(array_T* array, void* item) {
+  if (array->size >= array->capacity) {
+    size_t new_capacity;
+
+    if (array->capacity == 0) {
+      new_capacity = 1;
+    } else if (array->capacity > SIZE_MAX / (2 * sizeof(void*))) {
+      fprintf(stderr, "Warning: Approaching array size limits, using conservative growth.\n");
+      new_capacity = array->capacity + 1024 / sizeof(void*);
+
+      if (new_capacity < array->capacity) { new_capacity = SIZE_MAX / sizeof(void*); }
+    } else {
+      new_capacity = array->capacity * 2;
+    }
+
+    if (new_capacity > SIZE_MAX / sizeof(void*)) {
+      fprintf(stderr, "Error: Array allocation would exceed system limits.\n");
+      return;
+    }
+
+    size_t new_size_bytes = new_capacity * sizeof(void*);
+    void* new_items = safe_realloc(array->items, new_size_bytes);
+
+    if (unlikely(new_items == NULL)) { return; }
+
+    array->items = (void**) new_items;
+    array->capacity = new_capacity;
+  }
+
+  array->items[array->size] = item;
+  array->size++;
+}
+
+void* array_get(const array_T* array, const size_t index) {
+  if (index >= array->size) { return NULL; }
+
+  return array->items[index];
+}
+
+void* array_first(array_T* array) {
+  if (!array || array->size == 0) { return NULL; }
+  return array->items[0];
+}
+
+void* array_last(array_T* array) {
+  if (!array || array->size == 0) { return NULL; }
+  return array->items[array->size - 1];
+}
+
+void array_set(const array_T* array, const size_t index, void* item) {
+  if (index >= array->size) { return; }
+
+  array->items[index] = item;
+}
+
+void array_remove(array_T* array, const size_t index) {
+  if (index >= array->size) { return; }
+
+  for (size_t i = index; i < array->size - 1; i++) {
+    array->items[i] = array->items[i + 1];
+  }
+
+  array->size--;
+}
+
+size_t array_index_of(array_T* array, void* item) {
+  for (size_t i = 0; i < array->size; i++) {
+    if (array->items[i] == item) { return i; }
+  }
+
+  return SIZE_MAX;
+}
+
+void array_remove_item(array_T* array, void* item) {
+  size_t index = array_index_of(array, item);
+
+  if (index != SIZE_MAX) { array_remove(array, index); }
+}
+
+// Alias for array_append
+void array_push(array_T* array, void* item) {
+  array_append(array, item);
+}
+
+void* array_pop(array_T* array) {
+  if (!array || array->size == 0) { return NULL; }
+
+  void* last_item = array_last(array);
+  array->size--;
+
+  return last_item;
+}
+
+size_t array_size(const array_T* array) {
+  if (array == NULL) { return 0; }
+
+  return array->size;
+}
+
+size_t array_capacity(const array_T* array) {
+  return array->capacity;
+}
+
+void array_free(array_T** array) {
+  if (!array || !*array) { return; }
+
+  free((*array)->items);
+  free(*array);
+
+  *array = NULL;
+}

data/src/ast_node.c

@@ -0,0 +1,81 @@
+#include "include/ast_node.h"
+#include "include/ast_nodes.h"
+#include "include/errors.h"
+#include "include/token.h"
+#include "include/util.h"
+
+#include <prism.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+size_t ast_node_sizeof(void) {
+  return sizeof(struct AST_NODE_STRUCT);
+}
+
+void ast_node_init(AST_NODE_T* node, const ast_node_type_T type, position_T* start, position_T* end, array_T* errors) {
+  if (!node) { return; }
+
+  node->type = type;
+  node->location = location_init(position_copy(start), position_copy(end));
+
+  if (errors == NULL) {
+    node->errors = array_init(8);
+  } else {
+    node->errors = errors;
+  }
+}
+
+AST_LITERAL_NODE_T* ast_literal_node_init_from_token(const token_T* token) {
+  AST_LITERAL_NODE_T* literal = malloc(sizeof(AST_LITERAL_NODE_T));
+
+  ast_node_init(&literal->base, AST_LITERAL_NODE, token->location->start, token->location->end, NULL);
+
+  literal->content = herb_strdup(token->value);
+
+  return literal;
+}
+
+ast_node_type_T ast_node_type(const AST_NODE_T* node) {
+  return node->type;
+}
+
+size_t ast_node_errors_count(const AST_NODE_T* node) {
+  return array_size(node->errors);
+}
+
+array_T* ast_node_errors(const AST_NODE_T* node) {
+  return node->errors;
+}
+
+void ast_node_append_error(const AST_NODE_T* node, ERROR_T* error) {
+  array_append(node->errors, error);
+}
+
+void ast_node_set_start(AST_NODE_T* node, position_T* position) {
+  if (node->location->start != NULL) { position_free(node->location->start); }
+
+  node->location->start = position_copy(position);
+}
+
+void ast_node_set_end(AST_NODE_T* node, position_T* position) {
+  if (node->location->end != NULL) { position_free(node->location->end); }
+
+  node->location->end = position_copy(position);
+}
+
+void ast_node_set_start_from_token(AST_NODE_T* node, const token_T* token) {
+  ast_node_set_start(node, token->location->start);
+}
+
+void ast_node_set_end_from_token(AST_NODE_T* node, const token_T* token) {
+  ast_node_set_end(node, token->location->end);
+}
+
+void ast_node_set_positions_from_token(AST_NODE_T* node, const token_T* token) {
+  ast_node_set_start_from_token(node, token);
+  ast_node_set_end_from_token(node, token);
+}
+
+bool ast_node_is(const AST_NODE_T* node, const ast_node_type_T type) {
+  return node->type == type;
+}