oalefoutpin.cpp

openaccess读def,lef文件所用的源代码

// *****************************************************************************
// *****************************************************************************
// LefOutPin.cpp
//
// This file contains the member functions for the LefOutPin class.
//
// *****************************************************************************
// Except as specified in the OpenAccess terms of use of Cadence or Silicon
// Integration Initiative, this material may not be copied, modified,
// re-published, uploaded, executed, or distributed in any way, in any medium,
// in whole or in part, without prior written permission from Cadence.
//
//                Copyright 2002-2005 Cadence Design Systems, Inc.
//                           All Rights Reserved.
//
//  $Author: nitters $
//  $Revision: 1.48 $
//  $Date: 2005/06/23 18:32:25 $
//  $State: Exp $
// *****************************************************************************
// *****************************************************************************



#include "oaLefDef.h"

BEGIN_LEFDEF_NAMESPACE



// *****************************************************************************
// LefOutPin::LefOutPin()
// LefOutPin::~LefOutPin()
// 
// This is the default constructor for the LefOutPin class
// *****************************************************************************
LefOutPin::LefOutPin(LefOut &lefOutIn)
:   lefOut(lefOutIn)
{
    lefOutIn.lefOutPin = this;
}

LefOutPin::~LefOutPin()
{
}



// *****************************************************************************
// LefOutPin::write()
// 
// This function outputs a PIN definition for this terminal.
// The first weakPinGroup without the mustjoin property
// will be written out as the main PIN. Subsequent weakPinGroups
// on a terminal will be written out as separate LEF MUSTJOIN pins.
// If extra weakPinGroups do not have the mustjoin property,
// "_MJ<pinnumber>" is appended to the name.
// *****************************************************************************
void
LefOutPin::write(oaBitTerm  *termIn)
{
    term = termIn;
    
    oaString	pinName;
    term->getName(lefOut.getNS(), pinName);

    lefOut.output("PIN %s\n", (const char*) pinName);
    lefOut.incIndent();
	    
    writeMustJoin();
    writeTaperRule();
    writeDirection();
    writeUse();
    writeShape();

    if (lefOut.getOptions()->getVersion() > cLefDefVersion53) {
	writeAntenna();
    }

    if (lefOut.getOptions()->getVersion() > cLefDefVersion55) {
	writeSensitivity();
	writeNetExpr();
    }
    
    oaIter<oaPin>   pinIter(term->getPins());
    while (oaPin *pin = pinIter.getNext()) {
	writePort(pin);
    }

    lefOut.writeProperties(term, cLefDefPin);

    lefOut.decIndent();
    lefOut.output("END %s\n", (const char*) pinName);
}



// *****************************************************************************
// LefOutPin::writeTaperRule()
// 
// This function outputs the TAPERRULE construct for this pin, syntax:
// TAPERRULE ruleName ;
// *****************************************************************************
void
LefOutPin::writeTaperRule()
{
    oaNet *net = term->getNet();

    if (net && net->hasConstraintGroup()) {
	oaConstraintGroup		*rules = net->getConstraintGroup();
	oaIter<oaConstraintGroupMem>	cgmIter(rules->getMembers());
	oaConstraintGroupMem		*cgm;
	oaBoolean			output = false;

	while ((cgm = cgmIter.getNext()) && !output) {
	    oaConstraintGroup   *rule = NULL;
	    
	    if (cgm->getObject()->getType() == oacConstraintGroupHeaderType) {
		rule = ((oaConstraintGroupHeader*) cgm->getObject())->getConstraintGroup();
	    } else if (cgm->getObject()->getType() == oacConstraintGroupType) {
		rule = (oaConstraintGroup*) cgm->getObject();
	    }
		
	    if (rule && lefOut.isLefDefRule(rule)) {
		oaString    name;

		rule->getName(name);
		lefOut.output("TAPERRULE %s ;\n", (const char *) name);
		output = true;
	    }
	}
    }
}



