## modules/up/src/gnug++/NormalTermPtr.DLList.cc

/* [<][>][^][v][top][bottom][index][help] */

## FUNCTIONS

This source file includes following functions.

1. error
2. length
3. NormalTermPtrDLList
4. clear
5. prepend
6. append
7. ins_after
8. ins_before
9. join
10. owns
11. del
12. del_after
13. remove_front
14. del_front
15. remove_rear
16. del_rear
17. OK

       1 // This may look like C code, but it is really -*- C++ -*-
       2 // WARNING: This file is obsolete.  Use ../DLList.cc, if you can.
       3 /*
       4 Copyright (C) 1988 Free Software Foundation
       5     written by Doug Lea (dl@rocky.oswego.edu)
       6
       7 This file is part of the GNU C++ Library.  This library is free
       8 software; you can redistribute it and/or modify it under the terms of
       9 the GNU Library General Public License as published by the Free
      10 Software Foundation; either version 2 of the License, or (at your
      11 option) any later version.  This library is distributed in the hope
      12 that it will be useful, but WITHOUT ANY WARRANTY; without even the
      13 implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
      14 PURPOSE.  See the GNU Library General Public License for more details.
      15 You should have received a copy of the GNU Library General Public
      16 License along with this library; if not, write to the Free Software
      17 Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
      18 */
      19
      20 #ifdef __GNUG__
      21 #pragma implementation
      22 #endif
      23
      24 #include "config.h"
      25 #include <cstring>
      26 #include <climits>
      27 #include "NormalTermPtr.DLList.h"
      28 #include <builtin.h>
      29
      30 // error handling
      31
      32
      33
      34 void NormalTermPtrDLList::error(const char* msg)
         /* [<][>][^][v][top][bottom][index][help] */
      35 {
      36   (*lib_error_handler)("DLList", msg);
      37 }
      38
      39 int NormalTermPtrDLList::length()
         /* [<][>][^][v][top][bottom][index][help] */
      40 {
      41   int l = 0;
      42   NormalTermPtrDLListNode* t = h;
      43   if (t != 0) do { ++l; t = t->fd; } while (t != h);
      44   return l;
      45 }
      46
      47 NormalTermPtrDLList::NormalTermPtrDLList(const NormalTermPtrDLList& a)
         /* [<][>][^][v][top][bottom][index][help] */
      48 {
      49   if (a.h == 0)
      50     h = 0;
      51   else
      52   {
      53     NormalTermPtrDLListNode* p = a.h;
      54     NormalTermPtrDLListNode* t = new NormalTermPtrDLListNode(p->hd);
      55     h = t;
      56     p = p->fd;
      57     while (p != a.h)
      58     {
      59       NormalTermPtrDLListNode* n = new NormalTermPtrDLListNode(p->hd);
      60       t->fd = n;
      61       n->bk = t;
      62       t = n;
      63         p = p->fd;
      64     }
      65     t->fd = h;
      66     h->bk = t;
      67     return;
      68   }
      69 }
      70
      71 NormalTermPtrDLList& NormalTermPtrDLList::operator = (const NormalTermPtrDLList& a)
      72 {
      73   if (h != a.h)
      74   {
      75     clear();
      76     if (a.h != 0)
      77     {
      78       NormalTermPtrDLListNode* p = a.h;
      79       NormalTermPtrDLListNode* t = new NormalTermPtrDLListNode(p->hd);
      80       h = t;
      81       p = p->fd;
      82       while (p != a.h)
      83       {
      84         NormalTermPtrDLListNode* n = new NormalTermPtrDLListNode(p->hd);
      85         t->fd = n;
      86         n->bk = t;
      87         t = n;
      88         p = p->fd;
      89       }
      90       t->fd = h;
      91       h->bk = t;
      92     }
      93   }
      94   return *this;
      95 }
      96
      97 void NormalTermPtrDLList::clear()
         /* [<][>][^][v][top][bottom][index][help] */
      98 {
      99   if (h == 0)
     100     return;
     101
     102   NormalTermPtrDLListNode* p = h->fd;
     103   h->fd = 0;
     104   h = 0;
     105
     106   while (p != 0)
     107   {
     108     NormalTermPtrDLListNode* nxt = p->fd;
     109     // cengiz
     110     delete p->hd;
     111     delete(p);
     112     p = nxt;
     113   }
     114 }
     115
     116
     117 Pix NormalTermPtrDLList::prepend(NormalTermPtr  item)
         /* [<][>][^][v][top][bottom][index][help] */
     118 {
     119   NormalTermPtrDLListNode* t = new NormalTermPtrDLListNode(item);
     120   if (h == 0)
     121     t->fd = t->bk = h = t;
     122   else
     123   {
     124     t->fd = h;
     125     t->bk = h->bk;
     126     h->bk->fd = t;
     127     h->bk = t;
     128     h = t;
     129   }
     130   return Pix(t);
     131 }
     132
     133 Pix NormalTermPtrDLList::append(NormalTermPtr  item)
         /* [<][>][^][v][top][bottom][index][help] */
     134 {
     135   NormalTermPtrDLListNode* t = new NormalTermPtrDLListNode(item);
     136   if (h == 0)
     137     t->fd = t->bk = h = t;
     138   else
     139   {
     140     t->bk = h->bk;
     141     t->bk->fd = t;
     142     t->fd = h;
     143     h->bk = t;
     144   }
     145   return Pix(t);
     146 }
     147
     148 Pix NormalTermPtrDLList::ins_after(Pix p, NormalTermPtr  item)
         /* [<][>][^][v][top][bottom][index][help] */
     149 {
     150   if (p == 0) return prepend(item);
     151   NormalTermPtrDLListNode* u = (NormalTermPtrDLListNode*) p;
     152   NormalTermPtrDLListNode* t = new NormalTermPtrDLListNode(item, u, u->fd);
     153   u->fd->bk = t;
     154   u->fd = t;
     155   return Pix(t);
     156 }
     157
     158 Pix NormalTermPtrDLList::ins_before(Pix p, NormalTermPtr  item)
         /* [<][>][^][v][top][bottom][index][help] */
     159 {
     160   if (p == 0) error("null Pix");
     161   NormalTermPtrDLListNode* u = (NormalTermPtrDLListNode*) p;
     162   NormalTermPtrDLListNode* t = new NormalTermPtrDLListNode(item, u->bk, u);
     163   u->bk->fd = t;
     164   u->bk = t;
     165   if (u == h) h = t;
     166   return Pix(t);
     167 }
     168
     169 void NormalTermPtrDLList::join(NormalTermPtrDLList& b)
         /* [<][>][^][v][top][bottom][index][help] */
     170 {
     171   NormalTermPtrDLListNode* t = b.h;
     172   b.h = 0;
     173   if (h == 0)
     174     h = t;
     175   else if (t != 0)
     176   {
     177     NormalTermPtrDLListNode* l = t->bk;
     178     h->bk->fd = t;
     179     t->bk = h->bk;
     180     h->bk = l;
     181     l->fd = h;
     182   }
     183 }
     184
     185 int NormalTermPtrDLList::owns(Pix p)
         /* [<][>][^][v][top][bottom][index][help] */
     186 {
     187   NormalTermPtrDLListNode* t = h;
     188   if (t != 0 && p != 0)
     189   {
     190     do
     191     {
     192       if (Pix(t) == p) return 1;
     193       t = t->fd;
     194     } while (t != h);
     195   }
     196   return 0;
     197 }
     198
     199 void NormalTermPtrDLList::del(Pix& p, int dir)
         /* [<][>][^][v][top][bottom][index][help] */
     200 {
     201   if (p == 0) error("null Pix");
     202   NormalTermPtrDLListNode* t = (NormalTermPtrDLListNode*) p;
     203   if (t->fd == t)
     204   {
     205     h = 0;
     206     p = 0;
     207   }
     208   else
     209   {
     210     if (dir < 0)
     211     {
     212       if (t == h)
     213         p = 0;
     214       else
     215         p = Pix(t->bk);
     216     }
     217     else
     218     {
     219       if (t == h->bk)
     220         p = 0;
     221       else
     222         p = Pix(t->fd);
     223     }
     224     t->bk->fd = t->fd;
     225     t->fd->bk = t->bk;
     226     if (t == h) h = t->fd;
     227   }
     228   delete t;
     229 }
     230
     231 void NormalTermPtrDLList::del_after(Pix& p)
         /* [<][>][^][v][top][bottom][index][help] */
     232 {
     233   if (p == 0)
     234   {
     235     del_front();
     236     return;
     237   }
     238
     239   NormalTermPtrDLListNode* b = (NormalTermPtrDLListNode*) p;
     240   NormalTermPtrDLListNode* t = b->fd;
     241
     242   if (b == t)
     243   {
     244     h = 0;
     245     p = 0;
     246   }
     247   else
     248   {
     249     t->bk->fd = t->fd;
     250     t->fd->bk = t->bk;
     251     if (t == h) h = t->fd;
     252   }
     253   delete t;
     254 }
     255
     256 NormalTermPtr NormalTermPtrDLList::remove_front()
         /* [<][>][^][v][top][bottom][index][help] */
     257 {
     258   if (h == 0)
     259     error("remove_front of empty list");
     260   NormalTermPtrDLListNode* t = h;
     261   NormalTermPtr res = t->hd;
     262   if (h->fd == h)
     263     h = 0;
     264   else
     265   {
     266     h->fd->bk = h->bk;
     267     h->bk->fd = h->fd;
     268     h = h->fd;
     269   }
     270   delete t;
     271   return res;
     272 }
     273
     274
     275 void NormalTermPtrDLList::del_front()
         /* [<][>][^][v][top][bottom][index][help] */
     276 {
     277   if (h == 0)
     278     error("del_front of empty list");
     279   NormalTermPtrDLListNode* t = h;
     280   if (h->fd == h)
     281     h = 0;
     282   else
     283   {
     284     h->fd->bk = h->bk;
     285     h->bk->fd = h->fd;
     286     h = h->fd;
     287   }
     288   delete t;
     289 }
     290
     291 NormalTermPtr NormalTermPtrDLList::remove_rear()
         /* [<][>][^][v][top][bottom][index][help] */
     292 {
     293   if (h == 0)
     294     error("remove_rear of empty list");
     295   NormalTermPtrDLListNode* t = h->bk;
     296   NormalTermPtr res = t->hd;
     297   if (h->fd == h)
     298     h = 0;
     299   else
     300   {
     301     t->fd->bk = t->bk;
     302     t->bk->fd = t->fd;
     303   }
     304   delete t;
     305   return res;
     306 }
     307
     308
     309 void NormalTermPtrDLList::del_rear()
         /* [<][>][^][v][top][bottom][index][help] */
     310 {
     311   if (h == 0)
     312     error("del_rear of empty list");
     313   NormalTermPtrDLListNode* t = h->bk;
     314   if (h->fd == h)
     315     h = 0;
     316   else
     317   {
     318     t->fd->bk = t->bk;
     319     t->bk->fd = t->fd;
     320   }
     321   delete t;
     322 }
     323
     324
     325 int NormalTermPtrDLList::OK()
         /* [<][>][^][v][top][bottom][index][help] */
     326 {
     327   int v = 1;
     328   if (h != 0)
     329   {
     330     NormalTermPtrDLListNode* t = h;
     331     long count = LONG_MAX;      // Lots of chances to find h!
     332     do
     333     {
     334       count--;
     335       v &= t->bk->fd == t;
     336       v &= t->fd->bk == t;
     337       t = t->fd;
     338     } while (v && count > 0 && t != h);
     339     v &= count > 0;
     340   }
     341   if (!v) error("invariant failure");
     342   return v;
     343 }

/* [<][>][^][v][top][bottom][index][help] */