DIRECTORY
AMBridge USING[TVToCardinal, WordSequenceRecord, WordSequence, RemoteRef,
RemotePointer, RemoteSED, RemotePD, RemoteFrameHandle,
RemoteGlobalFrameHandle, nilRemotePD, nilRemoteSED, TVToLC,
TVForGFHReferent],
AMTypes USING[Error, Class, TypeClass, UnderType, TVType, TypedVariable, Status, Type,
TV],
AtomPrivate USING[AtomRec],
Basics USING[bitsPerWord],
Rope USING[RopeRep],
RTSymbolDefs USING[BodyIndex],
RTSymbolOps USING[NullBTI],
SafeStorage USING[nullType, fhType, gfhType, EquivalentTypes],
RTTypesPrivate USING[TypedVariableRec, BitsForType, TypedVariableHead],
RTTypesRemotePrivate USING[GetRemoteReferentType, GetRemoteProcedureType,
GetRemoteSignalType, AcquireBTIFromRemoteFH,
IsRemoteCatchFrame],
WorldVM USING[CurrentIncarnation, Long, LocalWorld, World, Address];

RTTypesRemoteImpl: PROGRAM
IMPORTS AMBridge, AMTypes, RTSymbolOps, SafeStorage, RTTypesPrivate,
RTTypesRemotePrivate, WorldVM
EXPORTS AMBridge
SHARES Rope

= BEGIN OPEN AMBridge, AMTypes, Basics, RTSymbolDefs, SafeStorage,
RTTypesPrivate, RTTypesRemotePrivate, WorldVM;

checkMutable: BOOL _ TRUE;

IsRemote: PUBLIC PROC[tv: TypedVariable] RETURNS[BOOLEAN] =
{WITH tv SELECT FROM
tvr: REF TypedVariableRec =>
WITH tvh: tvr.head SELECT FROM
remoteReference, remotePointer, remoteGFH,
remoteFH, copiedRemoteObject, remoteConstant
=> IF GetRemoteWorld[tv] = WorldVM.LocalWorld[]
THEN ERROR
ELSE RETURN[TRUE];
ENDCASE => RETURN[FALSE];
ENDCASE => RETURN[FALSE]};

TVForRemoteReferent: PUBLIC PROC[remoteRef: RemoteRef, status: Status _ mutable]
RETURNS[tv: TypedVariable] =
{ bitsForType: LONG CARDINAL;     
head: RTTypesPrivate.TypedVariableHead = [remoteReference[remoteRef: remoteRef]];
type: Type _ GetRemoteReferentType[remoteRef];

IF type = nullType THEN RETURN[NIL];

IF EquivalentTypes[type, CODE[AtomPrivate.AtomRec]]
OR EquivalentTypes[type, CODE[Rope.RopeRep]]
THEN ERROR Error[reason: typeFault, type: type];

bitsForType _ BitsForType[type].bft;

IF bitsForType < bitsPerWord
THEN
tv _ NEW[TypedVariableRec _
[referentType: [type],
head: head,
status: status,
field: embedded[fd: [wordOffset: 0,
extent: small[field: [bitFirst: bitsPerWord-bitsForType,
bitCount: bitsForType
]
]
]
]
]
]
ELSE tv _ NEW[TypedVariableRec _ [referentType: [type],
head: head,
status: status,
field: entire[]]];
};

RemoteRefFromTV: PUBLIC PROC[tv: TypedVariable] RETURNS[RemoteRef] =
{WITH tv SELECT FROM
tr: REF TypedVariableRec =>
{IF tr.tag # entire
THEN ERROR Error[reason: internalTV]
ELSE IF checkMutable AND tr.status # mutable
THEN ERROR Error[reason: notMutable]
ELSE WITH head: tr.head SELECT FROM
remoteReference => RETURN[head.remoteRef];
ENDCASE => ERROR Error[reason: internalTV]};
ENDCASE => ERROR Error[reason: typeFault, type: nullType]};



TVForRemotePointerReferent: PUBLIC PROC[remotePointer: RemotePointer,
type: Type,
status: Status _ mutable]
RETURNS[TypedVariable] =
{bitsForType: LONG CARDINAL = BitsForType[type].bft;
head: RTTypesPrivate.TypedVariableHead = [remotePointer[remotePointer: remotePointer]];
RETURN[
IF bitsForType < bitsPerWord
THEN
NEW[TypedVariableRec _
[referentType: [type],
head: head,
status: status,
field: embedded[fd: [wordOffset: 0,
extent: small[field: [bitFirst: bitsPerWord - bitsForType,
bitCount: bitsForType]]]]]]
ELSE NEW[TypedVariableRec _ [referentType: [type],
head: head,
status: status,
field: entire[]]]]};

