diff --git a/spec/helpers/tree_helpers.cc b/spec/helpers/tree_helpers.cc index 574fb801..682ec2c7 100644 --- a/spec/helpers/tree_helpers.cc +++ b/spec/helpers/tree_helpers.cc @@ -40,6 +40,10 @@ bool operator==(const TSNode &left, const TSNode &right) { return ts_node_eq(left, right); } +bool operator==(const TSLength &left, const TSLength &right) { + return ts_length_eq(left, right); +} + bool operator==(const std::vector &vec, const TreeArray &array) { if (vec.size() != array.size) return false; diff --git a/spec/helpers/tree_helpers.h b/spec/helpers/tree_helpers.h index acd3f0a2..18d62b80 100644 --- a/spec/helpers/tree_helpers.h +++ b/spec/helpers/tree_helpers.h @@ -12,6 +12,7 @@ std::ostream &operator<<(std::ostream &stream, const TSTree *tree); std::ostream &operator<<(std::ostream &stream, const TSNode &node); std::ostream &operator<<(std::ostream &stream, const TSLength &length); bool operator==(const TSNode &left, const TSNode &right); +bool operator==(const TSLength &left, const TSLength &right); bool operator==(const std::vector &right, const TreeArray &array); #endif // HELPERS_TREE_HELPERS_H_ diff --git a/spec/runtime/stack_spec.cc b/spec/runtime/stack_spec.cc index bd17bda9..8d98b8e9 100644 --- a/spec/runtime/stack_spec.cc +++ b/spec/runtime/stack_spec.cc @@ -8,7 +8,9 @@ #include "runtime/alloc.h" enum { - stateA, stateB, stateC, stateD, stateE, stateF, stateG, stateH, stateI, stateJ + stateA = 1, + stateB, + stateC, stateD, stateE, stateF, stateG, stateH, stateI, stateJ }; enum { @@ -59,6 +61,26 @@ void free_slice_array(StackSliceArray *slices) { } } +struct StackEntry { + TSStateId state; + size_t depth; +}; + +vector get_stack_entries(Stack *stack, int head_index) { + vector result; + ts_stack_pop_until( + stack, + head_index, + [](void *payload, TSStateId state, size_t depth, size_t extra_count) { + auto entries = static_cast *>(payload); + StackEntry entry = {state, depth}; + if (find(entries->begin(), entries->end(), entry) == entries->end()) + entries->push_back(entry); + return StackIterateContinue; + }, &result); + return result; +} + START_TEST describe("Stack", [&]() { @@ -69,7 +91,7 @@ describe("Stack", [&]() { TSLength tree_len = {2, 3, 0, 3}; TSSymbolMetadata metadata = {true, true, true, true}; - before_each([&]() { + before_each([&]() { record_alloc::start(); stack = ts_stack_new(); @@ -97,28 +119,30 @@ describe("Stack", [&]() { describe("pushing entries to the stack", [&]() { it("adds entries to the stack", [&]() { AssertThat(ts_stack_head_count(stack), Equals(1)); - AssertThat(ts_stack_head(stack, 0), Equals(nullptr)); + AssertThat(ts_stack_top_state(stack, 0), Equals(0)); + AssertThat(ts_stack_top_position(stack, 0), Equals(ts_length_zero())); // . <──0── A* ts_stack_push(stack, 0, trees[0], stateA); - const StackEntry *entry1 = ts_stack_head(stack, 0); - AssertThat(*entry1, Equals({stateA, tree_len})); - AssertThat(ts_stack_entry_next_count(entry1), Equals(1)); - AssertThat(ts_stack_entry_next(entry1, 0), Equals(nullptr)); + AssertThat(ts_stack_top_state(stack, 0), Equals(stateA)); + AssertThat(ts_stack_top_position(stack, 0), Equals(tree_len)); // . <──0── A <──1── B* ts_stack_push(stack, 0, trees[1], stateB); - const StackEntry *entry2 = ts_stack_head(stack, 0); - AssertThat(*entry2, Equals({stateB, tree_len * 2})); - AssertThat(ts_stack_entry_next_count(entry2), Equals(1)); - AssertThat(ts_stack_entry_next(entry2, 0), Equals(entry1)); + AssertThat(ts_stack_top_state(stack, 0), Equals(stateB)); + AssertThat(ts_stack_top_position(stack, 0), Equals(tree_len * 2)); // . <──0── A <──1── B <──2── C* ts_stack_push(stack, 0, trees[2], stateC); - const StackEntry *entry3 = ts_stack_head(stack, 0); - AssertThat(*entry3, Equals({stateC, tree_len * 3})); - AssertThat(ts_stack_entry_next_count(entry3), Equals(1)); - AssertThat(ts_stack_entry_next(entry3, 0), Equals(entry2)); + AssertThat(ts_stack_top_state(stack, 0), Equals(stateC)); + AssertThat(ts_stack_top_position(stack, 0), Equals(tree_len * 3)); + + AssertThat(get_stack_entries(stack, 0), Equals(vector({ + {stateC, 0}, + {stateB, 1}, + {stateA, 2}, + {0, 3}, + }))); }); }); @@ -132,23 +156,23 @@ describe("Stack", [&]() { it("removes the given number of nodes from the stack", [&]() { // . <──0── A* - StackPopResult pop_result = ts_stack_pop(stack, 0, 2, false); + StackPopResult pop_result = ts_stack_pop_count(stack, 0, 2); AssertThat(pop_result.status, Equals(StackPopResult::StackPopSucceeded)); AssertThat(pop_result.slices.size, Equals(1)); StackSlice slice = pop_result.slices.contents[0]; AssertThat(slice.trees, Equals(vector({ trees[1], trees[2] }))); - AssertThat(*ts_stack_head(stack, 0), Equals({stateA, tree_len})); + AssertThat(ts_stack_top_state(stack, 0), Equals(stateA)); free_slice_array(&pop_result.slices); // .* - pop_result = ts_stack_pop(stack, 0, 1, false); + pop_result = ts_stack_pop_count(stack, 0, 1); AssertThat(pop_result.status, Equals(StackPopResult::StackPopSucceeded)); AssertThat(pop_result.slices.size, Equals(1)); slice = pop_result.slices.contents[0]; AssertThat(slice.trees, Equals(vector({ trees[0] }))); - AssertThat(ts_stack_head(stack, 0), Equals(nullptr)); + AssertThat(ts_stack_top_state(stack, 0), Equals(0)); free_slice_array(&pop_result.slices); }); @@ -157,20 +181,20 @@ describe("Stack", [&]() { trees[1]->extra = true; // .* - StackPopResult pop_result = ts_stack_pop(stack, 0, 2, false); + StackPopResult pop_result = ts_stack_pop_count(stack, 0, 2); AssertThat(pop_result.status, Equals(StackPopResult::StackPopSucceeded)); AssertThat(pop_result.slices.size, Equals(1)); StackSlice slice = pop_result.slices.contents[0]; AssertThat(slice.trees, Equals(vector({ trees[0], trees[1], trees[2] }))); - AssertThat(ts_stack_head(stack, 0), Equals(nullptr)); + AssertThat(ts_stack_top_state(stack, 0), Equals(0)); free_slice_array(&pop_result.slices); }); it("pops the entire stack when given a negative count", [&]() { // .* - StackPopResult pop_result = ts_stack_pop(stack, 0, -1, false); + StackPopResult pop_result = ts_stack_pop_count(stack, 0, -1); AssertThat(pop_result.status, Equals(StackPopResult::StackPopSucceeded)); AssertThat(pop_result.slices.size, Equals(1)); @@ -180,20 +204,25 @@ describe("Stack", [&]() { free_slice_array(&pop_result.slices); }); - it("stops immediately after popping a node with the error state", [&]() { - // . <──0── A <──1── B <──2── C <──3── ? <──4── D* - ts_stack_push(stack, 0, trees[3], ts_parse_state_error); - ts_stack_push(stack, 0, trees[4], stateD); + describe("when an error state exists above the given depth", [&]() { + it("stops popping nodes at the error", [&]() { + // . <──0── A <──1── B <──2── C <──3── ERROR <──4── D* + ts_stack_push(stack, 0, trees[3], ts_parse_state_error); + ts_stack_push(stack, 0, trees[4], stateD); - StackPopResult pop_result = ts_stack_pop(stack, 0, 3, false); - AssertThat(pop_result.status, Equals(StackPopResult::StackPopStoppedAtError)); - AssertThat(pop_result.slices.size, Equals(1)); + StackPopResult pop_result = ts_stack_pop_count(stack, 0, 3); + AssertThat(pop_result.status, Equals(StackPopResult::StackPopStoppedAtError)); - StackSlice slice = pop_result.slices.contents[0]; - AssertThat(slice.trees, Equals(vector({ trees[3], trees[4] }))); - AssertThat(ts_stack_top_state(stack, 0), Equals(stateC)); + AssertThat(ts_stack_head_count(stack), Equals(1)); + AssertThat(ts_stack_top_state(stack, 0), Equals(ts_parse_state_error)); - free_slice_array(&pop_result.slices); + AssertThat(pop_result.slices.size, Equals(1)); + StackSlice slice = pop_result.slices.contents[0]; + AssertThat(slice.head_index, Equals(0)); + AssertThat(slice.trees, Equals(vector({ trees[4] }))); + + free_slice_array(&pop_result.slices); + }); }); }); @@ -216,11 +245,14 @@ describe("Stack", [&]() { // ↑ // └─* ts_stack_push(stack, 0, trees[3], stateD); - StackPopResult pop_result = ts_stack_pop(stack, 1, 1, false); + StackPopResult pop_result = ts_stack_pop_count(stack, 1, 1); AssertThat(ts_stack_head_count(stack), Equals(2)); - AssertThat(*ts_stack_head(stack, 0), Equals({stateD, tree_len * 4})); - AssertThat(*ts_stack_head(stack, 1), Equals({stateB, tree_len * 2})); + AssertThat(ts_stack_top_state(stack, 0), Equals(stateD)); + AssertThat(ts_stack_top_position(stack, 0), Equals(tree_len * 4)); + AssertThat(ts_stack_top_state(stack, 1), Equals(stateB)); + AssertThat(ts_stack_top_position(stack, 1), Equals(tree_len * 2)); + AssertThat(pop_result.slices.size, Equals(1)); StackSlice slice = pop_result.slices.contents[0]; AssertThat(slice.trees.size, Equals(1)); @@ -233,8 +265,10 @@ describe("Stack", [&]() { ts_stack_push(stack, 1, trees[5], stateF); AssertThat(ts_stack_head_count(stack), Equals(2)); - AssertThat(*ts_stack_head(stack, 0), Equals({stateD, tree_len * 4})); - AssertThat(*ts_stack_head(stack, 1), Equals({stateF, tree_len * 4})); + AssertThat(ts_stack_top_state(stack, 0), Equals(stateD)); + AssertThat(ts_stack_top_position(stack, 0), Equals(tree_len * 4)); + AssertThat(ts_stack_top_state(stack, 1), Equals(stateF)); + AssertThat(ts_stack_top_position(stack, 1), Equals(tree_len * 4)); }); }); @@ -252,8 +286,20 @@ describe("Stack", [&]() { ts_stack_push(stack, 1, trees[5], stateF); AssertThat(ts_stack_head_count(stack), Equals(2)); - AssertThat(*ts_stack_head(stack, 0), Equals({stateD, tree_len * 4})); - AssertThat(*ts_stack_head(stack, 1), Equals({stateF, tree_len * 4})); + AssertThat(get_stack_entries(stack, 0), Equals(vector({ + {stateD, 0}, + {stateC, 1}, + {stateB, 2}, + {stateA, 3}, + {0, 4}, + }))); + AssertThat(get_stack_entries(stack, 1), Equals(vector({ + {stateF, 0}, + {stateE, 1}, + {stateB, 2}, + {stateA, 3}, + {0, 4}, + }))); }); it("merges the heads", [&]() { @@ -264,11 +310,16 @@ describe("Stack", [&]() { AssertThat(ts_stack_push(stack, 1, trees[7], stateG), Equals(StackPushMerged)); AssertThat(ts_stack_head_count(stack), Equals(1)); - const StackEntry *entry1 = ts_stack_head(stack, 0); - AssertThat(*entry1, Equals({stateG, tree_len * 5})); - AssertThat(ts_stack_entry_next_count(entry1), Equals(2)); - AssertThat(*ts_stack_entry_next(entry1, 0), Equals({stateD, tree_len * 4})); - AssertThat(*ts_stack_entry_next(entry1, 1), Equals({stateF, tree_len * 4})); + AssertThat(get_stack_entries(stack, 0), Equals(vector({ + {stateG, 0}, + {stateD, 1}, + {stateF, 1}, + {stateC, 2}, + {stateE, 2}, + {stateB, 3}, + {stateA, 4}, + {0, 5}, + }))); }); describe("when the merged nodes share a successor", [&]() { @@ -286,13 +337,17 @@ describe("Stack", [&]() { AssertThat(ts_stack_push(stack, 1, trees[7], stateH), Equals(StackPushMerged)); AssertThat(ts_stack_head_count(stack), Equals(1)); - StackEntry *head = ts_stack_head(stack, 0); - AssertThat(*head, Equals({stateH, tree_len * 6})) - AssertThat(ts_stack_entry_next_count(head), Equals(1)); - - StackEntry *next = ts_stack_entry_next(head, 0); - AssertThat(*next, Equals({stateG, tree_len * 5})) - AssertThat(ts_stack_entry_next_count(next), Equals(2)); + AssertThat(get_stack_entries(stack, 0), Equals(vector({ + {stateH, 0}, + {stateG, 1}, + {stateD, 2}, + {stateF, 2}, + {stateC, 3}, + {stateE, 3}, + {stateB, 4}, + {stateA, 5}, + {0, 6}, + }))); }); }); @@ -302,9 +357,9 @@ describe("Stack", [&]() { ts_tree_retain(trees[3]); TSTree *parent = ts_tree_make_node(5, 2, tree_array({ trees[2], trees[3] }), metadata); - // . <──2── B <──3── C + // . <──────5─────── C* // ↑ | - // └────────5────────┘ + // └───2─── B ───3───┘ ts_stack_clear(stack); ts_stack_split(stack, 0); AssertThat(ts_stack_push(stack, 0, parent, stateC), Equals(StackPushContinued)); @@ -312,12 +367,13 @@ describe("Stack", [&]() { AssertThat(ts_stack_push(stack, 1, trees[3], stateC), Equals(StackPushMerged)); AssertThat(ts_stack_head_count(stack), Equals(1)); - StackEntry *head = ts_stack_head(stack, 0); - AssertThat(*head, Equals({stateC, tree_len * 2})); - - AssertThat(ts_stack_entry_next_count(head), Equals(2)); - AssertThat(ts_stack_entry_next(head, 0), Equals(nullptr)); - AssertThat(*ts_stack_entry_next(head, 1), Equals({stateB, tree_len})); + AssertThat(ts_stack_top_state(stack, 0), Equals(stateC)); + AssertThat(get_stack_entries(stack, 0), Equals(vector({ + {stateC, 0}, + {0, 1}, + {stateB, 1}, + {0, 2}, + }))); ts_tree_release(parent); }); @@ -340,8 +396,16 @@ describe("Stack", [&]() { ts_stack_push(stack, 1, trees[7], stateE); AssertThat(ts_stack_head_count(stack), Equals(1)); - AssertThat(ts_stack_top_state(stack, 0), Equals(stateE)); - AssertThat(ts_stack_entry_next_count(ts_stack_head(stack, 0)), Equals(2)); + AssertThat(get_stack_entries(stack, 0), Equals(vector({ + {stateE, 0}, + {stateD, 1}, + {stateG, 1}, + {stateC, 2}, + {stateF, 2}, + {stateB, 3}, + {stateA, 4}, + {0, 5}, + }))); }); describe("when there are two paths that lead to two different heads", [&]() { @@ -349,7 +413,7 @@ describe("Stack", [&]() { // . <──0── A <──1── B <──2── C* // ↑ // └───5─── F* - StackPopResult pop_result = ts_stack_pop(stack, 0, 2, false); + StackPopResult pop_result = ts_stack_pop_count(stack, 0, 2); AssertThat(pop_result.slices.size, Equals(2)); StackSlice slice1 = pop_result.slices.contents[0]; @@ -363,8 +427,18 @@ describe("Stack", [&]() { AssertThat(slice2.trees, Equals(vector({ trees[6], trees[7] }))); AssertThat(ts_stack_head_count(stack), Equals(2)); - AssertThat(*ts_stack_head(stack, 0), Equals({stateC, tree_len * 3})); - AssertThat(*ts_stack_head(stack, 1), Equals({stateF, tree_len * 3})); + AssertThat(get_stack_entries(stack, 0), Equals(vector({ + {stateC, 0}, + {stateB, 1}, + {stateA, 2}, + {0, 3}, + }))); + AssertThat(get_stack_entries(stack, 1), Equals(vector({ + {stateF, 0}, + {stateB, 1}, + {stateA, 2}, + {0, 3}, + }))); free_slice_array(&pop_result.slices); }); @@ -382,7 +456,7 @@ describe("Stack", [&]() { // . <──0── A <──1── B <──2── C <──3── D <──4── E* // ↑ | // └───5─── F <──6── G <──7───┘ - StackPopResult pop_result = ts_stack_pop(stack, 0, 1, false); + StackPopResult pop_result = ts_stack_pop_count(stack, 0, 1); AssertThat(pop_result.slices.size, Equals(1)); StackSlice slice1 = pop_result.slices.contents[0]; AssertThat(slice1.head_index, Equals(0)); @@ -401,9 +475,10 @@ describe("Stack", [&]() { tree_selection_spy.tree_to_return = trees[2]; // . <──0── A <──1── B* - StackPopResult pop_result = ts_stack_pop(stack, 0, 3, false); + StackPopResult pop_result = ts_stack_pop_count(stack, 0, 3); AssertThat(ts_stack_head_count(stack), Equals(1)); - AssertThat(*ts_stack_head(stack, 0), Equals({stateB, tree_len * 2})); + AssertThat(ts_stack_top_state(stack, 0), Equals(stateB)); + AssertThat(ts_stack_top_position(stack, 0), Equals(tree_len * 2)); AssertThat(pop_result.slices.size, Equals(1)); StackSlice slice1 = pop_result.slices.contents[0]; @@ -419,9 +494,10 @@ describe("Stack", [&]() { tree_selection_spy.tree_to_return = trees[4]; // . <──0── A <──1── B* - StackPopResult pop_result = ts_stack_pop(stack, 0, 3, false); + StackPopResult pop_result = ts_stack_pop_count(stack, 0, 3); AssertThat(ts_stack_head_count(stack), Equals(1)); - AssertThat(*ts_stack_head(stack, 0), Equals({stateB, tree_len * 2})); + AssertThat(ts_stack_top_state(stack, 0), Equals(stateB)); + AssertThat(ts_stack_top_position(stack, 0), Equals(tree_len * 2)); AssertThat(pop_result.slices.size, Equals(1)); StackSlice slice1 = pop_result.slices.contents[0]; @@ -454,10 +530,21 @@ describe("Stack", [&]() { ts_stack_push(stack, 1, trees[7], stateG); ts_stack_push(stack, 1, trees[8], stateH); ts_stack_push(stack, 1, trees[9], stateD); - AssertThat(ts_stack_head_count(stack), Equals(1)); - AssertThat(ts_stack_entry_next_count(ts_stack_head(stack, 0)), Equals(3)); ts_stack_push(stack, 0, trees[10], stateI); - AssertThat(ts_stack_entry_next_count(ts_stack_head(stack, 0)), Equals(1)); + + AssertThat(ts_stack_head_count(stack), Equals(1)); + AssertThat(get_stack_entries(stack, 0), Equals(vector({ + {stateI, 0}, + {stateD, 1}, + {stateC, 2}, + {stateF, 2}, + {stateH, 2}, + {stateB, 3}, + {stateE, 3}, + {stateG, 3}, + {stateA, 4}, + {0, 5}, + }))); }); describe("when there are three different paths that lead to three different heads", [&]() { @@ -467,7 +554,7 @@ describe("Stack", [&]() { // ├───4─── E <──5── F* // | // └───7─── G <──8── H* - StackPopResult pop_result = ts_stack_pop(stack, 0, 2, false); + StackPopResult pop_result = ts_stack_pop_count(stack, 0, 2); AssertThat(ts_stack_head_count(stack), Equals(3)); AssertThat(pop_result.slices.size, Equals(3)); @@ -496,11 +583,11 @@ describe("Stack", [&]() { END_TEST bool operator==(const StackEntry &left, const StackEntry &right) { - return left.state == right.state && ts_length_eq(left.position, right.position); + return left.state == right.state && left.depth == right.depth; } std::ostream &operator<<(std::ostream &stream, const StackEntry &entry) { - return stream << "{" << entry.state << ", " << entry.position << "}"; + return stream << "{" << entry.state << ", " << entry.depth << "}"; } std::ostream &operator<<(std::ostream &stream, const TreeArray &array) { diff --git a/spec/runtime/tree_spec.cc b/spec/runtime/tree_spec.cc index ea8d881e..6420a206 100644 --- a/spec/runtime/tree_spec.cc +++ b/spec/runtime/tree_spec.cc @@ -337,7 +337,3 @@ describe("Tree", []() { }); END_TEST - -bool operator==(TSLength left, TSLength right) { - return ts_length_eq(left, right); -} diff --git a/src/runtime/array.h b/src/runtime/array.h index a4f06036..e6934b10 100644 --- a/src/runtime/array.h +++ b/src/runtime/array.h @@ -21,6 +21,9 @@ extern "C" { #define array_init(self) \ ((self)->size = 0, (self)->capacity = 0, (self)->contents = NULL) +#define array_new() \ + { NULL, 0, 0 } + #define array_get(self, index) \ (assert((size_t)index < (self)->size), &(self)->contents[index]) diff --git a/src/runtime/stack.c b/src/runtime/stack.c index 909daecd..3d9ba192 100644 --- a/src/runtime/stack.c +++ b/src/runtime/stack.c @@ -12,6 +12,12 @@ #define STARTING_TREE_CAPACITY 10 #define MAX_NODE_POOL_SIZE 50 +#if __has_attribute(always_inline) +#define ALWAYS_INLINE __attribute__((always_inline)) +#else +#define ALWAYS_INLINE +#endif + typedef struct StackNode StackNode; typedef struct { @@ -20,19 +26,25 @@ typedef struct { } StackLink; struct StackNode { - StackEntry entry; + TSStateId state; + TSLength position; StackLink successors[MAX_SUCCESSOR_COUNT]; short unsigned int successor_count; short unsigned int ref_count; }; typedef struct { - size_t goal_tree_count; - StackNode *node; TreeArray trees; - bool is_shared; + size_t extra_count; + StackNode *node; + bool is_done; } PopPath; +typedef struct { + int goal_tree_count; + bool found_error; +} StackPopSession; + typedef Array(StackNode *) StackNodeArray; struct Stack { @@ -42,8 +54,92 @@ struct Stack { StackNodeArray node_pool; void *tree_selection_payload; TreeSelectionFunction tree_selection_function; + StackNode *base_node; }; +static const char *COLORS[] = { + "red", "blue", "orange", "green", "purple", +}; + +/* + * Section: Manipulating nodes (Private) + */ + +static void stack_node_retain(StackNode *self) { + if (!self) + return; + assert(self->ref_count != 0); + self->ref_count++; +} + +static void stack_node_release(StackNode *self, StackNodeArray *pool) { + if (!self) + return; + assert(self->ref_count != 0); + self->ref_count--; + if (self->ref_count == 0) { + for (int i = 0; i < self->successor_count; i++) { + ts_tree_release(self->successors[i].tree); + stack_node_release(self->successors[i].node, pool); + } + + if (pool->size >= MAX_NODE_POOL_SIZE) + ts_free(self); + else + array_push(pool, self); + } +} + +static StackNode *stack_node_new(StackNode *next, TSTree *tree, TSStateId state, + TSLength position, StackNodeArray *pool) { + StackNode *node; + if (pool->size > 0) + node = array_pop(pool); + else if (!(node = ts_malloc(sizeof(StackNode)))) + return NULL; + + *node = (StackNode){ + .ref_count = 1, + .successor_count = 0, + .successors = {}, + .state = state, + .position = position, + }; + + if (next) { + ts_tree_retain(tree); + stack_node_retain(next); + node->successor_count = 1, node->successors[0] = (StackLink){ next, tree }; + } + + return node; +} + +static void stack_node_add_successor(StackNode *self, TSTree *new_tree, + StackNode *new_node) { + for (int i = 0; i < self->successor_count; i++) { + StackLink successor = self->successors[i]; + if (successor.tree == new_tree) { + if (successor.node == new_node) + return; + if (successor.node && new_node && + successor.node->state == new_node->state) { + for (int j = 0; j < new_node->successor_count; j++) { + stack_node_add_successor(successor.node, new_node->successors[j].tree, + new_node->successors[j].node); + } + return; + } + } + } + + stack_node_retain(new_node); + ts_tree_retain(new_tree); + self->successors[self->successor_count++] = (StackLink){ + new_node, new_tree, + }; +} + /* * Section: Stack lifecycle */ @@ -76,7 +172,13 @@ Stack *ts_stack_new() { if (!array_grow(&self->node_pool, 20)) goto error; - array_push(&self->heads, NULL); + self->base_node = + stack_node_new(NULL, NULL, 0, ts_length_zero(), &self->node_pool); + stack_node_retain(self->base_node); + if (!self->base_node) + goto error; + + array_push(&self->heads, self->base_node); return self; @@ -100,92 +202,17 @@ error: */ TSStateId ts_stack_top_state(const Stack *self, int head_index) { - StackEntry *entry = ts_stack_head((Stack *)self, head_index); - return entry ? entry->state : 0; + return (*array_get(&self->heads, head_index))->state; } TSLength ts_stack_top_position(const Stack *self, int head_index) { - StackEntry *entry = ts_stack_head((Stack *)self, head_index); - return entry ? entry->position : ts_length_zero(); -} - -StackEntry *ts_stack_head(Stack *self, int head_index) { - StackNode *node = self->heads.contents[head_index]; - return node ? &node->entry : NULL; + return (*array_get(&self->heads, head_index))->position; } int ts_stack_head_count(const Stack *self) { return self->heads.size; } -int ts_stack_entry_next_count(const StackEntry *entry) { - return ((const StackNode *)entry)->successor_count; -} - -StackEntry *ts_stack_entry_next(const StackEntry *entry, int successor_index) { - return &((const StackNode *)entry)->successors[successor_index].node->entry; -} - -/* - * Section: Manipulating nodes (Private) - */ - -static void stack_node_retain(StackNode *self) { - if (!self) - return; - assert(self->ref_count != 0); - self->ref_count++; -} - -static void stack_node_release(StackNode *self, StackNodeArray *pool) { - if (!self) - return; - assert(self->ref_count != 0); - self->ref_count--; - if (self->ref_count == 0) { - for (int i = 0; i < self->successor_count; i++) { - stack_node_release(self->successors[i].node, pool); - ts_tree_release(self->successors[i].tree); - } - - if (pool->size >= MAX_NODE_POOL_SIZE) - ts_free(self); - else - array_push(pool, self); - } -} - -static StackNode *stack_node_new(StackNode *next, TSTree *tree, TSStateId state, - StackNodeArray *pool) { - assert(tree->ref_count > 0); - StackNode *node; - if (pool->size == 0) { - node = ts_malloc(sizeof(StackNode)); - if (!node) - return NULL; - } else { - node = array_pop(pool); - } - - ts_tree_retain(tree); - stack_node_retain(next); - TSLength position = ts_tree_total_size(tree); - if (next) - position = ts_length_add(next->entry.position, position); - *node = (StackNode){ - .ref_count = 1, - .successor_count = 1, - .successors = { { next, tree } }, - .entry = {.state = state, .position = position }, - }; - return node; -} - -static void ts_stack_slice__clear(StackSlice *slice) { - ts_tree_array_clear(&slice->trees); - array_delete(&slice->trees); -} - static void ts_stack__merge_slice(Stack *self, StackSlice *slice, StackSlice *new_slice) { bool should_update = false; @@ -207,39 +234,14 @@ static void ts_stack__merge_slice(Stack *self, StackSlice *slice, } if (should_update) { - ts_stack_slice__clear(slice); + ts_tree_array_delete(&slice->trees); slice->trees = new_slice->trees; slice->trees.size = new_slice->trees.size; } else { - ts_stack_slice__clear(new_slice); + ts_tree_array_delete(&new_slice->trees); } } -static void stack_node__add_successor(StackNode *self, TSTree *new_tree, - StackNode *new_node) { - for (int i = 0; i < self->successor_count; i++) { - StackLink successor = self->successors[i]; - if (successor.tree == new_tree) { - if (successor.node == new_node) - return; - if (successor.node && new_node && - successor.node->entry.state == new_node->entry.state) { - for (int j = 0; j < new_node->successor_count; j++) { - stack_node__add_successor(successor.node, new_node->successors[j].tree, - new_node->successors[j].node); - } - return; - } - } - } - - stack_node_retain(new_node); - ts_tree_retain(new_tree); - self->successors[self->successor_count++] = (StackLink){ - new_node, new_tree, - }; -} - /* * Section: Mutating the stack (Private) */ @@ -253,7 +255,7 @@ static int ts_stack__add_head(Stack *self, StackNode *node) { } } -static int ts_stack__find_head(Stack *self, StackNode *node) { +static int ts_stack__index_of_head(Stack *self, StackNode *node) { for (size_t i = 0; i < self->heads.size; i++) { if (self->heads.contents[i] == node) return i; @@ -273,24 +275,22 @@ void ts_stack_remove_head(Stack *self, int head_index) { StackPushResult ts_stack_push(Stack *self, int head_index, TSTree *tree, TSStateId state) { - TSLength position = ts_tree_total_size(tree); StackNode *current_head = *array_get(&self->heads, head_index); - if (current_head) - position = ts_length_add(current_head->entry.position, position); + TSLength position = + ts_length_add(current_head->position, ts_tree_total_size(tree)); for (int i = 0; i < head_index; i++) { StackNode *prior_node = self->heads.contents[i]; - StackEntry prior_entry = prior_node->entry; - if (prior_entry.state == state && - ts_length_eq(prior_entry.position, position)) { - stack_node__add_successor(prior_node, tree, current_head); + if (prior_node->state == state && + prior_node->position.chars == position.chars) { + stack_node_add_successor(prior_node, tree, current_head); ts_stack_remove_head(self, head_index); return StackPushMerged; } } StackNode *new_head = - stack_node_new(current_head, tree, state, &self->node_pool); + stack_node_new(current_head, tree, state, position, &self->node_pool); if (!new_head) return StackPushFailed; @@ -304,46 +304,51 @@ int ts_stack_split(Stack *self, int head_index) { return ts_stack__add_head(self, head); } -StackPopResult ts_stack_pop(Stack *self, int head_index, int child_count, - bool count_extra) { +static inline ALWAYS_INLINE StackSliceArray stack__pop( + Stack *self, int head_index, StackIterateCallback callback, void *payload) { array_clear(&self->slices); array_clear(&self->pop_paths); + StackNode *initial_head = *array_get(&self->heads, head_index); - StackNode *previous_head = *array_get(&self->heads, head_index); - int capacity = (child_count == -1) ? STARTING_TREE_CAPACITY : child_count; - PopPath initial_path = { - .goal_tree_count = child_count, .node = previous_head, .is_shared = false, + PopPath pop_path = { + .node = initial_head, .trees = array_new(), .extra_count = 0, .is_done = false, }; - array_init(&initial_path.trees); - - if (!array_grow(&initial_path.trees, capacity)) + if (!array_grow(&pop_path.trees, STARTING_TREE_CAPACITY)) + goto error; + if (!array_push(&self->pop_paths, pop_path)) goto error; - if (!array_push(&self->pop_paths, initial_path)) - goto error; - - /* - * Reduce along every possible path in parallel. Stop when the given number - * of child trees have been collected along every path. - */ bool all_paths_done = false; - int status = StackPopSucceeded; - while (!all_paths_done) { + for (size_t depth = 0; !all_paths_done; depth++) { all_paths_done = true; - - for (size_t i = 0; i < self->pop_paths.size; i++) { + for (size_t i = 0, size = self->pop_paths.size; i < size; i++) { PopPath *path = &self->pop_paths.contents[i]; - StackNode *node = path->node; - - if (!node || path->trees.size == path->goal_tree_count) + if (path->is_done) continue; + + StackNode *node = path->node; + size_t successor_count = node->successor_count; + switch (callback(payload, node->state, depth, path->extra_count)) { + case StackIteratePop: + path->is_done = true; + continue; + case StackIterateAbort: + successor_count = 0; + break; + default: + break; + } + + if (!successor_count) { + ts_tree_array_delete(&path->trees); + array_erase(&self->pop_paths, i--); + size--; + continue; + } + all_paths_done = false; - /* - * If a node has more than one successor, create new paths for each of - * the additional successors. - */ - for (int j = 0; j < node->successor_count; j++) { + for (size_t j = 0; j < successor_count; j++) { StackLink successor = node->successors[j]; PopPath *next_path; @@ -353,51 +358,36 @@ StackPopResult ts_stack_pop(Stack *self, int head_index, int child_count, if (!array_push(&self->pop_paths, *path)) goto error; next_path = array_back(&self->pop_paths); - next_path->is_shared = true; + next_path->trees.size--; + next_path->trees = ts_tree_array_copy(&next_path->trees); } - if (next_path->is_shared) { - TreeArray trees = path->trees; - trees.size--; - next_path->trees = ts_tree_array_copy(&trees); - next_path->is_shared = false; - } - - if (!count_extra && successor.tree->extra) - next_path->goal_tree_count++; - - ts_tree_retain(successor.tree); - if (!array_push(&next_path->trees, successor.tree)) - goto error; - next_path->node = successor.node; - if (!count_extra && node->entry.state == ts_parse_state_error) { - status = StackPopStoppedAtError; - next_path->goal_tree_count = next_path->trees.size; - } + if (!array_push(&next_path->trees, successor.tree)) + goto error; + if (successor.tree->extra) + next_path->extra_count++; + ts_tree_retain(successor.tree); } } } for (size_t i = 0; i < self->pop_paths.size; i++) { PopPath *path = &self->pop_paths.contents[i]; + if (!path->is_done) + continue; - if (!path->is_shared) - array_reverse(&path->trees); - - StackSlice slice = { - .trees = path->trees, .head_index = -1, - }; + StackSlice slice = {.trees = path->trees, .head_index = -1 }; + array_reverse(&slice.trees); if (i == 0) { stack_node_retain(path->node); self->heads.contents[head_index] = path->node; slice.head_index = head_index; } else { - slice.head_index = ts_stack__find_head(self, path->node); + slice.head_index = ts_stack__index_of_head(self, path->node); if (slice.head_index == -1) { - slice.head_index = ts_stack__add_head(self, path->node); - if (slice.head_index == -1) + if ((slice.head_index = ts_stack__add_head(self, path->node)) == -1) goto error; } else { bool merged = false; @@ -418,12 +408,62 @@ StackPopResult ts_stack_pop(Stack *self, int head_index, int child_count, goto error; } - stack_node_release(previous_head, &self->node_pool); - return (StackPopResult){ .status = status, .slices = self->slices }; + if (self->slices.size) + stack_node_release(initial_head, &self->node_pool); + return self->slices; error: - array_delete(&initial_path.trees); - return (StackPopResult){StackPopFailed, self->slices}; + for (size_t i = 0; i < self->pop_paths.size; i++) + array_delete(&self->pop_paths.contents[i].trees); + array_clear(&self->slices); + return self->slices; +} + +static inline ALWAYS_INLINE StackIterateAction stack__pop_count_callback( + void *payload, TSStateId state, size_t depth, size_t extra_count) { + StackPopSession *pop_session = (StackPopSession *)payload; + if (pop_session->found_error) + return StackIterateAbort; + + if (state == ts_parse_state_error && pop_session->goal_tree_count > 0) { + pop_session->found_error = true; + return StackIteratePop; + } + + if ((int)(depth - extra_count) == pop_session->goal_tree_count) + return StackIteratePop; + + if (state == 0 && depth > 0) + return StackIteratePop; + + return StackIterateContinue; +} + +StackPopResult ts_stack_pop_count(Stack *self, int head_index, int count) { + StackPopSession session = { + .goal_tree_count = count, + .found_error = false, + }; + + StackSliceArray slices = + stack__pop(self, head_index, stack__pop_count_callback, &session); + int status; + if (slices.size) { + if (session.found_error) + status = StackPopStoppedAtError; + else + status = StackPopSucceeded; + } else { + status = StackPopFailed; + } + + return (StackPopResult){.status = status, .slices = slices }; +} + +StackPopResult ts_stack_pop_until(Stack *self, int head_index, + StackIterateCallback callback, void *payload) { + StackSliceArray slices = stack__pop(self, head_index, callback, payload); + return (StackPopResult){.status = StackPopSucceeded, .slices = slices }; } void ts_stack_shrink(Stack *self, int head_index, int count) { @@ -440,10 +480,11 @@ void ts_stack_shrink(Stack *self, int head_index, int count) { } void ts_stack_clear(Stack *self) { + stack_node_retain(self->base_node); for (size_t i = 0; i < self->heads.size; i++) stack_node_release(self->heads.contents[i], &self->node_pool); array_clear(&self->heads); - array_push(&self->heads, NULL); + array_push(&self->heads, self->base_node); } void ts_stack_set_tree_selection_callback(Stack *self, void *payload, @@ -457,7 +498,10 @@ void ts_stack_delete(Stack *self) { array_delete(&self->slices); if (self->pop_paths.contents) array_delete(&self->pop_paths); - ts_stack_clear(self); + stack_node_release(self->base_node, &self->node_pool); + for (size_t i = 0; i < self->heads.size; i++) + stack_node_release(self->heads.contents[i], &self->node_pool); + array_clear(&self->heads); if (self->node_pool.contents) { for (size_t i = 0; i < self->node_pool.size; i++) ts_free(self->node_pool.contents[i]); @@ -467,12 +511,6 @@ void ts_stack_delete(Stack *self) { ts_free(self); } -static const char *COLORS[] = { - "red", "blue", "orange", "green", "purple", -}; - -static size_t COLOR_COUNT = sizeof(COLORS) / sizeof(COLORS[0]); - size_t ts_stack__write_dot_graph(Stack *self, char *string, size_t n, const char **symbol_names) { char *cursor = string; @@ -486,7 +524,8 @@ size_t ts_stack__write_dot_graph(Stack *self, char *string, size_t n, array_clear(&self->pop_paths); for (size_t i = 0; i < self->heads.size; i++) { StackNode *node = self->heads.contents[i]; - const char *color = COLORS[i % COLOR_COUNT]; + size_t color_count = sizeof(COLORS) / sizeof(COLORS[0]); + const char *color = COLORS[i % color_count]; cursor += snprintf(*s, n, "node_%p [color=%s];\n", node, color); array_push(&self->pop_paths, ((PopPath){.node = node })); } @@ -511,10 +550,10 @@ size_t ts_stack__write_dot_graph(Stack *self, char *string, size_t n, all_paths_done = false; cursor += snprintf(*s, n, "node_%p [label=", node); - if (node->entry.state == ts_parse_state_error) + if (node->state == ts_parse_state_error) cursor += snprintf(*s, n, "\"?\""); else - cursor += snprintf(*s, n, "%d", node->entry.state); + cursor += snprintf(*s, n, "%d", node->state); cursor += snprintf(*s, n, "];\n"); for (int j = 0; j < node->successor_count; j++) { @@ -553,7 +592,6 @@ size_t ts_stack__write_dot_graph(Stack *self, char *string, size_t n, } } - cursor += snprintf(*s, n, "node_%p [label=0];\n", NULL); cursor += snprintf(*s, n, "}\n"); array_delete(&visited_nodes); diff --git a/src/runtime/stack.h b/src/runtime/stack.h index 34b82657..c66086b8 100644 --- a/src/runtime/stack.h +++ b/src/runtime/stack.h @@ -11,11 +11,6 @@ extern "C" { typedef struct Stack Stack; -typedef struct { - TSStateId state; - TSLength position; -} StackEntry; - typedef struct { TreeArray trees; int head_index; @@ -38,7 +33,17 @@ typedef struct { StackSliceArray slices; } StackPopResult; -typedef int (*TreeSelectionFunction)(void *, TSTree *, TSTree *); +typedef enum { + StackIterateContinue, + StackIterateAbort, + StackIteratePop, +} StackIterateAction; + +typedef StackIterateAction (*StackIterateCallback)(void *, TSStateId state, + size_t depth, + size_t extra_count); + +typedef int (*TreeSelectionFunction)(void *, TSTree *tree1, TSTree *tree2); /* * Create a parse stack. @@ -67,21 +72,6 @@ TSStateId ts_stack_top_state(const Stack *, int head_index); */ TSLength ts_stack_top_position(const Stack *, int head_index); -/* - * Get the entry at the given head of the stack. - */ -StackEntry *ts_stack_head(Stack *, int head_index); - -/* - * Get the number of successors for the parse stack entry. - */ -int ts_stack_entry_next_count(const StackEntry *); - -/* - * Get the given successor for the parse stack entry. - */ -StackEntry *ts_stack_entry_next(const StackEntry *, int head_index); - /* * Push a (tree, state) pair onto the given head of the stack. This could cause * the head to merge with an existing head. @@ -94,7 +84,10 @@ StackPushResult ts_stack_push(Stack *, int head_index, TSTree *, TSStateId); * which had previously been merged. It returns a struct that indicates the * index of each revealed head and the trees removed from that head. */ -StackPopResult ts_stack_pop(Stack *, int head_index, int count, bool count_extra); +StackPopResult ts_stack_pop_count(Stack *, int head_index, int count); + +StackPopResult ts_stack_pop_until(Stack *, int head_index, StackIterateCallback, + void *); /* * Remove the given number of entries from the given head of the stack. diff --git a/src/runtime/tree.c b/src/runtime/tree.c index 872845fe..7a705167 100644 --- a/src/runtime/tree.c +++ b/src/runtime/tree.c @@ -45,10 +45,10 @@ TreeArray ts_tree_array_copy(TreeArray *self) { return result; } -void ts_tree_array_clear(TreeArray *self) { +void ts_tree_array_delete(TreeArray *self) { for (size_t i = 0; i < self->size; i++) ts_tree_release(self->contents[i]); - array_clear(self); + array_delete(self); } TSTree *ts_tree_make_error(TSLength size, TSLength padding, char lookahead_char) { diff --git a/src/runtime/tree.h b/src/runtime/tree.h index 9990dcfa..f5c68adb 100644 --- a/src/runtime/tree.h +++ b/src/runtime/tree.h @@ -45,7 +45,7 @@ struct TSTree { typedef Array(TSTree *) TreeArray; TreeArray ts_tree_array_copy(TreeArray *); -void ts_tree_array_clear(TreeArray *); +void ts_tree_array_delete(TreeArray *); TSTree *ts_tree_make_leaf(TSSymbol, TSLength, TSLength, TSSymbolMetadata); TSTree *ts_tree_make_node(TSSymbol, size_t, TSTree **, TSSymbolMetadata);