-- Copyright (C) 1983, 1985  by Xerox Corporation. All rights reserved. 
-- TestPopCorn.mesa, HGM, 25-Jun-85  3:39:05

DIRECTORY
  FormSW USING [
    AllocateItemDescriptor, ClientItemsProcType, CommandItem,
    Display, LongNumberItem, newLine, ProcType, StringItem],
  Heap USING [systemZone],
  MsgSW USING [Post],
  Process USING [Detach, Pause, SecondsToTicks, Yield],
  ProcessorFace USING [microsecondsPerHundredPulses],
  Put USING [Char, CR, Line, LongDecimal, LongNumber, Text],
  Runtime USING [GetBcdTime],
  String USING [AppendString],
  System USING [
    GetClockPulses, GetGreenwichMeanTime,
    GreenwichMeanTime, Pulses, PulsesToMicroseconds],
  Time USING [Append, Unpack],
  Tool USING [
    Create, UnusedLogName, MakeFormSW, MakeFileSW, MakeMsgSW, MakeSWsProc],
  ToolWindow USING [TransitionProcType],
  UserInput USING [UserAbort],
  UserTerminal USING [BlinkDisplay],
  Window USING [Handle],

  PopCorn USING [Error, GetClockOffset],
  PupDefs USING [
    AppendPupAddress, GetPupAddress, PupAddress, PupNameTrouble,
    PupPackageDestroy, PupPackageMake];

