#include <BaseNetlistBlock.hh>

Inheritance diagram for ProGe::BaseNetlistBlock:

Collaboration diagram for ProGe::BaseNetlistBlock:

Public Types
typedef std::vector< BaseNetlistBlock * >	BlockContainerType

typedef std::vector< Parameter >	ParameterContainerType

typedef std::vector< NetlistPort * >	PortContainerType

typedef std::vector< NetlistPortGroup * >	PortGroupContainerType

Public Member Functions
	BaseNetlistBlock ()

	BaseNetlistBlock (BaseNetlistBlock *parent)

	BaseNetlistBlock (const std::string &moduleName, const std::string &instanceName, BaseNetlistBlock *parent=nullptr)

virtual	~BaseNetlistBlock ()

const std::string &	instanceName () const

void	setInstanceName (const std::string &name)

const std::string &	moduleName () const

const std::string	name () const

virtual size_t	subBlockCount () const

virtual const BaseNetlistBlock &	subBlock (size_t index) const

virtual bool	hasSubBlock (const std::string &instanceName) const

virtual bool	isSubBlock (const BaseNetlistBlock &block) const

virtual bool	hasParameter (const std::string &name) const

virtual const Parameter &	parameter (const std::string &name) const

virtual size_t	parameterCount () const

virtual const Parameter &	parameter (size_t index) const

virtual size_t	portCount () const

virtual const NetlistPort &	port (size_t index) const

virtual std::vector< const NetlistPort * >	portsBy (SignalType type) const

virtual const NetlistPort &	portBy (SignalType type, size_t index=0) const

virtual bool	hasPortsBy (SignalType type) const

virtual const NetlistPort *	port (const std::string &portName, bool partialMatch=true) const

virtual size_t	portGroupCount () const

virtual const NetlistPortGroup &	portGroup (size_t index) const

virtual std::vector< const NetlistPortGroup * >	portGroupsBy (SignalGroupType type) const

virtual const Netlist &	netlist () const

virtual bool	hasParentBlock () const

virtual const BaseNetlistBlock &	parentBlock () const

virtual bool	isVirtual () const

virtual void	build () override

virtual void	connect () override

virtual void	finalize () override

virtual void	write (const Path &targetBaseDir, HDL targetLang=VHDL) const override

virtual void	writeSelf (const Path &targetBaseDir, HDL targetLang=VHDL) const

virtual size_t	packageCount () const

virtual const std::string &	package (size_t idx) const

PortContainerType &	ports ()

virtual bool	isLeaf () const

BaseNetlistBlock *	shallowCopy (const std::string &instanceName="") const

Public Member Functions inherited from ProGe::IGenerationPhases
virtual	~IGenerationPhases ()

Protected Member Functions
Netlist &	netlist ()

virtual NetlistPort &	port (size_t index)

virtual BaseNetlistBlock &	subBlock (size_t index)

virtual BaseNetlistBlock &	parentBlock ()

void	setModuleName (const std::string &name)

void	addSubBlock (BaseNetlistBlock *subBlock, const std::string &instanceName="")

void	deleteSubBlock (BaseNetlistBlock *subBlock)

void	removeSubBlock (BaseNetlistBlock *subBlock)

NetlistPort *	addPort (NetlistPort *port)

void	removePort (NetlistPort *port)

void	addPortGroup (NetlistPortGroup *portGroup)

void	removePortGroup (NetlistPortGroup *portGroup)

void	setParameter (const Parameter &param)

void	addParameter (const Parameter &param)

Parameter &	parameter (const std::string &name)

NetlistPort *	findPort (const std::string &portName, bool recursiveSearch=false, bool partialMatch=true) const

void	addPackage (const std::string &packageName)

void	connectClocks ()

void	connectResets ()

Private Member Functions
	BaseNetlistBlock (const BaseNetlistBlock &)

BaseNetlistBlock &	operator= (const BaseNetlistBlock &)

virtual void	setParent (BaseNetlistBlock *parent)

Private Attributes
BaseNetlistBlock *	parent_
	The reference to parent block of this block.

BlockContainerType	subBlocks_
	The sub blocks of this netlist block.

ParameterContainerType	parameters_
	The parameters of the block.

PortContainerType	ports_
	The ports of the block.

PortGroupContainerType	portGroups_
	The ports of the block.

Netlist *	netlist_
	The netlist of the block.

std::string	instanceName_
	The instance name of the block.

std::string	moduleName_
	The module name of the block.

std::vector< std::string >	packages_
	The referenced packages by the module.

Friends
class	NetlistPort

class	NetlistPortGroup

class	Parameter

Detailed Description

Definition at line 59 of file BaseNetlistBlock.hh.

Member Typedef Documentation

◆ BlockContainerType

typedef std::vector<BaseNetlistBlock*> ProGe::BaseNetlistBlock::BlockContainerType

Definition at line 65 of file BaseNetlistBlock.hh.

◆ ParameterContainerType

typedef std::vector<Parameter> ProGe::BaseNetlistBlock::ParameterContainerType

Definition at line 66 of file BaseNetlistBlock.hh.

◆ PortContainerType

typedef std::vector<NetlistPort*> ProGe::BaseNetlistBlock::PortContainerType

Definition at line 67 of file BaseNetlistBlock.hh.

◆ PortGroupContainerType

typedef std::vector<NetlistPortGroup*> ProGe::BaseNetlistBlock::PortGroupContainerType

Definition at line 68 of file BaseNetlistBlock.hh.

Constructor & Destructor Documentation

◆ BaseNetlistBlock() [1/4]

ProGe::BaseNetlistBlock::BaseNetlistBlock ( )

Definition at line 53 of file BaseNetlistBlock.cc.

    : parent_(nullptr),
      subBlocks_(),
      parameters_(),
      ports_(),
      portGroups_(),
      netlist_(new Netlist()),
      instanceName_("defaultInstanceName_inst0"),
      moduleName_("defaultModuleName"),
      packages_() {}

Referenced by shallowCopy().

◆ BaseNetlistBlock() [2/4]

ProGe::BaseNetlistBlock::BaseNetlistBlock ( BaseNetlistBlock * parent )

explicit

Definition at line 64 of file BaseNetlistBlock.cc.

    : parent_(parent),
      subBlocks_(),
      parameters_(),
      ports_(),
      portGroups_(),
      netlist_(new Netlist()),
      instanceName_("defaultInstanceName_inst0"),
      moduleName_("defaultModuleName"),
      packages_() {
    if (parent_ != nullptr) {
        parent_->addSubBlock(this);
    }
}

References addSubBlock(), and parent_.

Here is the call graph for this function:

◆ BaseNetlistBlock() [3/4]

ProGe::BaseNetlistBlock::BaseNetlistBlock	(	const std::string &	moduleName,
		const std::string &	instanceName,
		BaseNetlistBlock *	parent = `nullptr`
	)

