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