oalefoutvia.cpp

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

// *****************************************************************************
// *****************************************************************************
// LefOutVia.cpp
//
// This file contains the member functions for the LefOutVia 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.46 $
//  $Date: 2005/06/10 19:08:21 $
//  $State: Exp $
// *****************************************************************************
// *****************************************************************************



#include "oaLefDef.h"

BEGIN_LEFDEF_NAMESPACE



// *****************************************************************************
// LefOutVia::LefOutVia()
// LefOutVia::~LefOutVia()
//
// This is the default constructor for the LefOutVia class.
// *****************************************************************************
LefOutVia::LefOutVia(LefOut &lefOutIn)
:   lefOut(lefOutIn),
    numCuts(0)
{
    lefOutIn.lefOutVia = this;
}

LefOutVia::~LefOutVia()
{
}



// *****************************************************************************
// LefOutVia::write()
//
// This function outputs all via information for this viaDef.
// *****************************************************************************
void
LefOutVia::write(oaCustomViaDef	*viaDefIn,
		 oaBoolean	nonDefaultIn)
{
    viaDef = viaDefIn;
    nonDefault = nonDefaultIn;
    numCuts = 0;

    // Ignore any vias that do not use LEF layers.
    if (!lefOut.isValidLayer(viaDef->getLayer1())
	|| !lefOut.isValidLayer(viaDef->getLayer2())) {
	return;
    }

    oaString	    viaName;
    oaScalarName    libName;
    oaScalarName    cellName;
    oaScalarName    viewName;
    
    viaDef->getLibName(libName);
    viaDef->getCellName(cellName);
    viaDef->getViewName(viewName);
    viaDef->getName(viaName);
    viaMaster = oaDesign::open(libName, cellName, viewName, 'r');

    if (!viaMaster->getTopBlock()
	|| viaMaster->getTopBlock()->getLayerHeaders().getCount() > 3) {
	lefOut.warn(cViaTooManyLayers, (const char*) viaName);
	viaMaster->close();
	return;
    }


    lefOut.output("VIA %s", (const char*) viaName);
    
    if (!nonDefault) {
	writeDefault();
    }

    writeTopOfStack();
    
    lefOut.outNoIndent("\n");
    lefOut.incIndent();

    writeLayers();
    writeRes();
    lefOut.writeProperties(viaDef, cLefDefVia);

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

    viaMaster->close();
}



// *****************************************************************************
// LefOutVia::writeDefault()
//
// This function outputs the default keyword for this via, syntax:
// [DEFAULT] 
// *****************************************************************************
void
LefOutVia::writeDefault()
{
    oaValue	*v = lefOut.getConstraint(lefOut.getDefaultRules(),
					  oacValidRoutingVias);

    if (v && v->getType() == oacViaDefArrayValueType) {
	oaViaDefArray   viaDefArray;

	((oaViaDefArrayValue*) v)->get(viaDefArray);

	for (oaUInt4 i = 0; i < viaDefArray.getNumElements(); i++) {
	    if (viaDef == viaDefArray[i]) {
		lefOut.output(" DEFAULT");
		return;
	    }
	}
    }
}



// *****************************************************************************
// LefOutVia::writeTopOfStack()
//
// This function outputs the topofstack keyword for this via, syntax:
// [TOPOFSTACKONLY]
// *****************************************************************************
void
LefOutVia::writeTopOfStack()
{
    oaBooleanProp *topOfStack
	    = (oaBooleanProp *) oaProp::find(viaDef, cLefViaTopOfStack);

    if (topOfStack && topOfStack->getValue()) {
	lefOut.output(" TOPOFSTACKONLY");
    }
}



// *****************************************************************************
// LefOutVia::writeLayers()
//
// This function outputs all shapes found in the view associated with the
// viaDef, syntax:
// LAYER layerName ;
//   RECT pt pt ; ...
//
// This function uses LefOutGeom object to write out the actual geometry
// statements.
// *****************************************************************************
void
LefOutVia::writeLayers()
{
    oaIter<oaShape> iter(viaMaster->getTopBlock()->getShapes());

    lefOut.getLefOutGeom()->reset();
    while (oaShape  *shape = iter.getNext()) {
	if (shape->getType() == oacDotType || shape->getType() == oacLineType) {
	    continue;
	}
	
	lefOut.getLefOutGeom()->writeFig(shape);

        oaPhysicalLayer	*layer = lefOut.getLayer(shape->getLayerNum());

        if (layer->getMaterial() == oacCutMaterial) {
	    numCuts++;
        }
    }
}



// *****************************************************************************
// LefOutVia::writeRes()
//
// This function outputs the resistance value for this via, syntax:
// [RESISTANCE value ;]
// *****************************************************************************
void
LefOutVia::writeRes()
{
    oaFloat res = viaDef->getResistancePerCut();
    if (res > 0. && numCuts) {
	lefOut.output("RESISTANCE %g ;\n", res / numCuts);
    }
}



// *****************************************************************************
// LefOutVia::isNonDefaulRuleVia()
// 
// This function returns a boolean indicating if this via is used
// in a NonDefaultRule
// *****************************************************************************
oaBoolean
LefOutVia::isNonDefaultRuleVia(oaCustomViaDef	*via) {
    oaIter<oaConstraintGroup> cgIter(lefOut.tech()->getConstraintGroups());

    while (oaConstraintGroup *cg = cgIter.getNext()) {
	if (cg != lefOut.getDefaultRules() && cg != lefOut.getFoundryRules()) {
	    oaValue *v = lefOut.getConstraint(cg, oacValidRoutingVias);

	    if (v && v->getType() == oacViaDefArrayValueType) {
		oaViaDefArray	viaArray;

		((oaViaDefArrayValue*) v)->get(viaArray);
		for (oaUInt4 i = 0; i < viaArray.getNumElements(); i++) {
		    if (via == viaArray[i]) {
			return true;
		    }
		}
	    }
	}
    }

    return false;
}
END_LEFDEF_NAMESPACE