-- State.mesa  last edit, Johnsson  September 16, 1980  5:06 PM
  -- Bruce on Oct 10, 1980 2:58 PM
  
DIRECTORY
  BcdDefs USING [CTIndex, CTNull],
  Commands USING [CommandRec, Prompt, StringId],
  DebugOps USING [Foo, FooProc],
  MachineDefs USING [CFP, ConfigIndex, ExternalStateVector, FHandle, FileHandle, GFHandle, NullConfig, NullGF, nullPHandle, 
  PHandle, SVPointer],
  PrincOps USING [SignalDesc],
  UserInput USING [StringProcType];
  
State: DEFINITIONS IMPORTS Commands =
  BEGIN OPEN MachineDefs;
  
  WritePrompt: PROC = INLINE {IF gs.resetPrompt THEN Commands.Prompt[]};
  
  -- parsing
  ParseProc: TYPE = PROCEDURE [CHARACTER];
  SetParse: PROCEDURE [proc: ParseProc];
  ResetParse: PROCEDURE;
  StringProc: UserInput.StringProcType;
  
  -- global state
  StringId: TYPE = Commands.StringId;
  StringArray: TYPE = ARRAY StringId OF STRING;
  Strings: TYPE = DESCRIPTOR FOR StringArray;
  
  strings: Strings;
  AllStrings: PROCEDURE RETURNS [Strings] = INLINE BEGIN RETURN[strings] END;
  GetString: PROCEDURE [id: StringId] RETURNS [STRING] =
    INLINE BEGIN RETURN[strings[id]] END;
  SetString: PROCEDURE [id: StringId, val: STRING];
  
  gs: GSHandle;
  GetGS, GetSet: PROCEDURE RETURNS [gsh: GSHandle] = INLINE BEGIN RETURN[gs] END;
  
  Msg: TYPE = {none, interrupt, punt, bootloaded, maplog, invalid};
  
  GSHandle: TYPE = POINTER TO GState;
  GState: TYPE = RECORD [
    parse: ParseProc _ LOOPHOLE[0],
    worryBreaks: BOOLEAN _ FALSE,
    level: INTEGER _ 0,
    tree: BOOLEAN _ FALSE,
    nubLevel: CARDINAL _ 1, 
    search: BOOLEAN _ FALSE,
    nubFrame, sigGF: GFHandle _ MachineDefs.NullGF,
    debugging: BOOLEAN _ FALSE,
    frame, gf, bytePC, acount, ocount: UNSPECIFIED _ 0,
    spare1: BOOLEAN _ FALSE,
    aread, oread, owrite: LONG POINTER _ NIL,
    restartMsg: Msg _ none,
    loggedIn: BOOLEAN _ FALSE,
    initBCD: BOOLEAN _ FALSE,
    worryEntry: BOOLEAN _ FALSE,
    inNub: BOOLEAN _ FALSE,
    ready: BOOLEAN _ FALSE,
    teledebugging: BOOLEAN _ FALSE,
    -- used by GetString
    firstChar: BOOLEAN _ TRUE,
    resetPrompt: BOOLEAN _ TRUE,
    resetParse: BOOLEAN _ TRUE,
    tool: BOOLEAN _ FALSE,
    currentId: Commands.StringId _ NULL,
    currentString: STRING _ NIL,
    com2: Commands.CommandRec _ NULL,
    s1: STRING _ NIL,
    cr: BOOLEAN _ NULL,
    call0: PROC _ LOOPHOLE[1],
    call1: PROC [STRING] _ LOOPHOLE[0],
    call2: PROC [STRING, STRING] _ LOOPHOLE[0],
    term: PROC [CHARACTER] RETURNS [BOOLEAN] _ LOOPHOLE[0],
    spare2: BOOLEAN _ FALSE,
    ESV: ExternalStateVector _ NULL,
    StatePtr: SVPointer _ NIL,
    signal: PrincOps.SignalDesc _ LOOPHOLE[0],
    breakFrame: FHandle _ NIL,
    mds: CARDINAL _ 0,
    debuggerFP, debuggeeFP, selfFP: CFP _ NULL,
    selfFH, debuggeeFH: FileHandle _ NIL];
    
  -- level dependent state
  top: PRIVATE Handle;
  
  Push: PROCEDURE;
  Pop: PROCEDURE;
  Get: PROCEDURE RETURNS [h: Handle] = INLINE
    BEGIN IF top = NIL THEN ERROR OutOfState; RETURN[top] END;
    
  LF: PROC RETURNS [FHandle] = INLINE
    BEGIN IF top = NIL THEN ERROR OutOfState; RETURN[top.lContext] END;
  GF: PROC RETURNS [GFHandle] = INLINE
    BEGIN IF top = NIL THEN ERROR OutOfState; RETURN[top.gContext] END;
  PSB: PROC RETURNS [PHandle] = INLINE
    BEGIN IF top = NIL THEN ERROR OutOfState; RETURN[top.pContext] END;
    
  DNode: TYPE = RECORD [link: NodeHandle, node: POINTER];
  NodeHandle: TYPE = POINTER TO DNode;
  NodeType: TYPE = {fobs};
  ContextType: TYPE = {none, local, psb, global, state, break};
  
  Handle: TYPE = POINTER TO Context;
  Context: TYPE = RECORD [
    prev: Handle _ NIL,
    lContext: FHandle _ NIL,
    gContext: GFHandle _ NIL,
    pContext: PHandle _ nullPHandle,
    interpretContext: POINTER _ NIL,
    reentrantParse: ParseProc _ LOOPHOLE[0],
    howSet: ContextType _ none,
    cti: BcdDefs.CTIndex _ BcdDefs.CTNull,
    config: ConfigIndex _ NullConfig,
    fobs: NodeHandle _ NIL,
    proc: DebugOps.FooProc _ LOOPHOLE[0],
    fooStack: POINTER TO Stack _ NIL];
    
  Stack: TYPE = RECORD [link: POINTER TO Stack, foo: DebugOps.Foo];
  
  -- Signals and utilities
  OnYourMark, Go: PROCEDURE;
  OutOfState: ERROR;
  
  END.