DIRECTORY
CD USING [Instance, Layer, Number, Position],
CDSimpleRules,
CMosB USING [lambda, cmosB, ndif, pdif, pol, met, met2, nwell, nwellCont, pwellCont, cut, cut2, bur],
Rope USING [ROPE],
SX USING [CellPostProcessProc, Circuit, Constraint, ConstraintArray, ConstraintIndex, CircuitNode, ConstraintResolution, ConversionProc, GeometricRule, MapRec, nodeIndex, NodeLinkage, spaceIndex, SpinifexLayerIndex, TechHandle, BoxMapProc, violateIndex],
SXCMosB,
SXCMosBBasicRules,
SXOutput USING [LinkagePrintProc, LinkageHousekeeper],
SXOutputPrivate USING [UnNameTransType],
SXTechnology USING [RegisterTechnologyHandle, RegisterSpinifexObjectProcs, ResolutionTable, SetUpResolution],
TerminalIO USING [WriteRope];
SXCMosBInitImpl: CEDAR PROGRAM
IMPORTS CDSimpleRules, CMosB, SXCMosB, SXOutputPrivate, SXTechnology, TerminalIO
EXPORTS SXCMosB
~ BEGIN
OPEN SXCMosB;
Constraint: TYPE ~ SX.Constraint;
l: CD.Number ~ CMosB.lambda;
ndCnstr: PUBLIC REF ConstraintArray _ NEW[ConstraintArray];
ndInWel: CIndex ~ ndBur.SUCC; -- n-Diffusion in n-Well
ndWel: CIndex ~ ndInWel.SUCC; -- Exclude n-Diffusion by n-Well
ndCnt: CIndex ~ ndWel.SUCC; -- n-Diffusion contact here.
ndPWct: CIndex ~ ndCnt.SUCC; -- p-Diffusion contact here.
ndPdErr: CIndex ~ ndPWct.SUCC; -- n-Diffusion & p-Diffusion together => Error.
pdCnstr: PUBLIC REF ConstraintArray _ NEW[ConstraintArray];
pdNdErr: CIndex ~ pdCh.SUCC; -- p-Diffusion & n-Diffusion together => Error.
pdCnt: CIndex ~ pdNdErr.SUCC; -- p-Diffusion contact here.
pdNWct: CIndex ~ pdCnt.SUCC; -- n-Diffusion contact here.
polCnstr: PUBLIC REF ConstraintArray _ NEW[ConstraintArray];
pDErr: CIndex ~ pDandP.SUCC; -- Poly and Diffusion found together => Error.
metCnstr: PUBLIC REF ConstraintArray _ NEW[ConstraintArray];
mVC: CIndex ~ mVia.SUCC; -- Via and Cut seperated by less than 2 lambda.
InitRules: PROCEDURE [cMosHandle: REF SX.TechHandle] ~ {
Rule: TYPE ~ SX.GeometricRule;
TrigMap: TYPE ~ PACKED ARRAY CIndex OF BOOLEAN _ ALL[FALSE];
spaceRuleTrig, widthRuleTrig, nDifWidRuleTrig, polOverDifTrig1, polDifSepTrig1, polDifSepTrig2, nDifSpaceTrig1A, nDifSpaceTrig1B, nDifSpaceTrig2, pDifSpaceTrig1A, pDifSpaceTrig1B, pDifSpaceTrig2A, pDifSpaceTrig2B, pDifWidTrig, polSpaceTrig, polWidTrig, nDifSepNWellTrig1, nDifSepNWellTrig2, nDifInWellDifTrig1, nDifAndPDifTrig1, pDifAndNDifTrig1, alwaysErrorTrig2, nDifChannelTrig, metViaViaSpacing, metCutViaSpacing, metCutCutSpacing, metSpacing, metWidth: TrigMap;	-- ALL[FALSE]
detectOpaqueViolation: REF Rule;
spaceRuleTrig[SX.nodeIndex] _ TRUE;
widthRuleTrig _ ALL[TRUE];
widthRuleTrig[SX.nodeIndex] _ FALSE;
nDifSpaceTrig1A[SX.nodeIndex] _ TRUE;
nDifSpaceTrig1A[ndCh] _ TRUE;
nDifSpaceTrig1A[ndCnt] _ TRUE;
nDifSpaceTrig1B[ndPWct] _ TRUE;
nDifSpaceTrig2[SX.nodeIndex] _ TRUE;
nDifSpaceTrig2[ndCh] _ FALSE;	-- there is no diff at channels
nDifSpaceTrig2[ndCnt] _ TRUE;
nDifSpaceTrig2[ndPWct] _ TRUE;
nDifChannelTrig[ndCh] _ TRUE;
nDifWidRuleTrig _ ALL[TRUE];
nDifWidRuleTrig[SX.nodeIndex] _ FALSE;
nDifWidRuleTrig[ndCnt] _ FALSE;
pDifSpaceTrig1A[SX.nodeIndex] _ TRUE;
pDifSpaceTrig1A[pdCh] _ TRUE;
pDifSpaceTrig1A[pdCnt] _ TRUE;
pDifSpaceTrig2A[SX.nodeIndex] _ TRUE;
pDifSpaceTrig2A[pdCh] _ FALSE;	-- there is no diff at channels
pDifSpaceTrig2A[pdCnt] _ TRUE;
pDifSpaceTrig2A[pdNWct] _ TRUE;
pDifSpaceTrig1B[pdNWct] _ TRUE;
pDifSpaceTrig2B[SX.nodeIndex] _ TRUE;
pDifSpaceTrig2B[pdCnt] _ TRUE;
pDifWidTrig  _ ALL[TRUE];
pDifWidTrig[SX.nodeIndex] _ FALSE;
pDifWidTrig[pdCnt] _ FALSE;
nDifSepNWellTrig1[SX.nodeIndex] _ TRUE;
nDifSepNWellTrig2[ndWel] _ TRUE;
polSpaceTrig[SX.nodeIndex] _ TRUE;
polSpaceTrig[pDandP] _ TRUE;
polWidTrig _ ALL[TRUE];
polWidTrig[SX.nodeIndex] _ FALSE;
polWidTrig[pDandP] _ FALSE;
polWidTrig[pDErr] _ FALSE;
polDifSepTrig1 [SX.nodeIndex] _ TRUE;
polDifSepTrig1 [pDandP] _ TRUE;
polDifSepTrig2 [pExnD] _ TRUE;
polDifSepTrig2 [pExpD] _ TRUE;
polDifSepTrig2 [pExNdCon] _ TRUE;
polDifSepTrig2 [pExPdCon] _ TRUE;
metSpacing [SX.nodeIndex] _ TRUE;
metSpacing [mCut] _ TRUE;
metSpacing [mVia] _ TRUE;
metSpacing [mVC] _ TRUE;
metWidth _ ALL[TRUE];
metWidth [SX.nodeIndex] _ FALSE;
metWidth [mCut] _ FALSE;
metWidth [mVia] _ FALSE;
metWidth [mVC] _ FALSE;
polOverDifTrig1 [pDErr] _ TRUE;
nDifInWellDifTrig1 [ndInWel] _ TRUE;
nDifAndPDifTrig1 [ndPdErr] _ TRUE;
pDifAndNDifTrig1 [pdNdErr] _ TRUE;
metCutCutSpacing [mCut] _ TRUE;
metCutViaSpacing [mVC] _ TRUE;
metCutViaSpacing [mVia] _ TRUE;
metViaViaSpacing [mVia]  _ TRUE;
alwaysErrorTrig2 _ ALL[TRUE];
detectOpaqueViolation _ NEW[ Rule _ [ extent~ l, message~ "Opaque cell boundary violated", trigger1~ ALL[TRUE], trigger2~ ALL[TRUE]]];
detectOpaqueViolation.trigger1[SX.violateIndex] _ FALSE;
cMosHandle.rules [ndifSpinifex] _ LIST[
NEW [Rule _ [message~ "n-Diffusion spacing", extent~ CDSimpleRules.MinDist[CMosB.ndif, CMosB.ndif], okIfConnected~ TRUE, trigger1~ nDifSpaceTrig1A, trigger2~ nDifSpaceTrig2]],
NEW [Rule _ [message~ "n-Diffusion/unconnected p-substrate-contact spacing", extent~ SXCMosBBasicRules.ndifUncSubtrContSpacing, okIfConnected~ TRUE, trigger1~ nDifSpaceTrig1B, trigger2~ nDifSpaceTrig2]],
NEW [Rule _ [message~ "n-Diffusion width", extent~ CDSimpleRules.MinWidth[CMosB.ndif], trigger1~ nDifWidRuleTrig, trigger2~ nDifWidRuleTrig]],
NEW [Rule _ [message~ "n-Diffusion/n-Well spacing", extent~ SXCMosBBasicRules.nDifToWell, trigger1~ nDifSepNWellTrig1, trigger2~ nDifSepNWellTrig2]],
NEW [Rule _ [message~ "n-Well/n-Diffusion spacing", extent~ SXCMosBBasicRules.nDifToWell, trigger1~ nDifSepNWellTrig2, trigger2~ nDifSepNWellTrig1]],
NEW [Rule _ [message~ "n-Diffusion in n-Well", extent~ SXCMosBBasicRules.ndifInnWell, trigger1~ nDifInWellDifTrig1, trigger2~ alwaysErrorTrig2]],
NEW [Rule _ [message~ "n-Diffusion and p-substrate-contact", extent~ SXCMosBBasicRules.ndifpSubstrCont, trigger1~ nDifAndPDifTrig1, trigger2~ alwaysErrorTrig2]],
detectOpaqueViolation
];
cMosHandle.rules [pdifSpinifex] _ LIST[
NEW [Rule _ [message~ "p-Diffusion spacing", extent~ CDSimpleRules.MinDist[CMosB.pdif, CMosB.pdif], okIfConnected~ TRUE, trigger1~ pDifSpaceTrig1A, trigger2~ pDifSpaceTrig2A]],
NEW [Rule _ [message~ "p-Diffusion/unconnected n-Well-contact spacing", extent~ SXCMosBBasicRules.pdifUncnWellSpacing, okIfConnected~ TRUE, trigger1~ pDifSpaceTrig1B, trigger2~ pDifSpaceTrig2B]],
NEW [Rule _ [message~ "p-Diffusion width", extent~ CDSimpleRules.MinWidth[CMosB.pdif], trigger1~ pDifWidTrig, trigger2~ pDifWidTrig]],
NEW [Rule _ [message~ "p-Diffusion and n-Well-contact", extent~ SXCMosBBasicRules.pdifnWellCont, trigger1~ pDifAndNDifTrig1, trigger2~ alwaysErrorTrig2]],
detectOpaqueViolation
];
cMosHandle.rules [polSpinifex] _ LIST[
NEW [Rule _ [message~ "Poly spacing", extent~ CDSimpleRules.MinDist[CMosB.pol, CMosB.pol], okIfConnected~ TRUE, trigger1~ polSpaceTrig, trigger2~ polSpaceTrig]],
NEW [Rule _ [message~ "Poly width", extent~ CDSimpleRules.MinWidth[CMosB.pol], trigger1~ polWidTrig, trigger2~ polWidTrig]],
NEW [Rule _ [message~ "Poly/unconnected Diffusion spacing", extent~ SXCMosBBasicRules.polUncDifSpacing, okIfConnected~ TRUE,  trigger1~ polDifSepTrig1, trigger2~ polDifSepTrig2]],
NEW [Rule _ [message~ "Diffusion/unconnected Poly spacing", extent~ SXCMosBBasicRules.polDiffUncPolySpacing, okIfConnected~ TRUE,  trigger1~ polDifSepTrig2, trigger2~ polDifSepTrig1]],
NEW [Rule _ [message~ "Poly over Diffusion", extent~ SXCMosBBasicRules.polOverDiff, trigger1~ polOverDifTrig1, trigger2~ alwaysErrorTrig2]],
detectOpaqueViolation
];
cMosHandle.rules [metSpinifex] _ LIST[
NEW [Rule _ [message~ "Metal spacing", extent~ CDSimpleRules.MinDist[CMosB.met, CMosB.met], okIfConnected~ TRUE, trigger1~ metSpacing, trigger2~ metSpacing]],
NEW [Rule _ [message~ "Metal width", extent~ CDSimpleRules.MinWidth[CMosB.met], trigger1~ metWidth, trigger2~ metWidth]],
NEW [Rule _ [message~ "Cut to Cut spacing", extent~ SXCMosBBasicRules.metCutCutSpacing , trigger1~  metCutCutSpacing, trigger2~ metCutCutSpacing]],
NEW [Rule _ [message~ "Via to Via spacing", extent~ 4*l , trigger1~  metViaViaSpacing, trigger2~ metViaViaSpacing]],
NEW [Rule _ [message~ "Cut to Via spacing", extent~ SXCMosBBasicRules.metCutViaSpacing, trigger1~  metCutCutSpacing, trigger2~ metCutViaSpacing]],
detectOpaqueViolation
];
cMosHandle.rules [m2Spinifex] _ LIST[
NEW [Rule _ [message~ "Metal 2 spacing", extent~ CDSimpleRules.MinDist[CMosB.met2, CMosB.met2], okIfConnected~ TRUE, trigger1~ spaceRuleTrig, trigger2~ spaceRuleTrig]],
NEW [Rule _ [message~ "Metal 2 width", extent~ CDSimpleRules.MinWidth[CMosB.met2], trigger1~ widthRuleTrig, trigger2~ widthRuleTrig]],
detectOpaqueViolation
];
};
Init: PROCEDURE ~ {
cMosHandle: REF SX.TechHandle;
ndifResolution: REF SX.ConstraintResolution;
pdifResolution: REF SX.ConstraintResolution;
polyResolution: REF SX.ConstraintResolution;
metalResolution: REF SX.ConstraintResolution;
ndCnstr[ndCh] _ NEW [Constraint _  [$NDifChannel, ndCh, TRUE, polSpinifex]];
ndCnstr[ndBur] _ NEW [Constraint _  [$BuriedNDifPol, ndBur]];
ndCnstr[ndInWel] _ NEW [Constraint _  [$NDifInWellError, ndInWel]];
ndCnstr[ndWel] _ NEW [Constraint _  [$ExcludeNDifByWell, ndWel]];
ndCnstr[ndCnt] _ NEW [Constraint _  [$ContactNDif, ndCnt, TRUE, ndifSpinifex]];
ndCnstr[ndPWct] _ NEW [Constraint _  [$ExcludeNDifByPWellCont, ndPWct, TRUE, pdifSpinifex]];
ndCnstr[ndPdErr] _ NEW [Constraint _  [$NDifAndPDifError, ndPdErr]];
pdCnstr[pdCh] _ NEW [Constraint _  [$PDifChannel, pdCh, TRUE, pdifSpinifex]];
pdCnstr[pdNdErr] _ NEW [Constraint _  [$PDifAndNDifError, pdNdErr]];
pdCnstr[pdCnt] _ NEW [Constraint _  [$ContactPDif, pdCnt, TRUE, pdifSpinifex]];
pdCnstr[pdNWct] _ NEW [Constraint _  [$ExcludePDifByNWellCont, pdNWct, TRUE, ndifSpinifex]];
polCnstr[pExnD] _ NEW [Constraint _  [$PolExcludeByNDif, pExnD, TRUE, ndifSpinifex]];
polCnstr[pExpD] _ NEW [Constraint _  [$PolExcludeByPDif, pExpD, TRUE, pdifSpinifex]];
polCnstr[pExNdCon] _ NEW [Constraint _  [$PolExcludeByNDifContact, pExNdCon, TRUE, ndifSpinifex]];
polCnstr[pExPdCon] _ NEW [Constraint _  [$PolExcludeByPDifContact, pExPdCon, TRUE, pdifSpinifex]];
polCnstr[pChE] _ NEW [Constraint _  [$PolChannelEdge, pChE]];
polCnstr[pDxorP] _ NEW [Constraint _  [$PolXorDif, pDxorP]];
polCnstr[pDandP] _ NEW [Constraint _  [$polAndDif, pDandP, TRUE, polSpinifex]];
polCnstr[pDErr] _ NEW [Constraint _  [$PolDifError, pDErr]];
polCnstr[pBur] _ NEW [Constraint _  [$PolBuried, pBur]];
polCnstr[pDExcl] _ NEW [Constraint _  [$PolExcludeNDif, pDExcl]];
polCnstr[pBurErr] _ NEW [Constraint _  [$PolBuriedNDifError, pBurErr]];
metCnstr[mCut] _ NEW [Constraint _  [$MetCut, mCut, TRUE, metSpinifex]];
metCnstr[mVia] _ NEW [Constraint _  [$MetVia, mVia, TRUE, metSpinifex]];
metCnstr[mVC] _ NEW [Constraint _  [$MetViaAndCutError, mVC, TRUE, metSpinifex]];
{
nd: SX.ConstraintIndex ~ SX.nodeIndex;
sp: SX.ConstraintIndex ~ SX.spaceIndex;
ndifResTab: SXTechnology.ResolutionTable ~ [
[	sp,			nd,			ndCh,		ndBur,		ndInWel,	ndWel,		ndCnt,		ndPWct,	ndPdErr,	,,,,,,],
[	nd,			nd,			ndCh,		nd,			ndInWel,	ndInWel,	ndCnt,		ndPdErr,	ndPdErr,	,,,,,,],
[	ndCh,		ndCh,		ndCh,		ndCh,		ndInWel,	ndInWel,	ndCh,		ndPdErr,	ndPdErr,	,,,,,,],
[	ndBur,		nd,			ndCh,		ndBur,		ndInWel,	ndWel,		ndCnt,		ndPWct,	ndPdErr,	,,,,,,],
[	ndInWel,	ndInWel,	ndInWel,	ndInWel,	ndInWel,	ndInWel,	ndCnt,		ndPdErr,	ndPdErr,	,,,,,,],
[	ndWel,		ndInWel,	ndInWel,	ndWel,		ndInWel,	ndWel,		ndCnt,		ndPWct,	ndPdErr,	,,,,,,],
[	ndCnt,		ndCnt,		ndCh,		ndCnt,		ndCnt,		ndCnt,		ndCnt,		ndPdErr,	ndPdErr,	,,,,,,],
[	ndPWct,	ndPdErr,	ndPdErr,	ndPWct,	ndPdErr,	ndPWct,	ndPdErr,	ndPWct,	ndPdErr,	,,,,,,],
[	ndPdErr,	ndPdErr,	ndPdErr,	ndPdErr,	ndPdErr,	ndPdErr,	ndPdErr,	ndPdErr,	ndPdErr,	,,,,,,],
,,,,,,
];
pdifResTab: SXTechnology.ResolutionTable ~ [
[	sp,			nd,			pdCh,		pdNdErr,	pdCnt,		pdNWct,	,,,,,,,,,],
[	nd,			nd,			pdCh,		pdNdErr,	pdCnt,		pdNdErr,	,,,,,,,,,],
[	pdCh,		pdCh,		pdCh,		pdNdErr,	pdCh,		pdNdErr,	,,,,,,,,,],
[	pdNdErr,	pdNdErr,	pdNdErr,	pdNdErr,	pdNdErr,	pdNdErr,	,,,,,,,,,],
[	pdCnt,		pdCnt,		pdCh,		pdNdErr,	pdCnt,		pdNdErr,	,,,,,,,,,],
[	pdNWct,	pdNdErr,	pdNdErr,	pdNdErr,	pdNdErr,	pdNWct,	,,,,,,,,,],
,,,,,,,,,
];
polyResTab: SXTechnology.ResolutionTable ~ [
[	sp,			nd,			pExnD,		pExpD,		pExNdCon,	pExPdCon,	pChE,		pDExcl,	pBur,		pBurErr,	pDxorP,	pDandP,	pDErr,		,,],
[	nd,			nd,			pDErr,		pDErr,		pDErr,		pDErr,		pDErr,		nd,			nd,			pDErr,		nd,			pDandP,	pDErr,		,,],
[	pExnD,		pDErr,		pExnD,		pExpD,		pExNdCon,	pExPdCon,	pChE,		pBurErr,	pBur,		pBurErr,	pChE,		pDandP,	pDErr,		,,],
[	pExpD,		pDErr,		pExpD,		pExpD,		pExPdCon,	pExPdCon,	pChE,		pBurErr,	pBur,		pBurErr,	pChE,		pDandP,	pDErr,		,,],
[	pExNdCon,	pDErr,		pExNdCon,	pExPdCon,	pExNdCon,	pExPdCon,	pExNdCon,	pBurErr,	pBur,		pBurErr,	pChE,		pDandP,	pDErr,		,,],
[	pExPdCon,	pDErr,		pExPdCon,	pExPdCon,	pExPdCon,	pExPdCon,	pExPdCon,	pBurErr,	pBur,		pBurErr,	pChE,		pDandP,	pDErr,		,,],
[	pChE,		pDErr,		pChE,		pChE,		pExNdCon,	pExPdCon,	pChE,		pBurErr,	pBur,		pBurErr,	pChE,		pDandP,	pDErr,		,,],
[	pDExcl,	nd,			pBurErr,	pBurErr,	pBurErr,	pBurErr,	pBurErr,	pDExcl,	pBur,		pBurErr,	pDExcl,	pDandP,	pDErr,		,,],
[	pBur,		nd,			pBur,		pBur,		pBur,		pBur,		pBur,		pBur,		pBur,		pBur,		pBur,		pDandP,	pDErr,		,,],
[	pBurErr,	pDErr,		pBurErr,	pBurErr,	pBurErr,	pBurErr,	pBurErr,	pBurErr,	pBur,		pBurErr,	pBurErr,	pDandP,	pDErr,		,,],
[	pDxorP,	nd,			pChE,		pChE,		pChE,		pChE,		pChE,		pDExcl,	pBur,		pBurErr,	pDxorP,	pDandP,	pDErr,		,,],
[	pDandP,	pDandP,	pDandP,	pDandP,	pDandP,	pDandP,	pDandP,	pDandP,	pDandP,	pDandP,	pDandP,	pDandP,	pDandP,	,,],
[	pDErr,		pDErr,		pDErr,		pDErr,		pDErr,		pDErr,		pDErr,		pDErr,		pDErr,		pDErr,		pDErr,		pDandP,	pDErr,		,,],
,,
];
metalResTab: SXTechnology.ResolutionTable ~ [
[	sp,		nd,		mCut,	mVia,	mVC,	,,,,,,,,,,],
[	nd,		nd,		mCut,	mVia,	mVC,	,,,,,,,,,,],
[	mCut,	mCut,	mCut,	mVC,	mVC,	,,,,,,,,,,],
[	mVia,	mVia,	mVC,	mVia,	mVC,	,,,,,,,,,,],
[	mVC,	mVC,	mVC,	mVC,	mVC,	,,,,,,,,,,],
,,,,,,,,,,
];
ndifResolution _ SXTechnology.SetUpResolution [ndCnstr, ndifResTab];
pdifResolution _ SXTechnology.SetUpResolution [pdCnstr, pdifResTab];
polyResolution _ SXTechnology.SetUpResolution [polCnstr, polyResTab];
metalResolution _ SXTechnology.SetUpResolution [metCnstr, metalResTab];
};
cMosHandle _ NEW[SX.TechHandle _ [
numSpinifexLayers~ 6,
layerInterestBloat~ [SXCMosBBasicRules.nDifLayerSep, (CDSimpleRules.MinDist[CMosB.ndif, CMosB.ndif]/2), (CDSimpleRules.MinDist[CMosB.pol, CMosB.pol]/2), (CDSimpleRules.MinDist[CMosB.met, CMosB.met]/2), (CDSimpleRules.MinDist[CMosB.met2, CMosB.met2]/2), l,,],
combineNodeProperties~ CopyWellConnections,
cellPostProcess~ CheckWellConnections]
];
cMosHandle.illegalLayer[CMosB.nwellCont] _ FALSE;
cMosHandle.illegalLayer[CMosB.pwellCont] _ FALSE;
cMosHandle.illegalLayer[CMosB.ndif] _ FALSE;
cMosHandle.illegalLayer[CMosB.pdif] _ FALSE;
cMosHandle.illegalLayer[CMosB.nwell] _ FALSE;
cMosHandle.illegalLayer[CMosB.pol] _ FALSE;
cMosHandle.illegalLayer[CMosB.met] _ FALSE;
cMosHandle.illegalLayer[CMosB.met2] _ FALSE;
cMosHandle.cdLayerMapping[CMosB.nwellCont] _ LIST [[ndifSpinifex, (CDSimpleRules.MinDist[CMosB.ndif, CMosB.ndif]/2)], [wellSpinifex, l, NEW [SX.BoxMapProc _ AttachNWellContact]], [pdifSpinifex, (CDSimpleRules.MinDist[CMosB.ndif, CMosB.ndif]/2), pdCnstr[pdNWct]], [ndifSpinifex, (CDSimpleRules.MinDist[CMosB.ndif, CMosB.ndif]/2), ndCnstr[ndCnt]], [polSpinifex, SXCMosBBasicRules.difToPolExtSep, polCnstr[pExnD]]]; -- Order Important for well plugging, node is created in first mapping, and used in second.
cMosHandle.cdLayerMapping[CMosB.pwellCont] _ LIST [[pdifSpinifex, (CDSimpleRules.MinDist[CMosB.ndif, CMosB.ndif]/2)], [ndifSpinifex, (CDSimpleRules.MinDist[CMosB.ndif, CMosB.ndif]/2), ndCnstr[ndPWct]], [pdifSpinifex, (CDSimpleRules.MinDist[CMosB.ndif, CMosB.ndif]/2), pdCnstr[pdCnt]], [polSpinifex, SXCMosBBasicRules.difToPolExtSep, polCnstr[pExpD]]];
cMosHandle.cdLayerMapping[CMosB.ndif] _ LIST [[ndifSpinifex, (CDSimpleRules.MinDist[CMosB.ndif, CMosB.ndif]/2)], [polSpinifex, SXCMosBBasicRules.difToPolExtSep, polCnstr[pExnD]]];
cMosHandle.cdLayerMapping[CMosB.pdif] _ LIST [[pdifSpinifex, (CDSimpleRules.MinDist[CMosB.ndif, CMosB.ndif]/2)], [polSpinifex, SXCMosBBasicRules.difToPolExtSep, polCnstr[pExpD]]];
cMosHandle.cdLayerMapping[CMosB.nwell] _ LIST [[ndifSpinifex, SXCMosBBasicRules.nDifToWell-(CDSimpleRules.MinDist[CMosB.ndif, CMosB.ndif]/2), ndCnstr[ndWel]], [wellSpinifex, l]];  -- INTERIM
cMosHandle.cdLayerMapping[CMosB.pol] _ LIST [[polSpinifex, (CDSimpleRules.MinDist[CMosB.pol, CMosB.pol]/2)]];
cMosHandle.cdLayerMapping[CMosB.met] _ LIST [[metSpinifex, (CDSimpleRules.MinDist[CMosB.met, CMosB.met]/2)]];
cMosHandle.cdLayerMapping[CMosB.met2] _ LIST [[m2Spinifex, (CDSimpleRules.MinDist[CMosB.met2, CMosB.met2]/2)]];
{
conInfl: CD.Number~ lambda;	-- Influence distance of contacts.
cMosHandle.cdLayerMapping[CMosB.cut] _ LIST [[ndifSpinifex, conInfl, $Opaque], [pdifSpinifex, conInfl, $Opaque], [polSpinifex, conInfl, $Opaque], [metSpinifex, conInfl, $Opaque]];
cMosHandle.cdLayerMapping[CMosB.cut2] _ LIST [[metSpinifex, conInfl, $Opaque], [m2Spinifex, conInfl, $Opaque]];
cMosHandle.cdLayerMapping[CMosB.bur] _ LIST [[ndifSpinifex, (CDSimpleRules.MinDist[CMosB.met2, CMosB.met2]/2), $Opaque], [polSpinifex, conInfl, $Opaque]];
};

cMosHandle.spinifexLayerNames[ndifSpinifex].layerId _ $nDiffusion;
cMosHandle.spinifexLayerNames[pdifSpinifex].layerId _ $pDiffusion;
cMosHandle.spinifexLayerNames[polSpinifex].layerId _ $Poly;
cMosHandle.spinifexLayerNames[metSpinifex].layerId _ $Metal;
cMosHandle.spinifexLayerNames[m2Spinifex].layerId _ $Metal2;
cMosHandle.spinifexLayerNames[wellSpinifex].layerId _ $NWell;
cMosHandle.spinifexLayerNames[ndifSpinifex].thymeName _ "nD";
cMosHandle.spinifexLayerNames[pdifSpinifex].thymeName _ "pD";
cMosHandle.spinifexLayerNames[polSpinifex].thymeName _ "P";
cMosHandle.spinifexLayerNames[metSpinifex].thymeName _ "M";
cMosHandle.spinifexLayerNames[m2Spinifex].thymeName _ "M2";
cMosHandle.constraintResolutions[ndifSpinifex] _ ndifResolution;
cMosHandle.constraintResolutions[pdifSpinifex] _ pdifResolution;
cMosHandle.constraintResolutions[polSpinifex] _ polyResolution;
cMosHandle.constraintResolutions[metSpinifex] _ metalResolution;
InitRules[cMosHandle];
SXTechnology.RegisterTechnologyHandle[cdTech~ CMosB.cmosB, technologyHandle~ cMosHandle];
SXTechnology.RegisterSpinifexObjectProcs [cdTech~ CMosB.cmosB, objectType~ $C2Trans, conv~ ConvTransistor, thyme~ ThymeTransistor, rose~ RoseTransistor, fini~ SXOutputPrivate.UnNameTransType];
SXTechnology.RegisterSpinifexObjectProcs [cdTech~ CMosB.cmosB, objectType~ $C2WellTrans, conv~ ConvTransistor, thyme~ ThymeTransistor, rose~ RoseTransistor, fini~ SXOutputPrivate.UnNameTransType];
SXTechnology.RegisterSpinifexObjectProcs [cdTech~ CMosB.cmosB, objectType~ $C2LTrans, conv~ ConvTransistor, thyme~ ThymeTransistor, rose~ RoseTransistor, fini~ SXOutputPrivate.UnNameTransType];
SXTechnology.RegisterSpinifexObjectProcs [cdTech~ CMosB.cmosB, objectType~ $CLWellTrans, conv~ ConvTransistor, thyme~ ThymeTransistor, rose~ RoseTransistor, fini~ SXOutputPrivate.UnNameTransType];
SXTechnology.RegisterSpinifexObjectProcs [cdTech~ CMosB.cmosB, objectType~ $C2PDifRect, conv~ ConvertPDifRect];
SXTechnology.RegisterSpinifexObjectProcs [cdTech~ CMosB.cmosB, objectType~ $C2NDifRect, conv~ ConvertPDifRect];
SXTechnology.RegisterSpinifexObjectProcs [cdTech~ CMosB.cmosB, objectType~ $C2SimpleCon, conv~ ConvertContact];
SXTechnology.RegisterSpinifexObjectProcs [cdTech~ CMosB.cmosB, objectType~ $C2WellSimpleCon, conv~ ConvertContact];
SXTechnology.RegisterSpinifexObjectProcs [cdTech~ CMosB.cmosB, objectType~ $C2LargeSimpleCon, conv~ ConvertContact];
SXTechnology.RegisterSpinifexObjectProcs [cdTech~ CMosB.cmosB, objectType~ $C2LargeWellSimpleCon, conv~ ConvertContact];
SXTechnology.RegisterSpinifexObjectProcs [cdTech~ CMosB.cmosB, objectType~ $C2DifShortCon, conv~ ConvertContact];
SXTechnology.RegisterSpinifexObjectProcs [cdTech~ CMosB.cmosB, objectType~ $C2Via, conv~ ConvertContact];
SXTechnology.RegisterSpinifexObjectProcs [cdTech~ CMosB.cmosB, objectType~ $C2LargeVia, conv~ ConvertContact];
};
Init[];
TerminalIO.WriteRope["cMos technology parameters Loaded\n"];
END.
	¸SXCMosBInitImpl.mesa
