// ***************************************************************************** // ***************************************************************************** // Copyright 2012 - 2013, Cadence Design Systems // // This file is part of the Cadence LEF/DEF Open Source // Distribution, Product Version 5.8. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or // implied. See the License for the specific language governing // permissions and limitations under the License. // // For updates, support, or to become part of the LEF/DEF Community, // check www.openeda.org for details. // // $Author: dell $ // $Revision: #1 $ // $Date: 2017/06/06 $ // $State: $ // ***************************************************************************** // ***************************************************************************** #ifndef LEFW_WRITERCALLS_H #define LEFW_WRITERCALLS_H #include #include "lefiKRDefs.hpp" #include "lefiDefs.hpp" #include "lefiUser.hpp" BEGIN_LEFDEF_PARSER_NAMESPACE // Return codes for writing functions: #define LEFW_OK 0 #define LEFW_UNINITIALIZED 1 #define LEFW_BAD_ORDER 2 #define LEFW_BAD_DATA 3 #define LEFW_ALREADY_DEFINED 4 #define LEFW_WRONG_VERSION 5 #define LEFW_MIX_VERSION_DATA 6 #define LEFW_OBSOLETE 7 // orient // 0 = N // 1 = W // 2 = S // 3 = E // 4 = FN // 5 = FW // 6 = FS // 7 = FE // The LEF writer initialization. Must be called first. // Either this routine or lefwInitCbk should be call only, // Can't call both routines. // This routine must be called only once. // Returns 0 if successful. extern int lefwInit(FILE* f); // The LEF writer initialization. Must be called first. // Either this routine or lefwInit should be call only, // Can't call both routines. // This routine must be called only once. // Returns 0 if successful. extern int lefwInitCbk(FILE* f); // This routine will set the writer to write out an encrypted // lef file. // This routine must be called only once and has to be called after // lefwInit or lefwInitCbk // Need to call lefwCloseEncrypt to do some cleaning if this routine // has called extern int lefwEncrypt(); // This routine needs to be called if lefwEncrypt has called. // It should be called before the fclose. // It does some house cleaning. extern int lefwCloseEncrypt(); // This routine will write a blank line extern int lefwNewLine(); // This routine is called after lefwInit. // This routine can be called only once. // Returns 0 if successful. extern int lefwVersion (int vers1, int vers2); // This routine is called after lefwInit. // This routine can be called only once. // Returns 0 if successful. // The caseSensitive can be ON or OFF. extern int lefwCaseSensitive (const char* caseSensitive); // This routine is called after lefwInit. // This routine can be called only once. // Returns 0 if successful. // The noWireExtensionAtPin can be ON or OFF. extern int lefwNoWireExtensionAtPin (const char* noWireExt); // This routine is called after lefwInit. // This routine can be called only once. // Returns 0 if successful. // already have one extern int lefwMinfeature (double minFeatureX, double minFeatureY); // This routine is called after lefwInit. // This routine can be called only once. // Returns 0 if successful. extern int lefwDielectric (double dielectric); // This routine is called after lefwInit. // This routine can be called only once. // Returns 0 if successful. extern int lefwBusBitChars (const char* busBitChars); // This routine is called after lefwInit. // This routine can be called only once. // Returns 0 if successful. extern int lefwDividerChar (const char* dividerChar); // This routine is called after lefwInit. // This routine can be called only once. // This is a 5.4 syntax. // Returns 0 if successful. extern int lefwManufacturingGrid (double grid); // This routine is called after lefwInit. // This routine can be called only once. // This is a 5.8 syntax. // Returns 0 if successful. extern int lefwFixedMask(); // This routine is called after lefwInit. // This routine can be called multiple times. // This is a 5.4 syntax. // Returns 0 if successful. extern int lefwUseMinSpacing (const char* type, const char* onOff); // This routine is called after lefwInit. // This routine can be called only once. // This is a 5.4 syntax. // Returns 0 if successful. extern int lefwClearanceMeasure (const char* type); // This routine is called after lefwInit. // This routine can be called only once. // This is a 5.4 syntax. // Returns 0 if successful. extern int lefwAntennaInputGateArea (double inputGateArea); // This routine is called after lefwInit. // This routine can be called only once. // This is a 5.4 syntax. // Returns 0 if successful. extern int lefwAntennaInOutDiffArea (double inOutDiffArea); // This routine is called after lefwInit. // This routine can be called only once. // This is a 5.4 syntax. // Returns 0 if successful. extern int lefwAntennaOutputDiffArea (double outputDiffArea); // This routine is called after lefwInit. // This routine can be called only once. // Returns 0 if successful. // This section of routines is optional. // The routine starts the units section. All of the units must follow. extern int lefwStartUnits(); // This routine is called once for each unit. The call must // be preceeded by a call to lefwStartUnits and must be // terminated by a call to lefwEndUnits. // Returns 0 if successful. extern int lefwUnits(double time, // optional(0) - TIME NANOSECONDS double capacitance, // optional(0) - CAPACITANCE PICOFARADS double resistance, // optional(0) - RESISTANCE OHMS double power, // optional(0) - POWER MILLIWATTS double current, // optional(0) - CURRENT MILLIAMPS double voltage, // optional(0) - VOLTAGE VOLTS double database); // optional(0) - DATABASE MICRONS // This routine is called once for each unit. It is separated from // lefwUnits due to backwards compatible for pre 5.3. // Returns 0 if successful. extern int lefwUnitsFrequency(double frequency); // This routine must be called after the lefwUnits call (if any). // The routine can be called only once. // Returns 0 if successful. extern int lefwEndUnits(); // This routine is called after lefwInit. // Either this routine or lefwStartLayerRouting must be called. // Multiple sections of lefwStartLayer can be called. // This routine can be called only once per section. // Returns 0 if successful. // The routine starts the layer section. All of the layers must follow. // The type can be either CUT for Cut Layer, MASTERSLICE or OVERLAP for // Masterslice or Overlay Layer. extern int lefwStartLayer(const char* layerName, const char* type); // CUT | MASTERSLICE | OVERLAP // This routine must be called after lefwStartLayer. // This section of routines is optional. // Returns 0 if successful. // This is a 5.8 syntax. extern int lefwLayerMask(int maskColor); // This routine must be called after lefwStartLayer. // This section of routines is optional. // Returns 0 if successful. // This is a 5.5 syntax. // This routine is called if the layer type is IMPLANT when // lefwStartLayer is called. extern int lefwLayerWidth(double minWidth); // The following APIs are for lefwrite 5.7 Layer, Spacing with type CUT // Due to adding new constructs, it is impossible to use the previous // APIs. // The following APIs are obsoleted in 5.7: // lefwLayer // lefwLayerStack // lefwLayerSpacingAdjacent // lefwLayerSpacingCenterToCenter // This routine must be called after lefwStartLayer. // This routine starts the Layer Type Cut Spacing // Returns 0 if successful. // The routing lefwLayerCutSpacingEnd has to call at the end of each spacing. // This is a 5.7 syntax. extern int lefwLayerCutSpacing(double spacing) ; // This routine must be called after lefwLayerSpacing // This routine is optional. // Returns 0 if successful. // This is a 5.7 syntax. extern int lefwLayerCutSpacingCenterToCenter(); // This routine must be called after lefwLayerSpacing // This routine is optional. // Returns 0 if successful. // This is a 5.7 syntax. extern int lefwLayerCutSpacingSameNet(); // This routine must be called after lefwLayerSpacing // This routine is optional. // Either this routine, lefwLayerCutSpacingAdjacent, // lefwLayerCutSpacingParallel or lefwLayerCutSpacingArea is called per Spacing. // Returns 0 if successful. // This is a 5.7 syntax. extern int lefwLayerCutSpacingLayer(const char* name2, int stack); // optional(0) // This routine must be called after lefwLayerSpacing // This routine is optional. // Either this routine, lefwLayerCutSpacingLayer, // lefwLayerCutSpacingParallel or lefwLayerCutSpacingArea is called per Spacing. // Returns 0 if successful. // This is a 5.7 syntax. extern int lefwLayerCutSpacingAdjacent(int viaCuts, // either 2, 3, or 4, opt double distance, int stack); // optional(0) // This routine must be called after lefwLayerSpacing // This routine is optional. // Either this routine, lefwLayerCutSpacingLayer, // lefwLayerCutSpacingAdjacent or lefwLayerCutSpacingArea is called per Spacing. // Returns 0 if successful. // This is a 5.7 syntax. extern int lefwLayerCutSpacingParallel(); // This routine must be called after lefwLayerSpacing // This routine is optional. // Either this routine, lefwLayerCutSpacingLayer, * lefwLayerCutSpacingAdjacent // or lefwLayerCutSpacingParallel is called per Spacing. // Returns 0 if successful. // This is a 5.7 syntax. extern int lefwLayerCutSpacingArea(double cutArea); // This routine must be called after lefwLayerSpacing // This routine marks the end of a Layer Type CUT Spacing // Returns 0 if successful. // This is a 5.7 syntax. extern int lefwLayerCutSpacingEnd(); // This routine must be called after lefwStartLayer. // This routine can be called only once. // This section of routines is optional. // This is a 5.7 syntax // Returns 0 if successful. // This routine is called if the layer type is CUT when // lefwStartLayer is called. extern int lefwLayerCutSpacingTableOrtho(int numSpacing, double* cutWithins, double* orthoSpacings); // This routine must be called after lefwStartLayer. // This routine can be called only once. // This section of routines is optional. // This is a 5.7 syntax // Returns 0 if successful. // This routine is called if the layer type is CUT when // lefwStartLayer is called. extern int lefwLayerArraySpacing(int longArray, // optional (0) double viaWidth, // optional (0) double cutSpacing, int numArrayCut, int* arrayCuts, double* arraySpacings); // This routine must be called after lefwStartLayer. // This routine can be called multiple times. // This section of routines is optional. // This is a 5.6 syntax. // Returns 0 if successful. // This routine is called if the layer type is CUT when // lefwStartLayer is called. extern int lefwLayerEnclosure(const char* location, //ABOVE|BELOW, optional "" double overhang1, double overhang2, double width); // optional (0) // This routine must be called after lefwStartLayer. // This routine can be called multiple times. // This routine is similar as lefwLayerEnclosure, but allow user to add // EXCEPTEXTRACUT option // This section of routines is optional. // This is a 5.7 syntax. // Returns 0 if successful. // This routine is called if the layer type is CUT when // lefwStartLayer is called. extern int lefwLayerEnclosureWidth( const char* location, //ABOVE|BELOW, optional "" double overhang1, double overhang2, double width, // optional (0) double cutWithin); // optional (0) // This routine must be called after lefwStartLayer. // This routine can be called multiple times. // This routine is to write out minLength inside ENCLOSURE instead of WIDTH // as in the routine lefwLayerEnclosure & lefwLayerEnclosureWidth. // This section of routines is optional. // This is a 5.7 syntax. // Returns 0 if successful. // This routine is called if the layer type is CUT when // lefwStartLayer is called. extern int lefwLayerEnclosureLength( const char* location, //ABOVE|BELOW, optional "" double overhang1, double overhang2, double minLength); // optional (0) // This routine must be called after lefwStartLayer. // This routine can be called multiple times. // This section of routines is optional. // This is a 5.6 syntax. // Returns 0 if successful. // This routine is called if the layer type is CUT when // lefwStartLayer is called. extern int lefwLayerPreferEnclosure( const char* location, //ABOVE|BELOW, optional "" double overhang1, double overhang2, double width); // optional (0) // This routine must be called after lefwStartLayer. // This routine can be called only once per Layer. // This section of routines is optional. // This is a 5.6 syntax. // Returns 0 if successful. // This routine is called if the layer type is CUT when // lefwStartLayer is called. extern int lefwLayerResistancePerCut(double resistance); // This routine must be called after the lefwStartLayer call (if any). // The routine can be called only once per section. // Returns 0 if successful. extern int lefwEndLayer(const char* layerName); // This routine is called after lefwInit. // Either this routine or lefwStartLayer must be called. // Multiple section of lefwStartLayer can be called. // The routine can be called only once per section. // Returns 0 if successful. // The routine starts the layer routing section. // All of the layers must follow. extern int lefwStartLayerRouting(const char* layerName); // This routine must be called only once after lefwStartLayerRouting. // This routine is required for LayerRouting. // Returns 0 if successful. extern int lefwLayerRouting(const char* direction, // HORIZONTAL | VERTICAL | // DIAG45 | DIAG135 double width); // This routine must be called only once after lefwStartLayerRouting. // Either this routine or lefwLayerRoutingPitchXYDistance can be called // but not both // This is a 5.6 syntax. // Returns 0 if successful. extern int lefwLayerRoutingPitch(double pitch); // This routine must be called only once after lefwStartLayerRouting. // Either this routine or lefwLayerRoutingPitch can be called but not both // This is a 5.6 syntax. // Returns 0 if successful. extern int lefwLayerRoutingPitchXYDistance(double xDistance, double yDistance); // This routine must be called only once after lefwStartLayerRouting. // Either this routine or lefwLayerRoutingDiagPitchXYDistance can be called // but not both // This is a 5.6 syntax. // Returns 0 if successful. extern int lefwLayerRoutingDiagPitch(double distance); // This routine must be called only once after lefwStartLayerRouting. // Either this routine or lefwLayerRoutingDiagPitch can be called // but not both // This is a 5.6 syntax. // Returns 0 if successful. extern int lefwLayerRoutingDiagPitchXYDistance(double diag45Distance, double diag135Distance); // This routine must be called only once after lefwStartLayerRouting. // This is a 5.6 syntax. // Returns 0 if successful. extern int lefwLayerRoutingDiagWidth(double diagWidth); // This routine must be called only once after lefwStartLayerRouting. // This is a 5.6 syntax. // Returns 0 if successful. extern int lefwLayerRoutingDiagSpacing(double diagSpacing); // This routine must be called only once after lefwStartLayerRouting. // This is a 5.6 syntax. // Returns 0 if successful. extern int lefwLayerRoutingDiagMinEdgeLength(double diagLength); // This routine must be called only once after lefwStartLayerRouting. // This routine is optional // Either this routine or lefwLayerRoutingOffsetXYDistance can be called // but not both // Returns 0 if successful. extern int lefwLayerRoutingOffset(double offset); // This routine must be called only once after lefwStartLayerRouting. // This routine is optional // Either this routine or lefwLayerRoutingOffset can be called but not both // This is a 5.6 syntax. // Returns 0 if successful. extern int lefwLayerRoutingOffsetXYDistance(double xDistance, double yDistance); // This routine must be called only once after lefwStartLayerRouting. // This routine is optional // Returns 0 if successful. extern int lefwLayerRoutingArea(double area); // This routine must be called only once after lefwStartLayerRouting. // This routine is optional // Returns 0 if successful. extern int lefwLayerRoutingMinsize(int numRect, double* minWidth, double* minLength); // This routine must be called only once after lefwStartLayerRouting. // This routine is optional // Returns 0 if successful. extern int lefwLayerRoutingMinimumcut(double numCuts, double minWidth); // This routine must be called only once after lefwStartLayerRouting. // This routine is similar as lefwLayerRoutingMinimumcut, but allow user // to specify value for WITHIN // This is a 5.7 syntax. // This routine is optional // Returns 0 if successful. extern int lefwLayerRoutingMinimumcutWithin(double numCuts, double minWidth, double cutDistance); // This routine must be called only once after lefwLayerRoutingMinimumcut. // This routine is optional. // Direction can be either FROMABOVE or FROMBELOW // This is a 5.5 syntax. // Returns 0 if successful. extern int lefwLayerRoutingMinimumcutConnections(const char* direction); // This routine must be called only once after lefwLayerRoutingMinimumcut. // This routine is optional. // This is a 5.5 syntax. // Returns 0 if successful. extern int lefwLayerRoutingMinimumcutLengthWithin(double length, double distance); // This routine must be called multiple time after lefwStartLayerRouting. // This routine is optional // Returns 0 if successful. extern int lefwLayerRoutingSpacing(double spacing); // Either this routine, lefwLayerRoutingSpacingLengthThreshold or // lefwLayerRoutingSpacingSameNet can be // called only once after lefwLayerRoutingSpacing. // This routine is optional. // Returns 0 if successful. extern int lefwLayerRoutingSpacingRange(double minWidth, double maxWidth); // Either this routine or lefwLayerRoutingSpacingRangeInfluence or // lefwLayerRoutingSpacingRangeRange can // be called once after llefwLayerRoutingSpacingRange. // This routine is valid only if either or both leftRange and rightRange // in lefwLayerRoutingSpacing are non zero // Returns 0 if successful. extern int lefwLayerRoutingSpacingRangeUseLengthThreshold(); // Either this routine or lefwLayerRoutingSpacingRangeUseLengthThreshold or // lefwLayerRoutingSpacingRangeRange can be called once after // lefwLayerRoutingSpacingRange. // subMinWidth & subMaxWidth are optional. // Returns 0 if successful. extern int lefwLayerRoutingSpacingRangeInfluence(double infValue, double subMinWidth, double subMaxWidth); // Either this routine or lefwLayerRoutingSpacingRangeUseLengthThreshold or // lefwLayerRoutingSpacingRangeInfluence can be called once after // lefwLayerRoutingSpacingRange. // Returns 0 if successful. extern int lefwLayerRoutingSpacingRangeRange(double minWidth, double maxWidth); // Either this routine, lefwLayerRoutingSpacingRange or // lefwLayerRoutingSpacingSameNet can be // be called once after lefwLayerRoutingSpacing. // minWidth & maxWidth are optional. // Returns 0 if successful. extern int lefwLayerRoutingSpacingLengthThreshold(double lengthValue, double minWidth, double maxWidth); // Either this routine, lefwLayerRoutingSpacingRange or // lefwLayerRoutingSpacingRange can be // be called once after lefwLayerRoutingSpacing. // This is a 5.7 routine. // Returns 0 if successful. extern int lefwLayerRoutingSpacingSameNet(int PGOnly) ; // optional (0) // This routine must be called only once after lefwStartLayerRouting. // This routine is optional // This is a 5.7 syntax. // Returns 0 if successful. extern int lefwLayerRoutingSpacingEndOfLine(double eolWidth, double eolWithin); // This routine must be called only once after lefwLayerRoutingSpacingEndOfLine // This routine is optional // This is a 5.7 syntax. // Returns 0 if successful. extern int lefwLayerRoutingSpacingEOLParallel(double parSpace, double parWithin, int twoEdges); // optional(0) // This routine must be called only once after lefwStartLayerRouting. // This routine is optional // This is a 5.7 syntax. // Returns 0 if successful. extern int lefwLayerRoutingSpacingNotchLength(double minNLength); // This routine must be called only once after lefwStartLayerRouting. // This routine is optional // This is a 5.7 syntax. // Returns 0 if successful. extern int lefwLayerRoutingSpacingEndOfNotchWidth(double eonWidth, double minNSpacing, double minNLength); // This routine must be called only once after lefwStartLayerRouting. // This routine is optional // Returns 0 if successful. extern int lefwLayerRoutingWireExtension(double wireExtension); // This routine must be called only once after lefwStartLayerRouting. // This routine is optional // Returns 0 if successful. extern int lefwLayerRoutingResistance(const char* resistance); // This routine must be called only once after lefwStartLayerRouting. // This routine is optional // Returns 0 if successful. extern int lefwLayerRoutingCapacitance(const char* capacitance); // This routine must be called only once after lefwStartLayerRouting. // This routine is optional // Returns 0 if successful. extern int lefwLayerRoutingHeight(double height); // This routine must be called only once after lefwStartLayerRouting. // This routine is optional // Returns 0 if successful. extern int lefwLayerRoutingThickness(double thickness); // This routine must be called only once after lefwStartLayerRouting. // This routine is optional // Returns 0 if successful. extern int lefwLayerRoutingShrinkage(double shrinkage); // This routine must be called only once after lefwStartLayerRouting. // This routine is optional // Returns 0 if successful. extern int lefwLayerRoutingCapMultiplier(double capMultiplier); // This routine must be called only once after lefwStartLayerRouting. // This routine is optional // Returns 0 if successful. extern int lefwLayerRoutingEdgeCap(double edgeCap); // This routine must be called only once after lefwStartLayerRouting. // This routine is optional // Returns 0 if successful. extern int lefwLayerRoutingAntennaArea(double antennaArea); // This routine must be called only once after lefwStartLayerRouting. // This routine is optional // Returns 0 if successful. extern int lefwLayerRoutingAntennaLength(double antennaLength); // This routine must be called only once after lefwStartLayerRouting. // This routine is optional and can be called once. // This is a 5.5 syntax. // width is the maximum width. // Returns 0 if successful. extern int lefwLayerRoutingMaxwidth(double width); // This routine must be called only once after lefwStartLayerRouting. // This routine is optional and can be called once. // This is a 5.5 syntax. // width is the maximum width. // Returns 0 if successful. extern int lefwLayerRoutingMinwidth(double width); // This routine must be called only once after lefwStartLayerRouting. // This routine is optional. // This is a 5.5 syntax. // Area is the minimum area size limit for metal that encloses an empty area. // Width is optional, it says the rule only applies when a donut is careted // from a wire of width <= width. The parameter width is required for the // routine lefwLayerRoutineMinenclosedarea. If width is optional, a "0" // value is assigned for that index slot of the array. // Returns 0 if successful. extern int lefwLayerRoutingMinenclosedarea(int numMinenclosed, double* area, double* width); // This routine must be called only once after lefwStartLayerRouting. // This routine is optional and can be called once. // This is a 5.5 syntax. // Returns 0 if successful. extern int lefwLayerRoutingMinstep(double distance); // This routine must be called only once after lefwStartLayerRouting. // This routine is optional and can be called once. // This routine is equivalent to lefwLayerRoutingMinstep, except it also // takes the options for type & Lengthsum. // This is a 5.5 syntax. // Returns 0 if successful. extern int lefwLayerRoutingMinstepWithOptions(double distance, const char* rule, // INSIDECORNER|OUTSIDECORNER|STEP double maxLength); // This routine must be called only once after lefwStartLayerRouting. // This routine is optional and can be called once. // This routine is equivalent to lefwLayerRoutingMinstep, except it also // takes the option for MaxEdges. // This is a 5.7 syntax. // Returns 0 if successful. extern int lefwLayerRoutingMinstepMaxEdges(double distance, double maxEdges); // This routine must be called only once after lefwStartLayerRouting. // This routine is optional and can be called once. // This is a 5.5 syntax. // Returns 0 if successful. extern int lefwLayerRoutingProtrusion(double width1, double length, double width2); // This routine must be called only after lefwStartLayerRouting. // This routine is optional and can be called multiple times. // This is a 5.5 syntax. // numLength has the size of the array length. // length is an array of length values. // Returns 0 if successful. extern int lefwLayerRoutingStartSpacingtableParallel(int numLength, double* length); // This routine must be called only after // lefwLayerRoutingStartSpacingtableParallel. // This routine is required after lefwLayerRoutingStartSpacingtableParallel. // This routine can be called multiple times. // This is a 5.5 syntax. // Returns 0 if successful. extern int lefwLayerRoutingSpacingtableParallelWidth(double width, int numSpacing, double* spacing); // This routine must be called only after lefwStartLayerRouting. // This routine is optional and can be called multiple times. // This is a 5.5 syntax. // Returns 0 if successful. extern int lefwLayerRoutingStartSpacingtableInfluence(); // This routine must be called only after // lefwLayerRoutingStartSpacingtableInfluence. // This routine is required after lefwLayerRoutingStartSpacingtableInfluence. // This routine can be called multiple times. // This is a 5.5 syntax. // Returns 0 if successful. extern int lefwLayerRoutingSpacingInfluenceWidth(double width, double distance, double spacing); // This routine must be called only after lefwStartLayerRouting. // This routine is optional and can be called multiple times. // This is a 5.7 syntax. // Returns 0 if successful. extern int lefwLayerRoutingStartSpacingtableTwoWidths(); // This routine must be called only after // lefwLayerRoutingStartSpacingtableInfluence. // This routine is required after lefwLayerRoutingStartSpacingtableTwoWidths. // This routine can be called multiple times. // This is a 5.7 syntax. // Returns 0 if successful. extern int lefwLayerRoutingSpacingtableTwoWidthsWidth(double width, double runLength, // PRL, optional (0) int numSpacing, double* spacing); // This routine can be called after lefwLayerRoutingStartSpacingtableParallel // or lefwLayerRoutingStartSpacingtableInfluence. // It can only be called once. // This is a 5.5 syntax. // Returns 0 if successful. extern int lefwLayerRoutineEndSpacingtable(); // This routine must be called after the lefwStartLayer call (if any). // The routine can be called only once per section. // Returns 0 if successful. extern int lefwEndLayerRouting(const char* layerName); // This routine must be called after lefwStartLayerRouting or lefwStartLayer. // This routine is optional and can be called multiple times. // if the value for the variable value is not 0, one of the following // routines have to be called: lefwLayerACFrequency, // lefwLayerACWidth, lefwLayerACCutarea, or // lefwLayerACTableEntries // Returns 0 if successful. extern int lefwLayerACCurrentDensity(const char* type, double value); // This routine must be called after lefwLayerACCurrentDensity. // This routine is required and can be called only once after each // lefwLayerACCurrentDensity. // Returns 0 if successful. extern int lefwLayerACFrequency(int numFrequency, double* frequency); // This routine must be called after lefwLayerACCurrentDensity. // This routine is optional and can be called only once after each // lefwLayerACCurrentDensity. // This routine can only be called in Layer Routing // Returns 0 if successful. extern int lefwLayerACWidth(int numWidths, double* widths); // This routine must be called after lefwLayerACCurrentDensity. // This routine is optional and can be called only once after each // lefwLayerACCurrentDensity. // This routine can only be called in Layer // Returns 0 if successful. extern int lefwLayerACCutarea(int numCutareas, double* cutareas); // This routine must be called after lefwLayerACCurrentDensity. // This routine is required and can be called only once after each // lefwLayerACCurrentDensity. // Returns 0 if successful. extern int lefwLayerACTableEntries(int numEntries, double* entries); // This routine must be called after lefwStartLayerRouting or lefwStartLayer. // This routine is optional and can be called multiple times. // if the value for the variable value is not 0, one of the following // routines have to be called: lefwLayerDCWidth, lefwLayerDCCutarea, or // lefwLayerDCTableEntries // Returns 0 if successful. extern int lefwLayerDCCurrentDensity(const char* type, double value); // This routine must be called after lefwLayerDCCurrentDensity. // This routine is optional and can be called only once after each // lefwLayerDCCurrentDensity. // This routine can only be called in Layer Routing // Returns 0 if successful. extern int lefwLayerDCWidth(int numWidths, double* widths); // This routine must be called after lefwLayerDCCurrentDensity. // This routine is optional and can be called only once after each // lefwLayerDCCurrentDensity. // This routine can only be called in Layer // Returns 0 if successful. extern int lefwLayerDCCutarea(int numCutareas, double* cutareas); // This routine must be called after lefwLayerDCCurrentDensity. // This routine is required and can be called only once after each // lefwLayerDCCurrentDensity. // Returns 0 if successful. extern int lefwLayerDCTableEntries(int numEntries, double* entries); // This routine must be called after lefwStartLayerRouting or lefwStartLayer. // This routine is optional. The oxide value, can be either OXIDE1, OXIDE2, // OXIDE3, or OXIDE4. Each can only be called once within a layer. // This routine is valid only if the layer type is either ROUTING or CUT. // This is a 5.5 syntax. // Returns 0 if successful. extern int lefwLayerAntennaModel(const char* oxide); // This routine must be called after lefwStartLayerRouting or lefwStartLayer. // This routine is optional and can be called only once within a layer // after each lefwLayerAntennaModel function. // This routine is valid only if the layer type is either ROUTING or CUT. // This is a 5.4 syntax. // Either this routine or lefwLayerRoutingAntennaLength is allowed, not both. // Returns 0 if successful. extern int lefwLayerAntennaAreaRatio(double value); // This routine must be called after lefwStartLayerRouting or lefwStartLayer. // This routine is optional and can be called only once within a layer // after each lefwLayerAntennaModel function. // This routine is valid only if the layer type is either ROUTING or CUT. // Either this routine or lefwLayerAntennaDiffAreaRatioPwl can be called, but // not both // This is a 5.4 syntax. // Either this routine or lefwLayerRoutingAntennaLength is allowed, not both. // Returns 0 if successful. extern int lefwLayerAntennaDiffAreaRatio(double value); // This routine must be called after lefwStartLayerRouting or lefwStartLayer. // This routine is optional and can be called only once within a layer // after each lefwLayerAntennaModel function. // This routine is valid only if the layer type is either ROUTING or CUT. // Either this routine or lefwLayerAntennaDiffAreaRatio can be called, but // not both // This is a 5.4 syntax. // Either this routine or lefwLayerRoutingAntennaLength is allowed, not both. // Returns 0 if successful. extern int lefwLayerAntennaDiffAreaRatioPwl(int numPwls, double* diffusions, double* ratios); // This routine must be called after lefwStartLayerRouting or lefwStartLayer. // This routine is optional and can be called only once within a layer // after each lefwLayerAntennaModel function. // This routine is valid only if the layer type is either ROUTING or CUT. // This is a 5.4 syntax. // Either this routine or lefwLayerRoutingAntennaLength is allowed, not both. // Returns 0 if successful. extern int lefwLayerAntennaCumAreaRatio(double value); // This routine must be called after lefwStartLayerRouting or lefwStartLayer. // This routine is optional and can be called only once within a layer // after each lefwLayerAntennaModel function. // This routine is valid only if the layer type is either ROUTING or CUT. // Either this routine or lefwLayerAntennaCumDiffAreaRatioPwl can be called, // but not both // This is a 5.4 syntax. // Either this routine or lefwLayerRoutingAntennaLength is allowed, not both. // Returns 0 if successful. extern int lefwLayerAntennaCumDiffAreaRatio(double value); // This routine must be called after lefwStartLayerRouting or lefwStartLayer. // This routine is optional and can be called only once within a layer // after each lefwLayerAntennaModel function. // This routine is valid only if the layer type is either ROUTING or CUT. // Either this routine or lefwLayerAntennaCumDiffAreaRatio can be called, but // not both // This is a 5.4 syntax. // Either this routine or lefwLayerRoutingAntennaLength is allowed, not both. // Returns 0 if successful. extern int lefwLayerAntennaCumDiffAreaRatioPwl(int numPwls, double* diffusions, double* ratios); // This routine must be called after lefwStartLayerRouting or lefwStartLayer. // This routine is optional and can be called only once within a layer // after each lefwLayerAntennaModel function. // This routine is valid only if the layer type is either ROUTING or CUT. // The option DIFFUSEONLY is a 5.4 syntax. // If DIFFUSEONLY, lefwLayerRoutingAntennaLength is not allowed. // This function is similar to lefwLayerRoutingAntennaArea // diffUseOnly has to be DIFFUSEONLY. // Returns 0 if successful. extern int lefwLayerAntennaAreaFactor(double value, const char* diffUseOnly); // optional(NULL) // This routine must be called after lefwStartLayerRouting or lefwStartLayer. // This routine is optional and can be called only once within a layer // after each lefwLayerAntennaModel function. // This routine is valid only if the layer type is either ROUTING. // This is a 5.4 syntax. // Either this routine or lefwLayerRoutingAntennaLength is allowed, not both. // Returns 0 if successful. extern int lefwLayerAntennaSideAreaRatio(double value); // This routine must be called after lefwStartLayerRouting or lefwStartLayer. // This routine is optional and can be called only once within a layer // after each lefwLayerAntennaModel function. // This routine is valid only if the layer type is either ROUTING. // Either this routine or lefwLayerAntennaDiffSideAreaRatioPwl can be // called, but not both // This is a 5.4 syntax. // Either this routine or lefwLayerRoutingAntennaLength is allowed, not both. // Returns 0 if successful. extern int lefwLayerAntennaDiffSideAreaRatio(double value); // This routine must be called after lefwStartLayerRouting or lefwStartLayer. // This routine is optional and can be called only once within a layer // after each lefwLayerAntennaModel function. // This routine is valid only if the layer type is either ROUTING or CUT. // Either this routine or lefwLayerAntennaDiffSideAreaRatio can be called, // but not both // This is a 5.4 syntax. // Either this routine or lefwLayerRoutingAntennaLength is allowed, not both. // Returns 0 if successful. extern int lefwLayerAntennaDiffSideAreaRatioPwl(int numPwls, double* diffusions, double* ratios); // This routine must be called after lefwStartLayerRouting or lefwStartLayer. // This routine is optional and can be called only once within a layer // after each lefwLayerAntennaModel function. // This routine is valid only if the layer type is either ROUTING. // This is a 5.4 syntax. // Either this routine or lefwLayerRoutingAntennaLength is allowed, not both. // Returns 0 if successful. extern int lefwLayerAntennaCumSideAreaRatio(double value); // This routine must be called after lefwStartLayerRouting or lefwStartLayer. // This routine is optional and can be called only once within a layer // after each lefwLayerAntennaModel function. // This routine is valid only if the layer type is either ROUTING. // Either this routine or lefwLayerAntennaCumDiffSideAreaRatioPwl can be // called, but not both // This is a 5.4 syntax. // Either this routine or lefwLayerRoutingAntennaLength is allowed, not both. // Returns 0 if successful. extern int lefwLayerAntennaCumDiffSideAreaRatio(double value); // This routine must be called after lefwStartLayerRouting or lefwStartLayer. // This routine is optional and can be called only once within a layer // after each lefwLayerAntennaModel function. // This routine is valid only if the layer type is either ROUTING or CUT. // Either this routine or lefwLayerAntennaCumDiffSideAreaRatio can be called, // but not both // This is a 5.4 syntax. // Either this routine or lefwLayerRoutingAntennaLength is allowed, not both. // Returns 0 if successful. extern int lefwLayerAntennaCumDiffSideAreaRatioPwl(int numPwls, double* diffusions, double* ratios); // This routine must be called after lefwStartLayerRouting or lefwStartLayer. // This routine is optional and can be called only once within a layer // after each lefwLayerAntennaModel function. // This routine is valid only if the layer type is either ROUTING. // The option DIFFUSEONLY is a 5.4 syntax. // diffUseOnly has to be DIFFUSEONLY. // Returns 0 if successful. extern int lefwLayerAntennaSideAreaFactor(double value, const char* diffUseOnly); // optional(NULL) // This routine must be called after lefwStartLayerRouting or lefwStartLayer. // This routine is optional and can be called only once within a layer // after each lefwLayerAntennaModel function. // This routine is valid only if the layer type is either ROUTING or CUT. // This is a 5.7 routine. // Returns 0 if successful. extern int lefwLayerAntennaCumRoutingPlusCut() ; // This routine must be called after lefwStartLayerRouting or lefwStartLayer. // This routine is optional and can be called only once within a layer // after each lefwLayerAntennaModel function. // This routine is valid only if the layer type is either ROUTING or CUT. // This is a 5.7 routine. // Returns 0 if successful. extern int lefwLayerAntennaGatePlusDiff(double plusDiffFactor) ; // This routine must be called after lefwStartLayerRouting or lefwStartLayer. // This routine is optional and can be called only once within a layer // after each lefwLayerAntennaModel function. // This routine is valid only if the layer type is either ROUTING or CUT. // This is a 5.7 routine. // Returns 0 if successful. extern int lefwLayerAntennaAreaMinusDiff(double minusDiffFactor) ; // This routine must be called after lefwStartLayerRouting or lefwStartLayer. // This routine is optional and can be called only once within a layer // after each lefwLayerAntennaModel function. // This routine is valid only if the layer type is either ROUTING or CUT. // This is a 5.7 routine. // Returns 0 if successful. extern int lefwLayerAntennaAreaDiffReducePwl(int numPwls, double* diffAreas, double* metalDiffFactors); // This routine must be called only once after lefwStartLayer. // The option MINIMUMDENSITY is a 5.4 syntax. // Returns 0 if successful. extern int lefwMinimumDensity(double minDensity); // This routine must be called only once after lefwStartLayer. // The option MAXIMUMDENSITY is a 5.4 syntax. // Returns 0 if successful. extern int lefwMaximumDensity(double maxDensity); // This routine must be called only once after lefwStartLayer. // The option DENSITYCHECKWINDOW is a 5.4 syntax. // Returns 0 if successful. extern int lefwDensityCheckWindow(double checkWindowLength, double checkWindowWidth); // This routine must be called only once after lefwStartLayer. // The option DENSITYCHECKSTEP is a 5.4 syntax. // Returns 0 if successful. extern int lefwDensityCheckStep(double checkStepValue); // This routine must be called only once after lefwStartLayer. // The option FILLACTIVESPACING is a 5.4 syntax. // Returns 0 if successful. extern int lefwFillActiveSpacing(double fillToActiveSpacing); // This routine must be called only once after all the layers. // This routine is optional. // This is a 5.5 syntax. // Returns 0 if succesful. extern int lefwMaxviastack(int value, const char* bottomLayer, // optional (NULL) const char* topLayer); // optional (NULL) // This routine is called after lefwInit. // This section of routines is optional. // The routine can be called only once. // Returns 0 if successful. // The routine starts propertydefinitions section. extern int lefwStartPropDef(); // This routine must be called after lefwStartPropDef. // This routine can be called multiple times. // It adds integer property definition to the statement. // Returns 0 if successful. // The objType can be LIBRARY or VIA or MACRO or PIN. extern int lefwIntPropDef( const char* objType, // LIBRARY | LAYER | VIA | VIARULE | // NONDEFAULTRULE | MACRO | PIN const char* propName, double leftRange, // optional(0) - RANGE double rightRange, // optional(0) int propValue); // optional(NULL) // This routine must be called after lefwStartPropDef. // This routine can be called multiple times. // It adds real property definition to the statement. // Returns 0 if successful. // The objType can be LIBRARY or VIA or MACRO or PIN. extern int lefwRealPropDef( const char* objType, // LIBRARY | LAYER | VIA | VIARULE | // NONDEFAULTRULE | MACRO | PIN const char* propName, double leftRange, // optional(0) - RANGE double rightRange, // optional(0) double propValue); // optional(NULL) // This routine must be called after lefwStartPropDef. // This routine can be called multiple times. // It adds string property definition to the statement. // Returns 0 if successful. // The objType can be LIBRARY or VIA or MACRO or PIN. extern int lefwStringPropDef( const char* objType, // LIBRARY | LAYER | VIA | VIARULE | // NONDEFAULTRULE | MACRO | PIN const char* propName, double leftRange, // optional(0) - RANGE double rightRange, // optional(0) const char* propValue); // optional(NULL) // This routine must be called after the lefwStartPropDef call (if any). // The routine can be called only once. // Returns 0 if successful. extern int lefwEndPropDef(); // This routine is called after lefwInit. // This routine must be called only once. // Returns 0 if successful. // The routine starts the via section. All of the vias must follow. extern int lefwStartVia(const char* viaName, const char* isDefault); // optional(NULL) - DEFAULT // This routine is optional, it call only be called after lefwStartVia. // It can only be called once. // Returns 0 if successful. extern int lefwViaTopofstackonly(); // TOPOFSTACKONLY // This routine is optional, it call only be called after lefwStartVia. // It can only be called once. // Returns 0 if successful. extern int lefwViaForeign(const char* foreignName, double xl, // optional(0) - pt(x) double yl, // optional(0) - pt(y) int orient); // optional(-1) // This routine is optional, it call only be called after lefwStartVia. // It can only be called once. // Returns 0 if successful. // This routine is the same as lefwViaForeign, except orient is a char* extern int lefwViaForeignStr(const char* foreignName, double xl, // optional(0) - pt(x) double yl, // optional(0) - pt(y) const char* orient); // optional("") // This routine is optional, it call only be called after lefwStartVia. // Either this routine or lefwViaViarule can be called within a via. // It can only be called once in a via. // Returns 0 if successful. extern int lefwViaResistance(double resistance); // RESISTANCE // This routine must be called after lefwStartVia. // It can be called multiple times. // Returns 0 if successful. extern int lefwViaLayer(const char* layerName); // LAYER // This routine can call only after lefwViaLayer. // Either this routine or lefwViaLayerPolygon can be called within a layer // It can be called multiple times. // Returns 0 if successful. // mask is 5.8 syntax extern int lefwViaLayerRect(double x1l, // RECT pt1(x) double y1l, // RECT pt1(y) double x2l, // RECT pt2(x) double y2l, // RECT pt2(y) int mask = 0); // This routine can call only after lefwViaLayer. // Either this routine or lefwViaLayerRect can be called within a layer // It can be called multiple times. // This is a 5.6 syntax. // Returns 0 if successful. // mask is 5.8 syntax extern int lefwViaLayerPolygon(int num_polys, double* xl, double* yl, int mask = 0); // This routine can call only after lefwStartVia. // Either this routine or lefwViaResistance can be called within a via. // It can only be called once in a via. // This is a 5.6 syntax. // Returns 0 if successful. extern int lefwViaViarule(const char* viaRuleName, double xCutSize, double yCutSize, const char* botMetalLayer, const char* cutLayer, const char* topMetalLayer, double xCutSpacing, double yCutSpacing, double xBotEnc, double yBotEnc, double xTopEnc, double yTopEnc); // This routine can call only after lefwViaViarule. // It can only be called once. // This is a 5.6 syntax. // Returns 0 if successful. extern int lefwViaViaruleRowCol(int numCutRows, int numCutCols); // This routine can call only after lefwViaViarule. // It can only be called once. // This is a 5.6 syntax. // Returns 0 if successful. extern int lefwViaViaruleOrigin(double xOffset, double yOffset); // This routine can call only after lefwViaViarule. // It can only be called once. // This is a 5.6 syntax. // Returns 0 if successful. extern int lefwViaViaruleOffset(double xBotOffset, double yBotOffset, double xTopOffset, double yTopOffset); // This routine can call only after lefwViaViarule. // It can only be called once. // This is a 5.6 syntax. // Returns 0 if successful. extern int lefwViaViarulePattern(const char* cutPattern); // This routine is called after lefwVia. // This routine is optional, it adds string property to the statement. // It can be called multiple times. // Returns 0 if successful. extern int lefwStringProperty(const char* propName, const char* propValue); // This routine is called after lefwVia. // This routine is optional, it adds real property to the statement. // It can be called multiple times. // Returns 0 if successful. extern int lefwRealProperty(const char* propName, double propValue); // This routine is called after lefwVia. // This routine is optional, it adds int property to the statement. // It can be called multiple times. // Returns 0 if successful. extern int lefwIntProperty(const char* propName, int propValue); // This routine must be called after the lefwStartVia call (if any). // The routine can be called only once. // Returns 0 if successful. extern int lefwEndVia(const char* viaName); // This routine is called after lefwInit. // This routine must be called as a set with lefwViaRuleLayer, lefwViaRuleVia // and lefwEndViaRule // multiple times. // Returns 0 if successful. // The routine starts the via rule section. The via rule data and its property // must follow extern int lefwStartViaRule(const char* viaRuleName); // This routine is called after lefwStartViaRule. // This routine has to be called 2 times exact. // Returns 0 if successful. // The direction1 or direction2 can be HORIZONTAL or VERTICAL. extern int lefwViaRuleLayer( const char* layerName, const char* direction, // HORIZONTAL | VERTICAL double minWidth, // optional(0) - WIDTH double maxWidth, // optional(0) - WIDTH double overhang, // optional(0) - OVERHANG double metalOverhang); // optional(0) - METALOVERHANG // This routine is called after lefwViaRuleLayer is called twice. // This routine is required in a viarule and can be called more than once. // Returns 0 if successful. // The direction1 or direction2 can be HORIZONTAL or VERTICAL. extern int lefwViaRuleVia( const char* viaName); // This routine must be called after the lefwStartViaRule call (if any). // The routine can be called only once per lefwStartViaRule. // Returns 0 if successful. extern int lefwEndViaRule(const char* viaRuleName); // This routine is called after lefwInit. // This routine must be called as a set with lefwViaRuleGenLayer, // lefwViaRuleGenLayer3, and lefwEndViaRuleGen multiple times. // Returns 0 if successful. // The routine starts the via rule section. The via rule data and its property // must follow extern int lefwStartViaRuleGen(const char* viaRuleName); // This routine is called after lefwSartViaRuleGen. // This routine is optional // Returns 0 if successful extern int lefwViaRuleGenDefault(); // This routine is called after lefwStartViaRuleGen. // This routine has to be called 2 times exact. // Returns 0 if successful. // Either this routine or lefwViaRuleGenLayerEnclosure, not both. // The direction1 or direction2 can be HORIZONTAL or VERTICAL. extern int lefwViaRuleGenLayer( const char* layerName, const char* direction, // HORIZONTAL | VERTICAL double minWidth, // optional(0) - WIDTH double maxWidth, // optional(0) - WIDTH double overhang, // optional(0) - OVERHANG double metalOverhang); // optional(0) - METALOVERHANG // This routine is called after lefwStartViaRuleGen. // This routine has to be called 2 times exact. // This is 5.5 syntax // Returns 0 if successful. // Either this routine or lefwViaRuleGenLayer, not both. extern int lefwViaRuleGenLayerEnclosure( const char* layerName, double overhang1, double overhang2, double minWidth, // optional(0) - WIDTH double maxWidth); // optional(0) - WIDTH // This routine is called after lefwViaRuleLayerGen is called twice. // This routine is optional in a viarule generate and can be called once. // Returns 0 if successful. // The direction1 or direction2 can be HORIZONTAL or VERTICAL. extern int lefwViaRuleGenLayer3( const char* layerName, double xl, double yl, // RECT pt1(x), pt1(y) double xh, double yh, // RECT pt2(x), pt2(y) double xSpacing, double ySpacing, // SPACING x and y double resistance); // optional(0) - RESISTANCE // This routine must be called after the lefwStartViaRuleGen call (if any). // The routine can be called only once per lefwStartViaRuleGen. // Returns 0 if successful. extern int lefwEndViaRuleGen(const char* viaRuleName); // This routine is called after lefwInit. // This routine must be called only once. // Returns 0 if successful. // The routine starts the nonDefaultRule section. The nonDefaultRule layers // must follow extern int lefwStartNonDefaultRule(const char* ruleName); // This routine is called after lefwInit. // This routine must be called after lefwStartNonDefaultRule // This routine can be called multiple times. // Returns 0 if successful. extern int lefwNonDefaultRuleLayer(const char* routingLayerName, double width, // WIDTH double minSpacing, // MINSPACING double wireExtension, // optinal(0) - WIREEXTENSION double resistance, // optinal(0) - RESISTANCE RPERQ double capacitance, // optinal(0) - CAPACITANCE CPERSQDIST double edgeCap); // optinal(0) - EDGECAPACITANCE // This routine is called after lefwInit. // This routine must be called after lefwStartNonDefaultRule // This routine is optional and it can be called only once. // Returns 0 if successful. extern int lefwNonDefaultRuleHardspacing(); // This routine is called after lefwStartNonDefaultRule. // This routine must be called only once for each via section. // Returns 0 if successful. // The routine starts the nondefaultrule via section. // Call the following via functions for the rest of NONDEFAULTRULE VIA: // lefwViaTopofstackonly // lefwViaForeign // lefwViaForeignStr // lefwViaResistance // lefwViaLayer // lefwViaLayerRect // lefwNonDefaultRuleEndVia extern int lefwNonDefaultRuleStartVia(const char* viaName, const char* isDefault); // optional(NULL) - DEFAULT // This routine must be called after the lefwNonDefaultRuleStartVia call. // The routine can be called only once per via section. // Returns 0 if successful. extern int lefwNonDefaultRuleEndVia(const char* viaName); // This routine is called after lefwStartNonDefaultRule. // This routine can be called multiple times. // Returns 0 if successful. extern int lefwNonDefaultRuleUseVia(const char* viaName); // This routine is called after lefwStartNonDefaultRule. // This routine can be called multiple times. // Returns 0 if successful. extern int lefwNonDefaultRuleUseViaRule(const char* viaRuleName); // This routine is called after lefwStartNonDefaultRule. // This routine can be called multiple times. // Returns 0 if successful. extern int lefwNonDefaultRuleMinCuts(const char* layerName, int numCuts); // This routine must be called after the lefwStartNonDefaultRule call (if any). // The routine can be called only once. // Returns 0 if successful. extern int lefwEndNonDefaultRule(const char* ruleName); // This routine is called after lefwInit. // This section of routines is optional. // This routine can be called only once. // Returns 0 if successful. // It starts the spacing section. extern int lefwStartSpacing(); // This routine must be called after lefwStartSpacing. // It can be called multiple times. // Returns 0 if successful. // The stack has to be STACK. extern int lefwSpacing(const char* layerName1, const char* layerName2, double minSpace, const char* stack); // optional(NULL) // This routine must be called after the lefwStartSpacing call (if any). // The routine can be called only once. // Returns 0 if successful. extern int lefwEndSpacing(); // This routine is called after lefwInit. // This routine is optional and it can be called only once. // Returns 0 if successful. // This api is obsolete in 5.4. extern int lefwUniversalNoiseMargin (double high, double low); // This routine is called after lefwInit. // This routine is optional and it can be called only once. // Returns 0 if successful. // This api is obsolete in 5.4. extern int lefwEdgeRateThreshold1 (double num); // This routine is called after lefwInit. // This routine is optional and it can be called only once. // Returns 0 if successful. // This api is obsolete in 5.4. extern int lefwEdgeRateThreshold2 (double num); // This routine is called after lefwInit. // This routine is optional and it can be called only once. // Returns 0 if successful. // This api is obsolete in 5.4. extern int lefwEdgeRateScaleFactor (double num); // This routine is called after lefwInit. // This routine is optional and it can be called only once. // Returns 0 if successful. // This routine starts the noisetable section. // This api is obsolete in 5.4. extern int lefwStartNoiseTable(int num); // This routine is called after lefwStartNoiseTable or lefwStartCorrectTable. // This routine is optional and it can be called multiple times // Returns 0 if successful. // This api is obsolete in 5.4. extern int lefwEdgeRate(double num) ; // This routine is called after lefwEdgeRate. // This routine is optional and it can be called only once inside lefwEdgeRate. // Returns 0 if successful. // This api is obsolete in 5.4. extern int lefwOutputResistance(int numResists, double* resistance); // This routine is called after lefwOutputResistance. // This routine is optional and it can be called multiple times inside // lefwOutputResistance // Returns 0 if successful. // This api is obsolete in 5.4. extern int lefwVictims(int length, int numNoises, double* noises); // This routine must be called after the lefwStartNoiseTable call (if any). // The routine can be called only once per section. // Returns 0 if successful. // This api is obsolete in 5.4. extern int lefwEndNoiseTable(); // This routine is called after lefwInit. // This routine is optional and it can be called only once. // Returns 0 if successful. // This routine starts the correctTable section. // This api is obsolete in 5.4. extern int lefwStartCorrectTable(int num); // This routine must be called after the lefwStartCorrectTable call (if any). // The routine can be called only once per section. // Returns 0 if successful. // This api is obsolete in 5.4. extern int lefwEndCorrectTable(); // This routine is called after lefwInit. // This routine is optional and it can be called only once. // Returns 0 if successful. extern int lefwMinFeature (double x, double y); // This routine is called after lefwInit. // This routine is optional and it can be called only once. // Returns 0 if successful. // This api is obsolete in 5.4. // extern int lefwDielectric (float dielectric); // This routine is called after lefwInit. // This routine is optional and it can be called only once. // Returns 0 if successful. // This routine starts the irdrop section. // This api is obsolete in 5.4. extern int lefwStartIrdrop(); // This routine is must be called after lefwStartIrdrop. // It can be called multiple times. // Returns 0 if successful. // The currentsNvolts is a list of current and volts. // This api is obsolete in 5.4. extern int lefwIrdropTable(const char* tableName, const char* currentsNvolts); // This routine must be called after the lefwStartIrdrop call (if any). // The routine can be called only once. // Returns 0 if successful. // This api is obsolete in 5.4. extern int lefwEndIrdrop(); // This routine is must be called after lefwInit. // It can be called multiple times. // Returns 0 if successful. // The classType can be PAD or CORE. // The symmetry can be a list of X or Y or R90. extern int lefwSite(const char* siteName, const char* classType, const char* symmetry, double width, double height); // This routine is must be called after lefwSite. // It can be called multiple times. // This is a 5.6 syntax. // Returns 0 if successful. extern int lefwSiteRowPattern(const char* siteName, int orient); // This routine is must be called after lefwSite. // It can be called multiple times. // This is a 5.6 syntax. // Returns 0 if successful. // This routine is the same as lefwSiteRowPattern, except orient is a char* extern int lefwSiteRowPatternStr(const char* siteName, const char *orient); // This routine must be called after the lefwSite call (if any). // The routine can be called only once after lefwSite. // This is a 5.4 syntax. // Returns 0 if successful. extern int lefwEndSite(const char* siteName); // This routine is called after lefwInit. // This routine is optional and it can be called multiple times. // Returns 0 if successful. // This routine starts the array section. extern int lefwStartArray(const char* arrayName); // This routine is called after lefwStartArray. // Either this routine, lefwArrayCanplace, lefwArrayCannotoccupy, // lefwArrayTracks, or lefwStartArrayFloorplan must be called at least once. // It can be call multiple times. // Returns 0 if successful. extern int lefwArraySite(const char* name, double origX, double origY, int orient, double numX, double numY, double spaceX, double spaceY); // This routine is called after lefwStartArray. // Either this routine, lefwArrayCanplace, lefwArrayCannotoccupy, // lefwArrayTracks, or lefwStartArrayFloorplan must be called at least once. // It can be call multiple times. // Returns 0 if successful. // This routine is the same as lefwArraySite, except orient is a char* extern int lefwArraySiteStr(const char* name, double origX, double origY, const char *orient, double numX, double numY, double spaceX, double spaceY); // This routine is called after lefwStartArray. // Either this routine, lefwArraySite, lefwArrayCannotoccupy, // lefwArrayTracks, or lefwStartArrayFloorplan must be called at least once. // It can be call multiple times. // Returns 0 if successful. extern int lefwArrayCanplace(const char* name, double origX, double origY, int orient, double numX, double numY, double spaceX, double spaceY); // This routine is called after lefwStartArray. // Either this routine, lefwArraySite, lefwArrayCannotoccupy, // lefwArrayTracks, or lefwStartArrayFloorplan must be called at least once. // It can be call multiple times. // Returns 0 if successful. // This routine is the same as lefwArrayCanplace, except orient is a char* extern int lefwArrayCanplaceStr(const char* name, double origX, double origY, const char *orient, double numX, double numY, double spaceX, double spaceY); // This routine is called after lefwStartArray. // Either this routine, lefwArraySite, lefwArrayCanplace, // lefwArrayTracks, or lefwStartArrayFloorplan must be called at least once. // It can be call multiple times. // Returns 0 if successful. extern int lefwArrayCannotoccupy(const char* name, double origX, double origY, int orient, double numX, double numY, double spaceX, double spaceY); // This routine is called after lefwStartArray. // Either this routine, lefwArraySite, lefwArrayCanplace, // lefwArrayTracks, or lefwStartArrayFloorplan must be called at least once. // It can be call multiple times. // Returns 0 if successful. // This routine is the same as lefwArrayTracks, except orient is a char* extern int lefwArrayCannotoccupyStr(const char* name, double origX, double origY, const char *orient, double numX, double numY, double spaceX, double spaceY); // This routine is called after lefwStartArray. // Either this routine, lefwArraySite, lefwArrayCanplace, lefwArrayCannotoccupy, // or lefwStartArrayFloorplan must be called at least once. // It can be call multiple times. // Returns 0 if successful. extern int lefwArrayTracks(const char* xy, double start, int numTracks, double space, const char* layers); // This routine is called after lefwStartArray. // Either this routine, lefwArraySite, lefwArrayCanplace, lefwArrayCannotoccupy, // or lefwArrayTracks must be called at least once. // It can be call multiple times. // Returns 0 if successful. // The routine starts the array floorplan section extern int lefwStartArrayFloorplan(const char* name); // This routine must be called after lefwStartArrayFloorplan. // It can be called multiple times. // Returns 0 if successful. // The site can be CANPLACE or CANNOTOCCUPY extern int lefwArrayFloorplan(const char* site, const char* name, double origX, double origY, int orient, int numX, int numY, double spaceX, double spaceY); // This routine must be called after lefwStartArrayFloorplan. // It can be called multiple times. // Returns 0 if successful. // The site can be CANPLACE or CANNOTOCCUPY // This routine is the same as lefwArrayFloorplan, except orient is a char* extern int lefwArrayFloorplanStr(const char* site, const char* name, double origX, double origY, const char *orient, int numX, int numY, double spaceX, double spaceY); // This routine must be called after the lefwStartArrayFloorplan call (if any). // The routine can be called only once per section. // Returns 0 if successful. extern int lefwEndArrayFloorplan(const char* name); // This routine is called after lefwStartArray. // This routine is optional. // It can be called multiple times. // Returns 0 if successful. // The xy can be X or Y. extern int lefwArrayGcellgrid(const char* xy, double startXY, int colRows, double spaceXY); // This routine is called after lefwStartArray. // This section of routines is optional and can be call only once. // Returns 0 if successful. // The routine starts the array defaultcap section extern int lefwStartArrayDefaultCap(int size); // This routine must be called after lefwStartArrayDefaultCap. // It can be called multiple times. // Returns 0 if successful. extern int lefwArrayDefaultCap(double numPins, double cap); // This routine must be called after the lefwStartArrayDefaultCap call (if any). // The routine can be called only once. // Returns 0 if successful. extern int lefwEndArrayDefaultCap(); // This routine must be called after the lefwStartArray call (if any). // The routine can be called only once per section. // Returns 0 if successful. extern int lefwEndArray(const char* arrayName); // This routine is must be called after lefwInit. // This routine can be called multiple times. // Returns 0 if successful. // This routine starts the macro section. extern int lefwStartMacro(const char* macroName); // This routine is called after lefwStartMacro. // This routine is optional and can be called only once per macro section. // Returns 0 if successful. // The value1 can be COVER, RING, BLOCK, PAD, CORE, or ENCAP. // The value2 can be BUMP if value1 is COVER, // or BLACKBOX, or SOFT if value1 is BLOCK, // or INPUT, OUTPUT, INOUT, POWER, or SPACER if value1 is PAD, // or FEEDTHRU, TIEHIGH, TIELOW, SPACER, ANTENNACELL, or WELLTAP // if value1 is CORE, // or PRE, POST, TOPLEFT, TOPRIGHT, BOOTOMLEFT, or BOTTOMRIGHT if value1 is // ENCAP. extern int lefwMacroClass(const char* value1, const char* value2); // optional(NULL) // This routine is must be called after lefwInit. // This routine can be called multiple times. // Returns 0 if successful. // This is a 5.8 syntax. extern int lefwMacroFixedMask(); // This routine is called after lefwStartMacro. // This routine is optional and can be called only once per macro section. // Returns 0 if successful. // The value1 can be USER, GENERATE, or BLOCK. extern int lefwMacroSource(const char* value1); // This routine is called after lefwStartMacro. // This routine is optional and can be called multiple times per macro section. // Returns 0 if successful. extern int lefwMacroForeign(const char* name, double xl, // optional(0) - pt(x) double yl, // optional(0) - pt(y) int orient); // optional(-1) - 0 to 7 // This routine is called after lefwStartMacro. // This routine is optional and can be called multiple times per macro section. // Returns 0 if successful. // This routine is the same as lefwMacroForeign, except orient is a char* extern int lefwMacroForeignStr(const char* name, double xl, // optional(0) - pt(x) double yl, // optional(0) - pt(y) const char *orient); // optional("") // This routine is called after lefwStartMacro. // This routine is optional and can be called only once per macro section. // Returns 0 if successful. extern int lefwMacroOrigin(double xl, // pt(x) double yl); // pt(y) // This routine is called after lefwStartMacro. // This routine is optional and can be called only once per macro section. // Returns 0 if successful. extern int lefwMacroEEQ(const char* macroName); // This routine is called after lefwStartMacro. // This routine is optional and can be called only once per macro section. // Returns 0 if successful. extern int lefwMacroLEQ(const char* macroName); // This routine is called after lefwStartMacro. // This routine must be called only once per macro section. // Returns 0 if successful. extern int lefwMacroSize(double width, double height); // This routine is called after lefwStartMacro. // This routine is optional and can be called only once per macro section. // Returns 0 if successful. // The symmetry can be a list of X, Y, or R90 extern int lefwMacroSymmetry(const char* symmetry); // This routine is called after lefwStartMacro. // This routine must be called only once per macro section. // Returns 0 if successful. extern int lefwMacroSite(const char* siteName); // This routine is called after lefwStartMacro. // This routine must be called at least once per macro section. // Returns 0 if successful. extern int lefwMacroSitePattern(const char* name, double origX, double origY, // optional(0) int orient, // optional(-1) int numX, int numY, // optional(0) double spaceX, double spaceY); // optional(0) // This routine is called after lefwStartMacro. // This routine must be called at least once per macro section. // Returns 0 if successful. // This routine is the same as lefwMacroSitePattern, except orient is a char* extern int lefwMacroSitePatternStr(const char* name, double origX, double origY, // optional(0) const char *orient, // optional (-1) int numX, int numY, // optional(0) double spaceX, double spaceY); // optional(0) // This routine is called after lefwStartMacro. // This routine is optional and can be called only once per macro section. // Returns 0 if successful. // This api is obsolete in 5.4. extern int lefwMacroPower(double power); // This routine must be called after the lefwStartMacro call (if any). // The routine can be called only once per macro section. // Returns 0 if successful. extern int lefwEndMacro(const char* macroName); // This routine is called after lefwStartMacro. // This routine is optional and can be called only once per macro section. // This is a 5.6 syntax. // Returns 0 if successful. extern int lefwStartMacroDensity(const char* layerName); // This routine is called after lefwStartMacroDensity. // This routine can be called multiple times. // This is a 5.6 syntax. // Returns 0 if successful. extern int lefwMacroDensityLayerRect(double x1, double y1, double x2, double y2, double densityValue); // This routine must be called after the lefwStartMacroPin call (if any). // The routine can be called only once per macro section. // This is a 5.6 syntax. // Returns 0 if successful. extern int lefwEndMacroDensity(); // This routine must be called after the lefwStartMacro call (if any). // The routine can be called multiple time. // Returns 0 if successful. // It starts the macro pin section within macro. extern int lefwStartMacroPin(const char* pinName); // This routine is called after lefwStartMacroPin. // This routine is optional and can be called only once. // Returns 0 if successful. extern int lefwMacroPinTaperRule(const char* ruleName); // This routine is called after lefwStartMacroPin. // This routine is optional and can be called only once. // Returns 0 if successful. extern int lefwMacroPinForeign(const char* name, double xl, // optional(0) double yl, // optional(0) int orient); // optional(-1) - 0 to 7 // This routine is called after lefwStartMacroPin. // This routine is optional and can be called only once. // Returns 0 if successful. // Ths routine is the same as lefwMacroPinForeign, except orient is a char* extern int lefwMacroPinForeignStr(const char* name, double xl, // optional(0) double yl, // optional(0) const char* orient); // optional("") // This routine is called after lefwStartMacroPin. // This routine is optional and can be called only once. // Returns 0 if successful. extern int lefwMacroPinLEQ(const char* pinName); // This routine is called after lefwStartMacroPin. // This routine is optional and can be called only once. // Returns 0 if successful. // The direction can be INPUT, OUTPUT, OUTPUT TRISTATE, INOUT, or FEEDTHRU. extern int lefwMacroPinDirection(const char* direction); // This routine is called after lefwStartMacroPin. // This routine is optional and can be called only once. // Returns 0 if successful. // The use can be SIGNAL, ANALOG, POWER, GROUND, or CLOCK. extern int lefwMacroPinUse(const char* use); // This routine is called after lefwStartMacroPin. // This routine is optional and can be called only once. // Returns 0 if successful. // The namce can be ABUTMENT, RING, or FEEDTHRU. extern int lefwMacroPinShape(const char* name); // This routine is called after lefwStartMacroPin. // This routine is optional and can be called only once. // Returns 0 if successful. extern int lefwMacroPinMustjoin(const char* name); // This routine is called after lefwStartMacroPin. // This routine is optional and can be called only once. // This is a 5.6 syntax. // Returns 0 if successful. extern int lefwMacroPinNetExpr(const char* name); // This routine is called after lefwStartMacroPin. // This routine is optional and can be called only once. // This is a 5.6 syntax. // Returns 0 if successful. extern int lefwMacroPinSupplySensitivity(const char* pinName); // This routine is called after lefwStartMacroPin. // This routine is optional and can be called only once. // This is a 5.6 syntax. // Returns 0 if successful. extern int lefwMacroPinGroundSensitivity(const char* pinName); // This routine is called after lefwStartMacroPin. // This routine is optional and can be called only once. // Returns 0 if successful. // This api is obsolete in 5.4. extern int lefwMacroPinOutputnoisemargin(int high, int low); // This routine is called after lefwStartMacroPin. // This routine is optional and can be called only once. // Returns 0 if successful. // This api is obsolete in 5.4. extern int lefwMacroPinOutputresistance(int high, int low); // This routine is called after lefwStartMacroPin. // This routine is optional and can be called only once. // Returns 0 if successful. // This api is obsolete in 5.4. extern int lefwMacroPinInputnoisemargin(int high, int low); // This routine is called after lefwStartMacroPin. // This routine is optional and can be called only once. // Returns 0 if successful. // This api is obsolete in 5.4. extern int lefwMacroPinPower(double power); // This routine is called after lefwStartMacroPin. // This routine is optional and can be called only once. // Returns 0 if successful. // This api is obsolete in 5.4. extern int lefwMacroPinLeakage(double leakage); // This routine is called after lefwStartMacroPin. // This routine is optional and can be called only once. // Returns 0 if successful. // This api is obsolete in 5.4. extern int lefwMacroPinCapacitance(double capacitance); // This routine is called after lefwStartMacroPin. // This routine is optional and can be called only once. // Returns 0 if successful. // This api is obsolete in 5.4. extern int lefwMacroPinResistance(double resistance); // This routine is called after lefwStartMacroPin. // This routine is optional and can be called only once. // Returns 0 if successful. // This api is obsolete in 5.4. extern int lefwMacroPinPulldownres(double resistance); // This routine is called after lefwStartMacroPin. // This routine is optional and can be called only once. // Returns 0 if successful. // This api is obsolete in 5.4. extern int lefwMacroPinTieoffr(double resistance); // This routine is called after lefwStartMacroPin. // This routine is optional and can be called only once. // Returns 0 if successful. // This api is obsolete in 5.4. extern int lefwMacroPinVHI(double voltage); // This routine is called after lefwStartMacroPin. // This routine is optional and can be called only once. // Returns 0 if successful. // This api is obsolete in 5.4. extern int lefwMacroPinVLO(double voltage); // This routine is called after lefwStartMacroPin. // This routine is optional and can be called only once. // Returns 0 if successful. // This api is obsolete in 5.4. extern int lefwMacroPinRisevoltagethreshold(double voltage); // This routine is called after lefwStartMacroPin. // This routine is optional and can be called only once. // Returns 0 if successful. // This api is obsolete in 5.4. extern int lefwMacroPinFallvoltagethreshold(double voltage); // This routine is called after lefwStartMacroPin. // This routine is optional and can be called only once. // Returns 0 if successful. // This api is obsolete in 5.4. extern int lefwMacroPinRisethresh(double capacitance); // This routine is called after lefwStartMacroPin. // This routine is optional and can be called only once. // Returns 0 if successful. // This api is obsolete in 5.4. extern int lefwMacroPinFallthresh(double capacitance); // This routine is called after lefwStartMacroPin. // This routine is optional and can be called only once. // Returns 0 if successful. // This api is obsolete in 5.4. extern int lefwMacroPinRisesatcur(double current); // This routine is called after lefwStartMacroPin. // This routine is optional and can be called only once. // Returns 0 if successful. // This api is obsolete in 5.4. extern int lefwMacroPinFallsatcur(double current); // This routine is called after lefwStartMacroPin. // This routine is optional and can be called only once. // Returns 0 if successful. // The name can be ACTIVE or RESISTIVE. // This api is obsolete in 5.4. extern int lefwMacroPinCurrentsource(const char* name); // This routine is called after lefwStartMacroPin. // This routine is optional and can be called only once. // Returns 0 if successful. // This api is obsolete in 5.4. extern int lefwMacroPinIV_Tables(const char* lowName, const char* highName); // This routine is called after lefwStartMacroPin. // This routine is optional and can be called multiple times. // Either this routine or 5.4 Antenna syntax, cannot be both // Returns 0 if successful. extern int lefwMacroPinAntennasize(double value, const char* layerName); // optional(NULL) // This routine is called after lefwStartMacroPin. // This routine is optional and can be called multiple times. // Either this routine or 5.4 Antenna syntax, cannot be both // Returns 0 if successful. extern int lefwMacroPinAntennaMetalArea(double value, const char* layerName); // optional(NULL) // This routine is called after lefwStartMacroPin. // This routine is optional and can be called multiple times. // Either this routine or 5.4 Antenna syntax, cannot be both // Returns 0 if successful. extern int lefwMacroPinAntennaMetalLength(double value, const char* layerName); // optional(NULL) // This routine is called after lefwStartMacroPin. // This routine is optional and can be called multiple times. // This is a 5.4 syntax. // Either this routine or 5.3 Antenna syntax, cannot be both // Returns 0 if successful. extern int lefwMacroPinAntennaPartialMetalArea(double value, const char* layerName); // optional(NULL) // This routine is called after lefwStartMacroPin. // This routine is optional and can be called multiple times. // This is a 5.4 syntax. // Either this routine or 5.3 Antenna syntax, cannot be both // Returns 0 if successful. extern int lefwMacroPinAntennaPartialMetalSideArea(double value, const char* layerName); // optional(NULL) // This routine is called after lefwStartMacroPin. // This routine is optional and can be called multiple times. // This is a 5.4 syntax. // Either this routine or 5.3 Antenna syntax, cannot be both // Returns 0 if successful. extern int lefwMacroPinAntennaPartialCutArea(double value, const char* layerName); // optional(NULL) // This routine is called after lefwStartMacroPin. // This routine is optional and can be called multiple times. // This is a 5.4 syntax. // Either this routine or 5.3 Antenna syntax, cannot be both // Returns 0 if successful. extern int lefwMacroPinAntennaDiffArea(double value, const char* layerName); // optional(NULL) // This routine is called after lefwStartMacroPin. // The oxide value, can be either OXIDE1, OXIDE2, OXIDE3, or OXIDE4. // This routine is optional. Each oxide value can be called only once // after the lefwStartMacroPin. // This is a 5.5 syntax. // Returns 0 if successful. extern int lefwMacroPinAntennaModel(const char* oxide); // This routine is called after lefwStartMacroPin. // This routine is optional and can be called multiple times. // This is a 5.4 syntax. // Either this routine or 5.3 Antenna syntax, cannot be both // Returns 0 if successful. extern int lefwMacroPinAntennaGateArea(double value, const char* layerName); // optional(NULL) // This routine is called after lefwStartMacroPin. // This routine is optional and can be called only once. // This is a 5.4 syntax. // Either this routine or 5.3 Antenna syntax, cannot be both // Returns 0 if successful. extern int lefwMacroPinAntennaMaxAreaCar(double value, const char* layerName); // optional(NULL) // This routine is called after lefwStartMacroPin. // This routine is optional and can be called only once. // This is a 5.4 syntax. // Either this routine or 5.3 Antenna syntax, cannot be both // Returns 0 if successful. extern int lefwMacroPinAntennaMaxSideAreaCar(double value, const char* layerName); // optional(NULL) // This routine is called after lefwStartMacroPin. // This routine is optional and can be called only once. // This is a 5.4 syntax. // Either this routine or 5.3 Antenna syntax, cannot be both // Returns 0 if successful. extern int lefwMacroPinAntennaMaxCutCar(double value, const char* layerName); // optional(NULL) // This routine must be called after the lefwStartMacroPin call (if any). // The routine can be called only once per macro section. // Returns 0 if successful. extern int lefwEndMacroPin(const char* pinName); // This routine must be called after the lefwStartMacroPin call (if any). // The routine can be called multiple time. // Returns 0 if successful. // It starts the macro pin port section within macro pin. // The classType can be NONE or CORE. extern int lefwStartMacroPinPort(const char* classType); // optional(NULL) // This routine is called after lefwStartMacroPinPort. // Either this routine or lefwMacroPinPortDesignRuleWidth must be called, // but can't be both. // Spacing is optional for minimum spacing. // Returns 0 if successful. extern int lefwMacroPinPortLayer(const char* layerName, double spacing); // optional(0) // This routine is called after lefwStartMacroPinPort. // Either this routine or lefwMacroPinPortLayer must be called, but can't // be both. // width is optional for DesignRuleWidth // This is a 5.4 syntax. // Returns 0 if successful. extern int lefwMacroPinPortDesignRuleWidth(const char* layerName, double width); // optional(0) // This routine is called after lefwMacroPinPortLayer. // Returns 0 if successful. extern int lefwMacroPinPortLayerWidth(double width); // This routine is called after lefwStartMacroPinPortLayer. // Either this routine, lefwStartMacroPinPortLayerRect, or // lefwStartMacroPinPortLayerPolygon must be called. // Returns 0 if successful. extern int lefwMacroPinPortLayerPath(int num_paths, double* xl, double* yl, int numX, // optional(0) int numY, // optional(0) double spaceX, // optional(0) double spaceY, // optional(0) int mask = 0); // optional(0) // This routine is called after lefwStartMacroPinPortLayer. // Either this routine, lefwStartMacroPinPortLayerPath, or // lefwStartMacroPinPortLayerPolygon must be called. // Returns 0 if successful. extern int lefwMacroPinPortLayerRect(double xl1, double yl1, double xl2, double yl2, int numX, // optional(0) int numY, // optional(0) double spaceX, // optional(0) double spaceY, // optional(0) int mask = 0); // optional(0) // This routine is called after lefwStartMacroPinPortLayer. // Either this routine, lefwStartMacroPinPortLayerPath, or // lefwStartMacroPinPortLayerRect must be called. // Returns 0 if successful. extern int lefwMacroPinPortLayerPolygon(int num_polys, double* xl, double* yl, int numX, // optional(0) int numY, // optional(0) double spaceX, // optional(0) double spaceY, // optional(0) int mask = 0); // optional(0) // This routine is called after lefwStartMacroPinPort. // Either this routine or lefwStartMacroPinPortLayer must be called. // Returns 0 if successful. extern int lefwMacroPinPortVia(double xl, double yl, const char* viaName, int numX, // optional(0) int numY, // optional(0) double spaceX, // optional(0) double spaceY, // optional(0) int mask = 0); // optional(0) // This routine must be called after the lefwStartMacroPinPort call (if any). // The routine can be called only once per macro section. // Returns 0 if successful. extern int lefwEndMacroPinPort(); // This routine is called after the lefwStartMacro call (if any). // The routine is optional and can be called multiple times. // Returns 0 if successful. // It starts the macro obs section within macro. extern int lefwStartMacroObs(); // This routine is called after lefwStartMacroObs. // Either this routine, lefwMacroObsDesignRuleWidth, lefwMacroObsVia or // lefwMacroExceptPGNet must be called. // Spacing is optional for minimum spacing. // Returns 0 if successful. extern int lefwMacroObsLayer(const char* layerName, double spacing); // optional(0) // This routine is called after lefwStartMacroObs. // Either this routine, lefwMacroObsLayer, lefwMacroObsVia or // lefwMacroExceptPGNet must be called. // Spacing is optional for minimum spacing. // This is a 5.4 syntax. // Returns 0 if successful. extern int lefwMacroObsDesignRuleWidth(const char* layerName, double width); // optional(0) // This routine is called after lefwStartMacroObs. // Either this routine, lefwMacroObsLayer, lefwMacroObsVia or // lefwMacroObsDesignRuleWidth must be called. // Spacing is optional for minimum spacing. // This is a 5.4 syntax. // Returns 0 if successful. extern int lefwMacroExceptPGNet(const char* layerName); // This routine is called after lefwStartMacroObs. // Returns 0 if successful. extern int lefwMacroObsLayerWidth(double width); // This routine is called after lefwStartMacroObsLayer. // Either this routine, lefwMacroObsLayerRect, or // lefwStartMacroObsLayerPolygon must be called. // Returns 0 if successful. extern int lefwMacroObsLayerPath(int num_paths, double* xl, double* yl, int numX, // optional(0) int numY, // optional(0) double spaceX, // optional(0) double spaceY, // optional(0) int mask = 0); // optional(0) // This routine is called after lefwStartMacroObsLayer. // Either this routine, lefwMacroObsLayerPath, or // lefwStartMacroObsLayerPolygon must be called. // Returns 0 if successful. extern int lefwMacroObsLayerRect(double xl1, double yl1, double xl2, double yl2, int numX, // optional(0) int numY, // optional(0) double spaceX, // optional(0) double spaceY, // optional(0) int mask = 0); // optional(0) // This routine is called after lefwStartMacroObsLayer. // Either this routine, lefwMacroObsLayerPath, or // lefwStartMacroObsLayerPath must be called. // Returns 0 if successful. extern int lefwMacroObsLayerPolygon(int num_polys, double* xl, double* yl, int numX, // optional(0) int numY, // optional(0) double spaceX, // optional(0) double spaceY, // optional(0) int mask = 0); // optional(0) // This routine is called after lefwStartMacroObs. // Either this routine or lefwMacroObsLayer|lefwMacroObsDesignRuleWidth // must be called. // Returns 0 if successful. extern int lefwMacroObsVia(double xl, double yl, const char* viaName, int numX, // optional(0) int numY, // optional(0) double spaceX, // optional(0) double spaceY, // optional(0) int mask = 0); // optional(0) // This routine must be called after the lefwStartMacroObs call (if any). // The routine can be called only once per macro section. // Returns 0 if successful. extern int lefwEndMacroObs(); // This routine is called after the lefwStartMacro call (if any). // The routine is optional and can be called only once. // Returns 0 if successful. // It starts the macro timing section within macro. // This api is obsolete in 5.4. extern int lefwStartMacroTiming(); // This routine must be called after the lefwStartMacroTiming. // It can be called multiple times. // Returns 0 if successful. // This routine is for {FROMPIN pinName...; [TOPIN pinName...;] | FROMPIN // pinName...;} // This routince can be called multiple times. // The num_frPinNames contains the number of object in the array fromPins. // This api is obsolete in 5.4. extern int lefwMacroTimingPin(const char* fromPin, const char* toPin); // This routine must be called after the lefwStartMacroTiming. // It can be called multiple times. // Returns 0 if successful. // The riseFall can be RISE or FALL. // This api is obsolete in 5.4. extern int lefwMacroTimingIntrinsic(const char* riseFall, double min, double max, double slewT1, // optional(0) double slewT1Min, // optional(0) double slewT1Max, // optional(0) double slewT2, // optional(0) double slewT2Min, // optional(0) double slewT2Max, // optional(0) double slewT3, // optional(0) double varMin, double varMax); // This routine must be called after the lefwStartMacroTiming. // It can be called multiple times. // Returns 0 if successful. // This api is obsolete in 5.4. extern int lefwMacroTimingRisers(double min, double max); // This routine must be called after the lefwStartMacroTiming. // It can be called multiple times. // Returns 0 if successful. // This api is obsolete in 5.4. extern int lefwMacroTimingFallrs(double min, double max); // This routine must be called after the lefwStartMacroTiming. // It can be called multiple times. // Returns 0 if successful. // This api is obsolete in 5.4. extern int lefwMacroTimingRisecs(double min, double max); // This routine must be called after the lefwStartMacroTiming. // It can be called multiple times. // Returns 0 if successful. // This api is obsolete in 5.4. extern int lefwMacroTimingFallcs(double min, double max); // This routine must be called after the lefwStartMacroTiming. // It can be called multiple times. // Returns 0 if successful. // This api is obsolete in 5.4. extern int lefwMacroTimingRisesatt1(double min, double max); // This routine must be called after the lefwStartMacroTiming. // It can be called multiple times. // Returns 0 if successful. // This api is obsolete in 5.4. extern int lefwMacroTimingFallsatt1(double min, double max); // This routine must be called after the lefwStartMacroTiming. // It can be called multiple times. // Returns 0 if successful. // This api is obsolete in 5.4. extern int lefwMacroTimingRiset0(double min, double max); // This routine must be called after the lefwStartMacroTiming. // It can be called multiple times. // Returns 0 if successful. // This api is obsolete in 5.4. extern int lefwMacroTimingFallt0(double min, double max); // This routine must be called after the lefwStartMacroTiming. // It can be called multiple times. // Returns 0 if successful. // The unateness can be INVERT, NONINVERT or NONUNATE. // This api is obsolete in 5.4. extern int lefwMacroTimingUnateness(const char* unateness); // This routine must be called after the lefwStartMacroTiming call (if any). // The routine can be called only once. // Returns 0 if successful. // This api is obsolete in 5.4. extern int lefwEndMacroTiming(); // This routine is called after lefwInit. // This routine is optional and it can be called only once. // Returns 0 if successful. extern int lefwAntenna(const char* type, // INPUTPINANTENNASIZE | // OUTPUTPINANTENNASIZE | // INOUTPINANTENNASIZE double value); // This routine is called after lefwInit. // This routine is optional and it can be called only once. // Returns 0 if successful. extern int lefwStartBeginext(const char* name); // This routine is called after lefwBeginext. // This routine is optional, it can be called only once. // Returns 0 if successful. extern int lefwBeginextCreator (const char* creatorName); // This routine is called after lefwBeginext. // This routine is optional, it can be called only once. // It gets the current system time and date. // Returns 0 if successful. extern int lefwBeginextDate (); // This routine is called after lefwBeginext. // This routine is optional, it can be called only once. // Returns 0 if successful. extern int lefwBeginextRevision (int vers1, int vers2); // vers1.vers2 // This routine is called after lefwBeginext. // This routine is optional, it can be called many times. // It allows user to customize their own syntax. // Returns 0 if successful. extern int lefwBeginextSyntax (const char* title, const char* string); // This routine is called after lefwInit. // This routine is optional and it can be called only once. // Returns 0 if successful. extern int lefwEndBeginext(); // General routines that can be called anytime after the Init is called. extern int lefwCurrentLineNumber(); // This routine must call last, it ends the Lef library. // It must be called only once. // Returns 0 if successful. extern int lefwEnd(); // This routine will print the error message. extern void lefwPrintError(int status); // This routine will allow user to write their own comemnt. It will // automactically add a # infront of the line. extern void lefwAddComment(const char* comment); // This routine will indent 3 blank spaces extern void lefwAddIndent(); END_LEFDEF_PARSER_NAMESPACE USE_LEFDEF_PARSER_NAMESPACE #endif