DIRECTORY
Atom USING [GetPName, MakeAtom],
EditSpan USING [CompareNodeOrder, NodeOrder],
MessageWindow USING [Append],
NodeProps USING [CopyInfoProc, GetProp, MapProps, NullCopy, NullRead, NullWrite, PutProp, ReadSpecsProc, Register, RemProp, WriteSpecsProc],
NodeStyleOps USING [StyleNameForNode],
PutGet USING [FromFile, ToFile],
Rope USING [Concat, FromChar, IsEmpty, Map, ROPE],
RunReader USING [Backwards, FreeRunReader, Get, GetRunReader, Ref, SetPosition],
TEditDocument USING [Selection, SpinAndLock, TEditDocumentData, Unlock],
TEditDocumentPrivate USING [CloseAndOpenPreviousFile, DefaultMenus, DoCloseAndNewViewer, DoCloseAndOpenImplFile, DoLoadFile, DoLoadImplFile, DoNewViewer, DoOpenFile, DoOpenImplFile, DoStoreFile, EmptyViewer, JumpToPrevious, LoadPreviousFile, OpenPreviousFile, Reselect, Reset, Save],
TEditInput USING [AllLevels, CloseEvent, CommandProc, FewerLevels, FirstLevelOnly, FreeTree, MoreLevels, Normalize, Register, UnRegister],
TEditInputOps USING [CallWithLocks, DoFindPlaceholders, DoNextViewer, DoSelectMatchingBrackets],
TEditOps USING [RememberCurrentPosition],
TEditProfile USING [selectionCaret],
TEditRefresh USING [ScrollToEndOfSel],
TEditScrolling USING [ScrollToPosition],
TEditSelection USING [FindWhere, MakeSelection, Position, pSel, SetSelLooks],
TextEdit USING [FetchLooks, FromRope, SetLooks, Size],
TextFind USING [Finder, MalformedPattern, PatternErrorCode],
TextFindPrivate USING [FinderRecord],
TextLooks USING [Look, Looks, LooksAnd, noLooks, Runs],
TextNode USING [Body, FirstChild, FirstSibling, LastChild, LastLocWithin, LastSibling, LastWithin, Location, NarrowToTextNode, Next, NodeProps, Parent, Previous, Ref, Root, StepBackward, StepForward],
TiogaExtraOps USING [MapPropsAction],
TiogaMenuOps USING [],
TiogaOps USING [CommandProc, CommentControl, Dir, Finder, FinderRec, Pattern, PatternErrorCode, PatternRec, SearchDir, SetSelection],
TiogaOpsDefs USING [Location, Order, WhichSelection],
TreeFind USING [CommentControl, Create, CreateFromRope, Try, TryBackwards],
ViewerClasses USING [Column, Viewer];

TiogaOps2Impl: CEDAR PROGRAM
IMPORTS Atom, EditSpan, MessageWindow, NodeProps, NodeStyleOps, PutGet, Rope, RunReader, TEditDocument, TEditDocumentPrivate, TEditInput, TEditInputOps, TEditOps, TEditProfile, TEditRefresh, TEditScrolling, TEditSelection, TextEdit, TextFind, TextNode, TiogaOps, TreeFind
EXPORTS TiogaOpsDefs, TiogaOps, TiogaMenuOps, TiogaExtraOps
~ BEGIN

ROPE: TYPE ~ Rope.ROPE;
Viewer: TYPE ~ ViewerClasses.Viewer;
Column: TYPE ~ ViewerClasses.Column;

Node: TYPE = REF NodeBody; -- points to a Tioga node
NodeBody: PUBLIC TYPE = TextNode.Body; -- export opaque type

Finder: TYPE = REF FinderRec;
FinderRec: PUBLIC TYPE = TextFindPrivate.FinderRecord; -- export opaque type

MakeName: PROC [r: ROPE] RETURNS [ATOM] ~ {
RETURN [IF r.IsEmpty THEN NIL ELSE Atom.MakeAtom[r]];
};
LooksRope: PROC [looks: TextLooks.Looks] RETURNS [r: ROPE] = {
FOR c: CHAR IN TextLooks.Look DO
IF looks[c] THEN r _ Rope.Concat[r, Rope.FromChar[c]];
ENDLOOP
};

RopeToLooks: PROC [r: ROPE] RETURNS [looks: TextLooks.Looks] = {
Set: PROC [c: CHAR] RETURNS [quit: BOOL _ FALSE] = { looks[c] _ TRUE };
[] _ Rope.Map[base: r, action: Set];
};

tiogaOpsEcFromTextFindEc: ARRAY TextFind.PatternErrorCode OF TiogaOps.PatternErrorCode _ [
toobig: toobig,
endquote: endquote,
endtilda: endtilda,
boundary: boundary,
missingNameEnd: missingNameEnd,
unmatchedNameEnd: unmatchedNameEnd
];

MalformedPattern: PUBLIC ERROR [ec: TiogaOps.PatternErrorCode] ~ CODE;