Definition at line 79 of file BaseNetlistBlock.cc.

    : parent_(parent),
      subBlocks_(),
      parameters_(),
      ports_(),
      portGroups_(),
      netlist_(new Netlist()),
      instanceName_(instanceName),
      moduleName_(moduleName),
      packages_() {
    if (instanceName.empty()) {
        setInstanceName(moduleName + "_inst0");
    }
 
    if (parent_ != nullptr) {
        parent_->addSubBlock(this);
    }
}

◆ ~BaseNetlistBlock()

ProGe::BaseNetlistBlock::~BaseNetlistBlock ( )

virtual

Definition at line 100 of file BaseNetlistBlock.cc.

                                    {
    if (parent_ != nullptr) {
        parent_->removeSubBlock(this);
        parent_ = nullptr;
    }
 
    for (PortGroupContainerType::reverse_iterator it = portGroups_.rbegin();
         it != portGroups_.rend();) {
        NetlistPortGroup* toDeleted = *it;
        it++;
        portGroups_.pop_back();
        delete toDeleted;
    }
 
    for (PortContainerType::reverse_iterator it = ports_.rbegin();
         it != ports_.rend();) {
        NetlistPort* toDeleted = *it;
        it++;
        ports_.pop_back();
        delete toDeleted;
    }
 
    for (BlockContainerType::reverse_iterator it = subBlocks_.rbegin();
         it != subBlocks_.rend();) {
        BaseNetlistBlock* toDeleted = *it;
        it++;
        subBlocks_.pop_back();
        delete toDeleted;
    }
 
    delete netlist_;
    netlist_ = nullptr;
}

References parent_, portGroups_, and removeSubBlock().

Here is the call graph for this function:

◆ BaseNetlistBlock() [4/4]

ProGe::BaseNetlistBlock::BaseNetlistBlock ( const BaseNetlistBlock & )

private

Member Function Documentation

◆ addPackage()

void ProGe::BaseNetlistBlock::addPackage ( const std::string & packageName )

protected

Definition at line 687 of file BaseNetlistBlock.cc.

                                                         {
    if (!ContainerTools::containsValue(packages_, packageName)) {
        packages_.push_back(packageName);
    }
}

References ContainerTools::containsValue(), and packages_.

Referenced by addParameter(), ProGe::ProcessorWrapperBlock::ProcessorWrapperBlock(), and shallowCopy().

Here is the call graph for this function:

◆ addParameter()

void ProGe::BaseNetlistBlock::addParameter ( const Parameter & param )

protected

Adds new parameter to the block. Throws exception if the block has the parameter by the name already.

Definition at line 547 of file BaseNetlistBlock.cc.

                                                     {
    // Check for uniqueness //
    for (Parameter& p : parameters_) {
        if (p.name() == param.name()) {
            throw ObjectAlreadyExists(
                __FILE__, __LINE__,
                "The block \"" + name() + "\" already has parameter\"" +
                    param.name() + "\"");
        }
    }
 
    // Check if parameter's value refers to a constant //
    if (param.valueIsConstant()) {
        std::string packageName = param.packageNameOfConstant();
        assert(!packageName.empty());
        addPackage(packageName);
    }
 
    parameters_.push_back(param);
}

References addPackage(), assert, name(), ProGe::Parameter::name(), ProGe::Parameter::packageNameOfConstant(), parameters_, and ProGe::Parameter::valueIsConstant().

Referenced by ProGe::LoopBufferBlock::LoopBufferBlock(), ProGe::SinglePortByteMaskSSRAMBlock::SinglePortByteMaskSSRAMBlock(), and ProGe::SinglePortSSRAMBlock::SinglePortSSRAMBlock().

Here is the call graph for this function:

◆ addPort()

NetlistPort * ProGe::BaseNetlistBlock::addPort ( NetlistPort * port )

protected

Adds port to this block and acquires ownership of it.

Added port will point to this block after the call.

Exceptions

ObjectAlreadyExists Thrown if the netlist block already has a port by same name.

Definition at line 467 of file BaseNetlistBlock.cc.

                                           {
    assert(port != nullptr && "Attempted to add null port.");
    if (findPort(port->name(), false, false)) {
        THROW_EXCEPTION(
            ObjectAlreadyExists,
            "Given port by name (" + port->name() +
                ") already exists in the netlist block (" +
                this->instanceName() + " : " + this->moduleName() + ").");
    }
 
    if (!port->hasParentBlock() || &port->parentBlock() != this) {
        port->setParent(this);
    }
    ports_.push_back(port);
    netlist_->registerPort(*port);
    if (parent_ != nullptr) {
        parent_->netlist_->registerPort(*port);
    }
    return port;
}

References assert, findPort(), ProGe::NetlistPort::hasParentBlock(), ProGe::NetlistPort::name(), netlist_, parent_, ProGe::NetlistPort::parentBlock(), port(), ports_, ProGe::Netlist::registerPort(), ProGe::NetlistPort::setParent(), and THROW_EXCEPTION.

Referenced by addPortGroup(), ProGe::LoopBufferBlock::LoopBufferBlock(), ProGe::NetlistPort::NetlistPort(), ProGe::NetlistPort::NetlistPort(), ProGe::NetlistPort::NetlistPort(), ProGe::ProcessorWrapperBlock::ProcessorWrapperBlock(), ProGe::SinglePortByteMaskSSRAMBlock::SinglePortByteMaskSSRAMBlock(), and ProGe::SinglePortSSRAMBlock::SinglePortSSRAMBlock().

Here is the call graph for this function:

◆ addPortGroup()

void ProGe::BaseNetlistBlock::addPortGroup ( NetlistPortGroup * portGroup )

protected

Definition at line 508 of file BaseNetlistBlock.cc.

                                                          {
    portGroups_.push_back(portGroup);
    portGroup->setParent(this);
    for (size_t i = 0; i < portGroup->portCount(); i++) {
        if (!netlist().isRegistered(portGroup->portAt(i))) {
            addPort(&portGroup->portAt(i));
        }
    }
}

References addPort(), netlist(), ProGe::NetlistPortGroup::portAt(), ProGe::NetlistPortGroup::portCount(), portGroup(), portGroups_, and ProGe::NetlistPortGroup::setParent().

Referenced by shallowCopy(), ProGe::SinglePortByteMaskSSRAMBlock::SinglePortByteMaskSSRAMBlock(), and ProGe::SinglePortSSRAMBlock::SinglePortSSRAMBlock().

Here is the call graph for this function:

◆ addSubBlock()

void ProGe::BaseNetlistBlock::addSubBlock	(	BaseNetlistBlock *	subBlock,
		const std::string &	instanceName = `""`
	)

protected

Adds sub block to this block and acquires ownership of it.

Parameters

subBlock	The block to be added.
instanceName	The instance base name to be given for sub block. If the given or sub block's instance name is not unique within the block The name will be prefixed with a running number.

