DEFINITION MODULE Handler;
(* Exception and Event Handling. *)

FROM SYSTEM IMPORT ADDRESS, WORD;

EXPORT QUALIFIED BufferEmpty, BufferFull, KeyboardInt, ADCComplete, VSync,
		 TimerInt, Escape, Other,
		 ExceptionType,	UsersEnvironment, UsersEnvironmentPTR,
		 RegisterTypes,	RegisterType, PSRBits, PSRBit, TypeCode,
		 PointerToModuleRecord,	ModuleRecord,
		 ConditionHandlerType, UserEventHandler,
		 Signal, CallHandler, DeclareConditionHandler,
		 DeclareEventHandler, RemoveEventHandler,
		 EventStatus, SetEventStatus, ControlEventVariable,
		 XSignal, XCallHandler,	XDeclareConditionHandler,
		 XDeclareEventHandler, XRemoveEventHandler,
		 XEventStatus, XSetEventStatus,	XControlEventVariable;
		 
(* ----------------------------------------------------------------------- *)
CONST  BufferEmpty = 0;
       BufferFull = 1;
       KeyboardInt = 2;
       ADCComplete = 3;
       VSync = 4;
       TimerInt	= 5;
       Escape =	6;
       Other = 255;

(* ----------------------------------------------------------------------- *)
TYPE
   RegisterType	= (pc, sp1, fp,	upsr, mod, r0, r1, r2, r3, r4, r5, r6, r7,
     f0, f1, f2, f3, f4, f5, f6, f7, fsr);
   RegisterTypes = SET OF RegisterType;

   PSRBit = (c,	t, l, b3, b4, f, z, n, u, s, p,	i);
   PSRBits = SET OF PSRBit;

   TypeCode = (Init, Stop, Except, ExceptPassedOn, Diagnose,
     DiagnosePassedOn, DescribeFrame, DescibeModuleData, Unwind);

   LinkTableEntry = WORD;

   ExceptionType = (NVI, NMI, ABT, FPU,	ILL, SVC, DVZ, FLG, BPT, TRC, UND);

   PointerToModuleRecord = POINTER TO ModuleRecord;
   ModuleRecord	= RECORD
     StaticBase: ADDRESS;
     LinkTableBase: POINTER TO ARRAY[-1000000..+1000000]OF LinkTableEntry;
     ProgramBase: ADDRESS;
     Reserved: WORD;
   END;

   UsersEnvironment = RECORD
     Validity: RegisterTypes;
     PC: ADDRESS;
     SP1: ADDRESS;
     FP: ADDRESS;
     UserPSR: PSRBits;
     Mod: PointerToModuleRecord;
     Register: ARRAY[0..7]OF WORD;
     FPRegister: ARRAY[0..7]OF WORD;
     FSR: BITSET;
   END;
   UsersEnvironmentPTR = POINTER TO UsersEnvironment;

   ConditionHandlerType	= PROCEDURE(
     TypeCode, INTEGER,	VAR UsersEnvironment, VAR UsersEnvironment): INTEGER;

   UserEventHandler = PROCEDURE(
     INTEGER, INTEGER, INTEGER,	INTEGER, VAR UsersEnvironment);

(* ----------------------------------------------------------------------- *)
PROCEDURE Signal(
  cause: INTEGER;   (* in *)
  buffer: ADDRESS); (* in *)

(* ----------------------------------------------------------------------- *)
PROCEDURE CallHandler(
  type:	TypeCode;		    (* in *)
  parameter: INTEGER;		    (* in *)
  VAR currentEnv: UsersEnvironment; (* modified	*)
  VAR exceptEnv: UsersEnvironment)  (* modified	*)
  :INTEGER;			    (* result =	value returned from handler *)

(* ----------------------------------------------------------------------- *)
PROCEDURE DeclareConditionHandler(
  conditionHandler: ConditionHandlerType) (* in	*)
  :INTEGER;				  (* result >= 0 success else error *)

(* ----------------------------------------------------------------------- *)
PROCEDURE DeclareEventHandler(
  newHandler: UserEventHandler;	(* in *)
  event: CARDINAL;		(* in *)
  action: CARDINAL;		(* in *)
  handle: CARDINAL)		(* in *)
  :INTEGER;			(* result >= 0 success else error *)

(* ----------------------------------------------------------------------- *)
PROCEDURE RemoveEventHandler(
  handler: UserEventHandler; (*	in *)
  event: CARDINAL;	     (*	in *)
  handle: CARDINAL)	     (*	in *)
  :INTEGER;		     (*	result >= 0 success else error *)

(* ----------------------------------------------------------------------- *)
PROCEDURE EventStatus(
  event: CARDINAL) (* in *)
  :INTEGER;	   (* result < 0 error else 0..2 eventStatus *)

(* ----------------------------------------------------------------------- *)
PROCEDURE SetEventStatus(
  event: CARDINAL;     (* in *)
  newStatus: CARDINAL) (* in *)
  :INTEGER;	       (* result < 0 error else	0..2 oldEventStatus *)

(* ----------------------------------------------------------------------- *)
PROCEDURE ControlEventVariable(
  event: CARDINAL;		  (* in	*)
  action: CARDINAL;		  (* in	*)
  eventVariablesAddress: ADDRESS; (* in	*)
  value: CARDINAL)		  (* in	*)
  : INTEGER; (*	result < 0 error else success, result =	counterVariableValue
	     if	action = 4 *)

(* ----------------------------------------------------------------------- *)
PROCEDURE XSignal(
  cause: INTEGER;   (* in *)
  buffer: ADDRESS); (* in *)

(* ----------------------------------------------------------------------- *)
PROCEDURE XCallHandler(
  type:	TypeCode;		    (* in *)
  parameter: INTEGER;		    (* in *)
  VAR currentEnv: UsersEnvironment; (* modified	*)
  VAR exceptEnv: UsersEnvironment)  (* modified	*)
  :INTEGER;			    (* result =	value returned from handler *)

(* ----------------------------------------------------------------------- *)
PROCEDURE XDeclareConditionHandler(handler: ConditionHandlerType); (* in *)

(* ----------------------------------------------------------------------- *)
PROCEDURE XDeclareEventHandler(
  newHandler: UserEventHandler;	(* in *)
  event: CARDINAL;		(* in *)
  action: CARDINAL;		(* in *)
  handle: CARDINAL);		(* in *)

(* ----------------------------------------------------------------------- *)
PROCEDURE XRemoveEventHandler(
  handler: UserEventHandler; (*	in *)
  event: CARDINAL;	     (*	in *)
  handle: CARDINAL);	     (*	in *)

(* ----------------------------------------------------------------------- *)
PROCEDURE XEventStatus(
  event: CARDINAL) (* in *)
  :INTEGER;	   (* result = eventStatus *)

(* ----------------------------------------------------------------------- *)
PROCEDURE XSetEventStatus(
  event: CARDINAL;     (* in *)
  newStatus: CARDINAL) (* in *)
  :INTEGER;	       (* result = oldEventStatus *)

(* ----------------------------------------------------------------------- *)
PROCEDURE XControlEventVariable(
  event: CARDINAL;		  (* in	*)
  action: CARDINAL;		  (* in	*)
  eventVariablesAddress: ADDRESS; (* in	*)
  value: CARDINAL)		  (* in	*)
  : INTEGER; (*	result = counterVariableValue if action	= 4, else undefined *)

END Handler.