DIRECTORY
TJaMBasic USING [Object, Root, StringLength, Tag],
TJaMInternal USING [Cache, Frame, Locals, Node, Stack],
TJaMStreamDefs USING [StreamHandle];

TJaMOps: DEFINITIONS = {

StreamHandle: TYPE = TJaMStreamDefs.StreamHandle;
Text: TYPE = LONG STRING;
nullOb: TJaMBasic.Object = [X,null[]];
Error: ERROR[error: TJaMBasic.Object];
StackOverflow: ERROR[stack: TJaMInternal.Stack];
Bug: ERROR;
Assert: PROC[pred: BOOLEAN] = INLINE { IF NOT pred THEN ERROR Bug };
rangechk,typechk,undefname,limitchk: name TJaMBasic.Object;
Top: PROC[stack: TJaMInternal.Stack] RETURNS[TJaMBasic.Object] = INLINE {
node: TJaMInternal.Node _ stack.head; IF node=NIL THEN Underflow[stack];
RETURN[node.ob] 
};

Pop: PROC[stack: TJaMInternal.Stack] RETURNS[TJaMBasic.Object] = INLINE {
node: TJaMInternal.Node _ stack.head; IF node=NIL THEN Underflow[stack];
stack.head _ node.next; node.next _ stack.free;
stack.free _ node; RETURN[node.ob] 
};

Push: PROC[stack: TJaMInternal.Stack, ob: TJaMBasic.Object] = INLINE {
node: TJaMInternal.Node _ stack.free; IF node=NIL THEN Overflow[stack];
stack.free _ node.next; node.next _ stack.head;
stack.head _ node; node.ob _ ob 
};

Underflow,Overflow: PROC[stack: TJaMInternal.Stack]; -- these never return
Empty: PROC[stack: TJaMInternal.Stack] RETURNS[BOOLEAN] = INLINE { RETURN[stack.head=NIL] };
Full: PROC[stack: TJaMInternal.Stack] RETURNS[BOOLEAN] = INLINE { RETURN[stack.free=NIL] };
GetMark: PROC[stack: TJaMInternal.Stack] RETURNS[TJaMInternal.Node] = INLINE { RETURN[stack.free] };
Restore: PROC[stack: TJaMInternal.Stack, mark: TJaMInternal.Node];
Copy: PROC[stack: TJaMInternal.Stack, n: CARDINAL];
Dup: PROC[stack: TJaMInternal.Stack] = INLINE { Copy[stack,1] };
Exch: PROC[stack: TJaMInternal.Stack];
Roll: PROC[stack: TJaMInternal.Stack, n,k: CARDINAL];
ClearStack: PROC[stack: TJaMInternal.Stack];
CountStack: PROC[stack: TJaMInternal.Stack, max: CARDINAL _ LAST[CARDINAL]] RETURNS[CARDINAL];
CountToMark: PROC[stack: TJaMInternal.Stack] RETURNS[CARDINAL];
ClearToMark: PROC[stack: TJaMInternal.Stack];
Index: PROC[stack: TJaMInternal.Stack, i: CARDINAL] RETURNS[TJaMBasic.Object];
StackForAll: PROC[stack: TJaMInternal.Stack, proc: PROC[TJaMBasic.Object] RETURNS[BOOLEAN],
unwind: BOOLEAN _ FALSE] RETURNS[BOOLEAN];
ArrayFromStack: PROC[stack: TJaMInternal.Stack] RETURNS[array TJaMBasic.Object];
NewStack: PROC[CARDINAL] RETURNS[TJaMInternal.Stack];
FreeStack: PROC[TJaMInternal.Stack];
PushCardinal: PROC[stack: TJaMInternal.Stack, c: CARDINAL] = INLINE { Push[stack,[L,integer[c]]] };
PushInteger: PROC[stack: TJaMInternal.Stack, i: LONG INTEGER] = INLINE { Push[stack,[L,integer[i]]] };
PushReal: PROC[stack: TJaMInternal.Stack, r: REAL] = INLINE { Push[stack,[L,real[r]]] };
PushBoolean: PROC[stack: TJaMInternal.Stack, b: BOOLEAN] = INLINE { Push[stack,[L,boolean[b]]] };
PopCardinal: PROC[stack: TJaMInternal.Stack, limit: CARDINAL _ 0] RETURNS[CARDINAL];
PopInteger: PROC[stack: TJaMInternal.Stack] RETURNS[LONG INTEGER];
PopReal: PROC[stack: TJaMInternal.Stack] RETURNS[REAL];
PopBoolean: PROC[stack: TJaMInternal.Stack] RETURNS[BOOLEAN];
PopString: PROC[stack: TJaMInternal.Stack] RETURNS[string TJaMBasic.Object];
PopArray: PROC[stack: TJaMInternal.Stack] RETURNS[array TJaMBasic.Object];
PopDict: PROC[stack: TJaMInternal.Stack] RETURNS[dict TJaMBasic.Object];
PopCommand: PROC[stack: TJaMInternal.Stack] RETURNS[command TJaMBasic.Object];
PopStream: PROC[stack: TJaMInternal.Stack] RETURNS[stream TJaMBasic.Object];
TopInteger: PROC[stack: TJaMInternal.Stack] RETURNS[LONG INTEGER];
TopDict: PROC[stack: TJaMInternal.Stack] RETURNS[dict TJaMBasic.Object];
Array: PROC[length: CARDINAL] RETURNS[array TJaMBasic.Object];
ACopy: PROC[array: array TJaMBasic.Object, expand: CARDINAL _ 0] RETURNS[array TJaMBasic.Object];
SubArray: PROC[array: array TJaMBasic.Object, beg,len: CARDINAL] RETURNS[array TJaMBasic.Object];
PutArray: PROC[from: array TJaMBasic.Object, beg: CARDINAL, into: array TJaMBasic.Object];
APut: PROC[array: array TJaMBasic.Object, i: CARDINAL, ob: TJaMBasic.Object];
AGet: PROC[array: array TJaMBasic.Object, i: CARDINAL] RETURNS[TJaMBasic.Object];
AStore: PROC[stack: TJaMInternal.Stack, array: array TJaMBasic.Object];
ALoad: PROC[stack: TJaMInternal.Stack, array: array TJaMBasic.Object];
AFind: PROC[array: array TJaMBasic.Object, ob: TJaMBasic.Object] RETURNS[BOOLEAN,CARDINAL];
AAtom: PROC[array: array TJaMBasic.Object]
RETURNS[found: BOOLEAN, atom: TJaMBasic.Object, rem: array TJaMBasic.Object];
ABind: PROC[array: array TJaMBasic.Object, dict: dict TJaMBasic.Object];
ArrayForAll: PROC[array: array TJaMBasic.Object, proc: PROC[TJaMBasic.Object] RETURNS[BOOLEAN]]
RETURNS[BOOLEAN];

Dict: PROC[maxlen: CARDINAL] RETURNS[dict TJaMBasic.Object];
DictLength: PROC[dict: dict TJaMBasic.Object] RETURNS[CARDINAL];
Where: PROC[frame: TJaMInternal.Frame, key: TJaMBasic.Object] RETURNS[BOOLEAN,dict TJaMBasic.Object];
Get: PROC[dict: dict TJaMBasic.Object, key: TJaMBasic.Object] RETURNS[TJaMBasic.Object];
TryToGet: PROC[dict: dict TJaMBasic.Object, key: TJaMBasic.Object] RETURNS[BOOLEAN,TJaMBasic.Object];
Put: PROC[dict: dict TJaMBasic.Object, key, value: TJaMBasic.Object];
Def: PROC[frame: TJaMInternal.Frame, key, value: TJaMBasic.Object];
Load: PROC[frame: TJaMInternal.Frame, key: TJaMBasic.Object] RETURNS[TJaMBasic.Object];
TryToLoad: PROC[frame: TJaMInternal.Frame, key: TJaMBasic.Object] RETURNS[BOOLEAN,TJaMBasic.Object];
Store: PROC[frame: TJaMInternal.Frame, key, value: TJaMBasic.Object];
Del: PROC[dict: dict TJaMBasic.Object, key: TJaMBasic.Object];
ClrDict: PROC[dict: dict TJaMBasic.Object];
AttachDict: PROC[dict, adict: dict TJaMBasic.Object];
DetachDict: PROC[dict, adict: dict TJaMBasic.Object];
DetachAll: PROC[dict: dict TJaMBasic.Object];
Begin: PROC[frame: TJaMInternal.Frame, dict: dict TJaMBasic.Object];
End: PROC[frame: TJaMInternal.Frame];
NewCache: PROC RETURNS[TJaMInternal.Cache];
FreeCache: PROC[TJaMInternal.Cache];
GetLocalsTop: PROC[frame: TJaMInternal.Frame] RETURNS[CARDINAL] = INLINE {
RETURN[frame.locals.curlen] 
};
SetLocalsTop: PROC[frame: TJaMInternal.Frame, top: CARDINAL] = INLINE {
frame.locals.curlen _ MIN[frame.locals.curlen,top] 
};

DefineLocal: PROC[frame: TJaMInternal.Frame, key,value: TJaMBasic.Object];
LoadLocal: PROC[frame: TJaMInternal.Frame, key: TJaMBasic.Object] RETURNS[TJaMBasic.Object];
TryToLoadLocal: PROC[frame: TJaMInternal.Frame, key: TJaMBasic.Object] RETURNS[BOOLEAN,TJaMBasic.Object];
StoreLocal: PROC[frame: TJaMInternal.Frame, key,value: TJaMBasic.Object];
NewLocals: PROC RETURNS[TJaMInternal.Locals];
FreeLocals: PROC[TJaMInternal.Locals];
KeyName: PROC[key: TJaMBasic.Object] RETURNS[TJaMBasic.Object] = INLINE {
RETURN[WITH k:key SELECT FROM string => StringToName[k], ENDCASE => key] 
};

Equality: TYPE = {nil,F,T}; -- nil (if incompatible types), False, or True
Compare: PROC[a,b: TJaMBasic.Object] RETURNS[Equality];
Equal: PROC[a,b: TJaMBasic.Object] RETURNS[BOOLEAN] = INLINE {
WITH a:a SELECT FROM name => WITH b:b SELECT FROM name => RETURN[a.id=b.id];
ENDCASE; ENDCASE; RETURN[Compare[a,b]=T] 
};

Execute: PROC[TJaMInternal.Frame,TJaMBasic.Object];
Stop: PROC[TJaMInternal.Frame];
GetAbort: PROC[TJaMInternal.Frame] RETURNS[BOOLEAN];
SetAbort: PROC[TJaMInternal.Frame,BOOLEAN];
MarkLoop: PROC[frame: TJaMInternal.Frame];
UnmarkLoop: PROC[frame: TJaMInternal.Frame];
NameToString: PROC[name TJaMBasic.Object] RETURNS[string TJaMBasic.Object];
StringToName: PROC[string TJaMBasic.Object,Text _ NIL] RETURNS[name TJaMBasic.Object];
CreateName: PROC[text: Text, tag: TJaMBasic.Tag _ X] RETURNS[name: name TJaMBasic.Object, known: BOOLEAN];
MakeName: PROC[text: Text, tag: TJaMBasic.Tag _ X] RETURNS[name TJaMBasic.Object] = INLINE {
RETURN [CreateName[text,tag].name] 
};

String: PROC[length: TJaMBasic.StringLength] RETURNS[string TJaMBasic.Object];
SCopy: PROC[string: string TJaMBasic.Object, expand: CARDINAL _ 0] RETURNS[string TJaMBasic.Object];
SubString: PROC[s: string TJaMBasic.Object, beg,len: CARDINAL] RETURNS[string TJaMBasic.Object];
PutString: PROC[from: string TJaMBasic.Object, beg: CARDINAL, into: string TJaMBasic.Object];
StringCompare: PROC[a,b: string TJaMBasic.Object] RETURNS[INTEGER];
MakeString: PROC[Text,TJaMBasic.Tag _ L] RETURNS[string TJaMBasic.Object];
StringText: PROC[string TJaMBasic.Object, Text];
StringForAll: PROC[string TJaMBasic.Object, PROC[CHARACTER] RETURNS[BOOLEAN]];
StreamToken: PROC[frame: TJaMInternal.Frame, stream: StreamHandle]
RETURNS[found,error: BOOLEAN, token: TJaMBasic.Object];
StringToken: PROC[frame: TJaMInternal.Frame, ob: string TJaMBasic.Object]
RETURNS[found,error: BOOLEAN, token: TJaMBasic.Object, rem: string TJaMBasic.Object];
LineComplete: PROC[text: Text] RETURNS[BOOLEAN];
MakeStream: PROC[StreamHandle, TJaMBasic.Tag _ L] RETURNS[stream TJaMBasic.Object];
GetStream: PROC[stream TJaMBasic.Object] RETURNS[StreamHandle];
KillStream: PROC[stream TJaMBasic.Object];
root: READONLY LONG POINTER TO TJaMBasic.Root;
defaultFrame: READONLY TJaMInternal.Frame;
RegisterExplicit: PROC[frame: TJaMInternal.Frame, text: Text, proc: PROC[TJaMInternal.Frame]];
RegisterImplicit: PROC[frame: TJaMInternal.Frame, text: Text, proc: PROC[]];
RegisterInternal: PROC[text: Text, proc: PROC[TJaMInternal.Frame]] RETURNS[command TJaMBasic.Object];
ForEachFrame: PROC[PROC[TJaMInternal.Frame]];
ForEachFrameExcept: PROC[TJaMInternal.Frame,PROC[TJaMInternal.Frame]];
NewFrame: PROC RETURNS[TJaMInternal.Frame];
FreeFrame: PROC[TJaMInternal.Frame];
DoCommand: PROC[frame: TJaMInternal.Frame, ob: command TJaMBasic.Object];
InstallReason: TYPE = {init,free,register};
InstallProc: TYPE = PROC[InstallReason,TJaMInternal.Frame];
Install: PROC[InstallProc];
ForEachInstalled: InstallProc;
StartTJaM: PROC;
}.

