DIRECTORY
AMBridge USING [WordSequence, WordSequenceRecord, RemotePD, RemoteGlobalFrameHandle, RemoteFrameHandle, RemoteRef, RemoteSED, RemotePointer, TVForRemoteFrame, nilRemotePD, nilRemoteFrameHandle, GetWorld],
AMProcessBasic USING [ReturnLink],
AMTypes USING [Error, TypedVariable, TVType],
BcdDefs USING [MTIndex, BCD, FTSelf, SGIndex, SGNull, FTIndex, NameRecord, VersionStamp, BcdBase, MTHandle, NameString, FTHandle],
BcdOps USING [ProcessModules, ProcessFiles],
BrandXSymbolDefs USING [rootBodyIndex, SymbolTableBase, SymbolIdIndex, SymbolIndex, BodyIndex],
BrandYSymbolDefs USING [rootBodyIndex, SymbolTableBase, SymbolIdIndex, SymbolIndex, BodyIndex],
ConvertUnsafe USING [SubString, SubStringToRope],
LoadState USING [Acquire, ConfigID, local, GlobalFrameToModule, ConfigInfo, Release, Handle, ModuleIndex],
PrincOps USING [BytePC, ControlLink, CSegPrefix, EntryVectorItem, EPRange, Frame, FrameCodeBase, FrameHandle, GlobalFrame, GlobalFrameHandle, localbase, NullLink, ProcDesc, SignalDesc, UnboundLink, NullGlobalFrame, wordsPerPage, SD, sSignal],
RemotePrincOpsUtils USING [RemoteGlobalFrame, RemoteGlobalFrameAndEntryPoint],
Rope USING [ROPE, Concat, Text, Length],
RTCommon USING [Field, StoreFieldLong],
RTSD USING [sGCState, sMapStiStd],
RTSymbolDefs USING [SymbolTableBase, SymbolTableHandle, nullHandle, nullBase, CallableBodyIndex, BodyIndex, rootBodyIndex, SymbolIdIndex, SymbolRecordIndex, SymbolIndex, nullBodyIndex],
RTSymbolOps USING [AcquireType, EnumerateRecordIseis, AcquireRope, NullISEI],
RTSymbols USING [ReleaseSTB, AcquireSTB, GetSTHForModule],
RTSymbolsPrivate USING [AcquireSTHFromSTX],
RTTypesBasicPrivate USING [UniqueTypeFinger, STDesc, FindSTI, PSTDesc, RMapStiStd, SymbolTableIndex, MapStiStd, TypeDesc, RMapTiTd, PTypeDesc],
RTTypesPrivate USING [TypedVariableRec, GetCBTI, ConvertCbti],
RTTypesRemotePrivate USING [RemoteErrorType, EVRange],
RuntimeError USING [UNCAUGHT],
SafeStorage USING [Type, nullType],
Table USING [Base],
VM USING [Interval, Allocate, Free, PageNumberForAddress, AddressForPageNumber],
WorldVM USING [Address, AddressFault, CopyRead, CopyWrite, Long, LongRead, LongWrite, Read, ShortAddress, World, Write, Loadstate, Lock, Unlock, CurrentIncarnation, Incarnation];

RTTypesRemotePrivateImpl: MONITOR  -- protects the cache of remote BCDs
IMPORTS AMBridge, AMProcessBasic, AMTypes, BcdOps, ConvertUnsafe, LoadState, RemotePrincOpsUtils, Rope, RTCommon, RTSymbolOps, RTSymbols, RTSymbolsPrivate, RTTypesBasicPrivate, RTTypesPrivate, RuntimeError, VM, WorldVM
EXPORTS RTTypesPrivate, RTTypesRemotePrivate
SHARES Rope
= BEGIN OPEN AMBridge, AMTypes, bx: BrandXSymbolDefs, by: BrandYSymbolDefs, RemotePrincOpsUtils, RTSymbolDefs, RTSymbolOps, RTSymbols, RTTypesPrivate, RTTypesRemotePrivate, RuntimeError, SafeStorage, WorldVM;

RemoteBCDCache: TYPE = LIST OF BCDCacheRec;
BCDCacheRec: TYPE = RECORD[world: World _ ,
incarnation: Incarnation _ ,
remoteBCD: Address _ ,
localBCD: BcdDefs.BcdBase _ ,
useCount: INT _ ];
remoteBCDCache: RemoteBCDCache _ NIL;
remoteBCDCacheLength: NAT _ 0;
maxRemoteBCDCacheLength: NAT _ 1;

SignallerFrameMessageOffset: NAT = 9;
SignallerFrameSignalOffset: NAT = 7;


RemoteError: PUBLIC ERROR[type: RemoteErrorType, message: LONG POINTER TO TEXT _ NIL] = CODE;






AcquireSTBFromRemoteGFH: PUBLIC PROC [gfh: RemoteGlobalFrameHandle] RETURNS [SymbolTableBase] = {
mappedBCD: BcdDefs.BcdBase;
module: LoadState.ModuleIndex;
std: RTTypesBasicPrivate.STDesc;
sth: SymbolTableHandle _ nullHandle;
mth: BcdDefs.MTHandle;
ftb: Table.Base;
sti: RTTypesBasicPrivate.SymbolTableIndex;
moduleName: Rope.ROPE = RemoteGFHToName[gfh: gfh];

FindModule: PROC [mth: BcdDefs.MTHandle, mti: BcdDefs.MTIndex] RETURNS [BOOL] = {
RETURN[module IN [mth.gfi .. mth.gfi + mth.ngfi)]};

[mappedBCD, module] _ AcquireRemoteBCDAndModule[gfh];

ftb _ LOOPHOLE[mappedBCD + mappedBCD.ftOffset, Table.Base];

[mth, ] _ BcdOps.ProcessModules[mappedBCD, FindModule
! UNWIND => ReleaseRemoteBCD[mappedBCD]];
IF mth = NIL THEN {ReleaseRemoteBCD[mappedBCD]; ERROR};

std _ [symbolsStamp: IF mth.file = BcdDefs.FTSelf
THEN mappedBCD.version
ELSE ftb[mth.file].version];
ReleaseRemoteBCD[mappedBCD];
sti _ RTTypesBasicPrivate.FindSTI[std];
sth _ RTSymbolsPrivate.AcquireSTHFromSTX[sti ! AMTypes.Error => CONTINUE].sth;
IF sth = nullHandle THEN {
sth _ GetSTHForModule[stamp: std.symbolsStamp, moduleName: moduleName, fileName: Rope.Concat[moduleName, ".bcd"]];
IF sth # nullHandle THEN RTTypesBasicPrivate.MapStiStd[sti].sth _ sth;
};
IF sth = nullHandle
THEN ERROR AMTypes.Error[reason: noSymbols, msg: RemoteGFHToName[gfh]]
ELSE RETURN[AcquireSTB[sth]];
};

OuterFromRemoteGFH: PUBLIC PROC [gfh: RemoteGlobalFrameHandle, inner: PROC [stb: SymbolTableBase] ] = {
stb: SymbolTableBase _ AcquireSTBFromRemoteGFH[gfh];
inner[stb ! UNWIND => ReleaseSTB[stb] ];
ReleaseSTB[stb];
};

AcquireRemoteBCDAndModule: PUBLIC PROC [gfh: RemoteGlobalFrameHandle] RETURNS [BcdDefs.BcdBase, LoadState.ModuleIndex] = {
bcd: BcdDefs.BcdBase;  -- remote bcd
module: LoadState.ModuleIndex;
mappedBCD: BcdDefs.BcdBase;
IF gfh.gfh = 0 THEN ERROR AMTypes.Error[reason: noSymbols];
Lock[gfh.world];
{
ENABLE UNWIND => Unlock[gfh.world];
loadState: LoadState.Handle _ WorldVM.Loadstate[gfh.world];
config: LoadState.ConfigID;
loadState.Acquire[];
{
ENABLE UNWIND => loadState.Release[];
[config, module]
_ loadState.GlobalFrameToModule[LOOPHOLE[gfh.gfh, PrincOps.GlobalFrameHandle]];
bcd _ loadState.ConfigInfo[config].bcd;
};  -- end ENABLE UNWIND
loadState.Release[];
mappedBCD _ AcquireRemoteBCD[
world: gfh.world,
incarnation: gfh.worldIncarnation,
bcd: bcd];
};  -- end ENABLE UNWIND
Unlock[gfh.world];
RETURN[mappedBCD, module];
};  -- end AcquireRemoteBCDAndModule

ReleaseRemoteBCD: PUBLIC ENTRY PROC [bcd: BcdDefs.BcdBase] = {
ENABLE UNWIND => NULL;
FOR l: RemoteBCDCache _ remoteBCDCache, l.rest UNTIL l = NIL DO
IF l.first.localBCD = bcd THEN {
l.first.useCount _ l.first.useCount - 1;
IF remoteBCDCacheLength > maxRemoteBCDCacheLength THEN {
prev: RemoteBCDCache _ NIL;
FOR s: RemoteBCDCache _ remoteBCDCache, s.rest UNTIL s = NIL DO
IF s.first.useCount = 0 THEN {
bcdP: BcdDefs.BcdBase = s.first.localBCD;
pages: NAT _
IF bcdP.extended THEN bcdP.nPages - bcdP.rtPages.pages ELSE bcdP.nPages;
VM.Free[[page: VM.PageNumberForAddress[bcdP], count: pages]];
IF prev = NIL THEN remoteBCDCache _ s.rest ELSE prev.rest _ s.rest;
EXIT;
};
prev _ s;
ENDLOOP;
};
RETURN;
};
ENDLOOP;
ERROR;
};

