-- EmulatorTestImpl.mesa    11-Dec-81 10:07:06 by JGS

-- Test program to exercise the the Mesa emulator of a PrincOps machine.

DIRECTORY
  EmulatorTest,
  ESCAlpha,
  Mopcodes,
  SDDefs;

EmulatorTestImpl: PROGRAM
  IMPORTS EmulatorTest =

  BEGIN OPEN EmulatorTest, SDDefs, ESCAlpha, Mopcodes;
 
  -- Useful variables:

  BothOnes: PROCEDURE RETURNS [LONG CARDINAL] = MACHINE CODE {zLIN1; zLIN1};
  
  zero: CARDINAL _ 0; 
  one: CARDINAL _ 1; 
  two: CARDINAL _ 2; 
  three: CARDINAL _ 3; 
  four: CARDINAL _ 4; 
  five: CARDINAL _ 5; 
  six: CARDINAL _ 6; 
  seven: CARDINAL _ 7; 
  eight: CARDINAL _ 8; 
  nine: CARDINAL _ 9; 
  ten: CARDINAL _ 10; 
  eleven: CARDINAL _ 11; 
  twelve: CARDINAL _ 12; 
  thirteen: CARDINAL _ 13; 
  fourteen: CARDINAL _ 14; 
  fifteen: CARDINAL _ 15; 
  fourHundred: CARDINAL = 400B;
  allOnes: CARDINAL _ 177777B; 
  negInfinity: CARDINAL = 100000B;
  minusTwo: CARDINAL = 177776B;
  
  loopCount: CARDINAL _ 100; 
  currentOpcode: CARDINAL;
  
  oneTwo: LONG CARDINAL _ 200000B * 1 + 2;
  oneThree: LONG CARDINAL _ 200000B * 1 + 3;
  twoFour: LONG CARDINAL _ 200000B * 2 + 4;
  threeFour: LONG CARDINAL _ 200000B * 3 + 4;
  fourSix: LONG CARDINAL _ 200000B * 4 + 6;
  fiveSix: LONG CARDINAL _ 200000B * 5 + 6;
  zeroAllOnes: LONG CARDINAL _ 177777B;
  oneAllZeros: LONG CARDINAL _ 200000B;
  bothZero: LONG CARDINAL _ 0;
  bothOnes: LONG CARDINAL _ BothOnes[];
   
  a, b, i: CARDINAL;
  aD, bD: LONG CARDINAL;
   
  proc: PROCEDURE;
  
  SetMP: PROCEDURE [CARDINAL] = MACHINE CODE {zESC, aWRMP};

  Halt: PROCEDURE [code: CARDINAL] = INLINE {SetMP[code]; DO i _ 0 ENDLOOP};
  
  SetTest: PROCEDURE [opcode: CARDINAL] = INLINE {
    SetMP[opcode]; currentOpcode _ opcode};

  Low: PROCEDURE [a: LONG UNSPECIFIED] RETURNS [UNSPECIFIED] = INLINE {
    RETURN[LOOPHOLE[a, RECORD[low, high: CARDINAL]].low]};
  
  High: PROCEDURE [a: LONG UNSPECIFIED] RETURNS [UNSPECIFIED] = INLINE {
    RETURN[LOOPHOLE[a, RECORD[low, high: CARDINAL]].high]};
  
  -- Trap Handlers
  
  BreakTrap: PROCEDURE = {Halt[9000+SDDefs.sBreakTrap]};
  StackError: PROCEDURE = {Halt[8000+currentOpcode]};
  RescheduleError: PROCEDURE = {Halt[9000+SDDefs.sRescheduleError]};
  XferTrap: PROCEDURE = {Halt[9000+SDDefs.sXferTrap]};
  OpcodeTrap: PROCEDURE = {Halt[9000+SDDefs.sOpcodeTrap]};
  ControlTrap: PROCEDURE = {Halt[9000+SDDefs.sControlTrap]};
  CodeTrap: PROCEDURE = {Halt[9000+SDDefs.sCodeTrap]};
  HardwareError: PROCEDURE = {Halt[9000+SDDefs.sHardwareError]};
  UnboundTrap: PROCEDURE = {Halt[9000+SDDefs.sUnboundTrap]};
  DivZeroTrap: PROCEDURE = {Halt[9000+SDDefs.sDivZeroTrap]};
  DivCheckTrap: PROCEDURE = {Halt[9000+SDDefs.sDivCheckTrap]};
  InterruptError: PROCEDURE = {Halt[9000+SDDefs.sInterruptError]};
  ProcessTrap: PROCEDURE = {Halt[9000+SDDefs.sProcessTrap]};
  BoundsTrap: PROCEDURE = {Halt[9000+SDDefs.sBoundsTrap]};
  PointerTrap: PROCEDURE = {Halt[9000+SDDefs.sPointerTrap]};
  
  FillInSD: PROCEDURE = {
    SDDefs.SD[sBreakTrap] _ BreakTrap;
    SDDefs.SD[sStackError] _ StackError;
    SDDefs.SD[sRescheduleError] _ RescheduleError;
    SDDefs.SD[sXferTrap] _ XferTrap;
    SDDefs.SD[sOpcodeTrap] _ OpcodeTrap;
    SDDefs.SD[sControlTrap] _ ControlTrap;
    SDDefs.SD[sCodeTrap] _ CodeTrap;
    SDDefs.SD[sHardwareError] _ HardwareError;
    SDDefs.SD[sUnboundTrap] _ UnboundTrap;
    SDDefs.SD[sDivZeroTrap] _ DivZeroTrap;
    SDDefs.SD[sDivCheckTrap] _ DivCheckTrap;
    SDDefs.SD[sInterruptError] _ InterruptError;
    SDDefs.SD[sProcessTrap] _ ProcessTrap;
    SDDefs.SD[sBoundsTrap] _ BoundsTrap;
    SDDefs.SD[sPointerTrap] _ PointerTrap;
    SetTest[zRET]};

  JumpTests: PROC = {
    SetTest[zJEP];
    a _ one;
    b _ two;
    IF a # 2 THEN a _ one ELSE Halt[1000+zJEP];
    IF a # 1 THEN Halt[2000+zJEP];
    SetTest[zJEBB];
    a _ 40;
    b _ one;
    IF a # 44 THEN a _ 40 ELSE Halt[1000+zJEBB];
    IF a # 40 THEN Halt[2000+zJEBB];
    SetTest[zJNEP];
    a _ one;
    b _ two;
    IF a = 1 THEN a _ two ELSE Halt[1000+zJNEP];
    IF a = 1 THEN Halt[2000+zJNEP];
    SetTest[zJNEBB];
    a _ 40;
    b _ one;
    IF a = 40 THEN a _ 44 ELSE Halt[1000+zJNEBB];
    IF a = 40 THEN Halt[2000+zJNEBB];
    SetTest[zRET];
    RETURN};
     
  
  StackTests: PROCEDURE = {
    SetTest[zREC];
    i _ 0;
    DO
      a _ nine; IF REC[] # nine THEN Halt[1000+zREC]; 
      i _ i + one;
      IF loopCount = i THEN EXIT;
      ENDLOOP;
    SetTest[zREC2];
    i _ 0;
    DO
      aD _ threeFour;
      bD _ REC2[];
      IF High[bD] # three OR Low[bD] # four THEN Halt[1000+zREC2]; 
      i _ i + one;
      IF loopCount = i THEN EXIT;
      ENDLOOP;
    SetTest[zDIS];
    i _ 0;
    DO
      DIS[a]; IF REC[] # a THEN Halt[1000+zDIS]; 
      i _ i + one;
      IF loopCount = i THEN EXIT;
      ENDLOOP;
    SetTest[zDIS2];
    i _ 0;
    DO
      DIS2[twoFour]; 
      bD _ REC2[];
      IF High[bD] # two OR Low[bD] # four THEN Halt[1000+zDIS2]; 
      i _ i + one;
      IF loopCount = i THEN EXIT;
      ENDLOOP;
    SetTest[zEXCH];
    i _ 0;
    DO
      [c: a, d: b] _ EXCH[a: one, b: two];
      IF a # two OR b # one THEN Halt[1000+zEXCH];
      i _ i + one;
      IF loopCount = i THEN EXIT;
      ENDLOOP;
    SetTest[zDEXCH];
    i _ 0;
    DO
      [c: aD, d: bD] _ DEXCH[a: oneTwo, b: threeFour];
      IF High[aD] # three OR Low[aD] # four OR High[bD] # one OR Low[bD] # two THEN
        Halt[1000+zDEXCH];
      i _ i + one;
      IF loopCount = i THEN EXIT;
      ENDLOOP;
    SetTest[zDUP];
    i _ 0;
    DO
      [a: a, b: b] _ DUP[six];
      IF a # six OR b # six THEN Halt[1000+zDUP];
      i _ i + one;
      IF loopCount = i THEN EXIT;
      ENDLOOP;
    SetTest[zDDUP];
    i _ 0;
    DO
      [a: aD, b: bD] _ DDUP[fiveSix];
      IF High[aD] # five OR Low[aD] # six OR High[bD] # five OR Low[bD] # six THEN Halt[1000+zDDUP];
      i _ i + one;
      IF loopCount = i THEN EXIT;
      ENDLOOP;
    SetTest[zEXDIS];
    i _ 0;
    DO
      a _ EXDIS[a: three, b: four]; IF a # four THEN Halt[1000+zEXDIS]; 
      i _ i + one;
      IF loopCount = i THEN EXIT;
      ENDLOOP;
    SetTest[zNEG];
    i _ 0;
    DO
      a _ NEG[one]; IF a # allOnes THEN Halt[1000+zNEG]; 
      i _ i + one;
      IF loopCount = i THEN EXIT;
      ENDLOOP;
    SetTest[zINC];
    i _ 0;
    DO
      a _ INC[one]; IF a # two THEN Halt[1000+zINC]; 
      i _ i + one;
      IF loopCount = i THEN EXIT;
      ENDLOOP;
    SetTest[zDEC];
    i _ 0;
    DO
      a _ DEC[three]; IF a # two THEN Halt[1000+zDEC]; 
      i _ i + one;
      IF loopCount = i THEN EXIT;
      ENDLOOP;
    SetTest[zDINC];
    i _ 0;
    DO
      aD _ DINC[zeroAllOnes];
      IF Low[aD] # zero OR High[aD] # one THEN Halt[1000+zDINC]; 
      i _ i + one;
      IF loopCount = i THEN EXIT;
      ENDLOOP;
    SetTest[zDBL];
    i _ 0;
    DO
      a _ DBL[six]; IF a # twelve THEN Halt[1000+zDBL]; 
      i _ i + one;
      IF loopCount = i THEN EXIT;
      ENDLOOP;
    SetTest[zDDBL];
    i _ 0;
    DO
      aD _ DDBL[oneTwo];
      IF High[aD] # two OR Low[aD] # four THEN Halt[1000+zDDBL]; 
      i _ i + one;
      IF loopCount = i THEN EXIT;
      ENDLOOP;
    SetTest[zTRPL];
    i _ 0;
    DO
      a _ TRPL[three]; IF a # nine THEN Halt[1000+zTRPL]; 
      i _ i + one;
      IF loopCount = i THEN EXIT;
      ENDLOOP;
    SetTest[zAND];
    i _ 0;
    DO
      a _ ANDOp[a: three, b: six];
      IF a # two THEN Halt[1000+zAND]; 
      a _ ANDOp[a: five, b: allOnes];
      IF a # five THEN Halt[2000+zAND]; 
      a _ ANDOp[a: five, b: zero];
      IF a # zero THEN Halt[3000+zAND];
      i _ i + one;
      IF loopCount = i THEN EXIT;
      ENDLOOP;
    SetTest[zIOR];
    i _ 0;
    DO
      a _ IOR[a: three, b: six];
      IF a # seven THEN Halt[1000+zIOR]; 
      a _ IOR[a: five, b: allOnes];
      IF a # allOnes THEN Halt[2000+zIOR]; 
      a _ IOR[a: five, b: zero];
      IF a # five THEN Halt[3000+zIOR];
      i _ i + one;
      IF loopCount = i THEN EXIT;
      ENDLOOP;
    SetTest[zADDSB];
    i _ 0;
    DO
      ADDOne: PROC [CARDINAL] RETURNS [CARDINAL] = MACHINE CODE {zADDSB, 1};
      ADDNegOne: PROC [CARDINAL] RETURNS [CARDINAL] = MACHINE CODE {zADDSB, 377B};
      a _ ADDOne[four];
      IF a # five THEN Halt[1000+zADDSB]; 
      a _ ADDNegOne[four];
      IF a # three THEN Halt[2000+zADDSB]; 
      i _ i + one;
      IF loopCount = i THEN EXIT;
      ENDLOOP;
    SetTest[zADD];
    i _ 0;
    DO
      a _ ADD[a: three, b: four];
      IF a # seven THEN Halt[1000+zADD]; 
      i _ i + one;
      IF loopCount = i THEN EXIT;
      ENDLOOP;
    SetTest[zSUB];
    i _ 0;
    DO
      a _ SUB[a: four, b: three];
      IF a # one THEN Halt[1000+zSUB]; 
      i _ i + one;
      IF loopCount = i THEN EXIT;
      ENDLOOP;
    SetTest[zDADD];
    i _ 0;
    DO
      aD _ DADD[a: oneTwo, b: threeFour];
      IF High[aD] # four OR Low[aD] # six THEN Halt[1000+zDADD];
      aD _ DADD[a: zeroAllOnes, b: one];
      IF High[aD] # one OR Low[aD] # zero THEN Halt[2000+zDADD]; 
      i _ i + one;
      IF loopCount = i THEN EXIT;
      ENDLOOP;
    SetTest[zDSUB];
    i _ 0;
    DO
      aD _ DSUB[a: fourSix, b: threeFour];
      IF High[aD] # one OR Low[aD] # two THEN Halt[1000+zDSUB];
      aD _ DSUB[a: oneAllZeros, b: one];
      IF High[aD] # zero OR Low[aD] # allOnes THEN Halt[2000+zDSUB]; 
      i _ i + one;
      IF loopCount = i THEN EXIT;
      ENDLOOP;
    SetTest[zACD];
    i _ 0;
    DO
      aD _ ACD[a: one, b: oneTwo];
      IF High[aD] # one OR Low[aD] # three THEN Halt[1000+zACD];
      aD _ ACD[a: one, b: zeroAllOnes];
      IF High[aD] # one OR Low[aD] # zero THEN Halt[2000+zACD]; 
      i _ i + one;
      IF loopCount = i THEN EXIT;
      ENDLOOP;
    SetTest[zADC];
    i _ 0;
    DO
      aD _ ADC[a: oneTwo, b: one];
      IF High[aD] # one OR Low[aD] # three THEN Halt[1000+zADC];
      aD _ ADC[a: zeroAllOnes, b: one];
      IF High[aD] # one OR Low[aD] # zero THEN Halt[2000+zADC]; 
      i _ i + one;
      IF loopCount = i THEN EXIT;
      ENDLOOP;
    SetTest[zMUL];
    i _ 0;
    DO
      [c: a, d: b] _ MUL[a: one, b: three];
      IF a # three OR b # zero THEN Halt[1000+zMUL];
      [c: a, d: b] _ MUL[a: fourHundred, b: fourHundred];
      IF a # zero OR b # one THEN Halt[2000+zMUL]; 
      i _ i + one;
      IF loopCount = i THEN EXIT;
      ENDLOOP;
    SetTest[zDCMP];
    i _ 0;
    DO
      a _ DCMP[a: FIRST[LONG INTEGER], b: bothZero];
      IF a # allOnes THEN Halt[1000+zDCMP];
      a _ DCMP[a: oneTwo, b: oneTwo];
      IF a # zero THEN Halt[2000+zDCMP];
      a _ DCMP[a: LAST[LONG INTEGER], b: bothZero];
      IF a # one THEN Halt[3000+zDCMP]; 
      i _ i + one;
      IF loopCount = i THEN EXIT;
      ENDLOOP;
    SetTest[zUDCMP];
    i _ 0;
    DO
      a _ UDCMP[a: zero, b: fourSix];
      IF a # allOnes THEN Halt[1000+zUDCMP];
      a _ UDCMP[a: oneTwo, b: oneTwo];
      IF a # zero THEN Halt[2000+zUDCMP];
      a _ UDCMP[a: bothOnes, b: bothZero];
      IF a # one THEN Halt[3000+zUDCMP]; 
      i _ i + one;
      IF loopCount = i THEN EXIT;
      ENDLOOP;
    SetTest[zSHIFT];
    i _ 0;
    DO
      a _ SHIFT[a: one, b: two];
      IF a # four THEN Halt[1000+zSHIFT];
      a _ SHIFT[a: one, b: fourHundred];
      IF a # zero THEN Halt[2000+zSHIFT];
      a _ SHIFT[a: fourHundred, b: -5];
      IF a # eight THEN Halt[3000+zSHIFT];
      i _ i + one;
      IF loopCount = i THEN EXIT;
      ENDLOOP;
    SetTest[zSHIFTSB];
    i _ 0;
    DO
      a _ three*4;
      IF a # twelve THEN Halt[1000+zSHIFTSB];
      a _ fourHundred/200B;
      IF a # two THEN Halt[2000+zSHIFTSB];
      i _ i + one;
      IF loopCount = i THEN EXIT;
      ENDLOOP;
    SetTest[zRET];
    RETURN};
    
  Singles: TYPE = RECORD [a, b, c, d, e, f: CARDINAL _ NULL];
  pSingles: POINTER TO Singles;
  lpSingles: LONG POINTER TO Singles;
  singles: Singles;

  Doubles: TYPE = RECORD [a, b, c: LONG CARDINAL _ NULL];
  lpDoubles: LONG POINTER TO Doubles;
  pDoubles: POINTER TO Doubles;
  doubles: Doubles;
  
  Bytes: TYPE = RECORD [
    SELECT OVERLAID * FROM 
      bytes => [bytes: PACKED ARRAY [0..4) OF [0..256)],
      words => [words: ARRAY [0..2) OF CARDINAL],
      ENDCASE];
  lpBytes: LONG POINTER TO Bytes;
  pBytes: POINTER TO Bytes;
  bytes: Bytes;

  Fields: TYPE = RECORD [
    SELECT OVERLAID * FROM 
      fields => [a,b,c,d,e,f,g,h,i,j,k,l: [0..16) _ NULL],
      stackFields => [stackFields: PACKED ARRAY [0..12) OF [0..16)],
      words => [words: ARRAY [0..3) OF CARDINAL],
      ENDCASE];
  lpFields: LONG POINTER TO Fields;
  pFields: POINTER TO Fields;
  fields: Fields;

  SetupReadTests: PROC = {
    pSingles _ @singles;
    lpSingles _ @singles;
    pDoubles _ @doubles;
    lpDoubles _ @doubles;
    pBytes _ @bytes;
    lpBytes _ @bytes;
    pFields _ @fields;
    lpFields _ @fields;
    RETURN};
  
  ReadWriteTests: PROC = {
    LocalVars: TYPE = RECORD [
      l0, l1: POINTER TO Doubles, l2: LONG POINTER TO Doubles,
      l4: POINTER TO Singles, l5: LONG POINTER TO Singles,
      l7: POINTER TO Fields, l8: LONG POINTER TO Fields];
    locals: LocalVars _ [
      l0: pDoubles, l1: pDoubles, l2: lpDoubles, l4: pSingles, l5: lpSingles,
      l7: pFields, l8: lpFields];
    SetTest[zRD0];
    THROUGH [0..loopCount) DO
      doubles.a _ oneTwo;
      IF pDoubles.a # oneTwo THEN Halt[1000+zRD0]; 
      ENDLOOP;
    SetTest[zRDB];
    THROUGH [0..loopCount) DO
      doubles.b _ oneTwo;
      IF pDoubles.b # oneTwo THEN Halt[1000+zRDB]; 
      ENDLOOP;
    SetTest[zRDL0];
    THROUGH [0..loopCount) DO
      doubles.a _ oneTwo;
      IF lpDoubles.a # oneTwo THEN Halt[1000+zRDL0]; 
      ENDLOOP;
    SetTest[zRDLB];
    THROUGH [0..loopCount) DO
      doubles.b _ oneTwo;
      IF lpDoubles.b # oneTwo THEN Halt[1000+zRDLB]; 
      ENDLOOP;
    SetTest[zPSB];
    THROUGH [0..loopCount) DO
      pSingles^ _ [a: zero, c: one, e: two];
      IF singles.a # zero OR singles.c # one OR singles.e # two THEN
        Halt[1000+zPSB]; 
      ENDLOOP;
    SetTest[zWLB];
    THROUGH [0..loopCount) DO
      lpSingles.a _ four;
      IF singles.a # four THEN Halt[1000+zWLB]; 
      ENDLOOP;
    SetTest[zPSLB];
    THROUGH [0..loopCount) DO
      lpSingles^ _ [a: zero, c: one, e: two];
      IF singles.a # zero OR singles.c # one OR singles.e # two THEN
        Halt[1000+zPSLB]; 
      ENDLOOP;
    SetTest[zWDB];
    THROUGH [0..loopCount) DO
      pDoubles.a _ oneTwo;
      IF doubles.a # oneTwo THEN Halt[1000+zWDB]; 
      ENDLOOP;
    SetTest[zPSD0];
    THROUGH [0..loopCount) DO
      PSD0: PROC [p: POINTER, d: LONG CARDINAL] RETURNS[POINTER] =
        MACHINE CODE {zPSD0};
      [] _ PSD0[pDoubles, threeFour];
      IF doubles.a # threeFour THEN Halt[1000+zPSD0]; 
      ENDLOOP;
    SetTest[zPSDB];
    THROUGH [0..loopCount) DO
      pDoubles^ _ [b: oneTwo, c: fiveSix];
      IF doubles.b # oneTwo OR doubles.c # fiveSix THEN Halt[1000+zPSDB]; 
      ENDLOOP;
    SetTest[zWDLB];
    THROUGH [0..loopCount) DO
      lpDoubles.a _ oneTwo;
      IF doubles.a # oneTwo THEN Halt[1000+zWDLB]; 
      ENDLOOP;
    SetTest[zRLI00];
    THROUGH [0..loopCount) DO
      doubles.a _ oneTwo;
      IF Low[locals.l0.a] # two THEN Halt[1000+zRLI00]; 
      ENDLOOP;
    SetTest[zRLI01];
    THROUGH [0..loopCount) DO
      doubles.a _ oneTwo;
      IF High[locals.l0.a] # one THEN Halt[1000+zRLI01]; 
      ENDLOOP;
    SetTest[zRLI02];
    THROUGH [0..loopCount) DO
      doubles.b _ oneTwo;
      IF Low[locals.l0.b] # two THEN Halt[1000+zRLI02]; 
      ENDLOOP;
    SetTest[zRLI03];
    THROUGH [0..loopCount) DO
      doubles.b _ oneTwo;
      IF High[locals.l0.b] # one THEN Halt[1000+zRLI03]; 
      ENDLOOP;
    SetTest[zRLIP];
    THROUGH [0..loopCount) DO
      doubles.b _ oneTwo;
      IF High[locals.l1.b] # one THEN Halt[1000+zRLIP]; 
      ENDLOOP;
    SetTest[zRLILP];
    THROUGH [0..loopCount) DO
      doubles.b _ threeFour;
      IF High[locals.l2.b] # three THEN Halt[1000+zRLILP]; 
      ENDLOOP;
    SetTest[zRLDI00];
    THROUGH [0..loopCount) DO
      doubles.a _ threeFour;
      IF locals.l0.a # threeFour THEN Halt[1000+zRLDI00]; 
      ENDLOOP;
    SetTest[zRLDIP];
    THROUGH [0..loopCount) DO
      doubles.a _ threeFour;
      IF locals.l1.b # threeFour THEN Halt[1000+zRLDIP]; 
      ENDLOOP;
    SetTest[zRLDILP];
    THROUGH [0..loopCount) DO
      doubles.a _ threeFour;
      IF locals.l2.b # threeFour THEN Halt[1000+zRLDILP]; 
      ENDLOOP;
    SetTest[zWLIP];
    THROUGH [0..loopCount) DO
      locals.l4.a _ three;
      IF singles.a # three THEN Halt[1000+zWLIP]; 
      ENDLOOP;
    SetTest[zWLILP];
    THROUGH [0..loopCount) DO
      locals.l5.b _ one;
      IF singles.b # one THEN Halt[1000+zWLILP]; 
      ENDLOOP;
    SetTest[zWLDILP];
    THROUGH [0..loopCount) DO
      locals.l2.b _ allOnes;
      IF doubles.b # allOnes THEN Halt[1000+zWLDILP]; 
      ENDLOOP;
    SetTest[zRS];
    THROUGH [0..loopCount) DO
      bytes.words[0] _ fourHundred;
      IF pBytes.bytes[zero] # one OR pBytes.bytes[one] # zero THEN Halt[1000+zRS]; 
      ENDLOOP;
    SetTest[zRLS];
    THROUGH [0..loopCount) DO
      bytes.words[0] _ fourHundred;
      IF lpBytes.bytes[zero] # one OR lpBytes.bytes[one] # zero THEN
        Halt[1000+zRLS]; 
      ENDLOOP;
    SetTest[zWS];
    THROUGH [0..loopCount) DO
      pBytes.bytes[zero] _ zero;
      pBytes.bytes[one] _ allOnes;
      IF bytes.words[zero] # fourHundred - one THEN Halt[1000+zWS]; 
      ENDLOOP;
    SetTest[zWLS];
    THROUGH [0..loopCount) DO
      lpBytes.bytes[two] _ one;
      lpBytes.bytes[three] _ two;
      IF bytes.words[1] # (fourHundred + two) THEN Halt[1000+zWLS]; 
      ENDLOOP;
    SetTest[zR0F];
    THROUGH [0..loopCount) DO
      fields.words[0] _ four;
      IF pFields.a # zero OR pFields.d # four THEN Halt[1000+zR0F]; 
      ENDLOOP;
    SetTest[zRF];
    THROUGH [0..loopCount) DO
      fields.words[1] _ seven;
      IF pFields.f # zero OR pFields.h # seven THEN Halt[1000+zRF]; 
      ENDLOOP;
    SetTest[zRL0F];
    THROUGH [0..loopCount) DO
      fields.words[0] _ fourHundred;
      IF lpFields.b # one OR lpFields.d # zero THEN Halt[1000+zRL0F]; 
      ENDLOOP;
    SetTest[zRLF];
    THROUGH [0..loopCount) DO
      fields.words[1] _ nine;
      IF lpFields.g # zero OR lpFields.h # nine THEN Halt[1000+zRLF]; 
      ENDLOOP;
    SetTest[zRLFS];
    THROUGH [0..loopCount) DO
      fields.words[0] _ nine;
      IF lpFields.stackFields[one] # zero
      OR lpFields.stackFields[three] # nine THEN Halt[1000+zRLFS]; 
      ENDLOOP;
    SetTest[zRLIPF];
    THROUGH [0..loopCount) DO
      locals.l7.words[0] _ fourHundred + nine;
      IF locals.l7.b # one OR locals.l7.d # nine THEN
        Halt[1000+zRLIPF]; 
      ENDLOOP;
    SetTest[zRLILPF];
    THROUGH [0..loopCount) DO
      locals.l7.words[1] _ fourHundred + ten;
      IF locals.l8.f # one OR locals.l8.h # ten THEN
        Halt[1000+zRLILPF]; 
      ENDLOOP;
    SetTest[zW0F];
    THROUGH [0..loopCount) DO
      pFields.a _ one;
      pFields.c _ four;
      IF pFields.a # one OR pFields.c # four THEN Halt[1000+zW0F]; 
      ENDLOOP;
    SetTest[zWF];
    THROUGH [0..loopCount) DO
      pFields.e _ one;
      pFields.f _ four;
      IF pFields.e # one OR pFields.f # four THEN Halt[1000+zWF]; 
      ENDLOOP;
    SetTest[zPS0F];
    THROUGH [0..loopCount) DO
      pFields^ _ [fields[a: one, b: two, c: three, d: five]];
      IF pFields.a # one OR pFields.b # two OR pFields.c # three THEN
        Halt[1000+zPS0F]; 
      IF pFields.d # five THEN Halt[1000+zWS0F]; 
      ENDLOOP;
    SetTest[zWL0F];
    THROUGH [0..loopCount) DO
      lpFields.a _ one;
      lpFields.c _ four;
      IF lpFields.a # one OR lpFields.c # four THEN Halt[1000+zWL0F]; 
      ENDLOOP;
    SetTest[zWLF];
    THROUGH [0..loopCount) DO
      lpFields.e _ two;
      lpFields.h _ eight;
      IF lpFields.e # two OR lpFields.h # eight THEN Halt[1000+zWLF]; 
      ENDLOOP;
    SetTest[zPSLF];
    THROUGH [0..loopCount) DO
      lpFields^ _ [fields[a: one, b: two, c: three, d: five]];
      IF lpFields.a # one OR lpFields.b # two OR lpFields.c # three
      OR lpFields.d # five THEN Halt[1000+zPSLF]; 
      ENDLOOP;
    SetTest[zWLFS];
    THROUGH [0..loopCount) DO
      lpFields.stackFields[1] _ zero;
      lpFields.stackFields[3] _ nine;
      IF lpFields.stackFields[1] # zero OR lpFields.stackFields[3] # nine THEN
        Halt[1000+zWLFS]; 
      ENDLOOP;
    SetTest[zRET];
    RETURN}; 

  ExternalTests: PROC = {
    SetTest[zEFCB];
    EmulatorTest.InitHelper[]; 
    SetTest[zRKIB];
    THROUGH [0..loopCount) DO
      a _ EmulatorTest.varOne;
      IF a # one THEN Halt[1000+zRKIB]; 
      ENDLOOP;
    SetTest[zRKDIB];
    THROUGH [0..loopCount) DO
      aD _ EmulatorTest.varOneTwo;
      IF aD # varOneTwo THEN Halt[1000+zRKDIB]; 
      ENDLOOP;
    SetTest[zEFCB];
    proc _ EmulatorTest.Proc[];
    SetTest[zLLKB];
    THROUGH [0..loopCount) DO
      IF EmulatorTest.InitHelper # proc THEN Halt[1000+zLLKB]; 
      ENDLOOP;
    SetTest[zRET];
    RETURN}; 
      
        -- Start Tests
  
  SetTest[400];
  FillInSD[];

  DO
    SetTest[zLFCB];
    JumpTests[];
    SetTest[zLFCB];
    StackTests[];
    SetTest[zLFCB];
    SetupReadTests[];
    SetTest[zLFCB];
    ReadWriteTests[]
    ENDLOOP;
  
  
  END.


LOG

12-Oct-81 16:05:36   Knutsen   New instruction set.