/* Init a doubly linked list. You need to call this
 * to every declared dllist before to perform any
 * other action on it. Calling this will an already
 * initialized dllist is undefined behavior.
 */
void init (dlist *tdlist) /*HEADER*/
{
    tdlist->fist = tdlist->last = -1;
    tdlist->n=0;
}


/* This function will add a node to your linked list
 * pointer by *list
 */
void add (dlist *tdlist, int tnode) /*HEADER*/
{
    self.jects[tnode].next = -1;
    if (tdlist->n == 0) {
        tdlist->fist = tdlist->last = tnode;
        self.jects[tnode].prev = -1;
    } else {
        self.jects[tdlist->last].next = tnode;
        self.jects[tnode].prev = tdlist->last;
        tdlist->last = tnode;
    }
    tdlist->n++;
}


/* This function will unlink a node from
 * your dllist and free its memory.
 *
 * If you call this with a NULL node it will returns
 * ERROR, defined as -1. If you call it with a empty
 * list it will returns BADCALL defined as (ERROR -1)
 */
void del (dlist *tdlist, int tnode) /*HEADER*/
{
    if (tdlist->n == 0)
    {
                deb::lcroak("dlist::del( %i );error;\n",tnode); //DEBUG!!!
    }

    else if (tdlist->n == 1)
    {
        tdlist->fist = tdlist->last = -1;
    }

    else if (tnode == tdlist->fist)
    {
        tdlist->fist = self.jects[tdlist->fist].next;
        self.jects[tdlist->fist].prev=-1;
    }
    else if (tnode == tdlist->last)
    {
        tdlist->last = self.jects[tdlist->last].prev;
        self.jects[tdlist->last].next=-1;
    }
    else
    {
        self.jects[self.jects[tnode].next].prev = self.jects[tnode].prev;
        self.jects[self.jects[tnode].prev].next = self.jects[tnode].next;
    }
    tdlist->n--;
    return;
}
/*
#------------------------------------------------------
# next
#------------------------------------------------------*/
int next (int tnode) /*HEADER*/
{
    return( self.jects[tnode].next );
}

/*
#------------------------------------------------------
# getNode
#------------------------------------------------------*/
node *getNode (int tnode) /*HEADER*/
{
    return( &self.jects[tnode] );
}

/*
#------------------------------------------------------
# addFree
#------------------------------------------------------*/
int addFree () /*HEADER*/
{
    int tnode;
    if (self.freeNodes.n > 0)
    {
        tnode=self.freeNodes.fist;
        del(&self.freeNodes,tnode);
    }
    else
    {
        tnode=self.nodeNum;
        if (tnode >= self.nodeMax)
        {
              deb::lcroak("dlist::addNew( );error;\n"); //DEBUG!!!
        }
        self.nodeNum++;
    }
    return( tnode );
}
/*
#------------------------------------------------------
# addNew
#------------------------------------------------------*/
int addNew (dlist *tdlist) /*HEADER*/
{
    int tnode = addFree();
    add(tdlist,tnode);

    return( tnode );
}


/*
#------------------------------------------------------
# addDlist
#------------------------------------------------------*/
void addDlist (dlist *tdlist1, dlist *tdlist2) /*HEADER*/
{
    if (tdlist2->n == 0)
    {
            return;
    }

    if (tdlist1->n == 0)
    {
        *tdlist1 = *tdlist2;
    } else
    {
           self.jects[tdlist1->last].next = tdlist2->fist;
           self.jects[tdlist2->fist].prev = tdlist1->last;
           tdlist1->last=tdlist2->last;

           tdlist1->n += tdlist2->n;
    }

    init( tdlist2 );

        return;
}

/*
#------------------------------------------------------
# swapNodes
#------------------------------------------------------*/
void swapNodes (dlist *tdlist, int tnode1, int tnode2) /*HEADER*/
{

    if (tnode1 == tdlist->fist)
    {
         tdlist->fist=tnode2;
    } else if (tnode2 == tdlist->fist)
    {
         tdlist->fist=tnode1;
    }

    if (tnode1 == tdlist->last)
    {
         tdlist->last=tnode2;
    } else if (tnode2 == tdlist->last)
    {
         tdlist->last=tnode1;
    }

        int next =self.jects[tnode1].next;
        int prev =self.jects[tnode1].prev;
        self.jects[tnode1].next=self.jects[tnode2].next;
        self.jects[tnode1].prev=self.jects[tnode2].prev;
        self.jects[tnode2].next=next;
        self.jects[tnode2].prev=prev;

}
/*
#------------------------------------------------------*/