DIRECTORY
Ascii USING [CR, LF, SP, TAB],
Basics,
BasicTime,
Commander USING [CommandProc, Handle, Register],
CommandTool USING [DoCommand],
FS,
FileNames,
Interpreter,
IO,
SymTab,
RefText,
TiogaAccess,
List,
Rope;


UsingDependenciesImpl: CEDAR PROGRAM
IMPORTS BasicTime, IO, FS, FileNames, Commander, CommandTool, Interpreter, RefText, Rope, List, TiogaAccess, SymTab
~ BEGIN

ROPE: TYPE ~ Rope.ROPE;

Scanner: TYPE ~ REF ScannerRep;
ScannerRep: TYPE ~ RECORD [
stream: IO.STREAM,
tokenKind: Kind,
inputBuffer: REF TEXT,
locationOfBufferStart: INT,
tokenStart: NAT,
tokenLength: NAT
];

inputBufferSize: NAT _ 2*1024;
CreateScanner: PROC RETURNS [scanner: Scanner] ~ {
scanner _ NEW[ScannerRep];
scanner.inputBuffer _ NEW[TEXT[inputBufferSize]];
};

SetScanner: PROC [scanner: Scanner, stream: IO.STREAM] ~ {
scanner.stream _ stream;
scanner.tokenKind _ whitespace;
scanner.locationOfBufferStart _ IO.GetIndex[stream];
scanner.tokenStart _ 0;
scanner.tokenLength _ 0;
scanner.inputBuffer.length _ 0;
};

Kind: TYPE ~ {identifier, special, charconst, string, whitespace, newline, comment, eof};
KindOf: PROC [c: CHAR] RETURNS [Kind] ~ {
SELECT c FROM
IN ['a..'z], IN ['A..'Z], IN ['0..'9], '$ => RETURN [identifier];
Ascii.SP, Ascii.TAB, Ascii.LF => RETURN [whitespace];
Ascii.CR => RETURN [newline];
ENDCASE => RETURN [special];
};

breakLoc: INT _ LAST[INT];
breakCount: INT _ 0;

GetCharConstant: PROC [scanner: Scanner] ~ {
IF scanner.tokenStart>=scanner.inputBuffer.length-10 THEN RefillBuffer[scanner];
scanner.tokenKind _ charconst;
scanner.tokenLength _ 2;
IF scanner.inputBuffer[scanner.tokenStart+1] = '\\ THEN {
IF scanner.inputBuffer[scanner.tokenStart+scanner.tokenLength] IN ['0..'7] THEN {
WHILE scanner.inputBuffer[scanner.tokenStart+scanner.tokenLength] IN ['0..'7] DO
scanner.tokenLength _ scanner.tokenLength + 1;
ENDLOOP;
}
ELSE scanner.tokenLength _ 3;
};
};

GetStringConstant: PROC [scanner: Scanner] ~ {
GetC: PROC ~ {
IF scanner.tokenStart+scanner.tokenLength>=scanner.inputBuffer.length-10 THEN RefillBuffer[scanner];
scanner.tokenLength _ scanner.tokenLength + 1;
IF scanner.inputBuffer[scanner.tokenStart+scanner.tokenLength] = '\\ THEN {
scanner.tokenLength _ scanner.tokenLength + 1;
IF scanner.inputBuffer[scanner.tokenStart+scanner.tokenLength] IN ['0..'7] THEN {
WHILE scanner.inputBuffer[scanner.tokenStart+scanner.tokenLength] IN ['0..'7] DO
scanner.tokenLength _ scanner.tokenLength + 1;
ENDLOOP;
}
ELSE scanner.tokenLength _ scanner.tokenLength + 1;
};
};
scanner.tokenLength _ 0;
GetC[];
UNTIL scanner.inputBuffer[scanner.tokenStart+scanner.tokenLength] = '" DO
GetC[];
ENDLOOP;
scanner.tokenLength _ scanner.tokenLength + 1;
scanner.tokenKind _ string;
};

