libpcp/pcp_stack.h

   1 // Copyright (C) 2009 Free Software Foundation, Inc.
   2 // Contributed by Jan Sjodin <jan.sjodin@amd.com>.
   3
   4 // This file is part of the Polyhedral Compilation Package Library (libpcp).
   5
   6 // Libpcp is free software; you can redistribute it and/or modify it
   7 // under the terms of the GNU Lesser General Public License as published by
   8 // the Free Software Foundation; either version 2.1 of the License, or
   9 // (at your option) any later version.
  10
  11 // Libpcp is distributed in the hope that it will be useful, but WITHOUT ANY
  12 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  13 // FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
  14 // more details.
  15
  16 // You should have received a copy of the GNU Lesser General Public License
  17 // along with libpcp; see the file COPYING.LIB.  If not, write to the
  18 // Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
  19 // MA 02110-1301, USA.
  20
  21 // As a special exception, if you link this library with other files, some
  22 // of which are compiled with GCC, to produce an executable, this library
  23 // does not by itself cause the resulting executable to be covered by the
  24 // GNU General Public License.  This exception does not however invalidate
  25 // any other reasons why the executable file might be covered by the GNU
  26 // General Public License.
  27
  28 #ifndef _PCP_STACK_
  29 #define _PCP_STACK_
  30 #include "pcp_alloc.h"
  31
  32 template <typename Value> class PcpStack
  33 {
  34  public:
  35   virtual void push(Value v) = 0;
  36   virtual Value pop() = 0;
  37   virtual Value peek(int index) = 0;
  38   virtual int getSize() = 0;
  39 };
  40
  41
  42 // Simple implementation of a stack using a list.
  43 // Assumptions: operators '=' available
  44
  45 template <typename Value> class PcpListStack
  46 : public PcpStack<Value>
  47 {
  48  protected:
  49   class Entry
  50   {
  51     Value first;
  52     Entry* rest;
  53
  54   public:
  55
  56     void setFirst(Value value)
  57     {
  58       this->first = value;
  59     }
  60
  61     Value getFirst()
  62     {
  63       return this->first;
  64     }
  65
  66     void setRest(Entry* left)
  67     {
  68       this->rest = left;
  69     }
  70
  71     Entry* getRest()
  72     {
  73       return this->rest;
  74     }
  75
  76
  77     Entry(Value value, Entry* rest)
  78     {
  79       setFirst(value);
  80       setRest(rest);
  81     }
  82   };
  83
  84   Entry* stack;
  85
  86   void setStack(Entry* stack)
  87   {
  88     this->stack = stack;
  89   }
  90
  91   Entry* getStack()
  92   {
  93     return this->stack;
  94   }
  95
  96
  97  public:
  98   virtual void push(Value value)
  99   {
 100     this->setStack(new Entry(value, this->getStack()));
 101   }
 102
 103   virtual Value pop()
 104   {
 105     Entry* oldEntry = this->getStack();
 106     Value result = oldEntry->getFirst();
 107     setStack(oldEntry->getRest());
 108     delete oldEntry;
 109     return result;
 110   }
 111
 112   virtual Value peek(int depth)
 113   {
 114     Entry* current = this->getStack();
 115     while(current != NULL)
 116       {
 117         if(depth <= 0)
 118           return current->getFirst();
 119         else
 120           {
 121             depth = depth - 1;
 122             current = current->getRest();
 123           }
 124       }
 125     return 0;
 126   }
 127
 128   virtual int getSize()
 129   {
 130     int size = 0;
 131     Entry* current = this->getStack();
 132     while(current != NULL)
 133       {
 134         size = size + 1;
 135         current = current->getRest();
 136       }
 137     return size;
 138   }
 139
 140   PcpListStack()
 141   {
 142     setStack(NULL);
 143   }
 144 };
 145
 146 #endif // _PCP_STACK_