RemotePointerFromTV: PUBLIC PROC[tv: TypedVariable] RETURNS[RemotePointer] =
{WITH tv SELECT FROM
tr: REF TypedVariableRec =>
{IF checkMutable AND tr.status # mutable THEN ERROR Error[reason: notMutable];
WITH etr: tr SELECT FROM
embedded =>
WITH fd: etr.fd SELECT FROM
large => {rp: RemotePointer _ GetRemoteHeadPointer[tr];
rp.ptr _ rp.ptr + fd.wordOffset;
RETURN[rp]};
small => IF fd.field.bitFirst = 0
THEN {rp: RemotePointer _ GetRemoteHeadPointer[tr];
rp.ptr _ rp.ptr + fd.wordOffset;
RETURN[rp]}
ELSE ERROR Error[reason: internalTV];
ENDCASE => ERROR;
entire =>  RETURN[GetRemoteHeadPointer[tr]];   --may have been narrowed--
ENDCASE => ERROR}
ENDCASE => ERROR Error[reason: typeFault, type: nullType]};

GetRemoteHeadPointer: PROC[tr: REF TypedVariableRec] RETURNS[RemotePointer] =
{RETURN[(WITH head: tr.head SELECT FROM
remotePointer => head.remotePointer,
remoteGFH => [world: head.remoteGlobalFrameHandle.world,
worldIncarnation:
CurrentIncarnation[head.remoteGlobalFrameHandle.world],
ptr: Long[world: head.remoteGlobalFrameHandle.world,
addr: head.remoteGlobalFrameHandle.gfh]],
remoteFH => [world: head.remoteFrameHandle.world,
worldIncarnation:
CurrentIncarnation[head.remoteFrameHandle.world],
ptr: Long[world: head.remoteFrameHandle.world,
addr: head.remoteFrameHandle.fh]]
ENDCASE => ERROR Error[reason: typeFault, type: nullType])]};

TVForRemoteProc: PUBLIC PROC[remotePD: RemotePD] RETURNS[TypedVariable--procedure--] =
{RETURN[TVForRemotePD[remotePD]]};

TVForRemotePD: PUBLIC PROC[remotePD: RemotePD] RETURNS[TypedVariable--procedure--] =
{ws: WordSequence;
ws _ NEW[WordSequenceRecord[1]];
ws[0] _ LOOPHOLE[remotePD.pd, CARDINAL];
RETURN[NEW[TypedVariableRec _ [referentType: [GetRemoteProcedureType[remotePD]],
head: [remoteConstant
[world: remotePD.world,
worldIncarnation:
CurrentIncarnation[remotePD.world]]],
status: const,
field: constant[value: ws]]]]};

TVForRemoteSignal: PUBLIC PROC[remoteSED: RemoteSED]
RETURNS[TypedVariable--signal, error--] = {RETURN[TVForRemoteSED[remoteSED]]};

TVForRemoteSED: PUBLIC PROC[remoteSED: RemoteSED]
RETURNS[TypedVariable--signal, error--] =
{ws: WordSequence;
ws _ NEW[WordSequenceRecord[1]];
ws[0] _ LOOPHOLE[remoteSED.sed, CARDINAL];
RETURN[NEW[TypedVariableRec _ [referentType: [GetRemoteSignalType[remoteSED]],
head: [remoteConstant
[world: remoteSED.world,
worldIncarnation:
CurrentIncarnation[remoteSED.world]]],
status: const,
field: constant[value: ws]]]]};


TVToRemoteProc: PUBLIC PROC[tv: TypedVariable--procedure, program--]
RETURNS[RemotePD] = {RETURN[TVToRemotePD[tv]]};

TVToRemotePD: PUBLIC PROC[tv: TypedVariable--procedure, program--]
RETURNS[RemotePD] =
{ SELECT TypeClass[UnderType[TVType[tv]]] FROM
nil => RETURN[nilRemotePD];
program, procedure => NULL;
ENDCASE => ERROR Error[reason: typeFault, type: TVType[tv]];
RETURN[[world: GetWorld[tv],
worldIncarnation: CurrentIncarnation[GetWorld[tv]],
pd: TVToCardinal[tv]]]};

TVToRemoteSignal: PUBLIC PROC[tv: TypedVariable] RETURNS[RemoteSED] =
{RETURN[TVToRemoteSED[tv]]};

