DIRECTORY
Convert USING [IntFromRope],
File USING [SystemVolume],
FileBackdoor USING [IsDebugger],
FS USING [Error, ExpandName, GetName, OpenFileFromStream, StreamOpen],
IO USING [Backup, BreakProc, Close, CR, EndOfStream, Error, GetChar, GetIndex, GetRopeLiteral, GetTokenRope, int, PeekChar, PutF, PutFR, rope, SP, STREAM, TAB, time],
MachineProfile,
MachineProfileBackdoor USING [GuestProcsRec],
PupDefs USING [GetMyName],
Rope USING [Cat, Concat, Equal, ROPE, Run, SkipTo],
RuntimeError USING [UNCAUGHT],
UserProfile USING [ProfileChanged, ProfileChangeReason, ProfileChangedProc],
ViewerEvents USING [EventProc, RegisterEventProc];


MachineProfileImpl: CEDAR MONITOR
IMPORTS Convert, File, FileBackdoor, FS, IO, PupDefs, Rope, RuntimeError, UserProfile, ViewerEvents  
EXPORTS MachineProfile, MachineProfileBackdoor 
= BEGIN
ProfileList: TYPE = LIST OF ProfileEntry;
ProfileEntry: TYPE = REF ProfileRecord;
ProfileRecord: TYPE = RECORD[key: ROPE, tokens: LIST OF ROPE, position: INT];
ROPE: TYPE = Rope.ROPE;

ProfileChangedItem: TYPE = RECORD [
proc: UserProfile.ProfileChangedProc,
clientData: REF ANY
];
IsGuestProcess: PROC [] RETURNS [isGuest: BOOL] _ FalseProc;

GuestProcs: REF MachineProfileBackdoor.GuestProcsRec _ NEW[MachineProfileBackdoor.GuestProcsRec _ [FalseProc]] ;

Boolean: PUBLIC PROC [key: ROPE, default: BOOL _ FALSE] RETURNS [value: BOOL] = {
entry: ProfileEntry;
val: ROPE;
IF IsGuestProcess[] THEN RETURN GuestProcs.Boolean[key, default];
entry _ Lookup[key];
val _ GetRope[entry];
IF val = NIL THEN RETURN[default];
IF val.Equal["TRUE", FALSE] THEN RETURN[TRUE];
IF val.Equal["FALSE", FALSE] THEN RETURN[FALSE];
Report[entry, val.Concat[" is not a Boolean"]];
RETURN[default];
};

Number: PUBLIC PROC [key: ROPE, default: INT] RETURNS [value: INT] = {
entry: ProfileEntry;
val: ROPE;
IF IsGuestProcess[] THEN RETURN GuestProcs.Number[key, default];
entry _ Lookup[key];
val _ GetRope[entry];
IF val = NIL THEN RETURN[default];
value _ Convert.IntFromRope[val
! RuntimeError.UNCAUGHT => {
value _ default; 
Report[entry, val.Concat[" is not an INT"]];
CONTINUE;
}
];
};

Token: PUBLIC PROC [key: ROPE, default: ROPE] RETURNS [value: ROPE] = {
entry: ProfileEntry;
val: ROPE;
IF IsGuestProcess[] THEN RETURN GuestProcs.Token[key, default];
entry _ Lookup[key];
val _ GetRope[entry];
IF val = NIL THEN RETURN[default];
value _  val;
};

ListOfTokens: PUBLIC PROC [key: ROPE, default: LIST OF ROPE] RETURNS [value: LIST OF ROPE] = {
entry: ProfileEntry;
IF IsGuestProcess[] THEN RETURN GuestProcs.ListOfTokens[key, default];
entry _ Lookup[key];
IF entry = NIL THEN RETURN[default] ELSE RETURN[entry.tokens];
};