GetComment: PROC [scanner: Scanner] ~ {
c: CHAR _ ' ; -- next char after the current end-of-token
cc: CHAR _ ' ; -- char after c
PeekCC: PROC ~ {
IF scanner.tokenStart+scanner.tokenLength+2>=scanner.inputBuffer.length THEN RefillBuffer[scanner];
c _ cc _ '\n;
IF scanner.tokenStart+scanner.tokenLength<scanner.inputBuffer.length THEN
c _ scanner.inputBuffer[scanner.tokenStart+scanner.tokenLength];
IF scanner.tokenStart+scanner.tokenLength+1<scanner.inputBuffer.length THEN
cc _ scanner.inputBuffer[scanner.tokenStart+scanner.tokenLength+1];
};
scanner.tokenLength _ 2;
PeekCC[];
UNTIL c = '\n OR (c = '- AND cc = '-) DO
scanner.tokenLength _ scanner.tokenLength + 1;
PeekCC[];
ENDLOOP;
IF (c = '- AND cc = '-) THEN scanner.tokenLength _ scanner.tokenLength + 2;
scanner.tokenKind _ comment;
};

GetToken: PROC [scanner: Scanner] ~ {
c: CHAR;
scanner.tokenStart _ scanner.tokenStart+scanner.tokenLength;
scanner.tokenLength _ 0;
IF scanner.tokenStart>=scanner.inputBuffer.length-1 THEN RefillBuffer[scanner];
IF scanner.inputBuffer.length = 0 THEN {scanner.tokenKind _ eof; RETURN};
c _ scanner.inputBuffer[scanner.tokenStart];
IF c = '' THEN {GetCharConstant[scanner]; RETURN};
IF c = '" THEN {GetStringConstant[scanner]; RETURN};
IF c = '- AND scanner.inputBuffer[scanner.tokenStart+1] = '- THEN {GetComment[scanner]; RETURN};
scanner.tokenKind _ KindOf[scanner.inputBuffer[scanner.tokenStart]];
IF scanner.tokenKind = special THEN {
scanner.tokenLength _ 1;
RETURN;
};
WHILE scanner.tokenStart+scanner.tokenLength<scanner.inputBuffer.length
AND KindOf[scanner.inputBuffer[scanner.tokenStart+scanner.tokenLength]] = scanner.tokenKind DO
IF scanner.locationOfBufferStart+scanner.tokenStart+scanner.tokenLength = breakLoc THEN breakCount _ breakCount + 1;
scanner.tokenLength _ scanner.tokenLength + 1;
IF scanner.tokenStart + scanner.tokenLength = scanner.inputBuffer.length THEN {
IF IO.EndOf[scanner.stream] THEN RETURN;
RefillBuffer[scanner];
};
ENDLOOP;
};

RefillBuffer: PROC [scanner: Scanner] = {
residual: NAT ~ scanner.inputBuffer.length-scanner.tokenStart;
FOR i: NAT IN [0..residual) DO
scanner.inputBuffer[i] _ scanner.inputBuffer[i+scanner.tokenStart];
ENDLOOP;
scanner.inputBuffer.length _ residual;
scanner.locationOfBufferStart _ scanner.locationOfBufferStart+scanner.tokenStart;
scanner.tokenStart _ 0;
[] _ scanner.stream.GetBlock[block: scanner.inputBuffer, startIndex: residual, count: scanner.inputBuffer.maxLength-residual];
};

Match: PROC [scanner: Scanner, key: REF READONLY TEXT] RETURNS [equal: BOOLEAN] = {
i: NAT _ scanner.tokenStart;
IF key.length # scanner.tokenLength THEN RETURN [FALSE];
FOR j: NAT IN [0..key.length) DO
IF key[j]#scanner.inputBuffer[i] THEN RETURN [FALSE];
i_i+1;
ENDLOOP;
RETURN [TRUE]
};

MatchRope: PROC [scanner: Scanner, key: ROPE] RETURNS [equal: BOOLEAN] = {
i: NAT _ scanner.tokenStart;
IF key.Length # scanner.tokenLength THEN RETURN [FALSE];
FOR j: NAT IN [0..scanner.tokenLength) DO
IF key.Fetch[j]#scanner.inputBuffer[i] THEN RETURN [FALSE];
i_i+1;
ENDLOOP;
RETURN [TRUE]
};

IDRope: PROC [scanner: Scanner] RETURNS [rope: ROPE] = {
i: INTEGER _ scanner.tokenStart-1;
p: PROC RETURNS [CHAR] ~ {RETURN [scanner.inputBuffer[i_i+1]]};
IF scanner.tokenKind # identifier THEN RaiseError[scanner];
RETURN [Rope.FromProc[scanner.tokenLength, p]];
};

