diff --git a/Makefile b/Makefile index e847fc39..9fdf2a73 100644 --- a/Makefile +++ b/Makefile @@ -6,7 +6,7 @@ # By: rparodi +#+ +:+ +#+ # # +#+#+#+#+#+ +#+ # # Created: 2023/11/12 11:05:05 by rparodi #+# #+# # -# Updated: 2024/08/14 17:36:13 by maiboyer ### ########.fr # +# Updated: 2024/08/14 19:09:04 by maiboyer ### ########.fr # # # # **************************************************************************** # diff --git a/ast/src/from_node/node_utils.c b/ast/src/from_node/node_utils.c index 597ad519..42a9b6b0 100644 --- a/ast/src/from_node/node_utils.c +++ b/ast/src/from_node/node_utils.c @@ -1,12 +1,12 @@ /* ************************************************************************** */ /* */ /* ::: :::::::: */ -/* ast_utils.c :+: :+: :+: */ +/* node_utils.c :+: :+: :+: */ /* +:+ +:+ +:+ */ /* By: rparodi +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2024/08/04 10:55:45 by rparodi #+# #+# */ -/* Updated: 2024/08/04 11:06:14 by rparodi ### ########.fr */ +/* Updated: 2024/08/14 18:29:10 by maiboyer ### ########.fr */ /* */ /* ************************************************************************** */ @@ -45,7 +45,6 @@ t_ast_expansion_operator _extract_exp_op(t_parse_node self) t_ast_expansion_operator kind; t_symbol symbol; - kind = E_OP_NONE; symbol = ts_node_grammar_symbol(self); if (symbol == anon_sym_DASH) kind = E_OP_DEFAULT; diff --git a/exec/src/run_ast.c b/exec/src/run_ast.c index 6d137038..3fc1c9bc 100644 --- a/exec/src/run_ast.c +++ b/exec/src/run_ast.c @@ -6,7 +6,7 @@ /* By: maiboyer +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2024/07/11 17:22:29 by maiboyer #+# #+# */ -/* Updated: 2024/08/14 18:13:54 by maiboyer ### ########.fr */ +/* Updated: 2024/08/14 18:30:23 by maiboyer ### ########.fr */ /* */ /* ************************************************************************** */ @@ -523,7 +523,6 @@ t_error _ast_into_str(t_ast_node self, t_state *state, t_vec_str *append) // t_error run_heredoc_redirection(t_ast_heredoc_redirection *heredoc_redirection, t_state *state, void *out) NOT_DONE; // t_error run_raw_string(t_ast_raw_string *raw_string, t_state *state, void *out) NOT_DONE; - t_error run_case_(t_ast_case *case_, t_state *state, void *out) NOT_DONE; t_error run_case_item(t_ast_case_item *case_item, t_state *state, void *out) NOT_DONE; t_error run_command_substitution(t_ast_command_substitution *command_substitution, t_state *state, void *out) NOT_DONE; @@ -709,6 +708,7 @@ t_error run_subshell(t_ast_subshell *subshell, t_state *state, t_cmd_pipe cmd_pi if (info.stderr != NULL) (dup2(info.stderr->fd, 2), close_fd(info.stderr)); i = 0; + code = 0; while (i < subshell->body.len) { if (_run_get_exit_code(subshell->body.buffer[i], state, &code)) @@ -719,6 +719,8 @@ t_error run_subshell(t_ast_subshell *subshell, t_state *state, t_cmd_pipe cmd_pi } if (forked == -1) return (ERROR); + out->exit = -1; + out->pid = forked; if (info.stdin != NULL) (dup2(info.stdin->fd, 0), close_fd(info.stdin)); if (info.stdout != NULL) @@ -726,7 +728,7 @@ t_error run_subshell(t_ast_subshell *subshell, t_state *state, t_cmd_pipe cmd_pi if (info.stderr != NULL) (dup2(info.stderr->fd, 2), close_fd(info.stderr)); if (cmd_pipe.create_output || cmd_pipe.input != NULL) - return (out->pid = forked, out->stdout = info.ret_stdout, NO_ERROR); + return (out->stdout = info.ret_stdout, NO_ERROR); int status; if (waitpid(forked, &status, 0) == -1) return (ERROR); diff --git a/parser/include/parser/stack.h b/parser/include/parser/stack.h index 8b7dbd81..63cb62d2 100644 --- a/parser/include/parser/stack.h +++ b/parser/include/parser/stack.h @@ -1,14 +1,14 @@ #ifndef PARSE_STACK_H #define PARSE_STACK_H +#include "me/types.h" #include "parser/array.h" #include "parser/subtree.h" -#include "me/types.h" typedef struct Stack Stack; typedef t_u32 StackVersion; -#define STACK_VERSION_NONE ((StackVersion)-1) +#define STACK_VERSION_NONE ((StackVersion) - 1) typedef struct StackSlice { @@ -29,7 +29,7 @@ typedef Array(StackSummaryEntry) StackSummary; typedef void (*StackIterateCallback)(void *, TSStateId, t_u32); // Create a stack. -Stack *ts_stack_new(SubtreePool *); +Stack *ts_stack_new(void); // Release the memory reserved for a given stack. void ts_stack_delete(Stack *); diff --git a/parser/include/parser/subtree.h b/parser/include/parser/subtree.h index 1082518e..0ab3f253 100644 --- a/parser/include/parser/subtree.h +++ b/parser/include/parser/subtree.h @@ -1,11 +1,11 @@ #ifndef SUBTREE_H #define SUBTREE_H +#include "me/types.h" #include "parser/api.h" #include "parser/array.h" #include "parser/length.h" #include "parser/parser.h" -#include "me/types.h" #include #include #include @@ -36,37 +36,6 @@ struct ExternalScannerState // separately on the heap. typedef struct ExternalScannerState ExternalScannerState; -// A compact representation of a subtree. -// -// This representation is used for small leaf nodes that are not -// errors, and were not created by an external scanner. -// -// The idea behind the layout of this struct is that the `is_inline` -// bit will fall exactly into the same location as the least significant -// bit of the pointer in `Subtree` or `MutableSubtree`, respectively. -// Because of alignment, for any valid pointer this will be 0, giving -// us the opportunity to make use of this bit to signify whether to use -// the pointer or the inline struct. -typedef struct SubtreeInlineData SubtreeInlineData; - -struct SubtreeInlineData -{ - bool is_inline : 1; - bool visible : 1; - bool named : 1; - bool extra : 1; - bool has_changes : 1; - bool is_missing : 1; - bool is_keyword : 1; - t_u8 symbol; - t_u16 parse_state; - t_u8 padding_columns; - t_u8 padding_rows : 4; - t_u8 lookahead_bytes : 4; - t_u8 padding_bytes; - t_u8 size_bytes; -}; - // A heap-allocated representation of a subtree. // // This representation is used for parent nodes, external tokens, @@ -74,14 +43,14 @@ struct SubtreeInlineData // the inline representation. typedef struct SubtreeHeapData { - volatile t_u32 ref_count; - Length padding; - Length size; - t_u32 lookahead_bytes; - t_u32 error_cost; - t_u32 child_count; - TSSymbol symbol; - TSStateId parse_state; + t_u32 ref_count; + Length padding; + Length size; + t_u32 lookahead_bytes; + t_u32 error_cost; + t_u32 child_count; + TSSymbol symbol; + TSStateId parse_state; bool visible : 1; bool named : 1; @@ -122,94 +91,83 @@ typedef struct SubtreeHeapData // The fundamental building block of a syntax tree. typedef union Subtree { - SubtreeInlineData data; const SubtreeHeapData *ptr; } Subtree; // Like Subtree, but mutable. typedef union MutableSubtree { - SubtreeInlineData data; - SubtreeHeapData *ptr; + SubtreeHeapData *ptr; } MutableSubtree; typedef Array(Subtree) SubtreeArray; typedef Array(MutableSubtree) MutableSubtreeArray; -typedef struct SubtreePool -{ - MutableSubtreeArray free_trees; - MutableSubtreeArray tree_stack; -} SubtreePool; - void ts_external_scanner_state_init(ExternalScannerState *, const t_u8 *, t_u32); const t_u8 *ts_external_scanner_state_data(const ExternalScannerState *); bool ts_external_scanner_state_eq(const ExternalScannerState *self, const t_u8 *, t_u32); void ts_external_scanner_state_delete(ExternalScannerState *self); void ts_subtree_array_copy(SubtreeArray, SubtreeArray *); -void ts_subtree_array_clear(SubtreePool *, SubtreeArray *); -void ts_subtree_array_delete(SubtreePool *, SubtreeArray *); +void ts_subtree_array_clear(SubtreeArray *); +void ts_subtree_array_delete(SubtreeArray *); void ts_subtree_array_remove_trailing_extras(SubtreeArray *, SubtreeArray *); void ts_subtree_array_reverse(SubtreeArray *); -SubtreePool ts_subtree_pool_new(t_u32 capacity); -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_error(SubtreePool *, t_i32, Length, Length, t_u32, TSStateId, 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_missing_leaf(SubtreePool *, TSSymbol, Length, t_u32, const TSLanguage *); -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 *, t_u32, 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 *); -Subtree ts_subtree_last_external_token(Subtree); +Subtree ts_subtree_new_leaf(TSSymbol, Length, Length, t_u32, TSStateId, bool, bool, bool, const TSLanguage *); +Subtree ts_subtree_new_error(t_i32, Length, Length, t_u32, TSStateId, 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_missing_leaf(TSSymbol, Length, t_u32, const TSLanguage *); +MutableSubtree ts_subtree_make_mut(Subtree); +void ts_subtree_retain(Subtree); +void ts_subtree_release(Subtree); +int ts_subtree_compare(Subtree, Subtree); +void ts_subtree_set_symbol(MutableSubtree *, TSSymbol, const TSLanguage *); +void ts_subtree_summarize(MutableSubtree, const Subtree *, t_u32, const TSLanguage *); +void ts_subtree_summarize_children(MutableSubtree, const TSLanguage *); +void ts_subtree_balance(Subtree, const TSLanguage *); +Subtree ts_subtree_edit(Subtree, const TSInputEdit *edit); +char *ts_subtree_string(Subtree, TSSymbol, bool, const TSLanguage *, bool include_all); +void ts_subtree_print_dot_graph(Subtree, const TSLanguage *, 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); static inline TSSymbol ts_subtree_symbol(Subtree self) { - return ((self).data.is_inline ? (self).data.symbol : (self).ptr->symbol); + return ((self).ptr->symbol); } static inline bool ts_subtree_visible(Subtree self) { - return ((self).data.is_inline ? (self).data.visible : (self).ptr->visible); + return ((self).ptr->visible); } static inline bool ts_subtree_named(Subtree self) { - return ((self).data.is_inline ? (self).data.named : (self).ptr->named); + return ((self).ptr->named); } static inline bool ts_subtree_extra(Subtree self) { - return ((self).data.is_inline ? (self).data.extra : (self).ptr->extra); + return ((self).ptr->extra); } static inline bool ts_subtree_has_changes(Subtree self) { - return ((self).data.is_inline ? (self).data.has_changes : (self).ptr->has_changes); + return ((self).ptr->has_changes); } static inline bool ts_subtree_missing(Subtree self) { - return ((self).data.is_inline ? (self).data.is_missing : (self).ptr->is_missing); + return ((self).ptr->is_missing); } static inline bool ts_subtree_is_keyword(Subtree self) { - return ((self).data.is_inline ? (self).data.is_keyword : (self).ptr->is_keyword); + return ((self).ptr->is_keyword); } static inline TSStateId ts_subtree_parse_state(Subtree self) { - return ((self).data.is_inline ? (self).data.parse_state : (self).ptr->parse_state); + return ((self).ptr->parse_state); } static inline t_u32 ts_subtree_lookahead_bytes(Subtree self) { - return ((self).data.is_inline ? (self).data.lookahead_bytes : (self).ptr->lookahead_bytes); + return ((self).ptr->lookahead_bytes); } // Get the size needed to store a heap-allocated subtree with the given @@ -221,20 +179,15 @@ static inline size_t ts_subtree_alloc_size(t_u32 child_count) // Get a subtree's children, which are allocated immediately before the // tree's own heap data. -#define ts_subtree_children(self) ((self).data.is_inline ? NULL : (Subtree *)((self).ptr) - (self).ptr->child_count) +#define ts_subtree_children(self) ((Subtree *)((self).ptr) - (self).ptr->child_count) static inline void ts_subtree_set_extra(MutableSubtree *self, bool is_extra) { - if (self->data.is_inline) - self->data.extra = is_extra; - else - self->ptr->extra = is_extra; + self->ptr->extra = is_extra; } static inline TSSymbol 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; @@ -242,8 +195,6 @@ static inline TSSymbol ts_subtree_leaf_symbol(Subtree self) static inline TSStateId 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; @@ -251,18 +202,12 @@ static inline TSStateId ts_subtree_leaf_parse_state(Subtree self) static inline Length ts_subtree_padding(Subtree self) { - if (self.data.is_inline) - return ((Length){self.data.padding_bytes, {self.data.padding_rows, self.data.padding_columns}}); - else - return self.ptr->padding; + return self.ptr->padding; } static inline Length ts_subtree_size(Subtree self) { - if (self.data.is_inline) - return ((Length){self.data.size_bytes, {0, self.data.size_bytes}}); - else - return self.ptr->size; + return self.ptr->size; } static inline Length ts_subtree_total_size(Subtree self) @@ -277,22 +222,22 @@ static inline t_u32 ts_subtree_total_bytes(Subtree self) static inline t_u32 ts_subtree_child_count(Subtree self) { - return (self.data.is_inline ? 0 : self.ptr->child_count); + return (self.ptr->child_count); } static inline t_u32 ts_subtree_repeat_depth(Subtree self) { - return (self.data.is_inline ? 0 : self.ptr->repeat_depth); + return (self.ptr->repeat_depth); } static inline t_u32 ts_subtree_is_repetition(Subtree self) { - return (self.data.is_inline ? 0 : !self.ptr->named && !self.ptr->visible && self.ptr->child_count != 0); + return (!self.ptr->named && !self.ptr->visible && self.ptr->child_count != 0); } static inline t_u32 ts_subtree_visible_descendant_count(Subtree self) { - return ((self.data.is_inline || self.ptr->child_count == 0) ? 0 : self.ptr->visible_descendant_count); + return ((self.ptr->child_count == 0) ? 0 : self.ptr->visible_descendant_count); } static inline t_u32 ts_subtree_visible_child_count(Subtree self) @@ -308,12 +253,12 @@ static inline t_u32 ts_subtree_error_cost(Subtree self) if (ts_subtree_missing(self)) return (ERROR_COST_PER_MISSING_TREE + ERROR_COST_PER_RECOVERY); else - return (self.data.is_inline ? 0 : self.ptr->error_cost); + return (self.ptr->error_cost); } static inline t_i32 ts_subtree_dynamic_precedence(Subtree self) { - return ((self.data.is_inline || self.ptr->child_count == 0) ? 0 : self.ptr->dynamic_precedence); + return ((self.ptr->child_count == 0) ? 0 : self.ptr->dynamic_precedence); } static inline t_u16 ts_subtree_production_id(Subtree self) @@ -326,32 +271,32 @@ static inline t_u16 ts_subtree_production_id(Subtree self) static inline bool ts_subtree_fragile_left(Subtree self) { - return (self.data.is_inline ? false : self.ptr->fragile_left); + return (self.ptr->fragile_left); } static inline bool ts_subtree_fragile_right(Subtree self) { - return (self.data.is_inline ? false : self.ptr->fragile_right); + return (self.ptr->fragile_right); } static inline bool ts_subtree_has_external_tokens(Subtree self) { - return (self.data.is_inline ? false : self.ptr->has_external_tokens); + return (self.ptr->has_external_tokens); } static inline bool ts_subtree_has_external_scanner_state_change(Subtree self) { - return (self.data.is_inline ? false : self.ptr->has_external_scanner_state_change); + return (self.ptr->has_external_scanner_state_change); } static inline bool ts_subtree_depends_on_column(Subtree self) { - return (self.data.is_inline ? false : self.ptr->depends_on_column); + return (self.ptr->depends_on_column); } static inline bool ts_subtree_is_fragile(Subtree self) { - return (self.data.is_inline ? false : (self.ptr->fragile_left || self.ptr->fragile_right)); + return ((self.ptr->fragile_left || self.ptr->fragile_right)); } static inline bool ts_subtree_is_error(Subtree self) @@ -368,7 +313,7 @@ static inline Subtree ts_subtree_from_mut(MutableSubtree self) { Subtree result; - result.data = self.data; + result.ptr = self.ptr; return (result); } @@ -376,7 +321,7 @@ static inline MutableSubtree ts_subtree_to_mut_unsafe(Subtree self) { MutableSubtree result; - result.data = self.data; + result.ptr = (void *)self.ptr; return (result); } diff --git a/parser/src/node.c b/parser/src/node.c index f85bc3e1..2281eebb 100644 --- a/parser/src/node.c +++ b/parser/src/node.c @@ -84,6 +84,8 @@ static inline bool ts_node_child_iterator_next(NodeChildIterator *self, TSNode * return false; const Subtree *child = &ts_subtree_children(self->parent)[self->child_index]; TSSymbol alias_symbol = 0; + if (child == NULL) + return (false); if (!ts_subtree_extra(*child)) { if (self->alias_sequence) @@ -509,12 +511,14 @@ t_const_str ts_node_grammar_type(TSNode self) return ts_language_symbol_name(self.tree->language, symbol); } +/* char *ts_node_string(TSNode self) { TSSymbol alias_symbol = ts_node__alias(&self); return ts_subtree_string(ts_node__subtree(self), alias_symbol, ts_language_symbol_metadata(self.tree->language, alias_symbol).visible, self.tree->language, false); } +*/ bool ts_node_eq(TSNode self, TSNode other) { diff --git a/parser/src/parser.c b/parser/src/parser.c index 1d3ecb1a..fd8cfa5a 100644 --- a/parser/src/parser.c +++ b/parser/src/parser.c @@ -1,5 +1,7 @@ #define _POSIX_C_SOURCE 200112L +#include "me/mem/mem.h" +#include "me/types.h" #include "parser/api.h" #include "parser/array.h" #include "parser/language.h" @@ -9,8 +11,6 @@ #include "parser/stack.h" #include "parser/subtree.h" #include "parser/tree.h" -#include "me/mem/mem.h" -#include "me/types.h" #include #include @@ -40,7 +40,6 @@ struct TSParser { Lexer lexer; Stack *stack; - SubtreePool tree_pool; const TSLanguage *language; ReduceActionSet reduce_actions; Subtree finished_tree; @@ -163,7 +162,7 @@ static bool ts_parser__breakdown_top_of_stack(TSParser *self, StackVersion versi ts_stack_push(self->stack, slice.version, tree, false, state); } - ts_subtree_release(&self->tree_pool, parent); + ts_subtree_release(parent); array_delete(&slice.subtrees); LOG("breakdown_top_of_stack tree:%s", TREE_NAME(parent)); @@ -487,7 +486,7 @@ static Subtree ts_parser__lex(TSParser *self, StackVersion version, TSStateId pa Length padding = length_sub(error_start_position, start_position); Length size = length_sub(error_end_position, error_start_position); t_u32 lookahead_bytes = lookahead_end_byte - error_end_position.bytes; - result = ts_subtree_new_error(&self->tree_pool, first_error_character, padding, size, lookahead_bytes, parse_state, self->language); + result = ts_subtree_new_error(first_error_character, padding, size, lookahead_bytes, parse_state, self->language); } else { @@ -516,8 +515,8 @@ static Subtree ts_parser__lex(TSParser *self, StackVersion version, TSStateId pa } } - result = ts_subtree_new_leaf(&self->tree_pool, symbol, padding, size, lookahead_bytes, parse_state, found_external_token, - called_get_column, is_keyword, self->language); + result = ts_subtree_new_leaf(symbol, padding, size, lookahead_bytes, parse_state, found_external_token, called_get_column, + is_keyword, self->language); if (found_external_token) { @@ -556,9 +555,9 @@ static void ts_parser__set_cached_token(TSParser *self, t_u32 byte_index, Subtre if (last_external_token.ptr) ts_subtree_retain(last_external_token); if (cache->token.ptr) - ts_subtree_release(&self->tree_pool, cache->token); + ts_subtree_release(cache->token); if (cache->last_external_token.ptr) - ts_subtree_release(&self->tree_pool, cache->last_external_token); + ts_subtree_release(cache->last_external_token); cache->token = token; cache->byte_index = byte_index; cache->last_external_token = last_external_token; @@ -570,6 +569,7 @@ static void ts_parser__set_cached_token(TSParser *self, t_u32 byte_index, Subtre // 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) { + (void)(self); if (!left.ptr) return true; if (!right.ptr) @@ -604,7 +604,7 @@ static bool ts_parser__select_tree(TSParser *self, Subtree left, Subtree right) if (ts_subtree_error_cost(left) > 0) return true; - int comparison = ts_subtree_compare(left, right, &self->tree_pool); + int comparison = ts_subtree_compare(left, right); switch (comparison) { case -1: @@ -641,7 +641,7 @@ static void ts_parser__shift(TSParser *self, StackVersion version, TSStateId sta Subtree subtree_to_push = lookahead; if (extra != ts_subtree_extra(lookahead) && is_leaf) { - MutableSubtree result = ts_subtree_make_mut(&self->tree_pool, lookahead); + MutableSubtree result = ts_subtree_make_mut(lookahead); ts_subtree_set_extra(&result, extra); subtree_to_push = ts_subtree_from_mut(result); } @@ -677,14 +677,14 @@ static StackVersion ts_parser__reduce(TSParser *self, StackVersion version, TSSy if (slice_version > MAX_VERSION_COUNT + MAX_VERSION_COUNT_OVERFLOW) { ts_stack_remove_version(self->stack, slice_version); - ts_subtree_array_delete(&self->tree_pool, &slice.subtrees); + ts_subtree_array_delete(&slice.subtrees); removed_version_count++; while (i + 1 < pop.size) { StackSlice next_slice = pop.contents[i + 1]; if (next_slice.version != slice.version) break; - ts_subtree_array_delete(&self->tree_pool, &next_slice.subtrees); + ts_subtree_array_delete(&next_slice.subtrees); i++; } continue; @@ -714,15 +714,15 @@ static StackVersion ts_parser__reduce(TSParser *self, StackVersion version, TSSy if (ts_parser__select_children(self, ts_subtree_from_mut(parent), &next_slice_children)) { - ts_subtree_array_clear(&self->tree_pool, &self->trailing_extras); - ts_subtree_release(&self->tree_pool, ts_subtree_from_mut(parent)); + ts_subtree_array_clear(&self->trailing_extras); + ts_subtree_release(ts_subtree_from_mut(parent)); array_swap(&self->trailing_extras, &self->trailing_extras2); parent = ts_subtree_new_node(symbol, &next_slice_children, production_id, self->language); } else { array_clear(&self->trailing_extras2); - ts_subtree_array_delete(&self->tree_pool, &next_slice.subtrees); + ts_subtree_array_delete(&next_slice.subtrees); } } @@ -784,7 +784,6 @@ static void ts_parser__accept(TSParser *self, StackVersion version, Subtree look Subtree tree = trees.contents[j]; if (!ts_subtree_extra(tree)) { - assert(!tree.data.is_inline); t_u32 child_count = ts_subtree_child_count(tree); const Subtree *children = ts_subtree_children(tree); for (t_u32 k = 0; k < child_count; k++) @@ -793,7 +792,7 @@ static void ts_parser__accept(TSParser *self, StackVersion version, Subtree look } array_splice(&trees, j, 1, child_count, children); root = ts_subtree_from_mut(ts_subtree_new_node(ts_subtree_symbol(tree), &trees, tree.ptr->production_id, self->language)); - ts_subtree_release(&self->tree_pool, tree); + ts_subtree_release(tree); break; } } @@ -805,12 +804,12 @@ static void ts_parser__accept(TSParser *self, StackVersion version, Subtree look { if (ts_parser__select_tree(self, self->finished_tree, root)) { - ts_subtree_release(&self->tree_pool, self->finished_tree); + ts_subtree_release(self->finished_tree); self->finished_tree = root; } else { - ts_subtree_release(&self->tree_pool, root); + ts_subtree_release(root); } } else @@ -939,7 +938,7 @@ static bool ts_parser__recover_to_state(TSParser *self, StackVersion version, t_ if (slice.version == previous_version) { - ts_subtree_array_delete(&self->tree_pool, &slice.subtrees); + ts_subtree_array_delete(&slice.subtrees); array_erase(&pop, i--); continue; } @@ -947,7 +946,7 @@ static bool ts_parser__recover_to_state(TSParser *self, StackVersion version, t_ if (ts_stack_state(self->stack, slice.version) != goal_state) { ts_stack_halt(self->stack, slice.version); - ts_subtree_array_delete(&self->tree_pool, &slice.subtrees); + ts_subtree_array_delete(&slice.subtrees); array_erase(&pop, i--); continue; } @@ -966,7 +965,7 @@ static bool ts_parser__recover_to_state(TSParser *self, StackVersion version, t_ ts_subtree_retain(slice.subtrees.contents[j]); } } - ts_subtree_array_delete(&self->tree_pool, &error_trees); + ts_subtree_array_delete(&error_trees); } ts_subtree_array_remove_trailing_extras(&slice.subtrees, &self->trailing_extras); @@ -1081,14 +1080,14 @@ static void ts_parser__recover(TSParser *self, StackVersion version, Subtree loo if (did_recover && ts_stack_version_count(self->stack) > MAX_VERSION_COUNT) { ts_stack_halt(self->stack, version); - ts_subtree_release(&self->tree_pool, lookahead); + ts_subtree_release(lookahead); return; } if (did_recover && ts_subtree_has_external_scanner_state_change(lookahead)) { ts_stack_halt(self->stack, version); - ts_subtree_release(&self->tree_pool, lookahead); + ts_subtree_release(lookahead); return; } @@ -1110,7 +1109,7 @@ static void ts_parser__recover(TSParser *self, StackVersion version, Subtree loo if (ts_parser__better_version_exists(self, version, false, new_cost)) { ts_stack_halt(self->stack, version); - ts_subtree_release(&self->tree_pool, lookahead); + ts_subtree_release(lookahead); return; } @@ -1120,7 +1119,7 @@ static void ts_parser__recover(TSParser *self, StackVersion version, Subtree loo 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) { - MutableSubtree mutable_lookahead = ts_subtree_make_mut(&self->tree_pool, lookahead); + MutableSubtree mutable_lookahead = ts_subtree_make_mut(lookahead); ts_subtree_set_extra(&mutable_lookahead, true); lookahead = ts_subtree_from_mut(mutable_lookahead); } @@ -1147,7 +1146,7 @@ static void ts_parser__recover(TSParser *self, StackVersion version, Subtree loo { for (t_u32 i = 1; i < pop.size; i++) { - ts_subtree_array_delete(&self->tree_pool, &pop.contents[i].subtrees); + ts_subtree_array_delete(&pop.contents[i].subtrees); } while (ts_stack_version_count(self->stack) > pop.contents[0].version + 1) { @@ -1206,8 +1205,7 @@ static void ts_parser__handle_error(TSParser *self, StackVersion version, Subtre t_u32 lookahead_bytes = ts_subtree_total_bytes(lookahead) + ts_subtree_lookahead_bytes(lookahead); StackVersion version_with_missing_tree = ts_stack_copy_version(self->stack, v); - Subtree missing_tree = - ts_subtree_new_missing_leaf(&self->tree_pool, missing_symbol, padding, lookahead_bytes, self->language); + Subtree missing_tree = ts_subtree_new_missing_leaf(missing_symbol, padding, lookahead_bytes, self->language); ts_stack_push(self->stack, version_with_missing_tree, missing_tree, false, state_after_missing_symbol); if (ts_parser__do_all_potential_reductions(self, version_with_missing_tree, ts_subtree_leaf_symbol(lookahead))) @@ -1297,7 +1295,7 @@ static bool ts_parser__advance(TSParser *self, StackVersion version, bool allow_ { if (lookahead.ptr) { - ts_subtree_release(&self->tree_pool, lookahead); + ts_subtree_release(lookahead); } return false; } @@ -1413,7 +1411,7 @@ static bool ts_parser__advance(TSParser *self, StackVersion version, bool allow_ { LOG("switch from_keyword:%s, to_word_token:%s", TREE_NAME(lookahead), SYM_NAME(self->language->keyword_capture_token)); - MutableSubtree mutable_lookahead = ts_subtree_make_mut(&self->tree_pool, lookahead); + MutableSubtree mutable_lookahead = ts_subtree_make_mut(lookahead); ts_subtree_set_symbol(&mutable_lookahead, self->language->keyword_capture_token, self->language); lookahead = ts_subtree_from_mut(mutable_lookahead); continue; @@ -1437,7 +1435,7 @@ static bool ts_parser__advance(TSParser *self, StackVersion version, bool allow_ if (ts_parser__breakdown_top_of_stack(self, version)) { state = ts_stack_state(self->stack, version); - ts_subtree_release(&self->tree_pool, lookahead); + ts_subtree_release(lookahead); needs_lex = true; continue; } @@ -1586,8 +1584,7 @@ TSParser *ts_parser_new(void) ts_lexer_init(&self->lexer); array_init(&self->reduce_actions); array_reserve(&self->reduce_actions, 4); - self->tree_pool = ts_subtree_pool_new(32); - self->stack = ts_stack_new(&self->tree_pool); + self->stack = ts_stack_new(); self->finished_tree = NULL_SUBTREE; self->cancellation_flag = NULL; self->language = NULL; @@ -1613,12 +1610,11 @@ void ts_parser_delete(TSParser *self) } if (self->old_tree.ptr) { - ts_subtree_release(&self->tree_pool, self->old_tree); + ts_subtree_release(self->old_tree); self->old_tree = NULL_SUBTREE; } ts_lexer_delete(&self->lexer); ts_parser__set_cached_token(self, 0, NULL_SUBTREE, NULL_SUBTREE); - ts_subtree_pool_delete(&self->tree_pool); array_delete(&self->trailing_extras); array_delete(&self->trailing_extras2); array_delete(&self->scratch_trees); @@ -1651,7 +1647,7 @@ void ts_parser_reset(TSParser *self) ts_parser__external_scanner_destroy(self); if (self->old_tree.ptr) { - ts_subtree_release(&self->tree_pool, self->old_tree); + ts_subtree_release(self->old_tree); self->old_tree = NULL_SUBTREE; } @@ -1660,7 +1656,7 @@ void ts_parser_reset(TSParser *self) ts_parser__set_cached_token(self, 0, NULL_SUBTREE, NULL_SUBTREE); if (self->finished_tree.ptr) { - ts_subtree_release(&self->tree_pool, self->finished_tree); + ts_subtree_release(self->finished_tree); self->finished_tree = NULL_SUBTREE; } self->accept_count = 0; @@ -1739,7 +1735,7 @@ TSTree *ts_parser_parse(TSParser *self, const TSTree *old_tree, TSInput input) } while (version_count != 0); assert(self->finished_tree.ptr); - ts_subtree_balance(self->finished_tree, &self->tree_pool, self->language); + ts_subtree_balance(self->finished_tree, self->language); LOG("done"); LOG_TREE(self->finished_tree); diff --git a/parser/src/stack.c b/parser/src/stack.c index b64fd055..07b10131 100644 --- a/parser/src/stack.c +++ b/parser/src/stack.c @@ -1,11 +1,11 @@ #include "parser/stack.h" +#include "me/mem/mem.h" +#include "me/types.h" #include "parser/array.h" #include "parser/language.h" #include "parser/length.h" #include "parser/subtree.h" -#include "me/mem/mem.h" -#include "me/types.h" #include #include @@ -24,14 +24,14 @@ typedef struct StackLink struct StackNode { - TSStateId state; - Length position; - StackLink links[MAX_LINK_COUNT]; - t_u16 link_count; - t_u32 ref_count; - t_u32 error_cost; - t_u32 node_count; - int dynamic_precedence; + TSStateId state; + Length position; + StackLink links[MAX_LINK_COUNT]; + t_u16 link_count; + t_u32 ref_count; + t_u32 error_cost; + t_u32 node_count; + int dynamic_precedence; }; typedef struct StackIterator @@ -55,7 +55,7 @@ typedef struct StackHead { StackNode *node; StackSummary *summary; - t_u32 node_count_at_last_error; + t_u32 node_count_at_last_error; Subtree last_external_token; Subtree lookahead_when_paused; StackStatus status; @@ -68,7 +68,6 @@ struct Stack Array(StackIterator) iterators; StackNodeArray node_pool; StackNode *base_node; - SubtreePool *subtree_pool; }; typedef t_u32 StackAction; @@ -90,7 +89,7 @@ static void stack_node_retain(StackNode *self) assert(self->ref_count != 0); } -static void stack_node_release(StackNode *self, StackNodeArray *pool, SubtreePool *subtree_pool) +static void stack_node_release(StackNode *self, StackNodeArray *pool) { recur: assert(self->ref_count != 0); @@ -105,12 +104,12 @@ recur: { StackLink link = self->links[i]; if (link.subtree.ptr) - ts_subtree_release(subtree_pool, link.subtree); - stack_node_release(link.node, pool, subtree_pool); + ts_subtree_release(link.subtree); + stack_node_release(link.node, pool); } StackLink link = self->links[0]; if (link.subtree.ptr) - ts_subtree_release(subtree_pool, link.subtree); + ts_subtree_release(link.subtree); first_predecessor = self->links[0].node; } @@ -203,7 +202,7 @@ static bool stack__subtree_is_equivalent(Subtree left, Subtree right) ts_subtree_extra(left) == ts_subtree_extra(right) && ts_subtree_external_scanner_state_eq(left, right)); } -static void stack_node_add_link(StackNode *self, StackLink link, SubtreePool *subtree_pool) +static void stack_node_add_link(StackNode *self, StackLink link) { if (link.node == self) return; @@ -222,7 +221,7 @@ static void stack_node_add_link(StackNode *self, StackLink link, SubtreePool *su if (ts_subtree_dynamic_precedence(link.subtree) > ts_subtree_dynamic_precedence(existing_link->subtree)) { ts_subtree_retain(link.subtree); - ts_subtree_release(subtree_pool, existing_link->subtree); + ts_subtree_release(existing_link->subtree); existing_link->subtree = link.subtree; self->dynamic_precedence = link.node->dynamic_precedence + ts_subtree_dynamic_precedence(link.subtree); } @@ -235,7 +234,7 @@ static void stack_node_add_link(StackNode *self, StackLink link, SubtreePool *su { for (int j = 0; j < link.node->link_count; j++) { - stack_node_add_link(existing_link->node, link.node->links[j], subtree_pool); + stack_node_add_link(existing_link->node, link.node->links[j]); } t_i32 dynamic_precedence = link.node->dynamic_precedence; if (link.subtree.ptr) @@ -256,7 +255,7 @@ static void stack_node_add_link(StackNode *self, StackLink link, SubtreePool *su stack_node_retain(link.node); 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; if (link.subtree.ptr) @@ -272,24 +271,24 @@ static void stack_node_add_link(StackNode *self, StackLink link, SubtreePool *su self->dynamic_precedence = dynamic_precedence; } -static void stack_head_delete(StackHead *self, StackNodeArray *pool, SubtreePool *subtree_pool) +static void stack_head_delete(StackHead *self, StackNodeArray *pool) { if (self->node) { if (self->last_external_token.ptr) { - ts_subtree_release(subtree_pool, self->last_external_token); + ts_subtree_release(self->last_external_token); } if (self->lookahead_when_paused.ptr) { - ts_subtree_release(subtree_pool, self->lookahead_when_paused); + ts_subtree_release(self->lookahead_when_paused); } if (self->summary) { array_delete(self->summary); mem_free(self->summary); } - stack_node_release(self->node, pool, subtree_pool); + stack_node_release(self->node, pool); } } @@ -375,7 +374,7 @@ static StackSliceArray stack__iter(Stack *self, StackVersion version, StackCallb { if (!should_pop) { - ts_subtree_array_delete(self->subtree_pool, &iterator->subtrees); + ts_subtree_array_delete(&iterator->subtrees); } array_erase(&self->iterators, i); i--, size--; @@ -432,7 +431,7 @@ static StackSliceArray stack__iter(Stack *self, StackVersion version, StackCallb return self->slices; } -Stack *ts_stack_new(SubtreePool *subtree_pool) +Stack *ts_stack_new(void) { Stack *self = mem_alloc_array(1, sizeof(Stack)); @@ -445,7 +444,6 @@ Stack *ts_stack_new(SubtreePool *subtree_pool) array_reserve(&self->iterators, 4); array_reserve(&self->node_pool, MAX_NODE_POOL_SIZE); - self->subtree_pool = subtree_pool; self->base_node = stack_node_new(NULL, NULL_SUBTREE, false, 1, &self->node_pool); ts_stack_clear(self); @@ -458,10 +456,10 @@ void ts_stack_delete(Stack *self) array_delete(&self->slices); if (self->iterators.contents) array_delete(&self->iterators); - stack_node_release(self->base_node, &self->node_pool, self->subtree_pool); + stack_node_release(self->base_node, &self->node_pool); for (t_u32 i = 0; i < self->heads.size; i++) { - stack_head_delete(&self->heads.contents[i], &self->node_pool, self->subtree_pool); + stack_head_delete(&self->heads.contents[i], &self->node_pool); } array_clear(&self->heads); if (self->node_pool.contents) @@ -500,14 +498,14 @@ void ts_stack_set_last_external_token(Stack *self, StackVersion version, Subtree if (token.ptr) ts_subtree_retain(token); if (head->last_external_token.ptr) - ts_subtree_release(self->subtree_pool, head->last_external_token); + ts_subtree_release(head->last_external_token); head->last_external_token = token; } t_u32 ts_stack_error_cost(const Stack *self, StackVersion version) { StackHead *head = array_get(&self->heads, version); - t_u32 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)) { result += ERROR_COST_PER_RECOVERY; @@ -639,14 +637,14 @@ StackSliceArray ts_stack_pop_all(Stack *self, StackVersion version) typedef struct SummarizeStackSession { StackSummary *summary; - t_u32 max_depth; + t_u32 max_depth; } SummarizeStackSession; StackAction summarize_stack_callback(void *payload, const StackIterator *iterator) { SummarizeStackSession *session = payload; TSStateId state = iterator->node->state; - t_u32 depth = iterator->subtree_count; + t_u32 depth = iterator->subtree_count; if (depth > session->max_depth) return StackActionStop; for (t_u32 i = session->summary->size - 1; i + 1 > 0; i--) @@ -720,7 +718,7 @@ bool ts_stack_has_advanced_since_error(const Stack *self, StackVersion version) void ts_stack_remove_version(Stack *self, StackVersion version) { - stack_head_delete(array_get(&self->heads, version), &self->node_pool, self->subtree_pool); + stack_head_delete(array_get(&self->heads, version), &self->node_pool); array_erase(&self->heads, version); } @@ -737,7 +735,7 @@ void ts_stack_renumber_version(Stack *self, StackVersion v1, StackVersion v2) source_head->summary = target_head->summary; target_head->summary = NULL; } - stack_head_delete(target_head, &self->node_pool, self->subtree_pool); + stack_head_delete(target_head, &self->node_pool); *target_head = *source_head; array_erase(&self->heads, v1); } @@ -769,7 +767,7 @@ bool ts_stack_merge(Stack *self, StackVersion version1, StackVersion version2) StackHead *head2 = &self->heads.contents[version2]; for (t_u32 i = 0; i < head2->node->link_count; i++) { - stack_node_add_link(head1->node, head2->node->links[i], self->subtree_pool); + stack_node_add_link(head1->node, head2->node->links[i]); } if (head1->node->state == ERROR_STATE) { @@ -831,7 +829,7 @@ void ts_stack_clear(Stack *self) stack_node_retain(self->base_node); for (t_u32 i = 0; i < self->heads.size; i++) { - stack_head_delete(&self->heads.contents[i], &self->node_pool, self->subtree_pool); + stack_head_delete(&self->heads.contents[i], &self->node_pool); } array_clear(&self->heads); array_push(&self->heads, ((StackHead){ diff --git a/parser/src/subtree.c b/parser/src/subtree.c index afa2a10d..5984e2e7 100644 --- a/parser/src/subtree.c +++ b/parser/src/subtree.c @@ -1,15 +1,19 @@ #include #include +#include #include #include -#include +#include "me/mem/mem.h" #include "me/types.h" #include "parser/array.h" #include "parser/language.h" #include "parser/length.h" #include "parser/subtree.h" -#include "me/mem/mem.h" + +#pragma GCC diagnostic ignored "-Wunused-parameter" +#pragma GCC diagnostic ignored "-Wunknown-pragmas" +#pragma clang diagnostic ignored "-Wunused-parameter" typedef struct { @@ -91,18 +95,18 @@ void ts_subtree_array_copy(SubtreeArray self, SubtreeArray *dest) } } -void ts_subtree_array_clear(SubtreePool *pool, SubtreeArray *self) +void ts_subtree_array_clear(SubtreeArray *self) { for (t_u32 i = 0; i < self->size; i++) { - ts_subtree_release(pool, self->contents[i]); + ts_subtree_release(self->contents[i]); } array_clear(self); } -void ts_subtree_array_delete(SubtreePool *pool, SubtreeArray *self) +void ts_subtree_array_delete(SubtreeArray *self) { - ts_subtree_array_clear(pool, self); + ts_subtree_array_clear(self); array_delete(self); } @@ -136,139 +140,60 @@ void ts_subtree_array_reverse(SubtreeArray *self) } } -// SubtreePool - -SubtreePool ts_subtree_pool_new(t_u32 capacity) +static SubtreeHeapData *ts_subtree_pool_allocate() { - SubtreePool self = {array_new(), array_new()}; - array_reserve(&self.free_trees, capacity); - return self; + return mem_alloc(sizeof(SubtreeHeapData)); } -void ts_subtree_pool_delete(SubtreePool *self) -{ - if (self->free_trees.contents) - { - for (t_u32 i = 0; i < self->free_trees.size; i++) - { - mem_free(self->free_trees.contents[i].ptr); - } - array_delete(&self->free_trees); - } - if (self->tree_stack.contents) - array_delete(&self->tree_stack); -} - -static SubtreeHeapData *ts_subtree_pool_allocate(SubtreePool *self) -{ - if (self->free_trees.size > 0) - { - return array_pop(&self->free_trees).ptr; - } - else - { - return mem_alloc(sizeof(SubtreeHeapData)); - } -} - -static void ts_subtree_pool_free(SubtreePool *self, SubtreeHeapData *tree) -{ - if (self->free_trees.capacity > 0 && self->free_trees.size + 1 <= TS_MAX_TREE_POOL_SIZE) - { - array_push(&self->free_trees, (MutableSubtree){.ptr = tree}); - } - else - { - mem_free(tree); - } -} +// static void ts_subtree_pool_free(SubtreeHeapData *tree) +//{ +// mem_free(tree); +// } // Subtree -static inline bool ts_subtree_can_inline(Length padding, Length size, t_u32 lookahead_bytes) -{ - return padding.bytes < TS_MAX_INLINE_TREE_LENGTH && padding.extent.row < 16 && padding.extent.column < TS_MAX_INLINE_TREE_LENGTH && - size.extent.row == 0 && size.extent.column < TS_MAX_INLINE_TREE_LENGTH && lookahead_bytes < 16; -} - -Subtree ts_subtree_new_leaf(SubtreePool *pool, TSSymbol symbol, Length padding, Length size, t_u32 lookahead_bytes, - TSStateId parse_state, bool has_external_tokens, bool depends_on_column, bool is_keyword, - const TSLanguage *language) +Subtree ts_subtree_new_leaf(TSSymbol symbol, Length padding, Length size, t_u32 lookahead_bytes, TSStateId parse_state, + bool has_external_tokens, bool depends_on_column, bool is_keyword, const TSLanguage *language) { TSSymbolMetadata metadata = ts_language_symbol_metadata(language, symbol); bool extra = symbol == ts_builtin_sym_end; - bool is_inline = (symbol <= UINT8_MAX && !has_external_tokens && ts_subtree_can_inline(padding, size, lookahead_bytes)); - - if (is_inline) - { - return (Subtree){{ - .parse_state = parse_state, - .symbol = symbol, - .padding_bytes = padding.bytes, - .padding_rows = padding.extent.row, - .padding_columns = padding.extent.column, - .size_bytes = size.bytes, - .lookahead_bytes = lookahead_bytes, - .visible = metadata.visible, - .named = metadata.named, - .extra = extra, - .has_changes = false, - .is_missing = false, - .is_keyword = is_keyword, - .is_inline = true, - }}; - } - else - { - SubtreeHeapData *data = ts_subtree_pool_allocate(pool); - *data = (SubtreeHeapData){.ref_count = 1, - .padding = padding, - .size = size, - .lookahead_bytes = lookahead_bytes, - .error_cost = 0, - .child_count = 0, - .symbol = symbol, - .parse_state = parse_state, - .visible = metadata.visible, - .named = metadata.named, - .extra = extra, - .fragile_left = false, - .fragile_right = false, - .has_changes = false, - .has_external_tokens = has_external_tokens, - .has_external_scanner_state_change = false, - .depends_on_column = depends_on_column, - .is_missing = false, - .is_keyword = is_keyword, - {{.first_leaf = {.symbol = 0, .parse_state = 0}}}}; - return (Subtree){.ptr = data}; - } + SubtreeHeapData *data = ts_subtree_pool_allocate(); + *data = (SubtreeHeapData){.ref_count = 1, + .padding = padding, + .size = size, + .lookahead_bytes = lookahead_bytes, + .error_cost = 0, + .child_count = 0, + .symbol = symbol, + .parse_state = parse_state, + .visible = metadata.visible, + .named = metadata.named, + .extra = extra, + .fragile_left = false, + .fragile_right = false, + .has_changes = false, + .has_external_tokens = has_external_tokens, + .has_external_scanner_state_change = false, + .depends_on_column = depends_on_column, + .is_missing = false, + .is_keyword = is_keyword, + {{.first_leaf = {.symbol = 0, .parse_state = 0}}}}; + return (Subtree){.ptr = data}; } void ts_subtree_set_symbol(MutableSubtree *self, TSSymbol symbol, const TSLanguage *language) { TSSymbolMetadata metadata = ts_language_symbol_metadata(language, symbol); - if (self->data.is_inline) - { - assert(symbol < UINT8_MAX); - self->data.symbol = symbol; - self->data.named = metadata.named; - self->data.visible = metadata.visible; - } - else - { - self->ptr->symbol = symbol; - self->ptr->named = metadata.named; - self->ptr->visible = metadata.visible; - } + self->ptr->symbol = symbol; + self->ptr->named = metadata.named; + self->ptr->visible = metadata.visible; } -Subtree ts_subtree_new_error(SubtreePool *pool, t_i32 lookahead_char, Length padding, Length size, t_u32 bytes_scanned, - TSStateId parse_state, const TSLanguage *language) +Subtree ts_subtree_new_error(t_i32 lookahead_char, Length padding, Length size, t_u32 bytes_scanned, TSStateId parse_state, + const TSLanguage *language) { - Subtree result = - ts_subtree_new_leaf(pool, ts_builtin_sym_error, padding, size, bytes_scanned, parse_state, false, false, false, language); + Subtree result = ts_subtree_new_leaf(ts_builtin_sym_error, padding, size, bytes_scanned, parse_state, false, false, false, language); SubtreeHeapData *data = (SubtreeHeapData *)result.ptr; data->fragile_left = true; data->fragile_right = true; @@ -304,17 +229,16 @@ MutableSubtree ts_subtree_clone(Subtree self) // This takes ownership of the subtree. If the subtree has only one owner, // this will directly convert it into a mutable version. Otherwise, it will // perform a copy. -MutableSubtree ts_subtree_make_mut(SubtreePool *pool, Subtree self) +MutableSubtree ts_subtree_make_mut(Subtree self) { - if (self.data.is_inline) - return (MutableSubtree){self.data}; if (self.ptr->ref_count == 1) return ts_subtree_to_mut_unsafe(self); MutableSubtree result = ts_subtree_clone(self); - ts_subtree_release(pool, self); + ts_subtree_release(self); return result; } +/* static void ts_subtree__compress(MutableSubtree self, t_u32 count, const TSLanguage *language, MutableSubtreeArray *stack) { t_u32 initial_stack_size = stack->size; @@ -327,12 +251,11 @@ static void ts_subtree__compress(MutableSubtree self, t_u32 count, const TSLangu break; MutableSubtree child = ts_subtree_to_mut_unsafe(ts_subtree_children(tree)[0]); - if (child.data.is_inline || child.ptr->child_count < 2 || child.ptr->ref_count > 1 || child.ptr->symbol != symbol) + if (child.ptr->child_count < 2 || child.ptr->ref_count > 1 || child.ptr->symbol != symbol) break; MutableSubtree grandchild = ts_subtree_to_mut_unsafe(ts_subtree_children(child)[0]); - if (grandchild.data.is_inline || grandchild.ptr->child_count < 2 || grandchild.ptr->ref_count > 1 || - grandchild.ptr->symbol != symbol) + if (grandchild.ptr->child_count < 2 || grandchild.ptr->ref_count > 1 || grandchild.ptr->symbol != symbol) break; ts_subtree_children(tree)[0] = ts_subtree_from_mut(grandchild); @@ -352,11 +275,12 @@ static void ts_subtree__compress(MutableSubtree self, t_u32 count, const TSLangu ts_subtree_summarize_children(tree, language); } } +*/ -void ts_subtree_balance(Subtree self, SubtreePool *pool, const TSLanguage *language) +void ts_subtree_balance(Subtree self, const TSLanguage *language) { - array_clear(&pool->tree_stack); - + printf("BALANCING TREES\n"); + /* if (ts_subtree_child_count(self) > 0 && self.ptr->ref_count == 1) { array_push(&pool->tree_stack, ts_subtree_to_mut_unsafe(self)); @@ -391,13 +315,12 @@ 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) { - assert(!self.data.is_inline); - self.ptr->named_child_count = 0; self.ptr->visible_child_count = 0; self.ptr->error_cost = 0; @@ -408,9 +331,9 @@ void ts_subtree_summarize_children(MutableSubtree self, const TSLanguage *langua self.ptr->has_external_scanner_state_change = false; self.ptr->dynamic_precedence = 0; - t_u32 structural_index = 0; + t_u32 structural_index = 0; const TSSymbol *alias_sequence = ts_language_alias_sequence(language, self.ptr->production_id); - t_u32 lookahead_end_byte = 0; + t_u32 lookahead_end_byte = 0; const Subtree *children = ts_subtree_children(self); for (t_u32 i = 0; i < self.ptr->child_count; i++) @@ -589,38 +512,51 @@ Subtree ts_subtree_new_error_node(SubtreeArray *children, bool extra, const TSLa // // This node is treated as 'extra'. Its children are prevented from having // having any effect on the parse state. -Subtree ts_subtree_new_missing_leaf(SubtreePool *pool, TSSymbol symbol, Length padding, t_u32 lookahead_bytes, - const TSLanguage *language) +Subtree ts_subtree_new_missing_leaf(TSSymbol symbol, Length padding, t_u32 lookahead_bytes, const TSLanguage *language) { - Subtree result = ts_subtree_new_leaf(pool, symbol, padding, length_zero(), lookahead_bytes, 0, false, false, false, language); - if (result.data.is_inline) - { - result.data.is_missing = true; - } - else - { - ((SubtreeHeapData *)result.ptr)->is_missing = true; - } + Subtree result = ts_subtree_new_leaf(symbol, padding, length_zero(), lookahead_bytes, 0, false, false, false, language); + ((SubtreeHeapData *)result.ptr)->is_missing = true; return result; } void ts_subtree_retain(Subtree self) { - if (self.data.is_inline) - return; assert(self.ptr->ref_count > 0); (*(t_u32 *)(&self.ptr->ref_count))++; assert(self.ptr->ref_count != 0); } -void ts_subtree_release(SubtreePool *pool, Subtree self) +void ts_subtree_release(Subtree self) { - if (self.data.is_inline) - return; + t_usize i; + Subtree *children; + if (self.ptr->ref_count != 0 && --(*(t_u32 *)(&self.ptr->ref_count)) == 0) + { + + if (self.ptr->child_count > 0) + { + children = ts_subtree_children(self); + i = 0; + while (i < self.ptr->child_count) + ts_subtree_release(children[i++]); + mem_free(children); + } + else + { + + if (self.ptr->has_external_tokens) + { + ts_external_scanner_state_delete((void *)&self.ptr->external_scanner_state); + } + mem_free((void *)self.ptr); + } + } + + /* array_clear(&pool->tree_stack); assert(self.ptr->ref_count > 0); - if (--(*(t_u32 *)(&self.ptr->ref_count)) == 0) + if () { array_push(&pool->tree_stack, ts_subtree_to_mut_unsafe(self)); } @@ -634,8 +570,6 @@ void ts_subtree_release(SubtreePool *pool, Subtree self) for (t_u32 i = 0; i < tree.ptr->child_count; i++) { Subtree child = children[i]; - if (child.data.is_inline) - continue; assert(child.ptr->ref_count > 0); if (--(*(t_u32 *)(&child.ptr->ref_count)) == 0) { @@ -653,10 +587,13 @@ void ts_subtree_release(SubtreePool *pool, Subtree self) ts_subtree_pool_free(pool, tree.ptr); } } + */ } -int ts_subtree_compare(Subtree left, Subtree right, SubtreePool *pool) +int ts_subtree_compare(Subtree left, Subtree right) { + printf("SUBTREE COMPARE\n"); + /* array_push(&pool->tree_stack, ts_subtree_to_mut_unsafe(left)); array_push(&pool->tree_stack, ts_subtree_to_mut_unsafe(right)); @@ -687,24 +624,17 @@ int ts_subtree_compare(Subtree left, Subtree right, SubtreePool *pool) array_push(&pool->tree_stack, ts_subtree_to_mut_unsafe(left_child)); array_push(&pool->tree_stack, ts_subtree_to_mut_unsafe(right_child)); } - } + }*/ return 0; } static inline void ts_subtree_set_has_changes(MutableSubtree *self) { - if (self->data.is_inline) - { - self->data.has_changes = true; - } - else - { - self->ptr->has_changes = true; - } + self->ptr->has_changes = true; } -Subtree ts_subtree_edit(Subtree self, const TSInputEdit *input_edit, SubtreePool *pool) +Subtree ts_subtree_edit(Subtree self, const TSInputEdit *input_edit) { typedef struct { @@ -731,11 +661,11 @@ Subtree ts_subtree_edit(Subtree self, const TSInputEdit *input_edit, SubtreePool bool is_pure_insertion = edit.old_end.bytes == edit.start.bytes; bool invalidate_first_row = ts_subtree_depends_on_column(*entry.tree); - Length size = ts_subtree_size(*entry.tree); - Length padding = ts_subtree_padding(*entry.tree); - Length total_size = length_add(padding, size); - t_u32 lookahead_bytes = ts_subtree_lookahead_bytes(*entry.tree); - t_u32 end_byte = total_size.bytes + lookahead_bytes; + Length size = ts_subtree_size(*entry.tree); + Length padding = ts_subtree_padding(*entry.tree); + Length total_size = length_add(padding, size); + t_u32 lookahead_bytes = ts_subtree_lookahead_bytes(*entry.tree); + t_u32 end_byte = total_size.bytes + lookahead_bytes; if (edit.start.bytes > end_byte || (is_noop && edit.start.bytes == end_byte)) continue; @@ -767,46 +697,10 @@ Subtree ts_subtree_edit(Subtree self, const TSInputEdit *input_edit, SubtreePool size = length_add(length_sub(edit.new_end, padding), length_saturating_sub(total_size, edit.old_end)); } - MutableSubtree result = ts_subtree_make_mut(pool, *entry.tree); + MutableSubtree result = ts_subtree_make_mut(*entry.tree); - if (result.data.is_inline) - { - if (ts_subtree_can_inline(padding, size, lookahead_bytes)) - { - result.data.padding_bytes = padding.bytes; - result.data.padding_rows = padding.extent.row; - result.data.padding_columns = padding.extent.column; - result.data.size_bytes = size.bytes; - } - else - { - SubtreeHeapData *data = ts_subtree_pool_allocate(pool); - data->ref_count = 1; - data->padding = padding; - data->size = size; - data->lookahead_bytes = lookahead_bytes; - data->error_cost = 0; - data->child_count = 0; - data->symbol = result.data.symbol; - data->parse_state = result.data.parse_state; - data->visible = result.data.visible; - data->named = result.data.named; - data->extra = result.data.extra; - data->fragile_left = false; - data->fragile_right = false; - data->has_changes = false; - data->has_external_tokens = false; - data->depends_on_column = false; - data->is_missing = result.data.is_missing; - data->is_keyword = result.data.is_keyword; - result.ptr = data; - } - } - else - { - result.ptr->padding = padding; - result.ptr->size = size; - } + result.ptr->padding = padding; + result.ptr->size = size; ts_subtree_set_has_changes(&result); *entry.tree = ts_subtree_from_mut(result); @@ -885,215 +779,10 @@ Subtree ts_subtree_last_external_token(Subtree tree) return tree; } -static size_t ts_subtree__write_char_to_string(char *str, size_t n, t_i32 chr) -{ - if (chr == -1) - return snprintf(str, n, "INVALID"); - else if (chr == '\0') - return snprintf(str, n, "'\\0'"); - else if (chr == '\n') - return snprintf(str, n, "'\\n'"); - else if (chr == '\t') - return snprintf(str, n, "'\\t'"); - else if (chr == '\r') - return snprintf(str, n, "'\\r'"); - else if (0 < chr && chr < 128 && isprint(chr)) - return snprintf(str, n, "'%c'", chr); - else - return snprintf(str, n, "%d", chr); -} - -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, - TSSymbol alias_symbol, bool alias_is_named, t_const_str field_name) -{ - if (!self.ptr) - return snprintf(string, limit, "(NULL)"); - - char *cursor = string; - char **writer = (limit > 1) ? &cursor : &string; - bool is_root = field_name == ROOT_FIELD; - bool is_visible = - include_all || ts_subtree_missing(self) || (alias_symbol ? alias_is_named : ts_subtree_visible(self) && ts_subtree_named(self)); - - if (is_visible) - { - if (!is_root) - { - cursor += snprintf(*writer, limit, " "); - if (field_name) - { - cursor += snprintf(*writer, limit, "%s: ", field_name); - } - } - - if (ts_subtree_is_error(self) && ts_subtree_child_count(self) == 0 && self.ptr->size.bytes > 0) - { - 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_const_str symbol_name = ts_language_symbol_name(language, symbol); - if (ts_subtree_missing(self)) - { - cursor += snprintf(*writer, limit, "(MISSING "); - if (alias_is_named || ts_subtree_named(self)) - { - cursor += snprintf(*writer, limit, "%s", symbol_name); - } - else - { - cursor += snprintf(*writer, limit, "\"%s\"", symbol_name); - } - } - else - { - cursor += snprintf(*writer, limit, "(%s", symbol_name); - } - } - } - else if (is_root) - { - TSSymbol symbol = alias_symbol ? alias_symbol : ts_subtree_symbol(self); - t_const_str symbol_name = ts_language_symbol_name(language, symbol); - if (ts_subtree_child_count(self) > 0) - { - cursor += snprintf(*writer, limit, "(%s", symbol_name); - } - else if (ts_subtree_named(self)) - { - cursor += snprintf(*writer, limit, "(%s)", symbol_name); - } - else - { - cursor += snprintf(*writer, limit, "(\"%s\")", symbol_name); - } - } - - if (ts_subtree_child_count(self)) - { - const TSSymbol *alias_sequence = ts_language_alias_sequence(language, self.ptr->production_id); - const TSFieldMapEntry *field_map, *field_map_end; - ts_language_field_map(language, self.ptr->production_id, &field_map, &field_map_end); - - t_u32 structural_child_index = 0; - for (t_u32 i = 0; i < self.ptr->child_count; i++) - { - Subtree child = ts_subtree_children(self)[i]; - if (ts_subtree_extra(child)) - { - cursor += ts_subtree__write_to_string(child, *writer, limit, language, include_all, 0, false, NULL); - } - else - { - TSSymbol subtree_alias_symbol = alias_sequence ? alias_sequence[structural_child_index] : 0; - bool subtree_alias_is_named = - subtree_alias_symbol ? ts_language_symbol_metadata(language, subtree_alias_symbol).named : false; - - t_const_str child_field_name = is_visible ? NULL : field_name; - for (const TSFieldMapEntry *map = field_map; map < field_map_end; map++) - { - if (!map->inherited && map->child_index == structural_child_index) - { - child_field_name = language->field_names[map->field_id]; - break; - } - } - - cursor += ts_subtree__write_to_string(child, *writer, limit, language, include_all, subtree_alias_symbol, - subtree_alias_is_named, child_field_name); - structural_child_index++; - } - } - } - - if (is_visible) - cursor += snprintf(*writer, limit, ")"); - - return cursor - string; -} - -char *ts_subtree_string(Subtree self, TSSymbol alias_symbol, bool alias_is_named, const TSLanguage *language, bool include_all) -{ - char scratch_string[1]; - size_t size = ts_subtree__write_to_string(self, scratch_string, 1, language, include_all, alias_symbol, alias_is_named, ROOT_FIELD) + 1; - char *result = mem_alloc(size * sizeof(char)); - ts_subtree__write_to_string(self, result, size, language, include_all, alias_symbol, alias_is_named, ROOT_FIELD); - return result; -} - - -/* -void ts_subtree__print_dot_graph(const Subtree *self, t_u32 start_offset, const TSLanguage *language, TSSymbol alias_symbol, FILE *f) -{ - TSSymbol subtree_symbol = ts_subtree_symbol(*self); - TSSymbol symbol = alias_symbol ? alias_symbol : subtree_symbol; - t_u32 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); - fprintf(f, "\""); - - if (ts_subtree_child_count(*self) == 0) - fprintf(f, ", shape=plaintext"); - if (ts_subtree_extra(*self)) - fprintf(f, ", fontcolor=gray"); - - fprintf(f, - ", tooltip=\"" - "range: %u - %u\n" - "state: %d\n" - "error-cost: %u\n" - "has-changes: %u\n" - "depends-on-column: %u\n" - "descendant-count: %u\n" - "repeat-depth: %u\n" - "lookahead-bytes: %u", - start_offset, end_offset, ts_subtree_parse_state(*self), ts_subtree_error_cost(*self), ts_subtree_has_changes(*self), - ts_subtree_depends_on_column(*self), ts_subtree_visible_descendant_count(*self), ts_subtree_repeat_depth(*self), - ts_subtree_lookahead_bytes(*self)); - - if (ts_subtree_is_error(*self) && ts_subtree_child_count(*self) == 0 && self->ptr->lookahead_char != 0) - { - fprintf(f, "\ncharacter: '%c'", self->ptr->lookahead_char); - } - - fprintf(f, "\"]\n"); - - t_u32 child_start_offset = start_offset; - t_u32 child_info_offset = language->max_alias_sequence_length * ts_subtree_production_id(*self); - for (t_u32 i = 0, n = ts_subtree_child_count(*self); i < n; i++) - { - const Subtree *child = &ts_subtree_children(*self)[i]; - TSSymbol subtree_alias_symbol = 0; - if (!ts_subtree_extra(*child) && child_info_offset) - { - subtree_alias_symbol = language->alias_sequences[child_info_offset]; - child_info_offset++; - } - ts_subtree__print_dot_graph(child, child_start_offset, language, subtree_alias_symbol, f); - fprintf(f, "tree_%p -> tree_%p [tooltip=%u]\n", (void *)self, (void *)child, i); - child_start_offset += ts_subtree_total_bytes(*child); - } -} -*/ - -/* -void ts_subtree_print_dot_graph(Subtree self, const TSLanguage *language, FILE *f) -{ - fprintf(f, "digraph tree {\n"); - fprintf(f, "edge [arrowhead=none]\n"); - ts_subtree__print_dot_graph(&self, 0, language, 0, f); - fprintf(f, "}\n"); -} -*/ - const ExternalScannerState *ts_subtree_external_scanner_state(Subtree self) { static const ExternalScannerState empty_state = {{.short_data = {0}}, .length = 0}; - if (self.ptr && !self.data.is_inline && self.ptr->has_external_tokens && self.ptr->child_count == 0) + if (self.ptr && self.ptr->has_external_tokens && self.ptr->child_count == 0) { return &self.ptr->external_scanner_state; } diff --git a/parser/src/tree.c b/parser/src/tree.c index da90fa43..1198e772 100644 --- a/parser/src/tree.c +++ b/parser/src/tree.c @@ -30,10 +30,6 @@ void ts_tree_delete(TSTree *self) { if (!self) return; - - SubtreePool pool = ts_subtree_pool_new(0); - ts_subtree_release(&pool, self->root); - ts_subtree_pool_delete(&pool); ts_language_delete(self->language); mem_free(self->included_ranges); mem_free(self); @@ -94,10 +90,6 @@ void ts_tree_edit(TSTree *self, const TSInputEdit *edit) range->start_point = edit->start_point; } } - - SubtreePool pool = ts_subtree_pool_new(0); - self->root = ts_subtree_edit(self->root, edit, &pool); - ts_subtree_pool_delete(&pool); } TSRange *ts_tree_included_ranges(const TSTree *self, t_u32 *length)