@yalehwang/archguard 0.1.23 → 0.1.32

package/node_modules/tree-sitter/vendor/tree-sitter/lib/src/language.c

@@ -1,293 +0,0 @@
-#include "./language.h"
-#include "./wasm_store.h"
-#include "tree_sitter/api.h"
-#include <string.h>
-
-const TSLanguage *ts_language_copy(const TSLanguage *self) {
-  if (self && ts_language_is_wasm(self)) {
-    ts_wasm_language_retain(self);
-  }
-  return self;
-}
-
-void ts_language_delete(const TSLanguage *self) {
-  if (self && ts_language_is_wasm(self)) {
-    ts_wasm_language_release(self);
-  }
-}
-
-uint32_t ts_language_symbol_count(const TSLanguage *self) {
-  return self->symbol_count + self->alias_count;
-}
-
-uint32_t ts_language_state_count(const TSLanguage *self) {
-  return self->state_count;
-}
-
-const TSSymbol *ts_language_supertypes(const TSLanguage *self, uint32_t *length) {
-  if (self->abi_version >= LANGUAGE_VERSION_WITH_RESERVED_WORDS) {
-    *length = self->supertype_count;
-    return self->supertype_symbols;
-  } else {
-    *length = 0;
-    return NULL;
-  }
-}
-
-const TSSymbol *ts_language_subtypes(
-  const TSLanguage *self,
-  TSSymbol supertype,
-  uint32_t *length
-) {
-  if (self->abi_version < LANGUAGE_VERSION_WITH_RESERVED_WORDS || !ts_language_symbol_metadata(self, supertype).supertype) {
-    *length = 0;
-    return NULL;
-  }
-
-  TSMapSlice slice = self->supertype_map_slices[supertype];
-  *length = slice.length;
-  return &self->supertype_map_entries[slice.index];
-}
-
-uint32_t ts_language_version(const TSLanguage *self) {
-  return self->abi_version;
-}
-
-uint32_t ts_language_abi_version(const TSLanguage *self) {
-  return self->abi_version;
-}
-
-const TSLanguageMetadata *ts_language_metadata(const TSLanguage *self) {
-    return self->abi_version >= LANGUAGE_VERSION_WITH_RESERVED_WORDS ? &self->metadata : NULL;
-}
-
-const char *ts_language_name(const TSLanguage *self) {
-  return self->abi_version >= LANGUAGE_VERSION_WITH_RESERVED_WORDS ? self->name : NULL;
-}
-
-uint32_t ts_language_field_count(const TSLanguage *self) {
-  return self->field_count;
-}
-
-void ts_language_table_entry(
-  const TSLanguage *self,
-  TSStateId state,
-  TSSymbol symbol,
-  TableEntry *result
-) {
-  if (symbol == ts_builtin_sym_error || symbol == ts_builtin_sym_error_repeat) {
-    result->action_count = 0;
-    result->is_reusable = false;
-    result->actions = NULL;
-  } else {
-    ts_assert(symbol < self->token_count);
-    uint32_t action_index = ts_language_lookup(self, state, symbol);
-    const TSParseActionEntry *entry = &self->parse_actions[action_index];
-    result->action_count = entry->entry.count;
-    result->is_reusable = entry->entry.reusable;
-    result->actions = (const TSParseAction *)(entry + 1);
-  }
-}
-
-TSLexerMode ts_language_lex_mode_for_state(
-   const TSLanguage *self,
-   TSStateId state
-) {
-  if (self->abi_version < 15) {
-    TSLexMode mode = ((const TSLexMode *)self->lex_modes)[state];
-    return (TSLexerMode) {
-      .lex_state = mode.lex_state,
-      .external_lex_state = mode.external_lex_state,
-      .reserved_word_set_id = 0,
-    };
-  } else {
-    return self->lex_modes[state];
-  }
-}
-
-bool ts_language_is_reserved_word(
-  const TSLanguage *self,
-  TSStateId state,
-  TSSymbol symbol
-) {
-  TSLexerMode lex_mode = ts_language_lex_mode_for_state(self, state);
-  if (lex_mode.reserved_word_set_id > 0) {
-    unsigned start = lex_mode.reserved_word_set_id * self->max_reserved_word_set_size;
-    unsigned end = start + self->max_reserved_word_set_size;
-    for (unsigned i = start; i < end; i++) {
-      if (self->reserved_words[i] == symbol) return true;
-      if (self->reserved_words[i] == 0) break;
-    }
-  }
-  return false;
-}
-
-TSSymbolMetadata ts_language_symbol_metadata(
-  const TSLanguage *self,
-  TSSymbol symbol
-) {
-  if (symbol == ts_builtin_sym_error)  {
-    return (TSSymbolMetadata) {.visible = true, .named = true};
-  } else if (symbol == ts_builtin_sym_error_repeat) {
-    return (TSSymbolMetadata) {.visible = false, .named = false};
-  } else {
-    return self->symbol_metadata[symbol];
-  }
-}
-
-TSSymbol ts_language_public_symbol(
-  const TSLanguage *self,
-  TSSymbol symbol
-) {
-  if (symbol == ts_builtin_sym_error) return symbol;
-  return self->public_symbol_map[symbol];
-}
-
-TSStateId ts_language_next_state(
-  const TSLanguage *self,
-  TSStateId state,
-  TSSymbol symbol
-) {
-  if (symbol == ts_builtin_sym_error || symbol == ts_builtin_sym_error_repeat) {
-    return 0;
-  } else if (symbol < self->token_count) {
-    uint32_t count;
-    const TSParseAction *actions = ts_language_actions(self, state, symbol, &count);
-    if (count > 0) {
-      TSParseAction action = actions[count - 1];
-      if (action.type == TSParseActionTypeShift) {
-        return action.shift.extra ? state : action.shift.state;
-      }
-    }
-    return 0;
-  } else {
-    return ts_language_lookup(self, state, symbol);
-  }
-}
-
-const char *ts_language_symbol_name(
-  const TSLanguage *self,
-  TSSymbol symbol
-) {
-  if (symbol == ts_builtin_sym_error) {
-    return "ERROR";
-  } else if (symbol == ts_builtin_sym_error_repeat) {
-    return "_ERROR";
-  } else if (symbol < ts_language_symbol_count(self)) {
-    return self->symbol_names[symbol];
-  } else {
-    return NULL;
-  }
-}
-
-TSSymbol ts_language_symbol_for_name(
-  const TSLanguage *self,
-  const char *string,
-  uint32_t length,
-  bool is_named
-) {
-  if (!strncmp(string, "ERROR", length)) return ts_builtin_sym_error;
-  uint16_t count = (uint16_t)ts_language_symbol_count(self);
-  for (TSSymbol i = 0; i < count; i++) {
-    TSSymbolMetadata metadata = ts_language_symbol_metadata(self, i);
-    if ((!metadata.visible && !metadata.supertype) || metadata.named != is_named) continue;
-    const char *symbol_name = self->symbol_names[i];
-    if (!strncmp(symbol_name, string, length) && !symbol_name[length]) {
-      return self->public_symbol_map[i];
-    }
-  }
-  return 0;
-}
-
-TSSymbolType ts_language_symbol_type(
-  const TSLanguage *self,
-  TSSymbol symbol
-) {
-  TSSymbolMetadata metadata = ts_language_symbol_metadata(self, symbol);
-  if (metadata.named && metadata.visible) {
-    return TSSymbolTypeRegular;
-  } else if (metadata.visible) {
-    return TSSymbolTypeAnonymous;
-  } else if (metadata.supertype) {
-    return TSSymbolTypeSupertype;
-  } else {
-    return TSSymbolTypeAuxiliary;
-  }
-}
-
-const char *ts_language_field_name_for_id(
-  const TSLanguage *self,
-  TSFieldId id
-) {
-  uint32_t count = ts_language_field_count(self);
-  if (count && id <= count) {
-    return self->field_names[id];
-  } else {
-    return NULL;
-  }
-}
-
-TSFieldId ts_language_field_id_for_name(
-  const TSLanguage *self,
-  const char *name,
-  uint32_t name_length
-) {
-  uint16_t count = (uint16_t)ts_language_field_count(self);
-  for (TSSymbol i = 1; i < count + 1; i++) {
-    switch (strncmp(name, self->field_names[i], name_length)) {
-      case 0:
-        if (self->field_names[i][name_length] == 0) return i;
-        break;
-      case -1:
-        return 0;
-      default:
-        break;
-    }
-  }
-  return 0;
-}
-
-TSLookaheadIterator *ts_lookahead_iterator_new(const TSLanguage *self, TSStateId state) {
-  if (state >= self->state_count) return NULL;
-  LookaheadIterator *iterator = ts_malloc(sizeof(LookaheadIterator));
-  *iterator = ts_language_lookaheads(self, state);
-  return (TSLookaheadIterator *)iterator;
-}
-
-void ts_lookahead_iterator_delete(TSLookaheadIterator *self) {
-  ts_free(self);
-}
-
-bool ts_lookahead_iterator_reset_state(TSLookaheadIterator * self, TSStateId state) {
-  LookaheadIterator *iterator = (LookaheadIterator *)self;
-  if (state >= iterator->language->state_count) return false;
-  *iterator = ts_language_lookaheads(iterator->language, state);
-  return true;
-}
-
-const TSLanguage *ts_lookahead_iterator_language(const TSLookaheadIterator *self) {
-  const LookaheadIterator *iterator = (const LookaheadIterator *)self;
-  return iterator->language;
-}
-
-bool ts_lookahead_iterator_reset(TSLookaheadIterator *self, const TSLanguage *language, TSStateId state) {
-  if (state >= language->state_count) return false;
-  LookaheadIterator *iterator = (LookaheadIterator *)self;
-  *iterator = ts_language_lookaheads(language, state);
-  return true;
-}
-
-bool ts_lookahead_iterator_next(TSLookaheadIterator *self) {
-  LookaheadIterator *iterator = (LookaheadIterator *)self;
-  return ts_lookahead_iterator__next(iterator);
-}
-
-TSSymbol ts_lookahead_iterator_current_symbol(const TSLookaheadIterator *self) {
-  const LookaheadIterator *iterator = (const LookaheadIterator *)self;
-  return iterator->symbol;
-}
-
-const char *ts_lookahead_iterator_current_symbol_name(const TSLookaheadIterator *self) {
-  const LookaheadIterator *iterator = (const LookaheadIterator *)self;
-  return ts_language_symbol_name(iterator->language, iterator->symbol);
-}

