WIP

parser/src/stack.c

@@ -6,16 +6,16 @@
 /*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2024/08/31 15:22:58 by maiboyer          #+#    #+#             */
-/*   Updated: 2024/08/31 15:35:03 by maiboyer         ###   ########.fr       */
+/*   Updated: 2024/08/31 15:51:15 by maiboyer         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
-#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/stack.h"
 #include "parser/subtree.h"
 #include <assert.h>
 #include <stdio.h>
@@ -32,7 +32,8 @@ typedef struct s_stack_node				 t_stack_node;
 typedef struct s_summarize_stack_session	t_summarize_stack_session;
 typedef t_u32								t_stack_action;
 
-typedef t_stack_action (*t_stack_callback)(void *, const t_stack_iterator *);
+typedef t_stack_action						(*t_stack_callback)(void *,
+							const t_stack_iterator *);
 
 struct										s_stack_link
 {
@@ -110,30 +111,30 @@ static void stack_node_retain(t_stack_node *self)
 
 static void	stack_node_release(t_stack_node *self)
 {
+	t_stack_node	*first_predecessor;
+	t_stack_link	link;
+
 recur:
 	assert(self->ref_count != 0);
 	self->ref_count--;
 	if (self->ref_count > 0)
 		return ;
-
+	first_predecessor = NULL;
-	t_stack_node *first_predecessor = NULL;
 	if (self->link_count > 0)
 	{
 		for (t_u32 i = self->link_count - 1; i > 0; i--)
 		{
-			t_stack_link link = self->links[i];
+			link = self->links[i];
 			if (link.subtree)
 				ts_subtree_release(link.subtree);
 			stack_node_release(link.node);
 		}
-		t_stack_link link = self->links[0];
+		link = self->links[0];
 		if (link.subtree)
 			ts_subtree_release(link.subtree);
 		first_predecessor = self->links[0].node;
 	}
-
 	mem_free(self);
-
 	if (first_predecessor)
 	{
 		self = first_predecessor;
@@ -145,24 +146,26 @@ recur:
 /// how much progress has been made by a given version of the stack.
 static t_u32	stack__subtree_node_count(Subtree subtree)
 {
-	t_u32 count = ts_subtree_visible_descendant_count(subtree);
+	t_u32	count;
+
+	count = ts_subtree_visible_descendant_count(subtree);
 	if (ts_subtree_visible(subtree))
 		count++;
-
 	// Count intermediate error nodes even though they are not visible,
 	// because a stack version's node count is used to check whether it
 	// has made any progress since the last time it encountered an error.
 	if (ts_subtree_symbol(subtree) == ts_builtin_sym_error_repeat)
 		count++;
-
+	return (count);
-	return count;
 }
 
-static t_stack_node *stack_node_new(t_stack_node *previous_node, Subtree subtree, bool is_pending, TSStateId state)
+static t_stack_node	*stack_node_new(t_stack_node *previous_node,
+		Subtree subtree, bool is_pending, TSStateId state)
 {
-	t_stack_node *node = mem_alloc(sizeof(t_stack_node));
+	t_stack_node	*node;
-	*node = (t_stack_node){.ref_count = 1, .link_count = 0, .state = state};
 
+	node = mem_alloc(sizeof(t_stack_node));
+	*node = (t_stack_node){.ref_count = 1, .link_count = 0, .state = state};
 	if (previous_node != NULL)
 	{
 		node->link_count = 1;
@@ -171,16 +174,15 @@ static t_stack_node *stack_node_new(t_stack_node *previous_node, Subtree subtree
 			.subtree = subtree,
 			.is_pending = is_pending,
 		};
-
 		node->position = previous_node->position;
 		node->error_cost = previous_node->error_cost;
 		node->dynamic_precedence = previous_node->dynamic_precedence;
 		node->node_count = previous_node->node_count;
-
 		if (subtree)
 		{
 			node->error_cost += ts_subtree_error_cost(subtree);
-			node->position = length_add(node->position, ts_subtree_total_size(subtree));
+			node->position = length_add(node->position,
+					ts_subtree_total_size(subtree));
 			node->node_count += stack__subtree_node_count(subtree);
 			node->dynamic_precedence += ts_subtree_dynamic_precedence(subtree);
 		}
@@ -190,41 +192,43 @@ static t_stack_node *stack_node_new(t_stack_node *previous_node, Subtree subtree
 		node->position = length_zero();
 		node->error_cost = 0;
 	}
-
+	return (node);
-	return node;
 }
 
 static bool	stack__subtree_is_equivalent(Subtree left, Subtree right)
 {
 	if (left == right)
-		return true;
+		return (true);
 	if (!left || !right)
-		return false;
+		return (false);
-
 	// Symbols must match
 	if (ts_subtree_symbol(left) != ts_subtree_symbol(right))
-		return false;
+		return (false);
-
 	// If both have errors, don't bother keeping both.
 	if (ts_subtree_error_cost(left) > 0 && ts_subtree_error_cost(right) > 0)
-		return true;
+		return (true);
-
+	return (ts_subtree_padding(left).bytes == ts_subtree_padding(right).bytes
-	return (ts_subtree_padding(left).bytes == ts_subtree_padding(right).bytes &&
+		&& ts_subtree_size(left).bytes == ts_subtree_size(right).bytes
-			ts_subtree_size(left).bytes == ts_subtree_size(right).bytes && ts_subtree_child_count(left) == ts_subtree_child_count(right) &&
+		&& ts_subtree_child_count(left) == ts_subtree_child_count(right)
-			ts_subtree_extra(left) == ts_subtree_extra(right) && ts_subtree_external_scanner_state_eq(left, right));
+		&& ts_subtree_extra(left) == ts_subtree_extra(right)
+		&& ts_subtree_external_scanner_state_eq(left, right));
 }
 
 static void	stack_node_add_link(t_stack_node *self, t_stack_link link)
 {
+	t_stack_link	*existing_link;
+	t_i32			dynamic_precedence;
+	t_u32			node_count;
+
 	if (link.node == self)
 		return ;
-
 	for (int i = 0; i < self->link_count; i++)
 	{
-		t_stack_link *existing_link = &self->links[i];
+		existing_link = &self->links[i];
 		if (stack__subtree_is_equivalent(existing_link->subtree, link.subtree))
 		{
-			// In general, we preserve ambiguities until they are removed from the stack
+			// In general,
+			// we preserve ambiguities until they are removed from the stack
 			// during a pop operation where multiple paths lead to the same node. But in
 			// the special case where two links directly connect the same pair of nodes,
 			// we can safely remove the ambiguity ahead of time without changing behavior.
@@ -233,25 +237,29 @@ static void stack_node_add_link(t_stack_node *self, t_stack_link link)
 				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(/*subtree_pool,
+						*/ existing_link->subtree);
 					existing_link->subtree = link.subtree;