ReportMalformedPattern: PROC [textFindEc: TextFind.PatternErrorCode] ~ {
tiogaOpsEc: TiogaOps.PatternErrorCode ~ tiogaOpsEcFromTextFindEc[textFindEc];
ERROR MalformedPattern[tiogaOpsEc];
};

CreateGeneralPattern: PUBLIC PROC [
target: Node, -- node from which to get the pattern
text: BOOL _ TRUE, -- if true, match target text
looks: BOOL _ FALSE, -- if true, match target looks
format: BOOL _ FALSE, -- if true, match target format
style: BOOL _ FALSE, -- if true, match target style
comment: BOOL _ FALSE, -- if true, match target comment property
case: BOOL _ TRUE, -- if true, match case
literal: BOOL _ FALSE, -- if true, treat target literally rather than as a pattern
word: BOOL _ FALSE, -- if true, match words only
subset: BOOL _ TRUE, -- if true, use subset for looks test, else use equality
addBounds: BOOL _ FALSE] -- if true, add |'s to both ends of pattern
RETURNS [pattern: TiogaOps.Pattern] = {
error: BOOL _ FALSE;
errorCode: TextFind.PatternErrorCode;
txt: Node = TextNode.NarrowToTextNode[target];
patternTxt: Node _ txt;
pattern _ NEW[TiogaOps.PatternRec];
IF looks AND ~text THEN { -- make a phony search pattern and get the looks
size: INT = TextEdit.Size[txt];
lks: TextLooks.Looks = IF size=0 THEN TextLooks.noLooks ELSE TextEdit.FetchLooks[txt,0];
pattern.searchLooks _ LooksRope[lks];
FOR i: INT IN [1..size) DO
IF TextEdit.FetchLooks[txt,i]#lks THEN {

MessageWindow.Append["Search pattern does not have uniform looks.",TRUE];
MessageWindow.Append["  Using looks from first char."];
EXIT 
};
ENDLOOP;
literal _ FALSE;
patternTxt _ TextEdit.FromRope["#*"];
TextEdit.SetLooks[NIL, patternTxt, lks];
};
pattern.text _ text;
pattern.looks _ looks;
pattern.word _ word;
pattern.looksExact _ ~subset;
pattern.commentControl _ IF ~comment OR txt=NIL THEN includeComments
ELSE IF txt.comment THEN commentsOnly ELSE excludeComments;
pattern.checkFormat _ format;
pattern.format _ IF target=NIL OR target.formatName=NIL THEN NIL ELSE
Atom.GetPName[target.formatName];
pattern.checkStyle _ style;
pattern.style _ IF ~style THEN NIL ELSE Atom.GetPName[NodeStyleOps.StyleNameForNode[target]];
IF text OR looks THEN { -- create a description of the pattern
pattern.finder _ TreeFind.Create[patternTxt, literal, word, ~looks, ~case, addBounds !
TextFind.MalformedPattern => { errorCode _ ec; error _ TRUE; CONTINUE }];
};
IF error THEN ReportMalformedPattern[errorCode];
};

CreateSimplePattern: PUBLIC PROC [
target: ROPE, -- node from which to get the pattern
case: BOOL _ TRUE, -- if true, match case
literal: BOOL _ FALSE, -- if true, treat target literally rather than as a pattern
word: BOOL _ FALSE, -- if true, match words only
addBounds: BOOL _ FALSE] -- if true, add |'s to both ends of pattern
RETURNS [pattern: TiogaOps.Pattern] = {
error: BOOL _ FALSE;
errorCode: TextFind.PatternErrorCode;
pattern _ NEW[TiogaOps.PatternRec];
pattern.text _ TRUE;
pattern.looks _ FALSE;
pattern.word _ word;
pattern.commentControl _ includeComments;
pattern.checkFormat _ FALSE;
pattern.format _ NIL;
pattern.checkStyle _ FALSE;
pattern.style _ NIL;
pattern.finder _ TreeFind.CreateFromRope[target, literal, word, ~case, addBounds !
TextFind.MalformedPattern => { errorCode _ ec; error _ TRUE; CONTINUE }];
IF error THEN ReportMalformedPattern[errorCode];
};

FindCC: PROC [cc: TiogaOps.CommentControl] RETURNS [TreeFind.CommentControl] = {
RETURN [SELECT cc FROM
includeComments => includeComments,
excludeComments => excludeComments,
commentsOnly => commentsOnly,
ENDCASE => ERROR] 
};

