Copyright (C) 1994, Digital Equipment Corp.
********************************************************************
* NOTE: This file is generated automatically from the event
* definition file gefevent.evt.
********************************************************************
MODULE gefeventAlgClass;
<* NOWARN *> IMPORT RefList;
<* NOWARN *> IMPORT SLispClass;
IMPORT Algorithm, Fmt, FormsVBT, Rd, Text;
IMPORT VBT, Wr, ZeusClass, ZeusPanel, ZeusUtil;
<* PRAGMA LL *>
Fix any FormsVBT errors; don't handle exceptions for them.
<* FATAL FormsVBT.Error, FormsVBT.Unimplemented, Rd.Failure *>
REVEAL
T = Public BRANDED OBJECT
OVERRIDES
<* LL = VBT.mu *>
init := gefeventDefaultInit;
snapshot := gefeventDefaultSnapshot;
restore := gefeventDefaultRestore;
updateEventCounts := gefeventDefaultUpdateCts;
feFeedback := Feedback;
END;
PROCEDURE gefeventDefaultInit (v: T): Algorithm.T =
<* LL = VBT.mu *>
PROCEDURE Attach (id: TEXT; proc: FormsVBT.Proc) =
BEGIN
FormsVBT.AttachProc(v.eventData, id, proc, v);
END Attach;
BEGIN
v.eventData := ZeusPanel.NewForm("gefeventEventData.fv");
Attach("stopatCodeEvents", gefeventDoIt);
Attach("waitatCodeEvents", gefeventDoIt);
Attach("eventCounts", gefeventRefreshCts);
Attach("stopAtInit", gefeventDoIt);
Attach("waitAtInit", gefeventDoIt);
Attach("stopAtEvent", gefeventDoIt);
Attach("waitAtEvent", gefeventDoIt);
Attach("stopAtPause", gefeventDoIt);
Attach("waitAtPause", gefeventDoIt);
FromFV (v.eventData, v); (* Get FV and internal data in sync *)
RETURN Algorithm.T.init(v);
END gefeventDefaultInit;
PROCEDURE gefeventDoIt ( fv : FormsVBT.T;
e : TEXT;
arg: REFANY;
<*UNUSED*> t : VBT.TimeStamp) =
<* LL = VBT.mu *>
BEGIN
IF Text.Equal(e, "stopatCodeEvents") THEN
NARROW(arg, T).stopatCodeEvents :=
FormsVBT.GetBoolean(fv, "stopatCodeEvents");
END;
IF Text.Equal(e, "waitatCodeEvents") THEN
NARROW(arg, T).waitatCodeEvents :=
FormsVBT.GetInteger(fv, "waitatCodeEvents");
END;
IF Text.Equal(e, "stopAtInit") THEN
NARROW(arg, T).eventDataRec.stopAtInit :=
FormsVBT.GetBoolean(fv, "stopAtInit");
END;
IF Text.Equal(e, "waitAtInit") THEN
NARROW(arg, T).eventDataRec.waitAtInit :=
FormsVBT.GetInteger(fv, "waitAtInit");
END;
IF Text.Equal(e, "stopAtEvent") THEN
NARROW(arg, T).eventDataRec.stopAtEvent :=
FormsVBT.GetBoolean(fv, "stopAtEvent");
END;
IF Text.Equal(e, "waitAtEvent") THEN
NARROW(arg, T).eventDataRec.waitAtEvent :=
FormsVBT.GetInteger(fv, "waitAtEvent");
END;
IF Text.Equal(e, "stopAtPause") THEN
NARROW(arg, T).eventDataRec.stopAtPause :=
FormsVBT.GetBoolean(fv, "stopAtPause");
END;
IF Text.Equal(e, "waitAtPause") THEN
NARROW(arg, T).eventDataRec.waitAtPause :=
FormsVBT.GetInteger(fv, "waitAtPause");
END;
END gefeventDoIt;
PROCEDURE gefeventRefreshCts (
<*UNUSED*> fv : FormsVBT.T;
<*UNUSED*> e : TEXT;
arg : REFANY;
<*UNUSED*> t : VBT.TimeStamp) =
<* LL = VBT.mu *>
BEGIN
NARROW(arg, T).updateEventCounts(FALSE);
END gefeventRefreshCts;
PROCEDURE FromFV (fv : FormsVBT.T; alg: T) =
<* LL = VBT.mu *>
BEGIN
alg.stopatCodeEvents :=
FormsVBT.GetBoolean(fv, "stopatCodeEvents");
alg.waitatCodeEvents :=
FormsVBT.GetInteger(fv, "waitatCodeEvents");
alg.eventDataRec.stopAtInit :=
FormsVBT.GetBoolean(fv, "stopAtInit");
alg.eventDataRec.waitAtInit :=
FormsVBT.GetInteger(fv, "waitAtInit");
alg.eventDataRec.stopAtEvent :=
FormsVBT.GetBoolean(fv, "stopAtEvent");
alg.eventDataRec.waitAtEvent :=
FormsVBT.GetInteger(fv, "waitAtEvent");
alg.eventDataRec.stopAtPause :=
FormsVBT.GetBoolean(fv, "stopAtPause");
alg.eventDataRec.waitAtPause :=
FormsVBT.GetInteger(fv, "waitAtPause");
END FromFV;
<*UNUSED*>
PROCEDURE ToFV (fv : FormsVBT.T; alg: T) =
<* LL = VBT.mu *>
BEGIN
FormsVBT.PutBoolean(fv, "stopatCodeEvents", alg.stopatCodeEvents);
FormsVBT.PutInteger(fv, "waitatCodeEvents", alg.waitatCodeEvents);
FormsVBT.PutBoolean(fv, "stopAtInit",
alg.eventDataRec.stopAtInit);
FormsVBT.PutInteger(fv, "waitAtInit",
alg.eventDataRec.waitAtInit);
FormsVBT.PutBoolean(fv, "stopAtEvent",
alg.eventDataRec.stopAtEvent);
FormsVBT.PutInteger(fv, "waitAtEvent",
alg.eventDataRec.waitAtEvent);
FormsVBT.PutBoolean(fv, "stopAtPause",
alg.eventDataRec.stopAtPause);
FormsVBT.PutInteger(fv, "waitAtPause",
alg.eventDataRec.waitAtPause);
CountsToFV (fv, alg);
END ToFV;
PROCEDURE CountsToFV (fv : FormsVBT.T; alg: T) =
<* LL = VBT.mu *>
BEGIN
FormsVBT.PutText(fv, "ctOfInit",
Fmt.Int(alg.eventDataRec.ctOfInit));
FormsVBT.PutText(fv, "ctOfEvent",
Fmt.Int(alg.eventDataRec.ctOfEvent));
FormsVBT.PutText(fv, "ctOfPause",
Fmt.Int(alg.eventDataRec.ctOfPause));
END CountsToFV;
PROCEDURE gefeventDefaultUpdateCts ( v: T; reset: BOOLEAN) =
<* LL = VBT.mu *>
BEGIN
IF reset THEN
v.eventDataRec.ctOfInit := 0;
v.eventDataRec.ctOfEvent := 0;
v.eventDataRec.ctOfPause := 0;
END;
CountsToFV (v.eventData, v);
END gefeventDefaultUpdateCts;
PROCEDURE gefeventDefaultSnapshot (v: T; wr: Wr.T)
RAISES {ZeusClass.Error} =
<* LL = VBT.mu *>
BEGIN
TRY
Wr.PutChar(wr, '(')
EXCEPT
ELSE
RAISE ZeusClass.Error(
"gefeventAlgClass.gefeventDefaultSnapshot write error");
END;
IF v.eventData = NIL THEN
RAISE ZeusClass.Error(
"gefeventAlgClass.gefeventDefaultSnapshot: " &
"eventData not set!");
END;
TRY
v.eventData.snapshot(wr)
EXCEPT
FormsVBT.Error (msg) =>
RAISE ZeusClass.Error(
"gefeventAlgClass.gefeventDefaultSnapshot FV error: "
& msg);
ELSE
RAISE ZeusClass.Error(
"gefeventAlgClass.gefeventDefaultSnapshot error");
END;
Algorithm.T.snapshot(v, wr);
TRY
Wr.PutChar(wr, ')')
EXCEPT
ELSE
RAISE ZeusClass.Error(
"gefeventAlgClass.gefeventDefaultSnapshot write error");
END;
END gefeventDefaultSnapshot;
PROCEDURE gefeventDefaultRestore (v: T; rd: Rd.T)
RAISES {ZeusClass.Error} =
<* LL = VBT.mu *>
BEGIN
IF rd = NIL THEN RETURN END;
IF NOT ZeusUtil.EatChar(rd, '(') THEN
RAISE ZeusClass.Error(
"gefeventAlgClass.gefeventDefaultRestore read error");
END;
IF v.eventData = NIL THEN
RAISE ZeusClass.Error(
"gefeventAlgClass.gefeventDefaultRestore: " &
"eventData not set!");
END;
TRY
v.eventData.restore(rd);
v.updateEventCounts(FALSE);
FromFV(v.eventData, v);
EXCEPT
ELSE
RAISE ZeusClass.Error(
"gefeventAlgClass.gefeventDefaultRestore error");
END;
Algorithm.T.restore(v, rd);
IF NOT ZeusUtil.EatChar(rd, ')') THEN
RAISE ZeusClass.Error(
"gefeventAlgClass.gefeventDefaultRestore read error");
END;
END gefeventDefaultRestore;
PROCEDURE Feedback (self: T
; <*UNUSED*> name: TEXT
; <*UNUSED*> args: RefList.T
) =
<* LL = VBT.mu *>
BEGIN
self.evtHandled := FALSE;
END Feedback;
BEGIN
END gefeventAlgClass.