TJaMOps.mesa
Copyright c 1985 by Xerox Corporation.  All rights reserved.
Last changed by Wyatt, 24-Oct-81 15:18:05
Last changed by Paxton, 30-Jan-82  8:49:44
Michael Plass, February 14, 1985 12:24:11 pm PST

Types and Constants
Signals and Errors
Commonly-used error names
Stack operations
Type-specific stack operations
Array operations
Dictionary operations
Locals
Key comparison
Execution
Names
boolean is true if name already existed, false if was just created
Strings
Scanning
Streams
Registration and control
Installation
Κ"˜š
œ™Icodešœ
Οm
œ1™<Jš
œ)™)Jš
œ*™*Jš
œ0™0J™—š
Οk	˜	Jšœ
žœ#˜2Jšœ
žœ%˜7Jšœžœ˜$J˜—Jšœ	žœ˜˜Jš
œ™Jšœžœ˜1Jšœžœžœ
žœ
˜Jšœž
œ	˜&Jš
œ™Jšœžœ˜&Jšœžœ˜0Jšœžœ
˜JšΟnœžœžœžœžœ
žœžœ
žœ˜DJš
œ™J˜;Jš
œ™šŸœžœžœžœ˜IJšœ&žœžœ
žœ˜HJšžœ
˜J˜J˜—šŸœžœžœžœ˜IJšœ&žœžœ
žœ˜HJ˜/Jšœžœ
˜#J˜J˜—šŸœžœ4žœ˜FJšœ&žœžœ
žœ˜GJ˜/˜ J˜J˜——Jšœ
ŸœžœΟc˜JJšŸœžœžœ
žœžœžœžœ˜\JšŸœžœžœ
žœžœžœžœ˜[Jš
Ÿœžœžœžœžœ˜dJšŸœžœ5˜BJšŸœžœžœ˜3JšŸœžœžœ˜@JšŸœžœ˜&JšŸœžœ!žœ˜5JšŸ
œžœ˜,JšŸ
œžœ!žœžœ
žœžœ
žœ˜^JšŸœžœžœ
žœ˜?JšŸœžœ˜-JšŸœžœžœžœ˜Nš
Ÿœžœ"žœžœ
žœ˜[Jš	œžœžœžœ
žœ˜*—JšŸœžœžœ˜PJšŸœžœ
žœžœ˜5JšŸ	œžœ˜$Jš
œ™Jš
Ÿœžœžœžœž
œ˜cJšŸœžœžœ
žœžœž
œ˜fJš
Ÿœžœžœžœž
œ
˜XJš
Ÿœžœžœžœž
œ˜aJš
Ÿœžœ#žœžœ
žœ˜TJš
Ÿ
œžœžœ
žœ
žœ˜BJšŸœžœžœ
žœ˜7JšŸ
œžœžœ
žœ˜=JšŸ	œžœžœ˜LJšŸœžœžœ˜JJšŸœžœžœ˜HJšŸ
œžœžœ˜NJšŸ	œžœžœ˜LJš
Ÿ
œžœžœ
žœ
žœ˜BJšŸœžœžœ˜HJš
œ™JšŸœžœ	žœžœ˜>JšŸœžœ(žœžœ˜aJšŸœžœ)žœžœ˜aJšŸœžœ$žœ ˜ZJšŸœžœ#žœ˜MJšŸœžœ#žœžœ˜QJšŸœžœ;˜GJšŸœžœ;˜FJš
Ÿœžœ6žœ
žœ
žœ˜[JšŸœžœ˜*Jšžœžœ7˜MJšŸœžœ=˜HJš
Ÿœžœ&žœžœ
žœ˜_Jšžœ
žœ˜J˜Jš
œ™JšŸœžœ	žœžœ˜<JšŸ
œžœžœ
žœ˜@JšŸœžœ3žœ
žœ˜eJšŸœžœ5žœ˜XJšŸœžœ5žœ
žœ˜eJšŸœžœ<˜EJšŸœžœ:˜CJšŸœžœ3žœ˜WJšŸ	œžœ3žœ
žœ˜dJšŸœžœ:˜EJšŸœžœ5˜>JšŸœžœ˜+JšŸ
œžœ%˜5JšŸ
œžœ%˜5JšŸ	œžœ˜-JšŸœžœ9˜DJšŸœžœ˜%JšŸœžœ
žœ˜+JšŸ	œžœ˜$Jš
œ™š
Ÿœžœžœ
žœžœ˜JJšžœ˜J˜—šŸœžœ!žœžœ˜Gšœžœ˜3J˜J˜——JšŸœžœ9˜JJšŸ	œžœ3žœ˜\JšŸœžœ3žœ
žœ˜iJšŸ
œžœ9˜IJšŸ	œžœ
žœ˜-JšŸ
œžœ˜&Jš
œ™šŸœžœžœžœ˜IJš
žœ
žœžœ
žœžœ	˜IJ˜J˜—Jšœ
žœž
œ
ž
œ .˜JJšŸœžœžœ˜7š
Ÿœžœžœ
žœžœ˜>šžœžœ
žœ	žœžœ
žœ	žœ˜LJšžœžœžœž
œ˜)—J˜J˜—Jš
œ	™	JšŸœžœ&˜3JšŸœžœ˜JšŸœžœžœ
žœ˜4JšŸœžœžœ˜+JšŸœžœ˜*JšŸ
œžœ˜,Jš
œ™JšŸœžœžœ˜KJšŸœžœ žœžœ˜VJš
Ÿ
œžœ"ž
œžœ%žœ˜jJš
œB™Bš
Ÿœžœ"ž
œžœžœ˜\Jšžœ˜#J˜J˜—Jš
œ™JšŸœžœ!žœ˜NJšŸœžœ*žœžœ˜dJšŸ	œžœ&žœžœ˜`JšŸ	œžœ%žœ!˜]JšŸ
œžœžœ
žœ˜CJšŸ
œžœž
œžœ˜JJšŸ
œžœ ˜0JšŸœžœžœ
ž	œžœ
žœ˜NJš
œ™JšŸœžœ1˜BJšžœžœ˜7JšŸœžœ8˜IJšžœžœ9˜UJšŸœžœ
žœ
žœ˜0Jš
œ™JšŸ
œžœž
œžœ˜SJšŸ	œžœžœ˜?JšŸ
œžœ˜*Jš
œ™Jš	œžœ
žœ
žœ
žœ˜.Jšœžœ˜*JšŸœžœ.žœ˜^JšŸœžœ.žœ˜LJšŸœžœžœžœ˜eJšŸœžœ
žœ˜-JšŸœžœžœ˜FJšŸœžœ
žœ˜+JšŸ	œžœ˜$JšŸ	œžœ:˜IJš
œ™Jšœžœ˜+JšŸœžœžœ#˜;JšŸœžœ˜J˜JšŸ	œžœ
˜J˜J˜——…—%ώ38