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