-- procedure exporting module of silicon (pretty picture) program
-- last modified by McCreight, January 30, 1984 4:38 PM
-- to clean up buried contacts
-- modified by Dillon, March 14, 1984 6:49 PM
-- to reduce buried contact depletion extention to 1 lambda

DIRECTORY
SegmentDefs,
StringDefs,
ppddefs,
ppdddefs,pppdefs,
ppdefs;
ppprocs8: PROGRAM IMPORTS pppdefs EXPORTS pppdefs =
BEGIN OPEN ppdefs, ppddefs, pppdefs, SegmentDefs;

drPu0: PUBLIC drProc =
BEGIN
p: LONG POINTER TO xstr object = LOOPHOLE[ob];
IF x-p.surround > pr.r.x2 OR y-p.surround > pr.r.y2
OR x + p.size[0] +p.surround < pr.r.x1
OR y + p.size[1]+p.surround < pr.r.y1 THEN RETURN
ELSE
BEGIN
x1: locNum = x + p.wExt;
y1: locNum = y + p.lExt;
middleX: locNum = x + p.size[0]/2;
metal: Rect = [x1: middleX-2*Lambda, y1:y+p.size[1]-6*Lambda,
x2: middleX+2*Lambda, y2: y+p.size[1]];
pr.orArea[x1, y, x1 + p.width, y+p.size[1], p.l, @pr.r];
pr.orArea[x, y1, x + p.size[0], y1 + p.length, pol, @pr.r];
pr.orArea[x, y, x + p.size[0], metal.y2-Lambda,
imp, @pr.r];
pr.orArea[metal.x1, metal.y1+2*Lambda, metal.x2, metal.y2,
p.l, @pr.r];
pr.orArea[metal.x1, metal.y1, metal.x2, metal.y2, met, @pr.r];
pr.saveArea[metal.x1+Lambda, metal.y1+Lambda,
metal.x2-Lambda, metal.y2-Lambda, cut, @pr.r];
IF p.l=pdif THEN
pr.orArea[x-p.surround, y-p.surround, x + p.size[0]+p.surround,
y + p.size[1]+p.surround, nwel, @pr.r];
END;
END;

drPu2: PUBLIC drProc =
{drArb[drPu0, 4, ob, x, y, pr]};

drPu4: PUBLIC drProc =
{drArb[drPu0, 8, ob, x, y, pr]};

drPu6: PUBLIC drProc =
{drArb[drPu0, 12, ob, x, y, pr]};

drWire0: PUBLIC drProc =
BEGIN
p: LONG POINTER TO wire object = LOOPHOLE[ob];
IF x > pr.r.x2 OR y > pr.r.y2 OR x + p.size[0] < pr.r.x1
OR y + p.size[1] < pr.r.y1 THEN RETURN;
pr.orArea[x, y, x + p.size[0], y + p.size[1], p.l, @pr.r];
END;

drWire2: PUBLIC drProc =
BEGIN
p: LONG POINTER TO wire object = LOOPHOLE[ob];
IF x > pr.r.x2 OR y > pr.r.y2 OR x + p.size[1] < pr.r.x1
OR y + p.size[0] < pr.r.y1 THEN RETURN;
pr.orArea[x, y, x + p.size[1], y + p.size[0], p.l, @pr.r];
END;

drDifWire0: PUBLIC drProc =
BEGIN
p: LONG POINTER TO wire object = LOOPHOLE[ob];
IF x-p.surround > pr.r.x2 OR y-p.surround > pr.r.y2
OR x + p.size[0] +p.surround < pr.r.x1
OR y + p.size[1]+p.surround < pr.r.y1 THEN RETURN;
IF p.l=pdif THEN
pr.orArea[x-p.surround, y-p.surround, x + p.size[0]+p.surround,
y + p.size[1]+p.surround, nwel, @pr.r];
pr.orArea[x, y, x + p.size[0], y + p.size[1], p.l, @pr.r];
END;

drDifWire2: PUBLIC drProc =
BEGIN
p: LONG POINTER TO wire object = LOOPHOLE[ob];
IF x-p.surround > pr.r.x2 OR y-p.surround > pr.r.y2
OR x + p.size[1] +p.surround < pr.r.x1
OR y + p.size[0]+p.surround < pr.r.y1 THEN RETURN;
IF p.l=pdif THEN
pr.orArea[x-p.surround, y-p.surround, x + p.size[1]+p.surround,
y + p.size[0]+p.surround, nwel, @pr.r];
pr.orArea[x, y, x + p.size[1], y + p.size[0], p.l, @pr.r];
END;

