lxchen/Xplace_for_ICCAD
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
4d6c0d2ab4
Xplace_for_ICCAD/thirdparty/lefdef/def58/include/defwWriter.hpp

1753 lines
73 KiB
C++
Raw Normal View History

initial commit
2022-10-20 22:46:17 +08:00
// *****************************************************************************
// *****************************************************************************
// Copyright 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 DEFW_WRITER_H
#define DEFW_WRITER_H
#include <stdarg.h>
#include <stdio.h>
#include "defiKRDefs.hpp"
#include "defiDefs.hpp"
#include "defiUser.hpp"
BEGIN_LEFDEF_PARSER_NAMESPACE
/* Return codes for writing functions: */
#define DEFW_OK 0
#define DEFW_UNINITIALIZED 1
#define DEFW_BAD_ORDER 2
#define DEFW_BAD_DATA 3
#define DEFW_ALREADY_DEFINED 4
#define DEFW_WRONG_VERSION 5
#define DEFW_OBSOLETE 6
#define DEFW_TOO_MANY_STMS 7 // the number defined at the beginning of the
// section is smaller than the actual number
// of statements defined in that section
/* orient
0 = N
1 = W
2 = S
3 = E
4 = FN
5 = FW
6 = FS
7 = FE
*/
/* This routine will write a new line */
extern int defwNewLine();
/* The DEF writer initialization. Must be called first.
* Either this routine or defwInitCbk should be call only.
* Can't call both routines in one program.
* This routine is for user who does not want to use the callback machanism.
* Returns 0 if successful. */
extern int defwInit ( FILE* f, int vers1, int version2,
const char* caseSensitive, /* NAMESCASESENSITIVE */
const char* dividerChar, /* DIVIDERCHAR */
const char* busBitChars, /* BUSBITCHARS */
const char* designName, /* DESIGN */
const char* technology, /* optional(NULL) - TECHNOLOGY */
const char* array, /* optional(NULL) - ARRAYNAME */
const char* floorplan, /* optional(NULL) - FLOORPLAN */
double units ); /* optional (set to -1 to ignore) */
/* The DEF writer initialization. Must be called first.
* Either this routine or defwInit should be call only.
* Can't call both routines in one program.
* This routine is for user who choose to use the callback machanism.
* If user uses the callback for the writer, they need to provide
* callbacks for Version, NamesCaseSensitive, BusBitChars and DividerChar.
* These sections are required by the def. If any of these callbacks
* are missing, defaults will be used.
* Returns 0 if successful. */
extern int defwInitCbk (FILE* f);
/* This routine must be called after the defwInit.
* This routine is required.
* Returns 0 if successful.
* The routine can be called only once. */
extern int defwVersion (int vers1, int vers2);
/* This routine must be called after the defwInit.
* This routine is required.
* Returns 0 if successful.
* The routine can be called only once. */
extern int defwCaseSensitive ( const char* caseSensitive );
/* This routine must be called after the defwInit.
* This routine is required.
* Returns 0 if successful.
* The routine can be called only once. */
extern int defwBusBitChars ( const char* busBitChars );
/* This routine must be called after the defwInit.
* This routine is required.
* Returns 0 if successful.
* The routine can be called only once. */
extern int defwDividerChar ( const char* dividerChar );
/* This routine must be called after the defwInit.
* This routine is required.
* Returns 0 if successful.
* The routine can be called only once. */
extern int defwDesignName ( const char* name );
/* This routine must be called after the defwInit.
* This routine is optional.
* Returns 0 if successful.
* The routine can be called only once. */
extern int defwTechnology ( const char* technology );
/* This routine must be called after the defwInit.
* This routine is optional.
* Returns 0 if successful.
* The routine can be called only once. */
extern int defwArray ( const char* array );
/* This routine must be called after the defwInit.
* This routine is optional.
* Returns 0 if successful.
* The routine can be called only once. */
extern int defwFloorplan ( const char* floorplan );
/* This routine must be called after the defwInit.
* This routine is optional.
* Returns 0 if successful.
* The routine can be called only once. */
extern int defwUnits ( int units );
/* This routine must be called after the defwInit.
* This routine is optional.
* Returns 0 if successful.
* The routine can be called 0 to many times. */
extern int defwHistory ( const char* string );
/* This routine must be called after the history routines (if any).
* This routine is optional.
* Returns 0 if successful.
* The routine can be called only once. */
extern int defwStartPropDef ( void );
/* This routine must be called after defwStartPropDef.
* This routine can be called multiple times.
* It adds integer property definition to the statement.
* Returns 0 if successfull.
* The objType can be LIBRARY or VIA or MACRO or PIN. */
extern int defwIntPropDef(
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 defwStartPropDef.
* This routine can be called multiple times.
* It adds real property definition to the statement.
* Returns 0 if successfull.
* The objType can be LIBRARY or VIA or MACRO or PIN. */
extern int defwRealPropDef(
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 defwStartPropDef.
* This routine can be called multiple times.
* It adds string property definition to the statement.
* Returns 0 if successfull.
* The objType can be LIBRARY or VIA or MACRO or PIN. */
extern int defwStringPropDef(
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 all the properties have been
* added to the file.
* If you called defwPropertyDefinitions then this routine is NOT optional.
* Returns 0 if successful.
* The routine can be called only once. */
extern int defwEndPropDef ( void );
/* This routine can be called after defwRow, defwRegion, defwComponent,
* defwPin, defwSpecialNet, defwNet, and defwGroup
* This routine is optional, it adds string property to the statement.
* Returns 0 if successful.
* This routine can be called 0 to many times */
extern int defwStringProperty(const char* propName, const char* propValue);
/* This routine can be called after defwRow, defwRegion, defwComponent,
* defwPin, defwSpecialNet, defwNet, and defwGroup
* This routine is optional, it adds real property to the statement.
* Returns 0 if successful.
* This routine can be called 0 to many times */
extern int defwRealProperty(const char* propName, double propValue);
/* This routine can be called after defwRow, defwRegion, defwComponent,
* defwPin, defwSpecialNet, defwNet, and defwGroup
* This routine is optional, it adds int property to the statement.
* Returns 0 if successful.
* This routine can be called 0 to many times */
extern int defwIntProperty(const char* propName, int propValue);
/* This routine must be called after the property definitions (if any).
* This routine is optional.
* Returns 0 if successful.
* The routine can be called only once. */
extern int defwDieArea ( int xl, /* point1 - x */
int yl, /* point1 - y */
int xh, /* point2 - x */
int yh ); /* point2 - y */
/* This routine must be called after the property definitions (if any).
* This routine is optional.
* This routine is the same as defwDieArea, but accept more than 2 points
* This is a 5.6 syntax
* Returns 0 if successful.
* The routine can be called only once. */
extern int defwDieAreaList ( int num_points, /* number of points on list */
int* xl, /* all the x points */
int* yh); /* all the y points */
/* This routine must be called after the Die Area (if any).
* This routine is optional.
* Returns 0 if successful.
* The integer "orient" and operation of the do is explained in
* the documentation.
* In 5.6, the DO syntax is optional and the STEP syntax is optional in DO */
extern int defwRow ( const char* rowName, const char* rowType,
int x_orig, int y_orig, int orient,
int do_count, /* optional (0) */
int do_increment, /* optional (0) */
int xstep, /* optional (0) */
int ystep); /* optional (0) */
/* This routine must be called after the Die Area (if any).
* This routine is optional.
* Returns 0 if successful.
* This routine is the same as defwRow, excpet orient is a char* */
extern int defwRowStr ( const char* rowName, const char* rowType,
int x_orig, int y_orig, const char* orient,
int do_count, /* optional (0) */
int do_increment, /* optional (0) */
int xstep, /* optional (0) */
int ystep); /* optional (0) */
/* This routine must be called after the defwRow (if any).
* This routine is optional.
* Returns 0 if successful.
* The operation of the do is explained in the documentation. */
extern int defwTracks ( const char* master, /* X | Y */
int doStart, /* start */
int doCount, /* numTracks */
int doStep, /* space */
int numLayers, /* number of layers */
const char** layers, /* list of layers */
int mask = 0, /* optional */
int sameMask = 0); /* optional */
/* This routine must be called after the defwTracks (if any).
* This routine is optional.
* Returns 0 if successful.
* The operation of the do is explained in the documentation. */
extern int defwGcellGrid ( const char* master, /* X | Y */
int doStart, /* start */
int doCount, /* numColumns | numRows */
int doStep); /* space */
/* This routine must be called after the defwTracks (if any).
* This section of routines is optional.
* Returns 0 if successful.
* The routine starts the default capacitance section. All of the
* capacitances must follow.
* The count is the number of defwDefaultCap calls to follow.
* The routine can be called only once.
* This api is obsolete in 5.4. */
extern int defwStartDefaultCap ( int count );
/* This routine is called once for each default cap. The calls must
* be preceeded by a call to defwStartDefaultCap and must be
* terminated by a call to defwEndDefaultCap.
* Returns 0 if successful.
* This api is obsolete in 5.4. */
extern int defwDefaultCap ( int pins, /* MINPINS */
double cap); /* WIRECAP */
/* This routine must be called after the defwDefaultCap calls (if any).
* Returns 0 if successful.
* If the count in StartDefaultCap is not the same as the number of
* calls to DefaultCap then DEFW_BAD_DATA will return returned.
* The routine can be called only once.
* This api is obsolete in 5.4. */
extern int defwEndDefaultCap ( void );
/* This routine must be called after the defwDefaultCap calls (if any).
* The operation of the do is explained in the documentation.
* This routine is optional.
* Returns 0 if successful.
* The routine can be called many times. */
extern int defwCanPlace(const char* master, /* sitename */
int xOrig,
int yOrig,
int orient, /* 0 to 7 */
int doCnt, /* numX */
int doInc, /* numY */
int xStep, /* spaceX */
int yStep); /* spaceY */
/* This routine must be called after the defwDefaultCap calls (if any).
* The operation of the do is explained in the documentation.
* This routine is optional.
* Returns 0 if successful.
* The routine can be called many times.
* This routine is the same as defwCanPlace, except orient is a char* */
extern int defwCanPlaceStr(const char* master, /* sitename */
int xOrig,
int yOrig,
const char* orient, /* 0 to 7 */
int doCnt, /* numX */
int doInc, /* numY */
int xStep, /* spaceX */
int yStep); /* spaceY */
/* This routine must be called after the defwCanPlace calls (if any).
* The operation of the do is explained in the documentation.
* This routine is optional.
* Returns 0 if successful.
* The routine can be called many times. */
extern int defwCannotOccupy(const char* master, /* sitename */
int xOrig,
int yOrig,
int orient, /* 0 to 7 */
int doCnt, /* numX */
int doInc, /* numY */
int xStep, /* spaceX */
int yStep); /* spaceY */
/* This routine must be called after the defwCanPlace calls (if any).
* The operation of the do is explained in the documentation.
* This routine is optional.
* Returns 0 if successful.
* The routine can be called many times.
* This routine is the same as defwCannotOccupy, except orient is a char* */
extern int defwCannotOccupyStr(const char* master, /* sitename */
int xOrig,
int yOrig,
const char* orient, /* 0 to 7 */
int doCnt, /* numX */
int doInc, /* numY */
int xStep, /* spaceX */
int yStep); /* spaceY */
/* This routine must be called after defwCannotOccupy (if any).
* This section of routines is optional.
* Returns 0 if successful.
* The routine starts the via section. All of the vias must follow.
* The count is the number of defwVia calls to follow.
* The routine can be called only once. */
extern int defwStartVias( int count );
/* These routines enter each via into the file.
* These routines must be called after the defwStartVias call.
* defwViaName should be called first, follow either by defwViaPattern or
* defwViaLayer. At the end of each via, defwOneViaEnd should be called
* These routines are for [- viaName [+ PATTERNNAME patternName + RECT layerName
* pt pt]...;]...
* Returns 0 if successful.
* The routines can be called many times. */
extern int defwViaName(const char* name);
extern int defwViaPattern(const char* patternName);
/* This routine can be called multiple times. */
/* mask is 5.8 syntax */
extern int defwViaRect(const char* layerName,
int xl, /* xl from the RECT */
int yl, /* yl from the RECT */
int xh, /* xh from the RECT */
int yh, /* yh from the RECT */
int mask = 0); /* optional */
/* This is a 5.6 syntax
* This routine can be called multiple times. */
/* mask is 5.8 syntax */
extern int defwViaPolygon(const char* layerName,
int num_polys,
double* xl,
double* yl,
int mask = 0);
/* These routine must be called after defwViaName.
* Either this routine or defwViaPattern can be called after each
* defwViaName is called.
* This is a 5.6 syntax
* Returns 0 if successful
* The routine can be called only once per defwViaName called. */
extern int defwViaViarule(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 defwViaViarule.
* It can only be called once.
* This is a 5.6 syntax.
* Returns 0 if successful. */
extern int defwViaViaruleRowCol(int numCutRows, int numCutCols);
/* This routine can call only after defwViaViarule.
* It can only be called once.
* This is a 5.6 syntax.
* Returns 0 if successful. */
extern int defwViaViaruleOrigin(int xOffset, int yOffset);
/* This routine can call only after defwViaViarule.
* It can only be called once.
* This is a 5.6 syntax.
* Returns 0 if successful. */
extern int defwViaViaruleOffset(int xBotOffset, int yBotOffset,
int xTopOffset, int yTopOffset);
/* This routine can call only after defwViaViarule.
* It can only be called once.
* This is a 5.6 syntax.
* Returns 0 if successful. */
extern int defwViaViarulePattern(const char* cutPattern);
extern int defwOneViaEnd();
/* This routine must be called after the defwVia calls.
* Returns 0 if successful.
* If the count in StartVias is not the same as the number of
* calls to Via or ViaPattern then DEFW_BAD_DATA will return returned.
* The routine can be called only once. */
extern int defwEndVias( void );
/* This routine must be called after via section (if any).
* This section of routines is optional.
* Returns 0 if successful.
* The routine starts the region section. All of the regions must follow.
* The count is the number of defwRegion calls to follow.
* The routine can be called only once. */
extern int defwStartRegions( int count );
/* This routine enter each region into the file.
* This routine must be called after the defwStartRegions call.
* Returns 0 if successful.
* The routine can be called many times. */
extern int defwRegionName(const char* name);
/* This routine enter the region point to the region name.
* This routine must be called after the defwRegionName call.
* Returns 0 if successful.
* The routine can be called many times. */
extern int defwRegionPoints(int xl, int yl, int xh, int yh);
/* This routine enter the region type, FENCE | GUIDE.
* This routine must be called after the defwRegionName call.
* This is a 5.4.1 syntax.
* Returns 0 if successful.
* The routine can be called only once. */
extern int defwRegionType(const char* type); /* FENCE | GUIDE */
/* This routine must be called after the defwRegion calls.
* Returns 0 if successful.
* If the count in StartRegions is not the same as the number of
* calls to Region or RegionPattern then DEFW_BAD_DATA will return returned.
* The routine can be called only once. */
extern int defwEndRegions( void );
/* This is a 5.8 syntax.
* Returns 0 if successful.
* The routine can be called only once. */
extern int defwComponentMaskShiftLayers(const char** layerNames,
int numLayerName);
/* This routine must be called after the regions section (if any).
* This section of routines is NOT optional.
* Returns 0 if successful.
* The routine starts the components section. All of the components
* must follow.
* The count is the number of defwComponent calls to follow.
* The routine can be called only once. */
extern int defwStartComponents( int count );
/* This routine enter each component into the file.
* This routine must be called after the defwStartComponents call.
* The optional fields will be ignored if they are set to zero
* (except for weight which must be set to -1.0).
* Returns 0 if successful.
* The routine can be called many times. */
extern int defwComponent(const char* instance, /* compName */
const char* master, /* modelName */
int numNetName, // optional(0) - # netNames defined
const char** netNames, /* optional(NULL) - list */
const char* eeq, /* optional(NULL) - EEQMASTER */
const char* genName, /* optional(NULL) - GENERATE */
const char* genParemeters, /* optional(NULL) - parameters */
const char* source, // optional(NULL) - NETLIST | DIST |
// USER | TIMING
int numForeign, // optional(0) - # foreigns,
// foreignx, foreigny & orients
const char** foreigns, /* optional(NULL) - list */
int* foreignX, int* foreignY, /* optional(0) - list foreign pts */
int* foreignOrients, /* optional(-1) - 0 to 7 */
const char* status, // optional(NULL) - FIXED | COVER |
// PLACED | UNPLACED
int statusX, int statusY, /* optional(0) - status pt */
int statusOrient, /* optional(-1) - 0 to 7 */
double weight, /* optional(0) */
const char* region, // optional(NULL) - either xl, yl,
// xh, yh or region
int xl, int yl, /* optional(0) - region pt1 */
int xh, int yh); /* optional(0) - region pt2 */
/* This routine enter each component into the file.
* This routine must be called after the defwStartComponents call.
* The optional fields will be ignored if they are set to zero
* (except for weight which must be set to -1.0).
* Returns 0 if successful.
* The routine can be called many times.
* This routine is the same as defwComponent, except orient is a char** */
extern int defwComponentStr(const char* instance, /* compName */
const char* master, /* modelName */
int numNetName, // optional(0) - # netNames defined
//
const char** netNames, /* optional(NULL) - list */
const char* eeq, /* optional(NULL) - EEQMASTER */
const char* genName, /* optional(NULL) - GENERATE */
const char* genParemeters, /* optional(NULL) - parameters */
const char* source, // optional(NULL) - NETLIST | DIST |
// USER | TIMING
int numForeign, // optional(0) - # foreigns,
// foreignx, foreigny & orients
const char** foreigns, /* optional(NULL) - list */
int* foreignX, int* foreignY, /* optional(0) - list foreign pts */
const char** foreignOrients, /* optional(NULL) */
const char* status, // optional(NULL) - FIXED | COVER |
// PLACED | UNPLACED
int statusX, int statusY, /* optional(0) - status pt */
const char* statusOrient, /* optional(NULL) */
double weight, /* optional(0) */
const char* region, // optional(NULL) - either xl, yl,
// xh, yh or region
int xl, int yl, /* optional(0) - region pt1 */
int xh, int yh); /* optional(0) - region pt2 */
/* This is a 5.8 syntax.
* Returns 0 if successful.
* The routine can be called only once. */
extern int defwComponentMaskShift(int shiftLayerMasks);
/* This routine must be called after either the defwComponent or
* defwComponentStr.
* This routine can only called once per component.
* Either this routine or defwComponentHaloSoft can be called, but not both
* This routine is optional.
* This is a 5.6 syntax.
* Returns 0 if successful. */
extern int defwComponentHalo(int left, int bottom, int right, int top);
/* This routine must be called after either the defwComponent or
* defwComponentStr.
* This routine can only called once per component.
* This routine is just like defwComponentHalo, except it writes the option SOFT
* Either this routine or defwComponentHalo can be called, but not both
* This routine is optional.
* This is a 5.7 syntax.
* Returns 0 if successful. */
extern int defwComponentHaloSoft(int left, int bottom, int right, int top);
/* This routine must be called after either the defwComponent or
* defwComponentStr.
* This routine can only called once per component.
* This routine is optional.
* This is a 5.7 syntax.
* Returns 0 if successful. */
extern int defwComponentRouteHalo(int haloDist, const char* minLayer,
const char* maxLayer);
/* This routine must be called after the defwComponent calls.
* Returns 0 if successful.
* If the count in StartComponents is not the same as the number of
* calls to Component then DEFW_BAD_DATA will return returned.
* The routine can be called only once. */
extern int defwEndComponents( void );
/* This routine must be called after the components section (if any).
* This section of routines is optional.
* Returns 0 if successful.
* The routine starts the pins section. All of the pins must follow.
* The count is the number of defwPin calls to follow.
* The routine can be called only once. */
extern int defwStartPins( int count );
/* This routine enter each pin into the file.
* This routine must be called after the defwStartPins call.
* The optional fields will be ignored if they are set to zero.
* Returns 0 if successful.
* The routine can be called many times.
* NOTE: Use defwPinLayer to write out layer with SPACING or DESIGNRULEWIDTH */
extern int defwPin(const char* name, /* pinName */
const char* net, /* netName */
int special, /* 0 - ignore, 1 - special */
const char* direction, // optional(NULL) - INPUT | OUTPUT |
// INOUT | FEEDTHRU
const char* use, // optional(NULL) - SIGNAL | POWER |
// GROUND | CLOCK | TIEOFF | ANALOG
const char* status, // optional(NULL) - FIXED | PLACED |
// COVER
int statusX, int statusY, /* optional(0) - status point */
int orient, /* optional(-1) - status orient */
const char* layer, /* optional(NULL) - layerName */
int xl, int yl, /* optional(0) - layer point1 */
int xh, int yh); /* optional(0) - layer point2 */
/* This routine enter each pin into the file.
* This routine must be called after the defwStartPins call.
* The optional fields will be ignored if they are set to zero.
* Returns 0 if successful.
* The routine can be called many times.
* This routine is the same as defwPin, except orient is a char*
* NOTE: Use defwPinLayer to write out layer with SPACING or DESIGNRULEWIDTH */
extern int defwPinStr(const char* name, /* pinName */
const char* net, /* netName */
int special, /* 0 - ignore, 1 - special */
const char* direction, // optional(NULL) - INPUT | OUTPUT |
// INOUT | FEEDTHRU
const char* use, // optional(NULL) - SIGNAL | POWER |
// GROUND | CLOCK | TIEOFF | ANALOG
const char* status, // optional(NULL) - FIXED | PLACED |
// COVER
int statusX, int statusY, /* optional(0) - status point */
const char* orient, /* optional(NULL) */
const char* layer, /* optional(NULL) - layerName */
int xl, int yl, /* optional(0) - layer point1 */
int xh, int yh); /* optional(0) - layer point2 */
/* This routine should be called if the layer has either SPACING or
* DESIGNRULEWIDTH. If this routine is used and the pin has only one
* layer, the layer in defwPin or defwPinStr has to be null, otherwise
* the layer will be written out twice.
* This routine must be called after defwPin or defwPinStr.
* This is a 5.6 syntax.
* This routine is optional.
* Returns 0 if successful.
* This routine can be called multiple times within a pin. */
extern int defwPinLayer(const char* layerName,
int spacing, /* optional(0) - SPACING & DESIGNRULEWIDTH */
int designRuleWidth, /* are mutually exclusive */
int xl, int yl,
int xh, int yh,
int mask = 0);
/* This routine must be called after defwPin or defwPinStr.
* This routine is to write out layer with polygon.
* This is a 5.6 syntax.
* This routine is optional.
* Returns 0 if successful.
* The routine can be called multiple times within a pin. */
extern int defwPinPolygon(const char* layerName,
int spacing, /* optional(0) - SPACING & DESIGNRULEWIDTH */
int designRuleWidth, /* are mutually exclusive */
int num_polys, double* xl, double* yl,
int mask = 0);
/* This routine must be called after defwPin or defwPinStr.
* This routine is to write out layer with via.
* This is a 5.7 syntax.
* This routine is optional.
* Returns 0 if successful.
* The routine can be called multiple times within a pin. */
extern int defwPinVia(const char* viaName, int xl, int yl, int mask = 0);
/* This routine must be called after defwPin or defwPinStr.
* This routine is to write out pin with port.
* This is a 5.7 syntax.
* This routine is optional.
* Returns 0 if successful.
* The routine can be called multiple times within a pin. */
extern int defwPinPort();
/* This routine is called after defwPinPort.
* This is a 5.7 syntax.
* This routine is optional.
* Returns 0 if successful.
* This routine can be called multiple times within a pin. */
extern int defwPinPortLayer(const char* layerName,
int spacing, /* optional(0) - SPACING & DESIGNRULEWIDTH */
int designRuleWidth, /* are mutually exclusive */
int xl, int yl,
int xh, int yh,
int mask = 0);
/* This routine must be called after defwPinPort.
* This is a 5.7 syntax.
* This routine is optional.
* Returns 0 if successful.
* The routine can be called multiple times within a pin. */
extern int defwPinPortPolygon(const char* layerName,
int spacing, /* optional(0) - SPACING & DESIGNRULEWIDTH */
int designRuleWidth, /* are mutually exclusive */
int num_polys, double* xl, double* yl,
int mask = 0);
/* This routine must be called after defwPinPort.
* This is a 5.7 syntax.
* This routine is optional.
* Returns 0 if successful.
* The routine can be called multiple times within a pin. */
extern int defwPinPortVia(const char* viaName, int xl, int yl, int mask = 0);
/* This routine must be called after defwPinPort.
* This is a 5.7 syntax.
* This routine is optional.
* Returns 0 if successful.
* The routine can be called many times.
* NOTE: Use defwPinLayer to write out layer with SPACING or DESIGNRULEWIDTH */
extern int defwPinPortLocation(
const char* status, /* FIXED | PLACED | COVER */
int statusX, int statusY, /* status point */
const char* orient);
/* This routine must be called after defwPin.
* Returns 0 if successful.
* This is a 5.6 syntax.
* The routine can be called only once per pin. */
extern int defwPinNetExpr(const char* pinExpr);
/* This routine must be called after defwPin.
* Returns 0 if successful.
* This is a 5.6 syntax.
* The routine can be called only once per pin. */
extern int defwPinSupplySensitivity(const char* pinName);
/* This routine must be called after defwPin.
* Returns 0 if successful.
* This is a 5.6 syntax.
* The routine can be called only once per pin. */
extern int defwPinGroundSensitivity(const char* pinName);
/* This routine must be called after defwPin.
* Returns 0 if successful.
* This is a 5.4 syntax.
* The routine can be called multiple times. */
extern int defwPinAntennaPinPartialMetalArea(int value,
const char* layerName); /* optional(NULL) */
/* This routine must be called after defwPin.
* Returns 0 if successful.
* This is a 5.4 syntax.
* The routine can be called multiple times. */
extern int defwPinAntennaPinPartialMetalSideArea(int value,
const char* layerName); /* optional(NULL) */
/* This routine must be called after defwPin.
* Returns 0 if successful.
* This is a 5.4 syntax.
* The routine can be called multiple times. */
extern int defwPinAntennaPinPartialCutArea(int value,
const char* layerName); /* optional(NULL) */
/* This routine must be called after defwPin.
* Returns 0 if successful.
* This is a 5.4 syntax.
* The routine can be called multiple times. */
extern int defwPinAntennaPinDiffArea(int value,
const char* layerName); /* optional(NULL) */
/* This routine must be called after defwPin.
* Returns 0 if successful.
* This is a 5.5 syntax.
* The oxide can be either OXIDE1, OXIDE2, OXIDE3, or OXIDE4.
* Each oxide value can be called only once after defwPin. */
extern int defwPinAntennaModel(const char* oxide);
/* This routine must be called after defwPin.
* Returns 0 if successful.
* This is a 5.4 syntax.
* The routine can be called multiple times. */
extern int defwPinAntennaPinGateArea(int value,
const char* layerName); /* optional(NULL) */
/* This routine must be called after defwPin.
* Returns 0 if successful.
* This is a 5.4 syntax.
* The routine can be called multiple times. */
extern int defwPinAntennaPinMaxAreaCar(int value,
const char* layerName); /* optional(NULL) */
/* This routine must be called after defwPin.
* Returns 0 if successful.
* This is a 5.4 syntax.
* The routine can be called multiple times. */
extern int defwPinAntennaPinMaxSideAreaCar(int value,
const char* layerName); /* optional(NULL) */
/* This routine must be called after defwPin.
* Returns 0 if successful.
* This is a 5.4 syntax.
* The routine can be called multiple times. */
extern int defwPinAntennaPinMaxCutCar(int value,
const char* layerName); /* optional(NULL) */
/* This routine must be called after the defwPin calls.
* Returns 0 if successful.
* If the count in StartPins is not the same as the number of
* calls to Pin then DEFW_BAD_DATA will return returned.
* The routine can be called only once. */
extern int defwEndPins( void );
/* This routine must be called after the pin section (if any).
* This section of routines is optional.
* Returns 0 if successful.
* The routine starts the pinproperties section. All of the pinproperties
* must follow.
* The count is the number of defwPinProp calls to follow.
* The routine can be called only once. */
extern int defwStartPinProperties( int count );
/* This routine enter each pinproperty into the file.
* This routine must be called after the defwStartPinProperties call.
* The optional fields will be ignored if they are set to zero.
* Returns 0 if successful.
* The routine can be called many times. */
extern int defwPinProperty(const char* name, /* compName | PIN */
const char* pinName); /* pinName */
/* This routine must be called after the defwPinProperty calls.
* Returns 0 if successful.
* If the count in StartPins is not the same as the number of
* calls to Pin then DEFW_BAD_DATA will return returned.
* The routine can be called only once. */
extern int defwEndPinProperties( void );
/* Routines to enter a special net or nets into the file.
* You must first call defwStartSpecialNets with the number of
* nets. This section is required, even if you do not have any nets.
* For each net you should call defwSpecialNet followed by
* one or more defwSpecialNetConnection calls.
* After the connections come the options. Options are
* NOT required.
* Each net is completed by calling defwSpecialNetEndOneNet().
* The nets section is finished by calling defwEndNets(). */
extern int defwStartSpecialNets(int count);
/* This routine must be called after the defwStartSpecialNets it is for
* - netName */
extern int defwSpecialNet(const char* name); /* netName */
/* This routine is for compNameRegExpr, pinName, and SYNTHESIZED */
/* It can be called multiple times */
extern int defwSpecialNetConnection(const char* inst, /* compNameRegExpr */
const char* pin, /* pinName */
int synthesized); /* 0 - ignore, 1 - SYNTHESIZED */
/* This routine is for + FIXEDBUMP
* This is a 5.4.1 syntax */
extern int defwSpecialNetFixedbump();
/* This routine is for + VOLTAGE volts */
extern int defwSpecialNetVoltage(double v);
/* This routine is for + SPACING layerName spacing [RANGE minwidth maxwidth */
extern int defwSpecialNetSpacing(const char* layer, /* layerName */
int spacing, /* spacing */
double minwidth, /* optional(0) - minwidth */
double maxwidth); /* optional(0) - maxwidth */
/* This routine is for + WIDTH layerName width */
extern int defwSpecialNetWidth(const char* layer, /* layerName */
int width); /* width */
/* This routine is for + SOURCE {NETLIST | DIST | USER | TIMING} */
extern int defwSpecialNetSource(const char* name);
/* This routine is for + ORIGINAL netName */
extern int defwSpecialNetOriginal(const char* name); /* netName */
/* This routine is for + PATTERN {STEINER | BALANCED | WIREDLOGIC | TRUNK} */
extern int defwSpecialNetPattern(const char* name);
/* This routine is for + USE {SIGNAL | POWER | GROUND | CLOCK | TIEOFF |
ANALOG | SCAN | RESET} */
extern int defwSpecialNetUse(const char* name);
/* This routine is for + WEIGHT weight */
extern int defwSpecialNetWeight(double value);
/* This routine is for + ESTCAP wireCapacitance */
extern int defwSpecialNetEstCap(double value);
/* Paths are a special type of option. A path must begin
* with a defwSpecialNetPathStart and end with a defwSpecialNetPathEnd().
* The individual parts of the path can be entered in
* any order. */
extern int defwSpecialNetPathStart(const char* typ); // ROUTED | FIXED | COVER |
// SHIELD | NEW
extern int defwSpecialNetShieldNetName(const char* name); /* shieldNetName */
extern int defwSpecialNetPathLayer(const char* name); /* layerName */
extern int defwSpecialNetPathWidth(int width);
/* This routine is optional.
* This is a 5.6 syntax. */
extern int defwSpecialNetPathStyle(int styleNum);
extern int defwSpecialNetPathShape(const char* shapeType); // RING | STRIPE |
// FOLLOWPIN | IOWIRE | COREWIRE | BLOCKWIRE | FILLWIRE | BLOCKAGEWIRE
/* This routine is optional.
This is a 5.8 syntax.
* Returns 0 if successful. */
extern int defwSpecialNetPathMask(int colorMask);
/* x and y location of the path */
extern int defwSpecialNetPathPoint(int numPts, /* number of connected points */
double* pointx, /* point x list */
double* pointy); /* point y list */
extern int defwSpecialNetPathVia(const char* name); /* viaName */
/* This routine is called after defwSpecialNetPath
* This is a 5.4.1 syntax */
extern int defwSpecialNetPathViaData(int numX, int numY, int stepX, int stepY);
/* x and y location of the path */
extern int defwSpecialNetPathPointWithWireExt(
int numPts, /* number of connected points */
double* pointx, /* point x list */
double* pointy, /* point y list */
double* optValue); /* optional(NULL) value */
extern int defwSpecialNetPathEnd();
/* This is a 5.6 syntax
* This routine can be called multiple times. */
extern int defwSpecialNetPolygon(const char* layerName,
int num_polys, double* xl, double* yl);
/* This is a 5.6 syntax
* This routine can be called multiple times. */
extern int defwSpecialNetRect(const char* layerName,
int xl, int yl, int xh, int yh);
extern int defwSpecialNetVia(const char* layerName);
extern int defwSpecialNetViaWithOrient(const char* layerName, int orient);
extern int defwSpecialNetViaPoints(int num_points, double* xl, double* yl);
/* This routine is called at the end of each net */
extern int defwSpecialNetEndOneNet();
/* 5.3 for special net */
/* Shields are a special type of option. A shield must begin
* with a defwSpecialNetShieldStart and end with a defwSpecialNetShieldEnd().
* The individual parts of the shield can be entered in
* any order. */
extern int defwSpecialNetShieldStart(const char* name);
extern int defwSpecialNetShieldLayer(const char* name); /* layerName */
extern int defwSpecialNetShieldWidth(int width); /* width */
extern int defwSpecialNetShieldShape(const char* shapeType); // RING | STRIPE |
// FOLLOWPIN | IOWIRE | COREWIRE | BLOCKWIRE | FILLWIRE | BLOCKAGEWIRE
/* x and y location of the path */
extern int defwSpecialNetShieldPoint(int numPts, /* # of connected points */
double* pointx, /* point x list */
double* pointy); /* point y list */
extern int defwSpecialNetShieldVia(const char* name); /* viaName */
/* A 5.4.1 syntax */
extern int defwSpecialNetShieldViaData(int numX, int numY, int stepX, int stepY);
extern int defwSpecialNetShieldEnd();
/* end 5.3 */
/* This routine is called at the end of the special net section */
extern int defwEndSpecialNets();
/* Routines to enter a net or nets into the file.
* You must first call defwNets with the number of nets.
* This section is required, even if you do not have any nets.
* For each net you should call defwNet followed by one or
* more defwNetConnection calls.
* After the connections come the options. Options are
* NOT required.
* Each net is completed by calling defwNetEndOneNet().
* The nets section is finished by calling defwEndNets(). */
extern int defwStartNets(int count);
/* This routine must be called after the defwStartNets, it is for - netName */
extern int defwNet(const char* name);
/* This routine is for { compName | PIN } pinName [+ SYNTHESIZED] */
/* It can be called multiple times */
extern int defwNetConnection(const char* inst, /* compName */
const char* pin, /* pinName */
int synthesized); /* 0 - ignore, 1 - SYNTHESIZED */
/* This routine is for MUSTJOIN, compName, pinName */
extern int defwNetMustjoinConnection(const char* inst, /* compName */
const char* pin); /* pinName */
/* This routine is for + VPIN vpinName [LAYER layerName pt pt
* [{ PLACED | FIXED | COVER } pt orient] */
extern int defwNetVpin(const char* vpinName,
const char* layerName, /* optional(NULL) */
int layerXl, int layerYl, /* layer point1 */
int layerXh, int layerYh, /* layer point2 */
const char* status, /* optional(NULL) */
int statusX, int statusY, /* optional(0) - status point */
int orient); /* optional(-1) */
/* This routine is for + VPIN vpinName [LAYER layerName pt pt
* [{ PLACED | FIXED | COVER } pt orient]
* This routine is the same as defwNetVpin, except orient is a char* */
extern int defwNetVpinStr(const char* vpinName,
const char* layerName, /* optional(NULL) */
int layerXl, int layerYl, /* layer point1 */
int layerXh, int layerYh, /* layer point2 */
const char* status, /* optional(NULL) */
int statusX, int statusY, /* optional(0) - status point */
const char* orient); /* optional(NULL) */
/* This routine can be called either within net or subnet.
* it is for NONDEFAULTRULE rulename */
extern int defwNetNondefaultRule(const char* name);
/* This routine is for + XTALK num */
extern int defwNetXtalk(int xtalk);
/* This routine is for + FIXEDBUMP
* This is a 5.4.1 syntax */
extern int defwNetFixedbump();
/* This routine is for + FREQUENCY
* This is a 5.4.1 syntax */
extern int defwNetFrequency(double frequency);
/* This routine is for + SOURCE {NETLIST | DIST | USER | TEST | TIMING} */
extern int defwNetSource(const char* name);
/* This routine is for + ORIGINAL netname */
extern int defwNetOriginal(const char* name);
/* This routine is for + USE {SIGNAL | POWER | GROUND | CLOCK | TIEOFF |
* ANALOG} */
extern int defwNetUse(const char* name);
/* This routine is for + PATTERN {STEINER | BALANCED | WIREDLOGIC} */
extern int defwNetPattern(const char* name);
/* This routine is for + ESTCAP wireCapacitance */
extern int defwNetEstCap(double value);
/* This routine is for + WEIGHT weight */
extern int defwNetWeight(double value);
/* 5.3 for net */
/* This routine is for + SHIELDNET weight */
extern int defwNetShieldnet(const char* name);
/* Noshield are a special type of option. A noshield must begin
* with a defwNetNoshieldStart and end with a defwNetNoshieldEnd().
* The individual parts of the noshield can be entered in
* any order. */
extern int defwNetNoshieldStart(const char* name);
/* x and y location of the path */
extern int defwNetNoshieldPoint(int numPts, /* number of connected points */
const char** pointx, /* point x list */
const char** pointy); /* point y list */
extern int defwNetNoshieldVia(const char* name); /* viaName */
extern int defwNetNoshieldEnd();
/* end 5.3 */
/* Subnet are a special type of option. A subnet must begin
* with a defwNetSubnetStart and end with a defwNetSubnetEnd().
* Routines to call within the subnet are: defwNetSubnetPin,
* defwNetNondefaultRule and defwNetPathStart... */
extern int defwNetSubnetStart(const char* name);
/* This routine is called after the defwNetSubnet, it is for
* [({compName | PIN} pinName) | (VPIN vpinName)]... */
extern int defwNetSubnetPin(const char* compName, /* compName | PIN | VPIN */
const char* pinName); /* pinName | vpinName */
extern int defwNetSubnetEnd();
/* Paths are a special type of option. A path must begin
* with a defwNetPathStart and end with a defwPathEnd().
* The individual parts of the path can be entered in
* any order. */
extern int defwNetPathStart(const char* typ); // ROUTED | FIXED | COVER |
// NOSHIELD | NEW
extern int defwNetPathWidth(int w); /* width */
extern int defwNetPathLayer(const char* name, /* layerName */
int isTaper, /* 0 - ignore, 1 - TAPER */
const char* rulename); /* only one, isTaper or */
/*rulename can be assigned */
/* This routine is optional.
* This is a 5.6 syntax. */
extern int defwNetPathStyle(int styleNum);
/* This routine is optional.
* This is a 5.8 syntax. */
extern int defwNetPathMask(int maskNum);
extern int defwNetPathRect(int deltaX1, int deltaY1, int deltaX2, int deltaY2);
extern int defwNetPathVirtual(int x, int y);
/* x and y location of the path */
extern int defwNetPathPoint(int numPts, /* number of connected points */
double* pointx, /* point x list */
double* pointy); /* point y list */
extern int defwNetPathPointWithExt(int numPts,
double* pointx,
double* pointy,
double* optValue);
extern int defwNetPathVia(const char* name); /* viaName */
extern int defwNetPathViaWithOrient(const char* name,
int orient); /* optional(-1) */
extern int defwNetPathViaWithOrientStr(const char* name,
const char* orient); /* optional(Null) */
extern int defwNetPathEnd();
/* This routine is called at the end of each net */
extern int defwNetEndOneNet();
/* This routine is called at the end of the net section */
extern int defwEndNets();
/* This section of routines is optional.
* Returns 0 if successful.
* The routine starts the I/O Timing section. All of the iotimings options
* must follow.
* The count is the number of defwIOTiming calls to follow.
* The routine can be called only once.
* This api is obsolete in 5.4. */
extern int defwStartIOTimings(int count);
/* This routine can be called after defwStaratIOTiming
* It is for - - {(comp pin) | (PIN name)}
* This api is obsolete in 5.4. */
extern int defwIOTiming(const char* inst, /* compName | PIN */
const char* pin); /* pinName */
/* This routine is for + { RISE | FALL } VARIABLE min max
* This api is obsolete in 5.4. */
extern int defwIOTimingVariable(const char* riseFall, /* RISE | FALL */
int num1, /* min */
int num2); /* max */
/* This routine is for + { RISE | FALL } SLEWRATE min max
* This api is obsolete in 5.4. */
extern int defwIOTimingSlewrate(const char* riseFall, /* RISE | FALL */
int num1, /* min */
int num2); /* max */
/* This routine is for + DRIVECELL macroName [[FROMPIN pinName] TOPIN pinName]
* [PARALLEL numDrivers]
* This api is obsolete in 5.4. */
extern int defwIOTimingDrivecell(const char* name, /* macroName*/
const char* fromPin, /* optional(NULL) */
const char* toPin, /* optional(NULL) */
int numDrivers); /* optional(0) */
/* This routine is for + CAPACITANCE capacitance
* This api is obsolete in 5.4. */
extern int defwIOTimingCapacitance(double num);
/* This api is obsolete in 5.4. */
extern int defwEndIOTimings();
/* Routines to enter scan chains. This section is optional
* The section must start with a defwStartScanchains() call and
* end with a defwEndScanchain() call.
* Each scan chain begins with a defwScanchain() call.
* The rest of the calls follow. */
extern int defwStartScanchains(int count);
/* This routine can be called after defwStartScanchains
* It is for - chainName */
extern int defwScanchain(const char* name);
/* This routine is for + COMMONSCANPINS [IN pin] [OUT pin] */
extern int defwScanchainCommonscanpins(
const char* inst1, /* optional(NULL) - IN | OUT*/
const char* pin1, /* can't be null if inst1 is set */
const char* inst2, /* optional(NULL) - IN | OUT */
const char* pin2); /* can't be null if inst2 is set */
/* This routine is for + PARTITION paratitionName [MAXBITS maxBits] */
/* This is 5.4.1 syntax */
extern int defwScanchainPartition(const char* name,
int maxBits); /* optional(-1) */
/* This routine is for + START {fixedInComp | PIN } [outPin] */
extern int defwScanchainStart(const char* inst, /* fixedInComp | PIN */
const char* pin); /* outPin */
/* This routine is for + STOP {fixedOutComp | PIN } [inPin] */
extern int defwScanchainStop(const char* inst, /* fixedOutComp | PIN */
const char* pin); /* inPin */
/* This routine is for + FLOATING {floatingComp [IN pin] [OUT pin]}
* This is a 5.4.1 syntax */
extern int defwScanchainFloating(const char* name, /* floatingComp */
const char* inst1, /* optional(NULL) - IN | OUT */
const char* pin1, /* can't be null if inst1 is set */
const char* inst2, /* optional(NULL) - IN | OUT */
const char* pin2); /* can't be null if inst2 is set */
/* This routine is for + FLOATING {floatingComp [IN pin] [OUT pin]}
* This is a 5.4.1 syntax.
* This routine is the same as defwScanchainFloating. But also added
* the option BITS. */
extern int defwScanchainFloatingBits(const char* name, /* floatingComp */
const char* inst1, /* optional(NULL) - IN | OUT */
const char* pin1, /* can't be null if inst1 is set */
const char* inst2, /* optional(NULL) - IN | OUT */
const char* pin2, /* can't be null if inst2 is set */
int bits); /* optional (-1) */
/* This routine is for + ORDERED {fixedComp [IN pin] [OUT pin]
* fixedComp [IN pin] [OUT pin].
* When this routine is called for the 1st time within a scanchain,
* both name1 and name2 are required. Only name1 is required is the
* routine is called more than once. */
extern int defwScanchainOrdered(const char* name1,
const char* inst1, /* optional(NULL) - IN | OUT */
const char* pin1, /* can't be null if inst1 is set */
const char* inst2, /* optional(NULL) - IN | OUT */
const char* pin2, /* can't be null if inst2 is set */
const char* name2,
const char* inst3, /* optional(NULL) - IN | OUT */
const char* pin3, /* can't be null if inst3 is set */
const char* inst4, /* optional(NULL) - IN | OUT */
const char* pin4); /* can't be null if inst4 is set */
/* This routine is for + ORDERED {fixedComp [IN pin] [OUT pin]
* fixedComp [IN pin] [OUT pin].
* When this routine is called for the 1st time within a scanchain,
* both name1 and name2 are required. Only name1 is required is the
* routine is called more than once.
* This is a 5.4.1 syntax.
* This routine is the same as defwScanchainOrdered. But also added
* the option BITS */
extern int defwScanchainOrderedBits(const char* name1,
const char* inst1, /* optional(NULL) - IN | OUT */
const char* pin1, /* can't be null if inst1 is set */
const char* inst2, /* optional(NULL) - IN | OUT */
const char* pin2, /* can't be null if inst2 is set */
int bits1, /* optional(-1) */
const char* name2,
const char* inst3, /* optional(NULL) - IN | OUT */
const char* pin3, /* can't be null if inst3 is set */
const char* inst4, /* optional(NULL) - IN | OUT */
const char* pin4, /* can't be null if inst4 is set */
int bits2); /* optional(-1) */
extern int defwEndScanchain();
/* Routines to enter constraints. This section is optional
* The section must start with a defwStartConstrains() call and
* end with a defwEndConstraints() call.
* Each contraint will call the defwConstraint...().
* This api is obsolete in 5.4. */
extern int defwStartConstraints (int count); /* optional */
/* The following routines are for - {operand [+ RISEMAX time] [+ FALLMAX time]
* [+ RISEMIN time] [+ FALLMIN time] | WIREDLOGIC netName MAXDIST distance };}
* operand - NET netName | PATH comp fromPin comp toPin | SUM (operand, ...)
* The following apis are obsolete in 5.4. */
extern int defwConstraintOperand(); /* begin an operand */
extern int defwConstraintOperandNet(const char* netName); /* NET */
extern int defwConstraintOperandPath(const char* comp1, /* PATH - comp|PIN */
const char* fromPin,
const char* comp2,
const char* toPin);
extern int defwConstraintOperandSum(); /* SUM */
extern int defwConstraintOperandSumEnd(); /* mark the end of SUM */
extern int defwConstraintOperandTime(const char* timeType, // RISEMAX | FALLMAX | RISEMIN | FALLMIN
int time);
extern int defwConstraintOperandEnd(); /* mark the end of operand */
/* This routine is for - WIRELOGIC netName MAXDIST distance */
extern int defwConstraintWiredlogic(const char* netName,
int distance);
extern int defwEndConstraints ();
/* Routines to enter groups. This section is optional
* The section must start with a defwStartGroups() call and
* end with a defwEndGroups() call.
* Each group will call the defwGroup...(). */
extern int defwStartGroups (int count); /* optional */
/* This routine is for - groupName compNameRegExpr ... */
extern int defwGroup(const char* groupName,
int numExpr,
const char** groupExpr);
/* This routine is for + SOFT [MAXHALFPERIMETER value] [MAXX value]
* [MAXY value] */
extern int defwGroupSoft(const char* type1, /* MAXHALFPERIMETER | MAXX | MAXY */
double value1,
const char* type2,
double value2,
const char* type3,
double value3);
/* This routine is for + REGION {pt pt | regionName} */
extern int defwGroupRegion(int xl, int yl, /* either the x & y or */
int xh, int yh, /* regionName only, can't */
const char* regionName); /* be both */
extern int defwEndGroups();
/* Routines to enter Blockages. This section is optional
* The section must start with a defwStartBlockages() call and
* end with a defwEndBlockages() call.
* Each blockage will call the defwBlockages...().
* This is a 5.4 syntax. */
extern int defwStartBlockages(int count); /* count = numBlockages */
/* This routine is for - layerName
* This routine is called per entry within a blockage for layer.
* This is a 5.4 syntax. */
extern int defwBlockagesLayer(const char* layerName);
/* This routine is for - slots
* This routine is called per entry within a blockage layer, can't be more then one.
* This is a 5.4 syntax. */
extern int defwBlockagesLayerSlots();
/* This routine is for - fills
* This routine is called per entry within a blockage layer, can't be more then one.
* This is a 5.4 syntax. */
extern int defwBlockagesLayerFills();
/* This routine is for - pushdown
* This routine is called per entry within a blockage layer, can't be more then one.
* This is a 5.4 syntax. */
extern int defwBlockagesLayerPushdown();
/* This routine is for - exceptpgnet
* This routine is called per entry within a blockage layer, can't be more then one.
* This is a 5.7 syntax. */
extern int defwBlockagesLayerExceptpgnet();
/* This routine is for - component
* This routine called per entry within a blockage layer, can't be more than one.
* This is a 5.6 syntax. */
extern int defwBlockagesLayerComponent(const char* compName);
/* This routine is for - spacing
* Either this routine or defwBlockagesDesignRuleWidth is called per entry
* within a blockage layer, can't be more than one.
* This is a 5.6 syntax. */
extern int defwBlockagesLayerSpacing(int minSpacing);
/* This routine is for - designrulewidth
* Either this routine or defwBlockagesSpacing is called per entry
* within a blockage layer, can't be more than one.
* This is a 5.6 syntax. */
extern int defwBlockagesLayerDesignRuleWidth(int effectiveWidth);
/* This routine is for - mask.
* This routine called per entry within a blockage layer, can't be more than one.
* This is a 5.8 syntax. */
extern int defwBlockagesLayerMask(int maskColor);
/* This routine is for - layerName & compName
* Either this routine, defBlockageLayerSlots, defBlockageLayerFills,
* or defwBlockagePlacement is called per entry within
* a blockage, can't be more then one.
* This is a 5.4 syntax. */
extern int defwBlockageLayer(const char* layerName,
const char* compName); /* optional(NULL) */
/* This routine is for - layerName & slots
* Either this routine, defBlockageLayer, defBlockageLayerFills,
* defwBlockagePlacement, or defwBlockagePushdown is called per entry within
* a blockage, can't be more then one.
* This is a 5.4 syntax. */
extern int defwBlockageLayerSlots(const char* layerName);
/* This routine is for - layerName & fills
* Either this routine, defBlockageLayer, defBlockageLayerSlots,
* defwBlockagePlacement, or defwBlockagePushdown is called per entry within
* a blockage, can't be more then one.
* This is a 5.4 syntax. */
extern int defwBlockageLayerFills(const char* layerName);
/* This routine is for - layerName & pushdown
* Either this routine, defBlockageLayer, defBlockageLayerSlots,
* defwBlockagePlacement, or defwBlockageFills is called per entry within
* a blockage, can't be more then one.
* This is a 5.4 syntax. */
extern int defwBlockageLayerPushdown(const char* layerName);
/* This routine is for - exceptpgnet
* Either this routine, defBlockageLayer, defBlockageLayerSlots,
* defwBlockagePlacement, or defwBlockageFills is called per entry within
* a blockage, can't be more then one.
* This is a 5.7 syntax. */
extern int defwBlockageLayerExceptpgnet(const char* layerName);
/* This routine is for - spacing
* Either this routine or defwBlockageDesignRuleWidth is called per entry
* within a blockage, can't be more than one.
* This is a 5.6 syntax. */
extern int defwBlockageSpacing(int minSpacing);
/* This routine is for - designrulewidth
* Either this routine or defwBlockageSpacing is called per entry
* within a blockage, can't be more than one.
* This is a 5.6 syntax. */
extern int defwBlockageDesignRuleWidth(int effectiveWidth);
/* This routine is for - placement
* This routine is called per entry within blockage for placement.
* This is a 5.4 syntax.
* 11/25/2002 - bug fix: submitted by Craig Files (cfiles@ftc.agilent.com)
* this routine allows to call blockage without a component. */
extern int defwBlockagesPlacement();
/* This routine is for - component
* This routine is called per entry within blockage placement, can't be more then one.
* This is a 5.4 syntax. */
extern int defwBlockagesPlacementComponent(const char* compName);
/* This routine is for - Pushdown
* This routine is called per entry within blockage placement, can't be more then one.
* This is a 5.4 syntax. */
extern int defwBlockagesPlacementPushdown();
/* This routine is for - soft
* Either this routine or defwBlockagesPlacementPartial
* is called per entry within blockage placement, can't be more then one.
* This is a 5.7 syntax. */
extern int defwBlockagesPlacementSoft();
/* This routine is for - Partial
* Either this routine or defwBlockagesPlacementSoft
* is called per entry within blockage placement, can't be more then one.
* This is a 5.7 syntax. */
extern int defwBlockagesPlacementPartial(double maxDensity);
/* This routine is for rectangle.
* This routine is optional and can be called multiple time.
* This is a 5.4 syntax. */
extern int defwBlockagesRect(int xl, int yl, int xh, int yh);
/* This routine is for polygon.
* This routine is optional and can be called multiple time.
* This is a 5.6 syntax. */
extern int defwBlockagesPolygon(int num_polys, int* xl, int* yl);
/* This routine is for - placement
* Either this routine or defBlockageLayer
* is called per entry within blockage, can't be more then one.
* This is a 5.4 syntax.
* 11/25/2002 - bug fix: submitted by Craig Files (cfiles@ftc.agilent.com)
* this routine allows to call blockage without a component. */
extern int defwBlockagePlacement();
/* This routine is for - placement & component
* Either this routine or defwBlockagePlacementPushdown
* is called per entry within blockage, can't be more then one.
* This is a 5.4 syntax. */
extern int defwBlockagePlacementComponent(const char* compName);
/* This routine is for - placement & Pushdown
* Either this routine or defwBlockagePlacementComponent
* is called per entry within blockage, can't be more then one.
* This is a 5.4 syntax. */
extern int defwBlockagePlacementPushdown();
/* This routine is for - placement & soft
* Either this routine or defwBlockagePlacementPushdown
* is called per entry within blockage, can't be more then one.
* This is a 5.7 syntax. */
extern int defwBlockagePlacementSoft();
/* This routine is for - placement & Partial
* Either this routine or defwBlockagePlacementComponent
* is called per entry within blockage, can't be more then one.
* This is a 5.7 syntax. */
extern int defwBlockagePlacementPartial(double maxDensity);
/* This routine is optional.
* This is a 5.8 syntax. */
extern int defwBlockageMask(int maskColor);
/* This routine is for rectangle.
* This is a 5.4 syntax. */
extern int defwBlockageRect(int xl, int yl, int xh, int yh);
/* This routine is for polygon.
* This routine is optinal and can be called multiple time.
* This is a 5.6 syntax. */
extern int defwBlockagePolygon(int num_polys, int* xl, int* yl);
/* This is a 5.4 syntax. */
extern int defwEndBlockages();
/* Routines to enter Slots. This section is optional
* The section must start with a defwStartSlots() call and
* end with a defwEndSlots() call.
* Each slots will call the defwSlots...().
* This is a 5.4 syntax. */
extern int defwStartSlots(int count); /* count = numSlots */
/* This routine is for - layerName & compName
* Either this routine, defSlots, defSlotsLayerFills,
* or defwSlotsPlacement is called per entry within
* a slot, can't be more then one.
* This is a 5.4 syntax. */
extern int defwSlotLayer(const char* layerName);
/* This routine is for rectangle
* This is a 5.4 syntax. */
extern int defwSlotRect(int xl, int yl, int xh, int yh);
/* This routine is for rectangle
* This is a 5.6 syntax and can be called multiple time. */
extern int defwSlotPolygon(int num_polys, double* xl, double* yl);
/* This is a 5.4 syntax. */
extern int defwEndSlots();
/* Routines to enter Fills. This section is optional
* The section must start with a defwStartFills() call and
* end with a defwEndFills() call.
* Each fills will call the defwFills...().
* This is a 5.4 syntax. */
extern int defwStartFills(int count); /* count = numFills */
/* This routine is for - layerName & compName
* Either this routine, defFills, defFillsLayerFills,
* or defwFillsPlacement is called per entry within
* a fill, can't be more then one.
* This is a 5.4 syntax. */
extern int defwFillLayer(const char* layerName);
/* This routine is optional.
* This is a 5.8 syntax. */
extern int defwFillLayerMask(int maskColor);
/* This routine has to be called after defwFillLayer
* This routine is optional.
* This is a 5.7 syntax. */
extern int defwFillLayerOPC();
/* This routine is for rectangle.
* This is a 5.4 syntax. */
extern int defwFillRect(int xl, int yl, int xh, int yh);
/* This routine is for polygon.
* This is a 5.6 syntax and can be called multiple time. */
extern int defwFillPolygon(int num_polys, double* xl, double* yl);
/* This routine is for via.
* This routine is optional.
* This is a 5.7 syntax and can be called multiple time. */
extern int defwFillVia(const char* viaName);
/* This routine is optional.
* This is a 5.8 syntax. */
extern int defwFillViaMask(int colorMask);
/* This routine is for via OPC.
* This routine can only be called after defwFillVia.
* This routine is optional.
* This is a 5.7 syntax and can be called multiple time. */
extern int defwFillViaOPC();
/* This routine is for via OPC.
* This routine can only be called after defwFillVia.
* This routine is required following defwFillVia.
* This is a 5.7 syntax and can be called multiple time. */
extern int defwFillPoints(int num_points, double* xl, double* yl);
/* This is a 5.4 syntax. */
extern int defwEndFills();
/* Routines to enter NONDEFAULTRULES. This section is required
* The section must start with a defwStartNonDefaultRules() and
* end with defwEndNonDefaultRules() call.
* This is a 5.6 syntax. */
extern int defwStartNonDefaultRules(int count);
/* This routine is for Layer within the NONDEFAULTRULES
* This routine can be called multiple times. It is required.
* This is a 5.6 syntax.
* Returns 0 if successful. */
extern int defwNonDefaultRule(const char* ruleName,
int hardSpacing); /* optional(0) */
/* Routines to enter NONDEFAULTRULES. This section is required
* This routine must be called after the defwNonDefaultRule.
* This routine can be called multiple times.
* This is a 5.6 syntax.
* Returns 0 if successful. */
extern int defwNonDefaultRuleLayer(const char* layerName,
int width,
int diagWidth, /* optional(0) */
int spacing, /* optional(0) */
int wireExt); /* optional(0) */
/* Routines to enter NONDEFAULTRULES. This section is optional.
* This routine must be called after the defwNonDefaultRule.
* This routine can be called multiple times.
* This is a 5.6 syntax.
* Returns 0 if successful. */
extern int defwNonDefaultRuleVia(const char* viaName);
/* Routines to enter NONDEFAULTRULES. This section is optional.
* This routine must be called after the defwNonDefaultRule.
* This routine can be called multiple times.
* This is a 5.6 syntax.
* Returns 0 if successful. */
extern int defwNonDefaultRuleViaRule(const char* viaRuleName);
/* Routines to enter NONDEFAULTRULES. This section is optional.
* This routine must be called after the defwNonDefaultRule.
* This routine can be called multiple times.
* This is a 5.6 syntax.
* Returns 0 if successful. */
extern int defwNonDefaultRuleMinCuts(const char* cutLayerName, int numCutS);
/* This is a 5.4 syntax. */
extern int defwEndNonDefaultRules();
/* Routines to enter STYLES. This section is required
* The section must start with a defwStartStyles() and
* end with defwEndStyles() call.
* This is a 5.6 syntax. */
extern int defwStartStyles(int count);
/* This routine is for Layer within the NONDEFAULTRULES
* This routine can be called multiple times. It is required.
* This is a 5.6 syntax.
* Returns 0 if successful. */
extern int defwStyles(int styleNums, int num_points, double* xp, double* yp);
/* This is a 5.4 syntax. */
extern int defwEndStyles();
/* This routine is called after defwInit.
* This routine is optional and it can be called only once.
* Returns 0 if successful. */
extern int defwStartBeginext(const char* name);
/* This routine is called after defwBeginext.
* This routine is optional, it can be called only once.
* Returns 0 if successful. */
extern int defwBeginextCreator (const char* creatorName);
/* This routine is called after defwBeginext.
* This routine is optional, it can be called only once.
* It gets the current system time and date.
* Returns 0 if successful. */
extern int defwBeginextDate ();
/* This routine is called after defwBeginext.
* This routine is optional, it can be called only once.
* Returns 0 if successful. */
extern int defwBeginextRevision (int vers1, int vers2); /* vers1.vers2 */
/* This routine is called after defwBeginext.
* This routine is optional, it can be called many times.
* It allows user to customize their own syntax.
* Returns 0 if successful. */
extern int defwBeginextSyntax (const char* title, const char* string);
/* This routine is called after defwInit.
* This routine is optional and it can be called only once.
* Returns 0 if successful. */
extern int defwEndBeginext();
/* End the DEF file.
* This routine IS NOT OPTIONAL.
* The routine must be called LAST. */
extern int defwEnd ( void );
/* General routines that can be called anytime after the Init is called.
*/
extern int defwCurrentLineNumber ( void );
/*
* extern void defwError ( const char *, ... );
* extern void defwWarning ( const char *, ... );
* extern void defwVError ( const char *, va_list );
* extern void defwVWarning ( const char *, va_list );
* extern int defwGetCurrentLineNumber (void);
* extern const char *defwGetCurrentFileName (void);
*/
/* This routine will print the error message. */
extern void defwPrintError(int status);
/* This routine will allow user to write their own comemnt. It will
* automactically add a # infront of the line.
*/
extern void defwAddComment(const char* comment);
/* This routine will indent 3 blank spaces */
extern void defwAddIndent();
END_LEFDEF_PARSER_NAMESPACE
USE_LEFDEF_PARSER_NAMESPACE
#endif
Reference in New Issue Copy Permalink