tree-sitter-topaz 0.1.0

package/src/scanner.c

@@ -0,0 +1,571 @@
+#include "tree_sitter/parser.h"
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <string.h>
+
+enum TokenType {
+  NOMINAL_RECORD_CONSTRUCTION,
+  RECORD_LBRACE,
+  CALL_TYPE_ARGUMENTS,
+  CASE_PATTERN,
+  STRING,
+  TAGGED_TEMPLATE,
+  COMPREHENSION_CLAUSES,
+  BINDING_CONDITION,
+};
+
+void *tree_sitter_topaz_external_scanner_create(void) { return NULL; }
+void tree_sitter_topaz_external_scanner_destroy(void *payload) {
+  (void)payload;
+}
+unsigned tree_sitter_topaz_external_scanner_serialize(void *payload,
+                                                      char *buffer) {
+  (void)payload;
+  (void)buffer;
+  return 0;
+}
+void tree_sitter_topaz_external_scanner_deserialize(void *payload,
+                                                    const char *buffer,
+                                                    unsigned length) {
+  (void)payload;
+  (void)buffer;
+  (void)length;
+}
+
+static bool is_space(int32_t character) {
+  return character == ' ' || character == '\t' || character == '\r' ||
+         character == '\n' || character == '\f';
+}
+
+static bool is_identifier_start(int32_t character) {
+  return character == '_' || character >= 0x80 ||
+         (character >= 'A' && character <= 'Z') ||
+         (character >= 'a' && character <= 'z');
+}
+
+static bool is_identifier_continue(int32_t character) {
+  return is_identifier_start(character) ||
+         (character >= '0' && character <= '9');
+}
+
+static void skip_space_and_comments(TSLexer *lexer) {
+  for (;;) {
+    while (is_space(lexer->lookahead)) {
+      lexer->advance(lexer, true);
+    }
+    if (lexer->lookahead != '/') {
+      return;
+    }
+    lexer->advance(lexer, true);
+    if (lexer->lookahead == '/') {
+      while (lexer->lookahead != 0 && lexer->lookahead != '\n' &&
+             lexer->lookahead != '\r') {
+        lexer->advance(lexer, true);
+      }
+      continue;
+    }
+    if (lexer->lookahead == '*') {
+      lexer->advance(lexer, true);
+      int32_t previous = 0;
+      while (lexer->lookahead != 0) {
+        int32_t current = lexer->lookahead;
+        lexer->advance(lexer, true);
+        if (previous == '*' && current == '/') {
+          break;
+        }
+        previous = current;
+      }
+      continue;
+    }
+    return;
+  }
+}
+
+static bool scan_nominal_record_construction(TSLexer *lexer) {
+  if (!is_identifier_start(lexer->lookahead)) {
+    return false;
+  }
+  char head[24] = {0};
+  unsigned head_length = 0;
+  do {
+    if (lexer->lookahead < 0x80 && head_length + 1 < sizeof(head)) {
+      head[head_length++] = (char)lexer->lookahead;
+    }
+    lexer->advance(lexer, false);
+  } while (is_identifier_continue(lexer->lookahead));
+  static const char *reserved[] = {
+      "break",    "case",     "concurrent", "const",    "continue",
+      "defer",    "else",     "enum",       "export",   "false",
+      "for",      "function", "if",         "impl",     "import",
+      "let",      "loop",     "map",        "match",    "mut",
+      "newtype",  "null",     "protocol",   "record",   "return",
+      "set",      "true",     "type",       "using",    "while",
+  };
+  for (unsigned i = 0; i < sizeof(reserved) / sizeof(reserved[0]); i++) {
+    if (strcmp(head, reserved[i]) == 0) {
+      return false;
+    }
+  }
+  while (is_space(lexer->lookahead)) {
+    lexer->advance(lexer, false);
+  }
+  if (lexer->lookahead != '{') {
+    return false;
+  }
+
+  lexer->advance(lexer, false);
+  while (is_space(lexer->lookahead)) {
+    lexer->advance(lexer, false);
+  }
+  bool valid_head = lexer->lookahead == '}' || lexer->lookahead == '.';
+  if (!valid_head && is_identifier_start(lexer->lookahead)) {
+    do {
+      lexer->advance(lexer, false);
+    } while (is_identifier_continue(lexer->lookahead));
+    while (is_space(lexer->lookahead)) {
+      lexer->advance(lexer, false);
+    }
+    valid_head = lexer->lookahead == ':';
+  }
+  if (!valid_head) {
+    return false;
+  }
+
+  unsigned depth = 1;
+  bool string = false;
+  bool escaped = false;
+  while (lexer->lookahead != 0) {
+    int32_t character = lexer->lookahead;
+    lexer->advance(lexer, false);
+    if (string) {
+      if (escaped) {
+        escaped = false;
+      } else if (character == '\\') {
+        escaped = true;
+      } else if (character == '"') {
+        string = false;
+      }
+      continue;
+    }
+    if (character == '"') {
+      string = true;
+    } else if (character == '{') {
+      depth += 1;
+    } else if (character == '}') {
+      depth -= 1;
+      if (depth == 0) {
+        lexer->mark_end(lexer);
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+static bool scan_string_body(TSLexer *lexer) {
+  if (lexer->lookahead != '"') {
+    return false;
+  }
+
+  lexer->advance(lexer, false);
+  bool triple = false;
+  if (lexer->lookahead == '"') {
+    lexer->advance(lexer, false);
+    if (lexer->lookahead == '"') {
+      lexer->advance(lexer, false);
+      triple = true;
+    } else {
+      return true;
+    }
+  }
+
+  unsigned interpolation_depth = 0;
+  bool escaped = false;
+  bool nested_string = false;
+  while (lexer->lookahead != 0) {
+    int32_t character = lexer->lookahead;
+    if (escaped) {
+      lexer->advance(lexer, false);
+      escaped = false;
+      continue;
+    }
+    if (character == '\\') {
+      lexer->advance(lexer, false);
+      escaped = true;
+      continue;
+    }
+
+    if (interpolation_depth > 0) {
+      if (nested_string) {
+        lexer->advance(lexer, false);
+        if (character == '"') {
+          nested_string = false;
+        }
+        continue;
+      }
+      if (character == '"') {
+        nested_string = true;
+      } else if (character == '{') {
+        interpolation_depth += 1;
+      } else if (character == '}') {
+        interpolation_depth -= 1;
+      }
+      lexer->advance(lexer, false);
+      continue;
+    }
+
+    if (character == '{') {
+      interpolation_depth = 1;
+      lexer->advance(lexer, false);
+      continue;
+    }
+    if (character == '\n' || character == '\r') {
+      if (!triple) {
+        lexer->mark_end(lexer);
+        return true;
+      }
+      lexer->advance(lexer, false);
+      continue;
+    }
+    if (character != '"') {
+      lexer->advance(lexer, false);
+      continue;
+    }
+
+    lexer->advance(lexer, false);
+    if (!triple) {
+      lexer->mark_end(lexer);
+      return true;
+    }
+    if (lexer->lookahead != '"') {
+      continue;
+    }
+    lexer->advance(lexer, false);
+    if (lexer->lookahead != '"') {
+      continue;
+    }
+    lexer->advance(lexer, false);
+    lexer->mark_end(lexer);
+    return true;
+  }
+  lexer->mark_end(lexer);
+  return true;
+}
+
+static bool scan_tagged_template(TSLexer *lexer) {
+  if (lexer->lookahead == 'p' || lexer->lookahead == 'r') {
+    lexer->advance(lexer, false);
+  } else if (lexer->lookahead == 's') {
+    lexer->advance(lexer, false);
+    if (lexer->lookahead == 'h') {
+      lexer->advance(lexer, false);
+    } else if (lexer->lookahead == 'q') {
+      lexer->advance(lexer, false);
+      if (lexer->lookahead != 'l') {
+        return false;
+      }
+      lexer->advance(lexer, false);
+    } else {
+      return false;
+    }
+  } else {
+    return false;
+  }
+  return scan_string_body(lexer);
+}
+
+static bool scan_until_arrow(TSLexer *lexer, enum TokenType symbol) {
+  unsigned parentheses = 0;
+  unsigned brackets = 0;
+  unsigned braces = 0;
+  bool consumed = false;
+  bool string = false;
+  bool escaped = false;
+  while (lexer->lookahead != 0) {
+    int32_t character = lexer->lookahead;
+    if (string) {
+      lexer->advance(lexer, false);
+      consumed = true;
+      if (escaped) {
+        escaped = false;
+      } else if (character == '\\') {
+        escaped = true;
+      } else if (character == '"') {
+        string = false;
+      }
+      continue;
+    }
+    if (character == '"') {
+      string = true;
+      lexer->advance(lexer, false);
+      consumed = true;
+      continue;
+    }
+    if (character == '(') {
+      parentheses += 1;
+    } else if (character == ')' && parentheses > 0) {
+      parentheses -= 1;
+    } else if (character == '[') {
+      brackets += 1;
+    } else if (character == ']' && brackets > 0) {
+      brackets -= 1;
+    } else if (character == '{') {
+      braces += 1;
+    } else if (character == '}' && braces > 0) {
+      braces -= 1;
+    } else if (character == '=' && parentheses == 0 && brackets == 0 &&
+               braces == 0) {
+      lexer->mark_end(lexer);
+      lexer->advance(lexer, false);
+      if (lexer->lookahead == '>' && consumed) {
+        lexer->result_symbol = symbol;
+        return true;
+      }
+      consumed = true;
+      continue;
+    }
+    lexer->advance(lexer, false);
+    consumed = true;
+  }
+  return false;
+}
+
+static bool scan_comprehension_clauses(TSLexer *lexer) {
+  if (lexer->lookahead != 'f') {
+    return false;
+  }
+  lexer->advance(lexer, false);
+  if (lexer->lookahead != 'o') {
+    return false;
+  }
+  lexer->advance(lexer, false);
+  if (lexer->lookahead != 'r') {
+    return false;
+  }
+  lexer->advance(lexer, false);
+  if (!is_space(lexer->lookahead)) {
+    return false;
+  }
+  return scan_until_arrow(lexer, COMPREHENSION_CLAUSES);
+}
+
+static bool scan_binding_condition(TSLexer *lexer) {
+  const char *head = "let";
+  for (unsigned i = 0; head[i] != 0; i++) {
+    if (lexer->lookahead != head[i]) {
+      return false;
+    }
+    lexer->advance(lexer, false);
+  }
+  if (!is_space(lexer->lookahead)) {
+    return false;
+  }
+
+  unsigned parentheses = 0;
+  unsigned brackets = 0;
+  unsigned braces = 0;
+  bool seen_equals = false;
+  bool string = false;
+  bool escaped = false;
+  while (lexer->lookahead != 0) {
+    int32_t character = lexer->lookahead;
+    if (string) {
+      lexer->advance(lexer, false);
+      if (escaped) {
+        escaped = false;
+      } else if (character == '\\') {
+        escaped = true;
+      } else if (character == '"') {
+        string = false;
+      }
+      continue;
+    }
+    if (character == '"') {
+      string = true;
+      lexer->advance(lexer, false);
+      continue;
+    }
+    if (character == '(') {
+      parentheses += 1;
+    } else if (character == ')' && parentheses > 0) {
+      parentheses -= 1;
+    } else if (character == '[') {
+      brackets += 1;
+    } else if (character == ']' && brackets > 0) {
+      brackets -= 1;
+    } else if (character == '{') {
+      if (seen_equals && parentheses == 0 && brackets == 0 && braces == 0) {
+        lexer->mark_end(lexer);
+        lexer->result_symbol = BINDING_CONDITION;
+        return true;
+      }
+      braces += 1;
+    } else if (character == '}' && braces > 0) {
+      braces -= 1;
+    } else if (character == '=' && parentheses == 0 && brackets == 0 &&
+               braces == 0) {
+      seen_equals = true;
+    }
+    lexer->advance(lexer, false);
+  }
+  return false;
+}
+
+bool tree_sitter_topaz_external_scanner_scan(void *payload, TSLexer *lexer,
+                                             const bool *valid_symbols) {
+  (void)payload;
+  while (is_space(lexer->lookahead)) {
+    lexer->advance(lexer, true);
+  }
+
+  if (valid_symbols[COMPREHENSION_CLAUSES] && lexer->lookahead == 'f') {
+    return scan_comprehension_clauses(lexer);
+  }
+
+  if (valid_symbols[BINDING_CONDITION] && lexer->lookahead == 'l') {
+    return scan_binding_condition(lexer);
+  }
+
+  if (valid_symbols[CASE_PATTERN]) {
+    unsigned parentheses = 0;
+    unsigned brackets = 0;
+    unsigned braces = 0;
+    bool consumed = false;
+    bool string = false;
+    bool escaped = false;
+    while (lexer->lookahead != 0) {
+      int32_t character = lexer->lookahead;
+      if (string) {
+        lexer->advance(lexer, false);
+        consumed = true;
+        if (escaped) {
+          escaped = false;
+        } else if (character == '\\') {
+          escaped = true;
+        } else if (character == '"') {
+          string = false;
+        }
+        continue;
+      }
+      if (character == '"') {
+        string = true;
+        lexer->advance(lexer, false);
+        consumed = true;
+        continue;
+      }
+      if (character == '(') {
+        parentheses += 1;
+      } else if (character == ')' && parentheses > 0) {
+        parentheses -= 1;
+      } else if (character == '[') {
+        brackets += 1;
+      } else if (character == ']' && brackets > 0) {
+        brackets -= 1;
+      } else if (character == '{') {
+        braces += 1;
+      } else if (character == '}' && braces > 0) {
+        braces -= 1;
+      } else if (character == '=' && parentheses == 0 && brackets == 0 &&
+                 braces == 0) {
+        lexer->mark_end(lexer);
+        lexer->advance(lexer, false);
+        if (lexer->lookahead == '>' && consumed) {
+          lexer->result_symbol = CASE_PATTERN;
+          return true;
+        }
+        consumed = true;
+        continue;
+      }
+      lexer->advance(lexer, false);
+      consumed = true;
+    }
+    return false;
+  }
+
+  if (valid_symbols[STRING] && lexer->lookahead == '"') {
+    if (scan_string_body(lexer)) {
+      lexer->result_symbol = STRING;
+      return true;
+    }
+    return false;
+  }
+
+  if (valid_symbols[TAGGED_TEMPLATE] &&
+      (lexer->lookahead == 'p' || lexer->lookahead == 'r' ||
+       lexer->lookahead == 's')) {
+    if (scan_tagged_template(lexer)) {
+      lexer->result_symbol = TAGGED_TEMPLATE;
+      return true;
+    }
+    return false;
+  }
+
+  if (valid_symbols[CALL_TYPE_ARGUMENTS] && lexer->lookahead == '<') {
+    unsigned depth = 0;
+    do {
+      if (lexer->lookahead == '<') {
+        depth += 1;
+      } else if (lexer->lookahead == '>') {
+        depth -= 1;
+      }
+      lexer->advance(lexer, false);
+      if (depth == 0) {
+        lexer->mark_end(lexer);
+        if (lexer->lookahead == '(') {
+          lexer->result_symbol = CALL_TYPE_ARGUMENTS;
+          return true;
+        }
+        return false;
+      }
+    } while (lexer->lookahead != 0);
+    return false;
+  }
+
+  if (valid_symbols[RECORD_LBRACE] && lexer->lookahead == '{') {
+    lexer->advance(lexer, false);
+    lexer->mark_end(lexer);
+    skip_space_and_comments(lexer);
+
+    if (lexer->lookahead == '}') {
+      lexer->result_symbol = RECORD_LBRACE;
+      return true;
+    }
+    if (lexer->lookahead == '.') {
+      lexer->advance(lexer, true);
+      if (lexer->lookahead != '.') {
+        return false;
+      }
+      lexer->advance(lexer, true);
+      if (lexer->lookahead != '.') {
+        return false;
+      }
+      lexer->result_symbol = RECORD_LBRACE;
+      return true;
+    }
+    if (!is_identifier_start(lexer->lookahead)) {
+      return false;
+    }
+    do {
+      lexer->advance(lexer, true);
+    } while (is_identifier_continue(lexer->lookahead));
+    skip_space_and_comments(lexer);
+    if (lexer->lookahead != ':') {
+      return false;
+    }
+
+    lexer->result_symbol = RECORD_LBRACE;
+    return true;
+  }
+
+  if (valid_symbols[NOMINAL_RECORD_CONSTRUCTION] &&
+      is_identifier_start(lexer->lookahead)) {
+    if (scan_nominal_record_construction(lexer)) {
+      lexer->result_symbol = NOMINAL_RECORD_CONSTRUCTION;
+      return true;
+    }
+    return false;
+  }
+
+  return false;
+}

package/src/tree_sitter/alloc.h

@@ -0,0 +1,54 @@
+#ifndef TREE_SITTER_ALLOC_H_
+#define TREE_SITTER_ALLOC_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+// Allow clients to override allocation functions
+#ifdef TREE_SITTER_REUSE_ALLOCATOR
+
+extern void *(*ts_current_malloc)(size_t size);
+extern void *(*ts_current_calloc)(size_t count, size_t size);
+extern void *(*ts_current_realloc)(void *ptr, size_t size);
+extern void (*ts_current_free)(void *ptr);
+
+#ifndef ts_malloc
+#define ts_malloc  ts_current_malloc
+#endif
+#ifndef ts_calloc
+#define ts_calloc  ts_current_calloc
+#endif
+#ifndef ts_realloc
+#define ts_realloc ts_current_realloc
+#endif
+#ifndef ts_free
+#define ts_free    ts_current_free
+#endif
+
+#else
+
+#ifndef ts_malloc
+#define ts_malloc  malloc
+#endif
+#ifndef ts_calloc
+#define ts_calloc  calloc
+#endif
+#ifndef ts_realloc
+#define ts_realloc realloc
+#endif
+#ifndef ts_free
+#define ts_free    free
+#endif
+
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // TREE_SITTER_ALLOC_H_