-- definitions module for silicon (pretty picture) program
-- last modified by McCreight, December 30, 1982  2:47 PM
-- modified by Petit, September 18, 1981  2:40 PM

DIRECTORY
  SegmentDefs,
  multiGraphicsDefs,
  StreamDefs;

ppdefs: DEFINITIONS IMPORTS SegmentDefs, multiGraphicsDefs, StreamDefs =
  BEGIN OPEN multiGraphicsDefs, StreamDefs;


  -- Note: The Chipmonk design coordinate system has x increasing to the right
  -- and y increasing downward.  [x: 0, y: 0] is the center of the design
  -- space.

  locNum: TYPE = INTEGER;
  Lambda, lambda: locNum = 2; -- 2 locNums per lambda
  Point: TYPE = RECORD [x, y: locNum];
  Rect: TYPE = RECORD [x1, y1, x2, y2: locNum];

  orientation: TYPE = [0..7]; -- multiple of 45 degrees clockwise
  reflection: TYPE = [0..1]; -- 1 means mirror in x (x _ -x)
  orientationIndex: TYPE = [0..15]; -- = 2*orientation+reflection
  -- An orientationIndex idx is composed of two parts:
  --    a clockwise rotation of (idx/2)*45 degrees,
  --    followed by a reflection in x if (idx MOD 2)#0.
  -- Odd multiples of 45 degrees are not yet supported.

  Level: TYPE = MACHINE DEPENDENT{
    cut(0), dif(1), pol(2), met(3), imp(4), ovg(5), bur(6),
    snerd(7), cut2(8), pdif(9), pwelCont(10), met2(11), pwel(12),
    nwel(13), nwelCont(14), NOcOL(15),
    l16, l17, l18, l19, l20, l21, l22, l23, l24, l25, l26, l27, l28, l29, l30, l31,
    l32, l33, l34, l35, l36, l37, l38, l39, l40, l41, l42, l43, l44, l45, l46, l47,
    l48, l49, l50, l51, l52, l53, l54, l55, l56, l57, l58, l59, l60, l61, l62, l63};
  level: TYPE = Level[cut..NOcOL];


--  I t e m   L i s t

  masterList: listPtr; -- design now being displayed
  listPtr: TYPE = LONG POINTER TO list _ NIL;
  list: TYPE = RECORD [
    nxt: listPtr,
    lx, ly: locNum,
    super: listPtr,
    ob: obPtr,
    selected, deleted, cfok, bfok, gotText: BOOLEAN _ FALSE,
    mark: [0..1] _ 0,
    idx, ridx: orientationIndex,  -- ridx is BITXOR[idx,1], i.e. reflected
    props: propPtr
    ];


--  I t e m   P r o p e r t y

  propType: TYPE = {text, interPnt, tail};
  propPtr: TYPE = LONG POINTER TO prop _ NIL;
  prop: TYPE = RECORD [
    nxt: propPtr,
    varpart: SELECT ptyp: propType FROM
      text => [s: STRING _ NIL],-- instance name
      interPnt => [pnt: listPtr],
      tail => [bpnt: listPtr],
      ENDCASE];


