DIRECTORY
PortableCedarRuntimeSupport,
RuntimeError,
SignalStatistics; 
SignalsImpl: CEDAR PROGRAM -- MONITOR
IMPORTS RuntimeError 
EXPORTS PortableCedarRuntimeSupport, RuntimeError, SignalStatistics
~ BEGIN
OPEN PCRS: PortableCedarRuntimeSupport;

checking: BOOL = TRUE;
ucsHandler: RuntimeError.UCSProc ¬ InitialUCSHandler;
SigInfo: TYPE ~ RECORD [
sig: ExceptAny, 
arg: POINTER, 
rtns: POINTER, 
informational: BOOL
];

InformationalSignal: PUBLIC SAFE PROC [signal: SIGNAL] = TRUSTED {
SignalHandler[signal, NIL, NIL, TRUE];
};

RegisterUncaughtSignalHandler: PUBLIC -- ENTRY -- PROC [proc: RuntimeError.UCSProc] RETURNS [old: RuntimeError.UCSProc] = {
old ¬ ucsHandler;
ucsHandler ¬ proc;
};

InitialUCSHandler: RuntimeError.UCSProc ~ {
CallDebugger[];
};

CatchProc: TYPE ~ PCRS.Handler;
HandlerAction: TYPE = PCRS.HandlerAction;

NoHandler: CatchPhrase = NIL;
signalSpy: PROC ¬ NIL;
RegisterSignalSpy: PUBLIC -- ENTRY -- PROC [new: PROC] RETURNS [old: PROC] ~ {
old ¬ signalSpy;
signalSpy ¬ new;
};

SignalHandler: PROC
[sig: ExceptAny, arg: POINTER, rtns: POINTER, informational: BOOL ¬ FALSE] ~ TRUSTED {
action: PCRS.HandlerAction;
catchProc: PCRS.Handler;
warmestHandler: CatchPhrase ¬ NIL;
selfObj: SignallerStateObject ¬ [];
self: SignallerState ¬ LOOPHOLE[@selfObj];
exitTo: INT;
spy: PROC ~ signalSpy;
IF spy # NIL THEN spy[];
self.signal ¬ sig;
TRUSTED {
OPEN self;
unwinding ¬ FALSE;
warmestHandler ¬ WarmestHandler[];  -- in the current thread
start ¬ warmestHandler;
nextCatchPhrase ¬ start;
UNTIL (nextCatchPhrase = target)  OR unwinding DO
thisSignaller: SignallerState;
currentCatchPhrase ¬ nextCatchPhrase;
thisSignaller ¬ currentCatchPhrase.signallerState;
IF thisSignaller # NIL THEN {
IF signal ~= thisSignaller.signal 
THEN {
nextCatchPhrase ¬ Parent[currentCatchPhrase];
}
ELSE {
nextCatchPhrase ¬ thisSignaller.nextCatchPhrase;
};
} 
ELSE -- currentCatchPhrase.signallerState = NIL -- 
{
nextCatchPhrase ¬ Parent[currentCatchPhrase];
};

IF (catchProc ¬ currentCatchPhrase.catchProc) # NIL THEN {
ENABLE { 
RuntimeError.SendMsg => RESUME[self.signal, arg, rtns]; -- GetSignal is SIGNALled by an ANY-catcher to request the details of the signal it is processing --
};
hotHandler: CatchPhrase ¬ WarmestHandler[];
hotHandler.signallerState ¬ self;
[action, exitTo] ¬ 
catchProc[context: currentCatchPhrase.catchContext, except: signal, rtnPtr: rtns, argPtr: arg ! RuntimeError.Resume => TRUSTED { action ¬ resume; CONTINUE }];
SELECT action FROM
reject =>  NULL;
resume => {
RETURN
};
exit =>
IF ~informational THEN {
target ¬ currentCatchPhrase;
unwinding ¬ TRUE;
arg ¬ NIL;
};
ENDCASE;
};
ENDLOOP;

SELECT TRUE FROM
unwinding => NULL;
informational OR signal = LOOPHOLE[UNCAUGHT] => NULL;
ENDCASE => {
Uncaught: TYPE = SIGNAL [SIGNAL ANY RETURNS ANY, WORD];
LOOPHOLE[UNCAUGHT, Uncaught][signal, LOOPHOLE[arg]];
TRUSTED {ucsHandler[msg: LOOPHOLE[arg], signal: signal, frame: NIL]};
};

IF unwinding THEN { 
UnwindTo[LOOPHOLE[target]];
RestartHandlee[GetNextHandlee[NIL], target.jmpBufPtr, exitTo]
};
};
};

Parent: PROC [catchPhrase: CatchPhrase] RETURNS [parent: CatchPhrase]
~ TRUSTED {
env: DynamicFrame ~ LOOPHOLE[catchPhrase];
RETURN[LOOPHOLE[LookupInDynamicEnvironment[MesaHandlerKey, env.next]]];
};

