oalefoutlayer.cpp

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

    if (value && value->getType() == oacIntValueType) {
        lefOut.output("MINSTEP %.11g",
		      lefOut.dbuToUU(((oaIntValue*) value)->get()));

	if (lefOut.getOptions()->getVersion() > cLefDefVersion55) {
	    lefOut.outNoIndent(" OUTSIDECORNER");
	}

	writeMinStepLengthSum(params);

	lefOut.outNoIndent(" ;\n");
    }

    if (lefOut.getOptions()->getVersion() < cLefDefVersion56) {
	return;
    }


    // Write 5.6 and later rules
    value = lefOut.getConstraint(lefOut.getFoundryRules(),
				 oacMinConcaveEdgeLength, layer->getNumber(), 
				 &params);

    if (value && value->getType() == oacIntValueType) {
        lefOut.output("MINSTEP %.11g INSIDECORNER",
		      lefOut.dbuToUU(((oaIntValue*) value)->get()));

	writeMinStepLengthSum(params);

	lefOut.outNoIndent(" ;\n");
    }

    value = lefOut.getConstraint(lefOut.getFoundryRules(), oacMinEdgeLength,
				 layer->getNumber(), &params);

    if (value && value->getType() == oacIntValueType) {
        lefOut.output("MINSTEP %.11g STEP",
		      lefOut.dbuToUU(((oaIntValue*) value)->get()));

	writeMinStepLengthSum(params);

	lefOut.outNoIndent(" ;\n");
    }
}

void
LefOutLayer::writeMinStepLengthSum(oaConstraintParamArray  &params)
{
    oaConstraintParamDef    *pDef
	= oaConstraintParamDef::get(oacLengthSumConstraintParamType);
    oaConstraintParam	    *param = params.findParam(pDef);
	
    if (param) {
	oaValue	*value = param->getValue();

	if (value && value->getType() == oacIntValueType) {
	    lefOut.outNoIndent(" LENGTHSUM %.11g",
		lefOut.dbuToUU(((oaIntValue*) value)->get()));
	}
    }
}



// *****************************************************************************
// LefOutLayer::writeMinSize()
// 
// This function outputs the minimum width for this layer, syntax:
// MINSIZE width lenght [width length]... ;
// From LEF 5.6 Only.
// *****************************************************************************
void
LefOutLayer::writeMinSize()
{
    oaValue *value = lefOut.getConstraint(lefOut.getFoundryRules(), 
					  oacMinSize,
					  layer->getNumber());

    if (value && value->getType() == oacBoxArrayValueType) {
        oaBoxArray  minSizeArray;
	
	((oaBoxArrayValue*) value)->get(minSizeArray);
	
	lefOut.output("MINSIZE");

	for (oaUInt4 i = 0; i < minSizeArray.getNumElements(); i++) {
	    lefOut.outNoIndent(" %.11g %.11g",
			       lefOut.dbuToUU(minSizeArray[i].getWidth()),
			       lefOut.dbuToUU(minSizeArray[i].getHeight()));
	}

	lefOut.outNoIndent(" ;\n");
    }
}



// *****************************************************************************
// LefOutLayer::writeMinEnclosedArea()
// 
// This function outputs the minimum enclosed area for this layer, syntax:
// MINENCLOSEDAREA value [WIDTH value] ;
// From LEF 5.5 Only.
// *****************************************************************************
void
LefOutLayer::writeMinEnclosedArea()
{
    oaValue *value = lefOut.getConstraint(lefOut.getFoundryRules(), 
					  oacMinEnclosedArea,
					  layer->getNumber());

    if (value) {
        if (value->getType() == oacInt1DTblValueType) {
            oa1DLookupTbl<oaInt4, oaInt4> table;

            ((oaInt1DTblValue*) value)->get(table);
            for (oaUInt4 i = 0; i < table.getNumItems(); i++) {
                if (table.getHeader(i)) {
                    lefOut.output("MINENCLOSEDAREA %.11g WIDTH %.11g ;\n",
                                  lefOut.dbuToUUArea(table.getValue(i)),
                                  lefOut.dbuToUU(table.getHeader(i)));
                } else {
                    lefOut.output("MINENCLOSEDAREA %.11g ;\n",
                                  lefOut.dbuToUUArea(table.getValue(i)));
                }
            }
        } else if (value->getType() == oacIntValueType) {
            lefOut.output("MINENCLOSEDAREA %.11g ;\n",
                          lefOut.dbuToUUArea(((oaIntValue *) value)->get()));
        }
    }
}



