<> <<>> <> <> <> DIRECTORY IO USING [STREAM], Rope USING [ROPE]; JaM: CEDAR DEFINITIONS = BEGIN <> <<>> ROPE: TYPE = Rope.ROPE; STREAM: TYPE = IO.STREAM; State: TYPE = REF StateRep; StateRep: TYPE = RECORD[ aborted: BOOLEAN _ FALSE, stack: Stack, -- the operand stack dictstk: LIST OF Dict, -- the dictionary stack out: STREAM -- output stream, for .print ]; Stack: TYPE = REF StackRep; StackRep: TYPE; Any: TYPE = REF ANY; Command: TYPE = REF CommandRep; CommandRep: TYPE = RECORD[name: ATOM, proc: PROC[State]]; Op: TYPE = REF OpRep; OpRep: TYPE = RECORD[body: Any]; Dict: TYPE = REF DictRep; DictRep: TYPE = RECORD[tab: SymTab, attach: LIST OF Dict]; SymTab: TYPE = REF SymTabRep; SymTabRep: TYPE; Array: TYPE = REF ArrayRep; ArrayRep: TYPE = RECORD[start, length: NAT, seq: Sequence]; Sequence: TYPE = REF SequenceRep; SequenceRep: TYPE = RECORD[SEQUENCE size: NAT OF Any]; Mark: TYPE = REF MarkRep; MarkRep: TYPE = RECORD[m: INT]; <> <<>> Create: PROC[out: STREAM] RETURNS[State]; <> NewStack: PROC RETURNS[Stack]; Push: PROC[self: State, x: Any]; PushBool: PROC[self: State, x: BOOL]; PushInt: PROC[self: State, x: INT]; PushReal: PROC[self: State, x: REAL]; PushRope: PROC[self: State, x: ROPE] = INLINE { Push[self, x] }; PushStream: PROC[self: State, x: STREAM] = INLINE { Push[self, x] }; PushArray: PROC[self: State, x: Array] = INLINE { Push[self, x] }; PushDict: PROC[self: State, x: Dict] = INLINE { Push[self, x] }; Pop: PROC[self: State] RETURNS[Any]; PopBool: PROC[self: State] RETURNS[BOOL]; PopInt: PROC[self: State] RETURNS[INT]; PopReal: PROC[self: State] RETURNS[REAL]; PopRope: PROC[self: State] RETURNS[ROPE]; PopStream: PROC[self: State] RETURNS[STREAM]; PopArray: PROC[self: State] RETURNS[Array]; PopDict: PROC[self: State] RETURNS[Dict]; Copy: PROC[self: State, n: INT]; Roll: PROC[self: State, n, k: INT]; Index: PROC[self: State, i: INT] RETURNS[Any]; Count: PROC[self: State] RETURNS[INT]; PushMark: PROC[self: State, m: INT _ 0]; PopMark: PROC[self: State, m: INT _ 0]; CountToMark: PROC[self: State, m: INT _ 0] RETURNS[INT]; <> NewArray: PROC[length: INT] RETURNS[Array]; MakeArray: PROC[self: State, length: INT] RETURNS[Array]; SubArray: PROC[array: Array, start, length: INT] RETURNS[Array]; PutArray: PROC[from: Array, start: INT, into: Array]; APut: PROC[array: Array, i: INT, x: Any]; AGet: PROC[array: Array, i: INT] RETURNS[Any]; AFind: PROC[array: Array, x: Any] RETURNS[found: BOOL, i: INT]; ABind: PROC[array: Array, dict: Dict]; <> sysDict: Dict; NewDict: PROC[length: INT] RETURNS[Dict]; DictLength: PROC[dict: Dict] RETURNS[INT]; Put: PROC[dict: Dict, key, val: Any]; TryToGet: PROC[dict: Dict, key: Any] RETURNS[found: BOOL, val: Any]; Get: PROC[dict: Dict, key: Any] RETURNS[Any]; Del: PROC[dict: Dict, key: Any]; AttachDict: PROC[dict, adict: Dict]; DetachDict: PROC[dict, adict: Dict]; DetachAll: PROC[dict: Dict]; Def: PROC[self: State, key, val: Any]; Store: PROC[self: State, key, val: Any]; TryToLoad: PROC[self: State, key: Any] RETURNS[found: BOOL, val: Any]; Load: PROC[self: State, key: Any] RETURNS[Any]; Where: PROC[self: State, key: Any] RETURNS[found: BOOL, where: Dict]; Begin: PROC[self: State, dict: Dict]; End: PROC[self: State]; <> AtomToRope: PROC[ATOM] RETURNS[ROPE]; RopeToAtom: PROC[ROPE] RETURNS[ATOM]; <<>> <> Equal: PROC[a, b: Any] RETURNS[BOOL]; Eq: PROC[a, b: Any] RETURNS[BOOL] = INLINE { RETURN[IF a=b THEN TRUE ELSE Equal[a, b]] }; < CONTINUE]. >> <<>> <> ExecuteRope: PROC[self: State, rope: ROPE]; LineComplete: PROC[text: ROPE] RETURNS[BOOL]; <<>> <> Execute: PROC[self: State, x: Any]; GetAbort: PROC[self: State] RETURNS[BOOL]; SetAbort: PROC[self: State, b: BOOL]; <> ErrorType: TYPE = {AttachmentCycle, BoundsFault, DictionaryUnderflow, InvalidArgs, LoadFailed, NotAttached, NumericOverflow, OpenFailed, StackOverflow, StackUnderflow, UndefinedKey, Unimplemented, WrongMark, WrongType}; Error: ERROR[type: ErrorType, msg: Rope.ROPE _ NIL]; Exit: ERROR; Stop: ERROR; <> <<>> <> <> <> RegisterInit: PROC[name: ROPE, init: PROC[State]]; <> <> Register: PROC[self: State, name: ROPE, proc: PROC[State]]; <> END.