Line: PUBLIC PROC [key: ROPE, default: ROPE] RETURNS [value: ROPE] = {
entry: ProfileEntry;
IF IsGuestProcess[] THEN RETURN GuestProcs.Line[key, default];
entry _ Lookup[key];
IF entry = NIL THEN RETURN[default];
FOR l: LIST OF ROPE _ entry.tokens, l.rest UNTIL l = NIL DO
IF value = NIL THEN value _ l.first ELSE
value _ value.Cat[" ", l.first];
ENDLOOP;
};

Lookup: ENTRY PROC [key: ROPE] RETURNS [ProfileEntry] = {
ENABLE UNWIND => NULL;
RETURN[LookupInternal[key]]
};

LookupInternal: INTERNAL PROC [key: ROPE] RETURNS [ProfileEntry] = {
IF FileBackdoor.IsDebugger[File.SystemVolume[]] THEN {
s2: ROPE = Rope.Concat["Debugger.", key];
FOR l: ProfileList _ profileList, l.rest UNTIL l = NIL DO
IF Rope.Equal[s1: l.first.key, s2: s2, case: FALSE] THEN RETURN[l.first];
ENDLOOP;
};
FOR l: ProfileList _ profileList, l.rest UNTIL l = NIL DO
IF Rope.Equal[s1: l.first.key, s2: key, case: FALSE] THEN RETURN[l.first];
ENDLOOP;
RETURN[NIL];
};

GetRope: PROC [entry: ProfileEntry] RETURNS [value: ROPE] = INLINE {
IF entry = NIL OR entry.tokens = NIL THEN RETURN[NIL];
value _ entry.tokens.first;
IF entry.tokens.rest # NIL THEN Report[entry, "extra material on line"];
};

GetProfileName: PUBLIC PROC RETURNS [ROPE] = {
IF IsGuestProcess[] THEN RETURN GuestProcs.GetProfileName[]
 ELSE RETURN[profileName];
};

profileList: ProfileList _ NIL;
profileName: ROPE _ NIL;

ParseProfile: ENTRY PROC [startNewErrorLog: BOOL _ FALSE]  = {
ENABLE UNWIND => NULL;
ParseProfileInternal[startNewErrorLog];
};

