#include <assert.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>

#include "util.h"

/* --8<-- stack2_type */
typedef int T;

struct stack {
	T *    array;
	size_t sz, p;
};
/* -->8-- */

/* --8<-- stack2_init */
void
stack_init(struct stack *stack)
{
	stack->array = NULL;
	stack->sz    = 0;
	stack->p     = 0;
}
/* -->8-- */

/* --8<-- stack2_grow_if_needed */
static bool
stack_grow_if_needed(struct stack *stack)
{
	if ( stack->p == stack->sz ) {
		if ( stack->array == NULL ) {
			static const size_t initial_size = 10;

			if ( (stack->array = reallocarray(NULL, initial_size, sizeof stack->array[0])) != NULL ) {
				stack->sz = initial_size;
				stack->p  = 0;
			}
			else {
				ERROR("out of memory");
				return false;
			}
		}
		else {
			const size_t new_size = stack->sz * 3 / 2;

			T *new_array;

			if ( (new_array = reallocarray(stack->array, new_size, sizeof stack->array[0])) != NULL ) {
				stack->array = new_array;
				stack->sz    = new_size;
			}
			else {
				ERROR("out of memory");
				return false;
			}
		}
	}
	return true;
}
/* -->8-- */

/* --8<-- stack2_push */
bool
stack_push(struct stack *stack, T data)
{
	bool success = stack_grow_if_needed(stack);

	if ( success ) {
		stack->array[stack->p++] = data;
	}

	return success;
}
/* -->8-- */

/* --8<-- stack2_pop */
bool
stack_pop(struct stack *stack, T *data)
{
	if ( stack->p != 0 ) {
		--stack->p;

		if ( data ) {
			*data = stack->array[stack->p];
		}
		return true;
	}
	else
		return false;
}
/* -->8-- */

/* --8<-- stack2_empty */
bool
stack_empty(struct stack *stack)
{
	return stack->p == 0;
}
/* -->8-- */

/* --8<-- stack2_free */
void
stack_free(struct stack *stack)
{
	free(stack->array);
}
/* -->8-- */

void
test_stack(void)
{
	struct stack stack[1];

	stack_init(stack);

	assert(stack_empty(stack) == true);

	for ( int i = 0; i != 5; ++i )
		stack_push(stack, i);

	assert(stack_empty(stack) == false);

	T i;
	assert(stack_pop(stack, &i) == true);
	assert(i == 4);
	assert(stack_pop(stack, &i) == true);
	assert(i == 3);
	assert(stack_pop(stack, &i) == true);
	assert(i == 2);
	assert(stack_pop(stack, &i) == true);
	assert(i == 1);
	assert(stack_pop(stack, &i) == true);
	assert(i == 0);

	assert(stack_pop(stack, &i) == false);

	assert(stack_empty(stack) == true);

	assert(stack[0].sz == 10);
	assert(stack[0].p == 0);

	for ( int i = 0; i != 23; ++i )
		stack_push(stack, i);

	assert(stack[0].sz == 33);
	assert(stack[0].p == 23);

	stack_free(stack);
}

int
main()
{
	test_stack();
	return EXIT_SUCCESS;
}