/*------------------------------------------------------------------*/
/* stacklist.c (A Generic Stack ADT Implementation)                 */
/*------------------------------------------------------------------*/

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

struct StackNode
{
   const void *pvItem;
   struct StackNode *psNextNode;
};

struct Stack 
{
   struct StackNode *psFirstNode;
};

/*------------------------------------------------------------------*/

Stack_T Stack_new(void)

/* Return a new Stack_T. */
 
{
  Stack_T oStack;

  oStack = (Stack_T)malloc(sizeof(struct Stack));
  assert(oStack != NULL);

  oStack->psFirstNode = NULL; 
  return oStack; 
}

/*------------------------------------------------------------------*/

void Stack_free(Stack_T oStack)

/* Free oStack. */

{
   struct StackNode *psCurrentNode;
   struct StackNode *psNextNode;

   if (oStack == NULL)
       return;

   for (psCurrentNode = oStack->psFirstNode;
        psCurrentNode != NULL;
        psCurrentNode = psNextNode)
   {
      psNextNode = psCurrentNode->psNextNode;
      free(psCurrentNode);
   }

   free(oStack);
}

/*------------------------------------------------------------------*/

void Stack_push(Stack_T oStack, const void *pvItem) 

/* Push pvItem onto oStack. 
   It is a checked runtime error for oStack to be NULL. */

{
   struct StackNode *psNewNode;
  
   assert(oStack != NULL);

   psNewNode = (struct StackNode*)malloc(sizeof(struct StackNode));
   assert(psNewNode != NULL);

   psNewNode->pvItem = pvItem;
   psNewNode->psNextNode = oStack->psFirstNode;
   oStack->psFirstNode = psNewNode;
}

/*------------------------------------------------------------------*/

void *Stack_pop(Stack_T oStack) 

/* Pop oStack, and return the popped item.
   It is a checked runtime error for oStack to be NULL or empty. */ 

{
   const void *pvItem;
   struct StackNode *psNextNode;

   assert(oStack != NULL);
   assert(oStack->psFirstNode != NULL);

   pvItem = oStack->psFirstNode->pvItem;
   psNextNode = oStack->psFirstNode->psNextNode;
   free(oStack->psFirstNode);
   oStack->psFirstNode = psNextNode;
   return (void*)pvItem;
}

/*------------------------------------------------------------------*/
 
int Stack_isEmpty(Stack_T oStack) 

/* Return 1 (TRUE) iff oStack is empty. 
   It is a checked runtime error for oStack to be NULL. */

{
   assert(oStack != NULL);
 
   return oStack->psFirstNode == NULL; 
}