TVToRemoteSED: PUBLIC PROC[tv: TypedVariable] RETURNS[RemoteSED] =
{ SELECT TypeClass[UnderType[TVType[tv]]] FROM
signal, error => NULL;
nil => RETURN[nilRemoteSED];
ENDCASE => ERROR Error[reason: typeFault, type: TVType[tv]];
RETURN[[world: GetWorld[tv],
worldIncarnation: CurrentIncarnation[GetWorld[tv]],
sed: TVToCardinal[tv]]]};

TVForRemoteFrame: PUBLIC PROC[remoteFrameHandle: RemoteFrameHandle,
evalStack: WordSequence _ NIL,
return: BOOL _ FALSE,
contextPC: BOOL _ FALSE]
RETURNS[ans: TV _ NIL] =
{bti: BodyIndex;
isCatchFrame: BOOLEAN _ FALSE;
IF remoteFrameHandle.fh = 0 THEN RETURN[NIL];
bti _ AcquireBTIFromRemoteFH[remoteFrameHandle, contextPC];-- returns BTNull if no symbols
IF NOT RTSymbolOps.NullBTI[bti]
THEN [isCatchFrame, bti] _ IsRemoteCatchFrame[remoteFrameHandle, bti];
RETURN[NEW[TypedVariableRec
_ [referentType: [fhType],
head: [remoteFH[remoteFrameHandle: remoteFrameHandle,
evalStack: evalStack,
bti: bti,
isCatchFrame: isCatchFrame,
return: return,
contextPC: contextPC]],
status: mutable,
field: entire[]]]]};

RemoteFHFromTV: PUBLIC PROC[tv: TypedVariable] RETURNS[RemoteFrameHandle] =
{WITH tv SELECT FROM
tvr: REF TypedVariableRec =>
WITH tvh: tvr.head SELECT FROM
remoteFH => RETURN[tvh.remoteFrameHandle];
ENDCASE => ERROR Error[reason: typeFault, type: fhType];
ENDCASE => ERROR Error[reason: typeFault, type: fhType]};

TVForRemoteGFHReferent: PUBLIC PROC[remoteGlobalFrameHandle: RemoteGlobalFrameHandle]
RETURNS[TypedVariable] =
{ IF remoteGlobalFrameHandle.gfh = 0 THEN RETURN[NIL];
IF remoteGlobalFrameHandle.world = WorldVM.LocalWorld[]
THEN RETURN[TVForGFHReferent[LOOPHOLE[remoteGlobalFrameHandle.gfh]]];
RETURN[NEW[TypedVariableRec
_ [referentType: [gfhType],
head: [remoteGFH[remoteGlobalFrameHandle: remoteGlobalFrameHandle]],
status: mutable,
field: entire[]]]]};

RemoteGFHFromTV: PUBLIC PROC[tv: TypedVariable] RETURNS[RemoteGlobalFrameHandle] =
{WITH tv SELECT FROM
tvr: REF TypedVariableRec =>
WITH tvh: tvr.head SELECT FROM
remoteGFH => RETURN[tvh.remoteGlobalFrameHandle];
ENDCASE => ERROR Error[reason: typeFault, type: gfhType];
ENDCASE => ERROR Error[reason: typeFault, type: gfhType]};

GetRemoteWorld: PROC[tv: TypedVariable] RETURNS[World] =
{WITH tv SELECT FROM
tvr: REF TypedVariableRec =>
WITH tvh: tvr.head SELECT FROM
remoteReference => RETURN[tvh.remoteRef.world];
remotePointer => RETURN[tvh.remotePointer.world];
remoteFH => RETURN[tvh.remoteFrameHandle.world];
remoteGFH => RETURN[tvh.remoteGlobalFrameHandle.world];
copiedRemoteObject => RETURN[tvh.world];
remoteConstant => RETURN[tvh.world];
ENDCASE => ERROR;
ENDCASE => ERROR;
};

GetWorld: PUBLIC PROC[tv: TypedVariable] RETURNS[World] =
{IF IsRemote[tv]
THEN RETURN[GetRemoteWorld[tv]]
ELSE RETURN[LocalWorld[]];
};