--  O b j e c t

  obPtr: TYPE = LONG POINTER TO object _ NIL;
  cellPtr: TYPE = LONG POINTER TO cell object _ NIL;
  object: TYPE = RECORD [
    p: POINTER TO Procs,
    size: ARRAY [0..2] OF INTEGER,
    refCnt: CARDINAL,
    auxPnt: auxPtr,
    l: level,
    surround:[0..31] _ 0,
    returnable, marked: BOOLEAN,
    varpart: SELECT otyp: typeOfObject FROM
      rect => NULL,
      wire => [super: LONG POINTER TO wire object _ NIL],
      xstr => [
        super: LONG POINTER TO xstr object _ NIL,
        width, length: INTEGER,
        wExt, lExt: [0..63],
        impl, pullup, zType, angle: BOOLEAN _ FALSE],
      cell => [
        cnt: CARDINAL,
        ptr: listPtr,
        super: cellPtr _ NIL],
      cont => [
        super: LONG POINTER TO cont object _ NIL,
        typ: contType,
        magicN,m2Ext,c2Ext: [0..15] _ 0,lExt,wExt:[0..255]_4],
      bus => [
        wspace, firstLength, topIncr, lenIncr, offsetFirst: INTEGER _ 0,
        wwidth, wCnt, tWhich,bWhich: INTEGER _ 0],
      text => [s: STRING],
      cnText => [
        s: STRING,
        np: cListPtr _ NIL,
        op: cellPtr _ NIL],
      ENDCASE];

  Procs: TYPE = RECORD [ -- generic procedures for an object
    drawme: ARRAY orientationIndex OF drProc,
    setParm: parmProc,
    inBox: ibProc,
    inMe: inMeProc,
    release: relProc,
    anotherme: anoProc];

  drProc: TYPE = PROCEDURE [
    ob: obPtr, x, y: locNum, pr: POINTER TO drRecord];
  ibProc: TYPE = PROCEDURE [lp: listPtr, x1, y1, x2, y2: locNum]
    RETURNS [BOOLEAN];
  inMeProc: TYPE = PROCEDURE [
    ob: obPtr, x, y: locNum, o: orientationIndex]
    RETURNS [BOOLEAN];
  relProc: TYPE = PROCEDURE [ob: obPtr];
  anoProc: TYPE = PROCEDURE [ob: obPtr]
    RETURNS [obPtr];
  parmProc: TYPE = PROCEDURE [
    lp: listPtr, pt: parmType, dx, dy: locNum, cent: BOOLEAN]
    RETURNS [BOOLEAN];

  aux: TYPE; -- can be implemented by any application program
  auxPtr: TYPE = LONG POINTER TO aux _ NIL;


--  N a m e d   C e l l s

  cellList: cListPtr; -- all the named cells
  cListPtr: TYPE = LONG POINTER TO cList _ NIL;
  cList: TYPE = RECORD [nxt: cListPtr, ob: obPtr, name: STRING];


--  P u s h e d  C e l l s

  cellStack: cellSEPtr; -- we are pushed down into this stack of cells
  cellSEPtr: TYPE = LONG POINTER TO cellSE _ NIL;
  cellSE: TYPE = RECORD [
    nxt: cellSEPtr,
    lp, instance, unDel: listPtr,
    dest: cellPtr,
    origSize: Point, -- of dest
    origBB: Rect, -- of instance
    cCenter: Point, -- of color screen when push happened
    cScale: INTEGER,
    changes: BOOLEAN,
    udg, udi: CARDINAL];

  UsuallyFalse: TYPE = BOOLEAN _ FALSE;
  wireOK: ARRAY level OF UsuallyFalse =
    [dif: TRUE, pol: TRUE, met: TRUE, pdif: TRUE, met2: TRUE];


  Mode: TYPE = {wire, xstr, cell, null};

  -- MAGIC CONSTANTS:

  maxInfluence: locNum = 4*Lambda;
    -- max extension of influence (or well) beyond bounding box:
  wellSurround: locNum = 4*Lambda;
  butconSY: locNum = 6*Lambda;
  butconSX: locNum = 4*Lambda;
  butconGreenOff: locNum = Lambda;
  butconRedOff: locNum = (3*Lambda)/2;

  cWidth: locNum = 2*Lambda;
  cLength: locNum = 2*Lambda;
  wXExtension: locNum = 2*Lambda;
  lXExtension: locNum = 2*Lambda;

  cut2min: locNum = 3*Lambda;
  mmContExt: locNum = 2*Lambda;-- extension of met2 beyond cut2
  --m2DifContExt: locNum = (3*Lambda)/2;- extension of met2 beyond edge of dif in a
	--	met2-met-dif contact = (cut2min + 2*mmContExt - butconSX)/2
  welconSurround: locNum = 3*Lambda;-- min well surround around a well-contact

  -- switch controlling format of color screen:
  csHor: BOOLEAN = TRUE;
  -- TRUE for long direction horizontal, FALSE for vertical;
  colWidth: INTEGER = IF csHor THEN 640 ELSE 480;
  colHeight: INTEGER = IF csHor THEN 480 ELSE 640;
  bwBottom: INTEGER = 580;
  bwMsgTop: INTEGER = bwBottom;
  bwMsgBottom: INTEGER = 640;
  bwFeedTop:INTEGER=bwMsgBottom;

  --********** command interpreter stuff:

QuitSig: SIGNAL;
RestSig: SIGNAL;
cMos: BOOLEAN;

keCheckProc:TYPE = PROCEDURE[k:keyEvent] RETURNS[return,execute:BOOLEAN];
	-- return true if command interpreter should return
	-- execute true if command interpreter should execute the keyEvent

CmdTwerp:PROCEDURE[keCheckProc] RETURNS[keyEvent];
CmdTwerpMess:PROCEDURE[os1,os2,os3:STRING,check:keCheckProc]
	RETURNS[keyEvent];


  -- kbd stuff:

  keyEvent: TYPE = RECORD [
    k: [0..77B], ctl: [0..31], mx: [0..2000], my: [0..1000]];
  nilKeyEvent: keyEvent = [k: 77B, ctl: 0, mx: 0, my: 0];

-- mx and my are the screen coordinates of the cursor when the keystroke
-- happened.  (0,0) is upper left of color screen.  (colWidth,0) is upper
-- left of B&W screen.  (colWidth,bwBottom) is upper left of feedback area.
-- ctl indicates which control keys were down, or which mouse button was
-- pushed.  k is the character key.

  --key encodings (k field of keyEvent):
  --	0-11B: "0" to "9" (add 60B for ascii)
  --	12B-43B: "A" to "Z" (add 67B for ascii upper case)
  --	44B: ";" key
  --	45B: "=" key
  --	46B: "," key
  --	47B: "-" key
  --	50B: "." key
  --	51B: "/" key
  --	52B: "'" key
  --	53B: "[" key
  --	54B: "\" key
  --	55B: "]" key
  --	56B: "DONE" key (blank one below DEL)(UNdo)
  --	57B: "_" key
  --	60B: CR key
  --	61B: LF key
  --	62B: BS key
  --	63B: DEL key
  --	64B: space bar
  --	65B: ESC
  --	66B: blank to right of RET (not used)
  --	67B: swat key (not used)
  --	70B: TAB (not used, - a ctrl key instead)
  --	71B: ???
  --	72B: ???
  --	73B: yellow mouse button up (release)
  --	74B: ???
  --	75B: ???
  --	76B: ???
  --	77B: No key (for use with mouse buttons)

  --ctrl key encodings (ctl field of keyEvent):
  --	1,2: Mouse buttons: 0-none, 1-red, 2-yellow, 3-blue
  --	4: CTRL
  --	10B: TAB
  --	20B: Shift (either)


  cursorOnBW: BOOLEAN;
  curx, cury: INTEGER;
  gridCol, gridBW: CARDINAL;

  mType: SegmentDefs.MachineType;
  color: TYPE = [0..15];

  -- ********
  bwScale: INTEGER;
  bwxoff, bwyoff: INTEGER;
  cScale: INTEGER;
  cxoff, cyoff: INTEGER;
  bwScaleN: INTEGER;
  bwScaleD: INTEGER;
  cScaleN: INTEGER;
  cScaleD: INTEGER;

  bwClipx1: INTEGER;
  bwClipx2: INTEGER;
  bwClipy1: INTEGER;
  bwClipy2: INTEGER;
  cClipx1: INTEGER;
  cClipx2: INTEGER;
  cClipy1: INTEGER;
  cClipy2: INTEGER;

  fnt: POINTER TO StrikeFont;

  typeOfObject: TYPE = {rect, wire, xstr, cell, cont, bus, text, cnText};
  contType: TYPE = {butt, mDif, mPol, burr, mm2, mPDif,
	nwell, mmDif, mmPol, mmPDif, mmButt};
  parmType: TYPE = {width, length, default, wSpace, lSpace, count, bSpace};

  cmdMask: TYPE = [0..7777B];
  -- 1=mark,2=draw,4=sel,10B=none,20B=ctrl,40B=tab,100B=ctrl-tab,
  --  200B=shift,400B=ctrl-shift,1000B=tab-shift,2000B=ctrl-tab-shift.

  cmdProc: TYPE = PROCEDURE [k: keyEvent _ nilKeyEvent];
  cmdLent: TYPE = RECORD [mask: cmdMask, proc: cmdProc];
  cmdEnt: TYPE = POINTER TO ARRAY [0..0) OF cmdLent;

  rems: TYPE = RECORD [r: Rect, l: level];
  remPages: CARDINAL = 20000/256;
  remLen: CARDINAL = (remPages*256)/SIZE[rems];

  markPnt, markDPnt, selMarkPnt: Point;

  rectListPtr: TYPE = LONG POINTER TO rectList _ NIL;
  rectList: TYPE = RECORD [
    nxt: rectListPtr, r: Rect, l: level, freebl: BOOLEAN];

  --********** screen update process stuff:

  sCmdType: TYPE = {nop, rect, sel, all};
  sCmd: TYPE = RECORD [
    cmd: sCmdType, ers: BOOLEAN, p: listPtr, r: Rect];

  drawProcer: TYPE = PROCEDURE [
    INTEGER, INTEGER, INTEGER, INTEGER, level, POINTER TO Rect];
  drawProcerc: TYPE = PROCEDURE [
    INTEGER, INTEGER, INTEGER, INTEGER, color, POINTER TO Rect];
  drawProcers: TYPE = PROCEDURE [
    INTEGER, INTEGER, INTEGER, INTEGER, STRING, POINTER TO Rect];
  drRecord: TYPE = RECORD [
    r,bigr: Rect,
    orArea, saveArea: drawProcer,
    outl: drawProcerc,
    dtxt: drawProcers,
    minSize: INTEGER];

  initRects: PROCEDURE;
  CenterAndScale: PROC [center: Point, scale: INTEGER, bw, col: BOOLEAN _ FALSE];
  reDrawRect: PROCEDURE [r: Rect, whenErase: CARDINAL, bw, col, all: BOOLEAN];
  drawNewlySel: PROCEDURE [p: listPtr];
  getColNewRect: PROCEDURE RETURNS [sCmd]; -- waits if none ready
  getBwNewRect: PROCEDURE RETURNS [sCmd]; -- waits if none ready

  --********* exports from ppspace.mesa

  swdsAloc: CARDINAL;
  lwdsAloc: LONG INTEGER;
  GetSuperPointer: PROCEDURE RETURNS [listPtr];
  GetCellSuper: PROCEDURE RETURNS [cellPtr];
  GetSpace: PROCEDURE [CARDINAL] RETURNS [LONG POINTER];
  FreeSpace: PROCEDURE [p: LONG POINTER];
  InitHeap: PROCEDURE [np: CARDINAL];
  EraseHeap: PROCEDURE;
  GetString: PROCEDURE [nchars: CARDINAL] RETURNS [s: STRING];
  FreeString: PROCEDURE [s: STRING];
  newString: PROCEDURE [s: STRING] RETURNS [ss: STRING];
  alocRectD: PROCEDURE RETURNS [p: LONG POINTER TO rect object];
  alocWireD: PROCEDURE RETURNS [p: LONG POINTER TO wire object];
  alocBusD:  PROCEDURE RETURNS [p: LONG POINTER TO bus object];
  alocXstrD: PROCEDURE RETURNS [p: LONG POINTER TO xstr object];
  alocCellD: PROCEDURE RETURNS [p: cellPtr];
  alocContD: PROCEDURE RETURNS [p: LONG POINTER TO cont object];
  alocTextD: PROCEDURE RETURNS [p: LONG POINTER TO text object];
  alocCnTextD: PROCEDURE RETURNS [p: LONG POINTER TO cnText object];
  alocList: PROCEDURE RETURNS [p: listPtr];
  alocCList: PROCEDURE RETURNS [p: cListPtr];
  freeList: PROCEDURE [listPtr];
  freeCell: PROCEDURE [p: cellPtr];

  --**** old ppprocdefs stuff:

  unDelGrpMax: CARDINAL = 10;
  unDelItemMax: CARDINAL = 300;
  unDelItemMin: CARDINAL = 30;

  unDelPnt: listPtr;
  unDelGrpCnt, unDelItemCnt: CARDINAL;

  anyChanges, sinceIOchanges: BOOLEAN;

  xRatiow: INTEGER;
  xRatiol: INTEGER;
  implant: BOOLEAN;
  pRatiow: INTEGER;
  pRatiol: INTEGER;
  pushLevel: INTEGER;

  --**** from ppprocs?:

  minWidthAr: ARRAY level OF INTEGER;

  bwGrain: INTEGER;
  colGrain: INTEGER;
  abortColor, abortBW: BOOLEAN;

  redoCBBox: PROCEDURE;

  wireList: ARRAY level OF LONG POINTER TO wire object;
  tranList: LONG POINTER TO xstr object;
  puList: LONG POINTER TO xstr object;
  contList: LONG POINTER TO cont object;
  --doColRemember:PROCEDURE ;
  --doBwRemember: PROCEDURE ;

  inrect: PROCEDURE [x, y: INTEGER, lp: listPtr] RETURNS [BOOLEAN];
  whatLevels: PROCEDURE [lp: listPtr, x, y: locNum]
    RETURNS [levs: CARDINAL];
  flushDel: PROCEDURE [lp: listPtr];

  copyObject: PROCEDURE [lp, mp: listPtr, xoff, yoff: INTEGER]
    RETURNS [np: listPtr];
  minmax: PROCEDURE [lp: listPtr]
    RETURNS [mix, miy, max, may: INTEGER];
  typeInNum: PROCEDURE [os1, os2, os3: STRING]
    RETURNS [bb: BOOLEAN, ii: INTEGER, ke: keyEvent];
  typeIn: PROCEDURE [os1, os2, os3: STRING]
    RETURNS [bb: BOOLEAN, is: STRING, ke: keyEvent];
  typeInC: PROCEDURE [os1, os2, os3: STRING] RETURNS [kk: keyEvent];
  typeOut: PROCEDURE [os1, os2, os3: STRING];
  refreshTypeInScreen: PROCEDURE ;

  initColors: PROCEDURE;
  setColors: PROCEDURE;

  getchr: PROCEDURE RETURNS [ke: keyEvent];
  getNumber: PROCEDURE RETURNS [INTEGER];
  getstr: PROCEDURE [x, y: CARDINAL] RETURNS [BOOLEAN, STRING, keyEvent];


  -- ************

  xx, yy: INTEGER;
  bb: BOOLEAN;

  moveOb: PROCEDURE [p: listPtr, x, y: INTEGER];

  mergeRects: PROCEDURE [a, b: Rect] RETURNS [Rect];
  ClipRect: PROC [a, b: Rect] RETURNS [Rect] = INLINE -- intersection
    {RETURN[[x1: MAX[a.x1, b.x1], y1: MAX[a.y1, b.y1],
      x2: MIN[a.x2, b.x2], y2: MIN[a. y2, b.y2]]]};
  Empty: PROC [r: Rect] RETURNS[BOOLEAN] = INLINE
    {RETURN[r.x2<r.x1 OR r.y2<r.y1]}; -- for directed Rects
  cannonRect: PROCEDURE [r: Rect] RETURNS [Rect];
    -- produces a non-empty Rect

  getRect: PROCEDURE [l: listPtr] RETURNS [r: Rect];


  END.