Definition at line 405 of file BaseNetlistBlock.cc.

                                                               {
    if (!instanceName.empty()) {
        subBlock->instanceName_ =
            NetlistTools::getUniqueInstanceName(*this, instanceName);
    } else {
        if (subBlock->instanceName().empty()) {
            subBlock->setInstanceName(NetlistTools::getUniqueInstanceName(
                *this, subBlock->moduleName() + "_inst0"));
        } else {
            subBlock->setInstanceName(NetlistTools::getUniqueInstanceName(
                *this, subBlock->instanceName()));
        }
    }
 
    assert(!subBlock->hasParentBlock() || &subBlock->parentBlock() == this);
    subBlock->setParent(this);
    subBlocks_.push_back(subBlock);
 
    // Register ports of the subblock so connections can be made.
    for (size_t i = 0; i < subBlock->portCount(); i++) {
        netlist_->registerPort(subBlock->port(i));
    }
}

References assert, ProGe::NetlistTools::getUniqueInstanceName(), hasParentBlock(), instanceName(), instanceName_, moduleName(), netlist_, parentBlock(), port(), portCount(), ProGe::Netlist::registerPort(), setInstanceName(), setParent(), subBlock(), and subBlocks_.

Referenced by ProGe::ProcessorWrapperBlock::addInstructionMemory(), BaseNetlistBlock(), and ProGe::ProcessorWrapperBlock::ProcessorWrapperBlock().

Here is the call graph for this function:

◆ build()

void ProGe::BaseNetlistBlock::build ( )

overridevirtual

Implements ProGe::IGenerationPhases.

Definition at line 602 of file BaseNetlistBlock.cc.

602{}

◆ connect()

void ProGe::BaseNetlistBlock::connect ( )

overridevirtual

Implements ProGe::IGenerationPhases.

Definition at line 605 of file BaseNetlistBlock.cc.

605{}

◆ connectClocks()

void ProGe::BaseNetlistBlock::connectClocks ( )

protected

Connects all unconnected clock ports of sub block to this block's clock port if there is one.

Definition at line 722 of file BaseNetlistBlock.cc.

                                {
    auto clkPorts = this->portsBy(SignalType::CLOCK);
    assert(clkPorts.size() == 1);
    const NetlistPort& thisClk = *clkPorts.at(0);
 
    for (size_t i = 0; i < subBlockCount(); i++) {
        const BaseNetlistBlock& block = subBlock(i);
        for (auto port : block.portsBy(SignalType::CLOCK)) {
            if (!netlist().isPortConnected(*port) &&
                thisClk.direction() == port->direction()) {
                netlist().connect(thisClk, *port);
            }
        }
    }
}

References assert, ProGe::CLOCK, ProGe::Netlist::connect(), ProGe::NetlistPort::direction(), ProGe::Netlist::isPortConnected(), netlist(), port(), portsBy(), subBlock(), and subBlockCount().

Referenced by ProGe::ProcessorWrapperBlock::ProcessorWrapperBlock().

Here is the call graph for this function:

◆ connectResets()

void ProGe::BaseNetlistBlock::connectResets ( )

protected

Connects all unconnected reset ports of sub block to this block's reset port if there is one.

Definition at line 743 of file BaseNetlistBlock.cc.

                                {
    auto resetPorts = this->portsBy(SignalType::RESET);
    assert(resetPorts.size() == 1);
    const NetlistPort& thisReset = *resetPorts.at(0);
 
    for (size_t i = 0; i < subBlockCount(); i++) {
        const BaseNetlistBlock& block = subBlock(i);
        for (auto port : block.portsBy(SignalType::RESET)) {
            if (!netlist().isPortConnected(*port) &&
                thisReset.direction() == port->direction()) {
                netlist().connect(thisReset, *port);
            }
        }
    }
}

References assert, ProGe::Netlist::connect(), ProGe::NetlistPort::direction(), ProGe::Netlist::isPortConnected(), netlist(), port(), portsBy(), ProGe::RESET, subBlock(), and subBlockCount().

Referenced by ProGe::ProcessorWrapperBlock::ProcessorWrapperBlock().

Here is the call graph for this function:

◆ deleteSubBlock()

void ProGe::BaseNetlistBlock::deleteSubBlock ( BaseNetlistBlock * subBlock )

protected

Deletes given sub block and its all sub blocks.

Definition at line 434 of file BaseNetlistBlock.cc.

                                                           {
    // todo remove port descriptions of deleted block in the netlist.
    for (size_t i = 0; i < subBlocks_.size(); i++) {
        if (subBlocks_.at(i) == subBlock) {
            BaseNetlistBlock* toDeleted = subBlocks_.at(i);
            ContainerTools::swapRemoveValue(subBlocks_, i);
            delete toDeleted;
        }
    }
}

References subBlock(), subBlocks_, and ContainerTools::swapRemoveValue().

Here is the call graph for this function:

◆ finalize()

void ProGe::BaseNetlistBlock::finalize ( )

overridevirtual

Implements ProGe::IGenerationPhases.

Definition at line 608 of file BaseNetlistBlock.cc.

608{}

◆ findPort()

NetlistPort * ProGe::BaseNetlistBlock::findPort	(	const std::string &	portName,
		bool	recursiveSearch = `false`,
		bool	partialMatch = `true`
	)		const

protected

Returns a port that matches (partially) the given name.

If not found, returns nullptr

Definition at line 574 of file BaseNetlistBlock.cc.

                             {
    if (recursiveSearch) {
        assert(
            false &&
            "BaseNetlistBlock::findPort(): "
            "recursive search not implemented.");
    }
 
    NetlistPort* portPtr = nullptr;
    for (size_t i = 0; i < portCount(); i++) {
        if (ports_.at(i)->name() == portName) {
            return ports_.at(i);
        }
    }
    if (partialMatch) {
        for (size_t i = 0; i < portCount(); i++) {
            if (ports_.at(i)->name().find(portName) != std::string::npos) {
                return ports_.at(i);
            }
        }
    }
 
    return portPtr;
}

References assert, portCount(), and ports_.

Referenced by addPort(), ProGe::NetlistBlock::port(), and port().

Here is the call graph for this function:

◆ hasParameter()

bool ProGe::BaseNetlistBlock::hasParameter ( const std::string & name ) const

virtual

Definition at line 183 of file BaseNetlistBlock.cc.

                                                          {
    for (size_t i = 0; i < parameterCount(); i++) {
        if (parameter(i).name() == name) {
            return true;
        }
    }
    return false;
}

References name(), ProGe::Parameter::name(), parameter(), and parameterCount().

Referenced by AlteraMemGenerator::addGenerics(), ProGe::LoopBufferBlock::setIterationPortWidthParameter(), and ProGe::VHDLNetlistWriter::usesParameterWidth().

Here is the call graph for this function:

◆ hasParentBlock()

bool ProGe::BaseNetlistBlock::hasParentBlock ( ) const

virtual

Definition at line 353 of file BaseNetlistBlock.cc.

                                       {
    return parent_ != nullptr;
}

References parent_.