GetWorldIncarnation: PUBLIC PROC[tv: TypedVariable] RETURNS[LONG CARDINAL] =
{IF IsRemote[tv]
THEN
WITH tv SELECT FROM
tvr: REF TypedVariableRec =>
WITH tvh: tvr.head SELECT FROM
remoteReference => RETURN[tvh.remoteRef.worldIncarnation];
remotePointer => RETURN[tvh.remotePointer.worldIncarnation];
remoteFH => RETURN[tvh.remoteFrameHandle.worldIncarnation];
remoteGFH => RETURN[tvh.remoteGlobalFrameHandle.worldIncarnation];
copiedRemoteObject => RETURN[tvh.worldIncarnation];
remoteConstant => RETURN[tvh.worldIncarnation];
ENDCASE => ERROR;
ENDCASE => ERROR
ELSE RETURN[CurrentIncarnation[LocalWorld[]]];
};

TVToRemoteRef: PUBLIC PROC[tv: TypedVariable] RETURNS[RemoteRef] =
{ IF GetWorld[tv] = LocalWorld[]
THEN ERROR Error[reason: typeFault, msg: "Can't get a remote REF for a local object"];

SELECT TypeClass[UnderType[TVType[tv]]] FROM
atom, rope, list, ref => RETURN[[world: GetWorld[tv],
worldIncarnation: GetWorldIncarnation[tv],
ref: LOOPHOLE[TVToLC[tv], WorldVM.Address]]];
ENDCASE => ERROR Error[reason: typeFault, type: TVType[tv]];
};

END.


