DIRECTORY
Breakpoint,
BreakpointPrivate,
BreakWorldArchitecture,
RefTab,
Rope,
Shepherd,
TargetArchitecture;

BreakpointImpl: CEDAR PROGRAM 
IMPORTS Breakpoint, BreakpointPrivate, BreakWorldArchitecture, RefTab, Rope
EXPORTS Breakpoint, BreakpointPrivate, BreakWorldArchitecture
~ {
BreakAccess: PUBLIC TYPE ~ Breakpoint.BreakAccess _ Breakpoint.nullBreakAccess;
BreakAccessRep: PUBLIC TYPE ~ Breakpoint.BreakAccessRep;

BreakAccessData: PUBLIC TYPE ~ REF BreakAccessDataRep _ Breakpoint.nullBreakAccessData;
BreakAccessDataRep: PUBLIC TYPE ~ RECORD [
breakTable: RefTab.Ref _ NIL
];

Break: PUBLIC TYPE ~ REF BreakRep _ Breakpoint.nullBreak;
BreakRep: PUBLIC TYPE ~ RECORD [
breakAccess: Breakpoint.BreakAccess,
address: BreakWorldArchitecture.Address,
patch: Shepherd.Patch,
clientData: Breakpoint.ClientData
];

SetBreakpoint: PUBLIC Breakpoint.SetBreakProc ~ {

breakWorld: BreakWorldArchitecture.BreakWorld _ address.breakWorld;
worldAccess: BreakWorldArchitecture.WorldAccess _ BreakWorldArchitecture.WorldAccessFromBreakWorld[breakWorld];
targetBreaks: BreakpointPrivate.TargetBreaks _ BreakpointPrivate.RetrieveTargetBreaks[worldAccess.name];
breakProcDataSegment: BreakWorldArchitecture.Address _ worldAccess.procs.getProcDataSegment[breakWorld, breakProc];
RETURN[targetBreaks.SetBreakpoint[address, clientData, breakProc, breakProcDataSegment, breakData, damages]]
};

ClearBreakpoint: PUBLIC Breakpoint.ClearBreakProc ~ {

breakWorld: BreakWorldArchitecture.BreakWorld _ break.address.breakWorld;
worldAccess: BreakWorldArchitecture.WorldAccess _ BreakWorldArchitecture.WorldAccessFromBreakWorld[breakWorld];
targetBreaks: BreakpointPrivate.TargetBreaks _ BreakpointPrivate.RetrieveTargetBreaks[worldAccess.name];
targetBreaks.ClearBreakpoint[break];
RETURN;
};


NewBreakAccess: PUBLIC PROCEDURE [] 
RETURNS [Breakpoint.BreakAccess] ~{
procs: Breakpoint.BreakAccessProcs ~ NEW[Breakpoint.BreakAccessProcsRep _ [
set: Breakpoint.SetBreakpoint, 
clear: Breakpoint.ClearBreakpoint, 
enumerate: Breakpoint.EnumerateBreakpoints]];
data: Breakpoint.BreakAccessData ~ NEW[BreakAccessDataRep _ [
breakTable: RefTab.Create[]]];
breakAccess: Breakpoint.BreakAccess ~ NEW[Breakpoint.BreakAccessRep _ 
[procs: procs, data: data]];

RETURN [breakAccess];
};

EnumerateBreakpoints: PUBLIC Breakpoint.EnumerateBreakProc ~ {
Apply: RefTab.EachPairAction ~ {
break: Break ~ NARROW[val];
clientData: Breakpoint.ClientData ~ Breakpoint.ClientDataFromBreak[break: break];

quit _ proc[clientData: clientData];
RETURN [quit: quit];
};
breakAccess: Breakpoint.BreakAccess ~ 
BreakWorldArchitecture.BreakAccessFromBreakWorld[breakWorld: breakWorld];
breakTable: RefTab.Ref ~ BreakTableFromBreakAccess[breakAccess: breakAccess];

IF breakTable = NIL THEN {
ERROR Breakpoint.Cant[
code: $NullBreakTable, message: "EnumerateBreakpoints[nullBreakTable]"];
};
quit _ breakTable.Pairs[action: Apply];
RETURN [quit: quit];
};

RememberBreak: PUBLIC PROCEDURE [break: Break] ~ {
breakAccess: Breakpoint.BreakAccess ~ 
BreakAccessFromBreak[break: break];
breakTable: RefTab.Ref ~ BreakTableFromBreakAccess[breakAccess: breakAccess];

IF breakTable = NIL THEN {
ERROR Breakpoint.Cant[
code: $NullBreakTable, message: "RememberBreak[nullBreakTable]"];
};
IF NOT breakTable.Insert[key: break, val: break] THEN {
ERROR Breakpoint.Cant[code: $CantRememberBreak, message: "Can't remember break"];
};
RETURN;
};

ForgetBreak: PUBLIC PROCEDURE [break: Break] ~ {
breakAccess: Breakpoint.BreakAccess ~ BreakAccessFromBreak[break: break];
breakTable: RefTab.Ref ~ BreakTableFromBreakAccess[breakAccess: breakAccess];

IF breakTable = NIL THEN {
ERROR Breakpoint.Cant[
code: $NullBreakTable, message: "ForgetBreak[nullBreakTable]"];
};
IF NOT breakTable.Delete[key: break] THEN {
ERROR Breakpoint.Cant[code: $CantForgetBreak, message: "Can't forget break"];
};
RETURN;
};

NewBreak: PUBLIC PROCEDURE [
address: BreakWorldArchitecture.Address,
patch: Shepherd.Patch,
clientData: Breakpoint.ClientData]
RETURNS [Breakpoint.Break] ~ {
breakWorld: BreakWorldArchitecture.BreakWorld ~ 
BreakWorldArchitecture.BreakWorldFromBreakWorldAddress[address: address];
breakAccess: Breakpoint.BreakAccess ~ 
BreakWorldArchitecture.BreakAccessFromBreakWorld[breakWorld: breakWorld];
break: Breakpoint.Break ~ NEW[BreakRep _ [
breakAccess: breakAccess, address: address, patch: patch, clientData: clientData]];

RETURN [break];
};

IsNullBreak: PUBLIC PROCEDURE [break: Breakpoint.Break] RETURNS [BOOLEAN] ~ {
RETURN [break = Breakpoint.nullBreak];
};

AddressFromBreak: PUBLIC PROCEDURE [break: Breakpoint.Break] 
RETURNS [BreakWorldArchitecture.Address] ~ {
IF break.IsNullBreak[] THEN {
ERROR Breakpoint.Cant[code: $NullBreak, message: "AddressFromBreak[nullBreak]"];
};
RETURN [break.address];
};

PatchFromBreak: PUBLIC PROCEDURE [break: Breakpoint.Break] 
RETURNS [Shepherd.Patch] ~ {
IF break.IsNullBreak[] THEN {
ERROR Breakpoint.Cant[code: $NullBreak, message: "PatchFromBreak[nullBreak]"];
};
RETURN [break.patch];
};

ClientDataFromBreak: PUBLIC PROCEDURE [break: Breakpoint.Break] 
RETURNS [Breakpoint.ClientData] ~ {
IF break.IsNullBreak[] THEN {
ERROR Breakpoint.Cant[code: $NullBreak, message: "ClientDataFromBreak[nullBreak]"];
};
RETURN [break.clientData];
};

BreakAccessFromBreak: PROCEDURE [break: Break] RETURNS [Breakpoint.BreakAccess] ~ {
IF Breakpoint.IsNullBreak[break: break] THEN {
ERROR Breakpoint.Cant[
code: $NullBreak, message: "BreakAccessFromBreak[nullBreak]"];
};
RETURN [break.breakAccess];
};

BreakTableFromBreakAccess: PROCEDURE [breakAccess: Breakpoint.BreakAccess]
RETURNS [RefTab.Ref] ~ {
IF breakAccess = Breakpoint.nullBreakAccess THEN {
ERROR Breakpoint.Cant[code: $NullBreakAccess, message: "Null breakAccess"];
};
IF breakAccess.data = Breakpoint.nullBreakAccessData THEN {
ERROR Breakpoint.Cant[code: $NullBreakAccessData, message: "Null breakAccess.data"];
};
RETURN [breakAccess.data.breakTable];
};

CantSet: PUBLIC ERROR [
code: Breakpoint.ErrorCode, message: Breakpoint.ErrorMessage] ~ CODE;

CantClear: PUBLIC ERROR [
code: Breakpoint.ErrorCode, message: Breakpoint.ErrorMessage] ~ CODE;

registry: BreakpointPrivate.Registry _ NIL;

RegisterTargetBreaks: PUBLIC PROC[targetBreaks: BreakpointPrivate.TargetBreaks] ~ {
newR: BreakpointPrivate.Registry;
i:CARD;

IF registry = NIL THEN {
registry _ NEW[BreakpointPrivate.RegistryBody[1]];
registry[0] _ targetBreaks;
} ELSE IF (i _ RetrieveTargetBreaksInner[targetBreaks.targetName]) # LAST[CARD] THEN {
registry[i] _ targetBreaks;
} ELSE {
newR _ NEW[BreakpointPrivate.RegistryBody[registry.length+1]];
FOR i IN [0..registry.length) DO
newR[i] _ registry[i];
ENDLOOP;
newR[registry.length] _ targetBreaks;
registry _ newR;
};
};