Referenced by DefaultDecoderGenerator::addGlockPortToDecoder(), addSubBlock(), ProGe::NetlistTools::parent(), parentBlock(), parentBlock(), ProGe::NetlistBlock::parentBlock(), ProGe::NetlistBlock::parentBlock(), removePort(), and setInstanceName().

◆ hasPortsBy()

bool ProGe::BaseNetlistBlock::hasPortsBy ( SignalType type ) const

virtual

Return true if the netlist block has at least one port by given Signal Type.

Definition at line 300 of file BaseNetlistBlock.cc.

                                                  {
    std::vector<const NetlistPort*> result;
    for (size_t i = 0; i < portCount(); i++) {
        const NetlistPort& port = this->port(i);
        if (port.assignedSignal().type() == type) {
            return true;
        }
    }
    return false;
}

References ProGe::NetlistPort::assignedSignal(), port(), portCount(), and ProGe::Signal::type().

Here is the call graph for this function:

◆ hasSubBlock()

bool ProGe::BaseNetlistBlock::hasSubBlock ( const std::string & instanceName ) const

virtual

Definition at line 160 of file BaseNetlistBlock.cc.

                                                                 {
    for (size_t i = 0; i < subBlockCount(); i++) {
        if (subBlock(i).instanceName() == instanceName) {
            return true;
        }
    }
    return false;
}

References subBlockCount().

Referenced by ProGe::NetlistTools::getUniqueInstanceName(), and setInstanceName().

Here is the call graph for this function:

◆ instanceName()

const std::string & ProGe::BaseNetlistBlock::instanceName ( ) const

Definition at line 135 of file BaseNetlistBlock.cc.

                                     {
    return instanceName_;
}

References instanceName_.

◆ isLeaf()

virtual bool ProGe::BaseNetlistBlock::isLeaf ( ) const

inlinevirtual

Returns true if the netlist block in the block hierarchy is a leaf block.

Leaf block are not modifiable: No ports, sub blocks or ports may be added or removed.

Definition at line 134 of file BaseNetlistBlock.hh.

134{ return true; }

◆ isSubBlock()

bool ProGe::BaseNetlistBlock::isSubBlock ( const BaseNetlistBlock & block ) const

virtual

Returns true if the given netlist block is sub block of this block.

Definition at line 173 of file BaseNetlistBlock.cc.

                                                                {
    return ContainerTools::containsValue(subBlocks_, &block);
}

References ContainerTools::containsValue(), and subBlocks_.

Here is the call graph for this function:

◆ isVirtual()

virtual bool ProGe::BaseNetlistBlock::isVirtual ( ) const

inlinevirtual

Reimplemented in ProGe::VirtualNetlistBlock.

Definition at line 112 of file BaseNetlistBlock.hh.

112{ return false; };

Referenced by ProGe::VHDLNetlistWriter::writeComponentDeclarations(), ProGe::VerilogNetlistWriter::writePortMappings(), ProGe::VHDLNetlistWriter::writePortMappings(), ProGe::VerilogNetlistWriter::writeSignalDeclarations(), and ProGe::VHDLNetlistWriter::writeSignalDeclarations().

◆ moduleName()

const std::string & ProGe::BaseNetlistBlock::moduleName ( ) const

Definition at line 140 of file BaseNetlistBlock.cc.

                                   {
    return moduleName_;
}

◆ name()

const std::string ProGe::BaseNetlistBlock::name ( ) const

Definition at line 145 of file BaseNetlistBlock.cc.

                             {
    return instanceName_ + " : " + moduleName();
}

Referenced by addParameter(), hasParameter(), parameter(), parameter(), setInstanceName(), setModuleName(), and ProGe::NetlistBlock::setParameter().

◆ netlist() [1/2]

Netlist & ProGe::BaseNetlistBlock::netlist ( )

protected

Definition at line 681 of file BaseNetlistBlock.cc.

                          {
    assert(netlist_ != nullptr);
    return *netlist_;
}

References assert, and netlist_.

◆ netlist() [2/2]

const Netlist & ProGe::BaseNetlistBlock::netlist ( ) const

virtual

Reimplemented in ProGe::NetlistBlock.

Definition at line 348 of file BaseNetlistBlock.cc.

                                {
    return *netlist_;
}

References netlist_.

Referenced by ProGe::ProcessorWrapperBlock::addInstructionMemory(), addPortGroup(), connectClocks(), connectResets(), ProGe::NetlistVisualization::listConnections(), ProGe::NetlistVisualization::listNetlistDescriptors(), removePort(), ProGe::NetlistPort::resolveRealWidth(), shallowCopy(), ProGe::VerilogNetlistWriter::write(), ProGe::VerilogNetlistWriter::writeBlock(), ProGe::VHDLNetlistWriter::writeBlock(), ProGe::VHDLNetlistWriter::writeConnection(), ProGe::VerilogNetlistWriter::writeNetlistParameterPackage(), ProGe::VHDLNetlistWriter::writeNetlistParameterPackage(), ProGe::VerilogNetlistWriter::writePortMappings(), ProGe::VHDLNetlistWriter::writePortMappings(), ProGe::VerilogNetlistWriter::writeSignalAssignments(), ProGe::VHDLNetlistWriter::writeSignalAssignments(), ProGe::VerilogNetlistWriter::writeSignalDeclarations(), and ProGe::VHDLNetlistWriter::writeSignalDeclarations().

◆ operator=()

BaseNetlistBlock & ProGe::BaseNetlistBlock::operator= ( const BaseNetlistBlock & )

private

◆ package()

const std::string & ProGe::BaseNetlistBlock::package ( size_t idx ) const

virtual

Reimplemented in ProGe::NetlistBlock.

Definition at line 699 of file BaseNetlistBlock.cc.

                                          {
    return packages_.at(idx);
}

References packages_.

Referenced by ProGe::ProcessorWrapperBlock::ProcessorWrapperBlock(), shallowCopy(), ProGe::VerilogNetlistWriter::writeBlock(), and ProGe::VHDLNetlistWriter::writeBlock().

◆ packageCount()

size_t ProGe::BaseNetlistBlock::packageCount ( ) const

virtual

Reimplemented in ProGe::NetlistBlock.

Definition at line 694 of file BaseNetlistBlock.cc.

                                     {
    return packages_.size();
}

References packages_.

Referenced by ProGe::ProcessorWrapperBlock::ProcessorWrapperBlock(), shallowCopy(), ProGe::VerilogNetlistWriter::writeBlock(), and ProGe::VHDLNetlistWriter::writeBlock().

◆ parameter() [1/3]

Parameter & ProGe::BaseNetlistBlock::parameter ( const std::string & name )

protected

Returns a Parameter object by name.

Exceptions

NotAvailable Thrown if the block does not have such Parameter.

