/*
This file implements a singly linked list.
Copyright (C) 2004 The University of Texas at Austin

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

This program 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 General Public License
for more details.

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

Email: usman@cs.njit.edu
Mail: Usman Roshan, Department of Computer Sciences, NJIT-CCS, Computer
Science Department, GITC 4400, University Heights, Newark, NJ 07102
*/
#include<list.h>
#include<stdlib.h>
#include<assert.h>
#include<stdio.h>

int
size_list(list l)
{
	assert(l);
	return l->size;
}

list
new_list()
{

	list            l;
	l = (list) malloc(sizeof(struct list_struct));
	l->head = 0;
	l->tail = 0;
	l->size = 0;
	return l;
}

list_node
new_list_node(void *v)
{

	list_node       n;
	n = (list_node) malloc(sizeof(struct list_node_struct));
	n->next = 0;
	n->prev = 0;
	n->data = v;
	return n;
}

void
del_list_node(list_node n)
{

	assert(n);

	/* MUST free data from main code by casting appropriately */
	assert(n->data == NULL);

	free(n);
}

void
del_list(list l)
{

	list_node       n, next;

	assert(l);
	for (n = l->head; n;) {
		next = n->next;
		del_list_node(n);
		n = next;
	}
	free(l);
}

list_node
append_list(list l, void *v)
{

	list_node       n;

	assert(l);
	n = new_list_node(v);
	if (!l->head) {
		l->head = n;
		l->tail = n;
	} else {
		l->tail->next = n;
		n->prev = l->tail;
		l->tail = n;
	}
	l->size++;
	return n;
}

list_node
insert_list(list l, void *v, list_node n, int where)
{

	list_node       nn = new_list_node(v);

	assert(l);
	assert(n);

	/* where=0 means insert before n and where=1 means after n */
	if (where == 0) {
		if (l->head == n) {
			nn->next = n;
			nn->prev = n->prev;
			n->prev = nn;
			l->head = nn;
		} else {
			nn->next = n;
			nn->prev = n->prev;
			n->prev->next = nn;
			n->prev = nn;
		}
	} else if (where == 1) {
		if (l->tail == n) {
			nn->prev = n;
			nn->next = n->next;
			n->next = nn;
			l->tail = nn;
		} else {
			nn->prev = n;
			nn->next = n->next;
			n->next->prev = nn;
			n->next = nn;
		}
	}
	l->size++;
	return nn;
}

void           *
pop_list(list l)
{
	void           *d;
	list_node       n;

	assert(l);
	assert(l->head != 0);
	d = l->head->data;
	n = l->head->next;
	del_list_node(l->head);
	l->head = n;
	if (l->head)
		l->head->prev = 0;
	l->size--;
	return d;
}

void
push_list(list l, void *d)
{
	list_node       n;

	assert(l);
	n = new_list_node(d);
	if (!l->head) {
		l->head = n;
		l->tail = n;
	} else {
		n->next = l->head;
		l->head->prev = n;
		l->head = n;
	}
	l->size++;
}