herb 0.1.0-x86_64-linux-gnu

data/src/token.c

@@ -0,0 +1,194 @@
+#include "include/token.h"
+#include "include/json.h"
+#include "include/lexer.h"
+#include "include/position.h"
+#include "include/token_struct.h"
+#include "include/util.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+size_t token_sizeof(void) {
+  return sizeof(struct TOKEN_STRUCT);
+}
+
+token_T* token_init(const char* value, const token_type_T type, lexer_T* lexer) {
+  token_T* token = calloc(1, token_sizeof());
+
+  if (type == TOKEN_NEWLINE) {
+    lexer->current_line++;
+    lexer->current_column = 0;
+  }
+
+  if (value) {
+    token->value = herb_strdup(value);
+  } else {
+    token->value = NULL;
+  }
+
+  token->type = type;
+  token->range = range_init(lexer->previous_position, lexer->current_position);
+
+  token->location =
+    location_from(lexer->previous_line, lexer->previous_column, lexer->current_line, lexer->current_column);
+
+  lexer->previous_line = lexer->current_line;
+  lexer->previous_column = lexer->current_column;
+  lexer->previous_position = lexer->current_position;
+
+  return token;
+}
+
+const char* token_type_to_string(const token_type_T type) {
+  switch (type) {
+    case TOKEN_WHITESPACE: return "TOKEN_WHITESPACE";
+    case TOKEN_NBSP: return "TOKEN_NBSP";
+    case TOKEN_NEWLINE: return "TOKEN_NEWLINE";
+    case TOKEN_IDENTIFIER: return "TOKEN_IDENTIFIER";
+    case TOKEN_HTML_DOCTYPE: return "TOKEN_HTML_DOCTYPE";
+    case TOKEN_HTML_TAG_START: return "TOKEN_HTML_TAG_START";
+    case TOKEN_HTML_TAG_END: return "TOKEN_HTML_TAG_END";
+    case TOKEN_HTML_TAG_START_CLOSE: return "TOKEN_HTML_TAG_START_CLOSE";
+    case TOKEN_HTML_TAG_SELF_CLOSE: return "TOKEN_HTML_TAG_SELF_CLOSE";
+    case TOKEN_HTML_COMMENT_START: return "TOKEN_HTML_COMMENT_START";
+    case TOKEN_HTML_COMMENT_END: return "TOKEN_HTML_COMMENT_END";
+    case TOKEN_EQUALS: return "TOKEN_EQUALS";
+    case TOKEN_QUOTE: return "TOKEN_QUOTE";
+    case TOKEN_DASH: return "TOKEN_DASH";
+    case TOKEN_UNDERSCORE: return "TOKEN_UNDERSCORE";
+    case TOKEN_EXCLAMATION: return "TOKEN_EXCLAMATION";
+    case TOKEN_SLASH: return "TOKEN_SLASH";
+    case TOKEN_SEMICOLON: return "TOKEN_SEMICOLON";
+    case TOKEN_COLON: return "TOKEN_COLON";
+    case TOKEN_LT: return "TOKEN_LT";
+    case TOKEN_PERCENT: return "TOKEN_PERCENT";
+    case TOKEN_AMPERSAND: return "TOKEN_AMPERSAND";
+    case TOKEN_ERB_START: return "TOKEN_ERB_START";
+    case TOKEN_ERB_CONTENT: return "TOKEN_ERB_CONTENT";
+    case TOKEN_ERB_END: return "TOKEN_ERB_END";
+    case TOKEN_CHARACTER: return "TOKEN_CHARACTER";
+    case TOKEN_ERROR: return "TOKEN_ERROR";
+    case TOKEN_EOF: return "TOKEN_EOF";
+  }
+
+  return "Unkown token_type_T";
+}
+
+char* token_to_string(const token_T* token) {
+  const char* type_string = token_type_to_string(token->type);
+  const char* template = "#<Herb::Token type=\"%s\" value=\"%s\" range=[%d, %d] start=(%d:%d) end=(%d:%d)>";
+
+  char* string = calloc(strlen(type_string) + strlen(template) + strlen(token->value) + 16, sizeof(char));
+  char* escaped;
+
+  if (token->type == TOKEN_EOF) {
+    escaped = herb_strdup("<EOF>");
+  } else {
+    escaped = escape_newlines(token->value);
+  }
+
+  sprintf(
+    string,
+    template,
+    type_string,
+    escaped,
+    token->range->from,
+    token->range->to,
+    token->location->start->line,
+    token->location->start->column,
+    token->location->end->line,
+    token->location->end->column
+  );
+
+  free(escaped);
+
+  return string;
+}
+
+char* token_to_json(const token_T* token) {
+  buffer_T json = buffer_new();
+
+  json_start_root_object(&json);
+  json_add_string(&json, "type", token_type_to_string(token->type));
+  json_add_string(&json, "value", token->value);
+
+  buffer_T range = buffer_new();
+  json_start_array(&json, "range");
+  json_add_size_t(&range, NULL, token->range->from);
+  json_add_size_t(&range, NULL, token->range->to);
+  buffer_concat(&json, &range);
+  buffer_free(&range);
+  json_end_array(&json);
+
+  buffer_T start = buffer_new();
+  json_start_object(&json, "start");
+  json_add_size_t(&start, "line", token->location->start->line);
+  json_add_size_t(&start, "column", token->location->start->column);
+  buffer_concat(&json, &start);
+  buffer_free(&start);
+  json_end_object(&json);
+
+  buffer_T end = buffer_new();
+  json_start_object(&json, "end");
+  json_add_size_t(&end, "line", token->location->end->line);
+  json_add_size_t(&end, "column", token->location->end->column);
+  buffer_concat(&json, &end);
+  buffer_free(&end);
+  json_end_object(&json);
+
+  json_end_object(&json);
+
+  return buffer_value(&json);
+}
+
+char* token_value(const token_T* token) {
+  return token->value;
+}
+
+int token_type(const token_T* token) {
+  return token->type;
+}
+
+position_T* token_start_position(token_T* token) {
+  return token->location->start;
+}
+
+position_T* token_end_position(token_T* token) {
+  return token->location->end;
+}
+
+token_T* token_copy(token_T* token) {
+  if (!token) { return NULL; }
+
+  token_T* new_token = calloc(1, token_sizeof());
+
+  if (!new_token) { return NULL; }
+
+  if (token->value) {
+    new_token->value = herb_strdup(token->value);
+
+    if (!new_token->value) {
+      free(new_token);
+      return NULL;
+    }
+  } else {
+    new_token->value = NULL;
+  }
+
+  new_token->type = token->type;
+  new_token->range = range_copy(token->range);
+  new_token->location = location_copy(token->location);
+
+  return new_token;
+}
+
+void token_free(token_T* token) {
+  if (!token) { return; }
+
+  if (token->value != NULL) { free(token->value); }
+  if (token->range != NULL) { range_free(token->range); }
+  if (token->location != NULL) { location_free(token->location); }
+
+  free(token);
+}

