AbstractInterface.cpp

   1 #include "AbstractInterface.h"
   2 #include "BlockParameterPort.h"
   3 #include "AbstractBlock.h"
   4 #include "Parameters.h"
   5
   6 AbstractInterface::AbstractInterface(AbstractBlock* _owner) {
   7
   8   owner = _owner;
   9   name = "";
  10   width = "1";
  11   direction = Input;
  12   purpose = Data;
  13   type = Boolean;
  14   endianess = LittleEndian;
  15   associatedIface = NULL;
  16
  17 }
  18
  19 AbstractInterface::AbstractInterface(AbstractBlock* _owner, const QString& _name, int _direction, int _purpose, const QString& _type, const QString& _width, int _endianess) {
  20
  21   owner = _owner;
  22   name = Parameters::normalizeName(_name);
  23   width = _width;
  24   direction = _direction;
  25   purpose = _purpose;
  26   type = typeFromString(_type);
  27   endianess = _endianess;
  28   associatedIface = NULL;
  29 }
  30
  31 AbstractInterface::AbstractInterface(AbstractInterface* other) {
  32   owner = NULL;
  33   name = Parameters::normalizeName(other->name);
  34   type = other->type;
  35   width = other->width;
  36   direction = other->direction;
  37   purpose = other->purpose;
  38   endianess = LittleEndian;
  39   associatedIface = NULL;
  40 }
  41
  42 void AbstractInterface::setName(const QString& _name) {
  43   name = Parameters::normalizeName(_name);
  44 }
  45
  46 AbstractInterface::~AbstractInterface() {
  47
  48 }
  49
  50 bool AbstractInterface::isReferenceInterface() {
  51   return false;
  52 }
  53
  54 bool AbstractInterface::isFunctionalInterface() {
  55   return false;
  56 }
  57
  58 bool AbstractInterface::isGroupInterface() {
  59   return false;
  60 }
  61
  62 QString AbstractInterface::getEndianessString() {
  63   QString str="unknown";
  64   switch(endianess){
  65   case AbstractInterface::LittleEndian:
  66     str = QString("little");
  67     break;
  68   case AbstractInterface::BigEndian:
  69     str = QString("big");
  70     break;
  71   }
  72   return str;
  73 }
  74
  75 QString AbstractInterface::getPurposeString() {
  76   QString str;
  77   switch(purpose){
  78   case AbstractInterface::AnyPurpose:
  79     str = QString("any");
  80     break;
  81   case AbstractInterface::Data:
  82     str = QString("data");
  83     break;
  84   case AbstractInterface::Control:
  85     str = QString("control");
  86     break;
  87   case AbstractInterface::Clock:
  88     str = QString("clock");
  89     break;
  90   case AbstractInterface::Reset:
  91     str = QString("reset");
  92     break;
  93   case AbstractInterface::Wishbone:
  94     str = QString("wishbone");
  95     break;
  96   }
  97   return str;
  98 }
  99
 100 QString AbstractInterface::getDirectionString() {
 101     QString str;
 102     switch(direction){
 103         case AbstractInterface::Input:
 104             str = QString("input");
 105             break;
 106         case AbstractInterface::Output:
 107             str = QString("output");
 108             break;
 109         case AbstractInterface::InOut:
 110             str = QString("inout");
 111             break;
 112     }
 113     return str;
 114 }
 115
 116 double AbstractInterface::getDoubleWidth() throw(QException) {
 117
 118   static QString fctName = "AbstractInterface::getDoubleWidth()";
 119  #ifdef DEBUG_FCTNAME
 120    cout << "call to " << qPrintable(fctName) << endl;
 121  #endif
 122
 123    /*
 124     cout << "start AbstractInterface::getDoubleWidth()" << endl;
 125     bool ok;
 126     double width = getWidth().toDouble(&ok);
 127
 128     if(!ok){
 129       ArithmeticEvaluator *evaluator = new ArithmeticEvaluator;
 130       cout << "evaluator created!" << endl;
 131       evaluator->setExpression(getWidth());
 132       cout << "expression defined!" << endl;
 133       foreach(BlockParameter *param, getOwner()->getParameters()){
 134         evaluator->setVariableValue(param->getName(), param->getIntValue());
 135         cout << "param : " << param->getName().toStdString() << " evaluated!" << endl;
 136       }
 137       width = evaluator->evaluate();
 138       cout << "expression evaluated succefully!" << endl;
 139     }
 140     cout << "real width : " << width << endl;
 141     return width;
 142     */
 143
 144    return 1.0;
 145 }
 146
 147 void AbstractInterface::setPurpose(int _purpose) {
 148   if ((_purpose>=Data) && (_purpose <= Wishbone)) {
 149     purpose = _purpose;
 150   }
 151 }
 152
 153 void AbstractInterface::setDirection(int _direction) {
 154   if ((_direction > Input) && (_direction <= InOut)) {
 155     direction = _direction;
 156   }
 157 }
 158
 159 bool AbstractInterface::setAssociatedIface(AbstractInterface* iface) {
 160   if (purpose != Control) return false;
 161   if (iface->purpose != Data) return false;
 162   associatedIface = iface;
 163   iface->associatedIface = this;
 164   return true;
 165 }
 166
 167
 168 int AbstractInterface::getIntDirection(QString str) {
 169     if(str == "input") return Input;
 170     if(str == "output") return Output;
 171     if(str == "inout") return InOut;
 172     return -1;
 173 }
 174
 175 int AbstractInterface::getIntPurpose(QString str) {
 176     if(str == "data") return Data;
 177     else if(str == "clock") return Clock;
 178     else if(str == "reset") return Reset;
 179     else if(str == "wishbone") return Wishbone;
 180     return -1;
 181 }
 182
 183 QString AbstractInterface::getTypeString() {
 184
 185   if (type == Boolean) {
 186     return "boolean";
 187   }
 188   else if (type == Natural) {
 189     return "natural";
 190   }
 191   else if (type == Expression) {
 192     return "expression";
 193   }
 194   return "invalid_type";
 195 }
 196
 197 int AbstractInterface::typeFromString(const QString &_type) {
 198
 199   int ret = Expression; // default type
 200   if (_type == "expression") {
 201     ret = Expression;
 202   }
 203   else if (_type == "boolean") {
 204     ret = Boolean;
 205   }
 206   else if (_type == "natural") {
 207     ret = Natural;
 208   }
 209   else if (_type == "inherited") {
 210     ret = Inherited;
 211   }
 212   return ret;
 213 }
 214
 215 QString AbstractInterface::toVHDL(int context, int flags) throw(Exception) {
 216
 217
 218   if (isReferenceInterface()) throw(Exception(IFACE_INVALID_TYPE));
 219
 220   QString msb = width;
 221   QString ret="";
 222   bool ok;
 223     cout << "iface " << qPrintable(name) << " must be evaluated to vhdl :" << qPrintable(msb) << " with type = " << qPrintable(getTypeString()) << endl;
 224
 225   if ((context == BlockParameter::Entity) || (context == BlockParameter::Component)) {
 226
 227     QString formatBool = "%1 : %2 std_logic";
 228     QString formatVector = "";
 229     if (endianess == LittleEndian) formatVector = "%1 : %2 std_logic_vector(%3 downto %4)";
 230     else formatVector = "%1 : %2 std_logic_vector(%4 to %3)";
 231
 232     if ((flags & BlockParameter::NoComma) == 0) {
 233       formatBool.append(";");
 234       formatVector.append(";");
 235     }
 236     QString orientation="";
 237     if (direction == Input) {
 238       orientation = "in";
 239     }
 240     else if (direction == Output) {
 241       orientation = "out";
 242     }
 243     else {
 244       orientation = "inout";
 245     }
 246     if (type == Boolean) {
 247       ret = formatBool.arg(name).arg(orientation);
 248     }
 249     else if (type == Natural) {
 250       int w = width.toInt(&ok);
 251       if (!ok) {
 252         throw(Exception(INVALID_VALUE));
 253       }
 254       else {
 255         w -= 1;
 256         ret = formatVector.arg(name).arg(orientation).arg(w).arg("0");
 257       }
 258     }
 259     else if (type == Expression) {
 260
 261
 262       /* must check the following conditions :
 263            - if it contains user/port parameters : must evaluate their numeric value
 264            - if it contains generic parameters : just remove the $ -> the expression is not arithmetically evaluated.
 265       */
 266       QList<BlockParameter*> listGenerics = owner->getGenericParameters();
 267       QList<BlockParameter*> listUsers = owner->getUserParameters();
 268       QList<BlockParameter*> listPorts = owner->getPortParameters();
 269       foreach(BlockParameter* p, listUsers) {
 270         QString var = "$";
 271         var += p->getName();
 272         if (width.contains(var)) {
 273           int w = p->getValue().toInt(&ok);
 274           if (!ok) throw(Exception(INVALID_VALUE));
 275           msb.replace(var,p->getValue().toString());
 276         }
 277       }
 278       foreach(BlockParameter* p, listPorts) {
 279         QString var = "$";
 280         var += p->getName();
 281         if (width.contains(var)) {
 282           msb.replace(var,p->toVHDL(0,0));
 283         }
 284       }
 285       foreach(BlockParameter* p, listGenerics) {
 286         QString var = "$";
 287         var += p->getName();
 288         if (width.contains(var)) {
 289           msb.replace(var,p->getName());
 290         }
 291       }
 292       msb += "-1";
 293       cout << "iface size :" << qPrintable(msb) << endl;
 294       ret = formatVector.arg(name).arg(orientation).arg(msb).arg("0");
 295     }
 296   }
 297   return ret;
 298 }
 299