Copyright c 1984 by Xerox Corporation.  All rights reserved.
Written by gbb, November 25, 1985 6:36:23 pm PST
Last edited by: gbb February 7, 1986 1:31:36 pm PST
Constraints
n-Diffusion constraints.
PUBLIC ndCh, ndBur.
p-Diffusion constraints
PUBLIC pdCh.
Poly constraints
PUBLIC pExnD, pExpD, pExNdCon, pExPdCon, pChE, pDExcl, pBur, pBurErr, pDxorP, pDandP.
Metal constraints
PUBLIC mCut, mVia.
Geometric rule triggers.
Corners are defined by union of dif and gate
nDifWidRuleTrig[ndCh] _ FALSE;
Corners are defined by union of dif and gate
Metal
Purely local errors are not handled in a natural manner by my scheme, so for every corner we find in polCnstr[pDErr] we generate an error if there is anything on any layer nearby, of course there is always something so we get our error.
The geometric rules.
We set violateIndex = FALSE, ALL else TRUE so that corner checks face inward, which should result in more logically pleasing error reports.
The above two rules are no longer applied to channels.
NEW [Rule _ [message~ "Cut to Via spacing", extent~ SXCMosBBasicRules.metCutViaSpacing, trigger1~  metCutViaSpacing, trigger2~ metCutViaSpacing]],
Construction of the Layer Constraints.
Constraint: PUBLIC TYPE ~ RECORD [
name: ATOM,
index: ConstraintIndex,  -- index into the constraint array
hasCorrespondingNode: BOOLEAN _ FALSE,	-- used where connectivity affects the rule and there is a corresponding layer which has the node associated with this region.
correspondingNodeLayer: SpinifexLayerIndex _ SpinifexLayerIndex.FIRST	-- way to attach node values to constraints by looking at other layers.
];
metCnstr[mVC] _ NEW [Constraint _  [$MetViaAndCutError, mVC]];
Constraint priority: sp < ndBur < nd < ndCnt < ndCh < ndWel < ndInWel < ndPWct < ndPdErr.
-- Constraint priority: sp < nd < pdCnt < pdCh < pdNWct < pdNdErr
-- Constraint priority: sp < pDxorP < pExnD < pExpD < pChE < pExNdCon < pExPdCon < pDExcl < pBur < nd < pBurErr < pDErr < pDandP
-- Constraint priority: sp < nd < mCut < mVia < mVC
Basic cMosHandle & cdLayerMappings.
Translations for Opaque Cells.
Using value $Opaque ensures we get an error if these are ever used as normal cdLayerMappings.
Spinifex Layer Identification.
Thyme stray capacitance layer names.
Set Constraint Resolutions for each layer into the TechHandle.
The geometric rules.
Technology handle is attached to the ChipNDale technology.
Technology specific objects.
gbb January 14, 1986 2:56:00 pm PST
Fixed some rules.