SelectionSearch: PUBLIC PROC [
pattern: TiogaOps.Pattern, whichDir: TiogaOps.SearchDir _ forwards, interrupt: REF BOOL _ NIL,
startBoundaryNode, endBoundaryNode: Node _ NIL,
startBoundaryOffset: INT _ 0, endBoundaryOffset: INT _ LAST[INT]]
RETURNS [found: BOOL] = {
pSel: TEditDocument.Selection = TEditSelection.pSel;
Found: PROC [tSel: TEditDocument.Selection] = {
tSel.viewer _ pSel.viewer;
tSel.data _ pSel.data;
TEditOps.RememberCurrentPosition[pSel.viewer];
TEditSelection.SetSelLooks[tSel];
TEditSelection.MakeSelection[new: tSel];
TEditInput.CloseEvent[];
TEditRefresh.ScrollToEndOfSel[tSel.viewer, FALSE] 
};
Locations: PROC RETURNS [start, end: TextNode.Location] = {
start _ pSel.start.pos; end _ pSel.end.pos 
};
found _ DoSearch[pattern, whichDir, interrupt, Found, Locations,
startBoundaryNode, endBoundaryNode,
startBoundaryOffset, endBoundaryOffset] 
};

DocLoc: PROC [loc: TiogaOpsDefs.Location] RETURNS [TextNode.Location] = {
RETURN [[loc.node, loc.where]] 
};

MyLoc: PROC [loc: TextNode.Location] RETURNS [TiogaOpsDefs.Location] = {
RETURN [[loc.node, loc.where]] 
};

NodeSearch: PUBLIC PROC [
pattern: TiogaOps.Pattern, whichDir: TiogaOps.SearchDir _ forwards,
startLoc, endLoc: TiogaOpsDefs.Location, interrupt: REF BOOL _ NIL,
startBoundaryNode, endBoundaryNode: Node _ NIL,
startBoundaryOffset: INT _ 0, endBoundaryOffset: INT _ LAST[INT]]
RETURNS [found: BOOL, start, end: TiogaOpsDefs.Location] = {
Found: PROC [tSel: TEditDocument.Selection] = {
start _ MyLoc[tSel.start.pos]; end _ MyLoc[tSel.end.pos] 
};
Locations: PROC RETURNS [start, end: TextNode.Location] = {
start _ DocLoc[startLoc]; end _ DocLoc[endLoc] 
};
found _ DoSearch[pattern, whichDir, interrupt, Found, Locations,
startBoundaryNode, endBoundaryNode,
startBoundaryOffset, endBoundaryOffset] 
};

DoSearch: PROC [
pattern: TiogaOps.Pattern, whichDir: TiogaOps.SearchDir _ forwards, interrupt: REF BOOL _ NIL,
foundProc: PROC [tSel: TEditDocument.Selection],
locationProc: PROC RETURNS [start, end: TextNode.Location],
startBoundaryNode, endBoundaryNode: Node _ NIL,
startBoundaryOffset: INT _ 0, endBoundaryOffset: INT _ LAST[INT]]
RETURNS [found: BOOL] = {
at, atEnd, offset: INT;
first: Node;
where: Node;
startLoc, endLoc: TextNode.Location;

DoLookForPattern: PROC [root: Node, tSel: TEditDocument.Selection] = {
Forwards: PROC = {
IF (offset _ endLoc.where+1) >=
TextEdit.Size[TextNode.NarrowToTextNode[first _ endLoc.node]] THEN {
first _ TextNode.StepForward[first]; offset _ 0 
};
[found,where,at,atEnd,,] _
TreeFind.Try[finder: pattern.finder, first: first, start: offset,
last: endBoundaryNode, lastLen: endBoundaryOffset,
interrupt: interrupt,
looksExact: pattern.looksExact,
checkFormat: pattern.checkFormat,
format: MakeName[pattern.format],
commentControl: FindCC[pattern.commentControl],
checkStyle: pattern.checkStyle,
style: MakeName[pattern.style],
styleProc: NodeStyleOps.StyleNameForNode] 
};

Backwards: PROC = {
IF (offset _ startLoc.where)=0 THEN {
first _ TextNode.StepBackward[startLoc.node];
offset _ LAST[INT] 
}
ELSE first _ startLoc.node;
[found,where,at,atEnd,,] _
TreeFind.TryBackwards[finder: pattern.finder,
first: first, len: offset,
last: startBoundaryNode, lastStart: startBoundaryOffset,
interrupt: interrupt,
looksExact: pattern.looksExact,
checkFormat: pattern.checkFormat,
format: MakeName[pattern.format],
commentControl: FindCC[pattern.commentControl],
checkStyle: pattern.checkStyle,
style: MakeName[pattern.style],
styleProc: NodeStyleOps.StyleNameForNode] 
};

[startLoc, endLoc] _ locationProc[];
IF interrupt#NIL THEN interrupt^ _ FALSE;
SELECT whichDir FROM
forwards => Forwards[];
backwards => Backwards[];
anywhere => {
Forwards[];
IF found THEN whichDir _ forwards ELSE {
whichDir _ backwards; Backwards[] 
}
};
ENDCASE => ERROR;
IF ~found OR where=NIL THEN RETURN;
IF pattern.looks AND ~pattern.text AND ~pattern.word THEN
[at,atEnd] _ Extend[whichDir=forwards,
pattern.looksExact, RopeToLooks[pattern.searchLooks], where, at, atEnd];
tSel.start.pos _ [where,at];
tSel.end.pos _ [where,MAX[0,atEnd-1]];
tSel.granularity _
IF ~pattern.looks AND ~pattern.text THEN node
ELSE IF pattern.word THEN word ELSE char;
tSel.insertion _ IF TEditProfile.selectionCaret=before THEN before ELSE after;
foundProc[tSel];
};

TEditInputOps.CallWithLocks[DoLookForPattern, read] 
};