// *****************************************************************************
// LefOutPin::writeDirection()
// 
// This function outputs a DIRECTION for this terminal, taken from the
// termType, syntax:
// [DIRECTION {INPUT | OUTPUT [TRISTATE] | INOUT | FEEDTHRU} ;]
// *****************************************************************************
void
LefOutPin::writeDirection()
{
    oaString       dir;

    switch (term->getTermType()) {
      case oacInputTermType:
	dir = "INPUT";
	break;
      case oacOutputTermType:
	dir = "OUTPUT";
	break;
      case oacInputOutputTermType:
	dir = "INOUT";
	break;
      case oacJumperTermType:
	dir = "FEEDTHRU";
	break;
      case oacTristateTermType:
	dir = "OUTPUT TRISTATE";
	break;
      default:
	return;
    }

    lefOut.output("DIRECTION %s ;\n", (const char*) dir);
}



// *****************************************************************************
// LefOutPin::writeUse()
// 
// This function outputs the USE construct taken from the signalType of the net
// associated with the terminal, syntax:
// [USE { SIGNAL | ANALOG | POWER | GROUND | CLOCK } ;]
// *****************************************************************************
void
LefOutPin::writeUse()
{
    oaNet	*net = term->getNet();
    oaString	use;

    switch (net->getSigType()) {
      case oacSignalSigType:
	use = "SIGNAL";
	break;
      case oacPowerSigType:
	use = "POWER";
	break;
      case oacGroundSigType:
	use = "GROUND";
	break;
      case oacClockSigType:
	use = "CLOCK";
	break;
      case oacAnalogSigType:
	use = "ANALOG";
	break;
      default:
	return;
    }
    
    lefOut.output("USE %s ;\n", (const char*) use);
}



// *****************************************************************************
// LefOutPin::writeShape()
// 
// This function outputs the pin shape, syntax:
// [SHAPE {ABUTMENT | RING | FEEDTHRU} ;]
// *****************************************************************************
void
LefOutPin::writeShape()
{
    oaString	shape;

    switch (term->getPinConnectMethod()) {
      case oacAbutPinConnectMethod:
	shape = "ABUTMENT";
	break;
      case oacRingPinConnectMethod:
	shape = "RING";
	break;
      case oacFeedthruPinConnectMethod:
	shape = "FEEDTHRU";
	break;
      default:
	return;
    }
    
    lefOut.output("SHAPE %s ;\n", (const char*) shape);
}



// *****************************************************************************
// LefOutPin::writeMustJoin()
// 
// This function outputs the must-join construct. MustJoin terminals are only
// output if the referenced terminal is already output.
// Syntax:
// [MUSTJOIN pinName ;]
// *****************************************************************************
void
LefOutPin::writeMustJoin()
{
    oaIter<oaBitTerm>	mjTermIter(term->getMustJoinTerms());
    
    while (oaBitTerm *mjTerm = mjTermIter.getNext()) {
	oaIter<oaTerm>	termIter(term->getBlock()->getTerms(oacTermIterSingleBit | oacTermIterEquivNets));
	oaTerm		*t;

	while ((t = termIter.getNext()) && t != term) {
	    if (t == mjTerm) {
		oaString    pinName;

		mjTerm->getName(lefOut.getNS(), pinName);
		lefOut.output("MUSTJOIN %s ;\n", (const char*) pinName);
		return;
	    }
	}
    }
}



// *****************************************************************************
// LefOutPin::writePort()
// 
// This function output the port information for OA weak pin groups.
// Pins can be directly associated with the pinGroup, or can be grouped
// in OA strong pin groups. Strong pin groups and pins belonging to the
// weak pin group are output as separate LEF PORTs.
//
// PORT 
//    [CLASS {NONE | CORE} ;] 
//    layerGeometries... 
// END... 
// *****************************************************************************
void
LefOutPin::writePort(oaPin *pin)
{
    lefOut.output("PORT\n");
    lefOut.incIndent();

    oaBooleanProp   *p = (oaBooleanProp*) oaProp::find(pin, cLefPinClassCore);
	
    if (p && p->getValue()) {
	lefOut.output("CLASS CORE ;\n");
    }

    oaIter<oaPinFig>	figIter(pin->getFigs());
    
    lefOut.getLefOutGeom()->reset();
    while(oaPinFig  *fig = figIter.getNext()) {
	lefOut.getLefOutGeom()->writeFig(fig);
    }

    lefOut.decIndent();
    lefOut.output("END\n"); 
}



