oaverilogcallbacksout.cpp

openaccess与verilog互相转化时所用的源代码

// *****************************************************************************
// CallbacksOut::getNetExpr()
//
// This function transforms the given oaModNet into a valid net expression for
// IEEE 1364-2001 Verilog. Scalar, vector and vector bit names are left
// untouched (unless they represent a global name). Bundle names are
// transformed into Verilog concatenations or numerical constants (as
// appropriate).
// *****************************************************************************
NetExprType
CallbacksOut::getNetExpr(oaModNet   *net,
			 oaString   &netExpr,
			 oaBoolean  addPrefix)
{
    NetExprType	exprType;

    switch (net->getType()) {
      case oacModScalarNetType:
	exprType = getNetExpr((oaModScalarNet*) net, netExpr);
	break;

      case oacModBusNetType:
	exprType = getNetExpr((oaModBusNet*) net, netExpr);
	break;

      case oacModBusNetBitType:
	exprType = getNetExpr((oaModBusNetBit*) net, netExpr);
        break;

      case oacModBundleNetType:
	exprType = getNetExpr((oaModBundleNet*) net, netExpr);
	break;
    }

    if (addPrefix) {
	if (exprType == NameOneTicBZero || exprType == NameOneTicBOne) {
	    netExpr = numBits(netExpr) + binaryPrefix + netExpr;
	}
    } 

    return exprType;
}



// *****************************************************************************
// CallbacksOut::getNetExpr()
//
// These functions the given oaModNet into a valid net expression for IEEE
// 1364-2001 Verilog.
// *****************************************************************************
NetExprType
CallbacksOut::getNetExpr(oaModScalarNet	*net,
			 oaString	&netExpr)
{
    if (isTieHigh(net)) {
	netExpr = "1";
	return NameOneTicBOne;
    } else if (isTieLow(net)) {
	netExpr = "0";
	return NameOneTicBZero;
    }

    net->getName(verNS, netExpr);

    if (net->isGlobal()) {
	netExpr = options.getGlobalModuleName() + hierSep + netExpr;
    }

    return NameIsNet;
}

NetExprType
CallbacksOut::getNetExpr(oaModBusNet	*net,
			 oaString	&netExpr)
{
    if (net->getNumBits() == net->getDef()->getNumBits() && !net->isGlobal()) {
	net->getDef()->getName(verNS, netExpr);
    } else {
	net->getName(verNS, netExpr);
    }

    if (net->isGlobal()) {
	netExpr = options.getGlobalModuleName() + hierSep + netExpr;
    }

    return NameIsNet;
}

NetExprType
CallbacksOut::getNetExpr(oaModBusNetBit	*net,
			 oaString	&netExpr)
{
    if ((net->getDef()->getNumBits() == 1) && !net->isGlobal()) {
	net->getDef()->getName(verNS, netExpr);
    } else {
	net->getName(verNS, netExpr);
    }

    if (net->isGlobal()) {
	netExpr = options.getGlobalModuleName() + hierSep + netExpr;
    }

    return NameIsNet;
}

NetExprType
CallbacksOut::getNetExpr(oaModBundleNet	*net,
			 oaString	&netExpr)
{
    oaModNet		*member = net->getMember(0);
    oaString		numExpr;
    oaString		memExpr;
    NetExprType		memType = getNetExpr(member, memExpr, false);
    NetExprType		returnType;
    NetExprType		lastType;
    oaUInt4		nbits;
    oaBoolean		addedSep = false;

    initConcat(memType, memExpr, net->getRepeat(0), netExpr, numExpr, nbits,
	       lastType, addedSep);

    returnType = lastType;

    for (oaUInt4 i = 1; i < net->getNumMembers(); i++) {
	combineMembers(getNetExpr(net->getMember(i), memExpr, false), 
		       lastType, memExpr, netExpr, numExpr, 
		       net->getRepeat(i), nbits, addedSep);
	
	if (returnType != NameIsNet) {
	    returnType = lastType;
	}
    }

    if (!numExpr.isEmpty()) {
	addNumPrefix(numExpr, netExpr, nbits, addedSep);
    }

    if (returnType == NameIsNet
	&& (net->getNumMembers() != 1 || net->getRepeat(0) != 1)) {
	netExpr = concatPrefix + netExpr + concatSuffix;
    }

    return returnType;
}



