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

/*  Retourne une nouvelle pile vide, ou NULL en cas d'erreur.  */

stack *stack_new(void)
{
  stack *s;

  s = malloc(sizeof(stack));
  if (!s)
    return NULL;

  s -> first = NULL;
  s -> nb_values = 0;

  return s;
}

/*  Libère la pile <s>.  */

void stack_free(stack *s)
{
  stack_element *e, *e_suivant;
  for (e = s -> first; e; e = e_suivant)
    {
      e_suivant = e -> next;
      free(e);
    }

  free(s);
}

/*  Empile le pointeur <p> sur la pile <s>.  Retourne 0 en cas de succès,
    ou -1 en cas d'insuffisance mémoire.  */

int stack_push(stack *s, void *p)
{
  stack_element *e;

  e = malloc(sizeof(stack_element));
  if (!e)
    return -1;

  e -> content = p;
  e -> next = s -> first;
  s -> first = e;
  s -> nb_values++;

  return 0;
}

/*  Dépile un pointeur depuis la pile <s> et retourne ce pointeur,
    ou NULL si la pile est vide.  */

void *stack_pop(stack *s)
{
  stack_element *e;
  void          *p;

  if (!(s -> first))
    return NULL;

  e = s -> first;
  p = e -> content;

  s -> first = e -> next;
  s -> nb_values--;

  free(e);

  return p;
}

/*  Retourne le pointeur au sommet de la pile <s>, sans le dépiler,
    ou NULL si la pile est vide.  */

void *stack_top(stack *s)
{
  if (!(s -> first))
    return NULL;

  return s -> first -> content;
}

/*  Retourne le nombre d'éléments présents dans la pile <s>.  */

unsigned stack_size(stack *s)
{
  return s -> nb_values;
}

/*  Détermine si la pile <s> est vide.  */

int stack_is_empty(stack *s)
{
  return s -> nb_values == 0;
}