-- procedure exporting module of silicon (pretty picture) program
-- last modified by McCreight, December 3, 1982  9:40 AM
--  to remove repeated objects

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

  anyChanges, sinceIOchanges: PUBLIC BOOLEAN _ FALSE;

  Width: TYPE = locNum _ 0;
  minWidthAr: PUBLIC ARRAY level OF Width _ [
    cut: 2*Lambda,
    dif: 2*Lambda,
    pol: 2*Lambda,
    met: 3*Lambda,
    cut2: 3*Lambda,
    pdif: 2*Lambda,
    met2: 4*Lambda];

  bwGrain: PUBLIC INTEGER _ 10;
  colGrain: PUBLIC INTEGER _ 1;


  wireList: PUBLIC ARRAY level OF LONG POINTER TO wire object _ ALL[NIL];
  tranList: PUBLIC LONG POINTER TO xstr object _ NIL;
  puList: PUBLIC LONG POINTER TO xstr object _ NIL;
  contList: PUBLIC LONG POINTER TO cont object _ NIL;

  textProcs:Procs _ [
    drawme:ALL[drText],inBox:rectIB,inMe:inMeRect,release:nullRel,
    anotherme:permAnother,setParm:setNullParm];
  rectProcs:Procs _ [
    drawme:[
    drRect0,drRect0,drRect0,drRect0,drRect2,drRect2,drRect2,drRect2,
    drRect0,drRect0,drRect0,drRect0,drRect2,drRect2,drRect2,drRect2],
    inBox:rectIB,inMe:inMeRect,release:refCntRelease,anotherme:permAnother,
    setParm:setWireParm];
  xstrProcs:Procs _ [
    drawme:[
    drXstr0,drXstr0,drXstr0,drXstr0,drXstr2,drXstr2,drXstr2,drXstr2,
    drXstr0,drXstr0,drXstr0,drXstr0,drXstr2,drXstr2,drXstr2,drXstr2],
    inBox:rectIB,inMe:inMeRect,release:refCntRelease,anotherme:permAnother,
    setParm:setXstrParm];
  pxstrProcs:Procs _ [
    drawme:[
    drXstr0,drXstr0,drXstr0,drXstr0,drXstr2,drXstr2,drXstr2,drXstr2,
    drXstr0,drXstr0,drXstr0,drXstr0,drXstr2,drXstr2,drXstr2,drXstr2],
    inBox:rectIB,inMe:inMeRect,release:refCntRelease,anotherme:permAnother,
    setParm:setPXstrParm];
  angxstrProcs:Procs _ [
    drawme:[
    drAXstr0,drAXstrR0,drAXstr0,drAXstrR0,drAXstr2,drAXstrR2,drAXstr2,drAXstrR2,
    drAXstr4,drAXstrR4,drAXstr4,drAXstrR4,drAXstr6,drAXstrR6,drAXstr6,drAXstrR6],
    inBox:rectIB,inMe:inMeRect,release:refCntRelease,anotherme:permAnother,
    setParm:setAXstrParm];

  cellProcs:Procs _ [
    drawme:[
    drCell0,drCell0R,drCell0,drCell0R,drCell2,drCell2R,drCell2,drCell2R,
    drCell4,drCell4R,drCell4,drCell4R,drCell6,drCell6R,drCell6,drCell6R],
    inBox:rectIB,inMe:inMeRect,release:cellRel,anotherme:permAnother,
    setParm:setNullParm];
  wireProcs:Procs _ [
    drawme:[
    drWire0,drWire0,drWire0,drWire0,drWire2,drWire2,drWire2,drWire2,
    drWire0,drWire0,drWire0,drWire0,drWire2,drWire2,drWire2,drWire2],
    inBox:rectIB,inMe:inMeRect,release:refCntRelease,anotherme:permAnother,
    setParm:setWireParm];
  pwireProcs:Procs _ [
    drawme:[
    drPWire0,drPWire0,drPWire0,drPWire0,drPWire2,drPWire2,drPWire2,drPWire2,
    drPWire0,drPWire0,drPWire0,drPWire0,drPWire2,drPWire2,drPWire2,drPWire2],
    inBox:rectIB,inMe:inMeRect,release:refCntRelease,anotherme:permAnother,
    setParm:setWireParm];

  busProcs:Procs _ [
    drawme:[
    drBus0,drBusR0,drBus0,drBusR0,drBus2,drBusR2,drBus2,drBusR2,
    drBus4,drBusR4,drBus4,drBusR4,drBus6,drBusR6,drBus6,drBusR6],
    inBox:rectIB,inMe:inMeRect,release:uniqueRelease,anotherme:busAnother,
    setParm:setBusParm];
  puProcs:Procs _ [
    drawme:[
    drPu0,drPu0,drPu0,drPu0,drPu2,drPu6,drPu2,drPu6,drPu4,drPu4,drPu4,
    drPu4,drPu6,drPu2,drPu6,drPu2],inBox:rectIB,inMe:inMeRect,
    release:refCntRelease,anotherme:permAnother,setParm:setPuParm];
  bcProcs:Procs _ [
    drawme:[
    drBC0,drBC0,drBC0,drBC0,drBC2,drBC6,drBC2,drBC6,drBC4,drBC4,drBC4,
    drBC4,drBC6,drBC2,drBC6,drBC2],inBox:rectIB,inMe:inMeRect,
    release:nullRel,anotherme:permAnother,setParm:setNullParm];
  mcProcs:Procs _ [
    drawme:[
    drMDC0,drMDC0,drMDC0,drMDC0,drMDC2,drMDC2,drMDC2,drMDC2,drMDC0,drMDC0,
    drMDC0,drMDC0,drMDC2,drMDC2,drMDC2,drMDC2],inBox:rectIB,inMe:inMeRect,
    release:refCntRelease,anotherme:permAnother,setParm:setContParm];
  dcProcs:Procs _ [
    drawme:[
    drDC0,drDC0,drDC0,drDC0,drDC2,drDC2,drDC2,drDC2,drDC0,drDC0,drDC0,
    drDC0,drDC2,drDC2,drDC2,drDC2],inBox:rectIB,inMe:inMeRect,
    release:refCntRelease,anotherme:permAnother,setParm:setContParm];
  mpdcProcs:Procs _ [
    drawme:[
    drMPDC0,drMPDC0,drMPDC0,drMPDC0,drMPDC2,drMPDC2,drMPDC2,drMPDC2,
	drMPDC0,drMPDC0,drMPDC0,
    drMPDC0,drMPDC2,drMPDC2,drMPDC2,drMPDC2],inBox:rectIB,inMe:inMeRect,
    release:refCntRelease,anotherme:permAnother,setParm:setContParm];
  pdcProcs:Procs _ [
    drawme:[
    drPDC0,drPDC0,drPDC0,drPDC0,drPDC2,drPDC2,drPDC2,drPDC2,
	drPDC0,drPDC0,drPDC0,
    drPDC0,drPDC2,drPDC2,drPDC2,drPDC2],inBox:rectIB,inMe:inMeRect,
    release:refCntRelease,anotherme:permAnother,setParm:setContParm];
  bucProcs:Procs _ [
    drawme:[
    drBuC0,drBuC4,drBuC0,drBuC4,drBuC2,drBuC2,drBuC2,drBuC2,
	drBuC4,drBuC0,drBuC4,drBuC0,drBuC6,drBuC6,drBuC6,drBuC6],
	inBox:rectIB,inMe:inMeRect,
    release:refCntRelease,anotherme:permAnother,setParm:setBuContParm];
  mmcProcs:Procs _ [
    drawme:[
    drMM0,drMM0,drMM0,drMM0,drMM2,drMM2,drMM2,drMM2,drMM0,drMM0,drMM0,
    drMM0,drMM2,drMM2,drMM2,drMM2],inBox:rectIB,inMe:inMeRect,
    release:refCntRelease,anotherme:permAnother,setParm:setContParm];
  bcObject:cont object _ [
    p:@bcProcs,size:[butconSX,butconSY,butconSX],l:cut,refCnt:0,
    returnable:FALSE,marked:FALSE,
    varpart:cont[typ:butt,magicN:butconSX/4]];
  cnTextProcs:Procs _ [
    drawme:ALL[drCnText],inBox:rectIB,inMe:inMeRect,release:cnRelease,
    anotherme:permAnother,setParm:setNullParm];

  nullRel: relProc = BEGIN ob.refCnt _ ob.refCnt - 1; END;
  refCntRelease: relProc =
    BEGIN
    ob.refCnt _ ob.refCnt - 1;
    --	IF ob.refCnt>1 THEN ob.refCnt_ob.refCnt-1
    --	 ELSE FreeSpace[ob];
    END;
  cellRel: relProc =
    BEGIN
    cc: LONG POINTER TO cell object;
    ob.refCnt _ ob.refCnt - 1;
    IF ob.refCnt > 0 OR NOT ob.returnable THEN RETURN;
    cc _ LOOPHOLE[ob];
    flushDel[cc.ptr];
    freeCell[cc];
    END;
  cnRelease: relProc =
    BEGIN
    p: LONG POINTER TO cnText object = LOOPHOLE[ob];
    FreeString[p.s];
    FreeSpace[ob];
    END;
  uniqueRelease: relProc =
    BEGIN
    FreeSpace[ob];
    END;

  permAnother: anoProc = BEGIN ob.refCnt _ ob.refCnt + 1; RETURN[ob]; END;
  busAnother: anoProc =
    BEGIN
    nob:LONG POINTER TO bus object _ alocBusD[];
    oob:LONG POINTER TO bus object = LOOPHOLE[ob];
    nob^_oob^;
    RETURN[nob];
    END;

  makePullup: PUBLIC PROCEDURE [w,l:INTEGER,wExt:INTEGER_wXExtension,lExt:INTEGER_lXExtension]
    RETURNS [p: LONG POINTER TO object] =
    BEGIN
    dp: LONG POINTER TO xstr object _ puList;
    w _ MAX[w, 2*Lambda];
    l _ MAX[l, 2*Lambda];
    wExt _ MAX[wExt, 0];
    lExt _ MAX[lExt, 0];
    WHILE dp # NIL DO
      IF dp.width = w AND dp.length = l
         AND dp.wExt = wExt AND dp.lExt = lExt AND dp.l=dif
	 THEN BEGIN p _ dp.p.anotherme[dp]; RETURN; END;
      dp _ dp.super;
      ENDLOOP;
    p _ dp _ alocXstrD[];
    dp.super _ puList;
    puList _ dp;
    p^.p _ @puProcs;
    dp^.l _ dif;
    dp^.width _ w;
    dp^.length _ l;
    dp^.wExt _ wExt;
    dp^.lExt _ lExt;
    dp^.impl _ TRUE;
    dp^.pullup _ TRUE;
    dp^.size[0] _ dp^.size[2] _
      MAX[dp.width + dp.wExt*2, 4*Lambda];
    dp^.size[1] _ MAX[dp.length + dp.lExt + 3*Lambda, 6*Lambda];
    END; -- of makePullup

  makeXstr: PUBLIC PROCEDURE [w, l: INTEGER, imp: BOOLEAN _ FALSE
    , wExt: INTEGER _ wXExtension, lExt: INTEGER _ lXExtension]
    RETURNS [p: LONG POINTER TO object] =
    BEGIN
    dp: LONG POINTER TO xstr object _ tranList;
    w _ MAX[w, 2*Lambda];
    l _ MAX[l, 2*Lambda];
    wExt _ MAX[wExt, 0];
    lExt _ MAX[lExt, 0];
    WHILE dp # NIL DO
      IF dp.width = w AND dp.length = l AND dp.impl = imp
         AND dp.wExt = wExt AND dp.lExt = lExt AND NOT dp.angle AND dp.l=dif
        THEN
        BEGIN p _ dp.p.anotherme[dp]; RETURN; END;
      dp _ dp.super;
      ENDLOOP;
    p _ dp _ alocXstrD[];
    dp.super _ tranList;
    tranList _ dp;
    p^.p _ @xstrProcs;
    dp^.l _ dif;
    dp^.width _ w;
    dp^.length _ l;
    dp^.wExt _ wExt;
    dp^.lExt _ lExt;
    dp^.impl _ imp;
    dp^.pullup _ FALSE;
    dp^.size[0] _ dp^.size[2] _ dp.width + dp.wExt*2;
    dp^.size[1] _ dp.length + dp.lExt*2;
    END; -- of makeXstr

  makeAngleXstr: PUBLIC PROCEDURE [w, l: INTEGER, imp: BOOLEAN _ FALSE
    , wExt: INTEGER _ wXExtension, lExt: INTEGER _ lXExtension,aExt:INTEGER_0]
    RETURNS [p: LONG POINTER TO object] =
    BEGIN
    dp: LONG POINTER TO xstr object _ tranList;
    siz1:INTEGER;
    wExt _ MAX[wExt, 0];
    lExt _ MAX[lExt, 0];
    aExt _ MAX[aExt, -lExt];
    l _ MAX[l, 2*Lambda];
    w _ MAX[w, 2*lExt]; -- the width of the straight-line
      -- parts of the gate, excluding the corner
    siz1 _ wExt+2*lExt+aExt+l;
    WHILE dp # NIL DO
      IF dp.width = w AND dp.length = l AND dp.impl = imp AND dp.wExt=wExt
	 AND dp.lExt=lExt AND dp.angle AND dp.size[1]=siz1 AND dp.l=dif
        THEN
        BEGIN p _ dp.p.anotherme[dp]; RETURN; END;
      dp _ dp.super;
      ENDLOOP;
    p _ dp _ alocXstrD[];
    dp.super _ tranList;
    tranList _ dp;
    p^.p _ @angxstrProcs;
    dp^.l _ dif;
    dp^.width _ w;
    dp^.length _ l;
    dp^.wExt _ wExt;
    dp^.lExt _ lExt;
    dp^.impl _ imp;
    dp^.angle _ TRUE;
    dp^.pullup _ FALSE;
    dp^.size[0] _ dp^.size[2] _ wExt+(w-lExt-aExt)+l+lExt;
    dp^.size[1] _ siz1;
    END;

  makePXstr: PUBLIC PROCEDURE [w,l:INTEGER,imp:BOOLEAN_FALSE,
	wExt:INTEGER_wXExtension,lExt:INTEGER_lXExtension
	,surr:INTEGER_wellSurround]
    RETURNS [p: LONG POINTER TO object] =
    BEGIN
    dp: LONG POINTER TO xstr object _ tranList;
    w _ MAX[w, 2*Lambda];
    l _ MAX[l, 2*Lambda];
    wExt _ MAX[wExt, 0];
    lExt _ MAX[lExt, 0];
    WHILE dp # NIL DO
      IF dp.width = w AND dp.length = l AND dp.impl = imp
         AND dp.wExt = wExt AND dp.lExt = lExt AND NOT dp.angle AND dp.l=pdif
        AND dp.surround=surr THEN
        BEGIN p _ dp.p.anotherme[dp]; RETURN; END;
      dp _ dp.super;
      ENDLOOP;
    p _ dp _ alocXstrD[];
    dp.super _ tranList;
    tranList _ dp;
    p^.p _ @pxstrProcs;
    dp^.l _ pdif;
    dp^.surround _ surr;
    dp^.width _ w;
    dp^.length _ l;
    dp^.wExt _ wExt;
    dp^.lExt _ lExt;
    dp^.impl _ imp;
    dp^.pullup _ FALSE;
    dp^.size[0] _ dp^.size[2] _ w + dp.wExt*2;
    dp^.size[1] _ l + dp.lExt*2;
    END;

  makeRect: PUBLIC PROCEDURE [x, y: INTEGER, l: level]
    RETURNS [p: LONG POINTER TO object] =
    BEGIN
    dp: LONG POINTER TO rect object;
    x _ MAX[x, 1];
    y _ MAX[y, 1];
    p _ dp _ alocRectD[];
    p^.p _ @rectProcs;
    dp^.size[0] _ dp^.size[2] _ x;
    dp^.size[1] _ y;
    dp^.l _ l;
    END;

  makeText: PUBLIC PROCEDURE [s: STRING] RETURNS [p: LONG POINTER TO object] =
    BEGIN
    dp: LONG POINTER TO text object;
    p _ dp _ alocTextD[];
    p^.p _ @textProcs;
    dp^.size[0] _ dp^.size[2] _ 6*s.length;
    dp^.size[1] _ 8;
    dp^.s _ s;
    dp^.l _ cut;
    END;

  makeCnText: PUBLIC PROCEDURE [
    s: STRING, xw, byw, yw: INTEGER, op: LONG POINTER TO cell object,
    np: LONG POINTER TO cList] RETURNS [p: LONG POINTER TO object] =
    BEGIN
    dp: LONG POINTER TO cnText object;
    p _ dp _ alocCnTextD[];
    p^.p _ @cnTextProcs;
    dp^.size[0] _ xw;
    dp^.size[1] _ byw;
    dp^.size[2] _ byw*yw;
    dp^.s _ newString[s];
    dp^.np _ np;
    dp^.op _ op;
    END;

  makeButcon: PUBLIC PROCEDURE RETURNS [p: LONG POINTER TO object] =
    BEGIN p _ @bcObject; p.refCnt _ p.refCnt + 1; END;
  makePolycon: PUBLIC PROCEDURE [lll: INTEGER]
    RETURNS [p: LONG POINTER TO object] =
    BEGIN
    dp: LONG POINTER TO cont object _ contList;
    IF lll < butconSX THEN lll _ butconSX;
    WHILE dp # NIL DO
      IF dp.size[1] = lll AND dp.typ = mPol THEN
        BEGIN p _ dp.p.anotherme[dp]; RETURN; END;
      dp _ dp.super;
      ENDLOOP;
    p _ dp _ alocContD[];
    dp.super _ contList;
    contList _ dp;
    dp.size[0] _ dp.size[2] _ butconSX;
    dp.size[1] _ lll;
    dp.p _ @dcProcs;
    dp.typ _ mPol;
    dp.magicN _ butconSX/4;
    dp.l_pol
    END;
  makeDifcon: PUBLIC PROCEDURE [lll: INTEGER]
    RETURNS [p: LONG POINTER TO object] =
    BEGIN
    dp: LONG POINTER TO cont object _ contList;
    IF lll < butconSX THEN lll _ butconSX;
    WHILE dp # NIL DO
      IF dp.size[1] = lll AND dp.typ = mDif THEN
        BEGIN p _ dp.p.anotherme[dp]; RETURN; END;
      dp _ dp.super;
      ENDLOOP;
    p _ dp _ alocContD[];
    dp.super _ contList;
    contList _ dp;
    dp.size[0] _ dp.size[2] _ butconSX;
    dp.size[1] _ lll;
    dp.p _ @dcProcs;
    dp.typ _ mDif;
    dp.magicN _ butconSX/4;
    dp.l_dif
    END;
  makeMmDifcon: PUBLIC PROCEDURE [lll: INTEGER]
    RETURNS [p: LONG POINTER TO object] =
    BEGIN
    mins:INTEGER=cut2min+2*mmContExt;
    dp: LONG POINTER TO cont object _ contList;
    IF lll < mins THEN lll _ mins;
    WHILE dp # NIL DO
      IF dp.size[1] = lll AND dp.typ = mmDif THEN
        BEGIN p _ dp.p.anotherme[dp]; RETURN; END;
      dp _ dp.super;
      ENDLOOP;
    p _ dp _ alocContD[];
    dp.super _ contList;
    contList _ dp;
    dp.size[0] _ dp.size[2] _ mins;
    dp.size[1] _ lll;
    dp.p _ @mcProcs;
    dp.typ _ mmDif;
    dp.magicN _ (mins-4)/2;
    dp.m2Ext _ (mins-butconSX)/2;
    dp.c2Ext _ mmContExt;
    dp.l_dif
    END;
  makeMmPolcon: PUBLIC PROCEDURE [lll: INTEGER]
    RETURNS [p: LONG POINTER TO object] =
    BEGIN
    mins:INTEGER=cut2min+2*mmContExt;
    dp: LONG POINTER TO cont object _ contList;
    IF lll < mins THEN lll _ mins;
    WHILE dp # NIL DO
      IF dp.size[1] = lll AND dp.typ = mmPol THEN
        BEGIN p _ dp.p.anotherme[dp]; RETURN; END;
      dp _ dp.super;
      ENDLOOP;
    p _ dp _ alocContD[];
    dp.super _ contList;
    contList _ dp;
    dp.size[0] _ dp.size[2] _ mins;
    dp.size[1] _ lll;
    dp.p _ @mcProcs;
    dp.typ _ mmPol;
    dp.magicN _ (mins-4)/2;
    dp.m2Ext _ (mins-butconSX)/2;
    dp.c2Ext _ mmContExt;
    dp.l_pol
    END;
  makeNwellcon: PUBLIC PROCEDURE [lll: INTEGER]
    RETURNS [p: LONG POINTER TO object] =
    BEGIN
    dp: LONG POINTER TO cont object _ contList;
    IF lll < butconSX THEN lll _ butconSX;
    WHILE dp # NIL DO
      IF dp.size[1] = lll AND dp.typ = nwell THEN
        BEGIN p _ dp.p.anotherme[dp]; RETURN; END;
      dp _ dp.super;
      ENDLOOP;
    p _ dp _ alocContD[];
    dp.super _ contList;
    contList _ dp;
    dp.size[0] _ dp.size[2] _ butconSX;
    dp.size[1] _ lll;
    dp.p _ @dcProcs;
    dp.typ _ nwell;
    dp.magicN _ butconSX/4;
    dp.l_nwelCont
    END;
  makePDifcon: PUBLIC PROCEDURE [lll: INTEGER,surr:INTEGER_wellSurround]
    RETURNS [p: LONG POINTER TO object] =
    BEGIN
    dp: LONG POINTER TO cont object _ contList;
    IF lll < butconSX THEN lll _ butconSX;
    WHILE dp # NIL DO
      IF dp.size[1] = lll AND dp.typ = mPDif AND dp.surround=surr THEN
        BEGIN p _ dp.p.anotherme[dp]; RETURN; END;
      dp _ dp.super;
      ENDLOOP;
    p _ dp _ alocContD[];
    dp.super _ contList;
    contList _ dp;
    dp.size[0] _ dp.size[2] _ butconSX;
    dp.size[1] _ lll;
    dp.p _ @pdcProcs;
    dp.typ _ mPDif;
    dp.magicN _ butconSX/4;
    dp.l_pdif;
    dp.surround_surr;
    END;
  makeMPDifcon: PUBLIC PROCEDURE [lll: INTEGER,surr:INTEGER_wellSurround]
    RETURNS [p: LONG POINTER TO object] =
    BEGIN
    dp: LONG POINTER TO cont object _ contList;
    mins:INTEGER=cut2min+2*mmContExt;
    IF lll < mins THEN lll _ mins;
    WHILE dp # NIL DO
      IF dp.size[1] = lll AND dp.typ = mmPDif AND dp.surround=surr THEN
        BEGIN p _ dp.p.anotherme[dp]; RETURN; END;
      dp _ dp.super;
      ENDLOOP;
    p _ dp _ alocContD[];
    dp.super _ contList;
    contList _ dp;
    dp.size[0] _ dp.size[2] _ mins;
    dp.size[1] _ lll;
    dp.surround_surr;
    dp.p _ @mpdcProcs;
    dp.typ _ mmPDif;
    dp.magicN _ (mins-4)/2;
    dp.m2Ext _ (mins-butconSX)/2;
    dp.c2Ext _ mmContExt;
    dp.l_pdif
    END;
  makeBuCont: PUBLIC PROCEDURE [wid,len,wex,lex: INTEGER]
    RETURNS [p: LONG POINTER TO object] =
    BEGIN
    dp: LONG POINTER TO cont object _ contList;
    IF wex<0 THEN wex_0;IF lex<0 THEN lex_0;
    IF wid < 2*wex+2 THEN wid _ 2*wex+2;
    IF len < 2*lex+4 THEN len _ 2*lex+4;
    WHILE dp # NIL DO
      IF dp.typ=burr AND dp.size[1] = len AND dp.size[0] = wid AND
		dp.wExt=wex AND dp.lExt=lex THEN
        BEGIN p _ dp.p.anotherme[dp]; RETURN; END;
      dp _ dp.super;
      ENDLOOP;
    p _ dp _ alocContD[];
    dp.super _ contList;
    contList _ dp;
    dp.size[0] _ dp.size[2] _ wid;
    dp.size[1] _ len;
    dp.p _ @bucProcs;
    dp.typ _ burr;
    dp.wExt_wex;
    dp.lExt_lex;
    dp.magicN_IF wid>=2*wex+4 THEN 0 ELSE 2*wex+4-wid;
    END;
  makeMmCont: PUBLIC PROCEDURE [len,wex,lex: INTEGER]
    RETURNS [p: LONG POINTER TO object] =
    BEGIN
    mins:INTEGER=cut2min+2*mmContExt;
    dp: LONG POINTER TO cont object _ contList;
    IF len < mins THEN len _ mins;