WarmestHandler: PROC [] RETURNS [CatchPhrase] ~ {
env: DynamicFrame ~ GetDynamicEnvironment[];
RETURN[LOOPHOLE[LookupInDynamicEnvironment[MesaHandlerKey, env]]];
};

MesaUnwinderProc: TYPE ~ POINTER TO MesaUnwinderProcBody;
MesaUnwinderProcBody: TYPE ~ RECORD [
codeBody: WORD,
catchPhrase: CatchPhrase
];

MesaUnwinder: PROC [self: MesaUnwinderProc] ~ TRUSTED { -- XR¬MesaUnwinder
cp: CatchPhrase ¬ self.catchPhrase;
catchProc: PCRS.Handler;
action: PCRS.HandlerAction;
IF (catchProc ¬ cp.catchProc) # NIL THEN TRUSTED {
ENABLE { 
RuntimeError.SendMsg => RESUME[LOOPHOLE[UNWIND], NIL, NIL]; -- GetSignal is SIGNALled by an ANY-catcher to request the details of the signal it is processing --
};
[action, ] ¬ 
catchProc[context: cp.catchContext, except: LOOPHOLE[UNWIND], rtnPtr: NIL, argPtr: NIL ! RuntimeError.Resume => {action ¬ resume; CONTINUE }];
SELECT action FROM
reject =>  NULL;
resume => ERROR RuntimeError.ResumeFault;
exit => ERROR RuntimeError.UnwindFault;
ENDCASE;
};
};

SignalEnvironment: TYPE = REF SignalEnvironmentObject;
SignalEnvironmentObject: TYPE = MACHINE DEPENDENT RECORD [
unixTrapHandler: PROC,
aborted: ERROR,
abstractionFault: ERROR,
arithmeticFault: ERROR,
assignRefCompositeFault: ERROR,
boundsFault: ERROR, 
divideCheck: SAFE SIGNAL,
invalidProcess: ERROR [process: PROCESS], 
linkageFault: ERROR,
narrowFault: ERROR,
narrowRefFault: ERROR [ref: REF, type: RuntimeError.Type],
nestedProcFault: ERROR [proc: RuntimeError.ProcAny],
nilFault: ERROR,
resumeFault: ERROR, 
sendMsg: SIGNAL RETURNS [signal: SIGNAL ANY RETURNS ANY, args, results: POINTER],
stackFault: ERROR, 
startFault: SIGNAL [dest: PROGRAM], 
unboundProcedureFault: SIGNAL [dest: PROC ANY RETURNS ANY] RETURNS [PROC ANY RETURNS ANY], 
uncaught: ERROR [signal: SIGNAL ANY RETURNS ANY, parameters: WORD], 
unnamedError: ERROR, 
unnamedSignal: SIGNAL,
unwind: ERROR, 
unwindFault: ERROR, 
zeroDivisor: SAFE SIGNAL
];
DefSetSignalEnvironment: PROC [] = TRUSTED MACHINE CODE {  
"+";
"typedef struct {\n";
"  int  *unixTrapHandler;\n";
"  unsigned aborted;\n";
"  unsigned abstractionFault;\n";
"  unsigned arithmeticFault;\n";
"  unsigned assignRefCompositeFault;\n";
"  unsigned boundsFault;\n";
"  unsigned divideCheck;\n";
"  unsigned invalidProcess;\n";
"  unsigned linkageFault;\n";
"  unsigned narrowFault;\n";
"  unsigned narrowRefFault;\n";
"  unsigned nestedProcFault;\n";
"  unsigned nilFault;\n";
"  unsigned resumeFault;\n";
"  unsigned sendMsg;\n";
"  unsigned stackFault;\n";
"  unsigned startFault;\n";
"  unsigned unboundProcedureFault;\n";
"  unsigned uncaught;\n";
"  unsigned unnamedError;\n";
"  unsigned unnamedSignal;\n";
"  unsigned Unwind;\n";
"  unsigned unwindFault;\n";
"  unsigned zeroDivisor;\n";
"  } SignalEnvironmentObject;\n";
"typedef SignalEnvironmentObject *SignalEnvironment;\n";
"unsigned XR_UnnamedSignal;\n";
"unsigned XR_UnnamedError;\n";
"unsigned XR_Unwind;\n";
"unsigned XR_Aborted;\n";
"unsigned XR_Uncaught;\n";
"unsigned XR_NarrowFault;\n";
"unsigned XR_NarrowRefFault;\n";
"unsigned XR_InvalidProcess;\n";
"SignalEnvironment XR_SigEnv;\n";
"static void XR_SetSignalEnvironment(env)\n";
"   SignalEnvironment env;\n";
"   {\n";
"   XR_SigEnv = env;\n";
"   XR_UnnamedError = env-> unnamedError;\n";
"   XR_UnnamedSignal = env->unnamedSignal;\n";
"   XR_Unwind = env->Unwind;\n";
"   XR_Aborted = env->aborted;\n";
"   XR_Uncaught = env->uncaught;\n";
"   XR_NarrowFault = env->narrowFault;\n";
"   XR_NarrowRefFault = env->narrowRefFault;\n";
"   XR_InvalidProcess = env->invalidProcess;\n";
"   };\n";
".";
};
ExceptAny: TYPE ~ SIGNAL ANY RETURNS ANY;

