
DIRECTORY
BasicTime USING [Now],
Convert USING [IntFromRope],
Commander USING [CommandProc, Register],
CommanderOps USING [DoCommand, NextArgument],
InstallationBasicComforts,
IO,
PFS,
PFSNames,
Rope USING [Cat, Concat, Equal, ROPE],
RuntimeError USING [UNCAUGHT],
SimpleFeedback USING [Append],
SystemNames USING [MachineName, ReleaseName, SimpleHomeDirectory],
UserProfile USING [ProfileChangedProc, ProfileChangeReason],
UserProfileBackdoor USING [GuestProcsRec];


UserProfileImpl: CEDAR MONITOR
IMPORTS BasicTime, Convert, Commander, CommanderOps, InstallationBasicComforts, IO, PFS, PFSNames, Rope, RuntimeError, SimpleFeedback, SystemNames 
EXPORTS UserProfile, UserProfileBackdoor
= 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 UserProfileBackdoor.GuestProcsRec Ź NEW[UserProfileBackdoor.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, Rope.Cat["\t", val, " 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, Rope.Cat["\t", val, " 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] = {
<< Until we sort out what it means to have a Debugger volume in PCedar
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, "\textra material on line"];
};

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

profileDir: PFS.PATH ~ PFS.PathFromRope[SystemNames.SimpleHomeDirectory[]];
profileList: ProfileList Ź NIL;
profileName: ROPE Ź NIL;
profileNameList: LIST OF ROPE Ź NIL;
ropeProfile: ROPE Ź NIL;
userSetProfileName: ROPE Ź NIL;

ParseProfile: ENTRY PROC [startNewErrorLog: BOOL Ź FALSE]  = {
ENABLE UNWIND => NULL;
profileList Ź NIL;
profileName Ź NIL;
profileNameList Ź NIL;
<< (until something like the Booting interface comes along for PCedar 
IF Booting.switches[p] THEN RETURN -- return default values for the profile
ELSE>> { 
dot: ROPE ~ ".";
machineName: ROPE ~ SystemNames.MachineName[];

machineProfileName: ROPE ~ Rope.Cat[dot, machineName, dot, SystemNames.ReleaseName[], ".machineProfile"];
userProfileName: ROPE ~  Rope.Cat[".cedar.", SystemNames.ReleaseName[], ".profile"];
serverProfileName: ROPE ~ Rope.Cat[".server.", SystemNames.ReleaseName[], ".profile"];
defaultProfileName: ROPE ~ Rope.Cat[".user.", SystemNames.ReleaseName[], ".profile"];

oldMachineProfileName: ROPE ~ dot.Cat[machineName, ".machineProfile"];
oldUserProfileName: ROPE ~  ".cedar.profile";
oldServerProfileName: ROPE ~ ".server.profile";
oldDefaultProfileName: ROPE ~ ".user.profile";

TryFileProfile: INTERNAL PROC [shortName: ROPE, wDir: PFSNames.PATH]
RETURNS [found: BOOL Ź FALSE] ~ {
stream: IO.STREAM Ź NIL;
pPath: PFS.PATH;
pPath Ź PFSNames.ExpandName[name: PFS.PathFromRope[shortName], wDir: wDir ! PFS.Error => CONTINUE];
stream Ź PFS.StreamOpen[pPath ! PFS.Error => CONTINUE];
IF stream#NIL THEN {
profileName Ź PFS.RopeFromPath[pPath];
profileNameList Ź CONS[profileName, profileNameList];
ParseProfileInternal[stream];
found Ź TRUE;
};
};
TryFiles: INTERNAL PROC [] ~ {
IF TryFileProfile[machineProfileName, profileDir].found THEN
[] Ź TryFileProfile[oldMachineProfileName, profileDir];
IF TryFileProfile[serverProfileName, profileDir].found THEN RETURN;
IF TryFileProfile[oldServerProfileName, profileDir].found THEN RETURN;
IF userSetProfileName # NIL THEN
IF TryFileProfile[userSetProfileName, NIL].found THEN RETURN;
IF TryFileProfile[userProfileName, profileDir].found THEN RETURN;
IF TryFileProfile[oldUserProfileName, profileDir].found THEN RETURN;
IF TryFileProfile[defaultProfileName, profileDir].found THEN RETURN;
IF TryFileProfile[oldDefaultProfileName, profileDir].found THEN RETURN;
};
TryRopeProfile: INTERNAL PROC ~ {
stream: IO.STREAM;
IF ropeProfile = NIL THEN RETURN;
stream Ź IO.RIS[ropeProfile];
IF stream # NIL THEN {
profileName Ź "RopeProfile";  -- may need for error reporting
ParseProfileInternal[stream, FALSE];
};
};
IF startNewErrorLog THEN errorLog Ź NIL;
TryFiles[];
TryRopeProfile[]; -- make any requested additions/changes.
};
CheckErrorLogInternal["parsing your profile"];
};

