940 lines
25 KiB
C++
940 lines
25 KiB
C++
// *****************************************************************************
|
|
// *****************************************************************************
|
|
// Copyright 2012 - 2017, 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 lefiMacro_h
|
|
#define lefiMacro_h
|
|
|
|
#include <stdio.h>
|
|
#include "lefiKRDefs.hpp"
|
|
#include "lefiMisc.hpp"
|
|
|
|
BEGIN_LEFDEF_PARSER_NAMESPACE
|
|
|
|
class lefiObstruction {
|
|
public:
|
|
lefiObstruction();
|
|
void Init();
|
|
|
|
void Destroy();
|
|
~lefiObstruction();
|
|
|
|
void clear();
|
|
void setGeometries(lefiGeometries* g);
|
|
|
|
lefiGeometries* geometries() const;
|
|
|
|
void print(FILE* f) const;
|
|
|
|
protected:
|
|
|
|
lefiGeometries* geometries_;
|
|
};
|
|
|
|
// 5.5
|
|
class lefiPinAntennaModel {
|
|
public:
|
|
lefiPinAntennaModel();
|
|
~lefiPinAntennaModel();
|
|
|
|
void Init();
|
|
void clear();
|
|
void Destroy();
|
|
|
|
void setAntennaModel(int oxide);
|
|
void addAntennaGateArea(double value, const char* layer);
|
|
void addAntennaMaxAreaCar(double value, const char* layer);
|
|
void addAntennaMaxSideAreaCar(double value, const char* layer);
|
|
void addAntennaMaxCutCar(double value, const char* layer);
|
|
void setAntennaReturnFlag(int flag);
|
|
|
|
int hasAntennaGateArea() const;
|
|
int hasAntennaMaxAreaCar() const;
|
|
int hasAntennaMaxSideAreaCar() const;
|
|
int hasAntennaMaxCutCar() const;
|
|
|
|
char* antennaOxide() const;
|
|
|
|
int numAntennaGateArea() const;
|
|
double antennaGateArea(int index) const;
|
|
const char* antennaGateAreaLayer(int index) const;
|
|
|
|
int numAntennaMaxAreaCar() const;
|
|
double antennaMaxAreaCar(int index) const;
|
|
const char* antennaMaxAreaCarLayer(int index) const;
|
|
|
|
int numAntennaMaxSideAreaCar() const;
|
|
double antennaMaxSideAreaCar(int index) const;
|
|
const char* antennaMaxSideAreaCarLayer(int index) const;
|
|
|
|
int numAntennaMaxCutCar() const;
|
|
double antennaMaxCutCar(int index) const;
|
|
const char* antennaMaxCutCarLayer(int index) const;
|
|
|
|
int hasReturn() const;
|
|
|
|
protected:
|
|
char* oxide_;
|
|
int hasReturn_;
|
|
|
|
int numAntennaGateArea_;
|
|
int antennaGateAreaAllocated_;
|
|
double* antennaGateArea_;
|
|
char** antennaGateAreaLayer_;
|
|
|
|
int numAntennaMaxAreaCar_;
|
|
int antennaMaxAreaCarAllocated_;
|
|
double* antennaMaxAreaCar_;
|
|
char** antennaMaxAreaCarLayer_;
|
|
|
|
int numAntennaMaxSideAreaCar_;
|
|
int antennaMaxSideAreaCarAllocated_;
|
|
double* antennaMaxSideAreaCar_;
|
|
char** antennaMaxSideAreaCarLayer_;
|
|
|
|
int numAntennaMaxCutCar_;
|
|
int antennaMaxCutCarAllocated_;
|
|
double* antennaMaxCutCar_;
|
|
char** antennaMaxCutCarLayer_;
|
|
};
|
|
|
|
class lefiPin {
|
|
public:
|
|
lefiPin();
|
|
void Init();
|
|
|
|
void Destroy();
|
|
~lefiPin();
|
|
|
|
void clear();
|
|
void bump(char** array, int len, int* size);
|
|
void setName(const char* name);
|
|
void addPort(lefiGeometries* g);
|
|
void addForeign(const char* name, int hasPnt, double x, double y, int orient);
|
|
void setLEQ(const char* name);
|
|
void setDirection(const char* name);
|
|
void setUse(const char* name);
|
|
void setShape(const char* name);
|
|
void setMustjoin(const char* name);
|
|
void setOutMargin(double high, double low);
|
|
void setOutResistance(double high, double low);
|
|
void setInMargin(double high, double low);
|
|
void setPower(double power);
|
|
void setLeakage(double current);
|
|
void setMaxload(double capacitance);
|
|
void setMaxdelay(double delayTime);
|
|
void setCapacitance(double capacitance);
|
|
void setResistance(double resistance);
|
|
void setPulldownres(double resistance);
|
|
void setTieoffr(double resistance);
|
|
void setVHI(double voltage);
|
|
void setVLO(double voltage);
|
|
void setRiseVoltage(double voltage);
|
|
void setFallVoltage(double voltage);
|
|
void setRiseThresh(double capacitance);
|
|
void setFallThresh(double capacitance);
|
|
void setRiseSatcur(double current);
|
|
void setFallSatcur(double current);
|
|
void setCurrentSource(const char* name);
|
|
void setTables(const char* highName, const char* lowName);
|
|
void setProperty(const char* name, const char* value, const char type);
|
|
void setNumProperty(const char* name, double d, const char* value,
|
|
const char type);
|
|
void addAntennaModel(int oxide); // 5.5
|
|
void addAntennaSize(double value, const char* layer);
|
|
void addAntennaMetalArea(double value, const char* layer);
|
|
void addAntennaMetalLength(double value, const char* layer);
|
|
void addAntennaPartialMetalArea(double value, const char* layer);
|
|
void addAntennaPartialMetalSideArea(double value, const char* layer);
|
|
void addAntennaGateArea(double value, const char* layer);
|
|
void addAntennaDiffArea(double value, const char* layer);
|
|
void addAntennaMaxAreaCar(double value, const char* layer);
|
|
void addAntennaMaxSideAreaCar(double value, const char* layer);
|
|
void addAntennaPartialCutArea(double value, const char* layer);
|
|
void addAntennaMaxCutCar(double value, const char* layer);
|
|
void setRiseSlewLimit(double value);
|
|
void setFallSlewLimit(double value);
|
|
void setTaperRule(const char* name);
|
|
void setNetExpr(const char* name); // 5.6
|
|
void setSupplySensitivity(const char* pinName); // 5.6
|
|
void setGroundSensitivity(const char* pinName); // 5.6
|
|
void bumpProps();
|
|
|
|
int hasForeign() const;
|
|
int hasForeignOrient(int index = 0) const;
|
|
int hasForeignPoint(int index = 0) const;
|
|
int hasLEQ() const;
|
|
int hasDirection() const;
|
|
int hasUse() const;
|
|
int hasShape() const;
|
|
int hasMustjoin() const;
|
|
int hasOutMargin() const;
|
|
int hasOutResistance() const;
|
|
int hasInMargin() const;
|
|
int hasPower() const;
|
|
int hasLeakage() const;
|
|
int hasMaxload() const;
|
|
int hasMaxdelay() const;
|
|
int hasCapacitance() const;
|
|
int hasResistance() const;
|
|
int hasPulldownres() const;
|
|
int hasTieoffr() const;
|
|
int hasVHI() const;
|
|
int hasVLO() const;
|
|
int hasRiseVoltage() const;
|
|
int hasFallVoltage() const;
|
|
int hasRiseThresh() const;
|
|
int hasFallThresh() const;
|
|
int hasRiseSatcur() const;
|
|
int hasFallSatcur() const;
|
|
int hasCurrentSource() const;
|
|
int hasTables() const;
|
|
int hasAntennaSize() const;
|
|
int hasAntennaMetalArea() const;
|
|
int hasAntennaMetalLength() const;
|
|
int hasAntennaPartialMetalArea() const;
|
|
int hasAntennaPartialMetalSideArea() const;
|
|
int hasAntennaPartialCutArea() const;
|
|
int hasAntennaDiffArea() const;
|
|
int hasAntennaModel() const; // 5.5
|
|
int hasTaperRule() const;
|
|
int hasRiseSlewLimit() const;
|
|
int hasFallSlewLimit() const;
|
|
int hasNetExpr() const; // 5.6
|
|
int hasSupplySensitivity() const; // 5.6
|
|
int hasGroundSensitivity() const; // 5.6
|
|
|
|
const char* name() const;
|
|
|
|
int numPorts() const;
|
|
lefiGeometries* port(int index) const;
|
|
|
|
int numForeigns() const;
|
|
const char* foreignName(int index = 0) const;
|
|
const char* taperRule() const;
|
|
int foreignOrient(int index = 0) const;
|
|
const char* foreignOrientStr(int index = 0) const;
|
|
double foreignX(int index = 0) const;
|
|
double foreignY(int index = 0) const;
|
|
const char* LEQ() const;
|
|
const char* direction() const;
|
|
const char* use() const;
|
|
const char* shape() const;
|
|
const char* mustjoin() const;
|
|
double outMarginHigh() const;
|
|
double outMarginLow() const;
|
|
double outResistanceHigh() const;
|
|
double outResistanceLow() const;
|
|
double inMarginHigh() const;
|
|
double inMarginLow() const;
|
|
double power() const;
|
|
double leakage() const;
|
|
double maxload() const;
|
|
double maxdelay() const;
|
|
double capacitance() const;
|
|
double resistance() const;
|
|
double pulldownres() const;
|
|
double tieoffr() const;
|
|
double VHI() const;
|
|
double VLO() const;
|
|
double riseVoltage() const;
|
|
double fallVoltage() const;
|
|
double riseThresh() const;
|
|
double fallThresh() const;
|
|
double riseSatcur() const;
|
|
double fallSatcur() const;
|
|
double riseSlewLimit() const;
|
|
double fallSlewLimit() const;
|
|
const char* currentSource() const;
|
|
const char* tableHighName() const;
|
|
const char* tableLowName() const;
|
|
|
|
int numAntennaSize() const;
|
|
double antennaSize(int index) const;
|
|
const char* antennaSizeLayer(int index) const;
|
|
|
|
int numAntennaMetalArea() const;
|
|
double antennaMetalArea(int index) const;
|
|
const char* antennaMetalAreaLayer(int index) const;
|
|
|
|
int numAntennaMetalLength() const;
|
|
double antennaMetalLength(int index) const;
|
|
const char* antennaMetalLengthLayer(int index) const;
|
|
|
|
int numAntennaPartialMetalArea() const;
|
|
double antennaPartialMetalArea(int index) const;
|
|
const char* antennaPartialMetalAreaLayer(int index) const;
|
|
|
|
int numAntennaPartialMetalSideArea() const;
|
|
double antennaPartialMetalSideArea(int index) const;
|
|
const char* antennaPartialMetalSideAreaLayer(int index) const;
|
|
|
|
int numAntennaPartialCutArea() const;
|
|
double antennaPartialCutArea(int index) const;
|
|
const char* antennaPartialCutAreaLayer(int index) const;
|
|
|
|
int numAntennaDiffArea() const;
|
|
double antennaDiffArea(int index) const;
|
|
const char* antennaDiffAreaLayer(int index) const;
|
|
|
|
// 5.6
|
|
const char* netExpr() const;
|
|
const char* supplySensitivity() const;
|
|
const char* groundSensitivity() const;
|
|
|
|
// 5.5
|
|
int numAntennaModel() const;
|
|
lefiPinAntennaModel* antennaModel(int index) const;
|
|
|
|
int numProperties() const;
|
|
const char* propName(int index) const;
|
|
const char* propValue(int index) const;
|
|
double propNum(int index) const;
|
|
const char propType(int index) const;
|
|
int propIsNumber(int index) const;
|
|
int propIsString(int index) const;
|
|
|
|
void print(FILE* f) const ;
|
|
|
|
protected:
|
|
int nameSize_;
|
|
char* name_;
|
|
|
|
char hasLEQ_;
|
|
char hasDirection_;
|
|
char hasUse_;
|
|
char hasShape_;
|
|
char hasMustjoin_;
|
|
char hasOutMargin_;
|
|
char hasOutResistance_;
|
|
char hasInMargin_;
|
|
char hasPower_;
|
|
char hasLeakage_;
|
|
char hasMaxload_;
|
|
char hasMaxdelay_;
|
|
char hasCapacitance_;
|
|
char hasResistance_;
|
|
char hasPulldownres_;
|
|
char hasTieoffr_;
|
|
char hasVHI_;
|
|
char hasVLO_;
|
|
char hasRiseVoltage_;
|
|
char hasFallVoltage_;
|
|
char hasRiseThresh_;
|
|
char hasFallThresh_;
|
|
char hasRiseSatcur_;
|
|
char hasFallSatcur_;
|
|
char hasCurrentSource_;
|
|
char hasTables_;
|
|
char hasAntennasize_;
|
|
char hasRiseSlewLimit_;
|
|
char hasFallSlewLimit_;
|
|
|
|
int numForeigns_;
|
|
int foreignAllocated_;
|
|
int* hasForeignOrient_;
|
|
int* hasForeignPoint_;
|
|
int* foreignOrient_;
|
|
double* foreignX_;
|
|
double* foreignY_;
|
|
char** foreign_;
|
|
|
|
int LEQSize_;
|
|
char* LEQ_;
|
|
int mustjoinSize_;
|
|
char* mustjoin_;
|
|
double outMarginH_;
|
|
double outMarginL_;
|
|
double outResistanceH_;
|
|
double outResistanceL_;
|
|
double inMarginH_;
|
|
double inMarginL_;
|
|
double power_;
|
|
double leakage_;
|
|
double maxload_;
|
|
double maxdelay_;
|
|
double capacitance_;
|
|
double resistance_;
|
|
double pulldownres_;
|
|
double tieoffr_;
|
|
double VHI_;
|
|
double VLO_;
|
|
double riseVoltage_;
|
|
double fallVoltage_;
|
|
double riseThresh_;
|
|
double fallThresh_;
|
|
double riseSatcur_;
|
|
double fallSatcur_;
|
|
int lowTableSize_;
|
|
char* lowTable_;
|
|
int highTableSize_;
|
|
char* highTable_;
|
|
double riseSlewLimit_;
|
|
double fallSlewLimit_;
|
|
|
|
// 5.5 AntennaModel
|
|
int numAntennaModel_;
|
|
int antennaModelAllocated_;
|
|
int curAntennaModelIndex_; // save the current index of the antenna
|
|
lefiPinAntennaModel** antennaModel_;
|
|
|
|
int numAntennaSize_;
|
|
int antennaSizeAllocated_;
|
|
double* antennaSize_;
|
|
char** antennaSizeLayer_;
|
|
|
|
int numAntennaMetalArea_;
|
|
int antennaMetalAreaAllocated_;
|
|
double* antennaMetalArea_;
|
|
char** antennaMetalAreaLayer_;
|
|
|
|
int numAntennaMetalLength_;
|
|
int antennaMetalLengthAllocated_;
|
|
double* antennaMetalLength_;
|
|
char** antennaMetalLengthLayer_;
|
|
|
|
int numAntennaPartialMetalArea_;
|
|
int antennaPartialMetalAreaAllocated_;
|
|
double* antennaPartialMetalArea_;
|
|
char** antennaPartialMetalAreaLayer_;
|
|
|
|
int numAntennaPartialMetalSideArea_;
|
|
int antennaPartialMetalSideAreaAllocated_;
|
|
double* antennaPartialMetalSideArea_;
|
|
char** antennaPartialMetalSideAreaLayer_;
|
|
|
|
int numAntennaPartialCutArea_;
|
|
int antennaPartialCutAreaAllocated_;
|
|
double* antennaPartialCutArea_;
|
|
char** antennaPartialCutAreaLayer_;
|
|
|
|
int numAntennaDiffArea_;
|
|
int antennaDiffAreaAllocated_;
|
|
double* antennaDiffArea_;
|
|
char** antennaDiffAreaLayer_;
|
|
|
|
char* taperRule_;
|
|
|
|
char* netEpxr_;
|
|
char* ssPinName_;
|
|
char* gsPinName_;
|
|
|
|
char direction_[32];
|
|
char use_[12];
|
|
char shape_[12];
|
|
char currentSource_[12];
|
|
|
|
int numProperties_;
|
|
int propertiesAllocated_;
|
|
char** propNames_;
|
|
char** propValues_;
|
|
double* propNums_;
|
|
char* propTypes_;
|
|
|
|
int numPorts_;
|
|
int portsAllocated_;
|
|
lefiGeometries** ports_;
|
|
};
|
|
|
|
// 5.6
|
|
class lefiDensity {
|
|
public:
|
|
lefiDensity();
|
|
void Init();
|
|
|
|
void Destroy();
|
|
~lefiDensity();
|
|
|
|
void clear();
|
|
void addLayer(const char* name);
|
|
void addRect(double x1, double y1, double x2, double y2, double value);
|
|
|
|
int numLayer() const;
|
|
char* layerName(int index) const;
|
|
int numRects(int index) const;
|
|
lefiGeomRect getRect(int index, int rectIndex) const;
|
|
double densityValue(int index, int rectIndex) const;
|
|
|
|
void print(FILE* f) const;
|
|
|
|
protected:
|
|
int numLayers_;
|
|
int layersAllocated_;
|
|
char** layerName_;
|
|
int* numRects_;
|
|
int* rectsAllocated_;
|
|
struct lefiGeomRect** rects_;
|
|
double** densityValue_;
|
|
};
|
|
|
|
class lefiMacro {
|
|
public:
|
|
lefiMacro();
|
|
void Init();
|
|
|
|
void Destroy();
|
|
~lefiMacro();
|
|
|
|
void clear();
|
|
void bump(char** array, int len, int* size);
|
|
void setName(const char* name);
|
|
void setGenerator(const char* name);
|
|
void setGenerate(const char* name1, const char* name2);
|
|
void setPower(double d);
|
|
void setOrigin(double x, double y);
|
|
void setClass(const char* name);
|
|
void setSource(const char* name);
|
|
void setEEQ(const char* name);
|
|
void setLEQ(const char* name);
|
|
void setClockType(const char* name);
|
|
void setProperty(const char* name, const char* value, const char type);
|
|
void setNumProperty(const char* name, double d, const char* value,
|
|
const char type);
|
|
void bumpProps();
|
|
|
|
// orient=-1 means no orient was specified.
|
|
void addForeign(const char* name, int hasPnt,
|
|
double x, double y, int orient);
|
|
|
|
void setXSymmetry();
|
|
void setYSymmetry();
|
|
void set90Symmetry();
|
|
void setSiteName(const char* name);
|
|
void setSitePattern(lefiSitePattern* p);
|
|
void setSize(double x, double y);
|
|
void setBuffer();
|
|
void setInverter();
|
|
void setFixedMask(int isFixedMask = 0);
|
|
|
|
int hasClass() const;
|
|
int hasGenerator() const;
|
|
int hasGenerate() const;
|
|
int hasPower() const;
|
|
int hasOrigin() const;
|
|
int hasEEQ() const;
|
|
int hasLEQ() const;
|
|
int hasSource() const;
|
|
int hasXSymmetry() const;
|
|
int hasYSymmetry() const;
|
|
int has90Symmetry() const;
|
|
int hasSiteName() const;
|
|
int hasSitePattern() const;
|
|
int hasSize() const;
|
|
int hasForeign() const;
|
|
int hasForeignOrigin(int index = 0) const;
|
|
int hasForeignOrient(int index = 0) const;
|
|
int hasForeignPoint(int index = 0) const;
|
|
int hasClockType() const;
|
|
int isBuffer() const;
|
|
int isInverter() const;
|
|
int isFixedMask() const;
|
|
|
|
int numSitePattern() const;
|
|
int numProperties() const;
|
|
const char* propName(int index) const;
|
|
const char* propValue(int index) const;
|
|
double propNum(int index) const;
|
|
const char propType(int index) const;
|
|
int propIsNumber(int index) const;
|
|
int propIsString(int index) const;
|
|
|
|
const char* name() const;
|
|
const char* macroClass() const;
|
|
const char* generator() const;
|
|
const char* EEQ() const;
|
|
const char* LEQ() const;
|
|
const char* source() const;
|
|
const char* clockType() const;
|
|
double originX() const;
|
|
double originY() const;
|
|
double power() const;
|
|
void generate(char** name1, char** name2) const;
|
|
lefiSitePattern* sitePattern(int index) const;
|
|
const char* siteName() const;
|
|
double sizeX() const;
|
|
double sizeY() const;
|
|
int numForeigns() const;
|
|
int foreignOrient(int index = 0) const;
|
|
const char* foreignOrientStr(int index = 0) const;
|
|
double foreignX(int index = 0) const;
|
|
double foreignY(int index = 0) const;
|
|
const char* foreignName(int index = 0) const;
|
|
|
|
// Debug print
|
|
void print(FILE* f) const;
|
|
|
|
protected:
|
|
int nameSize_;
|
|
char* name_;
|
|
char macroClass_[32];
|
|
char source_[12];
|
|
|
|
int generatorSize_;
|
|
char* generator_;
|
|
|
|
char hasClass_;
|
|
char hasGenerator_;
|
|
char hasGenerate_;
|
|
char hasPower_;
|
|
char hasOrigin_;
|
|
char hasSource_;
|
|
char hasEEQ_;
|
|
char hasLEQ_;
|
|
char hasSymmetry_; // X=1 Y=2 R90=4 (can be combined)
|
|
char hasSiteName_;
|
|
char hasSize_;
|
|
char hasClockType_;
|
|
char isBuffer_;
|
|
char isInverter_;
|
|
|
|
char* EEQ_;
|
|
int EEQSize_;
|
|
char* LEQ_;
|
|
int LEQSize_;
|
|
char* gen1_;
|
|
int gen1Size_;
|
|
char* gen2_;
|
|
int gen2Size_;
|
|
double power_;
|
|
double originX_;
|
|
double originY_;
|
|
double sizeX_;
|
|
double sizeY_;
|
|
|
|
int numSites_;
|
|
int sitesAllocated_;
|
|
lefiSitePattern** pattern_;
|
|
|
|
int numForeigns_;
|
|
int foreignAllocated_;
|
|
int* hasForeignOrigin_;
|
|
int* hasForeignPoint_;
|
|
int* foreignOrient_;
|
|
double* foreignX_;
|
|
double* foreignY_;
|
|
char** foreign_;
|
|
|
|
int siteNameSize_;
|
|
char* siteName_;
|
|
|
|
char* clockType_;
|
|
int clockTypeSize_;
|
|
|
|
int numProperties_;
|
|
int propertiesAllocated_;
|
|
char** propNames_;
|
|
char** propValues_;
|
|
double* propNums_;
|
|
char* propTypes_;
|
|
|
|
int isFixedMask_;
|
|
};
|
|
|
|
class lefiTiming {
|
|
public:
|
|
lefiTiming();
|
|
void Init();
|
|
|
|
void Destroy();
|
|
~lefiTiming();
|
|
|
|
void addRiseFall(const char* risefall, double one, double two);
|
|
void addRiseFallVariable(double one, double two);
|
|
void addRiseFallSlew(double one, double two, double three, double four);
|
|
void addRiseFallSlew2(double one, double two, double three);
|
|
void setRiseRS(double one, double two);
|
|
void setFallRS(double one, double two);
|
|
void setRiseCS(double one, double two);
|
|
void setFallCS(double one, double two);
|
|
void setRiseAtt1(double one, double two);
|
|
void setFallAtt1(double one, double two);
|
|
void setRiseTo(double one, double two);
|
|
void setFallTo(double one, double two);
|
|
void addUnateness(const char* typ);
|
|
void setStable(double one, double two, const char* typ);
|
|
void addTableEntry(double one, double two, double three);
|
|
void addTableAxisNumber(double one);
|
|
void addFromPin(const char* name);
|
|
void addToPin(const char* name);
|
|
void addDelay(const char* risefall, const char* unateness, double one,
|
|
double two, double three);
|
|
void addTransition(const char* risefall, const char* unateness, double one,
|
|
double two, double three);
|
|
// addSDF2Pins & addSDF1Pin are for 5.1
|
|
void addSDF2Pins(const char* trigType, const char* fromTrig,
|
|
const char* toTrig, double one, double two, double three);
|
|
void addSDF1Pin(const char* trigType, double one, double two, double three);
|
|
void setSDFcondStart(const char* condStart);
|
|
void setSDFcondEnd(const char* condEnd);
|
|
void setSDFcond(const char* cond);
|
|
int hasData();
|
|
void clear();
|
|
|
|
int numFromPins();
|
|
const char* fromPin(int index);
|
|
int numToPins();
|
|
const char* toPin(int index);
|
|
int hasTransition();
|
|
int hasDelay();
|
|
int hasRiseSlew();
|
|
int hasRiseSlew2();
|
|
int hasFallSlew();
|
|
int hasFallSlew2();
|
|
int hasRiseIntrinsic();
|
|
int hasFallIntrinsic();
|
|
int numOfAxisNumbers();
|
|
double* axisNumbers();
|
|
int numOfTableEntries();
|
|
void tableEntry(int num, double* one, double* two, double* three);
|
|
const char* delayRiseOrFall();
|
|
const char* delayUnateness();
|
|
double delayTableOne();
|
|
double delayTableTwo();
|
|
double delayTableThree();
|
|
const char* transitionRiseOrFall();
|
|
const char* transitionUnateness();
|
|
double transitionTableOne();
|
|
double transitionTableTwo();
|
|
double transitionTableThree();
|
|
double fallIntrinsicOne();
|
|
double fallIntrinsicTwo();
|
|
double fallIntrinsicThree();
|
|
double fallIntrinsicFour();
|
|
double riseIntrinsicOne();
|
|
double riseIntrinsicTwo();
|
|
double riseIntrinsicThree();
|
|
double riseIntrinsicFour();
|
|
double fallSlewOne();
|
|
double fallSlewTwo();
|
|
double fallSlewThree();
|
|
double fallSlewFour();
|
|
double fallSlewFive();
|
|
double fallSlewSix();
|
|
double fallSlewSeven();
|
|
double riseSlewOne();
|
|
double riseSlewTwo();
|
|
double riseSlewThree();
|
|
double riseSlewFour();
|
|
double riseSlewFive();
|
|
double riseSlewSix();
|
|
double riseSlewSeven();
|
|
int hasRiseRS();
|
|
double riseRSOne();
|
|
double riseRSTwo();
|
|
int hasRiseCS();
|
|
double riseCSOne();
|
|
double riseCSTwo();
|
|
int hasFallRS();
|
|
double fallRSOne();
|
|
double fallRSTwo();
|
|
int hasFallCS();
|
|
double fallCSOne();
|
|
double fallCSTwo();
|
|
int hasUnateness();
|
|
const char* unateness();
|
|
int hasRiseAtt1();
|
|
double riseAtt1One();
|
|
double riseAtt1Two();
|
|
int hasFallAtt1();
|
|
double fallAtt1One();
|
|
double fallAtt1Two();
|
|
int hasFallTo();
|
|
double fallToOne();
|
|
double fallToTwo();
|
|
int hasRiseTo();
|
|
double riseToOne();
|
|
double riseToTwo();
|
|
int hasStableTiming();
|
|
double stableSetup();
|
|
double stableHold();
|
|
const char* stableRiseFall();
|
|
// The following are for 5.1
|
|
int hasSDFonePinTrigger();
|
|
int hasSDFtwoPinTrigger();
|
|
int hasSDFcondStart();
|
|
int hasSDFcondEnd();
|
|
int hasSDFcond();
|
|
const char* SDFonePinTriggerType();
|
|
const char* SDFtwoPinTriggerType();
|
|
const char* SDFfromTrigger();
|
|
const char* SDFtoTrigger();
|
|
double SDFtriggerOne();
|
|
double SDFtriggerTwo();
|
|
double SDFtriggerThree();
|
|
const char* SDFcondStart();
|
|
const char* SDFcondEnd();
|
|
const char* SDFcond();
|
|
|
|
protected:
|
|
int numFrom_;
|
|
char** from_;
|
|
int fromAllocated_;
|
|
int numTo_;
|
|
char** to_;
|
|
int toAllocated_;
|
|
|
|
int hasTransition_;
|
|
int hasDelay_;
|
|
int hasRiseSlew_;
|
|
int hasRiseSlew2_;
|
|
int hasFallSlew_;
|
|
int hasFallSlew2_;
|
|
int hasRiseIntrinsic_;
|
|
int hasFallIntrinsic_;
|
|
int hasRiseRS_;
|
|
int hasRiseCS_;
|
|
int hasFallRS_;
|
|
int hasFallCS_;
|
|
int hasUnateness_;
|
|
int hasFallAtt1_;
|
|
int hasRiseAtt1_;
|
|
int hasFallTo_;
|
|
int hasRiseTo_;
|
|
int hasStableTiming_;
|
|
int hasSDFonePinTrigger_;
|
|
int hasSDFtwoPinTrigger_;
|
|
int hasSDFcondStart_;
|
|
int hasSDFcondEnd_;
|
|
int hasSDFcond_;
|
|
int nowRise_;
|
|
|
|
int numOfAxisNumbers_;
|
|
double* axisNumbers_;
|
|
int axisNumbersAllocated_;
|
|
|
|
int numOfTableEntries_;
|
|
int tableEntriesAllocated_;
|
|
double* table_; // three numbers per entry
|
|
|
|
char* delayRiseOrFall_;
|
|
char* delayUnateness_;
|
|
double delayTableOne_;
|
|
double delayTableTwo_;
|
|
double delayTableThree_;
|
|
char* transitionRiseOrFall_;
|
|
char* transitionUnateness_;
|
|
double transitionTableOne_;
|
|
double transitionTableTwo_;
|
|
double transitionTableThree_;
|
|
double riseIntrinsicOne_;
|
|
double riseIntrinsicTwo_;
|
|
double riseIntrinsicThree_;
|
|
double riseIntrinsicFour_;
|
|
double fallIntrinsicOne_;
|
|
double fallIntrinsicTwo_;
|
|
double fallIntrinsicThree_;
|
|
double fallIntrinsicFour_;
|
|
double riseSlewOne_;
|
|
double riseSlewTwo_;
|
|
double riseSlewThree_;
|
|
double riseSlewFour_;
|
|
double riseSlewFive_;
|
|
double riseSlewSix_;
|
|
double riseSlewSeven_;
|
|
double fallSlewOne_;
|
|
double fallSlewTwo_;
|
|
double fallSlewThree_;
|
|
double fallSlewFour_;
|
|
double fallSlewFive_;
|
|
double fallSlewSix_;
|
|
double fallSlewSeven_;
|
|
double riseRSOne_;
|
|
double riseRSTwo_;
|
|
double riseCSOne_;
|
|
double riseCSTwo_;
|
|
double fallRSOne_;
|
|
double fallRSTwo_;
|
|
double fallCSOne_;
|
|
double fallCSTwo_;
|
|
char* unateness_;
|
|
double riseAtt1One_;
|
|
double riseAtt1Two_;
|
|
double fallAtt1One_;
|
|
double fallAtt1Two_;
|
|
double fallToOne_;
|
|
double fallToTwo_;
|
|
double riseToOne_;
|
|
double riseToTwo_;
|
|
double stableSetup_;
|
|
double stableHold_;
|
|
char* stableRiseFall_;
|
|
char* SDFtriggerType_;
|
|
char* SDFfromTrigger_;
|
|
char* SDFtoTrigger_;
|
|
double SDFtriggerTableOne_;
|
|
double SDFtriggerTableTwo_;
|
|
double SDFtriggerTableThree_;
|
|
char* SDFcondStart_;
|
|
char* SDFcondEnd_;
|
|
char* SDFcond_;
|
|
};
|
|
|
|
// 5.8
|
|
class lefiMacroSite {
|
|
public:
|
|
lefiMacroSite(const char *name, const lefiSitePattern* pattern);
|
|
|
|
const char *siteName() const;
|
|
const lefiSitePattern *sitePattern() const;
|
|
|
|
protected:
|
|
const char *siteName_;
|
|
const lefiSitePattern *sitePattern_;
|
|
};
|
|
|
|
class lefiMacroForeign {
|
|
public:
|
|
lefiMacroForeign(const char *name,
|
|
int hasPts,
|
|
double x,
|
|
double y,
|
|
int hasOrient,
|
|
int orient);
|
|
|
|
const char *cellName() const;
|
|
int cellHasPts() const;
|
|
double px() const;
|
|
double py() const;
|
|
int cellHasOrient() const;
|
|
int cellOrient() const;
|
|
|
|
protected:
|
|
const char *cellName_;
|
|
int cellHasPts_;
|
|
double px_;
|
|
double py_;
|
|
int cellHasOrient_;
|
|
int cellOrient_;
|
|
};
|
|
|
|
END_LEFDEF_PARSER_NAMESPACE
|
|
|
|
USE_LEFDEF_PARSER_NAMESPACE
|
|
|
|
#endif
|