Definition at line 217 of file BaseNetlistBlock.cc.

                                                 {
    for (size_t i = 0; i < parameterCount(); i++) {
        if (parameters_.at(i).name() == name) {
            return parameters_.at(i);
        }
    }
 
    throw NotAvailable(
        __FILE__, __LINE__, __func__,
        std::string("The block (") + instanceName() + ":" + moduleName() +
            ") does not have parameter \"" + name + "\"");
}

References __func__, instanceName(), moduleName(), name(), parameterCount(), and parameters_.

Here is the call graph for this function:

◆ parameter() [2/3]

const Parameter & ProGe::BaseNetlistBlock::parameter ( const std::string & name ) const

virtual

Returns a Parameter object by name.

Exceptions

NotAvailable Thrown if the block does not have such Parameter.

Reimplemented in ProGe::NetlistBlock.

Definition at line 198 of file BaseNetlistBlock.cc.

                                                       {
    for (size_t i = 0; i < parameterCount(); i++) {
        if (parameter(i).name() == name) {
            return parameter(i);
        }
    }
 
    throw NotAvailable(
        __FILE__, __LINE__, __func__,
        std::string("The block (") + instanceName() + ":" + moduleName() +
            ") does not have parameter \"" + name + "\"");
}

References __func__, instanceName(), moduleName(), name(), ProGe::Parameter::name(), parameter(), and parameterCount().

Referenced by hasParameter(), parameter(), ProGe::VHDLNetlistWriter::parameterWidthValue(), ProGe::NetlistVisualization::printBlockTree(), shallowCopy(), ProGe::VHDLNetlistWriter::writeComponentDeclarations(), ProGe::VerilogNetlistWriter::writeGenericDeclaration(), ProGe::VHDLNetlistWriter::writeGenericDeclaration(), ProGe::VerilogNetlistWriter::writePortMappings(), and ProGe::VHDLNetlistWriter::writePortMappings().

Here is the call graph for this function:

◆ parameter() [3/3]

const Parameter & ProGe::BaseNetlistBlock::parameter ( size_t index ) const

virtual

Reimplemented in ProGe::NetlistBlock.

Definition at line 236 of file BaseNetlistBlock.cc.

                                              {
    if (index >= parameterCount()) {
        throw OutOfRange(__FILE__, __LINE__, __func__);
    }
 
    return parameters_.at(index);
}

References __func__, parameterCount(), and parameters_.

Here is the call graph for this function:

◆ parameterCount()

size_t ProGe::BaseNetlistBlock::parameterCount ( ) const

virtual

Definition at line 231 of file BaseNetlistBlock.cc.

                                       {
    return parameters_.size();
}

References parameters_.

Referenced by PlatformIntegrator::copyProgeBlockToNetlist(), hasParameter(), parameter(), parameter(), parameter(), ProGe::NetlistVisualization::printBlockTree(), ProGe::NetlistBlock::shallowCopy(), shallowCopy(), ProGe::VHDLNetlistWriter::writeComponentDeclarations(), ProGe::VerilogNetlistWriter::writeGenericDeclaration(), ProGe::VHDLNetlistWriter::writeGenericDeclaration(), SOPCBuilderFileGenerator::writeGenerics(), ProGe::VerilogNetlistWriter::writePortMappings(), ProGe::VHDLNetlistWriter::writePortMappings(), and IPXactFileGenerator::writeProjectFiles().

◆ parentBlock() [1/2]

BaseNetlistBlock & ProGe::BaseNetlistBlock::parentBlock ( )

protectedvirtual

Reimplemented in ProGe::NetlistBlock.

Definition at line 364 of file BaseNetlistBlock.cc.

                              {
    assert(hasParentBlock());
    return *parent_;
}

References assert, hasParentBlock(), and parent_.

Here is the call graph for this function:

◆ parentBlock() [2/2]

const BaseNetlistBlock & ProGe::BaseNetlistBlock::parentBlock ( ) const

virtual

Reimplemented in ProGe::NetlistBlock.

Definition at line 358 of file BaseNetlistBlock.cc.

                                    {
    assert(hasParentBlock());
    return *parent_;
}

References assert, hasParentBlock(), and parent_.

Referenced by addSubBlock(), ProGe::NetlistTools::parent(), ProGe::NetlistBlock::parentBlock(), ProGe::NetlistBlock::parentBlock(), removePort(), and setInstanceName().

Here is the call graph for this function:

◆ port() [1/3]

const NetlistPort * ProGe::BaseNetlistBlock::port	(	const std::string &	portName,
		bool	partialMatch = `true`
	)		const

virtual

Returns a port that matches (partially) the given name.

Returns: The matching port. If not found, returns nullptr.

Reimplemented in ProGe::NetlistBlock.

Definition at line 317 of file BaseNetlistBlock.cc.

                                                                         {
    return findPort(portName, false, partialMatch);
}

References findPort().

Here is the call graph for this function:

◆ port() [2/3]

NetlistPort & ProGe::BaseNetlistBlock::port ( size_t index )

protectedvirtual

Reimplemented in ProGe::NetlistBlock.

Definition at line 322 of file BaseNetlistBlock.cc.

                                   {
    return *ports_.at(index);
}

References ports_.

◆ port() [3/3]

const NetlistPort & ProGe::BaseNetlistBlock::port ( size_t index ) const

virtual

Reimplemented in ProGe::NetlistBlock.

Definition at line 253 of file BaseNetlistBlock.cc.

                                         {
    return *ports_.at(index);
}

References ports_.

◆ portBy()

const NetlistPort & ProGe::BaseNetlistBlock::portBy	(	SignalType	type,
		size_t	index = `0`
	)		const

virtual

Returns a port by Signal Type at given index.

Parameters

The	list of ports by matching signal type at the index.

Exceptions

OutOfRange If the index is the number of found matches or larger.

Definition at line 284 of file BaseNetlistBlock.cc.

                                                            {
    std::vector<const NetlistPort*> matches = portsBy(type);
    if (index < matches.size()) {
        return *matches.at(index);
    } else {
        THROW_EXCEPTION(
            OutOfRange,
            "No port by signal at index " + Conversion::toString(index));
    }
}

References portsBy(), THROW_EXCEPTION, and Conversion::toString().

Here is the call graph for this function:

◆ portCount()

size_t ProGe::BaseNetlistBlock::portCount ( ) const

virtual

Return port count in this block including ports from netlist port groups.

Reimplemented in ProGe::NetlistBlock.

Definition at line 248 of file BaseNetlistBlock.cc.

                                  {
    return ports_.size();
}

References ports_.

Referenced by addSubBlock(), findPort(), hasPortsBy(), portsBy(), ProGe::NetlistVisualization::printBlockTree(), ProGe::ProcessorWrapperBlock::ProcessorWrapperBlock(), shallowCopy(), ProGe::VHDLNetlistWriter::writeComponentDeclarations(), ProGe::VerilogNetlistWriter::writePortDeclaration(), ProGe::VHDLNetlistWriter::writePortDeclaration(), ProGe::VerilogNetlistWriter::writePortMappings(), ProGe::VHDLNetlistWriter::writePortMappings(), ProGe::VerilogNetlistWriter::writeSignalAssignments(), ProGe::VHDLNetlistWriter::writeSignalAssignments(), ProGe::VerilogNetlistWriter::writeSignalDeclarations(), and ProGe::VHDLNetlistWriter::writeSignalDeclarations().