Extend: PROC [forward, looksExact: BOOL, searchLooks: TextLooks.Looks,
where: Node, at, atEnd: INT,
last: Node _ NIL, lastLen: INT _ LAST[INT]]
RETURNS [newAt, newAtEnd: INT] = {
runrdr: RunReader.Ref _ RunReader.GetRunReader[];
looks: TextLooks.Looks;
runLen: INT;
runs: TextLooks.Runs _ where.runs;
IF forward THEN { -- extend toward end of node
size: INT ~ TextEdit.Size[where];
IF atEnd<size THEN {
lastLen _ IF where=last THEN MIN[size,lastLen] ELSE size;
RunReader.SetPosition[runrdr,runs,atEnd];
WHILE atEnd < lastLen DO
IF runs=NIL THEN { runLen _ size-atEnd; looks _ TextLooks.noLooks }
ELSE [runLen,looks] _ RunReader.Get[runrdr];
IF ~looksExact THEN looks _ TextLooks.LooksAnd[looks,searchLooks];
IF searchLooks # looks THEN EXIT;
atEnd _ atEnd+runLen;
ENDLOOP;
atEnd _ MIN[atEnd,lastLen];
};
}
ELSE IF at>0 THEN { -- extend backward
RunReader.SetPosition[runrdr,runs,at];
WHILE at > 0 DO
IF runs=NIL THEN { runLen _ at; looks _ TextLooks.noLooks }
ELSE [runLen,looks] _ RunReader.Backwards[runrdr];
IF ~looksExact THEN looks _ TextLooks.LooksAnd[looks,searchLooks];
IF searchLooks # looks THEN EXIT;
at _ at-runLen;
ENDLOOP;
};
RunReader.FreeRunReader[runrdr];
RETURN[at, atEnd];
};

SelectMatchingBrackets: PUBLIC PROC [before, after: CHAR] RETURNS [found: BOOL] = {
found _ TEditInputOps.DoSelectMatchingBrackets[before, after] 
};

NextPlaceholder: PUBLIC PROC [dir: TiogaOps.Dir _ forward, gotoend: BOOL,
startBoundaryNode, endBoundaryNode: Node _ NIL,
startBoundaryOffset: INT _ 0, endBoundaryOffset: INT _ LAST[INT]]
RETURNS [found, wenttoend: BOOL] = {
[found, wenttoend] _ TEditInputOps.DoFindPlaceholders[
dir=forward, gotoend,
startBoundaryNode, endBoundaryNode,
startBoundaryOffset, endBoundaryOffset] 
};

NextViewer: PUBLIC PROC [dir: TiogaOps.Dir _ forward] RETURNS [found: BOOL] = {
found _ TEditInputOps.DoNextViewer[dir=forward] 
};

SearchWhere: PROC [whichDir: TiogaOps.SearchDir] RETURNS [TEditSelection.FindWhere] = INLINE {
RETURN [SELECT whichDir FROM
forwards => forwards,
backwards => backwards,
anywhere => anywhere,
ENDCASE => ERROR] 
};
Position: PUBLIC PROC [viewer: Viewer] = {
TEditSelection.Position[viewer];
};

Normalize: PUBLIC PROC [viewer: Viewer] = {
[] _ TEditInput.Normalize[viewer];
};

PrevPlace: PUBLIC PROC [viewer: Viewer] = {
TEditDocumentPrivate.JumpToPrevious[viewer];
};

Reselect: PUBLIC PROC [viewer: Viewer] = {
TEditDocumentPrivate.Reselect[viewer];
};
Save: PUBLIC PROC [viewer: Viewer] = {
TEditDocumentPrivate.Save[viewer];
};

Load: PUBLIC PROC [viewer: Viewer, fileName: ROPE _ NIL,
fileNameProcViewer: Viewer _ NIL] = {
[] _ TEditDocumentPrivate.DoLoadFile[viewer, fileName, FALSE, fileNameProcViewer];
};

Open: PUBLIC PROC [fileName: ROPE _ NIL, fileNameProcViewer: Viewer _ NIL, column: Column _ left] RETURNS [Viewer] = {
RETURN [TEditDocumentPrivate.DoOpenFile[fileName, column, fileNameProcViewer]];
};

CloseAndOpen: PUBLIC PROC [viewer: Viewer, fileName: ROPE _ NIL, fileNameProcViewer: Viewer _ NIL] RETURNS [Viewer] = {
RETURN [TEditDocumentPrivate.DoLoadFile[viewer, fileName, TRUE, fileNameProcViewer]];
};

LoadImpl: PUBLIC PROC [viewer: Viewer, fileName: ROPE _ NIL] = {
[] _ TEditDocumentPrivate.DoLoadImplFile[viewer, fileName];
};

