-- EditSpanSupportImpl.mesa
-- written by Bill Paxton, June 1981
-- last edit by Bill Paxton, November 9, 1982 10:30 am
Last Edited by: Maxwell, January 5, 1983 12:47 pm
DIRECTORY
EditSpan,
EditSpanSupport,
OtherNode,
TextEdit,
RopeEdit,
TextNode;
EditSpanSupportImpl:
CEDAR MONITOR
IMPORTS EditSpan, EditSpanSupport, TextEdit, TextNode, OtherNode, RopeEdit
EXPORTS EditSpanSupport, EditSpan =
BEGIN
OPEN EditSpanSupport, EditSpan;
-- ***** Slice support routines
freeSlice: Slice; -- free list of slices
numFreeSlices: NAT ← 0;
maxFreeSlices: NAT = 15;
minSliceSize: NAT = 10;
GetSlice:
PUBLIC
ENTRY
PROC [len:
NAT]
RETURNS [slice: Slice] = {
IF freeSlice #
NIL
THEN {
-- look on free list
prev: Slice;
IF freeSlice.maxLength >= len
THEN {
-- take the first from list
slice ← freeSlice; freeSlice ← freeSlice.next;
slice.next ← NIL;
numFreeSlices ← numFreeSlices-1; RETURN };
prev ← freeSlice;
FOR s: Slice ← freeSlice.next, s.next
UNTIL s=
NIL
DO
IF s.maxLength >= len
THEN {
-- take this one
prev.next ← s.next; s.next ← NIL;
numFreeSlices ← numFreeSlices-1; RETURN [s] };
prev ← s;
ENDLOOP };
RETURN [TextNode.pZone.NEW[SliceArray[MAX[len,minSliceSize]]]] };
FreeSlice:
PUBLIC
ENTRY
PROC [slice: Slice] = {
IF slice=
NIL
OR numFreeSlices >= maxFreeSlices
OR slice.maxLength < minSliceSize
THEN RETURN;
FOR i:NAT IN [0..slice.length) DO slice[i] ← NIL; ENDLOOP;
slice.next ← freeSlice; freeSlice ← slice;
numFreeSlices ← numFreeSlices+1 };
MakeSlices:
PROC [node: Ref]
RETURNS [before, after: Slice] = {
--
-- before[0]=root; before[i]=Parent[before[i+1]]; before[before.length-1]=node
-- after[i]=Next[before[i]]
-- if node.child # NIL then after[before.length]=node.child
--
last: NAT;
Slicer:
PROC [node: Ref, height:
NAT]
RETURNS [level:
NAT] = {
height ← height+1;
IF node=
NIL
THEN {
-- have gone beyond root
before ← GetSlice[height]; before.kind ← before;
after ← GetSlice[height+1]; after.kind ← after;
RETURN [0] };
level ← Slicer[TextNode.Parent[node],height];
before[level] ← node;
after[level] ← TextNode.Next[node];
RETURN [level+1] };
IF node=NIL THEN RETURN;
last ← Slicer[node,0];
before.length ← last;
IF node.child # NIL THEN { after[last] ← node.child; after.length ← last+1 }
ELSE after.length ← last;
FOR i:
NAT ← after.length, i-1
DO
-- delete trailing NIL's from after
IF i=0 THEN { after.length ← 0; EXIT };
IF after[i-1] # NIL THEN { after.length ← i; EXIT };
ENDLOOP };
InsertPrefix:
PROC [first, last: Slice, firstLen:
NAT]
RETURNS [new: Slice] = {
--
-- new[i]=first[i] for i in [0..firstLen)
-- new[i+firstLen]=last[i] for i in [0..last.length)
-- new.length=last.length+firstLen
--
newLen: NAT;
IF first =
NIL
OR last =
NIL
OR first.kind # before
OR last.kind # before
OR
first.length < firstLen THEN ERROR;
new ← GetSlice[newLen ← firstLen + last.length];
new.kind ← before; new.length ← newLen;
FOR i: NAT IN [0..firstLen) DO new[i] ← first[i]; ENDLOOP;
FOR i: NAT IN [0..last.length) DO new[firstLen+i] ← last[i]; ENDLOOP };
NeedNestingChange:
PUBLIC
PROC [before, after, top, bottom: Slice, nesting:
INTEGER, depth:
NAT]
RETURNS [NeededNestingChange] = {
bandStart, afterOver: INTEGER;
topLen, botLen: NAT;
nesting ← MIN[1,nesting];
topLen ← top.length; botLen ← bottom.length;
bandStart ← before.length+nesting-(topLen-depth);
IF bandStart <= 0 THEN RETURN [needNest]; -- must be at least 1
afterOver ← after.length-(botLen-depth+bandStart);
IF afterOver > 1 THEN RETURN [needUnNest];
RETURN [ok] };
Splice:
PUBLIC
PROC [before, after: Slice, beforeStart, afterStart:
NAT ← 0] = {
--
-- join slices
-- make after[afterStart+i] be successor of before[beforeStart+i]
-- if more after's than before's, adopt as children of last before
--
a, b: Ref;
beforeLen, afterLen: NAT;
beforeLen ← before.length - beforeStart;
afterLen ← after.length - afterStart;
IF before.kind # before OR after.kind # after THEN ERROR;
IF afterLen > beforeLen+1 THEN ERROR; -- cannot have gaps in tree
b ← LastOfSlice[before];
IF afterLen = beforeLen+1
THEN {
-- adopt children
b.child ← a ← LastOfSlice[after];
IF a # NIL AND beforeLen > 0 THEN TextNode.LastSibling[a].next ← b }
ELSE b.child ← NIL;
IF beforeLen=0 THEN RETURN;
FOR i:
NAT ← beforeLen-1, i-1
DO
-- do successors
b ← before[beforeStart+i];
IF i >= afterLen
OR (a�ter[afterStart+i])=
NIL
THEN {
-- no successor
IF i > 0 THEN { b.next ← before[beforeStart+i-1]; b.last ← TRUE }}
ELSE {
-- has successor
IF a=b THEN RETURN;
IF i > 0 THEN TextNode.LastSibling[a].next ← before[beforeStart+i-1];
b.next ← a; b.last ← FALSE };
IF i=0 THEN RETURN;
ENDLOOP };
ReplaceBand:
PUBLIC
PROC [before, after, top, bottom: Slice, nesting:
INTEGER, event: Event] = {
--
-- do Splices to insert (top-bottom) between (before-after)
-- nesting tells how to offset last of before vs. last of top
-- before[before.length-1+nesting] will be predecessor of top[top.length-1]
--
depth: NAT;
fullBottom: Slice;
nesting ← MIN[1,nesting];
IF top.length >= before.length+nesting THEN ERROR;
depth ← MAX[1,before.length+nesting-top.length];
fullBottom ← InsertPrefix[before,bottom,depth];
Splice[fullBottom,after];
Splice[before,top,depth];
FreeSlice[fullBottom] };
BadBand: PUBLIC ERROR = CODE;
DescribeBand:
PUBLIC
PROC [first, last: Ref]
RETURNS [before, after, top, bottom: Slice, nesting: INTEGER, depth: NAT] = {
--
-- top[top.length-1] = first
-- before[before.length-1+nesting] = predecessor of first
-- bottom[bottom.length-1] = last
-- raises BadBand error if last doesn't follow first in tree structure
-- or if first or last is root node
--
BadBandError:
PROC = {
ERROR BadBand [!
UNWIND => {
FreeSlice[before]; FreeSlice[after];
FreeSlice[top]; FreeSlice[bottom] } ] };
pred: Ref ← TextNode.StepBackward[first];
minDepth: NAT;
IF pred=NIL THEN ERROR BadBand; -- first is root node
IF pred=last THEN ERROR BadBand; -- this actually happened during testing!
[before,top] ← MakeSlices[pred];
nesting ← top.length-before.length;
[bottom,after] ← MakeSlices[last];
minDepth ← MIN[before.length,bottom.length];
FOR depth ← 0, depth+1
UNTIL depth >= minDepth
DO
IF before[depth] # bottom[depth]
THEN {
-- check for legality
bot: Ref ← bottom[depth];
FOR node: Ref ← before[depth], TextNode.Next[node]
DO
SELECT node
FROM
bot => EXIT;
NIL => BadBandError[]; -- last must come before first
ENDCASE;
ENDLOOP;
EXIT };
ENDLOOP;
IF depth=0 THEN BadBandError[]; -- different root nodes for first and last
--
-- check assertions
IF LastOfSlice[top] # first THEN ERROR;
IF before[before.length+nesting-2] # TextNode.Parent[first] THEN ERROR;
IF LastOfSlice[bottom] # last THEN ERROR };
DeletePrefix:
PUBLIC
PROC [slice: Slice, depth:
NAT] = {
--
-- remove entries from start of slice
--
newLen: NAT;
IF slice.length < depth THEN ERROR;
newLen ← slice.length-depth;
FOR i:NAT IN [0..newLen) DO slice[i] ← slice[i+depth]; ENDLOOP;
FOR i:NAT IN [newLen..slice.length) DO slice[i] ← NIL; ENDLOOP;
slice.length ← newLen };
DestSlices:
PUBLIC
PROC [dest: Ref, where: Place]
RETURNS [before, after: Slice, nesting: INTEGER] = {
--
-- where = after means insert starting as sibling after dest
-- where = child means insert starting as child of dest
-- where = before means insert starting as sibling before dest
--
SELECT where FROM
after => { [before,after] ← MakeSlices[dest]; nesting ← 0 };
child => { [before,after] ← MakeSlices[dest]; nesting ← 1 };
before => {
pred: Ref ← TextNode.StepBackward[dest];
[before,after] ← MakeSlices[pred];
nesting ← after.length-before.length };
ENDCASE => ERROR };
CreateDest:
PUBLIC
PROC [depth:
NAT]
RETURNS [dest: Location] = {
-- create tree of parents
node: Ref;
UNTIL depth = 0
DO
child: Ref ← TextNode.NewTextNode[];
IF node # NIL THEN { node.child ← child; child.next ← node };
node ← child; depth ← depth-1; ENDLOOP;
RETURN [[node,TextNode.NodeItself]] };
CopySpan:
PUBLIC
PROC [span: Span]
RETURNS [result: Span] =
TRUSTED {
node, sourceFirst, sourceLast, child, new, prev, parent, first: Ref;
firstLoc, lastLoc: Offset;
sourceFirst ← span.start.node; firstLoc ← span.start.where;
sourceLast ← span.end.node; lastLoc ← span.end.where;
IF (node ← sourceFirst)=NIL THEN RETURN [TextNode.nullSpan];
parent ← TextNode.NewTextNode[]; -- parent for the span
DO
-- create new node each time through the loop
WITH n:node
SELECT
FROM
text => {
txt: RefTextNode;
new ← txt ← TextNode.qZone.NEW[TextNode.TextBody];
txt.rope ← n.rope; txt.runs ← n.runs };
other => {
othr: RefOtherNode;
new ← othr ← TextNode.qZone.NEW[TextNode.OtherBody];
othr.variety ← n.variety;
othr.info ← OtherNode.CopyInfo[@n] };
ENDCASE => ERROR;
IF prev#NIL THEN { prev.last ← FALSE; prev.next ← new }
ELSE parent.child ← new; -- insert new
new.new ← new.last ← TRUE; new.next ← parent; prev ← new;
Inherit[node,new,TRUE]; -- inherit properties from node
IF node=sourceFirst THEN first ← new;
IF node=sourceLast
THEN {
RETURN [[[first,firstLoc],[new,lastLoc]]] };
-- go to next node
IF (child ← node.child) #
NIL
THEN {
-- descend in the tree
node ← child; parent ← new; prev ← NIL }
ELSE
DO
-- move to next node, sibling or up* then sibling
IF ~node.last THEN { node ← node.next; EXIT };
prev ← parent;
IF (parent ← parent.next) =
NIL
THEN {
-- need a new parent
parent ← TextNode.NewTextNode[];
parent.child ← prev;
prev.next ← parent };
IF (node ← node.next)=NIL THEN RETURN [TextNode.nullSpan]; -- bad arg span
ENDLOOP;
ENDLOOP };
CompareSliceOrder:
PUBLIC
PROC [s1, s2: Slice]
RETURNS [order: NodeOrder] = {
--
-- determines relative order in tree of last nodes in the slices
-- returns "same" if slices are identical
-- returns "before" if last node of s1 comes before last node of s2
-- returns "after" if last node of s1 comes after last node of s2
-- returns "disjoint" if slices are not from the same tree
--
s1Len, s2Len: NAT;
IF s1=
NIL
OR s2=
NIL
OR (s1Len←s1.length)=0
OR (s2Len←s2.length)=0
OR s1[0] # s2[0]
THEN RETURN [disjoint];
IF s1.kind # before OR s2.kind # before THEN ERROR; -- only valid for parent slices
FOR i:
NAT ← 1, i+1
DO
-- know that s1[j]=s2[j] for j<i
SELECT i
FROM
s1Len => {
IF i=s2Len THEN RETURN [same]; -- s1Last=s2Last
RETURN [before] }; -- s1Last is a parent of s2Last
s2Len => RETURN [after]; -- s2Last is a parent of s1Last
ENDCASE;
IF s1[i] # s2[i]
THEN {
-- they are siblings, so can check order by Next's
s2Node: Ref ← s2[i];
FOR n:Ref ← TextNode.Next[s1[i]], TextNode.Next[n]
DO
-- search from s1 to s2
SELECT n
FROM
s2Node => RETURN [before];
NIL => RETURN [after];
ENDCASE;
ENDLOOP };
ENDLOOP };
CompareNodeOrder:
PUBLIC
PROC [node1, node2: Ref]
RETURNS [order: NodeOrder] = {
s1, s2: Slice;
IF node1=NIL OR node2=NIL THEN RETURN [disjoint];
IF node1=node2 THEN RETURN [same];
s1 ← MakeParentSlice[node1];
s2 ← MakeParentSlice[node2];
order ← CompareSliceOrder[s1,s2];
FreeSlice[s1]; FreeSlice[s2] };
MakeParentSlice:
PROC [node: Ref]
RETURNS [slice: Slice] = {
-- result is same as MakeSlices[node].before
Slicer:
PROC [node: Ref, height:
NAT]
RETURNS [level:
NAT] = {
height ← height+1;
IF node=
NIL
THEN {
-- have gone beyond root
slice ← GetSlice[height]; slice.kind ← before;
RETURN [0] };
level ← Slicer[TextNode.Parent[node],height];
slice[level] ← node;
RETURN [level+1] };
IF node=NIL THEN RETURN;
slice.length ← Slicer[node,0] };
DoSplits:
PUBLIC
PROC [alpha, beta: Span, event: Event]
RETURNS [Span, Span] = {
-- split off head or tail sections of text
MakeSplit: PROC [node: Ref, offset: Offset] = {
FixLoc:
PROC [old: Location]
RETURNS [newLoc: Location] = {
where: Offset;
IF old.node # node THEN RETURN [old];
SELECT where ← old.where
FROM
= NodeItself => ERROR;
< offset => RETURN [[node,where]];
ENDCASE => RETURN [[new,where-offset]] };
new: Ref;
IF node = NIL THEN RETURN;
new ← Split[TextNode.Root[node],[node,offset],event];
alpha.start ← FixLoc[alpha.start];
alpha.end ← FixLoc[alpha.end];
beta.start ← FixLoc[beta.start];
beta.end ← FixLoc[beta.end] };
IF alpha.start.where # NodeItself THEN MakeSplit[alpha.start.node,alpha.start.where];
IF beta.start.where # NodeItself THEN MakeSplit[beta.start.node,beta.start.where];
IF alpha.end.where # NodeItself THEN MakeSplit[alpha.end.node,alpha.end.where+1];
IF beta.end.where # NodeItself THEN MakeSplit[beta.end.node,beta.end.where+1];
RETURN [alpha,beta] };
DoSplits2:
PUBLIC
PROC [dest: Location, source: Span,
where: Place, nesting: INTEGER, event: Event]
RETURNS [Location, Span, Place, INTEGER] = {
destLoc: Location;
destSpan: Span ← [dest,TextNode.nullLocation];
[destSpan,source] ← DoSplits[destSpan,source,event];
destLoc ← destSpan.start;
IF dest.where # NodeItself
THEN {
-- did a split
destLoc ← BackLoc[destLoc]; where ← after; nesting ← 0 };
RETURN [destLoc, source, where, nesting] };
ReMerge:
PUBLIC
PROC [alpha, beta: Span, merge: Ref, event: Event, tail:
BOOLEAN ←
FALSE]
RETURNS [Span, Span] = {
loc: Location;
FixLoc:
PROC [old: Location]
RETURNS [Location] = {
where: Offset;
IF old.node = merge
THEN
SELECT where ← old.where
FROM
= NodeItself => ERROR;
ENDCASE => RETURN [[loc.node,loc.where+where]];
RETURN [old] };
IF tail THEN merge ← TextNode.StepForward[merge];
loc ← Merge[TextNode.Root[merge],merge,event];
alpha.start ← FixLoc[alpha.start];
alpha.end ← FixLoc[alpha.end];
beta.start ← FixLoc[beta.start];
beta.end ← FixLoc[beta.end];
RETURN [alpha,beta] };
UndoSplits:
PUBLIC
PROC [alpha, beta: Span, event: Event]
RETURNS [Span, Span] = {
IF alpha.start.where # NodeItself
THEN
[alpha,beta] ← ReMerge[alpha,beta,alpha.start.node,event];
IF beta.start.where # NodeItself
THEN
[alpha,beta] ← ReMerge[alpha,beta,beta.start.node,event];
IF alpha.end.where # NodeItself
THEN
[alpha,beta] ← ReMerge[alpha,beta,alpha.end.node,event,TRUE];
IF beta.end.where # NodeItself
THEN
[alpha,beta] ← ReMerge[alpha,beta,beta.end.node,event,TRUE];
RETURN [alpha,beta] };
UndoSplits2:
PUBLIC
PROC [dest: Location, source: Span, event: Event]
RETURNS [Location, Span] = {
destSpan: Span ← [dest,TextNode.nullLocation];
[destSpan,source] ← UndoSplits[destSpan,source,event];
RETURN [destSpan.end,source] };
SliceOrder:
PUBLIC
PROC [alpha, beta: Span, aBefore, aBottom, bBefore, bBottom: Slice]
RETURNS [overlap: BOOLEAN, head, tail: Span, startOrder, endOrder: NodeOrder] = {
IF CompareSliceOrder[aBottom,bBefore]#after
--alphaend before betastart
OR CompareSliceOrder[aBefore,bBottom]#before
--alphastart after betaend
THEN { overlap ← FALSE; RETURN };
startOrder ← CompareSliceOrder[aBefore,bBefore];
endOrder ← CompareSliceOrder[aBottom,bBottom];
head ←
SELECT startOrder
FROM
before => [alpha.start,BackLoc[beta.start]],
same => TextNode.nullSpan,
after => [beta.start,BackLoc[alpha.start]],
ENDCASE => ERROR;
tail ←
SELECT endOrder
FROM
before => [ForwardLoc[alpha.end],beta.end],
same => TextNode.nullSpan,
after => [ForwardLoc[beta.end],alpha.end],
ENDCASE => ERROR;
overlap ← TRUE };
FixWordSpans:
PUBLIC
PROC [alpha, beta: Span, event: Event]
RETURNS [newAlpha, newBeta: Span] = {
FixWords: PROC [span: Span] = {
FixLoc:
PROC [dest: RefTextNode, old: Location, where: Offset, delta:
INTEGER]
RETURNS [Location] = {
IF old.node # dest THEN RETURN [old];
RETURN [
SELECT old.where
FROM
= NodeItself => old,
<= where => old,
ENDCASE => [old.node,old.where+delta]] };
DeleteBlank:
PROC [dest: RefTextNode, where: Offset] = {
[] ← TextEdit.DeleteText[TextNode.Root[dest],dest,where,1,event];
alpha.start ← FixLoc[dest,alpha.start,where,-1];
alpha.end ← FixLoc[dest,alpha.end,where,-1];
beta.start ← FixLoc[dest,beta.start,where,-1];
beta.end ← FixLoc[dest,beta.end,where,-1] };
InsertBlank:
PROC [dest: RefTextNode, where: Offset] = {
[] ← TextEdit.InsertChar[TextNode.Root[dest],dest,' ,where,TRUE,noLooks,event];
alpha.start ← FixLoc[dest,alpha.start,where,1];
alpha.end ← FixLoc[dest,alpha.end,where,1];
beta.start ← FixLoc[dest,beta.start,where,1];
beta.end ← FixLoc[dest,beta.end,where,1] };
startNode, endNode: RefTextNode;
startLen, endLen: Offset;
wantLeading, wantTrailing, hasLeading, hasTrailing: BOOLEAN;
IF span.start.where = NodeItself OR span.end.where = NodeItself THEN RETURN;
IF span.start=span.end THEN RETURN;
IF (startNode ← TextNode.NarrowToTextNode[span.start.node])=NIL THEN RETURN;
IF (endNode ← TextNode.NarrowToTextNode[span.end.node])=NIL THEN RETURN;
wantLeading ← WantLeadingSpace[startNode,span.start.where];
wantTrailing ← WantTrailingSpace[endNode,span.end.where,TextEdit.Size[endNode]];
startLen ← (
IF startNode=endNode
THEN span.end.where
ELSE TextEdit.Size[startNode])
- span.start.where;
endLen ← span.end.where-(IF startNode=endNode THEN span.start.where ELSE 0);
hasLeading ← HasLeadingSpace[startNode,span.start.where,startLen];
hasTrailing ← HasTrailingSpace[endNode,span.end.where-endLen,endLen];
IF hasTrailing AND ~wantTrailing THEN DeleteBlank[endNode,span.end.where-1];
IF ~hasTrailing AND wantTrailing THEN InsertBlank[endNode,span.end.where];
IF hasLeading AND ~wantLeading THEN DeleteBlank[startNode,span.start.where];
IF ~hasLeading AND wantLeading THEN InsertBlank[startNode,span.start.where] };
AdjustWordSpan:
PROC [span: Span]
RETURNS [Span] = {
following, preceeding, leading, trailing: BOOLEAN;
startNode, endNode: RefTextNode;
startLen, endLen: Offset;
startWhere, endWhere: Offset;
IF span.start=span.end THEN RETURN [nullSpan];
IF (startWhere ← span.start.where) = NodeItself
OR
(endWhere ← span.end.where) = NodeItself THEN RETURN [nullSpan];
IF (startNode ← TextNode.NarrowToTextNode[span.start.node])=NIL THEN RETURN [nullSpan];
IF (endNode ← TextNode.NarrowToTextNode[span.end.node])=NIL THEN RETURN [nullSpan];
startLen ← (
IF startNode=endNode
THEN endWhere
ELSE TextEdit.Size[startNode])
- startWhere;
endLen ← endWhere-(IF startNode=endNode THEN startWhere ELSE 0);
following ← HasFollowingSpace[endNode,endWhere,TextEdit.Size[endNode]];
preceeding ← HasPreceedingSpace[startNode,startWhere];
leading ← HasLeadingSpace[startNode,startWhere,TextEdit.Size[startNode]];
trailing ← HasTrailingSpace[endNode,endWhere-endLen,endLen];
IF leading
THEN
IF trailing THEN startWhere ← startWhere+1
ELSE IF following THEN { startWhere ← startWhere+1; endWhere ← endWhere+1 }
ELSE NULL
ELSE
IF ~trailing
THEN
IF following THEN endWhere ← endWhere+1
ELSE
IF preceeding
THEN {
startWhere ← startWhere-1; endWhere ← endWhere+1 }
ELSE NULL
ELSE NULL;
RETURN [[[startNode,startWhere],[endNode,endWhere]]] };
WantLeadingSpace:
PROC [dest: RefTextNode, destStart: Offset]
RETURNS [BOOLEAN] = {
-- returns true if char before destStart is a letter/digit
RETURN [destStart > 0
AND
RopeEdit.AlphaNumericChar[TextEdit.FetchChar[dest,destStart-1]]] };
WantTrailingSpace:
PROC [dest: RefTextNode, destEnd, destSize: Offset]
RETURNS [BOOLEAN] = {
-- returns true if char after destEnd is a letter/digit
RETURN [destEnd < destSize
AND
RopeEdit.AlphaNumericChar[TextEdit.FetchChar[dest,destEnd]]] };
HasLeadingSpace:
PROC [source: RefTextNode, start, len: Offset]
RETURNS [BOOLEAN] = {
RETURN [len > 0 AND RopeEdit.BlankChar[TextEdit.FetchChar[source,start]]] };
HasTrailingSpace:
PROC [source: RefTextNode, start, len: Offset]
RETURNS [BOOLEAN] = {
RETURN [len > 0 AND RopeEdit.BlankChar[TextEdit.FetchChar[source,start+len-1]]] };
HasFollowingSpace:
PROC [source: RefTextNode, end, size: Offset]
RETURNS [BOOLEAN] = {
RETURN [end < size AND RopeEdit.BlankChar[TextEdit.FetchChar[source,end]]] };
HasPreceedingSpace:
PROC [source: RefTextNode, start: Offset]
RETURNS [BOOLEAN] = {
RETURN [start > 0 AND RopeEdit.BlankChar[TextEdit.FetchChar[source,start-1]]] };
FixWords[alpha]; FixWords[beta];
alpha ← AdjustWordSpan[alpha];
beta ← AdjustWordSpan[beta];
RETURN [alpha,beta] };
-- ***** Miscellaneous
Apply:
PUBLIC
PROC [span: Span, proc: ApplyProc] = {
node, last: Ref;
start, lastLen: Offset;
IF (node ← span.start.node) = NIL THEN RETURN;
IF (last ← span.end.node) = NIL THEN RETURN;
IF (start ← span.start.where)=TextNode.NodeItself THEN start ← 0;
IF span.end.where=TextNode.NodeItself THEN lastLen ← MaxLen
ELSE IF span.end.where=MaxLen THEN lastLen ← MaxLen
ELSE { lastLen ← span.end.where+1; IF node=last THEN lastLen ← lastLen-start };
DO
TRUSTED {WITH n:node
SELECT
FROM
text => IF proc[@n,start,IF @n=last THEN lastLen ELSE MaxLen] THEN RETURN;
other => NULL;
ENDCASE => ERROR};
IF node=last OR (node ← TextNode.StepForward[node])=NIL THEN RETURN;
start ← 0; ENDLOOP };
BackLoc:
PUBLIC
PROC [loc: Location]
RETURNS [new: Location] = {
new.node ← TextNode.StepBackward[loc.node];
new.where ←
IF loc.where=NodeItself
THEN NodeItself
ELSE
TextEdit.Size[TextNode.NarrowToTextNode[new.node]] };
ForwardLoc:
PUBLIC
PROC [loc: Location]
RETURNS [new: Location] = {
new.node ← TextNode.StepForward[loc.node];
new.where ← IF loc.where=NodeItself THEN NodeItself ELSE 0 };
END.