noCP: CatchPhrase ~ NIL;

MesaHandlerKey: WORD ~ CODE;
DisabledMesaHandlerKey: WORD ~ CODE;
UnwindFrameKey: WORD ¬ GetUnwindFrameKey[];

DynamicFrame: TYPE ~ POINTER TO DynamicFrameObject;
DynamicFrameObject: TYPE ~ RECORD [
next: DynamicFrame,
key: WORD,
data: WORD
];

UnwindFrame: TYPE ~ POINTER TO UnwindFrameObject;
UnwindFrameObject: TYPE ~ RECORD [
next: DynamicFrame,
key: WORD,
unwinder: PROC,
rewinder: PROC
];
assertUnwindFrameObjectSize: [0..4] = WORDS[UnwindFrameObject];

CatchPhrase: TYPE ~ POINTER TO CatchPhraseObject;
CatchPhraseObject: TYPE ~ RECORD [
dynamicFrame: DynamicFrameObject,	
jmpBufPtr: POINTER,
catchProc: PCRS.Handler,
catchContext: POINTER,
signallerState: REF SignallerStateObject
];
assertCatchPhraseObjectSize: [0..7] = WORDS[CatchPhraseObject];

SignallerState: TYPE = REF SignallerStateObject;
SignallerStateObject: TYPE ~ RECORD [
startMark: CARD32 ¬ 0FF00FF00H,
start: CatchPhrase ¬ noCP,
signal: ExceptAny ¬ NIL,
currentCatchPhrase: CatchPhrase ¬ noCP,
nextCatchPhrase: CatchPhrase ¬ noCP,
target, nextTarget: CatchPhrase ¬ noCP,
unwinding: BOOL ¬ FALSE,
endMark: CARD32 ¬ 0FF11FF11H
];

RaiseErrorProc: TYPE = PROC [which: ExceptAny, args: POINTER];

RaiseSignalProc: TYPE = PROC [which: ExceptAny, rtns: POINTER, args: POINTER];
CallDebugger: PROC [] RETURNS [] ~ TRUSTED MACHINE CODE {
"XR_CallDebugger"
};

SetSignalEnvironment: PROC [env: SignalEnvironment] ~ TRUSTED MACHINE CODE {
"XR_SetSignalEnvironment"
};

RaiseError: PUBLIC RaiseErrorProc = TRUSTED { -- XR¬RaiseError
stats.errorsRaised ¬ stats.errorsRaised + 1;
SignalHandler[which, args, NIL];
ERROR RuntimeError.ResumeFault
};

RaiseSignal: PUBLIC RaiseSignalProc = TRUSTED {  -- XR¬RaiseSignal
stats.signalsRaised ¬ stats.signalsRaised + 1;
SignalHandler[which, args, rtns];
};

RaiseUnnamedError: PROC [] RETURNS [CARD ¬ 0] ~ {  -- XR¬RaiseUnnamedError
RaiseError[LOOPHOLE[RuntimeError.UnnamedError], NIL]
};

RaiseArithmeticFault: PUBLIC PROC [] RETURNS [CARD ¬ 0] ~ {  -- XR¬RaiseArithmeticFault
RaiseError[LOOPHOLE[RuntimeError.ArithmeticFault], NIL]
};

RaiseBoundsFault: PUBLIC PROC [] RETURNS [CARD ¬ 0] ~ {  -- XR¬RaiseBoundsFault
RaiseError[LOOPHOLE[RuntimeError.BoundsFault], NIL]
};

RaiseAbstractionFault: PUBLIC PROC [] RETURNS [] ~ {  -- XR¬RaiseAbstractionFault
RaiseError[LOOPHOLE[RuntimeError.AbstractionFault], NIL]
};

SetupPushHandler: PROC
[context: POINTER, proc: PCRS.Handler, catchPhrase: CatchPhrase, unwindFrame: UnwindFrame, unwinder: PROC, jmpBufPtr: POINTER ]
~ TRUSTED { -- XR¬SetupPushHandler
prevEnv: DynamicFrame ¬ GetDynamicEnvironment[];
catchPhrase.dynamicFrame.next ¬ LOOPHOLE[unwindFrame];
catchPhrase.dynamicFrame.key ¬ MesaHandlerKey;
catchPhrase.catchProc ¬ proc;
catchPhrase.catchContext ¬ context;
catchPhrase.signallerState ¬ NIL;
catchPhrase.jmpBufPtr ¬ jmpBufPtr;
unwindFrame.next ¬ prevEnv;
unwindFrame.key ¬ UnwindFrameKey;
unwindFrame.unwinder ¬ unwinder;
unwindFrame.rewinder ¬ NIL;
SetDynamicEnvironment[LOOPHOLE[catchPhrase]];
stats.newPushCount ¬ stats.newPushCount+1;
};

