DIRECTORY
Char USING [Code, Set],
IO USING [PutChar, RopeFromROS, ROS, STREAM],
NodeProps USING [PutProp, DoSpecs, GetSpecs],
NodeReader,
PFS,
Prop USING [PropList],
Rope USING [Concat, FromRefText, Flatten, Length, ROPE, Substr],
Rosary USING [Concat, FromItem, ROSARY, Substr],
TextEdit,
TextNode,
Tioga USING [Looks, noLooks, PropList, Node, Location],
TiogaAccess USING [TiogaChar],
TiogaAccessPrivate USING [Reader, ReaderRep, ropePieces, Writer, WriterRep],
TiogaIO USING [FromFile, FromOpenFile, ToFile, ToOpenFile];

TiogaAccessImpl: CEDAR PROGRAM
IMPORTS Char, IO, NodeProps, NodeReader, PFS, Rope, Rosary, TextEdit, TextNode, TiogaIO
EXPORTS TiogaAccess
~ BEGIN

ROPE: TYPE ~ Rope.ROPE;
ROSARY: TYPE ~ Rosary.ROSARY;
TiogaChar: TYPE ~ TiogaAccess.TiogaChar;
Node: TYPE ~ Tioga.Node;
Location: TYPE ~ Tioga.Location;
Looks: TYPE ~ Tioga.Looks;
noLooks: Looks ~ Tioga.noLooks;
PropList: TYPE ~ Tioga.PropList;


GetExternalProp: PUBLIC PROC [key: ATOM, value: REF] RETURNS [ROPE] ~ {
RETURN [NodeProps.GetSpecs[key, value]]
};

GetInternalProp: PUBLIC PROC [key: ATOM, value: ROPE] RETURNS [REF] ~ {
RETURN [NodeProps.DoSpecs[key, value]]
};

Error: PUBLIC ERROR [group: PFS.ErrorGroup, expl: ROPE] ~ CODE;


Reader: TYPE ~ TiogaAccessPrivate.Reader;
ReaderRep: PUBLIC TYPE ~ TiogaAccessPrivate.ReaderRep;


GetLocation: PUBLIC PROC [reader: Reader] RETURNS [Location] ~ {
RETURN[[reader.node, reader.index]];
};

LocNumber: PROC [reader: Reader, skip: BOOL Ź FALSE] RETURNS [INT] ~ {
RETURN[TextNode.LocOffset[loc1: [reader.root, 0], loc2: [reader.node, reader.index], 
skipCommentNodes: skip]];
};

LocWithin: PROC [reader: Reader, count: INT, skip: BOOL Ź FALSE] RETURNS [Location] ~ {
RETURN[TextNode.LocRelative[location: [reader.root, 0], count: count, 
skipCommentNodes: skip]];
};

SetLocation: PROC [reader: Reader, location: Location] ~ {
prevNode: Node ~ reader.node;
IF reader.putback#NIL THEN DiscardPutBack[reader];
NodeReader.Set[reader.rdr, reader.node Ź location.node];
reader.index Ź MIN[MAX[location.where, 0], NodeReader.Size[reader.rdr]];
IF reader.node#prevNode THEN reader.start Ź LocNumber[reader]-reader.index;
};

SkipToNextNode: PUBLIC PROC [reader: Reader] RETURNS [deltaLevel: INT] ~ {
prevNode: Node ~ reader.node;
prevSize: INT ~ NodeReader.Size[reader.rdr];
IF reader.putback#NIL THEN DiscardPutBack[reader];
IF prevNode=NIL THEN Error[client, "Attempt to read past end of document"];
[reader.node, deltaLevel] Ź TextNode.Forward[prevNode];
NodeReader.Set[reader.rdr, reader.node];
reader.index Ź 0;
reader.start Ź reader.start+prevSize+1;
};