ðRTTypesRemoteImpl.Mesa
last modified on August 10, 1983 12:30 pm by Paul Rovner
P R O C E D U R E S
raises notMutable, internalTV, typeFault
If possible, this returns the REF which points to the value represented by the specified
TypedVariable. Raises InternalTV if tv is embedded, NotVar if TVStatus[tv] # mutable.
If possible, RemotePointerFromTV returns the LONG POINTER which points
to the value represented by the specified TypedVariable.
Raises Error[reason: internalTV] if tv is embedded and not word aligned
Raises NotVar if TVStatus[tv] # mutable.
raises notMutable, internalTV, typeFault
raises typeFault
raises typeFault
raises typeFault
MOVE
raises typeFault
all such tvs have the same (distinguished) type: gfhType
raises typeFault
�ÊݘJ˜Jš
œ™Jš
œ8™8J˜š
Ïk	˜	šœ	�œ;˜IJ˜6J˜;J˜—šœ�œI˜VJš�œ˜—Jšœ�œ
˜Jšœ�œ˜Jšœ�œ
˜Jšœ
�œ˜Jšœ�œ
˜Jšœ�œ-˜>Jšœ�œ3˜Gšœ�œ/˜IJ˜,J˜—Jšœ�œ7˜DJ˜—šœ�˜š�œ=˜DJ˜—Jš�œ	˜Jš�œ˜J˜—šœ�œ
�œ6˜BJ˜.J˜—JšÏbœ�œ�œ
˜J˜Jš
œ™š
Ïnœ�œ
�œ�œ
�œ˜;šœ
�œ�œ
�˜šœ�œ˜š�œ�œ
�˜J˜*˜,šœ�œ*˜/Jš�œ
�˜
Jš�œ
�œ
�œ˜——Jš�œ�œ
�œ˜——Jš�œ�œ
�œ˜J˜——šŸœ�œ
�œ0˜PJš�œ˜šœ�œ
�œ˜"J˜QJ˜.J˜Jš�œ�œ
�œ
�œ˜$J˜š�œ�œ˜3Jš�œ�œ˜,Jš�œ
�œ&˜0J˜—J˜$J˜š�œ˜š
�˜šœ�œ˜˜J˜J˜˜#˜8J˜J˜
J˜
—J˜
J˜
——J˜
J˜
——š�œ�œ*˜7J˜J˜J˜——J˜J˜——Jš
œ(™(šŸœ�œ
�œ�œ
˜Dšœ
�œ�œ
�˜šœ�œ˜šœ
�œ˜Jš�œ
�œ˜$š�œ
�œ�œ˜,Jš�œ
�œ˜$š�œ
�œ�œ
�˜#Jšœ�œ˜*Jš�œ�œ˜,————Jš�œ�œ+˜;˜Jš
œX™XJš
œU™UJ˜J˜———šŸœ�œ
�œ˜EJ˜J˜Jš�œ˜šœ�œ
�œ˜4J˜Wš�œ
˜š�œ˜š
�˜š�œ˜˜J˜J˜˜#˜:J˜—————š�œ
�œ*˜2J˜J˜J˜J˜Jš
œF™FJš
œ8™8Jš
œG™GJš
œ(™(—————Jš
œ(™(šŸœ�œ
�œ�œ˜Lšœ
�œ�œ
�˜šœ�œ˜š	œ
�œ�œ�œ
�œ˜Nš�œ	�œ
�˜˜š�œ�œ
�˜˜7J˜ Jš�œ˜—šœ	�œ˜!š�œ/˜3J˜ Jš�œ˜—Jš�œ
�œ˜%—Jš�œ�œ
˜——Jšœ�œÏc˜IJš�œ�œ
˜———Jš�œ�œ+˜;J˜——Jš
œ™šŸœ�œ�œ�œ˜Mšœ
�œ�œ�œ
�˜'J˜$˜8˜J˜7—˜4J˜)——˜1˜J˜1—˜.J˜!——Jš�œ�œ-˜=J˜——š
Ÿœ�œ
�œ�œ 
œ˜VJšœ
�œ˜"J˜—š
Ÿ
œ�œ
�œ�œ 
œ˜T˜Jšœ�œ˜ šœ�œ�œ˜(š�œ
�œF˜P˜˜˜J˜%——J˜J˜J˜—————šŸœ�œ
�œ˜4Jš�œ œ�œ˜NJ˜—šŸœ�œ
�œ˜1Jš�œ œ˜)˜Jšœ�œ˜ šœ�œ�œ˜*š�œ
�œD˜N˜˜˜J˜&———J˜J˜J˜J˜————Jš
œ™šŸœ�œ
�œ œ
˜DJš�œ�œ˜/J˜—šŸœ�œ
�œ œ
˜BJš�œ˜šœ�œ"�˜.Jšœ�œ˜Jšœ�œ
˜Jš�œ�œ,˜<š�œ˜J˜3J˜J˜———Jš
œ™šŸœ�œ
�œ�œ
˜EJšœ
�œ˜J˜—šŸ
œ�œ
�œ�œ
˜Bšœ�œ"�˜.Jšœ�œ
˜Jšœ�œ˜Jš�œ�œ,˜<š�œ˜J˜3J˜J˜—Jš
œ™——šŸœ�œ
�œ&˜CJšœ�œ
˜Jšœ�œ�œ
˜Jšœ�œ�œ
˜Jš�œ�œ�œ˜˜Jšœ�œ�œ
˜Jš�œ�œ
�œ
�œ˜-Jšœ; ˜Zš�œ
�œ˜Jš�œB˜F—š�œ
�œ˜˜˜5J˜J˜	J˜J˜J˜—J˜J˜J˜————Jš
œ™šŸœ�œ
�œ�œ˜Kšœ
�œ�œ
�˜šœ�œ˜š�œ�œ
�˜Jšœ�œ˜*Jš�œ�œ(˜8——Jš�œ�œ)˜9˜Jš
œ8™8———šŸœ�œ
�œ2˜UJš�œ˜š	œ�œ!�œ
�œ
�œ˜6š�œ5˜7Jš�œ
�œ�œ ˜E—š�œ
�œ˜˜J˜DJ˜J˜J˜————Jš
œ™šŸœ�œ
�œ�œ˜Ršœ
�œ�œ
�˜šœ�œ˜š�œ�œ
�˜Jšœ
�œ˜1Jš�œ�œ)˜9——Jš�œ�œ*˜:J˜——šŸœ�œ�œ	˜8šœ
�œ�œ
�˜šœ�œ˜š�œ�œ
�˜Jšœ�œ˜/Jšœ�œ˜1Jšœ�œ˜0Jšœ
�œ$˜7Jšœ�œ˜(Jšœ�œ˜$Jš�œ�œ
˜——Jš�œ�œ
˜——J˜J˜šŸœ�œ
�œ�œ	˜9šœ
�œ
˜Jš�œ
�œ˜Jš�œ
�œ˜J˜J˜——šŸœ�œ
�œ�œ
�œ
�œ˜Lšœ
�œ
˜š
�˜š�œ�œ
�˜šœ�œ˜š�œ�œ
�˜Jšœ�œ!˜:Jšœ�œ%˜<Jšœ�œ)˜;Jšœ
�œ/˜BJšœ�œ˜3Jšœ�œ˜/Jš�œ�œ
˜——Jš�œ�˜——Jš�œ
�œ#˜.J˜J˜——šŸ
œ�œ
�œ�œ
˜Bšœ�œ˜ Jš�œ
�œL˜VJ˜š�œ"�˜,šœ�œ˜5J˜*Jšœ�œ ˜-—Jš�œ�œ,˜<——J˜J˜—Jš�œ
˜J˜J˜—…—'¾6‹