◆ portGroup()

const NetlistPortGroup & ProGe::BaseNetlistBlock::portGroup ( size_t index ) const

virtual

Definition at line 332 of file BaseNetlistBlock.cc.

                                              {
    return *portGroups_.at(index);
}

References portGroups_.

Referenced by addPortGroup(), portGroupsBy(), ProGe::ProcessorWrapperBlock::ProcessorWrapperBlock(), ProGe::NetlistBlock::shallowCopy(), and shallowCopy().

◆ portGroupCount()

size_t ProGe::BaseNetlistBlock::portGroupCount ( ) const

virtual

Definition at line 327 of file BaseNetlistBlock.cc.

                                       {
    return portGroups_.size();
}

References portGroups_.

Referenced by portGroupsBy(), ProGe::ProcessorWrapperBlock::ProcessorWrapperBlock(), ProGe::NetlistBlock::shallowCopy(), and shallowCopy().

◆ portGroupsBy()

std::vector< const NetlistPortGroup * > ProGe::BaseNetlistBlock::portGroupsBy ( SignalGroupType type ) const

virtual

Definition at line 337 of file BaseNetlistBlock.cc.

                                                         {
    std::vector<const NetlistPortGroup*> found;
    for (size_t i = 0; i < portGroupCount(); i++) {
        if (portGroup(i).assignedSignalGroup() == type) {
            found.push_back(&portGroup(i));
        }
    }
    return found;
}

References ProGe::NetlistPortGroup::assignedSignalGroup(), portGroup(), and portGroupCount().

Referenced by ProGe::ProcessorGenerator::instructionBus().

Here is the call graph for this function:

◆ ports()

PortContainerType & ProGe::BaseNetlistBlock::ports ( )

inline

Definition at line 125 of file BaseNetlistBlock.hh.

125{return ports_;}

References ports_.

◆ portsBy()

std::vector< const NetlistPort * > ProGe::BaseNetlistBlock::portsBy ( SignalType type ) const

virtual

Returns list of ports by Signal Type.

Parameters

The	list of ports by matching signal type in insertion order.

Definition at line 264 of file BaseNetlistBlock.cc.

                                               {
    std::vector<const NetlistPort*> result;
    for (size_t i = 0; i < portCount(); i++) {
        const NetlistPort& port = this->port(i);
        if (port.assignedSignal().type() == type) {
            result.push_back(&port);
        }
    }
    return result;
}

References ProGe::NetlistPort::assignedSignal(), port(), portCount(), and ProGe::Signal::type().

Referenced by connectClocks(), ProGe::Netlist::connectClocks(), connectResets(), ProGe::Netlist::connectResets(), and portBy().

Here is the call graph for this function:

◆ removePort()

void ProGe::BaseNetlistBlock::removePort ( NetlistPort * port )

protected

Removes the given port from the block.

After call the port is parent block reference is set to nullptr.

Definition at line 494 of file BaseNetlistBlock.cc.

                                              {
    assert(
        &port->parentBlock() == this &&
        "Attempted to remove a port the block does not have.");
 
    netlist().unregisterPort(*port);
    if (this->hasParentBlock()) {
        parentBlock().netlist().unregisterPort(*port);
    }
    ContainerTools::removeValueIfExists(ports_, port);
    port->setParent(nullptr);
}

References assert, hasParentBlock(), netlist(), parentBlock(), ProGe::NetlistPort::parentBlock(), port(), ports_, ContainerTools::removeValueIfExists(), ProGe::NetlistPort::setParent(), and ProGe::Netlist::unregisterPort().

Referenced by ProGe::NetlistPort::~NetlistPort().

Here is the call graph for this function:

◆ removePortGroup()

void ProGe::BaseNetlistBlock::removePortGroup ( NetlistPortGroup * portGroup )

protected

Definition at line 519 of file BaseNetlistBlock.cc.

                                                        {
    for (size_t i = 0; i < portGroups_.size(); i++) {
        if (portGroups_.at(i) == port) {
            ContainerTools::swapRemoveValue(portGroups_, i);
            break;
        }
    }
}

References port(), portGroups_, and ContainerTools::swapRemoveValue().

Here is the call graph for this function:

◆ removeSubBlock()

void ProGe::BaseNetlistBlock::removeSubBlock ( BaseNetlistBlock * subBlock )

protected

Removes sub block from this block and does not delete it.

Definition at line 449 of file BaseNetlistBlock.cc.

                                                           {
    // todo remove port descriptions of removed block in the netlist.
    for (size_t i = 0; i < subBlocks_.size(); i++) {
        if (subBlocks_.at(i) == subBlock) {
            ContainerTools::swapRemoveValue(subBlocks_, i);
        }
    }
}

References subBlock(), subBlocks_, and ContainerTools::swapRemoveValue().

Referenced by setParent(), and ~BaseNetlistBlock().

Here is the call graph for this function:

◆ setInstanceName()

void ProGe::BaseNetlistBlock::setInstanceName ( const std::string & name )

Replaces the instance name of the block.

The new name must be unique within sub blocks of parent block it is attached to.

Exceptions

ObjectAlreadyExists Thrown if the name is not unique.

Definition at line 379 of file BaseNetlistBlock.cc.

                                                       {
    if (hasParentBlock() && parentBlock().hasSubBlock(name)) {
        THROW_EXCEPTION(
            ObjectAlreadyExists, "New instance name of " + name +
                                     " is not unique within parent "
                                     "block of " +
                                     parentBlock().instanceName() + " : " +
                                     parentBlock().moduleName());
    }
    instanceName_ = name;
}

References hasParentBlock(), hasSubBlock(), instanceName(), instanceName_, moduleName(), name(), parentBlock(), and THROW_EXCEPTION.

Referenced by addSubBlock().

Here is the call graph for this function:

◆ setModuleName()

void ProGe::BaseNetlistBlock::setModuleName ( const std::string & name )

protected

Definition at line 392 of file BaseNetlistBlock.cc.

                                                     {
    moduleName_ = name;
}

References moduleName_, and name().

Referenced by ProGe::LoopBufferBlock::LoopBufferBlock().

Here is the call graph for this function:

◆ setParameter()

void ProGe::BaseNetlistBlock::setParameter ( const Parameter & param )

protected

Adds parameter to the block overwriting the existing one by name.

Definition at line 532 of file BaseNetlistBlock.cc.

                                                     {
    for (Parameter& p : parameters_) {
        if (p.name() == param.name()) {
            p = param;
            return;
        }
    }
    parameters_.push_back(param);
}

References ProGe::Parameter::name(), and parameters_.

