Power-Programmierung/CD2.mdf/c/library/os2/cfgedit/source/strdll.cc

C/C++ Source or Header | 1992-07-18 | 6.5 KB | 677 lines

// This may look like C code, but it is really -*- C++ -*-

/*

Copyright (C) 1988 Free Software Foundation

    written by Doug Lea ([e-mail])



This file is part of the GNU C++ Library.  This library is free

software; you can redistribute it and/or modify it under the terms of

the GNU Library General Public License as published by the Free

Software Foundation; either version 2 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 Library General Public License for more details.

You should have received a copy of the GNU Library General Public

License along with this library; if not, write to the Free Software

Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.

*/



#ifdef __GNUG__

#pragma implementation

#endif

#include <values.h>

#include <stream.h>

#include <builtin.h>

#include "StrDLL.h"



// error handling







void StrDLList::error(const char* msg)

{

  (*lib_error_handler)("DLList", msg);

}



int StrDLList::length()

{

  int l = 0;

  StrDLListNode* t = h;

  if (t != 0) do { ++l; t = t->fd; } while (t != h);

  return l;

}



StrDLList::StrDLList(StrDLList& a)

{

  if (a.h == 0)

    h = 0;

  else

  {

    StrDLListNode* p = a.h;

    StrDLListNode* t = new StrDLListNode(p->hd);

    h = t;

    p = p->fd;

    while (p != a.h)

    {

      StrDLListNode* n = new StrDLListNode(p->hd);

      t->fd = n;

      n->bk = t;

      t = n;

        p = p->fd;

    }

    t->fd = h;

    h->bk = t;

    return;

  }

}



StrDLList& StrDLList::operator = (StrDLList& a)

{

  if (h != a.h)

  {

    clear();

    if (a.h != 0)

    {

      StrDLListNode* p = a.h;

      StrDLListNode* t = new StrDLListNode(p->hd);

      h = t;

      p = p->fd;

      while (p != a.h)

      {

        StrDLListNode* n = new StrDLListNode(p->hd);

        t->fd = n;

        n->bk = t;

        t = n;

        p = p->fd;

      }

      t->fd = h;

      h->bk = t;

    }

  }

  return *this;

}



void StrDLList::clear()

{

  if (h == 0)

    return;



  StrDLListNode* p = h->fd;

  h->fd = 0;

  h = 0;



  while (p != 0)

  {

    StrDLListNode* nxt = p->fd;

    delete(p);

    p = nxt;

  }

}





Pix StrDLList::prepend(Str& item)

{

  StrDLListNode* t = new StrDLListNode(item);

  if (h == 0)

    t->fd = t->bk = h = t;

  else

  {

    t->fd = h;

    t->bk = h->bk;

    h->bk->fd = t;

    h->bk = t;

    h = t;

  }

  return Pix(t);

}



Pix StrDLList::append(Str& item)

{

  StrDLListNode* t = new StrDLListNode(item);

  if (h == 0)

    t->fd = t->bk = h = t;

  else

  {

    t->bk = h->bk;

    t->bk->fd = t;

    t->fd = h;

    h->bk = t;

  }

  return Pix(t);

}



Pix StrDLList::ins_after(Pix p, Str& item)

{

  if (p == 0) return prepend(item);

  StrDLListNode* u = (StrDLListNode*) p;

  StrDLListNode* t = new StrDLListNode(item, u, u->fd);

  u->fd->bk = t;

  u->fd = t;

  return Pix(t);

}



Pix StrDLList::ins_before(Pix p, Str& item)

{

  if (p == 0) error("null Pix");

  StrDLListNode* u = (StrDLListNode*) p;

  StrDLListNode* t = new StrDLListNode(item, u->bk, u);

  u->bk->fd = t;

  u->bk = t;

  if (u == h) h = t;

  return Pix(t);

}



void StrDLList::join(StrDLList& b)

{

  StrDLListNode* t = b.h;

  b.h = 0;

  if (h == 0)

    h = t;

  else if (t != 0)

  {

    StrDLListNode* l = t->bk;

    h->bk->fd = t;

    t->bk = h->bk;

    h->bk = l;

    l->fd = h;

  }

}



int StrDLList::owns(Pix p)

{

  StrDLListNode* t = h;

  if (t != 0 && p != 0)

  {

    do

    {

      if (Pix(t) == p) return 1;

      t = t->fd;

    } while (t != h);

  }

  return 0;

}



void StrDLList::del(Pix& p, int dir)

{

  if (p == 0) error("null Pix");

  StrDLListNode* t = (StrDLListNode*) p;

  if (t->fd == t)

  {

    h = 0;

    p = 0;

  }

  else

  {

    if (dir < 0)

    {

      if (t == h)

        p = 0;

      else

        p = Pix(t->bk);

    }

    else

    {

      if (t == h->bk)

        p = 0;

      else

        p = Pix(t->fd);

    }

    t->bk->fd = t->fd;

    t->fd->bk = t->bk;

    if (t == h) h = t->fd;

  }

  delete t;

}



void StrDLList::del_after(Pix& p)

{

  if (p == 0)

  {

    del_front();

    return;

  }



  StrDLListNode* b = (StrDLListNode*) p;

  StrDLListNode* t = b->fd;



  if (b == t)

  {

    h = 0;

    p = 0;

  }

  else

  {

    t->bk->fd = t->fd;

    t->fd->bk = t->bk;

    if (t == h) h = t->fd;

  }

  delete t;

}



Str StrDLList::remove_front()

{

  if (h == 0)

    error("remove_front of empty list");

  StrDLListNode* t = h;

  Str res = t->hd;

  if (h->fd == h)

    h = 0;

  else

  {

    h->fd->bk = h->bk;

    h->bk->fd = h->fd;

    h = h->fd;

  }

  delete t;

  return res;

}





void StrDLList::del_front()

{

  if (h == 0)

    error("del_front of empty list");

  StrDLListNode* t = h;

  if (h->fd == h)

    h = 0;

  else

  {

    h->fd->bk = h->bk;

    h->bk->fd = h->fd;

    h = h->fd;

  }

  delete t;

}



Str StrDLList::remove_rear()

{

  if (h == 0)

    error("remove_rear of empty list");

  StrDLListNode* t = h->bk;

  Str res = t->hd;

  if (h->fd == h)

    h = 0;

  else

  {

    t->fd->bk = t->bk;

    t->bk->fd = t->fd;

  }

  delete t;

  return res;

}





void StrDLList::del_rear()

{

  if (h == 0)

    error("del_rear of empty list");

  StrDLListNode* t = h->bk;

  if (h->fd == h)

    h = 0;

  else

  {

    t->fd->bk = t->bk;

    t->bk->fd = t->fd;

  }

  delete t;

}





int StrDLList::OK()

{

  int v = 1;

  if (h != 0)

  {

    StrDLListNode* t = h;

    long count = MAXLONG;      // Lots of chances to find h!

    do

    {

      count--;

      v &= t->bk->fd == t;

      v &= t->fd->bk == t;

      t = t->fd;

    } while (v && count > 0 && t != h);

    v &= count > 0;

  }

  if (!v) error("invariant failure");

  return v;

}