-- XDSwap.Mesa  Edited by:
  -- Bruce on October 8, 1980  6:56 PM
  -- Sandman on July 23, 1980  10:30 AM

DIRECTORY
  AltoDefs USING [MaxMDSPage],
  AltoHardware USING [BankRegister, BankRegisters],
  BcplOps USING [BcplInLd, BcplJSR, BcplOutLd],
  BP USING [Validate],
  Commands USING [Go],
  ControlDefs USING [SVPointer, TraceOff, TrapStatus],
  CoreSwapDefs USING [
    ExternalStateVector, PuntInfo, PuntTable, SVPointer, SwapReason, VersionID],
  DebugOps USING [Abort, ShortCopyREAD, ShortREAD],
  DHeap USING [Zero],
  DPsb USING [State],
  Dump USING [UserText],
  FrameDefs USING [UnlockCode],
  FrameOps USING [MyGlobalFrame, MyLocalFrame],
  Gf USING [NewLink],
  ImageDefs USING [StopMesa, UserCleanupProc],
  Init USING [
    Break, CoreSwapMsg, Debug, FlushCaches, GetUserMessage, NewLoadState, UCSHandler,
    usermessage, warning, bootLoaded],
  InitXD USING [ourBitmapSeg],
  Inline USING [LowHalf],
  OsStaticDefs USING [OsStaticRecord, OsStatics],
  Pc USING [EvalStackEmpty],
  PrincOps USING [SignalDesc],
  ProcessDefs USING [DisableInterrupts, EnableInterrupts],
  ProcessOps USING [ReadWDC, WriteWDC],
  Region USING [Handle, Index],
  SDDefs USING [SD, sXferTrap],
  SegmentDefs USING [
    DataSegmentHandle, DeleteDataSegment, memConfig, ObjectHandle, SwapOut],
  State USING [GetGS, GSHandle],
  SwapperOps USING [DisableBank, EnumerateObjects, mdsIndex, regions, SwapOutCodeSeg],
  TrapOps USING [ReadXTS, WriteXTS],
  TajoMisc USING [SetState],
  UserTerminalOps USING [SetBitmapSpace];