PushAllocedHandler: PUBLIC PROC
[context: POINTER, handler: PCRS.Handler, jmpBuf: POINTER] RETURNS [INT]
~ TRUSTED { -- XR¬PushAllocedHandler
unwindFrame: UnwindFrame ¬ LOOPHOLE[NEW[UnwindFrameObject]];
catchPhrase: CatchPhrase ¬ LOOPHOLE[NEW[CatchPhraseObject]];
MesaProcObject: TYPE ~ RECORD [
codePointer: WORD,
context: WORD
];
MesaProc: TYPE ~ POINTER TO MesaProcObject;
prevEnv: DynamicFrame ¬ GetDynamicEnvironment[];
catchPhrase.dynamicFrame.next ¬ LOOPHOLE[unwindFrame];
catchPhrase.dynamicFrame.key ¬ MesaHandlerKey;
catchPhrase.catchProc ¬ handler;
catchPhrase.catchContext ¬ context;
catchPhrase.signallerState ¬ NIL;
catchPhrase.jmpBufPtr ¬ jmpBuf;
unwindFrame.rewinder ¬ NIL;
unwindFrame.next ¬ prevEnv;
unwindFrame.key ¬ UnwindFrameKey;
unwindFrame.unwinder ¬ LOOPHOLE[NEW[MesaProcObject ¬ [LOOPHOLE[MesaUnwinder, MesaProc].codePointer, LOOPHOLE[catchPhrase]]]];
SetDynamicEnvironment[LOOPHOLE[catchPhrase]];
stats.pushCount ¬ stats.pushCount+1;
RETURN[0];
};

PopHandler: PUBLIC PROC [] RETURNS [] ~ TRUSTED { -- XR¬PopHandler
env: DynamicFrame ¬ GetDynamicEnvironment[];
IF (env.key = MesaHandlerKey OR env.key = DisabledMesaHandlerKey) AND env.next.key=UnwindFrameKey THEN {
SetDynamicEnvironment[env.next.next]
}
ELSE ERROR; 
};
XRThread: TYPE ~ POINTER;

GetDynamicEnvironment: PROC [] RETURNS [DynamicFrame] ~ TRUSTED MACHINE CODE {
"XR_GetDynamicEnvironment"
};

GetDynamicEnvironmentOf: PROC [XRThread] RETURNS [DynamicFrame] ~ TRUSTED MACHINE CODE {
"XR_GetDynamicEnvironmentOf"
};

SetDynamicEnvironment: PROC [DynamicFrame] RETURNS [] ~ TRUSTED MACHINE CODE {
"XR_SetDynamicEnvironment"
};

LookupInDynamicEnvironment: PROC [key: WORD, de: DynamicFrame] RETURNS [DynamicFrame] ~ TRUSTED MACHINE CODE {
"XR_LookupInDynamicEnvironment"
};

UnwindTo: PROC [DynamicFrame] RETURNS [] ~ TRUSTED MACHINE CODE {
"XR_UnwindTo"
};

GetNextHandlee: PROC[thread: XRThread] RETURNS [XRThread]~ TRUSTED MACHINE CODE {
"XR_GetNextHandlee"
};

GetUnwindFrameKey: PROC[] RETURNS [WORD] ~ TRUSTED MACHINE CODE {
"XR_GetUnwindFrameKey"
};

RestartHandlee: PROC[thread: XRThread, jmpBuf: POINTER, exitTo: INT] ~ TRUSTED MACHINE CODE {
"XR_RestartHandlee"
};
stats: SignalStatistics.Stats ¬ [];

GetStatistics: PUBLIC PROC [] RETURNS [SignalStatistics.Stats] ~ {
RETURN [stats];
};
DefEnable: PROC [] = TRUSTED MACHINE CODE {
"+";
"#include <xr/Threads.h>\n";
"typedef struct {fPt p; word c;} ProcDescBody;\n";
"extern word XR_Enable(body, handler, context)\n";
"   fPt body;\n";
"   fPt handler;\n";
"   ptr context;\n";
"   {\n";
"   word rtnCode;\n";
"   ptr beforeCall;\n";
"   ProcDescBody pdDescBody;\n";
"   ProcDescBody unwindDescBody;\n";
"   word catchSpace[7];\n";
"   struct XR_JmpBufRep jmpBuf;\n";
"   word unwindSpace[4];\n";
"   pdDescBody.p = handler;\n";
"   pdDescBody.c = 1;\n";
"   unwindDescBody.p = (fPt) XR_MesaUnwinder;\n";
"   unwindDescBody.c = (word) catchSpace;\n";
"   beforeCall = (ptr) XR_GetDynamicEnvironment();\n";
"   XR_SetupPushHandler(context, &pdDescBody, catchSpace, unwindSpace, &unwindDescBody, &jmpBuf);\n";
"   rtnCode = XR_setjmp(&jmpBuf);\n";
"   if (rtnCode == 0) rtnCode = body(context);\n";
"   {      /* INLINE version of XR_PopHandler, no stats */ \n";
"      ptr curr = (ptr) XR_GetDynamicEnvironment();\n";
"      ptr prev = (ptr) *((ptr) *curr);\n";
"      if (beforeCall != prev) XR_RaiseError(0,0);\n";
"      XR_SetDynamicEnvironment(prev);\n";
"      };\n";
"   return (rtnCode);\n";
"   };\n";
"extern word XR_UnwindFrameKey;\n";
"static word XR_GetUnwindFrameKey()\n";
"   {\n";
"   return( XR_UnwindFrameKey );\n";
"   };\n";
".";
};