RetrieveTargetBreaksInner: PROC[targetName: Rope.ROPE] RETURNS[registryIndex: CARD] ~ {
i: CARD;
IF registry = NIL THEN RETURN[LAST[CARD]];
FOR i _ 0, i + 1 UNTIL i = registry.length OR Rope.Equal[targetName, registry[i].targetName] DO
ENDLOOP;
IF i # registry.length THEN
RETURN[i]
ELSE
RETURN[LAST[CARD]];
};

RetrieveTargetBreaks: PUBLIC PROC[targetName: Rope.ROPE] RETURNS[BreakpointPrivate.TargetBreaks] ~ {
i: CARD _ RetrieveTargetBreaksInner[targetName];
IF i # LAST[CARD] THEN
RETURN[registry[i]]
ELSE
ERROR;
};
}.
  |  
BreakpointImpl.mesa
Copyright Ó 1989, 1990, 1991, 1992 by Xerox Corporation.  All rights reserved.
Peter B. Kessler, April 19, 1990 10:38 am PDT
Laurie Horton, October 16, 1991 1:27 am PDT
Katsuyuki Komatsu March 5, 1992 1:32 pm PST

Public Types EXPORTed to BreakWorldArchitecture
Public Types EXPORTed to Breakpoint
Public Procedures EXPORTed to Breakpoint
PROCEDURE [
address: BreakWorldArchitecture.Address, 
clientData: ClientData, 
breakProc: BreakProc, 
breakData: BreakData,
damages: TargetArchitecture.RegisterClass 
_ TargetArchitecture.RegisterClass.all] 
RETURNS [Break];
PROCEDURE [break: Break] RETURNS [];
PROCEDURE [breakWorld: BreakWorldArchitecture.BreakWorld, proc: BreakpointProc] 
RETURNS [quit: BOOLEAN _ FALSE];
PROC [key: Key, val: Val] RETURNS [quit: BOOL _ FALSE]
Private Procedures
Public Errors exported to Breakpoint.
Target-Dependent Procedure dispatch

 ÊL  •NewlineDelimiter