�Ê£˜
codeš
œ™Kšœ
Ïm
œ1™<K™0K™3—
unitš
Ïk	˜	Kšžœ
žœ%˜-K˜KšœžœZ˜eKšœžœžœ˜Kšœžœö
˜þ
Kš
œ˜Kš
œ˜Kšœ	žœ(˜6Kšœžœ˜(Kšœ
žœ[˜mKšœžœ
˜—Icode2šÐblœžœ
ž˜KšžœI˜PKšžœ˜Kšœž˜Kšžœ	˜
L•StartOfExpansion, -- [appl: CD.ApplicationPtr, cir: REF ] -- šœžœ˜!LšÏg
œžœ˜š
Ÿ™Lš
Ïl™šœ	žœ
žœžœ˜;Lš
œ™KšœžœÏc˜6Kšœžœ¢ ˜>Kšœžœ¢˜8Kšœžœ¢˜9Kšœžœ¢/˜N—Lš
¡™šœ	žœ
žœžœ˜;Lš
œ™Kšœžœ¢/˜LKšœžœ¢˜:Kšœžœ¢˜9—Lš
Ðcl™šœ
žœ
žœžœ˜<Lš
¢U™UKšœžœ¢.˜K—Lš
¡™šœ
žœ
žœžœ˜<Lš
œ™Kšœžœ¢/˜H——šÏn	œž	œžœ˜8Lšœžœ˜Lšœ	žœžœ
žœžœ
žœžœ
žœ˜<LšœÖžœ
žœ
˜àLšœžœ˜ š
¡™Lšœžœ
˜#Kšœžœ
žœ˜Kšœžœ
˜$š
œ,™,Kšœ žœ
˜%Kšœžœ
˜Kšœžœ
˜Kšœžœ
˜Kšœžœ
˜$Kšœžœ¢˜=Kšœžœ
˜Kšœžœ
˜Kšœžœ
˜Kšœžœ
žœ˜Kšœ žœ
˜&Kšœžœ
˜Kšœžœ
™—š
œ,™,Kšœ žœ
˜%Kšœžœ
˜Kšœžœ
˜Kšœ žœ
˜%Kšœžœ¢˜>Kšœžœ
˜Kšœžœ
˜Kšœžœ
˜Kšœ žœ
˜%Kšœžœ
˜Kšœžœ
žœ˜Kšœžœ
˜"Kšœžœ
˜Lšœ"žœ
˜'Kšœžœ
˜ Lšœžœ
˜"Kšœžœ
˜Kšœ
žœ
žœ˜Kšœžœ
˜!Kšœžœ
˜Kšœžœ
˜Kšœ žœ
˜%Kšœžœ
˜Kšœžœ
˜Kšœžœ
˜Kšœžœ
˜!Kšœžœ
˜!—™Kšœžœ
˜!Kšœžœ
˜Kšœžœ
˜Kšœžœ
˜Kšœžœ
žœ˜Kšœžœ
˜ Kšœžœ
˜Kšœžœ
˜Kšœžœ
˜—š
ϓ
™ì
Kšœžœ
˜Kšœžœ
˜$Kšœžœ
˜"Kšœžœ
˜"Kšœžœ
˜Kšœžœ
˜Kšœžœ
˜Kšœžœ
˜ Kšœžœ
žœ˜——š
¡™Kšœžœ 
œÏbœ
žœ
žœ
žœ
žœ˜†
Kš
œ‹
™‹
Kšœ2žœ
˜8šœ"žœ
˜'K–M[key: 
REF ANY, technology: 
CD.Technology _ NIL, default: 
REF ANY _ NIL]šžœ¥œIžœ8˜¯
–M[key: 
REF ANY, technology: 
CD.Technology _ NIL, default: 
REF ANY _ NIL]šžœ¥3œ 
œ(žœ8˜Ë
K™6—Kšžœ¥œf˜Ž
Kšžœ¥œd˜•
Kšžœ¥œd˜•
Kšžœ¥œ 
œH˜‘
Kšžœ¥#œ 
œJ˜¡
Kš
œ˜Kš
œ˜—šœ"žœ
˜'K–M[key: 
REF ANY, technology: 
CD.Technology _ NIL, default: 
REF ANY _ NIL]šžœ¥œIžœ9˜°
K–M[key: 
REF ANY, technology: 
CD.Technology _ NIL, default: 
REF ANY _ NIL]šžœ¥.œ 
œ$žœ9˜Ã
Kšžœ¥œ^˜†
Kšžœ¥œ 
œH˜š
Kš
œ˜Kš
œ˜—šœ!žœ
˜&Kšžœ¥œGžœ3˜¡
Kšžœ¥
œ[˜|Kšžœ¥"œ 
œ!žœ8˜³
Kšžœ¥"œ 
œ&žœ8˜¸
Kšžœ¥œ 
œE˜Œ
Kš
œ˜Kš
œ˜—šœ!žœ
˜&Kšžœ¥
œGžœ/˜ž
Kšžœ¥œW˜yKšžœ¥œ 
œM˜“
Kšžœ¥œ
 
œ=˜tKšžœ¥œ 
œL˜’
Kšžœ¥œ 
œL™’
Kš
œ˜Kš
œ˜—šœ žœ
˜%Kšžœ¥œIžœ5˜¨
Kšžœ¥
œb˜†
Kš
œ˜Kš
œ˜——K˜—š¤œž	œ˜LšŸ
œžœ˜Lšœžœ˜,Kšœžœ˜,Kšœžœ˜,Kšœžœ˜-š
¡&™&šœžœ
žœžœ™"Kšœžœ
™Kšœ¢"™;Kšœžœžœ¢{™¥
Kšœ@žœ¢D™�
K™—Lšœžœ$žœ˜LKšœžœ)˜=Kšœžœ-˜CKšœžœ-˜AKšœžœ&žœ˜OKšœžœ2žœ˜\Kšœžœ.˜DLšœžœ%žœ˜MKšœžœ.˜DKšœžœ&žœ˜OKšœžœ2žœ˜\Lšœžœ+žœ˜UKšœžœ+žœ˜UKšœžœ5žœ˜bKšœžœ5žœ˜bKšœžœ)˜=Kšœžœ&˜<Kšœžœ%žœ˜OKšœžœ'˜<Kšœžœ$˜8Kšœžœ+˜AKšœžœ0˜GLšœžœ žœ˜HKšœžœ žœ˜HKšœžœ+™>Kšœžœ*žœ˜QL˜
Kš
œ&˜&Kš
œ'˜'š
œ,˜,IdefaultšœÐosD™YNš
¦O˜ONš
¦O˜ONš
¦Q˜QNš
¦Q˜QNš
¦Z˜ZNš
¦V˜VNš
¦S˜SNš
¦W˜WNš
¦[˜[Nš¦œ˜N˜—š
œ,˜,Nšœ¦)™ANš
¦9˜9Nš
¦:˜:Nš
¦;˜;Nš
¦C˜CNš
¦>˜>Nš
¦A˜AJ˜	K˜—š
œ,˜,Nšœ¦h™€
Nš
¦m˜mNš
¦d˜dNš
¦q˜qNš
¦q˜qNš
¦z˜zNš
¦z˜zNš
¦n˜nNš
¦q˜qNš
¦b˜bNš
¦v˜vNš
¦g˜gNš
¦n˜nNš
¦n˜nNš
œ˜Kš
œ˜—š
œ-˜-Nšœ¦™3Nš
¦)˜)Nš
¦)˜)Nš
¦*˜*Nš
¦*˜*Nš
¦'˜'N˜
K˜—Lš
œD˜DKš
œD˜DKš
œE˜EKš
œG˜GK˜—š
¡#™#Lšœ
žœ¦ 
œZ˜‘Kšœ¥	œžœ
˜1Kšœ¥	œžœ
˜1Kšœ¥œžœ
˜,Kšœ¥œžœ
˜,Kšœ¥œžœ
˜-Kšœ¥œžœ
˜+Kšœ¥œžœ
˜+Kšœ¥œžœ
˜,Kš
œ ¥	œžœT 
œžœ’¢[˜øKšœ ¥	œžœ®˜ßKšœ ¥œžœ‡
˜³
Kšœ ¥œžœ‡
˜³
Kš	œ ¥œžœ�
 
œ¢Ñacl˜¾
Kšœ ¥œžœB˜mKšœ ¥œžœB˜mKšœ ¥œžœC˜oK™˜
Kšœ	žœ¢"˜>Kš
œ]™]Kšœ ¥œžœˆ
˜³
Kšœ ¥œžœC˜oKšœ ¥œžœo˜š
K˜K˜——š
¡™Lš
œB˜BKš
œB˜BKš
œ;˜;Kš
œ<˜<Kš
œ<˜<Kš
œ=˜=—š
¡$™$Lš
œ=˜=Kš
œ=˜=Kš
œ;˜;Kš
œ;˜;Kš
œ;˜;—š
¡>™>Lš
œ@˜@Kš
œ@˜@Kš
œ?˜?Kš
œ@˜@—š
¡™Lš
œ˜—š
¡:™:L–<[propList: 
Atom.PropList, prop: 
REF ANY, val: 
REF ANY]š
œY˜Y—š
¡™Lš
œÀ
˜À
Kš
π
˜Ä
Kš
œÁ
˜Á
Kš
π
˜Ä
Lš
œo˜oKš
œo˜oLš
œo˜oKš
œs˜sKš
œt˜tKš
œx˜xKš
œq˜qKš
œi˜iKš
œn˜n—K˜—L˜K˜<Lšžœ
˜™#K™—K™—…—N6g‘