DIRECTORY AMBridge, AMTypes, Atom, IO, List, OrderedSymbolTableRef, Rope, Rosemary, RosemaryInsides;

RosemaryCreate: CEDAR PROGRAM 
IMPORTS AMBridge, AMTypes, Atom, IO, List, OSTR: OrderedSymbolTableRef, Rope, Rosemary, RosemaryInsides
EXPORTS Rosemary =

BEGIN OPEN Rosemary, RosemaryInsides;

Warning: PUBLIC SIGNAL [msg: ROPE, data: REF ANY _ NIL] = CODE;

Error: PUBLIC ERROR [msg: ROPE, data: REF ANY _ NIL] = CODE;

InterfaceMismatch: PUBLIC ERROR [cell: Cell,
index: CARDINAL,
expected, got: SignalType] = CODE;

Stop: PUBLIC SIGNAL [msg: ROPE _ NIL, data: REF ANY _ NIL] = CODE;


Unspecified: PUBLIC REF ANY _ NEW [INT];

cellClasses: PUBLIC SymbolTable _ OSTR.CreateTable[CompareCellClasses];
roots: PUBLIC SymbolTable _ OSTR.CreateTable[CompareComponents];


RegisterCellClass: PUBLIC PROC [className: ROPE, expandProc: ExpandProc _ NIL, ioCreator: IOCreator _ NIL, initializer: Initializer _ NIL, evalProc, testProc: EvalProc _ NIL, ports: Ports, ioTemplate: REF ANY _ Unspecified] =
BEGIN
cc: CellClass _ NEW [CellClassRep _ [
name: className,
expand: expandProc,
ioCreator: ioCreator,
initializer: initializer,
eval: evalProc,
test: testProc,
ports: ports,
ioWordCount: 0,
ioTemplate: ioTemplate,
firstInstance: NIL]];
old: CellClass _ NARROW[cellClasses.Delete[className]];
FOR portIndex: CARDINAL IN [0 .. ports.length) DO
port: Port _ cc.ports[portIndex];
cc.ioWordCount _ MAX[cc.ioWordCount, port.firstWord + port.wordCount];
IF port.type = NIL THEN ERROR Error[IO.PutFR["No SignalType given for Port %g", IO.rope[port.name]]];
ENDLOOP;
IF old # NIL THEN
BEGIN
IF old.firstInstance # NIL THEN
BEGIN
ok: BOOLEAN _ TRUE;
IF old.ports.length # cc.ports.length THEN ok _ FALSE
ELSE BEGIN
FOR portIndex: CARDINAL IN [0 .. cc.ports.length) DO
IF (
cc.ports[portIndex].firstWord # old.ports[portIndex].firstWord OR
cc.ports[portIndex].wordCount # old.ports[portIndex].wordCount OR
cc.ports[portIndex].type # old.ports[portIndex].type OR
cc.ports[portIndex].input # old.ports[portIndex].input OR
cc.ports[portIndex].output # old.ports[portIndex].output OR
NOT cc.ports[portIndex].name.Equal[old.ports[portIndex].name])
THEN {ok _ FALSE; EXIT};
ENDLOOP;
END;
IF NOT ok THEN ERROR Error[IO.PutFR["Redefinition of Class %g not allowed because of different interface", IO.rope[className]]];
END;
FOR instance: Cell _ old.firstInstance, instance.nextInstance WHILE instance # NIL DO
IF instance.class # old THEN ERROR;
instance.class _ cc;
IF instance.expansion = Leaf THEN
BEGIN
IF instance.realCellStuff.eval # old.eval THEN ERROR;
instance.realCellStuff.eval _ cc.eval;
END;
IF instance.expansion # Inline AND instance.realCellStuff.newIO # NIL THEN
TRUSTED BEGIN
oldoldWP, oldnewWP: WordPtr;
holdOld _ instance.realCellStuff.oldIO;	--prevent GC
holdNew _ instance.realCellStuff.newIO;
oldoldWP _ instance.realCellStuff.oldIOAsWP;
oldnewWP _ instance.realCellStuff.newIOAsWP;
cc.ioCreator[instance, instance.realCellStuff.initData];
instance.realCellStuff.newIOAsWP _ LOOPHOLE[instance.realCellStuff.newIO];
instance.realCellStuff.oldIOAsWP _ LOOPHOLE[instance.realCellStuff.oldIO];
FOR i: CARDINAL IN [0 .. cc.ioWordCount) DO
(instance.realCellStuff.oldIOAsWP + i)^ _ (oldoldWP + i)^;
(instance.realCellStuff.newIOAsWP + i)^ _ (oldnewWP + i)^;
ENDLOOP;
END;
ENDLOOP;
END;
cellClasses.Insert[cc];
END;

holdOld, holdNew: REF ANY _ NIL;

CreateTopCell: PUBLIC PROC [instanceName, className: ROPE, initData: REF ANY _ NIL, decider: ExpandDeciderClosure] RETURNS [cell: Cell] =
BEGIN
class: CellClass;
class _ NARROW[cellClasses.Lookup[className]];
IF class = NIL THEN ERROR Error[IO.PutFR["No such class: %g", IO.rope[className]]];
cell _ NEW [CellRep _ [
name: instanceName, class: class,
parent: NIL, leftChild: NIL, rightSibling: NIL, firstInternalNode: NIL,
internalNodes: OSTR.CreateTable[CompareNodes],
components: OSTR.CreateTable[CompareComponents],
interfaceNodes: NEW [NodeSR[0]],
other: NIL,
type: Shadow, expansion: Inline,
realCellStuff: NIL]];
cell.other _ List.PutAssoc[$ExpandDeciderClosure, decider, cell.other];
FinishCreatingCell[cell, NIL, initData];
roots.Insert[cell !OSTR.DuplicateKey => ERROR Error[IO.PutFR["Duplicated Root name: %g", IO.rope[cell.name]]]];
END;