Referenced by ProGe::LoopBufferBlock::LoopBufferBlock(), ProGe::SinglePortByteMaskSSRAMBlock::setAccessTraceFile(), ProGe::SinglePortSSRAMBlock::setAccessTraceFile(), ProGe::LoopBufferBlock::setBlockWidthParameter(), ProGe::LoopBufferBlock::setBufferSizeParameter(), ProGe::LoopBufferBlock::setCoreIdParameter(), ProGe::LoopBufferBlock::setIterationPortWidthParameter(), ProGe::LoopBufferBlock::setUsageTracingParameter(), and shallowCopy().

Here is the call graph for this function:

◆ setParent()

void ProGe::BaseNetlistBlock::setParent ( BaseNetlistBlock * newparent )

privatevirtual

Changes parent block to given one.

Definition at line 707 of file BaseNetlistBlock.cc.

                                                       {
    if (parent_ != nullptr && parent_ != newparent) {
        BaseNetlistBlock* oldParent = parent_;
        parent_ = nullptr;  // Prevent parent block causing recursive call of
        // setParent() when calling detachSubBlock().
        oldParent->removeSubBlock(this);
    }
    parent_ = newparent;
}

References parent_, and removeSubBlock().

Referenced by addSubBlock().

Here is the call graph for this function:

◆ shallowCopy()

BaseNetlistBlock * ProGe::BaseNetlistBlock::shallowCopy ( const std::string & instanceName = "" ) const

Creates new netlist block that only includes without of its subblocks or interconnections.

Definition at line 640 of file BaseNetlistBlock.cc.

                                                                 {
    BaseNetlistBlock* block = new BaseNetlistBlock(
        this->moduleName(),
        (!instanceName.empty()) ? instanceName : this->instanceName(),
        nullptr);
 
    for (size_t i = 0; i < this->parameterCount(); i++) {
        block->setParameter(this->parameter(i));
    }
    for (size_t i = 0; i < netlist().parameterCount(); i++) {
        block->netlist().setParameter(this->netlist().parameter(i));
    }
    std::map<std::string, NetlistPort*> copiedPorts;
    // Copy ports while preserving their insertion order.
    for (size_t i = 0; i < portCount(); i++) {
        NetlistPort* copiedPort = nullptr;
        copiedPort = BaseNetlistBlock::port(i).copyTo(*block);
        copiedPorts.insert({{copiedPort->name(), copiedPort}});
    }
    for (size_t i = 0; i < portGroupCount(); i++) {
        const NetlistPortGroup* portGrp = &portGroup(i);
        // Cloning to copy original class type, but clear ports as they are
        // already created and added to the new block.
        NetlistPortGroup* newGroup = portGrp->clone();
        newGroup->clear();
        for (auto port : *portGrp) {
            newGroup->addPort(*copiedPorts.at(port->name()));
        }
        block->addPortGroup(newGroup);
    }
    for (size_t i = 0; i < packageCount(); i++) {
        block->addPackage(this->package(i));
    }
 
    assert(
        block->portCount() == this->portCount() &&
        "Port count mismatch in shallow copy.");
    return block;
}

References addPackage(), ProGe::NetlistPortGroup::addPort(), addPortGroup(), assert, BaseNetlistBlock(), ProGe::NetlistPortGroup::clear(), ProGe::NetlistPortGroup::clone(), ProGe::NetlistPort::copyTo(), instanceName(), moduleName(), ProGe::NetlistPort::name(), netlist(), package(), packageCount(), parameter(), ProGe::Netlist::parameter(), parameterCount(), ProGe::Netlist::parameterCount(), port(), portCount(), portGroup(), portGroupCount(), setParameter(), and ProGe::Netlist::setParameter().

Here is the call graph for this function:

◆ subBlock() [1/2]

BaseNetlistBlock & ProGe::BaseNetlistBlock::subBlock ( size_t index )

protectedvirtual

Reimplemented in ProGe::NetlistBlock.

Definition at line 178 of file BaseNetlistBlock.cc.

                                       {
    return *subBlocks_.at(index);
}

References subBlocks_.

◆ subBlock() [2/2]

const BaseNetlistBlock & ProGe::BaseNetlistBlock::subBlock ( size_t index ) const

virtual

Definition at line 155 of file BaseNetlistBlock.cc.

                                             {
    return *subBlocks_.at(index);
}

Referenced by addSubBlock(), connectClocks(), ProGe::Netlist::connectClocks(), connectResets(), ProGe::Netlist::connectResets(), deleteSubBlock(), ProGe::NetlistVisualization::printBlockTree(), removeSubBlock(), ProGe::NetlistBlock::subBlock(), ProGe::VHDLNetlistWriter::writeComponentDeclarations(), ProGe::VerilogNetlistWriter::writePortMappings(), ProGe::VHDLNetlistWriter::writePortMappings(), ProGe::VerilogNetlistWriter::writeSignalAssignments(), ProGe::VHDLNetlistWriter::writeSignalAssignments(), ProGe::VerilogNetlistWriter::writeSignalDeclarations(), and ProGe::VHDLNetlistWriter::writeSignalDeclarations().

◆ subBlockCount()

size_t ProGe::BaseNetlistBlock::subBlockCount ( ) const

virtual

Reimplemented in ProGe::NetlistBlock.

Definition at line 150 of file BaseNetlistBlock.cc.

                                      {
    return subBlocks_.size();
}

Referenced by connectClocks(), connectResets(), hasSubBlock(), ProGe::NetlistVisualization::printBlockTree(), ProGe::VHDLNetlistWriter::writeComponentDeclarations(), ProGe::VerilogNetlistWriter::writePortMappings(), ProGe::VHDLNetlistWriter::writePortMappings(), ProGe::VerilogNetlistWriter::writeSignalAssignments(), ProGe::VHDLNetlistWriter::writeSignalAssignments(), ProGe::VerilogNetlistWriter::writeSignalDeclarations(), and ProGe::VHDLNetlistWriter::writeSignalDeclarations().

◆ write()

void ProGe::BaseNetlistBlock::write	(	const Path &	targetBaseDir,
		HDL	targetLang = `VHDL`
	)		const

overridevirtual

Does nothing on self but calls write function on each sub block.

Implements ProGe::IGenerationPhases.

Reimplemented in ProGe::LoopBufferBlock, ProGe::NetlistBlock, ProGe::ProcessorWrapperBlock, ProGe::SinglePortByteMaskSSRAMBlock, ProGe::SinglePortSSRAMBlock, and ProGe::TestBenchBlock.

Definition at line 614 of file BaseNetlistBlock.cc.

                                                                       {
    // Call write of each sub block //
    for (BaseNetlistBlock* subblock : subBlocks_) {
        subblock->write(targetBaseDir, targetLang);
    }
}

References subBlocks_.

Referenced by ProGe::NetlistBlock::write(), and ProGe::ProcessorWrapperBlock::write().

◆ writeSelf()