// *****************************************************************************
// LefOutLayer::writeProtrusionWidth()
// 
// This function outputs the ProtrusionWidth for this layer, syntax:
// PROTRUSIONWIDTH value LENGTH length WIDTH width ;
// From LEF 5.5 Only.
// *****************************************************************************
void
LefOutLayer::writeProtrusionWidth()
{
    oaLayerConstraintDef    *def
	= oaLayerConstraintDef::get(oacMinProtrusionWidth);
    oaConstraintParamDef    *lengthDef
	= oaConstraintParamDef::get(oacLengthConstraintParamType);
    oaConstraintParamDef    *widthDef
	= oaConstraintParamDef::get(oacWidthConstraintParamType);

    oaConstraint    *c = oaLayerConstraint::find(lefOut.getFoundryRules(), 
						 layer->getNumber(), def);

    if (c) {
	oaConstraintParamArray params;

	c->getParams(params);

	oaConstraintParam   *lengthParam = params.findParam(lengthDef);
	oaConstraintParam   *widthParam = params.findParam(widthDef);

	if (!lengthParam || !widthParam) {
	    return;
	}

	oaValue *value = c->getValue();
	oaValue *lengthValue = lengthParam->getValue();
	oaValue *widthValue = widthParam->getValue();

	if (value && value->getType() == oacIntValueType
	    && lengthValue && lengthValue->getType() == oacIntValueType
	    && widthValue && widthValue->getType() == oacIntValueType) {
	    lefOut.output("PROTRUSIONWIDTH %.11g LENGTH %.11g WIDTH %.11g ;\n",
			  lefOut.dbuToUU(((oaIntValue*) value)->get()),
			  lefOut.dbuToUU(((oaIntValue*) lengthValue)->get()),
			  lefOut.dbuToUU(((oaIntValue*) widthValue)->get()));
	}
    }
}



// *****************************************************************************
// LefOutLayer::writeDiagMinEdgeLength()
// 
// This function outputs the routespec width for this layer, syntax:
// DIAGMINEDGELENGTH defWidth ;
// *****************************************************************************
void
LefOutLayer::writeDiagMinEdgeLength()
{
    oaValue *v = lefOut.getConstraint(lefOut.getFoundryRules(),
				      oacMinDiagonalEdgeLength,
				      layer->getNumber());
    
    if (v && v->getType() == oacIntValueType) {
	lefOut.output("DIAGMINEDGELENGTH %.11g ;\n",  
		      lefOut.dbuToUU(((oaIntValue*) v)->get()));
    }
}



// *****************************************************************************
// LefOutLayer::writeArea()
// 
// This function outputs the area for this layer, syntax:
// [AREA minArea ; ]
// *****************************************************************************
void
LefOutLayer::writeArea()
{
    oaValue *value = lefOut.getConstraint(lefOut.getFoundryRules(), oacMinArea,
					  layer->getNumber());

    if (value && value->getType() == oacIntValueType) {
	lefOut.output("AREA %.11g ;\n",
		      lefOut.dbuToUUArea(((oaIntValue*) value)->get()));
    }
}



// *****************************************************************************
// LefOutLayer::writeSpacing()
// 
// This function outputs the spacing for this layer, syntax:
// [SPACING minSpacing
//          [RANGE minWidth maxWidth 
//                 [USELENGTHTHRESHOLD 
//                  | INFLUENCE value [RANGE stubMinWidth stubMaxWidth]
//                  | RANGE minWidth maxWidth] 
//          | LENGTHTHRESHOLD maxLength [RANGE minWidth maxWidth] ] ;] ...
// *****************************************************************************
void
LefOutLayer::writeSpacing()
{
    oaValue *value = lefOut.getConstraint(lefOut.getFoundryRules(), oacMinSpacing,
					  layer->getNumber());

    if (value) {
	switch (value->getType()) {
	  case oacIntValueType:
	    lefOut.output("SPACING %.11g ;\n",
	      lefOut.dbuToUU(((oaIntValue *)value)->get()));
	    break;
          case oacInt1DTblValueType:
	    writeSpacingRange(value);
	    break;
          case oacInt2DTblValueType:
	    lefOut.getOptions()->getVersion() > cLefDefVersion54
	      ? writeSpacingTable(value) : writeSpacingThreshold(value);
	    break;
        default:
	  break;
	}
    }
}



// *****************************************************************************
// LefOutLayer::writeDiagSpacing()
// 
// This function outputs the routespec width for this layer, syntax:
// WIDTH defWidth ;
// *****************************************************************************
void
LefOutLayer::writeDiagSpacing()
{
    oaValue *v = lefOut.getConstraint(lefOut.getFoundryRules(),
				      oacMinDiagonalSpacing,
				      layer->getNumber());
    
    if (v && v->getType() == oacIntValueType) {
	lefOut.output("DIAGSPACING %.11g ;\n",  
		      lefOut.dbuToUU(((oaIntValue*) v)->get()));
    }
}