ExternalNames: PROC [] = TRUSTED MACHINE CODE {
"^ExternalNames\n";
"RaiseError XR_RaiseError\n";
"RaiseSignal XR_RaiseSignal\n";
"RaiseUnnamedError XR_RaiseUnnamedError\n";
"RaiseArithmeticFault XR_RaiseArithmeticFault\n";
"RaiseBoundsFault XR_RaiseBoundsFault\n";
"RaiseAbstractionFault XR_RaiseAbstractionFault\n";
"SetupPushHandler XR_SetupPushHandler\n";
"PushAllocedHandler XR_PushAllocedHandler\n";
"PopHandler XR_PopHandler\n";
"PushUnwinder XR_PushUnwinder\n";
"PopUnwinder XR_PopUnwinder\n";
"GetUnwinderContext XR_GetUnwinderContext\n";
"MesaUnwinder XR_MesaUnwinder\n";
};
Initialize: PROC = {
SetSignalEnvironment[ NEW[SignalEnvironmentObject ¬ [
aborted ~ RuntimeError.Aborted,
abstractionFault ~ RuntimeError.AbstractionFault,
arithmeticFault ~ RuntimeError.ArithmeticFault,
assignRefCompositeFault ~ RuntimeError.AssignRefCompositeFault,
boundsFault ~ RuntimeError.BoundsFault,
divideCheck ~ RuntimeError.DivideCheck,
invalidProcess ~ RuntimeError.InvalidProcess,
linkageFault ~ RuntimeError.LinkageFault,
narrowFault ~ RuntimeError.NarrowFault,
narrowRefFault ~ RuntimeError.NarrowRefFault,
nestedProcFault ~ RuntimeError.NestedProcFault,
nilFault ~ RuntimeError.NilFault,
resumeFault ~ RuntimeError.ResumeFault,
sendMsg ~ RuntimeError.SendMsg,
stackFault ~ RuntimeError.StackFault,
startFault ~ RuntimeError.StartFault,
unboundProcedureFault ~ RuntimeError.UnboundProcedureFault,
uncaught ~ RuntimeError.Uncaught,
unnamedError ~ RuntimeError.UnnamedError,
unnamedSignal ~ RuntimeError.UnnamedSignal,
unwind ~ RuntimeError.Unwind,
unwindFault ~ RuntimeError.UnwindFault,
zeroDivisor ~ RuntimeError.ZeroDivisor
]]];
DefEnable[];
DefSetSignalEnvironment[];
};

ExternalNames[];
Initialize[];

END.
 
¬
SignalsImpl.mesa
Copyright Σ 1987, 1989, 1991 by Xerox Corporation.  All rights reserved.
Carl Hauser, July 24, 1989 12:51:53 pm PDT
Russ Atkinson (RRA) July 27, 1989 9:05:46 pm PDT
Christian Jacobi, January 5, 1990 5:24:28 pm PST
Chauser, February 22, 1991 10:51 am PST
Foote, May 31, 1991 2:44 pm PDT
Willie-s, August 5, 1991 5:34 pm PDT
Michael Plass, December 13, 1991 3:22 pm PST
Options
Global Variables (protected by monitor)

