/*
Libraries for fields, doubly-linked lists and red-black trees.
Copyright (C) 2001 James S. Plank

This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

---------------------------------------------------------------------------

Jim Plank
plank@cs.utk.edu
http://web.eecs.utk.edu/~jplank

Associate Professor
Department of Computer Science
University of Tennessee
203 Claxton Complex
1122 Volunteer Blvd.
Knoxville, TN 37996-3450

     865-974-4397
Fax: 865-974-4404
*/

/* Revision Date: 9/09
 * Modified by Brad Vander Zanden in the following ways:
 * 
 * 1) Added a container object to point to the sentinel node
 * 2) Changed the val field from a JVal to a void *
 * 3) Changed the names of the flink and blink fields to next and prev
 * 4) Changed the typedef to a node from a pointer to a struct to a simple struct and
 *     appropriately modified the return values and parameter lists of the functions
 */

#include <stdio.h>    /* Basic includes and definitions */
#include <stdlib.h>
#include "dllist.h"

/*---------------------------------------------------------------------*
 * PROCEDURES FOR MANIPULATING DOUBLY LINKED LISTS 
 * Each list contains a sentinel node.
 * If l is empty, then the sentinel node points to itself.
 *---------------------------------------------------------------------*/

Dllist* new_dllist()
{
  Dllist *d;
  Dllist_Node *node;

  d = (Dllist *) malloc (sizeof(Dllist));
  node = (Dllist_Node *)malloc(sizeof(Dllist_Node));
  d->sentinel_node = node;
  node->next = node;
  node->prev = node;
  return d;
}

/* Inserts before a given node */
Dllist_Node *dll_insert_before(Dllist_Node *node, void *v)
{
  Dllist_Node *newnode;
  Dllist_Node *prev_node = node->prev;

  newnode = (Dllist_Node *) malloc (sizeof(Dllist_Node));
  newnode->val = v;

  newnode->next = node;
  newnode->prev = prev_node;
  node->prev = newnode;
  prev_node->next = newnode;

  return newnode;
}

/* Inserts after a given node */
Dllist_Node *dll_insert_after(Dllist_Node *n, void *val)        
{
  printf("you still have to implement  this function\n");
  /* Your code goes here */
}

/* Inserts at the end of the list */
Dllist_Node *dll_append(Dllist *l, void *val)
{
  printf("you still have to implement  this function\n");
  /* Your code goes here */
}

/* Inserts at the beginning of the list */
Dllist_Node *dll_prepend(Dllist *l, void *val)    
{
  printf("you still have to implement  this function\n");
  /* Your code goes here */
}

/* Deletes an arbitrary item */
void dll_delete_node(Dllist_Node *node)		
{
  printf("you still have to implement  this function\n");
  /* Your code goes here */
}

int dll_empty(Dllist *l)
{
  return (l->sentinel_node->next == l->sentinel_node);
}
 
void free_dllist(Dllist *l)
{
  while (!dll_empty(l)) {
    dll_delete_node(dll_first(l));
  }
  free(l->sentinel_node);
  free(l);
}

void *dll_val(Dllist_Node *n)
{
  return n->val;
}

Dllist_Node *dll_sentinel(Dllist *l) {
  return l->sentinel_node;
}

Dllist_Node *dll_first(Dllist *l) {
  return l->sentinel_node->next;
}

Dllist_Node *dll_last(Dllist *l) {
  return l->sentinel_node->prev;
}

Dllist_Node *dll_next(Dllist_Node *n) {
  return n->next;
}

Dllist_Node *dll_prev(Dllist_Node *n) {
  return n->prev;
}