[clib.git] / src / stack.c

#include <stdlib.h>
#include "stack.h"

#define INIT_SIZE  100

struct _Stack {
	int size;
	void** elems;
	StackFreeFunc free;
};

static void free_elem(Stack* stack) {
	if (stack->free) {
		for (int i = 0; i < stack->size; i++)
			stack->free(stack->elems[i]);
	}
	free(stack->elems);
}

static Stack* stack_new_common() {
	Stack* s = malloc(sizeof(Stack));
	s->elems = malloc(sizeof(void*) * INIT_SIZE);
	s->size = 0;
	s->free = NULL;
	return s;
}

Stack* stack_new() {
	return stack_new_common();
}

Stack* stack_new_full(StackFreeFunc free) {
	Stack* s = 	stack_new_common();
	s->free = free;
	return s;
}

void stack_destroy(Stack* stack) {
	free_elem(stack);
	free(stack);
}

void* stack_pop(Stack* stack) {
	if (stack_empty(stack))
		return NULL;
	stack->size -= 1;
	void* elem = stack->elems[stack->size];
	stack->elems[stack->size] = NULL;

	return elem;
}

void stack_push(Stack* stack, void* elem) {
	if (stack == NULL)
		return;

	stack->size += 1;
	if (stack->size == INIT_SIZE) {
		stack->elems = realloc(stack->elems, (INIT_SIZE + stack->size) * sizeof(void*));
	}

	stack->elems[stack->size - 1] = elem;
}

void* stack_peek(Stack* stack) {
	if (stack_empty(stack))
		return NULL;
	return stack->elems[stack->size - 1];
}

bool stack_empty(Stack* stack) {
	return (stack == NULL || stack->size == 0);
}

void stack_clear(Stack* stack) {
	if (stack == NULL)
		return;

	free_elem(stack);
	stack->size = 0;
}

int stack_size(Stack* stack) {
	if (stack_empty(stack))
		return 0;
	return stack->size;
}

/*
typedef struct _Stack {
	void** elems;
	int size;
	StackFreeFunc free;
} Stack;

static void free_elem(Stack* stack) {
	if (stack->free) {
		for (int i = 0; i < stack->size; i++)
			stack->free(stack->elems[i]);
	}
	free(stack->elems);
}

Stack* stack_new() {
	Stack* s = malloc(sizeof(Stack));
	s->size = 0;
	s->elems = NULL;
	s->free = NULL;
	return s;
}

Stack* stack_new_full(StackFreeFunc free) {
	Stack* s = malloc(sizeof(Stack));
	s->size = 0;
	s->elems = NULL;
	s->free = free;
	return s;
}

void stack_destroy(Stack* stack) {
	free_elem(stack);
	free(stack);
}

void* stack_pop(Stack* stack) {
	if (stack_empty(stack))
		return NULL;
	stack->size -= 1;
	void* elem = stack->elems[stack->size];
	stack->elems[stack->size] = NULL;
	stack->elems = realloc(stack->elems, stack->size * sizeof(void*));

	return elem;
}

void stack_push(Stack* stack, void* elem) {
	if (stack == NULL)
		return;

	stack->size += 1;
	stack->elems = realloc(stack->elems, stack->size * sizeof(void*));
	stack->elems[stack->size - 1] = elem;
}

void* stack_peek(Stack* stack) {
	if (stack_empty(stack))
		return NULL;
	return stack->elems[stack->size - 1];
}

bool stack_empty(Stack* stack) {
	return (stack == NULL || stack->size == 0);
}

void stack_clear(Stack* stack) {
	if (stack == NULL)
		return;

	free_elem(stack);
	stack->size = 0;
	stack->elems = NULL;
}

int stack_size(Stack* stack) {
	if (stack_empty(stack))
		return 0;
	return stack->size;
}
*/
Commit	Line	Data
392d65ba MR	1	#include <stdlib.h>
	2	#include "stack.h"
	3
	4	#define INIT_SIZE 100
	5
	6	struct _Stack {
	7	int size;
	8	void** elems;
	9	StackFreeFunc free;
	10	};
	11
	12	static void free_elem(Stack* stack) {
	13	if (stack->free) {
	14	for (int i = 0; i < stack->size; i++)
	15	stack->free(stack->elems[i]);
	16	}
	17	free(stack->elems);
	18	}
	19
	20	static Stack* stack_new_common() {
	21	Stack* s = malloc(sizeof(Stack));
	22	s->elems = malloc(sizeof(void) INIT_SIZE);
	23	s->size = 0;
	24	s->free = NULL;
	25	return s;
	26	}
	27
	28	Stack* stack_new() {
	29	return stack_new_common();
	30	}
	31
	32	Stack* stack_new_full(StackFreeFunc free) {
	33	Stack* s = stack_new_common();
	34	s->free = free;
	35	return s;
	36	}
	37
	38	void stack_destroy(Stack* stack) {
	39	free_elem(stack);
	40	free(stack);
	41	}
	42
	43	void* stack_pop(Stack* stack) {
	44	if (stack_empty(stack))
	45	return NULL;
	46	stack->size -= 1;
	47	void* elem = stack->elems[stack->size];
	48	stack->elems[stack->size] = NULL;
	49
	50	return elem;
	51	}
	52
	53	void stack_push(Stack* stack, void* elem) {
	54	if (stack == NULL)
	55	return;
	56
	57	stack->size += 1;
	58	if (stack->size == INIT_SIZE) {
	59	stack->elems = realloc(stack->elems, (INIT_SIZE + stack->size) * sizeof(void*));
	60	}
	61
	62	stack->elems[stack->size - 1] = elem;
	63	}
	64