GetLen: PROC [reader: Reader, skip: BOOL] RETURNS [INT] ~ {
loc1: Location ~ [reader.root, 0];
loc2: Location ~ TextNode.LastLocWithin[reader.root];
break: INT ~ IF (skip AND loc2.node.comment) THEN 0 ELSE 1;
RETURN[TextNode.LocOffset[loc1: loc1, loc2: loc2, skipCommentNodes: skip]+break];
};

GetLength: PUBLIC PROC [reader: Reader] RETURNS [INT] ~ {
loc1: Location ~ [reader.root, 0];
loc2: Location ~ TextNode.LastLocWithin[reader.root];
RETURN[TextNode.LocOffset[loc1: loc1, loc2: loc2, skipCommentNodes: FALSE]+1];
};

GetIndex: PUBLIC PROC [reader: Reader] RETURNS [index: INT] ~ {
RETURN[reader.start+reader.index];
};

SetIndex: PUBLIC PROC [reader: Reader, index: INT] ~ {
IF reader.putback#NIL THEN DiscardPutBack[reader];
IF index IN [reader.start..(reader.start+NodeReader.Size[reader.rdr])]
THEN reader.index Ź index-reader.start
ELSE SetLocation[reader, LocWithin[reader, index]];
};

GetPosition: PUBLIC PROC [reader: Reader] RETURNS [INT] ~ {
RETURN[reader.offset+LocNumber[reader, TRUE]];
};

SetPosition: PUBLIC PROC [reader: Reader, position: INT] ~ {
SetLocation[reader, LocWithin[reader, position-reader.offset, TRUE]];
};

FromNode: PUBLIC PROC [node: Node, offset: INT Ź 0] RETURNS [reader: Reader] ~ {
reader Ź NEW[ReaderRep Ź [root: TextNode.Root[node], rdr: NodeReader.New[]]];
SetLocation[reader, [node, 0]];
reader.offset Ź offset-LocNumber[reader, TRUE];
};

FromFile: PUBLIC PROC [fileName: ROPE] RETURNS [Reader] ~ {
RETURN [FromNode[TiogaIO.FromFile[PFS.PathFromRope[fileName]].root]]
};

FromOpenFile: PUBLIC PROC [openFile: PFS.OpenFile] RETURNS [Reader] ~ {
RETURN [FromNode[TiogaIO.FromOpenFile[openFile].root]]
};


Get: PUBLIC PROC [reader: Reader] RETURNS [TiogaChar] ~ {
node: Node ~ reader.node;
index: INT ~ reader.index;
IF reader.putback#NIL THEN {
t: LIST OF TiogaChar ~ reader.putback;
reader.putback Ź t.rest;
RETURN[t.first];
};
IF node=NIL THEN ERROR Error[client, "Attempt to read past end of document"];
IF index<NodeReader.Size[reader.rdr]
THEN {
info: NodeReader.CharInfo ~ NodeReader.Fetch[reader.rdr, index];
reader.index Ź reader.index+1;
RETURN[[
charSet: Char.Set[info.char],
char: VAL[Char.Code[info.char]],
looks: info.looks,
propList: info.props,
format: node.format,
comment: node.comment,
deltaLevel: 0,
endOfNode: FALSE
]];
}
ELSE {
deltaLevel: INTEGER ~ SkipToNextNode[reader];
RETURN[[
charSet: 0,
char: '\n--reader.newline--,
looks: noLooks,
propList: node.nodeProps,
format: node.format,
comment: node.comment,
deltaLevel: deltaLevel,
endOfNode: TRUE
]];
};
};

