-- File CIFExtNMOS2Defs.mesa
-- Written by Martin Newell, June 1980
-- Last updated: December 8, 1981  4:52 PM by CK

-- CIF Circuit Extractor NMOS dependent procedures

DIRECTORY CIFDevicesDefs, CIFExtDictDefs, CIFExtIODefs, CIFExtScanDefs, CIFExtUtilsDefs, RealFns, IODefs, MergeDefs, Real, SystemDefs, StreamDefs, StringDefs, SegmentDefs, XFSPDefs, CWF, CWFReal;



CIFExtNMOS2Defs: DEFINITIONS
IMPORTS CIFDevicesDefs, CIFExtDictDefs, CIFExtIODefs, CIFExtScanDefs, CIFExtUtilsDefs, RealFns, IODefs, MergeDefs, Real, SystemDefs, StreamDefs, StringDefs, SegmentDefs, XFSPDefs, CWF, CWFReal =

BEGIN
OPEN CIFDevicesDefs, CIFExtDictDefs, CIFExtIODefs, CIFExtScanDefs, CIFExtUtilsDefs, RealFns, IODefs, MergeDefs, Real, SystemDefs, StreamDefs, StringDefs, SegmentDefs, XFSPDefs;


ErrorFlag: BOOLEAN;	-- true when errors are on .extlog
AliasFlag: BOOLEAN;	-- true when aliases are on .al

NoEnhaTrans, NoDeplTrans: LONG CARDINAL;

NodeNumberType: TYPE = LONG POINTER;
Transistor: TYPE = LONG POINTER TO TransistorRecord;
TransistorRecord: TYPE = RECORD[
	link: Transistor,
	polyNumber: NodeNumberType,
	diffList: LONG POINTER TO DiffRecord,
	ion: BOOLEAN,
	marked: BOOLEAN,
	old: BOOLEAN,
	newNode: Transistor,
	area,circumference: REAL,
	x, y: REAL
  ];

FreeTransistors, AllocatedTransistors: Transistor;
FreeTransCount: CARDINAL;
TransAllocConstant: CARDINAL = 32;
CapacitorFile, TransistorFile: DiskHandle;
NodeFile, OutNodeFile: DiskHandle;
errorStream, out1: DiskHandle;
tmpErrorStream, defaultStream: StreamHandle;
--LabelLocationFile, -- LabelNodeFile: DiskHandle;

FreeDiffRecords: LONG POINTER TO DiffRecord;
DiffRecord: TYPE = RECORD [
	next: LONG POINTER TO DiffRecord,
	number: NodeNumberType,
	length: REAL
	];
FreeNodeSegments: NodeSegment;
NodeSegment: TYPE = LONG POINTER TO NodeSegmentRecord;
NodeSegmentRecord: TYPE = RECORD [
	next: NodeSegment,
	number: NodeNumberType,
	left: REAL,
	right: REAL,
	mark: BOOLEAN,
	transistor: SELECT COMPUTED BOOLEAN FROM
		TRUE => [
				leftLength: REAL,
				rightLength: REAL],
		FALSE => [
				circumference, area: ARRAY [1 .. 4] OF REAL],
		ENDCASE
];

Layers: TYPE = [diff .. metal];

CapRecord: TYPE = RECORD [
	number: NodeNumberType,
	layer: Layers,
	perimeter, area: REAL
];

FreeNodeLabels: NodeLabel;
NodeLabel: TYPE = LONG POINTER TO NodeLabelRecord;
NodeLabelRecord: TYPE = RECORD [
	next: NodeLabel,
	label: STRING,
	x,y: REAL,
	layer: CARDINAL,
	used: BOOLEAN
	];
LabelList: NodeLabel;

YCurr, YPrev: REAL;
Scale: REAL;

newNodeList, oldNodeList, NodeList: ARRAY [0..MaxLENGTHLayerArray+2] OF NodeSegment;
ptrnewNodeList: ARRAY [0..MaxLENGTHLayerArray+2] OF LONG POINTER TO NodeSegment;
NodeNumber: NodeNumberType;

NoAllocTrans,NoAllocDiffRecord, NoAllocNodeSegment, NoAllocNodeLabel, NoAllocString: LONG CARDINAL;
scanCount, displayCount: CARDINAL;

BaseFileName: STRING;

one: REAL = 1;
half: REAL = 0.5;

trapleft: ARRAY [0..MaxLENGTHLayerArray+2] OF Edge;
implant: CARDINAL = 0;
diff: CARDINAL = 1;
poly: CARDINAL = 2;
contact: CARDINAL = 3;
metal: CARDINAL = 4;
buried: CARDINAL = 5;
glass: CARDINAL = 6;
undef: CARDINAL = 7;
depl: CARDINAL;
enha: CARDINAL;




SetPoly: PROCEDURE [trans: Transistor, polyNumber: NodeNumberType] = INLINE
	BEGIN
	IF trans.polyNumber = NIL  THEN BEGIN
		trans.polyNumber _ polyNumber;
		RETURN;
		END;
	END;


