]> AND Private Git Repository - blast.git/blob - AbstractInterface.cpp
Logo AND Algorithmique Numérique Distribuée

Private GIT Repository
removed level attribute from interface
[blast.git] / 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