AppendID: PROC [text: REF TEXT, scanner: Scanner] RETURNS [REF TEXT] = {
RETURN [RefText.Append[to: text, from: scanner.inputBuffer, start: scanner.tokenStart, len: scanner.tokenLength]]
};

Pair: TYPE ~ RECORD [
member: ROPE,
owner: ROPE
];

ParseError: ERROR [sourceLoc: INT] = CODE;

RaiseError: PROC [scanner: Scanner] = {
ParseError[scanner.locationOfBufferStart+scanner.tokenStart];
};

RecordDependencies: PROC [scanner: Scanner, stem: ROPE, cmd: Commander.Handle, symTab: SymTab.Ref] ~ {
GetTok: PROC ~ {
GetToken[scanner];
WHILE scanner.tokenKind = comment OR scanner.tokenKind = whitespace OR scanner.tokenKind = newline DO
GetToken[scanner];
ENDLOOP;
};
text: REF TEXT _ RefText.ObtainScratch[100];
GetTok[];
UNTIL scanner.tokenKind = eof OR Match[scanner, "DIRECTORY"] DO
GetToken[scanner];
ENDLOOP;
IF scanner.tokenKind = eof THEN RaiseError[scanner];
GetTok[];
IF scanner.tokenKind = special AND scanner.inputBuffer[scanner.tokenStart] = '. THEN NULL
ELSE {
UNTIL Match[scanner, ";"] DO
text.length _ 0;
text _ AppendID[text, scanner];
GetTok[];
IF Match[scanner, ":"] THEN {
GetTok[];
IF NOT Match[scanner, "FROM"] THEN RaiseError[scanner];
GetTok[];
IF scanner.tokenKind # string THEN RaiseError[scanner];
text.length _ 0;
text _ RefText.Append[to: text, from: scanner.inputBuffer, start: scanner.tokenStart+1, len: scanner.tokenLength-2];
GetTok[];
};
IF NOT Match[scanner, "USING"] THEN RaiseError[scanner];
GetTok[];
IF NOT Match[scanner, "["] THEN RaiseError[scanner];
GetTok[];
UNTIL Match[scanner, "]"] DO
savedLength: NAT _ text.length;
val: REF LIST OF ROPE _ NIL;
text _ RefText.AppendChar[text, '.];
text _ AppendID[text, scanner];
TRUSTED {
val _ NARROW[symTab.Fetch[LOOPHOLE[text]].val];
};
IF val = NIL THEN {
val _ NEW[LIST OF ROPE _ NIL];
[] _ symTab.Store[Rope.FromRefText[text], val];
};
val^ _ CONS[stem, val^];
GetTok[];
IF Match[scanner, ","] THEN GetTok[]
ELSE IF NOT Match[scanner, "]"] THEN RaiseError[scanner];
text.length _ savedLength;
ENDLOOP;
GetTok[];
IF Match[scanner, ","] THEN GetTok[]
ELSE IF NOT Match[scanner, ";"] THEN RaiseError[scanner];
ENDLOOP;
};
RefText.ReleaseScratch[text];
};

Compare: PROC [ref1: REF ANY, ref2: REF ANY] RETURNS [Basics.Comparison] ~ {
r1: LIST OF ROPE _ NARROW[ref1];
r2: LIST OF ROPE _ NARROW[ref2];
RETURN [Rope.Compare[r1.first, r2.first, FALSE]]
};

WriteResults: PROC [stream: IO.STREAM, symTab: SymTab.Ref, cmd: Commander.Handle] ~ {
list: LIST OF REF _ NIL;
EachPair: PROC [key: ROPE, val: REF] RETURNS [quit: BOOL _ FALSE] ~ {
refList: REF LIST OF ROPE _ NARROW[val];
ropes: LIST OF ROPE _ refList^;
ropes _ CONS[key, ropes];
list _ CONS[ropes, list];
};
[] _ symTab.Pairs[EachPair];
list _ List.Sort[list, Compare];
FOR p: LIST OF REF _ list, p.rest UNTIL p = NIL DO
r: LIST OF ROPE _ NARROW[p.first];
s: LIST OF ROPE _ DReverse[r.rest];
r.rest _ NIL;
stream.PutRope[r.first];
stream.PutRope[":  "];
WHILE s # NIL DO
stream.PutRope[s.first];
stream.PutChar[' ];
{t: LIST OF ROPE _ s; s _ s.rest; t.rest _ NIL};
ENDLOOP;
IF doImpls THEN stream.PutRope[FindImplementor[r.first]];
stream.PutChar['\n];
ENDLOOP;
};

FindImplementor: PROC [def: ROPE] RETURNS [imp: ROPE] ~ {
deftail, result: ROPE _ NIL;
noResult: BOOL _ TRUE;
[result, , noResult] _ Interpreter.EvaluateToRope[def];
IF noResult OR result=NIL THEN RETURN["??"];
deftail _ FileNames.Tail[def, '.];
result _ IF Rope.Equal[deftail, FileNames.Tail[result, '.], TRUE] THEN Rope.Substr[base: result, start: 0, len: Rope.Length[result]-Rope.Length[deftail]-1] ELSE "!!";
RETURN[IF Rope.Length[result]=0 THEN "!!" ELSE result];
};

DReverse: PROC [old: LIST OF ROPE] RETURNS [new: LIST OF ROPE _ NIL] ~ {
WHILE old # NIL DO
t: LIST OF ROPE ~ old;
old _ t.rest;
t.rest _ new;
new _ t;
ENDLOOP;
};

Break: PROC [char: CHAR] RETURNS [IO.CharClass] = {
IF char = '_ OR char = '; THEN RETURN [break];
IF char = '  OR char = '	 OR char = ', OR char = '\n THEN RETURN [sepr];
RETURN [other];
};

GetCmdToken: PROC [stream: IO.STREAM] RETURNS [rope: ROPE _ NIL] ~ {
rope _ IO.GetTokenRope[stream, Break ! IO.EndOfStream => CONTINUE].token;
};

FindNewer: PROC [fileName: ROPE, newerThan: BasicTime.GMT] RETURNS [fullName: ROPE _ NIL] ~ {
full: ROPE _ NIL;
infoProc: FS.InfoProc ~ {IF BasicTime.Period[from: newerThan, to: created] > 0 THEN {fullName _ fullFName; continue _ FALSE}};
FS.EnumerateForInfo[fileName, infoProc];
};

UsingDependenciesCommand: Commander.CommandProc ~ {
Reformat: PROC [filename: ROPE]  ~ {
EndNode: PROC [delta: INTEGER _ 0, format: ATOM _ NIL] = {
tc.endOfNode _ TRUE;
tc.char _ '\n;
tc.format _ format;
tc.deltaLevel _ delta;
TiogaAccess.Put[writer, tc];
tc.endOfNode _ FALSE;
};
PutCharB: Rope.ActionType = {
tc.char _ c;
TiogaAccess.Put[writer, tc];
};
PutRope: PROC [rope: ROPE] = {
[] _ Rope.Map[base: rope, action: PutCharB];
};
PutRopeItalic: PROC [rope: ROPE] = {
tc.looks['i] _ TRUE;
[] _ Rope.Map[base: rope, action: PutCharB];
tc.looks['i] _ FALSE;
};
PutRopeBold: PROC [rope: ROPE] = {
tc.looks['b] _ TRUE;
[] _ Rope.Map[base: rope, action: PutCharB];
tc.looks['b] _ FALSE;
};
tc: TiogaAccess.TiogaChar _ [
charSet: 0,
char: '\n,
looks: ALL[FALSE],
format: $code,
comment: FALSE,
endOfNode: FALSE,
deltaLevel: 0,
propList: NIL
];
nextS: IO.STREAM;
in: IO.STREAM;
nextRope: ROPE;
ropeList, newList: LIST OF ROPE;
writer: TiogaAccess.Writer _ TiogaAccess.Create[];
in _ FS.StreamOpen[fileName: filename, accessOptions: $read ! FS.Error => {result _ $Failure; msg _ error.explanation; CONTINUE}];
IF in = NIL THEN RETURN;
UNTIL IO.EndOf[in] DO
newList _ ropeList _ NIL;
nextS _ IO.RIS[IO.GetLineRope[stream: in]]; -- get next rope from input
nextRope _ IO.GetTokenRope[nextS, IO.TokenProc].token; -- first token, boldface
PutRopeBold[Rope.Concat[nextRope, ":"]];
UNTIL IO.EndOf[nextS] DO ropeList _ CONS[IO.GetTokenRope[nextS, IO.TokenProc ! IO.EndOfStream => CONTINUE;].token, ropeList];
ENDLOOP;
IF ropeList#NIL THEN {
newList _ DReverse[ropeList]; -- destructive reverse
nextRope _ IF newList.rest=NIL THEN newList.first ELSE newList.rest.first; -- initialize in case never do following loop
FOR r: LIST OF ROPE _ newList, r.rest UNTIL r.rest=NIL DO -- do all but last rope
PutRope[Rope.Concat[" ", r.first]];
nextRope _ r.rest.first;
ENDLOOP;
IF doImpls THEN PutRopeItalic[Rope.Concat[" ", nextRope]] -- last rope is Implementor, italics
ELSE PutRope[Rope.Concat[" ", nextRope]]; -- last rope is not Implementor
EndNode[delta: 0, format: $code];
};
ENDLOOP;
TiogaAccess.WriteFile[writer, filename];
};

switchChar: CHAR = '-;
gets: ROPE _ NIL;
outputStream: IO.STREAM _ NIL;
symTab: SymTab.Ref _ SymTab.Create[997, TRUE];
scanner: Scanner _ CreateScanner[];
c: IO.STREAM _ IO.RIS[cmd.commandLine];
outputName: ROPE _ GetCmdToken[c];
IF outputName=NIL OR Rope.Equal[outputName, ""] THEN RETURN[$Failure, docRope];
doImpls _ reformat _ FALSE;
WHILE Rope.Fetch[base: outputName, index: 0]=switchChar DO 
FOR index: INT IN [1..Rope.Length[outputName]) DO
SELECT Rope.Fetch[base: outputName, index: index] FROM
'i => doImpls _ TRUE;
'f => reformat _ TRUE;
ENDCASE;
ENDLOOP;
outputName _ GetCmdToken[c];
ENDLOOP;
gets _ GetCmdToken[c];
IF NOT gets.Equal["_"] THEN RETURN[$Failure, docRope];
outputStream _ FS.StreamOpen[fileName: outputName, accessOptions: $create, keep: 2 ! FS.Error => {result _ $Failure; msg _ error.explanation; CONTINUE}];
IF outputStream = NIL THEN RETURN;
FOR stem: ROPE _ GetCmdToken[c], GetCmdToken[c] UNTIL stem.Length = 0 DO
pattern: ROPE _ IF Rope.Find[stem, ".bcd", 0, FALSE] < 0 THEN Rope.Concat[stem, ".bcd"] ELSE stem;
ForEachFile: PROC [fullFName: ROPE] RETURNS [continue: BOOLEAN _ TRUE] ~ {
bcdDate: BasicTime.GMT ~ FS.FileInfo[name: fullFName, remoteCheck: FALSE].created;
base: ROPE;
cp: FS.ComponentPositions;
useName: ROPE _ Rope.Concat[base, ".usingList"];
[fullFName, cp] _ FS.ExpandName[fullFName];
base _ fullFName.Substr[cp.base.start, cp.base.length];
useName _ FindNewer[Rope.Concat[base, ".usingList"], bcdDate];
IF useName=NIL THEN {
result _ CommandTool.DoCommand[Rope.Concat["UsingList ", fullFName], cmd];
useName _ Rope.Concat[base, ".usingList"];
}
ELSE {
cmd.out.PutF["Using old %g\n", IO.rope[useName]];
result _ NIL;
};
IF result = $Failure THEN NULL
ELSE {
stream: IO.STREAM _ NIL;
stream _ FS.StreamOpen[useName ! FS.Error => {cmd.out.PutRope[error.explanation]; cmd.out.PutChar['\n]; CONTINUE}];
IF stream # NIL THEN {
SetScanner[scanner, stream];
RecordDependencies[scanner, base, cmd, symTab];
stream.Close;
};
};
};
IF Rope.Find[pattern, "*"] >= 0 THEN FS.EnumerateForNames[pattern, ForEachFile ! FS.Error => {msg _ error.explanation; result _ $Failure; CONTINUE}]
ELSE [] _ ForEachFile[pattern ! FS.Error => {msg _ error.explanation; result _ $Failure; CONTINUE}];
IF result = $Failure THEN RETURN;
ENDLOOP;
WriteResults[outputStream, symTab, cmd];
outputStream.Close;
IF reformat THEN Reformat[outputName];
cmd.out.PutF["%g written.\n", IO.rope[outputName]];
};

reformat: BOOL _ FALSE;
doImpls: BOOL _ FALSE;
docRope: ROPE ~ "Create listing of procedure-level dependencies from bcds ([switches] <outputFile> _ <list of bcd patterns>)\n";
Commander.Register["UsingDependencies", UsingDependenciesCommand, docRope];

END.
zUsingDependenciesImpl.mesa
Copyright (C) 1984, 1985, Xerox Corporation.  All rights reserved.
Michael Plass, June 28, 1985 2:58:35 pm PDT
Pier, February 6, 1986 2:10:38 pm PST
Gets the next token into inputBuffer[tokenStart] .. inputBuffer[tokenLength-1]
this Proc calls the Interpreter to evaluate a rope of the form Interface.ProcName. If a rope of the form XXX.ProcName comes back, it is assumed that XXX is the implementor of Interface. Since it is possible to get other things back from the Interpreter, like types or errors, some defaults are returned ( -- or ??) instead of the interpreted result.
Destructive.
[c: CHAR] RETURNS [quit: BOOL _ FALSE]
propList: List.PutAssoc[key: $FromTiogaFile, val: $Yes, aList: NIL]
The following code assumes there are lines with one or more ropes per line. The first rope is of the form Interface.ProcName. Succeeding ropes up to the last rope in the line are assumed to be names of Implmentations which use that Interface.ProcName. The last rope is assumed to be the name of the Implementor of the Interface.ProcName.
result _ CommandTool.DoCommand[Rope.Concat["ReadIndent ", outputName], cmd];
Κy˜š
œ™Jš
œB™BJš
œ+™+Icode™%—J˜š
Οk	˜	Jšœœœœœœ˜J˜J˜
Jšœ
œ!˜0Jšœœ
˜Jšœ
˜J˜
J˜Jšœ
˜J˜J˜J˜J˜Jš
œ˜J˜—J˜šœœ
˜$JšœœœZ˜sJšœ˜J˜Jšœœœ
˜J˜Jšœ	œœ˜šœœœ˜Jšœœ
œ
˜Jš
œ˜Jšœ
œ
œ
˜Jšœœ
˜Jšœœ
˜Jšœ
˜Jš
œ˜J˜—Jšœœ
˜šΟn
œœ
œ˜2Jšœ
œ
˜Jšœœ
œ˜1Jš
œ˜J˜—šž
œœœ
œ˜:Jš
œ˜Jš
œ˜Jšœ œ˜4Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜J˜—JšœœO˜Yšžœœœœ˜)šœ˜
Jšœœœœ˜AJš	œœœœœ˜5Jšœœœ˜Jšœœ˜—Jš
œ˜J˜—Jšœ
œœ
œ˜šœœ˜J˜—šžœœ˜,Jšœ3œ˜PJš
œ˜Jš
œ˜šœ1œ˜9šœ=œ
œ˜Qšœ=œ
˜PJš
œ.˜.Jšœ
˜—Jš
œ
˜
—Jšœ˜Jš
œ˜—Jš
œ˜J˜—šžœœ˜.šžœœ˜JšœGœ˜dJš
œ.˜.šœCœ˜KJš
œ.˜.šœ=œ
œ˜Qšœ=œ
˜PJš
œ.˜.Jšœ
˜—Jš
œ
˜
—Jšœ/˜3Jš
œ˜—Jš
œ˜—Jš
œ˜Jš
œ˜šœB˜IJš
œ˜Jšœ
˜—Jš
œ.˜.Jš
œ˜Jš
œ˜J˜—šž
œœ˜'JšœœΟc+˜9JšœœŸœ
˜šžœœ˜JšœFœ˜cJ˜
šœC˜IJš
œ@˜@—šœE˜KJš
œC˜C—Jš
œ˜—Jš
œ˜Jš
œ	˜	šœ	œ	œ
˜(Jš
œ.˜.Jš
œ	˜	Jšœ
˜—Jšœ	œ
œ/˜KJš
œ˜Jš
œ˜J˜—šžœœ˜%Jš
œN™NJšœœ
˜Jš
œ<˜<Jš
œ˜Jšœ2œ˜OJšœ œœ˜IJš
œ,˜,Jšœœœ˜2Jšœœœ˜4Jšœœ0œœ˜`Jš
œD˜Dšœœ˜%Jš
œ˜Jšœ
˜Jš
œ˜—JšœB˜GšœY˜^JšœQœ˜tJš
œ.˜.šœGœ˜OJšœ
œœ
œ
˜(Jš
œ˜Jš
œ˜—Jšœ
˜—Jš
œ˜J˜—šžœœ˜)Jšœ
œ1˜>šœœ
œ˜Jš
œC˜CJšœ
˜—Jš
œ&˜&Jš
œQ˜QJš
œ˜Jš
œ~˜~J˜J˜—šžœœœ
œ
œœ	œ˜SJšœœ˜Jšœ"œ
œœ˜8šœœ
œ˜ Jšœœ
œœ˜5J˜Jšœ
˜—Jšœœ
˜
J˜J˜—š
ž	œœœœ	œ˜JJšœœ˜Jšœ"œ
œœ˜8šœœ
œ˜)Jšœ%œ
œœ˜;J˜Jšœ
˜—Jšœœ
˜
J˜J˜—šžœœœœ˜8Jšœœ˜"Jš	œœ
œœœ˜?Jšœ œ˜;Jšœ)˜/J˜J˜—šžœœœ
œœœ
œ˜HJšœk˜qJ˜J˜—šœœœ˜Jšœœ
˜
Jšœ˜Jš
œ˜J˜—šœœ
œœ
˜*J˜—šœœ˜'Jš
œ=˜=J˜J˜—šžœœœ0˜fšžœœ˜Jš
œ˜šœœ œ˜eJš
œ˜Jšœ
˜—Jš
œ˜—Jšœœ
œ˜,Jš
œ	˜	šœœ˜?Jš
œ˜Jšœ
˜—Jšœœ˜4Jš
œ	˜	J•StartOfExpansion[]šœœ.œ
˜Yšœ˜šœ˜J˜Jš
œ˜Jš
œ	˜	šœœ˜Jš
œ	˜	Jšœ
œœ˜7Jš
œ	˜	Jšœœ˜7J˜Jš
œt˜tJš
œ	˜	Jš
œ˜—Jšœ
œœ˜8Jš
œ	˜	Jšœ
œœ˜4Jš
œ	˜	šœ˜Jšœ
œ˜Jšœœ
œ
œ
œœ
˜Jš
œ$˜$Jš
œ˜šœ˜	Jšœœœ
˜/Jš
œ˜—šœœ
œ˜Jšœœ
œ
œ
œœ˜Jš
œ/˜/Jš
œ˜—Jšœœ
˜Jš
œ	˜	Jšœœ	˜$Jšœ
œ
œœ˜9Jš
œ˜Jšœ
˜—Jš
œ	˜	Jšœœ	˜$Jšœ
œ
œœ˜9Jšœ
˜—Jš
œ˜—Jš
œ˜J˜J˜—šžœœœ
œœ
œœ˜LJš	œœ
œ
œœ˜ Jš	œœ
œ
œœ˜ Jšœ#œ˜0Jš
œ˜J˜—šžœœ
œ
œ0˜UJš	œœ
œ
œœ
˜šžœœœœœœœ˜EJš	œ	œ
œ
œœ˜(Jšœœ
œ
œ˜Jšœœ
˜Jšœœ˜Jš
œ˜—Jš
œ˜Jš
œ ˜ š
œœ
œ
œœœ
˜2Jš	œœ
œ
œœ
˜"Jšœœ
œ
œ˜#Jšœ	œ
˜
Jš
œ˜Jš
œ˜šœœ
˜Jš
œ˜Jš
œ˜Jš	œœ
œ
œœ˜0Jšœ
˜—Kšœœ*˜9Jš
œ˜Jšœ
˜—J˜J˜—š
žœœœœœ˜9K™έKšœœœ
˜Kšœ
œœ
˜Kš
œ7˜7Kš
œ
œœ
œ
œ˜,Kš
œ"˜"K–9[base: 
ROPE, start: 
INT _ 0, len: 
INT _ 2147483647]š	œ	œ1œœVœ˜¦
Kšœ
œœœ	˜7K˜J˜—šžœœœ
œ
œœœ
œ
œœ˜HJ™šœœ
˜Jšœœ
œ
œ˜Jš
œ
˜
Jš
œ
˜
Jš
œ˜Jšœ
˜—Jš
œ˜J˜—–

"cedar" styleš
žœœœœœ˜3Jšœœœ
œ	˜.Jšœœœœœ
œ˜HJšœ	˜Jš
œ˜J˜—šžœœ
œ
œœœœ˜DJšœœœœ˜IJ˜J˜—šž	œœœœœœœ˜]Jšœœœ
˜Jš	œ
œ
œ4œ#œ˜~Jšœ&˜(J˜J˜—šžœ˜3šžœœœ˜$š
žœœ	œœœ˜:Kšœœ
˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kšœœ
˜K˜—–* -- [c: CHAR] RETURNS [quit: BOOL _ FALSE]šΟbœ˜Kš
Πck&™&Kš
œ˜Kš
œ˜K˜—šžœœœ˜K–T[base: 
ROPE, start: 
INT _ 0, len: 
INT _ 2147483647, action: 
Rope.ActionType]š
œ,˜,K˜—šž
œœœ˜$Kšœœ
˜K–T[base: 
ROPE, start: 
INT _ 0, len: 
INT _ 2147483647, action: 
Rope.ActionType]š
œ,˜,Kšœœ
˜K˜—šžœœœ˜"Kšœœ
˜K–T[base: 
ROPE, start: 
INT _ 0, len: 
INT _ 2147483647, action: 
Rope.ActionType]š
œ,˜,Kšœœ
˜K˜—š
œ˜Kš
œ˜Kš
œ
˜
Kšœœ
œ˜Kš
œ˜Kšœ	œ
˜Kšœœ
˜Kš
œ˜Kšœ?œ
™CKšœ
˜
K˜—Kšœœ
œ
˜Kšœœ
œ
˜Kšœ
œ
˜Kšœœ
˜ Kš
œ2˜2Kšœœ7œ7œ˜‚
Jšœœ
œ
œ
˜J™Ρšœ
œ˜J–[stream: 
STREAM]šœœ
˜Jšœœ
œ
œŸ˜GJšœœœŸ˜OKš
œ(˜(šœ
œœœ
œœ
œœ˜}Kšœ
˜—šœ
œ
œ˜KšœŸ˜4Kš
œœœ
œœŸ-˜xšœœ
œ
œœœ
œ
Ÿ˜QKš
œ#˜#K˜Kšœ
˜—Kšœ	œ+Ÿ$˜^Kšœ&Ÿœ
Ÿœ
Ÿ˜IKš
œ!˜!K˜—Kšœ
˜—Kš
œ(˜(K˜J˜—Jšœœ˜Jšœœœ
˜Jšœœ
œœ
˜Jšœ(œ˜.J˜#Jš	œœ
œœ
œ˜'Jšœœ˜"Jš
œœ
œœ
œ˜OK– [base: 
ROPE, index: 
INT _ 0]šœœ
˜šœ3œ
˜;šœœ
œ˜1šœ,˜6Kšœœ
˜Kšœœ
˜Kšœ
˜—Kšœ
˜—Jš
œ˜Jšœ
˜—Jš
œ˜Jšœ
œœ
œ˜6JšœœDœ7œ˜™
Jšœœ
œ
œ
˜"šœœ"œ˜HJšœ	œœœœœ˜bšžœœ
œœœœ˜JJšœœœ(œ
˜RJšœœ
˜Jšœœ˜Jšœ	œ#˜0Jšœœ˜+Jš
œ7˜7Jš
œ>˜>šœ	œ
œ˜Jš
œJ˜JJš
œ*˜*Jš
œ
˜
—šœ˜Jšœœ˜1Jšœ	œ
˜
Jš
œ˜—Jšœœ
˜šœ˜Jšœœ
œœ
˜Jšœ	œœEœ˜sšœ
œ
œ˜Jš
œ˜Jš
œ/˜/J˜
Jš
œ˜—J˜—J˜—Jš
œœ
œ*œ7œ˜”
Jšœœ7œ˜dJšœœ
œ
˜!Jšœ
˜—Jš
œ(˜(Jš
œ˜Jš
œL™LKšœ	œ˜&Jšœœ˜3J˜J˜—Kšœ
œœ
˜Kšœ	œœ
˜Jšœ	œs˜€
Jš
œK˜KJ˜Jšœ
˜——…—;:V-