libpcp/pcp_poly_spi.cc

   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 #include "config.h"
  29 #include "pcp_poly_spi.h"
  30 #include "pcp_dynamic_array.h"
  31 #include "pcp_string_buffer.h"
  32
  33 class PcpPolySpiDummy : public PcpPolySpi
  34 {
  35 public:
  36   class DummyCoefficient : public Coefficient
  37   {
  38   public:
  39     int value;
  40   };
  41
  42   class DummyLinearExpr : public LinearExpr
  43   {
  44   public:
  45     PcpArray<int>* array;
  46   };
  47
  48   class DummyConstraint : public Constraint
  49   {
  50   public:
  51     int kind;
  52     LinearExpr* linearExpr;
  53   };
  54
  55   class DummyConstraintSystem : public ConstraintSystem
  56   {
  57
  58   };
  59
  60   class DummyPolyhedron : public Polyhedron
  61   {
  62
  63   };
  64
  65   class DummyPointsetPowerset : public PointsetPowerset
  66   {
  67   };
  68
  69     // Coefficient primitives
  70 int coefficientGetValue(Coefficient* coeff)
  71 {
  72   return ((DummyCoefficient*)coeff)->value;
  73 }
  74
  75 PcpPolySpi::Coefficient* coefficientCreate(int value)
  76 {
  77   DummyCoefficient* coeff = new DummyCoefficient();
  78   coeff->value = value;
  79   return coeff;
  80 }
  81
  82 const char*
  83 coefficientToString(Coefficient* coeff)
  84 {
  85   PcpStringBuffer buffer;
  86   buffer.appendInt(((DummyCoefficient*)coeff)->value);
  87   return buffer.toString();
  88 }
  89
  90 void coefficientDestroy(Coefficient* coeff)
  91 {
  92   delete (DummyCoefficient*)coeff;
  93 }
  94
  95   // Linear Expr Primitives
  96 PcpPolySpi::LinearExpr* linearExprCopy(LinearExpr* linearExpr)
  97 {
  98   return NULL;
  99 }
 100
 101 void linearExprAddToCoefficient(LinearExpr* linearExpr, int dimension, Coefficient* value)
 102 {
 103   PcpArray<int>* array = ((DummyLinearExpr*)linearExpr)->array;
 104   array->set(dimension, array->get(dimension) + ((DummyCoefficient*)value)->value);
 105 }
 106
 107 void linearExprAddToInhomogenous(LinearExpr* linearExpr, Coefficient* value)
 108 {
 109   PcpArray<int>* array = ((DummyLinearExpr*)linearExpr)->array;
 110   int index = array->getSize()-1;
 111   linearExprAddToCoefficient(linearExpr, index, value);
 112 }
 113
 114 void linearExprSetCoefficient(LinearExpr* linearExpr, int dimension, Coefficient* value)
 115 {
 116   PcpArray<int>* array = ((DummyLinearExpr*)linearExpr)->array;
 117   array->set(dimension, ((DummyCoefficient*)value)->value);
 118 }
 119
 120 int linearExprGetNumDimensions(LinearExpr* linearExpr)
 121 {
 122   return ((DummyLinearExpr*)linearExpr)->array->getSize();
 123 }
 124
 125 void linearExprSubtract(LinearExpr* linearExpr, LinearExpr* subtract)
 126 {
 127
 128 }
 129
 130 const char*
 131 linearExprToString(LinearExpr* linearExpr)
 132 {
 133   PcpArray<int>* array = ((DummyLinearExpr*) linearExpr)->array;
 134   PcpStringBuffer buffer;
 135   for(int i = 0; i < array->getSize(); i++)
 136     {
 137       if(i > 0)
 138         buffer.append(" ");
 139       buffer.appendInt(array->get(i));
 140     }
 141   return buffer.toString();
 142 }
 143
 144 PcpPolySpi::LinearExpr* linearExprCreate()
 145 {
 146   return NULL;
 147 }
 148
 149 PcpPolySpi::LinearExpr* linearExprCreate(int numDimensions)
 150 {
 151   DummyLinearExpr* linearExpr = new DummyLinearExpr();
 152   linearExpr->array = new PcpArray<int>(numDimensions);
 153   return linearExpr;
 154 }
 155
 156 void linearExprDestroy(LinearExpr* linearExpr)
 157 {
 158   delete ((DummyLinearExpr*)linearExpr)->array;
 159 }
 160
 161   // Constraint primitives
 162 PcpPolySpi::Constraint* constraintCreateEqualZero(LinearExpr* linearExpr)
 163 {
 164   DummyConstraint* constraint = new DummyConstraint();
 165   constraint->kind = 0;
 166   constraint->linearExpr = linearExpr;
 167   return constraint;
 168 }
 169
 170 PcpPolySpi::Constraint* constraintCreateGreaterEqualZero(LinearExpr* linearExpr)
 171 {
 172   DummyConstraint* constraint = new DummyConstraint();
 173   constraint->kind = 1;
 174   constraint->linearExpr = linearExpr;
 175   return constraint;
 176 }
 177
 178 void constraintDestroy(Constraint* constraint)
 179 {
 180   delete ((DummyConstraint*)constraint)->linearExpr;
 181 }
 182
 183 const char*
 184 constraintToString(Constraint* constraint)
 185 {
 186   DummyConstraint* dconstraint = (DummyConstraint*) constraint;
 187   PcpStringBuffer buffer;
 188   const char* linearExprString = linearExprToString(dconstraint->linearExpr);
 189   buffer.append(linearExprString);
 190   buffer.append(dconstraint->kind == 0 ? " == 0" : " >= 0");
 191   return buffer.toString();
 192 }
 193
 194
 195   // Polyhedron primitives
 196 PcpPolySpi::ConstraintSystem* polyhedronGetConstraintSystem(Polyhedron* polyhedron)
 197 {
 198   return NULL;
 199 }
 200
 201 void polyhedronAddConstraint(Polyhedron* polyhedron, Constraint* constraint)
 202 {
 203 }
 204
 205 void polyhedronAddConstraints(Polyhedron* polyhedron, ConstraintSystem* constraintSystem)
 206 {
 207 }
 208
 209 void polyhedronRemap(Polyhedron* polyhedron, PcpArray<int>* map)
 210 {
 211 }
 212
 213 PcpPolySpi::Polyhedron* polyhedronCopy(Polyhedron* polyhedron)
 214 {
 215   return NULL;
 216 }
 217
 218 PcpPolySpi::Polyhedron* polyhedronCreate(int numDimensions)
 219 {
 220   return NULL;
 221 }
 222
 223 void polyhedronDestroy(Polyhedron* polyhedron)
 224 {
 225 }
 226
 227 void pointsetPowersetDestroy(PointsetPowerset* poinsetPowerset)
 228 {
 229 }
 230
 231
 232 PcpPolySpi::PointsetPowerset* pointsetPowersetCreate(Polyhedron* polyhedron)
 233 {
 234     return NULL;
 235 }
 236
 237
 238 };
 239
 240 #include "pcp_poly_spi_c.h"
 241 PcpPolySpi* PcpPolySpi::create()
 242 {
 243   //return new PcpPolySpiDummy();
 244   return createPPLPolySpi();
 245 }
 246
 247