ParseProfileInternal: INTERNAL PROC [startNewErrorLog: BOOL _ FALSE]  = {
name: ROPE;  
stream: IO.STREAM _ NIL;
IF startNewErrorLog THEN errorLog _ NIL;
profileList _ NIL;
profileName _ NIL;
name _ PupDefs.GetMyName[];
profileName _ Rope.Cat["///", name, ".profile"];
stream _ FS.StreamOpen[fileName: profileName
! FS.Error => IF error.group # bug THEN CONTINUE
];
IF stream = NIL THEN {
profileName _ "///Machine.profile";
stream _ FS.StreamOpen[fileName: profileName
! FS.Error => IF error.group # bug THEN CONTINUE
];
};
IF stream # NIL THEN {
ENABLE {
RuntimeError.UNCAUGHT => GOTO Out;
UNWIND => IO.Close[stream];
};
stream _ FS.StreamOpen[fileName: profileName, accessOptions: $read];
DO
SkipWhite: PROC [flushLines: BOOL _ FALSE] RETURNS [c: CHAR] = {
DO
ENABLE IO.Error, IO.EndOfStream => GO TO stop;
c _ stream.PeekChar[];
SELECT c FROM
'\n => IF NOT flushLines THEN RETURN;
<= 40C => {};
'- => {-- could be a comment
[] _ stream.GetChar[];
IF stream.PeekChar[] # '- THEN {
stream.Backup[c];
RETURN [c];
};
DO
c _ stream.GetChar[];
SELECT c FROM
'\n => {
stream.Backup[c];
IF flushLines THEN EXIT;
RETURN;
};
'- => IF stream.PeekChar[] = '- THEN EXIT;
ENDCASE;
ENDLOOP;
};
ENDCASE => RETURN;
[] _ stream.GetChar[];
ENDLOOP;
EXITS stop => {c _ 0C};
};
LocalToken: PROC [flushLines: BOOL _ FALSE] = {
stop: CHAR _ SkipWhite[flushLines];
position _ stream.GetIndex[];
token _ NIL;
SELECT stop FROM
0C, '\n => RETURN;
'" => token _ stream.GetRopeLiteral[];
ENDCASE => token _ stream.GetTokenRope[tokenProc].token;
};
tokenProc: IO.BreakProc = {
RETURN[SELECT char FROM
IO.SP, IO.TAB, ', => sepr,
IO.CR, ': => break,
ENDCASE => other
];
};
token: ROPE _ NIL;
tokens, tail: LIST OF ROPE _ NIL;
position: INT;
key: ROPE _ NIL;
LocalToken[TRUE];
IF (key _ token) = NIL THEN EXIT;
SELECT SkipWhite[] FROM
': => [] _ stream.GetChar[];  -- flush the ':
ENDCASE => {
DO
IF stream.GetChar[ ! IO.EndOfStream => EXIT] = '\n THEN EXIT;
ENDLOOP;
ReportInternal[msg: IO.PutFR["missing : at [%d]", IO.int[position]]];
LOOP;
};
DO
list: LIST OF ROPE _ NIL;
LocalToken[];
IF token = NIL THEN EXIT;
list _ LIST[token];
IF tail = NIL
THEN {tail _ tokens _ list}
ELSE {tail.rest _ list; tail _ list};
ENDLOOP;
IF LookupInternal[key] # NIL THEN
ReportInternal[
entry: LookupInternal[key],
msg: IO.PutFR["%g also appears at [%d]", IO.rope[key], IO.int[position]]
];
profileList _ CONS[NEW[ProfileRecord _ [key, tokens, position]], profileList];
ENDLOOP;
EXITS
Out => NULL;
};
IF stream # NIL THEN stream.Close[];
};

Report: ENTRY PROC [entry: ProfileEntry _ NIL, msg: ROPE] = {
ENABLE UNWIND => NULL;
ReportInternal[entry, msg];
};

ReportInternal: INTERNAL PROC [entry: ProfileEntry _ NIL, msg: ROPE] = {
ENABLE RuntimeError.UNCAUGHT => CONTINUE;
IF errorLog = NIL THEN {
errorLog _ FS.StreamOpen[fileName: "///MachineProfile.log", accessOptions: $create];
errorLog.PutF["Processing %g at %t", IO.rope[profileName], IO.time[]];
};
errorLog.PutF["\n\n%g", IO.rope[msg]]; 
IF entry # NIL THEN
errorLog.PutF[", at %g [%d]", IO.rope[entry.key], IO.int[entry.position]]; 
};

GetErrorLog: PUBLIC ENTRY PROC RETURNS [fileName: ROPE _ NIL] = {
ENABLE UNWIND => {errorLog _ NIL; NULL};
IF errorLog # NIL THEN {
fileName _ FS.GetName[FS.OpenFileFromStream[errorLog]].fullFName;
errorLog.Close[];
errorLog _ NIL;
};
};

errorLog: IO.STREAM _ NIL;

RegisterGuestProcs: PUBLIC PROC [newProcs: REF MachineProfileBackdoor.GuestProcsRec] = {
GuestProcs _ newProcs;
IsGuestProcess _ newProcs.IsGuestProcess;
};

FalseProc: PROC RETURNS [isGuest: BOOL] = { 
isGuest _ FALSE;
};

NoticeProfileChanges: ViewerEvents.EventProc = {
IF viewer # NIL THEN {
ENABLE FS.Error => GOTO GiveUp;
name1: ROPE _ FS.ExpandName[viewer.file].fullFName;
bang1: INT _ Rope.SkipTo[name1, 0, "!"];
name2: ROPE _ FS.ExpandName[GetProfileName[]].fullFName;
bang2: INT _ Rope.SkipTo[name2, 0, "!"];
IF bang1 # 0 AND bang1 = bang2 AND Rope.Run[name1, 0, name2, 0, FALSE] = bang1 THEN
UserProfile.ProfileChanged[edit];
EXITS GiveUp => NULL;
};
};