// *****************************************************************************
// LefOutPin::writeAntenna()
// 
// This function outputs the antenna constructs, syntax:
//     [ANTENNAPARTIALMETALAREA value [LAYER layerName] ;]...
//     [ANTENNAPARTIALMETALSIDEAREA value [LAYER layerName] ;]...
//     [ANTENNAGATEAREA value [LAYER layerName] ;]...
//     [ANTENNADIFFAREA value [LAYER layerName] ;]...
//     [ANTENNAMAXAREACAR value LAYER layerName ;]
//     [ANTENNAMAXSIDEAREACAR value LAYER layerName ;]
//     [ANTENNAPARTIALCUTAREA value [LAYER layerName] ;]
//     [ANTENNAMAXCUTCAR value LAYER layerName ;] 
// *****************************************************************************
void
LefOutPin::writeAntenna()
{
    if (!term->isAntennaDataSet()) {
	return;
    }

    oaUInt4 i(0);
    oaAntennaData data;
    term->getAntennaData(data);
    writeAntennaGeneric(data);

    if (lefOut.getOptions()->getVersion() < cLefDefVersion55) {
        writeAntennaModel(data);
        return;
    }
    
    lefOut.output("ANTENNAMODEL OXIDE1 ;\n");
    lefOut.incIndent();
    writeAntennaModel(data);
    lefOut.decIndent();

    if (term->isAntennaDataSet(oacSecondAntennaModel)) {
        term->getAntennaData(data, oacSecondAntennaModel);
        lefOut.output("ANTENNAMODEL OXIDE2 ;\n");
        lefOut.incIndent();
        writeAntennaModel(data);
        lefOut.decIndent();
    }
}



// *****************************************************************************
// LefOutPin::writeGeneric()
// 
// This function outputs the antenna constructs, syntax:
//     [ANTENNAPARTIALMETALAREA value [LAYER layerName] ;]...
//     [ANTENNAPARTIALMETALSIDEAREA value [LAYER layerName] ;]...
//     [ANTENNADIFFAREA value [LAYER layerName] ;]...
//     [ANTENNAPARTIALCUTAREA value [LAYER layerName] ;]
// *****************************************************************************
void
LefOutPin::writeAntennaGeneric(oaAntennaData	&data)
{
    // Partial Metal Area
    oaUInt4 i(0);
    for (i; i < data.partialMetal().getNumElements(); i++) {
	lefOut.output("ANTENNAPARTIALMETALAREA %.11g ",
		      lefOut.dbuToUUArea(data.partialMetal()[i].area()));
	writeAntennaLayer(data.partialMetal()[i].layerNum());
	lefOut.outNoIndent(";\n");
    }

    // Partial Metal Side Area
    for (i = 0; i < data.partialMetalSide().getNumElements(); i++) {
	lefOut.output("ANTENNAPARTIALMETALSIDEAREA %.11g ",
		      lefOut.dbuToUUArea(data.partialMetalSide()[i].area()));
	writeAntennaLayer(data.partialMetalSide()[i].layerNum());
	lefOut.outNoIndent(";\n");
    }

    // Patrial Cut Area
    for (i = 0; i < data.partialCut().getNumElements(); i++) {
	lefOut.output("ANTENNAPARTIALCUTAREA %.11g ",
		      lefOut.dbuToUUArea(data.partialCut()[i].area()));
	writeAntennaLayer(data.partialCut()[i].layerNum());
	lefOut.outNoIndent(";\n");
    }

    // Diff Area
    for (i = 0; i < data.diff().getNumElements(); i++) {
	lefOut.output("ANTENNADIFFAREA %.11g ",
		      lefOut.dbuToUUArea(data.diff()[i].area()));
	writeAntennaLayer(data.diff()[i].layerNum());
	lefOut.outNoIndent(";\n");
    }
}



