4 &nbsp;

The Cadence application programming interface (API) provides both C and C++ interfaces. The C API is generated from the C++ source, so there is no functional difference. The C API has been created in a pseudo object-oriented style. Examining a simple case should enable you to understand the API organization.

Deriving C Syntax from C++ Syntax

The following examples show the same statements in C and C++ syntax.

C++ Syntax

class lefiSite {

const char* siteClass() const;

int hasClass() const;

double sizeX() const;

double sizeY() const;

int numSites() const;

char* siteName(int index) const;

int siteOrient(int index) const;

char* siteOrientStr(int index) const;

};

C Syntax

const char * lefiSite_name

int lefiSite_hasClass

const char * lefiSite_siteClass

double lefiSite_sizeX

double lefiSite_sizeY

int lefiSite_numSites

The C routine prototypes for the API functions can be found in the following files:

char * lefiSite_siteName

( const lefiSite * this, int index );

int lefiSite_siteOrient

( const lefiSite * this, int index );

char * lefiSite_siteOrientStr

( const lefiSite * this, int index );


lefiArray.h	lefiNonDefault.h	lefiViaRule.h
lefiCrossTalk.h	lefrCallBacks.h	lefiProp.h
lefrReader.h	lefiDebug.h	lefiDefs.h
lefwWriter.h	lefiKRDefs.h	lefiLayer.h
lefiUnits.h	lefiUser.h	lefiMacro.h
lefiUtil.h	lefiMisc.h	lefiVia.h

LEF Reader Classes

The following table lists the classes routines that apply to the LEF information.


LEF Information	LEF Class
Layer Classes	lefiAntennaModel lefiAntennaPWL lefiInfluence lefiLayer lefiLayerDensity lefiOrthogonal lefiParallel lefiSpacingTable lefiTwoWidths
Macro Data Classes	lefiDensity lefiMacro lefiMacroForeign lefiMacroSite lefiPoints
Macro Obstruction Class	lefiObstruction
Macro Pin Classes	lefiGeometries lefiPin lefiPinAntennaModel
Maximum Via Stack Class	lefiMaxStackVia
Miscellaneous Class	lefiUserData
Nondefault Rule Class	lefiNonDefault
Property Definition Classes	lefiProp lefiPropType
Same-Net Spacing Class	lefiSpacing
Site Classes	lefiSite lefiSitePattern
Units Class	lefiUnits
Use Min Spacing Class	lefiUseMinSpacing
Via Classes	lefiVia lefiViaLayer
Via Rule Classes	lefiViaRule lefiViaRuleLayer

Layer Classes

The LEF LAYER routines include the following classes:

lefiAntennaModel

Retrieves antenna model information from a LAYER section of the LEF file.

For syntax information about the LEF LAYER sections, see "Layer (Cut)," and "Layer (Routing)" in the LEF/DEF Language Reference.

C++ Syntax

class lefiAntennaModel {

int hasAntennaAreaRatio() const;

int hasAntennaDiffAreaRatio() const;

int hasAntennaDiffAreaRatioPWL() const;

int hasAntennaCumAreaRatio() const;

int hasAntennaCumDiffAreaRatio() const

int hasAntennaCumDiffAreaRatioPWL() const;

int hasAntennaAreaFactor() const;

int hasAntennaAreaFactorDUO() const;

int hasAntennaSideAreaRatio() const;

int hasAntennaDiffSideAreaRatio() const;

int hasAntennaDiffSideAreaRatioPWL() const;

int hasAntennaCumSideAreaRatio() const;

int hasAntennaCumDiffSideAreaRatio() const;

int hasAntennaCumDiffSideAreaRatioPWL() const;

int hasAntennaSideAreaFactor() const;

int hasAntennaSideAreaFactorDUO() const;

int hasAntennaCumRoutingPlusCut() const;

int hasAntennaGatePlusDiff() const;

int hasAntennaAreaMinusDiff() const;

int hasAntennaAreaDiffReducePWL() const;

char* antennaOxide() const;

double antennaAreaRatio() const;

double antennaDiffAreaRatio() const;

lefiAntennaPWL* antennaDiffAreaRatioPWL() const;

double antennaCumAreaRatio() const;

double antennaCumDiffAreaRatio() const;

lefiAntennaPWL* antennaCumDiffAreaRatioPWL() const;

double antennaAreaFactor() const;

double antennaSideAreaRatio() const;

double antennaDiffSideAreaRatio() const;

lefiAntennaPWL* antennaDiffSideAreaRatioPWL() const;

double antennaCumSideAreaRatio() const;

double antennaCumDiffSideAreaRatio() const;

lefiAntennaPWL* antennaCumDiffSideAreaRatioPWL() const;

double antennaSideAreaFactor() const;

double antennaGatePlusDiff() const;

double antennaAreaMinusDiff() const;

lefiAntennaPWL* antennaAreaDiffReducePWL() const; };

For syntax information about the LEF LAYER (Routing) section, see "Layer (Routing)" in the LEF/DEF Language Reference.

C++ Syntax

class lefiInfluence {

int numInfluenceEntry() const;

double width(int index) const;

double distance(int index) const;

double spacing(int index) const; };

lefiLayer

Retrieves data from a LAYER section of the LEF file. This callback can be used for all layer types (cut, masterslice, implant, and routing). However, most of these functions apply to routing layers. Comments in the C++ syntax indicate those arguments that apply only to a particular layer type. All other arguments apply to all layer types.

For syntax information about the LEF LAYER sections, see "Layer (Cut)," "Layer (Masterslice or Overlap)," and "Layer (Routing)" in the LEF/DEF Language Reference.

C++ Syntax