Init: PROC ~ {
[] _ ViewerEvents.RegisterEventProc[NoticeProfileChanges, save, $Text, FALSE];
ParseProfile[];
};

Init[];

END.
RMachineProfileImpl.mesa
Copyright c 1984, 1985 by Xerox Corporation.  All rights reserved.
Copied from UserProfileImpl.mesa...
Teitelman on January 13, 1983 1:52 pm
Levin, October 6, 1983 12:03 pm
Russ Atkinson, April 11, 1985 10:31:43 am PST
Paul Rovner on December 12, 1983 8:45 pm
Bob Hagmann May 22, 1985 4:50:10 pm PDT
Russ Atkinson (RRA) May 20, 1985 5:16:59 pm PDT
Eric Nickell, June 13, 1985 9:24:48 pm PDT
Booting USING [switches],

Types


Variables
Accessing profile


Building profileList
IF Booting.switches[p] THEN RETURN; -- return default values for the profile
it is not a comment
the end of a comment is either a '\n or a double -
Only flush the \n if it was requested
key was NOT followed by ':, so flush to the end of line and report the error

Reporting errors

Exported to MachineProfileBackdoor
default IsGuestProcess (not really exported)
NO initialization, since InstallerImpl has that responsibility!
[viewer: ViewerClasses.Viewer, event: ViewerEvent, before: BOOL]
RETURNS[abort: BOOL _ FALSE]
The profile is the same (except for version info), so notify about a change


Κ_–