Peek: PUBLIC PROC [reader: Reader] RETURNS [TiogaChar] ~ {
node: Node ~ reader.node;
index: INT ~ reader.index;
IF reader.putback#NIL THEN RETURN[reader.putback.first];
IF node=NIL THEN ERROR Error[client, "Attempt to read past end of document"];
IF index<NodeReader.Size[reader.rdr]
THEN {
info: NodeReader.CharInfo ~ NodeReader.Fetch[reader.rdr, index];
RETURN[[
charSet: Char.Set[info.char],
char: VAL[Char.Code[info.char]],
looks: info.looks,
propList: info.props,
format: node.format,
comment: node.comment,
deltaLevel: 0,
endOfNode: FALSE
]];
}
ELSE {
deltaLevel: INTEGER ~ TextNode.Forward[node].levelDelta;
RETURN[[
charSet: 0,
char: '\n--reader.newline--,
looks: noLooks,
propList: node.nodeProps,
format: node.format,
comment: node.comment,
deltaLevel: deltaLevel,
endOfNode: TRUE
]];
};
};

PeekRope: PUBLIC PROC [reader: Reader] RETURNS [rope: ROPE Ź NIL] ~ {
IF reader.putback#NIL THEN {
s: IO.STREAM ~ IO.ROS[];
FOR t: LIST OF TiogaChar Ź reader.putback, t.rest UNTIL t=NIL DO
IF t.first.endOfNode THEN RETURN[IO.RopeFromROS[s]];
IO.PutChar[s, t.first.char]; -- should we complain if charSet#0?
ENDLOOP;
rope Ź IO.RopeFromROS[s];
};
IF reader.index<NodeReader.Size[reader.rdr] THEN rope Ź Rope.Concat[rope, 
Rope.Substr[base: reader.node.rope, start: reader.index]];
};

PeekRuns: PROC [reader: Reader] RETURNS [ROSARY] ~ {
node: Node ~ reader.node;
IF node.runs=NIL THEN RETURN[NIL];
RETURN[Rosary.Substr[base: node.runs, start: reader.index]];
};

PeekCharSets: PROC [reader: Reader] RETURNS [ROSARY] ~ {
node: Node ~ reader.node;
IF node.charSets=NIL THEN RETURN[NIL];
RETURN[Rosary.Substr[base: node.charSets, start: reader.index]];
};

PeekCharProps: PROC [reader: Reader] RETURNS [ROSARY] ~ {
node: Node ~ reader.node;
IF node.charProps=NIL THEN RETURN[NIL];
RETURN[Rosary.Substr[base: node.charProps, start: reader.index]];
};

EndOf: PUBLIC PROC [reader: Reader] RETURNS [BOOLEAN] ~ {
RETURN [reader.putback=NIL AND reader.node=NIL];
};


GetNodeProps: PUBLIC PROC [reader: Reader] RETURNS [PropList] ~ {
node: Node ~ reader.node;
RETURN [IF node=NIL THEN NIL ELSE node.nodeProps]
};

PutBack: PUBLIC PROC [reader: Reader, tiogaChar: TiogaChar] ~ {
reader.putback Ź CONS[tiogaChar, reader.putback];
};

DiscardPutBack: PROC [reader: Reader] ~ {
UNTIL reader.putback = NIL DO
t: LIST OF TiogaChar Ź reader.putback.rest;
reader.putback.rest Ź NIL;
reader.putback Ź t;
ENDLOOP;
};

DoneWith: PUBLIC PROC [reader: Reader] ~ {
IF reader.rdr#NIL THEN {
NodeReader.Free[reader.rdr];
reader.rdr Ź NIL;
DiscardPutBack[reader];
};
};


Writer: TYPE ~ TiogaAccessPrivate.Writer;
WriterRep: PUBLIC TYPE ~ TiogaAccessPrivate.WriterRep;

ropePieces: NAT ~ TiogaAccessPrivate.ropePieces;
textBufSize: NAT Ź (574-SIZE[TEXT[0]])*2;

Create: PUBLIC PROC RETURNS [Writer] ~ {
new: Writer Ź NEW[WriterRep];
new.textBuf Ź NEW[TEXT[textBufSize]];
Reset[new];
RETURN [new];
};

