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