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
 149 QString AbstractInterface::getTypeString() {
 150
 151   if (type == Boolean) {
 152     return "boolean";
 153   }
 154   else if (type == Natural) {
 155     return "natural";
 156   }
 157   else if (type == Expression) {
 158     return "expression";
 159   }
 160   return "invalid_type";
 161 }
 162
 163 int AbstractInterface::typeFromString(const QString &_type) {
 164
 165   int ret;
 166   if (_type == "expression") {
 167     ret = Expression;
 168   }
 169   else if (_type == "boolean") {
 170     ret = Boolean;
 171   }
 172   else if (_type == "natural") {
 173     ret = Natural;
 174   }
 175   else if (_type == "inherited") {
 176     ret = Inherited;
 177   }
 178   return ret;
 179 }
 180
 181 QString AbstractInterface::toVHDL(int context, int flags) throw(Exception) {
 182
 183   if (isReferenceInterface()) throw(Exception(IFACE_INVALID_TYPE));
 184
 185   QString msb = width;
 186   QString ret="";
 187   bool ok;
 188   if ((context == BlockParameter::Entity) || (context == BlockParameter::Component)) {
 189
 190     QString formatBool = "%1 : %2 std_logic";
 191     QString formatVector = "%1 : %2 std_logic_vector(%3 downto %4)";
 192     if ((flags & BlockParameter::NoComma) == 0) {
 193       formatBool.append(";");
 194       formatVector.append(";");
 195     }
 196     QString orientation="";
 197     if (direction == Input) {
 198       orientation = "in";
 199     }
 200     else if (direction == Output) {
 201       orientation = "out";
 202     }
 203     else {
 204       orientation = "inout";
 205     }
 206     if (type == Boolean) {
 207       ret = formatVector.arg(name).arg(orientation);
 208     }
 209     else if (type == Natural) {
 210       int w = width.toInt(&ok);
 211       if (!ok) {
 212         throw(Exception(INVALID_VALUE));
 213       }
 214       else {
 215         w -= 1;
 216         ret = formatVector.arg(name).arg(orientation).arg(w).arg("0");
 217       }
 218     }
 219     else if (type == Expression) {
 220       /* must check the following conditions :
 221            - if it contains user/port parameters : must evaluate their numeric value
 222            - if it contains generic parameters : just remove the $ -> the expression is not arithmetically evaluated.
 223       */
 224       QList<BlockParameter*> listGenerics = owner->getGenericParameters();
 225       QList<BlockParameter*> listUsers = owner->getUserParameters();
 226       QList<BlockParameter*> listPorts = owner->getPortParameters();
 227       foreach(BlockParameter* p, listUsers) {
 228         QString var = "$";
 229         var.append(p->getName());
 230         if (width.contains(var)) {
 231           int w = p->getValue().toInt(&ok);
 232           if (!ok) throw(Exception(INVALID_VALUE));
 233           msb.replace(var,p->getValue().toString());
 234         }
 235       }
 236       foreach(BlockParameter* p, listPorts) {
 237         QString var = "$";
 238         var.append(p->getName());
 239         if (width.contains(var)) {
 240           BlockParameterPort* pp = (BlockParameterPort*)p;
 241           AbstractInterface* iface = owner->getIfaceFromName(pp->getIfaceName());
 242
 243           int w = p->getValue().toInt(&ok);
 244           if (!ok) throw(Exception(INVALID_VALUE));
 245           msb.replace(var,p->getValue().toString());
 246         }
 247       }
 248
 249       ret = formatVector.arg(name).arg(orientation).arg("toto").arg("0");
 250     }
 251   }
 252   return ret;
 253 }
 254