AbstractInterface.cpp

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