stack.c

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

typedef struct frame frame;

struct stack
{
  frame *top;
  int size;
};

struct frame
{
  void *val;
  frame *nxt;
};

// Make a new stack (which is EMPTY)
stack *stack_new() {
  stack *tmp = calloc(1,sizeof(stack)); //ALWAYS USE CALLOC!
  tmp->top = NULL;
  return tmp;
}

// Remove a stack from memory
void stack_free(stack *s) {
  assert(s != NULL);
  while (stack_size(s) > 0) {
    stack_pop(s);
  }
  free(s);
  // Nice, but unnecessary:
  //  frame *cur = s->top;
  //  while (cur != NULL) {
  //    frame *nxt = cur->nxt;
  //    free(cur);
  //    cur = nxt;
  //  }
}

// Push elem to s
void stack_push(stack *s, void *elem) {
  assert(s != NULL);
  assert(elem != NULL);
  // 1. make new stackframe
  frame *new_top = calloc(1, sizeof(frame));
  new_top->val = elem;
  // 2. link from new frame to old top
  new_top->nxt = s->top;
  // 3. change top to refer to new stackframe
  s->top = new_top;
  s->size++;
}
// Pop an element from s. Returns NULL if s is empty
void *stack_pop(stack *s) {
  assert(s != NULL);
  frame *old_top = s->top;
  frame *new_top = old_top->nxt;
  void  *ret     = old_top->val;
  s->top         = new_top;
  free(old_top);
  s->size--;
  return ret;
}

// Return the top element of s. Returns NULL if s is empty
void *stack_top(stack *s) {
  assert(s != NULL);
  if (s->top == NULL) {
    return NULL;
  } else {
    return s->top->val; // IS THE SAME AS "return (*(*s).top).val;"
  }
}

// Return the number of elements in the stack
int stack_size(stack *s) {
  assert(s != NULL);
  return s->size;
  //  int cnt = 0;
  //  iter_t *it;
  //  for (it = iterator_new(s); iterator_has_more(it); iterator_next(it)) {
  //    cnt++;
  //  }
  //  iterator_free(it);
  //  return cnt;
}
// An iterator for the stack

struct iterator
{
  frame *cur;
};

// Initialize an iterator
iter_t *iterator_new(stack *s) {
  assert(s != NULL);
  iter_t *it = calloc(1, sizeof(iter_t));
  it->cur = s->top; //irony-mode
  return it;
}

// Remove an iterator from memory
void iterator_free(iter_t *i) {
  assert(i != NULL);
  free(i);
}

// Return current element and move i forward
void *iterator_next(iter_t *i) {
  assert(i != NULL);
  void *elt = i->cur->val;
  i->cur = i->cur->nxt;
  return elt;
}
// true if i has more elements, false otherwise
bool iterator_has_more(iter_t *i) {
  assert(i != NULL);
  return (i->cur != NULL);
  // IS THE SAME AS:
  //  if (i->cur != NULL) {
  //    return true;
  //  } else {
  //    return false;
  //  }
}