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]] }; 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. :JaM.mesa Last edited by: Doug Wyatt, August 24, 1983 5:52 pm Maureen Stone January 26, 1984 5:40:32 pm PST Types Creating a new interpreter Stack operations Array operations Dictionary operations Atoms Key comparison JaM will raise Error if any problems are encountered. The main execution loop converters these errors to ropes and prints them on the state.out stream since the main client of these procedures is the JaM typescript. It then raises the ERROR Stop. All clients of ExecuteRope and Execute may see the error Stop. If you are the top level procedure, it is adequate to immediately continue ie: Execute[state, any ! Stop => CONTINUE]. Scanning Execution Errors Registration (JaMControlImpl) There is a global list of names and initialization procedures kept in sysDict called .initprocs. Each program that wants to register commands with JaM should register an initialization procedure and a unique name (capitalization counts). There is a separate JaM dictionary for each typescript. To register commands in a particular dictionary execute (name) .callinit. This calls the named initialization proc with the correct JaM State. Note: you can create your own State independent of the typescripts by using JaM.Create. You can then register commands in that dictionary directly or simulate the typescript mechanism with ExecuteRope[state, "(name) .callinit \n"]; Register a name and an initialization proc that does all the calls to Register (below) Suggestion: make the name your module name put all your calls to Register in your initialization proc (above) Ê­˜Jšœ™J™šœ™Jšœ#™#J™-—J˜šÏk ˜ Jšœœœ˜Jšœœœ˜J˜—Jšœœ ˜Jšœ˜J˜J™J™Jšœœœ˜Jšœœœœ˜J˜Jšœœœ ˜šœ œœ˜Jšœ ˜JšœÏc˜"Jšœ œœž˜.Jšœœž˜(J˜J˜—Jšœœœ ˜Jšœ œ˜J˜Jšœœœœ˜J˜Jšœ œœ ˜Jš œ œœœœ ˜9J˜Jšœœœ˜Jšœœœ ˜ J˜Jšœœœ ˜Jš œ œœœœ˜:Jšœœœ ˜Jšœ œ˜J˜Jšœœœ ˜Jšœ œœœ˜;Jšœ œœ ˜!Jš œ œœœœœ˜6J˜Jšœœœ ˜Jšœ œœœ˜J˜J™J™JšÏnœœœœ˜)J˜J™J˜JšŸœœœ˜J˜JšŸœœ˜ JšŸœœœ˜%JšŸœœœ˜#JšŸœœœ˜%JšŸœœœœ˜@JšŸ œœœœ˜DJšŸ œœœ˜BJšŸœœœ˜@J˜JšŸœœœ˜$JšŸœœœœ˜)JšŸœœœœ˜'JšŸœœœœ˜)JšŸœœœœ˜)JšŸ œœœœ˜-JšŸœœœ˜+JšŸœœœ˜)J˜JšŸœœœ˜ JšŸœœœ˜#JšŸœœœœ˜.JšŸœœœœ˜&J˜JšŸœœœ˜(JšŸœœœ˜'Jš Ÿ œœœœœ˜8J˜Jšœ™J˜JšŸœœ œœ˜+JšŸ œœœœ˜9JšŸœœœœ˜@JšŸœœœ˜5JšŸœœœ ˜)JšŸœœœœ˜.Jš Ÿœœœœœ˜?šŸœœ˜&J˜—Jšœ™J˜Jšœ˜J˜JšŸœœ œœ˜)JšŸ œœ œœ˜*J˜JšŸœœ˜%JšŸœœœœ ˜DJšŸœœœ˜-JšŸœœ˜ JšŸ œœ˜$JšŸ œœ˜$JšŸ œœ ˜J˜JšŸœœ˜&JšŸœœ˜(JšŸ œœœœ ˜FJšŸœœœ˜/JšŸœœœœ˜EJšŸœœ˜%JšŸœœ˜J˜J™J˜Jš Ÿ œœœœœ˜%Jš Ÿ œœœœœ˜%J™Jšœ™J˜JšŸœœ œœ˜%JšŸœœ œœœœœœœœ˜YJ˜Jšœ³™³J™Jšœ™J˜JšŸ œœœ˜+Jš Ÿ œœœœœ˜-J™Jšœ ™ J˜JšŸœœ˜#JšŸœœœœ˜*JšŸœœœ˜%J˜Jšœ™J˜Jšœ œÌ˜ÛJšœœœœ˜4Jšœœ˜ Jšœœ˜ J˜Jšœ™J™J™îJ™ÉJ™éJ˜šŸ œœœœ ˜2JšœV™VJšœ*™*—šŸœœœœ ˜;JšœB™B—J˜Jšœ˜J˜J˜—…—¶