raphael/minishell
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Start work AGAIN

Browse source
This commit is contained in:
Maix0 2024-04-30 22:25:51 +02:00
parent 0eb8922770
commit 86b5025fb0
24 changed files with 13158 additions and 892 deletions
Download patch file Download diff file Expand all files Collapse all files

451
parser/src/api.h
View file

File diff suppressed because it is too large Load diff

30
parser/src/get_changed_ranges.c
View file

@ -13,7 +13,7 @@ static void ts_range_array_add(
Length end
) {
if (self->size > 0) {
TSRange *last_range = array_back(self);
t_range *last_range = array_back(self);
if (start.bytes <= last_range->end_byte) {
last_range->end_byte = end.bytes;
last_range->end_point = end.extent;
@ -22,7 +22,7 @@ static void ts_range_array_add(
}
if (start.bytes < end.bytes) {
TSRange range = { start.extent, end.extent, start.bytes, end.bytes };
t_range range = { start.extent, end.extent, start.bytes, end.bytes };
array_push(self, range);
}
}
@ -34,7 +34,7 @@ bool ts_range_array_intersects(
uint32_t end_byte
) {
for (unsigned i = start_index; i < self->size; i++) {
TSRange *range = &self->contents[i];
t_range *range = &self->contents[i];
if (range->end_byte > start_byte) {
if (range->start_byte >= end_byte) break;
return true;
@ -44,8 +44,8 @@ bool ts_range_array_intersects(
}
void ts_range_array_get_changed_ranges(
const TSRange *old_ranges, unsigned old_range_count,
const TSRange *new_ranges, unsigned new_range_count,
const t_range *old_ranges, unsigned old_range_count,
const t_range *new_ranges, unsigned new_range_count,
TSRangeArray *differences
) {
unsigned new_index = 0;
@ -55,8 +55,8 @@ void ts_range_array_get_changed_ranges(
bool in_new_range = false;
while (old_index < old_range_count || new_index < new_range_count) {
const TSRange *old_range = &old_ranges[old_index];
const TSRange *new_range = &new_ranges[new_index];
const t_range *old_range = &old_ranges[old_index];
const t_range *new_range = &new_ranges[new_index];
Length next_old_position;
if (in_old_range) {
@ -105,7 +105,7 @@ void ts_range_array_get_changed_ranges(
typedef struct {
TreeCursor cursor;
const TSLanguage *language;
const t_language *language;
unsigned visible_depth;
bool in_padding;
} Iterator;
@ -113,7 +113,7 @@ typedef struct {
static Iterator iterator_new(
TreeCursor *cursor,
const Subtree *tree,
const TSLanguage *language
const t_language *language
) {
array_clear(&cursor->stack);
array_push(&cursor->stack, ((TreeCursorEntry) {
@ -170,7 +170,7 @@ static bool iterator_tree_is_visible(const Iterator *self) {
static void iterator_get_visible_state(
const Iterator *self,
Subtree *tree,
TSSymbol *alias_symbol,
t_symbol *alias_symbol,
uint32_t *start_byte
) {
uint32_t i = self->cursor.stack.size - 1;
@ -309,8 +309,8 @@ static IteratorComparison iterator_compare(
Subtree new_tree = NULL_SUBTREE;
uint32_t old_start = 0;
uint32_t new_start = 0;
TSSymbol old_alias_symbol = 0;
TSSymbol new_alias_symbol = 0;
t_symbol old_alias_symbol = 0;
t_symbol new_alias_symbol = 0;
iterator_get_visible_state(old_iter, &old_tree, &old_alias_symbol, &old_start);
iterator_get_visible_state(new_iter, &new_tree, &new_alias_symbol, &new_start);
@ -357,9 +357,9 @@ static inline void iterator_print_state(Iterator *self) {
unsigned ts_subtree_get_changed_ranges(
const Subtree *old_tree, const Subtree *new_tree,
TreeCursor *cursor1, TreeCursor *cursor2,
const TSLanguage *language,
const t_language *language,
const TSRangeArray *included_range_differences,
TSRange **ranges
t_range **ranges
) {
TSRangeArray results = array_new();
@ -475,7 +475,7 @@ unsigned ts_subtree_get_changed_ranges(
// Keep track of the current position in the included range differences
// array in order to avoid scanning the entire array on each iteration.
while (included_range_difference_index < included_range_differences->size) {
const TSRange *range = &included_range_differences->contents[
const t_range *range = &included_range_differences->contents[
included_range_difference_index
];
if (range->end_byte <= position.bytes) {

10
parser/src/get_changed_ranges.h
View file

@ -8,11 +8,11 @@ extern "C" {
#include "./tree_cursor.h"
#include "./subtree.h"
typedef Array(TSRange) TSRangeArray;
typedef Array(t_range) TSRangeArray;
void ts_range_array_get_changed_ranges(
const TSRange *old_ranges, unsigned old_range_count,
const TSRange *new_ranges, unsigned new_range_count,
const t_range *old_ranges, unsigned old_range_count,
const t_range *new_ranges, unsigned new_range_count,
TSRangeArray *differences
);
@ -24,9 +24,9 @@ bool ts_range_array_intersects(
unsigned ts_subtree_get_changed_ranges(
const Subtree *old_tree, const Subtree *new_tree,
TreeCursor *cursor1, TreeCursor *cursor2,
const TSLanguage *language,
const t_language *language,
const TSRangeArray *included_range_differences,
TSRange **ranges
t_range **ranges
);
#ifdef __cplusplus

80
parser/src/language.c
View file

@ -3,34 +3,34 @@
#include "./api.h"
#include <string.h>
const TSLanguage *ts_language_copy(const TSLanguage *self) {
const t_language *ts_language_copy(const t_language *self) {
return self;
}
void ts_language_delete(const TSLanguage *self) {
void ts_language_delete(const t_language *self) {
(void)(self);
}
uint32_t ts_language_symbol_count(const TSLanguage *self) {
uint32_t ts_language_symbol_count(const t_language *self) {
return self->symbol_count + self->alias_count;
}
uint32_t ts_language_state_count(const TSLanguage *self) {
uint32_t ts_language_state_count(const t_language *self) {
return self->state_count;
}
uint32_t ts_language_version(const TSLanguage *self) {
uint32_t ts_language_version(const t_language *self) {
return self->version;
}
uint32_t ts_language_field_count(const TSLanguage *self) {
uint32_t ts_language_field_count(const t_language *self) {
return self->field_count;
}
void ts_language_table_entry(
const TSLanguage *self,
TSStateId state,
TSSymbol symbol,
const t_language *self,
t_state_id state,
t_symbol symbol,
TableEntry *result
) {
if (symbol == ts_builtin_sym_error || symbol == ts_builtin_sym_error_repeat) {
@ -48,8 +48,8 @@ void ts_language_table_entry(
}
TSSymbolMetadata ts_language_symbol_metadata(
const TSLanguage *self,
TSSymbol symbol
const t_language *self,
t_symbol symbol
) {
if (symbol == ts_builtin_sym_error) {
return (TSSymbolMetadata) {.visible = true, .named = true};
@ -60,18 +60,18 @@ TSSymbolMetadata ts_language_symbol_metadata(
}
}
TSSymbol ts_language_public_symbol(
const TSLanguage *self,
TSSymbol symbol
t_symbol ts_language_public_symbol(
const t_language *self,
t_symbol 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
t_state_id ts_language_next_state(
const t_language *self,
t_state_id state,
t_symbol symbol
) {
if (symbol == ts_builtin_sym_error || symbol == ts_builtin_sym_error_repeat) {
return 0;
@ -91,8 +91,8 @@ TSStateId ts_language_next_state(
}
const char *ts_language_symbol_name(
const TSLanguage *self,
TSSymbol symbol
const t_language *self,
t_symbol symbol
) {
if (symbol == ts_builtin_sym_error) {
return "ERROR";
@ -105,15 +105,15 @@ const char *ts_language_symbol_name(
}
}
TSSymbol ts_language_symbol_for_name(
const TSLanguage *self,
t_symbol ts_language_symbol_for_name(
const t_language *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++) {
for (t_symbol 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];
@ -124,9 +124,9 @@ TSSymbol ts_language_symbol_for_name(
return 0;
}
TSSymbolType ts_language_symbol_type(
const TSLanguage *self,
TSSymbol symbol
t_symbol_type ts_language_symbol_type(
const t_language *self,
t_symbol symbol
) {
TSSymbolMetadata metadata = ts_language_symbol_metadata(self, symbol);
if (metadata.named && metadata.visible) {
@ -139,8 +139,8 @@ TSSymbolType ts_language_symbol_type(
}
const char *ts_language_field_name_for_id(
const TSLanguage *self,
TSFieldId id
const t_language *self,
t_field_id id
) {
uint32_t count = ts_language_field_count(self);
if (count && id <= count) {
@ -150,13 +150,13 @@ const char *ts_language_field_name_for_id(
}
}
TSFieldId ts_language_field_id_for_name(
const TSLanguage *self,
t_field_id ts_language_field_id_for_name(
const t_language *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++) {
for (t_symbol 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;
@ -170,47 +170,47 @@ TSFieldId ts_language_field_id_for_name(
return 0;
}
TSLookaheadIterator *ts_lookahead_iterator_new(const TSLanguage *self, TSStateId state) {
t_lookahead_iterator *ts_lookahead_iterator_new(const t_language *self, t_state_id state) {
if (state >= self->state_count) return NULL;
LookaheadIterator *iterator = ts_malloc(sizeof(LookaheadIterator));
*iterator = ts_language_lookaheads(self, state);
return (TSLookaheadIterator *)iterator;
return (t_lookahead_iterator *)iterator;
}
void ts_lookahead_iterator_delete(TSLookaheadIterator *self) {
void ts_lookahead_iterator_delete(t_lookahead_iterator *self) {
ts_free(self);
}
bool ts_lookahead_iterator_reset_state(TSLookaheadIterator * self, TSStateId state) {
bool ts_lookahead_iterator_reset_state(t_lookahead_iterator * self, t_state_id 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 t_language *ts_lookahead_iterator_language(const t_lookahead_iterator *self) {
const LookaheadIterator *iterator = (const LookaheadIterator *)self;
return iterator->language;
}
bool ts_lookahead_iterator_reset(TSLookaheadIterator *self, const TSLanguage *language, TSStateId state) {
bool ts_lookahead_iterator_reset(t_lookahead_iterator *self, const t_language *language, t_state_id 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) {
bool ts_lookahead_iterator_next(t_lookahead_iterator *self) {
LookaheadIterator *iterator = (LookaheadIterator *)self;
return ts_lookahead_iterator__next(iterator);
}
TSSymbol ts_lookahead_iterator_current_symbol(const TSLookaheadIterator *self) {
t_symbol ts_lookahead_iterator_current_symbol(const t_lookahead_iterator *self) {
const LookaheadIterator *iterator = (const LookaheadIterator *)self;
return iterator->symbol;
}
const char *ts_lookahead_iterator_current_symbol_name(const TSLookaheadIterator *self) {
const char *ts_lookahead_iterator_current_symbol_name(const t_lookahead_iterator *self) {
const LookaheadIterator *iterator = (const LookaheadIterator *)self;
return ts_language_symbol_name(iterator->language, iterator->symbol);
}

76
parser/src/language.h
View file

@ -20,37 +20,37 @@ typedef struct {
} TableEntry;
typedef struct {
const TSLanguage *language;
const t_language *language;
const uint16_t *data;
const uint16_t *group_end;
TSStateId state;
t_state_id 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;
t_symbol symbol;
t_state_id next_state;
uint16_t action_count;
} LookaheadIterator;
void ts_language_table_entry(const TSLanguage *, TSStateId, TSSymbol, TableEntry *);
void ts_language_table_entry(const t_language *, t_state_id, t_symbol, TableEntry *);
TSSymbolMetadata ts_language_symbol_metadata(const TSLanguage *, TSSymbol);
TSSymbolMetadata ts_language_symbol_metadata(const t_language *, t_symbol);
TSSymbol ts_language_public_symbol(const TSLanguage *, TSSymbol);
t_symbol ts_language_public_symbol(const t_language *, t_symbol);
TSStateId ts_language_next_state(const TSLanguage *self, TSStateId state, TSSymbol symbol);
t_state_id ts_language_next_state(const t_language *self, t_state_id state, t_symbol symbol);
static inline bool ts_language_is_symbol_external(const TSLanguage *self, TSSymbol symbol) {
static inline bool ts_language_is_symbol_external(const t_language *self, t_symbol symbol) {
return 0 < symbol && symbol < self->external_token_count + 1;
}
static inline const TSParseAction *ts_language_actions(
const TSLanguage *self,
TSStateId state,
TSSymbol symbol,
const t_language *self,
t_state_id state,
t_symbol symbol,
uint32_t *count
) {
TableEntry entry;
@ -60,9 +60,9 @@ static inline const TSParseAction *ts_language_actions(
}
static inline bool ts_language_has_reduce_action(
const TSLanguage *self,
TSStateId state,
TSSymbol symbol
const t_language *self,
t_state_id state,
t_symbol symbol
) {
TableEntry entry;
ts_language_table_entry(self, state, symbol, &entry);
@ -77,9 +77,9 @@ static inline bool ts_language_has_reduce_action(
// 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
const t_language *self,
t_state_id state,
t_symbol symbol
) {
if (state >= self->large_state_count) {
uint32_t index = self->small_parse_table_map[state - self->large_state_count];
@ -99,9 +99,9 @@ static inline uint16_t ts_language_lookup(
}
static inline bool ts_language_has_actions(
const TSLanguage *self,
TSStateId state,
TSSymbol symbol
const t_language *self,
t_state_id state,
t_symbol symbol
) {
return ts_language_lookup(self, state, symbol) != 0;
}
@ -113,8 +113,8 @@ static inline bool ts_language_has_actions(
// 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
const t_language *self,
t_state_id state
) {
bool is_small_state = state >= self->large_state_count;
const uint16_t *data;
@ -186,8 +186,8 @@ static inline bool ts_lookahead_iterator__next(LookaheadIterator *self) {
// 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
const t_language *self,
t_state_id state
) {
if (self->version >= LANGUAGE_VERSION_WITH_PRIMARY_STATES) {
return state == self->primary_state_ids[state];
@ -197,7 +197,7 @@ static inline bool ts_language_state_is_primary(
}
static inline const bool *ts_language_enabled_external_tokens(
const TSLanguage *self,
const t_language *self,
unsigned external_scanner_state
) {
if (external_scanner_state == 0) {
@ -207,8 +207,8 @@ static inline const bool *ts_language_enabled_external_tokens(
}
}
static inline const TSSymbol *ts_language_alias_sequence(
const TSLanguage *self,
static inline const t_symbol *ts_language_alias_sequence(
const t_language *self,
uint32_t production_id
) {
return production_id ?
@ -216,8 +216,8 @@ static inline const TSSymbol *ts_language_alias_sequence(
NULL;
}
static inline TSSymbol ts_language_alias_at(
const TSLanguage *self,
static inline t_symbol ts_language_alias_at(
const t_language *self,
uint32_t production_id,
uint32_t child_index
) {
@ -227,7 +227,7 @@ static inline TSSymbol ts_language_alias_at(
}
static inline void ts_language_field_map(
const TSLanguage *self,
const t_language *self,
uint32_t production_id,
const TSFieldMapEntry **start,
const TSFieldMapEntry **end
@ -244,17 +244,17 @@ static inline void ts_language_field_map(
}
static inline void ts_language_aliases_for_symbol(
const TSLanguage *self,
TSSymbol original_symbol,
const TSSymbol **start,
const TSSymbol **end
const t_language *self,
t_symbol original_symbol,
const t_symbol **start,
const t_symbol **end
) {
*start = &self->public_symbol_map[original_symbol];
*end = *start + 1;
unsigned idx = 0;
for (;;) {
TSSymbol symbol = self->alias_map[idx++];
t_symbol symbol = self->alias_map[idx++];
if (symbol == 0 || symbol > original_symbol) break;
uint16_t count = self->alias_map[idx++];
if (symbol == original_symbol) {
@ -267,9 +267,9 @@ static inline void ts_language_aliases_for_symbol(
}
static inline void ts_language_write_symbol_as_dot_string(
const TSLanguage *self,
const t_language *self,
FILE *f,
TSSymbol symbol
t_symbol symbol
) {
const char *name = ts_language_symbol_name(self, symbol);
for (const char *chr = name; *chr; chr++) {

2
parser/src/length.h
View file

@ -8,7 +8,7 @@
typedef struct {
uint32_t bytes;
TSPoint extent;
t_point extent;
} Length;
static const Length LENGTH_UNDEFINED = {0, {0, 1}};

24
parser/src/lexer.c
View file

@ -23,7 +23,7 @@
static const int32_t BYTE_ORDER_MARK = 0xFEFF;
static const TSRange DEFAULT_RANGE = {
static const t_range DEFAULT_RANGE = {
.start_point = {
.row = 0,
.column = 0,
@ -127,7 +127,7 @@ static void ts_lexer_goto(Lexer *self, Length position) {
// Move to the first valid position at or after the given position.
bool found_included_range = false;
for (unsigned i = 0; i < self->included_range_count; i++) {
TSRange *included_range = &self->included_ranges[i];
t_range *included_range = &self->included_ranges[i];
if (
included_range->end_byte > self->current_position.bytes &&
included_range->end_byte > included_range->start_byte
@ -163,7 +163,7 @@ static void ts_lexer_goto(Lexer *self, Length position) {
// state - past the end of the included ranges.
else {
self->current_included_range_index = self->included_range_count;
TSRange *last_included_range = &self->included_ranges[self->included_range_count - 1];
t_range *last_included_range = &self->included_ranges[self->included_range_count - 1];
self->current_position = (Length) {
.bytes = last_included_range->end_byte,
.extent = last_included_range->end_point,
@ -186,7 +186,7 @@ static void ts_lexer__do_advance(Lexer *self, bool skip) {
}
}
const TSRange *current_range = &self->included_ranges[self->current_included_range_index];
const t_range *current_range = &self->included_ranges[self->current_included_range_index];
while (
self->current_position.bytes >= current_range->end_byte ||
current_range->end_byte == current_range->start_byte
@ -246,14 +246,14 @@ static void ts_lexer__mark_end(TSLexer *_self) {
// If the lexer is right at the beginning of included range,
// then the token should be considered to end at the *end* of the
// previous included range, rather than here.
TSRange *current_included_range = &self->included_ranges[
t_range *current_included_range = &self->included_ranges[
self->current_included_range_index
];
if (
self->current_included_range_index > 0 &&
self->current_position.bytes == current_included_range->start_byte
) {
TSRange *previous_included_range = current_included_range - 1;
t_range *previous_included_range = current_included_range - 1;
self->token_end_position = (Length) {
previous_included_range->end_byte,
previous_included_range->end_point,
@ -296,7 +296,7 @@ static uint32_t ts_lexer__get_column(TSLexer *_self) {
static bool ts_lexer__is_at_included_range_start(const TSLexer *_self) {
const Lexer *self = (const Lexer *)_self;
if (self->current_included_range_index < self->included_range_count) {
TSRange *current_range = &self->included_ranges[self->current_included_range_index];
t_range *current_range = &self->included_ranges[self->current_included_range_index];
return self->current_position.bytes == current_range->start_byte;
} else {
return false;
@ -336,7 +336,7 @@ void ts_lexer_delete(Lexer *self) {
ts_free(self->included_ranges);
}
void ts_lexer_set_input(Lexer *self, TSInput input) {
void ts_lexer_set_input(Lexer *self, t_input input) {
self->input = input;
ts_lexer__clear_chunk(self);
ts_lexer_goto(self, self->current_position);
@ -404,7 +404,7 @@ void ts_lexer_mark_end(Lexer *self) {
bool ts_lexer_set_included_ranges(
Lexer *self,
const TSRange *ranges,
const t_range *ranges,
uint32_t count
) {
if (count == 0 || !ranges) {
@ -413,7 +413,7 @@ bool ts_lexer_set_included_ranges(
} else {
uint32_t previous_byte = 0;
for (unsigned i = 0; i < count; i++) {
const TSRange *range = &ranges[i];
const t_range *range = &ranges[i];
if (
range->start_byte < previous_byte ||
range->end_byte < range->start_byte
@ -422,7 +422,7 @@ bool ts_lexer_set_included_ranges(
}
}
size_t size = count * sizeof(TSRange);
size_t size = count * sizeof(t_range);
self->included_ranges = ts_realloc(self->included_ranges, size);
memcpy(self->included_ranges, ranges, size);
self->included_range_count = count;
@ -430,7 +430,7 @@ bool ts_lexer_set_included_ranges(
return true;
}
TSRange *ts_lexer_included_ranges(const Lexer *self, uint32_t *count) {
t_range *ts_lexer_included_ranges(const Lexer *self, uint32_t *count) {
*count = self->included_range_count;
return self->included_ranges;
}

12
parser/src/lexer.h
View file

@ -16,10 +16,10 @@ typedef struct {
Length token_start_position;
Length token_end_position;
TSRange *included_ranges;
t_range *included_ranges;
const char *chunk;
TSInput input;
TSLogger logger;
t_input input;
t_logger logger;
uint32_t included_range_count;
uint32_t current_included_range_index;
@ -33,14 +33,14 @@ typedef struct {
void ts_lexer_init(Lexer *);
void ts_lexer_delete(Lexer *);
void ts_lexer_set_input(Lexer *, TSInput);
void ts_lexer_set_input(Lexer *, t_input);
void ts_lexer_reset(Lexer *, Length);
void ts_lexer_start(Lexer *);
void ts_lexer_finish(Lexer *, uint32_t *);
void ts_lexer_advance_to_end(Lexer *);
void ts_lexer_mark_end(Lexer *);
bool ts_lexer_set_included_ranges(Lexer *self, const TSRange *ranges, uint32_t count);
TSRange *ts_lexer_included_ranges(const Lexer *self, uint32_t *count);
bool ts_lexer_set_included_ranges(Lexer *self, const t_range *ranges, uint32_t count);
t_range *ts_lexer_included_ranges(const Lexer *self, uint32_t *count);
#ifdef __cplusplus
}

230
parser/src/node.c
View file

@ -5,58 +5,58 @@
typedef struct {
Subtree parent;
const TSTree *tree;
const t_tree *tree;
Length position;
uint32_t child_index;
uint32_t structural_child_index;
const TSSymbol *alias_sequence;
const t_symbol *alias_sequence;
} NodeChildIterator;
// TSNode - constructors
TSNode ts_node_new(
const TSTree *tree,
t_parse_node ts_node_new(
const t_tree *tree,
const Subtree *subtree,
Length position,
TSSymbol alias
t_symbol alias
) {
return (TSNode) {
return (t_parse_node) {
{position.bytes, position.extent.row, position.extent.column, alias},
subtree,
tree,
};
}
static inline TSNode ts_node__null(void) {
static inline t_parse_node ts_node__null(void) {
return ts_node_new(NULL, NULL, length_zero(), 0);
}
// TSNode - accessors
uint32_t ts_node_start_byte(TSNode self) {
uint32_t ts_node_start_byte(t_parse_node self) {
return self.context[0];
}
TSPoint ts_node_start_point(TSNode self) {
return (TSPoint) {self.context[1], self.context[2]};
t_point ts_node_start_point(t_parse_node self) {
return (t_point) {self.context[1], self.context[2]};
}
static inline uint32_t ts_node__alias(const TSNode *self) {
static inline uint32_t ts_node__alias(const t_parse_node *self) {
return self->context[3];
}
static inline Subtree ts_node__subtree(TSNode self) {
static inline Subtree ts_node__subtree(t_parse_node self) {
return *(const Subtree *)self.id;
}
// NodeChildIterator
static inline NodeChildIterator ts_node_iterate_children(const TSNode *node) {
static inline NodeChildIterator ts_node_iterate_children(const t_parse_node *node) {
Subtree subtree = ts_node__subtree(*node);
if (ts_subtree_child_count(subtree) == 0) {
return (NodeChildIterator) {NULL_SUBTREE, node->tree, length_zero(), 0, 0, NULL};
}
const TSSymbol *alias_sequence = ts_language_alias_sequence(
const t_symbol *alias_sequence = ts_language_alias_sequence(
node->tree->language,
subtree.ptr->production_id
);
@ -76,11 +76,11 @@ static inline bool ts_node_child_iterator_done(NodeChildIterator *self) {
static inline bool ts_node_child_iterator_next(
NodeChildIterator *self,
TSNode *result
t_parse_node *result
) {
if (!self->parent.ptr || ts_node_child_iterator_done(self)) return false;
const Subtree *child = &ts_subtree_children(self->parent)[self->child_index];
TSSymbol alias_symbol = 0;
t_symbol alias_symbol = 0;
if (!ts_subtree_extra(*child)) {
if (self->alias_sequence) {
alias_symbol = self->alias_sequence[self->structural_child_index];
@ -103,12 +103,12 @@ static inline bool ts_node_child_iterator_next(
// TSNode - private
static inline bool ts_node__is_relevant(TSNode self, bool include_anonymous) {
static inline bool ts_node__is_relevant(t_parse_node self, bool include_anonymous) {
Subtree tree = ts_node__subtree(self);
if (include_anonymous) {
return ts_subtree_visible(tree) || ts_node__alias(&self);
} else {
TSSymbol alias = ts_node__alias(&self);
t_symbol alias = ts_node__alias(&self);
if (alias) {
return ts_language_symbol_metadata(self.tree->language, alias).named;
} else {
@ -118,7 +118,7 @@ static inline bool ts_node__is_relevant(TSNode self, bool include_anonymous) {
}
static inline uint32_t ts_node__relevant_child_count(
TSNode self,
t_parse_node self,
bool include_anonymous
) {
Subtree tree = ts_node__subtree(self);
@ -133,18 +133,18 @@ static inline uint32_t ts_node__relevant_child_count(
}
}
static inline TSNode ts_node__child(
TSNode self,
static inline t_parse_node ts_node__child(
t_parse_node self,
uint32_t child_index,
bool include_anonymous
) {
TSNode result = self;
t_parse_node result = self;
bool did_descend = true;
while (did_descend) {
did_descend = false;
TSNode child;
t_parse_node child;
uint32_t index = 0;
NodeChildIterator iterator = ts_node_iterate_children(&result);
while (ts_node_child_iterator_next(&iterator, &child)) {
@ -184,21 +184,21 @@ static bool ts_subtree_has_trailing_empty_descendant(
return false;
}
static inline TSNode ts_node__prev_sibling(TSNode self, bool include_anonymous) {
static inline t_parse_node ts_node__prev_sibling(t_parse_node self, bool include_anonymous) {
Subtree self_subtree = ts_node__subtree(self);
bool self_is_empty = ts_subtree_total_bytes(self_subtree) == 0;
uint32_t target_end_byte = ts_node_end_byte(self);
TSNode node = ts_node_parent(self);
TSNode earlier_node = ts_node__null();
t_parse_node node = ts_node_parent(self);
t_parse_node earlier_node = ts_node__null();
bool earlier_node_is_relevant = false;
while (!ts_node_is_null(node)) {
TSNode earlier_child = ts_node__null();
t_parse_node earlier_child = ts_node__null();
bool earlier_child_is_relevant = false;
bool found_child_containing_target = false;
TSNode child;
t_parse_node child;
NodeChildIterator iterator = ts_node_iterate_children(&node);
while (ts_node_child_iterator_next(&iterator, &child)) {
if (child.id == self.id) break;
@ -245,19 +245,19 @@ static inline TSNode ts_node__prev_sibling(TSNode self, bool include_anonymous)
return ts_node__null();
}
static inline TSNode ts_node__next_sibling(TSNode self, bool include_anonymous) {
static inline t_parse_node ts_node__next_sibling(t_parse_node self, bool include_anonymous) {
uint32_t target_end_byte = ts_node_end_byte(self);
TSNode node = ts_node_parent(self);
TSNode later_node = ts_node__null();
t_parse_node node = ts_node_parent(self);
t_parse_node later_node = ts_node__null();
bool later_node_is_relevant = false;
while (!ts_node_is_null(node)) {
TSNode later_child = ts_node__null();
t_parse_node later_child = ts_node__null();
bool later_child_is_relevant = false;
TSNode child_containing_target = ts_node__null();
t_parse_node child_containing_target = ts_node__null();
TSNode child;
t_parse_node child;
NodeChildIterator iterator = ts_node_iterate_children(&node);
while (ts_node_child_iterator_next(&iterator, &child)) {
if (iterator.position.bytes < target_end_byte) continue;
@ -296,18 +296,18 @@ static inline TSNode ts_node__next_sibling(TSNode self, bool include_anonymous)
return ts_node__null();
}
static inline TSNode ts_node__first_child_for_byte(
TSNode self,
static inline t_parse_node ts_node__first_child_for_byte(
t_parse_node self,
uint32_t goal,
bool include_anonymous
) {
TSNode node = self;
t_parse_node node = self;
bool did_descend = true;
while (did_descend) {
did_descend = false;
TSNode child;
t_parse_node child;
NodeChildIterator iterator = ts_node_iterate_children(&node);
while (ts_node_child_iterator_next(&iterator, &child)) {
if (ts_node_end_byte(child) > goal) {
@ -325,20 +325,20 @@ static inline TSNode ts_node__first_child_for_byte(
return ts_node__null();
}
static inline TSNode ts_node__descendant_for_byte_range(
TSNode self,
static inline t_parse_node ts_node__descendant_for_byte_range(
t_parse_node self,
uint32_t range_start,
uint32_t range_end,
bool include_anonymous
) {
TSNode node = self;
TSNode last_visible_node = self;
t_parse_node node = self;
t_parse_node last_visible_node = self;
bool did_descend = true;
while (did_descend) {
did_descend = false;
TSNode child;
t_parse_node child;
NodeChildIterator iterator = ts_node_iterate_children(&node);
while (ts_node_child_iterator_next(&iterator, &child)) {
uint32_t node_end = iterator.position.bytes;
@ -364,23 +364,23 @@ static inline TSNode ts_node__descendant_for_byte_range(
return last_visible_node;
}
static inline TSNode ts_node__descendant_for_point_range(
TSNode self,
TSPoint range_start,
TSPoint range_end,
static inline t_parse_node ts_node__descendant_for_point_range(
t_parse_node self,
t_point range_start,
t_point range_end,
bool include_anonymous
) {
TSNode node = self;
TSNode last_visible_node = self;
t_parse_node node = self;
t_parse_node last_visible_node = self;
bool did_descend = true;
while (did_descend) {
did_descend = false;
TSNode child;
t_parse_node child;
NodeChildIterator iterator = ts_node_iterate_children(&node);
while (ts_node_child_iterator_next(&iterator, &child)) {
TSPoint node_end = iterator.position.extent;
t_point node_end = iterator.position.extent;
// The end of this node must extend far enough forward to touch
// the end of the range and exceed the start of the range.
@ -405,41 +405,41 @@ static inline TSNode ts_node__descendant_for_point_range(
// TSNode - public
uint32_t ts_node_end_byte(TSNode self) {
uint32_t ts_node_end_byte(t_parse_node self) {
return ts_node_start_byte(self) + ts_subtree_size(ts_node__subtree(self)).bytes;
}
TSPoint ts_node_end_point(TSNode self) {
t_point ts_node_end_point(t_parse_node self) {
return point_add(ts_node_start_point(self), ts_subtree_size(ts_node__subtree(self)).extent);
}
TSSymbol ts_node_symbol(TSNode self) {
TSSymbol symbol = ts_node__alias(&self);
t_symbol ts_node_symbol(t_parse_node self) {
t_symbol symbol = ts_node__alias(&self);
if (!symbol) symbol = ts_subtree_symbol(ts_node__subtree(self));
return ts_language_public_symbol(self.tree->language, symbol);
}
const char *ts_node_type(TSNode self) {
TSSymbol symbol = ts_node__alias(&self);
const char *ts_node_type(t_parse_node self) {
t_symbol symbol = ts_node__alias(&self);
if (!symbol) symbol = ts_subtree_symbol(ts_node__subtree(self));
return ts_language_symbol_name(self.tree->language, symbol);
}
const TSLanguage *ts_node_language(TSNode self) {
const t_language *ts_node_language(t_parse_node self) {
return self.tree->language;
}
TSSymbol ts_node_grammar_symbol(TSNode self) {
t_symbol ts_node_grammar_symbol(t_parse_node self) {
return ts_subtree_symbol(ts_node__subtree(self));
}
const char *ts_node_grammar_type(TSNode self) {
TSSymbol symbol = ts_subtree_symbol(ts_node__subtree(self));
const char *ts_node_grammar_type(t_parse_node self) {
t_symbol symbol = ts_subtree_symbol(ts_node__subtree(self));
return ts_language_symbol_name(self.tree->language, symbol);
}
char *ts_node_string(TSNode self) {
TSSymbol alias_symbol = ts_node__alias(&self);
char *ts_node_string(t_parse_node self) {
t_symbol alias_symbol = ts_node__alias(&self);
return ts_subtree_string(
ts_node__subtree(self),
alias_symbol,
@ -449,52 +449,52 @@ char *ts_node_string(TSNode self) {
);
}
bool ts_node_eq(TSNode self, TSNode other) {
bool ts_node_eq(t_parse_node self, t_parse_node other) {
return self.tree == other.tree && self.id == other.id;
}
bool ts_node_is_null(TSNode self) {
bool ts_node_is_null(t_parse_node self) {
return self.id == 0;
}
bool ts_node_is_extra(TSNode self) {
bool ts_node_is_extra(t_parse_node self) {
return ts_subtree_extra(ts_node__subtree(self));
}
bool ts_node_is_named(TSNode self) {
TSSymbol alias = ts_node__alias(&self);
bool ts_node_is_named(t_parse_node self) {
t_symbol alias = ts_node__alias(&self);
return alias
? ts_language_symbol_metadata(self.tree->language, alias).named
: ts_subtree_named(ts_node__subtree(self));
}
bool ts_node_is_missing(TSNode self) {
bool ts_node_is_missing(t_parse_node self) {
return ts_subtree_missing(ts_node__subtree(self));
}
bool ts_node_has_changes(TSNode self) {
bool ts_node_has_changes(t_parse_node self) {
return ts_subtree_has_changes(ts_node__subtree(self));
}
bool ts_node_has_error(TSNode self) {
bool ts_node_has_error(t_parse_node self) {
return ts_subtree_error_cost(ts_node__subtree(self)) > 0;
}
bool ts_node_is_error(TSNode self) {
TSSymbol symbol = ts_node_symbol(self);
bool ts_node_is_error(t_parse_node self) {
t_symbol symbol = ts_node_symbol(self);
return symbol == ts_builtin_sym_error;
}
uint32_t ts_node_descendant_count(TSNode self) {
uint32_t ts_node_descendant_count(t_parse_node self) {
return ts_subtree_visible_descendant_count(ts_node__subtree(self)) + 1;
}
TSStateId ts_node_parse_state(TSNode self) {
t_state_id ts_node_parse_state(t_parse_node self) {
return ts_subtree_parse_state(ts_node__subtree(self));
}
TSStateId ts_node_next_parse_state(TSNode self) {
const TSLanguage *language = self.tree->language;
t_state_id ts_node_next_parse_state(t_parse_node self) {
const t_language *language = self.tree->language;
uint16_t state = ts_node_parse_state(self);
if (state == TS_TREE_STATE_NONE) {
return TS_TREE_STATE_NONE;
@ -503,12 +503,12 @@ TSStateId ts_node_next_parse_state(TSNode self) {
return ts_language_next_state(language, state, symbol);
}
TSNode ts_node_parent(TSNode self) {
TSNode node = ts_tree_root_node(self.tree);
t_parse_node ts_node_parent(t_parse_node self) {
t_parse_node node = ts_tree_root_node(self.tree);
if (node.id == self.id) return ts_node__null();
while (true) {
TSNode next_node = ts_node_child_containing_descendant(node, self);
t_parse_node next_node = ts_node_child_containing_descendant(node, self);
if (ts_node_is_null(next_node)) break;
node = next_node;
}
@ -516,7 +516,7 @@ TSNode ts_node_parent(TSNode self) {
return node;
}
TSNode ts_node_child_containing_descendant(TSNode self, TSNode subnode) {
t_parse_node ts_node_child_containing_descendant(t_parse_node self, t_parse_node subnode) {
uint32_t start_byte = ts_node_start_byte(subnode);
uint32_t end_byte = ts_node_end_byte(subnode);
@ -536,15 +536,15 @@ TSNode ts_node_child_containing_descendant(TSNode self, TSNode subnode) {
return self;
}
TSNode ts_node_child(TSNode self, uint32_t child_index) {
t_parse_node ts_node_child(t_parse_node self, uint32_t child_index) {
return ts_node__child(self, child_index, true);
}
TSNode ts_node_named_child(TSNode self, uint32_t child_index) {
t_parse_node ts_node_named_child(t_parse_node self, uint32_t child_index) {
return ts_node__child(self, child_index, false);
}
TSNode ts_node_child_by_field_id(TSNode self, TSFieldId field_id) {
t_parse_node ts_node_child_by_field_id(t_parse_node self, t_field_id field_id) {
recur:
if (!field_id || ts_node_child_count(self) == 0) return ts_node__null();
@ -568,7 +568,7 @@ recur:
if (field_map == field_map_end) return ts_node__null();
}
TSNode child;
t_parse_node child;
NodeChildIterator iterator = ts_node_iterate_children(&self);
while (ts_node_child_iterator_next(&iterator, &child)) {
if (!ts_subtree_extra(ts_node__subtree(child))) {
@ -588,7 +588,7 @@ recur:
// Otherwise, descend into this child, but if it doesn't contain
// the field, continue searching subsequent children.
else {
TSNode result = ts_node_child_by_field_id(child, field_id);
t_parse_node result = ts_node_child_by_field_id(child, field_id);
if (result.id) return result;
field_map++;
if (field_map == field_map_end) return ts_node__null();
@ -616,7 +616,7 @@ recur:
return ts_node__null();
}
static inline const char *ts_node__field_name_from_language(TSNode self, uint32_t structural_child_index) {
static inline const char *ts_node__field_name_from_language(t_parse_node self, uint32_t structural_child_index) {
const TSFieldMapEntry *field_map, *field_map_end;
ts_language_field_map(
self.tree->language,
@ -632,15 +632,15 @@ static inline const char *ts_node__field_name_from_language(TSNode self, uint32_
return NULL;
}
const char *ts_node_field_name_for_child(TSNode self, uint32_t child_index) {
TSNode result = self;
const char *ts_node_field_name_for_child(t_parse_node self, uint32_t child_index) {
t_parse_node result = self;
bool did_descend = true;
const char *inherited_field_name = NULL;
while (did_descend) {
did_descend = false;
TSNode child;
t_parse_node child;
uint32_t index = 0;
NodeChildIterator iterator = ts_node_iterate_children(&result);
while (ts_node_child_iterator_next(&iterator, &child)) {
@ -671,12 +671,12 @@ const char *ts_node_field_name_for_child(TSNode self, uint32_t child_index) {
return NULL;
}
TSNode ts_node_child_by_field_name(
TSNode self,
t_parse_node ts_node_child_by_field_name(
t_parse_node self,
const char *name,
uint32_t name_length
) {
TSFieldId field_id = ts_language_field_id_for_name(
t_field_id field_id = ts_language_field_id_for_name(
self.tree->language,
name,
name_length
@ -684,7 +684,7 @@ TSNode ts_node_child_by_field_name(
return ts_node_child_by_field_id(self, field_id);
}
uint32_t ts_node_child_count(TSNode self) {
uint32_t ts_node_child_count(t_parse_node self) {
Subtree tree = ts_node__subtree(self);
if (ts_subtree_child_count(tree) > 0) {
return tree.ptr->visible_child_count;
@ -693,7 +693,7 @@ uint32_t ts_node_child_count(TSNode self) {
}
}
uint32_t ts_node_named_child_count(TSNode self) {
uint32_t ts_node_named_child_count(t_parse_node self) {
Subtree tree = ts_node__subtree(self);
if (ts_subtree_child_count(tree) > 0) {
return tree.ptr->named_child_count;
@ -702,65 +702,65 @@ uint32_t ts_node_named_child_count(TSNode self) {
}
}
TSNode ts_node_next_sibling(TSNode self) {
t_parse_node ts_node_next_sibling(t_parse_node self) {
return ts_node__next_sibling(self, true);
}
TSNode ts_node_next_named_sibling(TSNode self) {
t_parse_node ts_node_next_named_sibling(t_parse_node self) {
return ts_node__next_sibling(self, false);
}
TSNode ts_node_prev_sibling(TSNode self) {
t_parse_node ts_node_prev_sibling(t_parse_node self) {
return ts_node__prev_sibling(self, true);
}
TSNode ts_node_prev_named_sibling(TSNode self) {
t_parse_node ts_node_prev_named_sibling(t_parse_node self) {
return ts_node__prev_sibling(self, false);
}
TSNode ts_node_first_child_for_byte(TSNode self, uint32_t byte) {
t_parse_node ts_node_first_child_for_byte(t_parse_node self, uint32_t byte) {
return ts_node__first_child_for_byte(self, byte, true);
}
TSNode ts_node_first_named_child_for_byte(TSNode self, uint32_t byte) {
t_parse_node ts_node_first_named_child_for_byte(t_parse_node self, uint32_t byte) {
return ts_node__first_child_for_byte(self, byte, false);
}
TSNode ts_node_descendant_for_byte_range(
TSNode self,
t_parse_node ts_node_descendant_for_byte_range(
t_parse_node self,
uint32_t start,
uint32_t end
) {
return ts_node__descendant_for_byte_range(self, start, end, true);
}
TSNode ts_node_named_descendant_for_byte_range(
TSNode self,
t_parse_node ts_node_named_descendant_for_byte_range(
t_parse_node self,
uint32_t start,
uint32_t end
) {
return ts_node__descendant_for_byte_range(self, start, end, false);
}
TSNode ts_node_descendant_for_point_range(
TSNode self,
TSPoint start,
TSPoint end
t_parse_node ts_node_descendant_for_point_range(
t_parse_node self,
t_point start,
t_point end
) {
return ts_node__descendant_for_point_range(self, start, end, true);
}
TSNode ts_node_named_descendant_for_point_range(
TSNode self,
TSPoint start,
TSPoint end
t_parse_node ts_node_named_descendant_for_point_range(
t_parse_node self,
t_point start,
t_point end
) {
return ts_node__descendant_for_point_range(self, start, end, false);
}
void ts_node_edit(TSNode *self, const TSInputEdit *edit) {
void ts_node_edit(t_parse_node *self, const t_input_edit *edit) {
uint32_t start_byte = ts_node_start_byte(*self);
TSPoint start_point = ts_node_start_point(*self);
t_point start_point = ts_node_start_point(*self);
if (start_byte >= edit->old_end_byte) {
start_byte = edit->new_end_byte + (start_byte - edit->old_end_byte);

180
parser/src/parser.c
View file

@ -87,11 +87,11 @@ typedef struct {
uint32_t byte_index;
} TokenCache;
struct TSParser {
struct t_parser {
Lexer lexer;
Stack *stack;
SubtreePool tree_pool;
const TSLanguage *language;
const t_language *language;
ReduceActionSet reduce_actions;
Subtree finished_tree;
SubtreeArray trailing_extras;
@ -137,7 +137,7 @@ typedef struct {
static const char *ts_string_input_read(
void *_self,
uint32_t byte,
TSPoint point,
t_point point,
uint32_t *length
) {
(void)point;
@ -153,7 +153,7 @@ static const char *ts_string_input_read(
// Parser - Private
static void ts_parser__log(TSParser *self) {
static void ts_parser__log(t_parser *self) {
if (self->lexer.logger.log) {
self->lexer.logger.log(
self->lexer.logger.payload,
@ -173,7 +173,7 @@ static void ts_parser__log(TSParser *self) {
}
static bool ts_parser__breakdown_top_of_stack(
TSParser *self,
t_parser *self,
StackVersion version
) {
bool did_break_down = false;
@ -187,7 +187,7 @@ static bool ts_parser__breakdown_top_of_stack(
pending = false;
for (uint32_t i = 0; i < pop.size; i++) {
StackSlice slice = pop.contents[i];
TSStateId state = ts_stack_state(self->stack, slice.version);
t_state_id state = ts_stack_state(self->stack, slice.version);
Subtree parent = *array_front(&slice.subtrees);
for (uint32_t j = 0, n = ts_subtree_child_count(parent); j < n; j++) {
@ -221,9 +221,9 @@ static bool ts_parser__breakdown_top_of_stack(
}
static void ts_parser__breakdown_lookahead(
TSParser *self,
t_parser *self,
Subtree *lookahead,
TSStateId state,
t_state_id state,
ReusableNode *reusable_node
) {
bool did_descend = false;
@ -243,7 +243,7 @@ static void ts_parser__breakdown_lookahead(
}
static ErrorComparison ts_parser__compare_versions(
TSParser *self,
t_parser *self,
ErrorStatus a,
ErrorStatus b
) {
@ -286,7 +286,7 @@ static ErrorComparison ts_parser__compare_versions(
}
static ErrorStatus ts_parser__version_status(
TSParser *self,
t_parser *self,
StackVersion version
) {
unsigned cost = ts_stack_error_cost(self->stack, version);
@ -301,7 +301,7 @@ static ErrorStatus ts_parser__version_status(
}
static bool ts_parser__better_version_exists(
TSParser *self,
t_parser *self,
StackVersion version,
bool is_in_error,
unsigned cost
@ -337,13 +337,13 @@ static bool ts_parser__better_version_exists(
return false;
}
static bool ts_parser__call_main_lex_fn(TSParser *self, TSLexMode lex_mode) {
static bool ts_parser__call_main_lex_fn(t_parser *self, TSLexMode lex_mode) {
return self->language->lex_fn(&self->lexer.data, lex_mode.lex_state);
}
static bool ts_parser__call_keyword_lex_fn(TSParser *self, TSLexMode lex_mode) {
static bool ts_parser__call_keyword_lex_fn(t_parser *self, TSLexMode lex_mode) {
(void)(lex_mode);
return self->language->keyword_lex_fn(&self->lexer.data, 0);
@ -351,7 +351,7 @@ static bool ts_parser__call_keyword_lex_fn(TSParser *self, TSLexMode lex_mode) {
}
static void ts_parser__external_scanner_create(
TSParser *self
t_parser *self
) {
if (self->language && self->language->external_scanner.states) {
if (self->language->external_scanner.create) {
@ -361,7 +361,7 @@ if (self->language->external_scanner.create) {
}}
static void ts_parser__external_scanner_destroy(
TSParser *self
t_parser *self
) {
if (
self->language &&
@ -376,7 +376,7 @@ static void ts_parser__external_scanner_destroy(
}
static unsigned ts_parser__external_scanner_serialize(
TSParser *self
t_parser *self
) {
uint32_t length = self->language->external_scanner.serialize(
self->external_scanner_payload,
@ -388,7 +388,7 @@ static unsigned ts_parser__external_scanner_serialize(
}
static void ts_parser__external_scanner_deserialize(
TSParser *self,
t_parser *self,
Subtree external_token
) {
const char *data = NULL;
@ -408,8 +408,8 @@ static void ts_parser__external_scanner_deserialize(
}
static bool ts_parser__external_scanner_scan(
TSParser *self,
TSStateId external_lex_state
t_parser *self,
t_state_id external_lex_state
) {
const bool *valid_external_tokens = ts_language_enabled_external_tokens(
@ -425,14 +425,14 @@ static bool ts_parser__external_scanner_scan(
}
static bool ts_parser__can_reuse_first_leaf(
TSParser *self,
TSStateId state,
t_parser *self,
t_state_id state,
Subtree tree,
TableEntry *table_entry
) {
TSLexMode current_lex_mode = self->language->lex_modes[state];
TSSymbol leaf_symbol = ts_subtree_leaf_symbol(tree);
TSStateId leaf_state = ts_subtree_leaf_parse_state(tree);
t_symbol leaf_symbol = ts_subtree_leaf_symbol(tree);
t_state_id leaf_state = ts_subtree_leaf_parse_state(tree);
TSLexMode leaf_lex_mode = self->language->lex_modes[leaf_state];
// At the end of a non-terminal extra node, the lexer normally returns
@ -460,9 +460,9 @@ static bool ts_parser__can_reuse_first_leaf(
}
static Subtree ts_parser__lex(
TSParser *self,
t_parser *self,
StackVersion version,
TSStateId parse_state
t_state_id parse_state
) {
TSLexMode lex_mode = self->language->lex_modes[parse_state];
if (lex_mode.lex_state == (uint16_t)-1) {
@ -596,7 +596,7 @@ static Subtree ts_parser__lex(
);
} else {
bool is_keyword = false;
TSSymbol symbol = self->lexer.data.result_symbol;
t_symbol symbol = self->lexer.data.result_symbol;
Length padding = length_sub(self->lexer.token_start_position, start_position);
Length size = length_sub(self->lexer.token_end_position, self->lexer.token_start_position);
uint32_t lookahead_bytes = lookahead_end_byte - self->lexer.token_end_position.bytes;
@ -651,8 +651,8 @@ static Subtree ts_parser__lex(
}
static Subtree ts_parser__get_cached_token(
TSParser *self,
TSStateId state,
t_parser *self,
t_state_id state,
size_t position,
Subtree last_external_token,
TableEntry *table_entry
@ -672,7 +672,7 @@ static Subtree ts_parser__get_cached_token(
}
static void ts_parser__set_cached_token(
TSParser *self,
t_parser *self,
uint32_t byte_index,
Subtree last_external_token,
Subtree token
@ -688,7 +688,7 @@ static void ts_parser__set_cached_token(
}
static bool ts_parser__has_included_range_difference(
const TSParser *self,
const t_parser *self,
uint32_t start_position,
uint32_t end_position
) {
@ -701,9 +701,9 @@ static bool ts_parser__has_included_range_difference(
}
static Subtree ts_parser__reuse_node(
TSParser *self,
t_parser *self,
StackVersion version,
TSStateId *state,
t_state_id *state,
uint32_t position,
Subtree last_external_token,
TableEntry *table_entry
@ -759,7 +759,7 @@ static Subtree ts_parser__reuse_node(
continue;
}
TSSymbol leaf_symbol = ts_subtree_leaf_symbol(result);
t_symbol leaf_symbol = ts_subtree_leaf_symbol(result);
ts_language_table_entry(self->language, *state, leaf_symbol, table_entry);
if (!ts_parser__can_reuse_first_leaf(self, *state, result, table_entry)) {
LOG(
@ -783,7 +783,7 @@ static Subtree ts_parser__reuse_node(
//
// The decision is based on the trees' error costs (if any), their dynamic precedence,
// and finally, as a default, by a recursive comparison of the trees' symbols.
static bool ts_parser__select_tree(TSParser *self, Subtree left, Subtree right) {
static bool ts_parser__select_tree(t_parser *self, Subtree left, Subtree right) {
if (!left.ptr) return true;
if (!right.ptr) return false;
@ -831,7 +831,7 @@ static bool ts_parser__select_tree(TSParser *self, Subtree left, Subtree right)
// Determine if a given tree's children should be replaced by an alternative
// array of children.
static bool ts_parser__select_children(
TSParser *self,
t_parser *self,
Subtree left,
const SubtreeArray *children
) {
@ -856,9 +856,9 @@ static bool ts_parser__select_children(
}
static void ts_parser__shift(
TSParser *self,
t_parser *self,
StackVersion version,
TSStateId state,
t_state_id state,
Subtree lookahead,
bool extra
) {
@ -879,9 +879,9 @@ static void ts_parser__shift(
}
static StackVersion ts_parser__reduce(
TSParser *self,
t_parser *self,
StackVersion version,
TSSymbol symbol,
t_symbol symbol,
uint32_t count,
int dynamic_precedence,
uint16_t production_id,
@ -957,8 +957,8 @@ static StackVersion ts_parser__reduce(
}
}
TSStateId state = ts_stack_state(self->stack, slice_version);
TSStateId next_state = ts_language_next_state(self->language, state, symbol);
t_state_id state = ts_stack_state(self->stack, slice_version);
t_state_id next_state = ts_language_next_state(self->language, state, symbol);
if (end_of_non_terminal_extra && next_state == state) {
parent.ptr->extra = true;
}
@ -994,7 +994,7 @@ static StackVersion ts_parser__reduce(
}
static void ts_parser__accept(
TSParser *self,
t_parser *self,
StackVersion version,
Subtree lookahead
) {
@ -1047,9 +1047,9 @@ static void ts_parser__accept(
}
static bool ts_parser__do_all_potential_reductions(
TSParser *self,
t_parser *self,
StackVersion starting_version,
TSSymbol lookahead_symbol
t_symbol lookahead_symbol
) {
uint32_t initial_version_count = ts_stack_version_count(self->stack);
@ -1068,11 +1068,11 @@ static bool ts_parser__do_all_potential_reductions(
}
if (merged) continue;
TSStateId state = ts_stack_state(self->stack, version);
t_state_id state = ts_stack_state(self->stack, version);
bool has_shift_action = false;
array_clear(&self->reduce_actions);
TSSymbol first_symbol, end_symbol;
t_symbol first_symbol, end_symbol;
if (lookahead_symbol != 0) {
first_symbol = lookahead_symbol;
end_symbol = lookahead_symbol + 1;
@ -1081,7 +1081,7 @@ static bool ts_parser__do_all_potential_reductions(
end_symbol = self->language->token_count;
}
for (TSSymbol symbol = first_symbol; symbol < end_symbol; symbol++) {
for (t_symbol symbol = first_symbol; symbol < end_symbol; symbol++) {
TableEntry entry;
ts_language_table_entry(self->language, state, symbol, &entry);
for (uint32_t j = 0; j < entry.action_count; j++) {
@ -1137,10 +1137,10 @@ static bool ts_parser__do_all_potential_reductions(
}
static bool ts_parser__recover_to_state(
TSParser *self,
t_parser *self,
StackVersion version,
unsigned depth,
TSStateId goal_state
t_state_id goal_state
) {
StackSliceArray pop = ts_stack_pop_count(self->stack, version, depth);
StackVersion previous_version = STACK_VERSION_NONE;
@ -1196,7 +1196,7 @@ static bool ts_parser__recover_to_state(
}
static void ts_parser__recover(
TSParser *self,
t_parser *self,
StackVersion version,
Subtree lookahead
) {
@ -1373,7 +1373,7 @@ static void ts_parser__recover(
}
static void ts_parser__handle_error(
TSParser *self,
t_parser *self,
StackVersion version,
Subtree lookahead
) {
@ -1391,13 +1391,13 @@ static void ts_parser__handle_error(
bool did_insert_missing_token = false;
for (StackVersion v = version; v < version_count;) {
if (!did_insert_missing_token) {
TSStateId state = ts_stack_state(self->stack, v);
t_state_id state = ts_stack_state(self->stack, v);
for (
TSSymbol missing_symbol = 1;
t_symbol missing_symbol = 1;
missing_symbol < (uint16_t)self->language->token_count;
missing_symbol++
) {
TSStateId state_after_missing_symbol = ts_language_next_state(
t_state_id state_after_missing_symbol = ts_language_next_state(
self->language, state, missing_symbol
);
if (state_after_missing_symbol == 0 || state_after_missing_symbol == state) {
@ -1471,11 +1471,11 @@ static void ts_parser__handle_error(
}
static bool ts_parser__advance(
TSParser *self,
t_parser *self,
StackVersion version,
bool allow_node_reuse
) {
TSStateId state = ts_stack_state(self->stack, version);
t_state_id state = ts_stack_state(self->stack, version);
uint32_t position = ts_stack_position(self->stack, version).bytes;
Subtree last_external_token = ts_stack_last_external_token(self->stack, version);
@ -1548,7 +1548,7 @@ static bool ts_parser__advance(
switch (action.type) {
case TSParseActionTypeShift: {
if (action.shift.repetition) break;
TSStateId next_state;
t_state_id next_state;
if (action.shift.extra) {
next_state = state;
LOG("shift_extra");
@ -1688,7 +1688,7 @@ static bool ts_parser__advance(
}
}
static unsigned ts_parser__condense_stack(TSParser *self) {
static unsigned ts_parser__condense_stack(t_parser *self) {
bool made_changes = false;
unsigned min_error_cost = UINT_MAX;
for (StackVersion i = 0; i < ts_stack_version_count(self->stack); i++) {
@ -1788,7 +1788,7 @@ static unsigned ts_parser__condense_stack(TSParser *self) {
return min_error_cost;
}
static bool ts_parser_has_outstanding_parse(TSParser *self) {
static bool ts_parser_has_outstanding_parse(t_parser *self) {
return (
self->external_scanner_payload ||
ts_stack_state(self->stack, 0) != 1 ||
@ -1798,8 +1798,8 @@ static bool ts_parser_has_outstanding_parse(TSParser *self) {
// Parser - Public
TSParser *ts_parser_new(void) {
TSParser *self = ts_calloc(1, sizeof(TSParser));
t_parser *ts_parser_new(void) {
t_parser *self = ts_calloc(1, sizeof(t_parser));
ts_lexer_init(&self->lexer);
array_init(&self->reduce_actions);
array_reserve(&self->reduce_actions, 4);
@ -1822,7 +1822,7 @@ TSParser *ts_parser_new(void) {
return self;
}
void ts_parser_delete(TSParser *self) {
void ts_parser_delete(t_parser *self) {
if (!self) return;
ts_parser_set_language(self, NULL);
@ -1847,11 +1847,11 @@ void ts_parser_delete(TSParser *self) {
ts_free(self);
}
const TSLanguage *ts_parser_language(const TSParser *self) {
const t_language *ts_parser_language(const t_parser *self) {
return self->language;
}
bool ts_parser_set_language(TSParser *self, const TSLanguage *language) {
bool ts_parser_set_language(t_parser *self, const t_language *language) {
ts_parser_reset(self);
ts_language_delete(self->language);
self->language = NULL;
@ -1869,15 +1869,15 @@ bool ts_parser_set_language(TSParser *self, const TSLanguage *language) {
return true;
}
TSLogger ts_parser_logger(const TSParser *self) {
t_logger ts_parser_logger(const t_parser *self) {
return self->lexer.logger;
}
void ts_parser_set_logger(TSParser *self, TSLogger logger) {
void ts_parser_set_logger(t_parser *self, t_logger logger) {
self->lexer.logger = logger;
}
void ts_parser_print_dot_graphs(TSParser *self, int fd) {
void ts_parser_print_dot_graphs(t_parser *self, int fd) {
if (self->dot_graph_file) {
fclose(self->dot_graph_file);
}
@ -1893,35 +1893,35 @@ void ts_parser_print_dot_graphs(TSParser *self, int fd) {
}
}
const size_t *ts_parser_cancellation_flag(const TSParser *self) {
const size_t *ts_parser_cancellation_flag(const t_parser *self) {
return (const size_t *)self->cancellation_flag;
}
void ts_parser_set_cancellation_flag(TSParser *self, const size_t *flag) {
void ts_parser_set_cancellation_flag(t_parser *self, const size_t *flag) {
self->cancellation_flag = (const volatile size_t *)flag;
}
uint64_t ts_parser_timeout_micros(const TSParser *self) {
uint64_t ts_parser_timeout_micros(const t_parser *self) {
return duration_to_micros(self->timeout_duration);
}
void ts_parser_set_timeout_micros(TSParser *self, uint64_t timeout_micros) {
void ts_parser_set_timeout_micros(t_parser *self, uint64_t timeout_micros) {
self->timeout_duration = duration_from_micros(timeout_micros);
}
bool ts_parser_set_included_ranges(
TSParser *self,
const TSRange *ranges,
t_parser *self,
const t_range *ranges,
uint32_t count
) {
return ts_lexer_set_included_ranges(&self->lexer, ranges, count);
}
const TSRange *ts_parser_included_ranges(const TSParser *self, uint32_t *count) {
const t_range *ts_parser_included_ranges(const t_parser *self, uint32_t *count) {
return ts_lexer_included_ranges(&self->lexer, count);
}
void ts_parser_reset(TSParser *self) {
void ts_parser_reset(t_parser *self) {
ts_parser__external_scanner_destroy(self);
if (self->old_tree.ptr) {
@ -1941,12 +1941,12 @@ void ts_parser_reset(TSParser *self) {
self->has_scanner_error = false;
}
TSTree *ts_parser_parse(
TSParser *self,
const TSTree *old_tree,
TSInput input
t_tree *ts_parser_parse(
t_parser *self,
const t_tree *old_tree,
t_input input
) {
TSTree *result = NULL;
t_tree *result = NULL;
if (!self->language || !input.read) return NULL;
@ -1973,7 +1973,7 @@ TSTree *ts_parser_parse(
LOG("parse_after_edit");
LOG_TREE(self->old_tree);
for (unsigned i = 0; i < self->included_range_differences.size; i++) {
TSRange *range = &self->included_range_differences.contents[i];
t_range *range = &self->included_range_differences.contents[i];
LOG("different_included_range %u - %u", range->start_byte, range->end_byte);
}
} else {
@ -2037,7 +2037,7 @@ TSTree *ts_parser_parse(
}
while (self->included_range_difference_index < self->included_range_differences.size) {
TSRange *range = &self->included_range_differences.contents[self->included_range_difference_index];
t_range *range = &self->included_range_differences.contents[self->included_range_difference_index];
if (range->end_byte <= position) {
self->included_range_difference_index++;
} else {
@ -2064,24 +2064,24 @@ exit:
return result;
}
TSTree *ts_parser_parse_string(
TSParser *self,
const TSTree *old_tree,
t_tree *ts_parser_parse_string(
t_parser *self,
const t_tree *old_tree,
const char *string,
uint32_t length
) {
return ts_parser_parse_string_encoding(self, old_tree, string, length, TSInputEncodingUTF8);
}
TSTree *ts_parser_parse_string_encoding(
TSParser *self,
const TSTree *old_tree,
t_tree *ts_parser_parse_string_encoding(
t_parser *self,
const t_tree *old_tree,
const char *string,
uint32_t length,
TSInputEncoding encoding
t_input_encoding encoding
) {
TSStringInput input = {string, length};
return ts_parser_parse(self, old_tree, (TSInput) {
return ts_parser_parse(self, old_tree, (t_input) {
&input,
ts_string_input_read,
encoding,

26
parser/src/parser.h
View file

@ -9,7 +9,7 @@ extern "C" {
#include <stdint.h>
#include <stdlib.h>
#define ts_builtin_sym_error ((TSSymbol)-1)
#define ts_builtin_sym_error ((t_symbol)-1)
#define ts_builtin_sym_end 0
#define TREE_SITTER_SERIALIZATION_BUFFER_SIZE 1024
@ -21,7 +21,7 @@ typedef struct TSLanguage TSLanguage;
#endif
typedef struct {
TSFieldId field_id;
t_field_id field_id;
uint8_t child_index;
bool inherited;
} TSFieldMapEntry;
@ -41,7 +41,7 @@ typedef struct TSLexer TSLexer;
struct TSLexer {
int32_t lookahead;
TSSymbol result_symbol;
t_symbol result_symbol;
void (*advance)(TSLexer *, bool);
void (*mark_end)(TSLexer *);
uint32_t (*get_column)(TSLexer *);
@ -59,14 +59,14 @@ typedef enum {
typedef union {
struct {
uint8_t type;
TSStateId state;
t_state_id state;
bool extra;
bool repetition;
} shift;
struct {
uint8_t type;
uint8_t child_count;
TSSymbol symbol;
t_symbol symbol;
int16_t dynamic_precedence;
uint16_t production_id;
} reduce;
@ -91,7 +91,7 @@ typedef struct {
int32_t end;
} TSCharacterRange;
struct TSLanguage {
struct t_language {
uint32_t version;
uint32_t symbol_count;
uint32_t alias_count;
@ -111,23 +111,23 @@ struct TSLanguage {
const TSFieldMapSlice *field_map_slices;
const TSFieldMapEntry *field_map_entries;
const TSSymbolMetadata *symbol_metadata;
const TSSymbol *public_symbol_map;
const t_symbol *public_symbol_map;
const uint16_t *alias_map;
const TSSymbol *alias_sequences;
const t_symbol *alias_sequences;
const TSLexMode *lex_modes;
bool (*lex_fn)(TSLexer *, TSStateId);
bool (*keyword_lex_fn)(TSLexer *, TSStateId);
TSSymbol keyword_capture_token;
bool (*lex_fn)(TSLexer *, t_state_id);
bool (*keyword_lex_fn)(TSLexer *, t_state_id);
t_symbol keyword_capture_token;
struct {
const bool *states;
const TSSymbol *symbol_map;
const t_symbol *symbol_map;
void *(*create)(void);
void (*destroy)(void *);
bool (*scan)(void *, TSLexer *, const bool *symbol_whitelist);
unsigned (*serialize)(void *, char *);
void (*deserialize)(void *, const char *, unsigned);
} external_scanner;
const TSStateId *primary_state_ids;
const t_state_id *primary_state_ids;
};
static inline bool set_contains(TSCharacterRange *ranges, uint32_t len, int32_t lookahead) {

26
parser/src/point.h
View file

@ -3,56 +3,56 @@
#include "./api.h"
#define POINT_ZERO ((TSPoint) {0, 0})
#define POINT_MAX ((TSPoint) {UINT32_MAX, UINT32_MAX})
#define POINT_ZERO ((t_point) {0, 0})
#define POINT_MAX ((t_point) {UINT32_MAX, UINT32_MAX})
static inline TSPoint point__new(unsigned row, unsigned column) {
TSPoint result = {row, column};
static inline t_point point__new(unsigned row, unsigned column) {
t_point result = {row, column};
return result;
}
static inline TSPoint point_add(TSPoint a, TSPoint b) {
static inline t_point point_add(t_point a, t_point b) {
if (b.row > 0)
return point__new(a.row + b.row, b.column);
else
return point__new(a.row, a.column + b.column);
}
static inline TSPoint point_sub(TSPoint a, TSPoint b) {
static inline t_point point_sub(t_point a, t_point b) {
if (a.row > b.row)
return point__new(a.row - b.row, a.column);
else
return point__new(0, a.column - b.column);
}
static inline bool point_lte(TSPoint a, TSPoint b) {
static inline bool point_lte(t_point a, t_point b) {
return (a.row < b.row) || (a.row == b.row && a.column <= b.column);
}
static inline bool point_lt(TSPoint a, TSPoint b) {
static inline bool point_lt(t_point a, t_point b) {
return (a.row < b.row) || (a.row == b.row && a.column < b.column);
}
static inline bool point_gt(TSPoint a, TSPoint b) {
static inline bool point_gt(t_point a, t_point b) {
return (a.row > b.row) || (a.row == b.row && a.column > b.column);
}
static inline bool point_gte(TSPoint a, TSPoint b) {
static inline bool point_gte(t_point a, t_point b) {
return (a.row > b.row) || (a.row == b.row && a.column >= b.column);
}
static inline bool point_eq(TSPoint a, TSPoint b) {
static inline bool point_eq(t_point a, t_point b) {
return a.row == b.row && a.column == b.column;
}
static inline TSPoint point_min(TSPoint a, TSPoint b) {
static inline t_point point_min(t_point a, t_point b) {
if (a.row < b.row || (a.row == b.row && a.column < b.column))
return a;
else
return b;
}
static inline TSPoint point_max(TSPoint a, TSPoint b) {
static inline t_point point_max(t_point a, t_point b) {
if (a.row > b.row || (a.row == b.row && a.column > b.column))
return a;
else

346
parser/src/query.c
View file

File diff suppressed because it is too large Load diff

2
parser/src/reduce_action.h
View file

@ -10,7 +10,7 @@ extern "C" {
typedef struct {
uint32_t count;
TSSymbol symbol;
t_symbol symbol;
int dynamic_precedence;
unsigned short production_id;
} ReduceAction;

12
parser/src/stack.c
View file

@ -27,7 +27,7 @@ typedef struct {
} StackLink;
struct StackNode {
TSStateId state;
t_state_id state;
Length position;
StackLink links[MAX_LINK_COUNT];
short unsigned int link_count;
@ -139,7 +139,7 @@ static StackNode *stack_node_new(
StackNode *previous_node,
Subtree subtree,
bool is_pending,
TSStateId state,
t_state_id state,
StackNodeArray *pool
) {
StackNode *node = pool->size > 0
@ -460,7 +460,7 @@ uint32_t ts_stack_version_count(const Stack *self) {
return self->heads.size;
}
TSStateId ts_stack_state(const Stack *self, StackVersion version) {
t_state_id ts_stack_state(const Stack *self, StackVersion version) {
return array_get(&self->heads, version)->node->state;
}
@ -503,7 +503,7 @@ void ts_stack_push(
StackVersion version,
Subtree subtree,
bool pending,
TSStateId state
t_state_id state
) {
StackHead *head = array_get(&self->heads, version);
StackNode *new_node = stack_node_new(head->node, subtree, pending, state, &self->node_pool);
@ -593,7 +593,7 @@ typedef struct {
forceinline StackAction summarize_stack_callback(void *payload, const StackIterator *iterator) {
SummarizeStackSession *session = payload;
TSStateId state = iterator->node->state;
t_state_id state = iterator->node->state;
unsigned depth = iterator->subtree_count;
if (depth > session->max_depth) return StackActionStop;
for (unsigned i = session->summary->size - 1; i + 1 > 0; i--) {
@ -764,7 +764,7 @@ void ts_stack_clear(Stack *self) {
}));
}
bool ts_stack_print_dot_graph(Stack *self, const TSLanguage *language, FILE *f) {
bool ts_stack_print_dot_graph(Stack *self, const t_language *language, FILE *f) {
array_reserve(&self->iterators, 32);
if (!f) f = stderr;

10
parser/src/stack.h
View file

@ -24,7 +24,7 @@ typedef Array(StackSlice) StackSliceArray;
typedef struct {
Length position;
unsigned depth;
TSStateId state;
t_state_id state;
} StackSummaryEntry;
typedef Array(StackSummaryEntry) StackSummary;
@ -39,7 +39,7 @@ uint32_t ts_stack_version_count(const Stack *);
// Get the state at the top of the given version of the stack. If the stack is
// empty, this returns the initial state, 0.
TSStateId ts_stack_state(const Stack *, StackVersion);
t_state_id ts_stack_state(const Stack *, StackVersion);
// Get the last external token associated with a given version of the stack.
Subtree ts_stack_last_external_token(const Stack *, StackVersion);
@ -55,7 +55,7 @@ Length ts_stack_position(const Stack *, StackVersion);
// This transfers ownership of the tree to the Stack. Callers that
// need to retain ownership of the tree for their own purposes should
// first retain the tree.
void ts_stack_push(Stack *, StackVersion, Subtree , bool, TSStateId);
void ts_stack_push(Stack *, StackVersion, Subtree , bool, t_state_id);
// Pop the given number of entries from the given version of the stack. This
// operation can increase the number of stack versions by revealing multiple
@ -122,9 +122,9 @@ void ts_stack_remove_version(Stack *, StackVersion);
void ts_stack_clear(Stack *);
bool ts_stack_print_dot_graph(Stack *, const TSLanguage *, FILE *);
bool ts_stack_print_dot_graph(Stack *, const t_language *, FILE *);
typedef void (*StackIterateCallback)(void *, TSStateId, uint32_t);
typedef void (*StackIterateCallback)(void *, t_state_id, uint32_t);
#ifdef __cplusplus
}

60
parser/src/subtree.c
View file

@ -163,10 +163,10 @@ static inline bool ts_subtree_can_inline(Length padding, Length size, uint32_t l
}
Subtree ts_subtree_new_leaf(
SubtreePool *pool, TSSymbol symbol, Length padding, Length size,
uint32_t lookahead_bytes, TSStateId parse_state,
SubtreePool *pool, t_symbol symbol, Length padding, Length size,
uint32_t lookahead_bytes, t_state_id parse_state,
bool has_external_tokens, bool depends_on_column,
bool is_keyword, const TSLanguage *language
bool is_keyword, const t_language *language
) {
TSSymbolMetadata metadata = ts_language_symbol_metadata(language, symbol);
bool extra = symbol == ts_builtin_sym_end;
@ -224,8 +224,8 @@ Subtree ts_subtree_new_leaf(
void ts_subtree_set_symbol(
MutableSubtree *self,
TSSymbol symbol,
const TSLanguage *language
t_symbol symbol,
const t_language *language
) {
TSSymbolMetadata metadata = ts_language_symbol_metadata(language, symbol);
if (self->data.is_inline) {
@ -242,7 +242,7 @@ void ts_subtree_set_symbol(
Subtree ts_subtree_new_error(
SubtreePool *pool, int32_t lookahead_char, Length padding, Length size,
uint32_t bytes_scanned, TSStateId parse_state, const TSLanguage *language
uint32_t bytes_scanned, t_state_id parse_state, const t_language *language
) {
Subtree result = ts_subtree_new_leaf(
pool, ts_builtin_sym_error, padding, size, bytes_scanned,
@ -291,13 +291,13 @@ MutableSubtree ts_subtree_make_mut(SubtreePool *pool, Subtree self) {
static void ts_subtree__compress(
MutableSubtree self,
unsigned count,
const TSLanguage *language,
const t_language *language,
MutableSubtreeArray *stack
) {
unsigned initial_stack_size = stack->size;
MutableSubtree tree = self;
TSSymbol symbol = tree.ptr->symbol;
t_symbol symbol = tree.ptr->symbol;
for (unsigned i = 0; i < count; i++) {
if (tree.ptr->ref_count > 1 || tree.ptr->child_count < 2) break;
@ -334,7 +334,7 @@ static void ts_subtree__compress(
}
}
void ts_subtree_balance(Subtree self, SubtreePool *pool, const TSLanguage *language) {
void ts_subtree_balance(Subtree self, SubtreePool *pool, const t_language *language) {
array_clear(&pool->tree_stack);
if (ts_subtree_child_count(self) > 0 && self.ptr->ref_count == 1) {
@ -369,7 +369,7 @@ void ts_subtree_balance(Subtree self, SubtreePool *pool, const TSLanguage *langu
// Assign all of the node's properties that depend on its children.
void ts_subtree_summarize_children(
MutableSubtree self,
const TSLanguage *language
const t_language *language
) {
assert(!self.data.is_inline);
@ -384,7 +384,7 @@ void ts_subtree_summarize_children(
self.ptr->dynamic_precedence = 0;
uint32_t structural_index = 0;
const TSSymbol *alias_sequence = ts_language_alias_sequence(language, self.ptr->production_id);
const t_symbol *alias_sequence = ts_language_alias_sequence(language, self.ptr->production_id);
uint32_t lookahead_end_byte = 0;
const Subtree *children = ts_subtree_children(self);
@ -504,10 +504,10 @@ void ts_subtree_summarize_children(
//
// This takes ownership of the children array.
MutableSubtree ts_subtree_new_node(
TSSymbol symbol,
t_symbol symbol,
SubtreeArray *children,
unsigned production_id,
const TSLanguage *language
const t_language *language
) {
TSSymbolMetadata metadata = ts_language_symbol_metadata(language, symbol);
bool fragile = symbol == ts_builtin_sym_error || symbol == ts_builtin_sym_error_repeat;
@ -549,7 +549,7 @@ MutableSubtree ts_subtree_new_node(
Subtree ts_subtree_new_error_node(
SubtreeArray *children,
bool extra,
const TSLanguage *language
const t_language *language
) {
MutableSubtree result = ts_subtree_new_node(
ts_builtin_sym_error, children, 0, language
@ -564,10 +564,10 @@ Subtree ts_subtree_new_error_node(
// having any effect on the parse state.
Subtree ts_subtree_new_missing_leaf(
SubtreePool *pool,
TSSymbol symbol,
t_symbol symbol,
Length padding,
uint32_t lookahead_bytes,
const TSLanguage *language
const t_language *language
) {
Subtree result = ts_subtree_new_leaf(
pool, symbol, padding, length_zero(), lookahead_bytes,
@ -656,7 +656,7 @@ static inline void ts_subtree_set_has_changes(MutableSubtree *self) {
}
}
Subtree ts_subtree_edit(Subtree self, const TSInputEdit *input_edit, SubtreePool *pool) {
Subtree ts_subtree_edit(Subtree self, const t_input_edit *input_edit, SubtreePool *pool) {
typedef struct {
Subtree *tree;
Edit edit;
@ -847,8 +847,8 @@ static const char *const ROOT_FIELD = "__ROOT__";
static size_t ts_subtree__write_to_string(
Subtree self, char *string, size_t limit,
const TSLanguage *language, bool include_all,
TSSymbol alias_symbol, bool alias_is_named, const char *field_name
const t_language *language, bool include_all,
t_symbol alias_symbol, bool alias_is_named, const char *field_name
) {
if (!self.ptr) return snprintf(string, limit, "(NULL)");
@ -876,7 +876,7 @@ static size_t ts_subtree__write_to_string(
cursor += snprintf(*writer, limit, "(UNEXPECTED ");
cursor += ts_subtree__write_char_to_string(*writer, limit, self.ptr->lookahead_char);
} else {
TSSymbol symbol = alias_symbol ? alias_symbol : ts_subtree_symbol(self);
t_symbol symbol = alias_symbol ? alias_symbol : ts_subtree_symbol(self);
const char *symbol_name = ts_language_symbol_name(language, symbol);
if (ts_subtree_missing(self)) {
cursor += snprintf(*writer, limit, "(MISSING ");
@ -890,7 +890,7 @@ static size_t ts_subtree__write_to_string(
}
}
} else if (is_root) {
TSSymbol symbol = alias_symbol ? alias_symbol : ts_subtree_symbol(self);
t_symbol symbol = alias_symbol ? alias_symbol : ts_subtree_symbol(self);
const char *symbol_name = ts_language_symbol_name(language, symbol);
if (ts_subtree_child_count(self) > 0) {
cursor += snprintf(*writer, limit, "(%s", symbol_name);
@ -902,7 +902,7 @@ static size_t ts_subtree__write_to_string(
}
if (ts_subtree_child_count(self)) {
const TSSymbol *alias_sequence = ts_language_alias_sequence(language, self.ptr->production_id);
const t_symbol *alias_sequence = ts_language_alias_sequence(language, self.ptr->production_id);
const TSFieldMapEntry *field_map, *field_map_end;
ts_language_field_map(
language,
@ -921,7 +921,7 @@ static size_t ts_subtree__write_to_string(
0, false, NULL
);
} else {
TSSymbol subtree_alias_symbol = alias_sequence
t_symbol subtree_alias_symbol = alias_sequence
? alias_sequence[structural_child_index]
: 0;
bool subtree_alias_is_named = subtree_alias_symbol
@ -953,9 +953,9 @@ static size_t ts_subtree__write_to_string(
char *ts_subtree_string(
Subtree self,
TSSymbol alias_symbol,
t_symbol alias_symbol,
bool alias_is_named,
const TSLanguage *language,
const t_language *language,
bool include_all
) {
char scratch_string[1];
@ -974,10 +974,10 @@ char *ts_subtree_string(
}
void ts_subtree__print_dot_graph(const Subtree *self, uint32_t start_offset,
const TSLanguage *language, TSSymbol alias_symbol,
const t_language *language, t_symbol alias_symbol,
FILE *f) {
TSSymbol subtree_symbol = ts_subtree_symbol(*self);
TSSymbol symbol = alias_symbol ? alias_symbol : subtree_symbol;
t_symbol subtree_symbol = ts_subtree_symbol(*self);
t_symbol symbol = alias_symbol ? alias_symbol : subtree_symbol;
uint32_t end_offset = start_offset + ts_subtree_total_bytes(*self);
fprintf(f, "tree_%p [label=\"", (void *)self);
ts_language_write_symbol_as_dot_string(language, f, symbol);
@ -1017,7 +1017,7 @@ void ts_subtree__print_dot_graph(const Subtree *self, uint32_t start_offset,
ts_subtree_production_id(*self);
for (uint32_t i = 0, n = ts_subtree_child_count(*self); i < n; i++) {
const Subtree *child = &ts_subtree_children(*self)[i];
TSSymbol subtree_alias_symbol = 0;
t_symbol subtree_alias_symbol = 0;
if (!ts_subtree_extra(*child) && child_info_offset) {
subtree_alias_symbol = language->alias_sequences[child_info_offset];
child_info_offset++;
@ -1028,7 +1028,7 @@ void ts_subtree__print_dot_graph(const Subtree *self, uint32_t start_offset,
}
}
void ts_subtree_print_dot_graph(Subtree self, const TSLanguage *language, FILE *f) {
void ts_subtree_print_dot_graph(Subtree self, const t_language *language, FILE *f) {
fprintf(f, "digraph tree {\n");
fprintf(f, "edge [arrowhead=none]\n");
ts_subtree__print_dot_graph(&self, 0, language, 0, f);

42
parser/src/subtree.h
View file

@ -115,8 +115,8 @@ typedef struct {
uint32_t lookahead_bytes;
uint32_t error_cost;
uint32_t child_count;
TSSymbol symbol;
TSStateId parse_state;
t_symbol symbol;
t_state_id parse_state;
bool visible : 1;
bool named : 1;
@ -140,8 +140,8 @@ typedef struct {
uint16_t repeat_depth;
uint16_t production_id;
struct {
TSSymbol symbol;
TSStateId parse_state;
t_symbol symbol;
t_state_id parse_state;
} first_leaf;
};
@ -188,40 +188,40 @@ SubtreePool ts_subtree_pool_new(uint32_t capacity);
void ts_subtree_pool_delete(SubtreePool *);
Subtree ts_subtree_new_leaf(
SubtreePool *, TSSymbol, Length, Length, uint32_t,
TSStateId, bool, bool, bool, const TSLanguage *
SubtreePool *, t_symbol, Length, Length, uint32_t,
t_state_id, bool, bool, bool, const t_language *
);
Subtree ts_subtree_new_error(
SubtreePool *, int32_t, Length, Length, uint32_t, TSStateId, const TSLanguage *
SubtreePool *, int32_t, Length, Length, uint32_t, t_state_id, const t_language *
);
MutableSubtree ts_subtree_new_node(TSSymbol, SubtreeArray *, unsigned, const TSLanguage *);
Subtree ts_subtree_new_error_node(SubtreeArray *, bool, const TSLanguage *);
Subtree ts_subtree_new_missing_leaf(SubtreePool *, TSSymbol, Length, uint32_t, const TSLanguage *);
MutableSubtree ts_subtree_new_node(t_symbol, SubtreeArray *, unsigned, const t_language *);
Subtree ts_subtree_new_error_node(SubtreeArray *, bool, const t_language *);
Subtree ts_subtree_new_missing_leaf(SubtreePool *, t_symbol, Length, uint32_t, const t_language *);
MutableSubtree ts_subtree_make_mut(SubtreePool *, Subtree);
void ts_subtree_retain(Subtree);
void ts_subtree_release(SubtreePool *, Subtree);
int ts_subtree_compare(Subtree, Subtree, SubtreePool *);
void ts_subtree_set_symbol(MutableSubtree *, TSSymbol, const TSLanguage *);
void ts_subtree_summarize(MutableSubtree, const Subtree *, uint32_t, const TSLanguage *);
void ts_subtree_summarize_children(MutableSubtree, const TSLanguage *);
void ts_subtree_balance(Subtree, SubtreePool *, const TSLanguage *);
Subtree ts_subtree_edit(Subtree, const TSInputEdit *edit, SubtreePool *);
char *ts_subtree_string(Subtree, TSSymbol, bool, const TSLanguage *, bool include_all);
void ts_subtree_print_dot_graph(Subtree, const TSLanguage *, FILE *);
void ts_subtree_set_symbol(MutableSubtree *, t_symbol, const t_language *);
void ts_subtree_summarize(MutableSubtree, const Subtree *, uint32_t, const t_language *);
void ts_subtree_summarize_children(MutableSubtree, const t_language *);
void ts_subtree_balance(Subtree, SubtreePool *, const t_language *);
Subtree ts_subtree_edit(Subtree, const t_input_edit *edit, SubtreePool *);
char *ts_subtree_string(Subtree, t_symbol, bool, const t_language *, bool include_all);
void ts_subtree_print_dot_graph(Subtree, const t_language *, FILE *);
Subtree ts_subtree_last_external_token(Subtree);
const ExternalScannerState *ts_subtree_external_scanner_state(Subtree self);
bool ts_subtree_external_scanner_state_eq(Subtree, Subtree);
#define SUBTREE_GET(self, name) ((self).data.is_inline ? (self).data.name : (self).ptr->name)
static inline TSSymbol ts_subtree_symbol(Subtree self) { return SUBTREE_GET(self, symbol); }
static inline t_symbol ts_subtree_symbol(Subtree self) { return SUBTREE_GET(self, symbol); }
static inline bool ts_subtree_visible(Subtree self) { return SUBTREE_GET(self, visible); }
static inline bool ts_subtree_named(Subtree self) { return SUBTREE_GET(self, named); }
static inline bool ts_subtree_extra(Subtree self) { return SUBTREE_GET(self, extra); }
static inline bool ts_subtree_has_changes(Subtree self) { return SUBTREE_GET(self, has_changes); }
static inline bool ts_subtree_missing(Subtree self) { return SUBTREE_GET(self, is_missing); }
static inline bool ts_subtree_is_keyword(Subtree self) { return SUBTREE_GET(self, is_keyword); }
static inline TSStateId ts_subtree_parse_state(Subtree self) { return SUBTREE_GET(self, parse_state); }
static inline t_state_id ts_subtree_parse_state(Subtree self) { return SUBTREE_GET(self, parse_state); }
static inline uint32_t ts_subtree_lookahead_bytes(Subtree self) { return SUBTREE_GET(self, lookahead_bytes); }
#undef SUBTREE_GET
@ -245,13 +245,13 @@ static inline void ts_subtree_set_extra(MutableSubtree *self, bool is_extra) {
}
}
static inline TSSymbol ts_subtree_leaf_symbol(Subtree self) {
static inline t_symbol ts_subtree_leaf_symbol(Subtree self) {
if (self.data.is_inline) return self.data.symbol;
if (self.ptr->child_count == 0) return self.ptr->symbol;
return self.ptr->first_leaf.symbol;
}
static inline TSStateId ts_subtree_leaf_parse_state(Subtree self) {
static inline t_state_id ts_subtree_leaf_parse_state(Subtree self) {
if (self.data.is_inline) return self.data.parse_state;
if (self.ptr->child_count == 0) return self.ptr->parse_state;
return self.ptr->first_leaf.parse_state;

42
parser/src/tree.c
View file

@ -8,25 +8,25 @@
#include "./tree_cursor.h"
#include "./tree.h"
TSTree *ts_tree_new(
Subtree root, const TSLanguage *language,
const TSRange *included_ranges, unsigned included_range_count
t_tree *ts_tree_new(
Subtree root, const t_language *language,
const t_range *included_ranges, unsigned included_range_count
) {
TSTree *result = ts_malloc(sizeof(TSTree));
t_tree *result = ts_malloc(sizeof(t_tree));
result->root = root;
result->language = ts_language_copy(language);
result->included_ranges = ts_calloc(included_range_count, sizeof(TSRange));
memcpy(result->included_ranges, included_ranges, included_range_count * sizeof(TSRange));
result->included_ranges = ts_calloc(included_range_count, sizeof(t_range));
memcpy(result->included_ranges, included_ranges, included_range_count * sizeof(t_range));
result->included_range_count = included_range_count;
return result;
}
TSTree *ts_tree_copy(const TSTree *self) {
t_tree *ts_tree_copy(const t_tree *self) {
ts_subtree_retain(self->root);
return ts_tree_new(self->root, self->language, self->included_ranges, self->included_range_count);
}
void ts_tree_delete(TSTree *self) {
void ts_tree_delete(t_tree *self) {
if (!self) return;
SubtreePool pool = ts_subtree_pool_new(0);
@ -37,26 +37,26 @@ void ts_tree_delete(TSTree *self) {
ts_free(self);
}
TSNode ts_tree_root_node(const TSTree *self) {
t_parse_node ts_tree_root_node(const t_tree *self) {
return ts_node_new(self, &self->root, ts_subtree_padding(self->root), 0);
}
TSNode ts_tree_root_node_with_offset(
const TSTree *self,
t_parse_node ts_tree_root_node_with_offset(
const t_tree *self,
uint32_t offset_bytes,
TSPoint offset_extent
t_point offset_extent
) {
Length offset = {offset_bytes, offset_extent};
return ts_node_new(self, &self->root, length_add(offset, ts_subtree_padding(self->root)), 0);
}
const TSLanguage *ts_tree_language(const TSTree *self) {
const t_language *ts_tree_language(const t_tree *self) {
return self->language;
}
void ts_tree_edit(TSTree *self, const TSInputEdit *edit) {
void ts_tree_edit(t_tree *self, const t_input_edit *edit) {
for (unsigned i = 0; i < self->included_range_count; i++) {
TSRange *range = &self->included_ranges[i];
t_range *range = &self->included_ranges[i];
if (range->end_byte >= edit->old_end_byte) {
if (range->end_byte != UINT32_MAX) {
range->end_byte = edit->new_end_byte + (range->end_byte - edit->old_end_byte);
@ -94,14 +94,14 @@ void ts_tree_edit(TSTree *self, const TSInputEdit *edit) {
ts_subtree_pool_delete(&pool);
}
TSRange *ts_tree_included_ranges(const TSTree *self, uint32_t *length) {
t_range *ts_tree_included_ranges(const t_tree *self, uint32_t *length) {
*length = self->included_range_count;
TSRange *ranges = ts_calloc(self->included_range_count, sizeof(TSRange));
memcpy(ranges, self->included_ranges, self->included_range_count * sizeof(TSRange));
t_range *ranges = ts_calloc(self->included_range_count, sizeof(t_range));
memcpy(ranges, self->included_ranges, self->included_range_count * sizeof(t_range));
return ranges;
}
TSRange *ts_tree_get_changed_ranges(const TSTree *old_tree, const TSTree *new_tree, uint32_t *length) {
t_range *ts_tree_get_changed_ranges(const t_tree *old_tree, const t_tree *new_tree, uint32_t *length) {
TreeCursor cursor1 = {NULL, array_new(), 0};
TreeCursor cursor2 = {NULL, array_new(), 0};
ts_tree_cursor_init(&cursor1, ts_tree_root_node(old_tree));
@ -114,7 +114,7 @@ TSRange *ts_tree_get_changed_ranges(const TSTree *old_tree, const TSTree *new_tr
&included_range_differences
);
TSRange *result;
t_range *result;
*length = ts_subtree_get_changed_ranges(
&old_tree->root, &new_tree->root, &cursor1, &cursor2,
old_tree->language, &included_range_differences, &result
@ -156,7 +156,7 @@ int _ts_dup(int file_descriptor) {
return dup(file_descriptor);
}
void ts_tree_print_dot_graph(const TSTree *self, int file_descriptor) {
void ts_tree_print_dot_graph(const t_tree *self, int file_descriptor) {
FILE *file = fdopen(_ts_dup(file_descriptor), "a");
ts_subtree_print_dot_graph(self->root, self->language, file);
fclose(file);

12
parser/src/tree.h
View file

@ -11,18 +11,18 @@ typedef struct {
const Subtree *child;
const Subtree *parent;
Length position;
TSSymbol alias_symbol;
t_symbol alias_symbol;
} ParentCacheEntry;
struct TSTree {
struct t_tree {
Subtree root;
const TSLanguage *language;
TSRange *included_ranges;
const t_language *language;
t_range *included_ranges;
unsigned included_range_count;
};
TSTree *ts_tree_new(Subtree root, const TSLanguage *language, const TSRange *, unsigned);
TSNode ts_node_new(const TSTree *, const Subtree *, Length, TSSymbol);
t_tree *ts_tree_new(Subtree root, const t_language *language, const t_range *, unsigned);
t_parse_node ts_node_new(const t_tree *, const Subtree *, Length, t_symbol);
#ifdef __cplusplus
}

80
parser/src/tree_cursor.c
View file

@ -6,12 +6,12 @@
typedef struct {
Subtree parent;
const TSTree *tree;
const t_tree *tree;
Length position;
uint32_t child_index;
uint32_t structural_child_index;
uint32_t descendant_index;
const TSSymbol *alias_sequence;
const t_symbol *alias_sequence;
} CursorChildIterator;
// CursorChildIterator
@ -37,7 +37,7 @@ static inline CursorChildIterator ts_tree_cursor_iterate_children(const TreeCurs
if (ts_subtree_child_count(*last_entry->subtree) == 0) {
return (CursorChildIterator) {NULL_SUBTREE, self->tree, length_zero(), 0, 0, 0, NULL};
}
const TSSymbol *alias_sequence = ts_language_alias_sequence(
const t_symbol *alias_sequence = ts_language_alias_sequence(
self->tree->language,
last_entry->subtree->ptr->production_id
);
@ -150,17 +150,17 @@ static inline bool ts_tree_cursor_child_iterator_previous(
// TSTreeCursor - lifecycle
TSTreeCursor ts_tree_cursor_new(TSNode node) {
TSTreeCursor self = {NULL, NULL, {0, 0, 0}};
t_tree_cursor ts_tree_cursor_new(t_parse_node node) {
t_tree_cursor self = {NULL, NULL, {0, 0, 0}};
ts_tree_cursor_init((TreeCursor *)&self, node);
return self;
}
void ts_tree_cursor_reset(TSTreeCursor *_self, TSNode node) {
void ts_tree_cursor_reset(t_tree_cursor *_self, t_parse_node node) {
ts_tree_cursor_init((TreeCursor *)_self, node);
}
void ts_tree_cursor_init(TreeCursor *self, TSNode node) {
void ts_tree_cursor_init(TreeCursor *self, t_parse_node node) {
self->tree = node.tree;
self->root_alias_symbol = node.context[3];
array_clear(&self->stack);
@ -176,14 +176,14 @@ void ts_tree_cursor_init(TreeCursor *self, TSNode node) {
}));
}
void ts_tree_cursor_delete(TSTreeCursor *_self) {
void ts_tree_cursor_delete(t_tree_cursor *_self) {
TreeCursor *self = (TreeCursor *)_self;
array_delete(&self->stack);
}
// TSTreeCursor - walking the tree
TreeCursorStep ts_tree_cursor_goto_first_child_internal(TSTreeCursor *_self) {
TreeCursorStep ts_tree_cursor_goto_first_child_internal(t_tree_cursor *_self) {
TreeCursor *self = (TreeCursor *)_self;
bool visible;
TreeCursorEntry entry;
@ -201,7 +201,7 @@ TreeCursorStep ts_tree_cursor_goto_first_child_internal(TSTreeCursor *_self) {
return TreeCursorStepNone;
}
bool ts_tree_cursor_goto_first_child(TSTreeCursor *self) {
bool ts_tree_cursor_goto_first_child(t_tree_cursor *self) {
for (;;) {
switch (ts_tree_cursor_goto_first_child_internal(self)) {
case TreeCursorStepHidden:
@ -215,7 +215,7 @@ bool ts_tree_cursor_goto_first_child(TSTreeCursor *self) {
return false;
}
TreeCursorStep ts_tree_cursor_goto_last_child_internal(TSTreeCursor *_self) {
TreeCursorStep ts_tree_cursor_goto_last_child_internal(t_tree_cursor *_self) {
TreeCursor *self = (TreeCursor *)_self;
bool visible;
TreeCursorEntry entry;
@ -242,7 +242,7 @@ TreeCursorStep ts_tree_cursor_goto_last_child_internal(TSTreeCursor *_self) {
return TreeCursorStepNone;
}
bool ts_tree_cursor_goto_last_child(TSTreeCursor *self) {
bool ts_tree_cursor_goto_last_child(t_tree_cursor *self) {
for (;;) {
switch (ts_tree_cursor_goto_last_child_internal(self)) {
case TreeCursorStepHidden:
@ -257,9 +257,9 @@ bool ts_tree_cursor_goto_last_child(TSTreeCursor *self) {
}
static inline int64_t ts_tree_cursor_goto_first_child_for_byte_and_point(
TSTreeCursor *_self,
t_tree_cursor *_self,
uint32_t goal_byte,
TSPoint goal_point
t_point goal_point
) {
TreeCursor *self = (TreeCursor *)_self;
uint32_t initial_size = self->stack.size;
@ -298,16 +298,16 @@ static inline int64_t ts_tree_cursor_goto_first_child_for_byte_and_point(
return -1;
}
int64_t ts_tree_cursor_goto_first_child_for_byte(TSTreeCursor *self, uint32_t goal_byte) {
int64_t ts_tree_cursor_goto_first_child_for_byte(t_tree_cursor *self, uint32_t goal_byte) {
return ts_tree_cursor_goto_first_child_for_byte_and_point(self, goal_byte, POINT_ZERO);
}
int64_t ts_tree_cursor_goto_first_child_for_point(TSTreeCursor *self, TSPoint goal_point) {
int64_t ts_tree_cursor_goto_first_child_for_point(t_tree_cursor *self, t_point goal_point) {
return ts_tree_cursor_goto_first_child_for_byte_and_point(self, 0, goal_point);
}
TreeCursorStep ts_tree_cursor_goto_sibling_internal(
TSTreeCursor *_self,
t_tree_cursor *_self,
bool (*advance)(CursorChildIterator *, TreeCursorEntry *, bool *)) {
TreeCursor *self = (TreeCursor *)_self;
uint32_t initial_size = self->stack.size;
@ -341,11 +341,11 @@ TreeCursorStep ts_tree_cursor_goto_sibling_internal(
return TreeCursorStepNone;
}
TreeCursorStep ts_tree_cursor_goto_next_sibling_internal(TSTreeCursor *_self) {
TreeCursorStep ts_tree_cursor_goto_next_sibling_internal(t_tree_cursor *_self) {
return ts_tree_cursor_goto_sibling_internal(_self, ts_tree_cursor_child_iterator_next);
}
bool ts_tree_cursor_goto_next_sibling(TSTreeCursor *self) {
bool ts_tree_cursor_goto_next_sibling(t_tree_cursor *self) {
switch (ts_tree_cursor_goto_next_sibling_internal(self)) {
case TreeCursorStepHidden:
ts_tree_cursor_goto_first_child(self);
@ -357,7 +357,7 @@ bool ts_tree_cursor_goto_next_sibling(TSTreeCursor *self) {
}
}
TreeCursorStep ts_tree_cursor_goto_previous_sibling_internal(TSTreeCursor *_self) {
TreeCursorStep ts_tree_cursor_goto_previous_sibling_internal(t_tree_cursor *_self) {
// since subtracting across row loses column information, we may have to
// restore it
TreeCursor *self = (TreeCursor *)_self;
@ -392,7 +392,7 @@ TreeCursorStep ts_tree_cursor_goto_previous_sibling_internal(TSTreeCursor *_self
return step;
}
bool ts_tree_cursor_goto_previous_sibling(TSTreeCursor *self) {
bool ts_tree_cursor_goto_previous_sibling(t_tree_cursor *self) {
switch (ts_tree_cursor_goto_previous_sibling_internal(self)) {
case TreeCursorStepHidden:
ts_tree_cursor_goto_last_child(self);
@ -404,7 +404,7 @@ bool ts_tree_cursor_goto_previous_sibling(TSTreeCursor *self) {
}
}
bool ts_tree_cursor_goto_parent(TSTreeCursor *_self) {
bool ts_tree_cursor_goto_parent(t_tree_cursor *_self) {
TreeCursor *self = (TreeCursor *)_self;
for (unsigned i = self->stack.size - 2; i + 1 > 0; i--) {
if (ts_tree_cursor_is_entry_visible(self, i)) {
@ -416,7 +416,7 @@ bool ts_tree_cursor_goto_parent(TSTreeCursor *_self) {
}
void ts_tree_cursor_goto_descendant(
TSTreeCursor *_self,
t_tree_cursor *_self,
uint32_t goal_descendant_index
) {
TreeCursor *self = (TreeCursor *)_self;
@ -466,16 +466,16 @@ void ts_tree_cursor_goto_descendant(
} while (did_descend);
}
uint32_t ts_tree_cursor_current_descendant_index(const TSTreeCursor *_self) {
uint32_t ts_tree_cursor_current_descendant_index(const t_tree_cursor *_self) {
const TreeCursor *self = (const TreeCursor *)_self;
TreeCursorEntry *last_entry = array_back(&self->stack);
return last_entry->descendant_index;
}
TSNode ts_tree_cursor_current_node(const TSTreeCursor *_self) {
t_parse_node ts_tree_cursor_current_node(const t_tree_cursor *_self) {
const TreeCursor *self = (const TreeCursor *)_self;
TreeCursorEntry *last_entry = array_back(&self->stack);
TSSymbol alias_symbol = self->root_alias_symbol;
t_symbol alias_symbol = self->root_alias_symbol;
if (self->stack.size > 1 && !ts_subtree_extra(*last_entry->subtree)) {
TreeCursorEntry *parent_entry = &self->stack.contents[self->stack.size - 2];
alias_symbol = ts_language_alias_at(
@ -495,12 +495,12 @@ TSNode ts_tree_cursor_current_node(const TSTreeCursor *_self) {
// Private - Get various facts about the current node that are needed
// when executing tree queries.
void ts_tree_cursor_current_status(
const TSTreeCursor *_self,
TSFieldId *field_id,
const t_tree_cursor *_self,
t_field_id *field_id,
bool *has_later_siblings,
bool *has_later_named_siblings,
bool *can_have_later_siblings_with_this_field,
TSSymbol *supertypes,
t_symbol *supertypes,
unsigned *supertype_count
) {
const TreeCursor *self = (const TreeCursor *)_self;
@ -517,7 +517,7 @@ void ts_tree_cursor_current_status(
TreeCursorEntry *entry = &self->stack.contents[i];
TreeCursorEntry *parent_entry = &self->stack.contents[i - 1];
const TSSymbol *alias_sequence = ts_language_alias_sequence(
const t_symbol *alias_sequence = ts_language_alias_sequence(
self->tree->language,
parent_entry->subtree->ptr->production_id
);
@ -532,7 +532,7 @@ void ts_tree_cursor_current_status(
ts_subtree_symbol(subtree))
// Stop walking up when a visible ancestor is found.
TSSymbol entry_symbol = subtree_symbol(
t_symbol entry_symbol = subtree_symbol(
*entry->subtree,
entry->structural_child_index
);
@ -614,7 +614,7 @@ void ts_tree_cursor_current_status(
}
}
uint32_t ts_tree_cursor_current_depth(const TSTreeCursor *_self) {
uint32_t ts_tree_cursor_current_depth(const t_tree_cursor *_self) {
const TreeCursor *self = (const TreeCursor *)_self;
uint32_t depth = 0;
for (unsigned i = 1; i < self->stack.size; i++) {
@ -625,12 +625,12 @@ uint32_t ts_tree_cursor_current_depth(const TSTreeCursor *_self) {
return depth;
}
TSNode ts_tree_cursor_parent_node(const TSTreeCursor *_self) {
t_parse_node ts_tree_cursor_parent_node(const t_tree_cursor *_self) {
const TreeCursor *self = (const TreeCursor *)_self;
for (int i = (int)self->stack.size - 2; i >= 0; i--) {
TreeCursorEntry *entry = &self->stack.contents[i];
bool is_visible = true;
TSSymbol alias_symbol = 0;
t_symbol alias_symbol = 0;
if (i > 0) {
TreeCursorEntry *parent_entry = &self->stack.contents[i - 1];
alias_symbol = ts_language_alias_at(
@ -652,7 +652,7 @@ TSNode ts_tree_cursor_parent_node(const TSTreeCursor *_self) {
return ts_node_new(NULL, NULL, length_zero(), 0);
}
TSFieldId ts_tree_cursor_current_field_id(const TSTreeCursor *_self) {
t_field_id ts_tree_cursor_current_field_id(const t_tree_cursor *_self) {
const TreeCursor *self = (const TreeCursor *)_self;
// Walk up the tree, visiting the current node and its invisible ancestors.
@ -683,8 +683,8 @@ TSFieldId ts_tree_cursor_current_field_id(const TSTreeCursor *_self) {
return 0;
}
const char *ts_tree_cursor_current_field_name(const TSTreeCursor *_self) {
TSFieldId id = ts_tree_cursor_current_field_id(_self);
const char *ts_tree_cursor_current_field_name(const t_tree_cursor *_self) {
t_field_id id = ts_tree_cursor_current_field_id(_self);
if (id) {
const TreeCursor *self = (const TreeCursor *)_self;
return self->tree->language->field_names[id];
@ -693,9 +693,9 @@ const char *ts_tree_cursor_current_field_name(const TSTreeCursor *_self) {
}
}
TSTreeCursor ts_tree_cursor_copy(const TSTreeCursor *_cursor) {
t_tree_cursor ts_tree_cursor_copy(const t_tree_cursor *_cursor) {
const TreeCursor *cursor = (const TreeCursor *)_cursor;
TSTreeCursor res = {NULL, NULL, {0, 0}};
t_tree_cursor res = {NULL, NULL, {0, 0}};
TreeCursor *copy = (TreeCursor *)&res;
copy->tree = cursor->tree;
copy->root_alias_symbol = cursor->root_alias_symbol;
@ -704,7 +704,7 @@ TSTreeCursor ts_tree_cursor_copy(const TSTreeCursor *_cursor) {
return res;
}
void ts_tree_cursor_reset_to(TSTreeCursor *_dst, const TSTreeCursor *_src) {
void ts_tree_cursor_reset_to(t_tree_cursor *_dst, const t_tree_cursor *_src) {
const TreeCursor *cursor = (const TreeCursor *)_src;
TreeCursor *copy = (TreeCursor *)_dst;
copy->tree = cursor->tree;

20
parser/src/tree_cursor.h
View file

@ -12,9 +12,9 @@ typedef struct {
} TreeCursorEntry;
typedef struct {
const TSTree *tree;
const t_tree *tree;
Array(TreeCursorEntry) stack;
TSSymbol root_alias_symbol;
t_symbol root_alias_symbol;
} TreeCursor;
typedef enum {
@ -23,26 +23,26 @@ typedef enum {
TreeCursorStepVisible,
} TreeCursorStep;
void ts_tree_cursor_init(TreeCursor *, TSNode);
void ts_tree_cursor_init(TreeCursor *, t_parse_node);
void ts_tree_cursor_current_status(
const TSTreeCursor *,
TSFieldId *,
const t_tree_cursor *,
t_field_id *,
bool *,
bool *,
bool *,
TSSymbol *,
t_symbol *,
unsigned *
);
TreeCursorStep ts_tree_cursor_goto_first_child_internal(TSTreeCursor *);
TreeCursorStep ts_tree_cursor_goto_next_sibling_internal(TSTreeCursor *);
TreeCursorStep ts_tree_cursor_goto_first_child_internal(t_tree_cursor *);
TreeCursorStep ts_tree_cursor_goto_next_sibling_internal(t_tree_cursor *);
static inline Subtree ts_tree_cursor_current_subtree(const TSTreeCursor *_self) {
static inline Subtree ts_tree_cursor_current_subtree(const t_tree_cursor *_self) {
const TreeCursor *self = (const TreeCursor *)_self;
TreeCursorEntry *last_entry = array_back(&self->stack);
return *last_entry->subtree;
}
TSNode ts_tree_cursor_parent_node(const TSTreeCursor *);
t_parse_node ts_tree_cursor_parent_node(const t_tree_cursor *);
#endif // TREE_SITTER_TREE_CURSOR_H_