CreateNode: PUBLIC PROC [within: Cell, name: ROPE, type: SignalType _ NIL --means unspecified--] RETURNS [node: Node] =
BEGIN
node _ NEW [NodeRep _ [
name: name,
type: type,
visible: [NIL, LAST[CARDINAL]] ]];
within.internalNodes.Insert[node !OSTR.DuplicateKey => ERROR Error[IO.PutFR["Duplicated Node name: %g", IO.rope[name]]]];
node.next _ within.firstInternalNode;
--link in wrong order now; fix up when done expanding--
within.firstInternalNode _ node;
END;

CreateCell: PUBLIC PROC [within: Cell, instanceName, className, interfaceNodes: ROPE, initData: REF ANY _ NIL] RETURNS [cell: Cell] =
BEGIN
class: CellClass;
class _ NARROW[cellClasses.Lookup[className]];
IF class = NIL THEN ERROR Error[IO.PutFR["No such class: %g", IO.rope[className]]];
cell _ NEW [CellRep _ [
name: instanceName, class: class,
parent: within, leftChild: NIL, rightSibling: NIL, firstInternalNode: NIL,
internalNodes: OSTR.CreateTable[CompareNodes],
components: OSTR.CreateTable[CompareComponents],
interfaceNodes: NEW [NodeSR[class.ports.length]],
other: NIL,
type: Shadow, expansion: Inline,
realCellStuff: NIL]];
FinishCreatingCell[cell, interfaceNodes, initData];
IF cell.type = Real THEN ScheduleCell[cell];
END;

AddNodeWatcher: PUBLIC PROC [node: Node, watcher: NodeWatcher, priority: Priority _ 0] =
BEGIN
node.watchers[priority] _ CONS[watcher, node.watchers[priority]];
END;

RemoveNodeWatcher: PUBLIC PROC [node: Node, watcher: NodeWatcher, priority: Priority _ 0] =
BEGIN
cur, prev: NodeWatcherList _ NIL;
FOR cur _ node.watchers[priority], cur.rest WHILE cur # NIL DO
IF cur.first = watcher THEN
{IF prev = NIL THEN node.watchers[priority] _ cur.rest ELSE prev.rest _ cur.rest;
RETURN};
prev _ cur;
ENDLOOP;
END;

FilterCellWatcher: PROC [watcher: CellWatcher, watchers: CellWatcherList] RETURNS [ohne: CellWatcherList] =
BEGIN
cur, prev: CellWatcherList _ NIL;
ohne _ watchers;
FOR cur _ watchers, cur.rest WHILE cur # NIL DO
IF cur.first = watcher THEN
{IF prev = NIL THEN ohne _ cur.rest ELSE prev.rest _ cur.rest;
RETURN};
prev _ cur;
ENDLOOP;
END;

AddCellEventWatcher: PUBLIC PROC [cell: Cell, event: ATOM, watcher: CellWatcher] =
BEGIN
SELECT event FROM
$Schedule => {IF cell.type = Shadow THEN ERROR Error[IO.PutFR["Cell %g not Real", IO.rope[cell.name]]];
cell.realCellStuff.schedWatchers _ CONS[watcher, cell.realCellStuff.schedWatchers]};
$Eval => {IF cell.type = Shadow THEN ERROR Error[IO.PutFR["Cell %g not Real", IO.rope[cell.name]]];
cell.realCellStuff.evalWatchers _ CONS[watcher, cell.realCellStuff.evalWatchers]};
ENDCASE => BEGIN
wl: CellWatcherList _ NARROW[List.Assoc[key: event, aList: cell.other]];
wl _ CONS[watcher, wl];
cell.other _ List.PutAssoc[key: event, val: wl, aList: cell.other];
END;
END;

RemoveCellEventWatcher: PUBLIC PROC [cell: Cell, event: ATOM, watcher: CellWatcher] =
BEGIN
SELECT event FROM
$Schedule => {IF cell.type = Shadow THEN ERROR Error[IO.PutFR["Cell %g not Real", IO.rope[cell.name]]];
cell.realCellStuff.schedWatchers _ FilterCellWatcher[watcher, cell.realCellStuff.schedWatchers]};
$Eval => {IF cell.type = Shadow THEN ERROR Error[IO.PutFR["Cell %g not Real", IO.rope[cell.name]]];
cell.realCellStuff.evalWatchers _ FilterCellWatcher[watcher, cell.realCellStuff.evalWatchers]};
ENDCASE => BEGIN
wl: CellWatcherList _ NARROW[List.Assoc[key: event, aList: cell.other]];
wl _ FilterCellWatcher[watcher, wl];
cell.other _ List.PutAssoc[key: event, val: wl, aList: cell.other];
END;
END;