FindCachedRemoteBCD: ENTRY PROC [world: World, remoteBCD: Address] RETURNS [localBCD: BcdDefs.BcdBase _ NIL] = {
ENABLE UNWIND => NULL;
prev: RemoteBCDCache _ NIL;
incarnation: Incarnation = CurrentIncarnation[world];
FOR l: RemoteBCDCache _ remoteBCDCache, l.rest UNTIL l = NIL DO
IF l.first.world = world AND l.first.remoteBCD = remoteBCD AND l.first.incarnation = incarnation THEN {
l.first.useCount _ l.first.useCount + 1;
IF prev = NIL THEN remoteBCDCache _ l.rest ELSE prev.rest _ l.rest; --unhook it
l.rest _ remoteBCDCache;  -- stick it at the beginning (most recent)
remoteBCDCache _ l;
RETURN[l.first.localBCD];
};
prev _ l;
ENDLOOP;
};

EnterRemoteBCDInCache: ENTRY PROC [world: World, remoteBCD: Address, localBCD: BcdDefs.BcdBase] = {
ENABLE UNWIND => NULL;
incarnation: Incarnation = CurrentIncarnation[world];
FOR l: RemoteBCDCache _ remoteBCDCache, l.rest UNTIL l = NIL DO
IF l.rest = NIL THEN {
l.rest _ CONS[
[world: world,
 incarnation: incarnation,
 remoteBCD: remoteBCD,
 localBCD: localBCD,
 useCount: 1],
NIL];
RETURN;
};
ENDLOOP;
remoteBCDCache _ CONS[
[world: world,
 incarnation: incarnation,
 remoteBCD: remoteBCD,
 localBCD: localBCD,
 useCount: 1],
NIL];
};

AcquireRemoteBCD: PUBLIC PROC [world: World, incarnation: Incarnation, bcd: BcdDefs.BcdBase] RETURNS [mappedBCD: BcdDefs.BcdBase _ NIL] ={
pages: NAT;
interval: VM.Interval;
mappedBCD _ FindCachedRemoteBCD[world, LOOPHOLE[bcd, Address]];
IF mappedBCD # NIL THEN RETURN[mappedBCD];
interval _ VM.Allocate[count: 1];
mappedBCD _ VM.AddressForPageNumber[interval.page];
CopyRead[world: world,
from: LOOPHOLE[bcd, Address],
nwords: SIZE[BcdDefs.BCD],
to: LOOPHOLE[mappedBCD, LONG POINTER]
! UNWIND => VM.Free[interval]];

IF mappedBCD.extended
THEN pages _ mappedBCD.nPages - mappedBCD.rtPages.pages
ELSE pages _ mappedBCD.nPages;

VM.Free[interval];
interval _ VM.Allocate[count: pages];
mappedBCD _ VM.AddressForPageNumber[interval.page];
CopyRead[world: world,
from: LOOPHOLE[bcd, Address],
nwords: pages*PrincOps.wordsPerPage,
to: LOOPHOLE[mappedBCD, LONG POINTER]
! UNWIND => VM.Free[interval]];
EnterRemoteBCDInCache[
world: world,
remoteBCD: LOOPHOLE[bcd, Address],
localBCD: mappedBCD
];
};

GFHToName: PUBLIC PROC [f: PrincOps.GlobalFrameHandle] RETURNS [name: Rope.ROPE] = {
moduleIndex: LoadState.ModuleIndex; 
config: LoadState.ConfigID; 
ssb: BcdDefs.NameString; 
bcd: BcdDefs.BcdBase; 
FindModuleString: PROC
[mth: BcdDefs.MTHandle, mti: BcdDefs.MTIndex] RETURNS [ans: BOOL _ FALSE] = {
ssd: ConvertUnsafe.SubString;
IF moduleIndex IN [mth.gfi..mth.gfi + mth.ngfi) THEN {
ssd _ [base: @ssb.string, offset: mth.name, length: ssb.size[mth.name]]; 
name _ ConvertUnsafe.SubStringToRope[ssd]; 
RETURN [TRUE];
};
};
IF f = PrincOps.NullGlobalFrame THEN RETURN[NIL];
LoadState.local.Acquire[];
{ ENABLE UNWIND => LoadState.local.Release[];
[config, moduleIndex] _ LoadState.local.GlobalFrameToModule[f];
bcd _ LoadState.local.ConfigInfo[config].bcd; 
}; -- end ENABLE UNWIND
LoadState.local.Release[]; 
ssb _ LOOPHOLE[bcd + bcd.ssOffset]; 
[] _ BcdOps.ProcessModules[bcd, FindModuleString]; 
}; 

RemoteGFHToName: PUBLIC PROC [gfh: RemoteGlobalFrameHandle] RETURNS [ans: Rope.ROPE _ NIL] = {
bcd: BcdDefs.BcdBase; 
module: LoadState.ModuleIndex; 
ssb: BcdDefs.NameString; 
FindModuleString: PROC [mth: BcdDefs.MTHandle, mti: BcdDefs.MTIndex] RETURNS [stop: BOOL] = {
ssd: ConvertUnsafe.SubString;
IF module IN [mth.gfi..mth.gfi + mth.ngfi)
THEN {
ssd _ [base: @ssb.string, offset: mth.name, length: ssb.size[mth.name]]; 
ans _ ConvertUnsafe.SubStringToRope[ssd]; 
RETURN[TRUE]} 
ELSE RETURN[FALSE];
};
[bcd, module] _ AcquireRemoteBCDAndModule[gfh];
ssb _ LOOPHOLE[bcd + bcd.ssOffset, BcdDefs.NameString]; 
[] _ BcdOps.ProcessModules[bcd, FindModuleString ! UNCAUGHT => CONTINUE];
ReleaseRemoteBCD[bcd];
}; 

RemoteTypeToLocal: PUBLIC PROC [world: World, remoteType: CARDINAL] RETURNS [type: Type] = {
stb: SymbolTableBase;
td: RTTypesBasicPrivate.TypeDesc;  -- copied from the remote world.  NO REFS.
sth: SymbolTableHandle _ nullHandle;
seIndex: SymbolIndex;
CopyRead[
world: world,
from:
  LongRead[
world: world,
addr:
RemoteMapTiTd[world]  -- WorldRoot[world].GCStateBasic.mapTiTd
+ SIZE[RTTypesBasicPrivate.RMapTiTd[0]]
+ LOOPHOLE[remoteType, CARDINAL] * SIZE[RTTypesBasicPrivate.PTypeDesc]
],
nwords: SIZE[RTTypesBasicPrivate.TypeDesc],
to: @td];
seIndex _ td.utf.seIndex;  -- utf: (umid: original defining module, seIndex: sei therein)
sth _ RTSymbolsPrivate.AcquireSTHFromSTX[RTTypesBasicPrivate.FindSTI[[symbolsStamp: td.utf.umid]]].sth;

IF sth = nullHandle
THEN {
remoteBCD: BcdDefs.BcdBase;
remoteSGI: BcdDefs.SGIndex;
remoteSymbolsStamp: BcdDefs.VersionStamp;
[remoteBCD, remoteSGI, remoteSymbolsStamp]
_ WorldMapStiStdEntry[world: world, remoteSTI: td.symbolAccess.sti];
IF remoteBCD # NIL THEN {
moduleName: Rope.ROPE _ NIL;
mappedBCD: BcdDefs.BcdBase
_ AcquireRemoteBCD[world: world,
incarnation: CurrentIncarnation[world],
bcd: remoteBCD];
{ ENABLE UNWIND => ReleaseRemoteBCD[mappedBCD];
ssb: BcdDefs.NameString
= LOOPHOLE[mappedBCD + mappedBCD.ssOffset, BcdDefs.NameString];

IF remoteSGI = BcdDefs.SGNull
THEN {
findSymbolFTI: PROC [ffth: BcdDefs.FTHandle, ffti: BcdDefs.FTIndex] RETURNS [stop: BOOL] = {
IF ffth.version # remoteSymbolsStamp THEN RETURN[FALSE];
moduleName _ GetModuleName[ssb, ffth.name];
RETURN[TRUE]};
remoteSymbolsStamp _ td.utf.umid;
[] _ BcdOps.ProcessFiles[mappedBCD, findSymbolFTI];
IF moduleName = NIL THEN ERROR;
}
ELSE {
sgb: Table.Base = LOOPHOLE[mappedBCD + mappedBCD.sgOffset, Table.Base];
ftb: Table.Base = LOOPHOLE[mappedBCD + mappedBCD.ftOffset, Table.Base];
fti: BcdDefs.FTIndex _ sgb[remoteSGI].file;
seIndex _ td.symbolAccess.sei;
IF fti = BcdDefs.FTSelf
THEN moduleName _ GetModuleName[ssb, mappedBCD.source]
ELSE moduleName _ GetModuleName[ssb, ftb[fti].name]};
}; -- end ENABLE UNWIND

ReleaseRemoteBCD[mappedBCD];
sth _ GetSTHForModule [stamp: remoteSymbolsStamp, moduleName: moduleName, fileName: Rope.Concat[moduleName, ".bcd"]];
}; -- end remoteBCD # NIL
};  -- end sth = nullHandle

