DIRECTORY Atom, BackStop, Basics, DefDWIM, DocCache, FileDWIM, FS, IO, JaMAndStyleAnalyses, Menus, MesaAnalyses, MessageWindow, RefTab, RegularExpression, Rope, RopeHash, RopeList, RopeReader, SymTab, TDJaMScanner, TDLexing, TEditDocument, TEditDocumentPrivate, TEditInput, TEditOps, TEditProfile, TEditRefresh, TEditSelection, TEditSelectionOps, TextFind, TextNode, TiogaMenuOps, TiogaOps, TiogaRopes, TiogaStreams, TreeFind, UserProfile, ViewerClasses, ViewerForkers, VM;

DefDWIMImpl: CEDAR MONITOR
IMPORTS Atom, BackStop, DocCache, FileDWIM, FS, IO, JaMAndStyleAnalyses, MesaAnalyses, MessageWindow, RefTab, RegularExpression, Rope, RopeHash, RopeList, RopeReader, SymTab, TDJaMScanner, TDLexing, TEditDocumentPrivate, TEditInput, TEditOps, TEditProfile, TEditRefresh, TEditSelection, TextFind, TextNode, TiogaMenuOps, TiogaOps, TiogaRopes, TiogaStreams, TreeFind, UserProfile, ViewerForkers, VM
EXPORTS DefDWIM
SHARES ViewerClasses --in order to change existing Def button, which doesn't decode control
=

BEGIN OPEN TDLexing, DefDWIM;
LORA: TYPE = LIST OF REF ANY;
ROPEList: TYPE = LIST OF ROPE;
RefTextNode: TYPE = TextNode.RefTextNode;
MesaAnalysis: TYPE = MesaAnalyses.MesaAnalysis;
Viewer: TYPE = ViewerClasses.Viewer;
RegistrationList: TYPE = LIST OF Registration;
Registration: TYPE = RECORD [Test: LanguageTest, Find: Finder];

Failure: PUBLIC ERROR [where: Place, why: ROPE] = CODE;

registry: RegistrationList _ NIL;

FindDef: PUBLIC PROC [subjectRope: ROPE, from: Place, deep, verbose: BOOL, interrupt: REF BOOL _ NIL] RETURNS [fp: FoundPlace] --Finder-- = {
FOR rl: RegistrationList _ registry, rl.rest WHILE rl # NIL DO
IF rl.first.Test[from] THEN RETURN [rl.first.Find[subjectRope, from, deep, verbose, interrupt]];
ENDLOOP;
RETURN [DefaultFinder[subjectRope, from, deep, verbose, interrupt]];
};

Register: PUBLIC PROC [languageTest: LanguageTest, finder: Finder] = {
registry _ CONS[[languageTest, finder], registry];
};

RopeSeq: TYPE = REF RopeSequence;
RopeSequence: TYPE = RECORD [elts: SEQUENCE length: NAT OF ROPE];

msgRing: RopeSeq _ CreateRopeSeq[100];
msgRingInsert: NAT _ 0;

SetRingSize: ENTRY PROC [size: NAT] = {
ENABLE UNWIND => NULL;
msgRing _ CreateRopeSeq[size];
msgRingInsert _ 0;
};

Msg: ENTRY PROC [clearFirst: BOOL, r1, r2, r3, r4, r5: ROPE _ NIL] = {
ENABLE UNWIND => msgRingInsert _ 0;
msg: ROPE = Rope.Cat[r1, r2, r3, r4, r5];
MessageWindow.Append[msg, clearFirst];
IF clearFirst THEN {
msgRingInsert _ msgRingInsert + 1;
IF msgRingInsert = msgRing.length THEN msgRingInsert _ 0;
msgRing[msgRingInsert] _ msg;
}
ELSE msgRing[msgRingInsert] _ msgRing[msgRingInsert].Concat[msg];
};

CreateRopeSeq: PROC [length: NAT] RETURNS [rs: RopeSeq] = {
rs _ NEW [RopeSequence[length]]};

GetMsgs: ENTRY PROC [maxLen: NAT _ 32] RETURNS [history: ROPEList] = {
ENABLE UNWIND => NULL;
len: NAT = MIN[msgRing.length, maxLen];
i: NAT _ msgRingInsert;
history _ NIL;
THROUGH [1 .. len] DO
history _ CONS[msgRing[i], history];
i _ (i+msgRing.length-1) MOD msgRing.length;
ENDLOOP;
history _ history;
};
DefaultFinder: PROC [subjectRope: ROPE, from: Place, deep, verbose: BOOL, interrupt: REF BOOL _ NIL] RETURNS [fp: FoundPlace] --Finder-- = {
quick: TextFind.Finder ~ TextFind.CreateFromRope[pattern: Rope.Cat[subjectRope, ":"], literal: TRUE, word: TRUE];
textRoot: RefTextNode = TextNode.Root[from.loc.node];
start: INT = 0;
startLoc: Location = TextNode.LocRelative[[textRoot, 0], start];
before, after: INT;
foundLoc, nameEnd: Location;
foundNode: TextNode.Ref _ NIL;
TryFwd: PROC [fromLoc: Location] RETURNS [found: BOOL] = {
[found: found, where: foundNode, before: before, after: after] _ TreeFind.Try[finder: quick, first: fromLoc.node, start: fromLoc.where, interrupt: interrupt];
};
TryBkwd: PROC RETURNS [found: BOOL] = {
[found: found, where: foundNode, before: before, after: after] _ TreeFind.TryBackwards[finder: quick, first: from.loc.node, len: from.loc.where, last: startLoc.node, lastStart: startLoc.where, interrupt: interrupt];
};
found: BOOL _ SELECT from.searchOrder FROM
fromStart => TryFwd[[textRoot, 0]],
fwdThenBkwd => TryFwd[from.loc] OR TryBkwd[],
bkwdThenFwd => TryBkwd[] OR TryFwd[from.loc],
ENDCASE => ERROR;
IF interrupt#NIL AND interrupt^ THEN Failure[from, Rope.Concat["interrupted search for ", subjectRope]];
IF NOT found THEN {
dot: INT ~ subjectRope.FindBackward["."];
subjLen: INT ~ subjectRope.Length;
IF dot IN (0 .. subjLen-1) THEN {
module: ROPE ~ subjectRope.Substr[len: dot];
sub: ROPE ~ subjectRope.Substr[start: dot+1];
next: Place ~ EnterCedarModule[from, module, verbose];
fp _ FindCedarDef[sub, next, deep, verbose, FALSE, NIL, MakeStack[], interrupt];
RETURN};
};
IF found THEN {
foundLoc _ TextNode.LocRelative[[foundNode, 0], before];
nameEnd _ TextNode.LocRelative[foundLoc, after-2 - before];
after _ TextNode.LocOffset[[textRoot, 0], [foundNode, after]];
fp _ [[from.fileName, foundLoc, fwdThenBkwd], nameEnd];
}
ELSE Failure[from, Rope.Cat["Couldn't find ", subjectRope]];
};

RecognizeJS: PROC [place: Place] RETURNS [is: BOOL] --LanguageTest-- = {
is _ WhatJSType[place] # Other;
};

JSType: TYPE = {JaM, Style, Other};

WhatJSType: PROC [place: Place] RETURNS [type: JSType] = {
cp: FS.ComponentPositions;
fullFName, ext: ROPE;
IF place.fileName.Length[] = 0 THEN RETURN [Other];
[fullFName, cp, ] _ FS.ExpandName[place.fileName];
ext _ fullFName.Substr[cp.ext.start, cp.ext.length];
type _ SELECT TRUE FROM
ext.Equal["JaM", FALSE] => JaM,
ext.Equal["Style", FALSE] => Style,
ENDCASE => Other;
};

JSFinder: PROC [subjectRope: ROPE, from: Place, deep, verbose: BOOL, interrupt: REF BOOL _ NIL] RETURNS [fp: FoundPlace] --Finder-- = {
type: JSType = WhatJSType[from];
IF deep THEN subjectRope _ Rope.Cat["look.", subjectRope];
fp _ FindJSDef[subjectRope, from, verbose, NIL, MakeStack[], interrupt];
};