class lefiLayer {

int hasType() const;

int hasPitch() const; // Routing

int hasXYPitch() const;

int hasOffset() const; // Routing

int hasXYOffset() const;

int hasWidth() const; // Routing

int hasArea() const;

int hasDiagPitch() const;

int hasXYDiagPitch() const;

int hasDiagWidth() const;

int hasDiagSpacing() const;

int hasSpacingNumber() const;

int hasSpacingName(int index) const;

int hasSpacingLayerStack(int index) const;

int hasSpacingAdjacent(int index) const;

int hasSpacingCenterToCenter(int index) const;

int hasSpacingRange(int index) const; // Routing

int hasSpacingRangeUseLengthThreshold(int index) const;

int hasSpacingRangeInfluence(int index) const;

int hasSpacingRangeInfluenceRange(int index) const;

int hasSpacingRangeRange(int index) const;

int hasSpacingLengthThreshold(int index) const; // Routing

int hasSpacingLengthThresholdRange(int index) const; // Routing

int hasSpacingParallelOverlap(int index) const;

int hasSpacingArea(int index) const;

int hasSpacingEndOfLine(int index) const;

int hasSpacingParellelEdge(int index) const;

int hasSpacingTwoEdges(int index) const;

int hasSpacingAdjacentExcept(int index) const;

int hasSpacingSamenet(int index) const;

int hasSpacingSamenetPGonly(int index) const;

lefiLayerDensity

Retrieves data from the LAYERDENSITY statement in a LAYER section of the LEF file.

For syntax information about the LEF LAYER sections, see "Layer (Cut)," and "Layer (Routing)" in the LEF/DEF Language Reference.

C++ Syntax

class lefiLayerDensity {

double frequency(int index);

int numWidths();

double width(int index);

int numTableEntries();

double tableEntry(int index);

int numCutareas();

double cutArea(int index); };

lefiOrthogonal

Retrieves orthogonal spacing information from a LAYER section of the LEF file.

For syntax information about the LEF LAYER sections, see "Layer (Cut) in the LEF/DEF Language Reference.

C++ Syntax

class lefiOrthogonal {

int numOrthogonal() const;

double cutWithin(int index) const;

double orthoSpacing(int index) const; };

lefiParallel

Retrieves parallel run length information from a LAYER (Routing) section of the LEF file.

For syntax information about the LEF LAYER (Routing) section, see "Layer (Routing)" in the LEF/DEF Language Reference.

C++ Syntax

class lefiParallel {

int numLength() const;

int numWidth() const;

double length(int iLength) const;

double width(int iWidth) const;

double widthSpacing(int iWidth, int iWidthSpacing) const; };

lefiSpacingTable

Retrieves spacing table information from a LAYER (Routing) section of the LEF file.

For syntax information about the LEF LAYER (Routing) section, see "Layer (Routing)" in the LEF/DEF Language Reference.

C++ Syntax

class lefiSpacingTable {

int isInfluence() const;

lefiInfluence* influence() const;

int isParallel() const;

lefiParallel* parallel() const;

lefiTwoWidths* twoWidths() const; };

lefiTwoWidths

Retrieves two-width spacing information from a LAYER (Routing) section of the LEF file.

For syntax information about the LEF LAYER (Routing) section, see "Layer (Routing)" in the LEF/DEF Language Reference.

C++ Syntax

class lefiTwoWidths {

int numWidth() const;

double width(int iWidth) const;

int hasWidthPRL(int iWidth) const;

double widthPRL(int iWidth) const;

int numWidthSpacing(int iWidth) const;

double widthSpacing(int iWidth, int iWidthSpacing) const; };

Macro Data Classes

The LEF MACRO data routines include the following LEF classes:

lefiDensity

Retrieves density information from the MACRO section of the LEF file.

For syntax information about the MACRO section, see "Macro" in the LEF/DEF Language Reference.

C++ Syntax

class lefiDensity {

int numLayer() const;

char* layerName(int index) const;

int numRects(int index) const;

struct lefiGeomRect getRect(int index, int rectIndex) const;

double densityValue(int index, int rectIndex) const; };

lefiMacro

Retrieves data from the MACRO section of the LEF file.

For syntax information about the MACRO section, see "Macro" in the LEF/DEF Language Reference.

C++ Syntax

class lefiMacro {

int hasClass() const;

int hasGenerator() const;

int hasGenerate() const;

int hasPower() const;

int hasOrigin() const;

int hasEEQ() const;

int hasLEQ() const;

int hasSource() const;

int hasXSymmetry() const;

int hasYSymmetry() const;

int has90Symmetry() const;

int hasSiteName() const;

int hasSitePattern() const;

int hasSize() const;

int hasForeign() const;

int hasForeignOrigin(int index = 0) const;

int hasForeignOrient(int index = 0) const;

int hasForeignPoint(int index = 0) const;

int hasClockType() const;

int isBuffer() const;

int isInverter() const;

int numSitePattern() const;

int numProperties() const;

const char* propName(int index) const;

const char* propValue(int index) const;

double propNum(int index) const;

const char propType(int index) const;

int propIsString(int index) const;

const char* macroClass() const;

const char* generator() const;

const char* EEQ() const;

const char* LEQ() const;

const char* source() const;

const char* clockType() const;

double originX() const;

double originY() const;

double power() const;

void generate(char** name1, char** name2) const;

lefiSitePattern* sitePattern(int index) const;

const char* siteName() const;

double sizeX() const;

double sizeY() const;

int numForeigns() const;

int foreignOrient(int index = 0) const; //optional - for information, see

//Orientation Codes

const char* foreignOrientStr(int index = 0) const;

double foreignX(int index = 0) const;

double foreignY(int index = 0) const;

const char* foreignName(int index = 0) const; };

lefiMacroForeign

Retrieves data for in-place processing of a MACRO FOREIGN statement.

C++ Syntax

class lefiMacroForeign {

public:

lefiMacroForeign(const char *name,

const char *cellName() const;

int cellHasPts() const;

double px() const;

double py() const;

int cellHasOrient() const;

int cellOrient() const;

protected:

const char *cellName_;

};

lefiMacroSite

Retrieves data for in-place processing of a MACRO SITE statement.

C++ Syntax

class lefiMacroSite {

public:

lefiMacroSite(const char *name, const lefiSitePattern* pattern);

const char *siteName() const;

const lefiSitePattern *sitePattern() const;

protected:

const char *siteName_;

const lefiSitePattern *sitePattern_;

};

lefiPoints

Returns the X and Y points for the ORIGIN and SIZE statements in the MACRO section.

C++ Syntax

struct lefiPoints {

double x;

double y; };

typedef struct lefiPoints lefiNum;

Macro Examples

The following example shows a callback routine with the type lefrMacroBeginCbkType, and the class const char*.

int macroBeginCB (lefrCallbackType_e type,

const char *macroName,

if (type != lefiMacroBeginCbkType) {

// Incorrect type was passed in, expecting the type

// lefiMacroBeginCbkType

printf("Type is not lefiMacroBeginCbkType, terminate

if (!macroName || !*macroName) {

// Expect a non null char* macroName

printf("Macro name is null, terminate parsing.\n");

printf("Macro name is %s\n", macroName);

// Write out the macro name

return 0;}

The following example shows a callback routine with the type lefrMacroCbkType, and the class lefiMacro. This example only shows how to retrieve part of the data from the lefiMacro class.

int macroCB (lefrCallbackType_e type,

lefiMacro *macroInfo,

int propNum, i, hasPrtSym = 0;

lefiSitePattern* pattern;

if (type != lefrMacroCbkType) {

printf("Type is not lefrMacroCbkType, terminate

if (macroInfo->hasClass())

printf(" CLASS %s\n", macroInfo->macroClass());

if (macroInfo->hasXSymmetry()) {

printf(" SYMMETRY X ");

if (macroInfo->hasYSymmetry()) { // print X Y & R90 in one line

if (!hasPrtSym) { // the line has not started yet

printf(" SYMMETRY Y ");

else // the line has already started

printf("Y ");

if (macroInfo->has90Symmetry()) {

if (!hasPrtSym) { // the line has not started yet

printf(" SYMMETRY R90 ");

else // the line has already started

// Check if SITE pattern is defined in the macro

if (macroInfo->hasSitePattern()) {

for (i = 0; i < macroInfo->numSitePattern(); i++ ) {

pattern = macroInfo->sitePattern(i);

printf(" SITE %s %g %g %d DO %g BY %g STEP %g %g\n",

pattern->name(), pattern->x(), pattern->y(),

pattern->orient(), pattern->xStart(),

pattern->yStart(),

pattern->xStep(), pattern->yStep());

propNum = macroInfo->numProperties();

// Check if PROPERTY is defined in the macro

if (propNum > 0) {

printf(" PROPERTY ");

for (i = 0; i < propNum; i++) {

// value can either be a string or number

if (macroInfo->propValue(i)) {

printf("%s %s ", macroInfo->propName(i),

macroInfo->propValue(i));

printf("%s %g ", macroInfo->propName(i),

macroInfo->propNum(i));

The LEF Macro Obstruction routines include the following LEF class:

return 0;}

Macro Obstruction Class

lefiObstruction

Retrieves data from the Macro Obstruction (OBS) statement in the MACRO section of the LEF file. The Macro Obstruction statement defines sets of obstructions (blockages) on the macro.

For syntax information about the Macro Obstruction statement, see "Macro Obstruction Statement" in the LEF/DEF Language Reference.

C++ Syntax

class lefiObstruction {

lefiGeometries* geometries() const;};

Macro Obstruction Examples

The following example shows a callback routine with the type lefrObstructionCbkType, and the class lefiObstruction.

int macroObsCB (lefrCallbackType_e type,

lefiObstruction* obsInfo,

lefiGeometries* geometry;

int numItems;

int i, j;

lefiGeomPath* path;

lefiGeomPathIter* pathIter;

lefiGeomRect* rect;

lefiGeomRectIter* rectIter;

lefiGeomPolygon* polygon;

lefiGeomPolygonIter* polygonIter;

lefiGeomVia* via;

lefiGeomViaIter* viaIter;

if (type != lefrObstructionCbkType) {

printf("Type is not lefrObstructionCbkType,

terminate parsing.\n");

geometry = obs->geometries();

printf("OBS\n");

numItems = geometry->numItems();

for (i = 0; i < numItems; i++) {

switch (geometry->itemType(i)) {

case lefiGeomClassE:

printf(" CLASS %s\n", geometry->getClass(i));

printf(" LAYER %s\n", geometry->getLayer(i));

case lefiGeomLayerE:

printf(" WIDTH %g\n", geometry->getWidth(i))

case lefiGeomWidthE:

path = geometry->getPath(i);

case lefiGeomPathE:

printf(" PATH");

for (j = 0; j < path->numPoints; j++)

printf(" ( %g %g )", path->x[j], path->y[j]);

pathIter = geometry->getPathIter(i);

case lefiGeomPathIterE:

printf(" PATH ITERATED");

for (j = 0; j < pathIter->numPoints; j++)

printf(" ( %g %g )", pathIter->x[j],

pathIter ->y[j]);

printf(" DO %g BY %g STEP %g %g\n",

pathIter->xStart, pathIter->yStart,

pathIter->xStep, pathIter->yStep);

rect = geometry->getRect(i);

case lefiGeomRectE:

printf(" RECT ( %g %g ) ( %g %g )\n", rect->xl,

rect->yl, rect->xh, rect->yh);

break;
case lefiGeomRectIterE:
rectIter = geometry->getRectIter(i);
printf(" RECT ITERATE ( %g %g ) ( %g %g )\n",
rectIter->xl, rectIter->yl,
rectIter->xh, rectIter->yh);
printf(" DO %g BY %g STEP %g %g\n",
rectIter->xStart, rectIter->yStart,
rectIter->xStep, rectIter->yStep);
break;
case lefiGeomPolygonE:
polygon = geometry->getPolygon(i);
printf(" POLYGON");
for (j = 0; j < polygon->numPoints; j++)
printf(" ( %g %g )", polygon->x[j], polygon-
>y[j]);
printf("\n");
break;
case lefiGeomPolygonIterE:
polygonIter = geometry->getPolygonIter(i);
printf(" POLYGON ITERATE");
for (j = 0; j < polygonIter->numPoints; j++)
printf(" ( %g %g )", polygonIter->x[j],
polygonIter->y[j]);
printf("\n");
printf(" DO %g BY %g STEP %g %g\n",
polygonIter->xStart, polygonIter->yStart,
polygonIter->xStep, polygonIter->yStep);
break;
case lefiGeomViaE:
via = geometry->getVia(i);
printf(" VIA ( %g %g ) %s\n", via->x,
via->y, via->name);
break;
case lefiGeomViaIterE:
viaIter = geometry->getViaIter(i);
printf(" VIA ITERATE ( %g %g ) %s\n",
viaIter->x, viaIter->y, viaIter->name);
printf(" DO %g BY %g STEP %g %g\n",
viaIter->xStart, viaIter->yStart,
viaIter->xStep, viaIter->yStep);
break;
}
}
return 0; }

Macro Pin Classes

The LEF Macro Pin routines include the following LEF classes:

lefiPin

lefiPinAntennaModel

lefiGeometries

lefiPin

Retrieves data from the PIN statement in the MACRO section of the LEF file. MACRO PIN statements are included in the LEF file for each macro.

For syntax information about the Macro Pin statement, see "Macro Pin Statement" in the
LEF/DEF Language Reference.

C++ Syntax

class lefiPin {

int hasForeign() const;

int hasForeignOrient(int index = 0) const;

int hasForeignPoint(int index = 0) const;

int hasLEQ() const;

int hasDirection() const;

int hasUse() const;

int hasShape() const;

int hasMustjoin() const;

int hasOutMargin() const;

int hasOutResistance() const;

int hasInMargin() const;

int hasPower() const;

int hasLeakage() const;

int hasMaxload() const;

int hasMaxdelay() const;

int hasCapacitance() const;

int hasResistance() const;

int hasPulldownres() const;

int hasTieoffr() const;

int hasVHI() const;

int hasVLO() const;

int hasRiseVoltage() const;

int hasFallVoltage() const;

int hasRiseThresh() const;

int hasFallThresh() const;

int hasRiseSatcur() const;

int hasFallSatcur() const;

int hasCurrentSource() const;

int hasTables() const;

int hasAntennaSize() const;

int hasAntennaMetalArea() const;

int hasAntennaMetalLength() const;

int hasAntennaPartialMetalArea() const;

int hasAntennaPartialMetalSideArea() const;

int hasAntennaPartialCutArea() const;

int hasAntennaDiffArea() const;

int hasAntennaModel() const;

int hasTaperRule() const;

int hasRiseSlewLimit() const;

int hasFallSlewLimit() const;

int hasNetExpr() const;

int hasSupplySensitivity() const;

int hasGroundSensitivity() const;

Retrieves antenna model information from Macro Pin statement of the LEF file.

int numPorts() const;

lefiGeometries* port(int index) const;

int numForeigns() const;

const char* foreignName(int index = 0) const;

const char* taperRule() const;

int foreignOrient(int index = 0) const; // optional - for information, see

// Orientation Codes

const char* foreignOrientStr(int index = 0) const;
double foreignX(int index = 0) const;
double foreignY(int index = 0) const;
const char* LEQ() const;
const char* direction() const;
const char* use() const;
const char* shape() const;
const char* mustjoin() const;
double outMarginHigh() const;
double outMarginLow() const;
double outResistanceHigh() const;
double outResistanceLow() const;
double inMarginHigh() const;
double inMarginLow() const;
double power() const;
double leakage() const;
double maxload() const;
double maxdelay() const;
double capacitance() const;
double resistance() const;
double pulldownres() const;
double tieoffr() const;
double VHI() const;
double VLO() const;
double riseVoltage() const;
double fallVoltage() const;
double riseThresh() const;
double fallThresh() const;
double riseSatcur() const;
double fallSatcur() const;
double riseSlewLimit() const;
double fallSlewLimit() const;
const char* currentSource() const;
const char* tableHighName() const;
const char* tableLowName() const;

int numAntennaSize() const;
double antennaSize(int index) const;
const char* antennaSizeLayer(int index) const;

int numAntennaMetalArea() const;
double antennaMetalArea(int index) const;
const char* antennaMetalAreaLayer(int index) const;

int numAntennaMetalLength() const;
double antennaMetalLength(int index) const;
const char* antennaMetalLengthLayer(int index) const;

int numAntennaPartialMetalArea() const;
double antennaPartialMetalArea(int index) const;
const char* antennaPartialMetalAreaLayer(int index) const;

int numAntennaPartialMetalSideArea() const;
double antennaPartialMetalSideArea(int index) const;
const char* antennaPartialMetalSideAreaLayer(int index) const;

int numAntennaPartialCutArea() const;
double antennaPartialCutArea(int index) const;
const char* antennaPartialCutAreaLayer(int index) const;

int numAntennaDiffArea() const;
double antennaDiffArea(int index) const;
const char* antennaDiffAreaLayer(int index) const;

const char* netExpr() const;
const char* supplySensitivity() const;
const char* groundSensitivity() const;

int numantennaModel() const;
lefiPinAntennaModel* antennaModel(int index) const;

int numProperties() const;
const char* propName(int index) const;
const char* propValue(int index) const;
double propNum(int index) const;
const char propType(int index) const;
int propIsNumber(int index) const;
int propIsString(int index) const; };

lefiPinAntennaModel

For syntax information about the Macro Pin statement, see "Macro Pin Statement" in the
LEF/DEF Language Reference.

C++ Syntax

class lefiAntennaModel {

int hasAntennaGateArea() const;

int hasAntennaMaxAreaCar() cons

int hasAntennaMaxSideAreaCar() const;

int hasAntennaMaxCutCar() const;

char* antennaOxide() const;

int numantennaGateArea() const;

double antennaGateArea(int index) const;

const char* antennaGateAreaLayer(int index) const;

int numAntennaMaxAreaCar() const;

double antennaMaxAreaCar(int index) const;

const char* antennaMaxAreaCarLayer(int index) const;

int numAntennaMaxSideAreaCar() conts;

double antennaMaxSideAreaCar(int index) const;

const char* antennaMaxSideAreaCarLayer(int index) const;

int numAntennaMaxCutCar() const;

double antennaMaxCutCar(int index) const;

const char* antennaMaxCutCarLayer(int index) const; };

lefiGeometries

Retrieves data from the Macro Pin statement and from the Macro Obstruction statement in the MACRO section of the LEF file. These statements specify the pin port and obstruction geometries for the macro.

For syntax information about LEF geometries, see "Layer Geometries" in the LEF/DEF Language Reference.

C++ Syntax

class lefiGeometries {

int numItems() const;

enum lefiGeomEnum itemType(int index) const;

struct lefiGeomRect* getRect(int index) const;

struct lefiGeomRectIter* getRectIter(int index) const;

struct lefiGeomPath* getPath(int index) const;

struct lefiGeomPathIter* getPathIter(int index) const;

int hasLayerExceptPgNet(int index) const;

char* getLayer(int index) const;

double getLayerMinSpacing(int index) const;

double getLayerRuleWidth(int index) const;

double getWidth(int index) const;

struct lefiGeomPolygon* getPolygon(int index) const;

struct lefiGeomPolygonIter* getPolygonIter(int index) const;

char* getClass(int index) const;

struct lefiGeomVia* getVia(int index) const;

struct lefiGeomViaIter* getViaIter(int index) const;

int colorMask;

};

lefiGeomEnum

Returns the type of geometry of a macro.

C++ Syntax

enum lefiGeomEnum {

lefiGeomunknown = 0,

lefiGeomLayerE,

lefiGeomLayerMinSpacingE,

lefiGeomLayerRuleWidthE,

lefiGeomPolygonIterE,

lefiGeomViaE,

lefiGeomViaIterE,

lefiGeomClassE,

lefiGeomEnd };

lefiGeomRect

Returns data from the RECT statement in the MACRO section.

C++ Syntax

struct lefiGeomRect {

double xl;

double yl;

double xh;

double yh;

int colorMask; }; //specify color mask number for the GeomRect

//structure.

lefiGeomRectIter

Returns data from the RECT ITERATE statement in the MACRO section.

C++ Syntax

struct lefiGeomRectIter {

double xl;

double yl;

double xh;

double yh;

double xStart;

double yStart;

double xStep;

double yStep;

int colorMask;}; //specify color mask number for the GeomRectIter

//structure.

The values are mapped to the structure in the following way:

DO numX BY numY STEP spaceX spaceY


Step Pattern Value	Maps to Structure Value
numX	xStart
numY	yStart
spaceX	xStep
spaceY	yStep

lefiGeomPath

Returns data from the PATH statement in the MACRO section.

C++ Syntax

struct lefiGeomPath {

int numPoints;

double* x;

double* y;

int colorMask; }; //specify color mask number for the GeomPath

//structure.

lefiGeomPathIter

Returns data from the PATH ITERATE statement in the MACRO section.

C++ Syntax

struct lefiGeomPathIter {

int numPoints;

double* x;

double* y;

double xStart;

double yStart;

double xStep;

double yStep;

int colorMask; }; //specify color mask number for the GeomPathIter

//structure.

The values are mapped to the structure in the following way:

DO numX BY numY STEP spaceX spaceY


Step Pattern Value	Maps to Structure Value
numX	xStart
numY	yStart
spaceX	xStep
spaceY	yStep

lefiGeomPolygon

Returns data from the POLYGON statement in the MACRO section.

C++ Syntax

struct lefiGeomPolygon {

int numPoints;

double* x;

double* y;

int colorMask; }; //specify color mask number for the GeomPolygon

//structure.

lefiGeomPolygonIter

Returns data from the POLYGON ITERATE statement in the MACRO section.

C++ Syntax

struct lefiGeomPolygonIter {

int numPoints;

double* x;

double* y;

double xStart;

double yStart;

double xStep;

double yStep;

int colorMask; }; //specify color mask number for the GeomPolygonIter

//structure.

The values are mapped to the structure in the following way:

DO numX BY numY STEP spaceX spaceY


Step Pattern Value	Maps to Structure Value
numX	xStart
numY	yStart
spaceX	xStep
spaceY	yStep

lefiGeomVia

Returns data from the VIA statement in the MACRO section.

C++ Syntax

struct lefiGeomVia {

char* name;

double x;

double y;

int topMaskNum; //define top mask number for the GeomVia structure.

int cutMaskNum; //define cut mask number for the GeomVia structure.

int bottomMaskNum;}; //define bottom mask number for the GeomVia structure.

lefiGeomViaIter

Returns data from the VIA ITERATE statement in the MACRO section.

C++ Syntax

struct lefiGeomViaIter {

char* name;

double x;

double y;

double xStart;

double yStart;

double xStep;

double yStep;

int topMaskNum; //define top mask number for the GeomViaIter structure.

int cutMaskNum; //define cut mask number for the GeomViaIter structure.

int bottomMaskNum;}; //define bottom mask number for the GeomViaIter

//structure.

The values are mapped to the structure in the following way:

DO numX BY numY STEP spaceX spaceY


Step Pattern Value	Maps to Structure Value
numX	xStart
numY	yStart
spaceX	xStep
spaceY	yStep

Macro Pin Examples

The following example shows a callback routine with the type lefrPinCbkType, and the class lefiPin. This example only shows how to retrieve part of the data from the lefiPin class.

int macroPinCB (lefrCallbackType_e type,

lefiPin* pinInfo,

lefiGeometries* geometry;

lefiGeomPathIter* pathIter;

lefiGeomRect* rect;

lefiGeomRectIter* rectIter;

lefiGeomPolygon* polygon;

lefiGeomPolygonIter* polygonIter;

lefiGeomVia* via;

lefiGeomViaIter* viaIter;

if (type != lefrPinCbkType) {

printf("Type is not lefrPinCbkType, terminate parsing.\n");

if (pin->hasForeignOrient())

printf("PIN %s\n", pin->name());

if (pin->hasForeign()) {

printf(" FOREIGN %s STRUCTURE ( %g %g ) %d\n",

pin->foreignName(), pin->foreignX(),

pin->foreignY(), pin->foreignOrient());

else if (pin->hasForeignPoint())

printf(" FOREIGN %s STRUCTURE ( %g %g )\n",

pin->foreignName(), pin->foreignX(),

pin->foreignY());

printf(" FOREIGN %s\n", pin->foreignName());

printf(" LEQ %s\n", pin->LEQ());

if (pin->hasLEQ())

if (pin->hasAntennaSize()) {

for (i = 0; i < pin->numAntennaSize(); i++) {

printf(" ANTENNASIZE %g ", pin->antennaSize(i));

if (pin->antennaSizeLayer(i))

printf("LAYER %s ", pin->antennaSizeLayer(i));

for (i = 0; i < numPorts; i++) {

numPorts = pin->numPorts();

printf(" PORT\n");

geometry = pin->port(i);

// A complete example can be found .

numItems = geometry->numItems();

for (j = 0; j < numItems; j++) {

switch (geometry->itemType(j)) {

case lefiGeomClassE:

printf(" CLASS %s\n", geometry->getClass(j));

printf(" LAYER %s\n", geometry->getLayer(j));

case lefiGeomLayerE:

printf(" WIDTH %g\n", geometry->getWidth(j));

case lefiGeomWidthE:

case lefiGeomPathIterE:

rect = geometry->getRect(j);

case lefiGeomRectE:

printf(" RECT ( %g %g ) ( %g %g )\n", rect->xl,

rect->yl, rect->xh, rect->yh);

case lefiGeomRectIterE:

case lefiGeomPolygonE:

case lefiGeomPolygonIterE:

case lefiGeomViaIterE:

int hasMaxStackViaRange() const;

return 0; }

Maximum Via Stack Class

The LEF MAXSTACKVIA routines include the following LEF class:

lefiMaxStackVia

Retrieves data from the MAXVIASTACK statement in the LEF file.

For syntax information about the LEF MAXVIASTACK statement, see "Maximum Via Stack" in the LEF/DEF Language Reference.

C++ Syntax

class lefiMaxStackVia {

int maxStackVia() const;

const char* maxStackViaBottomLayer() const;

const char* maxStackViaTopLayer() const; }

Miscellaneous Class

Miscellaneous routines include the following LEF class:

lefiUserData

The user data can be set or changed at any time with the lefrSetUserData and lefrGetUserData calls. Every callback returns the user data as the third argument.

C++ Syntax

lefiUserData lefrGetUserData()

Nondefault Rule Class

The LEF NONDEFAULT RULE routines include the following LEF class:

lefiNonDefault

Retrieves data from the NONDEFAULTRULE statement in the LEF file.

For syntax information about the LEF NONDEFAULTRULE statement, see "Nondefault Rule" in the LEF/DEF Language Reference.

C++ Syntax

class lefiNonDefault {

const char* propName(int index) const;

int hardSpacing() const;

int numProps() const;

const char* propValue(int index) const;

double propNumber(int index) const;

const char propType(int index) const;

const char* layerName(int index) const;

int propIsString(int index) const;

int numLayers() const;

int hasLayerWidth(int index) const;

double layerWidth(int index) const;

int hasLayerSpacing(int index) const;

double layerSpacing(int index) const;

int hasLayerWireExtension(int index) const;

double layerWireExtension(int index) const;

int hasLayerDiagWidth(int index) const;

double layerDiagWidth(int index) const;

int numVias() const;

lefiVia* viaRule(int index) const;

int numSpacingRules() const;

lefiSpacing* spacingRule(int index) const;

int numUseVia() const;

const char* viaName(int index) const;

int numUseViaRule() const;

const char* viaRuleName(int index) const;

int numMinCuts() const;

const char* cutLayerName(int index) const;

int numCuts(int index) const; };

Nondefault Rule Examples

The following example shows a callback routine with the type lefrNonDefaultCbkType, and the class lefiNonDefault. This example only shows how to retrieve part of the data from the lefiNonDefault class. For examples of how to retrieve via and spacing data, see the Via Routines and Same-Net Spacing Routines sections.

int nonDefaultCB (lefrCallbackType_e type,

lefiNonDefault* nonDefInfo,

int i;

lefiVia* via;

lefiSpacing* spacing;

if (type != lefrNonDefaultCbkType) {

printf("Type is not lefrNonDefaultCbkType, terminate

// Print out nondefaultrule data

return 1; }

printf("NONDEFAULTRULE %s\n", def->name());

for (i = 0; i < def->numLayers(); i++) {

printf(" LAYER %s\n", def->layerName(i));

if (def->hasLayerWidth(i))

printf(" WIDTH %g\n", def->layerWidth(i));

if (def->hasLayerSpacing(i))

printf(" SPACING %g\n", def->layerSpacing(i));}

// handle via in nondefaultrule

for (i = 0; i < def->numVias(); i++) {

via = def->viaRule(i);

// handle spacing in nondefaultrule

for (i = 0; i < def->numSpacingRules(); i++) {

spacing = def->spacingRule(i);}

return 0;}

Property Definition Classes

The LEF PROPERTYDEFINITIONS routines include the following classes:

lefiProp

lefiPropType

lefiProp

Retrieves data from the PROPERTYDEFINITIONS statement in the LEF file. The PROPERTYDEFINITIONS statement lists all properties used in the LEF file. You must define properties before you refer to them in other routines in the LEF file.

For syntax information about the LEF PROPERTYDEFINITIONS statement, see "Property Definitions" in the LEF/DEF Language Reference.

C++ Syntax

class lefiProp {

const char* string() const;

const char* propType() const;

const char* propName() const;

char dataType() const;

int hasNumber() const;

int hasRange() const;

int hasString() const;

int hasNameMapString() const;

double number() const;

double left() const;

double right() const;};

void* dummy,

if (type != lefrPropBeginCbkType) {

printf("Type is not lefrPropBeginCbkType, terminate

printf("PROPERTYDEFINITIONS\n");

return 0;}

The following example shows a callback routine with the type lefrPropCbkType, and the class lefiProp. This callback routine will be called for each defined property definition.

int propDefCB (lefrCallbackType_e type,

lefiProp* propInfo,

if (type != lefrPropCbkType) {

printf("Type is not lefrPropCbkType, terminate

if (strcmp(propInfo->propType(), "library") == 0)

// Check the object type of the property definition

printf("LIBRARY %s ", propInfo->propName());

else if (strcmp(propInfo->propType(), "pin") == 0)

printf("PIN %s ", propInfo->propName());

else if (strcmp(propInfo->propType(), "macro") == 0)

printf("MACRO %s ", propInfo->propName());

else if (strcmp(propInfo->propType(), "via") == 0)

printf("VIA %s ", propInfo->propName());

else if (strcmp(propInfo->propType(), "viarule") == 0)

printf("VIARULE %s ", propInfo->propName());

else if (strcmp(propInfo->propType(), "layer") == 0)

printf("LAYER %s ", propInfo->propName());

else if (strcmp(propInfo->propType(), "nondefaultrule") == 0

printf("NONDEFAULTRULE %s ", propInfo->propName());

// Check the property type

if (propInfo->dataType() == 'I')

printf("INTEGER ");

if (propInfo->dataType() == 'R')

printf("REAL ");

if (propInfo->dataType() == 'S')

printf("STRING ");

if (propInfo->dataType() == 'Q')

printf("STRING ");

if (propInfo->hasRange()) {

printf("RANGE %g %g ", propInfo->left(), propInfo-

>right());

if (propInfo->hasNumber())

printf("%g ", propInfo->number());

if (propInfo->hasString())

printf("'%s' ", propInfo->string());

return 0;}

The following example shows a callback routine with the type lefrPropEndCbkType, and the class void *. This callback routine marks the end of the Property Definition section.

int propDefEndCB (lefrCallbackType_e type,

void* dummy,

if (type != lefrPropEndCbkType) {

printf("Type is not lefrPropEndCbkType, terminate

printf("END PROPERTYDEFINITIONS\n");

return 0;}

Same-Net Spacing Class

The LEF SPACING routines include the following LEF class:

lefiSpacing

Retrieves data from the SPACING statement in the LEF file.

C++ Syntax

class lefiSpacing {

int hasStack() const;

const char* name1() const;

const char* name2() const;

double distance() const;};

Same-Net Spacing Examples

The following example shows a callback routine with the type lefrSpacingCbkType, and the class lefiSpacing. This callback routine is called for each defined spacing between callback routines with the types lefrSpacingBeginCbkType and lefrSpacingEndCbkType.

int spacingCB (lefrCallbackType_e type,

lefiSpacing* spacingInfo,

if (type != lefrSpacingCbkType) {

printf("Type is not lefrSpacingCbkType, terminate

spacingInfo->name2(), spacingInfo->distance());

printf("SAMENET %s %s %g ", spacingInfo->name1(),

if (spacingInfo->hasStack())

printf("STACK ");

return 0; }

Site Classes

The LEF SITE routines include the following LEF class:

lefiSite

lefiSitePattern

lefiSite

Retrieves data from the SITE statement of the LEF file.

For syntax information about the LEF SITE statement, see "Site" in the LEF/DEF Language Reference.

C++ Syntax

class lefiSite {

const char* siteClass() const;

int hasClass() const;

double sizeX() const;

double sizeY() const;

int hasSize() const;

int hasXSymmetry() const;

int hasYSymmetry() const;

int has90Symmetry() const;

int hasRowPattern() const;

int numSites() const;

char* siteName(int index) const;

int siteOrient(int index) const;

char* siteOrientStr(int index) const; };

lefiSitePattern

Retrieves site pattern information from the SITE statement of the LEF file.

For syntax information about the LEF SITE statement, see "Site" in the LEF/DEF Language Reference.

C++ Syntax

lefiSitePattern {

const char* orientStr() const;

int orient() const;

double x() const;

double y() const;

int hasStepPattern () const;

double xStart() const;

double yStart() const;

double xStep() const;

double yStep() const; };

Site Examples

The following example shows a callback routine with the type lefrSiteCbkType, and the class lefiSite.

int siteCB (lefrCallbackType_e type,

lefiSite* siteInfo,

int hasPrtSym = 0;

if (type != lefrSiteCbkType) {

printf("Type is not lefrSiteCbkType, terminate

if (siteInfo->hasClass())

printf("SITE %s\n", siteInfo->name());

printf(" CLASS %s\n", siteInfo->siteClass());

if (siteInfo->hasXSymmetry()) {

printf(" SYMMETRY X ");

hasPrtSym = 1; // set the flag that the keyword SYMMETRY

has written

if (siteInfo->hasYSymmetry()) {

if (hasPrtSym)

printf("Y ");

else { // keyword SYMMETRY has not been written yet

printf(" SYMMETRY Y ");

if (siteInfo->has90Symmetry()) {

if (hasPrtSym)

printf("R90 ");

else {

printf(" SYMMETRY R90 ");

if (siteInfo->hasSize())

printf(" SIZE %g BY %g\n", siteInfo->sizeX(),

siteInfo->sizeY());

printf("END %s\n", siteInfo->name());

return 0;}

Units Class

The LEF UNITS routines include the following LEF class:

lefiUnits

Retrieves data from the UNITS statement of the LEF file. This statement defines the units of measure in LEF.

For syntax information about the LEF UNITS statement, see "Units" in the LEF/DEF Language Reference.

C++ Syntax

class lefiUnits {

int hasDatabase();

int hasCapacitance();

int hasFrequency();

const char* databaseName();

double databaseNumber();

double capacitance();

double frequency();};

Units Examples

The following example shows a callback routine with the type lefrUnitsCbkType, and the class lefiUnits.

int unitsCB (lefrCallbackType_e type,

lefiUnits* unitInfo,

if (type != lefrUnitsCbkType) {

printf("Type is not lefrUnitsCbkType, terminate

if (unitInfo->hasDatabase())

printf("UNITS\n");

printf(" DATABASE %s %g\n", unitInfo->databaseName(),

unitInfo->databaseNumber());

if (unitInfo->hasCapacitance())

printf(" CAPACITANCE PICOFARADS %g\n",

unitInfo->capacitance());

if (unitInfo->hasResistance())

printf(" RESISTANCE OHMS %g\n", unitInfo->resistance());

if (unitInfo->hasPower())

printf(" POWER MILLIWATTS %g\n", unitInfo->power());

if (unitInfo->hasCurrent())

printf(" CURRENT MILLIAMPS %g\n", unitInfo->current());

if (unitInfo->hasVoltage())

printf(" VOLTAGE VOLTS %g\n", unitInfo->voltage());

if (unitInfo->hasFrequency())

printf(" FREQUENCY MEGAHERTZ %g\n", unitInfo-

>frequency());

printf("END UNITS\n");

return 0;};

Use Min Spacing Class

The LEF USEMINSPACING routines include the following LEF class:

lefiUseMinSpacing

Retrieves data from the USEMINSPACING statement of the LEF file.

For syntax information about the LEF USEMINSPACING statement, see "Use Min Spacing" in the LEF/DEF Language Reference.

C++ Syntax

class lefiUseMinSpacing {

int hasGenerated() const;

int value() const;};

Via Classes

The LEF VIA routines include the following LEF classes:

lefiVia

lefiViaLayer

lefiVia

Retrieves data from the VIA section of the LEF file.

For syntax information about the LEF VIA section, see "Via" in the LEF/DEF Language Reference.

C++ Syntax

class lefiVia {

int hasDefault() const ;

int hasForeign() const ; // optional - for information, see

// Orientation Codes

int hasForeignPnt() const ;

int hasForeignOrient() const ;

int hasProperties() const ;

int hasResistance() const ;

int hasTopOfStack() const ;

int numLayers() const;

char* layerName(int layerNum) const;

int numRects(int layerNum) const;

double xl(int layerNum, int rectNum) const;

double yl(int layerNum, int rectNum) const;

double xh(int layerNum, int rectNum) const;

double yh(int layerNum, int rectNum) const;

int numPolygons(int layerNum) const;

struct lefiGeomPolygon getPolygon(int layerNum, int polyNum) const;

char* name() const ;

double resistance() const ;

int numProperties() const ;

char* propName(int index) const;

char* propValue(int index) const;

double propNumber(int index) const;

char propType(int index) const:

int propIsString(int index) const;

char* foreign() const;

double foreignX() const;

double foreignY() const;

int foreignOrient() const;

char* foreignOrientStr() const;

int hasViaRule() const;

const char* viaRuleName() const;

double xCutSize() const;

double yCutSize() const;

const char* botMetalLayer() const;

const char* cutLayer() const;

const char* topMetalLayer() const;

double xCutSpacing() const;

double yCutSpacing() const;

double xBotEnc() const;

double yBotEnc() const;

double xTopEnc() const;

double yTopEnc() const;

int hasRowCol() const;

int numCutRows() const;

int numCutCols() const;

int hasOrigin() const;

double xOffset() const;

double yOffset() const;

int hasOffset() const;

double xBotOffset() const;

double yBotOffset() const;

double xTopOffset() const;

double yTopOffset() const;

int hasCutPattern() const;

const char* cutPattern() const;

double xl,

double yl,

double xh,

double yh);

lefiGeometries* geom);

int rectColorMask(int layerNum,

int rectNum);

int polyColorMask(int layerNum,

int rectNum); };

lefiViaLayer

Retrieves data from the LAYER statement within the VIA section of the LEF file. The members of the C++ class and C structures correspond to elements of the LAYER statement in the VIA section.

For syntax information about the LEF VIA section, see "Via" in the LEF/DEF Language Reference.

C++ Syntax

class lefiViaLayer {

int numRects();

char* name();

double xl(int index);

double yl(int index);

double xh(int index);

double yh(int index);

int numPolygons();

struct lefiGeomPolygon* getPolygon(int index) const;

double xl,

double yl

double xh

double yn);

lefiGeometries* geom);

int rectColorMask(int index);

int polyColorMask(int index); };

Via Examples

The following example shows a callback routine with the type lefrViaCbkType, and the class lefiVia.

int viaCB (lefrCallbackType_e type,

lefiVia* viaInfo,

int i, j;

if (type != lefrViaCbkType) {

printf("Type is not lefrViaCbkType, terminate

printf("VIA %s ", viaInfo->lefiVia::name());

if (viaInfo->hasDefault())

printf("DEFAULT\n");

if (viaInfo->hasTopOfStack())

printf(" TOPOFSTACKONLY\n");

if (viaInfo->hasForeign()) {

printf(" FOREIGN %s ", viaInfo->foreign());

if (viaInfo->hasForeignPnt()) {

printf("( %g %g ) ", viaInfo->foreignX(),

viaInfo->foreignY());

if (viaInfo->hasForeignOrient())

printf("%s ", orientStr(viaInfo->foreignOrient()));

if (viaInfo->hasProperties()) {

printf(" PROPERTY ");

for (i = 0; i < viaInfo->numProperties(); i++) {

printf("%s ", viaInfo->propName(i));

if (viaInfo->propIsNumber(i))

printf("%g ", viaInfo->propNumber(i));

if (viaInfo->propIsString(i))

printf("%s ", viaInfo->propValue(i));

if (viaInfo->hasResistance())

printf(" RESISTANCE %g\n", viaInfo->resistance());

if (viaInfo->numLayers() > 0) {

for (i = 0; i < viaInfo->numLayers(); i++) {

printf(" LAYER %s\n", viaInfo->layerName(i));

for (j = 0; j < viaInfo->numRects(i); j++)

printf(" RECT ( %g %g ) ( %g %g )\n",
viaInfo->xl(i, j), viaInfo->yl(i, j),
viaInfo->xh(i, j), viaInfo->yh(i, j));
}
}
printf("END %s\n", viaInfo->name());
return 0;}

Via Rule Classes

The LEF VIARULE routines include the following LEF classes:

lefiViaRule

lefiViaRuleLayer

lefiViaRule

Retrieves data from the VIARULE and VIARULE GENERATE statements of the LEF file.

For syntax information about the LEF VIARULE and VIARULE GENERATE statements, see "Via Rule," and "Via Rule Generate" in the LEF/DEF Language Reference.

C++ Syntax

class lefiViaRule {

int hasGenerate() const;

int hasDefault() const;

char* name() const;

int numLayers() const;

lefiViaRuleLayer* layer(int index);

int numVias() const;

char* viaName(int index) const;

int numProps() const;

const char* propName(int index) const;

const char* propValue(int index) const;

double propNumber(int index) const;

const char propType(int index) const;

int hasDirection() const;

int propISString(int index) const; };

lefiViaRuleLayer

Retrieves data from the LAYER statement within the VIARULE and VIARULE GENERATE statements of the LEF file.

For syntax information about the LEF VIARULE and VIARULE GENERATE statements, see "Via Rule," and "Via Rule Generate" in the LEF/DEF Language Reference.

C++ Syntax

class lefiViaRuleLayer {

int hasEnclosure() const;

int hasWidth() const;

int hasResistance() const;

int hasOverhang() const;

int hasMetalOverhang() const;

int hasSpacing() const;

int hasRect() const;

char* name() const;

int isHorizontal() const;

int isVertical() const;

double enclosureOverhang1() const;

double enclosureOverhang2() const;

double widthMin() const;

double widthMax() const;

double overhang() const;

double metalOverhang() const;

double resistance() const;

double spacingStepX() const;

double spacingStepY() const;

double xl() const;

double yl() const;

double xh() const;

double yh() const; };

Via Rule Examples

The following example shows a callback routine with the type lefrViaRuleCbkType, and the class lefiViaRule. This example also shows how to retrieve data from the lefiViaRuleLayer class.

int viaRuleCB (lefrCallbackType_e type,

lefiViaRule* viaRuleInfo,

int numLayers, numVias, i;

lefiViaRuleLayer* vLayer;

printf("VIARULE %s", viaRuleInfo->name());

if (viaRuleInfo->hasGenerate())

printf(" GENERATE\n");