65	void* stack_peek(Stack* stack) {
66	if (stack_empty(stack))
67	return NULL;
68	return stack->elems[stack->size - 1];
69	}
70
71	bool stack_empty(Stack* stack) {
72	return (stack == NULL \|\| stack->size == 0);
73	}
74
75	void stack_clear(Stack* stack) {
76	if (stack == NULL)
77	return;
78
79	free_elem(stack);
80	stack->size = 0;
81	}
82
83	int stack_size(Stack* stack) {
84	if (stack_empty(stack))
85	return 0;
86	return stack->size;
87	}
88
89	/*
90	typedef struct _Stack {
91	void** elems;
92	int size;
93	StackFreeFunc free;
94	} Stack;
95
96	static void free_elem(Stack* stack) {
97	if (stack->free) {
98	for (int i = 0; i < stack->size; i++)
99	stack->free(stack->elems[i]);
100	}
101	free(stack->elems);
102	}
103
104	Stack* stack_new() {
105	Stack* s = malloc(sizeof(Stack));
106	s->size = 0;
107	s->elems = NULL;
108	s->free = NULL;
109	return s;
110	}
111
112	Stack* stack_new_full(StackFreeFunc free) {
113	Stack* s = malloc(sizeof(Stack));
114	s->size = 0;
115	s->elems = NULL;
116	s->free = free;
117	return s;
118	}
119
120	void stack_destroy(Stack* stack) {
121	free_elem(stack);
122	free(stack);
123	}
124
125	void* stack_pop(Stack* stack) {
126	if (stack_empty(stack))
127	return NULL;
128	stack->size -= 1;
129	void* elem = stack->elems[stack->size];
130	stack->elems[stack->size] = NULL;
131	stack->elems = realloc(stack->elems, stack->size * sizeof(void*));
132
133	return elem;
134	}
135
136	void stack_push(Stack* stack, void* elem) {
137	if (stack == NULL)
138	return;
139
140	stack->size += 1;
141	stack->elems = realloc(stack->elems, stack->size * sizeof(void*));
142	stack->elems[stack->size - 1] = elem;
143	}
144
145	void* stack_peek(Stack* stack) {
146	if (stack_empty(stack))
147	return NULL;
148	return stack->elems[stack->size - 1];
149	}
150
151	bool stack_empty(Stack* stack) {
152	return (stack == NULL \|\| stack->size == 0);
153	}
154
155	void stack_clear(Stack* stack) {
156	if (stack == NULL)
157	return;
158
159	free_elem(stack);
160	stack->size = 0;
161	stack->elems = NULL;
162	}
163
164	int stack_size(Stack* stack) {
165	if (stack_empty(stack))
166	return 0;
167	return stack->size;
168	}
169	*/