SetDiff: PROCEDURE [trans: Transistor, diffNumber: NodeNumberType, length: REAL] = INLINE
	BEGIN
	diffptr, newptr: LONG POINTER TO DiffRecord;
	-- Check to see that diffNumber is not already in diffusion list
	FOR diffptr _ trans.diffList, diffptr.next
		UNTIL diffptr = NIL DO
		IF diffptr.number = diffNumber THEN BEGIN
			diffptr.length _ diffptr.length + length;
			RETURN;
			END;
		ENDLOOP;
	-- diffNumber is not in diffusion list so enter it at the front of the list
	-- on the assumption that this new diffusion number is likely to reappear
	-- and therefore must be searched for.
	newptr _ AllocateDiffRecord[];
	newptr.number _ diffNumber;
	newptr.length _ length;
	newptr.next _ trans.diffList;
	trans.diffList _ newptr;
	END;

GenNodeNumber: PROCEDURE [layer: CARDINAL] RETURNS[NodeNumberType];

MakeTransistor: PROCEDURE	RETURNS[trans: Transistor];

FreeTransistor: PROCEDURE[trans: Transistor];

AllocateTransistor: PROCEDURE RETURNS[trans: Transistor];

CollectTransistors: PROCEDURE;

OutputTransistors: PROCEDURE = INLINE
	BEGIN
	NodeList[depl] _ NIL;
	newNodeList[depl] _ NIL;
	NodeList[enha] _ NIL;
	newNodeList[enha] _ NIL;
	CollectTransistors;		-- Writes all the remaining transistors
	ReleaseTransistors[];	-- Free core space
	END;

ReleaseTransistors: PROCEDURE;

AllocateDiffRecord: PROCEDURE RETURNS[d: LONG POINTER TO DiffRecord];

FreeDiffRecord: PROCEDURE[diffptr: LONG POINTER TO DiffRecord];

NodeToTransistor: PROCEDURE [node: NodeNumberType] RETURNS[trans: Transistor] = INLINE
	BEGIN
	temp: Transistor _ node;
	FOR trans _ temp, trans.newNode WHILE trans.old DO ENDLOOP;
	temp.newNode _ trans;	-- This avoids chasing pointers several times
	END;


MakeNodeSegment: PROCEDURE[nodeNumber: NodeNumberType, left,right: REAL, trans:BOOLEAN _ FALSE]
		RETURNS[nodeSegment: NodeSegment];

AllocateNodeSegment: PROCEDURE[trans: BOOLEAN] RETURNS[ns: NodeSegment];

FreeNodeSegment: PROCEDURE[nodeSegment: NodeSegment];

Combine: PROCEDURE[n1,n2: NodeSegment, layer: CARDINAL];

EqualToNodeNumber: PROCEDURE[n,m: NodeNumberType] RETURNS[BOOLEAN] = INLINE
	BEGIN
	RETURN[ LOOPHOLE[n,LONG CARDINAL] = LOOPHOLE[m,LONG CARDINAL] ];
	END;

LessThanNodeNumber: PROCEDURE[n,m: NodeNumberType] RETURNS[BOOLEAN] = INLINE
	BEGIN
	RETURN[ LOOPHOLE[n,LONG CARDINAL] < LOOPHOLE[m,LONG CARDINAL] ];
	END;

WriteNodeNumber: PROCEDURE[n: NodeNumberType];

WriteNodeName: PROCEDURE[n: NodeNumberType];

GetNodeNumber: PROCEDURE [s: DiskHandle] RETURNS[x: NodeNumberType];

PutNodeNumber: PROCEDURE [x: NodeNumberType, s: DiskHandle];

ConvertTransToText: PROCEDURE [s:StreamHandle];

WriteLocation: PROCEDURE[x,y: REAL, s:StreamHandle];

WriteCapacitor: PROCEDURE[n: NodeSegment, s:StreamHandle];

WriteNodeCap: PROCEDURE[n: NodeSegment, s:DiskHandle];

ReadCapacitor: PROCEDURE[s:DiskHandle, n: POINTER TO CapRecord];

EnterCapacitor: PROCEDURE[newNode: POINTER TO CapRecord];

WriteTransistor: PROCEDURE[n: Transistor];

CorrectLabelNodes: PROCEDURE [name: STRING];

WriteNodeLocation: PROCEDURE[n: NodeNumberType, x,y: REAL, layer:CARDINAL];

WriteNodeLabel: PROCEDURE[label: NodeLabel, n: NodeNumberType];

AllocateNodeLabel: PROCEDURE RETURNS[n: NodeLabel];

FreeNodeLabel: PROCEDURE [n: NodeLabel];

PrintAllocation: PROCEDURE[force: BOOLEAN];

PrintTransistors: PROCEDURE;

WriteFloat: PROCEDURE[r: REAL];

SetErrorStream: PROCEDURE[p: BOOLEAN];

ResetErrorStream: PROCEDURE[];


END.
(635)\170b9B190b15B449b1B51b1B2249b7B173b7B732b13B56b14B41b14B33b18B40b19B14b17B237b18B14b18B53b14B51b16B242b15B119b19B55b15B40b7B50b18B138b19B138b16B32b14B32b14B56b14B48b19B30b14B41b14B46b12B44b13B53b16B42b16B29b17B29b17B59b15B51b17B35b14B29b15B30b16B14b10B23b14B26b16B15b1B