IF sth = nullHandle THEN ERROR AMTypes.Error[reason: noSymbols];
stb _ AcquireSTB[sth];
type _ AcquireType[stb: stb, seIndex: seIndex ! UNWIND => ReleaseSTB[stb]];
ReleaseSTB[stb];
};  -- end RemoteTypeToLocal

GetModuleName: PROC [ssb: BcdDefs.NameString, n: BcdDefs.NameRecord] RETURNS [name: Rope.Text] = {
ssd: ConvertUnsafe.SubString _ [base: @ssb.string, offset: n, length: ssb.size[n]];
name _ ConvertUnsafe.SubStringToRope[ssd]; 
FOR i: INT IN [0..Rope.Length[name]) DO
IF name[i] = '. THEN {name.length _ i; EXIT};
ENDLOOP;
};

ValidateRemoteFrame: PUBLIC PROC [remoteFH: RemoteFrameHandle] = {
frame: rep PrincOps.ControlLink = LOOPHOLE[remoteFH.fh, rep PrincOps.ControlLink];
IF frame.proc
OR frame.indirect
OR ~ValidRemoteGlobalFrame[
[world: remoteFH.world,
 worldIncarnation: remoteFH.worldIncarnation,
 gfh: LOOPHOLE[GetRemoteFrameHeader[remoteFH].accesslink, WorldVM.ShortAddress]
]]
THEN ERROR RemoteError[invalidFrame];
};

ValidRemoteGlobalFrame: PROC [gfh: RemoteGlobalFrameHandle] RETURNS [ans: BOOL _ FALSE] = {
h: rep PrincOps.ControlLink = LOOPHOLE[gfh.gfh, rep PrincOps.ControlLink];
ans _ NOT h.proc AND NOT h.indirect;
};  --  AND InRemoteGFT[gfh ! ANY => CONTINUE]};


Kludge: TYPE = RECORD [ignore1, ignore2, ignore3, ignore4, ignore5, mapTiTd: LONG POINTER];
RemoteMapTiTd: PROC [world: World] RETURNS [LONG CARDINAL] = {
RETURN[
LongRead[  -- gets the remote address of an RTTypesBasicPrivate.RMapTiTd
world: world,
addr:  -- the remote address of a cell containing the remote address of an RMapTiTd
LongRead[  -- gets the remote address of a Kludge
world: world,
addr:  --the remote address of a cell containing the remote address of a Kludge
Long[world: world, addr: LOOPHOLE[PrincOps.SD + RTSD.sGCState, ShortAddress]]
] + 5 * SIZE[LONG POINTER]
]
];
};

WorldMapStiStdEntry: PROC [world: World, remoteSTI: RTTypesBasicPrivate.SymbolTableIndex] RETURNS [BcdDefs.BcdBase, BcdDefs.SGIndex, BcdDefs.VersionStamp] = {
ans: RTTypesBasicPrivate.STDesc;
CopyRead[-- gets an STDesc
world: world,
from:
LongRead[-- gets the remote address of an STDesc
world: world,
addr:-- the remote address of a cell containing the remote address of an STDesc
LongRead[  -- gets the remote address of an RMapStiStd
world: world,
addr:-- the remote address of a cell containing the remote address of an RMapStiStd
Long[
world: world,
addr: LOOPHOLE[PrincOps.SD + RTSD.sMapStiStd, ShortAddress]
]
]
+ SIZE[RTTypesBasicPrivate.RMapStiStd[0]]
+ SIZE[RTTypesBasicPrivate.PSTDesc] * remoteSTI
],
nwords: SIZE[RTTypesBasicPrivate.STDesc],
to: @ans
];
RETURN[ans.bcd, ans.sgi, ans.symbolsStamp]
};

GetRemotePc: PUBLIC PROC [gf: RemoteGlobalFrameHandle, i: EVRange] RETURNS [PrincOps.BytePC] = {
codeBase: RemotePointer = GetRemoteEntryTableBase[gf];
wpc: CARDINAL _ Read[world: gf.world,
addr: LOOPHOLE[codeBase.ptr, Address]
+ SIZE[PrincOps.CSegPrefix]
+ i*SIZE[PrincOps.EntryVectorItem]];
RETURN[LOOPHOLE[wpc*2, PrincOps.BytePC]]}; 

GetRemoteEntryTableBase: PROC [gfh: RemoteGlobalFrameHandle] RETURNS [RemotePointer] = {
c: PrincOps.FrameCodeBase _ GetRemoteGFHeader[gfh].code;
c.out _ FALSE;
RETURN[[world: gfh.world, worldIncarnation: gfh.worldIncarnation, ptr: LOOPHOLE[c, Address]]];
};

UnwindRemoteIndirectProcDesc: PUBLIC PROC [pd: RemotePD] RETURNS [RemotePD] = {
icl: PrincOps.ControlLink _ LOOPHOLE[pd.pd, PrincOps.ControlLink];
world: World = pd.world;
IF icl = PrincOps.NullLink OR icl = PrincOps.UnboundLink THEN RETURN[nilRemotePD];
Lock[world];
{ ENABLE UNWIND => Unlock[world];
UNTIL icl.proc DO
IF icl.indirect
THEN
icl _ LOOPHOLE[
Read[world: world,
	addr: Long[world: world, addr: LOOPHOLE[icl.link, ShortAddress]]],
PrincOps.ControlLink]
ELSE ERROR Error[reason: typeFault, type: nullType]
ENDLOOP;
};  -- end ENABLE UNWIND
Unlock[world];
RETURN[[world: world, worldIncarnation: pd.worldIncarnation, pd: LOOPHOLE[icl]]]};

AcquireCBTHandleFromRemotePD: PUBLIC PROC [pd: RemotePD] RETURNS [stb: SymbolTableBase, cbti: CallableBodyIndex] = {
world: World = pd.world;

Lock[world];
{ ENABLE UNWIND => Unlock[world];
gfh: RemoteGlobalFrameHandle
_ [world: world,
worldIncarnation: pd.worldIncarnation,
gfh: LOOPHOLE[RemoteGlobalFrame[world, pd.pd], WorldVM.ShortAddress]];
stb _ AcquireSTBFromRemoteGFH[gfh];
cbti _ RTTypesPrivate.GetCBTI[stb, RemoteGlobalFrameAndEntryPoint[world, pd.pd].ep];
};
Unlock[world];
};




GetRemoteGFHeader: PUBLIC PROC [gfh: RemoteGlobalFrameHandle]
RETURNS [ans: REF PrincOps.GlobalFrame] = {
world: World = gfh.world;
ans _ NEW[PrincOps.GlobalFrame];
Lock[world];
{ ENABLE UNWIND => Unlock[world];
CopyRead[
world: world,
from: Long[world: world, addr: LOOPHOLE[gfh.gfh, ShortAddress]],
nwords: SIZE[PrincOps.GlobalFrame],
to: LOOPHOLE[ans, LONG POINTER]
];
};  -- end ENABLE UNWIND
Unlock[world];
};

GetRemoteFrameHeader: PUBLIC PROC [fh: RemoteFrameHandle]
RETURNS [ans: REF PrincOps.Frame] = {
world: World = fh.world;
ans _ NEW[PrincOps.Frame];
Lock[world];
{ ENABLE UNWIND => Unlock[world];
CopyRead[
world: world,
from: Long[world: world, addr: LOOPHOLE[fh.fh, ShortAddress]],
nwords: SIZE[PrincOps.Frame],
to: LOOPHOLE[ans, LONG POINTER]
];
};  -- end ENABLE UNWIND
Unlock[world];
};

GetRemoteReferentType: PUBLIC PROC [remoteRef: RemoteRef] RETURNS [type: Type--valid locally--] = {
world: World = remoteRef.world;
IF remoteRef.ref = 0 THEN RETURN[nullType];
Lock[world];
type _ GetRemotePrefixedType[remoteRef ! UNWIND => Unlock[world]];
Unlock[world];
};

GetRemotePrefixedType: PROC [remoteRef: RemoteRef] RETURNS [Type--valid locally--] = {
remoteType: CARDINAL = WorldVM.Read[world: remoteRef.world, addr: remoteRef.ref - 1];
RETURN[RemoteTypeToLocal[world: remoteRef.world, remoteType: remoteType]];
};

GetRemoteProcedureType: PUBLIC PROC [remotePD: RemotePD] RETURNS [type: Type--valid locally--] = {
stb: SymbolTableBase;
cbti: CallableBodyIndex;
[stb, cbti] _ AcquireCBTHandleFromRemotePD[remotePD];
type _ AcquireType
[stb,
WITH stb SELECT FROM
t: SymbolTableBase.x => [x[t.e.bb[NARROW[cbti, CallableBodyIndex.x].e].ioType]],
t: SymbolTableBase.y => [y[t.e.bb[NARROW[cbti, CallableBodyIndex.y].e].ioType]],
ENDCASE => ERROR,
! UNWIND => ReleaseSTB[stb]];
ReleaseSTB[stb]};

