@athrio/loom 0.0.12 → 0.0.13

package/dist/tree-sitter-loom/src/scanner.c

@@ -1,293 +0,0 @@
-#include "tree_sitter/alloc.h"
-#include "tree_sitter/parser.h"
-
-#include <stdbool.h>
-#include <stdint.h>
-#include <string.h>
-
-enum TokenType {
-  FENCE_LINE,
-  FIELD_LINE,
-  HEADING_LINE,
-  ARROW_LINE,
-  TILDE_LINE,
-  PROSE_LINE,
-  CODE_LINE,
-  TOC_LINE,
-  VERBATIM_LINE,
-  NOTE_LINE,
-  NOTE_BODY_LINE,
-  NEWLINE,
-  ERROR_SENTINEL,
-};
-
-enum Mode { PREAMBLE, CODE, PROSE };
-
-typedef struct {
-  bool at_line_start;
-  bool started;
-  bool seen_heading;
-  bool in_frontmatter;
-  bool in_toc;
-  bool in_fence;
-  bool in_note;
-  bool in_explicit;
-  uint8_t mode;
-} Scanner;
-
-#define HEAD_SIZE 48
-
-typedef struct {
-  char head[HEAD_SIZE];
-  uint32_t head_length;
-  uint32_t length;
-  int32_t last_mark;
-  bool toc;
-} Line;
-
-static bool is_space(int32_t c) {
-  return c == ' ' || c == '\t' || c == '\v' || c == '\f' || c == '\r';
-}
-
-static char lower(int32_t c) {
-  if (c >= 'A' && c <= 'Z') return (char)(c - 'A' + 'a');
-  return c < 128 ? (char)c : '\x01';
-}
-
-static void peek_line(TSLexer *lexer, Line *line) {
-  char window[5] = {0, 0, 0, 0, 0};
-  memset(line, 0, sizeof(Line));
-  line->last_mark = -1;
-  while (!lexer->eof(lexer) && lexer->lookahead != '\n' &&
-         lexer->lookahead != '\r') {
-    int32_t c = lexer->lookahead;
-    if (line->head_length < HEAD_SIZE)
-      line->head[line->head_length++] = c < 128 ? (char)c : '\x01';
-    if (!is_space(c)) line->last_mark = (int32_t)line->length;
-    memmove(window, window + 1, 4);
-    window[4] = lower(c);
-    if (memcmp(window, "{toc}", 5) == 0) line->toc = true;
-    line->length++;
-    lexer->advance(lexer, false);
-  }
-}
-
-static bool head_has(const Line *line, uint32_t at, const char *text) {
-  uint32_t n = (uint32_t)strlen(text);
-  return at + n <= line->head_length && memcmp(line->head + at, text, n) == 0;
-}
-
-static uint32_t indent_of(const Line *line) {
-  uint32_t i = 0;
-  while (i < line->head_length && is_space(line->head[i])) i++;
-  return i;
-}
-
-static uint32_t hashes_of(const Line *line) {
-  uint32_t i = 0;
-  while (i < line->head_length && line->head[i] == '#') i++;
-  return i;
-}
-
-static bool is_heading(const Line *line) {
-  uint32_t hashes = hashes_of(line);
-  return hashes >= 1 && hashes <= 6 && head_has(line, hashes, " ");
-}
-
-static bool is_frontmatter_fence(const Line *line) {
-  return head_has(line, 0, "---") && line->last_mark == 2;
-}
-
-static bool is_arrow(const Line *line) {
-  uint32_t at = indent_of(line);
-  return head_has(line, at, "=>") || head_has(line, at, "~>");
-}
-
-static bool is_explicit_arrow(const Line *line) {
-  return head_has(line, indent_of(line), "~>");
-}
-
-static bool is_tilde(const Line *line) {
-  return head_has(line, 0, "~") &&
-         (line->length == 1 || is_space(line->head[1]));
-}
-
-static bool is_code_fence(const Line *line) {
-  return head_has(line, indent_of(line), "```");
-}
-
-static bool is_note_open(const Line *line) {
-  return head_has(line, indent_of(line), ":::" "[Note]");
-}
-
-static bool is_note_close(const Line *line) {
-  uint32_t at = indent_of(line);
-  return head_has(line, at, ":::") && line->last_mark == (int32_t)at + 2;
-}
-
-static enum TokenType prose_kind(Scanner *s, const Line *line,
-                                 enum TokenType kind, enum Mode mode) {
-  s->mode = mode;
-  s->in_fence = is_code_fence(line);
-  s->in_note = !s->in_fence && is_note_open(line);
-  if (s->in_fence) return VERBATIM_LINE;
-  if (s->in_note) return NOTE_LINE;
-  return kind;
-}
-
-static enum TokenType classify_line(Scanner *s, const Line *line) {
-  bool first = !s->started;
-  s->started = true;
-
-  if (first && is_frontmatter_fence(line)) {
-    s->in_frontmatter = true;
-    s->mode = PREAMBLE;
-    return FENCE_LINE;
-  }
-
-  if (s->in_frontmatter) {
-    s->mode = PREAMBLE;
-    if (is_frontmatter_fence(line)) {
-      s->in_frontmatter = false;
-      return FENCE_LINE;
-    }
-    return FIELD_LINE;
-  }
-
-  if (s->in_fence) {
-    s->in_fence = !is_code_fence(line);
-    s->mode = s->seen_heading ? PROSE : PREAMBLE;
-    return VERBATIM_LINE;
-  }
-
-  if (s->in_note) {
-    s->in_note = !is_note_close(line);
-    s->mode = s->seen_heading ? PROSE : PREAMBLE;
-    return NOTE_BODY_LINE;
-  }
-
-  if (s->in_explicit) {
-    if (is_tilde(line)) {
-      s->in_explicit = false;
-      return prose_kind(s, line, TILDE_LINE, PROSE);
-    }
-    s->mode = CODE;
-    return CODE_LINE;
-  }
-
-  if (is_heading(line)) {
-    s->mode = PREAMBLE;
-    if (s->in_toc && hashes_of(line) > 1) return TOC_LINE;
-    s->seen_heading = true;
-    s->in_toc = line->toc;
-    return HEADING_LINE;
-  }
-
-  if (s->in_toc) {
-    s->mode = PREAMBLE;
-    return TOC_LINE;
-  }
-
-  if (!s->seen_heading) return prose_kind(s, line, PROSE_LINE, PREAMBLE);
-
-  switch (s->mode) {
-    case PREAMBLE:
-      if (is_arrow(line)) {
-        s->in_explicit = is_explicit_arrow(line);
-        s->mode = CODE;
-        return ARROW_LINE;
-      }
-      if (is_tilde(line)) return prose_kind(s, line, TILDE_LINE, PROSE);
-      return prose_kind(s, line, PROSE_LINE, PREAMBLE);
-    case CODE:
-      if (is_tilde(line)) return prose_kind(s, line, TILDE_LINE, PROSE);
-      return CODE_LINE;
-    default:
-      if (is_arrow(line)) {
-        s->in_explicit = is_explicit_arrow(line);
-        s->mode = CODE;
-        return ARROW_LINE;
-      }
-      return prose_kind(s, line, PROSE_LINE, PROSE);
-  }
-}
-
-static bool scan_newline(Scanner *s, TSLexer *lexer) {
-  if (lexer->lookahead == '\r') lexer->advance(lexer, false);
-  if (lexer->lookahead == '\n') lexer->advance(lexer, false);
-  lexer->mark_end(lexer);
-  s->at_line_start = true;
-  lexer->result_symbol = NEWLINE;
-  return true;
-}
-
-static bool scan(Scanner *s, TSLexer *lexer, const bool *valid) {
-  bool recovering = valid[ERROR_SENTINEL];
-
-  if (!s->at_line_start) {
-    if (!valid[NEWLINE] && !recovering) return false;
-    if (lexer->eof(lexer) || lexer->lookahead == '\n' ||
-        lexer->lookahead == '\r')
-      return scan_newline(s, lexer);
-    return false;
-  }
-
-  if (lexer->eof(lexer)) return false;
-
-  lexer->mark_end(lexer);
-  Line line;
-  peek_line(lexer, &line);
-  enum TokenType kind = classify_line(s, &line);
-  if (!valid[kind] && !recovering) return false;
-  s->at_line_start = false;
-  lexer->result_symbol = kind;
-  return true;
-}
-
-void *tree_sitter_loom_external_scanner_create(void) {
-  Scanner *s = ts_calloc(1, sizeof(Scanner));
-  s->at_line_start = true;
-  return s;
-}
-
-void tree_sitter_loom_external_scanner_destroy(void *payload) {
-  ts_free(payload);
-}
-
-unsigned tree_sitter_loom_external_scanner_serialize(void *payload,
-                                                     char *buffer) {
-  Scanner *s = payload;
-  buffer[0] = (char)s->at_line_start;
-  buffer[1] = (char)s->started;
-  buffer[2] = (char)s->seen_heading;
-  buffer[3] = (char)s->in_frontmatter;
-  buffer[4] = (char)s->in_toc;
-  buffer[5] = (char)s->in_fence;
-  buffer[6] = (char)s->in_note;
-  buffer[7] = (char)s->in_explicit;
-  buffer[8] = (char)s->mode;
-  return 9;
-}
-
-void tree_sitter_loom_external_scanner_deserialize(void *payload,
-                                                   const char *buffer,
-                                                   unsigned length) {
-  Scanner *s = payload;
-  memset(s, 0, sizeof(Scanner));
-  s->at_line_start = true;
-  if (length < 9) return;
-  s->at_line_start = buffer[0];
-  s->started = buffer[1];
-  s->seen_heading = buffer[2];
-  s->in_frontmatter = buffer[3];
-  s->in_toc = buffer[4];
-  s->in_fence = buffer[5];
-  s->in_note = buffer[6];
-  s->in_explicit = buffer[7];
-  s->mode = (uint8_t)buffer[8];
-}
-
-bool tree_sitter_loom_external_scanner_scan(void *payload, TSLexer *lexer,
-                                            const bool *valid_symbols) {
-  return scan(payload, lexer, valid_symbols);
-}