OpenImpl: PUBLIC PROC [fileName: ROPE _ NIL, column: Column _ left] RETURNS [Viewer] = {
RETURN [TEditDocumentPrivate.DoOpenImplFile[fileName, column]];
};

CloseAndOpenImpl: PUBLIC PROC [viewer: Viewer, fileName: ROPE _ NIL] RETURNS [Viewer] = {
RETURN [TEditDocumentPrivate.DoCloseAndOpenImplFile[viewer, fileName]];
};

LoadPreviousFile: PUBLIC PROC [parent: Viewer] = {
TEditDocumentPrivate.LoadPreviousFile[parent];
};

OpenPreviousFile: PUBLIC PROC [parent: Viewer] = {
TEditDocumentPrivate.OpenPreviousFile[parent];
};

CloseAndOpenPreviousFile: PUBLIC PROC [parent: Viewer] = {
TEditDocumentPrivate.CloseAndOpenPreviousFile[parent];
};

DefaultMenus: PUBLIC PROC [viewer: Viewer, paint: BOOL _ FALSE] = {
TEditDocumentPrivate.DefaultMenus[viewer, paint];
};

Store: PUBLIC PROC [viewer: Viewer, fileName: ROPE _ NIL] = {
TEditDocumentPrivate.DoStoreFile[viewer, fileName];
};

New: PUBLIC PROC [column: Column _ left] RETURNS [Viewer] = {
RETURN [TEditDocumentPrivate.DoNewViewer[column]];
};

Empty: PUBLIC PROC [viewer: Viewer] = {
TEditDocumentPrivate.EmptyViewer[viewer];
};

CloseAndNewViewer: PUBLIC PROC [viewer: Viewer] RETURNS [Viewer] = {
RETURN [TEditDocumentPrivate.DoCloseAndNewViewer[viewer]];
};

Reset: PUBLIC PROC [viewer: Viewer] = {
TEditDocumentPrivate.Reset[viewer];
};

Jump: PUBLIC PROC [viewer: Viewer, loc: TiogaOpsDefs.Location] = {
[] _ TEditScrolling.ScrollToPosition[viewer, [loc.node, loc.where]];
};
FirstLevelOnly: PUBLIC PROC [viewer: Viewer] = { [] _ TEditInput.FirstLevelOnly[viewer] };

MoreLevels: PUBLIC PROC [viewer: Viewer] = { [] _ TEditInput.MoreLevels[viewer] };

FewerLevels: PUBLIC PROC [viewer: Viewer] = { [] _ TEditInput.FewerLevels[viewer] };

AllLevels: PUBLIC PROC [viewer: Viewer] = { [] _ TEditInput.AllLevels[viewer] };

GetRope: PUBLIC PROC [node: Node] RETURNS [ROPE]  = {
RETURN [IF node=NIL THEN NIL ELSE node.rope]
};

Parent: PUBLIC PROC [node: Node] RETURNS [Node] = { RETURN [TextNode.Parent[node]] };

Root: PUBLIC PROC [node: Node] RETURNS [Node] = { RETURN [TextNode.Root[node]] };

Next: PUBLIC PROC [node: Node] RETURNS [Node] = { RETURN [TextNode.Next[node]] };

Previous: PUBLIC PROC [node: Node, parent: Node _ NIL] RETURNS [nx: Node] = { RETURN [TextNode.Previous[node]] };

StepForward: PUBLIC PROC [node: Node] RETURNS [nx: Node] = { RETURN [TextNode.StepForward[node]] };

StepBackward: PUBLIC PROC [node: Node, parent: Node _ NIL] RETURNS [back: Node] = { RETURN [TextNode.StepBackward[node, parent]] };

FirstSibling: PUBLIC PROC [node: Node] RETURNS [Node] = { RETURN [TextNode.FirstSibling[node]] };

LastSibling: PUBLIC PROC [node: Node] RETURNS [Node] = { RETURN [TextNode.LastSibling[node]] };

LastWithin: PUBLIC PROC [node: Node] RETURNS [Node] = { RETURN [TextNode.LastWithin[node]] };

LastLocWithin: PUBLIC PROC [node: Node] RETURNS [TiogaOpsDefs.Location] = {
loc: TextNode.Location ~ TextNode.LastLocWithin[node];
RETURN [[loc.node, loc.where]];
}; 

FirstChild: PUBLIC PROC [node: Node] RETURNS [Node] = { RETURN [TextNode.FirstChild[node]] };

LastChild: PUBLIC PROC [node: Node] RETURNS [Node] = { RETURN [TextNode.LastChild[node]] };

IsDirty: PUBLIC PROC [node: Node] RETURNS [BOOL] = { RETURN [node.dirty] };

IsNew: PUBLIC PROC [node: Node] RETURNS [BOOL] = { RETURN [node.new] };

ClearDirty: PUBLIC PROC [node: Node] = { node.dirty _ FALSE };

ClearNew: PUBLIC PROC [node: Node] = { node.new _ FALSE };