GetRemoteSignalType: PUBLIC PROC [remoteSED: RemoteSED] RETURNS [type: Type _ nullType--valid locally--] = {
ep: CARDINAL;
stb: SymbolTableBase;
world: World = remoteSED.world;

proc: PROC [stb: SymbolTableBase, isei: SymbolIdIndex] RETURNS [stop: BOOL] = {
WITH stb SELECT FROM
t: SymbolTableBase.x => RETURN[procX[t.e, NARROW[isei, SymbolIdIndex.x].e]];
t: SymbolTableBase.y => RETURN[procY[t.e, NARROW[isei, SymbolIdIndex.y].e]];
ENDCASE => ERROR};
procX: PROC [stb: bx.SymbolTableBase, isei: bx.SymbolIdIndex] RETURNS [stop: BOOL] = {
tsei: bx.SymbolIndex;
IF stb.seb[isei].constant
AND stb.seb[tsei _ stb.UnderType[stb.seb[isei].idType]].typeTag = transfer
AND (SELECT stb.XferMode[tsei] FROM
error, signal => TRUE,
ENDCASE => FALSE)
AND ep = STInfoToEPN[LOOPHOLE[stb.seb[isei].idValue, PrincOps.SignalDesc]]
THEN {type _ AcquireType[[x[stb]], [x[stb.seb[isei].idType]]]; RETURN[TRUE]}
ELSE RETURN[FALSE]};
procY: PROC [stb: by.SymbolTableBase, isei: by.SymbolIdIndex] RETURNS [stop: BOOL] = {
tsei: by.SymbolIndex;
IF stb.seb[isei].constant
AND stb.seb[tsei _ stb.UnderType[stb.seb[isei].idType]].typeTag = transfer
AND (SELECT stb.XferMode[tsei] FROM
error, signal => TRUE,
ENDCASE => FALSE)
AND ep = STInfoToEPN[LOOPHOLE[stb.seb[isei].idValue, PrincOps.SignalDesc]]
THEN {type _ AcquireType[[y[stb]], [y[stb.seb[isei].idType]]]; RETURN[TRUE]}
ELSE RETURN[FALSE]};


IF LOOPHOLE[remoteSED.sed, CARDINAL] = 177777B  -- ERROR
OR LOOPHOLE[remoteSED.sed, CARDINAL] = LOOPHOLE[UNWIND, CARDINAL]
OR LOOPHOLE[remoteSED.sed, CARDINAL] = LOOPHOLE[ABORTED, CARDINAL]
THEN RETURN[CODE[ERROR]];

Lock[world];
{ ENABLE UNWIND => Unlock[world];
gfh: PrincOps.GlobalFrameHandle;
[gfh, ep] _ RemoteGlobalFrameAndEntryPoint[world, remoteSED.sed];
stb _ AcquireSTBFromRemoteGFH[[world, remoteSED.worldIncarnation, LOOPHOLE[gfh]]];
[] _ EnumerateRecordIseis
[stb,
 WITH stb SELECT FROM
t: SymbolTableBase.x => [x[t.e.bb[bx.rootBodyIndex].type]],
t: SymbolTableBase.y => [y[t.e.bb[by.rootBodyIndex].type]],
ENDCASE => ERROR,
 proc
! UNWIND => ReleaseSTB[stb]];
ReleaseSTB[stb];
};  -- end ENABLE UNWIND
Unlock[world];
};

IsRemoteCatchFrame: PUBLIC PROC [remoteFrameHandle: RemoteFrameHandle, bti: BodyIndex] RETURNS [isCatchFrame: BOOL _ TRUE, revBti: BodyIndex] = {
world: World = remoteFrameHandle.world;
Lock[world];
{ ENABLE UNWIND => Unlock[world];
revBti _ bti;
ValidateRemoteFrame[remoteFrameHandle
! RuntimeError.UNCAUGHT, RemoteError, WorldVM.AddressFault => GOTO notCatch];
{   -- return FALSE if input invalid
nextFrame: RemoteFrameHandle
_ [world: remoteFrameHandle.world,
 worldIncarnation: remoteFrameHandle.worldIncarnation,
 fh: LOOPHOLE[AMProcessBasic.ReturnLink
[world,
LOOPHOLE[remoteFrameHandle.fh, PrincOps.FrameHandle]],
ShortAddress]];
nextFHdr: REF PrincOps.Frame;
ValidateRemoteFrame[nextFrame
! RuntimeError.UNCAUGHT, RemoteError, WorldVM.AddressFault => GOTO notCatch];
nextFHdr _ GetRemoteFrameHeader[nextFrame];
IF nextFHdr.accesslink # RemoteSigGF[remoteFrameHandle.world]
THEN GOTO notCatch;
{   -- return FALSE if caller not signaller
sl: CARDINAL = LOOPHOLE[GetRemoteFrameHeader[remoteFrameHandle].staticlink];
L0Frame: RemoteFrameHandle
_ [world: remoteFrameHandle.world,
 worldIncarnation: remoteFrameHandle.worldIncarnation,
 fh: 0];
IF sl = 0 THEN GOTO notCatch;
L0Frame _ [
world: remoteFrameHandle.world,
worldIncarnation: remoteFrameHandle.worldIncarnation,
fh: LOOPHOLE[sl - PrincOps.localbase, ShortAddress]
];
ValidateRemoteFrame[L0Frame
! RuntimeError.UNCAUGHT, RemoteError, WorldVM.AddressFault => GOTO notCatch];
IF GetRemoteFrameHeader[remoteFrameHandle].accesslink
# GetRemoteFrameHeader[L0Frame].accesslink
THEN GOTO notCatch;
IF ~nextFHdr.mark THEN GOTO notCatch;  -- calling frame not the signaller
{ -- detect situation where catch frame has no locals, thus no body table.
tr: REF TypedVariableRec
= NARROW[TVForRemoteFrame[L0Frame], REF TypedVariableRec];
WITH hd: tr.head SELECT FROM
remoteFH => IF bti = hd.bti THEN revBti _ nullBodyIndex;
ENDCASE => ERROR
};  -- end detect situation where ...
};  -- end return FALSE if caller not signaller
};  -- end return FALSE if input invalid
};  -- end ENABLE UNWIND
Unlock[world];
EXITS notCatch => {Unlock[remoteFrameHandle.world]; isCatchFrame _ FALSE};
};  -- end IsRemoteCatchFrame

RemoteSigGF: PROC [world: World] RETURNS [PrincOps.GlobalFrameHandle] = {
pd: PrincOps.ProcDesc = LOOPHOLE[Read[world: world, addr: Long[world: world, addr: LOOPHOLE[PrincOps.SD + PrincOps.sSignal, ShortAddress]]], PrincOps.ProcDesc];
RETURN[RemoteGlobalFrame[world, LOOPHOLE[pd]]];
};

AcquireBTIFromRemoteFH: PUBLIC PROC [remoteFrameHandle: RemoteFrameHandle, contextPC: BOOL] RETURNS [bti: BodyIndex _ nullBodyIndex] = {
stb: SymbolTableBase _ nullBase;
world: World = remoteFrameHandle.world;
Lock[world];
{ ENABLE UNWIND => Unlock[world];
[stb, bti]
_ AcquireBTHandleFromRemoteFH[remoteFrameHandle, contextPC
! RuntimeError.UNCAUGHT, RemoteError, WorldVM.AddressFault, AMTypes.Error
=> CONTINUE
];
};  -- end ENABLE UNWIND
Unlock[world];
IF stb # nullBase THEN ReleaseSTB[stb];
};

AcquireBTHandleFromRemoteFH: PROC [fh: RemoteFrameHandle, contextPC: BOOL] RETURNS [stb: SymbolTableBase, bti: BodyIndex] = {
start: PrincOps.BytePC;
epn: CARDINAL;
remoteFrame: REF PrincOps.Frame = GetRemoteFrameHeader[fh];
framePC: PrincOps.BytePC = [(remoteFrame.pc - (IF contextPC THEN 0 ELSE 1))];

stb _ AcquireSTBFromRemoteGFH[[world: fh.world,
worldIncarnation: fh.worldIncarnation,
gfh: LOOPHOLE[remoteFrame.accesslink, ShortAddress]]];

[epn, start] _ GetRemoteEp[pc: framePC,
gf: [world: fh.world,
worldIncarnation: fh.worldIncarnation,
gfh: LOOPHOLE[remoteFrame.accesslink, ShortAddress]],
stb: stb
! UNWIND => ReleaseSTB[stb]];
bti _ RTTypesPrivate.ConvertCbti[base: stb,
pc: framePC,
start: start,
lastBti: LOOPHOLE[RTTypesPrivate.GetCBTI[stb, epn]]
! UNWIND => ReleaseSTB[stb]];
IF bti = rootBodyIndex THEN bti _ nullBodyIndex};