// *****************************************************************************
// CallbacksOut::initConcat()
//
// This function initializes a concatenation of net expressions.
// *****************************************************************************
void
CallbacksOut::initConcat(const NetExprType  memType,
			 const oaString	    &memExpr,
			 const oaUInt4	    repeat,
			 oaString	    &netExpr,
			 oaString	    &numExpr,
			 oaUInt4	    &nbits,
			 NetExprType	    &lastType,
			 oaBoolean	    &addedSep) const
{
    if (memType == NameOneTicBOne || memType == NameOneTicBZero) {
	netExpr = "";
	numExpr = binaryPrefix + memExpr;
	nbits = 1;
	lastType = NameIsNumber;
    } else {
	netExpr = memExpr;
	numExpr = "";
	nbits = 0;
	lastType = NameIsNet;
    }

    if (repeat > 1) {
	combineMembers(memType, lastType, memExpr, netExpr, numExpr, 
		       repeat - 1, nbits, addedSep);
    }
}



// *****************************************************************************
// CallbacksOut::combineMembers()
//
// This function combines the net expressions of a bundle net into a Verilog
// concatenation.
// *****************************************************************************
void
CallbacksOut::combineMembers(const NetExprType	currentType,
			     NetExprType	&lastType,
			     const oaString	&memExpr,
			     oaString		&netExpr,
			     oaString		&numExpr,
			     const oaUInt4	repeat,
			     oaUInt4		&nbits,
			     oaBoolean		&addedSep) const
{
    if (currentType == NameIsNet && lastType != NameIsNet) {
	netExpr += intToStr(nbits) + numExpr;

	for (oaUInt4 i = 0; i < repeat; i++) {
	    netExpr += concatSep + memExpr;
	}

	numExpr = "";
	nbits = 0;
	lastType = NameIsNet;
	addedSep = false;
    } else if (currentType != NameIsNet && lastType == NameIsNet) {
	if (!addedSep) {
	    netExpr += concatSep;
	    addedSep = true;
	}

	numExpr = binaryPrefix;

	for (oaUInt4 i = 0; i < repeat; i++) {
	    numExpr += memExpr;
	}

	nbits = repeat;
	lastType = NameIsNumber;
    } else if (currentType == NameIsNet && lastType == NameIsNet) {
	for (oaUInt4 i = 0; i < repeat; i++) {
	    netExpr += concatSep + memExpr;
	}

	numExpr = "";
	nbits = 0;
	lastType = NameIsNet;
    } else {
	for (oaUInt4 i = 0; i < repeat; i++) {
	    numExpr += memExpr;
	}

	nbits += repeat;
	lastType = nbits > 1 ? NameIsNumber : currentType;
    }
}



// *****************************************************************************
// CallbacksOut::addNumPrefix()
//
// This function adds the number of bits prefix to the numerical representation
// of a tieHi/tieLo bundle and returns the result into netExpr.
// *****************************************************************************
void
CallbacksOut::addNumPrefix(oaString	&numExpr,
			   oaString	&netExpr,
			   oaUInt4	nbits,
			   oaBoolean	addedSep) const
{
    if (!netExpr.isEmpty() && !addedSep) {
	netExpr += concatSep;
    }

    netExpr += intToStr(nbits) + numExpr;
}



// *****************************************************************************
// CallbacksOut::collectTerms()
//
// This function produces a single portID and netExpr for terminals that are 
// marked as being part of the interface.  Terminals which are not marked will
// be skipped.
// *****************************************************************************
oaBoolean
CallbacksOut::collectTerms(TermIter &termIter,
			   oaString &portID,
			   oaString &netExpr)
{
    while (termIter != terms.end() && !testProduceTerm(*termIter)) {
	termIter++;
    }

    if (termIter == terms.end()) {
	return false;
    }

    oaModTerm	*term = *termIter++;
    oaName	termName;
    oaName	netName;

    getTermName(term, termName);
    getNetName(term->getNet(), netName);

    if (termName.getType() == oacScalarNameType) {
	nameToPortID(termName, portID);
	getNetExpr(term->getNet(), netExpr);
    } else {
	getNetExpr(term->getNet(), netExpr);
	portID = netExpr;
    }

    return true;
}