"Cedar" style˜
codeš
Οc™Kšœ
Οm
œ7™B™#Kš
œ™%K™K™-Kšœ™(K™'K™/—K™*—K˜š
Οk	˜	KšœŸœ™KšœŸœ˜KšœŸœ˜Kšœ
Ÿœ˜ KšŸœ
Ÿœ>˜FKšŸœ
ŸœŸœiŸœŸœŸœ˜¦
K˜KšœŸœ˜-KšœŸœ
˜KšœŸœŸœ˜3Kšœ
ŸœŸœ˜KšœŸœ;˜LKšœ
Ÿœ ˜2K˜—K˜šΟbœŸœ
Ÿ˜!KšŸœŸœŸœ:˜eKšŸœ(˜/KšœŸ˜—K™š
œ™K™Kšœ
ŸœŸœ
Ÿœ˜)KšœŸœŸœ˜'KšœŸœŸœŸœ
Ÿœ
Ÿœ
ŸœŸœ˜MKšŸœŸœŸœ
˜K˜šœŸœŸœ˜#Kš
œ%˜%KšœŸœ
Ÿ˜Kš
œ˜——K™™	JšΠbnœŸœŸœŸœ˜<J˜JšœŸœ(Ÿœ6˜pJ˜—™K™šΟnœŸœ
ŸœŸœŸœŸœŸœ	Ÿœ˜QK˜KšœŸœ
˜
KšŸœŸœ
Ÿœ"˜AJ˜Jš
œ˜KšŸœŸœ
Ÿœ
Ÿœ
˜"Kš
ŸœŸœŸœ
Ÿœ
Ÿœ˜.Kš
ŸœŸœŸœ
Ÿœ
Ÿœ˜0K˜/KšŸœ
˜K˜K˜—š’œŸœ
ŸœŸœŸœŸœ	Ÿœ˜FK˜KšœŸœ
˜
KšŸœŸœ
Ÿœ!˜@J˜Jš
œ˜KšŸœŸœ
Ÿœ
Ÿœ
˜"š
œ˜šœŸœ˜Kš
œ˜K˜,KšŸœ
˜	Kš
œ
˜
—Kš
œ˜—K˜—K˜š’œŸœ
ŸœŸœŸœŸœ	Ÿœ˜GK˜KšœŸœ
˜
KšŸœŸœ
Ÿœ ˜?K˜Kš
œ˜KšŸœŸœ
Ÿœ
Ÿœ
˜"K˜
K˜K˜—š’œŸœ
ŸœŸœŸœ
Ÿœ
ŸœŸœ	Ÿœ
Ÿœ
Ÿœ˜^K˜KšŸœŸœ
Ÿœ'˜FK˜KšŸœ	Ÿœ
Ÿœ
Ÿœ
Ÿœ
Ÿœ˜>K˜K˜—š’œŸœ
ŸœŸœŸœŸœ	Ÿœ˜FK˜KšŸœŸœ
Ÿœ˜>K˜KšŸœ	Ÿœ
Ÿœ
Ÿœ
˜$š
ŸœŸœ
Ÿœ
ŸœŸœŸœ
Ÿ˜;KšŸœ	Ÿœ
ŸœŸ˜(K˜ KšŸœ
˜—K˜K˜—š
’œŸœ
ŸœŸœŸœ˜9KšŸœ
ŸœŸœ
˜KšŸœ˜Kš
œ˜K˜—š
’œŸœ
ŸœŸœŸœ˜DšŸœ.Ÿœ˜6KšœŸœ!˜)šŸœ&ŸœŸœ
Ÿ˜9KšŸœ+ŸœŸœ
Ÿœ
˜IKšŸœ
˜—K˜—šŸœ&ŸœŸœ
Ÿ˜9KšŸœ,ŸœŸœ
Ÿœ
˜JKšŸœ
˜—KšŸœ
Ÿœ˜K˜K˜—š
’œŸœŸœ	ŸœŸœ˜DKšŸœ	Ÿœ
ŸœŸœ
Ÿœ
Ÿœ
Ÿœ˜6K˜KšŸœŸœ
Ÿœ)˜HK˜K˜—š
’œŸœ
Ÿœ
ŸœŸœ˜.KšŸœŸœ
Ÿœ˜;Kšœ
Ÿœ
Ÿœ˜Kš
œ˜——K™™K˜KšœŸœ
˜Kšœ
ŸœŸœ˜š
’œŸœ
ŸœŸœŸœ˜>KšŸœ
ŸœŸœ
˜Kš
œ'˜'K˜K˜—š
’œŸœ
ŸœŸœŸœ˜IKšœŸœ˜
KšœŸœ
ŸœŸœ
˜KšŸœŸœŸœ
˜(KšœŸœ
˜KšœŸœ
˜KšŸœŸœ
Ÿœ(™LKš
œ˜Kš
œ0˜0šœ	Ÿœ!˜,KšœŸœ
ŸœŸœ
Ÿ˜0Kš
œ˜—šŸœ
Ÿœ
Ÿœ˜Kš
œ#˜#šœ	Ÿœ!˜,KšœŸœ
ŸœŸœ
Ÿ˜0Kš
œ˜—K˜—šŸœ
Ÿœ
Ÿœ˜šŸœ˜Kšœ
ŸœŸœ˜"KšŸœŸœ˜K˜—Kšœ	Ÿœ9˜Dš
Ÿ˜š’	œŸœŸœŸœŸœŸœ˜@š
Ÿ˜Kš
Ÿœ
ŸœŸœŸœ
Ÿœ˜.Kš
œ˜šŸœŸ˜
Kš	œŸœ
ŸœŸœ
Ÿœ
˜%Kš
œ
˜
šœ˜Kš
œ˜šŸœŸœ˜ Kš
œ™Kš
œ˜KšŸœ˜K˜—š
Ÿ˜Kš
œ2™2Kš
œ˜šŸœŸ˜
š
œ˜Kš
œ%™%Kš
œ˜KšŸœŸœ
Ÿœ
˜KšŸœ
˜Kš
œ˜—KšœŸœŸœ
Ÿœ
˜*KšŸœ
˜—KšŸœ
˜—K˜—KšŸœŸœ
˜—Kš
œ˜KšŸœ
˜—KšŸœ˜K˜—š’
œŸœŸœŸœ˜/KšœŸœ˜#Kš
œ˜KšœŸœ
˜šŸœŸ˜KšœŸœ
˜Kš
œ&˜&KšŸœ1˜8—K˜—šœŸœ˜šŸœ
ŸœŸ˜KšŸœ
ŸœŸœ
Ÿœ
˜KšŸœ
Ÿœ˜KšŸœ	˜K˜—Kš
œ˜—KšœŸœŸœ
˜Kš	œŸœ
Ÿœ
ŸœŸœ
˜!Kšœ
Ÿœ
˜KšœŸœŸœ
˜KšœŸœ˜KšŸœŸœ
Ÿœ
Ÿœ
˜!šŸœ
Ÿ˜Kšœ˜-šŸœ˜Kš
œL™Lš
Ÿ˜Kš
ŸœŸœŸœŸœ
Ÿœ
˜=KšŸœ
˜—KšœŸœŸœ˜EKšŸœ
˜Kš
œ˜——š
Ÿ˜Kš	œŸœ
Ÿœ
ŸœŸœ
˜Kš
œ
˜
KšŸœ	Ÿœ
Ÿœ
Ÿœ
˜KšœŸœ˜šŸœŸ˜
KšŸœ˜KšŸœ!˜%—KšŸœ
˜—šŸœŸœ
Ÿ˜!š
œ˜Kš
œ˜KšœŸœ"ŸœŸœ˜HKš
œ˜——KšœŸœ
Ÿœ8˜NKšŸœ
˜—š
Ÿ˜KšœŸœ
˜—K˜—KšŸœ
Ÿœ
Ÿœ˜$Kš
œ˜——K™™K˜š
’œŸœ
ŸœŸœŸœ˜=KšŸœ
ŸœŸœ
˜Kš
œ˜Kš
œ˜—K˜š
’œŸœ
ŸœŸœŸœ˜HKšŸœŸœŸœ
˜)šŸœŸœ
Ÿœ˜KšœŸœG˜TKšœ%ŸœŸœ	˜FK˜—KšœŸœ
˜'šŸœ	Ÿœ
Ÿ˜KšœŸœŸœ˜K—Kš
œ˜—K˜š’œŸœ
Ÿœ
Ÿœ
ŸœŸœŸœ˜AKšŸœ
ŸœŸœŸœ˜(šŸœŸœ
Ÿœ˜KšœŸœ	Ÿœ)˜AKš
œ˜KšœŸœ
˜Kš
œ˜—K˜—K˜Kšœ
Ÿœ
ŸœŸœ
˜—K™š
œ"™"J˜š’œŸœ
ŸœŸœ*˜XIcode2š
œ˜Lš
œ)˜)L˜L˜Lš
œ,™,—š’	œŸœ
ŸœŸœ˜,Lšœ
Ÿœ
˜L˜L˜——Kš
œ?™?š
œ0˜0Kš	œ;Ÿœ
ŸœŸœŸœ
™]šŸœ
Ÿœ
Ÿœ˜KšŸœ
Ÿœ
Ÿœ˜KšœŸœŸœ#˜3KšœŸœ˜(KšœŸœŸœ(˜8KšœŸœ˜(š	ŸœŸœŸœŸœ
Ÿ˜SKš
œK™KKš
œ!˜!—KšŸœŸœ
˜K˜—Kš
œ˜K˜—š’œŸœ˜KšœGŸœ˜NKš
œ˜K˜K˜—K˜K˜KšŸœ
˜K™K™—…— B2σ