data/src/token_matchers.c

@@ -0,0 +1,32 @@
+#include "include/token_matchers.h"
+#include "include/parser.h"
+#include "include/token.h"
+
+#include <stdarg.h>
+#include <stdbool.h>
+
+bool token_is(parser_T* parser, token_type_T expected_type) {
+  return parser->current_token->type == expected_type;
+}
+
+bool token_is_not(parser_T* parser, token_type_T type) {
+  return parser->current_token->type != type;
+}
+
+bool token_matches_any(token_type_T current_token, token_type_T first_token, ...) {
+  if (current_token == first_token) { return true; }
+
+  va_list tokens;
+  va_start(tokens, first_token);
+  token_type_T token;
+
+  while ((token = va_arg(tokens, token_type_T)) != TOKEN_SENTINEL) {
+    if (current_token == token) {
+      va_end(tokens);
+      return true;
+    }
+  }
+
+  va_end(tokens);
+  return false;
+}

data/src/util.c

@@ -0,0 +1,128 @@
+#include "include/util.h"
+
+#include <ctype.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+int is_whitespace(const int character) {
+  return character == ' ' || character == '\t';
+}
+
+int is_newline(const int character) {
+  return character == 13 || character == 10;
+}
+
+int count_in_string(const char* string, const char character) {
+  int count = 0;
+
+  while (*string != '\0') {
+    if (*string == character) { count++; }
+
+    string++;
+  }
+
+  return count;
+}
+
+int count_newlines(const char* string) {
+  int count = 0;
+
+  while (*string) {
+    if (*string == '\r') {
+      count++;
+      if (*(string + 1) == '\n') { string++; }
+    } else if (*string == '\n') {
+      count++;
+    }
+
+    string++;
+  }
+
+  return count;
+}
+
+char* replace_char(char* string, const char find, const char replace) {
+  while (*string != '\0') {
+    if (*string == find) { *string = replace; }
+
+    string++;
+  }
+
+  return string;
+}
+
+char* escape_newlines(const char* input) {
+  char* output = calloc(strlen(input) * 2 + 1, sizeof(char));
+  char* orig_output = output;
+
+  while (*input) {
+    if (*input == '\n') {
+      *output++ = '\\';
+      *output++ = 'n';
+    } else if (*input == '\r') {
+      *output++ = '\\';
+      *output++ = 'r';
+    } else {
+      *output++ = *input;
+    }
+
+    input++;
+  }
+
+  *output = '\0';
+
+  return orig_output;
+}
+
+char* wrap_string(const char* input, const char character) {
+  if (input == NULL) { return NULL; }
+
+  const size_t length = strlen(input);
+  char* wrapped = malloc(length + 3);
+
+  if (wrapped == NULL) { return NULL; }
+
+  wrapped[0] = character;
+  strcpy(wrapped + 1, input);
+  wrapped[length + 1] = character;
+  wrapped[length + 2] = '\0';
+
+  return wrapped;
+}
+
+char* quoted_string(const char* input) {
+  return wrap_string(input, '"');
+}
+
+// Check if a string is blank (NULL, empty, or only contains whitespace)
+bool string_blank(const char* input) {
+  if (input == NULL || input[0] == '\0') { return true; }
+
+  for (const char* p = input; *p != '\0'; p++) {
+    if (!isspace(*p)) { return false; }
+  }
+
+  return true;
+}
+
+// Check if a string is present (not blank)
+bool string_present(const char* input) {
+  return !string_blank(input);
+}
+
+char* herb_strdup(const char* s) {
+  size_t len = strlen(s) + 1;
+  char* copy = malloc(len);
+
+  if (copy) { memcpy(copy, s, len); }
+
+  return copy;
+}
+
+char* size_t_to_string(const size_t value) {
+  char* buffer = malloc(21);
+  snprintf(buffer, 21, "%zu", value);
+
+  return buffer;
+}

