Copyright (C) 1994, Digital Equipment Corp.
********************************************************************
* NOTE: This file is generated automatically from the event
* definition file gefevent.evt.
********************************************************************
<* PRAGMA LL *>
MODULE gefeventIE;
<* NOWARN *> IMPORT RefList;
<* NOWARN *> IMPORT SLispClass;
<*NOWARN*> IMPORT gefeventAlgClass, gefeventViewClass;
<*NOWARN*> IMPORT Algorithm, AlgorithmClass, Thread, View, Zeus, ZeusClass;
<* FATAL Zeus.Error, Zeus.Locked *>
If you get either of these errors, contact a Zeus implementor.
TYPE
InitArgs = BRANDED REF RECORD
files: RefList.T
END;
EventArgs = BRANDED REF RECORD
name: TEXT; args: RefList.T
END;
UpdateArgs = BRANDED REF RECORD
name: TEXT; args: RefList.T
END;
FeedbackArgs = BRANDED REF RECORD
name: TEXT; args: RefList.T
END;
PauseArgs = BRANDED REF RECORD
END;
Zeus calls the following to invoke vbt v's event handler:
<*NOWARN*> PROCEDURE OEDispatcher(v: ZeusClass.T; evt: REFANY) RAISES {Thread.Alerted} =
<* LL <= VBT.mu *>
(* LL = {} if event style is output, LL = VBT.mu if event style is update. *)
BEGIN
TYPECASE v OF
| gefeventViewClass.T (view) => <*NOWARN*>
TYPECASE evt OF
| InitArgs(varInitArgs) => <*NOWARN*>
view.oeInit (
varInitArgs.files
)
| EventArgs(varEventArgs) => <*NOWARN*>
view.oeEvent (
varEventArgs.name
,
varEventArgs.args
)
| PauseArgs(varPauseArgs) => <*NOWARN*>
view.oePause (
)
| UpdateArgs(varUpdateArgs) => <*NOWARN*>
view.ueUpdate (
varUpdateArgs.name
,
varUpdateArgs.args
)
ELSE <* ASSERT FALSE *>
END;
ELSE (* this view isn't a gefeventViewClass, so just ignore *)
END
END OEDispatcher;
<*NOWARN*> PROCEDURE FEDispatcher(v: ZeusClass.T; evt: REFANY) =
<* LL = VBT.mu *>
BEGIN
TYPECASE v OF
| gefeventAlgClass.T (alg) => <*NOWARN*>
TYPECASE evt OF
| FeedbackArgs(varFeedbackArgs) => <*NOWARN*>
alg.feFeedback (
varFeedbackArgs.name
,
varFeedbackArgs.args
)
ELSE <* ASSERT FALSE *>
END;
ELSE (* this alg isn't a gefeventAlgClass, so just ignore *)
END
END FEDispatcher;
PROCEDURE Init (
initiator: Algorithm.T;
files: RefList.T
) RAISES {Thread.Alerted} =
<* LL = {} *>
VAR zumeArgRec := NEW(InitArgs
, files := files
);
alg := NARROW(initiator, gefeventAlgClass.T);
BEGIN
LOCK alg.evtMu DO
INC(alg.eventDataRec.ctOfInit);
alg.stopAtEvent := alg.eventDataRec.stopAtInit;
alg.waitAtEvent := alg.eventDataRec.waitAtInit;
Zeus.Dispatch(initiator, Zeus.EventStyle.Output, 1,
"Init", OEDispatcher, zumeArgRec);
END;
END Init;
PROCEDURE Event (
initiator: Algorithm.T;
name: TEXT; args: RefList.T
) RAISES {Thread.Alerted} =
<* LL = {} *>
VAR zumeArgRec := NEW(EventArgs
, name := name
, args := args
);
alg := NARROW(initiator, gefeventAlgClass.T);
BEGIN
LOCK alg.evtMu DO
INC(alg.eventDataRec.ctOfEvent);
alg.stopAtEvent := alg.eventDataRec.stopAtEvent;
alg.waitAtEvent := alg.eventDataRec.waitAtEvent;
Zeus.Dispatch(initiator, Zeus.EventStyle.Output, 1,
"Event", OEDispatcher, zumeArgRec);
END;
END Event;
PROCEDURE Pause (
initiator: Algorithm.T;
) RAISES {Thread.Alerted} =
<* LL = {} *>
VAR zumeArgRec := NEW(PauseArgs
);
alg := NARROW(initiator, gefeventAlgClass.T);
BEGIN
LOCK alg.evtMu DO
INC(alg.eventDataRec.ctOfPause);
alg.stopAtEvent := alg.eventDataRec.stopAtPause;
alg.waitAtEvent := alg.eventDataRec.waitAtPause;
Zeus.Dispatch(initiator, Zeus.EventStyle.Output, 1,
"Pause", OEDispatcher, zumeArgRec);
END;
END Pause;
PROCEDURE Update (
initiator: Algorithm.T;
name: TEXT; args: RefList.T
) RAISES {Thread.Alerted} =
<* LL = VBT.mu *>
VAR zumeArgRec := NEW(UpdateArgs
, name := name
, args := args
);
BEGIN
Zeus.Dispatch(initiator, Zeus.EventStyle.Update, 1,
"Update", OEDispatcher, zumeArgRec);
END Update;
PROCEDURE Feedback (
initiator: View.T;
name: TEXT; args: RefList.T
) RAISES {Thread.Alerted} =
<* LL = VBT.mu *>
VAR zumeArgRec := NEW(FeedbackArgs
, name := name
, args := args
);
BEGIN
Zeus.Dispatch(initiator, Zeus.EventStyle.Notify, 1,
"Feedback", FEDispatcher, zumeArgRec);
END Feedback;
BEGIN
END gefeventIE.