131 lines
3.6 KiB
C
131 lines
3.6 KiB
C
/* This file contains the function implementations for a stack. */
|
|
/* Include guards + includes. */
|
|
#ifndef STACK_C
|
|
#define STACK_C
|
|
/* Include statements. */
|
|
#include "stack.h"
|
|
#endif /* STACK_C */
|
|
|
|
/* This function initializes a new empty stack. */
|
|
/* Returns a valid pointer on success, and NULL on failure. */
|
|
stack_t* initialize_stack() {
|
|
/* Variables. */
|
|
stack_t *result;
|
|
|
|
/* Attempt to allocate. */
|
|
result = (stack_t*) malloc(sizeof(stack_t));
|
|
if (result == NULL)
|
|
return NULL;
|
|
/* Allocation succeeded, initialize and return. */
|
|
result->size = INITIAL_STACK_SIZE;
|
|
result->head = NULL;
|
|
return result;
|
|
}
|
|
|
|
/* This function pops the current head node out, if it exists, otherwise will return NULL (also returns NULL on errornous input). */
|
|
node_t* pop(stack_t *stack) {
|
|
/* Sanity check. */
|
|
if (stack == NULL || stack->head == NULL)
|
|
return NULL;
|
|
|
|
/* Remove the head. */
|
|
node_t *head = stack->head;
|
|
stack->head = head->next;
|
|
(stack->size) -= 1;
|
|
|
|
/* Return the head.*/
|
|
return head;
|
|
}
|
|
|
|
/* This function "peeks" at the top of the stack, will return NULL on error (in input/internal). */
|
|
const void* peek(stack_t *stack) {
|
|
/* Sanity check. */
|
|
if (stack == NULL)
|
|
return NULL;
|
|
|
|
}
|
|
|
|
/* This function pushes a node in, returns PUSH_SUCCESS on succes and PUSH_FAIL on failure. */
|
|
/* Will fail for a NULL stack or node! */
|
|
int push(stack_t *stack, node_t *node) {
|
|
/* Sanity check. */
|
|
if (stack == NULL || node == NULL)
|
|
return PUSH_FAIL;
|
|
/* Try to push. */
|
|
/* Increase the count. */
|
|
(stack->size) += 1;
|
|
/* Check if the head is NULL or not. */
|
|
if (stack->head == NULL) {
|
|
stack->head = node;
|
|
node->next = NULL;
|
|
return PUSH_SUCCESS;
|
|
}
|
|
/* Relink the head. */
|
|
node->next = stack->head;
|
|
stack->head = node;
|
|
return PUSH_SUCCESS;
|
|
}
|
|
|
|
/* This function creates a node, stores the given data and pushes it into the stack, will fail on a NULL stack or allocation errors. */
|
|
/* Returns PUSH_SUCCESS on success, and PUSH_FAIL on failure. */
|
|
int push_data(stack_t *stack, void *data) {
|
|
/* Sanity check. */
|
|
if (stack == NULL)
|
|
return PUSH_FAIL;
|
|
/* Try to allocate the new node. */
|
|
node_t *node = (node_t*) malloc(sizeof(node_t));
|
|
if (node == NULL)
|
|
return PUSH_FAIL;
|
|
/* Store the data in the node. */
|
|
node->data = data;
|
|
/* Delegate. */
|
|
return push(stack, node);
|
|
}
|
|
|
|
/* This function returns the stack's size, will return INVALID_SIZE for a NULL stack. */
|
|
int stack_size(stack_t *stack) {
|
|
return (stack == NULL) ? INVALID_SIZE : stack->size;
|
|
}
|
|
|
|
/* This function frees a stack, doesn't touch the data. */
|
|
/* Takes a pointer to a pointer so it can set the original pointer to NULL. */
|
|
void free_stack(stack_t **stack) {
|
|
/* Sanity check. */
|
|
if (stack == NULL || *stack == NULL)
|
|
return;
|
|
/* Start by freeing node after node. */
|
|
node_t *current = (*stack)->head;
|
|
node_t *tmp;
|
|
while (current != NULL) {
|
|
tmp = current->next;
|
|
free(current);
|
|
current = tmp;
|
|
}
|
|
/* Free the stack. */
|
|
free(*stack);
|
|
*stack = NULL;
|
|
}
|
|
|
|
/* This function frees a stack and the data stored within the nodes thereof, if free_function is NULL will use STDLIB's free() instead to free the data. */
|
|
/* Takes a pointer to a pointer so it can set the original pointer to NULL. */
|
|
void free_stack_data(stack_t **stack, void (*free_function)()) {
|
|
/* Sanity check. */
|
|
if (stack == NULL || *stack == NULL)
|
|
return;
|
|
/* Start by freeing node after node. */
|
|
node_t *current = (*stack)->head;
|
|
node_t *tmp;
|
|
while (current != NULL) {
|
|
tmp = current->next;
|
|
if (free_function != NULL)
|
|
free_function(current->data);
|
|
else
|
|
free(current->data);
|
|
free(current);
|
|
current = tmp;
|
|
}
|
|
/* Free the stack. */
|
|
free(*stack);
|
|
*stack = NULL;
|
|
}
|