/* Output from p2c, the Pascal-to-C translator */
/* From input file "lists.pas" */


#include <p2c/p2c.h>


#define LISTS_G
#include "lists1.h"


Static inode dummy_node = {
  0x7FFFFFFF, NULL, NULL
};


Void init_list(ilist)
list *ilist;
{
  ilist->head = &dummy_node;
  ilist->tail = &dummy_node;
  ilist->next = &dummy_node;
  ilist->count = 0;
}


/* Local variables for add: */
struct LOC_add {
  list *ilist;
  Anyptr element;
  long idx;
  inode *current, *last;
} ;

Local Void insert_(LINK)
struct LOC_add *LINK;
{
  inode *temp;

  LINK->ilist->count++;
  temp = (inode *)Malloc(sizeof(inode));
  /* link in new node to next node */
  temp->next = LINK->current;

  /* set element pointer */
  temp->e = LINK->element;

  /* set index */
  temp->idx = LINK->idx;

  /* fix previous node to point to new node,
     unless current is present head of list */
  if (LINK->current != LINK->last)
    LINK->last->next = temp;

  /* inserted at head of list, replace head */
  if (LINK->current == LINK->ilist->head)
    LINK->ilist->head = temp;

  /* inserted at tail of list, replace tail */
  if (LINK->current == &dummy_node)
    LINK->ilist->tail = temp;
}


Void add(ilist_, element_, idx_)
list *ilist_;
Anyptr element_;
long idx_;
{
  struct LOC_add V;

  V.ilist = ilist_;
  V.element = element_;
  V.idx = idx_;
  V.current = V.ilist->head;
  V.last = V.current;
  while (V.current->next != NULL) {   /*not at end of list... */
    if (V.idx > V.current->idx) {   /* not found yet... */
      V.last = V.current;
      V.current = V.current->next;
      continue;
    } else {  /* proper place to insert new node */
      if (V.idx == V.current->idx) {   /* replace element */
	Free(V.current->e);
	V.current->e = V.element;
	V.ilist->next = V.current;
	return;
      } else {  /* add new element to list */
	insert_(&V);
	V.ilist->next = V.last->next;
	return;
      }
    }
  }
  /* else empty list */
  insert_(&V);
  V.ilist->next = V.ilist->head;
}


Anyptr recall(ilist, idx)
list *ilist;
long idx;
{
  Anyptr Result;
  inode *current;

  Result = NULL;   /* default is NOT found! */
  current = ilist->head;
  while (current->next != NULL) {
    if (idx <= current->idx) {   /* not found yet... */
      if (idx == current->idx)   /* retrieve element */
	return (current->e);
      else  /* index not found */
	return Result;
    }
    current = current->next;
  }
  return Result;

  /* maybe matches desired index */
}


/* Local variables for remove: */
struct LOC_remove {
  list *ilist;
  inode *current, *last;
} ;

Local Void delete__(LINK)
struct LOC_remove *LINK;
{
  LINK->ilist->count--;

  /* delete element pointer */
  Free(LINK->current->e);

  /* fix previous node to point to next node,
     unless current is present head of list */
  if (LINK->current != LINK->last)
    LINK->last->next = LINK->current->next;

  /* deleted at head of list, replace head */
  if (LINK->current == LINK->ilist->head)
    LINK->ilist->head = LINK->current->next;

  /* deleted at 'next' on list, replace next */
  if (LINK->current == LINK->ilist->next)
    LINK->ilist->next = LINK->current->next;

  /* deleted at tail of list, replace tail */
  if (LINK->current == LINK->ilist->tail) {
    if (LINK->current != LINK->last)
      LINK->ilist->tail = LINK->last;
    else
      LINK->ilist->tail = &dummy_node;
  }

  /* finally, remove inode */
  Free(LINK->current);
}

Void removelist(ilist_, idx)
list *ilist_;
long idx;
{
  struct LOC_remove V;

  V.ilist = ilist_;
  V.current = V.ilist->head;
  V.last = V.current;
  while (V.current->next != NULL) {   /*not at end of list... */
    if (idx <= V.current->idx) {   /* not found yet... */
      if (idx == V.current->idx) {   /* delete element */
	delete__(&V);
	return;
      } else  /* index not found */
	return;
    }
    V.last = V.current;
    V.current = V.current->next;
  }
  /* else empty list */

  /* proper place to delete node */
}


Void kill_netres(ilist)
list *ilist;
{
  inode *current, *last;

  current = ilist->head;
  while (current != &dummy_node) {   /*not at end of list... */
    last = current;
    current = current->next;
    Free(last->e);
    Free(last);
  }
  /* else already empty list */

  /* always set list up for possible reuse */
  init_list(ilist);
}


Anyptr head(ilist)
list *ilist;
{
  Anyptr Result;

  Result = ilist->head->e;
  ilist->next = ilist->head;
  return Result;
}


Anyptr tail(ilist)
list *ilist;
{
  Anyptr Result;

  Result = ilist->tail->e;
  ilist->next = ilist->tail;
  return Result;
}


Anyptr next(ilist)
list *ilist;
{
  ilist->next = ilist->next->next;
  return (ilist->next->e);
}


boolean member(ilist, idx)
list *ilist;
long idx;
{
  boolean Result;
  inode *current;

  Result = false;   /* default is NOT found! */
  current = ilist->head;
  while (current->next != NULL) {
    if (idx <= current->idx) {   /* not found yet... */
      if (idx == current->idx)   /* element found */
	return true;
      else  /* index not found */
	return Result;
    }
    current = current->next;
  }
  return Result;

  /* maybe matches desired index */
}


Void setnext(ilist, idx)
list *ilist;
long idx;
{
  inode *current, *last;

  current = ilist->head;
  last = current;
  while (current->next != NULL) {
    if (idx > current->idx) {   /* not found yet... */
      last = current;
      current = current->next;
      continue;
    } else {  /* maybe matches desired index */
      if (idx == current->idx) {   /* set next */
	ilist->next = last;
	return;
      } else {  /* index not found */
	ilist->next = ilist->tail;
	return;
      }
    }
  }
}




/* End. */