XDSwap: PROGRAM
  IMPORTS BcplOps, BP, Commands, DebugOps, DHeap, DPsb, Dump,
    FrameDefs, FrameOps, Gf, ImageDefs, Init, InitXD, Inline,
    Pc, ProcessDefs, ProcessOps, SegmentDefs, SwapperOps,
    State, TrapOps, TajoMisc, UserTerminalOps
  EXPORTS Init, InitXD
  SHARES SegmentDefs =
  BEGIN OPEN Init, PrincOps;

  data: State.GSHandle _ State.GetGS[];
  saveDWT: AltoHardware.BankRegister _ AltoHardware.BankRegisters[Emulator];

  AbandonHyperspace: PUBLIC PROCEDURE =
    BEGIN OPEN SegmentDefs, SwapperOps;
    UpdateSegs: PROC [object: ObjectHandle] RETURNS [BOOLEAN] = {
      WITH o: object SELECT FROM
	segment => IF o.VMpage > AltoDefs.MaxMDSPage THEN
	  WITH s: o SELECT FROM
	    file =>
	      IF s.class = code THEN SwapOutCodeSeg[@s] ELSE SwapOut[@s];
	    data => DeleteDataSegment[@s];
	  ENDCASE;
	ENDCASE;
      RETURN[FALSE]};
    r: Region.Handle;
    IF InitXD.ourBitmapSeg # NIL THEN {
      DeleteDataSegment[InitXD.ourBitmapSeg]; InitXD.ourBitmapSeg _ NIL};
    FOR i: Region.Index IN Region.Index DO
      IF i = mdsIndex THEN LOOP;
      IF (r _ regions[i]) # NIL THEN r.disable[TRUE];
      ENDLOOP;
    [] _ EnumerateObjects[segment, UpdateSegs];
    FOR i: Region.Index IN Region.Index DO
      IF i = mdsIndex THEN LOOP;
      IF regions[i] # NIL THEN DisableBank[i];
      ENDLOOP;
    FrameDefs.UnlockCode[FrameOps.MyGlobalFrame[]];
    END;

  CoreSwap: PUBLIC PROCEDURE [why: CoreSwapDefs.SwapReason] =
    BEGIN OPEN BcplOps, ControlDefs, SDDefs;
    ourDWT: AltoHardware.BankRegister;
    wdc: CARDINAL;
    xferTrapStatus: TrapStatus;
    xferTrapHandler: UNSPECIFIED;
    e: CoreSwapDefs.ExternalStateVector _ data.ESV;
    alto2xm: BOOLEAN _ SegmentDefs.memConfig.AltoType = AltoIIXM;
    flag: [0..2];

    IF Init.bootLoaded THEN
      BEGIN
      IF why = quit OR why = kill THEN ImageDefs.StopMesa[];
      CoreSwapMsg[cantSwap];
      SIGNAL DebugOps.Abort;
      END;
    DO
    e.reason _ why;
    FlushCaches[IF why = kill THEN abortSession ELSE resumeDebuggee];
    IF why = install THEN {
      [] _ TajoMisc.SetState[disconnected]; UserTerminalOps.SetBitmapSpace[NIL,0]}
    ELSE [] _ TajoMisc.SetState[off];
    ImageDefs.UserCleanupProc[OutLd];
    data.worryEntry _ FALSE;
    ProcessDefs.DisableInterrupts[];
    xferTrapHandler _ SD[sXferTrap];
    SD[sXferTrap] _ FrameOps.MyLocalFrame[];
    xferTrapStatus _ TrapOps.ReadXTS[];
    TrapOps.WriteXTS[TraceOff];
    wdc _ ProcessOps.ReadWDC[];
    IF alto2xm THEN ourDWT _ AltoHardware.BankRegisters[DWT];
    flag _ BcplOutLd[OutLd, @data.selfFP, @e];
    ProcessOps.WriteWDC[wdc];
    SD[sXferTrap] _ xferTrapHandler;
    ProcessDefs.EnableInterrupts[];
    IF flag = 0 THEN	-- just completed OutLd
      BEGIN
      IF why = install THEN ImageDefs.StopMesa[];
      IF alto2xm THEN AltoHardware.BankRegisters[DWT] _ saveDWT;
      IF why = cleanmaplog THEN RETURN;
      e.level _ data.level;
      BcplInLd[InLd,@data.debuggeeFP,@e];
      END;
    IF alto2xm THEN 
      BEGIN
      saveDWT _ AltoHardware.BankRegisters[DWT];
      AltoHardware.BankRegisters[DWT] _ ourDWT;
      END;
    TrapOps.WriteXTS[xferTrapStatus];
    IF e.level # data.level THEN AbandonHyperspace[];
    ImageDefs.UserCleanupProc[InLd];

    [] _ TajoMisc.SetState[disconnected];
    data.ESV _ e;
    data.StatePtr _ e.state;
    data.signal _ LOOPHOLE[0];
    data.breakFrame _ NIL;
    usermessage _ NIL;
    warning _ none;

    SELECT flag FROM
      1 =>	-- just started by InLd
	BEGIN
	SetDebugeeType[];
	Init.bootLoaded _ FALSE;
	SELECT e.reason FROM
	  breakpoint, worrybreak, interrupt =>
	    BEGIN
	    IF e.reason = worrybreak THEN data.worryEntry _ TRUE;
	    IF ~BP.Validate[e.state] OR e.reason = interrupt THEN
	      BEGIN
	      IF ~Pc.EvalStackEmpty[] THEN warning _ evalstack;
	      IF e.level # data.level THEN
		BEGIN
		data.restartMsg _ interrupt;
		NewLoadState[debug];
		END;
	      FlushCaches[resumeSession];
	      CoreSwapMsg[interrupt];
	      Commands.Go[];
	      END
	    ELSE {FlushCaches[resumeSession]; Break[]};
	    why _ proceed;
	    END;
	  explicitcall, worrycall =>
	    BEGIN
	    GetUserMessage[];
	    IF e.reason = worrycall THEN data.worryEntry _ TRUE;
	    IF e.level # data.level THEN NewLoadState[debug];
	    FlushCaches[resumeSession];
	    IF usermessage # NIL THEN Dump.UserText[usermessage];
	    Commands.Go[];
	    why _ proceed;
	    END;
	  uncaughtsignal =>
	    BEGIN
	    data.signal _
	      LOOPHOLE[Gf.NewLink[DebugOps.ShortREAD[@e.state.stk[1]]]];
	    IF e.level # data.level THEN NewLoadState[ucs];
	    FlushCaches[resumeSession];
	    UCSHandler[];
	    why _ resume;
	    END;
	  punt =>
	    BEGIN
	    data.restartMsg _ punt;
	    Init.bootLoaded _ TRUE;
	    data.StatePtr _ data.ESV.state _ Inline.LowHalf[DPsb.State[]]; 
	    NewLoadState[debug];
	    END;
	  return => {FlushCaches[resumeSession]; EXIT};
	  ENDCASE => InvalidMessage[];
	END;
      2 =>	-- just booted
	BEGIN OPEN CoreSwapDefs;
	punt: POINTER TO PuntTable = DebugOps.ShortREAD[PuntInfo];
	Init.bootLoaded _ TRUE;
	SetDebugeeType[];  --so data can be intialized before READs
	data.restartMsg _ bootloaded;
	IF punt # NIL THEN DebugOps.ShortCopyREAD[
	  from: @punt.puntESV, to: @data.ESV, nwords: SIZE[ExternalStateVector]]
	ELSE DHeap.Zero[@data.ESV, SIZE[ExternalStateVector]];
	data.ESV.bitmap _ NIL;
	data.StatePtr _ data.ESV.state _ Inline.LowHalf[DPsb.State[]]; 
	NewLoadState[debug];
	END;
      ENDCASE;
    ENDLOOP;

    data.ESV _ e;
    RETURN
    END;

  SetDebugeeType: PROCEDURE =
    BEGIN OPEN OsStaticDefs, BcplOps;
    vers: ARRAY [0..1] OF WORD _ [61014B, 1400B];
    OsStatics.AltoVersion _ BcplJSR[JSR, @vers, 0];
    data.mds _ 0;
    IF data.ESV.versionident = CoreSwapDefs.VersionID OR Init.bootLoaded THEN RETURN;
    InvalidMessage[];
    END;

  InvalidMessage: PROCEDURE =
    BEGIN
    data.restartMsg _ invalid;
    SIGNAL Debug;
    END;

END.