void ProGe::BaseNetlistBlock::writeSelf	(	const Path &	targetBaseDir,
		HDL	targetLang = `VHDL`
	)		const

virtual

Writes HDL source of itself only using default netlist writer.

Definition at line 625 of file BaseNetlistBlock.cc.

                                                                           {
    if (targetLang == HDL::VHDL) {
        VHDLNetlistWriter(*this).write(targetBaseDir.string());
    } else if (targetLang == HDL::Verilog) {
        VerilogNetlistWriter(*this).write(targetBaseDir.string());
    } else {
        THROW_EXCEPTION(NotAvailable, "Given HDL language is not supported.");
    }
}

References THROW_EXCEPTION, ProGe::Verilog, ProGe::VHDL, ProGe::VerilogNetlistWriter::write(), and ProGe::VHDLNetlistWriter::write().

Referenced by ProGe::ProcessorWrapperBlock::write().

Here is the call graph for this function:

Friends And Related Symbol Documentation

◆ NetlistPort

friend class NetlistPort

friend

Definition at line 61 of file BaseNetlistBlock.hh.

◆ NetlistPortGroup

friend class NetlistPortGroup

friend

Definition at line 62 of file BaseNetlistBlock.hh.

Referenced by ProGe::SinglePortByteMaskSSRAMBlock::SinglePortByteMaskSSRAMBlock(), and ProGe::SinglePortSSRAMBlock::SinglePortSSRAMBlock().

◆ Parameter

friend class Parameter

friend

Definition at line 63 of file BaseNetlistBlock.hh.

Referenced by ProGe::LoopBufferBlock::LoopBufferBlock(), ProGe::SinglePortByteMaskSSRAMBlock::setAccessTraceFile(), ProGe::SinglePortSSRAMBlock::setAccessTraceFile(), ProGe::LoopBufferBlock::setBlockWidthParameter(), ProGe::LoopBufferBlock::setBufferSizeParameter(), ProGe::LoopBufferBlock::setCoreIdParameter(), ProGe::LoopBufferBlock::setIterationPortWidthParameter(), ProGe::NetlistBlock::setParameter(), ProGe::LoopBufferBlock::setUsageTracingParameter(), ProGe::SinglePortByteMaskSSRAMBlock::SinglePortByteMaskSSRAMBlock(), and ProGe::SinglePortSSRAMBlock::SinglePortSSRAMBlock().

Member Data Documentation

◆ instanceName_

std::string ProGe::BaseNetlistBlock::instanceName_

private

The instance name of the block.

Definition at line 186 of file BaseNetlistBlock.hh.

Referenced by addSubBlock(), instanceName(), and setInstanceName().

◆ moduleName_

std::string ProGe::BaseNetlistBlock::moduleName_

private

The module name of the block.

Definition at line 188 of file BaseNetlistBlock.hh.

Referenced by setModuleName().

◆ netlist_

Netlist* ProGe::BaseNetlistBlock::netlist_

private

The netlist of the block.

Definition at line 184 of file BaseNetlistBlock.hh.

Referenced by addPort(), addSubBlock(), netlist(), and netlist().

◆ packages_

std::vector<std::string> ProGe::BaseNetlistBlock::packages_

private

The referenced packages by the module.

Definition at line 190 of file BaseNetlistBlock.hh.

Referenced by addPackage(), package(), and packageCount().

◆ parameters_

ParameterContainerType ProGe::BaseNetlistBlock::parameters_

private

The parameters of the block.

Definition at line 178 of file BaseNetlistBlock.hh.

Referenced by addParameter(), parameter(), parameter(), parameterCount(), and setParameter().

◆ parent_

BaseNetlistBlock* ProGe::BaseNetlistBlock::parent_

private

The reference to parent block of this block.

Definition at line 174 of file BaseNetlistBlock.hh.

Referenced by addPort(), BaseNetlistBlock(), hasParentBlock(), parentBlock(), parentBlock(), setParent(), and ~BaseNetlistBlock().

◆ portGroups_

PortGroupContainerType ProGe::BaseNetlistBlock::portGroups_

private

The ports of the block.

Definition at line 182 of file BaseNetlistBlock.hh.

Referenced by addPortGroup(), ProGe::NetlistBlock::netlist(), portGroup(), portGroupCount(), removePortGroup(), and ~BaseNetlistBlock().

◆ ports_

PortContainerType ProGe::BaseNetlistBlock::ports_

private

The ports of the block.

Definition at line 180 of file BaseNetlistBlock.hh.

Referenced by addPort(), findPort(), port(), port(), portCount(), ports(), and removePort().

◆ subBlocks_

BlockContainerType ProGe::BaseNetlistBlock::subBlocks_

private

The sub blocks of this netlist block.

Definition at line 176 of file BaseNetlistBlock.hh.

Referenced by addSubBlock(), deleteSubBlock(), isSubBlock(), ProGe::NetlistBlock::package(), removeSubBlock(), subBlock(), and write().

The documentation for this class was generated from the following files:

Public Types

Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Friends

Detailed Description

Member Typedef Documentation

◆ BlockContainerType

◆ ParameterContainerType

◆ PortContainerType

◆ PortGroupContainerType

Constructor & Destructor Documentation

◆ BaseNetlistBlock() [1/4]

◆ BaseNetlistBlock() [2/4]

◆ BaseNetlistBlock() [3/4]

◆ ~BaseNetlistBlock()

◆ BaseNetlistBlock() [4/4]

Member Function Documentation

◆ addPackage()

◆ addParameter()

◆ addPort()

◆ addPortGroup()

◆ addSubBlock()

◆ build()

◆ connect()

◆ connectClocks()

◆ connectResets()

◆ deleteSubBlock()

◆ finalize()

◆ findPort()

◆ hasParameter()

◆ hasParentBlock()

◆ hasPortsBy()

◆ hasSubBlock()

◆ instanceName()

◆ isLeaf()

◆ isSubBlock()

◆ isVirtual()

◆ moduleName()

◆ name()

◆ netlist() [1/2]

◆ netlist() [2/2]

◆ operator=()

◆ package()

◆ packageCount()

◆ parameter() [1/3]

◆ parameter() [2/3]

◆ parameter() [3/3]

◆ parameterCount()

◆ parentBlock() [1/2]

◆ parentBlock() [2/2]

◆ port() [1/3]

◆ port() [2/3]

◆ port() [3/3]

◆ portBy()

◆ portCount()

◆ portGroup()

◆ portGroupCount()

◆ portGroupsBy()

◆ ports()

◆ portsBy()

◆ removePort()

◆ removePortGroup()

◆ removeSubBlock()

◆ setInstanceName()

◆ setModuleName()

◆ setParameter()

◆ setParent()

◆ shallowCopy()

◆ subBlock() [1/2]

◆ subBlock() [2/2]

◆ subBlockCount()

◆ write()

◆ writeSelf()

Friends And Related Symbol Documentation

◆ NetlistPort

◆ NetlistPortGroup

◆ Parameter

Member Data Documentation