NotifyCellEvent: PUBLIC PROC [cell: Cell, event: ATOM] =
BEGIN
wl: CellWatcherList _ NARROW[List.Assoc[key: event, aList: cell.other]];
abort: BOOLEAN _ FALSE;
WHILE wl # NIL DO
wl.first.notify[cell: cell, clientData: wl.first.clientData !ABORTED => {abort _ TRUE; CONTINUE}];
wl _ wl.rest;
ENDLOOP;
IF abort THEN ERROR ABORTED;
END;

GlobalWatcherList: TYPE = LIST OF GlobalWatcher;
gwKey: ATOM _ Atom.Gensym[];

FilterGlobalWatcher: PROC [watcher: GlobalWatcher, watchers: GlobalWatcherList] RETURNS [ohne: GlobalWatcherList] =
BEGIN
cur, prev: GlobalWatcherList _ NIL;
ohne _ watchers;
FOR cur _ watchers, cur.rest WHILE cur # NIL DO
IF cur.first = watcher THEN
{IF prev = NIL THEN ohne _ cur.rest ELSE prev.rest _ cur.rest;
RETURN};
prev _ cur;
ENDLOOP;
END;

AddGlobalEventWatcher: PUBLIC PROC [event: ATOM, watcher: GlobalWatcher] =
BEGIN
watchers: GlobalWatcherList _ NARROW[Atom.GetProp[atom: event, prop: gwKey]];
watchers _ CONS[watcher, watchers];
Atom.PutProp[atom: event, prop: gwKey, val: watchers];
END;

RemoveGlobalEventWatcher: PUBLIC PROC [event: ATOM, watcher: GlobalWatcher] =
BEGIN
watchers: GlobalWatcherList _ NARROW[Atom.GetProp[atom: event, prop: gwKey]];
Atom.PutProp[atom: event, prop: gwKey, val: FilterGlobalWatcher[watcher, watchers]];
END;

NotifyGlobalEvent: PUBLIC PROC [event: ATOM] =
BEGIN
wl: GlobalWatcherList _ NARROW[Atom.GetProp[atom: event, prop: gwKey]];
abort: BOOLEAN _ FALSE;
WHILE wl # NIL DO
wl.first.notify[clientData: wl.first.clientData !ABORTED => {abort _ TRUE; CONTINUE}];
wl _ wl.rest;
ENDLOOP;
IF abort THEN ERROR ABORTED;
END;

GetIndex: PUBLIC PROC [ports: Ports, key: ROPE] RETURNS [index: CARDINAL] =
BEGIN
FOR i: CARDINAL IN [0..ports.length) DO
IF key.Equal[ports[i].name] THEN RETURN [i];
ENDLOOP;
RETURN [notFound];
END;

IDBreak: IO.BreakProc =
{RETURN [SELECT char FROM
IO.SP, IO.CR, IO.LF, IO.TAB => sepr,
IN ['a..'z], IN ['A..'Z], IN['0..'9] => other,
ENDCASE => break]};