FindJSDef: PROC [subjectRope: ROPE, from: Place, verbose: BOOL, searchedOpens: SymTab.Ref--file name _ $T--, stack: RefTab.Ref--Frame _ $T--, interrupt: REF BOOL _ NIL] RETURNS [fp: FoundPlace] --Finder-- = {
frame: Frame = NEW [FramePrivate _ [subjectRope, from]];
IF stack.Fetch[frame].found THEN {
Failure[from, Rope.Concat["Recursion detected for ", subjectRope]];
};
IF NOT stack.Insert[frame, $T] THEN ERROR;
IF verbose THEN Msg[TRUE, "Looking for ", subjectRope, " in ", from.fileName];
{ENABLE UNWIND => [] _ stack.Delete[frame];
quick: RegularExpression.Finder = RegularExpression.CreateFromRope[pattern: Rope.Cat["(", subjectRope, ")"], literal: TRUE, word: TRUE];
textRoot: RefTextNode = TextNode.Root[from.loc.node];
anal: JaMAndStyleAnalyses.JSAnalysis = JaMAndStyleAnalyses.GetAnalysis[textRoot, from.fileName, verbose];
start: INT = IF anal # NIL THEN anal.bodyStart ELSE 0;
startLoc: Location = TextNode.LocRelative[[textRoot, 0], start];
here: INT = TextNode.LocOffset[[textRoot, 0], from.loc];
before, after: INT;
foundLoc, nameEnd: Location;
TryFwd: PROC [searchFrom: INT] RETURNS [found: BOOL] = {
searchRope: ROPE = MF[TiogaRopes.RopeFromTioga[textRoot]];
found _ FALSE;
WHILE NOT found DO
[found: found, before: before, after: after] _ RegularExpression.SearchRope[finder: quick, rope: searchRope, start: searchFrom, interrupt: interrupt];
IF NOT found THEN EXIT;
IF NOT JaMOKAround[searchRope, subjectRope, before, after] THEN {searchFrom _ after; found _ FALSE};
ENDLOOP;
};
TryBkwd: PROC RETURNS [found: BOOL] = {
searchRope: ROPE = MF[TiogaRopes.RopeFromTioga[textRoot]];
searchLength: INT _ here - start;
found _ FALSE;
WHILE NOT found DO
[found: found, before: before, after: after] _ RegularExpression.SearchRopeBackwards[finder: quick, rope: searchRope, start: start, len: searchLength, interrupt: interrupt];
IF NOT found THEN EXIT;
IF NOT JaMOKAround[searchRope, subjectRope, before, after] THEN {searchLength _ before - start; found _ FALSE};
ENDLOOP;
};
found: BOOL _ SELECT from.searchOrder FROM
fromStart => TryFwd[0],
fwdThenBkwd => TryFwd[here] OR TryBkwd[],
bkwdThenFwd => TryBkwd[] OR TryFwd[here],
ENDCASE => ERROR;
IF interrupt#NIL AND interrupt^ THEN Failure[from, Rope.Concat["interrupted search for ", subjectRope]];
IF found THEN {
foundLoc _ TextNode.LocRelative[[textRoot, 0], before+1];
nameEnd _ TextNode.LocRelative[foundLoc, after-2 - (before+1)];
after _ TextNode.LocOffset[[textRoot, 0], nameEnd]+1;
fp _ [[from.fileName, foundLoc, fwdThenBkwd], nameEnd];
}
ELSE {
Try: PROC [files: ROPEList, ext: ROPE] RETURNS [found: BOOL] = {
FOR files _ files, files.rest WHILE files # NIL DO
fileName: ROPE = files.first.Concat[ext];
IF interrupt#NIL AND interrupt^ THEN Failure[from, Rope.Concat["interrupted search for ", subjectRope]];
IF searchedOpens = NIL THEN searchedOpens _ SymTab.Create[case: TRUE];
found _ TRUE;
IF searchedOpens.Fetch[fileName].found THEN found _ FALSE
ELSE {
IF NOT searchedOpens.Insert[fileName, $T] THEN ERROR;
fp _ FindJSDef[subjectRope, JSModuleBody[from, fileName, verbose, stack, interrupt].where, verbose, searchedOpens, stack, interrupt !Failure => {found _ FALSE; CONTINUE}];
};
IF found THEN RETURN;
ENDLOOP;
found _ FALSE;
};
IF anal # NIL AND (Try[anal.runs, ".JaM"] OR Try[anal.attachs, ".Style"])
THEN NULL
ELSE Failure[from, Rope.Cat["Couldn't find ", subjectRope]];
};
};
IF NOT stack.Delete[frame] THEN ERROR;
};

JSModuleBody: PROC [from: Place, filename: ROPE, verbose: BOOL, stack: RefTab.Ref--Frame _ $T--, interrupt: REF BOOL] RETURNS [fp: FoundPlace] = {
ans: FileDWIM.Answer = FileDWIM.ResolveHint[filename, from.fileName, FALSE];
IF ans.fullFileName = NIL THEN ERROR Failure[from, Rope.Cat["couldn't find file ", filename]];
{next: Place = [ans.fullFileName, [GetDoc[from, ans.fullFileName], 0], fromStart];
fp _ [next, next.loc];
}};