ParseProfileInternal: INTERNAL PROC [stream: IO.STREAM, reportSameKeys: BOOL Ź TRUE]  = {
DO
ENABLE {
RuntimeError.UNCAUGHT => EXIT;
UNWIND => IO.Close[stream];
};
SkipWhite: PROC [flushLines: BOOL Ź FALSE] RETURNS [c: CHAR] = {
DO
ENABLE IO.Error, IO.EndOfStream => GO TO stop;
c Ź stream.PeekChar[];
SELECT c FROM
'\n, '\r, '\l => 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, '\r, '\l => {
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, '\r, '\l => RETURN;
'" => token Ź stream.GetRopeLiteral[];
ENDCASE => token Ź stream.GetTokenRope[tokenProc].token;
};
tokenProc: IO.BreakProc = {
RETURN[SELECT char FROM
IO.SP, IO.TAB, ', => sepr,
'\n, '\r, '\l, ': => break,
ENDCASE => other
];
};
Cat: PROC [a, b: LIST OF ROPE] RETURNS [LIST OF ROPE] ~ {
RETURN [IF a=NIL THEN b ELSE CONS[a.first, Cat[a.rest, b]]];
};
LookupTokens: INTERNAL PROC [key: ROPE] RETURNS [tokens: LIST OF ROPE] ~ {
entry: ProfileEntry ~ LookupInternal[key];
RETURN [IF entry=NIL THEN NIL ELSE entry.tokens];
};
token: ROPE Ź NIL;
tokens, tail: LIST OF ROPE Ź NIL;
position: INT;
key: ROPE Ź NIL;
additive: {none, prefix, suffix};
LocalToken[TRUE];
IF (key Ź token) = NIL THEN EXIT;
SELECT SkipWhite[] FROM
': => {
[] Ź stream.GetChar[];  -- flush the ':
IF (additive Ź SELECT stream.PeekChar[] FROM
'< => prefix,
'> => suffix,
ENDCASE => none)#none THEN [] Ź stream.GetChar[];  --flush '< or '> if needed
};
ENDCASE => {
position: INT Ź stream.GetIndex[];
DO
IF stream.GetChar[ ! IO.EndOfStream => EXIT] = '\n THEN EXIT;
ENDLOOP;
ReportInternal[msg: IO.PutFR1["\tmissing : at [%d]\n", [integer[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 key.Equal["Include", FALSE] THEN {	--Insert a profile slice
position Ź stream.GetIndex[];
FOR each: LIST OF ROPE Ź tokens, each.rest UNTIL each=NIL DO
profileSlice: IO.STREAM Ź NIL;
profileSlice Ź PFS.StreamOpen[fileName: PFS.AbsoluteName[short: PFS.PathFromRope[each.first], wDir: profileDir] ! PFS.Error => CONTINUE];
IF profileSlice#NIL THEN ParseProfileInternal[profileSlice] ELSE {
ReportInternal[
entry: NEW[ProfileRecord Ź [each.first, tokens, position]],
msg: "\tFile not found."
];
};
ENDLOOP;
}
ELSE {				--Add a profile entry
SELECT additive FROM
prefix => tokens Ź Cat[tokens, LookupTokens[key]];
suffix => tokens Ź Cat[LookupTokens[key], tokens];
ENDCASE => IF reportSameKeys AND LookupInternal[key] # NIL THEN
ReportInternal[
entry: LookupInternal[key],
msg: IO.PutFR["\t%g also appears at [%d]", [rope[key]], [integer[position]]]
];
profileList Ź CONS[NEW[ProfileRecord Ź [key, tokens, stream.GetIndex[]]], profileList];
};
ENDLOOP;
IO.Close[stream];
};

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

logPath: PFS.PATH ~ PFS.PathFromRope["UserProfile.log"];
createNewErrorLog: BOOL Ź TRUE;

ReportInternal: INTERNAL PROC [entry: ProfileEntry Ź NIL, msg: ROPE] = {
ENABLE RuntimeError.UNCAUGHT => CONTINUE;
IF errorLog = NIL THEN {
errorLog Ź PFS.StreamOpen[fileName: PFSNames.Cat[profileDir, logPath], 
accessOptions: IF createNewErrorLog THEN $create ELSE $write];
IF NOT createNewErrorLog THEN errorLog.SetIndex[errorLog.GetLength[]];
createNewErrorLog Ź FALSE;		-- once per startup
errorLog.PutF["\n\n*** %g - processing %g\n", [time[BasicTime.Now[]]], [rope[profileName]]];
};
errorLog.PutF1["\n %g", [rope[msg]] ]; 
IF entry # NIL THEN
errorLog.PutF[", at %g [%d]", [rope[entry.key]], [integer[entry.position]]]; 
errorLog.Flush[];
};

GetErrorLog: PUBLIC ENTRY PROC RETURNS [fileName: ROPE Ź NIL] = {
ENABLE UNWIND => { errorLog Ź NIL; NULL };
RETURN[InternalErrorLogName[]];
};

CheckErrorLog: ENTRY PROC[msg: ROPE] ~ {
CheckErrorLogInternal[msg]
};

CheckErrorLogInternal: INTERNAL PROC[msg: ROPE] ~ {
IF errorLog # NIL THEN
SimpleFeedback.Append[$UserProfile, $begin, $info, IO.PutFR["** There were errors %g; see %g for details (%g)\n", [rope[msg]], [rope[InternalErrorLogName[]]], [time[BasicTime.Now[]]] ]];

};

InternalErrorLogName: INTERNAL PROC RETURNS[fileName: ROPE Ź NIL] = {
IF errorLog # NIL THEN {
fileName Ź PFS.RopeFromPath[PFS.GetName[PFS.OpenFileFromStream[errorLog]].fullFName];
errorLog.Close[];
errorLog Ź NIL;
};
};

errorLog: IO.STREAM Ź NIL;

profileChangedList: LIST OF ProfileChangedItem Ź NIL;
profileChangedListLast: LIST OF ProfileChangedItem Ź NIL;

AddToList: ENTRY PROC [item: ProfileChangedItem] ~ {
itemL: LIST OF ProfileChangedItem = CONS[item, NIL];
IF profileChangedList = NIL THEN profileChangedList Ź itemL
ELSE profileChangedListLast.rest Ź itemL;
profileChangedListLast Ź itemL;
};

CopyList: ENTRY PROC RETURNS [LIST OF ProfileChangedItem] ~ {
head, tail: LIST OF ProfileChangedItem Ź NIL;
FOR list: LIST OF ProfileChangedItem Ź profileChangedList, list.rest UNTIL list=NIL DO
copy: LIST OF ProfileChangedItem ~ CONS[list.first, NIL];
IF head=NIL THEN head Ź copy ELSE tail.rest Ź copy;
tail Ź copy;
ENDLOOP;
RETURN [head];
};

CallWhenProfileChanges: PUBLIC PROC [proc: UserProfile.ProfileChangedProc] = {
IF IsGuestProcess[] THEN GuestProcs.CallWhenProfileChanges[proc]
ELSE {
item: ProfileChangedItem ~ [proc, --clientData--NIL];
AddToList[item];
DoIt[item, firstTime];
CheckErrorLog["during add ProfileChangedProc"];
};
};

ProfileChanged: PUBLIC PROC [reason: UserProfile.ProfileChangeReason] = {
ProfileChangedInternal[reason, reason # firstTime];
};

ProfileChangedInternal: PROC [reason: UserProfile.ProfileChangeReason,
nillRopeProfile: BOOL Ź TRUE] = {
IF IsGuestProcess[] THEN GuestProcs.ProfileChanged[reason]
ELSE {
IF nillRopeProfile THEN ropeProfile Ź NIL;
ParseProfile[startNewErrorLog: TRUE ! RuntimeError.UNCAUGHT => CONTINUE];
FOR l: LIST OF ProfileChangedItem Ź CopyList[], l.rest UNTIL l=NIL DO
DoIt[l.first, reason];
ENDLOOP;
};
};

DoIt: PROC [item: ProfileChangedItem, reason: UserProfile.ProfileChangeReason] = {
item.proc[reason--, item.clientData--
! RuntimeError.UNCAUGHT => {
Report[msg: Rope.Concat["\tUncaught error while executing ProfileChangedProc: ", InstallationBasicComforts.BasicProcName[item.proc]]];
CONTINUE
}
];
};

GetRopeProfile: PUBLIC PROC RETURNS [ROPE] = {
RETURN[ropeProfile];
};

SetRopeProfile: PUBLIC PROC [rope: ROPE Ź NIL] = {
ropeProfile Ź rope;
ProfileChangedInternal[edit, FALSE];
};


RegisterGuestProcs: PUBLIC PROC [newProcs: REF UserProfileBackdoor.GuestProcsRec] = {
GuestProcs Ź newProcs;
IsGuestProcess Ź newProcs.IsGuestProcess;
};
FalseProc: PROC RETURNS [isGuest: BOOL] = { 
isGuest Ź FALSE;
};

<< Until something like the Booting interface comes along for PCedar 
CheckpointWatcher: ENTRY Booting.CheckpointProc ~ {
ENABLE UNWIND => {errorLog Ź NIL; NULL};
IF errorLog # NIL THEN {
errorLog.Close[];
errorLog Ź NIL;
};
};>>

<< Until threads and filing come along for PCedar
ProfileWatcher: PROC ~ {
FOR event: REF READONLY FSBackdoor.CreateEvent Ź 
FSBackdoor.NextCreateEvent[NIL], FSBackdoor.NextCreateEvent[event] DO
fileName: ROPE ~ event.fName;
bang: INT ~ Rope.SkipTo[s: fileName, skip: "!"];
FOR list: LIST OF ROPE Ź profileNameList, list.rest UNTIL list=NIL DO
run: INT ~ Rope.Run[s1: fileName, s2: list.first, case: FALSE];
IF run>bang THEN { ProfileChanged[edit]; EXIT };
ENDLOOP;
ENDLOOP;
}; >>

ParseProfileCommand: Commander.CommandProc ~ {
ProfileChanged[edit]
};

NotePerLogin: Commander.CommandProc ~ {
line: ROPE Ź Line["CommandTool.PerLogin", NIL];
IF line # NIL THEN [] Ź CommanderOps.DoCommand[line, cmd];
};

NoteNewUser: Commander.CommandProc ~ {
line: ROPE Ź Line["CommandTool.NewUser", NIL];
IF line # NIL THEN [] Ź CommanderOps.DoCommand[line, cmd];
};

NotePerCommandTool: Commander.CommandProc ~ {
line: ROPE Ź Line["CommandTool.PerCommandTool", NIL];
IF line # NIL THEN [] Ź CommanderOps.DoCommand[line, cmd];
};

NoteBootCommands: Commander.CommandProc ~ {
line: ROPE Ź Line["CommandTool.BootCommands", NIL];
IF line # NIL THEN [] Ź CommanderOps.DoCommand[line, cmd];
};

GetProfileEntryAsRope: Commander.CommandProc = {
key: ROPE = CommanderOps.NextArgument[cmd];
IF key = NIL THEN RETURN;
cmd.out.PutF["ProfileEntryAsRope: key: %g, value: %g\n",
[rope[key]], [rope[Line[key, NIL]]] ];
};

SetFileNameForUserProfile: ENTRY Commander.CommandProc ~ {
userSetProfileName Ź CommanderOps.NextArgument[cmd];
};

partialRopeProfile: ROPE Ź NIL;

SetProfileEntry: Commander.CommandProc = {
partialRopeProfile Ź Rope.Concat[partialRopeProfile, cmd.commandLine];
};

UpdateProfileEntries: Commander.CommandProc = {
SetRopeProfile[Rope.Cat[GetRopeProfile[], partialRopeProfile, cmd.commandLine]];
partialRopeProfile Ź NIL;
};

UndoProfileChanges: Commander.CommandProc = {
SetRopeProfile[partialRopeProfile Ź NIL];
};

PrintProfileChanges: Commander.CommandProc = {
cmd.out.PutRope[ GetRopeProfile[] ];
};


Commander.Register["NoteBootCommands", NoteBootCommands, "Executes CommandTool.NoteBootCommands commands"];

Commander.Register["NoteNewUser", NoteNewUser, "Executes CommandTool.NoteNewUser commands"];

Commander.Register["NotePerCommandTool", NotePerCommandTool, "Executes CommandTool.NotePerCommandTool commands"];

Commander.Register["NotePerLogin", NotePerLogin, "Executes CommandTool.PerLogin commands"];

Commander.Register["GetProfileEntryAsRope", GetProfileEntryAsRope, "Prints the rope value of the asked for profile entry"];

Commander.Register["PrintProfileChanges", PrintProfileChanges, "Print the entries that are currently layered over existing profile entries."];

Commander.Register["ProfileChanged", ParseProfileCommand, "Same as UserProfile.ProfileChanged[edit]"];

Commander.Register["SetFileNameForUserProfile", SetFileNameForUserProfile, "Tells UserProfile a specific file to use - no checking done"];

Commander.Register["SetProfileEntry", SetProfileEntry, "Reads a new value for the indicated profile entry.  Syntax is identical to UserProfile, don't forget the ': following the key.  NOTE: this will not take effect until the command UpdateProfileEntries is executed."];

Commander.Register["UndoProfileChanges", UndoProfileChanges, "Resets all UserProfile entries to their file specified values."];

Commander.Register["UpdateProfileEntries", UpdateProfileEntries, "Causes SetProfileEntry commands to take effect."];


ProfileChanged[firstTime];
--Booting.RegisterProcs[c: CheckpointWatcher];
--TRUSTED { Process.Detach[FORK ProfileWatcher] };

END.

   ě  
UserProfileImpl.mesa
Copyright Ó 1984, 1985, 1986, 1987, 1990, 1991 by Xerox Corporation.  All rights reserved.
Bob Hagmann May 22, 1985 4:50:10 pm PDT
Russ Atkinson (RRA) July 3, 1985 8:40:09 am PDT
Hal Murray, January 14, 1986 4:22:44 am PST
Doug Wyatt, June 10, 1987 5:09:27 pm PDT
Eric Nickell, October 29, 1987 1:34:17 pm PST
Wes Irish, May 3, 1988 12:15:48 pm PDT
Andy Litman August 12, 1988 1:33:08 am PDT
JKF October 26, 1988 7:35:02 am PDT
Michael Plass, November 22, 1991 5:27 pm PST
Willie-s, June 9, 1993 12:29 pm PDT
Chauser, November 6, 1991 4:40 pm PST
Swen Johnson, May 2, 1992 6:48 pm PDT
Christian Jacobi, October 30, 1992 10:20 am PST

Types


Variables

Accessing profile

Utillity PROCs


Building profileList
--Parse machine profile, if any, for machine-dependent stuff
--The presence of "Server.profile" overrides a user's profile (for use by servers).
--Try explicitely set profile.
--Try for user's personal profile.
--Use the default profile (if any).
Given an open stream, parse the profile and close the stream.  Successive calls "overwrite" previous entries.
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
': => [] _ stream.GetChar[];  -- flush the ':
key was NOT followed by ':, so flush to the end of line and report the error

Reporting errors

When the profile changes
Note that registration order is important; procs must be called in the same order in which they were registered (otherwise deadlocks may occur at rollback time).
RopeProfile Interface

Exported to UserProfileBackdoor
default IsGuestProcess (not really exported)

Watching for profile changes

Commander commands
Notice that this necessarily includes the CR.  Also notice that this won't take effect until UpdateProfileEntries.
******** Main program ********


Bob Hagmann May 3, 1985 11:38:36 am PDT
changes to: DIRECTORY, UserProfileImpl, Boolean, Number, CallWhenProfileChanges, ProfileChanged, FalseProc

Russ Atkinson (RRA) May 13, 1985 4:33:37 pm PDT
Eliminated UserCredentials change watcher (InstallerImpl has this responsibility), UserProfileImpl

Bob Hagmann May 22, 1985 4:50:11 pm PDT
changes to: Token, ListOfTokens, Line, GetProfileName, UserProfileImpl, ProfileList, ProfileEntry, ProfileRecord, ProfileChangedItem, IsGuestProcess, Boolean, Number, Lookup, LookupInternal, GetRope, profileList, profileName, ParseProfile, ParseProfileInternal, SkipWhite (local of ParseProfileInternal), LocalToken (local of ParseProfileInternal), Report, ReportInternal, GetErrorLog, errorLog, profileChangedList, CallWhenProfileChanges, ProfileChanged, DoIt, AcquireList, ReleaseList, RegisterGuestProcs, FalseProc

Christian Jacobi, October 23, 1987 11:56:16 am PDT
changes: Added checkpoint watcher to close log file.

Eric Nickell, October 29, 1987 1:32:19 pm PST
changes: Added ability to Include other profiles.  Allowed '< and '> placed after ': to mean to prepend and append tokens on the line to tokens previously stored under this key.

Wesley Irish, April 29, 1988 4:15:47 pm PDT
changes: Added RopeProfile feature.

Jim Foote, August 11, 1988 10:55:53 am PDT
changes: Ported to PCedar. Removed references to Booting until something like it shows up for PCedar. Removed references to the debugger volume, until we figure out what that means for PCedar. Removed references to threads and FSBackDoor.
 
Swen Johnson, May 2, 1992 6:48:10 pm PDT
Bug fix: code to open stream on Include file was unconditionally Cat'ing specified filename to directory name, even when specified filename was absolute.
changes to: ParseProfileInternal: Use PFS.AbsoluteName instead of PFSNames.Cat.

Christian Jacobi, October 30, 1992 10:12:04 am PST
changes: Added release version number to profile file names.  For compatibility not yet removed the old way.


 Ę Ö  (cedarcode) styleNewlineDelimiter
 codeK
ĎeOZK$Ďk'K/K(+K%(K*-K&&K*K#K,K#K%K%K/K 		K
KK
(K-KKKK		K&KK
K1BK+<K*K K ĐbnKI<K!(KK K K)K'K
MKK #K%%KKK 	K K<K KĎn
%3jK K K  	QKK
K"AKKK
"K
.K
0K8K
KK  	FKK
K!@KKK
"KK5K	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 K 
 9KKKK 
 DKFF.6K!)&9K+
IKK&9K,
JKKKK 
 	DK	6KK+JKK 
 .K'KJKK K K1KKKK	$KK 
 >KKKKKFKĎc(K	KK.K KQiK?TK?VK=UK K+FK-K/K.K  	fKKK"'
cK	
7K&K5KKKK K<6<K7KSK5CK8FK K$=K"K3AK6DK#K6DK9GK !KK!K		KĄ=K$KKK(KKĄ(:KK..KK  
YKmmKKK 	@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 9K<K 
JK*K1KKK	!K
KK!KK!KĄ',KKKĄMKKĄ-KALK
"K
=KK8NKKK	KK	KKK!%KStartOfExpansion-[s1: ROPE, s2: ROPE, case: BOOL _ TRUE]Ą>K<KĘ[fileName: ROPE, accessOptions: FS.AccessOptions _ read, streamOptions: FS.StreamOptions _ (3)[TRUE, TRUE, TRUE], keep: CARDINAL _ 1B (1), createByteCount: FS.ByteCount _ 2560, streamBufferParms: FS.StreamBufferParms _ [vmPagesPerBuffer: 8, nBuffers: 2], extendFileProc: FS.ExtendFileProc, wantedCreatedTime: GMT _ nullGMT, remoteCheck: BOOL _ TRUE, wDir: ROPE _ NIL, checkFileType: BOOL _ FALSE, fileType: FS.FileType _ [0B (0)]]KĘ[fileName: ROPE, accessOptions: FS.AccessOptions _ read, streamOptions: FS.StreamOptions _ (3)[TRUE, TRUE, TRUE], keep: CARDINAL _ 1B (1), createByteCount: FS.ByteCount _ 2560, streamBufferParms: FS.StreamBufferParms _ [vmPagesPerBuffer: 8, nBuffers: 2], extendFileProc: FS.ExtendFileProc, wantedCreatedTime: GMT _ nullGMT, remoteCheck: BOOL _ TRUE, wDir: ROPE _ NIL, checkFileType: BOOL _ FALSE, fileType: FS.FileType _ [0B (0)]]/
$BK1;K[format: ROPE _ NIL, v1: IO.Value _ [null[]], v2: IO.Value _ [null[]], v3: IO.Value _ [null[]], v4: IO.Value _ [null[]], v5: IO.Value _ [null[]]]KKKKĄ
K22K22	?KKELKKAWKKKKK K 
 =KKKK K	!8KK 
 HK)K	I		K)FKĄ/K\\KK'	KMMKKK  AK*KKK  
(KKK  3K3şK KK  EK	*UKKKKK K
K KĄK K5K9K  	4K	4K%eKKK  =K-4VK	9K3KKKKK  +N(@K"Ą5KKK//KKK  .IK33KK <hK":K*KI)EKKKKK  HRĄ%KKKKKK K 
.KKK 
2KK$KK K  'UIcode2L))LL,, 	,L
LL K K K"cedar" styleĎyEE"cedar" styleĐny˘Đky˘3K
¤˘¤˘˘¤˘¤˘(¤˘¤˘¤˘K˘K˘	˘¤˘K˘K"cedar" style˘K"cedar" style K"cedar" style˘11Ł˘¤˘¤˘¤˘¤˘˘¤˘%¤wK˘
¤˘K˘¤˘'0¤˘¤˘¤˘¤˘˘¤˘¤˘¤EK˘¤˘0¤˘?K¤˘
¤˘¤˘0K¤˘K¤˘K˘K  .K"cedar" styleK"cedar" styleK"cedar" style Ďb'K"cedar" style /K"cedar" style(:K"cedar" styleK"cedar" style Ľ&K"cedar" style.K"cedar" style(:K"cedar" styleK"cedar" style Ľ-K"cedar" style&5K"cedar" style(:K"cedar" styleK"cedar" style Ľ+K"cedar" style$3K"cedar" style(:K"cedar" styleK"cedar" style  0K"+KKV_KK  :K"cedar" style44K"cedar" styleK"cedar" style K  *FFK*FrKK /KPPKKK -K$)KK .K$$K"cedar" style K"cedar" style K "cedar" stylekkK"cedar" style "cedar" style\\K"cedar" style "cedar" styleqqK"cedar" style "cedar" style[[K"cedar" style {K K "cedar" styleffK"cedar" style "cedar" styleK"cedar" style K K Ktt"cedar" style K"cedar" style K"cedar" styleK"cedar" style..K	2K K KK $'KĐkr	ĎrUjK /KQ§bK Ďi$Đik'K¨Đir¨ Ş¨ ŞŞK /2K44K *-KĎoąK (+K##K *KîîKĽ(K Ť§UK§§§OK 2KlK K      Db  t$  