FillInInterfaceNodes: PROC [cell: Cell, interfaceNodes: ROPE] =
BEGIN
index: CARDINAL _ 0;
in: IO.STREAM _ IO.RIS[interfaceNodes];
[] _ in.GetIndex[];	--wake up generic GetIndex impl
in.SkipOver[IO.WhiteSpace];
IF NOT in.EndOf[] THEN DO
name: ROPE _ in.GetToken[IDBreak];
key: ROPE;
this: CARDINAL;
in.SkipOver[IO.WhiteSpace];
IF (IF in.EndOf[] THEN FALSE ELSE in.PeekChar[] = ':) THEN
BEGIN
key _ name;
IF in.GetChar[] # ': THEN ERROR;
IF in.EndOf[] THEN ERROR Error[IO.PutFR["Interface spec syntax error, at %g", IO.int[in.GetIndex[]]]];
name _ in.GetToken[IDBreak];
IF (this _ GetIndex[cell.class.ports, key]) = notFound THEN ERROR Error[IO.PutFR["No such port (%g) for CellClass %g", IO.rope[key], IO.rope[cell.class.name]]];
END
ELSE BEGIN
IF index >= cell.interfaceNodes.length THEN ERROR Error[IO.PutFR["No %g'th element in %g's Interface", IO.int[index], IO.rope[cell.class.name]]];
key _ cell.class.ports[this _ index].name;
END;
IF cell.interfaceNodes[this] # NIL THEN ERROR Error[IO.PutFR["Port %g specified twice in \"%g\"", IO.rope[key], IO.rope[interfaceNodes]]];
cell.interfaceNodes[this] _ LookupNode[cell.parent, name];
IF cell.interfaceNodes[this] = NIL THEN ERROR Error[IO.PutFR["Node %g not found", IO.rope[name]]];
IF cell.class.ports[this].output AND cell.interfaceNodes[this].unwriteability > 0 THEN SIGNAL Warning[IO.PutFR["Node %g is, but shouldn't be, written to by port %g of cell %g", IO.rope[cell.interfaceNodes[this].name], IO.rope[cell.class.ports[this].name], IO.rope[cell.name]]];
index _ index + 1;
in.SkipOver[IO.WhiteSpace];
IF in.EndOf[] THEN EXIT;
IF in.GetChar[] # ', THEN ERROR Error[IO.PutFR["Interface spec syntax error, at %g", IO.int[in.GetIndex[]]]];
ENDLOOP;
FOR this: CARDINAL IN [0 .. cell.interfaceNodes.length) DO
IF cell.interfaceNodes[this] = NIL THEN
BEGIN
name: ROPE _ cell.class.ports[this].name;
cell.interfaceNodes[this] _ LookupNode[cell.parent, name];
IF cell.interfaceNodes[this] = NIL THEN ERROR Error[IO.PutFR["Port %g not specified in \"%g\"", IO.rope[name], IO.rope[interfaceNodes]]]
ELSE IF cell.class.ports[this].output AND cell.interfaceNodes[this].unwriteability > 0 THEN SIGNAL Warning[IO.PutFR["Node %g is, but shouldn't be, written to by port %g of cell %g", IO.rope[cell.interfaceNodes[this].name], IO.rope[cell.class.ports[this].name], IO.rope[cell.name]]];
END;
ENDLOOP;
in.Close[];
END;

LookupNode: PROC [cell: Cell, name: ROPE] RETURNS [node: Node] =
BEGIN
index: CARDINAL;
IF (node _ NARROW[cell.internalNodes.Lookup[name]]) # NIL THEN RETURN [node];
IF (index _ GetIndex[cell.class.ports, name]) # notFound THEN RETURN [cell.interfaceNodes[index]];
node _ NIL;
END;

FinishCreatingCell: PROC [cell: Cell, interfaceNodes: ROPE, initData: REF ANY _ NIL] =
BEGIN
class: CellClass _ cell.class;
thisChild, lastChild: Cell;
thisNode, lastNode: Node;
IF cell.parent # NIL THEN
BEGIN
cell.parent.components.Insert[cell !OSTR.DuplicateKey => ERROR Error[IO.PutFR["Duplicated Cell name: %g", IO.rope[cell.name]]]];
cell.rightSibling _ cell.parent.leftChild;
--do it in wrong order for now; parent will fix up after done expanding--
cell.parent.leftChild _ cell;
END;
cell.nextInstance _ class.firstInstance;
class.firstInstance _ cell;
FillInInterfaceNodes[cell, interfaceNodes];
cell.expansion _ FindAndUseExpandDecider[cell];
SELECT cell.expansion FROM
Inline => BEGIN
cell.type _ Shadow;
cell.realCellStuff _ NIL;
FOR index: CARDINAL IN [0 .. class.ports.length) DO
interfaceNode: Node _ cell.interfaceNodes[index];
IF NOT class.ports[index].output THEN interfaceNode.unwriteability _ interfaceNode.unwriteability + 1;
ENDLOOP;
class.expand[thisCell: cell, initData: initData];
FOR index: CARDINAL IN [0 .. class.ports.length) DO
interfaceNode: Node _ cell.interfaceNodes[index];
IF NOT class.ports[index].output THEN interfaceNode.unwriteability _ interfaceNode.unwriteability - 1;
ENDLOOP;
END;
Leaf, Nested => BEGIN
cell.type _ Real;
cell.realCellStuff _ NEW [RealCellStuffRep _ [schedNext: notInSchedule,
newIO: NIL, oldIO: NIL,
newIOAsWP: NIL, oldIOAsWP: NIL,
initData: initData,
state: NIL,
eval: class.eval]];
FOR portIndex: CARDINAL IN [0..class.ports.length) DO
node: Node _ cell.interfaceNodes[portIndex];
targType: SignalType _ cell.class.ports[portIndex].type;
IF node.type = NIL THEN node.type _ targType;
IF targType # node.type THEN ERROR InterfaceMismatch[cell: cell, index: portIndex, expected: targType, got: node.type];
IF cell.class.ports[portIndex].input THEN node.readers _ CONS[[cell, portIndex], node.readers];
NoteMaybeVisible[node, [cell, portIndex]];
ENDLOOP;
IF class.ioCreator # NIL THEN class.ioCreator[cell: cell, initData: initData]
ELSE IF class.ioWordCount > 0 THEN ERROR Error[IO.PutFR["No IOCreator for class %g", IO.rope[class.name]]];
cell.realCellStuff.newIOAsWP _ LOOPHOLE[cell.realCellStuff.newIO];
cell.realCellStuff.oldIOAsWP _ LOOPHOLE[cell.realCellStuff.oldIO];
FOR portIndex: CARDINAL IN [0 .. class.ports.length) DO
targType: SignalType _ cell.class.ports[portIndex].type;
IF targType.init # NIL THEN targType.init[SocketToWP[[cell, portIndex]], targType.typeData];
ENDLOOP;
IF class.initializer # NIL THEN class.initializer[cell: cell, initData: initData, leafily: cell.expansion = Leaf];
IF cell.expansion = Nested THEN
BEGIN
insides: Structure;
cell.realCellStuff.eval _ EvalStructure;
cell.realCellStuff.state _ insides _ NEW [StructureRep _ [
container: cell,
mirror: NEW [CellRep _ [
name: cell.name.Cat["-mirror"],
class: GetMirrorClass[cell.class],
parent: cell,
leftChild: NIL,
rightSibling: NIL,
firstInternalNode: NIL,
internalNodes: NIL,
components: NIL,
interfaceNodes: NIL,
other: NIL,
type: Real,
expansion: Leaf,
realCellStuff: NEW [RealCellStuffRep _ [
schedNext: notInSchedule,
newIO: NIL, oldIO: NIL,
newIOAsWP: NIL, oldIOAsWP: NIL,
state: NIL,
eval: NIL]]]],
schedFirst: NIL, schedLast: NIL,
insideNodes: NEW [NodeSR[class.ports.length]] ]];
insides.mirror.interfaceNodes _ insides.insideNodes;
FOR index: CARDINAL IN [0 .. class.ports.length) DO
outsideNode: Node _ cell.interfaceNodes[index];
insideNode: Node _ CreateNode[within: cell, name: class.ports[index].name, type: outsideNode.type];
insides.insideNodes[index] _ insideNode;
NoteMaybeVisible[insideNode, [insides.mirror, index]];
IF cell.class.ports[index].output THEN insideNode.readers _ CONS[[insides.mirror, index], insideNode.readers];
IF NOT class.ports[index].output THEN insideNode.unwriteability _ insideNode.unwriteability + 1;
ENDLOOP;
[insides.mirror.realCellStuff.oldIO, insides.mirror.realCellStuff.newIO] _ MakeMirrorIO[cell];
insides.mirror.realCellStuff.newIOAsWP _ LOOPHOLE[insides.mirror.realCellStuff.newIO];
insides.mirror.realCellStuff.oldIOAsWP _ LOOPHOLE[insides.mirror.realCellStuff.oldIO];
class.expand[thisCell: cell, initData: initData];
END;
END;
ENDCASE => ERROR;
lastChild _ NIL;
thisChild _ cell.leftChild;
WHILE thisChild # NIL DO
nextChild: Cell _ thisChild.rightSibling;
thisChild.rightSibling _ lastChild;
lastChild _ thisChild;
thisChild _ nextChild;
ENDLOOP;
cell.leftChild _ lastChild;
lastNode _ NIL;
thisNode _ cell.firstInternalNode;
WHILE thisNode # NIL DO
nextNode: Node _ thisNode.next;
thisNode.next _ lastNode;
lastNode _ thisNode;
thisNode _ nextNode;
ENDLOOP;
cell.firstInternalNode _ lastNode;
END;

NoteMaybeVisible: PROC [node: Node, socket: Socket] = INLINE
BEGIN
IF node.visible.cell = NIL THEN node.visible _ socket
ELSE IF node.visible.cell.class.ports[node.visible.index].output THEN RETURN
ELSE node.visible _ socket;
END;

MakeMirrorIO: PROC [cell: Cell] RETURNS [a, b: REF ANY] = TRUSTED
BEGIN
org, aTV, bTV: AMTypes.TypedVariable;
type: AMTypes.Type;
IF cell.realCellStuff.newIO = NIL THEN RETURN [NIL, NIL];
org _ AMBridge.TVForReferent[cell.realCellStuff.newIO];
type _ AMTypes.TVType[org];
aTV _ AMTypes.New[type];
AMTypes.Assign[aTV, org];
a _ AMBridge.RefFromTV[aTV];
bTV _ AMTypes.New[type];
AMTypes.Assign[bTV, org];
b _ AMBridge.RefFromTV[bTV];
END;

GetMirrorClass: PROC [class: CellClass] RETURNS [mirrorClass: CellClass] =
BEGIN
name: ROPE _ class.name.Concat["-mirror"];
asAny: REF ANY;
IF (asAny _ cellClasses.Lookup[name]) # NIL THEN RETURN [NARROW[asAny]];
RegisterCellClass[className: name, ports: MirrorPorts[class.ports]];
mirrorClass _ NARROW[cellClasses.Lookup[name]];
END;

MirrorPorts: PUBLIC PROC [fwd: Ports] RETURNS [bkwd: Ports] =
BEGIN
bkwd _ NEW [PortsRep[fwd.length]];
FOR i: CARDINAL IN [0 .. fwd.length) DO
bkwd[i] _ fwd[i];
bkwd[i].input _ fwd[i].output;
bkwd[i].output _ fwd[i].input;
ENDLOOP;
END;

FindAndUseExpandDecider: PROC [cell: Cell] RETURNS [ExpandDecision] =
BEGIN
ed: ExpandDecision;
possibilities: [0..3];
[ed, possibilities] _ PickOne[cell];
IF possibilities = 1 THEN RETURN [ed];
IF possibilities = 0 THEN ERROR Error[IO.PutFR["Can't do anything with class %g", IO.rope[cell.class.name]]];
FOR temp: Cell _ cell, temp.parent WHILE temp # NIL DO
asAny: REF ANY _ List.Assoc[$ExpandDeciderClosure, temp.other];
edc: ExpandDeciderClosure;
try: ExpandDecision;
IF asAny = NIL THEN LOOP;
edc _ NARROW[asAny];
try _ edc.Decide[cell, edc.otherData];
RETURN [IF Possible[cell, try] THEN try ELSE ed];
ENDLOOP;
RETURN [ed];
END;

PickOne: PROC [cell: Cell] RETURNS [whatToDo: ExpandDecision, possibilities: [0..3]] =
BEGIN
possibilities _ 0;
FOR i: [1..3] IN [1..3] DO
d: ExpandDecision _ orderedChoices[i];
IF Possible[cell, d] THEN {whatToDo _ d; possibilities _ possibilities + 1};
ENDLOOP;
END;

orderedChoices: ARRAY [1..3] OF ExpandDecision = [Leaf, Nested, Inline];

Possible: PUBLIC PROC [cell: Cell, whatToDo: ExpandDecision] RETURNS [possible: BOOLEAN] =
BEGIN
RETURN [SELECT whatToDo FROM
Leaf => cell.class.eval # NIL AND (IF cell.class.ioWordCount > 0 THEN cell.class.ioCreator # NIL ELSE TRUE),
Nested => cell.class.expand # NIL AND (IF cell.class.ioWordCount > 0 THEN cell.class.ioCreator # NIL ELSE TRUE),
Inline => cell.class.expand # NIL AND cell.parent # NIL,
ENDCASE => ERROR];
END;

CompareNodes: OSTR.CompareProc =
BEGIN
k1, k2: ROPE;
WITH r1 SELECT FROM
r: ROPE => k1 _ r;
n: Node => k1 _ n.name;
ENDCASE => ERROR;
k2 _ WITH r2 SELECT FROM
r: ROPE => r,
n: Node => n.name,
ENDCASE => ERROR;
RETURN [k1.Compare[k2]];
END;

CompareComponents: OSTR.CompareProc =
BEGIN
ToKey: SAFE PROC [ref: REF ANY] RETURNS [ROPE] =
{RETURN [WITH ref SELECT FROM
r: ROPE => r, c: Cell => c.name, ENDCASE => ERROR]};
RETURN [ToKey[r1].Compare[ToKey[r2]]];
END;

CompareCellClasses: OSTR.CompareProc =
BEGIN
ToKey: SAFE PROC [ref: REF ANY] RETURNS [ROPE] =
{RETURN [WITH ref SELECT FROM
r: ROPE => r, cc: CellClass => cc.name, ENDCASE => ERROR]};
RETURN [ToKey[r1].Compare[ToKey[r2]]];
END;

END.

œRosemaryCreate.mesa
last changed by Barth, June 9, 1983 11:14 am
Last Edited by: Spreitzer, September 15, 1983 10:51 am

Data Structure manipulation:
�Ê{˜Jš
œ™Jš
œ,™,J™6Icode˜KšÏk	œ�œ?˜dK˜šÐbxœ�œ
�œ
˜Kš�œ�œ�œ8˜gKš�œ˜—K˜Kš�œ
�œ˜%K˜KšÏbœ�œ
�œ�œ�œ
�œ�œ�œ
˜?K˜KšŸœ�œ
�œ�œ�œ
�œ�œ�œ
˜<K˜šŸœ�œ
�œ
˜,Kšœ�œ
˜Kšœ�œ
˜"—K˜KšÏnœ�œ
�œ�œ�œ�œ
�œ�œ�œ
˜BK˜K˜Kšœ
�œ
�œ
�œ�œ�œ˜(K˜Kšœ
�œ�œ!˜GKšœ�œ�œ ˜@K˜K™Kš
Ïl™K˜š œ�œ
�œ
�œ�œ�œ�œ!�œ�œ
�œ˜á
Kš
�˜šœ�œ˜%Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜K˜Kš
œ
˜
K˜Kš
œ˜Kšœ�œ˜—Kšœ�œ ˜7š�œ�œ
�œ�˜1K˜!Kšœ�œ2˜FKš�œ
�œ
�œ
�œ�œ*�œ˜eKš�œ
˜—š�œ�œ
�˜Kš
�˜š�œ�œ
�˜Kš
�˜Kšœ�œ�œ
˜Kš�œ$�œ�˜5š�œ
�˜
š�œ�œ
�œ�˜4š�œ˜Kšœ?�˜AKšœ?�˜AKšœ5�˜7Kšœ7�˜9Kšœ9�˜;Kš�œ;˜>—Kš�œ�œ�œ˜Kš�œ
˜—Kš�œ
˜—Kš�œ
�œ�œ
�œ�œN�œ˜€
Kš�œ
˜—š�œ;�œ�œ
�˜UKš�œ�œ
�œ
˜#K˜š�œ�˜!Kš
�˜Kš�œ(�œ
�œ
˜5Kš
œ&˜&Kš�œ
˜—š�œ�œ �œ
�˜JKš�œ
�˜
K˜Kšœ(Ïc˜4Kš
œ'˜'K˜,K˜,K˜8Kšœ#�œ˜JKšœ#�œ˜Jš�œ�œ
�œ�˜+Kš
œ:˜:Kš
œ:˜:Kš�œ
˜—Kš�œ
˜—Kš�œ
˜—Kš�œ
˜—K˜Kš�œ
˜—K˜Kšœ�œ
�œ�œ
˜ K˜š 
œ�œ
�œ�œ�œ
�œ�œ!�œ˜‰
Kš
�˜K˜Kšœ�œ ˜.Kš�œ	�œ
�œ
�œ�œ�œ˜Sšœ�œ
˜K˜!Kš	œ�œ
�œ�œ�œ
˜GKšœ�œ˜.Kšœ�œ ˜0Kšœ�œ
˜ Kšœ�œ
˜Kš
œ ˜ Kšœ�œ˜—K˜GKšœ�œ˜(Kš	œ�œ�œ�œ#�œ˜oKš�œ
˜—K˜š 
œ�œ
�œ�œ�œ
¢œ�œ˜wKš
�˜šœ�œ
˜K˜Kš
œ˜Kšœ
�œ�œ
�œ˜"—Kš	œ"�œ�œ�œ#�œ˜yK˜%Kš
¢7˜7K˜ Kš�œ
˜—K˜š 
œ�œ
�œ9�œ�œ
�œ�œ�œ˜…
Kš
�˜K˜Kšœ�œ ˜.Kš�œ	�œ
�œ
�œ�œ�œ˜Sšœ�œ
˜K˜!Kšœ�œ�œ�œ
˜JKšœ�œ˜.Kšœ�œ ˜0Kšœ�œ˜1Kšœ�œ
˜Kš
œ ˜ Kšœ�œ˜—K˜3Kš�œ�œ˜,Kš�œ
˜—K˜š œ�œ
�œ=˜XKš
�˜Kšœ�œ#˜AKš�œ
˜—K˜š œ�œ
�œ=˜[Kš
�˜Kšœ�œ
˜!š�œ)�œ�œ
�˜>š�œ�˜Kš	œ
�œ�œ
�œ$�œ˜QKš�œ˜—K˜Kš�œ
˜—Kš�œ
˜—K˜š œ�œ3�œ˜kKš
�˜Kšœ�œ
˜!K˜š�œ�œ�œ
�˜/š�œ�˜Kš	œ
�œ�œ
�œ�œ˜>Kš�œ˜—K˜Kš�œ
˜—Kš�œ
˜—K˜š œ�œ
�œ�œ˜RKš
�˜š�œ�˜šœ�œ�œ
�œ�œ�œ˜gKšœ#�œ-˜T—šœ
�œ�œ
�œ�œ�œ˜cKšœ"�œ,˜R—š�œ�˜Kšœ�œ,˜HKšœ�œ˜Kš
œC˜CKš�œ
˜——Kš�œ
˜—K˜š œ�œ
�œ�œ˜UKš
�˜š�œ�˜šœ�œ�œ
�œ�œ�œ˜gKš
œa˜a—šœ
�œ�œ
�œ�œ�œ˜cKš
œ_˜_—š�œ�˜Kšœ�œ,˜HK˜$K˜CKš�œ
˜——Kš�œ
˜—K˜š œ�œ
�œ�œ˜8Kš
�˜Kšœ�œ,˜HKšœ�œ�œ
˜š�œ�œ
�˜Kšœ=�œ
�œ�œ˜bK˜
Kš�œ
˜—Kš�œ�œ
�œ
�œ
˜Kš�œ
˜—K˜Kšœ�œ�œ
�œ˜0Kšœ�œ˜K˜š œ�œ7�œ˜sKš
�˜Kšœ�œ
˜#K˜š�œ�œ�œ
�˜/š�œ�˜Kš	œ
�œ�œ
�œ�œ˜>Kš�œ˜—K˜Kš�œ
˜—Kš�œ
˜—K˜š œ�œ
�œ	�œ˜JKš
�˜Kšœ�œ)˜MKšœ�œ˜#Kš
œ6˜6Kš�œ
˜—K˜š œ�œ
�œ	�œ˜MKš
�˜Kšœ�œ)˜MKš
œT˜TKš�œ
˜—K˜š œ�œ
�œ	�œ˜.Kš
�˜Kšœ�œ)˜GKšœ�œ�œ
˜š�œ�œ
�˜Kšœ1�œ
�œ�œ˜VK˜
Kš�œ
˜—Kš�œ�œ
�œ
�œ
˜Kš�œ
˜—K˜š œ�œ
�œ�œ�œ	�œ˜KKš
�˜š�œ�œ
�œ�˜'Kš�œ�œ
�œ˜,Kš�œ
˜—Kš�œ˜Kš�œ
˜—K˜š œ�œ˜šœ
�œ�œ�˜Kš�œ
�œ�œ
�œ�œ
�œ�œ
�œ	˜$Kš�œ�œ�œ˜.Kš�œ˜——K˜š œ�œ�œ˜?Kš
�˜Kšœ�œ˜Kš	œ�œ
�œ�œ
�œ˜'Kšœ¢˜3Kšœ�œ
˜š�œ
�œ�œ
�˜Kšœ�œ˜"Kšœ�œ
˜
Kšœ�œ
˜Kšœ�œ
˜š�œ�œ�œ
�œ
�œ�˜:Kš
�˜K˜Kš�œ�œ
�œ
˜ Kš
�œ�œ
�œ�œ-�œ˜fKš
œ˜Kš�œ5�œ
�œ�œ-�œ�œ˜ 
Kš
�˜—š�œ
�˜
Kš�œ%�œ
�œ�œ-�œ
�œ˜‘
Kš
œ*˜*Kš�œ
˜—Kš�œ�œ
�œ
�œ�œ,�œ�œ˜Š
K˜:Kš�œ�œ
�œ
�œ�œ�œ˜bKš�œ�œ.�œ
�œ	�œI�œ'�œ$�œ˜•K˜Kšœ�œ
˜Kš�œ�œ
�œ
˜Kš
�œ�œ
�œ�œ-�œ˜mKš�œ
˜—š�œ�œ
�œ#�˜:š�œ�œ
�˜'Kš
�˜Kšœ�œ˜)K˜:Kš�œ�œ
�œ
�œ�œ*�œ
�œ˜ˆ
Kš�œ
�œ�œ.�œ
�œ	�œI�œ'�œ$�œ˜šKš�œ
˜—Kš�œ
˜—K˜Kš�œ
˜—K˜š 
œ�œ�œ�œ˜@Kš
�˜Kšœ�œ
˜Kš
�œ	�œ%�œ
�œ
�œ˜MKš�œ7�œ
�œ˜bKšœ�œ
˜Kš�œ
˜—K˜š œ�œ�œ�œ
�œ�œ˜VKš
�˜K˜K˜K˜š�œ�œ
�˜Kš
�˜Kš	œ$�œ�œ�œ#�œ˜€
K˜*Kš
¢I˜IK˜Kš�œ
˜—K˜(K˜K˜+Kš
œ/˜/š�œ�˜šœ
�˜K˜Kšœ�œ
˜š�œ�œ
�œ�˜3Kš
œ1˜1Kš�œ
�œ�œA˜fKš�œ
˜—K˜1š�œ�œ
�œ�˜3Kš
œ1˜1Kš�œ
�œ�œA˜fKš�œ
˜—Kš�œ
˜—šœ�˜K˜š
œG˜GKšœ�œ	�œ
˜Kšœ�œ
�œ
˜K˜Kšœ�œ
˜Kš
œ˜—š�œ�œ
�œ�˜5Kš
œ,˜,K˜8Kš�œ
�œ
�œ˜-Kš�œ�œ
�œU˜wKš�œ#�œ�œ"˜_Kš
œ*˜*Kš�œ
˜—Kš�œ�œ
�œ0˜MKš�œ
�œ�œ
�œ�œ$�œ˜kKšœ�œ˜BKšœ�œ˜Bš�œ�œ
�œ�˜7K˜8Kš�œ�œ
�œA˜\Kš�œ
˜—Kš�œ�œ
�œS˜rš�œ�˜Kš
�˜Kš
œ˜K˜(šœ%�œ˜:Kš
œ˜šœ�œ
˜Kš
œ˜Kš
œ"˜"Kš
œ
˜
Kšœ�œ
˜Kšœ�œ
˜Kšœ�œ
˜Kšœ�œ
˜Kšœ�œ
˜Kšœ�œ
˜Kšœ�œ
˜Kš
œ˜K˜šœ�œ˜(Kš
œ˜Kšœ�œ	�œ
˜Kšœ�œ
�œ
˜Kšœ�œ
˜Kšœ�œ˜——Kšœ�œ
�œ
˜ Kšœ
�œ!˜1—K˜4š�œ�œ
�œ�˜3Kš
œ/˜/Kš
œc˜cKš
œ(˜(Kš
œ6˜6Kš�œ �œ�œ.˜nKš�œ
�œ�œ;˜`Kš�œ
˜—Kš
œ^˜^Kšœ)�œ%˜VKšœ)�œ%˜VK˜1Kš�œ
˜—Kš�œ
˜—Kš�œ�œ
˜—Kšœ�œ
˜K˜š�œ
�œ
�˜K˜)K˜#K˜K˜Kš�œ
˜—K˜Kšœ�œ
˜K˜"š�œ�œ
�˜K˜Kš
œ˜Kš
œ˜Kš
œ˜Kš�œ
˜—Kš
œ"˜"Kš�œ
˜—K˜š œ�œ �˜<Kš
�˜Kš�œ�œ
�œ˜5Kš�œ
�œ:�œ
�˜LKš�œ˜Kš�œ
˜—K˜š œ�œ�œ�œ
�œ�˜AKš
�˜K˜%K˜Kš�œ�œ
�œ
�œ�œ�œ˜9K˜7K˜K˜K˜K˜K˜K˜K˜Kš�œ
˜—K˜š œ�œ�œ˜JKš
�˜Kšœ�œ ˜*Kšœ�œ
�œ
˜Kš
�œ&�œ
�œ
�œ�œ	˜HKš
œD˜DKšœ�œ˜/Kš�œ
˜—K˜š œ�œ
�œ�œ˜=Kš
�˜Kšœ�œ˜"š�œ�œ
�œ�˜'K˜K˜K˜Kš�œ
˜—Kš�œ
˜—K˜š œ�œ�œ˜EKš
�˜K˜K˜K˜$Kš�œ�œ
�œ˜&Kš
�œ�œ
�œ�œ*�œ˜mš�œ �œ�œ
�˜6Kšœ�œ
�œ1˜?K˜Kš
œ˜Kš�œ	�œ
�œ
�œ
˜Kšœ�œ˜Kš
œ&˜&Kš�œ�œ�œ�œ˜1Kš�œ
˜—Kš�œ˜Kš�œ
˜—K˜š œ�œ�œ4˜VKš
�˜K˜š�œ�œ�˜Kš
œ&˜&Kš�œ�œ3˜LKš�œ
˜—Kš�œ
˜—K˜Kšœ�œ�œ)˜HK˜š
 œ�œ
�œ(�œ�œ˜ZKš
�˜š�œ�œ
�˜Kšœ�œ
�œ�œ�œ�œ
�œ
�œ˜lKšœ�œ
�œ�œ�œ�œ
�œ
�œ˜pKšœ�œ
�œ�œ
˜8Kš�œ�œ˜—Kš�œ
˜—K˜š œ�œ˜ Kš
�˜Kšœ�œ
˜
š�œ�œ
�˜Kšœ�œ˜Kš
œ˜Kš�œ�œ
˜—šœ�œ�œ
�˜Kšœ�œ˜
K˜Kš�œ�œ
˜—Kš�œ˜Kš�œ
˜—K˜š œ�œ˜%Kš
�˜š œ�œ
�œ�œ
�œ�œ�œ˜0šœ
�œ�œ�œ
�˜Kšœ�œ�œ�œ˜4——Kš�œ ˜&Kš�œ
˜—K˜š œ�œ˜&Kš
�˜š œ�œ
�œ�œ
�œ�œ�œ˜0šœ
�œ�œ�œ
�˜Kšœ�œ!�œ�œ˜;——Kš�œ ˜&Kš�œ
˜—K˜Kš�œ
˜J˜—…—NÒgé