package/node_modules/tree-sitter/vendor/tree-sitter/lib/src/language.h

@@ -1,293 +0,0 @@
-#ifndef TREE_SITTER_LANGUAGE_H_
-#define TREE_SITTER_LANGUAGE_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "./subtree.h"
-#include "./parser.h"
-
-#define ts_builtin_sym_error_repeat (ts_builtin_sym_error - 1)
-
-#define LANGUAGE_VERSION_WITH_RESERVED_WORDS 15
-#define LANGUAGE_VERSION_WITH_PRIMARY_STATES 14
-
-typedef struct {
-  const TSParseAction *actions;
-  uint32_t action_count;
-  bool is_reusable;
-} TableEntry;
-
-typedef struct {
-  const TSLanguage *language;
-  const uint16_t *data;
-  const uint16_t *group_end;
-  TSStateId state;
-  uint16_t table_value;
-  uint16_t section_index;
-  uint16_t group_count;
-  bool is_small_state;
-
-  const TSParseAction *actions;
-  TSSymbol symbol;
-  TSStateId next_state;
-  uint16_t action_count;
-} LookaheadIterator;
-
-void ts_language_table_entry(const TSLanguage *self, TSStateId state, TSSymbol symbol, TableEntry *result);
-TSLexerMode ts_language_lex_mode_for_state(const TSLanguage *self, TSStateId state);
-bool ts_language_is_reserved_word(const TSLanguage *self, TSStateId state, TSSymbol symbol);
-TSSymbolMetadata ts_language_symbol_metadata(const TSLanguage *self, TSSymbol symbol);
-TSSymbol ts_language_public_symbol(const TSLanguage *self, TSSymbol symbol);
-
-static inline const TSParseAction *ts_language_actions(
-  const TSLanguage *self,
-  TSStateId state,
-  TSSymbol symbol,
-  uint32_t *count
-) {
-  TableEntry entry;
-  ts_language_table_entry(self, state, symbol, &entry);
-  *count = entry.action_count;
-  return entry.actions;
-}
-
-static inline bool ts_language_has_reduce_action(
-  const TSLanguage *self,
-  TSStateId state,
-  TSSymbol symbol
-) {
-  TableEntry entry;
-  ts_language_table_entry(self, state, symbol, &entry);
-  return entry.action_count > 0 && entry.actions[0].type == TSParseActionTypeReduce;
-}
-
-// Lookup the table value for a given symbol and state.
-//
-// For non-terminal symbols, the table value represents a successor state.
-// For terminal symbols, it represents an index in the actions table.
-// For 'large' parse states, this is a direct lookup. For 'small' parse
-// states, this requires searching through the symbol groups to find
-// the given symbol.
-static inline uint16_t ts_language_lookup(
-  const TSLanguage *self,
-  TSStateId state,
-  TSSymbol symbol
-) {
-  if (state >= self->large_state_count) {
-    uint32_t index = self->small_parse_table_map[state - self->large_state_count];
-    const uint16_t *data = &self->small_parse_table[index];
-    uint16_t group_count = *(data++);
-    for (unsigned i = 0; i < group_count; i++) {
-      uint16_t section_value = *(data++);
-      uint16_t symbol_count = *(data++);
-      for (unsigned j = 0; j < symbol_count; j++) {
-        if (*(data++) == symbol) return section_value;
-      }
-    }
-    return 0;
-  } else {
-    return self->parse_table[state * self->symbol_count + symbol];
-  }
-}
-
-static inline bool ts_language_has_actions(
-  const TSLanguage *self,
-  TSStateId state,
-  TSSymbol symbol
-) {
-  return ts_language_lookup(self, state, symbol) != 0;
-}
-
-// Iterate over all of the symbols that are valid in the given state.
-//
-// For 'large' parse states, this just requires iterating through
-// all possible symbols and checking the parse table for each one.
-// For 'small' parse states, this exploits the structure of the
-// table to only visit the valid symbols.
-static inline LookaheadIterator ts_language_lookaheads(
-  const TSLanguage *self,
-  TSStateId state
-) {
-  bool is_small_state = state >= self->large_state_count;
-  const uint16_t *data;
-  const uint16_t *group_end = NULL;
-  uint16_t group_count = 0;
-  if (is_small_state) {
-    uint32_t index = self->small_parse_table_map[state - self->large_state_count];
-    data = &self->small_parse_table[index];
-    group_end = data + 1;
-    group_count = *data;
-  } else {
-    data = &self->parse_table[state * self->symbol_count] - 1;
-  }
-  return (LookaheadIterator) {
-    .language = self,
-    .data = data,
-    .group_end = group_end,
-    .group_count = group_count,
-    .is_small_state = is_small_state,
-    .symbol = UINT16_MAX,
-    .next_state = 0,
-  };
-}
-
-static inline bool ts_lookahead_iterator__next(LookaheadIterator *self) {
-  // For small parse states, valid symbols are listed explicitly,
-  // grouped by their value. There's no need to look up the actions
-  // again until moving to the next group.
-  if (self->is_small_state) {
-    self->data++;
-    if (self->data == self->group_end) {
-      if (self->group_count == 0) return false;
-      self->group_count--;
-      self->table_value = *(self->data++);
-      unsigned symbol_count = *(self->data++);
-      self->group_end = self->data + symbol_count;
-      self->symbol = *self->data;
-    } else {
-      self->symbol = *self->data;
-      return true;
-    }
-  }
-
-  // For large parse states, iterate through every symbol until one
-  // is found that has valid actions.
-  else {
-    do {
-      self->data++;
-      self->symbol++;
-      if (self->symbol >= self->language->symbol_count) return false;
-      self->table_value = *self->data;
-    } while (!self->table_value);
-  }
-
-  // Depending on if the symbols is terminal or non-terminal, the table value either
-  // represents a list of actions or a successor state.
-  if (self->symbol < self->language->token_count) {
-    const TSParseActionEntry *entry = &self->language->parse_actions[self->table_value];
-    self->action_count = entry->entry.count;
-    self->actions = (const TSParseAction *)(entry + 1);
-    self->next_state = 0;
-  } else {
-    self->action_count = 0;
-    self->next_state = self->table_value;
-  }
-  return true;
-}
-
-// Whether the state is a "primary state". If this returns false, it indicates that there exists
-// another state that behaves identically to this one with respect to query analysis.
-static inline bool ts_language_state_is_primary(
-  const TSLanguage *self,
-  TSStateId state
-) {
-  if (self->abi_version >= LANGUAGE_VERSION_WITH_PRIMARY_STATES) {
-    return state == self->primary_state_ids[state];
-  } else {
-    return true;
-  }
-}
-
-static inline const bool *ts_language_enabled_external_tokens(
-  const TSLanguage *self,
-  unsigned external_scanner_state
-) {
-  if (external_scanner_state == 0) {
-    return NULL;
-  } else {
-    return self->external_scanner.states + self->external_token_count * external_scanner_state;
-  }
-}
-
-static inline const TSSymbol *ts_language_alias_sequence(
-  const TSLanguage *self,
-  uint32_t production_id
-) {
-  return production_id ?
-    &self->alias_sequences[production_id * self->max_alias_sequence_length] :
-    NULL;
-}
-
-static inline TSSymbol ts_language_alias_at(
-  const TSLanguage *self,
-  uint32_t production_id,
-  uint32_t child_index
-) {
-  return production_id ?
-    self->alias_sequences[production_id * self->max_alias_sequence_length + child_index] :
-    0;
-}
-
-static inline void ts_language_field_map(
-  const TSLanguage *self,
-  uint32_t production_id,
-  const TSFieldMapEntry **start,
-  const TSFieldMapEntry **end
-) {
-  if (self->field_count == 0) {
-    *start = NULL;
-    *end = NULL;
-    return;
-  }
-
-  TSMapSlice slice = self->field_map_slices[production_id];
-  *start = &self->field_map_entries[slice.index];
-  *end = &self->field_map_entries[slice.index] + slice.length;
-}
-
-static inline void ts_language_aliases_for_symbol(
-  const TSLanguage *self,
-  TSSymbol original_symbol,
-  const TSSymbol **start,
-  const TSSymbol **end
-) {
-  *start = &self->public_symbol_map[original_symbol];
-  *end = *start + 1;
-
-  unsigned idx = 0;
-  for (;;) {
-    TSSymbol symbol = self->alias_map[idx++];
-    if (symbol == 0 || symbol > original_symbol) break;
-    uint16_t count = self->alias_map[idx++];
-    if (symbol == original_symbol) {
-      *start = &self->alias_map[idx];
-      *end = &self->alias_map[idx + count];
-      break;
-    }
-    idx += count;
-  }
-}
-
-static inline void ts_language_write_symbol_as_dot_string(
-  const TSLanguage *self,
-  FILE *f,
-  TSSymbol symbol
-) {
-  const char *name = ts_language_symbol_name(self, symbol);
-  for (const char *chr = name; *chr; chr++) {
-    switch (*chr) {
-      case '"':
-      case '\\':
-        fputc('\\', f);
-        fputc(*chr, f);
-        break;
-      case '\n':
-        fputs("\\n", f);
-        break;
-      case '\t':
-        fputs("\\t", f);
-        break;
-      default:
-        fputc(*chr, f);
-        break;
-    }
-  }
-}
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // TREE_SITTER_LANGUAGE_H_