GetRemoteEp: PUBLIC PROC [pc: PrincOps.BytePC, gf: RemoteGlobalFrameHandle, stb: SymbolTableBase] RETURNS [ep: EVRange, start: PrincOps.BytePC] = {
 FindMaxEI: PROC RETURNS [max: EVRange] = {
 GetMaxX: PROC [bti: bx.BodyIndex] RETURNS [stop: BOOL] = {
WITH stb SELECT FROM
t: SymbolTableBase.x =>
WITH t.e.bb[bti] SELECT FROM
Callable => IF ~inline THEN max _ MAX[max, entryIndex];
ENDCASE;
ENDCASE => ERROR;
RETURN[FALSE]};
GetMaxY: PROC [bti: by.BodyIndex] RETURNS [stop: BOOL] = {
WITH stb SELECT FROM
t: SymbolTableBase.y =>
WITH t.e.bb[bti] SELECT FROM
Callable => IF ~inline THEN max _ MAX[max, entryIndex];
ENDCASE;
ENDCASE => ERROR;
RETURN[FALSE]};
max _ 0;
WITH stb SELECT FROM
t: SymbolTableBase.x => [] _ t.e.EnumerateBodies[bx.rootBodyIndex, GetMaxX];
t: SymbolTableBase.y => [] _ t.e.EnumerateBodies[by.rootBodyIndex, GetMaxY];
ENDCASE => ERROR};

diff: CARDINAL _ LAST[CARDINAL];
anyProcedure: BOOL _ FALSE;
FOR i: EVRange IN [0..FindMaxEI[]] DO
last: PrincOps.BytePC _ GetRemotePc[gf, i];
IF Card[last] > Card[pc] THEN LOOP;
IF Card[pc] - Card[last] > diff THEN LOOP;
diff _ Card[pc] - Card[last];
ep _ i; start _ last;
anyProcedure _ TRUE;
ENDLOOP;
IF ~anyProcedure THEN ERROR;  -- SIGNAL NotInAnyProcedure;
RETURN};

RemotePDToName: PUBLIC PROC [pd: RemotePD] RETURNS [ans: Rope.ROPE] = {
stb: SymbolTableBase;
cbti: CallableBodyIndex;
pd _ UnwindRemoteIndirectProcDesc[pd];
IF pd.pd = 0 THEN RETURN[NIL];
[stb, cbti] _ AcquireCBTHandleFromRemotePD[pd];
ans _ AcquireRope[stb,
WITH stb SELECT FROM
t: SymbolTableBase.x =>
[x[t.e.seb[t.e.bb[NARROW[cbti, CallableBodyIndex.x].e].id].hash]],
t: SymbolTableBase.y =>
[y[t.e.seb[t.e.bb[NARROW[cbti, CallableBodyIndex.y].e].id].hash]],
ENDCASE => ERROR
! UNWIND => ReleaseSTB[stb]];
ReleaseSTB[stb];
RETURN[ans]};

RemoteSEDToName: PUBLIC PROC [sed: RemoteSED] RETURNS [ans: Rope.ROPE _ NIL] = {
ep: CARDINAL;
stb: SymbolTableBase;
world: World = sed.world;

proc: PROC [stb: SymbolTableBase, isei: SymbolIdIndex] RETURNS [stop: BOOL] = {
WITH stb SELECT FROM
t: SymbolTableBase.x => RETURN[procX[t.e, NARROW[isei, SymbolIdIndex.x].e]];
t: SymbolTableBase.y => RETURN[procY[t.e, NARROW[isei, SymbolIdIndex.y].e]];
ENDCASE => ERROR};
procX: PROC [stb: bx.SymbolTableBase, isei: bx.SymbolIdIndex] RETURNS [stop: BOOL] = {
tsei: bx.SymbolIndex;
IF stb.seb[isei].constant
AND stb.seb[tsei _ stb.UnderType[stb.seb[isei].idType]].typeTag = transfer
AND (SELECT stb.XferMode[tsei] FROM
error, signal => TRUE,
ENDCASE => FALSE)
AND ep = STInfoToEPN[LOOPHOLE[stb.seb[isei].idValue, PrincOps.SignalDesc]]
THEN {ans _ AcquireRope[[x[stb]], [x[stb.seb[isei].hash]]]; RETURN[TRUE]}
ELSE RETURN[FALSE]};
procY: PROC [stb: by.SymbolTableBase, isei: by.SymbolIdIndex] RETURNS [stop: BOOL] = {
tsei: by.SymbolIndex;
IF stb.seb[isei].constant
AND stb.seb[tsei _ stb.UnderType[stb.seb[isei].idType]].typeTag = transfer
AND (SELECT stb.XferMode[tsei] FROM
error, signal => TRUE,
ENDCASE => FALSE)
AND ep = STInfoToEPN[LOOPHOLE[stb.seb[isei].idValue, PrincOps.SignalDesc]]
THEN {ans _ AcquireRope[[y[stb]], [y[stb.seb[isei].hash]]]; RETURN[TRUE]}
ELSE RETURN[FALSE]};

SELECT LOOPHOLE[sed.sed, CARDINAL] FROM
LOOPHOLE[PrincOps.NullLink, CARDINAL] => RETURN[NIL];
LOOPHOLE[PrincOps.UnboundLink, CARDINAL] => RETURN[NIL];
177777B => RETURN["ERROR"];
LOOPHOLE[UNWIND, CARDINAL] => RETURN["UNWIND"];
LOOPHOLE[ABORTED, CARDINAL] => RETURN["ABORTED"];
ENDCASE;

Lock[world];
{ ENABLE UNWIND => Unlock[world];
sei: SymbolRecordIndex;
gfh: PrincOps.GlobalFrameHandle;
[gfh, ep] _ RemoteGlobalFrameAndEntryPoint[world, sed.sed];
stb _ AcquireSTBFromRemoteGFH[[world, sed.worldIncarnation, LOOPHOLE[gfh]]];
sei _ WITH stb SELECT FROM
t: SymbolTableBase.x => [x[t.e.bb[bx.rootBodyIndex].type]],
t: SymbolTableBase.y => [y[t.e.bb[by.rootBodyIndex].type]],
ENDCASE => ERROR;
IF NOT NullISEI[LOOPHOLE[sei]] THEN
[] _ EnumerateRecordIseis[stb, sei, proc ! UNWIND => ReleaseSTB[stb]];
ReleaseSTB[stb];
};  -- end ENABLE UNWIND
Unlock[world];
};

RemoteStoreWords: PUBLIC PROC [from: LONG POINTER, to: RemotePointer, nWords: NAT] = {
Lock[to.world];
CopyWrite[world: to.world, from: from, nwords: nWords, to: to.ptr
! UNWIND => Unlock[to.world]];
Unlock[to.world];
};

RemoteStoreWord: PUBLIC PROC [to: RemotePointer, value: CARDINAL] = {
Lock[to.world];
Write[world: to.world, addr: to.ptr, value: value ! UNWIND => Unlock[to.world]];
Unlock[to.world];
};

RemoteStoreDoubleWord: PUBLIC PROC [to: RemotePointer, value: LONG CARDINAL] = {
Lock[to.world];
LongWrite[world: to.world, addr: to.ptr, value: value ! UNWIND => Unlock[to.world]];
Unlock[to.world];
};

RemoteStoreFieldLong: PUBLIC PROC [ptr: RemotePointer, field: RTCommon.Field, value: LONG CARDINAL] = {
val: LONG CARDINAL;
Lock[ptr.world];
{ENABLE UNWIND => Unlock[ptr.world];
val _ LongRead[world: ptr.world, addr: LOOPHOLE[ptr.ptr, Address]];
RTCommon.StoreFieldLong[ptr: @val, field: field, newValue: value];
LongWrite[world: ptr.world, addr: LOOPHOLE[ptr.ptr, Address], value: val];
};  -- end ENABLE UNWIND
Unlock[ptr.world];
};

GetRemoteWord: PUBLIC PROC [remotePointer: RemotePointer] RETURNS [ans: WORD] = {
Lock[remotePointer.world];
ans _ Read[world: remotePointer.world, addr: remotePointer.ptr
! UNWIND => Unlock[remotePointer.world]];
Unlock[remotePointer.world];
};

GetRemoteLC: PUBLIC PROC [remotePointer: RemotePointer] RETURNS [ans: LONG CARDINAL] = {
Lock[remotePointer.world];
ans _ LongRead[world: remotePointer.world, addr: remotePointer.ptr
! UNWIND => Unlock[remotePointer.world]];
Unlock[remotePointer.world];
};

GetRemoteWords: PUBLIC PROC [remotePointer: RemotePointer, nWords: NAT] RETURNS [ans: WordSequence] = {
Lock[remotePointer.world];
{ENABLE UNWIND => Unlock[remotePointer.world];
ans _ NEW[WordSequenceRecord[nWords]];
CopyRead[
world: remotePointer.world,
from: remotePointer.ptr,
nwords: nWords,
to: LOOPHOLE[@ans[0], LONG POINTER]];
};  -- end ENABLE UNWIND
Unlock[remotePointer.world];
};

