GroupBlock.cpp

   1 #include "GroupBlock.h"
   2 #include "BlockParameterGeneric.h"
   3 #include "AbstractInterface.h"
   4 #include "ConnectedInterface.h"
   5 #include "GroupInterface.h"
   6 #include "string.h"
   7 #include <sstream>
   8 #include "Parameters.h"
   9 #include "DelayInputModifier.h"
  10
  11 int GroupBlock::counter = 1;
  12
  13 GroupBlock::GroupBlock(GroupBlock *_parent, bool createIfaces) throw(Exception) :  AbstractBlock() {
  14
  15   GroupInterface* clk = NULL;
  16   GroupInterface* rst = NULL;
  17
  18   // force topGroup to false if this group has a parent
  19   if (_parent != NULL) {
  20     topGroup = false;
  21     name = QString("sub_group")+"_"+QString::number(counter++);
  22     // creating clk/rst interfaces
  23     clk = new GroupInterface(this,"clk", AbstractInterface::Input, AbstractInterface::Clock);
  24     rst = new GroupInterface(this,"reset", AbstractInterface::Input, AbstractInterface::Reset);
  25     addInterface(clk);
  26     addInterface(rst);
  27
  28     try {
  29       connectClkReset();
  30     }
  31     catch(Exception e) {
  32       AbstractBlock* source = (AbstractBlock *)(e.getSource());
  33       cerr << qPrintable(source->getName()) << ":" << qPrintable(e.getMessage()) << endl;
  34       throw(e);
  35     }
  36   }
  37   else {
  38     topGroup = true;
  39     name = QString("top_group");
  40     // creating external clk/rst interfaces
  41     clk = new GroupInterface(this,"ext_clk", AbstractInterface::Input, AbstractInterface::Clock);
  42     rst = new GroupInterface(this,"ext_reset", AbstractInterface::Input, AbstractInterface::Reset);
  43     addInterface(clk);
  44     addInterface(rst);
  45     // creating clkrstgen block and connecting it to this: done in Dispatcher since this has no access to library
  46     cout << "created ext_clk and reset ifaces for top group" << endl;
  47   }
  48   parent = _parent;
  49
  50 }
  51
  52 GroupBlock::~GroupBlock() {
  53   foreach(AbstractBlock* block, blocks) {
  54     delete block;
  55   }
  56 }
  57
  58 bool GroupBlock::isGroupBlock() {
  59   return true;
  60 }
  61
  62 bool GroupBlock::isTopGroupBlock() {
  63   return topGroup;
  64 }
  65
  66 void GroupBlock::setParent(AbstractBlock *_parent) {
  67   parent = _parent;
  68   if (parent != NULL) {
  69     topGroup = false;
  70   }
  71 }
  72
  73 void GroupBlock::removeAllBlocks() {
  74   foreach(AbstractBlock* block, blocks) {
  75     if (block->isGroupBlock()) {
  76       GroupBlock* group = AB_TO_GRP(block);
  77       group->removeAllBlocks();
  78     }
  79     removeBlock(block);
  80   }
  81 }
  82
  83 void GroupBlock::removeBlock(AbstractBlock* block) {
  84   /* CAUTION: no check is done if the block has connected interface
  85      or not. Thus, they must be deleted elsewhere.
  86   */
  87   blocks.removeAll(block);
  88   delete block;
  89 }
  90
  91 AbstractBlock *GroupBlock::getFunctionalBlockByName(QString name) {
  92   foreach(AbstractBlock* block, blocks) {
  93     if (block->isFunctionalBlock()) {
  94       if (block->getName() == name) return block;
  95     }
  96   }
  97   return NULL;
  98 }
  99
 100 void GroupBlock::parametersValidation(QList<AbstractBlock *> *checkedBlocks, QList<AbstractBlock *> *blocksToConfigure) {
 101
 102   /*
 103   checkedBlocks->append(this);
 104
 105   foreach(BlockParameter* param, params){
 106     if(param->isUserParameter() && !param->isValueSet()){
 107       if(!blocksToConfigure->contains(param->getOwner())){
 108         blocksToConfigure->append(param->getOwner());
 109       }
 110     }
 111   }
 112   foreach(AbstractInterface *inter, outputs){
 113     foreach(AbstractInterface *connectedInter, inter->getConnectedTo()){
 114       if(!checkedBlocks->contains(connectedInter->getOwner())){
 115         connectedInter->getOwner()->parametersValidation(checkedBlocks, blocksToConfigure);
 116       }
 117     }
 118   }
 119   */
 120 }
 121
 122 void GroupBlock::addGenericParameter(QString name, QString type, QString value) {
 123   BlockParameter* param = new BlockParameterGeneric(this, name, type, value);
 124   params.append(param);
 125 }
 126
 127 void GroupBlock::removeGenericParameter(QString name) {
 128   BlockParameter* p = getParameterFromName(name);
 129   if (p != NULL) params.removeAll(p);
 130 }
 131
 132 void GroupBlock::createInputPattern() {
 133   foreach(AbstractInterface* iface, getControlInputs()) {
 134     ConnectedInterface* connIface = AI_TO_CON(iface);
 135     QList<char>* pattern = new QList<char>(*(connIface->getConnectedFrom()->getOutputPattern()));
 136     connIface->setOutputPattern(pattern);
 137   }
 138 }
 139
 140 void GroupBlock::computeAdmittanceDelays() throw(Exception) {
 141   throw(Exception(INVALID_GROUPBLOCK_USE));
 142 }
 143
 144 void GroupBlock::checkInputPatternCompatibility()  throw(Exception){
 145   throw(Exception(INVALID_GROUPBLOCK_USE));
 146 }
 147
 148
 149 void GroupBlock::computeOutputPattern(int nbExec) throw(Exception) {
 150
 151   static QString fctName = "GroupBlock::computeOutputPattern()";
 152 #ifdef DEBUG_FCTNAME
 153   cout << "call to " << qPrintable(fctName) << endl;
 154 #endif
 155
 156   cout << "computing output pattern of group " << qPrintable(name) << endl;
 157
 158   bool canCompute = false;
 159   // get the input pattern on each inputs
 160   createInputPattern();
 161
 162   cout << "Input pattern OK" << endl;
 163   // find blocks that are connected to that inputs and generators
 164   QList<AbstractBlock*> fifo;
 165   foreach(AbstractBlock* block, blocks) {
 166
 167     bool addIt = false;
 168     // if a block is a generator and has control outputs, add it
 169     if (block->isGeneratorBlock()) {
 170       if (block->getControlOutputs().size() > 0) addIt = true;
 171     }
 172     else {
 173       // if the block has all its connected control inputs that are connected to an intput of the group, add it too
 174       if (block->getControlInputs().size() > 0) {
 175         addIt = true;
 176         foreach(AbstractInterface* iface, block->getControlInputs()) {
 177           //cout << qPrintable(iface->getName()) << " of " << qPrintable(iface->getOwner()->getName()) << " connected to " << endl;
 178           ConnectedInterface* connFrom = ((ConnectedInterface*)iface)->getConnectedFrom();
 179           //cout << qPrintable(connFrom->getName()) << " of " << qPrintable(connFrom->getOwner()->getName()) << endl;
 180
 181           if (connFrom == NULL) {
 182             addIt = false;
 183             break;
 184           }
 185           else if (connFrom->getOwner() != this) {
 186             addIt = false;
 187             break;
 188           }
 189         }
 190       }
 191     }
 192     if (addIt) {
 193       cout << "adding " << qPrintable(block->getName()) << " to initialize the FIFO" << endl;
 194       block->setTraversalLevel(0); // level 0 = first blocks to be evaluated
 195       fifo.append(block);
 196     }
 197   }
 198
 199   while (!fifo.isEmpty()) {
 200     AbstractBlock* block = fifo.takeFirst();
 201
 202     if (block->getPatternComputed()) continue; // block has already been processed
 203
 204     cout << "computing compat and output for " << qPrintable(block->getName()) << endl;
 205
 206
 207     try {
 208       block->checkInputPatternCompatibility();
 209     }
 210     catch(Exception e) {
 211       cout << qPrintable(block->getName()) << " is not compatible with its input pattern" << endl;
 212       throw(e);
 213     }
 214
 215     try {
 216       block->computeOutputPattern();
 217     }
 218     catch(Exception e) {
 219       cout << "cannot finalize output pattern computation of " << qPrintable(block->getName()) << endl;
 220       throw(e);
 221     }
 222     canCompute = true;
 223     block->setPatternComputed(true);
 224     /* add other blocks connected from block to the fifo but only if
 225        all their connected inputs are connected to blocks that have
 226        a traversalLevel >=0
 227      */
 228     foreach(AbstractInterface* iface, block->getControlOutputs()) {
 229       ConnectedInterface* conn = (ConnectedInterface*)iface;
 230       foreach(ConnectedInterface* connTo, conn->getConnectedTo()) {
 231
 232         AbstractBlock* block1 = connTo->getOwner();
 233         cout << "testing if " << qPrintable(block1->getName()) << " has all connected inputs connected to already processed blocks" << endl;
 234         bool addIt = true;
 235         int maxLevel = 0;
 236
 237         foreach(AbstractInterface* iface, block1->getControlInputs()) {
 238           //cout << qPrintable(iface->getName()) << " of " << qPrintable(iface->getOwner()->getName()) << " connected to " << endl;
 239           ConnectedInterface* connFrom = ((ConnectedInterface*)iface)->getConnectedFrom();
 240           //cout << qPrintable(connFrom->getName()) << " of " << qPrintable(connFrom->getOwner()->getName()) << endl;
 241
 242           if ((connFrom != NULL) && (connFrom->getOwner()->getPatternComputed() == false)) {
 243             addIt = false;
 244             break;
 245           }
 246           else {
 247             if (connFrom->getOwner()->getTraversalLevel() > maxLevel) maxLevel = connFrom->getOwner()->getTraversalLevel();
 248           }
 249         }
 250
 251         if (addIt) {
 252           cout << "adding " << qPrintable(block1->getName()) << " to the FIFO" << endl;
 253           block1->setTraversalLevel(maxLevel+1); // level 0 = first blocks to be evaluated
 254           fifo.append(block1);
 255         }
 256       }
 257     }
 258   }
 259
 260   if (canCompute) {
 261     foreach(AbstractInterface* iface, getControlOutputs()) {
 262       ConnectedInterface* connIface = AI_TO_CON(iface);
 263       QList<char>* pattern = new QList<char>(*(connIface->getConnectedFrom()->getOutputPattern()));
 264       connIface->setOutputPattern(pattern);
 265     }
 266     setPatternComputed(true);
 267   }
 268 }
 269
 270 QList<QString> GroupBlock::getExternalResources() {
 271
 272   QList<QString> list;
 273   foreach(AbstractBlock* block, blocks) {
 274     list.append(block->getExternalResources());
 275   }
 276   return list;
 277 }
 278
 279 void GroupBlock::generateVHDL(const QString& path) throw(Exception) {
 280
 281   QString coreFile = "";
 282
 283   coreFile = path;
 284   coreFile.append(Parameters::normalizeName(name));
 285   coreFile.append(".vhd");
 286
 287   QFile vhdlCore(coreFile);
 288
 289   if (!vhdlCore.open(QIODevice::WriteOnly)) {
 290     throw(Exception(VHDLFILE_NOACCESS));
 291   }
 292
 293   cout << "generate VHDL of block " << qPrintable(name) << " in " << qPrintable(coreFile) << endl;
 294   QTextStream outCore(&vhdlCore);
 295
 296   QDomElement dummyElt;
 297   try {
 298     generateComments(outCore,dummyElt,"");
 299     generateLibraries(outCore,dummyElt);
 300     generateEntity(outCore);
 301     generateArchitecture(outCore,dummyElt);
 302
 303     foreach(AbstractBlock* block, blocks) {
 304       block->generateVHDL(path);
 305     }
 306   }
 307   catch(Exception err) {
 308     throw(err);
 309   }
 310
 311   vhdlCore.close();
 312 }
 313
 314
 315 void GroupBlock::generateComments(QTextStream& out, QDomElement &elt, QString coreFile) throw(Exception) {
 316   out << " -- VHDL generated automatically for " << name << " --" << endl << endl;
 317 }
 318
 319 void GroupBlock::generateLibraries(QTextStream& out, QDomElement &elt) throw(Exception) {
 320
 321   out << "library IEEE;" << endl;
 322   out << "use IEEE.STD_LOGIC_1164.all;" << endl;
 323   out << "use IEEE.numeric_std.all;" << endl;
 324
 325 }
 326
 327 void GroupBlock::generateEntityOrComponentBody(QTextStream& out, int indentLevel, bool hasController) throw(Exception) {
 328
 329   int i;
 330   QString indent = "";
 331   for(i=0;i<indentLevel;i++) {
 332     indent += " ";
 333   }
 334
 335   QList<BlockParameter*> listGenerics = getGenericParameters();
 336   QList<AbstractInterface*> listInputs = getInputs();
 337   QList<AbstractInterface*> listOutputs = getOutputs();
 338   QList<AbstractInterface*> listBidirs = getBidirs();
 339
 340   if (!listGenerics.isEmpty()) {
 341     out << indent << "  generic (" << endl;
 342     for(i=0;i<listGenerics.size()-1;i++) {
 343       out << indent << "    " << listGenerics.at(i)->toVHDL(BlockParameter::Entity, 0) << endl;
 344     }
 345     out << indent << "    " << listGenerics.at(i)->toVHDL(BlockParameter::Entity,BlockParameter::NoComma) << endl;
 346     out << indent << "    );" << endl;
 347   }
 348
 349   out << indent << "  port (" << endl;
 350
 351   // Generation of the clk & rst signals
 352   out << indent << "    -- clk/rst" << endl;
 353   foreach(AbstractInterface* iface, listInputs) {
 354     if(iface->getPurpose() == AbstractInterface::Clock || iface->getPurpose() == AbstractInterface::Reset) {
 355       out << indent << "    " << iface->getName() << " : in std_logic;" << endl;
 356     }
 357   }
 358
 359   int count = 0;
 360   foreach(AbstractInterface* iface, getInterfaces()) {
 361     if((iface->getPurpose() == AbstractInterface::Data)||(iface->getPurpose() == AbstractInterface::Control)) count++;
 362   }
 363   // Generation of the data/control signals
 364
 365   int flag = 0;
 366   bool first = true;
 367
 368   foreach(AbstractInterface* iface, listInputs) {
 369     if(iface->getPurpose() == AbstractInterface::Data) {
 370       if (first) {
 371         out << indent << "    -- input data ports" << endl;
 372         first = false;
 373       }
 374       count--;
 375       if (count == 0) flag = AbstractInterface::NoComma;
 376       out << indent << "    " << iface->toVHDL(AbstractInterface::Entity, flag) << endl;
 377     }
 378   }
 379   first = true;
 380   foreach(AbstractInterface* iface, listInputs) {
 381     if(iface->getPurpose() == AbstractInterface::Control) {
 382       if (first) {
 383         out << indent << "    -- input control ports" << endl;
 384         first = false;
 385       }
 386       count--;
 387       if (count == 0) flag = AbstractInterface::NoComma;
 388       out << indent << "    " << iface->toVHDL(AbstractInterface::Entity, flag) << endl;
 389     }
 390   }
 391   first = true;
 392   foreach(AbstractInterface* iface, listOutputs) {
 393     if(iface->getPurpose() == AbstractInterface::Data) {
 394       if (first) {
 395         out << indent << "    -- output data ports" << endl;
 396         first = false;
 397       }
 398       count--;
 399       if (count == 0) flag = AbstractInterface::NoComma;
 400       out << indent << "    " << iface->toVHDL(AbstractInterface::Entity, flag) << endl;
 401     }
 402   }
 403   first = true;
 404   foreach(AbstractInterface* iface, listOutputs) {
 405     if(iface->getPurpose() == AbstractInterface::Control) {
 406       if (first) {
 407         out << indent << "    -- output control ports" << endl;
 408         first = false;
 409       }
 410       count--;
 411       if (count == 0) flag = AbstractInterface::NoComma;
 412       out << indent << "    " << iface->toVHDL(AbstractInterface::Entity, flag) << endl;
 413     }
 414   }
 415   first = true;
 416   foreach(AbstractInterface* iface, listBidirs) {
 417     if(iface->getPurpose() == AbstractInterface::Data) {
 418       if (first) {
 419         out << indent << "    -- bidirs data ports" << endl;
 420         first = false;
 421       }
 422       count--;
 423       if (count == 0) flag = AbstractInterface::NoComma;
 424       out << indent << "    " << iface->toVHDL(AbstractInterface::Entity, flag) << endl;
 425     }
 426   }
 427   out << indent << "    );" << endl << endl;
 428 }
 429
 430 void GroupBlock::generateArchitecture(QTextStream& out, QDomElement &elt) throw(Exception) {
 431
 432   int i;
 433
 434   out << "architecture rtl of " << name << " is " << endl << endl;
 435
 436   // generate type for delays, if needed.
 437   QList<int> modWidth;
 438   foreach(AbstractBlock* block, blocks) {
 439     QList<AbstractInterface*> listCtlInputs = block->getControlInputs();
 440     foreach(AbstractInterface* iface, listCtlInputs) {
 441       ConnectedInterface* connCtlIface = AI_TO_CON(iface);
 442       AbstractInputModifier* modifier = connCtlIface->getInputModifier();
 443       if (modifier != NULL) {
 444         ConnectedInterface* connIface = AI_TO_CON(connCtlIface->getAssociatedIface());
 445         int w = connIface->getWidth();
 446         if (w == -1) throw(Exception(INVALID_VALUE));
 447         if (!modWidth.contains(w)) {
 448           modWidth.append(w);
 449         }
 450       }
 451     }
 452   }
 453   if (modWidth.size() > 0) {
 454
 455     out << "  -- types for modified inputs" << endl;
 456     out << "  type vector_of_std_logic is array (natural range <>) of std_logic;" << endl;
 457     foreach(int w, modWidth) {
 458       QString mw = "";
 459       mw.setNum(w);
 460       QString mwm1 = "";
 461       mwm1.setNum(w-1);
 462       out << "  type vector_of_std_logic_vector"<< mw << " is array (natural range <>) of std_logic_vector(" << mwm1 << " downto 0);" << endl;
 463     }
 464     out << endl;
 465   }
 466
 467
 468   // generate the components
 469   foreach(AbstractBlock* block, blocks) {
 470     try {
 471       block->generateComponent(out,false);
 472     }
 473     catch(Exception e) {
 474       throw(e);
 475     }
 476   }
 477
 478   out << endl;
 479   // generate signals
 480   out << "  ----------------------------" << endl;
 481   out << "  --  SIGNALS" << endl;
 482   out << "  ----------------------------" << endl << endl;
 483
 484   // signals to synchronize inputs
 485   out << "  -- signals to synchronize inputs" << endl;
 486   foreach(AbstractInterface* iface, getInputs()) {
 487     if ((iface->getPurpose() == AbstractInterface::Data)||(iface->getPurpose() == AbstractInterface::Control)) {
 488       QString name = iface->toVHDL(AbstractInterface::Signal,0);
 489       name.replace(" : ","_sync : ");
 490       out << "  signal " << name<< endl;
 491     }
 492   }
 493   out << endl;
 494
 495   // "normal" signals
 496   foreach(AbstractBlock* block, blocks) {
 497     try {
 498       out << "  -- signals from output ports of " << block->getName() << endl;
 499       QList<AbstractInterface*> listOutputs = block->getOutputs();
 500       foreach(AbstractInterface* iface, listOutputs) {
 501         if ((iface->getPurpose() == AbstractInterface::Data)||(iface->getPurpose() == AbstractInterface::Control)) {
 502           out << "  signal " << iface->toVHDL(AbstractInterface::Signal,0) << endl;
 503         }
 504         else if (block->getName() == "clkrstgen") {
 505           if ((iface->getPurpose() == AbstractInterface::Clock)||(iface->getPurpose() == AbstractInterface::Reset)) {
 506             out << "  signal " << iface->toVHDL(AbstractInterface::Signal,0) << endl;
 507           }
 508         }
 509       }
 510     }
 511     catch(Exception e) {
 512       throw(e);
 513     }
 514     out << endl;
 515   }
 516
 517   // signal for modifiers
 518   foreach(AbstractBlock* block, blocks) {
 519     bool hasModif = false;
 520     QList<AbstractInterface*> listCtlInputs = block->getControlInputs();
 521
 522     foreach(AbstractInterface* iface, listCtlInputs) {
 523       ConnectedInterface* connCtlIface = AI_TO_CON(iface);
 524       AbstractInputModifier* modifier = connCtlIface->getInputModifier();
 525       if (modifier != NULL) {
 526         hasModif = true;
 527         break;
 528       }
 529     }
 530     if (hasModif) {
 531       try {
 532         out << "  -- signals for modified input ports of " << block->getName() << endl;
 533         foreach(AbstractInterface* iface, listCtlInputs) {
 534           ConnectedInterface* connCtlIface = AI_TO_CON(iface);
 535           AbstractInputModifier* modifier = connCtlIface->getInputModifier();
 536           if (modifier != NULL) {
 537             out << modifier->toVHDL(AbstractInputModifier::Signal,0) << endl;
 538           }
 539         }
 540       }
 541       catch(Exception e) {
 542         throw(e);
 543       }
 544       out << endl;
 545     }
 546   }
 547
 548   out << "begin" << endl;
 549
 550   // generate signals that goes to the output ports
 551
 552   out << "  -- connections to output ports of " << name << endl;
 553   QList<AbstractInterface*> listOutputs = getOutputs();
 554   foreach(AbstractInterface* iface, listOutputs) {
 555     if ((iface->getPurpose() == AbstractInterface::Data)||(iface->getPurpose() == AbstractInterface::Control)) {
 556       ConnectedInterface* connIface = AI_TO_CON(iface);
 557       ConnectedInterface* fromIface = connIface->getConnectedFrom();
 558       out << "  " << connIface->getName() << " <= " << fromIface->toVHDL(AbstractInterface::Instance,0) << ";" << endl;
 559     }
 560   }
 561
 562   out << endl;
 563
 564
 565
 566   // generate instances
 567   foreach(AbstractBlock* block, blocks) {
 568     try {
 569       out << "  " << block->getName() << "_1 : " << block->getName() << endl;
 570
 571       QList<BlockParameter*> listGenerics = block->getGenericParameters();
 572       QList<AbstractInterface*> listInputs = block->getInputs();
 573       QList<AbstractInterface*> listOutputs = block->getOutputs();
 574       QList<AbstractInterface*> listBidirs = block->getBidirs();
 575
 576       if (!listGenerics.isEmpty()) {
 577         out << "    generic map (" << endl;
 578         for(i=0;i<listGenerics.size()-1;i++) {
 579           out << "      " << listGenerics.at(i)->toVHDL(BlockParameter::Instance, BlockParameter::NoComma) << "," << endl;
 580         }
 581         out << "      " << listGenerics.at(i)->toVHDL(BlockParameter::Instance,BlockParameter::NoComma) << endl;
 582         out << "    )" << endl;
 583       }
 584
 585       out << "    port map (" << endl;
 586       QString portMap = "";
 587
 588       for(i=0;i<listInputs.size();i++) {
 589         ConnectedInterface* connIface = AI_TO_CON(listInputs.at(i));
 590         ConnectedInterface* fromIface = connIface->getConnectedFrom();
 591
 592         if (fromIface->isFunctionalInterface()) {
 593           portMap += "      " + connIface->getName() + " => ";
 594           bool hasMod = false;
 595           if (connIface->getPurpose() == AbstractInterface::Data) {
 596             ConnectedInterface* connCtlIface = AI_TO_CON(connIface->getAssociatedIface());
 597             if ((connCtlIface != NULL) && (connCtlIface->getInputModifier() != NULL)) {
 598               hasMod = true;
 599             }
 600           }
 601           else if (connIface->getPurpose() == AbstractInterface::Control) {
 602             if (connIface->getInputModifier() != NULL) {
 603               hasMod = true;
 604             }
 605           }
 606           if (hasMod) {
 607             portMap += connIface->getOwner()->getName()+"_"+connIface->getName()+"_mod,\n";
 608           }
 609           else {
 610             portMap += fromIface->toVHDL(AbstractInterface::Instance, AbstractInterface::NoComma) + ",\n";
 611           }
 612         }
 613         else if (fromIface->isGroupInterface()) {
 614           if ((fromIface->getOwner()->isTopGroupBlock()) && ((fromIface->getPurpose() == AbstractInterface::Data)||(fromIface->getPurpose() == AbstractInterface::Control))) {
 615             portMap += "      " + connIface->getName() + " => " + fromIface->getOwner()->getName()+ "_"+ fromIface->getName() + "_sync,\n";
 616           }
 617           else {
 618             portMap += "      " + connIface->getName() + " => " + fromIface->getName() + ",\n";
 619           }
 620         }
 621       }
 622       if (listOutputs.size()>0) {
 623         for(i=0;i<listOutputs.size();i++) {
 624           ConnectedInterface* connIface = AI_TO_CON(listOutputs.at(i));
 625           portMap += "      " + connIface->getName() + " => " + connIface->toVHDL(AbstractInterface::Instance, AbstractInterface::NoComma) + ",\n";
 626         }
 627       }
 628       if (listBidirs.size()>0) {
 629         for(i=0;i<listBidirs.size();i++) {
 630           ConnectedInterface* connIface = AI_TO_CON(listBidirs.at(i));
 631           portMap += "      " + connIface->getName() + " => " + connIface->toVHDL(AbstractInterface::Instance, AbstractInterface::NoComma) + ",\n";
 632         }
 633       }
 634       portMap.chop(2);
 635       out << portMap << endl;
 636
 637
 638       out << "    );" << endl;
 639     }
 640     catch(Exception e) {
 641       throw(e);
 642     }
 643     out << endl;
 644   }
 645
 646   // generate input modifiers
 647   foreach(AbstractBlock* block, blocks) {
 648
 649     foreach(AbstractInterface* iface, block->getControlInputs()) {
 650       ConnectedInterface* connIface = AI_TO_CON(iface);
 651       // check if it is connected
 652       if (connIface->getConnectedFrom() == NULL) {
 653         throw(Exception(IFACE_NOT_CONNECTED,this));
 654       }
 655       AbstractInputModifier* modifier = connIface->getInputModifier();
 656       if (modifier != NULL) {
 657         try {
 658           out << modifier->toVHDL(AbstractInputModifier::Architecture,0) << endl;
 659         }
 660         catch(Exception e) {
 661           throw(e);
 662         }
 663       }
 664     }
 665   }
 666
 667   if (topGroup) {
 668     // generate input sync process
 669     out << "  -- process to synchronize inputs of top group" << endl;
 670     out << "sync_inputs : process(from_clkrstgen_clk,from_clkrstgen_reset)" << endl;
 671     out << "  begin" << endl;
 672     out << "    if from_clkrstgen_reset = '1' then" << endl;
 673     foreach(AbstractInterface* iface, getInputs()) {
 674       if ((iface->getPurpose() == AbstractInterface::Data)||(iface->getPurpose() == AbstractInterface::Control)) {
 675         if (iface->getWidth() == 0) {
 676           out << "      " << name << "_" << iface->getName() << "_sync <= '0';" << endl;
 677         }
 678         else {
 679           out << "      " << name << "_" << iface->getName() << "_sync <= (others => '0');" << endl;
 680         }
 681       }
 682     }
 683     out << "    elsif rising_edge(from_clkrstgen_clk) then" << endl;
 684     foreach(AbstractInterface* iface, getInputs()) {
 685       if ((iface->getPurpose() == AbstractInterface::Data)||(iface->getPurpose() == AbstractInterface::Control)) {
 686         if (iface->getWidth() == 0) {
 687           out << "      " << name << "_" << iface->getName() << "_sync <= " << iface->getName() << ";" << endl;
 688         }
 689         else {
 690           out << "      " << name << "_" << iface->getName() << "_sync <= " << iface->getName() << ";" << endl;
 691         }
 692       }
 693     }
 694     out << "    end if;" << endl;
 695     out << "  end process sync_inputs;" << endl;
 696
 697     out << endl;
 698   }
 699
 700   out << "end architecture rtl;" << endl;
 701 }
 702
 703 void GroupBlock::generateController(QTextStream &out) throw(Exception) {
 704
 705 }
 706