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

Changed types

Browse source
This commit is contained in:
Maix0 2024-07-03 20:10:38 +02:00
parent d609da4e96
commit 634a8762f1
19 changed files with 144 additions and 144 deletions
Download patch file Download diff file Expand all files Collapse all files

24
parser/src/api.h
View file

@ -73,7 +73,7 @@ typedef struct TSRange
typedef struct TSInput typedef struct TSInput
{ {
void *payload; void *payload;
const char *(*read)(void *payload, t_u32 byte_index, TSPoint position, t_u32 *bytes_read); const t_u8 *(*read)(void *payload, t_u32 byte_index, TSPoint position, t_u32 *bytes_read);
TSInputEncoding encoding; TSInputEncoding encoding;
} TSInput; } TSInput;
@ -86,7 +86,7 @@ typedef enum TSLogType
typedef struct TSLogger typedef struct TSLogger
{ {
void *payload; void *payload;
void (*log)(void *payload, TSLogType log_type, const char *buffer); void (*log)(void *payload, TSLogType log_type, const t_u8 *buffer);
} TSLogger; } TSLogger;
typedef struct TSInputEdit typedef struct TSInputEdit
@ -275,7 +275,7 @@ TSTree *ts_parser_parse(TSParser *self, const TSTree *old_tree, TSInput input);
* above. The second two parameters indicate the location of the buffer and its * above. The second two parameters indicate the location of the buffer and its
* length in bytes. * length in bytes.
*/ */
TSTree *ts_parser_parse_string(TSParser *self, const TSTree *old_tree, const char *string, t_u32 length); TSTree *ts_parser_parse_string(TSParser *self, const TSTree *old_tree, t_const_str string, t_u32 length);
/** /**
* Use the parser to parse some source code stored in one contiguous buffer with * Use the parser to parse some source code stored in one contiguous buffer with
@ -283,7 +283,7 @@ TSTree *ts_parser_parse_string(TSParser *self, const TSTree *old_tree, const cha
* [`ts_parser_parse_string`] method above. The final parameter indicates whether * [`ts_parser_parse_string`] method above. The final parameter indicates whether
* the text is encoded as UTF8 or UTF16. * the text is encoded as UTF8 or UTF16.
*/ */
TSTree *ts_parser_parse_string_encoding(TSParser *self, const TSTree *old_tree, const char *string, t_u32 length, TSInputEncoding encoding); TSTree *ts_parser_parse_string_encoding(TSParser *self, const TSTree *old_tree, t_const_str string, t_u32 length, TSInputEncoding encoding);
/** /**
* Instruct the parser to start the next parse from the beginning. * Instruct the parser to start the next parse from the beginning.
@ -423,7 +423,7 @@ void ts_tree_print_dot_graph(const TSTree *self, int file_descriptor);
/** /**
* Get the node's type as a null-terminated string. * Get the node's type as a null-terminated string.
*/ */
const char *ts_node_type(TSNode self); t_const_str ts_node_type(TSNode self);
/** /**
* Get the node's type as a numerical id. * Get the node's type as a numerical id.
@ -439,7 +439,7 @@ const TSLanguage *ts_node_language(TSNode self);
* Get the node's type as it appears in the grammar ignoring aliases as a * Get the node's type as it appears in the grammar ignoring aliases as a
* null-terminated string. * null-terminated string.
*/ */
const char *ts_node_grammar_type(TSNode self); t_const_str ts_node_grammar_type(TSNode self);
/** /**
* Get the node's type as a numerical id as it appears in the grammar ignoring * Get the node's type as a numerical id as it appears in the grammar ignoring
@ -549,7 +549,7 @@ TSNode ts_node_child(TSNode self, t_u32 child_index);
* Get the field name for node's child at the given index, where zero represents * Get the field name for node's child at the given index, where zero represents
* the first child. Returns NULL, if no field is found. * the first child. Returns NULL, if no field is found.
*/ */
const char *ts_node_field_name_for_child(TSNode self, t_u32 child_index); t_const_str ts_node_field_name_for_child(TSNode self, t_u32 child_index);
/** /**
* Get the field name for node's child at the given index, where zero represents * Get the field name for node's child at the given index, where zero represents
@ -579,7 +579,7 @@ t_u32 ts_node_named_child_count(TSNode self);
/** /**
* Get the node's child with the given field name. * Get the node's child with the given field name.
*/ */
TSNode ts_node_child_by_field_name(TSNode self, const char *name, t_u32 name_length); TSNode ts_node_child_by_field_name(TSNode self, t_const_str name, t_u32 name_length);
/** /**
* Get the node's child with the given numerical field id. * Get the node's child with the given numerical field id.
@ -674,12 +674,12 @@ t_u32 ts_language_state_count(const TSLanguage *self);
/** /**
* Get a node type string for the given numerical id. * Get a node type string for the given numerical id.
*/ */
const char *ts_language_symbol_name(const TSLanguage *self, TSSymbol symbol); t_const_str ts_language_symbol_name(const TSLanguage *self, TSSymbol symbol);
/** /**
* Get the numerical id for the given node type string. * Get the numerical id for the given node type string.
*/ */
TSSymbol ts_language_symbol_for_name(const TSLanguage *self, const char *string, t_u32 length, bool is_named); TSSymbol ts_language_symbol_for_name(const TSLanguage *self, t_const_str string, t_u32 length, bool is_named);
/** /**
* Get the number of distinct field names in the language. * Get the number of distinct field names in the language.
@ -689,12 +689,12 @@ t_u32 ts_language_field_count(const TSLanguage *self);
/** /**
* Get the field name string for the given numerical id. * Get the field name string for the given numerical id.
*/ */
const char *ts_language_field_name_for_id(const TSLanguage *self, TSFieldId id); t_const_str ts_language_field_name_for_id(const TSLanguage *self, TSFieldId id);
/** /**
* Get the numerical id for the given field name string. * Get the numerical id for the given field name string.
*/ */
TSFieldId ts_language_field_id_for_name(const TSLanguage *self, const char *name, t_u32 name_length); TSFieldId ts_language_field_id_for_name(const TSLanguage *self, t_const_str name, t_u32 name_length);
/** /**
* Check whether the given node type id belongs to named nodes, anonymous nodes, * Check whether the given node type id belongs to named nodes, anonymous nodes,

4
parser/src/array.h
View file

@ -115,7 +115,7 @@
#define array_insert_sorted_with(self, compare, value) \ #define array_insert_sorted_with(self, compare, value) \
do \ do \
{ \ { \
unsigned _index, _exists; \ t_u32 _index, _exists; \
array_search_sorted_with(self, compare, &(value), &_index, &_exists); \ array_search_sorted_with(self, compare, &(value), &_index, &_exists); \
if (!_exists) \ if (!_exists) \
array_insert(self, _index, value); \ array_insert(self, _index, value); \
@ -128,7 +128,7 @@
#define array_insert_sorted_by(self, field, value) \ #define array_insert_sorted_by(self, field, value) \
do \ do \
{ \ { \
unsigned _index, _exists; \ t_u32 _index, _exists; \
array_search_sorted_by(self, field, (value)field, &_index, &_exists); \ array_search_sorted_by(self, field, (value)field, &_index, &_exists); \
if (!_exists) \ if (!_exists) \
array_insert(self, _index, value); \ array_insert(self, _index, value); \

4
parser/src/create_language.c
View file

@ -36,8 +36,8 @@ void *create_small_parse_table(void);
void *create_small_parse_table_map(void); void *create_small_parse_table_map(void);
bool ts_lex_keywords(TSLexer *lexer, TSStateId state); bool ts_lex_keywords(TSLexer *lexer, TSStateId state);
bool ts_lex(TSLexer *lexer, TSStateId state); bool ts_lex(TSLexer *lexer, TSStateId state);
t_u32 tree_sitter_sh_external_scanner_serialize(void *ctx, char *s); t_u32 tree_sitter_sh_external_scanner_serialize(void *ctx, t_u8 *state);
void tree_sitter_sh_external_scanner_deserialize(void *ctx, const char *s, t_u32 val); void tree_sitter_sh_external_scanner_deserialize(void *ctx, const t_u8 *state, t_u32 val);
void tree_sitter_sh_external_scanner_destroy(void *ctx); void tree_sitter_sh_external_scanner_destroy(void *ctx);
void *tree_sitter_sh_external_scanner_create(void); void *tree_sitter_sh_external_scanner_create(void);

12
parser/src/language.c
View file

@ -102,7 +102,7 @@ TSStateId ts_language_next_state(const TSLanguage *self, TSStateId state, TSSymb
} }
} }
const char *ts_language_symbol_name(const TSLanguage *self, TSSymbol symbol) t_const_str ts_language_symbol_name(const TSLanguage *self, TSSymbol symbol)
{ {
if (symbol == ts_builtin_sym_error) if (symbol == ts_builtin_sym_error)
{ {
@ -122,7 +122,7 @@ const char *ts_language_symbol_name(const TSLanguage *self, TSSymbol symbol)
} }
} }
TSSymbol ts_language_symbol_for_name(const TSLanguage *self, const char *string, t_u32 length, bool is_named) TSSymbol ts_language_symbol_for_name(const TSLanguage *self, t_const_str string, t_u32 length, bool is_named)
{ {
if (!strncmp(string, "ERROR", length)) if (!strncmp(string, "ERROR", length))
return ts_builtin_sym_error; return ts_builtin_sym_error;
@ -132,7 +132,7 @@ TSSymbol ts_language_symbol_for_name(const TSLanguage *self, const char *string,
TSSymbolMetadata metadata = ts_language_symbol_metadata(self, i); TSSymbolMetadata metadata = ts_language_symbol_metadata(self, i);
if ((!metadata.visible && !metadata.supertype) || metadata.named != is_named) if ((!metadata.visible && !metadata.supertype) || metadata.named != is_named)
continue; continue;
const char *symbol_name = self->symbol_names[i]; t_const_str symbol_name = self->symbol_names[i];
if (!strncmp(symbol_name, string, length) && !symbol_name[length]) if (!strncmp(symbol_name, string, length) && !symbol_name[length])
{ {
return self->public_symbol_map[i]; return self->public_symbol_map[i];
@ -158,7 +158,7 @@ TSSymbolType ts_language_symbol_type(const TSLanguage *self, TSSymbol symbol)
} }
} }
const char *ts_language_field_name_for_id(const TSLanguage *self, TSFieldId id) t_const_str ts_language_field_name_for_id(const TSLanguage *self, TSFieldId id)
{ {
t_u32 count = ts_language_field_count(self); t_u32 count = ts_language_field_count(self);
if (count && id <= count) if (count && id <= count)
@ -171,7 +171,7 @@ const char *ts_language_field_name_for_id(const TSLanguage *self, TSFieldId id)
} }
} }
TSFieldId ts_language_field_id_for_name(const TSLanguage *self, const char *name, t_u32 name_length) TSFieldId ts_language_field_id_for_name(const TSLanguage *self, t_const_str name, t_u32 name_length)
{ {
t_u16 count = (t_u16)ts_language_field_count(self); t_u16 count = (t_u16)ts_language_field_count(self);
for (TSSymbol i = 1; i < count + 1; i++) for (TSSymbol i = 1; i < count + 1; i++)
@ -231,7 +231,7 @@ TSFieldId ts_language_field_id_for_name(const TSLanguage *self, const char *name
// return iterator->symbol; // return iterator->symbol;
// } // }
// const char *ts_lookahead_iterator_current_symbol_name(const TSLookaheadIterator *self) { // t_const_str ts_lookahead_iterator_current_symbol_name(const TSLookaheadIterator *self) {
// const LookaheadIterator *iterator = (const LookaheadIterator *)self; // const LookaheadIterator *iterator = (const LookaheadIterator *)self;
// return ts_language_symbol_name(iterator->language, iterator->symbol); // return ts_language_symbol_name(iterator->language, iterator->symbol);
// } // }

8
parser/src/language.h
View file

@ -58,11 +58,11 @@ static inline t_u16 ts_language_lookup(const TSLanguage *self, TSStateId state,
t_u32 index = self->small_parse_table_map[state - self->large_state_count]; t_u32 index = self->small_parse_table_map[state - self->large_state_count];
const t_u16 *data = &self->small_parse_table[index]; const t_u16 *data = &self->small_parse_table[index];
t_u16 group_count = *(data++); t_u16 group_count = *(data++);
for (unsigned i = 0; i < group_count; i++) for (t_u32 i = 0; i < group_count; i++)
{ {
t_u16 section_value = *(data++); t_u16 section_value = *(data++);
t_u16 symbol_count = *(data++); t_u16 symbol_count = *(data++);
for (unsigned j = 0; j < symbol_count; j++) for (t_u32 j = 0; j < symbol_count; j++)
{ {
if (*(data++) == symbol) if (*(data++) == symbol)
return section_value; return section_value;
@ -81,7 +81,7 @@ static inline bool ts_language_has_actions(const TSLanguage *self, TSStateId sta
return ts_language_lookup(self, state, symbol) != 0; return ts_language_lookup(self, state, symbol) != 0;
} }
static inline const bool *ts_language_enabled_external_tokens(const TSLanguage *self, unsigned external_scanner_state) static inline const bool *ts_language_enabled_external_tokens(const TSLanguage *self, t_u32 external_scanner_state)
{ {
if (external_scanner_state == 0) if (external_scanner_state == 0)
{ {
@ -124,7 +124,7 @@ static inline void ts_language_aliases_for_symbol(const TSLanguage *self, TSSymb
*start = &self->public_symbol_map[original_symbol]; *start = &self->public_symbol_map[original_symbol];
*end = *start + 1; *end = *start + 1;
unsigned idx = 0; t_u32 idx = 0;
for (;;) for (;;)
{ {
TSSymbol symbol = self->alias_map[idx++]; TSSymbol symbol = self->alias_map[idx++];

4
parser/src/lexer.c
View file

@ -95,7 +95,7 @@ static void ts_lexer_goto(Lexer *self, Length position)
// Move to the first valid position at or after the given position. // Move to the first valid position at or after the given position.
bool found_included_range = false; bool found_included_range = false;
for (unsigned i = 0; i < self->included_range_count; i++) for (t_u32 i = 0; i < self->included_range_count; i++)
{ {
TSRange *included_range = &self->included_ranges[i]; TSRange *included_range = &self->included_ranges[i];
if (included_range->end_byte > self->current_position.bytes && included_range->end_byte > included_range->start_byte) if (included_range->end_byte > self->current_position.bytes && included_range->end_byte > included_range->start_byte)
@ -416,7 +416,7 @@ bool ts_lexer_set_included_ranges(Lexer *self, const TSRange *ranges, t_u32 coun
else else
{ {
t_u32 previous_byte = 0; t_u32 previous_byte = 0;
for (unsigned i = 0; i < count; i++) for (t_u32 i = 0; i < count; i++)
{ {
const TSRange *range = &ranges[i]; const TSRange *range = &ranges[i];
if (range->start_byte < previous_byte || range->end_byte < range->start_byte) if (range->start_byte < previous_byte || range->end_byte < range->start_byte)

4
parser/src/lexer.h
View file

@ -14,7 +14,7 @@ typedef struct Lexer
Length token_end_position; Length token_end_position;
TSRange *included_ranges; TSRange *included_ranges;
const char *chunk; const t_u8 *chunk;
TSInput input; TSInput input;
TSLogger logger; TSLogger logger;
@ -25,7 +25,7 @@ typedef struct Lexer
t_u32 lookahead_size; t_u32 lookahead_size;
bool did_get_column; bool did_get_column;
char debug_buffer[TREE_SITTER_SERIALIZATION_BUFFER_SIZE]; t_u8 debug_buffer[TREE_SITTER_SERIALIZATION_BUFFER_SIZE];
} Lexer; } Lexer;
void ts_lexer_init(Lexer *); void ts_lexer_init(Lexer *);

20
parser/src/node.c
View file

@ -187,7 +187,7 @@ static inline TSNode ts_node__child(TSNode self, t_u32 child_index, bool include
static bool ts_subtree_has_trailing_empty_descendant(Subtree self, Subtree other) static bool ts_subtree_has_trailing_empty_descendant(Subtree self, Subtree other)
{ {
for (unsigned i = ts_subtree_child_count(self) - 1; i + 1 > 0; i--) for (t_u32 i = ts_subtree_child_count(self) - 1; i + 1 > 0; i--)
{ {
Subtree child = ts_subtree_children(self)[i]; Subtree child = ts_subtree_children(self)[i];
if (ts_subtree_total_bytes(child) > 0) if (ts_subtree_total_bytes(child) > 0)
@ -484,7 +484,7 @@ TSSymbol ts_node_symbol(TSNode self)
return ts_language_public_symbol(self.tree->language, symbol); return ts_language_public_symbol(self.tree->language, symbol);
} }
const char *ts_node_type(TSNode self) t_const_str ts_node_type(TSNode self)
{ {
TSSymbol symbol = ts_node__alias(&self); TSSymbol symbol = ts_node__alias(&self);
if (!symbol) if (!symbol)
@ -502,7 +502,7 @@ TSSymbol ts_node_grammar_symbol(TSNode self)
return ts_subtree_symbol(ts_node__subtree(self)); return ts_subtree_symbol(ts_node__subtree(self));
} }
const char *ts_node_grammar_type(TSNode self) t_const_str ts_node_grammar_type(TSNode self)
{ {
TSSymbol symbol = ts_subtree_symbol(ts_node__subtree(self)); TSSymbol symbol = ts_subtree_symbol(ts_node__subtree(self));
return ts_language_symbol_name(self.tree->language, symbol); return ts_language_symbol_name(self.tree->language, symbol);
@ -712,7 +712,7 @@ recur:
return ts_node__null(); return ts_node__null();
} }
static inline const char *ts_node__field_name_from_language(TSNode self, t_u32 structural_child_index) static inline t_const_str ts_node__field_name_from_language(TSNode self, t_u32 structural_child_index)
{ {
const TSFieldMapEntry *field_map, *field_map_end; const TSFieldMapEntry *field_map, *field_map_end;
ts_language_field_map(self.tree->language, ts_node__subtree(self).ptr->production_id, &field_map, &field_map_end); ts_language_field_map(self.tree->language, ts_node__subtree(self).ptr->production_id, &field_map, &field_map_end);
@ -726,11 +726,11 @@ static inline const char *ts_node__field_name_from_language(TSNode self, t_u32 s
return NULL; return NULL;
} }
const char *ts_node_field_name_for_child(TSNode self, t_u32 child_index) t_const_str ts_node_field_name_for_child(TSNode self, t_u32 child_index)
{ {
TSNode result = self; TSNode result = self;
bool did_descend = true; bool did_descend = true;
const char *inherited_field_name = NULL; t_const_str inherited_field_name = NULL;
while (did_descend) while (did_descend)
{ {
@ -749,7 +749,7 @@ const char *ts_node_field_name_for_child(TSNode self, t_u32 child_index)
{ {
return NULL; return NULL;
} }
const char *field_name = ts_node__field_name_from_language(result, iterator.structural_child_index - 1); t_const_str field_name = ts_node__field_name_from_language(result, iterator.structural_child_index - 1);
if (field_name) if (field_name)
return field_name; return field_name;
return inherited_field_name; return inherited_field_name;
@ -762,7 +762,7 @@ const char *ts_node_field_name_for_child(TSNode self, t_u32 child_index)
t_u32 grandchild_count = ts_node__relevant_child_count(child, true); t_u32 grandchild_count = ts_node__relevant_child_count(child, true);
if (grandchild_index < grandchild_count) if (grandchild_index < grandchild_count)
{ {
const char *field_name = ts_node__field_name_from_language(result, iterator.structural_child_index - 1); t_const_str field_name = ts_node__field_name_from_language(result, iterator.structural_child_index - 1);
if (field_name) if (field_name)
inherited_field_name = field_name; inherited_field_name = field_name;
@ -779,7 +779,7 @@ const char *ts_node_field_name_for_child(TSNode self, t_u32 child_index)
return NULL; return NULL;
} }
TSNode ts_node_child_by_field_name(TSNode self, const char *name, t_u32 name_length) TSNode ts_node_child_by_field_name(TSNode self, t_const_str name, t_u32 name_length)
{ {
TSFieldId field_id = ts_language_field_id_for_name(self.tree->language, name, name_length); TSFieldId field_id = ts_language_field_id_for_name(self.tree->language, name, name_length);
return ts_node_child_by_field_id(self, field_id); return ts_node_child_by_field_id(self, field_id);
@ -884,7 +884,7 @@ void ts_node_edit(TSNode *self, const TSInputEdit *edit)
TSSymbol ts_node_field_id_for_child(TSNode self, t_u32 child_index) TSSymbol ts_node_field_id_for_child(TSNode self, t_u32 child_index)
{ {
const char *name = ts_node_field_name_for_child(self, child_index); t_const_str name = ts_node_field_name_for_child(self, child_index);
if (name == NULL) if (name == NULL)
return (0); return (0);
return (ts_language_field_id_for_name(ts_node_language(self), name, strlen(name))); return (ts_language_field_id_for_name(ts_node_language(self), name, strlen(name)));

80
parser/src/parser.c
View file

@ -23,11 +23,11 @@
#define TREE_NAME(tree) SYM_NAME(ts_subtree_symbol(tree)) #define TREE_NAME(tree) SYM_NAME(ts_subtree_symbol(tree))
static const unsigned MAX_VERSION_COUNT = 6; static const t_u32 MAX_VERSION_COUNT = 6;
static const unsigned MAX_VERSION_COUNT_OVERFLOW = 4; static const t_u32 MAX_VERSION_COUNT_OVERFLOW = 4;
static const unsigned MAX_SUMMARY_DEPTH = 16; static const t_u32 MAX_SUMMARY_DEPTH = 16;
static const unsigned MAX_COST_DIFFERENCE = 16 * ERROR_COST_PER_SKIPPED_TREE; static const t_u32 MAX_COST_DIFFERENCE = 16 * ERROR_COST_PER_SKIPPED_TREE;
static const unsigned OP_COUNT_PER_TIMEOUT_CHECK = 100; static const t_u32 OP_COUNT_PER_TIMEOUT_CHECK = 100;
typedef struct TokenCache typedef struct TokenCache
{ {
@ -49,18 +49,18 @@ struct TSParser
SubtreeArray scratch_trees; SubtreeArray scratch_trees;
TokenCache token_cache; TokenCache token_cache;
void *external_scanner_payload; void *external_scanner_payload;
unsigned accept_count; t_u32 accept_count;
unsigned operation_count; t_u32 operation_count;
const volatile size_t *cancellation_flag; const volatile size_t *cancellation_flag;
Subtree old_tree; Subtree old_tree;
unsigned included_range_difference_index; t_u32 included_range_difference_index;
bool has_scanner_error; bool has_scanner_error;
}; };
typedef struct ErrorStatus typedef struct ErrorStatus
{ {
unsigned cost; t_u32 cost;
unsigned node_count; t_u32 node_count;
int dynamic_precedence; int dynamic_precedence;
bool is_in_error; bool is_in_error;
} ErrorStatus; } ErrorStatus;
@ -76,20 +76,20 @@ typedef enum ErrorComparison
typedef struct TSStringInput typedef struct TSStringInput
{ {
const char *string; const t_u8 *string;
t_u32 length; t_u32 length;
} TSStringInput; } TSStringInput;
// StringInput // StringInput
static const char *ts_string_input_read(void *_self, t_u32 byte, TSPoint point, t_u32 *length) static const t_u8 *ts_string_input_read(void *_self, t_u32 byte, TSPoint point, t_u32 *length)
{ {
(void)point; (void)point;
TSStringInput *self = (TSStringInput *)_self; TSStringInput *self = (TSStringInput *)_self;
if (byte >= self->length) if (byte >= self->length)
{ {
*length = 0; *length = 0;
return ""; return (const t_u8 *)"";
} }
else else
{ {
@ -234,7 +234,7 @@ static ErrorComparison ts_parser__compare_versions(TSParser *self, ErrorStatus a
static ErrorStatus ts_parser__version_status(TSParser *self, StackVersion version) static ErrorStatus ts_parser__version_status(TSParser *self, StackVersion version)
{ {
unsigned cost = ts_stack_error_cost(self->stack, version); t_u32 cost = ts_stack_error_cost(self->stack, version);
bool is_paused = ts_stack_is_paused(self->stack, version); bool is_paused = ts_stack_is_paused(self->stack, version);
if (is_paused) if (is_paused)
cost += ERROR_COST_PER_SKIPPED_TREE; cost += ERROR_COST_PER_SKIPPED_TREE;
@ -244,7 +244,7 @@ static ErrorStatus ts_parser__version_status(TSParser *self, StackVersion versio
.is_in_error = is_paused || ts_stack_state(self->stack, version) == ERROR_STATE}; .is_in_error = is_paused || ts_stack_state(self->stack, version) == ERROR_STATE};
} }
static bool ts_parser__better_version_exists(TSParser *self, StackVersion version, bool is_in_error, unsigned cost) static bool ts_parser__better_version_exists(TSParser *self, StackVersion version, bool is_in_error, t_u32 cost)
{ {
if (self->finished_tree.ptr && ts_subtree_error_cost(self->finished_tree) <= cost) if (self->finished_tree.ptr && ts_subtree_error_cost(self->finished_tree) <= cost)
{ {
@ -313,7 +313,7 @@ static void ts_parser__external_scanner_destroy(TSParser *self)
self->external_scanner_payload = NULL; self->external_scanner_payload = NULL;
} }
static unsigned ts_parser__external_scanner_serialize(TSParser *self) static t_u32 ts_parser__external_scanner_serialize(TSParser *self)
{ {
t_u32 length = self->language->external_scanner.serialize(self->external_scanner_payload, self->lexer.debug_buffer); t_u32 length = self->language->external_scanner.serialize(self->external_scanner_payload, self->lexer.debug_buffer);
@ -323,7 +323,7 @@ static unsigned ts_parser__external_scanner_serialize(TSParser *self)
static void ts_parser__external_scanner_deserialize(TSParser *self, Subtree external_token) static void ts_parser__external_scanner_deserialize(TSParser *self, Subtree external_token)
{ {
const char *data = NULL; const t_u8 *data = NULL;
t_u32 length = 0; t_u32 length = 0;
if (external_token.ptr) if (external_token.ptr)
{ {
@ -829,7 +829,7 @@ static bool ts_parser__do_all_potential_reductions(TSParser *self, StackVersion
bool can_shift_lookahead_symbol = false; bool can_shift_lookahead_symbol = false;
StackVersion version = starting_version; StackVersion version = starting_version;
for (unsigned i = 0; true; i++) for (t_u32 i = 0; true; i++)
{ {
t_u32 version_count = ts_stack_version_count(self->stack); t_u32 version_count = ts_stack_version_count(self->stack);
if (version >= version_count) if (version >= version_count)
@ -928,12 +928,12 @@ static bool ts_parser__do_all_potential_reductions(TSParser *self, StackVersion
return can_shift_lookahead_symbol; return can_shift_lookahead_symbol;
} }
static bool ts_parser__recover_to_state(TSParser *self, StackVersion version, unsigned depth, TSStateId goal_state) static bool ts_parser__recover_to_state(TSParser *self, StackVersion version, t_u32 depth, TSStateId goal_state)
{ {
StackSliceArray pop = ts_stack_pop_count(self->stack, version, depth); StackSliceArray pop = ts_stack_pop_count(self->stack, version, depth);
StackVersion previous_version = STACK_VERSION_NONE; StackVersion previous_version = STACK_VERSION_NONE;
for (unsigned i = 0; i < pop.size; i++) for (t_u32 i = 0; i < pop.size; i++)
{ {
StackSlice slice = pop.contents[i]; StackSlice slice = pop.contents[i];
@ -961,7 +961,7 @@ static bool ts_parser__recover_to_state(TSParser *self, StackVersion version, un
if (error_child_count > 0) if (error_child_count > 0)
{ {
array_splice(&slice.subtrees, 0, 0, error_child_count, ts_subtree_children(error_tree)); array_splice(&slice.subtrees, 0, 0, error_child_count, ts_subtree_children(error_tree));
for (unsigned j = 0; j < error_child_count; j++) for (t_u32 j = 0; j < error_child_count; j++)
{ {
ts_subtree_retain(slice.subtrees.contents[j]); ts_subtree_retain(slice.subtrees.contents[j]);
} }
@ -981,7 +981,7 @@ static bool ts_parser__recover_to_state(TSParser *self, StackVersion version, un
array_delete(&slice.subtrees); array_delete(&slice.subtrees);
} }
for (unsigned j = 0; j < self->trailing_extras.size; j++) for (t_u32 j = 0; j < self->trailing_extras.size; j++)
{ {
Subtree tree = self->trailing_extras.contents[j]; Subtree tree = self->trailing_extras.contents[j];
ts_stack_push(self->stack, slice.version, tree, false, goal_state); ts_stack_push(self->stack, slice.version, tree, false, goal_state);
@ -996,11 +996,11 @@ static bool ts_parser__recover_to_state(TSParser *self, StackVersion version, un
static void ts_parser__recover(TSParser *self, StackVersion version, Subtree lookahead) static void ts_parser__recover(TSParser *self, StackVersion version, Subtree lookahead)
{ {
bool did_recover = false; bool did_recover = false;
unsigned previous_version_count = ts_stack_version_count(self->stack); t_u32 previous_version_count = ts_stack_version_count(self->stack);
Length position = ts_stack_position(self->stack, version); Length position = ts_stack_position(self->stack, version);
StackSummary *summary = ts_stack_get_summary(self->stack, version); StackSummary *summary = ts_stack_get_summary(self->stack, version);
unsigned node_count_since_error = ts_stack_node_count_since_error(self->stack, version); t_u32 node_count_since_error = ts_stack_node_count_since_error(self->stack, version);
unsigned current_error_cost = ts_stack_error_cost(self->stack, version); t_u32 current_error_cost = ts_stack_error_cost(self->stack, version);
// When the parser is in the error state, there are two strategies for recovering with a // When the parser is in the error state, there are two strategies for recovering with a
// given lookahead token: // given lookahead token:
@ -1016,7 +1016,7 @@ static void ts_parser__recover(TSParser *self, StackVersion version, Subtree loo
// if the current lookahead token would be valid in that state. // if the current lookahead token would be valid in that state.
if (summary && !ts_subtree_is_error(lookahead)) if (summary && !ts_subtree_is_error(lookahead))
{ {
for (unsigned i = 0; i < summary->size; i++) for (t_u32 i = 0; i < summary->size; i++)
{ {
StackSummaryEntry entry = summary->contents[i]; StackSummaryEntry entry = summary->contents[i];
@ -1024,13 +1024,13 @@ static void ts_parser__recover(TSParser *self, StackVersion version, Subtree loo
continue; continue;
if (entry.position.bytes == position.bytes) if (entry.position.bytes == position.bytes)
continue; continue;
unsigned depth = entry.depth; t_u32 depth = entry.depth;
if (node_count_since_error > 0) if (node_count_since_error > 0)
depth++; depth++;
// Do not recover in ways that create redundant stack versions. // Do not recover in ways that create redundant stack versions.
bool would_merge = false; bool would_merge = false;
for (unsigned j = 0; j < previous_version_count; j++) for (t_u32 j = 0; j < previous_version_count; j++)
{ {
if (ts_stack_state(self->stack, j) == entry.state && ts_stack_position(self->stack, j).bytes == position.bytes) if (ts_stack_state(self->stack, j) == entry.state && ts_stack_position(self->stack, j).bytes == position.bytes)
{ {
@ -1042,7 +1042,7 @@ static void ts_parser__recover(TSParser *self, StackVersion version, Subtree loo
continue; continue;
// Do not recover if the result would clearly be worse than some existing stack version. // Do not recover if the result would clearly be worse than some existing stack version.
unsigned new_cost = current_error_cost + entry.depth * ERROR_COST_PER_SKIPPED_TREE + t_u32 new_cost = current_error_cost + entry.depth * ERROR_COST_PER_SKIPPED_TREE +
(position.bytes - entry.position.bytes) * ERROR_COST_PER_SKIPPED_CHAR + (position.bytes - entry.position.bytes) * ERROR_COST_PER_SKIPPED_CHAR +
(position.extent.row - entry.position.extent.row) * ERROR_COST_PER_SKIPPED_LINE; (position.extent.row - entry.position.extent.row) * ERROR_COST_PER_SKIPPED_LINE;
if (ts_parser__better_version_exists(self, version, false, new_cost)) if (ts_parser__better_version_exists(self, version, false, new_cost))
@ -1065,7 +1065,7 @@ static void ts_parser__recover(TSParser *self, StackVersion version, Subtree loo
// In the process of attempting to recover, some stack versions may have been created // In the process of attempting to recover, some stack versions may have been created
// and subsequently halted. Remove those versions. // and subsequently halted. Remove those versions.
for (unsigned i = previous_version_count; i < ts_stack_version_count(self->stack); i++) for (t_u32 i = previous_version_count; i < ts_stack_version_count(self->stack); i++)
{ {
if (!ts_stack_is_active(self->stack, i)) if (!ts_stack_is_active(self->stack, i))
{ {
@ -1105,7 +1105,7 @@ static void ts_parser__recover(TSParser *self, StackVersion version, Subtree loo
} }
// Do not recover if the result would clearly be worse than some existing stack version. // Do not recover if the result would clearly be worse than some existing stack version.
unsigned new_cost = current_error_cost + ERROR_COST_PER_SKIPPED_TREE + ts_subtree_total_bytes(lookahead) * ERROR_COST_PER_SKIPPED_CHAR + t_u32 new_cost = current_error_cost + ERROR_COST_PER_SKIPPED_TREE + ts_subtree_total_bytes(lookahead) * ERROR_COST_PER_SKIPPED_CHAR +
ts_subtree_total_size(lookahead).extent.row * ERROR_COST_PER_SKIPPED_LINE; ts_subtree_total_size(lookahead).extent.row * ERROR_COST_PER_SKIPPED_LINE;
if (ts_parser__better_version_exists(self, version, false, new_cost)) if (ts_parser__better_version_exists(self, version, false, new_cost))
{ {
@ -1116,7 +1116,7 @@ static void ts_parser__recover(TSParser *self, StackVersion version, Subtree loo
// If the current lookahead token is an extra token, mark it as extra. This means it won't // If the current lookahead token is an extra token, mark it as extra. This means it won't
// be counted in error cost calculations. // be counted in error cost calculations.
unsigned n; t_u32 n;
const TSParseAction *actions = ts_language_actions(self->language, 1, ts_subtree_symbol(lookahead), &n); const TSParseAction *actions = ts_language_actions(self->language, 1, ts_subtree_symbol(lookahead), &n);
if (n > 0 && actions[n - 1].type == TSParseActionTypeShift && actions[n - 1].shift.extra) if (n > 0 && actions[n - 1].type == TSParseActionTypeShift && actions[n - 1].shift.extra)
{ {
@ -1145,7 +1145,7 @@ static void ts_parser__recover(TSParser *self, StackVersion version, Subtree loo
// arbitrarily and discard the rest. // arbitrarily and discard the rest.
if (pop.size > 1) if (pop.size > 1)
{ {
for (unsigned i = 1; i < pop.size; i++) for (t_u32 i = 1; i < pop.size; i++)
{ {
ts_subtree_array_delete(&self->tree_pool, &pop.contents[i].subtrees); ts_subtree_array_delete(&self->tree_pool, &pop.contents[i].subtrees);
} }
@ -1225,7 +1225,7 @@ static void ts_parser__handle_error(TSParser *self, StackVersion version, Subtre
v = (v == version) ? previous_version_count : v + 1; v = (v == version) ? previous_version_count : v + 1;
} }
for (unsigned i = previous_version_count; i < version_count; i++) for (t_u32 i = previous_version_count; i < version_count; i++)
{ {
bool did_merge = ts_stack_merge(self->stack, version, previous_version_count); bool did_merge = ts_stack_merge(self->stack, version, previous_version_count);
assert(did_merge); assert(did_merge);
@ -1453,10 +1453,10 @@ static bool ts_parser__advance(TSParser *self, StackVersion version, bool allow_
} }
} }
static unsigned ts_parser__condense_stack(TSParser *self) static t_u32 ts_parser__condense_stack(TSParser *self)
{ {
bool made_changes = false; bool made_changes = false;
unsigned min_error_cost = UINT_MAX; t_u32 min_error_cost = UINT_MAX;
for (StackVersion i = 0; i < ts_stack_version_count(self->stack); i++) for (StackVersion i = 0; i < ts_stack_version_count(self->stack); i++)
{ {
// Prune any versions that have been marked for removal. // Prune any versions that have been marked for removal.
@ -1724,7 +1724,7 @@ TSTree *ts_parser_parse(TSParser *self, const TSTree *old_tree, TSInput input)
// After advancing each version of the stack, re-sort the versions by their cost, // After advancing each version of the stack, re-sort the versions by their cost,
// removing any versions that are no longer worth pursuing. // removing any versions that are no longer worth pursuing.
unsigned min_error_cost = ts_parser__condense_stack(self); t_u32 min_error_cost = ts_parser__condense_stack(self);
// If there's already a finished parse tree that's better than any in-progress version, // If there's already a finished parse tree that's better than any in-progress version,
// then terminate parsing. Clear the parse stack to remove any extra references to subtrees // then terminate parsing. Clear the parse stack to remove any extra references to subtrees
@ -1751,14 +1751,14 @@ exit:
return result; return result;
} }
TSTree *ts_parser_parse_string(TSParser *self, const TSTree *old_tree, const char *string, t_u32 length) TSTree *ts_parser_parse_string(TSParser *self, const TSTree *old_tree, t_const_str string, t_u32 length)
{ {
return ts_parser_parse_string_encoding(self, old_tree, string, length, TSInputEncodingUTF8); return ts_parser_parse_string_encoding(self, old_tree, string, length, TSInputEncodingUTF8);
} }
TSTree *ts_parser_parse_string_encoding(TSParser *self, const TSTree *old_tree, const char *string, t_u32 length, TSInputEncoding encoding) TSTree *ts_parser_parse_string_encoding(TSParser *self, const TSTree *old_tree, t_const_str string, t_u32 length, TSInputEncoding encoding)
{ {
TSStringInput input = {string, length}; TSStringInput input = {(const t_u8 *)string, length};
return ts_parser_parse(self, old_tree, return ts_parser_parse(self, old_tree,
(TSInput){ (TSInput){
&input, &input,

8
parser/src/parser.h
View file

@ -111,8 +111,8 @@ struct TSLanguage
const t_u16 *small_parse_table; const t_u16 *small_parse_table;
const t_u32 *small_parse_table_map; const t_u32 *small_parse_table_map;
const TSParseActionEntry *parse_actions; const TSParseActionEntry *parse_actions;
const char *const *symbol_names; t_const_str const *symbol_names;
const char *const *field_names; t_const_str const *field_names;
const TSFieldMapSlice *field_map_slices; const TSFieldMapSlice *field_map_slices;
const TSFieldMapEntry *field_map_entries; const TSFieldMapEntry *field_map_entries;
const TSSymbolMetadata *symbol_metadata; const TSSymbolMetadata *symbol_metadata;
@ -130,8 +130,8 @@ struct TSLanguage
void *(*create)(void); void *(*create)(void);
void (*destroy)(void *); void (*destroy)(void *);
bool (*scan)(void *, TSLexer *, const bool *symbol_whitelist); bool (*scan)(void *, TSLexer *, const bool *symbol_whitelist);
unsigned (*serialize)(void *, char *); t_u32 (*serialize)(void *, t_u8 *);
void (*deserialize)(void *, const char *, unsigned); void (*deserialize)(void *, const t_u8 *, t_u32);
} external_scanner; } external_scanner;
const TSStateId *primary_state_ids; const TSStateId *primary_state_ids;
}; };

2
parser/src/point.h
View file

@ -7,7 +7,7 @@
#define POINT_ZERO ((TSPoint){0, 0}) #define POINT_ZERO ((TSPoint){0, 0})
#define POINT_MAX ((TSPoint){UINT32_MAX, UINT32_MAX}) #define POINT_MAX ((TSPoint){UINT32_MAX, UINT32_MAX})
static inline TSPoint point__new(unsigned row, unsigned column) static inline TSPoint point__new(t_u32 row, t_u32 column)
{ {
TSPoint result = {row, column}; TSPoint result = {row, column};
return result; return result;

2
parser/src/reduce_action.h
View file

@ -10,7 +10,7 @@ typedef struct ReduceAction
t_u32 count; t_u32 count;
TSSymbol symbol; TSSymbol symbol;
int dynamic_precedence; int dynamic_precedence;
unsigned short production_id; t_u16 production_id;
} ReduceAction; } ReduceAction;
typedef Array(ReduceAction) ReduceActionSet; typedef Array(ReduceAction) ReduceActionSet;

10
parser/src/scanner.c
View file

@ -97,7 +97,7 @@ static inline void reset(Scanner *scanner)
} }
} }
static unsigned serialize(Scanner *scanner, char *buffer) static t_u32 serialize(Scanner *scanner, t_u8 *buffer)
{ {
t_u32 size = 0; t_u32 size = 0;
@ -129,7 +129,7 @@ static unsigned serialize(Scanner *scanner, char *buffer)
return size; return size;
} }
static void deserialize(Scanner *scanner, const char *buffer, unsigned length) static void deserialize(Scanner *scanner, const t_u8 *buffer, t_u32 length)
{ {
if (length == 0) if (length == 0)
{ {
@ -141,7 +141,7 @@ static void deserialize(Scanner *scanner, const char *buffer, unsigned length)
scanner->last_glob_paren_depth = buffer[size++]; scanner->last_glob_paren_depth = buffer[size++];
scanner->ext_was_in_double_quote = buffer[size++]; scanner->ext_was_in_double_quote = buffer[size++];
scanner->ext_saw_outside_quote = buffer[size++]; scanner->ext_saw_outside_quote = buffer[size++];
t_u32 heredoc_count = (unsigned char)buffer[size++]; t_u32 heredoc_count = (t_u8)buffer[size++];
for (t_u32 i = 0; i < heredoc_count; i++) for (t_u32 i = 0; i < heredoc_count; i++)
{ {
Heredoc *heredoc = NULL; Heredoc *heredoc = NULL;
@ -1172,13 +1172,13 @@ bool tree_sitter_sh_external_scanner_scan(void *payload, TSLexer *lexer, const b
return scan(scanner, lexer, valid_symbols); return scan(scanner, lexer, valid_symbols);
} }
unsigned tree_sitter_sh_external_scanner_serialize(void *payload, char *state) t_u32 tree_sitter_sh_external_scanner_serialize(void *payload, t_u8 *state)
{ {
Scanner *scanner = (Scanner *)payload; Scanner *scanner = (Scanner *)payload;
return serialize(scanner, state); return serialize(scanner, state);
} }
void tree_sitter_sh_external_scanner_deserialize(void *payload, const char *state, unsigned length) void tree_sitter_sh_external_scanner_deserialize(void *payload, const t_u8 *state, t_u32 length)
{ {
Scanner *scanner = (Scanner *)payload; Scanner *scanner = (Scanner *)payload;
deserialize(scanner, state, length); deserialize(scanner, state, length);

32
parser/src/stack.c
View file

@ -27,10 +27,10 @@ struct StackNode
TSStateId state; TSStateId state;
Length position; Length position;
StackLink links[MAX_LINK_COUNT]; StackLink links[MAX_LINK_COUNT];
short unsigned int link_count; t_u16 link_count;
t_u32 ref_count; t_u32 ref_count;
unsigned error_cost; t_u32 error_cost;
unsigned node_count; t_u32 node_count;
int dynamic_precedence; int dynamic_precedence;
}; };
@ -55,7 +55,7 @@ typedef struct StackHead
{ {
StackNode *node; StackNode *node;
StackSummary *summary; StackSummary *summary;
unsigned node_count_at_last_error; t_u32 node_count_at_last_error;
Subtree last_external_token; Subtree last_external_token;
Subtree lookahead_when_paused; Subtree lookahead_when_paused;
StackStatus status; StackStatus status;
@ -71,7 +71,7 @@ struct Stack
SubtreePool *subtree_pool; SubtreePool *subtree_pool;
}; };
typedef unsigned StackAction; typedef t_u32 StackAction;
enum StackAction enum StackAction
{ {
StackActionNone, StackActionNone,
@ -101,7 +101,7 @@ recur:
StackNode *first_predecessor = NULL; StackNode *first_predecessor = NULL;
if (self->link_count > 0) if (self->link_count > 0)
{ {
for (unsigned i = self->link_count - 1; i > 0; i--) for (t_u32 i = self->link_count - 1; i > 0; i--)
{ {
StackLink link = self->links[i]; StackLink link = self->links[i];
if (link.subtree.ptr) if (link.subtree.ptr)
@ -255,7 +255,7 @@ static void stack_node_add_link(StackNode *self, StackLink link, SubtreePool *su
return; return;
stack_node_retain(link.node); stack_node_retain(link.node);
unsigned node_count = link.node->node_count; t_u32 node_count = link.node->node_count;
int dynamic_precedence = link.node->dynamic_precedence; int dynamic_precedence = link.node->dynamic_precedence;
self->links[self->link_count++] = link; self->links[self->link_count++] = link;
@ -504,10 +504,10 @@ void ts_stack_set_last_external_token(Stack *self, StackVersion version, Subtree
head->last_external_token = token; head->last_external_token = token;
} }
unsigned ts_stack_error_cost(const Stack *self, StackVersion version) t_u32 ts_stack_error_cost(const Stack *self, StackVersion version)
{ {
StackHead *head = array_get(&self->heads, version); StackHead *head = array_get(&self->heads, version);
unsigned result = head->node->error_cost; t_u32 result = head->node->error_cost;
if (head->status == StackStatusPaused || (head->node->state == ERROR_STATE && !head->node->links[0].subtree.ptr)) if (head->status == StackStatusPaused || (head->node->state == ERROR_STATE && !head->node->links[0].subtree.ptr))
{ {
result += ERROR_COST_PER_RECOVERY; result += ERROR_COST_PER_RECOVERY;
@ -515,7 +515,7 @@ unsigned ts_stack_error_cost(const Stack *self, StackVersion version)
return result; return result;
} }
unsigned ts_stack_node_count_since_error(const Stack *self, StackVersion version) t_u32 ts_stack_node_count_since_error(const Stack *self, StackVersion version)
{ {
StackHead *head = array_get(&self->heads, version); StackHead *head = array_get(&self->heads, version);
if (head->node->node_count < head->node_count_at_last_error) if (head->node->node_count < head->node_count_at_last_error)
@ -536,7 +536,7 @@ void ts_stack_push(Stack *self, StackVersion version, Subtree subtree, bool pend
StackAction pop_count_callback(void *payload, const StackIterator *iterator) StackAction pop_count_callback(void *payload, const StackIterator *iterator)
{ {
unsigned *goal_subtree_count = payload; t_u32 *goal_subtree_count = payload;
if (iterator->subtree_count == *goal_subtree_count) if (iterator->subtree_count == *goal_subtree_count)
{ {
return StackActionPop | StackActionStop; return StackActionPop | StackActionStop;
@ -607,7 +607,7 @@ StackAction pop_error_callback(void *payload, const StackIterator *iterator)
SubtreeArray ts_stack_pop_error(Stack *self, StackVersion version) SubtreeArray ts_stack_pop_error(Stack *self, StackVersion version)
{ {
StackNode *node = array_get(&self->heads, version)->node; StackNode *node = array_get(&self->heads, version)->node;
for (unsigned i = 0; i < node->link_count; i++) for (t_u32 i = 0; i < node->link_count; i++)
{ {
if (node->links[i].subtree.ptr && ts_subtree_is_error(node->links[i].subtree)) if (node->links[i].subtree.ptr && ts_subtree_is_error(node->links[i].subtree))
{ {
@ -639,17 +639,17 @@ StackSliceArray ts_stack_pop_all(Stack *self, StackVersion version)
typedef struct SummarizeStackSession typedef struct SummarizeStackSession
{ {
StackSummary *summary; StackSummary *summary;
unsigned max_depth; t_u32 max_depth;
} SummarizeStackSession; } SummarizeStackSession;
StackAction summarize_stack_callback(void *payload, const StackIterator *iterator) StackAction summarize_stack_callback(void *payload, const StackIterator *iterator)
{ {
SummarizeStackSession *session = payload; SummarizeStackSession *session = payload;
TSStateId state = iterator->node->state; TSStateId state = iterator->node->state;
unsigned depth = iterator->subtree_count; t_u32 depth = iterator->subtree_count;
if (depth > session->max_depth) if (depth > session->max_depth)
return StackActionStop; return StackActionStop;
for (unsigned i = session->summary->size - 1; i + 1 > 0; i--) for (t_u32 i = session->summary->size - 1; i + 1 > 0; i--)
{ {
StackSummaryEntry entry = session->summary->contents[i]; StackSummaryEntry entry = session->summary->contents[i];
if (entry.depth < depth) if (entry.depth < depth)
@ -665,7 +665,7 @@ StackAction summarize_stack_callback(void *payload, const StackIterator *iterato
return StackActionNone; return StackActionNone;
} }
void ts_stack_record_summary(Stack *self, StackVersion version, unsigned max_depth) void ts_stack_record_summary(Stack *self, StackVersion version, t_u32 max_depth)
{ {
SummarizeStackSession session = {.summary = mem_alloc(sizeof(StackSummary)), .max_depth = max_depth}; SummarizeStackSession session = {.summary = mem_alloc(sizeof(StackSummary)), .max_depth = max_depth};
array_init(session.summary); array_init(session.summary);

10
parser/src/stack.h
View file

@ -8,7 +8,7 @@
typedef struct Stack Stack; typedef struct Stack Stack;
typedef unsigned StackVersion; typedef t_u32 StackVersion;
#define STACK_VERSION_NONE ((StackVersion)-1) #define STACK_VERSION_NONE ((StackVersion)-1)
typedef struct StackSlice typedef struct StackSlice
@ -21,7 +21,7 @@ typedef Array(StackSlice) StackSliceArray;
typedef struct StackSummaryEntry typedef struct StackSummaryEntry
{ {
Length position; Length position;
unsigned depth; t_u32 depth;
TSStateId state; TSStateId state;
} StackSummaryEntry; } StackSummaryEntry;
@ -76,7 +76,7 @@ StackSliceArray ts_stack_pop_all(Stack *, StackVersion);
// Get the maximum number of tree nodes reachable from this version of the stack // Get the maximum number of tree nodes reachable from this version of the stack
// since the last error was detected. // since the last error was detected.
unsigned ts_stack_node_count_since_error(const Stack *, StackVersion); t_u32 ts_stack_node_count_since_error(const Stack *, StackVersion);
int ts_stack_dynamic_precedence(Stack *, StackVersion); int ts_stack_dynamic_precedence(Stack *, StackVersion);
@ -84,14 +84,14 @@ bool ts_stack_has_advanced_since_error(const Stack *, StackVersion);
// Compute a summary of all the parse states near the top of the given // Compute a summary of all the parse states near the top of the given
// version of the stack and store the summary for later retrieval. // version of the stack and store the summary for later retrieval.
void ts_stack_record_summary(Stack *, StackVersion, unsigned max_depth); void ts_stack_record_summary(Stack *, StackVersion, t_u32 max_depth);
// Retrieve a summary of all the parse states near the top of the // Retrieve a summary of all the parse states near the top of the
// given version of the stack. // given version of the stack.
StackSummary *ts_stack_get_summary(Stack *, StackVersion); StackSummary *ts_stack_get_summary(Stack *, StackVersion);
// Get the total cost of all errors on the given version of the stack. // Get the total cost of all errors on the given version of the stack.
unsigned ts_stack_error_cost(const Stack *, StackVersion version); t_u32 ts_stack_error_cost(const Stack *, StackVersion version);
// Merge the given two stack versions if possible, returning true // Merge the given two stack versions if possible, returning true
// if they were successfully merged and false otherwise. // if they were successfully merged and false otherwise.

34
parser/src/subtree.c
View file

@ -23,7 +23,7 @@ typedef struct
// ExternalScannerState // ExternalScannerState
void ts_external_scanner_state_init(ExternalScannerState *self, const char *data, unsigned length) void ts_external_scanner_state_init(ExternalScannerState *self, const t_u8 *data, t_u32 length)
{ {
self->length = length; self->length = length;
if (length > sizeof(self->short_data)) if (length > sizeof(self->short_data))
@ -56,19 +56,19 @@ void ts_external_scanner_state_delete(ExternalScannerState *self)
} }
} }
const char *ts_external_scanner_state_data(const ExternalScannerState *self) const t_u8 *ts_external_scanner_state_data(const ExternalScannerState *self)
{ {
if (self->length > sizeof(self->short_data)) if (self->length > sizeof(self->short_data))
{ {
return self->long_data; return (const t_u8 *)self->long_data;
} }
else else
{ {
return self->short_data; return (const t_u8 *)self->short_data;
} }
} }
bool ts_external_scanner_state_eq(const ExternalScannerState *self, const char *buffer, unsigned length) bool ts_external_scanner_state_eq(const ExternalScannerState *self, const t_u8 *buffer, t_u32 length)
{ {
return self->length == length && memcmp(ts_external_scanner_state_data(self), buffer, length) == 0; return self->length == length && memcmp(ts_external_scanner_state_data(self), buffer, length) == 0;
} }
@ -149,7 +149,7 @@ void ts_subtree_pool_delete(SubtreePool *self)
{ {
if (self->free_trees.contents) if (self->free_trees.contents)
{ {
for (unsigned i = 0; i < self->free_trees.size; i++) for (t_u32 i = 0; i < self->free_trees.size; i++)
{ {
mem_free(self->free_trees.contents[i].ptr); mem_free(self->free_trees.contents[i].ptr);
} }
@ -315,13 +315,13 @@ MutableSubtree ts_subtree_make_mut(SubtreePool *pool, Subtree self)
return result; return result;
} }
static void ts_subtree__compress(MutableSubtree self, unsigned count, const TSLanguage *language, MutableSubtreeArray *stack) static void ts_subtree__compress(MutableSubtree self, t_u32 count, const TSLanguage *language, MutableSubtreeArray *stack)
{ {
unsigned initial_stack_size = stack->size; t_u32 initial_stack_size = stack->size;
MutableSubtree tree = self; MutableSubtree tree = self;
TSSymbol symbol = tree.ptr->symbol; TSSymbol symbol = tree.ptr->symbol;
for (unsigned i = 0; i < count; i++) for (t_u32 i = 0; i < count; i++)
{ {
if (tree.ptr->ref_count > 1 || tree.ptr->child_count < 2) if (tree.ptr->ref_count > 1 || tree.ptr->child_count < 2)
break; break;
@ -373,8 +373,8 @@ void ts_subtree_balance(Subtree self, SubtreePool *pool, const TSLanguage *langu
long repeat_delta = (long)ts_subtree_repeat_depth(child1) - (long)ts_subtree_repeat_depth(child2); long repeat_delta = (long)ts_subtree_repeat_depth(child1) - (long)ts_subtree_repeat_depth(child2);
if (repeat_delta > 0) if (repeat_delta > 0)
{ {
unsigned n = (unsigned)repeat_delta; t_u32 n = (t_u32)repeat_delta;
for (unsigned i = n / 2; i > 0; i /= 2) for (t_u32 i = n / 2; i > 0; i /= 2)
{ {
ts_subtree__compress(tree, i, language, &pool->tree_stack); ts_subtree__compress(tree, i, language, &pool->tree_stack);
n -= i; n -= i;
@ -540,7 +540,7 @@ void ts_subtree_summarize_children(MutableSubtree self, const TSLanguage *langua
// Create a new parent node with the given children. // Create a new parent node with the given children.
// //
// This takes ownership of the children array. // This takes ownership of the children array.
MutableSubtree ts_subtree_new_node(TSSymbol symbol, SubtreeArray *children, unsigned production_id, const TSLanguage *language) MutableSubtree ts_subtree_new_node(TSSymbol symbol, SubtreeArray *children, t_u32 production_id, const TSLanguage *language)
{ {
TSSymbolMetadata metadata = ts_language_symbol_metadata(language, symbol); TSSymbolMetadata metadata = ts_language_symbol_metadata(language, symbol);
bool fragile = symbol == ts_builtin_sym_error || symbol == ts_builtin_sym_error_repeat; bool fragile = symbol == ts_builtin_sym_error || symbol == ts_builtin_sym_error_repeat;
@ -903,10 +903,10 @@ static size_t ts_subtree__write_char_to_string(char *str, size_t n, t_i32 chr)
return snprintf(str, n, "%d", chr); return snprintf(str, n, "%d", chr);
} }
static const char *const ROOT_FIELD = "__ROOT__"; static t_const_str 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, 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) TSSymbol alias_symbol, bool alias_is_named, t_const_str field_name)
{ {
if (!self.ptr) if (!self.ptr)
return snprintf(string, limit, "(NULL)"); return snprintf(string, limit, "(NULL)");
@ -936,7 +936,7 @@ static size_t ts_subtree__write_to_string(Subtree self, char *string, size_t lim
else else
{ {
TSSymbol symbol = alias_symbol ? alias_symbol : ts_subtree_symbol(self); TSSymbol symbol = alias_symbol ? alias_symbol : ts_subtree_symbol(self);
const char *symbol_name = ts_language_symbol_name(language, symbol); t_const_str symbol_name = ts_language_symbol_name(language, symbol);
if (ts_subtree_missing(self)) if (ts_subtree_missing(self))
{ {
cursor += snprintf(*writer, limit, "(MISSING "); cursor += snprintf(*writer, limit, "(MISSING ");
@ -958,7 +958,7 @@ static size_t ts_subtree__write_to_string(Subtree self, char *string, size_t lim
else if (is_root) else if (is_root)
{ {
TSSymbol symbol = alias_symbol ? alias_symbol : ts_subtree_symbol(self); TSSymbol symbol = alias_symbol ? alias_symbol : ts_subtree_symbol(self);
const char *symbol_name = ts_language_symbol_name(language, symbol); t_const_str symbol_name = ts_language_symbol_name(language, symbol);
if (ts_subtree_child_count(self) > 0) if (ts_subtree_child_count(self) > 0)
{ {
cursor += snprintf(*writer, limit, "(%s", symbol_name); cursor += snprintf(*writer, limit, "(%s", symbol_name);
@ -993,7 +993,7 @@ static size_t ts_subtree__write_to_string(Subtree self, char *string, size_t lim
bool subtree_alias_is_named = bool subtree_alias_is_named =
subtree_alias_symbol ? ts_language_symbol_metadata(language, subtree_alias_symbol).named : false; subtree_alias_symbol ? ts_language_symbol_metadata(language, subtree_alias_symbol).named : false;
const char *child_field_name = is_visible ? NULL : field_name; t_const_str child_field_name = is_visible ? NULL : field_name;
for (const TSFieldMapEntry *map = field_map; map < field_map_end; map++) for (const TSFieldMapEntry *map = field_map; map < field_map_end; map++)
{ {
if (!map->inherited && map->child_index == structural_child_index) if (!map->inherited && map->child_index == structural_child_index)

8
parser/src/subtree.h
View file

@ -179,9 +179,9 @@ typedef struct SubtreePool
MutableSubtreeArray tree_stack; MutableSubtreeArray tree_stack;
} SubtreePool; } SubtreePool;
void ts_external_scanner_state_init(ExternalScannerState *, const char *, unsigned); void ts_external_scanner_state_init(ExternalScannerState *, const t_u8 *, t_u32);
const char *ts_external_scanner_state_data(const ExternalScannerState *); const t_u8 *ts_external_scanner_state_data(const ExternalScannerState *);
bool ts_external_scanner_state_eq(const ExternalScannerState *self, const char *, unsigned); bool ts_external_scanner_state_eq(const ExternalScannerState *self, const t_u8 *, t_u32);
void ts_external_scanner_state_delete(ExternalScannerState *self); void ts_external_scanner_state_delete(ExternalScannerState *self);
void ts_subtree_array_copy(SubtreeArray, SubtreeArray *); void ts_subtree_array_copy(SubtreeArray, SubtreeArray *);
@ -195,7 +195,7 @@ void ts_subtree_pool_delete(SubtreePool *);
Subtree ts_subtree_new_leaf(SubtreePool *, TSSymbol, Length, Length, t_u32, TSStateId, bool, bool, bool, const TSLanguage *); Subtree ts_subtree_new_leaf(SubtreePool *, TSSymbol, Length, Length, t_u32, TSStateId, bool, bool, bool, const TSLanguage *);
Subtree ts_subtree_new_error(SubtreePool *, t_i32, Length, Length, t_u32, TSStateId, const TSLanguage *); Subtree ts_subtree_new_error(SubtreePool *, t_i32, Length, Length, t_u32, TSStateId, const TSLanguage *);
MutableSubtree ts_subtree_new_node(TSSymbol, SubtreeArray *, unsigned, const TSLanguage *); MutableSubtree ts_subtree_new_node(TSSymbol, SubtreeArray *, t_u32, const TSLanguage *);
Subtree ts_subtree_new_error_node(SubtreeArray *, bool, const TSLanguage *); Subtree ts_subtree_new_error_node(SubtreeArray *, bool, const TSLanguage *);
Subtree ts_subtree_new_missing_leaf(SubtreePool *, TSSymbol, Length, t_u32, const TSLanguage *); Subtree ts_subtree_new_missing_leaf(SubtreePool *, TSSymbol, Length, t_u32, const TSLanguage *);
MutableSubtree ts_subtree_make_mut(SubtreePool *, Subtree); MutableSubtree ts_subtree_make_mut(SubtreePool *, Subtree);

4
parser/src/tree.c
View file

@ -8,7 +8,7 @@
#include "./subtree.h" #include "./subtree.h"
#include "api.h" #include "api.h"
TSTree *ts_tree_new(Subtree root, const TSLanguage *language, const TSRange *included_ranges, unsigned included_range_count) TSTree *ts_tree_new(Subtree root, const TSLanguage *language, const TSRange *included_ranges, t_u32 included_range_count)
{ {
TSTree *result = mem_alloc(sizeof(TSTree)); TSTree *result = mem_alloc(sizeof(TSTree));
result->root = root; result->root = root;
@ -56,7 +56,7 @@ const TSLanguage *ts_tree_language(const TSTree *self)
void ts_tree_edit(TSTree *self, const TSInputEdit *edit) void ts_tree_edit(TSTree *self, const TSInputEdit *edit)
{ {
for (unsigned i = 0; i < self->included_range_count; i++) for (t_u32 i = 0; i < self->included_range_count; i++)
{ {
TSRange *range = &self->included_ranges[i]; TSRange *range = &self->included_ranges[i];
if (range->end_byte >= edit->old_end_byte) if (range->end_byte >= edit->old_end_byte)

4
parser/src/tree.h
View file

@ -18,10 +18,10 @@ struct TSTree
Subtree root; Subtree root;
const TSLanguage *language; const TSLanguage *language;
TSRange *included_ranges; TSRange *included_ranges;
unsigned included_range_count; t_u32 included_range_count;
}; };
TSTree *ts_tree_new(Subtree root, const TSLanguage *language, const TSRange *, unsigned); TSTree *ts_tree_new(Subtree root, const TSLanguage *language, const TSRange *, t_u32);
TSNode ts_node_new(const TSTree *, const Subtree *, Length, TSSymbol); TSNode ts_node_new(const TSTree *, const Subtree *, Length, TSSymbol);
#endif // TREE_SITTER_TREE_H_ #endif // TREE_SITTER_TREE_H_