drBC0: PUBLIC drProc =
BEGIN
p: LONG POINTER TO cont object = LOOPHOLE[ob];
IF x-p.surround > pr.r.x2 OR y-p.surround > pr.r.y2
OR x + p.size[0] +p.surround < pr.r.x1
OR y + p.size[1]+p.surround < pr.r.y1 THEN RETURN;
pr.orArea[x, y, x + p.size[0], y + p.size[1], met, @pr.r];
pr.orArea[x, y, x + p.size[0], y + p.size[1]/2, pol, @pr.r];
pr.orArea[x, y + p.magicN*2, x + p.size[0], y + p.size[1], p.l, @pr.r];
pr.saveArea[
x + p.magicN, y + p.magicN, x - p.magicN + p.size[0],
y + p.magicN + p.size[0], cut, @pr.r];
IF p.l=pdif THEN
pr.orArea[x-p.surround, y-p.surround, x + p.size[0]+p.surround,
y + p.size[1]+p.surround, nwel, @pr.r];
END;

drBC2: PUBLIC drProc =
{drArb[drBC0, 4, ob, x, y, pr]};

drBC4: PUBLIC drProc =
{drArb[drBC0, 8, ob, x, y, pr]};

drBC6: PUBLIC drProc =
{drArb[drBC0, 12, ob, x, y, pr]};

drDC0: PUBLIC drProc =
BEGIN
p: LONG POINTER TO cont object = LOOPHOLE[ob];
IF x-p.surround > pr.r.x2 OR y-p.surround > pr.r.y2
OR x + p.size[0] +p.surround < pr.r.x1
OR y + p.size[1]+p.surround < pr.r.y1 THEN RETURN;
pr.orArea[x, y, x + p.size[0], y + p.size[1], met, @pr.r];
pr.orArea[x, y, x + p.size[0], y + p.size[1], p.l, @pr.r];
pr.saveArea[
x + p.magicN, y + p.magicN, x - p.magicN + p.size[0],
y - p.magicN + p.size[1], cut, @pr.r];
IF p.l=pdif THEN
pr.orArea[x-p.surround, y-p.surround, x + p.size[0]+p.surround,
y + p.size[1]+p.surround, nwel, @pr.r];
END;

drDC2: PUBLIC drProc =
BEGIN
p: LONG POINTER TO cont object = LOOPHOLE[ob];
IF x-p.surround > pr.r.x2 OR y-p.surround > pr.r.y2
OR x + p.size[1] +p.surround < pr.r.x1
OR y + p.size[0]+p.surround < pr.r.y1 THEN RETURN;
pr.orArea[x, y, x + p.size[1], y + p.size[0], met, @pr.r];
pr.orArea[x, y, x + p.size[1], y + p.size[0], p.l, @pr.r];
pr.saveArea[
x + p.magicN, y + p.magicN, x - p.magicN + p.size[1],
y - p.magicN + p.size[0], cut, @pr.r];
IF p.l=pdif THEN
pr.orArea[x-p.surround, y-p.surround, x + p.size[1]+p.surround,
y + p.size[0]+p.surround, nwel, @pr.r];
END;


drMM0: PUBLIC drProc =
BEGIN
p: LONG POINTER TO cont object = LOOPHOLE[ob];
IF x > pr.r.x2 OR y > pr.r.y2 OR x + p.size[0] < pr.r.x1
OR y + p.size[1] < pr.r.y1 THEN RETURN;
pr.orArea[x, y, x + p.size[0], y + p.size[1], met, @pr.r];
pr.orArea[x, y, x + p.size[0], y + p.size[1], met2, @pr.r];
pr.saveArea[
x + p.magicN, y + p.magicN, x - p.magicN + p.size[0],
y - p.magicN + p.size[1], cut2, @pr.r];
END;

drMM2: PUBLIC drProc =
BEGIN
p: LONG POINTER TO cont object = LOOPHOLE[ob];
IF x > pr.r.x2 OR y > pr.r.y2 OR x + p.size[1] < pr.r.x1
OR y + p.size[0] < pr.r.y1 THEN RETURN;
pr.orArea[x, y, x + p.size[1], y + p.size[0], met, @pr.r];
pr.orArea[x, y, x + p.size[1], y + p.size[0], met2, @pr.r];
pr.saveArea[
x + p.magicN, y + p.magicN, x - p.magicN + p.size[1],
y - p.magicN + p.size[0], cut2, @pr.r];
END;

drBuC0: PUBLIC drProc =
BEGIN
p: LONG POINTER TO cont object = LOOPHOLE[ob];
burAct: locNum = 2*lambda;

dBur: locNum = lambda/2;
difBur: Point;

IF x-p.surround > pr.r.x2 OR y-p.surround > pr.r.y2
OR x + p.size[0] +p.surround < pr.r.x1
OR y + p.size[1]+p.surround < pr.r.y1 THEN RETURN;