InsertRoot: PROC [writer: Writer, x: Node Ź NIL] ~ {
IF x = NIL THEN {
x Ź TextNode.NewTextNode[];
NodeProps.PutProp[x, $NewlineDelimiter, Rope.Flatten["\n"]];
x.comment Ź TRUE;
};
IF Rope.Length[x.rope] # 0 THEN Error[client, "Root may not contain text"];
x.parent Ź x.next Ź NIL;
writer.root Ź x;
writer.last Ź x;
writer.level Ź writer.lastLevel Ź 0;
};

InsertSibling: PROC [writer: Writer, new: Tioga.Node] ~ {
x: Tioga.Node ~ writer.last;
new.next Ź x.next;
new.parent Ź x.parent;
x.next Ź new;
writer.last Ź new;
};

InsertChild: PROC [writer: Writer, new: Tioga.Node] ~ {
x: Tioga.Node ~ writer.last;
IF x.child # NIL THEN ERROR;
new.parent Ź x;
x.child Ź new;
writer.last Ź new;
writer.lastLevel Ź writer.lastLevel + 1;
};

FoldText: PROC [writer: Writer] ~ {
FoldRope[writer, Rope.FromRefText[writer.textBuf]];
writer.textBuf.length Ź 0;
};

FoldRope: PROC [writer: Writer, rope: ROPE] ~ {
i: NAT Ź 0;
writer.textBuf.length Ź 0;
DO
IF writer.ropes[i] = NIL THEN {writer.ropes[i] Ź rope; EXIT};
rope Ź Rope.Concat[writer.ropes[i], rope];
writer.ropes[i] Ź NIL;
IF i < ropePieces-1 THEN i Ź i + 1;
ENDLOOP;
};

GetRope: PROC [writer: Writer] RETURNS [rope: ROPE Ź NIL] ~ {
FoldText[writer];
FOR i: NAT IN [0..ropePieces) DO
IF writer.ropes[i] # NIL THEN {
rope Ź Rope.Concat[writer.ropes[i], rope];
writer.ropes[i] Ź NIL;
};
ENDLOOP;
};

FoldRosary: PROC [rosary: ROSARY, item: REF, repeat, size: INT] RETURNS [ROSARY] ~ {
IF repeat=0 THEN RETURN[rosary];
IF rosary=NIL AND item=NIL THEN RETURN[NIL];
IF rosary=NIL THEN rosary Ź Rosary.FromItem[NIL, size-repeat];
RETURN[Rosary.Concat[rosary, Rosary.FromItem[item, repeat]]];
};

ConcatRosary: PROC [r1: ROSARY, size1: INT, r2: ROSARY, size2: INT] RETURNS [ROSARY] ~ {
IF r1=NIL AND r2=NIL THEN RETURN[NIL];
IF r1=NIL THEN r1 Ź Rosary.FromItem[NIL, size1];
IF r2=NIL THEN r2 Ź Rosary.FromItem[NIL, size2];
RETURN[Rosary.Concat[r1, r2]];
};

FoldRuns: PROC [writer: Writer] ~ {
IF writer.newLooksRepeat>0 THEN writer.runs Ź FoldRosary[rosary: writer.runs, 
item: TextEdit.ItemFromLooks[writer.newLooks], repeat: writer.newLooksRepeat, 
size: writer.nodeSize];
writer.newLooks Ź noLooks;
writer.newLooksRepeat Ź 0;
};

GetRuns: PROC [writer: Writer] RETURNS [runs: ROSARY] ~ {
FoldRuns[writer];
runs Ź writer.runs;
writer.runs Ź NIL;
};

FoldCharSets: PROC [writer: Writer] ~ {
IF writer.newCharSetRepeat>0 THEN writer.charSets Ź FoldRosary[rosary: writer.charSets, 
item: TextEdit.ItemFromCharSet[writer.newCharSet], repeat: writer.newCharSetRepeat, 
size: writer.nodeSize];
writer.newCharSet Ź 0;
writer.newCharSetRepeat Ź 0;
};