ViewerDoc: PUBLIC PROC [viewer: Viewer] RETURNS [root: Node] = {
tdd: TEditDocument.TEditDocumentData = NARROW[viewer.data];
IF tdd = NIL THEN RETURN [NIL];
[] _ TEditDocument.SpinAndLock[tdd, "ViewerDoc"]; -- make sure nothing else going on
root _ tdd.text;
TEditDocument.Unlock[tdd]
};

PutProp: PUBLIC PROC [n: Node, name: ATOM, value: REF] = {
NodeProps.PutProp[n, name, value] 
};
GetProp: PUBLIC PROC [n: Node, name: ATOM] RETURNS [REF] = {
RETURN [NodeProps.GetProp[n, name]] 
};

RemProp: PUBLIC PROC [n: Node, name: ATOM] = {
NodeProps.RemProp[n, name] 
};

MapProps: PUBLIC PROC [n: Node, action: TiogaExtraOps.MapPropsAction, formatFlag, commentFlag: BOOL _ TRUE] RETURNS [BOOL] = {
RETURN [NodeProps.MapProps[n, action, formatFlag, commentFlag]]
};


RegisterPropProc: PUBLIC PROC [name: ATOM, 
reader: NodeProps.ReadSpecsProc, writer: NodeProps.WriteSpecsProc, copier: NodeProps.CopyInfoProc] = {
NodeProps.Register[name, reader, writer, copier];
};

NullRead: PUBLIC NodeProps.ReadSpecsProc = { [] _ NodeProps.NullRead[name, specs] };
NullWrite: PUBLIC NodeProps.WriteSpecsProc = { [] _ NodeProps.NullWrite[name, value] };
NullCopy: PUBLIC NodeProps.CopyInfoProc = { [] _ NodeProps.NullCopy[name, value] };

NodeOrder: PROC [order: EditSpan.NodeOrder] RETURNS [TiogaOpsDefs.Order] = {
RETURN [SELECT order FROM before => before, same => same, after => after, disjoint => disjoint, ENDCASE => ERROR] };

CompareLocOrder: PUBLIC PROC [loc1, loc2: TiogaOpsDefs.Location] RETURNS [order: TiogaOpsDefs.Order] = {
order _ NodeOrder[EditSpan.CompareNodeOrder[loc1.node, loc2.node]];
IF order=same THEN order _ SELECT loc1.where FROM
< loc2.where => before,
= loc2.where => same,
ENDCASE => after };

CompareNodeOrder: PUBLIC PROC [node1, node2: Node] RETURNS [order: TiogaOpsDefs.Order] = {
RETURN [NodeOrder[EditSpan.CompareNodeOrder[node1, node2]]] };

GetFile: PUBLIC PROC [name: ROPE] RETURNS [root: Node] = {
RETURN [PutGet.FromFile[name]] };

PutFile: PUBLIC PROC [name: ROPE, root: Node] = { [] _ PutGet.ToFile[name, root] };

FreeTree: PUBLIC PROC [root: Node] = { TEditInput.FreeTree[root] };
SelectPoint: PUBLIC PROC [viewer: Viewer, caret: TiogaOpsDefs.Location, which: TiogaOpsDefs.WhichSelection _ primary] = {
TiogaOps.SetSelection[viewer: viewer, start: caret, end: caret, level: point, which: which];
};

RegisterCommand: PUBLIC PROC [name: ATOM, proc: TiogaOps.CommandProc, before: BOOL _ TRUE] = {
TEditInput.Register[name, proc, before]
};

UnRegisterCommand: PUBLIC PROC [name: ATOM, proc: TiogaOps.CommandProc] = {
TEditInput.UnRegister[name, proc]
};

END.

ΜTiogaOps2Impl.mesa
Copyright Σ 1985, 1987, 1988 by Xerox Corporation.  All rights reserved.
written by Bill Paxton. June 1982
last written by Paxton. December 30, 1982 11:13 am
Last Edited by: Maxwell, January 6, 1983 11:48 am
Russ Atkinson (RRA) January 23, 1986 0:02:15 am PST
Michael Plass, October 16, 1987 5:21:07 pm PDT
Rick Beach, March 28, 1985 10:15:04 am PST
Doug Wyatt, February 17, 1988 11:28:45 am PST
Search 
Places menu commands 
Files and text viewers 
Levels menu commands 
TiogaExtraOps Implementation 
Miscellaneous operations on nodes 
Node Property Lists


read, write, copy props
Comparing order of nodes or locations in document


File I/O


Make point selection

Command registration