pr.saveArea[x+dBur, y+dBur, x+p.size[0]-dBur, y+p.size[1]-dBur, bur, @pr.r];
pr.orArea[x+burAct, y+p.lExt, x+p.size[0]-p.wExt, y+p.size[1]-p.lExt, pol, @pr.r];
difBur ← [
x: (IF p.wExt<burAct THEN MAX[p.wExt+lambda, burAct] ELSE (p.wExt-lambda)),
y: (IF p.lExt<burAct THEN MAX[p.lExt+lambda, burAct] ELSE (p.lExt-lambda))];
pr.orArea[x+lambda, y+difBur.y, x+p.size[0]-difBur.x, y+p.size[1]-difBur.y, p.l, @pr.r];
IF p.l=pdif THEN
pr.orArea[x+lambda-p.surround, y+difBur.y-p.surround, x + p.size[0]-difBur.x+p.surround,
y+p.size[1]-difBur.y+p.surround, nwel, @pr.r];
END;

drBuC2: PUBLIC drProc =
{drArb[drBuC0, 4, ob, x, y, pr]};

drBuC4: PUBLIC drProc =
{drArb[drBuC0, 8, ob, x, y, pr]};

drBuC6: PUBLIC drProc =
{drArb[drBuC0, 12, ob, x, y, pr]};



drDifShort0: PUBLIC drProc =
BEGIN
p: LONG POINTER TO cont object = LOOPHOLE[ob];
IF x-p.surround > pr.r.x2 OR y-p.surround > pr.r.y2
OR x + p.size[0] +p.surround < pr.r.x1
OR y + p.size[1]+p.surround < pr.r.y1 THEN RETURN;
pr.orArea[x, y, x + p.size[0], y + p.size[1], met, @pr.r];
pr.orArea[x, y, x + p.size[0], y + p.size[1]/2, p.l, @pr.r];
pr.orArea[x, y + p.size[1]/2, x + p.size[0], y + p.size[1],
(SELECT p.l FROM
dif => pwelCont,
pdif => nwelCont,
ENDCASE => ERROR), @pr.r];
pr.saveArea[
x + p.magicN, y + p.magicN, x - p.magicN + p.size[0],
y + p.magicN+2*Lambda, cut, @pr.r];
pr.saveArea[
x + p.magicN, y + p.size[1] - p.magicN-2*Lambda,
x - p.magicN + p.size[0], y + p.size[1] - p.magicN, cut, @pr.r];
IF p.l=pdif THEN
pr.orArea[x-p.surround, y-p.surround, x + p.size[0]+p.surround,
y + p.size[1]/2+p.surround, nwel, @pr.r];
END;

drDifShort2: PUBLIC drProc =
{drArb[drDifShort0, 4, ob, x, y, pr]};

drDifShort4: PUBLIC drProc =
{drArb[drDifShort0, 8, ob, x, y, pr]};

drDifShort6: PUBLIC drProc =
{drArb[drDifShort0, 12, ob, x, y, pr]};


drBus0: PUBLIC drProc =
BEGIN
p: LONG POINTER TO bus object = LOOPHOLE[ob];
len,wid:INTEGER;
IF x-p.surround > pr.r.x2 OR y-p.surround > pr.r.y2
OR x + p.size[0] +p.surround < pr.r.x1
OR y + p.size[1]+p.surround < pr.r.y1 THEN RETURN;
IF p.l=pdif THEN
pr.orArea[x-p.surround, y-p.surround, x + p.size[0]+p.surround,
y + p.size[1]+p.surround, nwel, @pr.r];
wid←p.wwidth;
len←p.firstLength;
y←y+p.offsetFirst;
THROUGH [0..p.wCnt) DO
pr.orArea[x,y,x+wid,y+len,p.l,@pr.r];
x←x+p.wspace;
y←y+p.topIncr;
len←len+p.lenIncr;
ENDLOOP;
END;

drBus2: PUBLIC drProc =
{drArb[drBus0, 4, ob, x, y, pr]};

drBus4: PUBLIC drProc =
{drArb[drBus0, 8, ob, x, y, pr]};

drBus6: PUBLIC drProc =
{drArb[drBus0, 12, ob, x, y, pr]};

drBusR0: PUBLIC drProc =
{drArb[drBus0, 1, ob, x, y, pr]};

drBusR2: PUBLIC drProc =
{drArb[drBus0, 5, ob, x, y, pr]};

drBusR4: PUBLIC drProc =
{drArb[drBus0, 9, ob, x, y, pr]};

drBusR6: PUBLIC drProc =
{drArb[drBus0, 13, ob, x, y, pr]};


END.