GetCharSets: PROC [writer: Writer] RETURNS [charSets: ROSARY] ~ {
FoldCharSets[writer];
charSets Ź writer.charSets;
writer.charSets Ź NIL;
};

FoldCharProps: PROC [writer: Writer] ~ {
IF writer.newCharPropRepeat>0 THEN writer.charProps Ź FoldRosary[rosary: writer.charProps, 
item: writer.newCharProp, repeat: writer.newCharPropRepeat, 
size: writer.nodeSize];
writer.newCharProp Ź NIL;
writer.newCharPropRepeat Ź 0;
};

GetCharProps: PROC [writer: Writer] RETURNS [charProps: ROSARY] ~ {
FoldCharProps[writer];
charProps Ź writer.charProps;
writer.charProps Ź NIL;
};

Put: PUBLIC PROC [writer: Writer, tiogaChar: TiogaChar] ~ {
IF tiogaChar.endOfNode THEN {
new: Node Ź TextNode.NewTextNode[];
new.format Ź tiogaChar.format;
new.comment Ź tiogaChar.comment;
new.rope Ź GetRope[writer];
new.runs Ź GetRuns[writer];
new.charSets Ź GetCharSets[writer];
new.charProps Ź GetCharProps[writer];
FOR l: Prop.PropList Ź tiogaChar.propList, l.rest UNTIL l = NIL DO
NodeProps.PutProp[new, NARROW[l.first.key], l.first.val];
ENDLOOP;
IF writer.root = NIL AND writer.level=0 AND tiogaChar.deltaLevel=1 AND Rope.Length[new.rope] = 0 THEN InsertRoot[writer, new]
ELSE {
IF writer.level < 1 THEN {
InsertRoot[writer];
writer.level Ź 1;
};
WHILE writer.level < writer.lastLevel DO
writer.last Ź TextNode.Parent[writer.last];
writer.lastLevel Ź writer.lastLevel - 1;
ENDLOOP;
IF writer.level = writer.lastLevel THEN InsertSibling[writer, new]
ELSE IF writer.level = writer.lastLevel + 1 THEN InsertChild[writer, new]
ELSE Error[client, "Nesting level may not increase by more than one"];
IF writer.first = NIL THEN writer.first Ź new;
};
writer.nodeSize Ź 0;
IF writer.lastLevel # writer.level THEN ERROR;
writer.level Ź MAX[writer.lastLevel + tiogaChar.deltaLevel, 1];
}
ELSE {
text: REF TEXT ~ writer.textBuf;
IF tiogaChar.looks # writer.newLooks THEN {
FoldRuns[writer];
writer.newLooks Ź tiogaChar.looks;
};
writer.newLooksRepeat Ź writer.newLooksRepeat + 1;
IF tiogaChar.charSet # writer.newCharSet THEN {
FoldCharSets[writer];
writer.newCharSet Ź tiogaChar.charSet;
};
writer.newCharSetRepeat Ź writer.newCharSetRepeat + 1;
IF tiogaChar.propList # writer.newCharProp THEN {
FoldCharProps[writer];
writer.newCharProp Ź tiogaChar.propList;
};
writer.newCharPropRepeat Ź writer.newCharPropRepeat + 1;
IF text.length = text.maxLength THEN FoldText[writer];
text[(text.length Ź text.length+1)-1] Ź tiogaChar.char;
writer.nodeSize Ź writer.nodeSize + 1;
};
};