JaMOKAround: PROC [searchRope, target: ROPE, before, after: INT] RETURNS [ok: BOOL] = {
Token: TYPE = TDJaMScanner.Token;
reader: RopeReader.Ref = RopeReader.Create[];
Match: PROC [left: {leftSquare, leftCurly}] RETURNS [ok: BOOL] = {
DO
token: Token = TDJaMScanner.GetToken[reader];
SELECT token.type FROM
nil => RETURN [FALSE--because EOF--];
name => {
a: ATOM = NARROW[TDJaMScanner.ParseToken[token, searchRope]];
SELECT a FROM
leftSquare => IF NOT Match[leftSquare] THEN RETURN [FALSE];
rightSquare => RETURN [left = leftSquare];
ENDCASE => NULL;
};
string, int, real => NULL;
lbrace => IF NOT Match[leftCurly] THEN RETURN [FALSE];
rbrace => RETURN [left = leftCurly];
comment => NULL;
ENDCASE => ERROR;
ENDLOOP;
};
stack: LORA _ LIST[target];
IF after >= searchRope.Length[] THEN RETURN [FALSE];
reader.SetPosition[searchRope, after];
DO
token: Token = TDJaMScanner.GetToken[reader];
SELECT token.type FROM
nil => RETURN [FALSE--because EOF--];
name => {
a: ATOM = NARROW[TDJaMScanner.ParseToken[token, searchRope]];
SELECT a FROM
dotCvx, $bp => NULL;
dotDef, $StyleParam => RETURN [stack # NIL AND stack.rest # NIL AND stack.rest.rest = NIL];
slashDef, $StyleRule, $ScreenRule, $PrintRule => RETURN [stack # NIL AND stack.rest # NIL AND stack.rest.rest # NIL AND stack.rest.rest.rest = NIL];
slashXdef => RETURN [stack # NIL AND stack.rest # NIL AND stack.rest.rest # NIL AND stack.rest.rest.rest = NIL];
leftSquare => IF  Match[leftSquare] THEN stack _ CONS[$square, stack] ELSE RETURN [FALSE];
dotTrue => stack _ CONS[a, stack];
ENDCASE => RETURN [FALSE];
};
string, int, real => stack _ CONS[TDJaMScanner.ParseToken[token, searchRope], stack];
lbrace => IF Match[leftCurly] THEN stack _ CONS[$curly, stack] ELSE RETURN [FALSE];
rbrace => RETURN [FALSE];
comment => NULL;
ENDCASE => ERROR;
ENDLOOP;
};
dotDef: ATOM = Atom.MakeAtom[".def"];
dotCvx: ATOM = Atom.MakeAtom[".cvx"];
dotTrue: ATOM = Atom.MakeAtom[".true"];
slashDef: ATOM = Atom.MakeAtom["/def"];
slashXdef: ATOM = Atom.MakeAtom["/xdef"];
leftSquare: ATOM = Atom.MakeAtom["["];
rightSquare: ATOM = Atom.MakeAtom["]"];

RecognizeLisp: PROC [place: Place] RETURNS [is: BOOL] = {
textRoot: RefTextNode = TextNode.Root[place.loc.node];
asRope: ROPE = MF[TiogaRopes.RopeFromTioga[node: textRoot, skipCommentNode: TRUE]];
length: INT = asRope.Length[];
in: IO.STREAM = IO.RIS[asRope];
[] _ in.SkipWhitespace[];
IF in.EndOf[] THEN RETURN [FALSE];
{firstNonwhite: CHAR = in.GetChar[];
in.Close[];
IF firstNonwhite # '( THEN RETURN [FALSE];
FOR i: INT _ length-1, i-1 WHILE i > 0 DO
SELECT asRope.Fetch[i] FROM
IN ['\000 .. IO.SP] => NULL;
') => RETURN [TRUE];
ENDCASE => RETURN [FALSE];
ENDLOOP;
RETURN [FALSE];
}};

LispFinder: PROC [subjectRope: ROPE, from: Place, deep, verbose: BOOL, interrupt: REF BOOL _ NIL] RETURNS [fp: FoundPlace] --Finder-- = {
quick: TextFind.Finder _ TextFind.CreateFromRope[pattern: Rope.Cat["(defun ", subjectRope], literal: TRUE, word: TRUE];
textRoot: RefTextNode = TextNode.Root[from.loc.node];
start: INT = 0;
startLoc: Location = TextNode.LocRelative[[textRoot, 0], start];
before, after: INT;
foundLoc, nameEnd: Location;
foundNode: TextNode.Ref _ NIL;
TryFwd: PROC [fromLoc: Location] RETURNS [found: BOOL] = {
[found: found, where: foundNode, before: before, after: after] _ TreeFind.Try[finder: quick, first: from.loc.node, start: from.loc.where, interrupt: interrupt];
};
TryBkwd: PROC RETURNS [found: BOOL] = {
[found: found, where: foundNode, before: before, after: after] _ TreeFind.TryBackwards[finder: quick, first: from.loc.node, len: from.loc.where, last: startLoc.node, lastStart: startLoc.where, interrupt: interrupt];
};
found: BOOL _ SELECT from.searchOrder FROM
fromStart => TryFwd[startLoc],
fwdThenBkwd => TryFwd[from.loc] OR TryBkwd[],
bkwdThenFwd => TryBkwd[] OR TryFwd[from.loc],
ENDCASE => ERROR;
IF interrupt#NIL AND interrupt^ THEN Failure[from, Rope.Concat["interrupted search for ", subjectRope]];
IF found THEN {
foundLoc _ TextNode.LocRelative[[foundNode, 0], before+7];
nameEnd _ TextNode.LocRelative[foundLoc, after-1 - (before+7)];
after _ TextNode.LocOffset[[textRoot, 0], [foundNode, after]];
fp _ [[from.fileName, foundLoc, fwdThenBkwd], nameEnd];
}
ELSE Failure[from, Rope.Cat["Couldn't find ", subjectRope]];
};

CedarTree: TYPE = REF ANY --actually UNION [FieldSelection, ROPE]--;

FieldSelection: TYPE = REF FieldSelectionPrivate;
FieldSelectionPrivate: TYPE = RECORD [
record: CedarTree,
field: ROPE
];

Frame: TYPE = REF FramePrivate;
FramePrivate: TYPE = RECORD [tree: CedarTree, from: Place];

guessDIRECTORY: BOOL _ TRUE;

RecognizeCedar: PROC [place: Place] RETURNS [isCedar: BOOL] --LanguageTest-- = {
cp: FS.ComponentPositions;
fullFName, ext: ROPE;
IF place.fileName.Length[] = 0 THEN RETURN [FALSE];
[fullFName, cp, ] _ FS.ExpandName[place.fileName];
ext _ fullFName.Substr[cp.ext.start, cp.ext.length];
isCedar _ ext.Equal["mesa", FALSE] OR ext.Equal["cedar", FALSE];
};

CedarFinder: PROC [subjectRope: ROPE, from: Place, deep, verbose: BOOL, interrupt: REF BOOL _ NIL] RETURNS [fp: FoundPlace] --Finder-- = {
in: IO.STREAM = IO.RIS[subjectRope];
p: Lexer = MakeLexer[in];
{ENABLE IO.Error => IF stream = in THEN Failure[noplace, IF ec = SyntaxError THEN "selection not of form ID(\".\"ID)*" ELSE "IO.Error parsing selection"];
t1: Token = GetToken[p];
IF t1.kind # tokenID THEN Failure[noplace, "selection not of form ID(\".\"ID)*"];
{tree: CedarTree = GetTree[p, t1];
in.Close[];
IF p.tokenStack = NIL OR p.tokenStack.rest # NIL OR p.tokenStack.first.kind # tokenEOF THEN Failure[noplace, "selection not of form ID(\".\"ID)*"];
fp _ FindCedarDef[tree, from, deep, verbose, TRUE, NIL, MakeStack[], interrupt];
}}};

commentControl: TreeFind.CommentControl[includeComments..excludeComments] _ excludeComments;

FindCedarDef: PROC [tree: CedarTree, from: Place, deep, verbose, leftmost: BOOL, searchedOpens: SymTab.Ref--module name _ $T--, stack: RefTab.Ref--Frame _ $T--, interrupt: REF BOOL _ NIL] RETURNS [fp: FoundPlace] = {
frame: Frame = NEW [FramePrivate _ [tree, from]];
IF stack.Fetch[frame].found THEN {
Failure[from, Rope.Concat["Recursion detected for ", FmtTree[tree]]];
};
IF NOT stack.Insert[frame, $T] THEN ERROR;
{ENABLE UNWIND => [] _ stack.Delete[frame];
WITH tree SELECT FROM
fs: FieldSelection => {
next: Place = FindCedarDef[fs.record, from, TRUE, verbose, leftmost, searchedOpens, stack, interrupt].where;
fp _ FindCedarDef[fs.field, next, deep, verbose, FALSE, NIL, stack, interrupt];
};
target: ROPE => {
quick: TextFind.Finder _ TextFind.CreateFromRope[pattern: Rope.Cat[target, ":"], literal: TRUE, word: TRUE];
textRoot: RefTextNode = TextNode.Root[from.loc.node];
T2RIndex: PROC [count: INT] RETURNS [x: INT] ~ {x _ IF commentControl=excludeComments THEN TextNode.LocOffset[[textRoot, 0], TextNode.LocRelative[[textRoot, 0], count], 1, TRUE] ELSE count};
R2TIndex: PROC [count: INT] RETURNS [y: INT] ~ {y _ IF commentControl=excludeComments THEN TextNode.LocOffset[[textRoot, 0], TextNode.LocRelative[[textRoot, 0], count, 1, TRUE]] ELSE count};
ma: MesaAnalysis = MesaAnalyses.GetAnalysis[textRoot, from.fileName, verbose];
start: INT = IF ma # NIL THEN ma.bodyStart ELSE 0;
startLoc: Location = TextNode.LocRelative[[textRoot, 0], start];
before, after: INT;
found: BOOL;
foundLoc, nameEnd: Location;
IF verbose THEN Msg[TRUE, "Looking for ", target, " in ", from.fileName];
{foundNode: TextNode.Ref _ NIL;
TryFwd: PROC [fromLoc: Location] RETURNS [found: BOOL] = {
[found: found, where: foundNode, before: before, after: after] _ TreeFind.Try[finder: quick, first: from.loc.node, start: from.loc.where, commentControl: commentControl, interrupt: interrupt];
};
TryBkwd: PROC RETURNS [found: BOOL] = {
[found: found, where: foundNode, before: before, after: after] _ TreeFind.TryBackwards[finder: quick, first: from.loc.node, len: from.loc.where, last: startLoc.node, lastStart: startLoc.where, commentControl: commentControl, interrupt: interrupt];
};
found _ SELECT from.searchOrder FROM
fromStart => TryFwd[[textRoot, 0]],
fwdThenBkwd => TryFwd[from.loc] OR TryBkwd[],
bkwdThenFwd => TryBkwd[] OR TryFwd[from.loc],
ENDCASE => ERROR;
IF interrupt#NIL AND interrupt^ THEN Failure[from, Rope.Concat["interrupted search for ", target]];
IF verbose THEN Msg[FALSE, " ."];
IF found THEN {
foundLoc _ TextNode.LocRelative[[foundNode, 0], before];
nameEnd _ TextNode.LocRelative[foundLoc, after-2 - before];
after _ TextNode.LocOffset[[textRoot, 0], [foundNode, after], 1, commentControl=excludeComments];
}
};
IF (NOT found) AND ma # NIL THEN {
def: REF ANY = ma.globalDefs.Fetch[target].val;
IF def # NIL THEN {
fp _ WITH def SELECT FROM
it: MesaAnalyses.InterfaceType => CedarModuleBody[from, it, verbose, stack, interrupt],
ir: MesaAnalyses.InterfaceRecord => IF deep
THEN CedarModuleBody[from, ir.type, verbose, stack, interrupt]
ELSE [[from.fileName, TextNode.LocRelative[[textRoot, 0], ir.namePos.before], fwdThenBkwd], TextNode.LocRelative[[textRoot, 0], ir.namePos.after-1]],
ie: MesaAnalyses.InterfaceElement => FindCedarDef[ie.name, CedarModuleBody[from, ie.interface.type, verbose, stack, interrupt].where, deep, verbose, FALSE, searchedOpens, stack, interrupt],
ENDCASE => ERROR;
GOTO Dun};
};
IF NOT found THEN {
here: INT = TextNode.LocOffset[[textRoot, 0], from.loc];
targLen: INT = target.Length[];
slow: RegularExpression.Finder = RegularExpression.CreateFromRope[target.Concat["[ \n\t]**(',[ \n\t]**[a..zA..Z][a..zA..Z0..9]**[ \n\t]**)**('([~'(')]++')[ \n\t]**|)':"]];
xStart: INT ~ T2RIndex[start];
xHere: INT ~ T2RIndex[here];
searchRope: ROPE ~ MF[TiogaRopes.RopeFromTioga[node: textRoot, skipCommentNode: commentControl=excludeComments]];
TryFwd: PROC [searchFrom: INT] RETURNS [found: BOOL] = {
found _ FALSE;
WHILE NOT found DO
[found: found, before: before, after: after] _ RegularExpression.SearchRope[finder: slow, rope: searchRope, start: searchFrom, interrupt: interrupt];
IF NOT found THEN EXIT;
IF NOT CedarOKBefore[searchRope, before] THEN {searchFrom _ after; found _ FALSE};
ENDLOOP;
};
TryBkwd: PROC RETURNS [found: BOOL] = {
searchLength: INT _ xHere - xStart;
found _ FALSE;
WHILE NOT found DO
[found: found, before: before, after: after] _ RegularExpression.SearchRopeBackwards[finder: slow, rope: searchRope, start: xStart, len: searchLength, interrupt: interrupt];
IF NOT found THEN EXIT;
IF NOT CedarOKBefore[searchRope, before] THEN {searchLength _ before - xStart; found _ FALSE};
ENDLOOP;
};
IF verbose THEN Msg[TRUE, "Looking hard for ", target, " in ", from.fileName];
found _ SELECT from.searchOrder FROM
fromStart => TryFwd[0],
fwdThenBkwd => TryFwd[xHere] OR TryBkwd[],
bkwdThenFwd => TryBkwd[] OR TryFwd[xHere],
ENDCASE => ERROR;
IF interrupt#NIL AND interrupt^ THEN Failure[from, Rope.Concat["interrupted search for ", target]];
IF verbose THEN Msg[FALSE, " ."];
IF found THEN {
foundLoc _ TextNode.LocRelative[[textRoot, 0], before, 1, commentControl=excludeComments];
nameEnd _ TextNode.LocRelative[foundLoc, targLen-1];
};
};
IF (NOT found) AND ma # NIL THEN {
FOR owus: MesaAnalyses.IRList _ ma.openedWithoutUsingList, owus.rest WHILE owus # NIL DO
ir: MesaAnalyses.InterfaceRecord = owus.first;
IF interrupt#NIL AND interrupt^ THEN Failure[from, Rope.Concat["interrupted search for ", target]];
IF searchedOpens = NIL THEN searchedOpens _ SymTab.Create[case: TRUE];
found _ TRUE;
IF searchedOpens.Fetch[ir.type.typeClass].found THEN found _ FALSE
ELSE {
IF NOT searchedOpens.Insert[ir.type.typeClass, $T] THEN ERROR;
fp _ FindCedarDef[target, CedarModuleBody[from, ir.type, verbose, stack, interrupt].where, deep, verbose, FALSE, searchedOpens, stack, interrupt !Failure => {found _ FALSE; CONTINUE}];
};
IF found THEN GOTO Dun;
ENDLOOP;
};
IF (NOT found) AND guessDIRECTORY AND leftmost THEN {
IF verbose THEN Msg[TRUE, "Guessing ", target, " missing from DIRECTORY in ", from.fileName];
{ans: FileDWIM.Answer = FileDWIM.ResolveHint[target.Concat[".mesa"], from.fileName, FALSE];
IF ans.fullFileName # NIL THEN {
next: Place = [ans.fullFileName, [GetDoc[from, ans.fullFileName], 0], fromStart];
found _ TRUE;
fp _ FindCedarDef[target, next, deep, verbose, FALSE, searchedOpens, stack, interrupt !Failure => {found _ FALSE; CONTINUE}];
IF found THEN GOTO Dun;
};
IF verbose THEN Msg[FALSE, " ."];
}};
IF NOT found THEN ERROR Failure[from, Rope.Cat["couldn't find ", target]];
fp _ [[from.fileName, foundLoc, fwdThenBkwd], nameEnd];
IF NOT deep THEN GOTO Dun;
{in: IO.STREAM = TiogaStreams.CreateInput[
from: textRoot,
commentHandling: SELECT commentControl FROM
includeComments => useDirectly,
excludeComments => discard,
ENDCASE => ERROR];
in.SetIndex[after];
{ENABLE IO.Error => IF stream=in THEN Failure[[from.fileName, TextNode.LocRelative[[textRoot, 0], after], from.searchOrder], IF ec=SyntaxError THEN "Cedar Syntax Error" ELSE "IO.Error"];
p: Lexer = MakeLexer[in];
toke: Token;
SkipMumble[p];
toke _ GetToken[p];
IF toke.kind = tokenID THEN {
IF NOT ReservedWord[toke.rope] THEN {
defTree: CedarTree = GetTree[p, toke];
IF (WITH defTree SELECT FROM
rope: ROPE => NOT PredefinedType[rope],
ENDCASE => TRUE)
THEN {fp _ FindCedarDef[defTree, fp.where, TRUE, verbose, TRUE, NIL, stack, interrupt]; GOTO Dun};
}
ELSE IF toke.rope.Equal["TYPE"] THEN {
toke2: Token = GetToken[p];
IF toke2.kind = tokenSINGLE AND RopeList.Memb[list: LIST["~", "="], r: toke2.rope] THEN {
SkipMumble[p];
{toke3: Token = GetToken[p];
IF toke3.kind = tokenID AND NOT ReservedWord[toke3.rope] THEN {
defTree: CedarTree = GetTree[p, toke3];
IF (WITH defTree SELECT FROM
rope: ROPE => NOT PredefinedType[rope],
ENDCASE => TRUE)
THEN {fp _ FindCedarDef[defTree, fp.where, deep, verbose, TRUE, NIL, stack, interrupt]; GOTO Dun};
};
}};
};
};
in.Close[];
}}};
ENDCASE => ERROR;
EXITS Dun => fp _ fp;
};
IF NOT stack.Delete[frame] THEN ERROR;
};