// *****************************************************************************
// CallbacksOut::collectInstTerms()
//
// This function produces a single portID and netExpr for InstTerms. This
// function is used when the instance is not bound.
// *****************************************************************************
oaBoolean 
CallbacksOut::collectInstTerms(InstTermIter &termIter,
			       Connection   &connection)
{
    if (termIter == iterms.end()) {
	return false;
    }

    oaModInstTerm   *iterm = *termIter++;

    oaModTerm	    *term = iterm->getTerm();
    oaModNet	    *net = iterm->getNet();
    oaString	    netExpr;

    getNetExpr(net, netExpr);

    oaString	portID;
    oaUInt4	position;

    if (term) {
	oaName	termName;

	getTermName(term, termName);
	nameToPortID(termName, portID);
	position = termPosition->get(term);
    } else {
	if (getInstTermName(iterm, portID)) {
	    position = oacNullIndex;
	} else {
	    position = iterm->getTermPosition();
	    portID = "";
	}
    }

    if (portID.isEmpty()) {
	connection.init(netExpr, position);
    } else {
	connection.init(portID, netExpr);
	connection.setPosition(position);
    }

    return true;
}



// *****************************************************************************
// CallbacksOut::appendToName()
//
// This function appends the source (src) name to the destination (dest) name.
// If the destination name is empty or if the last member of the destination
// name is a bus (or bus bit) and the source name is a bus bit then the range 
// of the bus is extended to include the source bit. Otherwise, a bundle name
// is formed and the source name is added as the last member of the bundle.
// *****************************************************************************
void    
CallbacksOut::appendToName(const oaName	&src,
			   oaName	&dest)
{
    switch (dest.getType()) {
      case oacEmptyNameType:
	dest = src;
	break;

      case oacScalarNameType:
	addToBundle(src, dest);
	break;

      case oacVectorNameType:
	if (src.getType() == oacVectorBitNameType) {
	    combineBitWithVector(src.getVectorBit(), dest);
	} else {
	    addToBundle(src, dest);
	}
	break;

      case oacVectorBitNameType:
	if (src.getType() == oacVectorBitNameType) {
	    combineBitWithBit(src.getVectorBit(), dest);
	} else {
	    addToBundle(src, dest);
	}
	break;

      case oacBundleNameType:
	{
	    oaBundleName    *destBundle = dest.getBundle();
	    oaUInt4	    lastIndex = destBundle->getNumMembers() - 1;
	    oaName	    lastMember = (*destBundle)[lastIndex];
	    oaUInt4	    lastRepeat = (*destBundle)[lastIndex].getRepeat();

	    appendToName(src, lastMember);

	    oaBundleName    newBundle;

	    for (oaUInt4 i = 0; i < lastIndex; i++) {
		oaUInt4	repeat = (*destBundle)[i].getRepeat();

		for (oaUInt4 j = 0; j < repeat; j++) {
		    newBundle.append((*destBundle)[i]);
		}
	    }

	    dest = newBundle;

	    if (lastMember.getType() == oacBundleNameType) {
		if (lastMember.getBundle()->getNumMembers() == 2) {
		    for (oaUInt4 i = 0; i < lastRepeat; i++) {
			addToBundle((*lastMember.getBundle())[0], dest);
		    }

		    addToBundle((*lastMember.getBundle())[1], dest);
		} else {
		    for (oaUInt4 i = 0; i < lastRepeat + 1; i++) {
			addToBundle((*lastMember.getBundle())[0], dest);
		    }
		}
	    } else {
		addToBundle(lastMember, dest);
	    }
	}

	break;
    }
}



// *****************************************************************************
// CallbacksOut::addToBundle()
//
// This function adds the source name to the destination name as a bundle.  If
// the destination name is not already a bundle, then it will become a bundle
// and the first element of the destination name will be the original
// destination name.
// *****************************************************************************
void  
CallbacksOut::addToBundle(const	oaName	&src,
			  oaName	&dest)
{