package/dist/tree-sitter-loom/src/tree_sitter/alloc.h

@@ -1,54 +0,0 @@
-#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_

package/dist/tree-sitter-loom/src/tree_sitter/array.h

@@ -1,330 +0,0 @@
-#ifndef TREE_SITTER_ARRAY_H_
-#define TREE_SITTER_ARRAY_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "./alloc.h"
-
-#include <assert.h>
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdlib.h>
-#include <string.h>
-
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4101)
-#elif defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wunused-variable"
-#endif
-
-#define Array(T)       \
-  struct {             \
-    T *contents;       \
-    uint32_t size;     \
-    uint32_t capacity; \
-  }
-
-/// Initialize an array.
-#define array_init(self) \
-  ((self)->size = 0, (self)->capacity = 0, (self)->contents = NULL)
-
-/// Create an empty array.
-#define array_new() \
-  { NULL, 0, 0 }
-
-/// Get a pointer to the element at a given `index` in the array.
-#define array_get(self, _index) \
-  (assert((uint32_t)(_index) < (self)->size), &(self)->contents[_index])
-
-/// Get a pointer to the first element in the array.
-#define array_front(self) array_get(self, 0)
-
-/// Get a pointer to the last element in the array.
-#define array_back(self) array_get(self, (self)->size - 1)
-
-/// Clear the array, setting its size to zero. Note that this does not free any
-/// memory allocated for the array's contents.
-#define array_clear(self) ((self)->size = 0)
-
-/// Reserve `new_capacity` elements of space in the array. If `new_capacity` is
-/// less than the array's current capacity, this function has no effect.
-#define array_reserve(self, new_capacity)        \
-  ((self)->contents = _array__reserve(           \
-    (void *)(self)->contents, &(self)->capacity, \
-    array_elem_size(self), new_capacity)         \
-  )
-
-/// Free any memory allocated for this array. Note that this does not free any
-/// memory allocated for the array's contents.
-#define array_delete(self)                           \
-  do {                                               \
-    if ((self)->contents) ts_free((self)->contents); \
-    (self)->contents = NULL;                         \
-    (self)->size = 0;                                \
-    (self)->capacity = 0;                            \
-  } while (0)
-
-/// Push a new `element` onto the end of the array.
-#define array_push(self, element)                                 \
-  do {                                                            \
-    (self)->contents = _array__grow(                              \
-      (void *)(self)->contents, (self)->size, &(self)->capacity,  \
-      1, array_elem_size(self)                                    \
-    );                                                            \
-   (self)->contents[(self)->size++] = (element);                  \
-  } while(0)
-
-/// Increase the array's size by `count` elements.
-/// New elements are zero-initialized.
-#define array_grow_by(self, count)                                               \
-  do {                                                                           \
-    if ((count) == 0) break;                                                     \
-    (self)->contents = _array__grow(                                             \
-      (self)->contents, (self)->size, &(self)->capacity,                         \
-      count, array_elem_size(self)                                               \
-    );                                                                           \
-    memset((self)->contents + (self)->size, 0, (count) * array_elem_size(self)); \
-    (self)->size += (count);                                                     \
-  } while (0)
-
-/// Append all elements from one array to the end of another.
-#define array_push_all(self, other) \
-  array_extend((self), (other)->size, (other)->contents)
-
-/// Append `count` elements to the end of the array, reading their values from the
-/// `contents` pointer.
-#define array_extend(self, count, other_contents)                 \
-  (self)->contents = _array__splice(                              \
-    (void*)(self)->contents, &(self)->size, &(self)->capacity,    \
-    array_elem_size(self), (self)->size, 0, count, other_contents \
-  )
-
-/// Remove `old_count` elements from the array starting at the given `index`. At
-/// the same index, insert `new_count` new elements, reading their values from the
-/// `new_contents` pointer.
-#define array_splice(self, _index, old_count, new_count, new_contents) \
-  (self)->contents = _array__splice(                                   \
-    (void *)(self)->contents, &(self)->size, &(self)->capacity,        \
-    array_elem_size(self), _index, old_count, new_count, new_contents  \
-  )
-
-/// Insert one `element` into the array at the given `index`.
-#define array_insert(self, _index, element)                     \
-  (self)->contents = _array__splice(                            \
-    (void *)(self)->contents, &(self)->size, &(self)->capacity, \
-    array_elem_size(self), _index, 0, 1, &(element)             \
-  )
-
-/// Remove one element from the array at the given `index`.
-#define array_erase(self, _index) \
-  _array__erase((void *)(self)->contents, &(self)->size, array_elem_size(self), _index)
-
-/// Pop the last element off the array, returning the element by value.
-#define array_pop(self) ((self)->contents[--(self)->size])
-
-/// Assign the contents of one array to another, reallocating if necessary.
-#define array_assign(self, other)                                   \
-  (self)->contents = _array__assign(                                \
-    (void *)(self)->contents, &(self)->size, &(self)->capacity,     \
-    (const void *)(other)->contents, (other)->size, array_elem_size(self) \
-  )
-
-/// Swap one array with another
-#define array_swap(self, other)                                     \
-  do {                                                              \
-    void *_array_swap_tmp = (void *)(self)->contents;               \
-    (self)->contents = (other)->contents;                           \
-    (other)->contents = _array_swap_tmp;                            \
-    _array__swap(&(self)->size, &(self)->capacity,                  \
-                 &(other)->size, &(other)->capacity);               \
-  } while (0)
-
-/// Get the size of the array contents
-#define array_elem_size(self) (sizeof *(self)->contents)
-
-/// Search a sorted array for a given `needle` value, using the given `compare`
-/// callback to determine the order.
-///
-/// If an existing element is found to be equal to `needle`, then the `index`
-/// out-parameter is set to the existing value's index, and the `exists`
-/// out-parameter is set to true. Otherwise, `index` is set to an index where
-/// `needle` should be inserted in order to preserve the sorting, and `exists`
-/// is set to false.
-#define array_search_sorted_with(self, compare, needle, _index, _exists) \
-  _array__search_sorted(self, 0, compare, , needle, _index, _exists)
-
-/// Search a sorted array for a given `needle` value, using integer comparisons
-/// of a given struct field (specified with a leading dot) to determine the order.
-///
-/// See also `array_search_sorted_with`.
-#define array_search_sorted_by(self, field, needle, _index, _exists) \
-  _array__search_sorted(self, 0, _compare_int, field, needle, _index, _exists)
-
-/// Insert a given `value` into a sorted array, using the given `compare`
-/// callback to determine the order.
-#define array_insert_sorted_with(self, compare, value) \
-  do { \
-    unsigned _index, _exists; \
-    array_search_sorted_with(self, compare, &(value), &_index, &_exists); \
-    if (!_exists) array_insert(self, _index, value); \
-  } while (0)
-
-/// Insert a given `value` into a sorted array, using integer comparisons of
-/// a given struct field (specified with a leading dot) to determine the order.
-///
-/// See also `array_search_sorted_by`.
-#define array_insert_sorted_by(self, field, value) \
-  do { \
-    unsigned _index, _exists; \
-    array_search_sorted_by(self, field, (value) field, &_index, &_exists); \
-    if (!_exists) array_insert(self, _index, value); \
-  } while (0)
-
-// Private
-
-// Pointers to individual `Array` fields (rather than the entire `Array` itself)
-// are passed to the various `_array__*` functions below to address strict aliasing
-// violations that arises when the _entire_ `Array` struct is passed as `Array(void)*`.
-//
-// The `Array` type itself was not altered as a solution in order to avoid breakage
-// with existing consumers (in particular, parsers with external scanners).
-
-/// This is not what you're looking for, see `array_erase`.
-static inline void _array__erase(void* self_contents, uint32_t *size,
-                                size_t element_size, uint32_t index) {
-  assert(index < *size);
-  char *contents = (char *)self_contents;
-  memmove(contents + index * element_size, contents + (index + 1) * element_size,
-          (*size - index - 1) * element_size);
-  (*size)--;
-}
-
-/// This is not what you're looking for, see `array_reserve`.
-static inline void *_array__reserve(void *contents, uint32_t *capacity,
-                                  size_t element_size, uint32_t new_capacity) {
-  void *new_contents = contents;
-  if (new_capacity > *capacity) {
-    if (contents) {
-      new_contents = ts_realloc(contents, new_capacity * element_size);
-    } else {
-      new_contents = ts_malloc(new_capacity * element_size);
-    }
-    *capacity = new_capacity;
-  }
-  return new_contents;
-}
-
-/// This is not what you're looking for, see `array_assign`.
-static inline void *_array__assign(void* self_contents, uint32_t *self_size, uint32_t *self_capacity,
-                                 const void *other_contents, uint32_t other_size, size_t element_size) {
-  void *new_contents = _array__reserve(self_contents, self_capacity, element_size, other_size);
-  *self_size = other_size;
-  memcpy(new_contents, other_contents, *self_size * element_size);
-  return new_contents;
-}
-
-/// This is not what you're looking for, see `array_swap`.
-static inline void _array__swap(uint32_t *self_size, uint32_t *self_capacity,
-                               uint32_t *other_size, uint32_t *other_capacity) {
-  uint32_t tmp_size = *self_size;
-  uint32_t tmp_capacity = *self_capacity;
-  *self_size = *other_size;
-  *self_capacity = *other_capacity;
-  *other_size = tmp_size;
-  *other_capacity = tmp_capacity;
-}
-
-/// This is not what you're looking for, see `array_push` or `array_grow_by`.
-static inline void *_array__grow(void *contents, uint32_t size, uint32_t *capacity,
-                               uint32_t count, size_t element_size) {
-  void *new_contents = contents;
-  uint32_t new_size = size + count;
-  if (new_size > *capacity) {
-    uint32_t new_capacity = *capacity * 2;
-    if (new_capacity < 8) new_capacity = 8;
-    if (new_capacity < new_size) new_capacity = new_size;
-    new_contents = _array__reserve(contents, capacity, element_size, new_capacity);
-  }
-  return new_contents;
-}
-
-/// This is not what you're looking for, see `array_splice`.
-static inline void *_array__splice(void *self_contents, uint32_t *size, uint32_t *capacity,
-                                 size_t element_size,
-                                 uint32_t index, uint32_t old_count,
-                                 uint32_t new_count, const void *elements) {
-  uint32_t new_size = *size + new_count - old_count;
-  uint32_t old_end = index + old_count;
-  uint32_t new_end = index + new_count;
-  assert(old_end <= *size);
-
-  void *new_contents = _array__reserve(self_contents, capacity, element_size, new_size);
-
-  char *contents = (char *)new_contents;
-  if (*size > old_end) {
-    memmove(
-      contents + new_end * element_size,
-      contents + old_end * element_size,
-      (*size - old_end) * element_size
-    );
-  }
-  if (new_count > 0) {
-    if (elements) {
-      memcpy(
-        (contents + index * element_size),
-        elements,
-        new_count * element_size
-      );
-    } else {
-      memset(
-        (contents + index * element_size),
-        0,
-        new_count * element_size
-      );
-    }
-  }
-  *size += new_count - old_count;
-
-  return new_contents;
-}
-
-/// A binary search routine, based on Rust's `std::slice::binary_search_by`.
-/// This is not what you're looking for, see `array_search_sorted_with` or `array_search_sorted_by`.
-#define _array__search_sorted(self, start, compare, suffix, needle, _index, _exists) \
-  do { \
-    *(_index) = start; \
-    *(_exists) = false; \
-    uint32_t size = (self)->size - *(_index); \
-    if (size == 0) break; \
-    int comparison; \
-    while (size > 1) { \
-      uint32_t half_size = size / 2; \
-      uint32_t mid_index = *(_index) + half_size; \
-      comparison = compare(&((self)->contents[mid_index] suffix), (needle)); \
-      if (comparison <= 0) *(_index) = mid_index; \
-      size -= half_size; \
-    } \
-    comparison = compare(&((self)->contents[*(_index)] suffix), (needle)); \
-    if (comparison == 0) *(_exists) = true; \
-    else if (comparison < 0) *(_index) += 1; \
-  } while (0)
-
-/// Helper macro for the `_sorted_by` routines below. This takes the left (existing)
-/// parameter by reference in order to work with the generic sorting function above.
-#define _compare_int(a, b) ((int)*(a) - (int)(b))
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#elif defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic pop
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // TREE_SITTER_ARRAY_H_