IMPLEMENTATION MODULE TestHandler ;

IMPORT Handler , DirtyHandler , Versions ;
IMPORT DecodeArg ;
IMPORT Debug ;
FROM SYSTEM IMPORT TKCALL,ADR;
FROM TKCalls IMPORT TKcli,TKnewl;
FROM String IMPORT LengthC;
FROM Handler IMPORT UsersEnvironment,TypeCode;
FROM Debug IMPORT WriteS , WriteI ;
FROM IO IMPORT FindOutput , SelectOutput ;
VAR ticks : CARDINAL;
VAR eventcount :CARDINAL;
(* ------------------------------------------------------------------------- *)
PROCEDURE JohnsConditionhandler(    t :TypeCode;
                           i : INTEGER ;
                      VAR E1 : UsersEnvironment;
                      VAR E2 : UsersEnvironment) : INTEGER ;
VAR junk :INTEGER;
BEGIN
       junk := TKCALL( TKnewl);
  Debug.WriteHex( i,8) ;
       junk := TKCALL( TKnewl);
  Debug.WriteHex( E2.PC,8) ;
       junk := TKCALL( TKnewl);

  Debug.WriteHex( E2.Mod,8) ;
       junk := TKCALL( TKnewl);

  Debug.WriteHex( E2.PC,8) ;
  Debug.WriteS( "*NMod=" ) ;
  Debug.WriteHex( E2.Mod,8) ;
  Debug.WriteS( "*N" ) ;
IF i = 6 THEN
   E2.PC :=  E2.PC + 4;
  Debug.WriteS( "*Nmodified PC=" ) ;
  Debug.WriteS( "*Ndivide by zero-skip inst and continue*N" ) ;
  RETURN 1 
END;
(*signal so return*)
  Debug.WriteS( "*Nsignal so return*N" ) ;
  RETURN 1
END JohnsConditionhandler ;
(* ------------------------------------------------------------------------- *)
PROCEDURE JohnsEventhandler(    code   : INTEGER;
                                data1  : INTEGER ;
                                data2  : INTEGER ;
                                handle : INTEGER ;
                                VAR E  : UsersEnvironment) ;
BEGIN
  Debug.WriteS( "*N johnies event handler> " ) ;

  Debug.WriteS( "data1" ) ;
  Debug.WriteHex( data1,2) ;
  Debug.WriteS( "*N" ) ;

  Debug.WriteS( "data2" ) ;
  Debug.WriteHex( data2,2) ;
  Debug.WriteS( "*N" ) ;

END JohnsEventhandler ;
(* ------------------------------------------------------------------------- *)
PROCEDURE OTHEREventhandler(    code   : INTEGER;
                                data1  : INTEGER ;
                                data2  : INTEGER ;
                                handle : INTEGER ;
                                VAR E  : UsersEnvironment) ;
BEGIN
 IF code = 4 THEN
  ticks := ticks + CARDINAL(data1) ;
 END;
 IF code = 2 THEN
  eventcount := eventcount + 1;
 END;
END OTHEREventhandler ;

(* ------------------------------------------------------------------------- *)

PROCEDURE Program( ArgumentString : ARRAY OF CHAR ) : INTEGER ;
VAR
   Result                  : INTEGER ;

 (* ------------------------------------------------------------------------- *)   PROCEDURE Check( This : INTEGER ) : BOOLEAN ;
   BEGIN
      IF ( This < 0 ) AND ( Result = 0 ) THEN
         Result := This ;
      END (* if *) ;
      RETURN This >= 0 ;
   END Check ;


VAR
   Handle                  : DecodeArg.DecodedInformation ;
   OldValue                : BOOLEAN ;
   Div                     : BOOLEAN ;
   thestate                : BOOLEAN ;
   count                   : CARDINAL;
   thetime                 : CARDINAL;
   repeatcount             : CARDINAL;
   Left                    : INTEGER ;
   Right                   : INTEGER ;
   Number                  : INTEGER ;
   Identity                : BOOLEAN ;
   Output                  : INTEGER ;
   junk                    : INTEGER ;
   runLength                  : CARDINAL;
   runstring               : ARRAY [ 0.. 80] OF CHAR ;
   KeyString               : ARRAY [ 0..40 ] OF CHAR ;

BEGIN
   Result := 0;
   KeyString := "time/C[10],repeat/C[10],test/S" ;
   IF Check( DecodeArg.DecodeInit( Handle , KeyString , ArgumentString ) ) AND
      Check( DecodeArg.GetCardinalArg( thetime , "time" , 1 ,Handle ) ) AND
      Check( DecodeArg.GetCardinalArg( repeatcount , "repeat" ,1, Handle ))AND
      Check( DecodeArg.GetStateArg( thestate,"test",Handle ) ) THEN
      Debug.WriteS( "JOHNIES Test*N" ) ;
      ticks := 0;
      eventcount :=0;

      junk :=Handler.DeclareConditionHandler(JohnsConditionhandler);

      Debug.WriteS( "DIVIDE BY ZERO*N" ) ;
      ticks := ticks DIV eventcount;

 

      Debug.WriteS( "SIGNAL 23*N" ) ;
      Handler.Signal(23,NIL);

      Debug.WriteS( "TURN ON VERTICAL SYNCS*N" ) ;
      junk :=Handler.DeclareEventHandler(OTHEREventhandler,4,1,15);
      junk :=Handler.SetEventStatus(4,TRUE);
 
      junk :=Handler.DeclareEventHandler(OTHEREventhandler,2,1,15);

      IF thestate THEN
      Debug.WriteS( "TURN ON KEYBOARD EVENTS*N" ) ;
      junk :=Handler.SetEventStatus(2,TRUE);
      ELSE
      runstring := "events";
      runLength := LengthC(runstring);
      junk := TKCALL( TKcli ,ADR(runstring),runLength );
      END;

      FOR count := 1 TO repeatcount DO
       REPEAT 
       UNTIL ( ticks > (thetime*50));
       Debug.WriteI( eventcount) ;
       Debug.WriteI( ticks DIV 50) ;
       ticks := 0;
       eventcount := 0;
     END;

     IF Check( DecodeArg.DecodeEnd( Handle ) ) THEN
     END (* if *) ;
   END;
   RETURN Result ;
END Program ;

END TestHandler.