RemoteSignalValues: PUBLIC PROC [tv: TypedVariable--catch Frame--] RETURNS [message: CARDINAL, signal: PrincOps.SignalDesc, world: World] = {
rtr:  REF TypedVariableRec _ NARROW[tv];
world _ GetWorld[tv];
WITH th: rtr.head SELECT FROM
fh =>
IF th.isCatchFrame
THEN {signallerFrameHandle: PrincOps.FrameHandle;
signallerFrameHandle _ AMProcessBasic.ReturnLink[world, th.fh].frame;
message _ LOOPHOLE[signallerFrameHandle + SignallerFrameMessageOffset,
POINTER TO UNSPECIFIED]^;
signal _    LOOPHOLE[signallerFrameHandle + SignallerFrameSignalOffset,
POINTER TO PrincOps.SignalDesc]^;
RETURN}
ELSE ERROR Error[reason: typeFault, type: TVType[tv]];
remoteFH =>
IF th.isCatchFrame
THEN {
remoteSignallerFrameHandle: RemoteFrameHandle _ nilRemoteFrameHandle;
Lock[world];
{ ENABLE UNWIND => Unlock[world];
ValidateRemoteFrame[th.remoteFrameHandle];
remoteSignallerFrameHandle
_ [world: world,
 worldIncarnation: th.remoteFrameHandle.worldIncarnation,
 fh: LOOPHOLE[
AMProcessBasic.ReturnLink
[world, LOOPHOLE[th.remoteFrameHandle.fh, PrincOps.FrameHandle]],
ShortAddress]];
message _ Read[
world: world, 
addr: Long[
world: world,
addr: remoteSignallerFrameHandle.fh + SignallerFrameMessageOffset]];
signal _ LOOPHOLE
[Read[world: world, 
addr: Long[
world: world,
addr: remoteSignallerFrameHandle.fh + SignallerFrameSignalOffset]],
PrincOps.SignalDesc];
};  -- end ENABLE UNWIND
Unlock[world];
RETURN;
}
ELSE ERROR Error[reason: typeFault, type: TVType[tv]];
ENDCASE => ERROR Error[reason: typeFault, type: TVType[tv]]};

STInfoToEPN: PROC [cl: PrincOps.SignalDesc] RETURNS [CARDINAL] = {
RETURN[(cl.gfi - 1) * PrincOps.EPRange + cl.ep]};

Card: PROC [pc: PrincOps.BytePC] RETURNS [CARDINAL] = {
RETURN[LOOPHOLE[pc, CARDINAL]]};

END.