// *****************************************************************************
// LefOutLayer::writeSpacingRange()
// 
// This function outputs the spacing for this layer, syntax:
// [SPACING minSpacing
//          [RANGE minWidth maxWidth 
//                 [USELENGTHTHRESHOLD 
//                  | INFLUENCE value [RANGE stubMinWidth stubMaxWidth]
//                  | RANGE minWidth maxWidth] 
//          | LENGTHTHRESHOLD maxLength [RANGE minWidth maxWidth] ] ;] ...
// *****************************************************************************
void
LefOutLayer::writeSpacingRange(oaValue	*value)
{
    oa1DLookupTbl<oaInt4, oaInt4> table;

    ((oaInt1DTblValue *) value)->get(table);
    for (oaUInt4 w = 0; w < table.getNumItems(); w++) {
        
        if (w && (table.getValue(w) == table.getValue(w - 1))) {
            // The range is redundant
            // (spacing same as generic spacing for this length)
            continue;
        }
        
        oaInt4 spacing = table.getValue(w);

        lefOut.output("SPACING %g", lefOut.dbuToUU(spacing));
        
	if (w > 0) {
	    oaInt4 width     = table.getHeader(w);
	    oaInt4 nextWidth = 10000 * lefOut.getDBUPerUU();

	    if (w < table.getNumItems() - 1) {
		nextWidth = table.getHeader(w + 1) - 1;
	    }

	    lefOut.outNoIndent(" RANGE %g %g",
		lefOut.dbuToUU(width),
		lefOut.dbuToUU(nextWidth));
	}

	lefOut.outNoIndent(" ;\n");
    }
}



// *****************************************************************************
// LefOutLayer::writeSpacingThreshold()
// 
// This function outputs the spacing for this layer, syntax:
// [SPACING minSpacing
//          [RANGE minWidth maxWidth 
//                 [USELENGTHTHRESHOLD 
//                  | INFLUENCE value [RANGE stubMinWidth stubMaxWidth]
//                  | RANGE minWidth maxWidth] 
//          | LENGTHTHRESHOLD maxLength [RANGE minWidth maxWidth] ] ;] ...
// *****************************************************************************
void
LefOutLayer::writeSpacingThreshold(oaValue *value)
{
    oa2DLookupTbl<oaInt4, oaInt4, oaInt4> table;

    ((oaInt2DTblValue *) value)->get(table);

    // write the generic spacing
    for (oaUInt4 w = 0; w < table.getNumRows(); w++) {
	oaBoolean   useLength(false);

	for (oaUInt4 l = 0; l < table.getNumCols(); l++) {
	    
	    if (l < table.getNumCols() - 1) {
		if (table.getValue(w, l) == table.getValue(w, l + 1)) {
                    // the lengththreshold value is redundant
                    // (spacing is same as spacing for next length)
                    continue;
                }
            }

	    oaInt4 spacing(table.getValue(w, l));
            lefOut.output("SPACING %g", lefOut.dbuToUU(spacing));
            
            if ((l == table.getNumCols() - 1) && (w == 0)) {
                // this is the generic spacing
                lefOut.outNoIndent(" ;\n");
                continue;
            }
            
            if (l != table.getNumCols() - 1) {
                oaInt4 length(table.getColHeader(l + 1));
                lefOut.outNoIndent(" LENGTHTHRESHOLD %g",
                                   lefOut.dbuToUU(length));
		useLength = true;
	    }
            
	    oaInt4 width     = table.getRowHeader(w);
            oaInt4 nextWidth = 10000 * lefOut.getDBUPerUU();

	    if (w < table.getNumRows() - 1) {
		nextWidth = table.getRowHeader(w + 1) - 1;
	    }

	    lefOut.outNoIndent(" RANGE %g %g",
                               lefOut.dbuToUU(width),
		               lefOut.dbuToUU(nextWidth));

	    if ((l == table.getNumCols() - 1) && useLength) {
		lefOut.outNoIndent(" USELENGTHTHRESHOLD");
	    }

	    lefOut.outNoIndent(" ;\n");
        }
    }
}



// *****************************************************************************
// LefOutLayer::writeSpacingTable()
// 
// This function outputs the spacing for this layer, syntax:
// [SPACINGTABLE 
//              PARALLELRUNLENGTH {length} ...
//                  {WIDTH width {spacing} ...} ... ;
// *****************************************************************************
void
LefOutLayer::writeSpacingTable(oaValue	*value)
{
    oa2DLookupTbl<oaInt4, oaInt4, oaInt4> table;

    ((oaInt2DTblValue *) value)->get(table);
    lefOut.output("SPACINGTABLE\n");
    lefOut.incIndent();

    lefOut.output("PARALLELRUNLENGTH ");
    for (oaUInt4 l = 0; l < table.getNumCols(); l++) {
	oaUInt4	length = table.getColHeader(l);

	if (length > 0
	    && table.getColInterpolateType() == oacSnapDownInterpolateType) {
	    length -= 1;
	}

        lefOut.outNoIndent("%.11g ", lefOut.dbuToUU(length));
    }

    for (oaUInt4 w = 0; w < table.getNumRows(); w++) {
	oaUInt4	width = table.getRowHeader(w);

	if (width > 0