--    IF wex<0 THEN wex_0;IF lex<0 THEN lex_0;
--    IF wid < 2*wex+2 THEN wid _ 2*wex+2;
--    IF len < 2*lex+4 THEN len _ 2*lex+4;
    WHILE dp # NIL DO
      IF dp.typ=mm2 AND dp.size[1] = len --AND dp.size[0] = wid AND
		--dp.wExt=wex AND dp.lExt=lex --THEN
        BEGIN p _ dp.p.anotherme[dp]; RETURN; END;
      dp _ dp.super;
      ENDLOOP;
    p _ dp _ alocContD[];
    dp.super _ contList;
    contList _ dp;
    dp.size[0] _ dp.size[2] _ mins;
    dp.size[1] _ len;
    dp.p _ @mmcProcs;
    dp.typ _ mm2;
--    dp.wExt_wex;
--    dp.lExt_lex;
    dp.magicN_mmContExt;
    END;
  makeWire:PUBLIC PROCEDURE[len,wid:INTEGER,l:level,surr:INTEGER_wellSurround]
    RETURNS [p: LONG POINTER TO object] =
    BEGIN
    dc: LONG POINTER TO wire object;
    IF wireOK[l]--=dif OR l=pol OR l=met OR l=met2-- THEN
      BEGIN
      dc _ wireList[l];
      WHILE dc # NIL DO
        IF dc.size[0] = wid AND dc.size[1] = len
		AND (l#pdif OR dc.surround=surr) THEN
          BEGIN p _ dc.p.anotherme[dc]; RETURN; END;
        dc _ dc.super;
        ENDLOOP;
      END;
    p _ dc _ alocWireD[];
    IF wireOK[l] THEN BEGIN dc.super _ wireList[l]; wireList[l] _ dc; END;
    p^.p _ IF NOT wireOK[l] THEN @rectProcs ELSE IF l=pdif THEN
	@pwireProcs ELSE @wireProcs;
--    IF l=pdif THEN {dc.size[0]_dc.size[2]_wid+2*tubMinExt;
--		dc.size[1]_len+2*tubMinExt;}
     -- ELSE {--dc^.size[0] _ dc^.size[2] _ wid;
		dc^.size[1] _ len;--};
    dc.surround_IF l=pdif THEN surr ELSE 0;
    dc^.l _ l;
    END;
  makeBus: PUBLIC PROCEDURE [len, wid: INTEGER, l: level, cnt, spc, tinc, binc: INTEGER]
    RETURNS [p: LONG POINTER TO object] =
    BEGIN
    b: LONG POINTER TO bus object;
    p _ b _ alocBusD[];
    p^.p _ @busProcs;
    b.wspace _ spc;
    b.firstLength _ len;
    b.topIncr _ tinc;
    b.lenIncr _ binc - tinc;
    b.wwidth _ wid;
    b.wCnt _ cnt;
    p.l _ l;
    setBusSizes[b];
    END;
  setBusSizes:PROCEDURE[p:LONG POINTER TO bus object] =
    BEGIN
    binc:INTEGER_p.lenIncr+p.topIncr;
    p.offsetFirst _ IF p.topIncr>=0 THEN 0 ELSE (1-p.wCnt)*p.topIncr;
    p.size[0] _ p.size[2] _ (p.wCnt-1)*p.wspace + p.wwidth;
    p.size[1] _ IF binc>0 THEN p.offsetFirst+p.firstLength+(p.wCnt-1)*binc
	ELSE p.offsetFirst+p.firstLength;
    END;

  makeRep: PUBLIC PROC [ob:obPtr,winc,linc,dx,dy,cnt:INTEGER,
    idx:orientationIndex] RETURNS [p: LONG POINTER TO object] =
    BEGIN
    repeat: cellPtr _ p _ makeCell[sx: 0, sy: 0, cnt: cnt, ptr: NIL];
    FOR i: INTEGER IN [0..cnt) DO
      repeat.ptr _ insertList[mp: repeat.ptr,
        lp: makeList[p: ob.p.anotherme[ob], x: i*dx, y: i*dy,
          o: idx/2, refl: idx MOD 2]];
      ENDLOOP;
    [max: repeat.size[0], may: repeat.size[1]] _ minmax[repeat.ptr];
    repeat.size[2] _ repeat.size[0]; -- sigh!
    END;

  makeCell: PUBLIC PROCEDURE [
    sx, sy: INTEGER, cnt: CARDINAL, ptr: LONG POINTER TO list]
    RETURNS [p: LONG POINTER TO cell object] =
    BEGIN
    dc: LONG POINTER TO cell object;
    p _ dc _ alocCellD[];
    p^.p _ @cellProcs;
    dc^.ptr _ ptr;
    dc^.size[0] _ dc^.size[2] _ sx;
    dc^.size[1] _ sy;
    dc^.l _ cut;
    dc^.cnt _ cnt;
    END;


  inMeRect: inMeProc =  --tells if cursor(or whatever)at x,y is inside object
    BEGIN
    xs, ys: INTEGER;
    IF BITAND[o, 4] = 0 THEN BEGIN xs _ ob.size[0]; ys _ ob.size[1]; END
    ELSE BEGIN xs _ ob.size[1]; ys _ ob.size[0]; END;
    IF x IN [0..xs] AND y IN [0..ys] THEN RETURN[TRUE] ELSE RETURN[FALSE];
    END;

  rectIB: ibProc =
    BEGIN
    x, y, sx, sy: INTEGER;
    x _ lp.lx;
    y _ lp.ly;
    IF BITAND[lp.idx, 4] = 0 THEN
      BEGIN sx _ lp.ob.size[0]; sy _ lp.ob.size[1]; END
    ELSE BEGIN sx _ lp.ob.size[1]; sy _ lp.ob.size[0]; END;
    IF x >= x2 OR y >= y2 OR x + sx <= x1 OR y + sy <= y1 THEN RETURN[FALSE];
    RETURN[TRUE];
    END;

  setWireParm: parmProc =
    BEGIN
    dp: LONG POINTER TO wire object _ LOOPHOLE[lp.ob];
    nw, nl, wd, ln, mn: INTEGER;
    l: level _ dp.l;
	movl:BOOLEAN_FALSE;
    wd _ dp.size[0];
    ln _ dp.size[1];
    SELECT pt FROM
      width => BEGIN nl _ ln; nw _ (wd*dy) + dx; END;
      length => BEGIN nl _ (ln*dy) + dx; nw _ wd; END;
      default =>
        BEGIN
        IF NOT wireOK[l] THEN RETURN[FALSE];
        nl _ ln;
        nw _ minWidthAr[l];
        END;
      wSpace => BEGIN nl _ ln; nw _ wd + dx; END;
      ENDCASE => RETURN[FALSE];
    IF nw < INTEGER[lambdaGrid] THEN nw _ lambdaGrid;
    IF nl<1 THEN {IF nl<0 THEN {movl_TRUE;nl_-nl} ELSE nl_Lambda;};
--    IF l=pdif THEN {IF nw<INTEGER[lambdaGrid]+2*tubMinExt THEN
--	nw_lambdaGrid+2*tubMinExt;
--	IF nl<2*tubMinExt+1 THEN nl_2*tubMinExt+1;};
    IF nw = wd AND nl = ln THEN RETURN[FALSE];
    mn _ 2*lambdaGrid;
    IF BITAND[lp.idx, 4] = 0 THEN
      BEGIN
	IF cent THEN {lp.lx _ lp.lx + lambdaGrid*(wd/mn - nw/mn);
		lp.ly _ lp.ly + lambdaGrid*(ln/mn - nl/mn);};
	IF movl THEN lp.ly _ lp.ly - nl;
      END
    ELSE
      BEGIN
        IF cent THEN {lp.lx _ lp.lx + lambdaGrid*(ln/mn - nl/mn);
		lp.ly _ lp.ly + lambdaGrid*(wd/mn - nw/mn);};
	IF movl THEN lp.lx _ lp.lx - nl;
      END;
    RETURN[NewObject[lp, makeWire[nl, nw, l]]];
    END;

  NewObject: PROCEDURE [lp: listPtr, ob: obPtr] RETURNS [BOOLEAN] =
    BEGIN
    lp.ob.p.release[lp.ob];
    lp.ob _ ob;
    RETURN[TRUE];
    END;

  setBusParm: parmProc =
    BEGIN
    dp: LONG POINTER TO bus object _ LOOPHOLE[lp.ob];
    nw, nl, wd, ln, mn: INTEGER;
    l: level _ dp.l;
    wd _ dp.wwidth;
    ln _ dp.firstLength;
    SELECT pt FROM
      width => BEGIN nl _ ln; nw _ (wd*dy) + dx; END;
      length => BEGIN nl _ (ln*dy) + dx; nw _ wd; END;
      default =>
        BEGIN
        IF NOT (l=dif OR l=pol OR l=met OR l=met2) THEN RETURN[FALSE];
        nl _ ln;
        nw _ minWidthAr[l];
        END;
      ENDCASE =>
	BEGIN
	    SELECT pt FROM
		wSpace => BEGIN dp.wspace_dp.wspace + dx; IF dp.wspace<dp.wwidth+1 THEN dp.wspace_dp.wwidth+1; END;
		count => BEGIN dp.wCnt_dp.wCnt + dx; IF dp.wCnt<1 THEN dp.wCnt_1; END;
		lSpace => BEGIN dp.topIncr_dp.topIncr + dx; END;
		bSpace => BEGIN dp.lenIncr_dp.lenIncr + dx; END;
	      ENDCASE;
	    setBusSizes[dp];
	    RETURN[TRUE];
	END;
    IF nw < INTEGER[lambdaGrid] THEN nw _ lambdaGrid;
    IF nl < 1 THEN nl _ 1;
    IF nw = wd AND nl = ln THEN RETURN[FALSE];
    mn _ 2*lambdaGrid;
    IF BITAND[lp.idx, 4] = 0 AND cent THEN
      BEGIN
      lp.lx _ lp.lx + lambdaGrid*(wd/mn - nw/mn);
      lp.ly _ lp.ly + lambdaGrid*(ln/mn - nl/mn);
      END
    ELSE
      IF cent THEN
        BEGIN
        lp.lx _ lp.lx + lambdaGrid*(ln/mn - nl/mn);
        lp.ly _ lp.ly + lambdaGrid*(wd/mn - nw/mn);
        END;
    dp.size[0] _ dp.size[2] _ dp.size[0] + nw - wd;
    dp.size[1] _ dp.size[1] +  nl - ln;
    dp.wwidth _ nw;
    dp.firstLength _ nl;
    RETURN[TRUE];
    END;

  setNullParm: parmProc = BEGIN RETURN[FALSE]; END;

  setAXstrParm: parmProc =
    BEGIN
    dp: LONG POINTER TO xstr object _ LOOPHOLE[lp.ob];
    nw, nl, wd, ln, mn,nwe,nle,nax,oax: INTEGER;
    im: BOOLEAN _ dp.impl;
    nw_wd _ dp.width;
    nl_ln _ dp.length;
    nwe_dp.wExt;
    nle_dp.lExt;
    oax_nax_dp.size[1]-dp.length-2*dp.lExt-dp.wExt;
    SELECT pt FROM
      width => BEGIN nw _ (wd*dy) + dx; END;
      length => BEGIN nw _ (wd*dy) + dx; nax_nax+nw-wd;END;
      default => BEGIN nl _ cLength*xRatiol; nw _ cWidth*xRatiow; nax_0;
		nwe_wXExtension;nle_lXExtension;END;
      wSpace => BEGIN IF -dx>dp.wExt THEN dx_-dp.wExt;nwe_dp.wExt+dx; END;
      lSpace => BEGIN IF -dx>dp.lExt THEN dx_-dp.lExt;nle_dp.lExt+dx; END;
      count => BEGIN im_IF dx<0 THEN FALSE ELSE TRUE; END;
      ENDCASE => RETURN[FALSE];
    -- new parameter ranges now tested in makeAngleXstr
    IF nw = wd AND nl = ln AND dp.wExt=nwe AND dp.lExt=nle
	AND oax=nax AND dp.impl=im THEN RETURN[FALSE];
    mn _ 2*lambdaGrid;
    IF BITAND[lp.idx, 4] = 0 AND cent THEN
      BEGIN
      lp.lx _ lp.lx + lambdaGrid*((wd-oax)/mn - (nw-nax)/mn);
      lp.ly _ lp.ly + lambdaGrid*(oax/mn - nax/mn);
      END
    ELSE
      IF cent THEN
        BEGIN
        lp.lx _ lp.lx + lambdaGrid*(oax/mn - nax/mn);
        lp.ly _ lp.ly + lambdaGrid*((wd-oax)/mn - (nw-nax)/mn);
        END;
    RETURN[NewObject[lp, makeAngleXstr[nw, nl, im,nwe,nle,nax]]];
    END;

  setXstrParm: parmProc =
    BEGIN
    dp: LONG POINTER TO xstr object _ LOOPHOLE[lp.ob];
    nw, nl, wd, ln, mn,nwe,nle: INTEGER;
    im: BOOLEAN _ dp.impl;
    nw_wd _ dp.width;
    nl_ln _ dp.length;
    nwe_dp.wExt;
    nle_dp.lExt;
    SELECT pt FROM
      width => BEGIN nw _ (wd*dy) + dx; END;
      length => BEGIN nl _ (ln*dy) + dx; END;
      default => BEGIN nl _ cLength*xRatiol; nw _ cWidth*xRatiow;
		nwe_wXExtension;nle_lXExtension;END;
      wSpace => BEGIN IF -dx>dp.wExt THEN dx_-dp.wExt;nwe_dp.wExt+dx; END;
      lSpace => BEGIN IF -dx>dp.lExt THEN dx_-dp.lExt;nle_dp.lExt+dx; END;
      count => BEGIN im_IF dx<0 THEN FALSE ELSE TRUE; END;
      ENDCASE => RETURN[FALSE];
    -- new parameter ranges now tested in makeXstr
    IF nw = wd AND nl = ln AND dp.wExt=nwe AND dp.lExt=nle AND dp.impl=im THEN RETURN[FALSE];
    mn _ 2*lambdaGrid;
    IF BITAND[lp.idx, 4] = 0 AND cent THEN
      BEGIN
      lp.lx _ lp.lx + lambdaGrid*(wd/mn - nw/mn);
      lp.ly _ lp.ly + lambdaGrid*(ln/mn - nl/mn);
      END
    ELSE
      IF cent THEN
        BEGIN
        lp.lx _ lp.lx + lambdaGrid*(ln/mn - nl/mn);
        lp.ly _ lp.ly + lambdaGrid*(wd/mn - nw/mn);
        END;
    RETURN[NewObject[lp, makeXstr[nw, nl, im,nwe,nle]]];
    END;

  setPXstrParm: parmProc =
    BEGIN
    dp: LONG POINTER TO xstr object _ LOOPHOLE[lp.ob];
    nw, nl, wd, ln, mn,nwe,nle: INTEGER;
    im: BOOLEAN _ dp.impl;
    nw_wd _ dp.width;
    nl_ln _ dp.length;
    nwe_dp.wExt;
    nle_dp.lExt;
    SELECT pt FROM
      width => BEGIN nw _ (wd*dy) + dx; END;
      length => BEGIN nl _ (ln*dy) + dx; END;
      default => BEGIN nl _ cLength*xRatiol; nw _ cWidth*xRatiow;
		nwe_wXExtension;nle_lXExtension;END;
      wSpace => BEGIN IF -dx>dp.wExt THEN dx_-dp.wExt;nwe_dp.wExt+dx; END;
      lSpace => BEGIN IF -dx>dp.lExt THEN dx_-dp.lExt;nle_dp.lExt+dx; END;
      count => BEGIN im_IF dx<0 THEN FALSE ELSE TRUE; END;
      ENDCASE => RETURN[FALSE];
    -- new parameter ranges now tested in makePXstr
    IF nw = wd AND nl = ln AND dp.wExt=nwe AND dp.lExt=nle AND dp.impl=im THEN RETURN[FALSE];
    mn _ 2*lambdaGrid;
    IF BITAND[lp.idx, 4] = 0 AND cent THEN
      BEGIN
      lp.lx _ lp.lx + lambdaGrid*(wd/mn - nw/mn);
      lp.ly _ lp.ly + lambdaGrid*(ln/mn - nl/mn);
      END
    ELSE
      IF cent THEN
        BEGIN
        lp.lx _ lp.lx + lambdaGrid*(ln/mn - nl/mn);
        lp.ly _ lp.ly + lambdaGrid*(wd/mn - nw/mn);
        END;
    RETURN[NewObject[lp, makePXstr[nw, nl, im,nwe,nle]]];
    END;

  setPuParm: parmProc =
    BEGIN
    dp: LONG POINTER TO xstr object _ LOOPHOLE[lp.ob];
    nw, nl, wd, ln, mn,nwe,nle: INTEGER;
    nw_wd _ dp.width;
    nl_ln _ dp.length;
    nwe_dp.wExt;
    nle_dp.lExt;
    SELECT pt FROM
      width => BEGIN nw _ (wd*dy) + dx; END;
      length => BEGIN nl _ (ln*dy) + dx; END;
      default => BEGIN nl _ cLength*pRatiol; nw _ cWidth*pRatiow; END;
      wSpace => BEGIN IF -dx>dp.wExt THEN dx_-dp.wExt;nwe_dp.wExt+dx; END;
      lSpace => BEGIN IF -dx>dp.lExt THEN dx_-dp.lExt;nle_dp.lExt+dx; END;
      ENDCASE => RETURN[FALSE];
    -- new parameter ranges now tested in makePu
    IF nw = wd AND nl = ln AND dp.wExt=nwe AND dp.lExt=nle THEN RETURN[FALSE];
    mn _ 2*lambdaGrid;
    IF BITAND[lp.idx, 4] = 0 AND cent THEN
      BEGIN
      lp.lx _ lp.lx + lambdaGrid*(wd/mn - nw/mn);
      lp.ly _ lp.ly + lambdaGrid*(ln/mn - nl/mn);
      END
    ELSE
      IF cent THEN
        BEGIN
        lp.lx _ lp.lx + lambdaGrid*(ln/mn - nl/mn);
        lp.ly _ lp.ly + lambdaGrid*(wd/mn - nw/mn);
        END;
    RETURN[NewObject[lp, makePullup[nw, nl,nwe,nle]]];
    END;

  setContParm: parmProc =
    BEGIN
    dp: LONG POINTER TO cont object _ LOOPHOLE[lp.ob];
    nl, ln, mn: INTEGER;
    typ: contType _ dp.typ;
    ln _ dp.size[1];
    SELECT pt FROM
      length => BEGIN nl _ (ln*dy) + dx; END;
      default => BEGIN nl _ butconSX; END;
      ENDCASE => RETURN[FALSE];
    IF nl < butconSX THEN nl _ butconSX;
    IF nl = ln THEN RETURN[FALSE];
    mn _ 2*lambdaGrid;
    IF BITAND[lp.idx, 4] = 0 AND cent THEN
      BEGIN lp.ly _ lp.ly + lambdaGrid*(ln/mn - nl/mn); END
    ELSE IF cent THEN BEGIN lp.lx _ lp.lx + lambdaGrid*(ln/mn - nl/mn); END;
    RETURN[NewObject[lp, SELECT typ FROM
	mPol => makePolycon[nl],
	mDif => makeDifcon[nl],
	mPDif => makePDifcon[nl],
	ENDCASE => makeMmCont[nl,0,0]]];
    END;

  setBuContParm: parmProc =
    BEGIN
    dp: LONG POINTER TO cont object _ LOOPHOLE[lp.ob];
    nw, nl, wd, ln, mn,nwe,nle: INTEGER;
    nw_wd _ dp.size[0];
    nl_ln _ dp.size[1];
    nwe_dp.wExt;
    nle_dp.lExt;
    SELECT pt FROM
      width => BEGIN nw _ (wd*dy) + dx; END;
      length => BEGIN nl _ (ln*dy) + dx; END;
      default => BEGIN nl _ 8; nw _ 10;nwe_4;nle_2;END;
      wSpace => BEGIN IF -dx>dp.wExt THEN dx_-dp.wExt;
		nwe_dp.wExt+dx;nw_nw+dx*2; END;
      lSpace => BEGIN IF -dx>dp.lExt THEN dx_-dp.lExt;
		nle_dp.lExt+dx;nl_nl+dx*2; END;
      ENDCASE => RETURN[FALSE];
    IF nwe<0 THEN nwe_0;IF nle<0 THEN nle_0;
    IF nw < 2*nwe+2 THEN nw _ 2*nwe+2;
    IF nl < 2*nle+4 THEN nl _ 2*nle+4;
    IF nw = wd AND nl = ln AND dp.wExt=nwe AND dp.lExt=nle THEN RETURN[FALSE];
    mn _ 2*lambdaGrid;
    IF BITAND[lp.idx, 4] = 0 AND cent THEN
      BEGIN
      lp.lx _ lp.lx + lambdaGrid*(wd/mn - nw/mn);
      lp.ly _ lp.ly + lambdaGrid*(ln/mn - nl/mn);
      END
    ELSE
      IF cent THEN
        BEGIN
        lp.lx _ lp.lx + lambdaGrid*(ln/mn - nl/mn);
        lp.ly _ lp.ly + lambdaGrid*(wd/mn - nw/mn);
        END;
    RETURN[NewObject[lp, makeBuCont[nw, nl, nwe,nle]]];
    END;


  END.