RTTypesRemotePrivateImpl.Mesa
Copyright c 1985 by Xerox Corporation.  All rights reserved.
Rovner, January 16, 1984 2:39 pm
Russ Atkinson (RRA) March 22, 1985 10:00:30 am PST
TYPES
VARIABLES
CONSTANTS
S I G N A L S
P R O C E D U R E S
raises notImplemented
ValidateRemoteRef: PUBLIC PROC[ref: RemoteRef] =
{IF FALSE THEN ERROR AMTypes.Error[reason: notImplemented, msg: "ValidateRemoteRef"];
};
SameCode: PUBLIC PROC [f1, f2: RemoteGlobalFrameHandle] RETURNS [BOOL] =
{ fcb1, fcb2: PrincOps.FrameCodeBase;
fcb1 _ GetRemoteGFHeader[f1].code;
fcb2 _ GetRemoteGFHeader[f2].code;
fcb1.out _ fcb2.out _ FALSE;
RETURN[fcb1 = fcb2]};
EnumerateRemoteGlobalFrames: PUBLIC PROC[world: World,
proc: PROC[RemoteGlobalFrameHandle]
RETURNS[BOOLEAN]]
RETURNS[RemoteGlobalFrameHandle] = 
{ gftLength: CARDINAL;
{ ENABLE UNWIND => Unlock[world];
Lock[world];
gftLength _ Read[world: world,
addr: Long[world: world,
addr: LOOPHOLE[PrincOps.SD + SDDefs.sGFTLength,
ShortAddress]]];
FOR i: CARDINAL IN [1..gftLength) DO
item: PrincOpsRuntime.GFTItem;
frame: PrincOps.GlobalFrameHandle;
CopyRead[world: world,
from: Long[world: world,
addr: LOOPHOLE[PrincOpsRuntime.GFT
+ i * SIZE[PrincOpsRuntime.GFTItem],
ShortAddress]],
nwords: SIZE[PrincOpsRuntime.GFTItem],
to: @item];
frame _ PrincOpsRuntime.GetFrame[item];
IF frame # PrincOps.NullGlobalFrame AND item.epbias = 0 THEN
{IF proc[[world: world,
worldIncarnation: CurrentIncarnation[world],
gfh: LOOPHOLE[frame, ShortAddress]]]
THEN {Unlock[world]; RETURN[[world: world,
worldIncarnation: CurrentIncarnation[world],
gfh: LOOPHOLE[frame, ShortAddress]]]}};
ENDLOOP;
Unlock[world];
RETURN[nilRemoteGlobalFrameHandle]}};
here with the copied remote BCD. Now poke around in the remote bcd to find the version stamp, then get the symboltable
now find the bcd and module of interest
UnsafeStorage.GetSystemUZone[].FREE[@nBCD];
assumes world is locked
UnsafeStorage.NewUObject
[size: PrincOps.wordsPerPage, zone: UnsafeStorage.GetSystemUZone[]];
UnsafeStorage.GetSystemUZone[].FREE[@mappedBCD]];
UnsafeStorage.GetSystemUZone[].FREE[@mappedBCD];
UnsafeStorage.NewUObject[
size: pages*PrincOps.wordsPerPage,
zone: UnsafeStorage.GetSystemUZone[]];
UnsafeStorage.GetSystemUZone[].FREE[@mappedBCD]];
seIndex must be consistent with sth:
either symbols from the UTF or from the Typs's symbol access info
first try for the original defining module
not easy. Try harder using symbol access info for the remote type.
go again for the defining module, this time with its name
(search the BCD's file table)
go for the module specified by the SGI
NOTE module name vs file name
raises RemoteError
InRemoteGFT: PROC[gfh: RemoteGlobalFrameHandle] RETURNS[BOOL] =
{gftLength: CARDINAL;
world: World = gfh.world;
Lock[world];
{ ENABLE UNWIND => Unlock[world];
gftLength _ Read[world: world,
addr: Long[world: world,
addr: LOOPHOLE[PrincOps.SD + PrincOps.sGFTLength,
ShortAddress]]];
FOR k: CARDINAL IN [1..gftLength) DO
IF GetRemoteGFHandle[world: world, gfi: k] = gfh
AND GetRemoteGFHeader[gfh].gfi = k
THEN {Unlock[world]; RETURN[TRUE]};
ENDLOOP;
Unlock[world];
};
RETURN[FALSE];
};
LONG POINTER TO PrincOps.CSegPrefix
raises typeFault
GetRemoteGFHandle: PUBLIC PROC[world: World, gfi: PrincOps.GFTIndex]
RETURNS[RemoteGlobalFrameHandle] =
{item: PrincOpsRuntime.GFTItem;
{ ENABLE UNWIND => Unlock[world];
Lock[world];
CopyRead[world: world,
from: Long[world: world,
addr: LOOPHOLE[PrincOpsRuntime.GFT
+ gfi * SIZE[PrincOpsRuntime.GFTItem],
ShortAddress]],
nwords: SIZE[PrincOpsRuntime.GFTItem],
to: @item
];
Unlock[world];
RETURN[[world: world,
worldIncarnation: CurrentIncarnation[world],
gfh: LOOPHOLE[PrincOpsRuntime.GetFrame[item], ShortAddress]]]};
};
START GetRemoteSignalType HERE
return FALSE if no valid calling frame
L0Frame is the frame that encloses the catch frame
return FALSE if static frame not valid (??)
body of GetEp begins here
Κ#P˜
codeš
œ™Kšœ
Οm
œ1™<Kš
œ ™ K™2—K˜š
Οk	˜	Kšœ	žœΎ
˜Μ
Kšœžœ˜"Kšœžœ ˜-Kšœžœžœg˜‚
Kšœžœ ˜,KšœžœI˜_KšœžœI˜_Kšœžœ˜1Kšœ
žœ[˜jKšœ	žœΧ
žœ˜ς
Kšœžœ5˜NKšœžœžœ˜(Kšœ	žœ˜'Kšžœ
žœ˜"Kšœ
žœ§
˜Ή
Kšœžœ<˜MKšœ
žœ+˜:Kšœžœ˜+Kšœžœv˜
Kšœžœ*˜>Kšœžœ˜6Kšœ
žœžœ˜Kšœžœ˜#Kšœžœ˜Kšžœ
žœH˜Pšœžœ₯
˜²
K˜——šœžœΟc$˜GKšžœΘ
žœ	˜Ϊ
Kšžœ%˜,Kšžœ˜Kšœžœ
žœΔ
˜Π
K˜—š
œ™Kšœžœžœ
žœ
˜+šœ
žœžœ˜+K˜K˜K˜Kšœ
žœ˜——š
œ	™	Kšœ!žœ
˜%Kšœžœ˜Kšœžœ˜!K˜—š
œ	™	Kšœžœ˜%Kšœžœ˜$K˜—š
œ
™
K˜šœ
žœ
žœ!žœ
žœ
žœ
žœžœžœ
˜]K˜——Kš
œ™K˜Kš
œ™Kš
œ0™0Kš
œU™UKš
œ™K˜Kš
œH™HKš
œ%™%Kš
œ"™"Kš
œ"™"Kš
œ™Kš
œ™K˜Kš
œ6™6Kš
œ#™#Kš
œ™Kš
œ#™#Kš
œ™K˜Kš
œ!™!Kš
œ™Kš
œ™Kš
œ™Kš
œ/™/Kš
œ™Kš
œ$™$Kš
œ™Kš
œ"™"Kš
œ™Kš
œ™Kš
œ"™"Kš
œ$™$Kš
œ™Kš
œ&™&Kš
œ™Kš
œ'™'Kš
œ<™<Kš
œ™Kš
œ,™,Kš
œ$™$Kš
œ*™*Kš
œ,™,Kš
œ'™'Kš
œ™Kš
œ™Kš
œ%™%K˜šΟnœžœ
žœžœ˜aKš
œ˜K˜K˜ K˜$K˜K˜K˜*Kšœžœ˜2K˜š 
œžœ/žœžœ˜QKšžœžœ#˜3K˜—K˜5K˜Kš
œv™vKšœžœ-˜;K˜˜5Kšœžœ!˜)—Kšžœžœ
žœžœ˜7K˜šœžœ˜1Kšžœ˜Kšžœ˜—K˜K˜'Kšœ@žœ˜Nšžœžœ˜K˜rKšžœžœ.˜FK˜—šžœ˜Kšžœ
žœ<˜FKšžœ
žœ˜—K˜K˜—š œžœ
žœ'žœ˜gKš
œ4˜4Kšœžœ˜(Kš
œ˜˜K˜——š œžœ
žœžœ-˜zKšœŸ
˜$K˜K˜Kšžœ
žœ
žœ"˜;K˜š
œ
˜
Kšžœ
žœ˜#K˜;K˜K˜Kš
œ'™'š
œ
˜
Kšžœ
žœ˜%˜Kšœ žœ'˜O—K˜'KšœŸ˜—K˜˜K˜Kš
œ"˜"K˜
—KšœŸ˜—K˜Kšžœ˜KšœŸ ˜$K˜—š œžœ
žœ
žœ˜>Kšžœ
žœžœ
˜šžœ,žœž˜?šžœžœ˜ Kš
œ(˜(šžœ/žœ˜8Kšœžœ
˜šžœ,žœž˜?šžœžœ˜Kš
œ)˜)šœžœ˜Kšžœžœ!žœ
˜H—šžœ
žœ,˜=Kš
œ+™+—Kšžœžœžœ˜CKšžœ
˜Kš
œ˜—K˜	Kš
ž˜—Kš
œ˜—Kš
ž˜Kš
œ˜—Kšžœ
˜—Kšžœ
˜K˜K˜—š
 œžœ
žœ#žœžœ˜pKšžœ
žœžœ
˜Kšœžœ
˜Kš
œ5˜5šžœ,žœž˜?šžœžœžœ"žœ˜gKš
œ(˜(Kš	žœžœ
žœžœŸ˜OKšœŸ*˜DK˜Kšžœ˜K˜—K˜	Kšžœ
˜—K˜K˜—š œžœ
žœB˜cKšžœ
žœžœ
˜Kš
œ5˜5šžœ,žœž˜?šžœ
žœ˜šœ	žœ
˜Kš
œ˜K˜K˜K˜K˜Kšžœ˜—Kšžœ
˜K˜—Kšžœ
˜—šœžœ
˜Kš
œ˜K˜K˜K˜K˜Kšžœ˜—K˜K˜—š
 œžœ
žœ?žœžœ˜Š
Kš
œ™Kšœžœ
˜Kšœ
žœ
˜Kšœ'žœ˜?Kšžœ
žœ
žœ
žœ˜*Kšœžœ˜!šœžœ%˜3š
œ™K™D——˜Kšœžœ˜Kšœžœ	žœ˜šœžœžœ
žœ
˜%Kšœžœ˜Kšœžœ™1—K˜—šžœ˜Kšžœ3˜7Kšžœ˜K˜—š
œ˜Kšœžœ
™0—Kšœžœ˜%šœžœ%˜3™K™"K™&——˜Kšœžœ˜K˜$šœžœžœ
žœ
˜%Kšœžœ˜Kšœžœ™1——˜K˜
Kšœžœ˜"K˜K˜—K˜K˜—š
 	œžœ
žœ!žœ
žœ˜TK˜$K˜K˜K˜š œž˜Kšœ.žœžœžœ˜MK˜šžœ
žœžœ˜6K˜IK˜+Kšžœžœ˜K˜—K˜—Kšžœžœ
žœ
žœ˜1K˜šœžœ
žœ˜-K˜?K˜.KšœŸ˜—K˜Kšœžœ˜$K˜3K˜—K˜š œžœ
žœžœžœžœ˜^Kš
œ˜K˜K˜š œžœ.žœžœ˜]Kš
œ˜šžœžœ˜*šžœ˜Kš
œI˜IK˜*Kšžœ
žœ˜—Kšžœ
žœ
žœ˜—Kš
œ˜—K˜/Kšœžœ*˜8Kšœ3žœžœ˜IK˜K˜K˜—š
 œžœ
žœžœ
žœ˜\Kš
œ˜Kšœ#Ÿ*˜MK˜$˜Kš
œ$™$Kš
œA™A—˜	K˜
K˜˜K˜
š
œ˜šœŸ(˜>Kšœžœ!˜'Kšœžœ
žœžœ˜F——K˜—Kšœžœ˜+K˜	—Kš
œ*™*KšœŸ>˜Y˜gK˜—šžœ˜šžœ˜Kš
œB™BKš
œ˜K˜K˜)˜*K˜D—šžœ
žœ
žœ˜Kšœžœžœ
˜˜˜ K˜'K˜——šœžœ
žœ ˜/˜Kšœžœ5˜?K˜—šžœ˜š
ž˜š
œ9™9Kš
œ™—šœžœ0žœžœ˜\Kšžœ#žœ
žœ
žœ˜8Kš
œ+˜+Kšžœ
žœ˜—K˜!K˜3Kšžœžœ
žœ
žœ
˜K˜
—šžœ˜Kš
œ&™&Kšœžœ-˜GKšœžœ-˜GK˜+K˜šžœ˜šžœ2˜6Kš
œ™—Kšžœ1˜5———KšœŸ˜—K˜K˜K˜uKšœŸ˜—KšœŸ˜K˜——Kšžœžœ
žœ"˜@K˜Kšœ0žœ˜KK˜KšœŸ˜K˜—š 
œžœ2žœ˜bK˜SK˜+šžœžœ
žœž˜'Kšžœžœžœ˜-Kšžœ
˜—š
œ˜K˜——š œžœ
žœ"˜BKš
œ™Kšœ"žœ(˜Ršžœ˜
Kšžœ˜šžœ˜Kš
œ˜Kš
œ-˜-KšœžœA˜OKš
œ˜—Kšžœ
žœ˜%—š
œ˜K˜——š
 œžœžœžœžœ˜[Kšœžœ$˜JKšœžœžœ
žœ˜$šœŸ,˜0K˜——Kš
œ?™?Kš
œ™Kš
œ™Kš
œ™Kš
œ!™!Kš
œ™Kš
œ™Kš
œ1™1Kš
œ™Kš
œ$™$Kš
œ0™0Kš
œ"™"Kš
œ#™#Kš
œ™Kš
œ™Kš
œ™Kš
œ™Kš
œ™˜Kš	œžœžœ8žœ
žœ˜[—š
Πbn
œžœžœžœ
žœ˜>šžœ
˜šœŸ=˜HK˜
šœŸL˜SšœŸ&˜1Kš
œ
˜
šœŸH˜OKšœžœ
žœžœ˜M—Kšœžœ
žœ
žœ
˜——K˜
—K˜—K˜K˜—š œžœ@žœ=˜ž
K˜ šœ	Ÿ˜K˜
š
œ˜šœ	Ÿ'˜0K˜
šœŸJ˜OšœŸ+˜6Kš
œ
˜
šœŸN˜Sš
œ˜Kš
œ
˜
Kšœžœ
žœžœ˜;Kš
œ
˜
——Kš
œ
˜
—Kšœžœ#˜)Kšœžœ)˜/—Kš
œ˜——Kšœžœ˜)K˜K˜—Kšžœ$˜*K˜K˜—š œžœ
žœ*žœ˜`š
œ6˜6Kš
œ#™#—šœžœ˜%šœžœ˜%Kšœžœ˜Kšœžœ˜$——Kšžœ
žœ˜+K˜—š œžœžœ˜XKš
œ8˜8Kšœžœ
˜KšžœAžœ˜^K˜K˜—š œžœ
žœžœ˜OKš
œ™Kšœžœ˜BK˜Kšžœžœžœ
žœ˜RK˜šœžœ
žœ˜!šžœ
ž˜šžœ
˜š
ž˜šœžœ
˜š
œ˜Kšœ žœ˜C—K˜——Kšžœ
žœ)˜3—Kšžœ
˜—KšœŸ˜—K˜šžœ;žœ	˜RK˜——š œžœ
žœžœ4˜tK˜K˜K˜šœžœ
žœ˜!˜˜Kš
œ&˜&Kšœžœ9˜F——K˜#K˜TK˜—K˜K˜K˜—Kš
œD™DKš
œ"™"Kš
œ™K˜Kš
œ!™!Kš
œ™K˜Kš
œ™Kš
œ™Kš
œ"™"Kš
œ&™&Kš
œ™Kš
œ&™&Kš
œ	™	Kš
œ™Kš
œ™Kš
œ™Kš
œ,™,Kš
œ?™?Kš
œ™K˜š œžœ
žœ˜=Kšžœžœ˜+K˜Kšœžœ˜ K˜šœžœ
žœ˜!˜	K˜
Kšœžœ˜@Kšœžœ˜#Kšœžœžœ
žœ
˜Kš
œ˜—KšœŸ˜—K˜š
œ˜K˜——š œžœ
žœ˜9Kšžœžœ˜%K˜Kšœžœ˜K˜šœžœ
žœ˜!˜	K˜
Kšœžœ˜>Kšœžœ˜Kšœžœžœ
žœ
˜Kš
œ˜—KšœŸ˜—K˜˜K˜——š
 œžœ
žœžœŸœ˜cK˜Kšžœžœ
žœ˜+K˜Kšœ)žœ˜BK˜K˜K˜—š œžœžœŸœ˜VKšœžœA˜UKšžœD˜JK˜K˜—š
 œžœ
žœžœŸœ˜bKš
œ˜K˜K˜5˜˜šžœžœ
ž˜Kšœ"žœ(˜PKšœ"žœ(˜PKšžœžœ
˜——Kšœžœ˜—K˜K˜—š
 œžœ
žœžœŸœ˜lKšœžœ
˜
K˜K˜K˜šœžœ,žœžœ˜Ošžœžœ
ž˜Kšœžœžœ˜LKšœžœžœ˜LKšžœžœ˜——šœžœ2žœžœ˜VKš
œ˜šžœ˜KšžœG˜Jšžœžœž˜#Kšœžœ
˜Kšžœžœ
˜—Kšžœžœ-˜JKšžœ;žœ
žœ˜LKšžœ
žœ
žœ˜——šœžœ2žœžœ˜VKš
œ˜šžœ˜KšžœG˜Jšžœžœž˜#Kšœžœ
˜Kšžœžœ
˜—Kšžœžœ-˜JKšžœ;žœ
žœ˜LKšžœ
žœ
žœ˜K˜——Kš
œ™K˜šžœ
žœžœ
Ÿ˜8Kšžœ
žœžœžœ
žœžœ
˜AKšžœ
žœžœžœ
žœžœ
˜BKšžœ
žœ
žœ
žœ˜K˜—K˜šœžœ
žœ˜!K˜ K˜AKšœBžœ˜R˜K˜šžœžœ
ž˜K˜;K˜;Kšžœžœ
˜—K˜Kšœžœ˜—K˜KšœŸ˜—K˜˜K˜——š œžœ
žœ7žœžœžœ˜‘
K˜'K˜šœžœ
žœ˜!K˜
š
œ%˜%Kšœžœ'žœ˜M—šœŸ ˜$˜˜"Kš
œ6˜6šœžœ˜'˜Kšžœ.˜6—K˜———Kšœ
žœ˜š
œ˜Kšœžœ'žœ˜MKš
œ&™&—K˜+šžœ;˜=Kšžœ
žœ
˜—šœŸ'˜+Kšœžœžœ5˜L˜˜"Kš
œ6˜6K˜——Kšžœžœ
žœ
˜˜K˜Kš
œ5˜5Kšœžœ'˜3Kš
œ˜Kš
œ2™2—š
œ˜Kšœžœ'žœ˜MKš
œ+™+—šžœ3˜5K˜*Kšžœ
žœ
˜—Kšžœžœ
žœŸ"˜IšœŸH˜Jšœžœ˜Kšœžœžœ˜:—šžœ
žœ
ž˜Kšœžœžœ˜8Kšžœž˜—KšœŸ!˜%—KšœŸ+˜/—KšœŸ$˜(—KšœŸ˜—K˜Kšžœ>žœ˜JKšœŸ˜—K˜š œžœžœ!˜IKšœžœ3žœ
žœ9˜ 
Kšžœžœ˜/Kš
œ˜K˜—š
Οbœ
žœ
žœ3žœ
žœ%˜ˆ
Kš
œ ˜ K˜'K˜šœžœ
žœ˜!˜
˜:šœžœ2˜IKšœž˜—Kš
œ˜——KšœŸ˜—K˜Kšžœžœ˜'š
œ˜K˜——š œžœ$žœ
žœ+˜}Kš
œ˜Kšœžœ
˜Kšœ
žœ+˜;Kšœ/žœžœžœ˜MK˜˜/Kš
œ&˜&Kšœžœ)˜6K˜—˜'˜Kš
œ&˜&Kšœžœ(˜5—K˜Kšœžœ˜—˜+K˜K˜
šœ	žœ"˜3Kšœžœ˜——Kšžœžœ˜1K˜—š œžœ
žœIžœ*˜“
šœ
 	œžœ
žœ˜+š	œ
 œžœžœžœ˜;šžœžœ
ž˜˜šžœ
žœ
ž˜Kšœžœ	žœžœ˜7Kšžœ
˜——Kšžœžœ
˜Kšžœ
žœ˜——š œžœžœžœ˜:šžœžœ
ž˜˜šžœ
žœ
ž˜Kšœžœ	žœžœ˜7Kšžœ
˜——Kšžœžœ
˜Kšžœ
žœ˜——K˜šžœžœ
ž˜K˜LK˜LKšžœžœ˜—K˜—Kš
œ™Kšœžœžœ
žœ˜ Kšœžœžœ
˜šžœžœž˜%K˜+Kšžœžœ
žœ
˜#Kšžœžœ
žœ
˜*K˜K˜Kšœžœ
˜Kšžœ
˜—Kšžœžœ
žœŸ˜:Kšžœ˜K˜—š
 œžœ
žœžœžœ˜GKš
œ˜K˜K˜&Kšžœžœ
žœ
žœ˜K˜/˜šžœžœ
ž˜˜Kšœžœ*˜B—˜Kšœžœ*˜B—Kšžœž˜—Kšœžœ˜—K˜Kšžœ˜
K˜—š œžœ
žœžœžœžœ˜PKšœžœ
˜
K˜K˜K˜šœžœ,žœžœ˜Ošžœžœ
ž˜Kšœžœžœ˜LKšœžœžœ˜LKšžœžœ˜——šœžœ2žœžœ˜VKš
œ˜šžœ˜KšžœG˜Jšžœžœž˜#Kšœžœ
˜Kšžœžœ
˜—Kšžœžœ-˜JKšžœ8žœ
žœ˜IKšžœ
žœ
žœ˜——šœžœ2žœžœ˜VKš
œ˜šžœ˜KšžœG˜Jšžœžœž˜#Kšœžœ
˜Kšžœžœ
˜—Kšžœžœ-˜JKšžœ8žœ
žœ˜IKšžœ
žœ
žœ˜K˜——šžœ
žœ
žœž˜'Kšžœžœžœ
žœ˜5Kšžœžœžœ
žœ˜8Kšœžœ
˜Kšžœ
žœžœžœ˜/Kšžœ
žœžœžœ˜1Kšžœ
˜K˜—K˜šœžœ
žœ˜!K˜K˜ K˜;Kšœ<žœ˜Lšœžœžœ
ž˜K˜;K˜;Kšžœžœ
˜—šžœ
žœ
žœž˜#Kšœ+žœ˜F—K˜KšœŸ˜—K˜š
œ˜K˜——š œ
žœ
žœžœ
žœžœ˜VK˜š
œA˜AKšœžœ˜—K˜˜K˜——š œžœ
žœžœ˜EK˜Kšœ4žœ˜PK˜˜K˜——š
 œžœ
žœžœ
žœ˜PK˜Kšœ8žœ˜TK˜˜K˜——š
’œ
žœ
žœ4žœ
žœ˜gKšœžœ
žœ
˜K˜šœ
žœ
žœ˜$Kšœ'žœ˜CK˜BKšœ"žœ ˜JKšœŸ˜—K˜K˜K˜—š
 
œžœ
žœ žœžœ˜QK˜š
œ>˜>Kšœžœ!˜)—K˜K˜K˜—š œžœ
žœ žœžœ
žœ˜XK˜š
œB˜BKšœžœ!˜)—K˜K˜K˜—š
 œžœ
žœ(žœ
žœ˜gK˜šœ
žœ
žœ ˜.Kšœžœ˜&˜	K˜K˜K˜Kšœžœ
žœ
žœ˜%—KšœŸ˜—K˜K˜K˜—š œžœ
žœŸœ
žœžœ0˜
Kšœžœžœ˜(K˜šžœžœ
ž˜˜šžœ˜šžœ-˜1K˜Ešœ
žœ4˜FKšžœ
žœ
žœ˜—šœžœ3˜GKšžœ
žœ˜!—Kšžœ
˜Kšžœ
žœ,˜6———˜šžœ˜šžœ˜K˜EK˜šœžœ
žœ˜!K˜*˜˜Kš
œ9˜9šœžœ
˜š
œ˜Kšœž	œ1˜A—K˜———˜K˜˜K˜
K˜D——šœ	ž˜˜˜K˜
K˜C——K˜—KšœŸ˜—K˜Kš
ž˜Kš
œ
˜
Kšžœ
žœ,˜6———Kšžœžœ-˜=K˜——š œžœžœžœ˜BKšžœ+˜1K˜—š œžœžœžœ˜7Kšžœ
žœžœ˜ K˜—Kšžœ
˜K˜K˜—…—}Ά°