package/node_modules/tree-sitter/vendor/tree-sitter/lib/src/length.h

@@ -1,52 +0,0 @@
-#ifndef TREE_SITTER_LENGTH_H_
-#define TREE_SITTER_LENGTH_H_
-
-#include <stdlib.h>
-#include <stdbool.h>
-#include "./point.h"
-#include "tree_sitter/api.h"
-
-typedef struct {
-  uint32_t bytes;
-  TSPoint extent;
-} Length;
-
-static const Length LENGTH_UNDEFINED = {0, {0, 1}};
-static const Length LENGTH_MAX = {UINT32_MAX, {UINT32_MAX, UINT32_MAX}};
-
-static inline bool length_is_undefined(Length length) {
-  return length.bytes == 0 && length.extent.column != 0;
-}
-
-static inline Length length_min(Length len1, Length len2) {
-  return (len1.bytes < len2.bytes) ? len1 : len2;
-}
-
-static inline Length length_add(Length len1, Length len2) {
-  Length result;
-  result.bytes = len1.bytes + len2.bytes;
-  result.extent = point_add(len1.extent, len2.extent);
-  return result;
-}
-
-static inline Length length_sub(Length len1, Length len2) {
-  Length result;
-  result.bytes = (len1.bytes >= len2.bytes) ? len1.bytes - len2.bytes : 0;
-  result.extent = point_sub(len1.extent, len2.extent);
-  return result;
-}
-
-static inline Length length_zero(void) {
-  Length result = {0, {0, 0}};
-  return result;
-}
-
-static inline Length length_saturating_sub(Length len1, Length len2) {
-  if (len1.bytes > len2.bytes) {
-    return length_sub(len1, len2);
-  } else {
-    return length_zero();
-  }
-}
-
-#endif