#define AI_TO_REF(ptr) ((ReferenceInterface*)ptr)
#define AI_TO_FUN(ptr) ((FunctionalInterface*)ptr)
#define AI_TO_GRP(ptr) ((GroupInterface*)ptr)
+#define AI_TO_CON(ptr) ((ConnectedInterface*)ptr)
using namespace std;
using namespace Qt;
public :
enum IfaceWidthType { Expression = 1, Boolean, Natural, Inherited}; //! Inherited is only for Group interface
+ enum IfaceWidthDir { LittleEndian = 1, BigEndian}; //! LittleEndian = X downto 0, BigEndian = 0 to X
enum IfacePurpose { AnyPurpose = 0, Data = 1, Control, Clock, Reset, Wishbone };
enum IfaceDirection { AnyDirection = 0, Input = 1, Output = 2, InOut = 3 };
- enum IfaceVHDLContext {AnyContext = 0, Entity = 1, Component = 2, Architecture = 3 }; // NB : 3 is when creating an instance of the block that owns this iface
+ enum IfaceVHDLContext {AnyContext = 0, Entity = 1, Component = 2, Instance = 3, Signal = 4 };
enum IfaceVHDLFlags { NoComma = 1 };
+ enum IfaceClockName { NoName = 0, ClockName, ParameterName };
- static int getIntDirection(QString str);
+ static int getIntDirection(QString str);
+ static int getIntPurpose(QString str);
AbstractInterface(AbstractBlock* _owner);
- AbstractInterface(AbstractBlock* _owner, const QString& _name, const QString& _type, const QString& _width, int _direction, int _purpose);
+ AbstractInterface(AbstractBlock* _owner, const QString& _name, int _direction, int _purpose, const QString& _type, const QString& _width, int _endianess = LittleEndian);
AbstractInterface(AbstractInterface* other);
virtual ~AbstractInterface();
inline QString getName() { return name;}
inline int getType() { return type; }
QString getTypeString();
- inline QString getWidth() { return width;}
+ inline int getEndianess() { return endianess; }
+ QString getEndianessString();
+ inline QString getWidthString() { return width;}
+ virtual int getWidth(); // return -1 if size cannot be determine
inline int getPurpose() { return purpose;}
QString getPurposeString();
inline int getDirection() { return direction;}
QString getDirectionString();
inline AbstractBlock *getOwner() { return owner;}
inline AbstractInterface* getAssociatedIface() { return associatedIface; }
+ inline QString getClockIfaceString() { return clkIface; }
+ inline int getClockIfaceType() { return clkIfaceType; }
+ AbstractInterface* getClockIface();
+
double getDoubleWidth() throw(QException);
- inline QList<char> getConsumptionPattern() { return consumptionPattern; }
- inline QList<char> getProductionPattern() { return productionPattern; }
- inline QList<char> getOutputPattern() { return outputPattern; }
-
- //virtual QList<AbstractInterface*> getConnectedTo() = 0;
-
- /* NB: only GroupInterface and FunctionalInterface have a connectedFrom, so
- defining getConnectedFrom as pure virtual is normal, usefull even though it is ugly :-)
- */
- virtual AbstractInterface* getConnectedFrom() = 0;
// setters
inline void setOwner(AbstractBlock* _owner) { owner = _owner; }
- inline void setName(const QString& _name) { name = _name; }
+ void setName(const QString& _name);
inline void setWidth(const QString& _width) { width = _width; }
inline void setType(int _type) { type = _type;}
+ inline void setEndianess(int _endianess) { endianess = _endianess;}
inline void setType(const QString& _type) { type = typeFromString(_type);}
void setPurpose(int _purpose);
void setDirection(int _direction);
bool setAssociatedIface(AbstractInterface* iface);
+ bool setClockIface(QString name);
- inline void setConsumptionPattern(QList<char> pattern) { consumptionPattern = pattern; }
- inline void setProductionPattern(QList<char> pattern) { productionPattern = pattern; }
- inline void setOutputPattern(QList<char> pattern) { outputPattern = pattern; }
-
// testers
virtual bool isReferenceInterface();
virtual bool isFunctionalInterface();
virtual bool isGroupInterface();
- //virtual bool isConnectedTo() = 0;
- //virtual bool isConnectedFrom() = 0;
- //virtual bool canConnectTo(AbstractInterface* iface) = 0; // returns yes if this can be connected to iface, no if not
- //virtual bool canConnectFrom(AbstractInterface* iface) = 0; // returns yes if this can be connected from iface, no if not
// others
virtual AbstractInterface *clone() = 0;
-
- //virtual bool addConnectedTo(AbstractInterface *inter) = 0;
- //virtual void removeConnectedTo(AbstractInterface *inter) = 0;
- //virtual bool setConnectedFrom(AbstractInterface* inter) = 0;
- //virtual void clearConnectedTo() = 0;
- //virtual void clearConnections() = 0;
- //virtual void connectionsValidation(QStack<AbstractInterface*> *interfacetoValidate, QList<AbstractInterface*> *validatedInterfaces) throw(Exception) = 0;
+
int typeFromString(const QString &_type);
- QString toVHDL(int context, int flags) throw(Exception);
+ QString toVHDL(IfaceVHDLContext context, int flags) throw(Exception);
protected:
QString name;
- int type;
- QString width;
int purpose;
int direction;
+ int type;
+ QString width;
+ int endianess;
+
AbstractBlock* owner;
/*!
* (NB: a test is done in the method to prevent the other case).
*/
AbstractInterface* associatedIface;
+ /*!
+ * \brief clkIface represents the clock interface that is used in processes modifying this interface. It is only relevant for
+ * Data interfaces and clock outputs (that comes from a clkrstgen). Since Control interfaces are automatically associated to a
+ * Data interface, clkIface is "" for them. Wishbone interfaces
+ * In general, blocks have a single
+ * clock interface which is by default automatically connected to the main clock dispatched by the clkrstgen block in top group.
+ * Nevertheless, the designer has the possibility to connect the block taht owns this interface to another clkrstgen block. Moreover,
+ * some blocks may have several clocks, e.g. dual port RAMs, FIFOs.
+ */
+ QString clkIface;
+ int clkIfaceType; // 0 for not affected, 1 for clock input name, 2 for user param name
- // patterns
- QList<char> consumptionPattern; //! only usefull for input interfaces
- QList<char> productionPattern; //! only usefull for output interfaces
- QList<char> outputPattern; //! only usefull for output interfaces
};
