From 6a46dff89a9d9bd9ceb13d7838c1a801974ac08d Mon Sep 17 00:00:00 2001 From: Max Brunsfeld Date: Mon, 15 Jun 2020 09:58:07 -0700 Subject: [PATCH] Add ts_language_alias_at helper function --- lib/src/get_changed_ranges.c | 24 +++++++------- lib/src/language.h | 51 +++++++++++++++++++---------- lib/src/subtree.c | 8 ++--- lib/src/tree_cursor.c | 62 +++++++++++++++++++----------------- 4 files changed, 84 insertions(+), 61 deletions(-) diff --git a/lib/src/get_changed_ranges.c b/lib/src/get_changed_ranges.c index 5bd1d814..b24f3149 100644 --- a/lib/src/get_changed_ranges.c +++ b/lib/src/get_changed_ranges.c @@ -146,17 +146,21 @@ static bool iterator_tree_is_visible(const Iterator *self) { if (ts_subtree_visible(*entry.subtree)) return true; if (self->cursor.stack.size > 1) { Subtree parent = *self->cursor.stack.contents[self->cursor.stack.size - 2].subtree; - const TSSymbol *alias_sequence = ts_language_alias_sequence( + return ts_language_alias_at( self->language, - parent.ptr->production_id - ); - return alias_sequence && alias_sequence[entry.structural_child_index] != 0; + parent.ptr->production_id, + entry.structural_child_index + ) != 0; } return false; } -static void iterator_get_visible_state(const Iterator *self, Subtree *tree, - TSSymbol *alias_symbol, uint32_t *start_byte) { +static void iterator_get_visible_state( + const Iterator *self, + Subtree *tree, + TSSymbol *alias_symbol, + uint32_t *start_byte +) { uint32_t i = self->cursor.stack.size - 1; if (self->in_padding) { @@ -169,13 +173,11 @@ static void iterator_get_visible_state(const Iterator *self, Subtree *tree, if (i > 0) { const Subtree *parent = self->cursor.stack.contents[i - 1].subtree; - const TSSymbol *alias_sequence = ts_language_alias_sequence( + *alias_symbol = ts_language_alias_at( self->language, - parent->ptr->production_id + parent->ptr->production_id, + entry.structural_child_index ); - if (alias_sequence) { - *alias_symbol = alias_sequence[entry.structural_child_index]; - } } if (ts_subtree_visible(*entry.subtree) || *alias_symbol) { diff --git a/lib/src/language.h b/lib/src/language.h index 341f0f85..2bb9a6f9 100644 --- a/lib/src/language.h +++ b/lib/src/language.h @@ -41,17 +41,21 @@ static inline const TSParseAction *ts_language_actions( return entry.actions; } -static inline bool ts_language_has_actions(const TSLanguage *self, - TSStateId state, - TSSymbol symbol) { +static inline bool ts_language_has_actions( + const TSLanguage *self, + TSStateId state, + TSSymbol symbol +) { TableEntry entry; ts_language_table_entry(self, state, symbol, &entry); return entry.action_count > 0; } -static inline bool ts_language_has_reduce_action(const TSLanguage *self, - TSStateId state, - TSSymbol symbol) { +static inline bool ts_language_has_reduce_action( + const TSLanguage *self, + TSStateId state, + TSSymbol symbol +) { TableEntry entry; ts_language_table_entry(self, state, symbol, &entry); return entry.action_count > 0 && entry.actions[0].type == TSParseActionTypeReduce; @@ -82,9 +86,11 @@ static inline uint16_t ts_language_lookup( } } -static inline TSStateId ts_language_next_state(const TSLanguage *self, - TSStateId state, - TSSymbol symbol) { +static inline TSStateId ts_language_next_state( + const TSLanguage *self, + TSStateId state, + TSSymbol symbol +) { if (symbol == ts_builtin_sym_error || symbol == ts_builtin_sym_error_repeat) { return 0; } else if (symbol < self->token_count) { @@ -102,9 +108,10 @@ static inline TSStateId ts_language_next_state(const TSLanguage *self, } } -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, + unsigned external_scanner_state +) { if (external_scanner_state == 0) { return NULL; } else { @@ -112,13 +119,25 @@ ts_language_enabled_external_tokens(const TSLanguage *self, } } -static inline const TSSymbol * -ts_language_alias_sequence(const TSLanguage *self, uint32_t production_id) { - return production_id > 0 ? - self->alias_sequences + production_id * self->max_alias_sequence_length : +static inline const TSSymbol *ts_language_alias_sequence( + const TSLanguage *self, + uint32_t production_id +) { + return production_id ? + &self->alias_sequences[production_id * self->max_alias_sequence_length] : NULL; } +static inline TSSymbol ts_language_alias_at( + const TSLanguage *self, + uint32_t production_id, + uint32_t child_index +) { + return production_id ? + self->alias_sequences[production_id * self->max_alias_sequence_length + child_index] : + 0; +} + static inline void ts_language_field_map( const TSLanguage *self, uint32_t production_id, diff --git a/lib/src/subtree.c b/lib/src/subtree.c index ef92a32f..24dc06b2 100644 --- a/lib/src/subtree.c +++ b/lib/src/subtree.c @@ -360,7 +360,7 @@ void ts_subtree_set_children( self.ptr->has_external_tokens = false; self.ptr->dynamic_precedence = 0; - uint32_t non_extra_index = 0; + uint32_t structural_index = 0; const TSSymbol *alias_sequence = ts_language_alias_sequence(language, self.ptr->production_id); uint32_t lookahead_end_byte = 0; @@ -387,9 +387,9 @@ void ts_subtree_set_children( self.ptr->dynamic_precedence += ts_subtree_dynamic_precedence(child); self.ptr->node_count += ts_subtree_node_count(child); - if (alias_sequence && alias_sequence[non_extra_index] != 0 && !ts_subtree_extra(child)) { + if (alias_sequence && alias_sequence[structural_index] != 0 && !ts_subtree_extra(child)) { self.ptr->visible_child_count++; - if (ts_language_symbol_metadata(language, alias_sequence[non_extra_index]).named) { + if (ts_language_symbol_metadata(language, alias_sequence[structural_index]).named) { self.ptr->named_child_count++; } } else if (ts_subtree_visible(child)) { @@ -407,7 +407,7 @@ void ts_subtree_set_children( self.ptr->parse_state = TS_TREE_STATE_NONE; } - if (!ts_subtree_extra(child)) non_extra_index++; + if (!ts_subtree_extra(child)) structural_index++; } self.ptr->lookahead_bytes = lookahead_end_byte - self.ptr->size.bytes - self.ptr->padding.bytes; diff --git a/lib/src/tree_cursor.c b/lib/src/tree_cursor.c index 00b9679d..06c724d2 100644 --- a/lib/src/tree_cursor.c +++ b/lib/src/tree_cursor.c @@ -205,19 +205,21 @@ bool ts_tree_cursor_goto_parent(TSTreeCursor *_self) { TreeCursor *self = (TreeCursor *)_self; for (unsigned i = self->stack.size - 2; i + 1 > 0; i--) { TreeCursorEntry *entry = &self->stack.contents[i]; - bool is_aliased = false; - if (i > 0) { - TreeCursorEntry *parent_entry = &self->stack.contents[i - 1]; - const TSSymbol *alias_sequence = ts_language_alias_sequence( - self->tree->language, - parent_entry->subtree->ptr->production_id - ); - is_aliased = alias_sequence && alias_sequence[entry->structural_child_index]; - } - if (ts_subtree_visible(*entry->subtree) || is_aliased) { + if (ts_subtree_visible(*entry->subtree)) { self->stack.size = i + 1; return true; } + if (i > 0 && !ts_subtree_extra(*entry->subtree)) { + TreeCursorEntry *parent_entry = &self->stack.contents[i - 1]; + if (ts_language_alias_at( + self->tree->language, + parent_entry->subtree->ptr->production_id, + entry->structural_child_index + )) { + self->stack.size = i + 1; + return true; + } + } } return false; } @@ -226,15 +228,13 @@ TSNode ts_tree_cursor_current_node(const TSTreeCursor *_self) { const TreeCursor *self = (const TreeCursor *)_self; TreeCursorEntry *last_entry = array_back(&self->stack); TSSymbol alias_symbol = 0; - if (self->stack.size > 1) { + if (self->stack.size > 1 && !ts_subtree_extra(*last_entry->subtree)) { TreeCursorEntry *parent_entry = &self->stack.contents[self->stack.size - 2]; - const TSSymbol *alias_sequence = ts_language_alias_sequence( + alias_symbol = ts_language_alias_at( self->tree->language, - parent_entry->subtree->ptr->production_id + parent_entry->subtree->ptr->production_id, + last_entry->structural_child_index ); - if (alias_sequence && !ts_subtree_extra(*last_entry->subtree)) { - alias_symbol = alias_sequence[last_entry->structural_child_index]; - } } return ts_node_new( self->tree, @@ -263,13 +263,14 @@ TSFieldId ts_tree_cursor_current_status( // Stop walking up when a visible ancestor is found. if (i != self->stack.size - 1) { if (ts_subtree_visible(*entry->subtree)) break; - const TSSymbol *alias_sequence = ts_language_alias_sequence( - self->tree->language, - parent_entry->subtree->ptr->production_id - ); - if (alias_sequence && alias_sequence[entry->structural_child_index]) { - break; - } + if ( + !ts_subtree_extra(*entry->subtree) && + ts_language_alias_at( + self->tree->language, + parent_entry->subtree->ptr->production_id, + entry->structural_child_index + ) + ) break; } if (ts_subtree_child_count(*parent_entry->subtree) > entry->child_index + 1) { @@ -321,13 +322,14 @@ TSFieldId ts_tree_cursor_current_field_id(const TSTreeCursor *_self) { // Stop walking up when another visible node is found. if (i != self->stack.size - 1) { if (ts_subtree_visible(*entry->subtree)) break; - const TSSymbol *alias_sequence = ts_language_alias_sequence( - self->tree->language, - parent_entry->subtree->ptr->production_id - ); - if (alias_sequence && alias_sequence[entry->structural_child_index]) { - break; - } + if ( + !ts_subtree_extra(*entry->subtree) && + ts_language_alias_at( + self->tree->language, + parent_entry->subtree->ptr->production_id, + entry->structural_child_index + ) + ) break; } if (ts_subtree_extra(*entry->subtree)) break;