-					self->dynamic_precedence = link.node->dynamic_precedence + ts_subtree_dynamic_precedence(link.subtree);
+					self->dynamic_precedence = link.node->dynamic_precedence
+						+ ts_subtree_dynamic_precedence(link.subtree);
 				}
 				return ;
 			}
-
 			// If the previous nodes are mergeable, merge them recursively.
-			if (existing_link->node->state == link.node->state && existing_link->node->position.bytes == link.node->position.bytes &&
+			if (existing_link->node->state == link.node->state
-				existing_link->node->error_cost == link.node->error_cost)
+				&& existing_link->node->position.bytes == link.node->position.bytes
+				&& existing_link->node->error_cost == link.node->error_cost)
 			{
 				for (int j = 0; j < link.node->link_count; j++)
 				{
-					stack_node_add_link(existing_link->node, link.node->links[j]);
+					stack_node_add_link(existing_link->node,
+						link.node->links[j]);
 				}
-				t_i32 dynamic_precedence = link.node->dynamic_precedence;
+				dynamic_precedence = link.node->dynamic_precedence;
 				if (link.subtree)
 				{
-					dynamic_precedence += ts_subtree_dynamic_precedence(link.subtree);
+					dynamic_precedence
+						+= ts_subtree_dynamic_precedence(link.subtree);
 				}
 				if (dynamic_precedence > self->dynamic_precedence)
 				{
@@ -261,22 +269,18 @@ static void stack_node_add_link(t_stack_node *self, t_stack_link link)
 			}
 		}
 	}
-
 	if (self->link_count == MAX_LINK_COUNT)
 		return ;
-
 	stack_node_retain(link.node);
-	t_u32 node_count = link.node->node_count;
+	node_count = link.node->node_count;
-	int	  dynamic_precedence = link.node->dynamic_precedence;
+	dynamic_precedence = link.node->dynamic_precedence;
 	self->links[self->link_count++] = link;
-
 	if (link.subtree)
 	{
 		ts_subtree_retain(link.subtree);
 		node_count += stack__subtree_node_count(link.subtree);
 		dynamic_precedence += ts_subtree_dynamic_precedence(link.subtree);
 	}
-
 	if (node_count > self->node_count)
 		self->node_count = node_count;
 	if (dynamic_precedence > self->dynamic_precedence)