CopyNode: PUBLIC PROC [writer: Writer, reader: Reader, maxLength: INT] RETURNS [nodeEnd: BOOLEAN] ~ {
textRope: ROPE Ź NIL;
textRuns: ROSARY Ź NIL;
textCharSets: ROSARY Ź NIL;
textCharProps: ROSARY Ź NIL;
textSize: INT Ź 0;
WHILE maxLength > 0 AND reader.putback # NIL DO
tchar: TiogaChar Ź Get[reader];
Put[writer, tchar];
maxLength Ź maxLength - 1;
IF tchar.endOfNode THEN RETURN [TRUE];
ENDLOOP;
FoldText[writer];
FoldRuns[writer];
FoldCharSets[writer];
FoldCharProps[writer];
textRope Ź PeekRope[reader];
textSize Ź Rope.Length[textRope];
textRuns Ź PeekRuns[reader];
textCharSets Ź PeekCharSets[reader];
textCharProps Ź PeekCharProps[reader];
nodeEnd Ź textSize < maxLength;
IF NOT nodeEnd THEN {
textRope Ź Rope.Substr[textRope, 0, maxLength];
textSize Ź Rope.Length[textRope];
IF textRuns # NIL THEN textRuns Ź Rosary.Substr[textRuns, 0, textSize];
IF textCharSets # NIL THEN textCharSets Ź Rosary.Substr[textCharSets, 0, textSize];
IF textCharProps # NIL THEN textCharSets Ź Rosary.Substr[textCharProps, 0, textSize];
};
FoldRope[writer, textRope];
writer.runs Ź ConcatRosary[writer.runs, writer.nodeSize, textRuns, textSize];
writer.charSets Ź ConcatRosary[writer.charSets, writer.nodeSize, textCharSets, textSize];
writer.charProps Ź ConcatRosary[writer.charProps, writer.nodeSize, textCharProps, textSize];
reader.index Ź reader.index + textSize;
writer.nodeSize Ź writer.nodeSize + textSize;
IF nodeEnd THEN Put[writer, Get[reader]];
};

Nest: PUBLIC PROC [writer: Writer, delta: INT] ~ {
level: INT ~ writer.level + delta;
IF level > writer.lastLevel+1 THEN Error[client, "Nesting level may not increase by more than one"];
writer.level Ź level;
};

FinishWrite: PUBLIC PROC [writer: Writer, action: PROC [root, first, last: Node]] ~ {
IF writer.nodeSize>0 THEN Put[writer, [
charSet: 0,
char: '\n,
looks: ALL[FALSE],
format: NIL,
comment: FALSE,
endOfNode: TRUE,
deltaLevel: 0,
propList: NIL
]];
action[writer.root, writer.first, writer.last];
Reset[writer];
};

WriteFile: PUBLIC PROC [writer: Writer, fileName: ROPE] ~ {
path: PFS.PATH ~ PFS.PathFromRope[fileName];
action: PROC [root, first, last: Node] ~ { [] Ź TiogaIO.ToFile[path, root] };
FinishWrite[writer, action];
};

WriteOpenFile: PUBLIC PROC [writer: Writer, openFile: PFS.OpenFile] ~ {
action: PROC [root, first, last: Node] ~ { [] Ź TiogaIO.ToOpenFile[openFile, root] };
FinishWrite[writer, action];
};

WriteReader: PUBLIC PROC [writer: Writer] RETURNS [reader: Reader] ~ {
action: PROC [root, first, last: Node] ~ { reader Ź FromNode[root] };
FinishWrite[writer, action];
};

WriteNode: PUBLIC PROC [writer: Writer] RETURNS [node: Node] ~ {
action: PROC [root, first, last: Node] ~ { node Ź root; writer.root Ź NIL };
FinishWrite[writer, action];
};

Reset: PUBLIC PROC [writer: Writer] ~ {
IF writer.root # NIL THEN {
writer.root Ź NIL;
};
writer.first Ź writer.last Ź NIL;
writer.level Ź 0;
writer.lastLevel Ź 0;
writer.nodeSize Ź 0;
writer.ropes Ź ALL[NIL];
writer.textBuf.length Ź 0;
writer.runs Ź NIL;
writer.newLooks Ź noLooks;
writer.newLooksRepeat Ź 0;
writer.charSets Ź NIL;
writer.newCharSet Ź 0;
writer.newCharSetRepeat Ź 0;
writer.charProps Ź NIL;
writer.newCharProp Ź NIL;
writer.newCharPropRepeat Ź 0;
};