Who makes informational signals?  What language feature?  According to Dan Swinehart, this kind of signalling is done in code written by wizards and not produced by any Mesa language feature.  The idea is to signal in such a way that if the signal is not caught, you don't end up in the debugger.
SignalHandler
First pass: find catch phrases, looking for GOTO out of one 
unwinding = FALSE
walk from nextFrame toward "cool" end of stack, looking for target
catchPhrase is for another instance of this (SignalHandler) procedure.
choose our nextFrame
different signals propagate through intervening frames
from the Mesa 11.0 manual: "all of the routines whose frames lie beyond thisSignaller, up to the frame containing the catch phrase called by thisSignaller, have already had a chance to handle signal, so they are not given it again." 
I claim that all signals should propagate through intervening frames, or none.  I lean to the side of none, but I'll leave this as-is for the time being. 
frame is NOT for another SignalHandler - just walk the stack to nextFrame 
Will this frame catch any signals? It may, depending on the body of the catch phrase (it may also raise signals!)
call the catch phrase
now WarmestHandler will give us the catchPhrase just pushed for the above ENABLE 
stuff our "self" record in the catchPhrase so later instances of the SignalHandler can find it.
the handler has filled rtns^ with the results for signal's raiser
ELSE
Apparently, non-local GOTOs from a handlers for signals originated as informational are ignored and treated as REJECTs.
What happened?
does an implicit RESUME
Informational signals are resumed either by an explicit resume in a catch phrase or when the signal has propagated to the top of the stack.  IF signal = LOOPHOLE[UNCAUGHT] at this point, it was raised in the following ENDCASE (in a different invocation of SignalHandler), so upon resumption, that SignalHandler calls ucsHandler. 
We want to be able to RESUME UNCAUGHT, but we don't want a random catch phrase to do so.  So, we declare it to be an ERROR in the interface, but raise it as a SIGNAL here.  When (if) UNCAUGHT percolates to the top of the stack, it is implicitly resumed (see the preceding line of code).  Control then passes to the statement following the invocation of UNCAUGHT, which calls the debugger (or whatever).
for now dummy msg parameter because the PrincOps world is so different.
frame: NIL because I think that's what happens in PrincOps world.
disable ordinary handlers in the stack to be unwound
nextCatchPhrase _ start;
UNTIL (nextCatchPhrase = target) DO
nextCatchPhrase.dynamicFrame.key _ DisabledMesaHandlerKey;
nextCatchPhrase _ Parent[nextCatchPhrase];
ENDLOOP;
target.dynamicFrame.key _ DisabledMesaHandlerKey;
propagate an UNWIND
follows the caller pointer of frame
call the catch phrase -- this is old-style, with UNWIND handling buried in normal catch phrases.
Signalling types
Maintain correspondence with declaration in DefSetSignalEnvironment below

formerly from SignalSupport.c and SignalSupport.h:
If this fails to compile, change the number in "unwindSpace[4]" in XR_Enable
If this fails to compile, change the number in "catchSpace[7]" in XR_Enable
XR routines
--make this procedure PUBLIC when interface changes for any other reason
the jmpBuf^ should be dynamically allocated (not on the stack)
dead, but it keeps the compiler happy
Thread state manipulation
Statistics
Embedded C procedure (for XR_Enable)
n.b. the context for the unwinder is the catchPhrase, not the unwindFrame
External names
Initialization
Κt•NewlineDelimiter

–
(cedarcode) style™
head™Icodešœ
Οe
œ=™HL™*L™0L™0L™'L™L™$L™,—˜š
Οk	˜	Lš
œ˜Lš
œ
˜
Lš
œ˜——šΟnœžœ
žœ
Οc
˜%Lšžœ˜Lšžœ<˜Cšœž˜Lšžœ
žœ˜'—L˜—™Lšœ
žœžœ
˜—™'Lš
œ5˜5L™šœ	žœžœ˜Lš
œ˜Lšœžœ˜Lšœžœ˜Lšœž˜Lš
œ˜L˜—šŸœžœ
žœ
žœ
žœžœ˜BL™¨Lšœžœžœžœ˜&Lš
œ˜L˜—š
Ÿœžœ
žœžœžœ ˜{Lš
œ˜Lš
œ˜Lš
œ˜L˜—šŸœ˜+L˜L˜L˜—Lšœžœžœ	˜šœžœžœ˜)L˜—LšŸ	œžœ
˜—™
Lšœžœžœ
˜šŸœžœ
 œ
žœžœžœžœ˜NLš
œ˜Lš
œ˜L˜L˜—šŸ
œžœžœžœžœžœžœ˜jLšœžœ˜Lšœžœ	˜Lšœžœ
˜"Lš
œ#˜#Lšœžœ˜*Lšœžœ
˜Lšœžœ
˜Lšžœžœ
žœ˜Lš
œ˜šžœ˜	Lšžœ˜
Lšœžœ
˜Lšœ$ ˜<Lšœ,žœ™<Lšœž™Lš
œ˜Lš
œ˜šžœžœž˜1Lš
œ˜Lš
œB™BLš
œ%˜%Lš
œ2˜2šžœžœ
žœ˜Lš
œF™FLš
œ™šžœ˜"šžœ˜Lš
œ-˜-L˜
—šžœ˜Lš
œ0˜0L˜Lš
œ6™6LšœHΟf
œ8‘
œ&‘œ#™ι
Lš
œš
™š
——L˜—šžœ
 -œ