@@ -304,9 +308,12 @@ static void stack_head_delete(t_stack_head *self)
 	}
 }
 
-static t_stack_version ts_stack__add_version(t_stack *self, t_stack_version original_version, t_stack_node *node)
+static t_stack_version	ts_stack__add_version(t_stack *self,
+		t_stack_version original_version, t_stack_node *node)
 {
-	t_stack_head head = {
+	t_stack_head head;
+
+	head = (t_stack_head){
 		.node = node,
 		.node_count_at_last_error = self->heads.contents[original_version].node_count_at_last_error,
 		.last_external_token = self->heads.contents[original_version].last_external_token,
@@ -317,64 +324,75 @@ static t_stack_version ts_stack__add_version(t_stack *self, t_stack_version orig
 	stack_node_retain(node);
 	if (head.last_external_token)
 		ts_subtree_retain(head.last_external_token);
-	return (t_stack_version)(self->heads.size - 1);
+	return ((t_stack_version)(self->heads.size - 1));
 }
 
-static void ts_stack__add_slice(t_stack *self, t_stack_version original_version, t_stack_node *node, SubtreeArray *subtrees)
+static void	ts_stack__add_slice(t_stack *self, t_stack_version original_version,
+		t_stack_node *node, SubtreeArray *subtrees)
 {
+	t_stack_version	version;
+	t_stack_slice	slice;
+
 	for (t_u32 i = self->slices.size - 1; i + 1 > 0; i--)
 	{
-		t_stack_version version = self->slices.contents[i].version;
+		version = self->slices.contents[i].version;
 		if (self->heads.contents[version].node == node)
 		{
-			t_stack_slice slice = {*subtrees, version};
+			slice = (t_stack_slice){*subtrees, version};
 			array_insert(&self->slices, i + 1, slice);
 			return ;
 		}
 	}
-
+	version = ts_stack__add_version(self, original_version, node);
-	t_stack_version version = ts_stack__add_version(self, original_version, node);
+	slice = (t_stack_slice){*subtrees, version};
-	t_stack_slice	slice = {*subtrees, version};
 	array_push(&self->slices, slice);
 }
 
-static t_stack_slice_array stack__iter(t_stack *self, t_stack_version version, t_stack_callback callback, void *payload,
+static t_stack_slice_array	stack__iter(t_stack *self, t_stack_version version,
-									   int goal_subtree_count)
+		t_stack_callback callback, void *payload, int goal_subtree_count)
 {
+	t_stack_head		*head;
+	bool				include_subtrees;
+	t_stack_iterator	*iterator;
+	t_stack_node		*node;
+	t_stack_action		action;
+	bool				should_pop;
+	bool				should_stop;
+	SubtreeArray		subtrees;
+	t_stack_iterator	*next_iterator;
+	t_stack_link 		link;
+	t_stack_iterator	current_iterator;
+	t_stack_iterator	new_iterator;
+
 	array_clear(&self->slices);
 	array_clear(&self->iterators);
-
+	head = array_get(&self->heads, version);
-	t_stack_head	*head = array_get(&self->heads, version);
+	new_iterator = (t_stack_iterator){
-	t_stack_iterator new_iterator = {
 		.node = head->node,
 		.subtrees = array_new(),
 		.subtree_count = 0,
 		.is_pending = true,
 	};
-
+	include_subtrees = false;
-	bool include_subtrees = false;
 	if (goal_subtree_count >= 0)
 	{
 		include_subtrees = true;
-		array_reserve(&new_iterator.subtrees, (t_u32)ts_subtree_alloc_size(goal_subtree_count) / sizeof(Subtree));
+		array_reserve(&new_iterator.subtrees,
+			(t_u32)ts_subtree_alloc_size(goal_subtree_count) / sizeof(Subtree));
 	}
-
 	array_push(&self->iterators, new_iterator);
-
 	while (self->iterators.size > 0)
 	{
 		for (t_u32 i = 0, size = self->iterators.size; i < size; i++)
 		{
-			t_stack_iterator *iterator = &self->iterators.contents[i];
+			iterator = &self->iterators.contents[i];
-			t_stack_node	 *node = iterator->node;
+			node = iterator->node;
-
+			action = callback(payload, iterator);
-			t_stack_action action = callback(payload, iterator);
+			should_pop = action & SActionPop;
-			bool		   should_pop = action & SActionPop;
+			should_stop = action & SActionStop || node->link_count == 0;
-			bool		   should_stop = action & SActionStop || node->link_count == 0;
-
 			if (should_pop)
 			{
-				SubtreeArray subtrees = iterator->subtrees;
+				subtrees = iterator->subtrees;
 				if (!should_stop)
 				{
 					ts_subtree_array_copy(subtrees, &subtrees);
@@ -382,7 +400,6 @@ static t_stack_slice_array stack__iter(t_stack *self, t_stack_version version, t
 				ts_subtree_array_reverse(&subtrees);
 				ts_stack__add_slice(self, version, node, &subtrees);
 			}
-
 			if (should_stop)
 			{
 				if (!should_pop)
@@ -393,11 +410,8 @@ static t_stack_slice_array stack__iter(t_stack *self, t_stack_version version, t
 				i--, size--;
 				continue ;
 			}
-
 			for (t_u32 j = 1; j <= node->link_count; j++)
 			{
-				t_stack_iterator *next_iterator;
-				t_stack_link	  link;
 				if (j == node->link_count)
 				{
 					link = node->links[0];
@@ -408,12 +422,12 @@ static t_stack_slice_array stack__iter(t_stack *self, t_stack_version version, t
 					if (self->iterators.size >= MAX_ITERATOR_COUNT)
 						continue ;
 					link = node->links[j];
-					t_stack_iterator current_iterator = self->iterators.contents[i];
+					current_iterator = self->iterators.contents[i];
 					array_push(&self->iterators, current_iterator);
 					next_iterator = array_back(&self->iterators);
-					ts_subtree_array_copy(next_iterator->subtrees, &next_iterator->subtrees);
+					ts_subtree_array_copy(next_iterator->subtrees,
+						&next_iterator->subtrees);
 				}
-
 				next_iterator->node = link.node;
 				if (link.subtree)
 				{
@@ -422,7 +436,6 @@ static t_stack_slice_array stack__iter(t_stack *self, t_stack_version version, t
 						array_push(&next_iterator->subtrees, link.subtree);
 						ts_subtree_retain(link.subtree);
 					}
-
 					if (!ts_subtree_extra(link.subtree))
 					{
 						next_iterator->subtree_count++;
@@ -440,8 +453,7 @@ static t_stack_slice_array stack__iter(t_stack *self, t_stack_version version, t
 			}
 		}
 	}
-
+	return (self->slices);
-	return self->slices;
 }
 
 t_stack	*ts_stack_new(void)
@@ -449,17 +461,14 @@ t_stack *ts_stack_new(void)
 	t_stack	*self;
 
 	self = mem_alloc(sizeof(*self));
-
 	array_init(&self->heads);
 	array_init(&self->slices);
 	array_init(&self->iterators);
 	array_reserve(&self->heads, 4);
 	array_reserve(&self->slices, 4);
 	array_reserve(&self->iterators, 4);
-
 	self->base_node = stack_node_new(NULL, NULL, false, 1);
 	ts_stack_clear(self);
-
 	return (self);
 }
 
@@ -481,27 +490,31 @@ void ts_stack_delete(t_stack *self)
 
 t_u32	ts_stack_version_count(const t_stack *self)
 {
-	return self->heads.size;
+	return (self->heads.size);
 }
 
 TSStateId	ts_stack_state(const t_stack *self, t_stack_version version)
 {
-	return array_get(&self->heads, version)->node->state;
+	return (array_get(&self->heads, version)->node->state);
 }
 
 Length	ts_stack_position(const t_stack *self, t_stack_version version)
 {
-	return array_get(&self->heads, version)->node->position;
+	return (array_get(&self->heads, version)->node->position);
 }
 
-Subtree ts_stack_last_external_token(const t_stack *self, t_stack_version version)
+Subtree	ts_stack_last_external_token(const t_stack *self,
+		t_stack_version version)
 {
-	return array_get(&self->heads, version)->last_external_token;
+	return (array_get(&self->heads, version)->last_external_token);
 }
 
-void ts_stack_set_last_external_token(t_stack *self, t_stack_version version, Subtree token)
+void	ts_stack_set_last_external_token(t_stack *self, t_stack_version version,
+		Subtree token)
 {
-	t_stack_head *head = array_get(&self->heads, version);
+	t_stack_head	*head;
+
+	head = array_get(&self->heads, version);
 	if (token)
 		ts_subtree_retain(token);
 	if (head->last_external_token)
@@ -511,165 +524,204 @@ void ts_stack_set_last_external_token(t_stack *self, t_stack_version version, Su
 
 t_u32	ts_stack_error_cost(const t_stack *self, t_stack_version version)
 {
-	t_stack_head *head = array_get(&self->heads, version);
+	t_stack_head	*head;
-	t_u32		  result = head->node->error_cost;
+	t_u32			result;
-	if (head->status == SStatusPaused || (head->node->state == ERROR_STATE && !head->node->links[0].subtree))
+
+	head = array_get(&self->heads, version);
+	result = head->node->error_cost;
+	if (head->status == SStatusPaused || (head->node->state == ERROR_STATE
+			&& !head->node->links[0].subtree))
 	{
 		result += ERROR_COST_PER_RECOVERY;
 	}
-	return result;
+	return (result);
 }
 
-t_u32 ts_stack_node_count_since_error(const t_stack *self, t_stack_version version)
+t_u32	ts_stack_node_count_since_error(const t_stack *self,
+		t_stack_version version)
 {
-	t_stack_head *head = array_get(&self->heads, version);
+	t_stack_head	*head;
+
+	head = array_get(&self->heads, version);
 	if (head->node->node_count < head->node_count_at_last_error)
 	{
 		head->node_count_at_last_error = head->node->node_count;
 	}
-	return head->node->node_count - head->node_count_at_last_error;
+	return (head->node->node_count - head->node_count_at_last_error);
 }
 
-void ts_stack_push(t_stack *self, t_stack_version version, Subtree subtree, bool pending, TSStateId state)
+void	ts_stack_push(t_stack *self, t_stack_version version, Subtree subtree,
+		bool pending, TSStateId state)
 {
-	t_stack_head *head = array_get(&self->heads, version);
+	t_stack_head	*head;
-	t_stack_node *new_node = stack_node_new(head->node, subtree, pending, state);
+	t_stack_node	*new_node;
+
+	head = array_get(&self->heads, version);
+	new_node = stack_node_new(head->node, subtree, pending, state);
 	if (!subtree)
 		head->node_count_at_last_error = new_node->node_count;
 	head->node = new_node;
 }
 
-t_stack_action pop_count_callback(void *payload, const t_stack_iterator *iterator)
+t_stack_action	pop_count_callback(void *payload,
+		const t_stack_iterator *iterator)
 {
-	t_u32 *goal_subtree_count = payload;
+	t_u32	*goal_subtree_count;
+
+	goal_subtree_count = payload;
 	if (iterator->subtree_count == *goal_subtree_count)
 	{
-		return SActionPop | SActionStop;
+		return (SActionPop | SActionStop);
 	}
 	else
 	{
-		return SActionNone;
+		return (SActionNone);
 	}
 }
 
-t_stack_slice_array ts_stack_pop_count(t_stack *self, t_stack_version version, t_u32 count)
+t_stack_slice_array	ts_stack_pop_count(t_stack *self, t_stack_version version,
+		t_u32 count)
 {
-	return stack__iter(self, version, pop_count_callback, &count, (int)count);
+	return (stack__iter(self, version, pop_count_callback, &count, (int)count));
 }
 
-t_stack_action pop_pending_callback(void *payload, const t_stack_iterator *iterator)
+t_stack_action	pop_pending_callback(void *payload,
+		const t_stack_iterator *iterator)
 {
 	(void)payload;
 	if (iterator->subtree_count >= 1)
 	{
 		if (iterator->is_pending)
-		{
+			return (SActionPop | SActionStop);
-			return SActionPop | SActionStop;
+		else
+			return (SActionStop);
 	}
 	else
-		{
+		return (SActionNone);
-			return SActionStop;
-		}
-	}
-	else
-	{
-		return SActionNone;
-	}
 }
 
 t_stack_slice_array	ts_stack_pop_pending(t_stack *self, t_stack_version version)
 {
-	t_stack_slice_array pop = stack__iter(self, version, pop_pending_callback, NULL, 0);
+	t_stack_slice_array	pop;
+
+	pop = stack__iter(self, version, pop_pending_callback, NULL, 0);
 	if (pop.size > 0)
 	{
 		ts_stack_renumber_version(self, pop.contents[0].version, version);
 		pop.contents[0].version = version;
 	}
-	return pop;
+	return (pop);
 }
 
-t_stack_action pop_error_callback(void *payload, const t_stack_iterator *iterator)
+t_stack_action	pop_error_callback(void *payload,
+		const t_stack_iterator *iterator)
 {
+	bool	*found_error;
+
 	if (iterator->subtrees.size > 0)
 	{
-		bool *found_error = payload;
+		found_error = payload;
-		if (!*found_error && ts_subtree_is_error(iterator->subtrees.contents[0]))
+		if (!*found_error
+			&& ts_subtree_is_error(iterator->subtrees.contents[0]))
 		{
 			*found_error = true;
-			return SActionPop | SActionStop;
+			return (SActionPop | SActionStop);
 		}
 		else
-		{
+			return (SActionStop);
-			return SActionStop;
-		}
 	}
 	else
-	{
+		return (SActionNone);
-		return SActionNone;
-	}
 }
 
 SubtreeArray	ts_stack_pop_error(t_stack *self, t_stack_version version)
 {
-	t_stack_node *node = array_get(&self->heads, version)->node;
+	t_stack_node		*node;
-	for (t_u32 i = 0; i < node->link_count; i++)
+	bool				found_error;
+	t_stack_slice_array	pop;
+	t_usize				i;
+
+	node = array_get(&self->heads, version)->node;
+	i = 0;
+	while (i < node->link_count)
 	{
-		if (node->links[i].subtree && ts_subtree_is_error(node->links[i].subtree))
+		if (node->links[i].subtree
+			&& ts_subtree_is_error(node->links[i].subtree))
 		{
-			bool				found_error = false;
+			found_error = false;
-			t_stack_slice_array pop = stack__iter(self, version, pop_error_callback, &found_error, 1);
+			pop = stack__iter(self, version, pop_error_callback, &found_error,
+					1);
 			if (pop.size > 0)
 			{
 				assert(pop.size == 1);
-				ts_stack_renumber_version(self, pop.contents[0].version, version);
+				ts_stack_renumber_version(self, pop.contents[0].version,
-				return pop.contents[0].subtrees;
+					version);
+				return (pop.contents[0].subtrees);
 			}
 			break ;
 		}
+		i++;
 	}
-	return (SubtreeArray){.size = 0};
+	return ((SubtreeArray){.size = 0});
 }
 
-t_stack_action pop_all_callback(void *payload, const t_stack_iterator *iterator)
+t_stack_action	pop_all_callback(void *payload,
+		const t_stack_iterator *iterator)
 {
 	(void)payload;
-	return iterator->node->link_count == 0 ? SActionPop : SActionNone;
+	if (iterator->node->link_count == 0)
+		return (SActionPop);
+	else
+		return (SActionNone);
 }
 
 t_stack_slice_array	ts_stack_pop_all(t_stack *self, t_stack_version version)
 {
-	return stack__iter(self, version, pop_all_callback, NULL, 0);
+	return (stack__iter(self, version, pop_all_callback, NULL, 0));
 }
 
-t_stack_action summarize_stack_callback(void *payload, const t_stack_iterator *iterator)
+t_stack_action	summarize_stack_callback(void *payload,
+		const t_stack_iterator *iterator)
 {
-	t_summarize_stack_session *session = payload;
+	t_summarize_stack_session	*session;
-	TSStateId				   state = iterator->node->state;
+	TSStateId					state;
-	t_u32					   depth = iterator->subtree_count;
+	t_u32						depth;
+	t_stack_summary_entry		entry;
+	t_usize						i;
+
+	session	= payload;
+	state = iterator->node->state;
+	depth = iterator->subtree_count;
 	if (depth > session->max_depth)
-		return SActionStop;
+		return (SActionStop);
-	for (t_u32 i = session->summary->size - 1; i + 1 > 0; i--)
+	i = session->summary->size - 1;
+	while (i + 1 > 0)
 	{
-		t_stack_summary_entry entry = session->summary->contents[i];
+		entry = session->summary->contents[i--];
 		if (entry.depth < depth)
 			break ;
 		if (entry.depth == depth && entry.state == state)
-			return SActionNone;
+			return (SActionNone);
 	}
-	array_push(session->summary, ((t_stack_summary_entry){
+	array_push(session->summary,
+				((t_stack_summary_entry){
 					.position = iterator->node->position,
 					.depth = depth,
 					.state = state,
 				}));
-	return SActionNone;
+	return (SActionNone);
 }
 
-void ts_stack_record_summary(t_stack *self, t_stack_version version, t_u32 max_depth)
+void	ts_stack_record_summary(t_stack *self, t_stack_version version,
+		t_u32 max_depth)
 {
-	t_summarize_stack_session session = {.summary = mem_alloc(sizeof(t_stack_summary)), .max_depth = max_depth};
+	t_summarize_stack_session	session; 
+	t_stack_head				*head;
+
+	session = (t_summarize_stack_session){.summary = mem_alloc(sizeof(t_stack_summary)), .max_depth = max_depth};
 	array_init(session.summary);
 	stack__iter(self, version, summarize_stack_callback, &session, -1);
-	t_stack_head *head = &self->heads.contents[version];
+	head = &self->heads.contents[version];
 	if (head->summary)
 	{
 		array_delete(head->summary);
@@ -680,32 +732,36 @@ void ts_stack_record_summary(t_stack *self, t_stack_version version, t_u32 max_d
 
 t_stack_summary	*ts_stack_get_summary(t_stack *self, t_stack_version version)
 {
-	return array_get(&self->heads, version)->summary;
+	return (array_get(&self->heads, version)->summary);
 }
 
 int	ts_stack_dynamic_precedence(t_stack *self, t_stack_version version)
 {
-	return array_get(&self->heads, version)->node->dynamic_precedence;
+	return (array_get(&self->heads, version)->node->dynamic_precedence);
 }
 
-bool ts_stack_has_advanced_since_error(const t_stack *self, t_stack_version version)
+bool	ts_stack_has_advanced_since_error(const t_stack *self,
+		t_stack_version version)
 {
 	const t_stack_head	*head = array_get(&self->heads, version);
 	const t_stack_node	*node = head->node;
+	Subtree				subtree;
+
 	if (node->error_cost == 0)
-		return true;
+		return (true);
 	while (node)
 	{
 		if (node->link_count > 0)
 		{
-			Subtree subtree = node->links[0].subtree;
+			subtree = node->links[0].subtree;
 			if (subtree)
 			{
 				if (ts_subtree_total_bytes(subtree) > 0)
 				{
-					return true;
+					return (true);
 				}
-				else if (node->node_count > head->node_count_at_last_error && ts_subtree_error_cost(subtree) == 0)
+				else if (node->node_count > head->node_count_at_last_error
+					&& ts_subtree_error_cost(subtree) == 0)
 				{
 					node = node->links[0].node;
 					continue ;
@@ -714,7 +770,7 @@ bool ts_stack_has_advanced_since_error(const t_stack *self, t_stack_version vers
 		}
 		break ;
 	}
-	return false;
+	return (false);
 }
 
 void	ts_stack_remove_version(t_stack *self, t_stack_version version)
@@ -723,14 +779,18 @@ void ts_stack_remove_version(t_stack *self, t_stack_version version)
 	array_erase(&self->heads, version);
 }
 
-void ts_stack_renumber_version(t_stack *self, t_stack_version v1, t_stack_version v2)
+void	ts_stack_renumber_version(t_stack *self, t_stack_version v1,
+		t_stack_version v2)
 {
+	t_stack_head	*source_head;
+	t_stack_head	*target_head;
+
 	if (v1 == v2)
 		return ;
 	assert(v2 < v1);
 	assert((t_u32)v1 < self->heads.size);
-	t_stack_head *source_head = &self->heads.contents[v1];
+	source_head = &self->heads.contents[v1];
-	t_stack_head *target_head = &self->heads.contents[v2];
+	target_head = &self->heads.contents[v2];
 	if (target_head->summary && !source_head->summary)
 	{
 		source_head->summary = target_head->summary;
@@ -741,50 +801,64 @@ void ts_stack_renumber_version(t_stack *self, t_stack_version v1, t_stack_versio
 	array_erase(&self->heads, v1);
 }
 
-void ts_stack_swap_versions(t_stack *self, t_stack_version v1, t_stack_version v2)
+void	ts_stack_swap_versions(t_stack *self, t_stack_version v1,
+		t_stack_version v2)
 {
-	t_stack_head temporary_head = self->heads.contents[v1];
+	t_stack_head	temporary_head;
+
+	temporary_head = self->heads.contents[v1];
 	self->heads.contents[v1] = self->heads.contents[v2];
 	self->heads.contents[v2] = temporary_head;
 }
 
 t_stack_version	ts_stack_copy_version(t_stack *self, t_stack_version version)
 {
+	t_stack_head	*head;
+
 	assert(version < self->heads.size);
 	array_push(&self->heads, self->heads.contents[version]);
-	t_stack_head *head = array_back(&self->heads);
+	head = array_back(&self->heads);
 	stack_node_retain(head->node);
 	if (head->last_external_token)
 		ts_subtree_retain(head->last_external_token);
 	head->summary = NULL;
-	return self->heads.size - 1;
+	return (self->heads.size - 1);
 }
 
-bool ts_stack_merge(t_stack *self, t_stack_version version1, t_stack_version version2)
+bool	ts_stack_merge(t_stack *self, t_stack_version version1,
+		t_stack_version version2)
 {
+	t_stack_head	*head1;
+	t_stack_head	*head2;
+	t_usize i;
+
 	if (!ts_stack_can_merge(self, version1, version2))
-		return false;
+		return (false);
-	t_stack_head *head1 = &self->heads.contents[version1];
+	head1 = &self->heads.contents[version1];
-	t_stack_head *head2 = &self->heads.contents[version2];
+	head2 = &self->heads.contents[version2];
-	for (t_u32 i = 0; i < head2->node->link_count; i++)
+	i = 0;
-	{
+	while (i < head2->node->link_count)
-		stack_node_add_link(head1->node, head2->node->links[i]);
+		stack_node_add_link(head1->node, head2->node->links[i++]);
-	}
 	if (head1->node->state == ERROR_STATE)
-	{
 		head1->node_count_at_last_error = head1->node->node_count;
-	}
 	ts_stack_remove_version(self, version2);
-	return true;
+	return (true);
 }
 
-bool ts_stack_can_merge(t_stack *self, t_stack_version version1, t_stack_version version2)
+bool	ts_stack_can_merge(t_stack *self, t_stack_version version1,
+		t_stack_version version2)
 {
-	t_stack_head *head1 = &self->heads.contents[version1];
+	t_stack_head	*head1;
-	t_stack_head *head2 = &self->heads.contents[version2];
+	t_stack_head	*head2;
-	return head1->status == SStatusActive && head2->status == SStatusActive && head1->node->state == head2->node->state &&
+
-		   head1->node->position.bytes == head2->node->position.bytes && head1->node->error_cost == head2->node->error_cost &&
+	head1 = &self->heads.contents[version1];
-		   ts_subtree_external_scanner_state_eq(head1->last_external_token, head2->last_external_token);
+	head2 = &self->heads.contents[version2];
+	return (head1->status == SStatusActive && head2->status == SStatusActive
+		&& head1->node->state == head2->node->state
+		&& head1->node->position.bytes == head2->node->position.bytes
+		&& head1->node->error_cost == head2->node->error_cost
+		&& ts_subtree_external_scanner_state_eq(head1->last_external_token,
+			head2->last_external_token));
 }
 
 void	ts_stack_halt(t_stack *self, t_stack_version version)
@@ -792,9 +866,12 @@ void ts_stack_halt(t_stack *self, t_stack_version version)
 	array_get(&self->heads, version)->status = SStatusHalted;
 }
 
-void ts_stack_pause(t_stack *self, t_stack_version version, Subtree lookahead)
+void	ts_stack_pause(t_stack *self, t_stack_version version,
+		Subtree lookahead)
 {
-	t_stack_head *head = array_get(&self->heads, version);
+	t_stack_head	*head;
+
+	head = array_get(&self->heads, version);
 	head->status = SStatusPaused;
 	head->lookahead_when_paused = lookahead;
 	head->node_count_at_last_error = head->node->node_count;
@@ -802,38 +879,43 @@ void ts_stack_pause(t_stack *self, t_stack_version version, Subtree lookahead)
 
 bool	ts_stack_is_active(const t_stack *self, t_stack_version version)
 {
-	return array_get(&self->heads, version)->status == SStatusActive;
+	return (array_get(&self->heads, version)->status == SStatusActive);
 }
 
 bool	ts_stack_is_halted(const t_stack *self, t_stack_version version)
 {
-	return array_get(&self->heads, version)->status == SStatusHalted;
+	return (array_get(&self->heads, version)->status == SStatusHalted);
 }
 
 bool	ts_stack_is_paused(const t_stack *self, t_stack_version version)
 {
-	return array_get(&self->heads, version)->status == SStatusPaused;
+	return (array_get(&self->heads, version)->status == SStatusPaused);
 }
 
 Subtree	ts_stack_resume(t_stack *self, t_stack_version version)
 {
-	t_stack_head *head = array_get(&self->heads, version);
+	t_stack_head	*head;
+	Subtree			result;
+
+	head = array_get(&self->heads, version);
 	assert(head->status == SStatusPaused);
-	Subtree result = head->lookahead_when_paused;
+	result = head->lookahead_when_paused;
 	head->status = SStatusActive;
 	head->lookahead_when_paused = NULL;
-	return result;
+	return (result);
 }
 
 void	ts_stack_clear(t_stack *self)
 {
+	t_usize i;
+
 	stack_node_retain(self->base_node);
-	for (t_u32 i = 0; i < self->heads.size; i++)
+	i = 0;
-	{
+	while (i < self->heads.size)
-		stack_head_delete(&self->heads.contents[i]);
+		stack_head_delete(&self->heads.contents[i++]);
-	}
 	array_clear(&self->heads);
-	array_push(&self->heads, ((t_stack_head){
+	array_push(&self->heads,
+				((t_stack_head){
 					.node = self->base_node,
 					.status = SStatusActive,
 					.last_external_token = NULL,