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