BeforeState: TYPE ~ {start, gotWhite, gotN, wantG, wantE, wantB, wantP, wantO, dontWantLetter};

CedarOKBefore: PROC [searchRope: ROPE, before: INT] RETURNS [ok: BOOL] = {
state: BeforeState _ start;
WHILE before > 0 DO
char: CHAR = searchRope.Fetch[before _ before - 1];
SELECT state FROM
start => SELECT char FROM
' , '\n, '\t => state _ gotWhite;
'[, '{, ';, ', => RETURN [TRUE];
ENDCASE => RETURN [FALSE];
gotWhite => SELECT char FROM
' , '\n, '\t => NULL;
'[, '{, ';, ', => RETURN [TRUE];
'N => state _ gotN;
ENDCASE => RETURN [FALSE];
gotN => SELECT char FROM
'I => state _ wantG;
'E => state _ wantP;
ENDCASE => RETURN [FALSE];
wantG => SELECT char FROM
'G => state _ wantE;
ENDCASE => RETURN [FALSE];
wantE => SELECT char FROM
'E => state _ wantB;
ENDCASE => RETURN [FALSE];
wantB => SELECT char FROM
'B => state _ dontWantLetter;
ENDCASE => RETURN [FALSE];
wantP => SELECT char FROM
'P => state _ wantO;
ENDCASE => RETURN [FALSE];
wantO => SELECT char FROM
'O => state _ dontWantLetter;
ENDCASE => RETURN [FALSE];
dontWantLetter => SELECT char FROM
IN ['a .. 'z], IN ['A .. 'Z], IN ['0 .. '9] => RETURN [FALSE];
ENDCASE => RETURN [TRUE];
ENDCASE => ERROR;
ENDLOOP;
RETURN [TRUE]};

SkipMumble: PROC [p: Lexer] = {
DO
SELECT TRUE FROM
p.NextIs["REF"] => LOOP;
p.NextIs["LONG"] => LOOP;
p.NextIsSeq[LIST["POINTER", "TO"]] => LOOP;
p.NextIs["PRIVATE"] => LOOP;
p.NextIs["PUBLIC"] => LOOP;
p.NextIs["READONLY"] => LOOP;
ENDCASE => NULL;
EXIT;
ENDLOOP;
};

GetTree: PROC [p: Lexer, start: Token] RETURNS [tree: CedarTree] = {
want: {dot, name} _ dot;
tree _ start.rope;
DO
toke: Token = GetToken[p];
SELECT want FROM
dot => {
IF toke.rope.Equal["^"] THEN LOOP
ELSE IF toke.rope.Equal["."] THEN want _ name
ELSE {ReturnToken[p, toke]; EXIT};
};
name => {
IF toke.kind = tokenID AND NOT ReservedWord[toke.rope] THEN {
tree _ NEW [FieldSelectionPrivate _ [tree, toke.rope]];
want _ dot;
}
ELSE {ReturnToken[p, toke]; EXIT};
};
ENDCASE => ERROR;
ENDLOOP;
};

EnterCedarModule: PROC [from: Place, moduleName: ROPE, verbose: BOOL] RETURNS [Place] = {
ans: FileDWIM.Answer = FileDWIM.ResolveHint[moduleName.Concat[".mesa"], from.fileName, FALSE];
IF ans.fullFileName = NIL THEN ERROR Failure[from, Rope.Cat["couldn't find file ", moduleName, ".mesa"]];
RETURN [[ans.fullFileName, [GetDoc[from, ans.fullFileName], 0], fromStart]]};

CedarModuleBody: PROC [from: Place, it: MesaAnalyses.InterfaceType, verbose: BOOL, stack: RefTab.Ref--Frame _ $T--, interrupt: REF BOOL] RETURNS [fp: FoundPlace] = {
ans: FileDWIM.Answer = FileDWIM.ResolveHint[it.fileHint, from.fileName, FALSE];
IF ans.fullFileName = NIL THEN ERROR Failure[from, Rope.Cat["couldn't find file ", it.fileHint, " for module ", it.name]];
{next: Place = [ans.fullFileName, [GetDoc[from, ans.fullFileName], 0], fromStart];
fp _ FindCedarDef[it.typeClass, next, FALSE, verbose, FALSE, NIL, stack, interrupt];
}};

MF: PROC [rope: ROPE] RETURNS [fr: ROPE] = INLINE {
fr _ IF teledebug THEN rope.Flatten[] ELSE rope};
teledebug: BOOL _ FALSE;

MakeStack: PROC RETURNS [stack: RefTab.Ref--Frame _ $T--] = {
stack _ RefTab.Create[hash: HashFrame, equal: CompareFrames];
};

HashFrame: PROC [key: REF ANY] RETURNS [hash: CARDINAL] --RefTab.HashProc-- = {
f: Frame = NARROW[key];
hash _ HashTree[f.tree] + RopeHash.FromRope[f.from.fileName] + HashRef[f.from.loc.node] + HashInt[f.from.loc.where];
};

HashTree: PROC [t: CedarTree] RETURNS [hash: CARDINAL] = {
WITH t SELECT FROM
x: ROPE => hash _ RopeHash.FromRope[x];
x: FieldSelection => hash _ HashTree[x.record]*3 + RopeHash.FromRope[x.field];
ENDCASE => ERROR;
};

HashRef: PROC [ref: REF ANY] RETURNS [hash: CARDINAL]
= TRUSTED INLINE {hash _ HashInt[LOOPHOLE[ref]]};

HashInt: PROC [i: INT] RETURNS [hash: CARDINAL]
= INLINE {ln: Basics.LongNumber = [li[i]]; hash _ ln.lo + ln.hi};

CompareFrames: PROC [key1, key2: REF ANY] RETURNS [equal: BOOL] = {
f1: Frame = NARROW[key1];
f2: Frame = NARROW[key2];
equal _ CompareTrees[f1.tree, f2.tree] AND f1.from.fileName.Equal[f2.from.fileName, FALSE] AND f1.from.loc = f2.from.loc;
};

CompareTrees: PROC [t1, t2: CedarTree] RETURNS [equal: BOOL] = {
equal _ WITH t1 SELECT FROM
x: ROPE => WITH t2 SELECT FROM
y: ROPE => x.Equal[y],
y: FieldSelection => FALSE,
ENDCASE => ERROR,
x: FieldSelection => WITH t2 SELECT FROM
y: ROPE => FALSE,
y: FieldSelection => CompareTrees[x.record, y.record] AND x.field.Equal[y.field],
ENDCASE => ERROR,
ENDCASE => ERROR;
};

FmtTree: PROC [t: CedarTree] RETURNS [rope: ROPE] = {
rope _ WITH t SELECT FROM
x: ROPE => x,
x: FieldSelection => FmtTree[x.record].Cat[".", x.field],
ENDCASE => ERROR;
};

GetDoc: PROC [from: Place, fileName: ROPE] RETURNS [doc: TextNode.Ref] ~ {
IF fileName=NIL THEN Failure[from, "Trying to fetch NIL-named document"];
IF fileName.Length[]=0 THEN Failure[from, "Trying to fetch empty-named document"];
doc _ DocCache.GetDoc[fileName];
IF doc=NIL THEN Failure[from, IO.PutFR["Bug: DocCache.GetCache[%g] returned NIL", [rope[fileName]]]];
};

cmdEnabled: BOOL _ TRUE;
workVerbose: BOOL _ TRUE;

DefButt: PROC [parent: REF ANY, clientData: REF ANY _ NIL, 
mouseButton: Menus.MouseButton _ red, shift, control: BOOL _ FALSE] --Menus.ClickProc-- = {
TEditInput.InterpretAtom[NARROW[parent], defAtoms[mouseButton][control][shift]];
};
defAtoms: ARRAY Menus.MouseButton OF ARRAY --control--BOOL OF ARRAY --shift--BOOL OF ATOM = [
[[$FindNextDef, $FindNextDefCaseless], [$FindNextDefCtl, $FindNextDefCaselessCtl]],
[[$FindAnyDef, $FindAnyDefCaseless], [$FindAnyDefCtl, $FindAnyDefCaselessCtl]],
[[$FindPrevDef, $FindPrevDefCaseless], [$FindPrevDefCtl, $FindPrevDefCaselessCtl]]];

GetImplButt: PROC [parent: REF ANY, clientData: REF ANY _ NIL, 
mouseButton: Menus.MouseButton _ red, shift, control: BOOL _ FALSE] --Menus.ClickProc-- = {
TEditInput.InterpretAtom[NARROW[parent], implAtoms[mouseButton][control][shift]];
};
implAtoms: ARRAY Menus.MouseButton OF ARRAY --control--BOOL OF ARRAY --shift--BOOL OF ATOM = [
[[$LoadImpl, $LoadSmartImpl], [$LoadImpl, $LoadSmartImpl]],
[[$OpenImpl, $OpenSmartImpl], [$OpenImpl, $OpenSmartImpl]],
[[$CloseAndOpenImpl, $CloseAndOpenSmartImpl], [$CloseAndOpenImpl, $CloseAndOpenSmartImpl]]];

DefCommand: PROC [viewer: Viewer _ NIL] RETURNS [recordAtom: BOOL _ TRUE, quit: BOOL _ FALSE] --TiogaOps.CommandProc-- = {[recordAtom, quit] _ DefCommandWork[viewer, FALSE, FALSE, open]};

DefDeepCommand: PROC [viewer: Viewer _ NIL] RETURNS [recordAtom: BOOL _ TRUE, quit: BOOL _ FALSE] --TiogaOps.CommandProc-- = {[recordAtom, quit] _ DefCommandWork[viewer, TRUE, FALSE, open]};

LoadSmartImplCommand: PROC [viewer: Viewer _ NIL] RETURNS [recordAtom: BOOL _ TRUE, quit: BOOL _ FALSE] --TiogaOps.CommandProc-- = {[recordAtom, quit] _ DefCommandWork[viewer, TRUE, TRUE, load]};

OpenSmartImplCommand: PROC [viewer: Viewer _ NIL] RETURNS [recordAtom: BOOL _ TRUE, quit: BOOL _ FALSE] --TiogaOps.CommandProc-- = {[recordAtom, quit] _ DefCommandWork[viewer, TRUE, TRUE, open]};

CloseAndOpenSmartImplCommand: PROC [viewer: Viewer _ NIL] RETURNS [recordAtom: BOOL _ TRUE, quit: BOOL _ FALSE] --TiogaOps.CommandProc-- = {[recordAtom, quit] _ DefCommandWork[viewer, TRUE, TRUE, closeAndOpen]};

How: TYPE ~ {load, open, closeAndOpen};

DefCommandWork: PROC [viewer: Viewer, deep, getImpl: BOOL, how: How] RETURNS [recordAtom: BOOL _ TRUE, quit: BOOL _ FALSE] --TiogaOps.CommandProc-- = {
subjectRope: ROPE = TEditOps.GetSelContents[];
msg: ROPE _ NIL;
IF NOT cmdEnabled THEN RETURN [FALSE, FALSE];
recordAtom _ FALSE;
quit _ TRUE;
IF subjectRope.IsEmpty[] THEN {
Msg[TRUE, IF getImpl THEN "Select target for impl-search." ELSE "Select target for definition-search."];
MessageWindow.Blink[];
RETURN;
};
{
start: Place;
def: FoundPlace;
inSelf: BOOL;
sought, backErr: ROPE _ NIL;
Protected: PROC ~ {
ENABLE Failure => {
Msg[TRUE, why];
IF where # noplace THEN Msg[FALSE, " in ", where.fileName];
MessageWindow.Blink[];
CONTINUE
};
TEditSelection.CallWithSelAndDocAndTddLocks[viewer, primary, WithLocks];
IF getImpl THEN {
v: Viewer ~ IF inSelf THEN viewer ELSE TEditDocumentPrivate.DoOpenFile[fileName: def.where.fileName, column: right];
subject, fullFName: ROPE;
cp: FS.ComponentPositions;
[fullFName, cp] _ FS.ExpandName[def.where.fileName];
subject _ fullFName.Substr[start: cp.base.start, len: cp.base.length].Cat[".", sought];
SELECT how FROM
load => [] _ TEditDocumentPrivate.DoLoadImplFile[v, subject, FALSE];
open => [] _ TEditDocumentPrivate.DoOpenImplFile[subject, left, v];
closeAndOpen => [] _ TEditDocumentPrivate.DoCloseAndOpenImplFile[v, subject];
ENDCASE => ERROR;
};
MessageWindow.Clear[];
RETURN};
WithLocks: PROC [tdd: TEditDocument.TEditDocumentData, tSel: TEditDocument.Selection] = {
root: TextNode.Ref = IF TextNode.Parent[tdd.text]=NIL THEN tdd.text ELSE TextNode.Root[tdd.text];
startLoc: Location = IF root = TextNode.Root[tSel.start.pos.node] THEN tSel.start.pos ELSE [root, 0];
IF tiogaInterrupt # NIL THEN tiogaInterrupt^ _ FALSE;
start _ [viewer.file, startLoc, bkwdThenFwd];
def _ FindDef[subjectRope, start, deep, workVerbose, tiogaInterrupt];
inSelf _ TextNode.Root[startLoc.node] = TextNode.Root[def.where.loc.node];
IF getImpl THEN {
IF def.where.loc.node # def.nameEnd.node THEN Failure[def.where, "name stretches across node boundary"];
sought _ def.where.loc.node.rope.Substr[start: def.where.loc.where, len: def.nameEnd.where-def.where.loc.where+1];
RETURN;
};
IF inSelf THEN {
tSel.start.pos _ def.where.loc;
tSel.end.pos _ def.nameEnd;
tSel.granularity _ word;
tSel.viewer _ viewer;
tSel.data _ tdd;
tSel.pendingDelete _ FALSE;
TEditOps.RememberCurrentPosition[viewer];
TEditSelection.SetSelLooks[tSel];
TEditSelection.MakeSelection[new: tSel, selection: primary];
TEditInput.CloseEvent[];
TEditRefresh.ScrollToEndOfSel[viewer, FALSE, primary];
}
ELSE {
TEditInput.CloseEvent[];
ViewerForkers.ForkCall[viewer, OpenAndSelect, LIST[NEW [Place _ start], NEW [FoundPlace _ def]]];
};
};
IF protect THEN backErr _ BackStop.Call[Protected] ELSE Protected[];
IF backErr # NIL THEN {MessageWindow.Append[backErr, TRUE]; RETURN [TRUE, FALSE]};
}};
tiogaInterrupt: REF BOOL _ NIL;
protect: BOOL _ TRUE;

OpenAndSelect: PROC [data: REF ANY] --ViewerForkers.CallBack-- = {
args: LORA = NARROW[data];
start: REF Place = NARROW[args.first];
end: REF FoundPlace = NARROW[args.rest.first];
first: INT = TextNode.LocNumber[end.where.loc];
last: INT = first + TextNode.LocOffset[end.where.loc, end.nameEnd];
v: Viewer = TEditDocumentPrivate.DoOpenFile[fileName: end.where.fileName, column: right];
IF v = NIL THEN {
Msg[TRUE, "Couldn't open ", end.where.fileName, "."];
MessageWindow.Blink[];
RETURN;
};
ShowGivenPosition[v, first, last, FALSE];
};

ShowGivenPosition: PUBLIC PROC [viewer: Viewer, first, last: INT, skipCommentNodes: BOOL _ TRUE] = {
DoPosition: PROC [tdd: TEditDocument.TEditDocumentData, tSel: TEditDocument.Selection] = {
tSel.start.pos _ TextNode.LocWithin[tdd.text, first, 1, skipCommentNodes];
tSel.end.pos _ TextNode.LocRelative[tSel.start.pos, last-first, 1, skipCommentNodes];
tSel.granularity _ word;
tSel.viewer _ viewer;
tSel.data _ tdd;
tSel.pendingDelete _ FALSE;
tSel.insertion _ IF TEditProfile.selectionCaret=before THEN before ELSE after;
TEditOps.RememberCurrentPosition[viewer];
TEditSelection.SetSelLooks[tSel];
TEditSelection.MakeSelection[new: tSel, selection: feedback];
TEditRefresh.ScrollToEndOfSel[viewer, FALSE, feedback];
};
TEditSelection.CallWithSelAndDocAndTddLocks[viewer, feedback, DoPosition];
};

AmbushMenuEntry: PROC [first: Menus.MenuEntry, name: ROPE, proc: Menus.ClickProc] = {
me: Menus.MenuEntry;
FOR me _ first, me.link WHILE NOT me.name.Equal[name] DO NULL ENDLOOP;
me.proc _ proc;
};

NoteProfile: PROC [changeReason: UserProfile.ProfileChangeReason] --UserProfile.ProfileChangedProc-- = {
cmdEnabled _ UserProfile.Boolean["DefDWIM.Enabled", TRUE];
guessDIRECTORY _ UserProfile.Boolean["DefDWIM.GuessDIRECTORY", TRUE];
workVerbose _ UserProfile.Boolean["DefDWIM.Verbose", FALSE];
protect _ UserProfile.Boolean["DefDWIM.Protect", TRUE];
};

GetTiogaInterrupt: PROC RETURNS [interrupt: REF BOOL]
= {interrupt _ TEditInput.interrupt};

Start: PROC = {
tiogaInterrupt _ GetTiogaInterrupt[!VM.AddressFault => CONTINUE];
TiogaOps.RegisterCommand[$FindAnyDef, DefCommand];
TiogaOps.RegisterCommand[$FindAnyDefCtl, DefDeepCommand];
TiogaOps.RegisterCommand[$LoadSmartImpl, LoadSmartImplCommand];
TiogaOps.RegisterCommand[$OpenSmartImpl, OpenSmartImplCommand];
TiogaOps.RegisterCommand[$CloseAndOpenSmartImpl, CloseAndOpenSmartImplCommand];
AmbushMenuEntry[TEditDocumentPrivate.findMenu, "Def", DefButt];
AmbushMenuEntry[TiogaMenuOps.tiogaMenu.lines[0], "GetImpl", GetImplButt];
UserProfile.CallWhenProfileChanges[NoteProfile];
Register[RecognizeLisp, LispFinder];
Register[RecognizeJS, JSFinder];
Register[RecognizeCedar, CedarFinder];
};

Start[];

END.
NDefDWIMImpl.mesa
Mike Spreitzer March 1, 1987 5:45:39 pm PST
Last tweaked by Mike Spreitzer on November 30, 1987 2:48:46 pm PST
INVARIANT
The Ring.
Stuff
Kernel
Some particular languages
Controls whether the Cedar finder ignores comment nodes.
If not leftmost, we never guess it might be a missing DIRECTORY entry.
An OPENed module without a USING list is recorded in searchedOpens, which may be NIL.
Accepts, in reverse: ((nonAlpha ("BEGIN"|"OPEN") white+) | "{" | "[" | ";" | ",") white*
User Interface
Copied from TEditSelectionOpsImpl
sets bit to cause scroll after refresh
Setup
Κ(
–

"cedar" style•NewlineDelimiter

˜
code™K™+K™B—K˜KšΟk	œ6œœ‘œ
˜ΩK˜šΟnœœ
˜™	K™	—Kšœ%œœΩ˜Kšœ˜KšœΟcF˜[K˜
—K˜Kšœ
œ˜Ihead™Kšœœœ
œ
œ
œ
˜Kš	œ
œœ
œ
œ
˜Kšœ
œ˜)Kšœœ˜/Kšœœ˜$L™Kšœœœ
œ˜.Kšœœœ$˜?K˜Kš
žœœ
œœœ
˜7K˜Kšœœ
˜!K˜šžœœ
œœœ
œ
œœœŸ
œ˜
šœ*œœ
˜>Kšœœ
œ>˜`Kšœ
˜—Kšœ>˜DK˜K˜—šžœœ
œ1˜FKšœœ#˜2K˜K˜—Kšœ	œœ˜!Kš
œœœœ	œ
œ
œ˜AK˜K˜&Kšœœ˜K˜šžœœ
œœ˜'Kšœ
œœ
˜K˜Kš
œ˜K˜—K˜šžœœ
œœœœ˜FKšœ
œ˜#Kšœœ ˜)K˜&šœœ˜Kš
œ"˜"Kšœ œ˜9Kš
œ˜K˜
—Kšœ=˜AK˜—K˜šž
œœ
œœ˜;Kšœœ˜!—K˜š
žœœ
œ
œœ˜FKšœ
œœ
˜Kšœœœ˜'Kšœœ˜Kšœ
œ
˜šœ˜Kšœ
œ˜$Kšœœ˜,Kšœ
˜—K˜K˜—L™šž
œœœœ
œ
œœœŸ
œ˜Œ
Kšœ_œœ˜qK˜5Kšœœ˜K˜@Kšœœ
˜K˜Kšœœ
˜šžœœœ	œ˜:Kš
œž
˜ž
K˜—šžœœ
œ	œ˜'Kš
œΧ
˜Χ
K˜—šœœœ˜*Kš
œ#˜#Kšœ œ˜-Kšœœ˜-Kšœœ
˜—Kšœœ
œœD˜hšœ
œœ˜Kšœœ!˜)Kšœ	œ˜"šœœœ˜!Kšœœ ˜,Kšœœ$˜-Kš
œ6˜6Kšœ,œœ˜PKšœ˜—K˜—šœœ˜Kš
œ8˜8Kš
œ;˜;Kš
œ>˜>Kš
œ7˜7K˜
—Kšœ8˜<K˜K˜—š
žœœœœŸœ˜HKš
œ˜K˜K˜—Kšœœ˜#K˜šž
œœœ˜:Kšœœ˜Kšœœ
˜Kšœœ
œ	˜3Kšœœ˜2Kš
œ4˜4šœœ
œ
˜Kšœœ	˜Kšœœ˜#Kšœ
˜—K˜K˜—šžœœœœ
œ
œœœŸ
œ˜‡
Kš
œ ˜ Kšœœ.˜:Kšœ+œ˜HK˜K˜—šž	œœœœŸΠcm
ŸœŸ 
Ÿœ
œ
œœœŸ
œ˜Π
Kšœœ&˜8šœœ˜"Kš
œC˜CK˜—Kšœ
œœ
œ
˜*Kšœ	œœ6˜NKšœ
œ
œ˜+Kšœvœœ˜ˆ
K˜5Kš
œi˜iKšœœœœ
œœ˜6K˜@Kšœœ/˜8Kšœœ
˜K˜š
žœœœœ	œ˜8Kšœœœ%˜:Kšœœ
˜šœ
œ˜Kš
œ–
˜–
Kšœ
œœ
œ
˜Kšœ
œ5œœ˜dKšœ
˜—K˜—šžœœ
œ	œ˜'Kšœœœ%˜:Kšœœ˜!Kšœœ
˜šœ
œ˜Kš
œ­
˜­
Kšœ
œœ
œ
˜Kšœ
œ5œ)œ˜oKšœ
˜—K˜—šœœœ˜*Kš
œ˜Kšœœ˜)Kšœœ˜)Kšœœ
˜—Kšœœ
œœD˜hšœœ˜Kš
œ9˜9Kš
œ?˜?Kš
œ5˜5Kš
œ7˜7K˜
—šœ˜š
žœœœœ	œ˜@šœœ	œ
˜2Kšœ
œ˜)Kšœœ
œœD˜hKšœœ
œ%œ˜FKšœœ
˜
Kšœ%œ	˜9šœ˜Kšœ
œ$œ
œ
˜5Kšœ™
œœ˜«
Kš
œ˜—Kšœœ
œ
˜Kšœ
˜—Kšœœ
˜K˜—šœœ
œœ˜IKšœ
˜	Kšœ8˜<—Kš
œ˜—K˜Kšœ
œœ
œ
˜&K˜K˜—šžœœœœŸ 
Ÿœ
œ
œœ˜’
KšœEœ˜LKšœœ
œ
œ:˜^Kš
œR˜RKš
œ˜K˜K˜—šžœœœœœœ˜WKšœœ˜!K˜-šžœœ!œœ˜Bš
˜Kš
œ-˜-šœ˜KšœœŸœ˜%˜	Kšœœœ-˜=šœ˜
Kšœœ
œœ
œœ˜;Kšœœ˜*Kšœœ
˜—K˜—Kšœœ
˜Kšœ
œ
œœ
œœ˜6Kšœ
œ˜$Kšœœ
˜Kšœœ
˜—Kšœ
˜—K˜—Kšœœœ	˜Kšœœ
œœ˜4K˜&š
˜Kš
œ-˜-šœ˜KšœœŸœ˜%˜	Kšœœœ-˜=šœ˜
Kšœœ
˜Kš
œœ
œ
œœ
œœ˜[Kšœ1œ
œ
œœ
œœ
œœ˜”
Kšœ
œ
œ
œœ
œœ
œœ˜pKš
œœœ	œœ
œœ˜ZKšœœ˜"Kšœœœ˜—K˜—Kšœœ4˜UKš
œ
œœ	œœ
œœ˜SKšœ
œœ˜Kšœœ
˜Kšœœ
˜—Kšœ
˜—K˜Kšœœ˜%Kšœœ˜%Kšœ	œ˜'Kšœ
œ˜'Kšœœ˜)Kšœœ˜&Kšœ
œ˜'K˜—šž
œœœœ˜9Kš
œ6˜6Kšœœœ;œ˜SKšœœ˜Kš	œœ
œœ
œ	˜K˜Kšœœ
œœ˜"Kšœœ˜$K˜Kšœœ
œœ˜*šœœœ˜)šœ˜Kšœœ
œœ
˜Kšœœœ˜Kšœœœ˜—Kšœ
˜—Kšœœ˜K˜K˜—šž
œœœœ
œ
œœœŸ
œ˜‰
Kšœeœœ˜wK˜5Kšœœ˜K˜@Kšœœ
˜K˜Kšœœ
˜šžœœœ	œ˜:Kš
œ 
˜ 
K˜—šžœœ
œ	œ˜'Kš
œΧ
˜Χ
K˜—šœœœ˜*Kš
œ˜Kšœ œ˜-Kšœœ˜-Kšœœ
˜—Kšœœ
œœD˜hšœœ˜Kš
œ:˜:Kš
œ?˜?Kš
œ>˜>Kš
œ7˜7K˜
—Kšœ8˜<K˜K˜—Kš	œœœ
œ
Ÿ)œ
˜DK˜Kšœœœ˜1šœœœ˜&K˜Kšœ˜K˜—K˜Kšœœœ˜Kšœœœ ˜;K˜Kšœœœ
˜K˜š
žœœœœŸœ˜PKšœœ˜Kšœœ
˜Kšœœ
œœ˜3Kšœœ˜2Kš
œ4˜4Kšœœœœ˜@K˜K˜—šžœœœœ
œ
œœœŸ
œ˜Š
Kš	œœ
œœ
œ˜$Kš
œ˜Kšœ
œ
œ
œ
œœœ&œ˜š
K˜Kšœœ8˜QK˜"K˜Kšœœ
œœ
œ$œ8˜“
Kšœ-œœ˜PK˜K˜—š
œ\˜\K™8—K˜šžœœ9œŸ 
ŸœŸ 
Ÿœ
œ
œœœ˜Ψ
K™FKš
œU™UKšœœ˜1šœœ˜"Kš
œE˜EK˜—Kšœ
œœ
œ
˜*Kšœ
œ
œ˜+šœœ
˜š
œ˜Kšœ,œ<˜lKšœ1œœ˜OK˜—šœœ˜KšœZœœ˜lK˜5Kšžœœ	œœœ	œ œRœœ˜Ύ
Kšžœœ	œœœ	œ œQœœ˜Ύ
Kš
œN˜NKšœœœœ
œœ˜2K˜@Kšœœ
˜Kšœœ
˜K˜Kšœ	œœ1˜IKšœœ
˜šžœœœ	œ˜:Kš
œΐ
˜ΐ
K˜—šžœœ
œ	œ˜'Kš
œχ
˜χ
K˜—šœœ˜$Kš
œ#˜#Kšœ œ˜-Kšœœ˜-Kšœœ
˜—Kšœœ
œœ?˜cKšœ	œœ˜!šœœ˜Kš
œ8˜8Kš
œ;˜;Kš
œa˜aK˜
—Kš
œ˜š
œœœœ
œ˜"Kšœœ
œ#˜/šœœ
œ˜šœœœ
˜Kš
œW˜Wšœ$œ˜+Kšœ:˜>Kšœ‘
˜•
—Kšœ•
œ#˜½
Kšœœ
˜—Kšœ˜
—K˜—šœ
œœ˜Kšœœ/˜8Kšœ	œ˜Kš
œ«
˜«
Kšœœ˜Kšœœ˜Kšœœœ\˜qš
žœœœœ	œ˜8Kšœœ
˜šœ
œ˜Kš
ϥ
˜•
Kšœ
œœ
œ
˜Kšœ
œ#œœ˜RKšœ
˜—K˜—šžœœ
œ	œ˜'Kšœœ˜#Kšœœ
˜šœ
œ˜Kš
œ­
˜­
Kšœ
œœ
œ
˜Kšœ
œ#œ*œ˜^Kšœ
˜—K˜—Kšœ	œœ6˜Nšœœ˜$Kš
œ˜Kšœœ˜*Kšœœ˜*Kšœœ
˜—Kšœœ
œœ?˜cKšœ	œœ˜!šœœ˜Kš
œZ˜ZKš
œ4˜4K˜—K˜—š
œœœœ
œ˜"šœBœœ
˜XKš
œ.˜.Kšœœ
œœ?˜cKšœœ
œ%œ˜FKšœœ
˜
Kšœ.œ	˜Bšœ˜Kšœ
œ-œ
œ
˜>Kšœjœ7œœ˜Έ
Kš
œ˜—Kšœœ
œ˜Kšœ
˜—K˜—š
œœœœ
œ˜5Kšœ	œœE˜]KšœTœ˜[šœœ
œ˜ Kš
œQ˜QKšœœ
˜
Kšœ/œ7œœ˜}Kšœœ
œ˜K˜—Kšœ	œœ˜!K˜—Kšœ
œœ
œ3˜JKš
œ7˜7Kšœ
œœ
œ˜šœœ
œ˜*Kš
œ˜šœœ˜+Kš
œ˜Kš
œ˜Kšœœ˜——K˜Kšœ
œ
œ
œœXœœœ
˜Ί
Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜šœœ˜šœ
œœ˜%K˜&šœœ	œ
˜Kšœœœ˜'Kšœœ
˜—Kš
œ'œœœœ˜bK˜
—šœ
œœ˜&K˜•StartOfExpansion6[list: 
LIST OF ROPE, r: 
ROPE, case: 
BOOL _ TRUE]šœœœœ˜YKš
œ˜K˜šœœ
œœ˜?K˜'šœœ	œ
˜Kšœœœ˜'Kšœœ
˜—Kšœ6œœœ˜bK˜—K˜—K˜—K˜—Kš
œ˜K˜—Kšœœ
˜—Kšœ˜K˜Kšœ
œœ
œ
˜&K˜—K˜Kšœ
œN˜_K˜šž
œœœ
œœœ˜JK™XKš
œ˜šœ˜Kšœœ)˜3šœ˜šœ	œ˜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˜—šž
œœ˜š
˜šœ
œ
˜Kšœœ
˜Kšœœ
˜Kšœœœ
˜+Kšœœ
˜Kšœœ
˜Kšœœ
˜Kšœœ
˜—Kšœ
˜Kšœ
˜—K˜K˜—šžœœœ˜DK˜K˜š
˜K˜šœ˜˜Kšœœ
˜!Kšœ
œœ˜-Kšœœ˜"K˜—˜	šœœ
œœ˜=Kšœœ-˜7K˜K˜
—Kšœœ˜"K˜—Kšœœ
˜—Kšœ
˜—K˜K˜—š
žœœœœœ˜YKšœWœ˜^Kšœœ
œ
œE˜iKšœG˜MK˜—šžœœ8œŸ 
Ÿœ
œ
œœ˜₯
KšœHœ˜OKšœœ
œ
œV˜zKš
œR˜RKšœ&œœœ˜TK˜K˜—šœœœœœœ˜3Kšœœœœ˜1Kšœœœ
˜K˜—š
ž	œœ
œŸ 
Ÿœ˜=Kš
œ=˜=K˜K˜—šž	œœœ
œœœŸœ˜OKšœœ˜Kš
œt˜tK˜K˜—šžœœœœ˜:šœœ
˜Kšœœ ˜'Kš
œN˜NKšœœ
˜—K˜K˜—šžœœœ
œœœ
˜5Kšœœ
œœ˜1K˜—š
žœœœœœ
˜/Kšœœ9˜AK˜—šž
œœœ
œœ	œ˜CKšœœ˜Kšœœ˜Kšœ'œ*œœ˜yK˜K˜—šžœœœ	œ˜@šœœœ
˜šœœœœ
˜Kšœœ˜Kšœœ
˜Kšœœ
˜—šœœœ
˜(Kšœœœ
˜Kšœ6œ˜QKšœœ
˜—Kšœœ
˜—K˜K˜—šžœœœœ˜5šœœœ
˜Kšœœ˜
Kš
œ9˜9Kšœœ
˜—K˜K˜—šžœœœœ˜JKšœ
œ
œ5˜IKšœœ7˜RK˜ Kšœœ
œœE˜eK˜K˜—L™Kšœœœ
˜Kšœ
œœ
˜K˜šžœœ
œ
œœ
œœ9œœŸœ˜—
Kšœœ1˜PKš
œ˜šœ
œœ
œ
Ÿœ
œ
œ
Ÿ	œ
œ
œ˜]Kš
œS˜SKš
œO˜OKš
œT˜T—K˜—šžœœ
œ
œœ
œœ9œœŸœ˜›
Kšœœ2˜QKš
œ˜šœœœ
œ
Ÿœ
œ
œ
Ÿ	œ
œ
œ˜^Kš
œ;˜;Kš
œ;˜;Kš
œ\˜\—K˜—Kšž
œœœœœœœœŸœ0œœ	˜»
K˜KšžœœœœœœœœŸœ0œœ	˜Ύ
K˜KšžœœœœœœœœŸœ0œœ	˜Γ
K˜KšžœœœœœœœœŸœ0œœ	˜Γ
K˜KšžœœœœœœœœŸœ0œœ˜Σ
K˜Kšœœ˜'K˜šžœœ!œœœœœœŸœ˜—
Kšœ
œ˜.Kšœœœ
˜Kšœ
œœ
œœœ˜-Kšœ
œ
˜Kšœœ
˜šœœ˜Kš	œœœ	œ"œ)˜hK˜Kšœ
˜K˜—Kš
œ
˜
Kš
œ
˜
K˜Kšœœ
˜
Kšœœœ
˜šž	œœ˜šœ
˜Kšœœ˜Kšœœœ˜;K˜Kš
˜K˜—Kš
œH˜Hšœ	œ˜KšœœœœN˜tKšœœ
˜Kšœœ˜Kšœœ ˜4K˜Wšœ˜Kšœ=œ˜DKš
œC˜CKš
œM˜MKšœœ
˜—Kš
œ˜—Kš
œ˜Kšœ˜—šž	œœJ˜YKš	œœœ
œ
œ˜aKšœœ+œœ˜eKšœœ
œœ
˜5K˜-Kš
œE˜EKš
œJ˜Jšœ	œ˜Kšœ'œ;˜hKš
œr˜rKšœ
˜K˜—šœœ˜K˜Kš
œ˜Kš
œ˜Kš
œ˜K˜Kšœœ
˜K˜)K˜!K˜<K˜Kšœ&œ˜6K˜
—šœ˜K˜Kšœ.œ
œœ˜aK˜—K˜—Kšœ	œ$œ
˜DKšœœ
œ œœœœ˜RK˜Kšœœ
œœ
˜Kšœ	œœ
˜—K˜š
ž
œœœ
œŸœ˜BKšœœœ˜Kšœœ	œ
˜&Kšœœœ˜.Kšœœ%˜/Kšœœ:˜CKš
œY˜Yšœœ
œ˜Kšœœ-˜5K˜Kšœ
˜K˜—Kšœ"œ˜)K˜—K˜šžœœ
œœœœ˜dKš
œ!™!šž
œœJ˜ZKš
œJ˜JKš
œU˜UK˜K˜K˜Kšœœ
˜Kšœœ$œœ˜NK˜)K˜!K˜=Kšœ&œ˜7Kš
œ&™&K˜—K˜JK˜K˜—šžœœ œ˜UKš
œ˜Kšœœ
œœ
œ
œ
˜FK˜K˜K˜—L™šžœœ1Ÿ"œ˜hKšœ4œ˜:Kšœ?œ˜EKšœ5œ˜<Kšœ1œ˜7K˜K˜—š
žœœ
œ
œ
œ
˜5Kš
œ%˜%K˜—šžœœ˜Kšœ$œœ˜AKš
œ2˜2Kš
œ9˜9Kš
œ?˜?Kš
œ?˜?Kš
œO˜OKš
œ?˜?Kš
œI˜IKš
œ0˜0K˜$K˜ K˜&K˜—K˜Kš
œ˜K˜Kšœ
˜—…—2·Š