// *****************************************************************************
// LefOutPin::writeAntennaModel()
// 
// This function outputs the antenna constructs for the given model, syntax:
//     [ANTENNAGATEAREA value [LAYER layerName] ;]...
//     [ANTENNAMAXAREACAR value LAYER layerName ;]
//     [ANTENNAMAXSIDEAREACAR value LAYER layerName ;]
//     [ANTENNAMAXCUTCAR value LAYER layerName ;] 
// *****************************************************************************
void
LefOutPin::writeAntennaModel(oaAntennaData	&data)
{

    // Gate Area
    oaUInt4 i(0);
    for (i; i < data.gate().getNumElements(); i++) {
	lefOut.output("ANTENNAGATEAREA %.11g ",
		      lefOut.dbuToUUArea(data.gate()[i].area()));
	writeAntennaLayer(data.gate()[i].layerNum());
	lefOut.outNoIndent(";\n");
    }

    // Max Area CAR
    for (i = 0; i < data.maxCAR().getNumElements(); i++) {
	lefOut.output("ANTENNAMAXAREACAR %.11g ",
		      lefOut.dbuToUUArea(data.maxCAR()[i].area()));
	writeAntennaLayer(data.maxCAR()[i].layerNum());
	lefOut.outNoIndent(";\n");
    }

    // Max Side Area CAR
    for (i = 0; i < data.maxSideCAR().getNumElements(); i++) {
	lefOut.output("ANTENNAMAXSIDEAREACAR %.11g ",
		      lefOut.dbuToUUArea(data.maxSideCAR()[i].area()));
	writeAntennaLayer(data.maxSideCAR()[i].layerNum());
	lefOut.outNoIndent(";\n");
    }

    // Max Cut CAR
    for (i = 0; i < data.maxCutCAR().getNumElements(); i++) {
	lefOut.output("ANTENNAMAXCUTCAR %.11g ",
		      lefOut.dbuToUUArea(data.maxCutCAR()[i].area()));
	writeAntennaLayer(data.maxCutCAR()[i].layerNum());
	lefOut.outNoIndent(";\n");
    }
}



// *****************************************************************************
// LefOutPin::writeAntennaLayer()
// 
// This function writes a layer statement for the specified layerNum.
// *****************************************************************************
void
LefOutPin::writeAntennaLayer(oaLayerNum layerNum)
{
    if (layerNum != oacNullIndex) {
	oaLayer	    *layer = lefOut.getLayer(layerNum);
	oaString    layerName;

	layer->getName(layerName);
	lefOut.outNoIndent("LAYER %s ", (const char *) layerName);
    }
}



// *****************************************************************************
// LefOutPin::writeSensitivity()
// 
// This function outputs the sensitivity attributes, syntax:
// [SUPPLYSENSITIVITY pinName ;]
// [GROUNDSENSITIVITY pinName ;]
// *****************************************************************************
void
LefOutPin::writeSensitivity()
{
    oaString	pinName;
    
    oaTerm  *sTerm = term->getGroundSensitivity();
    if (sTerm) {
	sTerm->getName(lefOut.getNS(), pinName);
	lefOut.output("GROUNDSENSITIVITY %s ;\n", (const char*) pinName);
    }

    sTerm = term->getSupplySensitivity();
    if (sTerm) {
	sTerm->getName(lefOut.getNS(), pinName);
	lefOut.output("SUPPLYSENSITIVITY %s ;\n", (const char*) pinName);
    }
}



// *****************************************************************************
// LefOutPin::writeNetExpr()
// 
// This function outputs the net expression construct, syntax:
// [NETEXPR "assignment netName" ;]
// *****************************************************************************
void
LefOutPin::writeNetExpr()
{
    oaTermConnectDef	*cDef = ((oaBitTerm*) term)->getConnectDef();

    if (cDef) {
	oaAssignmentDef	assign;
	oaString	defNet;

	cDef->getAssignmentDef(assign);
	assign.defaultName().get(lefOut.getNS(), defNet);

	lefOut.output("NETEXPR \"%s %s\" ;\n",
		      (const char*) assign.assignmentName(),
		      (const char*) defNet);
    }
}



END_LEFDEF_NAMESPACE