˜3Lš
œJ™Jš
œ
˜
Lš
œ-˜-L˜——L˜L™qšžœ.žœ
žœ˜:L™šžœ˜	Lšœžœ d˜œ
L˜—Lš
œQ™QLš
œ+˜+L™_Lš
œ!˜!Lšœ‹
žœžœ˜²
šžœž˜Lšœžœ
˜˜L™Aš
ž˜Lš
œ˜——˜šžœžœ˜Lš
œ˜Lšœžœ
˜Lšœžœ
˜
Lš
œ˜—š
ž™L™w——Lšžœ
˜—L˜—Lšžœ
˜——˜L™šžœ
žœ
ž˜Lšœ
žœ
˜š	œžœ
žœ
žœžœ
˜5Lš
œ™—Lšœ™
žœ
žœ0žœh™Ιšžœ˜Lš
œžœ
žœPžœ%žœžœ’
žœ)™’Lšœ
žœžœžœ
žœ
žœ
žœžœ˜7Lšžœ
žœžœ˜4L™GL™ALšžœžœžœ˜EL˜L˜——šžœž˜L™4Lš
œ™šžœž™#Lš
œ:™:Lš
œ*™*Lšžœ
™—Lš
œ1™1L™Lšœ	žœ
˜Lšœžœ˜=L˜—Lš
œ˜—L˜L˜—šŸœžœžœžœ˜QLš
œ#™#Lšœžœ˜*Lšžœ
žœ8˜GL˜L˜—šŸœžœžœ˜1L˜,Lšžœ
žœ3˜BL˜—L˜Lšœžœžœ
žœ˜9šœžœžœ˜%Lšœ
žœ
˜L˜Lš
œ˜L˜—š	Ÿœžœžœ œ
 ˜JL˜#Lšœžœ	˜Lšœžœ˜šžœžœ
