From 5520983144582bf259211e6705cf588a9ae1cf0a Mon Sep 17 00:00:00 2001 From: Max Brunsfeld Date: Thu, 29 Mar 2018 17:37:54 -0700 Subject: [PATCH] Clean up Stack API * Remove StackPopResult * Rename top_state() -> state() * Rename top_position() -> position() * Improve docs --- src/runtime/parser.c | 102 ++++++++++++++++---------------- src/runtime/stack.c | 34 +++++------ src/runtime/stack.h | 95 ++++++++++++++--------------- test/runtime/stack_test.cc | 118 ++++++++++++++++++------------------- 4 files changed, 169 insertions(+), 180 deletions(-) diff --git a/src/runtime/parser.c b/src/runtime/parser.c index 7d861b25..34b4506b 100644 --- a/src/runtime/parser.c +++ b/src/runtime/parser.c @@ -76,15 +76,14 @@ static bool parser__breakdown_top_of_stack(Parser *self, StackVersion version) { bool pending = false; do { - StackPopResult pop = ts_stack_pop_pending(self->stack, version); - if (!pop.slices.size) - break; + StackSliceArray pop = ts_stack_pop_pending(self->stack, version); + if (!pop.size) break; did_break_down = true; pending = false; - for (uint32_t i = 0; i < pop.slices.size; i++) { - StackSlice slice = pop.slices.contents[i]; - TSStateId state = ts_stack_top_state(self->stack, slice.version); + for (uint32_t i = 0; i < pop.size; i++) { + StackSlice slice = pop.contents[i]; + TSStateId state = ts_stack_state(self->stack, slice.version); Tree *parent = *array_front(&slice.trees); for (uint32_t j = 0; j < parent->child_count; j++) { @@ -106,13 +105,12 @@ static bool parser__breakdown_top_of_stack(Parser *self, StackVersion version) { ts_stack_push(self->stack, slice.version, tree, false, state); } - LOG("breakdown_top_of_stack tree:%s", SYM_NAME(parent->symbol)); - LOG_STACK(); - ts_stack_decrease_push_count(self->stack, slice.version, parent->child_count + 1); - ts_tree_release(&self->tree_pool, parent); array_delete(&slice.trees); + + LOG("breakdown_top_of_stack tree:%s", SYM_NAME(parent->symbol)); + LOG_STACK(); } } while (pending); @@ -177,7 +175,7 @@ static bool parser__better_version_exists(Parser *self, StackVersion version, bool is_in_error, unsigned cost) { if (self->finished_tree && self->finished_tree->error_cost <= cost) return true; - Length position = ts_stack_top_position(self->stack, version); + Length position = ts_stack_position(self->stack, version); ErrorStatus status = { .cost = cost, .is_in_error = is_in_error, @@ -188,10 +186,10 @@ static bool parser__better_version_exists(Parser *self, StackVersion version, for (StackVersion i = 0, n = ts_stack_version_count(self->stack); i < n; i++) { if (i == version || ts_stack_is_halted(self->stack, i) || - ts_stack_top_position(self->stack, i).bytes < position.bytes) continue; + ts_stack_position(self->stack, i).bytes < position.bytes) continue; ErrorStatus status_i = { .cost = ts_stack_error_cost(self->stack, i), - .is_in_error = ts_stack_top_state(self->stack, i) == ERROR_STATE, + .is_in_error = ts_stack_state(self->stack, i) == ERROR_STATE, .dynamic_precedence = ts_stack_dynamic_precedence(self->stack, i), .push_count = ts_stack_push_count(self->stack, i) }; @@ -222,7 +220,7 @@ static unsigned parser__condense_stack(Parser *self) { .cost = ts_stack_error_cost(self->stack, i), .push_count = ts_stack_push_count(self->stack, i), .dynamic_precedence = ts_stack_dynamic_precedence(self->stack, i), - .is_in_error = ts_stack_top_state(self->stack, i) == ERROR_STATE, + .is_in_error = ts_stack_state(self->stack, i) == ERROR_STATE, }; if (!status_i.is_in_error && status_i.cost < min_error_cost) { min_error_cost = status_i.cost; @@ -233,7 +231,7 @@ static unsigned parser__condense_stack(Parser *self) { .cost = ts_stack_error_cost(self->stack, j), .push_count = ts_stack_push_count(self->stack, j), .dynamic_precedence = ts_stack_dynamic_precedence(self->stack, j), - .is_in_error = ts_stack_top_state(self->stack, j) == ERROR_STATE, + .is_in_error = ts_stack_state(self->stack, j) == ERROR_STATE, }; bool can_merge = ts_stack_can_merge(self->stack, j, i); @@ -298,7 +296,7 @@ static void parser__restore_external_scanner(Parser *self, Tree *external_token) } static Tree *parser__lex(Parser *self, StackVersion version, TSStateId parse_state) { - Length start_position = ts_stack_top_position(self->stack, version); + Length start_position = ts_stack_position(self->stack, version); Tree *external_token = ts_stack_last_external_token(self->stack, version); TSLexMode lex_mode = self->language->lex_modes[parse_state]; const bool *valid_external_tokens = ts_language_enabled_external_tokens( @@ -492,7 +490,7 @@ static bool parser__can_reuse_first_leaf(Parser *self, TSStateId state, Tree *tr static Tree *parser__get_lookahead(Parser *self, StackVersion version, TSStateId *state, ReusableNode *reusable_node, TableEntry *table_entry) { - Length position = ts_stack_top_position(self->stack, version); + Length position = ts_stack_position(self->stack, version); Tree *last_external_token = ts_stack_last_external_token(self->stack, version); Tree *result; @@ -532,7 +530,7 @@ static Tree *parser__get_lookahead(Parser *self, StackVersion version, TSStateId if (!reusable_node_breakdown(reusable_node)) { reusable_node_pop(reusable_node); parser__breakdown_top_of_stack(self, version); - *state = ts_stack_top_state(self->stack, version); + *state = ts_stack_state(self->stack, version); } continue; } @@ -652,15 +650,15 @@ static bool parser__replace_children(Parser *self, Tree *tree, Tree **children, } } -static StackPopResult parser__reduce(Parser *self, StackVersion version, TSSymbol symbol, +static StackSliceArray parser__reduce(Parser *self, StackVersion version, TSSymbol symbol, uint32_t count, int dynamic_precedence, uint16_t alias_sequence_id, bool fragile) { uint32_t initial_version_count = ts_stack_version_count(self->stack); - StackPopResult pop = ts_stack_pop_count(self->stack, version, count); + StackSliceArray pop = ts_stack_pop_count(self->stack, version, count); - for (uint32_t i = 0; i < pop.slices.size; i++) { - StackSlice slice = pop.slices.contents[i]; + for (uint32_t i = 0; i < pop.size; i++) { + StackSlice slice = pop.contents[i]; // Extra tokens on top of the stack should not be included in this new parent // node. They will be re-pushed onto the stack after the parent node is @@ -678,8 +676,8 @@ static StackPopResult parser__reduce(Parser *self, StackVersion version, TSSymbo // into one, because they all diverged from a common state. In that case, // choose one of the arrays of trees to be the parent node's children, and // delete the rest of the tree arrays. - while (i + 1 < pop.slices.size) { - StackSlice next_slice = pop.slices.contents[i + 1]; + while (i + 1 < pop.size) { + StackSlice next_slice = pop.contents[i + 1]; if (next_slice.version != slice.version) break; i++; @@ -699,9 +697,9 @@ static StackPopResult parser__reduce(Parser *self, StackVersion version, TSSymbo parent->dynamic_precedence += dynamic_precedence; parent->alias_sequence_id = alias_sequence_id; - TSStateId state = ts_stack_top_state(self->stack, slice.version); + TSStateId state = ts_stack_state(self->stack, slice.version); TSStateId next_state = ts_language_next_state(self->language, state, symbol); - if (fragile || self->in_ambiguity || pop.slices.size > 1 || initial_version_count > 1) { + if (fragile || self->in_ambiguity || pop.size > 1 || initial_version_count > 1) { parent->fragile_left = true; parent->fragile_right = true; parent->parse_state = TS_TREE_STATE_NONE; @@ -755,10 +753,10 @@ static void parser__accept(Parser *self, StackVersion version, assert(lookahead->symbol == ts_builtin_sym_end); ts_tree_retain(lookahead); ts_stack_push(self->stack, version, lookahead, false, 1); - StackPopResult pop = ts_stack_pop_all(self->stack, version); + StackSliceArray pop = ts_stack_pop_all(self->stack, version); - for (uint32_t i = 0; i < pop.slices.size; i++) { - StackSlice slice = pop.slices.contents[i]; + for (uint32_t i = 0; i < pop.size; i++) { + StackSlice slice = pop.contents[i]; TreeArray trees = slice.trees; Tree *root = NULL; @@ -792,7 +790,7 @@ static void parser__accept(Parser *self, StackVersion version, } } - ts_stack_remove_version(self->stack, pop.slices.contents[0].version); + ts_stack_remove_version(self->stack, pop.contents[0].version); ts_stack_halt(self->stack, version); } @@ -803,7 +801,7 @@ static bool parser__do_all_potential_reductions(Parser *self, StackVersion start uint32_t version_count = ts_stack_version_count(self->stack); if (version >= version_count) break; - TSStateId state = ts_stack_top_state(self->stack, version); + TSStateId state = ts_stack_state(self->stack, version); bool has_shift_action = false; array_clear(&self->reduce_actions); @@ -898,7 +896,7 @@ static void parser__handle_error(Parser *self, StackVersion version, TSSymbol lo bool did_insert_missing_token = false; for (StackVersion v = version; v < version_count;) { if (!did_insert_missing_token) { - TSStateId state = ts_stack_top_state(self->stack, v); + TSStateId state = ts_stack_state(self->stack, v); for (TSSymbol missing_symbol = 1; missing_symbol < self->language->token_count; missing_symbol++) { @@ -952,7 +950,7 @@ static void parser__halt_parse(Parser *self) { ts_lexer_advance_to_end(&self->lexer); Length remaining_length = length_sub( self->lexer.current_position, - ts_stack_top_position(self->stack, 0) + ts_stack_position(self->stack, 0) ); Tree *filler_node = ts_tree_make_error(&self->tree_pool, remaining_length, length_zero(), 0, self->language); @@ -970,28 +968,28 @@ static void parser__halt_parse(Parser *self) { static bool parser__recover_to_state(Parser *self, StackVersion version, unsigned depth, TSStateId goal_state) { - StackPopResult 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; - for (unsigned i = 0; i < pop.slices.size; i++) { - StackSlice slice = pop.slices.contents[i]; + for (unsigned i = 0; i < pop.size; i++) { + StackSlice slice = pop.contents[i]; if (slice.version == previous_version) { ts_tree_array_delete(&self->tree_pool, &slice.trees); - array_erase(&pop.slices, i--); + array_erase(&pop, i--); continue; } - if (ts_stack_top_state(self->stack, slice.version) != goal_state) { + if (ts_stack_state(self->stack, slice.version) != goal_state) { ts_stack_halt(self->stack, slice.version); ts_tree_array_delete(&self->tree_pool, &slice.trees); - array_erase(&pop.slices, i--); + array_erase(&pop, i--); continue; } - StackPopResult error_pop = ts_stack_pop_error(self->stack, slice.version); - if (error_pop.slices.size > 0) { - StackSlice error_slice = error_pop.slices.contents[0]; + StackSliceArray error_pop = ts_stack_pop_error(self->stack, slice.version); + if (error_pop.size > 0) { + StackSlice error_slice = error_pop.contents[0]; array_push_all(&error_slice.trees, &slice.trees); array_delete(&slice.trees); slice.trees = error_slice.trees; @@ -1023,7 +1021,7 @@ static bool parser__recover_to_state(Parser *self, StackVersion version, unsigne static void parser__recover(Parser *self, StackVersion version, Tree *lookahead) { bool did_recover = false; unsigned previous_version_count = ts_stack_version_count(self->stack); - Length position = ts_stack_top_position(self->stack, version); + Length position = ts_stack_position(self->stack, version); StackSummary *summary = ts_stack_get_summary(self->stack, version); for (unsigned i = 0; i < summary->size; i++) { @@ -1088,7 +1086,7 @@ static void parser__recover(Parser *self, StackVersion version, Tree *lookahead) } static void parser__advance(Parser *self, StackVersion version, ReusableNode *reusable_node) { - TSStateId state = ts_stack_top_state(self->stack, version); + TSStateId state = ts_stack_state(self->stack, version); TableEntry table_entry; Tree *lookahead = parser__get_lookahead(self, version, &state, reusable_node, &table_entry); @@ -1124,12 +1122,12 @@ static void parser__advance(Parser *self, StackVersion version, ReusableNode *re case TSParseActionTypeReduce: { bool is_fragile = table_entry.action_count > 1; LOG("reduce sym:%s, child_count:%u", SYM_NAME(action.params.symbol), action.params.child_count); - StackPopResult reduction = parser__reduce( + StackSliceArray reduction = parser__reduce( self, version, action.params.symbol, action.params.child_count, action.params.dynamic_precedence, action.params.alias_sequence_id, is_fragile ); - StackSlice slice = *array_front(&reduction.slices); + StackSlice slice = *array_front(&reduction); last_reduction_version = slice.version; break; } @@ -1168,12 +1166,12 @@ static void parser__advance(Parser *self, StackVersion version, ReusableNode *re return; } else if (lookahead->size.bytes == 0) { ts_tree_release(&self->tree_pool, lookahead); - state = ts_stack_top_state(self->stack, version); + state = ts_stack_state(self->stack, version); lookahead = parser__get_lookahead(self, version, &state, reusable_node, &table_entry); } } - state = ts_stack_top_state(self->stack, version); + state = ts_stack_state(self->stack, version); ts_language_table_entry(self->language, state, lookahead->first_leaf.symbol, &table_entry); } } @@ -1222,7 +1220,7 @@ Tree *parser_parse(Parser *self, TSInput input, Tree *old_tree, bool halt_on_err reusable_node = self->reusable_node; while (!ts_stack_is_halted(self->stack, version)) { - position = ts_stack_top_position(self->stack, version).bytes; + position = ts_stack_position(self->stack, version).bytes; if (position > last_position || (version > 0 && position == last_position)) { last_position = position; break; @@ -1230,9 +1228,9 @@ Tree *parser_parse(Parser *self, TSInput input, Tree *old_tree, bool halt_on_err LOG("process version:%d, version_count:%u, state:%d, row:%u, col:%u", version, ts_stack_version_count(self->stack), - ts_stack_top_state(self->stack, version), - ts_stack_top_position(self->stack, version).extent.row, - ts_stack_top_position(self->stack, version).extent.column); + ts_stack_state(self->stack, version), + ts_stack_position(self->stack, version).extent.row, + ts_stack_position(self->stack, version).extent.column); parser__advance(self, version, &reusable_node); LOG_STACK(); diff --git a/src/runtime/stack.c b/src/runtime/stack.c index c7252e03..162a616c 100644 --- a/src/runtime/stack.c +++ b/src/runtime/stack.c @@ -232,9 +232,9 @@ static void ts_stack__add_slice(Stack *self, StackVersion original_version, Stac array_push(&self->slices, slice); } -inline StackPopResult stack__iter(Stack *self, StackVersion version, - StackIterateInternalCallback callback, void *payload, - bool include_trees) { +inline StackSliceArray stack__iter(Stack *self, StackVersion version, + StackIterateInternalCallback callback, void *payload, + bool include_trees) { array_clear(&self->slices); array_clear(&self->iterators); @@ -315,7 +315,7 @@ inline StackPopResult stack__iter(Stack *self, StackVersion version, } } - return (StackPopResult){self->slices}; + return self->slices; } Stack *ts_stack_new(TreePool *tree_pool) { @@ -360,11 +360,11 @@ uint32_t ts_stack_version_count(const Stack *self) { return self->heads.size; } -TSStateId ts_stack_top_state(const Stack *self, StackVersion version) { +TSStateId ts_stack_state(const Stack *self, StackVersion version) { return array_get(&self->heads, version)->node->state; } -Length ts_stack_top_position(const Stack *self, StackVersion version) { +Length ts_stack_position(const Stack *self, StackVersion version) { return array_get(&self->heads, version)->node->position; } @@ -409,8 +409,8 @@ inline StackIterateAction iterate_callback(void *payload, const Iterator *iterat return session->callback(session->payload, iterator->node->state, &iterator->trees, iterator->tree_count); } -StackPopResult ts_stack_iterate(Stack *self, StackVersion version, - StackIterateCallback callback, void *payload) { +StackSliceArray ts_stack_iterate(Stack *self, StackVersion version, + StackIterateCallback callback, void *payload) { StackIterateSession session = {payload, callback}; return stack__iter(self, version, iterate_callback, &session, true); } @@ -424,7 +424,7 @@ inline StackIterateAction pop_count_callback(void *payload, const Iterator *iter } } -StackPopResult ts_stack_pop_count(Stack *self, StackVersion version, uint32_t count) { +StackSliceArray ts_stack_pop_count(Stack *self, StackVersion version, uint32_t count) { return stack__iter(self, version, pop_count_callback, &count, true); } @@ -440,11 +440,11 @@ inline StackIterateAction pop_pending_callback(void *payload, const Iterator *it } } -StackPopResult ts_stack_pop_pending(Stack *self, StackVersion version) { - StackPopResult pop = stack__iter(self, version, pop_pending_callback, NULL, true); - if (pop.slices.size > 0) { - ts_stack_renumber_version(self, pop.slices.contents[0].version, version); - pop.slices.contents[0].version = version; +StackSliceArray ts_stack_pop_pending(Stack *self, StackVersion version) { + StackSliceArray pop = stack__iter(self, version, pop_pending_callback, NULL, true); + if (pop.size > 0) { + ts_stack_renumber_version(self, pop.contents[0].version, version); + pop.contents[0].version = version; } return pop; } @@ -463,7 +463,7 @@ inline StackIterateAction pop_error_callback(void *payload, const Iterator *iter } } -StackPopResult ts_stack_pop_error(Stack *self, StackVersion version) { +StackSliceArray ts_stack_pop_error(Stack *self, StackVersion version) { StackNode *node = array_get(&self->heads, version)->node; for (unsigned i = 0; i < node->link_count; i++) { if (node->links[i].tree && node->links[i].tree->symbol == ts_builtin_sym_error) { @@ -471,14 +471,14 @@ StackPopResult ts_stack_pop_error(Stack *self, StackVersion version) { return stack__iter(self, version, pop_error_callback, &found_error, true); } } - return (StackPopResult){.slices = array_new()}; + return (StackSliceArray){.size = 0}; } inline StackIterateAction pop_all_callback(void *payload, const Iterator *iterator) { return iterator->node->link_count == 0 ? StackIteratePop : StackIterateNone; } -StackPopResult ts_stack_pop_all(Stack *self, StackVersion version) { +StackSliceArray ts_stack_pop_all(Stack *self, StackVersion version) { return stack__iter(self, version, pop_all_callback, NULL, true); } diff --git a/src/runtime/stack.h b/src/runtime/stack.h index df902b8c..a04e9a8a 100644 --- a/src/runtime/stack.h +++ b/src/runtime/stack.h @@ -19,12 +19,14 @@ typedef struct { TreeArray trees; StackVersion version; } StackSlice; - typedef Array(StackSlice) StackSliceArray; typedef struct { - StackSliceArray slices; -} StackPopResult; + Length position; + unsigned depth; + TSStateId state; +} StackSummaryEntry; +typedef Array(StackSummaryEntry) StackSummary; typedef unsigned StackIterateAction; enum { @@ -33,81 +35,74 @@ enum { StackIteratePop = 2, }; -typedef struct { - Length position; - unsigned depth; - TSStateId state; -} StackSummaryEntry; - -typedef Array(StackSummaryEntry) StackSummary; - typedef StackIterateAction (*StackIterateCallback)(void *, TSStateId state, const TreeArray *trees, uint32_t tree_count); -/* - * Create a parse stack. - */ +// Create a stack. Stack *ts_stack_new(TreePool *); -/* - * Release any resources reserved by a parse stack. - */ +// Release the memory reserved for a given stack. void ts_stack_delete(Stack *); -/* - * Get the stack's current number of versions. - */ +// Get the stack's current number of versions. uint32_t ts_stack_version_count(const Stack *); -/* - * Get the state at the top of the given version of the stack. If the stack is - * empty, this returns the initial state (0). - */ -TSStateId ts_stack_top_state(const Stack *, StackVersion); +// Get the state at the top of the given version of the stack. If the stack is +// empty, this returns the initial state, 0. +TSStateId ts_stack_state(const Stack *, StackVersion); +// Get the number of trees that have been pushed to a given version of +// the stack. unsigned ts_stack_push_count(const Stack *, StackVersion); +// In the event that trees were permanently removed from some version +// of the stack, decrease the version's push count to account for the +// removal. void ts_stack_decrease_push_count(Stack *, StackVersion, unsigned); +// Get the last external token associated with a given version of the stack. Tree *ts_stack_last_external_token(const Stack *, StackVersion); +// Set the last external token associated with a given version of the stack. void ts_stack_set_last_external_token(Stack *, StackVersion, Tree *); -/* - * Get the position at the top of the given version of the stack. If the stack - * is empty, this returns zero. - */ -Length ts_stack_top_position(const Stack *, StackVersion); +// Get the position of the given version of the stack within the document. +Length ts_stack_position(const Stack *, StackVersion); -/* - * Push a tree and state onto the given head of the stack. - */ +// Push a tree and state onto the given version of the stack. +// +// This transfers ownership of the tree to the Stack. Callers that +// need to retain ownership of the tree for their own purposes should +// first retain the tree. void ts_stack_push(Stack *, StackVersion, Tree *, bool, TSStateId); -/* - * Pop the given number of entries from the given version of the stack. This - * operation can increase the number of stack versions by revealing multiple - * versions which had previously been merged. It returns a struct that - * indicates the index of each revealed version and the trees removed from that - * version. - */ -StackPopResult ts_stack_pop_count(Stack *, StackVersion, uint32_t count); +// Pop the given number of entries from the given version of the stack. This +// operation can increase the number of stack versions by revealing multiple +// versions which had previously been merged. It returns an array that +// specifies the index of each revealed version and the trees that were +// removed from that version. +StackSliceArray ts_stack_pop_count(Stack *, StackVersion, uint32_t count); -StackPopResult ts_stack_iterate(Stack *, StackVersion, StackIterateCallback, void *); +// Remove an error at the top of the given version of the stack. +StackSliceArray ts_stack_pop_error(Stack *, StackVersion); -StackPopResult ts_stack_pop_error(Stack *, StackVersion); +// Remove any pending trees from the top of the given version of the stack. +StackSliceArray ts_stack_pop_pending(Stack *, StackVersion); -StackPopResult ts_stack_pop_pending(Stack *, StackVersion); - -StackPopResult ts_stack_pop_all(Stack *, StackVersion); +// Remove any all trees from the given version of the stack. +StackSliceArray ts_stack_pop_all(Stack *, StackVersion); unsigned ts_stack_depth_since_error(Stack *, StackVersion); int ts_stack_dynamic_precedence(Stack *, StackVersion); +// 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. void ts_stack_record_summary(Stack *, StackVersion, unsigned max_depth); +// Retrieve a summary of all the parse states near the top of the +// given version of the stack. StackSummary *ts_stack_get_summary(Stack *, StackVersion); unsigned ts_stack_error_cost(const Stack *, StackVersion version); @@ -128,17 +123,13 @@ void ts_stack_swap_versions(Stack *, StackVersion, StackVersion); StackVersion ts_stack_copy_version(Stack *, StackVersion); -/* - * Remove the given version from the stack. - */ +// Remove the given version from the stack. void ts_stack_remove_version(Stack *, StackVersion); -/* - * Remove all entries from the stack. - */ void ts_stack_clear(Stack *); bool ts_stack_print_dot_graph(Stack *, const char **, FILE *); +StackSliceArray ts_stack_iterate(Stack *, StackVersion, StackIterateCallback, void *); #ifdef __cplusplus } diff --git a/test/runtime/stack_test.cc b/test/runtime/stack_test.cc index f0eb3546..c1fcd76c 100644 --- a/test/runtime/stack_test.cc +++ b/test/runtime/stack_test.cc @@ -108,23 +108,23 @@ describe("Stack", [&]() { describe("push(version, tree, is_pending, state)", [&]() { it("adds entries to the given version of the stack", [&]() { AssertThat(ts_stack_version_count(stack), Equals(1)); - AssertThat(ts_stack_top_state(stack, 0), Equals(1)); - AssertThat(ts_stack_top_position(stack, 0), Equals(length_zero())); + AssertThat(ts_stack_state(stack, 0), Equals(1)); + AssertThat(ts_stack_position(stack, 0), Equals(length_zero())); // . <──0── A* push(0, trees[0], stateA); - AssertThat(ts_stack_top_state(stack, 0), Equals(stateA)); - AssertThat(ts_stack_top_position(stack, 0), Equals(tree_len)); + AssertThat(ts_stack_state(stack, 0), Equals(stateA)); + AssertThat(ts_stack_position(stack, 0), Equals(tree_len)); // . <──0── A <──1── B* push(0, trees[1], stateB); - AssertThat(ts_stack_top_state(stack, 0), Equals(stateB)); - AssertThat(ts_stack_top_position(stack, 0), Equals(tree_len * 2)); + AssertThat(ts_stack_state(stack, 0), Equals(stateB)); + AssertThat(ts_stack_position(stack, 0), Equals(tree_len * 2)); // . <──0── A <──1── B <──2── C* push(0, trees[2], stateC); - AssertThat(ts_stack_top_state(stack, 0), Equals(stateC)); - AssertThat(ts_stack_top_position(stack, 0), Equals(tree_len * 3)); + AssertThat(ts_stack_state(stack, 0), Equals(stateC)); + AssertThat(ts_stack_position(stack, 0), Equals(tree_len * 3)); AssertThat(get_stack_entries(stack, 0), Equals(vector({ {stateC, 0}, @@ -256,16 +256,16 @@ describe("Stack", [&]() { // . <──0── A <──1── B <──2── C* // ↑ // └─* - StackPopResult pop = ts_stack_pop_count(stack, 0, 2); - AssertThat(pop.slices.size, Equals(1)); + StackSliceArray pop = ts_stack_pop_count(stack, 0, 2); + AssertThat(pop.size, Equals(1)); AssertThat(ts_stack_version_count(stack), Equals(2)); - StackSlice slice = pop.slices.contents[0]; + StackSlice slice = pop.contents[0]; AssertThat(slice.version, Equals(1)); AssertThat(slice.trees, Equals(vector({ trees[1], trees[2] }))); - AssertThat(ts_stack_top_state(stack, 1), Equals(stateA)); + AssertThat(ts_stack_state(stack, 1), Equals(stateA)); - free_slice_array(&pool,&pop.slices); + free_slice_array(&pool,&pop); }); it("does not count 'extra' trees toward the given count", [&]() { @@ -274,14 +274,14 @@ describe("Stack", [&]() { // . <──0── A <──1── B <──2── C* // ↑ // └─* - StackPopResult pop = ts_stack_pop_count(stack, 0, 2); - AssertThat(pop.slices.size, Equals(1)); + StackSliceArray pop = ts_stack_pop_count(stack, 0, 2); + AssertThat(pop.size, Equals(1)); - StackSlice slice = pop.slices.contents[0]; + StackSlice slice = pop.contents[0]; AssertThat(slice.trees, Equals(vector({ trees[0], trees[1], trees[2] }))); - AssertThat(ts_stack_top_state(stack, 1), Equals(1)); + AssertThat(ts_stack_state(stack, 1), Equals(1)); - free_slice_array(&pool,&pop.slices); + free_slice_array(&pool,&pop); }); describe("when the version has been merged", [&]() { @@ -290,8 +290,8 @@ describe("Stack", [&]() { // ↑ | // └───4─── E <──5── F <──6───┘ push(0, trees[3], stateD); - StackPopResult pop = ts_stack_pop_count(stack, 0, 3); - free_slice_array(&pool,&pop.slices); + StackSliceArray pop = ts_stack_pop_count(stack, 0, 3); + free_slice_array(&pool,&pop); push(1, trees[4], stateE); push(1, trees[5], stateF); push(1, trees[6], stateD); @@ -318,14 +318,14 @@ describe("Stack", [&]() { // | └* // | // └───4─── E* - StackPopResult pop = ts_stack_pop_count(stack, 0, 3); - AssertThat(pop.slices.size, Equals(2)); + StackSliceArray pop = ts_stack_pop_count(stack, 0, 3); + AssertThat(pop.size, Equals(2)); - StackSlice slice1 = pop.slices.contents[0]; + StackSlice slice1 = pop.contents[0]; AssertThat(slice1.version, Equals(1)); AssertThat(slice1.trees, Equals(vector({ trees[2], trees[3], trees[10] }))); - StackSlice slice2 = pop.slices.contents[1]; + StackSlice slice2 = pop.contents[1]; AssertThat(slice2.version, Equals(2)); AssertThat(slice2.trees, Equals(vector({ trees[5], trees[6], trees[10] }))); @@ -351,7 +351,7 @@ describe("Stack", [&]() { {1, 2}, }))); - free_slice_array(&pool,&pop.slices); + free_slice_array(&pool,&pop); }); }); @@ -362,18 +362,18 @@ describe("Stack", [&]() { // └───5─── F <──6── G <──7───┘ // | // └* - StackPopResult pop = ts_stack_pop_count(stack, 0, 1); - AssertThat(pop.slices.size, Equals(1)); + StackSliceArray pop = ts_stack_pop_count(stack, 0, 1); + AssertThat(pop.size, Equals(1)); - StackSlice slice1 = pop.slices.contents[0]; + StackSlice slice1 = pop.contents[0]; AssertThat(slice1.version, Equals(1)); AssertThat(slice1.trees, Equals(vector({ trees[10] }))); AssertThat(ts_stack_version_count(stack), Equals(2)); - AssertThat(ts_stack_top_state(stack, 0), Equals(stateI)); - AssertThat(ts_stack_top_state(stack, 1), Equals(stateD)); + AssertThat(ts_stack_state(stack, 0), Equals(stateI)); + AssertThat(ts_stack_state(stack, 1), Equals(stateD)); - free_slice_array(&pool,&pop.slices); + free_slice_array(&pool,&pop); }); }); @@ -384,22 +384,22 @@ describe("Stack", [&]() { // ├───4─── E <──5── F <──6───┘ // | // └* - StackPopResult pop = ts_stack_pop_count(stack, 0, 4); - AssertThat(pop.slices.size, Equals(2)); + StackSliceArray pop = ts_stack_pop_count(stack, 0, 4); + AssertThat(pop.size, Equals(2)); - StackSlice slice1 = pop.slices.contents[0]; + StackSlice slice1 = pop.contents[0]; AssertThat(slice1.version, Equals(1)); AssertThat(slice1.trees, Equals(vector({ trees[1], trees[2], trees[3], trees[10] }))); - StackSlice slice2 = pop.slices.contents[1]; + StackSlice slice2 = pop.contents[1]; AssertThat(slice2.version, Equals(1)); AssertThat(slice2.trees, Equals(vector({ trees[4], trees[5], trees[6], trees[10] }))); AssertThat(ts_stack_version_count(stack), Equals(2)); - AssertThat(ts_stack_top_state(stack, 0), Equals(stateI)); - AssertThat(ts_stack_top_state(stack, 1), Equals(stateA)); + AssertThat(ts_stack_state(stack, 0), Equals(stateI)); + AssertThat(ts_stack_state(stack, 1), Equals(stateA)); - free_slice_array(&pool,&pop.slices); + free_slice_array(&pool,&pop); }); }); @@ -410,8 +410,8 @@ describe("Stack", [&]() { // ├───4─── E <──5── F <──6───┘ // | | // └───7─── G <──8── H <──9───┘ - StackPopResult pop = ts_stack_pop_count(stack, 0, 4); - free_slice_array(&pool,&pop.slices); + StackSliceArray pop = ts_stack_pop_count(stack, 0, 4); + free_slice_array(&pool,&pop); push(1, trees[7], stateG); push(1, trees[8], stateH); push(1, trees[9], stateD); @@ -440,27 +440,27 @@ describe("Stack", [&]() { // | // └───7─── G <──8── H* pop = ts_stack_pop_count(stack, 0, 2); - AssertThat(pop.slices.size, Equals(3)); + AssertThat(pop.size, Equals(3)); - StackSlice slice1 = pop.slices.contents[0]; + StackSlice slice1 = pop.contents[0]; AssertThat(slice1.version, Equals(1)); AssertThat(slice1.trees, Equals(vector({ trees[3], trees[10] }))); - StackSlice slice2 = pop.slices.contents[1]; + StackSlice slice2 = pop.contents[1]; AssertThat(slice2.version, Equals(2)); AssertThat(slice2.trees, Equals(vector({ trees[6], trees[10] }))); - StackSlice slice3 = pop.slices.contents[2]; + StackSlice slice3 = pop.contents[2]; AssertThat(slice3.version, Equals(3)); AssertThat(slice3.trees, Equals(vector({ trees[9], trees[10] }))); AssertThat(ts_stack_version_count(stack), Equals(4)); - AssertThat(ts_stack_top_state(stack, 0), Equals(stateI)); - AssertThat(ts_stack_top_state(stack, 1), Equals(stateC)); - AssertThat(ts_stack_top_state(stack, 2), Equals(stateF)); - AssertThat(ts_stack_top_state(stack, 3), Equals(stateH)); + AssertThat(ts_stack_state(stack, 0), Equals(stateI)); + AssertThat(ts_stack_state(stack, 1), Equals(stateC)); + AssertThat(ts_stack_state(stack, 2), Equals(stateF)); + AssertThat(ts_stack_state(stack, 3), Equals(stateH)); - free_slice_array(&pool,&pop.slices); + free_slice_array(&pool,&pop); }); }); }); @@ -475,15 +475,15 @@ describe("Stack", [&]() { ts_stack_push(stack, 0, trees[1], true, stateB); ts_tree_retain(trees[1]); - StackPopResult pop = ts_stack_pop_pending(stack, 0); - AssertThat(pop.slices.size, Equals(1)); + StackSliceArray pop = ts_stack_pop_pending(stack, 0); + AssertThat(pop.size, Equals(1)); AssertThat(get_stack_entries(stack, 0), Equals(vector({ {stateA, 0}, {1, 1}, }))); - free_slice_array(&pool,&pop.slices); + free_slice_array(&pool,&pop); }); it("skips entries whose trees are extra", [&]() { @@ -496,24 +496,24 @@ describe("Stack", [&]() { push(0, trees[2], stateB); push(0, trees[3], stateB); - StackPopResult pop = ts_stack_pop_pending(stack, 0); - AssertThat(pop.slices.size, Equals(1)); + StackSliceArray pop = ts_stack_pop_pending(stack, 0); + AssertThat(pop.size, Equals(1)); - AssertThat(pop.slices.contents[0].trees, Equals(vector({ trees[1], trees[2], trees[3] }))); + AssertThat(pop.contents[0].trees, Equals(vector({ trees[1], trees[2], trees[3] }))); AssertThat(get_stack_entries(stack, 0), Equals(vector({ {stateA, 0}, {1, 1}, }))); - free_slice_array(&pool,&pop.slices); + free_slice_array(&pool,&pop); }); it("does nothing if the top node was not pushed in pending mode", [&]() { push(0, trees[1], stateB); - StackPopResult pop = ts_stack_pop_pending(stack, 0); - AssertThat(pop.slices.size, Equals(0)); + StackSliceArray pop = ts_stack_pop_pending(stack, 0); + AssertThat(pop.size, Equals(0)); AssertThat(get_stack_entries(stack, 0), Equals(vector({ {stateB, 0}, @@ -521,7 +521,7 @@ describe("Stack", [&]() { {1, 2}, }))); - free_slice_array(&pool,&pop.slices); + free_slice_array(&pool,&pop); }); });