-- File: PtCommand.mesa,  Last Edit: HGM  November 8, 1979  11:12 PM

DIRECTORY
  AltoDisplay: FROM "AltoDisplay" USING [DCBHandle, DCBnil, DCBchainHead],
  IODefs: FROM "IODefs" USING [CR, ReadChar, WriteChar, WriteDecimal, WriteLine, WriteString],
  KeyDefs: FROM "KeyDefs" USING [Keys],
  MiscDefs: FROM "MiscDefs" USING [CallDebugger],
  ProcessDefs: FROM "ProcessDefs" USING [MsecToTicks, SetTimeout],
  StreamDefs: FROM "StreamDefs" USING [StreamHandle, GetDefaultKey],
  TrapDefs: FROM "TrapDefs" USING [UnboundProcedure],
  StatsDefs: FROM "StatsDefs" USING [StatFinish],
  PupDefs: FROM "PupDefs" USING [
    PupPackageDestroy, PupPackageMake,
    InspectIncomingPups, InspectOutgoingPups, ShowPupBuffer,
    SetPupCheckit, SetLocalOnly, SetPupStormy],
  PtDefs: FROM "PtDefs" USING [
    CursorBits,
    PtBSPDoubleSend, PtBSPListen, PtBSPPushPull, PtBSPRecv, PtBSPSend, PtBSPUnListen,
    PtOCDoubleSend, PtOCListen, PtOCPushPull, PtOCRecv, PtOCSend, PtOCUnListen,
    PtPktDoubleSend, PtPktListen, PtPktPushPull, PtPktRecv, PtPktSend, PtPktUnListen,
    PtRejListen, PtRejUnListen,
    PtSocEcho, PtSocPushPull, PtSocRecv, PtSocSend, PtSocTurnabout,
    PtBuffers, PtDisplay, PtHost, PtInterface, PtLookerSince, PtNames,
    PtPrintThings, PtPRThings,
    PtFixHostAndNet, PtOnOff, PtSched, PtEchoer,
    PtEchoOff, PtEchoOn, PtStatsOff, PtStatsOn];

PtCommand: MONITOR [pt: PtDefs.PtInterface]
  IMPORTS
    IODefs, MiscDefs, ProcessDefs, StreamDefs, TrapDefs,
    StatsDefs, PupDefs, PtDefs
  EXPORTS PtDefs =
BEGIN OPEN IODefs, StatsDefs, PupDefs, PtDefs, pt;


LengthMismatch: PUBLIC SIGNAL = CODE;
DataMismatch: PUBLIC SIGNAL = CODE;


firstDCB: AltoDisplay.DCBHandle _ AltoDisplay.DCBchainHead^;
checkit: BOOLEAN _ TRUE;  -- See PupRouter
showit, stormy: BOOLEAN _ FALSE;

-- various diddly routines used by other parts of puptest

-- next random number generator
Random: PUBLIC PROCEDURE [random: CARDINAL] RETURNS [CARDINAL] =
  BEGIN
  RETURN [(random*1976+3)/2];
  END;

