
<<RTTypesPrivate.Mesa>>
<<last modified on June 28, 1983 3:21 pm by Paul Rovner>>

DIRECTORY
AMBridge USING[
TVHeadType, WordSequence, RemoteRef, RemotePointer, nilRemotePointer, RemoteFrameHandle, RemoteGlobalFrameHandle],
AMTypes USING[Status, TypedVariable],
PrincOps USING[
ProcDesc, SignalDesc, FrameHandle, GlobalFrameHandle, BytePC, EPRange, ControlLink, StateVector],
Rope USING[ROPE],
RTCommon USING[Field],
RTSymbolDefs USING[SymbolTableBase, SymbolIdIndex, BodyIndex, CallableBodyIndex],
SafeStorage USING[Type],
WorldVM USING[World];

RTTypesPrivate: DEFINITIONS
= BEGIN OPEN AMBridge, AMTypes, PrincOps, RTSymbolDefs, SafeStorage, WorldVM;


<<T Y P E S>>
TypedVariableRec: TYPE = RECORD[
referentType: TypeBundle,
head: TypedVariableHead,
status: Status _ mutable,
field: SELECT tag: * FROM
entire => [],
embedded => [fd: FieldDescriptor],
constant => [value: WordSequence]
ENDCASE
];

TypeBundle: TYPE = RECORD[type: Type, tag: TypedVariable _ NIL];

TypedVariableHead: TYPE = RECORD[
SELECT tag: TVHeadType FROM
reference => [ref: REF ANY],
remoteReference => [remoteRef: RemoteRef],
copiedRemoteObject => [
world: World _ ,
worldIncarnation: LONG CARDINAL,
copy: WordSequence
],
pointer => [ptr: LONG POINTER],
remotePointer => [remotePointer: RemotePointer],
gfh => [gfh: GlobalFrameHandle],
remoteGFH => [remoteGlobalFrameHandle: RemoteGlobalFrameHandle],
fh => [
fh: FrameHandle,
bti: BodyIndex,
evalStack: POINTER TO StateVector,
isCatchFrame: BOOL _ FALSE,
return: BOOL,
contextPC: BOOL
],
remoteFH => [
remoteFrameHandle: RemoteFrameHandle,
bti: BodyIndex,
evalStack: WordSequence _ ,
isCatchFrame: BOOL _ FALSE,
return: BOOL,
contextPC: BOOL
],
constant => [],
remoteConstant => [world: World _ , worldIncarnation: LONG CARDINAL]
ENDCASE
];

FieldDescriptor: TYPE = RECORD[
wordOffset: INTEGER,
extent: SELECT magnitude: * FROM
small => [field: RTCommon.Field],
large => [size: CARDINAL],
ENDCASE
];

EVRange: TYPE = [0..4*EPRange);
<<>>
<<>>
<<PROCEDURES>>

GetIdConstantValue: PROC[
tv: TypedVariable,
stb: SymbolTableBase,
isei: SymbolIdIndex]
RETURNS[WordSequence];

BuildRecordFieldDescriptor: PROC[
parentTV: TypedVariable,
fieldBitOffset,
fieldBits,
bitsForType: INT]
RETURNS[fD: FieldDescriptor];

ValueAddress: TYPE = RECORD[
SELECT tag: * FROM
constant => [value: WordSequence _ ],
pointer => [
ptr: LONG POINTER _ NIL,  --includes the word offset
fd: FieldDescriptor _ [wordOffset: 0, extent: large[size: 0]]
],
remotePointer => [
ptr: RemotePointer _ nilRemotePointer,  --includes word offset
fd: FieldDescriptor _ [wordOffset: 0, extent: large[size: 0]]
],
copiedRemoteObject => [
ptr: LONG POINTER _ NIL,  --includes the word offset
fd: FieldDescriptor _ [wordOffset: 0, extent: large[size: 0]]
]
ENDCASE
];

GetValueAddress: PROC[tv: TypedVariable, mutableOnly: BOOL _ FALSE]
RETURNS[ValueAddress];  -- Raises NotMutable

RecordComponentISEI: PROC[
type: Type--record--,
index: NAT,
p: PROC[stb: SymbolTableBase,
isei: SymbolIdIndex]
];

ComponentISEI: PROC[
type: Type--record, union, enumerated--,
index: NAT,
p: PROC[stb: SymbolTableBase, isei: SymbolIdIndex]
];

PDToName: PROC[pd: ProcDesc] RETURNS[Rope.ROPE];

SEDToName: PROC[sed: SignalDesc] RETURNS[Rope.ROPE];

GFHToName: PROC[gfh: GlobalFrameHandle] RETURNS[Rope.ROPE];

GetCBTI: PROC[stb: SymbolTableBase, epn: CARDINAL]
RETURNS[cbti: CallableBodyIndex];

ConvertCbti: PROC[
lastBti: BodyIndex,
pc, start: BytePC,
base: SymbolTableBase
]
RETURNS [bti: BodyIndex];

GetEp: PROC [pc: BytePC, gf: GlobalFrameHandle, stb: SymbolTableBase]
RETURNS [ep: EVRange, start: BytePC];

GetPc: PROC[gf: GlobalFrameHandle, i: EVRange] RETURNS [BytePC];

BitsForType: PROC[type: Type]
RETURNS [bft: LONG CARDINAL, argumentRecord, interfaceRecord: BOOL];

GetOrigin: PROC[type: Type] RETURNS[origin: INTEGER];  -- for subrange types 

UnwindIndirectProcDesc: PROC[icl: ControlLink] RETURNS[ProcDesc];

END.