X-Git-Url: https://bilbo.iut-bm.univ-fcomte.fr/and/gitweb/blast.git/blobdiff_plain/abbc64cf04a35ab3549d5c516f44c7c5921baa63..18fecf25efe710631fabecbb9f689c2997fdfe18:/AbstractBlock.cpp

diff --git a/AbstractBlock.cpp b/AbstractBlock.cpp
index 6e9cc86..336b677 100644
--- a/AbstractBlock.cpp
+++ b/AbstractBlock.cpp
@@ -3,31 +3,27 @@
 #include <QMessageBox>
 #include "AbstractInterface.h"
 #include "BlockParameter.h"
+#include "Parameters.h"
+#include "GroupBlock.h"
+#include "ConnectedInterface.h"
+
 
 AbstractBlock::AbstractBlock() {
   name = "";
   parent = NULL;
 }
 
+/*
 AbstractBlock::AbstractBlock(const QString& _name) {
-  name = _name;
+  name = Parameters::normalizeName(_name);
   parent = NULL;
 }
+*/
 
 AbstractBlock::~AbstractBlock() {
 
-  foreach(AbstractInterface* iface, inputs) {
-    delete iface;
-  }
-  foreach(AbstractInterface* iface, outputs) {
-    delete iface;
-  }
-  foreach(AbstractInterface* iface, bidirs) {
-    delete iface;
-  }
-  inputs.clear();
-  outputs.clear();
-  bidirs.clear();
+  removeAllInterfaces();
+
   foreach(BlockParameter* p, params) {
     delete p;
   }
@@ -35,7 +31,7 @@ AbstractBlock::~AbstractBlock() {
 }
 
 void AbstractBlock::setName(const QString& str) {
-  name = str;
+  name = Parameters::normalizeName(str);
 }
 
 void AbstractBlock::setParent(AbstractBlock* _parent) {
@@ -54,6 +50,22 @@ bool AbstractBlock::isGroupBlock() {
   return false;
 }
 
+bool AbstractBlock::isTopGroupBlock() {  
+  return false;
+}
+
+bool AbstractBlock::isSourceBlock() {
+  return false;
+}
+/* NB: a generator is a block that has no data inputs
+ * and has at least one data output.
+ */
+bool AbstractBlock::isGeneratorBlock() {
+  if (getDataInputs().size() > 0) return false;
+  
+  return true;
+}
+
 void AbstractBlock::addParameter(BlockParameter *param) {
   params.append(param);
 }
@@ -90,6 +102,23 @@ void AbstractBlock::removeInterface(AbstractInterface *inter) {
   delete inter;
 }
 
+void AbstractBlock::removeAllInterfaces() {
+
+  foreach(AbstractInterface* iface, inputs) {
+    delete iface;
+  }
+  foreach(AbstractInterface* iface, outputs) {
+    delete iface;
+  }
+  foreach(AbstractInterface* iface, bidirs) {
+    delete iface;
+  }
+  inputs.clear();
+  outputs.clear();
+  bidirs.clear();
+
+}
+
 void AbstractBlock::defineBlockParam(BlockParameter *param)
 {
   cout << "definition of param : " << param->getName().toStdString() << endl;
@@ -104,14 +133,60 @@ void AbstractBlock::defineBlockParam(BlockParameter *param)
   param->setValue(value);  
 }
 
-QList<AbstractInterface *> AbstractBlock::getInterfaces() {
+QList<AbstractInterface *> AbstractBlock::getInterfaces(int direction, int purpose) {
   QList<AbstractInterface *> list;
-  list.append(inputs);
-  list.append(outputs);
-  list.append(bidirs);
+  bool selIn = false;
+  bool selOut = false;
+  bool selInOut = false;
+  
+  if (direction == AbstractInterface::AnyDirection) {
+    selIn = true;
+    selOut = true;
+    selInOut = true;
+  }
+  else if (direction == AbstractInterface::Input) {
+    selIn = true;    
+  }
+  else if (direction == AbstractInterface::Output) {
+    selOut = true;    
+  }
+  else if (direction == AbstractInterface::InOut) {
+    selInOut = true;    
+  }
+  if (selIn) {
+    foreach(AbstractInterface* iface, inputs) {
+      if ((iface->getPurpose() == purpose) || (purpose == AbstractInterface::AnyPurpose)) list.append(iface);      
+    }
+  }
+  if (selOut) {
+    foreach(AbstractInterface* iface, outputs) {
+      if ((iface->getPurpose() == purpose) || (purpose == AbstractInterface::AnyPurpose)) list.append(iface);      
+    }
+  }
+  if (selInOut) {
+    foreach(AbstractInterface* iface, bidirs) {
+      if ((iface->getPurpose() == purpose) || (purpose == AbstractInterface::AnyPurpose)) list.append(iface);      
+    }
+  }
   return list;
 }
 
+QList<AbstractInterface *> AbstractBlock::getDataInputs() {
+  return getInterfaces(AbstractInterface::Input, AbstractInterface::Data);  
+}
+
+QList<AbstractInterface *> AbstractBlock::getDataOutputs() {
+  return getInterfaces(AbstractInterface::Output, AbstractInterface::Data);  
+}
+
+QList<AbstractInterface *> AbstractBlock::getControlInputs() {
+  return getInterfaces(AbstractInterface::Input, AbstractInterface::Control);  
+}
+
+QList<AbstractInterface *> AbstractBlock::getControlOutputs() {
+  return getInterfaces(AbstractInterface::Output, AbstractInterface::Control);    
+}
+
 AbstractInterface* AbstractBlock::getIfaceFromName(QString name) {
 
   foreach(AbstractInterface* iface, inputs) {
@@ -165,3 +240,52 @@ QList<BlockParameter *> AbstractBlock::getWishboneParameters() {
   }
   return lst;
 }
+
+
+
+void AbstractBlock::connectClkReset() throw(Exception) {
+
+  GroupBlock* parentBlock = AB_TO_GRP(parent);
+
+  cout << "connecting clk/rst for child " << qPrintable(name) << " of " << qPrintable(parentBlock->getName()) << endl;
+
+  QList<AbstractInterface* > lstClk = getInterfaces(AbstractInterface::Input,AbstractInterface::Clock);
+  QList<AbstractInterface* > lstRst = getInterfaces(AbstractInterface::Input,AbstractInterface::Reset);
+
+  if ((lstClk.isEmpty()) || (lstRst.isEmpty())) {
+    throw(Exception(IFACE_GROUP_NOCLKRST,this));
+  }
+
+  ConnectedInterface* toClk = AI_TO_CON(lstClk.at(0));
+  ConnectedInterface* toRst = AI_TO_CON(lstRst.at(0));
+
+  ConnectedInterface* fromClk = NULL;
+  ConnectedInterface* fromRst = NULL;
+
+  if (parentBlock->isTop()) {
+    AbstractBlock* clkrstgen = parentBlock->getFunctionalBlockByName("clkrstgen");
+    if (clkrstgen == NULL) {
+      throw(Exception(IFACE_TOP_NOCLKRSTGEN,this));
+    }
+    else {
+      fromClk = AI_TO_CON(clkrstgen->getIfaceFromName("clk"));
+      fromRst = AI_TO_CON(clkrstgen->getIfaceFromName("reset"));
+    }
+  }
+  else {
+    fromClk = AI_TO_CON(parentBlock->getIfaceFromName("clk"));
+    fromRst = AI_TO_CON(parentBlock->getIfaceFromName("reset"));
+  }
+  if ((fromClk == NULL) || (fromRst == NULL)) {
+    throw(Exception(IFACE_GROUP_NOCLKRST,parentBlock));
+  }
+  else {
+    fromClk->connectTo(toClk);
+    fromRst->connectTo(toRst);
+  }
+
+
+}
+
+
+