lxchen/Xplace_for_ICCAD
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
ae6644aabd
Xplace_for_ICCAD/thirdparty/lefdef/lef58/include/lefwWriter.hpp

2375 lines
97 KiB
C++
Raw Normal View History

initial commit
2022-10-20 22:46:17 +08:00
// *****************************************************************************
// *****************************************************************************
// 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 <stdio.h>
#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
Reference in New Issue Copy Permalink