
DIRECTORY
PFS USING [Error, PathFromRope, StreamOpen],
Profiles,
ProfilesBackdoor,
ProfilesPrivate USING [ProfileChangedItem, ProfileRep],
Convert USING [IntFromRope],
IO,
Rope USING [ROPE, Cat, Concat, Equal, Index, Match, Substr],
RuntimeError USING [UNCAUGHT],
SymTab USING [Create, EachPairAction, Fetch, Pairs, Ref, Store];


ProfilesImpl: CEDAR MONITOR
IMPORTS Convert, IO, PFS, Rope, RuntimeError, SymTab--, UXIO--
EXPORTS Profiles, ProfilesBackdoor 
= BEGIN
OPEN Profiles, ProfilesBackdoor;
profileDir: ROPE м NIL;
freshProfiles: LIST OF Profile м NIL;

Profile: PUBLIC TYPE ~ REF ProfileRep;
ProfileRep: PUBLIC TYPE ~ ProfilesPrivate.ProfileRep;
ProfileChangedItem: TYPE ~ ProfilesPrivate.ProfileChangedItem;

Create: PUBLIC PROC [files: LIST OF ROPE, keepFresh: BOOL м TRUE] RETURNS [profile: Profile] ~ {
SlicesFromFileNames: PROC [files: LIST OF ROPE] RETURNS [slices: LIST OF Slice] ~ {
dummy: LIST OF Slice ~ LIST[[rope[NIL]]];
tail: LIST OF Slice м dummy;
FOR each: LIST OF ROPE м files, each.rest UNTIL each=NIL DO
tail м (tail.rest м LIST[[file[fileName: each.first]]]);
ENDLOOP;
RETURN [dummy.rest];
};
profile м NEW[ProfileRep м [
entries: NIL,		--Set by ParseProfile
filesUsed: SymTab.Create[case: FALSE],
slices: SlicesFromFileNames[files],
keepFresh: keepFresh
]];
ParseProfile[profile];
IF keepFresh THEN freshProfiles м CONS[profile, freshProfiles];
};
CreateFromRope: PUBLIC PROC [slices: LIST OF ROPE] RETURNS [profile: Profile] ~ {
SlicesFromRopes: PROC [slices: LIST OF ROPE] RETURNS [LIST OF Slice] ~ {
dummy: LIST OF Slice ~ LIST[[rope[NIL]]];
tail: LIST OF Slice м dummy;
FOR each: LIST OF ROPE м slices, each.rest UNTIL each=NIL DO
tail м (tail.rest м LIST[[rope[each.first]]]);
ENDLOOP;
RETURN [dummy.rest];
};
profile м NEW[ProfileRep м [
entries: NIL,		--Set by ParseProfile
filesUsed: SymTab.Create[case: FALSE],
slices: SlicesFromRopes[slices],
keepFresh: FALSE
]];
ParseProfile[profile];
};
CreateFromSlices: PUBLIC PROC [slices: LIST OF Slice, keepFresh: BOOL м TRUE] RETURNS [profile: Profile] ~ {
profile м NEW[ProfileRep м [
entries: NIL,		--Set by ParseProfile
filesUsed: SymTab.Create[case: FALSE],
slices: slices,
keepFresh: keepFresh
]];
ParseProfile[profile];
IF keepFresh THEN freshProfiles м CONS[profile, freshProfiles];
};
LetProfileGetStale: PUBLIC ENTRY PROC [profile: Profile] ~ {
IF profile.keepFresh THEN {
dummy: LIST OF Profile м CONS[NIL, freshProfiles];
FOR each: LIST OF Profile м dummy, each.rest DO	--Addr fault => ERROR
IF each.rest.first=profile THEN {
each.rest м each.rest.rest;
EXIT;
};
ENDLOOP;
profile.keepFresh м FALSE;
};
};

