ProGe::NetlistTools Class Reference

#include <NetlistTools.hh>

Collaboration diagram for ProGe::NetlistTools:

Static Public Member Functions
static std::pair< const BaseNetlistBlock *, size_t >	commonParent (const BaseNetlistBlock &b1, const BaseNetlistBlock &b2)
static void	addPrefixToPortNames (NetlistPortGroup &portGroup, const std::string &prefix)
static void	addPrefixToPortName (NetlistPort &port, const std::string &prefix)
static size_t	renamePorts (NetlistPortGroup &portGroup, std::map< SignalType, const std::string > &&renameRules)
static std::string	getUniqueInstanceName (const BaseNetlistBlock &within, const std::string &basename)
static const BaseNetlistBlock *	parent (const BaseNetlistBlock &block)
static const BaseNetlistBlock *	parent (const BaseNetlistBlock *block)
static Direction	mirror (Direction direction)
static NetlistPort *	mirror (NetlistPort *port)

Detailed Description

Definition at line 52 of file NetlistTools.hh.

Member Function Documentation

addPrefixToPortName()

void ProGe::NetlistTools::addPrefixToPortName ( NetlistPort &  port, const std::string &  prefix  )

static

Renames port by adding prefix into it.

Definition at line 117 of file NetlistTools.cc.

                                                {
    port.rename(prefix + port.name());
}

References ProGe::NetlistPort::name(), and ProGe::NetlistPort::rename().

Referenced by addPrefixToPortNames().

Here is the call graph for this function:

addPrefixToPortNames()

void ProGe::NetlistTools::addPrefixToPortNames ( NetlistPortGroup &  portGroup, const std::string &  prefix  )

static

Renames ports by adding prefix into them.

Definition at line 106 of file NetlistTools.cc.

                                                          {
    for (NetlistPort* port : portGroup) {
        addPrefixToPortName(*port, prefix);
    }
}

References addPrefixToPortName().

Here is the call graph for this function:

commonParent()

std::pair< const BaseNetlistBlock *, size_t > ProGe::NetlistTools::commonParent ( const BaseNetlistBlock &  b1, const BaseNetlistBlock &  b2  )

static

Finds common parent block of given netlist blocks and maximum distance to the common parent.

Distance is calculated how many times parent block pointer is needed to followed to get to the common parent block.

Returns

Returns found common parent and maximum distance to the parent as pair. The first member is the common parent and the second is the distance. If common parent has not found return (NULL, 0).

Definition at line 59 of file NetlistTools.cc.

                                                            {
    // Todo check trivial cases: b1 id parent of b2 or vice versa.
 
    std::set<const BaseNetlistBlock*> parentChain;
 
    const BaseNetlistBlock* block = &b1;
    do {
        parentChain.insert(block);
    } while ((block = parent(block)));
 
    const BaseNetlistBlock* found = NULL;
    block = &b2;
    do {
        if (parentChain.count(block)) {
            found = block;
            break;
        }
    } while ((block = parent(block)));
 
    if (found == NULL) {
        return std::make_pair(found, 0);
    }
 
    size_t distance = 0;
    block = &b1;
    size_t hops = 0;
    while (block != found) {
        hops++;
        block = parent(block);
    }
    distance = hops;
    block = &b2;
    hops = 0;
    while (block != found) {
        hops++;
        block = parent(block);
    }
    distance = std::max(distance, hops);
 
    return std::make_pair(found, distance);
}

References parent().

Here is the call graph for this function:

getUniqueInstanceName()

std::string ProGe::NetlistTools::getUniqueInstanceName ( const BaseNetlistBlock &  within, const std::string &  basename  )

static

Returns a string that is unique within the given netlist block.

That is, the string as instance name does not clash with any of the immediate sub block of the given netlist block.

Parameters

within	The netlist block.
basename	The string used as base for the instance name.

Returns

The unique instance name. May be the given base name if it itself is unique within the block. Otherwise the the returned string is base name postfixed with a running number.

Definition at line 155 of file NetlistTools.cc.

                                                               {
    std::string name(basename);
    while (within.hasSubBlock(name)) {
        int postFixNumber = -1;
        std::string::iterator it;
        std::string::reverse_iterator rit;
        for (rit = name.rbegin(); rit != name.rend(); rit++) {
            std::locale loc;
            if (!std::isdigit(*rit, loc)) {
                it = rit.base();  // Points to first number digit or end().
                break;
            }
        }
        if (it != name.end()) {
            postFixNumber = Conversion::toInt(std::string(it, name.end()));
        }
        postFixNumber++;
        name.replace(it, name.end(), Conversion::toString(postFixNumber));
    }
    return name;
}

References ProGe::BaseNetlistBlock::hasSubBlock(), Conversion::toInt(), and Conversion::toString().

Referenced by ProGe::BaseNetlistBlock::addSubBlock().

Here is the call graph for this function:

mirror() [1/2]

Direction ProGe::NetlistTools::mirror ( Direction  direction )

static

Returns given direction mirrored.

Definition at line 202 of file NetlistTools.cc.

                                        {
    switch (direction) {
        case IN:
            return OUT;
            break;
        case OUT:
            return IN;
            break;
        case BIDIR:
            return BIDIR;
            break;
        default:
            assert(false && "Unregocnized direction.");
            return IN;
    }
}

References assert, ProGe::BIDIR, ProGe::IN, and ProGe::OUT.

Referenced by ProGe::PortFactory::createPort(), mirror(), and ProGe::NetlistPort::NetlistPort().

mirror() [2/2]

NetlistPort * ProGe::NetlistTools::mirror ( NetlistPort *  port )

static

Mirrors ports direction.

Definition at line 223 of file NetlistTools.cc.

                                      {
    port->setDirection(mirror(port->direction()));
    return port;
}

References ProGe::NetlistPort::direction(), mirror(), and ProGe::NetlistPort::setDirection().

Here is the call graph for this function:

parent() [1/2]

const BaseNetlistBlock * ProGe::NetlistTools::parent ( const BaseNetlistBlock &  block )

static

Returns parent of the given block or NULL if the block does not have one.

Definition at line 182 of file NetlistTools.cc.

                                                  {
    return parent(&block);
}

Referenced by commonParent().

parent() [2/2]

const BaseNetlistBlock * ProGe::NetlistTools::parent ( const BaseNetlistBlock *  block )

static

Returns parent of the given block or NULL if the block does not have one.

Definition at line 190 of file NetlistTools.cc.

                                                  {
    if (!block->hasParentBlock()) {
        return NULL;
    } else {
        return &block->parentBlock();
    }
}

References ProGe::BaseNetlistBlock::hasParentBlock(), and ProGe::BaseNetlistBlock::parentBlock().

Here is the call graph for this function:

renamePorts()

size_t ProGe::NetlistTools::renamePorts ( NetlistPortGroup &  portGroup, std::map< SignalType, const std::string > &&  renameRules  )

static

Renames ports in netlist port group by given rules.

returns number of ports left renamed.

Definition at line 128 of file NetlistTools.cc.

                                                       {
    size_t renamedCount = 0;
    for (NetlistPort* port : portGroup) {
        SignalType type = port->assignedSignal().type();
        if (renameRules.count(type)) {
            port->rename(renameRules.at(type));
            renamedCount++;
        }
    }
    return portGroup.portCount() - renamedCount;
}

---

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

• NetlistTools.hh
• NetlistTools.cc