-- File: DJExtTrans.mesa
-- combine routines used by the disjoint circuit extractor
-- Written by Martin Newell/Dan Fitzpatrick July 1981
-- Last edited: 12-Aug-81 13:54:07

DIRECTORY

DJExtAllocDefs: FROM "DJExtAllocDefs" USING [AllocateDiffusion, FreeDiffusion, AllocateTransistor, FreeTransistor],
DJExtCombineDefs: FROM "DJExtCombineDefs" USING [GetNode,AttachNode],
DJExtTransDefs: FROM "DJExtTransDefs",
DJExtMergeDefs: FROM "DJExtMergeDefs" USING [Lookup,LookSmall,IsSmall],
DJExtTypes: FROM "DJExtTypes" USING [Node, NodeRecord, Diffusion, NodeNumber],
Runtime: FROM "Runtime" USING [CallDebugger];
 
DJExtTrans: PROGRAM
IMPORTS DJExtAllocDefs, DJExtCombineDefs, DJExtMergeDefs, Runtime
EXPORTS DJExtTransDefs =
BEGIN
OPEN DJExtAllocDefs, DJExtCombineDefs, DJExtMergeDefs, DJExtTypes, Runtime;

AddDiff: PUBLIC PROCEDURE [trans:Node,node:NodeNumber,len:REAL] =
BEGIN
	diff:Diffusion;
	node _ Lookup[node];
	FOR ptr: Diffusion _ trans.diff,ptr.next UNTIL ptr = NIL DO
		ptr.node _ Lookup[ptr.node];
		IF ptr.node = node THEN {
			ptr.length _ ptr.length + len;
			RETURN;
			};
		ENDLOOP;
	diff _ AllocateDiffusion[];
	diff.node _ node;
	diff.length _ len;
	diff.next _ trans.diff;
	trans.diff _ diff;
	END;

FindTransistor: PUBLIC PROCEDURE [num:NodeNumber, x,y:REAL] RETURNS[node:Node] =
BEGIN
	node _ GetNode[num];
	IF node # NIL THEN RETURN;
	node _ MakeTransistor[x,y];
	node.node _ Lookup[num];
	AttachNode[node.node,node];
	END;

CombineTransistors: PUBLIC PROCEDURE [t1,t2:Node] RETURNS[Node] =
BEGIN
	next:Diffusion;
	FOR ptr: Diffusion _ t2.diff,next UNTIL ptr = NIL DO
		next _ ptr.next;
		AddDiff[t1,ptr.node,ptr.length];
		FreeDiffusion[ptr];
		ENDLOOP;
	IF t2.ion THEN t1.ion _ TRUE;
	IF t2.nion THEN t1.nion _ TRUE;
	t1.area _ t1.area + t2.area;
	t1.perim _ t1.perim + t2.perim;
	DeleteTransistor[t2];
	RETURN[t1];
	END;

ReleaseTransistor: PUBLIC PROCEDURE [trans:Node] =
BEGIN
	next:Diffusion;
	FOR ptr: Diffusion _ trans.diff,next UNTIL ptr = NIL DO
		next _ ptr.next;
		FreeDiffusion[ptr];
		ENDLOOP;
	 DeleteTransistor[trans];
	END;

CopyTrans: PUBLIC PROCEDURE[t:Node,offset:NodeNumber] RETURNS[trans:Node] =
BEGIN
	trans _ AllocateTransistor[];
	IF tList.next # NIL THEN tList.next.back _ trans;
	trans.next _ tList.next;
	trans.back _ @tList;
	tList.next _ trans;

	trans.node _ t.node+offset;
	trans.type _ Transistor;
	trans.poly _ t.poly+offset;
	trans.ion _ t.ion;
	trans.nion _ t.nion;
	trans.area _ t.area;
	trans.perim _ t.perim;
	trans.x _ t.x;
	trans.y _ t.y;
	trans.diff _ NIL;
	FOR d:Diffusion _ t.diff,d.next UNTIL d = NIL DO
		AddDiff[trans,d.node+offset,d.length];
		ENDLOOP;
	END;

MakeTransistor: PUBLIC PROCEDURE[x,y:REAL] RETURNS[trans:Node] =
BEGIN
	trans _ AllocateTransistor[];
	IF tList.next # NIL THEN tList.next.back _ trans;
	trans.next _ tList.next;
	trans.back _ @tList;
	tList.next _ trans;

	trans.node _ 0;
	trans.type _ Transistor;
	trans.poly _ 0;
	trans.diff _ NIL;
	trans.ion _ FALSE;
	trans.nion _ FALSE;
	trans.x _ x;
	trans.y _ y;
	trans.area _ trans.perim _ 0;
	END;

DeleteTransistor: PUBLIC PROCEDURE[trans:Node] =
BEGIN
	IF trans.next # NIL THEN trans.next.back _ trans.back;
	IF trans.back # NIL THEN trans.back.next _ trans.next
	 ELSE CallDebugger["messed up on doubly linked lists for transistors"];
	trans.type _ Unknown;
	FreeTransistor[trans];
	END;

GetTransistorList: PUBLIC PROCEDURE RETURNS[trans:Node] =
BEGIN
	trans _ tList.next;
	tList.next _ NIL;
	END;

SelectTransistors: PUBLIC PROCEDURE RETURNS[intTrans,extTrans:Node] =
BEGIN
	trans,next:Node;
	intTrans _ NIL;
	extTrans _ NIL;
	FOR trans _ GetTransistorList[],next UNTIL trans = NIL DO
		next _ trans.next;
		IF IsSmall[trans.node] THEN {
			-- it belongs on the external transistor list
			trans.next _ extTrans;
			extTrans _ trans;
			}
		 ELSE {
			-- it belongs on the internal transistor list
			trans.next _ intTrans;
			intTrans _ trans;
			};
		ENDLOOP;
	END;

AddDiffSmall: PROCEDURE [trans:Node,d:Diffusion] =
BEGIN
	d.node _ LookSmall[d.node];
	FOR ptr: Diffusion _ trans.diff,ptr.next UNTIL ptr = NIL DO
		IF ptr.node = d.node THEN {
			ptr.length _ ptr.length + d.length;
			FreeDiffusion[d];
			RETURN;
			};
		ENDLOOP;
	d.next _ trans.diff;
	trans.diff _ d;
	END;

RenumberTrans: PUBLIC PROCEDURE[trans:Node] =
BEGIN
	d,next: Diffusion;
	FOR trans _ trans,trans.next UNTIL trans = NIL DO
		trans.node _ LookSmall[trans.node];
		trans.poly _ LookSmall[trans.poly];
		d _ trans.diff;
		trans.diff _ NIL;
		FOR d _ d,next UNTIL d = NIL DO
			next _ d.next;
			-- do a AddDiff without using Lookup
			AddDiffSmall[trans,d];
			ENDLOOP;
		ENDLOOP;
	END;

tList: trans NodeRecord;

tList.next _ NIL;
tList.back _ NIL;

END.
(672)\178b10B428b10B185b8B406b14B213b19B382b17B200b9B557b14B395b16B277b17B94b17B229i42I69i42I71b13B299b13B282i33I