Boolean: PUBLIC PROC [profile: Profile, key: ROPE, default: BOOL м FALSE] RETURNS [value: BOOL] = {
entry: ProfileEntry;
val: ROPE;
entry м Lookup[profile, 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 [profile: Profile, key: ROPE, default: INT] RETURNS [value: INT] = {
entry: ProfileEntry м Lookup[profile, key];
val: ROPE м 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 [profile: Profile, key: ROPE, default: ROPE] RETURNS [value: ROPE] = {
entry: ProfileEntry м Lookup[profile, key];
val: ROPE м GetRope[entry];
IF val = NIL THEN RETURN [default];
value м  val;
};

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

Line: PUBLIC PROC [profile: Profile, key: ROPE, default: ROPE] RETURNS [value: ROPE] = {
entry: ProfileEntry м Lookup[profile, 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;
};

EnumerateKeys: PUBLIC PROC [profile: Profile, pattern: ROPE, proc: EnumProc] ~ {
Enum: SymTab.EachPairAction = {
IF Rope.Match[pattern: pattern, object: key, case: FALSE] THEN RETURN [proc[key]];
};
[] м SymTab.Pairs[x: profile.entries, action: Enum];
};

HasEntry: PUBLIC ENTRY PROC [profile: Profile, key: ROPE] RETURNS [BOOL] ~ {
ENABLE UNWIND => NULL;
RETURN [FetchInternal[profile, key].found];
};

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

LookupInternal: INTERNAL PROC [profile: Profile, key: ROPE] RETURNS [ProfileEntry] = {
RETURN [NARROW[FetchInternal[profile, key].val]];
};

FetchInternal: INTERNAL PROC [profile: Profile, key: ROPE] RETURNS [found: BOOL, val: REF ANY] ~ {
[found: found, val: val] м SymTab.Fetch[x: profile.entries, key: key];
};

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"];
};

GetProfileSlices: PUBLIC PROC [profile: Profile] RETURNS [LIST OF Slice] = {
RETURN [profile.slices];
};

GetProfileNames: PUBLIC PROC [profile: Profile] RETURNS [LIST OF ROPE] = {
dummy: LIST OF ROPE ~ LIST[NIL];
tail: LIST OF ROPE м dummy;
FOR each: LIST OF Slice м profile.slices, each.rest UNTIL each=NIL DO
WITH each.first SELECT FROM
fileSlice: Slice.file => tail м (tail.rest м LIST[fileSlice.fileName]);
ENDCASE;
ENDLOOP;
RETURN [dummy.rest];
};


NoVersion: PROC [file: ROPE] RETURNS [ROPE] ~ {
RETURN [Rope.Substr[base: file, len: Rope.Index[s1: file, s2: "!"]]];
};

ParseProfile: ENTRY PROC [profile: Profile] ~ {
ENABLE UNWIND => NULL;
TryProfile: INTERNAL PROC [slice: Slice] ~ {
stream: IO.STREAM м NIL;
WITH slice SELECT FROM
slice: Slice.rope => stream м IO.RIS[rope: slice.text];
slice: Slice.file => {
profileName: ROPE м Rope.Concat[profileDir, slice.fileName];
stream м PFS.StreamOpen[fileName: PFS.PathFromRope[profileName], accessOptions: read ! PFS.Error => CONTINUE];
IF stream = NIL THEN RETURN;
[] м SymTab.Store[x: profile.filesUsed, key: profileName, val: $Parent];
};
ENDCASE => ERROR;
ParseProfileInternal[profile, stream];
};
profile.entries м SymTab.Create[case: FALSE];
profile.filesUsed м SymTab.Create[case: FALSE];
FOR each: LIST OF Slice м profile.slices, each.rest UNTIL each=NIL DO
TryProfile[each.first];
ENDLOOP;
};

ParseProfileInternal: INTERNAL PROC [profile: Profile, stream: IO.STREAM] ~ {
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,
IO.LF, IO.CR, ': => 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[profile, key];
RETURN [IF entry=NIL THEN NIL ELSE entry.tokens];
};
token: ROPE м NIL;
tokens, tail: LIST OF ROPE м NIL;
position: INT м 0;
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 => {
DO
SELECT stream.GetChar[ ! IO.EndOfStream => EXIT] FROM
'\n, '\r, '\l => EXIT;
ENDCASE;
ENDLOOP;
ReportInternal[msg: IO.PutFR1["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 key.Equal["Include", FALSE] THEN {	--Insert a profile slice
FOR each: LIST OF ROPE м tokens, each.rest UNTIL each=NIL DO
profileSlice: IO.STREAM м NIL;
profileName: ROPE м Rope.Concat[profileDir, each.first];
profileSlice м PFS.StreamOpen[PFS.PathFromRope[profileName], read ! PFS.Error => CONTINUE];
IF profileSlice # NIL
THEN {
[] м SymTab.Store[x: profile.filesUsed, key: profileName, val: $Child];
ParseProfileInternal[profile, profileSlice];
}
ELSE ReportInternal[
entry: NEW[ProfileRecord м [each.first, tokens, position]],
msg: "File 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 LookupInternal[profile, key] # NIL THEN
ReportInternal[
entry: LookupInternal[profile, key],
msg: IO.PutFR["%g also appears at [%d]", [rope[key]], [integer[position]]]
];
[] м SymTab.Store[x: profile.entries, key: key, val: NEW[ProfileRecord м [key, tokens, position]]]
};
ENDLOOP;
IO.Close[stream];
};

Error: PUBLIC ERROR [reason: ROPE] ~ CODE;
Report: PUBLIC 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;
msg м IO.PutFR1["\n\n%g", [rope[msg]]];
IF entry#NIL THEN msg м IO.PutFLR["%g, at %g [%d]", LIST[[rope[msg]], [rope[entry.key]], [integer[entry.position]]]];
Error[msg];
};

ProfileChangeList: TYPE ~ LIST OF ProfileChangedItem;

AddToList: ENTRY PROC [profile: Profile, item: ProfileChangedItem] ~ {
dummy: ProfileChangeList м CONS[[NIL, NIL], profile.changeWatchers];
FOR each: ProfileChangeList м dummy, each.rest DO
IF each.rest=NIL THEN {each.restмLIST[item]; EXIT};	--Append to end
ENDLOOP;
profile.changeWatchers м dummy.rest;
};

CopyList: ENTRY PROC [toCopy: LIST OF ProfileChangedItem] RETURNS [LIST OF ProfileChangedItem] ~ {
RETURN [IF toCopy=NIL THEN NIL ELSE CONS[toCopy.first, CopyList[toCopy.rest]]];
};

CallWhenProfileChanges: PUBLIC PROC [profile: Profile, proc: Profiles.ProfileChangedProc, clientData: REF] = {
item: ProfileChangedItem ~ [proc, clientData];
IF profile.keepFresh THEN AddToList[profile, item];
DoIt[profile, item, firstTime];
};

ProfileChanged: PUBLIC ProfileChangedProc = {
ParseProfile[profile: profile ! RuntimeError.UNCAUGHT => CONTINUE];
FOR each: ProfileChangeList м CopyList[profile.changeWatchers], each.rest UNTIL each=NIL DO
DoIt[profile, each.first, reason];
ENDLOOP;
};

DoIt: PROC [profile: Profile, item: ProfileChangedItem, reason: Profiles.ProfileChangeReason] = {
item.proc[
profile: profile,
reason: reason,
clientData: item.clientData
! RuntimeError.UNCAUGHT => {
Report[msg: "Problem while executing ProfileChangedProc"];
CONTINUE
}
];
};


END.
  Ь  
ProfilesImpl.mesa
Copyright ╙ 1984, 1985, 1986, 1987, 1988, 1991 by Xerox Corporation.  All rights reserved.
Bob Hagmann May 22, 1985 4:50:10 pm PDT
Russ Atkinson (RRA) November 28, 1988 10:48:34 pm PST
Hal Murray, January 14, 1986 4:22:44 am PST
Doug Wyatt, June 10, 1987 5:09:27 pm PDT
Eric Nickell, May 17, 1988 4:47:12 pm PDT
Bob Coleman, August 29, 1989 12:44:50 pm PDT
Dave Rumph, January 8, 1990 12:02:55 pm PST
Michael Plass, November 25, 1991 11:28 am PST
UXIO USING [CreateFileStream, Error];


Global Data
Creating the Profile
Parses a set of profile files and returns the data structure which can be used to access the values.

Parses a set of profile files and returns the data structure which can be used to access the values.
IF keepFresh THEN freshProfiles _ CONS[profile, freshProfiles];	--Always FALSE

Parses a set of profile files and returns the data structure which can be used to access the values.


Accessing profile

[key: ROPE, val: SymTab.Val] RETURNS [quit: BOOL _ FALSE]

Building profileList
stream _ UXIO.CreateFileStream[profileName, read ! UXIO.Error => CONTINUE];
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
key was NOT followed by ':, so flush to the end of line and report the error
profileSlice _ UXIO.CreateFileStream[profileName, read ! UXIO.Error => CONTINUE];

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).

 Э╩U  Ц(cedarcode) styleХNewlineDelimiter
Щ codeЪ╧cЩKЪЬ
╧eЬOЩZKЩ'KЩ5KЪ╧y+Щ+KЩ(KЩ)KЩ,KЩ+KЩ-ЧШ Ъ╧k	Ш	KЪЬаЬ#Ш,KШ	KШKЪЬаЬ"Ш7KЪЬаЬШKЪаЬШKЪЬаЬаЬ,Ш<KЪЬаЬаЬШKЪЬаЬ4Ш@KЪаЬаЬЩ%KШ ЧЧKШ Ъ╧bЬаЬаШKЪаЬ
аЬаЬЭ
Ш>KЪаЬШ#KЪЬаШKЪаЬШ KЩ ЧKЩ ЩKЪЬаЬаЬШKЪЬаЬаЬаЬШ%KШ ЧЩKЪЬ	аЬаЬаЬШ&KЪЬаЬаЬШ5KЪЬаЬ&Ш>KШ Ъ╧nЬаЬаЬ	аЬаЬаЬаЬаЬаЬШ`KЩdЪвЬаЬ	аЬаЬаЬаЬ
аЬаЬШSKЪ	ЬаЬаЬ	аЬаЬШ)KЪЬаЬаЬШЪаЬаЬаЬаЬаЬаЬаШ;KЪЬаЬ Ш8KЪаЬШЧKЪаЬШKШЧЪЬ
аЬШKЪЬ	аЬЭШ$KХStartOfExpansion&[mod: NAT _ 17, case: BOOL _ TRUE]ЪЬаЬШ&KЪЬ#Ш#KШKЪЬШЧKШKЪаЬаЬаЬШ?KЪЬШKЩ ЧЪвЬаЬаЬ
аЬаЬаЬаЬШQKЩdЪвЬаЬ
аЬаЬаЬаЬаЬаЬШHKЪ	ЬаЬаЬ	аЬаЬШ)KЪЬаЬаЬШЪаЬаЬаЬаЬаЬаЬаШ<KЪЬаЬШ.KЪаЬШЧKЪаЬШKШЧЪЬ
аЬШKЪЬ	аЬЭШ$KЦ&[mod: NAT _ 17, case: BOOL _ TRUE]ЪЬаЬШ&KЪЬ Ш KЪЬаШKЪЬШЧKШKЪаЬаЬаЬаЩNKЪЬШKЩ ЧЪвЬаЬаЬ
аЬаЬаЬаЬаЬШlKЩdЪЬ
аЬШKЪЬ	аЬЭШ$KЦ&[mod: NAT _ 17, case: BOOL _ TRUE]ЪЬаЬШ&KЪЬШKШKЪЬШЧKШKЪаЬаЬаЬШ?KЪЬШKЩ ЧЪвЬаЬаЬаЬШ<ЪаЬаЬШKЪ	ЬаЬаЬаЬаЬШ2Ъ	аЬаЬаЬаЬЭШEЪаЬаЬШ!KШKЪаЬШKЪЬШЧKЪаЬШЧKЪЬаЬШKЪЬШЧKШKШ ЧKЩ ЧЩKЩ ЪвЬаЬаЬаЬаЬаЬаЬ	аЬШcKШKЪЬаЬШ
KШKЪЬШKЪаЬаЬаЬаЬШ#KЪ
аЬаЬаЬаЬаЬШ/KЪ
аЬаЬаЬаЬаЬШ1KШ/KЪаЬШKШKШ ЧЪвЬаЬаЬаЬаЬаЬ	аЬШXKШ+KЪЬаЬШKЪаЬаЬаЬаЬШ#ЪЬШЪЬаЬШKЪЬШKШ,KЪаЬШ	KЪЬШЧKЪЬШЧKШЧKШ ЪвЬаЬаЬаЬаЬаЬ	аЬШYKШ+KЪЬаЬШKЪаЬаЬаЬаЬ
Ш#KШKШKШ ЧЪвЬаЬаЬаЬаЬаЬаЬаЬ	аЬаЬаЬШpKШ+KЪаЬ	аЬаЬаЬаЬаЬШ@KШKШ ЧЪвЬаЬаЬаЬаЬаЬ	аЬШXKШ+KЪаЬ	аЬаЬаЬШ%ЪаЬаЬаЬаЬаЬаЬаШ;KЪаЬ	аЬаЬаШ(KШ KЪаЬШЧKШKШ ЧЪвЬаЬаЬШPЦ= -- [key: ROPE, val: SymTab.Val] RETURNS [quit: BOOL _ FALSE]ЪвЬШKЪ╨ck9Щ9KЦ6[pattern: ROPE, object: ROPE, case: BOOL _ TRUE]ЪаЬ1аЬаЬаЬШRKШЧKЦ2[x: SymTab.Ref, action: SymTab.EachPairAction]Ш4KШKШ ЧЪвЬаЬаЬаЬаЬаЬаЬШLKЪаЬаЬаЬШKЪаЬ%Ш+KШKШ ЧЪвЬаЬаЬаЬаЬаЬШRKЪаЬаЬаЬШKЪаЬШ%KЪЬШKШ ЧЪ
вЬаЬаЬаЬаЬШVKЪаЬаЬ#Ш1KШKШ ЧЪвЬаЬаЬаЬ	аЬаЬаЬШbKЦ[x: SymTab.Ref, key: ROPE]ЪЬFШFKШKШ ЧЪ
вЬаЬаЬ	аЬаЬШDKЪаЬ	аЬаЬаЬаЬаЬаЬШ7KШKЪаЬаЬаЬ)ШHKШKШ ЧЪвЬаЬаЬаЬаЬаЬШLKЪаЬШKЪЬШKШ ЧЪвЬаЬаЬаЬаЬаЬаЬШJKЪЬаЬаЬаЬаЬаЬШ KЪЬаЬаЬаЬ	ШЪаЬаЬаЬ#аЬаЬаШEЪаЬаЬаШKЪЬ-аЬШGKЪаЬШЧKЪаЬШЧKЪаЬШKЪЬШKШ ЧKЩ ЧЩШ KШ ЧЪ
в	ЬаЬаЬаЬаЬШ/KЦ>[s1: ROPE, s2: ROPE, pos1: INT _ 0, case: BOOL _ TRUE]ЪаЬ?ШEKШKШ ЧЪвЬаЬаЬШ/KЪаЬаЬаЬШЪв
ЬаЬаЬШ,KЪЬаЬаЬаЬШЪаЬаЬаШKЦ)[rope: ROPE, oldStream: STREAM _ NIL]ЪЬаЬаЬШ7ЪЬШKЪЬаЬ+Ш<KЪЬ	аЬ&аЬ
аЬЩKKЪ	Ь	аЬаЬ2аЬ
аЬШnKЪаЬ
аЬаЬаЬШKЦ1[x: SymTab.Ref, key: ROPE, val: SymTab.Val]ШHKЪЬШЧKЪаЬаЬШЧKЪЬ&Ш&KШЧKЦ&[mod: NAT _ 17, case: BOOL _ TRUE]ЪЬ&аЬШ-KЦ&[mod: NAT _ 17, case: BOOL _ TRUE]ЪЬ(аЬШ/ЪаЬаЬаЬ#аЬаЬаШEKШKЪаЬШЧKШKШ ЧЪ
вЬаЬаЬаЬаЬШMKЪЬ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Ш3KЪаЬаЬаЬаЬаЬаЬШ1KШЧKЪЬаЬаЬШKЪ	ЬаЬаЬаЬаЬШ!KЪЬ
аЬШKЪЬаЬаЬШKШ!KЪЬаЬШKЪаЬаЬаЬаЬШ!ЪаЬаШЪЬШKЪЬЭШ'ЪаЬаЬаШ,KЪЬШKЪЬШKЪаЬаЬЭШMЧKЪЬШЧЪаЬШKЪЬLЩLЪаШЪаЬаЬаЬаШ5KЪЬаЬШKЪаЬШЧKЪаЬШЧKЪЬаЬаЬШFKЪаЬШKЪЬШЧЧЪаШKЪ	ЬаЬаЬаЬаЬШKЪЬШKЪаЬ	аЬаЬаЬШKЪЬаЬШЪаЬаШKЪаЬШKЪаЬ!Ш%ЧKЪаЬШЧЦ-[s1: ROPE, s2: ROPE, case: BOOL _ TRUE]ЪаЬаЬаЬЭШ>ЪаЬаЬаЬаЬаЬаЬаШ<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ЪЬаЬ'Ш8KЪЬаЬ&аЬ
аЬЩQKЪ	ЬаЬаЬ#аЬ
аЬШ[ЪаЬаШЪаЬШKЪЬGШGKЪЬ,Ш,KЪЬШЧЪаЬШ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ЪЬ2Ш2KЪЬ2Ш2ЪаЬаЬ аЬаШ5ЪЬШKЪЬ$Ш$KЪЬаЬCШJKЪЬШЧЧЧKЦ1[x: SymTab.Ref, key: ROPE, val: SymTab.Val]ЪЬ5аЬ*ШbKЪЬШЧKЪаЬШЧKЪаЬШKЪЬШЧЧKЩ ЩKШ KЪ
вЬаЬаЬ
аЬаЬШ*ЪвЬаЬаЬаЬаЬаЬШDKЪаЬаЬаЬШKЪЬШKЪЬШЧKШ Ъ
вЬаЬаЬаЬаЬШHKЪаЬаЬаЬШ)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ЦЭ[format: ROPE _ NIL, v1: IO.Value _ [null[]], v2: IO.Value _ [null[]], v3: IO.Value _ [null[]], v4: IO.Value _ [null[]], v5: IO.Value _ [null[]]]Ъ
аЬаЬаЬаЬаЬ=ШuKШKЪЬШЧЧKЩ ЪЬЩKЩбKШ KЪЬаЬаЬаЬШ5KШ Ъв	ЬаЬаЬ1ШFKЪЬаЬаЬаЬШDЪаЬ,аШ1KЪаЬаЬаЬаЬаЬЭШCKЪаЬШЧKЪЬ$Ш$KШKШ ЧЪвЬаЬаЬ
аЬаЬаЬаЬаЬШbKЪаЬаЬаЬаЬаЬаЬаЬ'ШOKШKШ ЧЪвЬаЬаЬCаЬШnKЪЬ.Ш.KЪаЬаЬШ3KЪЬШKШЧKШ ЪвЬаЬШ-KЪЬ-аЬаЬШCЪаЬGаЬаЬаШ[KШ"KЪаЬШЧKШЧKШ ЪвЬаЬWШaЪЬ
Ш
KШKШKШЪЬаЬШKЪЬ:Ш:KЪаШKЪЬШЧKЪЬШЧKЪЬШЧKШ ЧKШ KЪаЬШKЩ Ч ЕЧ    -D  M5  