Subversion Repositories f9daq

//****************************************************************************
// Copyright (C) 2000-2004  ARW Elektronik Germany
//
//
// 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., 675 Mass Ave, Cambridge, MA 02139, USA.
//
// This product is not authorized for use as critical component in
// life support systems without the express written approval of
// ARW Elektronik Germany.
//  
// Please announce changes and hints to ARW Elektronik
//
// Maintainer(s): Klaus Hitschler (klaus.hitschler@gmx.de)
//
//****************************************************************************

//****************************************************************************
//
// list.c - provide list management functions to the driver,
//          like C++ templates.
//
// $Log: list.c,v $
// Revision 1.6  2004/08/12 19:59:19  klaus
// conversion to kernel-version 2.6, released version 6.0
//
// Revision 1.5  2003/05/11 11:12:03  klaus
// matched to kernel 2.4 PCI handling, debug messages improved
//
// Revision 1.4  2001/11/20 20:12:50  klaus
// included new header and CVS log
//
//
// created by D. Muehlenberg and H.J.Mathes             1999
// added getNextNode and getPrevNode             AR     18.02.2000
// MODVERSIONS included                          AR     24.04.2000
//
//****************************************************************************

#include "common.h"  /* must be the first include */

#include "list.h"

Node *newNode(void)
{
  Node *mynode;
     
  mynode = (Node *)kmalloc(sizeof(Node), GFP_ATOMIC);
  if (!mynode) return NULL;
  mynode->pred = NULL;
  mynode->succ = NULL;
  mynode->data = NULL;
   
  return mynode;
}

Node *addNode(Node *pos, void *insert, enum NodePosition p)
{
  Node *mynode;
  mynode = (Node *)kmalloc(sizeof(Node), GFP_ATOMIC);
  if (!mynode) return NULL;
  if (p == CurrentLeft) {
    mynode->pred = pos;
    mynode->succ = pos->succ;
    pos->succ = mynode;
  } else {
    mynode->pred = pos->pred;
    pos->pred = mynode;
    mynode->succ = pos;
  }
  mynode->data = insert;
  return mynode;
}

Node *delNodeAndData(Node *pos)
{
  Node *tail = NULL;
  if (!pos->pred) return NULL;
  /* can't delete head */
  if (!pos->succ) {
    tail = pos->pred;
    tail->succ = NULL;
  } else {
    pos->pred->succ = pos->succ;
    pos->succ->pred = pos->pred;
  }
  kfree_s(pos->data, sizeof(*pos->data)); // FREE(pos->data);
  kfree_s(pos, sizeof(*pos));             // FREE(pos);
  return tail;
}

Node *delNode(Node *pos)
{
  Node *tail = NULL;
  if (!pos) return NULL;
  if (!pos->pred) return NULL;
  /* can't delete head */
  if (!pos->succ) {
    tail = pos->pred;
    tail->succ = NULL;
  } else {
    pos->pred->succ = pos->succ;
    pos->succ->pred = pos->pred;
  }
  kfree_s(pos, sizeof(*pos));             // FREE(pos);
  return tail;
}
/* ------------------------------ */

List *newList(void)
{
  List *ret = (List *)kmalloc(sizeof(List), GFP_ATOMIC);
  if (!ret) return NULL;
  ret->head = ret->tail = newNode();
  if (!ret->head) {
    kfree_s(ret, sizeof(*ret));           // FREE(ret);
    return NULL;
  }
  ret->nodes = 0;
  return ret;
}

void deleteList(List *l, void (*delete)(void *))
{
  if (l) {
    resetList(l,delete);
    kfree_s(l->head, sizeof(*l->head));   // FREE(l->head);
    kfree_s(l, sizeof(*l));               // FREE(l);
  }
}