žœ
žœ˜2šžœ˜	Lšœžœ
žœ
žœžœžœ d˜ 
L˜—L™`Lšœ:žœ
žœžœ
žœ,žœ˜œ
šžœž˜Lšœžœ
˜Lšœ
žœ˜)Lšœžœ˜'Lšžœ
˜—L˜—L˜——™L™IL˜Lšœžœžœ˜6š	œžœžœ
ž	œ
žœ˜:Lšœžœ
˜Lšœ	žœ
˜Lšœžœ
˜Lšœžœ
˜Lšœžœ
˜Lšœ
žœ˜Lšœ
žœ
žœ
˜Lšœžœžœ˜*Lšœžœ
˜Lšœ
žœ
˜Lšœžœžœ˜:Lšœžœ˜4Lšœ
žœ
˜Lšœ
žœ˜Lšœ	žœ
žœ
žœ
žœ
žœ
žœžœ˜QLšœžœ˜Lšœžœžœ˜$Lšœžœžœ
žœ
žœ
žœžœžœ
žœ
žœ
žœ˜[Lš
œ
žœ
žœ
žœ
žœ
žœžœ˜DLšœžœ˜Lšœžœ
˜Lšœžœ˜Lšœ
žœ˜Lšœ
žœ
ž˜L˜—™Lš
œ2™2—š
Ÿœžœžœ
žœ
žœ˜;Lš
Οo˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ!˜!Lš
œ ˜ Lš
œ(˜(Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ ˜ Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ&˜&Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš’œ’˜!Lš
œ8˜8Lšœ‘
œ˜Lšœ‘
œ˜Lšœ‘
œ˜Lšœ‘
œ˜Lšœ‘
œ˜Lšœ‘
œ˜Lšœ‘
œ˜ Lšœ‘
œ˜ Lšœ‘
œ˜!Lšœ
’œ!’˜-Lš’œ’˜Lš
’	˜	Lš’œ’˜Lš’œ$’˜-Lš’œ%’˜.Lš’œ’˜ Lš’œ’˜"Lš’œ’˜$Lš’œ!’˜*Lš’œ'’˜0Lš’œ'’˜0Lš
’
˜
Lš
’˜L˜—Lšœžœžœ
žœ
žœ
žœ
˜)L˜šœžœ
˜L˜—LšŸœžœžœ
˜LšŸœžœžœ
˜$LšŸœžœ˜+L˜Lšœžœžœ
žœ˜3šœžœžœ˜#Lš
œ˜Lšœžœ
˜
Lšœž˜
Lš
œ˜L˜—Lšœ
žœžœ
žœ˜1šœžœžœ˜"Lš
œ˜Lšœžœ
˜
Lšœ
žœ
˜Lšœ
ž˜Lš
œ˜šœ&žœ˜?Lšœ0’œ™L—L˜—Lšœ
žœžœ
žœ˜1šœžœžœ˜"Lš
œ"˜"Lšœžœ
˜Lšœžœ	˜Lšœžœ
˜Lšœžœ˜(Lš
œ˜šœ&žœ˜?Lšœ0’
œ™K—L˜—Lšœžœžœ˜0šœžœžœ˜%Lšœžœ˜Lš
œ˜Lšœžœ
˜Lš
œ'˜'Lš
œ$˜$Lš
œ'˜'Lšœžœ
ž˜Lšœ	žœ
˜L˜—L˜šœžœžœžœ˜>L˜—Lš	œžœžœžœžœ˜N—š
œ™šŸœžœžœžœ
žœ
žœ˜9L˜L˜L˜—š
Ÿœžœžœ
žœ
žœ˜LL˜L˜L˜—š	Ÿ
œžœžœ œ
 
˜>L˜,Lšœžœ˜ Lšžœ˜Lš
œ˜—L˜š	Ÿœžœžœ œ
 ˜BL˜.Lš
œ!˜!Lš
œ˜L˜—šŸœžœžœžœ œ
 ˜JLš
œH™HLšœžœžœ
˜4L˜L˜—š
Ÿœžœ
žœžœžœ œ
 ˜WLšœžœ žœ
˜7L˜L˜—š
Ÿœžœ
žœžœžœ œ
 ˜OLšœžœžœ
˜3L˜L˜—šŸœžœ
žœžœ	 œ
 ˜QLšœžœ!žœ
˜8L˜L˜—šŸœžœ
žœžœHžœ
žœžœ œ
 ˜Ή
Lš
œ0˜0Lšœ žœ˜6Lš
œ.˜.Lš
œ˜Lš
œ#˜#Lšœžœ
˜!Lš
œ"˜"Lš
œ˜Lš
œ!˜!Lš
œ ˜ Lšœžœ
˜Lšœžœ˜-L˜*L˜L˜—šŸœžœ
žœ
žœžœžœžœžœžœ œ
 ˜
L™>Lšœžœ
žœ˜<Lšœžœ
žœ˜<šœžœžœ˜Lšœ
žœ
˜Lšœ	ž˜
Lš
œ˜—Lšœ
žœžœ
žœ˜+Lš
œ0˜0Lšœ žœ˜6Lš
œ.˜.Lš
œ ˜ Lš
œ#˜#Lšœžœ
˜!Lš
œ˜Lšœžœ
˜Lš
œ˜Lš
œ!˜!Lš	œžœ
žœžœ&žœ˜}Lšœžœ˜-L˜$šžœ˜
L™%—L˜L˜—š
Ÿ
œžœ
žœžœžœ œ
 
˜BLš
œ,˜,šžœžœ!žœžœ˜hLš
œ$˜$Lš
œ
˜
—Lšžœ
žœ˜L˜——™Lšœ
žœžœ
˜L˜šŸœžœžœžœ
žœ
žœ˜NLš
œ˜L˜L˜—šŸœžœžœžœ
žœ
žœ˜XLš
œ˜L˜—L˜šŸœžœžœžœ
žœ
žœ˜NLš
œ˜L˜L˜—šŸœžœžœžœžœ
žœ
žœ˜nLš
œ˜L˜L˜—šŸœžœžœžœ
žœ
žœ˜ALš
œ
˜
L˜L˜—šŸœžœžœ
žœ
žœ
žœ˜QLš
œ˜L˜L˜—šŸœžœžœžœžœ
žœ
žœ˜ALš
œ˜L˜L˜—šŸœžœžœ
žœžœ
žœ
žœ˜]L˜L˜——™
Lš
œ#˜#L˜šŸ
œžœ
žœžœ˜BLšžœ	˜L˜——šœ’	œ
™$š
Ÿ	œžœžœ
žœ
žœ˜+Lš
’˜L˜Lšœ
‘-œ˜2Lšœ
’1˜2Lš
’˜Lš
’˜Lš
’˜Lš
’	˜	Lš
’˜Lš
’˜Lš
’ ˜ Lš
’$˜$Lš
’˜Lš
’#˜#Lš
’˜Lš
’˜Lš
’˜Lš
’1˜1Lšœ)œ™ILš
’-˜-Lš’œ’˜6Lš
’e˜eLš
’%˜%Lš
’2˜2Lš
’?˜?Lš’œ’˜7Lš
’+˜+Lš
’6˜6Lš’
œ’˜*Lš
’
˜
Lš
’˜Lš
’
˜
Lšœ
’œ’˜#Lšœ
’&˜'Lš
’	˜	Lš’œ’˜$Lš
’
˜
Lš
’˜L˜L˜——™š
Ÿ
œžœžœ
žœ
žœ˜/L˜L˜L˜Lš
œ+˜+L˜1L˜)L˜3L˜)L˜-L˜L˜!L˜Lš
œ-˜-L˜!Lš
œ˜——™šŸ
œžœ˜šœžœ˜5L˜L˜1L˜/L˜?L˜'L˜'L˜-L˜)L˜'L˜-L˜/L˜!L˜'L˜L˜%L˜%L˜;L˜!L˜)L˜+L˜L˜'L˜&L˜—Lš
œ˜Lš
œ˜Lš
œ˜L˜—Lš
œ˜˜
L˜——Lšžœ
˜L˜
—…—;N_n