END.
  F  
TiogaAccessImpl.mesa
Copyright Ó 1985, 1986, 1988, 1989, 1990, 1991, 1992 by Xerox Corporation.  All rights reserved.
Michael Plass, April 4, 1991 5:39 pm PST
Tim Diebert May 13, 1985 12:06:39 pm PDT
Russ Atkinson (RRA) July 2, 1985 11:08:52 am PDT
Willie-s, April 5, 1991 2:48 pm PST
Doug Wyatt, July 9, 1992 5:12 pm PDT

Putback stuff is harder than all the rest!
Largest size that will come from the small-grain allocator (see Allocator.maxSmallBlockSize)
CreateOneMoreLevel: PROC [writer: Writer] ~ {
IF writer.root = NIL THEN {
InsertRoot[writer, TextNode.NewTextNode[]];
}
ELSE {
new: TextNode.Ref _ TextNode.NewTextNode[];
new^ _ writer.root^;
writer.root.props _ NIL;
writer.root.hasstyledef _ writer.root.hasprefix _ writer.root.haspostfix _ writer.root.hascharprops _ writer.root.hascharsets _ writer.root.hasartwork _ FALSE;
new.last _ TRUE;
new.child _ writer.root;
new.next _ NIL;
writer.root.next _ new;
writer.root _ new;
writer.lastLevel _ writer.lastLevel + 1;
writer.level _ writer.level + 1;
};
};

Collects all the pieces together.
TEditInput.FreeTree[writer.root];
 Ę  NewlineDelimiter
(cedarcode) style codeK
ĎeU`K(K(K0K#K$K Ďk		KK-K
-KKKK(
@K
0K		K		K,7KK4LK.;K ĎnK+WKKK KK
K(KK
 KK
 K K 	GK!'KK 	GK &KK 	?K K K) 6K K @K$KK 	FKioKK 	WKZ`KK ):KK2K8K2HK/KKK 
JKK
,K2K
7KK7K(KK'KK 
;K"K5K;KKQKK 
	9K"K5K>NKK 
	?K"KK 6K2;FK"&K/3KK 
;K!.KK <K>EKK 
PK	AMKK)/KK 
;KDKK 
GK06KK K 9KKK&KK
KK7M"$K@KKK KKKKKKKKK-KK	ĎcKKKKKKKKKK :KKK8K7M"$K@KK KKKKKKKKK%8KK	 KKKKKKKKKK EK**K	$@K4K #@KKKK*UKK 4KK
"K6<KK 8KK
&K:@KK 9KK
'K;AKK 
9K0KK K AKK1KK +?K1KK )K!+KKKKK *KKKKKK K K) 6K K!0)K\\K (KK%KKKK 
4KKStartOfExpansionN[name: ATOM, value: REF ANY, which: TiogaOpsDefs.WhichNodes _ selection]<<KKK,KKKKK$KK -K++KK++KKKKKKKKK((K  KKK &9KKKKKKK &7KKKKKK((KK #K33KKK /KKK=K*KK#KKK 
=K K*KKKKK 

TK
	 K,K>K7=KK 		XK&K	0K	0KKK #KľKKKK 9KKKKK 'K¤ĹKKKK AKKKKK (K°KKKK CKKKKK +;K#KK KKK#K%/BK9KK}KKK!(K+K(KK!BK%IKBFK.KKK!.K-?KK #+KK"KK2'/KK&KK6)1KK(KK8K6K7K&KKK -eK
K
KKK
/KKKK&KKKKKKK!KK$K&K	K/K!K1GK9SK:UKKKMKYK\K'K-K	)KK 2K"KBdKKK UK!'KK

KKK	KKK
KK/KKK 	;K,KAMKKK GKIUKKK FK9EKKK 	@K:LKKK 'K!!KKK!KKKKKKKKKKKKKKKK K K     ?h  Y°  