Node *addTail(List *list, void *insert)
{
  Node *tail;
  if (!list) return NULL;
  tail = addNode(list->tail,insert,CurrentLeft);
  if (!tail)
  {
    #ifdef __DEBUG__
    printk("addTail(): addNode failed!\n");
    #endif
    return NULL;
  }
  list->tail = tail;
  list->nodes++;
  return tail;
}

Node *addHead(List *list, void *insert)
{
  Node *node;
  if (!list) return NULL;
  if (!list->head->succ) {
    return addTail(list,insert);
  } else {
    node = addNode(list->head,insert,CurrentRight);
  }
  if (node) list->nodes++;
  return node;
}

Node *searchList(List *list, void *c, int (*comp)(void *, void *))
{
  register Node *n;

  if (!list) return NULL;
  n = list->head->succ;
  while (n) {
    if (!comp(c,n->data)) {
      return n;
    }
    n = n->succ;
  }  
  return NULL;
}

void delNodeAndDataInList(List *l, Node *pos)
{
  Node *n;
  if (!l) return;
  if ((n = delNodeAndData(pos))) l->tail = n;
  l->nodes--;
}

void delNodeInList(List *l, Node *pos)
{
  Node *n;
  if (!l) return;
  if ((n = delNode(pos))) l->tail = n;
  l->nodes--;
}

int emptyList(List *l)
{
  if (!l) return 1;
  return l->head->succ ? 0 : 1;
}

void delTailAndData(List *l)
{
  Node *t;
  if (!l) return;
  t = l->tail;
  if (emptyList(l)) return;
  l->tail = l->tail->pred;
  l->tail->succ = NULL;
  kfree_s(t->data, sizeof(*t->data));     // FREE(t->data);
  kfree_s(t, sizeof(*t));                 // FREE(t);
  l->nodes--;
}

void delTail(List *l)
{
  Node *t;
  if (!l) return;
  t = l->tail;
  if (emptyList(l)) return;
  l->tail = l->tail->pred;
  l->tail->succ = NULL;
  kfree_s(t, sizeof(*t));                 // FREE(t);
  l->nodes--;
}

void resetList(List *l, void (*delete)(void *))
{
  register Node *n;
  register void *data;

  if (!l) return;
  n = l->tail;
  while (n->pred) {
    data = n->data;
    if (delete) {
      delete(data);
    }
    else
    {
      kfree_s(data, sizeof(*data));        // FREE(data);
    }
#if 0
    n = delNode(n);
#endif
    delNode(n);
    n = n->pred;
  }
  l->tail = l->head;
  l->nodes = 0;
}

Node *getFirstNode(List *l)
{
  if (!l) return NULL;
  return l->head->succ;
}

Node *getNextNode(Node *n)
{
  if (n)
    return n->succ;
  else
    return NULL;
}

Node *getPrevNode(Node *n)
{
  if (n)
    return n->pred;
  else
    return NULL;
}

void *getContent(Node *n)
{
  return n->data;
}

Node *getLastNode(List *l)
{
  if (!l) return NULL;
  return l->tail;
}

void delFirstNode(List *l)
{
  if (!l) return;
  delNodeInList(l,getFirstNode(l));
}

void delFirstNodeAndData(List *l)
{
  if (!l) return;
  delNodeAndDataInList(l,getFirstNode(l));
}

void delLastNode(List *l)
{
  if (!l) return;
  delNodeInList(l,getLastNode(l));
}

void delLastNodeAndData(List *l)
{
  if (!l) return;
  delNodeAndDataInList(l,getLastNode(l));
}

#ifndef USE_MACROS
int getNumOfNodesInList(List *l)
{
  if (!l) return 0;
  return l->nodes;
}
#endif

void printList(List *l, char *(*StructToString)(void *))
{
  register Node *n = l->head;
  int i=1;
  if (!l) return;
  if (!n->succ)
  {
    printk("List empty!\n");
    return;
  }
  while (n->succ)
  {
    printk("Node %d: %s",i++,StructToString(n->succ->data));
    n = n->succ;
  }
  printk("\n");
}

#undef printk