data/src/visitor.c

@@ -0,0 +1,321 @@
+// NOTE: This file is generated by the templates/template.rb script and should not
+// be modified manually. See /Users/marcoroth/Development/herb-release/templates/src/visitor.c.erb
+
+#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) {
+    case AST_DOCUMENT_NODE: {
+      const AST_DOCUMENT_NODE_T* document_node = ((const AST_DOCUMENT_NODE_T *) node);
+
+      if (document_node->children != NULL) {
+        for (size_t index = 0; index < array_size(document_node->children); index++) {
+          herb_visit_node(array_get(document_node->children, index), visitor, data);
+        }
+      }
+
+    } break;
+
+    case AST_HTML_OPEN_TAG_NODE: {
+      const AST_HTML_OPEN_TAG_NODE_T* html_open_tag_node = ((const AST_HTML_OPEN_TAG_NODE_T *) node);
+
+      if (html_open_tag_node->children != NULL) {
+        for (size_t index = 0; index < array_size(html_open_tag_node->children); index++) {
+          herb_visit_node(array_get(html_open_tag_node->children, index), visitor, data);
+        }
+      }
+
+    } break;
+
+    case AST_HTML_SELF_CLOSE_TAG_NODE: {
+      const AST_HTML_SELF_CLOSE_TAG_NODE_T* html_self_close_tag_node = ((const AST_HTML_SELF_CLOSE_TAG_NODE_T *) node);
+
+      if (html_self_close_tag_node->attributes != NULL) {
+        for (size_t index = 0; index < array_size(html_self_close_tag_node->attributes); index++) {
+          herb_visit_node(array_get(html_self_close_tag_node->attributes, index), visitor, data);
+        }
+      }
+
+    } break;
+
+    case AST_HTML_ELEMENT_NODE: {
+      const AST_HTML_ELEMENT_NODE_T* html_element_node = ((const AST_HTML_ELEMENT_NODE_T *) node);
+
+      if (html_element_node->open_tag != NULL) {
+        herb_visit_node((AST_NODE_T *) html_element_node->open_tag, visitor, data);
+      }
+
+      if (html_element_node->body != NULL) {
+        for (size_t index = 0; index < array_size(html_element_node->body); index++) {
+          herb_visit_node(array_get(html_element_node->body, index), visitor, data);
+        }
+      }
+
+      if (html_element_node->close_tag != NULL) {
+        herb_visit_node((AST_NODE_T *) html_element_node->close_tag, visitor, data);
+      }
+
+    } break;
+
+    case AST_HTML_ATTRIBUTE_VALUE_NODE: {
+      const AST_HTML_ATTRIBUTE_VALUE_NODE_T* html_attribute_value_node = ((const AST_HTML_ATTRIBUTE_VALUE_NODE_T *) node);
+
+      if (html_attribute_value_node->children != NULL) {
+        for (size_t index = 0; index < array_size(html_attribute_value_node->children); index++) {
+          herb_visit_node(array_get(html_attribute_value_node->children, index), visitor, data);
+        }
+      }
+
+    } break;
+
+    case AST_HTML_ATTRIBUTE_NODE: {
+      const AST_HTML_ATTRIBUTE_NODE_T* html_attribute_node = ((const AST_HTML_ATTRIBUTE_NODE_T *) node);
+
+      if (html_attribute_node->name != NULL) {
+        herb_visit_node((AST_NODE_T *) html_attribute_node->name, visitor, data);
+      }
+
+      if (html_attribute_node->value != NULL) {
+        herb_visit_node((AST_NODE_T *) html_attribute_node->value, visitor, data);
+      }
+
+    } break;
+
+    case AST_HTML_COMMENT_NODE: {
+      const AST_HTML_COMMENT_NODE_T* html_comment_node = ((const AST_HTML_COMMENT_NODE_T *) node);
+
+      if (html_comment_node->children != NULL) {
+        for (size_t index = 0; index < array_size(html_comment_node->children); index++) {
+          herb_visit_node(array_get(html_comment_node->children, index), visitor, data);
+        }
+      }
+
+    } break;
+
+    case AST_HTML_DOCTYPE_NODE: {
+      const AST_HTML_DOCTYPE_NODE_T* html_doctype_node = ((const AST_HTML_DOCTYPE_NODE_T *) node);
+
+      if (html_doctype_node->children != NULL) {
+        for (size_t index = 0; index < array_size(html_doctype_node->children); index++) {
+          herb_visit_node(array_get(html_doctype_node->children, index), visitor, data);
+        }
+      }
+
+    } break;
+
+    case AST_ERB_ELSE_NODE: {
+      const AST_ERB_ELSE_NODE_T* erb_else_node = ((const AST_ERB_ELSE_NODE_T *) node);
+
+      if (erb_else_node->statements != NULL) {
+        for (size_t index = 0; index < array_size(erb_else_node->statements); index++) {
+          herb_visit_node(array_get(erb_else_node->statements, index), visitor, data);
+        }
+      }
+
+    } break;
+
+    case AST_ERB_IF_NODE: {
+      const AST_ERB_IF_NODE_T* erb_if_node = ((const AST_ERB_IF_NODE_T *) node);
+
+      if (erb_if_node->statements != NULL) {
+        for (size_t index = 0; index < array_size(erb_if_node->statements); index++) {
+          herb_visit_node(array_get(erb_if_node->statements, index), visitor, data);
+        }
+      }
+
+      if (erb_if_node->subsequent != NULL) {
+        herb_visit_node((AST_NODE_T *) erb_if_node->subsequent, visitor, data);
+      }
+
+      if (erb_if_node->end_node != NULL) {
+        herb_visit_node((AST_NODE_T *) erb_if_node->end_node, visitor, data);
+      }
+
+    } break;
+
+    case AST_ERB_BLOCK_NODE: {
+      const AST_ERB_BLOCK_NODE_T* erb_block_node = ((const AST_ERB_BLOCK_NODE_T *) node);
+
+      if (erb_block_node->body != NULL) {
+        for (size_t index = 0; index < array_size(erb_block_node->body); index++) {
+          herb_visit_node(array_get(erb_block_node->body, index), visitor, data);
+        }
+      }
+
+      if (erb_block_node->end_node != NULL) {
+        herb_visit_node((AST_NODE_T *) erb_block_node->end_node, visitor, data);
+      }
+
+    } break;
+
+    case AST_ERB_WHEN_NODE: {
+      const AST_ERB_WHEN_NODE_T* erb_when_node = ((const AST_ERB_WHEN_NODE_T *) node);
+
+      if (erb_when_node->statements != NULL) {
+        for (size_t index = 0; index < array_size(erb_when_node->statements); index++) {
+          herb_visit_node(array_get(erb_when_node->statements, index), visitor, data);
+        }
+      }
+
+    } break;
+
+    case AST_ERB_CASE_NODE: {
+      const AST_ERB_CASE_NODE_T* erb_case_node = ((const AST_ERB_CASE_NODE_T *) node);
+
+      if (erb_case_node->children != NULL) {
+        for (size_t index = 0; index < array_size(erb_case_node->children); index++) {
+          herb_visit_node(array_get(erb_case_node->children, index), visitor, data);
+        }
+      }
+
+      if (erb_case_node->conditions != NULL) {
+        for (size_t index = 0; index < array_size(erb_case_node->conditions); index++) {
+          herb_visit_node(array_get(erb_case_node->conditions, index), visitor, data);
+        }
+      }
+
+      if (erb_case_node->else_clause != NULL) {
+        herb_visit_node((AST_NODE_T *) erb_case_node->else_clause, visitor, data);
+      }
+
+      if (erb_case_node->end_node != NULL) {
+        herb_visit_node((AST_NODE_T *) erb_case_node->end_node, visitor, data);
+      }
+
+    } break;
+
+    case AST_ERB_WHILE_NODE: {
+      const AST_ERB_WHILE_NODE_T* erb_while_node = ((const AST_ERB_WHILE_NODE_T *) node);
+
+      if (erb_while_node->statements != NULL) {
+        for (size_t index = 0; index < array_size(erb_while_node->statements); index++) {
+          herb_visit_node(array_get(erb_while_node->statements, index), visitor, data);
+        }
+      }
+
+      if (erb_while_node->end_node != NULL) {
+        herb_visit_node((AST_NODE_T *) erb_while_node->end_node, visitor, data);
+      }
+
+    } break;
+
+    case AST_ERB_UNTIL_NODE: {
+      const AST_ERB_UNTIL_NODE_T* erb_until_node = ((const AST_ERB_UNTIL_NODE_T *) node);
+
+      if (erb_until_node->statements != NULL) {
+        for (size_t index = 0; index < array_size(erb_until_node->statements); index++) {
+          herb_visit_node(array_get(erb_until_node->statements, index), visitor, data);
+        }
+      }
+
+      if (erb_until_node->end_node != NULL) {
+        herb_visit_node((AST_NODE_T *) erb_until_node->end_node, visitor, data);
+      }
+
+    } break;
+
+    case AST_ERB_FOR_NODE: {
+      const AST_ERB_FOR_NODE_T* erb_for_node = ((const AST_ERB_FOR_NODE_T *) node);
+
+      if (erb_for_node->statements != NULL) {
+        for (size_t index = 0; index < array_size(erb_for_node->statements); index++) {
+          herb_visit_node(array_get(erb_for_node->statements, index), visitor, data);
+        }
+      }
+
+      if (erb_for_node->end_node != NULL) {
+        herb_visit_node((AST_NODE_T *) erb_for_node->end_node, visitor, data);
+      }
+
+    } break;
+
+    case AST_ERB_RESCUE_NODE: {
+      const AST_ERB_RESCUE_NODE_T* erb_rescue_node = ((const AST_ERB_RESCUE_NODE_T *) node);
+
+      if (erb_rescue_node->statements != NULL) {
+        for (size_t index = 0; index < array_size(erb_rescue_node->statements); index++) {
+          herb_visit_node(array_get(erb_rescue_node->statements, index), visitor, data);
+        }
+      }
+
+      if (erb_rescue_node->subsequent != NULL) {
+        herb_visit_node((AST_NODE_T *) erb_rescue_node->subsequent, visitor, data);
+      }
+
+    } break;
+
+    case AST_ERB_ENSURE_NODE: {
+      const AST_ERB_ENSURE_NODE_T* erb_ensure_node = ((const AST_ERB_ENSURE_NODE_T *) node);
+
+      if (erb_ensure_node->statements != NULL) {
+        for (size_t index = 0; index < array_size(erb_ensure_node->statements); index++) {
+          herb_visit_node(array_get(erb_ensure_node->statements, index), visitor, data);
+        }
+      }
+
+    } break;
+
+    case AST_ERB_BEGIN_NODE: {
+      const AST_ERB_BEGIN_NODE_T* erb_begin_node = ((const AST_ERB_BEGIN_NODE_T *) node);
+
+      if (erb_begin_node->statements != NULL) {
+        for (size_t index = 0; index < array_size(erb_begin_node->statements); index++) {
+          herb_visit_node(array_get(erb_begin_node->statements, index), visitor, data);
+        }
+      }
+
+      if (erb_begin_node->rescue_clause != NULL) {
+        herb_visit_node((AST_NODE_T *) erb_begin_node->rescue_clause, visitor, data);
+      }
+
+      if (erb_begin_node->else_clause != NULL) {
+        herb_visit_node((AST_NODE_T *) erb_begin_node->else_clause, visitor, data);
+      }
+
+      if (erb_begin_node->ensure_clause != NULL) {
+        herb_visit_node((AST_NODE_T *) erb_begin_node->ensure_clause, visitor, data);
+      }
+
+      if (erb_begin_node->end_node != NULL) {
+        herb_visit_node((AST_NODE_T *) erb_begin_node->end_node, visitor, data);
+      }
+
+    } break;
+
+    case AST_ERB_UNLESS_NODE: {
+      const AST_ERB_UNLESS_NODE_T* erb_unless_node = ((const AST_ERB_UNLESS_NODE_T *) node);
+
+      if (erb_unless_node->statements != NULL) {
+        for (size_t index = 0; index < array_size(erb_unless_node->statements); index++) {
+          herb_visit_node(array_get(erb_unless_node->statements, index), visitor, data);
+        }
+      }
+
+      if (erb_unless_node->else_clause != NULL) {
+        herb_visit_node((AST_NODE_T *) erb_unless_node->else_clause, visitor, data);
+      }
+
+      if (erb_unless_node->end_node != NULL) {
+        herb_visit_node((AST_NODE_T *) erb_unless_node->end_node, visitor, data);
+      }
+
+    } break;
+
+    default: break;
+  }
+}