-- lightning (debugging hack in router) really slows things down
SeeStorms: PUBLIC PROCEDURE =
  BEGIN
  IF dataWordsPerPup#266 THEN
    BEGIN
    WriteDecimal[dataWordsPerPup];
    WriteLine[" data words per pup."L];
    END;
  IF checkit THEN WriteLine["
*****   CheckSums on - be patient."L];
  IF stormy THEN WriteLine["
*****   Beware of lightning storms."L];
  IF ~ticking THEN WriteLine["Clock not ticking."L];
  IF ~displaying THEN WriteLine["Display is off."L];
  END;

UnListen: PUBLIC PROCEDURE =
  BEGIN
  PtPktUnListen[];
  PtBSPUnListen[];
  PtOCUnListen[];
  PtRejUnListen[];
  END;

Confirm: PROCEDURE RETURNS [b: BOOLEAN] =
  BEGIN
  WriteString[" [Confirm] "L];
  IF ReadChar[]=IODefs.CR THEN b_TRUE ELSE b_FALSE;
  WriteLine[""L];
  END;

SmashCursor: PROCEDURE =
  BEGIN
  CursorBits^ _ [177777B,177777B,0,0,0,0,0,0,0,0,0,0,0,0,0,0];
  END;



active: CARDINAL;
timer: CONDITION;

Done: PUBLIC ENTRY PROCEDURE =
  BEGIN
  active _ active-1;
  NOTIFY timer;
  END;

ks: StreamDefs.StreamHandle = StreamDefs.GetDefaultKey[];
WaitUntilDone: PUBLIC ENTRY PROCEDURE [num: CARDINAL] =
  BEGIN
  clockInterruptWord: POINTER TO WORD = LOOPHOLE[421B];
  oldClockWord: WORD _ clockInterruptWord^;
  active _ num;
  ProcessDefs.SetTimeout[@timer,ProcessDefs.MsecToTicks[1000]];
  -- leave the timeout ticker on
  IF ~ticking THEN clockInterruptWord^ _ 0000020B;  -- this kills ^Swat
  IF ~displaying THEN AltoDisplay.DCBchainHead^ _ AltoDisplay.DCBnil;
  stopFlag _ FALSE;
  UNTIL active=0 DO
    WAIT timer;  -- peek at KBD every second or so
    IF ticking THEN
      BEGIN
      IF ~ks.endof[ks] THEN stopFlag _ TRUE;
      END
    ELSE
      BEGIN
      IF KeyDefs.Keys.Space=down THEN stopFlag _ TRUE;
      IF KeyDefs.Keys.Ctrl=down AND KeyDefs.Keys.Spare3=down THEN
        MiscDefs.CallDebugger["Control Swat."L];
      END;
    ENDLOOP;
  IF ~displaying THEN AltoDisplay.DCBchainHead^ _ firstDCB;
  IF ~ticking THEN clockInterruptWord^ _ oldClockWord;
  WriteLine[""L];
  PtLookerSince[];
  stopFlag _ FALSE;
  END;

PupTestMainLoop: PUBLIC PROCEDURE =
  BEGIN
  c: CHARACTER;
  SeeStorms[];
  DO
    SmashCursor[];
    WriteChar['*];
    SELECT ReadChar[] FROM
      '  => WriteLine[""L];
      '. => WriteLine["."L];
      '- =>
        BEGIN
        WriteChar['-]; WriteChar['-];
        UNTIL (c_ReadChar[])=CR DO WriteChar[c]; ENDLOOP;
        WriteChar[CR];
        END;
      'B, 'b =>
        BEGIN
        WriteString["BSP "L];
        SELECT ReadChar[] FROM
          'D, 'd => BEGIN WriteLine["DoubleSend."L]; PtBSPDoubleSend[]; END;
          'L, 'l =>
            BEGIN
            WriteLine["Listen."L];
            UnListen[];
            pullHim.socket _ [0,0];
            pushMe.socket _ [0,0];
            PtBSPListen[];
            END;
          'M, 'm =>
            BEGIN
            WriteString["Mode b"L];
            SELECT ReadChar[] FROM
              'L, 'l => BEGIN WriteLine["Lock."L]; mode_block; END;
              'Y, 'y => BEGIN WriteLine["Yte."L]; mode_byte; END;
              '? => WriteLine[" (b)Y(te) or (b)L(ock)."L];
              ENDCASE => WriteLine["???"L];
            END;
          'P, 'p => BEGIN WriteLine["PushPull."L]; PtBSPPushPull[]; END;
          'R, 'r => BEGIN WriteLine["Receive."L]; PtBSPRecv[]; END;
          'S, 's => BEGIN WriteLine["Send."L]; PtBSPSend[]; END;
          '? => WriteLine[" D(oubleSend), L(isten), M(ode), P(ushPull), R(eceive), or S(end)."L];
          ENDCASE => WriteLine["???"L];
        END;
      'C, 'c =>
        BEGIN
        WriteString["Contents "L];
        SELECT ReadChar[] FROM
          'A, 'a => BEGIN WriteLine["Alternating."L]; data_alternating; END;
          'C, 'c => BEGIN WriteLine["Cyclic."L]; data_cyclic; END;
          'I, 'i => BEGIN WriteLine["Ignore."L]; data_ignore; END;
          'O, 'o => BEGIN WriteLine["Ones."L]; data_ones; END;
          'R, 'r => BEGIN WriteLine["Random."L]; data_random; END;
          'Z, 'z => BEGIN WriteLine["Zeros."L]; data_zeros; END;
          '? => WriteLine[" A(lternating), C(yclic), O(nes), Z(eros), R(andom), or I(gnore)."L];
          ENDCASE => WriteLine["???"L];
        END;
      'D, 'd => BEGIN WriteLine["D(ebug)."L]; MiscDefs.CallDebugger["Debug."L]; END;
      'E, 'e => BEGIN WriteLine["E(cho)."L]; PtEchoer[]; END;
      'H, 'h => BEGIN WriteString["Host: "L]; PtHost[]; END;
      'L, 'l =>
        BEGIN
        WriteString["Length "L];
        SELECT ReadChar[] FROM
          'C, 'c => BEGIN WriteLine["Cyclic."L]; length_cyclic; END;
          'I, 'i => BEGIN WriteLine["Ignore."L]; length_ignore; END;
          'L, 'l => BEGIN WriteLine["Long."L]; length_long; END;
          'R, 'r => BEGIN WriteLine["Random."L]; length_random; END;
          'S, 's => BEGIN WriteLine["Short."L]; length_short; END;
          '? => WriteLine[" L(ong), S(hort),  I(gnore), R(andom), or C(yclic)."L];
          ENDCASE => WriteLine["???"L];
        END;
      'M, 'm =>
        BEGIN
        WriteString["Miscellaneous "L];
        SELECT ReadChar[] FROM
          'B, 'b => BEGIN WriteLine["Buffers"L]; PtBuffers[]; END;
          'D, 'd => BEGIN WriteLine["Display"L]; PtDisplay[]; END;
          'N, 'n => BEGIN WriteLine["NameTester"L]; PtNames[]; END;
          'O, 'o => BEGIN WriteLine["On-Off tester."L]; PtOnOff[]; END;
          'P, 'p => PtPrintThings[];  -- it does the rest of the decoding
          'R, 'r =>
            BEGIN
            PtPRThings[ !  -- Larry Stewart's Packet Radio Experiments
              TrapDefs.UnboundProcedure => GOTO Reject];
            EXITS Reject => WriteLine["Packet Radio tester not loaded!"L];
            END;
          'S, 's => BEGIN WriteLine["Scheduler timer."L]; PtSched[]; END;
          '? => WriteLine[" B(uffers), L(ook), N(ame), O(n-Off), P(rint), R(adio), S(cheduler)."L];
          ENDCASE => WriteLine["???"L];
        END;
      'O, 'o =>
        BEGIN
        WriteString["OpenClose "L];
        SELECT ReadChar[] FROM
          'D, 'd => BEGIN WriteLine["DoubleSend."L]; PtOCDoubleSend[]; END;
          'L, 'l =>
            BEGIN
            WriteLine["Listen."L];
            UnListen[];
            pullHim.socket _ [0,0];
            pushMe.socket _ [0,0];
            PtOCListen[];
            END;
          'P, 'p => BEGIN WriteLine["PushPull."L]; PtOCPushPull[]; END;
          'R, 'r => BEGIN WriteLine["Receive."L]; PtOCRecv[]; END;
          'S, 's => BEGIN WriteLine["Send."L]; PtOCSend[]; END;
          '? => WriteLine[" D(oubleSend), L(isten), P(ushPull), R(eceive), or S(end)."L];
          ENDCASE => WriteLine["???"L];
        END;
      'P, 'p =>
        BEGIN
        WriteString["Packet "L];
        SELECT ReadChar[] FROM
          'D, 'd => BEGIN WriteLine["DoubleSend."L]; PtPktDoubleSend[]; END;
          'L, 'l =>
            BEGIN
            WriteLine["Listen."L];
            UnListen[];
            pullHim.socket _ [0,0];
            pushMe.socket _ [0,0];
            PtPktListen[];
            END;
          'P, 'p => BEGIN WriteLine["PushPull."L]; PtPktPushPull[]; END;
          'R, 'r => BEGIN WriteLine["Receive."L]; PtPktRecv[]; END;
          'S, 's => BEGIN WriteLine["Send."L]; PtPktSend[]; END;
          '? => WriteLine[" D(oubleSend), L(isten), P(ushPull), R(eceive), or S(end)."L];
          ENDCASE => WriteLine["???"L];
        END;
      'Q, 'q =>
        BEGIN
        WriteString["Quit."L];
        IF Confirm[] THEN BEGIN StatFinish[]; RETURN[]; END
        ELSE WriteLine[" ???."L];
        END;
      'R, 'r =>
        BEGIN
        WriteLine["Rejector listen."L];
        PtRejListen[];
        END;
      'S, 's =>
        BEGIN
        WriteString["Socket "L];
        SELECT ReadChar[] FROM
          'E, 'e => BEGIN WriteLine["Echo."L]; PtSocEcho[]; END;
          'P, 'p => BEGIN WriteLine["PushPull."L]; PtSocPushPull[]; END;
          'R, 'r => BEGIN WriteLine["Receive."L]; PtSocRecv[]; END;
          'S, 's => BEGIN WriteLine["Send."L]; PtSocSend[]; END;
          'T, 't => BEGIN WriteLine["Turnabout."L]; PtSocTurnabout[]; END;
          '? => WriteLine[" E(cho), P(ushPull), R(eceive), S(end), or T(urnabout)."L];
          ENDCASE => WriteLine["???"L];
        END;
      'T, 't =>
        BEGIN
        WriteString["Toggle "L];
        SELECT ReadChar[] FROM
          'C, 'c =>
            BEGIN
            WriteString["checkIt.  "L];
            SetPupCheckit[checkit_~checkit];
            IF checkit THEN WriteLine["Checksums on."L]
            ELSE WriteLine["Checksums off."L];
            END;
          'D, 'd =>
            BEGIN
            WriteLine["displaying."L];
            displaying _ ~displaying;
            IF displaying THEN WriteLine["Display on while testing."L]
            ELSE WriteLine["Display off while testing."L];
            END;
          'I, 'i =>
            BEGIN
            WriteLine["info."L];
            info _ ~info;
            IF info THEN WriteLine["Normal info while testing."L]
            ELSE WriteLine["No info while testing."L];
            END;
          'L, 'l =>
            BEGIN
            WriteLine["localOnly."L];
            UnListen[];
            PtStatsOff[];
            PtEchoOff[];
            PupPackageDestroy[];
            SetLocalOnly[localOnly_~localOnly];
            PupPackageMake[];
            PtFixHostAndNet[];
            PtStatsOn[];
            PtEchoOn[];
            IF localOnly THEN WriteLine["It's quiet in here."L]
            ELSE WriteLine["Its noisy outside."L];
            END;
          'T, 't =>
            BEGIN
            WriteLine["ticking."L];
            ticking _ ~ticking;
            IF ticking THEN WriteLine["Clock will run normally."L]
            ELSE WriteLine["No KBD while testing - ^Swat won't work."L];
            END;
          'V, 'v =>
            BEGIN
            WriteLine["Verbose=showit."L];
            showit_~showit;
            InspectIncomingPups[showit,ShowPupBuffer];
            InspectOutgoingPups[showit,ShowPupBuffer];
            IF showit THEN WriteLine["Watch out, you might see a lot of things."L]
            ELSE WriteLine["No more Showing packets."L];
            END;
          'Z, 'z =>
            BEGIN
            WriteLine["Zappem=stormy."L];
            SetPupStormy[stormy_~stormy];
            IF stormy THEN WriteLine["Zapping packets."L]
            ELSE WriteLine["No more Zapping packets."L];
            END;
          '? => WriteLine["C(heckit), I(nfo), L(ocalOnly),
  V(erbose), or Z(apem)"L];
          ENDCASE => WriteLine["???"L];
        END;
      'U, 'u => BEGIN WriteLine["Unlisten."L]; UnListen[]; END;
      'X, 'x => BEGIN WriteLine["Statistics."L]; PtLookerSince[]; END;
      '? => WriteLine["?
B(SP), P(acket), S(ocket), O(penClose), U(nListen), E(cho),
C(ontents), H(ost), L(ength),
D(ebug), Q(uit), R(eject), M(isc), T(oggle), X(stats)."L];
      ENDCASE => WriteLine["???"L];
    ENDLOOP;
  END;


END.  -- of PtCommand(2048)\82t2 1t0 140t2 8t0 13t2 1t0 72t2 8t0 17t2 1t0