TestPopCorn: PROGRAM
  IMPORTS
    FormSW, Heap, MsgSW, Process, ProcessorFace, Put, Runtime, String, System,
    Time, Tool, UserInput, UserTerminal,
    PopCorn, PupDefs =
  BEGIN

  z: UNCOUNTED ZONE = Heap.systemZone;

  msg, log, form: Window.Handle ¬ NIL;
  target: LONG STRING ¬ NIL;
  lo: LONG INTEGER ¬ -9999999;
  hi: LONG INTEGER ¬ 9999999;
  min, max: LONG CARDINAL ¬ 1000000;
  error: LONG CARDINAL ¬ 0;
  running: BOOLEAN ¬ FALSE;

  Init: PROCEDURE =
    BEGIN
    herald: STRING = [100];
    String.AppendString[herald, "TestPopCorn of  "L];
    Time.Append[herald, Time.Unpack[Runtime.GetBcdTime[]]];
    [] ¬ Tool.Create[
      name: herald, makeSWsProc: MakeSWs, clientTransition: Transition];
    END;

  MakeSWs: Tool.MakeSWsProc =
    BEGIN
    logFileName: STRING = [40];
    msg ¬ Tool.MakeMsgSW[window: window, lines: 1];
    form ¬ Tool.MakeFormSW[window: window, formProc: MakeItemArray];
    Tool.UnusedLogName[logFileName, "TestPopCorn.log$"L];
    log ¬ Tool.MakeFileSW[window: window, name: logFileName];
    END;

  MakeItemArray: FormSW.ClientItemsProcType =
    BEGIN
    nItems: CARDINAL = 9;
    i: INTEGER ¬ -1;
    items ¬ FormSW.AllocateItemDescriptor[nItems];
    items[i ¬ i + 1] ¬ FormSW.CommandItem[
      tag: "PokeIt"L, place: FormSW.newLine, proc: PokeIt];
    items[i ¬ i + 1] ¬ FormSW.CommandItem[tag: "Tick"L, proc: Tick];
    items[i ¬ i + 1] ¬ FormSW.CommandItem[tag: "Tock"L, proc: Tock];
    items[i ¬ i + 1] ¬ FormSW.StringItem[tag: "Target"L, string: @target, inHeap: TRUE];
    items[i ¬ i + 1] ¬ FormSW.LongNumberItem[tag: " Lo"L, value: @lo, place: FormSW.newLine];
    items[i ¬ i + 1] ¬ FormSW.LongNumberItem[tag: " Hi"L, value: @hi];
    items[i ¬ i + 1] ¬ FormSW.LongNumberItem[tag: "Min"L, value: @min, place: FormSW.newLine];
    items[i ¬ i + 1] ¬ FormSW.LongNumberItem[tag: "Max"L, value: @max];
    items[i ¬ i + 1] ¬ FormSW.LongNumberItem[tag: "Error"L, value: @error];
    IF (i + 1) # nItems THEN ERROR;
    RETURN[items, TRUE];
    END;

  Transition: ToolWindow.TransitionProcType =
    BEGIN
    SELECT TRUE FROM
      old = inactive =>  -- tool is becomming active
        BEGIN
        [] ¬ PupDefs.PupPackageMake[];
        target ¬ z.NEW[StringBody[40]];
        String.AppendString[target, "PopCorn"L];
        END;
      new = inactive =>
        BEGIN
        z.FREE[@target];
        PupDefs.PupPackageDestroy[];
        END;
      ENDCASE;
    END;

  PokeIt: FormSW.ProcType =
    BEGIN
    where: PupDefs.PupAddress;
    IF running THEN
      BEGIN
      MsgSW.Post[msg, "Already running."L];
      RETURN;
      END;
    Header["Poking...."L];
    Put.Text[log, target];
    Put.Char[log, '=];
    PupDefs.GetPupAddress[@where, target !
      PupDefs.PupNameTrouble =>
        BEGIN MsgSW.Post[msg, e]; Put.Line[log, e]; GOTO Trouble; END];
    PrintPupAddress[where];
    Put.Line[log, "."L];
    running ¬ TRUE;
    Process.Detach[FORK Poker[where]];
    EXITS Trouble => NULL;
    END;
    
  Poker: PROCEDURE [where: PupDefs.PupAddress] =
    BEGIN
    UNTIL UserInput.UserAbort[log] DO
      diff: LONG INTEGER;
      flight, error: LONG CARDINAL;
      [diff, flight] ¬ PopCorn.GetClockOffset[where, 2 !
        PopCorn.Error =>
          BEGIN
	  Put.Text[log, "  Error from PupCorn: "L];
	  Put.Text[log, text];
	  Put.Line[log, "."L];
	  GOTO Trouble;
	  END;];
      Put.Text[log, target];
      Put.Text[log, " says it's clock is "L];
      Put.LongDecimal[log, diff];
      Put.Text[log, " ms faster than ours.  The flight time was "L];
      Put.LongDecimal[log, flight];
      Put.Line[log, " ms."L];
      error ¬ flight + 80;  -- DLion clock jitters  ****************
      CheckLoHigh[diff - error, diff + error];
      Process.Pause[Process.SecondsToTicks[5]];
      ENDLOOP;
    Trailer["Finished."L];
    running ¬ FALSE;
    EXITS Trouble => running ¬ FALSE;
    END;
  
  CheckLoHigh: PROCEDURE [newLow, newHigh: LONG INTEGER] =
    BEGIN
    hit: BOOLEAN ¬ FALSE;
    IF newLow > lo THEN
      BEGIN
      hit ¬ TRUE;
      lo ¬ newLow;
      Put.Text[log, "Better Lo is "L];
      Put.LongDecimal[log, lo];
      Put.Line[log, "."L];
      END;
    IF newHigh < hi THEN
      BEGIN
      hit ¬ TRUE;
      hi ¬ newHigh;
      Put.Text[log, "Better Hi is "L];
      Put.LongDecimal[log, hi];
      Put.Line[log, "."L];
      END;
    IF hit THEN
      BEGIN
      FormSW.Display[form];
      Put.Text[log, "Time is now known within "L];
      Put.LongDecimal[log, (hi - lo + 1) / 2];
      Put.Line[log, " ms."L];
      END;
    IF lo > hi THEN
      BEGIN
      UserTerminal.BlinkDisplay[];
      Put.Line[log, " ******** Clocks are mixed up."L];
      lo ¬ -999999;
      hi ¬ 999999;
      FormSW.Display[form];
      END;
    END;

  Tick: FormSW.ProcType =
    BEGIN
    IF running THEN
      BEGIN
      MsgSW.Post[msg, "Already running."L];
      RETURN;
      END;
    Header["Ticking... (using processor clock)."L];
    running ¬ TRUE;
    Process.Detach[FORK Ticker[]];
    END;
    
  Ticker: PROCEDURE =
    BEGIN
    FOR i: CARDINAL IN [0..100) UNTIL UserInput.UserAbort[log] DO
      start, stop, oldStart, oldStop: System.Pulses;
      first, second: System.GreenwichMeanTime;
      start ¬ System.GetClockPulses[];
      first ¬ System.GetGreenwichMeanTime[];
      DO
        temp: System.Pulses ¬ System.GetClockPulses[];
	second ¬ System.GetGreenwichMeanTime[];
        stop ¬ System.GetClockPulses[];
        IF first # second THEN EXIT;
	start ¬ temp;
        ENDLOOP;
      IF i # 0 THEN
        BEGIN
        slop: LONG CARDINAL;
        slop ¬ System.PulsesToMicroseconds[[stop-start]];
        Put.LongNumber[log, stop-start, [10, FALSE, FALSE, 4]];
        Put.LongNumber[log, slop, [10, FALSE, FALSE, 6]];
        Put.LongNumber[log, System.PulsesToMicroseconds[[start-oldStart]], [10, FALSE, FALSE, 8]];
	Put.Line[log, "."L];
	CheckMinMax[[stop - oldStart], [start - oldStop]];
	END;
      THROUGH [0..10) DO Process.Yield[]; ENDLOOP;
      oldStart ¬ start;
      oldStop ¬ stop;
      ENDLOOP;
    Trailer["Finished."L];
    running ¬ FALSE;
    END;
	
  Tock: FormSW.ProcType =
    BEGIN
    IF running THEN
      BEGIN
      MsgSW.Post[msg, "Already running."L];
      RETURN;
      END;
    Header["Tocking... (using our clock)."L];
    running ¬ TRUE;
    Process.Detach[FORK Tocker[]];
    END;
    
  Tocker: PROCEDURE =
    BEGIN
    FOR i: CARDINAL IN [0..100) UNTIL UserInput.UserAbort[log] DO
      start, stop, oldStart, oldStop: System.Pulses;
      first, second: System.GreenwichMeanTime;
      start ¬ System.GetClockPulses[];
      first ¬ MyGetGreenwichMeanTime[];
      DO
        temp: System.Pulses ¬ System.GetClockPulses[];
	second ¬ MyGetGreenwichMeanTime[];
        stop ¬ System.GetClockPulses[];
        IF first # second THEN EXIT;
	start ¬ temp;
        ENDLOOP;
      IF i # 0 THEN
        BEGIN
        slop: LONG CARDINAL;
        slop ¬ System.PulsesToMicroseconds[[stop-start]];
        Put.LongNumber[log, stop-start, [10, FALSE, FALSE, 4]];
        Put.LongNumber[log, slop, [10, FALSE, FALSE, 6]];
        Put.LongNumber[log, System.PulsesToMicroseconds[[start-oldStart]], [10, FALSE, FALSE, 8]];
	Put.Line[log, "."L];
	CheckMinMax[[stop - oldStart], [start - oldStop]];
	END;
      THROUGH [0..10) DO Process.Yield[]; ENDLOOP;
      oldStart ¬ start;
      oldStop ¬ stop;
      ENDLOOP;
    Trailer["Finished."L];
    running ¬ FALSE;
    END;
	
  CheckMinMax: PROCEDURE [minPulses, maxPulses: System.Pulses] =
    BEGIN
    hit: BOOLEAN ¬ FALSE;
    newMin: LONG CARDINAL ¬ System.PulsesToMicroseconds[minPulses];
    newMax: LONG CARDINAL ¬ System.PulsesToMicroseconds[maxPulses];
    UNTIL newMax < 1500000 DO newMax ¬ newMax - 1000000; ENDLOOP;
    IF newMin < min THEN
      BEGIN
      hit ¬ TRUE;
      min ¬ newMin;
      Put.Text[log, "New Min is "L];
      Put.LongDecimal[log, min];
      Put.Line[log, "."L];
      END;
    IF newMax > max THEN
      BEGIN
      hit ¬ TRUE;
      max ¬ newMax;
      Put.Text[log, "New Max is "L];
      Put.LongDecimal[log, max];
      Put.Line[log, "."L];
      END;
    IF hit THEN
      BEGIN
      oldError: LONG CARDINAL ¬ error;
      error ¬ MAX[(1000000 - min), (max - 1000000)];
      FormSW.Display[form];
      IF error # oldError THEN
        BEGIN
        Put.Text[log, "Clock error is now up to "L];
        Put.LongDecimal[log, error];
        Put.Line[log, " microsec."L];
	END;
      END;
    END;
      
  -- Simulate greenwich mean time features of ProcessorFace using
  -- interval timer because DLion TOD clock has much jitter

  MyGetGreenwichMeanTime: PROCEDURE RETURNS [System.GreenwichMeanTime] =
    BEGIN
    seconds: System.GreenwichMeanTime =
      [((System.GetClockPulses[] - pulsesGmtSimulated)*100)/pulsesPer100Seconds];
    pulsesGmtSimulated ¬ pulsesGmtSimulated + seconds*pulsesPer100Seconds/100;
    -- long multiply!  The truncation keeps pulsesGmtSimulated at the right value
    gmtSimulated ¬ [gmtSimulated + seconds];
    RETURN[gmtSimulated]
    END;
      
  MySetGreenwichMeanTime: PROCEDURE [gmt: System.GreenwichMeanTime] =
    BEGIN
    pulsesGmtSimulated ¬ System.GetClockPulses[];
    gmtSimulated ¬ gmt;
    END;
  
  gmtSimulated: System.GreenwichMeanTime;
  pulsesGmtSimulated: LONG CARDINAL;
  pulsesPer100Seconds: LONG CARDINAL ¬ 10*(1D9/ProcessorFace.microsecondsPerHundredPulses);
  
  Header: PROCEDURE [s: STRING] =
    BEGIN
    Put.CR[log];
    Put.Line[log, s];
    MsgSW.Post[msg, s];
    END;
  
  Trailer: PROCEDURE [s: STRING] =
    BEGIN
    Put.Line[log, s];
    MsgSW.Post[msg, s];
    END;
    
  PrintPupAddress: PROCEDURE [a: PupDefs.PupAddress] =
    BEGIN
    temp: STRING = [40];
    PupDefs.AppendPupAddress[temp, a];
    Put.Text[log, temp];
    END;

  MySetGreenwichMeanTime[System.GetGreenwichMeanTime[]];
  Init[];
  END...