–"cedar" style™ code™Kšœ
ÏrœC™NKšœ-™-K™+K™+—™ šÏk	˜	Kšœ˜Kšœ˜Kšœ˜Kšœ˜Kšœ˜Kšœ	˜	Kšœ˜—K˜ —unitšÐlnœžœžœ˜KšžœD˜KKšžœ6˜=Kšœ˜headšœ/™/šœžœžœ7˜OKšœžœžœ˜8K˜ ——šœ#™#šœžœžœžœ5˜Wšœžœžœžœ˜*Kšœž˜Kšœ˜—K˜ —šœžœžœžœ!˜9šœ
žœžœžœ˜ K˜$K˜(K˜K˜!Kšœ˜—K˜ ——šœ(™(šÏnœžœ˜1šž	œ™Kšœ)™)Kšœ™Kšœ™Kšœ™šœ*™*Kšœ(™(—Kšžœ	™K˜ KšœC˜CKšœo˜oKšœh˜hKšœs˜sKšžœf˜lK˜—K˜ —š œžœ˜5Kšž	œžœ™$K˜ KšœI˜IKšœo˜oKšœh˜hKšœ$˜$Kšžœ˜K˜K˜ K˜ —š œžœž	œžœ˜Hšœ%žœ#˜KKšœ˜Kšœ#˜#Kšœ-˜-—šœ#žœ˜=K˜—šœ&žœ˜FKšœ˜—K˜ Kšžœ˜K˜K˜ —š œžœ"˜>Kšž	œHžœžœ™qš œ˜ Kšžœžœžœžœ™6Kšœžœ˜KšœQ˜QJ˜ Kšœ$˜$Kšžœ˜K˜—˜&K˜I—KšœM˜MK˜ šžœžœžœ˜šžœ˜KšœH˜HK˜——K˜'Kšžœ˜Kšœ˜K˜ —š œžœž	œ˜2˜&K˜#—KšœM˜MK˜ šžœžœžœ˜šžœ˜KšœA˜AK˜——šžœžœ+žœ˜7KšžœL˜QKšœ˜—Kšžœ˜Kšœ˜K˜ —š œžœž	œ˜0K˜IKšœM˜MK˜ šžœžœžœ˜šžœ˜Kšœ?˜?K˜——šžœžœžœ˜+KšžœH˜MKšœ˜—Kšžœ˜Kšœ˜K˜ —š œžœž	œfžœ˜žšœ0˜0KšœI˜I—˜&K˜I—šœžœ˜*K˜S—K˜ Kšžœ	˜Kšœ˜K˜ —š
 œžœž	œžœžœ˜MKšžœ ˜&Kšœ˜K˜ —š œžœž	œžœ%˜jšžœžœ˜KšžœK˜PK˜—Kšžœ˜Kšœ˜K˜ —š œžœž	œžœ˜Xšžœžœ˜KšžœI˜NK˜—Kšžœ˜Kšœ˜K˜ —š œžœž	œžœ˜dšžœžœ˜KšžœN˜SK˜—Kšžœ˜Kšœ˜K˜ ——šœ™š œž	œžœ˜Sšžœ&žœ˜.šžœ˜Kšœ>˜>—K˜—Kšžœ˜K˜K˜ —š œž	œ'žœ˜cšžœ*žœ˜2KšžœF˜KKšœ˜—šžœ3žœ˜;KšžœO˜TKšœ˜—Kšžœ˜%K˜K˜ ——™%š œžœžœCžœ˜]K˜ —š 	œžœžœCžœ˜_K˜ ——M™#Kšœ'žœ˜+K˜ š œžœžœ2˜SKšœ!˜!Kšœžœ˜K˜ šžœžœžœ˜Kšœžœ$˜2Kšœ˜—šœžœžœ<žœžœžœ˜VKšœ˜—šœžœ˜Kšœžœ4˜>šžœžœž˜ Kšœ˜Kšžœ˜—Kšœ%˜%Kšœ˜K˜—K˜—K˜ K˜ š
 œžœžœžœžœ˜WKšœžœ˜Kšžœžœžœžœžœžœ˜*šžœžœžœ0ž˜_Kšžœ˜—šžœž˜Kšžœ˜	—šž˜Kšžœžœžœ˜—K˜K˜ —š
 œžœžœžœžœ$˜dKšœžœ)˜0šžœžœžœž˜Kšžœ˜—šž˜Kšžœ˜—K˜—K™ L˜—— …—    *  'ò  