Κu˜
codeš
œ™Kš
œH™HKš
œ!™!Kš
œ2™2Kš
œ1™1Kš
œ3™3Kš
œ.™.Kš
œ*™*Kš
œ-™-K˜—š
Οk	˜	Kšœœ˜ Kšœ	œ˜-Kšœœ
˜Kšœ
œ}˜Œ
Kšœ
œ˜&Kšœœ˜ Kšœœ"œ˜2Kšœ
œA˜PKšœœ5˜HKšœœ˜›Kšœœz˜Š
KšœœM˜`Kšœ	œ˜)Kšœ
œ˜$Kšœ
œ˜&Kšœœ˜(Kšœœ9˜MKšœ	œ(˜6Kšœ	œ.˜<Kšœœ˜%Kšœ
œ(˜7Kšœ	œΊ
˜Θ
Kšœœ˜%Kšœ
œ˜Kšœ	œw˜…
Kšœ
œ#˜5Kšœ	œ=˜KKšœœ˜%—K˜KšΠln
œœ
˜Kšœˆ˜Kšœ4˜;šœ˜K˜Kšœœœ
˜Kšœœ˜$Kšœœ˜$K˜KšœœœΟc˜4Kšœ
œ
œŸ˜<K˜Kšœœœ˜Kšœœ
œ!Ÿ˜LK˜š
Οnœœœœœ˜+Kš
œœœ
œ
œ˜5K˜——
headš
œ™š 	œœœœ˜>šœœ
œ˜ Kšœ
œ&˜6Kš
˜—K˜—K˜š œœœœ˜@Kš œœœœœœœ˜GK˜$K˜—K˜šœœœ˜ZK˜K˜K˜K˜K˜K˜"K˜—K˜Kš œœ
œ#œ
˜FK˜š œœ,˜HK˜MKšœ˜#K˜—K˜š œœ
œ˜#KšœŸ%˜3šœœœŸ˜0KšœœœŸ˜3KšœœœŸ˜5KšœœœŸ˜3Kšœ	œœŸ)˜@KšœœœŸ˜)Kšœ	œœŸ;˜RKšœœœŸ˜0KšœœœŸ8˜MKšœœœŸ+˜D—Kšœ ˜'Kšœœœ
˜K˜%K˜.K˜Kšœ
œ˜#šœœœŸ0˜JKšœœ˜Kšœœœœ˜XK˜%šœœ
œ˜šœ œ˜(K˜KšœCœ˜IK˜7Kšœ
˜K˜—Kšœ
˜—Kšœ
œ
˜K˜%Kšœœ˜(K˜—K˜K˜K˜K˜Kš	œœ
œœ
œ˜DKšœ
œ
œœ˜;K˜Kšœœœ
œœ
œ
œ
˜EK˜!K˜Kš	œœœ
œ
œ6˜]šœœœŸ&˜>˜VKšœ7œœ˜I—K˜—Kšœœ#˜0K˜—K˜š œœ
œ˜"KšœœŸ%˜3šœœœŸ˜)Kšœ	œœŸ;˜RKšœœœŸ˜0KšœœœŸ+˜D—Kšœ ˜'Kšœœœ
˜K˜%Kšœ
œ˜#Kšœœ
˜Kšœœ
˜K˜K˜)Kšœœ
˜Kšœœ
˜Kšœœ
˜Kšœœ
˜˜RKšœ7œœ˜I—Kšœœ#˜0K˜—K˜š œœœ˜Pšœœ˜K˜#K˜#K˜Kšœœ˜—K˜—K˜š œœ
œ˜šœOœ
œœ
˜^Kšœ+œ
˜/Kš	œœœœ
œ˜A—Kšœ	œ˜K˜4š œœ$˜/K˜K˜K˜.K˜!K˜(K˜Kšœ+œ˜2K˜—š 	œœ
œ$˜;K˜+K˜—˜@K˜#K˜(—K˜—K˜š œœœ˜IKšœ˜K˜—K˜š œœœ˜HKšœ˜K˜—K˜š 
œœ
œ˜˜CKšœ4œ
œœ
˜CKšœ+œ
˜/Kš	œœœœ
œ˜A—Kšœ	œ(˜<š œœ$˜/K˜9K˜—š 	œœ
œ$˜;K˜/K˜—˜@K˜#K˜(—K˜—K˜š œœ˜šœOœ
œœ
˜^Kšœœ!˜0Kšœœ
œ!˜;Kšœ+œ
˜/Kš	œœœœ
œ˜A—Kšœ	œ˜Kšœœ
˜K˜K˜K˜$K˜š œœ0˜Fš œœ˜Kšœ˜šœ>œ˜DK˜0K˜—˜˜AK˜2K˜K˜K˜!K˜!K˜/K˜K˜K˜*——K˜—K˜š 	œœ˜šœœ˜%K˜-Kšœ	œ
œ˜K˜
—Kšœ˜˜˜-K˜K˜8K˜K˜K˜!K˜!K˜/K˜K˜K˜*——K˜—K˜K˜$Kšœœ
œœ
˜)šœ
˜K˜K˜˜
K˜šœœœ˜(K˜"K˜
—K˜—Kšœœ
˜—Kš
œœœ
œ
œ
˜#Kšœœœ˜9˜&K˜H—K˜Kšœœ
˜&˜Kšœœœ˜-—Kšœ
œœœ˜)Kšœœ$œœ˜NK˜K˜—K˜K˜4K˜—K˜š œœœ˜FKšœœ
˜Kš	œ
œœœ
œ˜+Kšœœ˜"K˜1K˜Kšœœ
˜K˜"šœ	œŸ˜.Kšœœ˜!šœœ˜Kš	œ
œœ
œœ˜9K˜)šœ˜Kšœœ
œ3˜CKšœ(˜,Kšœ
œ/˜BKšœœ
œ
˜!K˜Kšœ
˜—Kšœœ˜K˜—K˜
—šœ
œœŸ˜&K˜&šœ˜Kšœœ
œ+˜;Kšœ.˜2Kšœ
œ/˜BKšœœ
œ
˜!K˜Kšœ
˜—K˜—K˜ Kšœ˜K˜—K˜š œœ
œœœ	œ˜SK˜>K˜—K˜š œœ
œ(œ
˜IKšœ+œ
˜/Kš	œœœœ
œ˜AKšœœ˜$˜6K˜K˜#K˜(—K˜—K˜š
 
œœ
œœ	œ˜OK˜0K˜—K˜š œœ œœ˜^šœœ
˜K˜K˜K˜Kšœœ˜—K˜——š
œ™š œœ
œ˜*K˜ K˜—K˜š 	œœ
œ˜+K˜"K˜—K˜š 	œœ
œ˜+K˜,K˜—K˜š œœ
œ˜*K˜&K˜——š
œ™š œœ
œ˜&K˜"K˜—K˜š
 œœ
œœœ
˜8Kšœœ˜%Kšœ7œ˜RK˜—K˜š œœ
œœœœœ
˜vKšœI˜OK˜—K˜š œœ
œœœœœ
˜wKšœ4œ˜UK˜—K˜š
 œœ
œœœ˜@K˜;K˜—K˜š œœ
œœœœ
˜XKšœ9˜?K˜—K˜š œœ
œœœœ
˜YKšœA˜GK˜—K˜š œœ
œ˜2K˜.K˜—K˜š œœ
œ˜2K˜.K˜—K˜š œœ
œ˜:K˜6K˜—K˜š
 œœ
œœœ˜CK˜1K˜—K˜š
 œœ
œœœ˜=K˜3K˜—K˜š œœ
œœ
˜=Kšœ,˜2K˜—K˜š œœ
œ˜'K˜)K˜—K˜š œœ
œœ
˜DKšœ4˜:K˜—K˜š œœ
œ˜'K˜#K˜—K˜š œœ
œ1˜BK˜DK˜——š
œ™Kš œœ
œ?˜ZK˜Kš 
œœ
œ;˜RK˜Kš œœ
œ<˜TK˜Kš 	œœ
œ:˜PK˜—š
œ™š
œ"™"š
 œœ
œœœ˜5Kšœœœ
œ
œ
œ˜,K˜—K˜Kš
 œœ
œœœ˜UK˜Kš
 œœ
œœœ˜QK˜Kš
 œœ
œœœ˜QK˜Kš œœ
œœœœ˜qK˜Kš
 œœ
œœœ ˜cK˜Kš œœ
œœœœ)˜ƒ
K˜Kš
 œœ
œœœ!˜aK˜Kš
 œœ
œœœ ˜_K˜Kš
 
œœ
œœœ˜]K˜š 
œœ
œœ˜KK˜6Kšœ˜K˜—K˜Kš
 
œœ
œœœ˜]K˜Kš
 	œœ
œœœ˜[K˜Kš œœ
œœœœ˜KK˜Kš œœ
œœœœ˜GK˜Kš 
œœ
œœ˜>K˜Kš œœ
œœ˜:K˜š 	œœ
œœ˜@Kšœ'œ˜;Kš
œœ
œ
œœ˜Kšœ2Ÿ"˜TK˜K˜K˜—K˜—Kš
œ™™š
 œœ
œœ	œ˜:K˜"K˜—K™š œœ
œœœœ˜<Kšœ˜$K˜—K˜š œœ
œœ˜.K˜K˜—K˜š œœ
œJœœœœ˜~Kšœ9˜?K˜——K˜Kš
œ™˜š œœ
œœi˜’
Kš
œ1˜1Kš
œ˜K˜—Kš œœD˜TKš 	œœF˜WKš œœC˜S—K˜š
œ1™1K™š 	œœœ˜LKš
œœœGœœ˜tK˜—š œœ
œ%œ ˜hK•StartOfExpansion.[node1: 
TextNode.Ref, node2: 
TextNode.Ref]š
œC˜Cšœœ	œ˜1K˜K˜Kšœ˜——K˜š œœ
œœ ˜ZKšœ8˜>K˜——K™š
œ™K™š
 œœ
œœœ˜:Kšœ˜!—K˜Kš œœ
œœ3˜SK˜Kš œœ
œ.˜C—K™š
œ™K™š œœ
œa˜yKš
œ\˜\Kš
œ˜K˜——š
œ™K™š œœ
œœ&œœ˜^K˜'K˜—K˜š œœ
œœ!˜KK˜!K˜——K™—K˜Kšœ
˜K˜—…—PBhƒ