FunctionalBlock.cpp

   1 #include "FunctionalBlock.h"\r
   2 #include "ReferenceBlock.h"\r
   3 #include "GroupBlock.h"\r
   4 #include "AbstractInterface.h"\r
   5 #include "FunctionalInterface.h"\r
   6 #include "ReferenceInterface.h"\r
   7 #include "BlockParameter.h"\r
   8 #include "ArithmeticEvaluator.h"\r
   9 \r
  10 \r
  11 FunctionalBlock::FunctionalBlock(GroupBlock *_parent, ReferenceBlock *_reference) throw(Exception) :  AbstractBlock() {\r
  12   //if (! _reference->isReferenceBlock()) throw(Exception(BLOCK_INVALID_TYPE));\r
  13   //if (! _group->isGroupBlock()) throw(Exception(BLOCK_INVALID_TYPE));\r
  14   reference = _reference;\r
  15   parent = _parent;\r
  16   name = reference->getName();\r
  17 \r
  18   if (reference->getImplementations().isEmpty()) {\r
  19     implementation = NULL;\r
  20     cout << "block has no implementation" << endl;\r
  21   }\r
  22   else {\r
  23     implementation = reference->getImplementations().at(0);\r
  24   }\r
  25   lengthAP = -1;\r
  26   lengthCP = -1;\r
  27   lengthIP = -1;\r
  28   lengthOP = -1;\r
  29   lengthPP = -1;\r
  30   delta = -1;\r
  31   evaluator = NULL;\r
  32 \r
  33 }\r
  34 \r
  35 FunctionalBlock::~FunctionalBlock() {\r
  36   if (evaluator != NULL) delete evaluator;\r
  37 }\r
  38 \r
  39 void FunctionalBlock::parametersValidation(QList<AbstractBlock*>* checkedBlocks, QList<AbstractBlock *> *blocksToConfigure) {\r
  40   /*\r
  41   checkedBlocks->append(this);\r
  42 \r
  43   foreach(BlockParameter* param, params){\r
  44     if(param->isUserParameter() && !param->isValueSet()){\r
  45       if(!blocksToConfigure->contains(param->getOwner())){\r
  46         blocksToConfigure->append(param->getOwner());\r
  47       }\r
  48     }\r
  49   }\r
  50   foreach(AbstractInterface *inter, outputs){\r
  51     foreach(AbstractInterface *connectedInter, inter->getConnectedTo()){\r
  52       if(!checkedBlocks->contains(connectedInter->getOwner())){\r
  53         connectedInter->getOwner()->parametersValidation(checkedBlocks, blocksToConfigure);\r
  54       }\r
  55     }\r
  56   }\r
  57   */\r
  58 }\r
  59 \r
  60 bool FunctionalBlock::isFunctionalBlock() {\r
  61   return true;\r
  62 }\r
  63 \r
  64 bool FunctionalBlock::isSourceBlock() {\r
  65   if (parent == NULL) return true;\r
  66   return false;\r
  67 }\r
  68 \r
  69 void FunctionalBlock::populate() {\r
  70   int i;\r
  71   BlockParameter* p;\r
  72   AbstractInterface* inter;\r
  73 \r
  74   // create parameters from reference block\r
  75   QList<BlockParameter*> lstParam = reference->getParameters();\r
  76   for(i=0;i<lstParam.size();i++) {\r
  77     p = lstParam.at(i)->clone();\r
  78     addParameter(p);\r
  79   }\r
  80 \r
  81   ConnectedInterface* toClk = NULL;\r
  82   ConnectedInterface* toRst = NULL;\r
  83   // create interfaces from reference block\r
  84   QList<AbstractInterface *> lstRef = reference->getInterfaces();\r
  85   // store relation between functional and reference\r
  86   QHash<AbstractInterface *, AbstractInterface *> hashIface;\r
  87   for(i=0;i<lstRef.size();i++) {\r
  88     try {\r
  89       inter = new FunctionalInterface(this, AI_TO_REF(lstRef.at(i)));\r
  90     }\r
  91     catch(Exception e) {\r
  92       cerr << "Abnormal case: " << qPrintable(e.getDefaultMessage()) << endl << "Aborting execution." << endl;\r
  93       exit(1);\r
  94     }\r
  95     hashIface.insert(lstRef.at(i),inter);\r
  96     addInterface(inter);\r
  97     /* WARNING FOR THE FUTURE :\r
  98        in case of there are several clock interfaces ofr that block\r
  99        it would be a godd idea to make the user choose which one\r
 100        must be connected to defautl clk.\r
 101        Presently, the first encountered is chosen\r
 102      */\r
 103     if ((toClk == NULL) && (inter->getPurpose() == AbstractInterface::Clock)) {\r
 104       toClk = AI_TO_CON(inter);\r
 105     }\r
 106     if ((toRst == NULL) && (inter->getPurpose() == AbstractInterface::Reset)) {\r
 107       toRst = AI_TO_CON(inter);\r
 108     }\r
 109   }\r
 110     \r
 111   AbstractInterface* funCtlIface = NULL;\r
 112   AbstractInterface* funDataIface = NULL;\r
 113   \r
 114   for(i=0;i<lstRef.size();i++) {    \r
 115     AbstractInterface* refIface = lstRef.at(i);    \r
 116     if (refIface->getPurpose() == AbstractInterface::Control) {\r
 117       funCtlIface = hashIface.value(refIface);\r
 118       funDataIface = hashIface.value(refIface->getAssociatedIface());\r
 119       if (! funCtlIface->setAssociatedIface(funDataIface)) {\r
 120         cerr << "Abnormal case when associating a control interface to data" << endl << "Aborting execution." << endl;\r
 121         exit(1);\r
 122       }       \r
 123     }\r
 124   }\r
 125 \r
 126   // connect clk and rst to group clk/rst or to clkrstgen\r
 127   if ((name != "clkrstgen") && (parent != NULL)) {\r
 128     try {\r
 129       connectClkReset();\r
 130     }\r
 131     catch(Exception e) {\r
 132       AbstractBlock* source = (AbstractBlock *)(e.getSource());\r
 133       cerr << qPrintable(source->getName()) << ":" << qPrintable(e.getMessage()) << endl;\r
 134       throw(e);\r
 135     }\r
 136   }\r
 137 }\r
 138 \r
 139 QString FunctionalBlock::getReferenceXmlFile() {\r
 140     return ((ReferenceBlock *)reference)->getXmlFile();\r
 141 }\r
 142 \r
 143 QString FunctionalBlock::getReferenceHashMd5() {\r
 144     return ((ReferenceBlock *)reference)->getHashMd5();\r
 145 }\r
 146 \r
 147 void FunctionalBlock::createPatterns() throw(Exception) {\r
 148   static QString fctName = "FunctionalBlock::createPatterns()";\r
 149 #ifdef DEBUG_FCTNAME\r
 150   cout << "call to " << qPrintable(fctName) << endl;\r
 151 #endif\r
 152 \r
 153   if (implementation->hasNoPatterns()) return;\r
 154   \r
 155   cout << "create patterns for block " << qPrintable(name) << endl;\r
 156   if (evaluator == NULL) evaluator = new ArithmeticEvaluator();\r
 157   if (! isGeneratorBlock()) {\r
 158     try {\r
 159       createDelta();\r
 160       createConsumptionPattern();    \r
 161       createProductionCounter();\r
 162     }\r
 163     catch(Exception e) {\r
 164       throw(e); // rethrow e\r
 165     }\r
 166   }\r
 167   try {\r
 168     createProductionPattern();\r
 169   }\r
 170   catch(Exception e) {\r
 171     throw(e);\r
 172   }\r
 173   cout << "PP of " << qPrintable(name) << endl;\r
 174   QMapIterator<AbstractInterface*,QList<char>* > it(productionPattern);\r
 175   while (it.hasNext()) {\r
 176     it.next();\r
 177     QList<char>* pat = it.value();\r
 178     foreach(char c, *pat) cout << (int)c;\r
 179     cout << endl;\r
 180   }\r
 181 }\r
 182 \r
 183 void FunctionalBlock::createDelta() throw(Exception) {\r
 184   static QString fctName = "FunctionalBlock::createDelta()";\r
 185 #ifdef DEBUG_FCTNAME\r
 186   cout << "call to " << qPrintable(fctName) << endl;\r
 187 #endif \r
 188   \r
 189   QString deltaStr = implementation->getDelta();  \r
 190   cout << "delta for " << qPrintable(name) << " = " << qPrintable(deltaStr) << endl;\r
 191   if (deltaStr.isEmpty()) {\r
 192     delta = -1;\r
 193     return;\r
 194   }\r
 195   \r
 196   // look for parameter names  \r
 197   double result = 0;\r
 198   try {\r
 199     result = evaluateExpression(deltaStr);\r
 200   }\r
 201   catch(Exception e) {\r
 202     throw(e);\r
 203   }\r
 204   delta = result;\r
 205   cout << "delta = " << delta << endl;\r
 206 }\r
 207 \r
 208 void FunctionalBlock::createConsumptionPattern()  throw(Exception) {\r
 209   static QString fctName = "FunctionalBlock::createConsumptionPattern()";\r
 210 #ifdef DEBUG_FCTNAME\r
 211   cout << "call to " << qPrintable(fctName) << endl;\r
 212 #endif\r
 213   \r
 214   // first clear if already exists\r
 215   clearConsumptionPattern();\r
 216 \r
 217   lengthCP = -1;  \r
 218   QHash<QString,QString> consPattern = implementation->getConsumptionPattern();  \r
 219   \r
 220   foreach(AbstractInterface* iface, getControlInputs()) {       \r
 221     FunctionalInterface* connIface = AI_TO_FUN(iface);\r
 222     QString refName = connIface->getReference()->getName();    \r
 223     if (! consPattern.contains(refName)) {\r
 224       throw(Exception(NO_IFACE_CP,this));\r
 225       cerr << "no consumption pattern for reference interface " << qPrintable(refName) << endl;\r
 226     }\r
 227     QList<char>* pattern = NULL;\r
 228     try {\r
 229       pattern = expandPattern(consPattern.value(refName));\r
 230     }\r
 231     catch(Exception e) {\r
 232       throw(e);\r
 233     }\r
 234     consumptionPattern.insert(connIface,pattern);\r
 235     if (lengthCP == -1) {\r
 236       lengthCP = pattern->size();\r
 237     }\r
 238     else {\r
 239       if (pattern->size() != lengthCP) {\r
 240         throw(Exception(INVALID_IFACE_CP_LENGTH,this));\r
 241       }\r
 242     }\r
 243   }          \r
 244 }\r
 245 \r
 246 void FunctionalBlock::createProductionPattern() throw(Exception){  \r
 247   static QString fctName = "FunctionalBlock::createProductionPattern()";\r
 248 #ifdef DEBUG_FCTNAME\r
 249   cout << "call to " << qPrintable(fctName) << endl;\r
 250 #endif\r
 251 \r
 252   // first clear if already exists\r
 253   clearProductionPattern();\r
 254   \r
 255   lengthPP = -1;  \r
 256   QHash<QString,QString> prodPattern = implementation->getProductionPattern();  \r
 257   \r
 258   foreach(AbstractInterface* iface, getControlOutputs()) {    \r
 259     FunctionalInterface* connIface = AI_TO_FUN(iface);\r
 260     QString refName = connIface->getReference()->getName();    \r
 261     if (! prodPattern.contains(refName)) {\r
 262       throw(Exception(NO_IFACE_PP,this));\r
 263     }\r
 264     QList<char>* pattern = NULL;\r
 265     try {\r
 266       pattern = expandPattern(prodPattern.value(refName));\r
 267     }\r
 268     catch(Exception e) {\r
 269       throw(e);\r
 270     }\r
 271     productionPattern.insert(connIface,pattern);\r
 272     if (lengthPP == -1) {\r
 273       lengthPP = pattern->size();\r
 274     }\r
 275     else {\r
 276       if (pattern->size() != lengthPP) {\r
 277         throw(Exception(INVALID_IFACE_PP_LENGTH,this));\r
 278       }\r
 279     }\r
 280   }      \r
 281 }\r
 282 \r
 283 void FunctionalBlock::createProductionCounter() throw(Exception) {\r
 284   static QString fctName = "FunctionalBlock::createProductionCounter()";\r
 285 #ifdef DEBUG_FCTNAME\r
 286   cout << "call to " << qPrintable(fctName) << endl;\r
 287 #endif\r
 288 \r
 289   // first clear if already exists\r
 290   productionCounter.clear();\r
 291 \r
 292   \r
 293   QStringList counterParts = implementation->getProductionCounter().split(",");\r
 294   foreach(QString s, counterParts) {\r
 295     cout << "cont part = " << qPrintable(s) << endl;\r
 296     bool ok;\r
 297     double val = s.toDouble(&ok);\r
 298     if (ok) {\r
 299       productionCounter.append(val);\r
 300     }\r
 301     else if (s.at(0) == '{') {\r
 302       s.remove(0,1);\r
 303       s.chop(1);\r
 304       QStringList gen = s.split(":");\r
 305       if (gen.size() != 3) {\r
 306         throw(Exception(INVALID_IFACE_PC,this));\r
 307       }\r
 308       int start = 0;\r
 309       int nb = 0;\r
 310       int step = 0;\r
 311       for(int i=0;i<3;i++) {        \r
 312         double result = 0.0;\r
 313         try {\r
 314           result = evaluateExpression(gen.at(i));\r
 315         }\r
 316         catch(Exception e) {\r
 317           throw(e);\r
 318         }\r
 319         if (i==0) start = result;\r
 320         else if (i==1) nb = result;\r
 321         else if (i==2) step = result;\r
 322       }\r
 323       for(int j=0;j<nb;j++) {\r
 324         productionCounter.append(start+j*step);\r
 325       }\r
 326     }\r
 327     else {      \r
 328       double result = 0.0;\r
 329       try {\r
 330         result = evaluateExpression(s);\r
 331       }\r
 332       catch(Exception e) {\r
 333         throw(e);\r
 334       }\r
 335       productionCounter.append(result);      \r
 336     }\r
 337   }\r
 338   foreach(int val, productionCounter) {\r
 339     cout << val << ",";\r
 340   }\r
 341   cout << endl;\r
 342 }\r
 343 \r
 344 QList<char>* FunctionalBlock::expandPattern(const QString& patternIn) throw(Exception) {\r
 345   static QString fctName = "FunctionalBlock::expandPattern()";\r
 346 #ifdef DEBUG_FCTNAME\r
 347   cout << "call to " << qPrintable(fctName) << endl;\r
 348 #endif\r
 349   /* expanding a pattern is done in two steps :\r
 350       - 1 : finding all variables that correspond to an expression\r
 351             and copy them in the pattern\r
 352       - 2 : parsing the result\r
 353 \r
 354       Note that the result MUST contain only variables that have a\r
 355       integer/double value. Otherwise, expanding will fail.\r
 356 \r
 357    */\r
 358 \r
 359   // first step.\r
 360 \r
 361   QString p = replaceExpressions(patternIn);\r
 362 \r
 363   QList<char> lst;  \r
 364   p.append(')');\r
 365   int offset = 0;  \r
 366   QList<char>* patternOut = new QList<char>();\r
 367   try {\r
 368     patternOut->append(expandPatternRecur(p,&offset));\r
 369   }\r
 370   catch(Exception e) {\r
 371     throw(e);\r
 372   }\r
 373 \r
 374   return patternOut;\r
 375 }\r
 376 \r
 377 QString FunctionalBlock::replaceExpressions(const QString& patternIn) throw(Exception) {\r
 378 \r
 379   QString res = patternIn;\r
 380   bool stop = false;\r
 381   QRegularExpression re("[$][a-zA-Z0-9_]+");\r
 382 \r
 383   while (!stop) {\r
 384     stop = true;\r
 385     QRegularExpressionMatchIterator matcher = re.globalMatch(res);\r
 386     while(matcher.hasNext()) {\r
 387       QRegularExpressionMatch m = matcher.next();\r
 388       QString param = m.captured(0);\r
 389       QString paramName = param;\r
 390       paramName.remove(0,1);\r
 391       BlockParameter* p = getParameterFromName(paramName);\r
 392       if ((p != NULL) && (p->getType() == BlockParameter::Expression)) {\r
 393         res.replace(param,p->getStringValue());\r
 394         stop = false;\r
 395         cout << "found an expr: " << qPrintable(paramName) << ", patern => " << qPrintable(res) << endl;\r
 396       }\r
 397     }\r
 398   }\r
 399   return res;\r
 400 }\r
 401 \r
 402 QList<char> FunctionalBlock::expandPatternRecur(const QString& patternIn, int *offset) throw(Exception) {\r
 403   \r
 404   QList<char> patternOut;\r
 405 \r
 406   while ((*offset < patternIn.size()) && (patternIn.at(*offset) != ')')) {\r
 407     \r
 408     QChar c = patternIn.at(*offset);\r
 409     if (c == '(') {\r
 410       *offset += 1;\r
 411       try {\r
 412         patternOut.append(expandPatternRecur(patternIn,offset));\r
 413       }\r
 414       catch(Exception e) {\r
 415         throw(e);\r
 416       }\r
 417     }\r
 418     else if (c == '0') {\r
 419       patternOut.append(0);\r
 420     }\r
 421     else if (c == '1') {\r
 422       patternOut.append(1);\r
 423     }\r
 424     else if (c == 'X') {\r
 425       patternOut.append(-1);\r
 426     }\r
 427     else if (c == '{') {\r
 428       *offset += 1;\r
 429       QString expr = "";      \r
 430       while ((*offset < patternIn.size()) && (patternIn.at(*offset) != '}')) {\r
 431         expr += patternIn.at(*offset);        \r
 432         *offset += 1;\r
 433       }\r
 434       if (*offset == patternIn.size()) {\r
 435         throw(Exception(INVALID_IFACE_PATTERN,this));\r
 436       }\r
 437       double repeat = 0;\r
 438       try {\r
 439         repeat = evaluateExpression(expr);\r
 440       }\r
 441       catch(Exception e) {\r
 442         throw(e);\r
 443       }\r
 444       // repeat just the last value in currentGroup\r
 445       char last = patternOut.last();\r
 446       //cout << "repeat last char " << repeat << " times : " << (int)last << endl;\r
 447       \r
 448       for(int i=1;i<(int)repeat;i++) {\r
 449         patternOut.append(last);\r
 450       }\r
 451     }    \r
 452     *offset += 1;\r
 453   }\r
 454   \r
 455   // must check if after ), there is a {\r
 456   if ((*offset < patternIn.size()-1) && (patternIn.at(*offset+1) == '{')) {\r
 457     *offset += 2;\r
 458     QString expr = "";      \r
 459     while ((*offset < patternIn.size()) && (patternIn.at(*offset) != '}')) {\r
 460       expr += patternIn.at(*offset);        \r
 461       *offset += 1;\r
 462     }\r
 463     if (*offset == patternIn.size()) {\r
 464       throw(Exception(INVALID_IFACE_PATTERN,this));\r
 465     }\r
 466     double repeat = 0;\r
 467     try {\r
 468       repeat = evaluateExpression(expr);\r
 469     }\r
 470     catch(Exception e) {\r
 471       throw(e);\r
 472     }\r
 473     /*\r
 474     cout << "repeat last group " << repeat << " times : ";\r
 475     foreach (char c, currentGroup) cout <<(int)c;\r
 476     cout << endl;  \r
 477     */\r
 478     QList<char> single = patternOut;\r
 479     for(int i=1;i<(int)repeat;i++) {\r
 480       patternOut.append(single);\r
 481     }    \r
 482   }  \r
 483   return patternOut;\r
 484 }\r
 485 \r
 486 double FunctionalBlock::evaluateExpression(const QString& expression) throw(Exception) {\r
 487   static QString fctName = "FunctionalBlock::evaluateExpression()";\r
 488 #ifdef DEBUG_FCTNAME\r
 489   cout << "call to " << qPrintable(fctName) << endl;\r
 490 #endif\r
 491     \r
 492   QHash<QString,double> vars;\r
 493   evaluator->setExpression(expression);\r
 494   QList<QString> varNames = evaluator->getVariableNames();\r
 495   foreach (QString name, varNames) {\r
 496     QString paramName = name;\r
 497     paramName.remove(0,1);\r
 498     BlockParameter* param = getParameterFromName(paramName);\r
 499     if (param == NULL) {\r
 500       throw(Exception(EVAL_PARAM_UNKNOWN,this));\r
 501     }\r
 502     bool okVal;\r
 503     int val = param->getDoubleValue(&okVal);    \r
 504     if (!okVal) {\r
 505       throw(Exception(EVAL_PARAM_NOVALUE,this));\r
 506     }\r
 507     vars.insert(name,(double)val);    \r
 508   }\r
 509   \r
 510   evaluator->setVariablesValue(vars);\r
 511   double result = 0.0;\r
 512   try {\r
 513     result = evaluator->evaluate();\r
 514   }\r
 515   catch(int index) {\r
 516     cerr << "Error at index " << index << ": " << qPrintable(evaluator->getError()) << endl;\r
 517     throw(Exception(EVAL_INVALID_EXPR,this));\r
 518   }\r
 519   return result;\r
 520 }\r
 521 \r
 522 void FunctionalBlock::computeAdmittanceDelays() throw(Exception) {\r
 523   static QString fctName = "FunctionalBlock::computeAdmittanceDelays()";\r
 524 #ifdef DEBUG_FCTNAME\r
 525   cout << "call to " << qPrintable(fctName) << endl;\r
 526 #endif\r
 527   QList<int> inClock;\r
 528   QList<int> delays;\r
 529 \r
 530   clearAdmittanceDelays();\r
 531 \r
 532   // trying to synchronize the first one in AP\r
 533   QMapIterator<AbstractInterface*,QList<char>* > iterAP(admittance);\r
 534   QMapIterator<AbstractInterface*,QList<char>* > iterIP(inputPattern);\r
 535 \r
 536   while (iterAP.hasNext()) {\r
 537     iterAP.next();\r
 538     iterIP.next();\r
 539     QList<char>* ap = iterAP.value();\r
 540     QList<char>* ip = iterIP.value();\r
 541     int first = 0;\r
 542     while ((first < lengthIP) && (ip->at(first) == 0)) first++;\r
 543     while ((first < lengthAP) && (ap->at(first) == 0)) first--;\r
 544     delays.append(first);\r
 545     inClock.append(0);\r
 546     QList<int>* delays = new QList<int>();\r
 547     admittanceDelays.insert(iterAP.key(), delays);\r
 548   }\r
 549 \r
 550   QMapIterator<AbstractInterface*,QList<int>* > iterDelays(admittanceDelays);\r
 551 \r
 552   // get the delay to apply\r
 553   int maxDelay = 0;\r
 554   for(int i=0;i<delays.size();i++) {\r
 555     if (delays[i] > maxDelay) maxDelay = delays[i];\r
 556   }\r
 557   // adding the delays to IP\r
 558   iterIP.toFront();\r
 559   int i = 0;\r
 560   while (iterIP.hasNext()) {\r
 561     iterIP.next();\r
 562     iterDelays.next();\r
 563     QList<char>* ip = iterIP.value();\r
 564     QList<int>* d = iterDelays.value();\r
 565     d->append(maxDelay-delays[i]);\r
 566     cout << "prependind " << qPrintable(iterIP.key()->getName()) << " with " << (maxDelay-delays[i]) << " 0" << endl;\r
 567     for(int j=0;j<maxDelay-delays[i];j++) {\r
 568       ip->prepend(0);\r
 569     }\r
 570     for(int j=0;j<delays[i];j++) {\r
 571       ip->append(0);\r
 572     }\r
 573     i++;\r
 574   }\r
 575   lengthIP += maxDelay;\r
 576 \r
 577   cout << "IP length = " << lengthIP << ", AP length = " << lengthAP << endl;\r
 578   bool stop = false;\r
 579   int apIndex = 0;\r
 580   int ipIndex = 0;\r
 581   while (!stop) {\r
 582 \r
 583     // if AP is a valid group, search for the next valid group in IP\r
 584     if (isValidDataGroup(admittance,apIndex)) {\r
 585 \r
 586       while ((ipIndex < lengthIP) && (! isValidDataGroup(inputPattern,ipIndex))) ipIndex++;\r
 587       if (ipIndex == lengthIP) {\r
 588         stop = true;\r
 589         continue;\r
 590       }\r
 591     }\r
 592 \r
 593     iterAP.toFront();\r
 594     iterIP.toFront();\r
 595     iterDelays.toFront();\r
 596 \r
 597     if (samePatterns(inputPattern,ipIndex,admittance,apIndex)) {\r
 598       while (iterAP.hasNext()) {\r
 599         iterAP.next();\r
 600         iterDelays.next();\r
 601         QList<char>* ap = iterAP.value();\r
 602         if (ap->at(apIndex) == 1) {\r
 603           QList<int>* d = iterDelays.value();\r
 604           d->append(0); // the 1 is at its good place, so no delay\r
 605         }\r
 606       }\r
 607     }\r
 608     else {\r
 609       cout << "diff between IP and AP at " << apIndex << endl;\r
 610       // search for the next 1 in IP for every input that has a 1 in AP\r
 611 \r
 612       while (iterAP.hasNext()) {\r
 613         iterAP.next();\r
 614         iterIP.next();\r
 615         iterDelays.next();\r
 616         QList<char>* ap = iterAP.value();\r
 617         QList<char>* ip = iterIP.value();\r
 618         QList<int>* d = iterDelays.value();\r
 619         // case 1: 1 in IP is too late\r
 620         if ((ap->at(apIndex) == 1) && (ip->at(ipIndex) == 0)) {\r
 621           int delay = 1;\r
 622           while ( ((ipIndex+delay) < lengthIP) && (ip->at(ipIndex+delay) == 0) ) delay++;\r
 623           cout << "found a delay of " << (-delay) << " for iface " << qPrintable(iterAP.key()->getName()) << endl;\r
 624           // moving the 1 to its normal pos.\r
 625           ip->replace(ipIndex,1);\r
 626           ip->replace(ipIndex+delay,0);\r
 627           d->append(-delay);\r
 628         }\r
 629         // case 2: 1 in IP is too soon\r
 630         else if ((ap->at(apIndex) == 0) && (ip->at(ipIndex) == 1)) {\r
 631           int delay = 1;\r
 632           while ( ((apIndex+delay) < lengthAP) && (ap->at(apIndex+delay) == 0) ) delay++;\r
 633           cout << "found a delay of " << delay << " for iface " << qPrintable(iterAP.key()->getName()) << endl;\r
 634           // search for next 0 in IP to put the 1\r
 635           int k = ipIndex+delay;\r
 636           while ((k < lengthIP) && (ip->at(k) == 1)) k++;\r
 637           ip->replace(ipIndex,0);\r
 638           ip->replace(k,1);\r
 639           d->append(delay);\r
 640         }\r
 641       }\r
 642       if (! samePatterns(inputPattern,inClock,admittance,apIndex)) {\r
 643          cout << "Abnormal case while searching for delays" << endl;\r
 644       }\r
 645     }\r
 646 \r
 647     apIndex++;\r
 648     ipIndex++;\r
 649     if ((apIndex >= lengthAP) || (ipIndex >= lengthIP)) stop = true;\r
 650   }\r
 651   iterDelays.toFront();\r
 652   while (iterDelays.hasNext()) {\r
 653     iterDelays.next();\r
 654     QList<int>* d = iterDelays.value();\r
 655     foreach(int v, *d) {\r
 656       cout << v << " ";\r
 657     }\r
 658     cout << endl;\r
 659   }\r
 660 \r
 661 }\r
 662 \r
 663 void FunctionalBlock::createInputPattern()  throw(Exception) {\r
 664   static QString fctName = "FunctionalBlock::createInputPattern())";\r
 665 #ifdef DEBUG_FCTNAME\r
 666   cout << "call to " << qPrintable(fctName) << endl;\r
 667 #endif\r
 668   \r
 669   lengthIP = -1;\r
 670   foreach(AbstractInterface* iface, getControlInputs()) {\r
 671 \r
 672     ConnectedInterface* connIface = AI_TO_CON(iface);\r
 673     // check if it is connected\r
 674     if (connIface->getConnectedFrom() == NULL) {\r
 675       throw(Exception(IFACE_NOT_CONNECTED,this));\r
 676     }\r
 677     // get the precursor output pattern\r
 678     QList<char>* out = connIface->getConnectedFrom()->getOutputPattern();\r
 679     AbstractInputModifier* modifier = connIface->getInputModifier();\r
 680     // check if the input is modified\r
 681     if (modifier != NULL) {\r
 682 \r
 683       out = modifier->getModifiedInput(out);\r
 684     }\r
 685 \r
 686     if (out->size() == 0) {\r
 687       clearInputPattern();\r
 688       throw(Exception(NO_IFACE_IP,this));\r
 689     }\r
 690     if (lengthIP == -1) {\r
 691       lengthIP = out->size();\r
 692     }\r
 693     else {\r
 694       if (out->size() < lengthIP) lengthIP = out->size();\r
 695     }\r
 696     \r
 697     QList<char>* in = new QList<char>(*out);\r
 698     foreach(char c, *in) {\r
 699       cout << (int)c;\r
 700     }\r
 701     cout << endl;    \r
 702     inputPattern.insert(connIface,in);    \r
 703   }\r
 704   // search the last valid group in IP,\r
 705   while(! isValidDataGroup(inputPattern,lengthIP-1)) {\r
 706     //removeDataGroup(inputPattern,lengthIP-1);\r
 707     lengthIP -= 1;\r
 708   }\r
 709 }\r
 710 \r
 711 void FunctionalBlock::createAdmittance(int nbExec) throw(Exception) {\r
 712   static QString fctName = "FunctionalBlock::createAdmittance()";\r
 713 #ifdef DEBUG_FCTNAME\r
 714   cout << "call to " << qPrintable(fctName) << endl;\r
 715 #endif  \r
 716   // firstly, copy CP in AP\r
 717   QMapIterator<AbstractInterface*,QList<char>* > iterC(consumptionPattern);\r
 718   while (iterC.hasNext()) {\r
 719     iterC.next();\r
 720     QList<char>* pattern = new QList<char>(*(iterC.value()));\r
 721     admittance.insert(iterC.key(), pattern);    \r
 722   }\r
 723   lengthAP = lengthCP;\r
 724   int clock = 0;  \r
 725   cout << "trigger 1 at c.c. 0" << endl;\r
 726   for(int i=1;i<nbExec;i++) {\r
 727     // searching for the clock cycle for which a new exec starts\r
 728     int nbGroup = 0;\r
 729     while ((clock < lengthAP) && (nbGroup < delta)) {\r
 730       if (isValidDataGroup(admittance,clock)) nbGroup+=1;\r
 731       clock += 1;\r
 732     }\r
 733     while ((clock < lengthAP) && (! isValidDataGroup(admittance,clock))) clock+=1;\r
 734     cout << "trigger " << (i+1) << " at c.c. " << clock << endl;\r
 735     int sc = clock;\r
 736     // combine CP with AP at sc\r
 737     for(int j=0;j<lengthCP;j++) {\r
 738       // first case : column of CP must be placed beyond AP's end.\r
 739       if (sc == lengthAP) {\r
 740         cout << i << "," << j << " append in AP at " << sc << endl;\r
 741         appendToPattern(consumptionPattern,j,admittance,1);\r
 742         lengthAP += 1;\r
 743         sc += 1;               \r
 744       }\r
 745       // second case : CP and AP can be combined directly (i.e. no X | 1 to do)\r
 746       else if (canCombinePatterns(consumptionPattern,j,admittance,sc)) {\r
 747         cout << i << "," << j << " combine at " << sc << endl;\r
 748         combinePatterns(consumptionPattern,j,admittance,sc);\r
 749         sc += 1;\r
 750       }\r
 751       // third case : CP has an X column\r
 752       else if (isOnlyXDataGroup(consumptionPattern,j)) {\r
 753         cout << i << "," << j << " shift rigth AP to combine at " << sc << endl;\r
 754         shiftRightPattern(admittance,sc);\r
 755         lengthAP += 1;\r
 756         if (! canCombinePatterns(consumptionPattern,j,admittance,sc)) {\r
 757           cerr << "Abnormal case when combining AP and CP" << endl;\r
 758         }\r
 759         combinePatterns(consumptionPattern,j,admittance,sc);        \r
 760         sc += 1;\r
 761       }\r
 762       // fourth case : AP has an X column\r
 763       else if (isOnlyXDataGroup(admittance,sc)) {\r
 764         cout << i << "," << j << " jump c.c. for CP at " << sc << endl;        \r
 765         sc += 1;\r
 766         j -= 1;\r
 767       }\r
 768       else {\r
 769         throw(INVALID_DELTA_CP);        \r
 770       }\r
 771     }\r
 772   }\r
 773   // turn all X into 0\r
 774   QMapIterator<AbstractInterface*,QList<char>* > iterA(admittance);\r
 775   while (iterA.hasNext()) {\r
 776     iterA.next();\r
 777     QList<char>* pattern = iterA.value();\r
 778     for(int i=0;i<pattern->size();i++) {\r
 779       if (pattern->at(i) == -1) pattern->replace(i,0);\r
 780       cout << (int)(pattern->at(i));\r
 781     }\r
 782     cout << endl;\r
 783   }  \r
 784 }\r
 785 \r
 786 void FunctionalBlock::checkInputPatternCompatibility() throw(Exception) {\r
 787   static QString fctName = "FunctionalBlock::checkInputPatternCompatibility()";\r
 788 #ifdef DEBUG_FCTNAME\r
 789   cout << "call to " << qPrintable(fctName) << endl;\r
 790 #endif\r
 791     \r
 792   // firstly, create input pattern\r
 793   try {\r
 794     createInputPattern();\r
 795   }\r
 796   catch(Exception e) {\r
 797     throw(e);\r
 798   }\r
 799   int nbExec = createTriggers();\r
 800   cout << qPrintable(name) << " will exec. " << nbExec << " times." << endl;\r
 801   \r
 802   try {\r
 803     createAdmittance(nbExec);\r
 804   }\r
 805   catch(Exception e) {\r
 806     cout << "cannot create admittance" << endl;\r
 807     throw(e);\r
 808   }\r
 809   \r
 810   int clock = 0; // index in IP  \r
 811   int i = 0; // index in AP  \r
 812   while ((clock < lengthIP) && (i < lengthAP)) {\r
 813      \r
 814     // if AP is a valid group, search for the next valid group in IP\r
 815     if (isValidDataGroup(admittance,i)) {\r
 816       while ((clock < lengthIP) && (! isValidDataGroup(inputPattern,clock))) clock++;\r
 817       if (clock == lengthIP) {\r
 818         cerr << "Abnormal case: end of IP has been reached without finding a valid group" << endl;\r
 819         throw(Exception(IP_END_NULLCOL,this));\r
 820       }\r
 821     }    \r
 822     /* at that point 2 cases of compat : IP(clock) and AP(i) are equal valid group, or\r
 823        are both null columns\r
 824     */\r
 825     if (! samePatterns(inputPattern,clock,admittance,i)) {\r
 826       cout << "AP(" << i << ") and IP(" << clock << ") are not equal" << endl;\r
 827       throw(Exception(IP_AP_NOTCOMPAT,this)); // IP and AP not compatible\r
 828     }\r
 829     clock++;\r
 830     i++;\r
 831   }\r
 832   if (clock < lengthIP) {\r
 833     throw(Exception(AP_TOO_SHORT,this));\r
 834     cerr << "Abnormal case: AP is to short" << endl;   \r
 835   }  \r
 836 }\r
 837 \r
 838 void FunctionalBlock::computeOutputPattern(int nbExec) throw(Exception) {\r
 839   static QString fctName = "FunctionalBlock::computeOutputPattern()";\r
 840 #ifdef DEBUG_FCTNAME\r
 841   cout << "call to " << qPrintable(fctName) << endl;\r
 842 #endif\r
 843 \r
 844   clearOutputPattern();\r
 845 \r
 846   /* case 1: the block is a generator for which output pattern\r
 847      must be computed for a nbExec following executions\r
 848   */\r
 849 \r
 850   if (nbExec > 0) {\r
 851     cout << "computing output pattern of " << qPrintable(name) << " for " << nbExec << " executions" << endl;\r
 852     foreach(AbstractInterface* iface, getControlOutputs()) {\r
 853       FunctionalInterface* connIface = AI_TO_FUN(iface);\r
 854       // create output pattern\r
 855       QList<char>* pp = productionPattern.value(connIface);\r
 856       QList<char>* pattern = new QList<char>(*pp);\r
 857       for(int i=1;i<nbExec;i++) pattern->append(*pp);\r
 858       // assign pattern to interface\r
 859       connIface->setOutputPattern(pattern);\r
 860       // store it in QMap\r
 861       outputPattern.insert(connIface,pattern);      \r
 862     }\r
 863   }\r
 864   else {\r
 865     cout << "computing output pattern of " << qPrintable(name) << endl;\r
 866     \r
 867     // in case of inputPattern not created, do it\r
 868     if (lengthIP <= 0) {\r
 869 \r
 870       cout << "Strange case: input pattern is not created while it is time to compute output pattern !" << endl;\r
 871       // collect the input patterns for each input    \r
 872       try {\r
 873         createInputPattern();\r
 874       }\r
 875       catch(Exception e) {\r
 876         throw(e);\r
 877       }\r
 878       cout << "input pattern array initialized with min. len " << lengthIP << endl;\r
 879     }\r
 880     \r
 881     // initialize the output pattern    \r
 882     lengthOP = 0;\r
 883     foreach(AbstractInterface* iface, getControlOutputs()) {\r
 884       FunctionalInterface* connIface = AI_TO_FUN(iface);      \r
 885       lengthOP = lengthIP+productionPattern.value(connIface)->size();\r
 886       QList<char>* pattern = new QList<char>();\r
 887       for(int i=0;i<lengthOP;i++) pattern->append(0);\r
 888       connIface->setOutputPattern(pattern);\r
 889       outputPattern.insert(connIface,pattern);\r
 890     }\r
 891     cout << "output pattern array initialized" << endl;\r
 892     \r
 893     int clock = 0;\r
 894     nbExec = 0;\r
 895     // search for the beginning of the first execution.\r
 896     while ((clock < lengthIP) && (! isValidDataGroup(inputPattern,clock))) clock++;\r
 897     cout << "found 1st exec clock: " << clock << endl;\r
 898     \r
 899     while (clock < lengthIP) {\r
 900       // initialize counters for current execution.\r
 901       int p = 0; // index in production pattern\r
 902       int o = 0; // clock+o will give the clock cycle of each output group\r
 903       int cip = 0; // clock+cip give the clock cycle of an input group\r
 904       int ccp = 0; // ccp give a column in the consumptio pattern\r
 905       int nip = 0; // number of input data groups already consumed during the current execution, used while exploring IP\r
 906       int ncp = 0; // number of input data groups already consumed during the current execution, used while exploring CP\r
 907       bool cannotCompleteExec = false;\r
 908       for(int m=0;m<productionCounter.size();m++) {\r
 909         // search for the first production in PP\r
 910         while (!isValidDataGroup(productionPattern,p)) {\r
 911           p += 1;\r
 912           o += 1;\r
 913         }\r
 914         int gap = 0; // count the number of extra null columns\r
 915         // search for PC(m) valid input group in IP\r
 916         while (nip < productionCounter.at(m)) {\r
 917           if (clock+cip < lengthIP) {\r
 918             if (isValidDataGroup(inputPattern,clock+cip)) nip += 1;\r
 919             cip += 1;\r
 920             gap += 1;\r
 921           }\r
 922           else {\r
 923             cannotCompleteExec = true;\r
 924             break;\r
 925           }        \r
 926         }        \r
 927         \r
 928         if (cannotCompleteExec) break; // no need to go further since the next search of input data group will lead to go outside inputPattern\r
 929         \r
 930         // search for PC(m) valid input group in IP\r
 931         while (ncp < productionCounter.at(m)) {\r
 932           if (isValidDataGroup(consumptionPattern,ccp)) ncp += 1;\r
 933           ccp += 1;\r
 934           gap -= 1;\r
 935         }\r
 936         o += gap; // to take into acocunt of extra null columns\r
 937         combinePatterns(productionPattern,p,outputPattern,clock+o);\r
 938         p += 1;\r
 939         o += 1;\r
 940       }\r
 941       \r
 942       if (cannotCompleteExec) break; // no need to go further since the next search of input data group will lead to go outside inputPattern\r
 943       \r
 944       // current exec. taken into accunt\r
 945       nbExec += 1;\r
 946       \r
 947       // search for the next exec.\r
 948       clock += 1;      \r
 949       nip = 0;\r
 950       while ((clock < lengthIP) && (nip < delta)) {\r
 951         if (isValidDataGroup(inputPattern,clock)) nip += 1;\r
 952         if (nip < delta) clock += 1;\r
 953       }\r
 954       cout << "found exec " << nbExec << " at clock: " << clock << endl;\r
 955     }\r
 956     // find the last valid output data group\r
 957     while(! isValidDataGroup(outputPattern,lengthOP-1)) {\r
 958       removeDataGroup(outputPattern,lengthOP-1);\r
 959       lengthOP -= 1;\r
 960     }\r
 961 \r
 962     // clear input pattern\r
 963     clearInputPattern();\r
 964   }  \r
 965 }\r
 966 \r
 967 /*\r
 968 \r
 969 void FunctionalBlock::computeOutputPattern(int nbExec) throw(Exception) {\r
 970   static QString fctName = "FunctionalBlock::computeOutputPattern()";\r
 971 #ifdef DEBUG_FCTNAME\r
 972   cout << "call to " << qPrintable(fctName) << endl;\r
 973 #endif\r
 974 \r
 975   // case 1: the block is a generator for which output pattern\r
 976   //   must be computed for a nbExec following executions\r
 977 \r
 978   if (nbExec > 0) {\r
 979     cout << "computing output pattern of " << qPrintable(name) << " for " << nbExec << " executions" << endl;\r
 980     foreach(AbstractInterface* iface, getControlOutputs()) {\r
 981       FunctionalInterface* connIface = AI_TO_FUN(iface);\r
 982       // create output pattern\r
 983       QList<char>* pp = productionPattern.value(connIface);\r
 984       QList<char>* pattern = new QList<char>(*pp);\r
 985       for(int i=1;i<nbExec;i++) pattern->append(*pp);\r
 986       // assign pattern to interface\r
 987       connIface->setOutputPattern(pattern);\r
 988       // store it in QMap\r
 989       outputPattern.insert(connIface,pattern);\r
 990     }\r
 991   }\r
 992   else {\r
 993     cout << "computing output pattern of " << qPrintable(name) << endl;\r
 994 \r
 995     // in case of inputPattern not created, do it\r
 996     if (lengthIP <= 0) {\r
 997       // collect the input patterns for each input\r
 998       try {\r
 999         createInputPattern();\r
1000       }\r
1001       catch(Exception e) {\r
1002         throw(e);\r
1003       }\r
1004       cout << "input pattern array initialized with min. len " << lengthIP << endl;\r
1005     }\r
1006 \r
1007     // initialize the output pattern\r
1008     lengthOP = 0;\r
1009     foreach(AbstractInterface* iface, getControlOutputs()) {\r
1010       FunctionalInterface* connIface = AI_TO_FUN(iface);\r
1011       lengthOP = lengthIP+productionPattern.value(connIface)->size();\r
1012       QList<char>* pattern = new QList<char>();\r
1013       for(int i=0;i<lengthOP;i++) pattern->append(0);\r
1014       connIface->setOutputPattern(pattern);\r
1015       outputPattern.insert(connIface,pattern);\r
1016     }\r
1017     cout << "output pattern array initialized" << endl;\r
1018 \r
1019     int clock = 0;\r
1020     nbExec = 0;\r
1021     // search for the beginning of the first execution.\r
1022     while ((clock < lengthIP) && (! isValidDataGroup(inputPattern,clock))) clock++;\r
1023     cout << "found 1st exec clock: " << clock << endl;\r
1024 \r
1025     while (clock < lengthIP) {\r
1026       // initialize counters for current execution.\r
1027       int p = 0; // index in production pattern\r
1028       int o = 0; // clock+o will give the clock cycle of each output group\r
1029       int cip = 0; // clock+cip give the clock cycle of an input group\r
1030       int ccp = 0; // ccp give a column in the consumptio pattern\r
1031       int nip = 0; // number of input data groups already consumed during the current execution, used while exploring IP\r
1032       int ncp = 0; // number of input data groups already consumed during the current execution, used while exploring CP\r
1033       bool cannotCompleteExec = false;\r
1034       for(int m=0;m<productionCounter.size();m++) {\r
1035         // search for the first production in PP\r
1036         while (!isValidDataGroup(productionPattern,p)) {\r
1037           p += 1;\r
1038           o += 1;\r
1039         }\r
1040         int gap = 0; // count the number of extra null columns\r
1041         // search for PC(m) valid input group in IP\r
1042         while (nip < productionCounter.at(m)) {\r
1043           if (clock+cip < lengthIP) {\r
1044             if (isValidDataGroup(inputPattern,clock+cip)) nip += 1;\r
1045             cip += 1;\r
1046             gap += 1;\r
1047           }\r
1048           else {\r
1049             cannotCompleteExec = true;\r
1050             break;\r
1051           }\r
1052         }\r
1053 \r
1054         if (cannotCompleteExec) break; // no need to go further since the next search of input data group will lead to go outside inputPattern\r
1055 \r
1056         // search for PC(m) valid input group in IP\r
1057         while (ncp < productionCounter.at(m)) {\r
1058           if (isValidDataGroup(consumptionPattern,ccp)) ncp += 1;\r
1059           ccp += 1;\r
1060           gap -= 1;\r
1061         }\r
1062         o += gap; // to take into acocunt of extra null columns\r
1063         combinePatterns(productionPattern,p,outputPattern,clock+o);\r
1064         p += 1;\r
1065         o += 1;\r
1066       }\r
1067 \r
1068       if (cannotCompleteExec) break; // no need to go further since the next search of input data group will lead to go outside inputPattern\r
1069 \r
1070       // current exec. taken into accunt\r
1071       nbExec += 1;\r
1072 \r
1073       // search for the next exec.\r
1074       clock += 1;\r
1075       nip = 0;\r
1076       while ((clock < lengthIP) && (nip < delta)) {\r
1077         if (isValidDataGroup(inputPattern,clock)) nip += 1;\r
1078         if (nip < delta) clock += 1;\r
1079       }\r
1080       cout << "found exec " << nbExec << " at clock: " << clock << endl;\r
1081     }\r
1082     // find the last valid output data group\r
1083     while(! isValidDataGroup(outputPattern,lengthOP-1)) {\r
1084       removeDataGroup(outputPattern,lengthOP-1);\r
1085       lengthOP -= 1;\r
1086     }\r
1087 \r
1088     // clear input pattern\r
1089     clearInputPattern();\r
1090   }\r
1091 }\r
1092 */\r
1093 bool FunctionalBlock::samePatterns(const QMap<AbstractInterface*, QList<char>* >& patternSrc, int srcCol, const QMap<AbstractInterface*, QList<char>* >& patternDest, int destCol) {\r
1094   \r
1095   if (patternSrc.size() != patternDest.size()) return false;\r
1096   QMapIterator<AbstractInterface*, QList<char>* > iterSrc(patternSrc);\r
1097   QMapIterator<AbstractInterface*, QList<char>* > iterDest(patternDest);\r
1098   while (iterSrc.hasNext()) {\r
1099     iterSrc.next();\r
1100     iterDest.next();    \r
1101     QList<char>* srcPat = iterSrc.value();\r
1102     QList<char>* destPat = iterDest.value();\r
1103     if (srcCol >= srcPat->size()) return false;\r
1104     if (destCol >= destPat->size()) return false;\r
1105     if (srcPat->at(srcCol) != destPat->at(destCol)) return false;    \r
1106   }\r
1107   return true;\r
1108 }\r
1109 \r
1110 bool FunctionalBlock::samePatterns(const QMap<AbstractInterface*, QList<char>* >& patternSrc, const QList<int> &srcCols, const QMap<AbstractInterface*, QList<char>* >& patternDest, int destCol) {\r
1111   if (patternSrc.size() != srcCols.size()) return false;\r
1112   if (patternSrc.size() != patternDest.size()) return false;\r
1113 \r
1114   QMapIterator<AbstractInterface*, QList<char>* > iterSrc(patternSrc);\r
1115   QListIterator<int> iterSrcCol(srcCols);\r
1116   QMapIterator<AbstractInterface*, QList<char>* > iterDest(patternDest);\r
1117   while (iterSrc.hasNext()) {\r
1118     iterSrc.next();\r
1119     int srcCol = iterSrcCol.next();\r
1120     iterDest.next();\r
1121     QList<char>* srcPat = iterSrc.value();\r
1122     QList<char>* destPat = iterDest.value();\r
1123     if (srcCol >= srcPat->size()) return false;\r
1124     if (destCol >= destPat->size()) return false;\r
1125     if (srcPat->at(srcCol) != destPat->at(destCol)) return false;\r
1126   }\r
1127   return true;\r
1128 }\r
1129 \r
1130 bool FunctionalBlock::canCombinePatterns(const QMap<AbstractInterface*, QList<char>* >& patternSrc, int srcCol, QMap<AbstractInterface*, QList<char>* > patternDest, int destCol) {\r
1131   if (patternSrc.size() != patternDest.size()) return false;\r
1132   QMapIterator<AbstractInterface*, QList<char>* > iterSrc(patternSrc);\r
1133   QMapIterator<AbstractInterface*, QList<char>* > iterDest(patternDest);\r
1134   while (iterSrc.hasNext()) {\r
1135     iterSrc.next();\r
1136     iterDest.next();    \r
1137     QList<char>* srcPat = iterSrc.value();\r
1138     QList<char>* destPat = iterDest.value();\r
1139     if (srcCol >= srcPat->size()) return false;\r
1140     if (destCol >= destPat->size()) return false;\r
1141     if ((srcPat->at(srcCol) == -1) && (destPat->at(destCol) == 1)) return false;\r
1142     if ((srcPat->at(srcCol) == 1) && (destPat->at(destCol) == -1)) return false;\r
1143   }\r
1144   return true;\r
1145 }\r
1146 \r
1147 void FunctionalBlock::combinePatterns(const QMap<AbstractInterface*, QList<char>* >& patternSrc, int srcCol, QMap<AbstractInterface*, QList<char>* > patternDest, int destCol) {\r
1148   if (patternSrc.size() != patternDest.size()) return;\r
1149   QMapIterator<AbstractInterface*, QList<char>* > iterSrc(patternSrc);\r
1150   QMapIterator<AbstractInterface*, QList<char>* > iterDest(patternDest);\r
1151   while (iterSrc.hasNext()) {\r
1152     iterSrc.next();\r
1153     iterDest.next();    \r
1154     QList<char>* srcPat = iterSrc.value();\r
1155     QList<char>* destPat = iterDest.value();\r
1156     if (srcCol >= srcPat->size()) return;\r
1157     if (destCol >= destPat->size()) return;\r
1158     if ((srcPat->at(srcCol) == -1) && (destPat->at(destCol) == 1)) return;\r
1159     if ((srcPat->at(srcCol) == 1) && (destPat->at(destCol) == -1)) return;    \r
1160     destPat->replace(destCol,destPat->at(destCol) | srcPat->at(srcCol));\r
1161   }  \r
1162 }\r
1163 \r
1164 void FunctionalBlock::appendToPattern(const QMap<AbstractInterface*, QList<char>* >& patternSrc, int srcCol, QMap<AbstractInterface*, QList<char>* > patternDest, int nbCols) {\r
1165   if (patternSrc.size() != patternDest.size()) return;\r
1166   QMapIterator<AbstractInterface*, QList<char>* > iterSrc(patternSrc);\r
1167   QMapIterator<AbstractInterface*, QList<char>* > iterDest(patternDest);\r
1168   while (iterSrc.hasNext()) {\r
1169     iterSrc.next();\r
1170     iterDest.next();    \r
1171     QList<char>* srcPat = iterSrc.value();\r
1172     QList<char>* destPat = iterDest.value();    \r
1173     int i=0;\r
1174     while ((srcCol+i < srcPat->size()) && (i<nbCols)) {\r
1175       destPat->append(srcPat->at(srcCol+i));\r
1176       i++;\r
1177     }\r
1178   }  \r
1179 }\r
1180 \r
1181 void FunctionalBlock::removeDataGroup(QMap<AbstractInterface *, QList<char> *> &pattern, int offset) {\r
1182   QMapIterator<AbstractInterface*, QList<char>* > iterSrc(pattern);  \r
1183   while (iterSrc.hasNext()) {\r
1184     iterSrc.next();    \r
1185     QList<char>* srcPat = iterSrc.value();\r
1186     if (offset < srcPat->size()) {\r
1187       srcPat->removeAt(offset);\r
1188     }\r
1189   }\r
1190 }\r
1191 \r
1192 void FunctionalBlock::shiftRightPattern(const QMap<AbstractInterface *, QList<char> *> &pattern, int offset) {\r
1193   QMapIterator<AbstractInterface*, QList<char>* > iterSrc(pattern);  \r
1194   while (iterSrc.hasNext()) {\r
1195     iterSrc.next();    \r
1196     QList<char>* srcPat = iterSrc.value();\r
1197     if (offset < srcPat->size()) {\r
1198       srcPat->insert(offset,0);\r
1199     }\r
1200   }\r
1201 }\r
1202 \r
1203 bool FunctionalBlock::isValidDataGroup(const QMap<AbstractInterface *, QList<char> *> &pattern, int offset) {\r
1204   QMapIterator<AbstractInterface*, QList<char>* > iterSrc(pattern);  \r
1205   while (iterSrc.hasNext()) {\r
1206     iterSrc.next();    \r
1207     QList<char>* srcPat = iterSrc.value();\r
1208     if (offset >= srcPat->size()) return false;\r
1209     if (srcPat->at(offset) == 1) return true;\r
1210   }\r
1211   return false;\r
1212 }\r
1213 \r
1214 bool FunctionalBlock::isValidDataGroup(const QMap<AbstractInterface*, QList<char>* >& pattern, const QList<int> offsets) {\r
1215   QMapIterator<AbstractInterface*, QList<char>* > iterSrc(pattern);\r
1216   QListIterator<int> iterOffsets(offsets);\r
1217   while (iterSrc.hasNext()) {\r
1218     iterSrc.next();\r
1219     int offset = iterOffsets.next();\r
1220     QList<char>* srcPat = iterSrc.value();\r
1221     if (offset >= srcPat->size()) return false;\r
1222     if (srcPat->at(offset) == 1) return true;\r
1223   }\r
1224   return false;\r
1225 }\r
1226 \r
1227 bool FunctionalBlock::isOnlyXDataGroup(const QMap<AbstractInterface *, QList<char> *> &pattern, int offset) {\r
1228   QMapIterator<AbstractInterface*, QList<char>* > iterSrc(pattern);  \r
1229   while (iterSrc.hasNext()) {\r
1230     iterSrc.next();    \r
1231     QList<char>* srcPat = iterSrc.value();\r
1232     if (offset >= srcPat->size()) return false;\r
1233     if (srcPat->at(offset) != -1) return false;\r
1234   }\r
1235   return true;  \r
1236 }\r
1237 \r
1238 void FunctionalBlock::clearConsumptionPattern() {\r
1239   QMapIterator<AbstractInterface*, QList<char>* > iterP(consumptionPattern);  \r
1240   while (iterP.hasNext()) {\r
1241     iterP.next();\r
1242     QList<char>* pattern = iterP.value();\r
1243     if (pattern != NULL) delete pattern;\r
1244   }\r
1245   consumptionPattern.clear();\r
1246   lengthCP = -1;      \r
1247 }  \r
1248 \r
1249 void FunctionalBlock::clearProductionPattern() {\r
1250   QMapIterator<AbstractInterface*, QList<char>* > iterP(productionPattern);  \r
1251   while (iterP.hasNext()) {\r
1252     iterP.next();\r
1253     QList<char>* pattern = iterP.value();\r
1254     if (pattern != NULL) delete pattern;\r
1255   }\r
1256   productionPattern.clear();\r
1257   lengthPP = -1;\r
1258 }  \r
1259 \r
1260 void FunctionalBlock::clearInputPattern() {\r
1261   \r
1262   QMapIterator<AbstractInterface*,QList<char>* > iterI(inputPattern);\r
1263   while (iterI.hasNext()) {\r
1264     iterI.next();\r
1265     QList<char>* pattern = iterI.value();\r
1266     if (pattern != NULL) delete pattern;\r
1267   }\r
1268   inputPattern.clear();\r
1269   lengthIP = -1;\r
1270 }\r
1271 \r
1272 void FunctionalBlock::clearOutputPattern() {\r
1273 \r
1274   QMapIterator<AbstractInterface*,QList<char>* > iterO(outputPattern);\r
1275   while (iterO.hasNext()) {\r
1276     iterO.next();\r
1277     ConnectedInterface* connIface = AI_TO_CON(iterO.key());\r
1278     connIface->resetOutputPattern();\r
1279     QList<char>* pattern = iterO.value();\r
1280     if (pattern != NULL) delete pattern;\r
1281   }\r
1282   outputPattern.clear();\r
1283   lengthOP = -1;\r
1284 }\r
1285 \r
1286 void FunctionalBlock::clearAdmittanceDelays() {\r
1287   QMapIterator<AbstractInterface*, QList<int>* > iterA(admittanceDelays);\r
1288   while (iterA.hasNext()) {\r
1289     iterA.next();\r
1290     QList<int>* d = iterA.value();\r
1291     if (d != NULL) delete d;\r
1292   }\r
1293   admittanceDelays.clear();\r
1294 }\r
1295 \r
1296 int FunctionalBlock::createTriggers() {\r
1297   triggers.clear();\r
1298   /* NB: this method returns the number of executions that have been started\r
1299      but not necessary completed.\r
1300   */\r
1301   if (delta <= 0) return 0;  \r
1302   int offset = 0;\r
1303   // search for the first exec.\r
1304   while ((offset < lengthIP) && (! isValidDataGroup(inputPattern,offset))) offset++;\r
1305   if (offset == lengthIP) return 0;\r
1306   triggers.append(offset);  \r
1307   int nbGroup = 0;\r
1308   for(int i = offset;i<lengthIP;i++) {\r
1309     if (isValidDataGroup(inputPattern,i)) nbGroup++;\r
1310     if (nbGroup == delta+1) {\r
1311       triggers.append(i);\r
1312       nbGroup = 1;\r
1313     }\r
1314   }      \r
1315   return triggers.size();\r
1316 }\r
1317 \r
1318 QList<QString> FunctionalBlock::getExternalResources() {\r
1319 \r
1320   BlockImplementation* impl = reference->getImplementations().at(0); // for now only take first impl available\r
1321   QList<QString> list = impl->getResources();\r
1322   foreach(QString s, list) {\r
1323     cout << qPrintable(s) << " ";\r
1324   }\r
1325   cout << endl;\r
1326 \r
1327   return list;\r
1328 }\r
1329 \r
1330 \r
1331 void FunctionalBlock::generateVHDL(const QString& path) throw(Exception){\r
1332     \r
1333   BlockImplementation* impl = reference->getImplementations().at(0); // for now only take first impl available  \r
1334 \r
1335   QFile implFile(impl->getXmlFile());\r
1336 \r
1337   // reading in into QDomDocument\r
1338   QDomDocument document("implFile");\r
1339 \r
1340   if (!implFile.open(QIODevice::ReadOnly)) {\r
1341     throw(Exception(IMPLFILE_NOACCESS));\r
1342   }\r
1343   if (!document.setContent(&implFile)) {\r
1344     implFile.close();\r
1345     throw(Exception(IMPLFILE_NOACCESS));\r
1346   }\r
1347   implFile.close();\r
1348 \r
1349   bool genController = false;\r
1350   QString coreFile = "";\r
1351   QString controllerFile = "";\r
1352 \r
1353   if (reference->isWBConfigurable()) {\r
1354     genController = true;\r
1355     controllerFile = path;\r
1356     controllerFile += "/";\r
1357     controllerFile.append(name);\r
1358     controllerFile.append("_ctrl.vhd");    \r
1359   }\r
1360   else {\r
1361     controllerFile = "nofile.vhd";    \r
1362   }\r
1363   coreFile = path;\r
1364   coreFile += "/";\r
1365   coreFile.append(name);\r
1366   coreFile.append(".vhd");\r
1367 \r
1368   QFile vhdlCore(coreFile);\r
1369   QFile vhdlController(controllerFile);\r
1370 \r
1371   if (!vhdlCore.open(QIODevice::WriteOnly)) {\r
1372     throw(Exception(VHDLFILE_NOACCESS));\r
1373   }\r
1374 \r
1375   if (genController) {\r
1376     if (!vhdlController.open(QIODevice::WriteOnly)) {\r
1377       throw(Exception(VHDLFILE_NOACCESS));\r
1378     }\r
1379   }\r
1380   QTextStream outCore(&vhdlCore);\r
1381   QTextStream outController;\r
1382   if (genController) {\r
1383     outController.setDevice(&vhdlController);\r
1384   }\r
1385 \r
1386   try {\r
1387     //Get the root element\r
1388     QDomElement impl = document.documentElement();\r
1389     QDomElement eltComments = impl.firstChildElement("comments");\r
1390     generateComments(outCore,eltComments, coreFile);\r
1391     QDomElement eltLibs = eltComments.nextSiblingElement("libraries");\r
1392     generateLibraries(outCore, eltLibs);\r
1393     generateEntity(outCore, genController);\r
1394     QDomElement eltArch = eltLibs.nextSiblingElement("architecture");\r
1395     generateArchitecture(outCore, eltArch );\r
1396     if (genController) {\r
1397       generateController(outController);\r
1398     }\r
1399   }\r
1400   catch(Exception err) {\r
1401     throw(err);\r
1402   }\r
1403 \r
1404   vhdlCore.close();\r
1405   vhdlController.close();\r
1406   \r
1407  }\r
1408 \r
1409 void FunctionalBlock::generateComments(QTextStream& out, QDomElement &elt, QString coreFile) throw(Exception) {\r
1410 \r
1411   for(int i = 0; i < 50; i++) {\r
1412     out << "--";\r
1413   }\r
1414   out << "\n--" << endl;\r
1415   QString fileName = coreFile;\r
1416   out << "--  File        : " << fileName << endl;\r
1417   out << "--" << endl;\r
1418   QDomElement eltAuthor = elt.firstChildElement("author");\r
1419   QString firstName = eltAuthor.attribute("firstname","");\r
1420   QString lastName = eltAuthor.attribute("lastname","");\r
1421   QString mail = eltAuthor.attribute("mail","");\r
1422   out << "--  Author(s)   : "<<firstName+" "<<lastName<<" ("<<mail<<")" << endl;\r
1423   out << "--" << endl;\r
1424   QDomElement eltDate = eltAuthor.nextSiblingElement("date");\r
1425   QString crea = eltDate.attribute("creation","");\r
1426   out << "--  Creation Date   : "<<crea<< endl;\r
1427   out << "--" << endl;\r
1428   QDomElement eltRelated = eltDate.nextSiblingElement("related_files");\r
1429   QString relateds = eltRelated.attribute("list","");\r
1430   out << "--  Related files   :\n"<<relateds<<endl;\r
1431   out << "--" << endl;\r
1432   QDomElement eltDesc = eltRelated.nextSiblingElement("description");\r
1433   QDomElement desc = eltDesc.firstChildElement();\r
1434   QString descTxt = desc.text();\r
1435   out << "--  Decription      :\n"<<descTxt<<endl;\r
1436   out << "--" << endl;\r
1437   QDomElement eltNote = eltDesc.nextSiblingElement("description");\r
1438   QDomElement note = eltNote.firstChildElement();\r
1439   QString noteTxt = note.text();\r
1440   out << "--  Note          :\n"<<noteTxt<<endl;\r
1441   out << "--" << endl;\r
1442   for(int i = 0; i < 50; i++) {\r
1443     out << "--";\r
1444   }\r
1445   out << endl << endl;\r
1446 }\r
1447 \r
1448 void FunctionalBlock::generateLibraries(QTextStream& out, QDomElement &elt) throw(Exception) {\r
1449   \r
1450   QDomNodeList listLib = elt.elementsByTagName("library");\r
1451   for(int i = 0; i < listLib.length(); i++) {\r
1452     QDomNode nodeLib = listLib.item(i);\r
1453     QDomElement eltLib = nodeLib.toElement();\r
1454     QString nameLib = eltLib.attribute("name","none");\r
1455     out << "library " << nameLib << ";" << endl;\r
1456     QDomNodeList listPack = eltLib.elementsByTagName("package");\r
1457     for(int j = 0; j < listPack.length(); j++) {\r
1458       QDomNode nodePack = listPack.item(j);\r
1459       QDomElement eltPack = nodePack.toElement();\r
1460       QString namePack = eltPack.attribute("name","none");\r
1461       QString usePack = eltPack.attribute("use","none");\r
1462       out << "use " << nameLib << "." << namePack << "." << usePack << ";" << endl;\r
1463     }\r
1464     out << endl;\r
1465   }\r
1466 }\r
1467 \r
1468 \r
1469 void FunctionalBlock::generateEntityOrComponentBody(QTextStream& out, int indentLevel, bool hasController) throw(Exception) {\r
1470 \r
1471   int i=0;\r
1472   QString indent = "";\r
1473   for(i=0;i<indentLevel;i++) {\r
1474     indent += " ";\r
1475   }\r
1476   \r
1477   //QList<BlockParameter*> listParams = reference->getParameters();\r
1478   QList<AbstractInterface*> listInputs = getInputs();\r
1479   QList<AbstractInterface*> listOutputs = getOutputs();\r
1480   QList<AbstractInterface*> listBidirs = getBidirs();    \r
1481 \r
1482   // Generation of the generics\r
1483   QList<BlockParameter*> listGenerics = getGenericParameters();\r
1484   if ((!listGenerics.isEmpty()) || (hasController)) {\r
1485     out << indent << "  generic (" << endl;\r
1486     if (hasController) {\r
1487       out << indent << "    wb_data_width : integer = 16;" << endl;\r
1488       out << indent << "    wb_addr_width : integer = 12";\r
1489       if (!listGenerics.isEmpty()) out << indent << ";";\r
1490       out << endl;\r
1491     }\r
1492     for(i=0;i<listGenerics.size()-1;i++) {\r
1493       out << indent << "    " << listGenerics.at(i)->toVHDL(BlockParameter::Entity, 0) << endl;\r
1494     }\r
1495     out << indent << "    " << listGenerics.at(i)->toVHDL(BlockParameter::Entity,BlockParameter::NoComma) << endl;\r
1496 \r
1497     out << indent << "    );" << endl;\r
1498   }\r
1499 \r
1500   out << indent << "  port (" << endl;\r
1501 \r
1502   QString ports = "";\r
1503   QTextStream outPorts(&ports);\r
1504 \r
1505   // Generation of the clk & rst signals\r
1506   outPorts << indent << "    -- clk/rst" << endl;\r
1507   foreach(AbstractInterface* iface, listInputs) {\r
1508     if(iface->getPurpose() == AbstractInterface::Clock || iface->getPurpose() == AbstractInterface::Reset) {\r
1509       outPorts << indent << "    " << iface->getName() << " : in std_logic;" << endl;\r
1510     }\r
1511   }\r
1512   foreach(AbstractInterface* iface, listOutputs) {\r
1513     if(iface->getPurpose() == AbstractInterface::Clock || iface->getPurpose() == AbstractInterface::Reset) {\r
1514       outPorts << indent << "    " << iface->getName() << " : out std_logic;" << endl;\r
1515     }\r
1516   }\r
1517 \r
1518   if (hasController) {\r
1519     // Generation of the wishbone signals\r
1520     outPorts << indent << "    -- registers r/w via wishbone" << endl;\r
1521     QList<BlockParameter*> listWB = reference->getWishboneParameters();\r
1522     for(i=0;i<listWB.size()-1;i++) {\r
1523       outPorts << indent << "    " << listWB.at(i)->toVHDL(BlockParameter::Entity, 0) << endl;\r
1524     }\r
1525     outPorts << indent << "    " << listWB.at(i)->toVHDL(BlockParameter::Entity,BlockParameter::NoComma) << endl;\r
1526   }\r
1527 \r
1528   // Generation of the data/control signals\r
1529 \r
1530   QList<AbstractInterface*> listIface = getInterfaces(AbstractInterface::Input, AbstractInterface::Data);\r
1531   if (listIface.size()>0) {\r
1532     outPorts << indent << "    -- input data ports" << endl;\r
1533     foreach(AbstractInterface* iface, listIface) {\r
1534       outPorts << indent << "    " << iface->toVHDL(AbstractInterface::Entity, 0) << endl;\r
1535     }\r
1536   }\r
1537   listIface = getInterfaces(AbstractInterface::Input, AbstractInterface::Control);\r
1538   if (listIface.size()>0) {\r
1539     outPorts << indent << "    -- input control ports" << endl;\r
1540     foreach(AbstractInterface* iface, listIface) {\r
1541       outPorts << indent << "    " << iface->toVHDL(AbstractInterface::Entity, 0) << endl;\r
1542     }\r
1543   }\r
1544   listIface = getInterfaces(AbstractInterface::Output, AbstractInterface::Data);\r
1545   if (listIface.size()>0) {\r
1546     outPorts << indent << "    -- output data ports" << endl;\r
1547     foreach(AbstractInterface* iface, listIface) {\r
1548       outPorts << indent << "    " << iface->toVHDL(AbstractInterface::Entity, 0) << endl;\r
1549     }\r
1550   }\r
1551   listIface = getInterfaces(AbstractInterface::Output, AbstractInterface::Control);\r
1552   if (listIface.size()>0) {\r
1553     outPorts << indent << "    -- output control ports" << endl;\r
1554     foreach(AbstractInterface* iface, listIface) {\r
1555       outPorts << indent << "    " << iface->toVHDL(AbstractInterface::Entity, 0) << endl;\r
1556     }\r
1557   }\r
1558   listIface = getInterfaces(AbstractInterface::InOut, AbstractInterface::Data);\r
1559   if (listIface.size()>0) {\r
1560     outPorts << indent << "    -- bidirs data ports" << endl;\r
1561     foreach(AbstractInterface* iface, listIface) {\r
1562       outPorts << indent << "    " << iface->toVHDL(AbstractInterface::Entity, 0) << endl;\r
1563     }\r
1564   }\r
1565 \r
1566   ports.chop(2);\r
1567   ports += "\n";\r
1568   out << ports;\r
1569   out << indent << "    );" << endl << endl;\r
1570 \r
1571 }\r
1572 \r
1573 void FunctionalBlock::generateArchitecture(QTextStream& out, QDomElement &elt ) throw(Exception) {\r
1574   QRegularExpression rxPort("@\\{([a-zA-Z0-9_]+)\\}");\r
1575   QString expr;\r
1576   QString code = elt.text();\r
1577   //cout << qPrintable(code) << endl;\r
1578   out << "architecture rtl of " << name << " is" << endl;\r
1579 \r
1580   QStringList listLine = code.split("\n");\r
1581   for(int i =0; i < listLine.size(); i++) {\r
1582     QString line = listLine.at(i).simplified();\r
1583 \r
1584     /*\r
1585     if(listLine.at(i).contains(QRegularExpression("@foreach{"))) {\r
1586       while(listLine.at(i).compare("@endforeach") != -1) {\r
1587         expr = expr + listLine.at(i) + '\n';\r
1588         i++;\r
1589       }\r
1590       expr = expr + listLine.at(i);\r
1591       out << evalComplex(expr, 1) << '\n';\r
1592     }\r
1593     if(listLine.at(i).contains(QRegularExpression("@caseeach{"))) {\r
1594       while(listLine.at(i).compare("@endcaseeach") != -1) {\r
1595         expr = expr + listLine.at(i) + '\n';\r
1596         i++;\r
1597       }\r
1598       expr = expr + listLine.at(i);\r
1599       out << evalComplex(expr, 2) << '\n';\r
1600     }\r
1601 */\r
1602     if(line.contains("@{")) {\r
1603       QMap<QString,QString> modifs;\r
1604       //cout << qPrintable(line) << endl;\r
1605       QRegularExpressionMatchIterator matchPort = rxPort.globalMatch(line);\r
1606       while(matchPort.hasNext()) {\r
1607         QRegularExpressionMatch m = matchPort.next();\r
1608         QString refName = m.captured(1);\r
1609         AbstractInterface* refIface = reference->getIfaceFromName(refName);\r
1610         QString funName = getIfaceUserName(refIface);\r
1611         if (!funName.isEmpty()) {\r
1612           modifs.insert(m.captured(0),funName);\r
1613           //cout << "replace " << qPrintable(refIface->getName()) << " by " << qPrintable(funIface->getName()) << endl;\r
1614         }\r
1615       }\r
1616       QMapIterator<QString,QString> iterM(modifs);\r
1617       while(iterM.hasNext()) {\r
1618         iterM.next();\r
1619         QString oldName = iterM.key();\r
1620         QString newName = iterM.value();\r
1621         line.replace(oldName,newName);\r
1622       }\r
1623     }\r
1624     out << line << endl;\r
1625   }\r
1626 \r
1627   out << "end rtl;" << endl;\r
1628 }\r
1629 \r
1630 void FunctionalBlock::generateController(QTextStream &out) throw(Exception) {\r
1631   \r
1632 }\r
1633 \r
1634 QString FunctionalBlock::getIfaceUserName(AbstractInterface* refIface) {\r
1635 \r
1636   if (! refIface->isReferenceInterface()) return "";\r
1637 \r
1638   AbstractInterface* funcIface = NULL;\r
1639 \r
1640   if (refIface->getDirection() == AbstractInterface::Input) {\r
1641     foreach(AbstractInterface* iface, getInputs()) {\r
1642       FunctionalInterface* fi = AI_TO_FUN(iface);\r
1643       if (fi->getReference() == refIface) {\r
1644         funcIface = iface;\r
1645         break;\r
1646       }\r
1647     }\r
1648   }\r
1649   else if (refIface->getDirection() == AbstractInterface::Output) {\r
1650     foreach(AbstractInterface* iface, getOutputs()) {\r
1651       FunctionalInterface* fi = AI_TO_FUN(iface);\r
1652       if (fi->getReference() == refIface) {\r
1653         funcIface = iface;\r
1654         break;\r
1655       }\r
1656     }\r
1657   }\r
1658   else if (refIface->getDirection() == AbstractInterface::InOut) {\r
1659     foreach(AbstractInterface* iface, getBidirs()) {\r
1660       FunctionalInterface* fi = AI_TO_FUN(iface);\r
1661       if (fi->getReference() == refIface) {\r
1662         funcIface = iface;\r
1663         break;\r
1664       }\r
1665     }\r
1666   }\r
1667   if (funcIface == NULL) return "";\r
1668 \r
1669   return funcIface->getName();\r
1670 }\r
1671 \r