-- Copyright (C) 1985 by Xerox Corporation. All rights reserved.
-- Stub file was translated on May 4, 1985 10:43:27 pm PDT by Lupine of March 15, 1985 2:49:13 pm PST
-- Source interface ComputeServerCallbacks came from file ComputeServerCallbacks.bcd, which was created on May 4, 1985 10:43:10 pm PDT with version stamp 317#56#35156063743 from source of May 4, 1985 10:42:35 pm PDT.
-- The RPC stub modules for ComputeServerCallbacks are:
-- ComputeServerCallbacksRpcControl.mesa;
-- ComputeServerCallbacksRpcClientImpl.mesa;
-- ComputeServerCallbacksRpcBinderImpl.mesa;
-- ComputeServerCallbacksRpcServerImpl.mesa.
-- The parameters for this translation are:
-- Target language = Cedar
-- Default parameter passing = VALUE
-- Deallocate server heap arguments = TRUE
-- Inline RpcServerImpl dispatcher stubs = FALSE
-- Declare signals = FALSE
-- Warn about short POINTER ("MDS") allocations = TRUE
-- Maximum number of dynamic heap NEWs = 50, MDS NEWs = 50
-- Acceptable parameter protocols = VersionRange[1..1].
DIRECTORY
BasicTime,
FS,
IO,
PupDefs,
Rope,
RPC,
ComputeServerCallbacks,
ComputeServerCallbacksRpcControl USING [InterfaceRecord, InterMdsCallsOnly,
LupineProtocolVersion, ProcedureIndex, SignalIndex],
RPCLupine --USING SOME OF [Alloc, Call, DataLength, DeAlloc, Dispatcher,
-- GetPkt, GetStubPkt, ImportHandle, ImportInterface, maxDataLength,
-- maxPrincipalLength, maxShortStringLength, pktOverhead, ReceiveExtraPkt,
-- SendPrelimPkt, StartCall, StartSignal, StubPkt, UnimportInterface]--,
LupineRuntime --USING SOME OF [BindingError, CheckPktLength, CopyFromPkt,
-- CopyFromMultiplePkts, CopyToPkt, CopyToMultiplePkts, defaultZones,
-- DispatchingError, FinishThisPkt, ListHeader, MarshalingError,
-- MarshalingExprError, MarshalAtom, MarshalRope, NilHeader, ProtocolError,
-- RopeHeader, RpcPktDoubleWord, RuntimeError, SequenceHeader, SHORT,
-- StartNextPkt, StringHeader, StubPktDoubleWord, TranslationError,
-- UnmarshalingError, UnmarshalingExprError, UnmarshalAtom, UnmarshalRope,
-- WordsForChars]--,
Atom --USING SOME OF [GetPName, MakeAtom]--,
PrincOpsUtils --USING SOME OF [Enter, Exit]--,
VM --USING SOME OF [AddressForPageNumber, PageCount, PageNumber,
-- PageNumberForAddress, PagesForWords]--;
ComputeServerCallbacksRpcClientImpl: MONITOR
IMPORTS ComputeServerCallbacks, RpcPrivate: RPCLupine, Lupine: LupineRuntime,
Atom, PrincOpsUtils, Rope
EXPORTS ComputeServerCallbacksRpcControl
SHARES ComputeServerCallbacks, ComputeServerCallbacksRpcControl,
Rope
= BEGIN OPEN ComputeServerCallbacks, RpcControl: ComputeServerCallbacksRpcControl,
RpcPublic: RPC;
-- Standard remote binding routines.
ImportInterface: PUBLIC ENTRY SAFE PROCEDURE [
interface: RpcControl.InterfaceRecord,
interfaceName: RpcPublic.InterfaceName,
parameterStorage: RpcPublic.Zones ] =
TRUSTED BEGIN ENABLE UNWIND => NULL;
IsNull: PROCEDURE [string: Rope.ROPE] RETURNS [BOOLEAN] =
INLINE {RETURN[string.Length[] = 0]};
IF interface.bound THEN Lupine.BindingError;
interface↑ ← [Error: Error, clientStubrSetDefaultWDir: clientStubrSetDefaultWDir,
clientStubrGetDefaultWDir: clientStubrGetDefaultWDir, clientStubrExpandName:
clientStubrExpandName, clientStubrFileInfo: clientStubrFileInfo,
clientStubrStartEnumerateForInfo: clientStubrStartEnumerateForInfo,
clientStubrNextEnumerateForInfo: clientStubrNextEnumerateForInfo,
clientStubrStartEnumerateForNames: clientStubrStartEnumerateForNames,
clientStubrNextEnumerateForNames: clientStubrNextEnumerateForNames,
clientStubrDoneEnumerate: clientStubrDoneEnumerate, clientStubrOpen:
clientStubrOpen, clientStubrCreate: clientStubrCreate, clientStubrOpenOrCreate:
clientStubrOpenOrCreate, clientStubrGetClass: clientStubrGetClass,
clientStubrSameFile: clientStubrSameFile, clientStubrGetName: clientStubrGetName,
clientStubrGetInfo: clientStubrGetInfo, clientStubrSetPageCount:
clientStubrSetPageCount, clientStubrSetByteCountAndCreatedTime:
clientStubrSetByteCountAndCreatedTime, clientStubrRead: clientStubrRead,
clientStubrWrite: clientStubrWrite, clientStubrClose: clientStubrClose,
clientStubrCopy: clientStubrCopy, clientStubrDelete: clientStubrDelete,
clientStubrRename: clientStubrRename, clientStubrSetKeep: clientStubrSetKeep];
interface.myInterface ← RpcPrivate.ImportInterface [
interface: [
type: IF ~IsNull[interfaceName.type]
THEN interfaceName.type ELSE "ComputeServerCallbacks~317#56#35156063743",
instance: interfaceName.instance,
version: interfaceName.version ],
localOnly: RpcControl.InterMdsCallsOnly,
stubProtocol: RpcControl.LupineProtocolVersion ];
interface.paramZones ← [
gc: IF parameterStorage.gc # NIL
THEN parameterStorage.gc ELSE Lupine.defaultZones.gc,
heap: IF parameterStorage.heap # NIL
THEN parameterStorage.heap ELSE Lupine.defaultZones.heap,
mds: IF parameterStorage.mds # NIL
THEN parameterStorage.mds ELSE Lupine.defaultZones.mds ];
interface.bound ← TRUE;
END;
-- Remote public procedure stubs.
clientStubrSetDefaultWDir: PUBLIC SAFE PROCEDURE [interface: RpcControl.InterfaceRecord,
dir: RPC.ShortROPE] =
TRUSTED BEGIN
ArgumentOverlay: TYPE = MACHINE DEPENDENT RECORD [
transferIndex (0): RpcControl.ProcedureIndex ← rSetDefaultWDir];
pkt: RpcPrivate.RPCPkt = RpcPrivate.GetPkt[space: RpcPrivate.Alloc[RpcPrivate.pktOverhead+35]];
argPkt: LONG POINTER TO ArgumentOverlay = @pkt.data[0];
pktLength: RpcPrivate.DataLength ← 1;
lastPkt: BOOLEAN;
BEGIN ENABLE UNWIND => RpcPrivate.DeAlloc[LOOPHOLE[pkt], RpcPrivate.pktOverhead+35];
RpcPrivate.StartCall[callPkt: pkt, interface: interface.myInterface];
argPkt.transferIndex ← rSetDefaultWDir;
BEGIN -- Marshal dir: RPC.ShortROPE to pkt.data[pktLength].
pktLength ← Lupine.MarshalRope[dir, pkt, pktLength, TRUE];
END; -- Marshal dir.
[returnLength: , lastPkt: lastPkt] ←
RpcPrivate.Call[ pkt: pkt, callLength: pktLength,
maxReturnLength: 0, signalHandler: ClientDispatcher];
Lupine.CheckPktLength[pkt: pkt, pktLength: 0];
RpcPrivate.DeAlloc[LOOPHOLE[pkt], RpcPrivate.pktOverhead+35];
RETURN[];
END; -- UNWIND.
END; -- rSetDefaultWDir.
clientStubrGetDefaultWDir: PUBLIC SAFE PROCEDURE [interface: RpcControl.InterfaceRecord]RETURNS
[anonP1id1822039: RPC.ShortROPE] =
TRUSTED BEGIN
ArgumentOverlay: TYPE = MACHINE DEPENDENT RECORD [
transferIndex (0): RpcControl.ProcedureIndex ← rGetDefaultWDir];
pkt: RpcPrivate.RPCPkt = RpcPrivate.GetPkt[space: RpcPrivate.Alloc[RpcPrivate.pktOverhead+34]];
argPkt: LONG POINTER TO ArgumentOverlay = @pkt.data[0];
pktLength: RpcPrivate.DataLength ← 1;
lastPkt: BOOLEAN;
BEGIN ENABLE UNWIND => RpcPrivate.DeAlloc[LOOPHOLE[pkt], RpcPrivate.pktOverhead+34];
RpcPrivate.StartCall[callPkt: pkt, interface: interface.myInterface];
argPkt.transferIndex ← rGetDefaultWDir;
[returnLength: , lastPkt: lastPkt] ←
RpcPrivate.Call[ pkt: pkt, callLength: pktLength,
maxReturnLength: 34, signalHandler: ClientDispatcher];
pktLength ← 0;
BEGIN -- Unmarshal anonP1id1822039: RPC.ShortROPE from pkt.data[pktLength].
[anonP1id1822039, pktLength] ← Lupine.UnmarshalRope[pkt, pktLength,
TRUE];
END; -- Unmarshal anonP1id1822039.
Lupine.CheckPktLength[pkt: pkt, pktLength: pktLength];
RpcPrivate.DeAlloc[LOOPHOLE[pkt], RpcPrivate.pktOverhead+34];
RETURN[anonP1id1822039];
END; -- UNWIND.
END; -- rGetDefaultWDir.
clientStubrExpandName: PUBLIC SAFE PROCEDURE [interface: RpcControl.InterfaceRecord,
name: ROPE, wDir: RPC.ShortROPE] RETURNS [fullFName: ROPE, cp: FS.ComponentPositions,
dirOmitted: BOOLEAN] =
TRUSTED BEGIN
ArgumentOverlay: TYPE = MACHINE DEPENDENT RECORD [
transferIndex (0): RpcControl.ProcedureIndex ← rExpandName];
ResultOverlay: TYPE = MACHINE DEPENDENT RECORD [
cp (0): FS.ComponentPositions, dirOmitted (12): BOOLEAN];
pkt: RpcPrivate.RPCPkt = RpcPrivate.GetPkt[space: RpcPrivate.Alloc[RpcPrivate.pktOverhead+254]];
argPkt: LONG POINTER TO ArgumentOverlay = @pkt.data[0];
resPkt: LONG POINTER TO ResultOverlay = @pkt.data[0];
pktLength: RpcPrivate.DataLength ← 1;
lastPkt: BOOLEAN;
BEGIN ENABLE UNWIND => RpcPrivate.DeAlloc[LOOPHOLE[pkt], RpcPrivate.pktOverhead+254];
RpcPrivate.StartCall[callPkt: pkt, interface: interface.myInterface];
argPkt.transferIndex ← rExpandName;
BEGIN -- Marshal name: ROPE to pkt.data[pktLength].
pktLength ← Lupine.MarshalRope[name, pkt, pktLength, FALSE];
END; -- Marshal name.
BEGIN -- Marshal wDir: RPC.ShortROPE to pkt.data[pktLength].
pktLength ← Lupine.MarshalRope[wDir, pkt, pktLength, TRUE];
END; -- Marshal wDir.
[returnLength: , lastPkt: lastPkt] ←
RpcPrivate.Call[ pkt: pkt, callLength: pktLength,
maxReturnLength: 254, signalHandler: ClientDispatcher];
pktLength ← 13;
BEGIN -- OnePkt.
-- Move statics from pkt now.
[cp: cp, dirOmitted: dirOmitted] ← resPkt↑;
BEGIN -- Unmarshal fullFName: ROPE from pkt.data[pktLength].
[fullFName, pktLength] ← Lupine.UnmarshalRope[pkt, pktLength,
FALSE];
END; -- Unmarshal fullFName.
Lupine.CheckPktLength[pkt: pkt, pktLength: pktLength];
RpcPrivate.DeAlloc[LOOPHOLE[pkt], RpcPrivate.pktOverhead+254];
RETURN[fullFName, cp, dirOmitted];
END; -- OnePkt.
END; -- UNWIND.
END; -- rExpandName.
clientStubrFileInfo: PUBLIC SAFE PROCEDURE [interface: RpcControl.InterfaceRecord,
name: ROPE, wantedCreatedTime: BasicTime.GMT, remoteCheck: BOOLEAN,
wDir: RPC.ShortROPE]
RETURNS [fullFName: ROPE, attachedTo: ROPE, keep: CARDINAL, bytes:
INT, created: BasicTime.GMT] =
TRUSTED BEGIN
ArgumentOverlay: TYPE = MACHINE DEPENDENT RECORD [
transferIndex (0): RpcControl.ProcedureIndex ← rFileInfo, wantedCreatedTime
(1): BasicTime.GMT, remoteCheck (3): BOOLEAN];
ResultOverlay: TYPE = MACHINE DEPENDENT RECORD [
keep (0): CARDINAL, bytes (1): INT, created (3): BasicTime.GMT];
pkt: RpcPrivate.RPCPkt = RpcPrivate.GetPkt[space: RpcPrivate.Alloc[RpcPrivate.pktOverhead+254]];
argPkt: LONG POINTER TO ArgumentOverlay = @pkt.data[0];
resPkt: LONG POINTER TO ResultOverlay = @pkt.data[0];
pktLength: RpcPrivate.DataLength ← 4;
lastPkt: BOOLEAN;
BEGIN ENABLE UNWIND => RpcPrivate.DeAlloc[LOOPHOLE[pkt], RpcPrivate.pktOverhead+254];
RpcPrivate.StartCall[callPkt: pkt, interface: interface.myInterface];
argPkt↑ ← [wantedCreatedTime: wantedCreatedTime, remoteCheck:
remoteCheck];
BEGIN -- Marshal name: ROPE to pkt.data[pktLength].
pktLength ← Lupine.MarshalRope[name, pkt, pktLength, FALSE];
END; -- Marshal name.
BEGIN -- Marshal wDir: RPC.ShortROPE to pkt.data[pktLength].
pktLength ← Lupine.MarshalRope[wDir, pkt, pktLength, TRUE];
END; -- Marshal wDir.
[returnLength: , lastPkt: lastPkt] ←
RpcPrivate.Call[ pkt: pkt, callLength: pktLength,
maxReturnLength: 254, signalHandler: ClientDispatcher];
pktLength ← 5;
BEGIN -- OnePkt.
-- Move statics from pkt now.
[keep: keep, bytes: bytes, created: created] ← resPkt↑;
BEGIN -- Unmarshal fullFName: ROPE from pkt.data[pktLength].
[fullFName, pktLength] ← Lupine.UnmarshalRope[pkt, pktLength,
FALSE];
END; -- Unmarshal fullFName.
BEGIN -- Unmarshal attachedTo: ROPE from pkt.data[pktLength].
[attachedTo, pktLength] ← Lupine.UnmarshalRope[pkt, pktLength,
FALSE];
END; -- Unmarshal attachedTo.
Lupine.CheckPktLength[pkt: pkt, pktLength: pktLength];
RpcPrivate.DeAlloc[LOOPHOLE[pkt], RpcPrivate.pktOverhead+254];
RETURN[fullFName, attachedTo, keep, bytes, created];
END; -- OnePkt.
END; -- UNWIND.
END; -- rFileInfo.
clientStubrStartEnumerateForInfo: PUBLIC SAFE PROCEDURE [interface:
RpcControl.InterfaceRecord, listenerPupAddress: PupDefs.PupAddress,
pattern: ROPE, wDir: RPC.ShortROPE]
RETURNS [fullFName: ROPE, attachedTo: ROPE, created: BasicTime.GMT,
bytes: INT, keep: CARDINAL, continue: BOOLEAN] =
TRUSTED BEGIN
ArgumentOverlay: TYPE = MACHINE DEPENDENT RECORD [
transferIndex (0): RpcControl.ProcedureIndex ← rStartEnumerateForInfo,
listenerPupAddress (1): PupDefs.PupAddress];
ResultOverlay: TYPE = MACHINE DEPENDENT RECORD [
created (0): BasicTime.GMT, bytes (2): INT, keep (4): CARDINAL,
continue (5): BOOLEAN];
pkt: RpcPrivate.RPCPkt = RpcPrivate.GetPkt[space: RpcPrivate.Alloc[RpcPrivate.pktOverhead+254]];
argPkt: LONG POINTER TO ArgumentOverlay = @pkt.data[0];
resPkt: LONG POINTER TO ResultOverlay = @pkt.data[0];
pktLength: RpcPrivate.DataLength ← 4;
lastPkt: BOOLEAN;
BEGIN ENABLE UNWIND => RpcPrivate.DeAlloc[LOOPHOLE[pkt], RpcPrivate.pktOverhead+254];
RpcPrivate.StartCall[callPkt: pkt, interface: interface.myInterface];
argPkt↑ ← [listenerPupAddress: listenerPupAddress];
BEGIN -- Marshal pattern: ROPE to pkt.data[pktLength].
pktLength ← Lupine.MarshalRope[pattern, pkt, pktLength, FALSE];
END; -- Marshal pattern.
BEGIN -- Marshal wDir: RPC.ShortROPE to pkt.data[pktLength].
pktLength ← Lupine.MarshalRope[wDir, pkt, pktLength, TRUE];
END; -- Marshal wDir.
[returnLength: , lastPkt: lastPkt] ←
RpcPrivate.Call[ pkt: pkt, callLength: pktLength,
maxReturnLength: 254, signalHandler: ClientDispatcher];
pktLength ← 6;
BEGIN -- OnePkt.
-- Move statics from pkt now.
[created: created, bytes: bytes, keep: keep, continue: continue]
← resPkt↑;
BEGIN -- Unmarshal fullFName: ROPE from pkt.data[pktLength].
[fullFName, pktLength] ← Lupine.UnmarshalRope[pkt, pktLength,
FALSE];
END; -- Unmarshal fullFName.
BEGIN -- Unmarshal attachedTo: ROPE from pkt.data[pktLength].
[attachedTo, pktLength] ← Lupine.UnmarshalRope[pkt, pktLength,
FALSE];
END; -- Unmarshal attachedTo.
Lupine.CheckPktLength[pkt: pkt, pktLength: pktLength];
RpcPrivate.DeAlloc[LOOPHOLE[pkt], RpcPrivate.pktOverhead+254];
RETURN[fullFName, attachedTo, created, bytes, keep, continue];
END; -- OnePkt.
END; -- UNWIND.
END; -- rStartEnumerateForInfo.
clientStubrNextEnumerateForInfo: PUBLIC SAFE PROCEDURE [interface:
RpcControl.InterfaceRecord, listenerPupAddress: PupDefs.PupAddress]
RETURNS [fullFName: ROPE, attachedTo: ROPE, created: BasicTime.GMT,
bytes: INT, keep: CARDINAL, continue: BOOLEAN] =
TRUSTED BEGIN
ArgumentOverlay: TYPE = MACHINE DEPENDENT RECORD [
transferIndex (0): RpcControl.ProcedureIndex ← rNextEnumerateForInfo,
listenerPupAddress (1): PupDefs.PupAddress];
ResultOverlay: TYPE = MACHINE DEPENDENT RECORD [
created (0): BasicTime.GMT, bytes (2): INT, keep (4): CARDINAL,
continue (5): BOOLEAN];
pkt: RpcPrivate.RPCPkt = RpcPrivate.GetPkt[space: RpcPrivate.Alloc[RpcPrivate.pktOverhead+254]];
argPkt: LONG POINTER TO ArgumentOverlay = @pkt.data[0];
resPkt: LONG POINTER TO ResultOverlay = @pkt.data[0];
pktLength: RpcPrivate.DataLength ← 4;
lastPkt: BOOLEAN;
BEGIN ENABLE UNWIND => RpcPrivate.DeAlloc[LOOPHOLE[pkt], RpcPrivate.pktOverhead+254];
RpcPrivate.StartCall[callPkt: pkt, interface: interface.myInterface];
argPkt↑ ← [listenerPupAddress: listenerPupAddress];
[returnLength: , lastPkt: lastPkt] ←
RpcPrivate.Call[ pkt: pkt, callLength: pktLength,
maxReturnLength: 254, signalHandler: ClientDispatcher];
pktLength ← 6;
BEGIN -- OnePkt.
-- Move statics from pkt now.
[created: created, bytes: bytes, keep: keep, continue: continue]
← resPkt↑;
BEGIN -- Unmarshal fullFName: ROPE from pkt.data[pktLength].
[fullFName, pktLength] ← Lupine.UnmarshalRope[pkt, pktLength,
FALSE];
END; -- Unmarshal fullFName.
BEGIN -- Unmarshal attachedTo: ROPE from pkt.data[pktLength].
[attachedTo, pktLength] ← Lupine.UnmarshalRope[pkt, pktLength,
FALSE];
END; -- Unmarshal attachedTo.
Lupine.CheckPktLength[pkt: pkt, pktLength: pktLength];
RpcPrivate.DeAlloc[LOOPHOLE[pkt], RpcPrivate.pktOverhead+254];
RETURN[fullFName, attachedTo, created, bytes, keep, continue];
END; -- OnePkt.
END; -- UNWIND.
END; -- rNextEnumerateForInfo.
clientStubrStartEnumerateForNames: PUBLIC SAFE PROCEDURE [interface:
RpcControl.InterfaceRecord, listenerPupAddress: PupDefs.PupAddress,
pattern: ROPE, wDir: RPC.ShortROPE]
RETURNS [fullFName: ROPE, continue: BOOLEAN] =
TRUSTED BEGIN
ArgumentOverlay: TYPE = MACHINE DEPENDENT RECORD [
transferIndex (0): RpcControl.ProcedureIndex ← rStartEnumerateForNames,
listenerPupAddress (1): PupDefs.PupAddress];
ResultOverlay: TYPE = MACHINE DEPENDENT RECORD [
continue (0): BOOLEAN];
pkt: RpcPrivate.RPCPkt = RpcPrivate.GetPkt[space: RpcPrivate.Alloc[RpcPrivate.pktOverhead+254]];
argPkt: LONG POINTER TO ArgumentOverlay = @pkt.data[0];
resPkt: LONG POINTER TO ResultOverlay = @pkt.data[0];
pktLength: RpcPrivate.DataLength ← 4;
lastPkt: BOOLEAN;
BEGIN ENABLE UNWIND => RpcPrivate.DeAlloc[LOOPHOLE[pkt], RpcPrivate.pktOverhead+254];
RpcPrivate.StartCall[callPkt: pkt, interface: interface.myInterface];
argPkt↑ ← [listenerPupAddress: listenerPupAddress];
BEGIN -- Marshal pattern: ROPE to pkt.data[pktLength].
pktLength ← Lupine.MarshalRope[pattern, pkt, pktLength, FALSE];
END; -- Marshal pattern.
BEGIN -- Marshal wDir: RPC.ShortROPE to pkt.data[pktLength].
pktLength ← Lupine.MarshalRope[wDir, pkt, pktLength, TRUE];
END; -- Marshal wDir.
[returnLength: , lastPkt: lastPkt] ←
RpcPrivate.Call[ pkt: pkt, callLength: pktLength,
maxReturnLength: 254, signalHandler: ClientDispatcher];
pktLength ← 1;
BEGIN -- OnePkt.
-- Move statics from pkt now.
[continue: continue] ← resPkt↑;
BEGIN -- Unmarshal fullFName: ROPE from pkt.data[pktLength].
[fullFName, pktLength] ← Lupine.UnmarshalRope[pkt, pktLength,
FALSE];
END; -- Unmarshal fullFName.
Lupine.CheckPktLength[pkt: pkt, pktLength: pktLength];
RpcPrivate.DeAlloc[LOOPHOLE[pkt], RpcPrivate.pktOverhead+254];
RETURN[fullFName, continue];
END; -- OnePkt.
END; -- UNWIND.
END; -- rStartEnumerateForNames.
clientStubrNextEnumerateForNames: PUBLIC SAFE PROCEDURE [interface:
RpcControl.InterfaceRecord, listenerPupAddress: PupDefs.PupAddress]
RETURNS [fullFName: ROPE, continue: BOOLEAN] =
TRUSTED BEGIN
ArgumentOverlay: TYPE = MACHINE DEPENDENT RECORD [
transferIndex (0): RpcControl.ProcedureIndex ← rNextEnumerateForNames,
listenerPupAddress (1): PupDefs.PupAddress];
ResultOverlay: TYPE = MACHINE DEPENDENT RECORD [
continue (0): BOOLEAN];
pkt: RpcPrivate.RPCPkt = RpcPrivate.GetPkt[space: RpcPrivate.Alloc[RpcPrivate.pktOverhead+254]];
argPkt: LONG POINTER TO ArgumentOverlay = @pkt.data[0];
resPkt: LONG POINTER TO ResultOverlay = @pkt.data[0];
pktLength: RpcPrivate.DataLength ← 4;
lastPkt: BOOLEAN;
BEGIN ENABLE UNWIND => RpcPrivate.DeAlloc[LOOPHOLE[pkt], RpcPrivate.pktOverhead+254];
RpcPrivate.StartCall[callPkt: pkt, interface: interface.myInterface];
argPkt↑ ← [listenerPupAddress: listenerPupAddress];
[returnLength: , lastPkt: lastPkt] ←
RpcPrivate.Call[ pkt: pkt, callLength: pktLength,
maxReturnLength: 254, signalHandler: ClientDispatcher];
pktLength ← 1;
BEGIN -- OnePkt.
-- Move statics from pkt now.
[continue: continue] ← resPkt↑;
BEGIN -- Unmarshal fullFName: ROPE from pkt.data[pktLength].
[fullFName, pktLength] ← Lupine.UnmarshalRope[pkt, pktLength,
FALSE];
END; -- Unmarshal fullFName.
Lupine.CheckPktLength[pkt: pkt, pktLength: pktLength];
RpcPrivate.DeAlloc[LOOPHOLE[pkt], RpcPrivate.pktOverhead+254];
RETURN[fullFName, continue];
END; -- OnePkt.
END; -- UNWIND.
END; -- rNextEnumerateForNames.
clientStubrDoneEnumerate: PUBLIC SAFE PROCEDURE [interface: RpcControl.InterfaceRecord,
listenerPupAddress: PupDefs.PupAddress] =
TRUSTED BEGIN
ArgumentOverlay: TYPE = MACHINE DEPENDENT RECORD [
transferIndex (0): RpcControl.ProcedureIndex ← rDoneEnumerate,
listenerPupAddress (1): PupDefs.PupAddress];
pktBuffer: ARRAY [1..RpcPrivate.pktOverhead+4] OF WORD;
pkt: RpcPrivate.StubPkt = RpcPrivate.GetStubPkt[space: @pktBuffer];
argPkt: LONG POINTER TO ArgumentOverlay = @pkt.data[0];
pktLength: RpcPrivate.DataLength ← 4;
lastPkt: BOOLEAN;
RpcPrivate.StartCall[callPkt: pkt, interface: interface.myInterface];
argPkt↑ ← [listenerPupAddress: listenerPupAddress];
[returnLength: , lastPkt: lastPkt] ←
RpcPrivate.Call[ pkt: pkt, callLength: pktLength,
maxReturnLength: 0, signalHandler: ClientDispatcher];
Lupine.CheckPktLength[pkt: pkt, pktLength: 0];
RETURN[];
END; -- rDoneEnumerate.
clientStubrOpen: PUBLIC SAFE PROCEDURE [interface: RpcControl.InterfaceRecord,
listenerPupAddress: PupDefs.PupAddress, name: ROPE, lock: FS.Lock,
wantedCreatedTime: BasicTime.GMT, remoteCheck: BOOLEAN, wDir: RPC.ShortROPE,
forceRemoteOpen: BOOL]
RETURNS [globalNameToOpen: ROPE, openFile: OpenFile] =
TRUSTED BEGIN
ArgumentOverlay: TYPE = MACHINE DEPENDENT RECORD [
transferIndex (0): RpcControl.ProcedureIndex ← rOpen, listenerPupAddress
(1): PupDefs.PupAddress, lock (4): FS.Lock, wantedCreatedTime (5):
BasicTime.GMT, remoteCheck (7): BOOLEAN, forceRemoteOpen (8): BOOL];
ResultOverlay: TYPE = MACHINE DEPENDENT RECORD [
openFile (0): OpenFile];
pkt: RpcPrivate.RPCPkt = RpcPrivate.GetPkt[space: RpcPrivate.Alloc[RpcPrivate.pktOverhead+254]];
argPkt: LONG POINTER TO ArgumentOverlay = @pkt.data[0];
resPkt: LONG POINTER TO ResultOverlay = @pkt.data[0];
pktLength: RpcPrivate.DataLength ← 9;
lastPkt: BOOLEAN;
BEGIN ENABLE UNWIND => RpcPrivate.DeAlloc[LOOPHOLE[pkt], RpcPrivate.pktOverhead+254];
RpcPrivate.StartCall[callPkt: pkt, interface: interface.myInterface];
argPkt↑ ← [listenerPupAddress: listenerPupAddress, lock: lock,
wantedCreatedTime: wantedCreatedTime, remoteCheck: remoteCheck,
forceRemoteOpen: forceRemoteOpen];
BEGIN -- Marshal name: ROPE to pkt.data[pktLength].
pktLength ← Lupine.MarshalRope[name, pkt, pktLength, FALSE];
END; -- Marshal name.
BEGIN -- Marshal wDir: RPC.ShortROPE to pkt.data[pktLength].
pktLength ← Lupine.MarshalRope[wDir, pkt, pktLength, TRUE];
END; -- Marshal wDir.
[returnLength: , lastPkt: lastPkt] ←
RpcPrivate.Call[ pkt: pkt, callLength: pktLength,
maxReturnLength: 254, signalHandler: ClientDispatcher];
pktLength ← 2;
BEGIN -- OnePkt.
-- Move statics from pkt now.
[openFile: openFile] ← resPkt↑;
BEGIN -- Unmarshal globalNameToOpen: ROPE from pkt.data[pktLength].
[globalNameToOpen, pktLength] ← Lupine.UnmarshalRope[pkt, pktLength,
FALSE];
END; -- Unmarshal globalNameToOpen.
Lupine.CheckPktLength[pkt: pkt, pktLength: pktLength];
RpcPrivate.DeAlloc[LOOPHOLE[pkt], RpcPrivate.pktOverhead+254];
RETURN[globalNameToOpen, openFile];
END; -- OnePkt.
END; -- UNWIND.
END; -- rOpen.
clientStubrCreate: PUBLIC SAFE PROCEDURE [interface: RpcControl.InterfaceRecord,
listenerPupAddress: PupDefs.PupAddress, name: ROPE, setPages: BOOLEAN,
pages: INT, setKeep: BOOLEAN, keep: CARDINAL, wDir: RPC.ShortROPE]
RETURNS [anonP1id1822397: OpenFile] =
TRUSTED BEGIN
ArgumentOverlay: TYPE = MACHINE DEPENDENT RECORD [
transferIndex (0): RpcControl.ProcedureIndex ← rCreate, listenerPupAddress
(1): PupDefs.PupAddress, setPages (4): BOOLEAN, pages (5): INT,
setKeep (7): BOOLEAN, keep (8): CARDINAL];
ResultOverlay: TYPE = MACHINE DEPENDENT RECORD [
anonP1id1822397 (0): OpenFile];
pkt: RpcPrivate.RPCPkt = RpcPrivate.GetPkt[space: RpcPrivate.Alloc[RpcPrivate.pktOverhead+254]];
argPkt: LONG POINTER TO ArgumentOverlay = @pkt.data[0];
resPkt: LONG POINTER TO ResultOverlay = @pkt.data[0];
pktLength: RpcPrivate.DataLength ← 9;
lastPkt: BOOLEAN;
BEGIN ENABLE UNWIND => RpcPrivate.DeAlloc[LOOPHOLE[pkt], RpcPrivate.pktOverhead+254];
RpcPrivate.StartCall[callPkt: pkt, interface: interface.myInterface];
argPkt↑ ← [listenerPupAddress: listenerPupAddress, setPages:
setPages, pages: pages, setKeep: setKeep, keep: keep];
BEGIN -- Marshal name: ROPE to pkt.data[pktLength].
pktLength ← Lupine.MarshalRope[name, pkt, pktLength, FALSE];
END; -- Marshal name.
BEGIN -- Marshal wDir: RPC.ShortROPE to pkt.data[pktLength].
pktLength ← Lupine.MarshalRope[wDir, pkt, pktLength, TRUE];
END; -- Marshal wDir.
[returnLength: , lastPkt: lastPkt] ←
RpcPrivate.Call[ pkt: pkt, callLength: pktLength,
maxReturnLength: 2, signalHandler: ClientDispatcher];
[anonP1id1822397: anonP1id1822397] ← resPkt↑;
Lupine.CheckPktLength[pkt: pkt, pktLength: 2];
RpcPrivate.DeAlloc[LOOPHOLE[pkt], RpcPrivate.pktOverhead+254];
RETURN[anonP1id1822397];
END; -- UNWIND.
END; -- rCreate.
clientStubrOpenOrCreate: PUBLIC SAFE PROCEDURE [interface: RpcControl.InterfaceRecord,
listenerPupAddress: PupDefs.PupAddress, name: ROPE, keep: CARDINAL,
pages: INT, wDir: RPC.ShortROPE]
RETURNS [anonP1id1822436: OpenFile] =
TRUSTED BEGIN
ArgumentOverlay: TYPE = MACHINE DEPENDENT RECORD [
transferIndex (0): RpcControl.ProcedureIndex ← rOpenOrCreate, listenerPupAddress
(1): PupDefs.PupAddress, keep (4): CARDINAL, pages (5): INT];
ResultOverlay: TYPE = MACHINE DEPENDENT RECORD [
anonP1id1822436 (0): OpenFile];
pkt: RpcPrivate.RPCPkt = RpcPrivate.GetPkt[space: RpcPrivate.Alloc[RpcPrivate.pktOverhead+254]];
argPkt: LONG POINTER TO ArgumentOverlay = @pkt.data[0];
resPkt: LONG POINTER TO ResultOverlay = @pkt.data[0];
pktLength: RpcPrivate.DataLength ← 7;
lastPkt: BOOLEAN;
BEGIN ENABLE UNWIND => RpcPrivate.DeAlloc[LOOPHOLE[pkt], RpcPrivate.pktOverhead+254];
RpcPrivate.StartCall[callPkt: pkt, interface: interface.myInterface];
argPkt↑ ← [listenerPupAddress: listenerPupAddress, keep: keep,
pages: pages];
BEGIN -- Marshal name: ROPE to pkt.data[pktLength].
pktLength ← Lupine.MarshalRope[name, pkt, pktLength, FALSE];
END; -- Marshal name.
BEGIN -- Marshal wDir: RPC.ShortROPE to pkt.data[pktLength].
pktLength ← Lupine.MarshalRope[wDir, pkt, pktLength, TRUE];
END; -- Marshal wDir.
[returnLength: , lastPkt: lastPkt] ←
RpcPrivate.Call[ pkt: pkt, callLength: pktLength,
maxReturnLength: 2, signalHandler: ClientDispatcher];
[anonP1id1822436: anonP1id1822436] ← resPkt↑;
Lupine.CheckPktLength[pkt: pkt, pktLength: 2];
RpcPrivate.DeAlloc[LOOPHOLE[pkt], RpcPrivate.pktOverhead+254];
RETURN[anonP1id1822436];
END; -- UNWIND.
END; -- rOpenOrCreate.
clientStubrGetClass: PUBLIC SAFE PROCEDURE [interface: RpcControl.InterfaceRecord,
listenerPupAddress: PupDefs.PupAddress, file: OpenFile] RETURNS [anonP1id1822460:
ATOM] =
TRUSTED BEGIN
ArgumentOverlay: TYPE = MACHINE DEPENDENT RECORD [
transferIndex (0): RpcControl.ProcedureIndex ← rGetClass, listenerPupAddress
(1): PupDefs.PupAddress, file (4): OpenFile];
pkt: RpcPrivate.RPCPkt = RpcPrivate.GetPkt[space: RpcPrivate.Alloc[RpcPrivate.pktOverhead+254]];
argPkt: LONG POINTER TO ArgumentOverlay = @pkt.data[0];
pktLength: RpcPrivate.DataLength ← 6;
lastPkt: BOOLEAN;
BEGIN ENABLE UNWIND => RpcPrivate.DeAlloc[LOOPHOLE[pkt], RpcPrivate.pktOverhead+254];
RpcPrivate.StartCall[callPkt: pkt, interface: interface.myInterface];
argPkt↑ ← [listenerPupAddress: listenerPupAddress, file: file];
[returnLength: , lastPkt: lastPkt] ←
RpcPrivate.Call[ pkt: pkt, callLength: pktLength,
maxReturnLength: 254, signalHandler: ClientDispatcher];
pktLength ← 0;
BEGIN -- Unmarshal anonP1id1822460: ATOM from pkt.data[pktLength].
[anonP1id1822460, pktLength] ← Lupine.UnmarshalAtom[pkt, pktLength];
END; -- Unmarshal anonP1id1822460.
Lupine.CheckPktLength[pkt: pkt, pktLength: pktLength];
RpcPrivate.DeAlloc[LOOPHOLE[pkt], RpcPrivate.pktOverhead+254];
RETURN[anonP1id1822460];
END; -- UNWIND.
END; -- rGetClass.
clientStubrSameFile: PUBLIC SAFE PROCEDURE [interface: RpcControl.InterfaceRecord,
listenerPupAddress: PupDefs.PupAddress, file1: OpenFile, file2: OpenFile]
RETURNS [anonP1id1822489: BOOLEAN] =
TRUSTED BEGIN
ArgumentOverlay: TYPE = MACHINE DEPENDENT RECORD [
transferIndex (0): RpcControl.ProcedureIndex ← rSameFile, listenerPupAddress
(1): PupDefs.PupAddress, file1 (4): OpenFile, file2 (6): OpenFile];
ResultOverlay: TYPE = MACHINE DEPENDENT RECORD [
anonP1id1822489 (0): BOOLEAN];
pktBuffer: ARRAY [1..RpcPrivate.pktOverhead+8] OF WORD;
pkt: RpcPrivate.StubPkt = RpcPrivate.GetStubPkt[space: @pktBuffer];
argPkt: LONG POINTER TO ArgumentOverlay = @pkt.data[0];
resPkt: LONG POINTER TO ResultOverlay = @pkt.data[0];
pktLength: RpcPrivate.DataLength ← 8;
lastPkt: BOOLEAN;
RpcPrivate.StartCall[callPkt: pkt, interface: interface.myInterface];
argPkt↑ ← [listenerPupAddress: listenerPupAddress, file1: file1,
file2: file2];
[returnLength: , lastPkt: lastPkt] ←
RpcPrivate.Call[ pkt: pkt, callLength: pktLength,
maxReturnLength: 1, signalHandler: ClientDispatcher];
[anonP1id1822489: anonP1id1822489] ← resPkt↑;
Lupine.CheckPktLength[pkt: pkt, pktLength: 1];
RETURN[anonP1id1822489];
END; -- rSameFile.
clientStubrGetName: PUBLIC SAFE PROCEDURE [interface: RpcControl.InterfaceRecord,
listenerPupAddress: PupDefs.PupAddress, file: OpenFile] RETURNS [fullFName:
ROPE, attachedTo: ROPE] =
TRUSTED BEGIN
ArgumentOverlay: TYPE = MACHINE DEPENDENT RECORD [
transferIndex (0): RpcControl.ProcedureIndex ← rGetName, listenerPupAddress
(1): PupDefs.PupAddress, file (4): OpenFile];
pkt: RpcPrivate.RPCPkt = RpcPrivate.GetPkt[space: RpcPrivate.Alloc[RpcPrivate.pktOverhead+254]];
argPkt: LONG POINTER TO ArgumentOverlay = @pkt.data[0];
pktLength: RpcPrivate.DataLength ← 6;
lastPkt: BOOLEAN;
BEGIN ENABLE UNWIND => RpcPrivate.DeAlloc[LOOPHOLE[pkt], RpcPrivate.pktOverhead+254];
RpcPrivate.StartCall[callPkt: pkt, interface: interface.myInterface];
argPkt↑ ← [listenerPupAddress: listenerPupAddress, file: file];
[returnLength: , lastPkt: lastPkt] ←
RpcPrivate.Call[ pkt: pkt, callLength: pktLength,
maxReturnLength: 254, signalHandler: ClientDispatcher];
pktLength ← 0;
BEGIN -- Unmarshal fullFName: ROPE from pkt.data[pktLength].
[fullFName, pktLength] ← Lupine.UnmarshalRope[pkt, pktLength,
FALSE];
END; -- Unmarshal fullFName.
BEGIN -- Unmarshal attachedTo: ROPE from pkt.data[pktLength].
[attachedTo, pktLength] ← Lupine.UnmarshalRope[pkt, pktLength,
FALSE];
END; -- Unmarshal attachedTo.
Lupine.CheckPktLength[pkt: pkt, pktLength: pktLength];
RpcPrivate.DeAlloc[LOOPHOLE[pkt], RpcPrivate.pktOverhead+254];
RETURN[fullFName, attachedTo];
END; -- UNWIND.
END; -- rGetName.
clientStubrGetInfo: PUBLIC SAFE PROCEDURE [interface: RpcControl.InterfaceRecord,
listenerPupAddress: PupDefs.PupAddress, file: OpenFile] RETURNS [keep:
CARDINAL, pages: INT, bytes: INT, created: BasicTime.GMT, lock: FS.Lock]
=
TRUSTED BEGIN
ArgumentOverlay: TYPE = MACHINE DEPENDENT RECORD [
transferIndex (0): RpcControl.ProcedureIndex ← rGetInfo, listenerPupAddress
(1): PupDefs.PupAddress, file (4): OpenFile];
ResultOverlay: TYPE = MACHINE DEPENDENT RECORD [
keep (0): CARDINAL, pages (1): INT, bytes (3): INT, created (5):
BasicTime.GMT, lock (7): FS.Lock];
pktBuffer: ARRAY [1..RpcPrivate.pktOverhead+8] OF WORD;
pkt: RpcPrivate.StubPkt = RpcPrivate.GetStubPkt[space: @pktBuffer];
argPkt: LONG POINTER TO ArgumentOverlay = @pkt.data[0];
resPkt: LONG POINTER TO ResultOverlay = @pkt.data[0];
pktLength: RpcPrivate.DataLength ← 6;
lastPkt: BOOLEAN;
RpcPrivate.StartCall[callPkt: pkt, interface: interface.myInterface];
argPkt↑ ← [listenerPupAddress: listenerPupAddress, file: file];
[returnLength: , lastPkt: lastPkt] ←
RpcPrivate.Call[ pkt: pkt, callLength: pktLength,
maxReturnLength: 8, signalHandler: ClientDispatcher];
[keep: keep, pages: pages, bytes: bytes, created: created, lock:
lock] ← resPkt↑;
Lupine.CheckPktLength[pkt: pkt, pktLength: 8];
RETURN[keep, pages, bytes, created, lock];
END; -- rGetInfo.
clientStubrSetPageCount: PUBLIC SAFE PROCEDURE [interface: RpcControl.InterfaceRecord,
listenerPupAddress: PupDefs.PupAddress, file: OpenFile, pages: INT]
=
TRUSTED BEGIN
ArgumentOverlay: TYPE = MACHINE DEPENDENT RECORD [
transferIndex (0): RpcControl.ProcedureIndex ← rSetPageCount, listenerPupAddress
(1): PupDefs.PupAddress, file (4): OpenFile, pages (6): INT];
pktBuffer: ARRAY [1..RpcPrivate.pktOverhead+8] OF WORD;
pkt: RpcPrivate.StubPkt = RpcPrivate.GetStubPkt[space: @pktBuffer];
argPkt: LONG POINTER TO ArgumentOverlay = @pkt.data[0];
pktLength: RpcPrivate.DataLength ← 8;
lastPkt: BOOLEAN;
RpcPrivate.StartCall[callPkt: pkt, interface: interface.myInterface];
argPkt↑ ← [listenerPupAddress: listenerPupAddress, file: file,
pages: pages];
[returnLength: , lastPkt: lastPkt] ←
RpcPrivate.Call[ pkt: pkt, callLength: pktLength,
maxReturnLength: 0, signalHandler: ClientDispatcher];
Lupine.CheckPktLength[pkt: pkt, pktLength: 0];
RETURN[];
END; -- rSetPageCount.
clientStubrSetByteCountAndCreatedTime: PUBLIC SAFE PROCEDURE [interface:
RpcControl.InterfaceRecord, listenerPupAddress: PupDefs.PupAddress,
file: OpenFile, bytes: INT, created: BasicTime.GMT] =
TRUSTED BEGIN
ArgumentOverlay: TYPE = MACHINE DEPENDENT RECORD [
transferIndex (0): RpcControl.ProcedureIndex ← rSetByteCountAndCreatedTime,
listenerPupAddress (1): PupDefs.PupAddress, file (4): OpenFile,
bytes (6): INT, created (8): BasicTime.GMT];
pktBuffer: ARRAY [1..RpcPrivate.pktOverhead+10] OF WORD;
pkt: RpcPrivate.StubPkt = RpcPrivate.GetStubPkt[space: @pktBuffer];
argPkt: LONG POINTER TO ArgumentOverlay = @pkt.data[0];
pktLength: RpcPrivate.DataLength ← 10;
lastPkt: BOOLEAN;
RpcPrivate.StartCall[callPkt: pkt, interface: interface.myInterface];
argPkt↑ ← [listenerPupAddress: listenerPupAddress, file: file,
bytes: bytes, created: created];
[returnLength: , lastPkt: lastPkt] ←
RpcPrivate.Call[ pkt: pkt, callLength: pktLength,
maxReturnLength: 0, signalHandler: ClientDispatcher];
Lupine.CheckPktLength[pkt: pkt, pktLength: 0];
RETURN[];
END; -- rSetByteCountAndCreatedTime.
clientStubrRead: PUBLIC SAFE PROCEDURE [interface: RpcControl.InterfaceRecord,
listenerPupAddress: PupDefs.PupAddress, file: OpenFile, from: INT,
nPages: INT, pageBuffer: RESULTPageBuffer] =
TRUSTED BEGIN
ArgumentOverlay: TYPE = MACHINE DEPENDENT RECORD [
transferIndex (0): RpcControl.ProcedureIndex ← rRead, listenerPupAddress
(1): PupDefs.PupAddress, file (4): OpenFile, from (6): INT, nPages
(8): INT];
pkt: RpcPrivate.RPCPkt = RpcPrivate.GetPkt[space: RpcPrivate.Alloc[RpcPrivate.pktOverhead+254]];
argPkt: LONG POINTER TO ArgumentOverlay = @pkt.data[0];
pktLength: RpcPrivate.DataLength ← 10;
lastPkt: BOOLEAN;
BEGIN ENABLE UNWIND => RpcPrivate.DeAlloc[LOOPHOLE[pkt], RpcPrivate.pktOverhead+254];
RpcPrivate.StartCall[callPkt: pkt, interface: interface.myInterface];
argPkt↑ ← [listenerPupAddress: listenerPupAddress, file: file,
from: from, nPages: nPages];
BEGIN -- Marshal pageBuffer: RESULTPageBuffer to pkt.data[pktLength].
Lupine.RpcPktDoubleWord[pkt, pktLength]↑ ← (IF BASE[pageBuffer]=NIL
THEN 0 ELSE LENGTH[pageBuffer]);
pktLength ← pktLength + 2;
IF BASE[pageBuffer] # NIL THEN
NULL; -- Call by result, send length only.
END; -- Marshal pageBuffer.
[returnLength: , lastPkt: lastPkt] ←
RpcPrivate.Call[ pkt: pkt, callLength: pktLength,
maxReturnLength: 254, signalHandler: ClientDispatcher];
pktLength ← 0;
BEGIN -- Unmarshal pageBuffer: RESULTPageBuffer from pkt.data[pktLength].
DescriptorType: TYPE = RECORD [SEQUENCE COMPUTED CARDINAL OF
WORD];
descLength: Lupine.SequenceHeader;
IF pktLength+2 > RpcPrivate.maxDataLength
THEN pktLength ← Lupine.FinishThisPkt[pkt: pkt, pktLength:
pktLength];
descLength ← Lupine.RpcPktDoubleWord[pkt, pktLength]↑;
pktLength ← pktLength + 2;
IF descLength # (IF BASE[pageBuffer]=NIL THEN 0 ELSE LENGTH[pageBuffer])
THEN Lupine.UnmarshalingError;
NULL; -- Call by var or result, use existing descriptor.
pktLength ← Lupine.CopyFromPkt[pkt: pkt, pktLength: pktLength,
dataAdr: BASE[pageBuffer], dataLength: SIZE[WORD]*LENGTH[pageBuffer],
alwaysOnePkt: FALSE];
END; -- Unmarshal pageBuffer.
Lupine.CheckPktLength[pkt: pkt, pktLength: pktLength];
RpcPrivate.DeAlloc[LOOPHOLE[pkt], RpcPrivate.pktOverhead+254];
RETURN[];
END; -- UNWIND.
END; -- rRead.
clientStubrWrite: PUBLIC SAFE PROCEDURE [interface: RpcControl.InterfaceRecord,
listenerPupAddress: PupDefs.PupAddress, file: OpenFile, to: INT,
nPages: INT, pageBuffer: VALUEPageBuffer] =
TRUSTED BEGIN
ArgumentOverlay: TYPE = MACHINE DEPENDENT RECORD [
transferIndex (0): RpcControl.ProcedureIndex ← rWrite, listenerPupAddress
(1): PupDefs.PupAddress, file (4): OpenFile, to (6): INT, nPages
(8): INT];
pkt: RpcPrivate.RPCPkt = RpcPrivate.GetPkt[space: RpcPrivate.Alloc[RpcPrivate.pktOverhead+254]];
argPkt: LONG POINTER TO ArgumentOverlay = @pkt.data[0];
pktLength: RpcPrivate.DataLength ← 10;
lastPkt: BOOLEAN;
BEGIN ENABLE UNWIND => RpcPrivate.DeAlloc[LOOPHOLE[pkt], RpcPrivate.pktOverhead+254];
RpcPrivate.StartCall[callPkt: pkt, interface: interface.myInterface];
argPkt↑ ← [listenerPupAddress: listenerPupAddress, file: file,
to: to, nPages: nPages];
BEGIN -- Marshal pageBuffer: VALUEPageBuffer to pkt.data[pktLength].
IF pktLength+2 > RpcPrivate.maxDataLength
THEN pktLength ← Lupine.StartNextPkt[pkt: pkt, pktLength:
pktLength];
Lupine.RpcPktDoubleWord[pkt, pktLength]↑ ← (IF BASE[pageBuffer]=NIL
THEN 0 ELSE LENGTH[pageBuffer]);
pktLength ← pktLength + 2;
IF BASE[pageBuffer] # NIL THEN
pktLength ← Lupine.CopyToPkt[pkt: pkt, pktLength: pktLength,
dataAdr: BASE[pageBuffer], dataLength: SIZE[WORD]*LENGTH[pageBuffer],
alwaysOnePkt: FALSE];
END; -- Marshal pageBuffer.
[returnLength: , lastPkt: lastPkt] ←
RpcPrivate.Call[ pkt: pkt, callLength: pktLength,
maxReturnLength: 0, signalHandler: ClientDispatcher];
Lupine.CheckPktLength[pkt: pkt, pktLength: 0];
RpcPrivate.DeAlloc[LOOPHOLE[pkt], RpcPrivate.pktOverhead+254];
RETURN[];
END; -- UNWIND.
END; -- rWrite.
clientStubrClose: PUBLIC SAFE PROCEDURE [interface: RpcControl.InterfaceRecord,
listenerPupAddress: PupDefs.PupAddress, file: OpenFile] =
TRUSTED BEGIN
ArgumentOverlay: TYPE = MACHINE DEPENDENT RECORD [
transferIndex (0): RpcControl.ProcedureIndex ← rClose, listenerPupAddress
(1): PupDefs.PupAddress, file (4): OpenFile];
pktBuffer: ARRAY [1..RpcPrivate.pktOverhead+6] OF WORD;
pkt: RpcPrivate.StubPkt = RpcPrivate.GetStubPkt[space: @pktBuffer];
argPkt: LONG POINTER TO ArgumentOverlay = @pkt.data[0];
pktLength: RpcPrivate.DataLength ← 6;
lastPkt: BOOLEAN;
RpcPrivate.StartCall[callPkt: pkt, interface: interface.myInterface];
argPkt↑ ← [listenerPupAddress: listenerPupAddress, file: file];
[returnLength: , lastPkt: lastPkt] ←
RpcPrivate.Call[ pkt: pkt, callLength: pktLength,
maxReturnLength: 0, signalHandler: ClientDispatcher];
Lupine.CheckPktLength[pkt: pkt, pktLength: 0];
RETURN[];
END; -- rClose.
clientStubrCopy: PUBLIC SAFE PROCEDURE [interface: RpcControl.InterfaceRecord,
listenerPupAddress: PupDefs.PupAddress, from: ROPE, to: ROPE, setKeep:
BOOLEAN, keep: CARDINAL, wantedCreatedTime: BasicTime.GMT, remoteCheck:
BOOLEAN, attach: BOOLEAN, wDir: RPC.ShortROPE]
RETURNS [toFName: ROPE] =
TRUSTED BEGIN
ArgumentOverlay: TYPE = MACHINE DEPENDENT RECORD [
transferIndex (0): RpcControl.ProcedureIndex ← rCopy, listenerPupAddress
(1): PupDefs.PupAddress, setKeep (4): BOOLEAN, keep (5): CARDINAL,
wantedCreatedTime (6): BasicTime.GMT, remoteCheck (8): BOOLEAN,
attach (9): BOOLEAN];
pkt: RpcPrivate.RPCPkt = RpcPrivate.GetPkt[space: RpcPrivate.Alloc[RpcPrivate.pktOverhead+254]];
argPkt: LONG POINTER TO ArgumentOverlay = @pkt.data[0];
pktLength: RpcPrivate.DataLength ← 10;
lastPkt: BOOLEAN;
BEGIN ENABLE UNWIND => RpcPrivate.DeAlloc[LOOPHOLE[pkt], RpcPrivate.pktOverhead+254];
RpcPrivate.StartCall[callPkt: pkt, interface: interface.myInterface];
argPkt↑ ← [listenerPupAddress: listenerPupAddress, setKeep: setKeep,
keep: keep, wantedCreatedTime: wantedCreatedTime, remoteCheck:
remoteCheck, attach: attach];
BEGIN -- Marshal from: ROPE to pkt.data[pktLength].
pktLength ← Lupine.MarshalRope[from, pkt, pktLength, FALSE];
END; -- Marshal from.
BEGIN -- Marshal to: ROPE to pkt.data[pktLength].
pktLength ← Lupine.MarshalRope[to, pkt, pktLength, FALSE];
END; -- Marshal to.
BEGIN -- Marshal wDir: RPC.ShortROPE to pkt.data[pktLength].
pktLength ← Lupine.MarshalRope[wDir, pkt, pktLength, TRUE];
END; -- Marshal wDir.
[returnLength: , lastPkt: lastPkt] ←
RpcPrivate.Call[ pkt: pkt, callLength: pktLength,
maxReturnLength: 254, signalHandler: ClientDispatcher];
pktLength ← 0;
BEGIN -- Unmarshal toFName: ROPE from pkt.data[pktLength].
[toFName, pktLength] ← Lupine.UnmarshalRope[pkt, pktLength,
FALSE];
END; -- Unmarshal toFName.
Lupine.CheckPktLength[pkt: pkt, pktLength: pktLength];
RpcPrivate.DeAlloc[LOOPHOLE[pkt], RpcPrivate.pktOverhead+254];
RETURN[toFName];
END; -- UNWIND.
END; -- rCopy.
clientStubrDelete: PUBLIC SAFE PROCEDURE [interface: RpcControl.InterfaceRecord,
listenerPupAddress: PupDefs.PupAddress, name: ROPE, wantedCreatedTime:
BasicTime.GMT, wDir: RPC.ShortROPE] =
TRUSTED BEGIN
ArgumentOverlay: TYPE = MACHINE DEPENDENT RECORD [
transferIndex (0): RpcControl.ProcedureIndex ← rDelete, listenerPupAddress
(1): PupDefs.PupAddress, wantedCreatedTime (4): BasicTime.GMT];
pkt: RpcPrivate.RPCPkt = RpcPrivate.GetPkt[space: RpcPrivate.Alloc[RpcPrivate.pktOverhead+254]];
argPkt: LONG POINTER TO ArgumentOverlay = @pkt.data[0];
pktLength: RpcPrivate.DataLength ← 6;
lastPkt: BOOLEAN;
BEGIN ENABLE UNWIND => RpcPrivate.DeAlloc[LOOPHOLE[pkt], RpcPrivate.pktOverhead+254];
RpcPrivate.StartCall[callPkt: pkt, interface: interface.myInterface];
argPkt↑ ← [listenerPupAddress: listenerPupAddress, wantedCreatedTime:
wantedCreatedTime];
BEGIN -- Marshal name: ROPE to pkt.data[pktLength].
pktLength ← Lupine.MarshalRope[name, pkt, pktLength, FALSE];
END; -- Marshal name.
BEGIN -- Marshal wDir: RPC.ShortROPE to pkt.data[pktLength].
pktLength ← Lupine.MarshalRope[wDir, pkt, pktLength, TRUE];
END; -- Marshal wDir.
[returnLength: , lastPkt: lastPkt] ←
RpcPrivate.Call[ pkt: pkt, callLength: pktLength,
maxReturnLength: 0, signalHandler: ClientDispatcher];
Lupine.CheckPktLength[pkt: pkt, pktLength: 0];
RpcPrivate.DeAlloc[LOOPHOLE[pkt], RpcPrivate.pktOverhead+254];
RETURN[];
END; -- UNWIND.
END; -- rDelete.
clientStubrRename: PUBLIC SAFE PROCEDURE [interface: RpcControl.InterfaceRecord,
listenerPupAddress: PupDefs.PupAddress, from: ROPE, to: ROPE, setKeep:
BOOLEAN, keep: CARDINAL, wantedCreatedTime: BasicTime.GMT, wDir:
RPC.ShortROPE] =
TRUSTED BEGIN
ArgumentOverlay: TYPE = MACHINE DEPENDENT RECORD [
transferIndex (0): RpcControl.ProcedureIndex ← rRename, listenerPupAddress
(1): PupDefs.PupAddress, setKeep (4): BOOLEAN, keep (5): CARDINAL,
wantedCreatedTime (6): BasicTime.GMT];
pkt: RpcPrivate.RPCPkt = RpcPrivate.GetPkt[space: RpcPrivate.Alloc[RpcPrivate.pktOverhead+254]];
argPkt: LONG POINTER TO ArgumentOverlay = @pkt.data[0];
pktLength: RpcPrivate.DataLength ← 8;
lastPkt: BOOLEAN;
BEGIN ENABLE UNWIND => RpcPrivate.DeAlloc[LOOPHOLE[pkt], RpcPrivate.pktOverhead+254];
RpcPrivate.StartCall[callPkt: pkt, interface: interface.myInterface];
argPkt↑ ← [listenerPupAddress: listenerPupAddress, setKeep: setKeep,
keep: keep, wantedCreatedTime: wantedCreatedTime];
BEGIN -- Marshal from: ROPE to pkt.data[pktLength].
pktLength ← Lupine.MarshalRope[from, pkt, pktLength, FALSE];
END; -- Marshal from.
BEGIN -- Marshal to: ROPE to pkt.data[pktLength].
pktLength ← Lupine.MarshalRope[to, pkt, pktLength, FALSE];
END; -- Marshal to.
BEGIN -- Marshal wDir: RPC.ShortROPE to pkt.data[pktLength].
pktLength ← Lupine.MarshalRope[wDir, pkt, pktLength, TRUE];
END; -- Marshal wDir.
[returnLength: , lastPkt: lastPkt] ←
RpcPrivate.Call[ pkt: pkt, callLength: pktLength,
maxReturnLength: 0, signalHandler: ClientDispatcher];
Lupine.CheckPktLength[pkt: pkt, pktLength: 0];
RpcPrivate.DeAlloc[LOOPHOLE[pkt], RpcPrivate.pktOverhead+254];
RETURN[];
END; -- UNWIND.
END; -- rRename.
clientStubrSetKeep: PUBLIC SAFE PROCEDURE [interface: RpcControl.InterfaceRecord,
listenerPupAddress: PupDefs.PupAddress, name: ROPE, keep: CARDINAL,
wDir: RPC.ShortROPE] =
TRUSTED BEGIN
ArgumentOverlay: TYPE = MACHINE DEPENDENT RECORD [
transferIndex (0): RpcControl.ProcedureIndex ← rSetKeep, listenerPupAddress
(1): PupDefs.PupAddress, keep (4): CARDINAL];
pkt: RpcPrivate.RPCPkt = RpcPrivate.GetPkt[space: RpcPrivate.Alloc[RpcPrivate.pktOverhead+254]];
argPkt: LONG POINTER TO ArgumentOverlay = @pkt.data[0];
pktLength: RpcPrivate.DataLength ← 5;
lastPkt: BOOLEAN;
BEGIN ENABLE UNWIND => RpcPrivate.DeAlloc[LOOPHOLE[pkt], RpcPrivate.pktOverhead+254];
RpcPrivate.StartCall[callPkt: pkt, interface: interface.myInterface];
argPkt↑ ← [listenerPupAddress: listenerPupAddress, keep: keep];
BEGIN -- Marshal name: ROPE to pkt.data[pktLength].
pktLength ← Lupine.MarshalRope[name, pkt, pktLength, FALSE];
END; -- Marshal name.
BEGIN -- Marshal wDir: RPC.ShortROPE to pkt.data[pktLength].
pktLength ← Lupine.MarshalRope[wDir, pkt, pktLength, TRUE];
END; -- Marshal wDir.
[returnLength: , lastPkt: lastPkt] ←
RpcPrivate.Call[ pkt: pkt, callLength: pktLength,
maxReturnLength: 0, signalHandler: ClientDispatcher];
Lupine.CheckPktLength[pkt: pkt, pktLength: 0];
RpcPrivate.DeAlloc[LOOPHOLE[pkt], RpcPrivate.pktOverhead+254];
RETURN[];
END; -- UNWIND.
END; -- rSetKeep.
--Remote public signals and errors are imported from the interface.
-- Public signal and error dispatcher.
ClientDispatcher: --PROCEDURE [pkt: RPCPkt, callLength: DataLength,
-- lastPkt: BOOLEAN, localConversation: Conversation] RETURNS [returnLength:
-- DataLength]-- RpcPrivate.Dispatcher =
BEGIN
SELECT LOOPHOLE[pkt.data[0], RpcControl.SignalIndex] FROM
Error => RETURN[
ErrorStub[pkt: pkt, callLength: callLength, lastPkt: lastPkt,
localConversation: localConversation]];
ENDCASE => RETURN[Lupine.DispatchingError[]];
END; -- ClientDispatcher
-- Public signal and error dispatcher stubs.
ErrorStub: --ERROR [error: FS.ErrorDesc]-- RpcPrivate.Dispatcher
=
INLINE BEGIN
error: FS.ErrorDesc;
pktLength: RpcPrivate.DataLength ← 1;
BEGIN -- Unmarshal error: FS.ErrorDesc from pkt.data[pktLength].
pktLength ← Lupine.CopyFromPkt[pkt: pkt, pktLength: pktLength,
dataAdr: @error, dataLength: SIZE[FS.ErrorDesc], alwaysOnePkt:
FALSE];
-- Restore garbled REFs to NIL following copy.
BEGIN OPEN record: error;
LOOPHOLE[record.code, LONG POINTER] ← NIL;
LOOPHOLE[record.explanation, LONG POINTER] ← NIL;
END; -- OPEN record: error.
BEGIN OPEN record: error;
BEGIN -- Unmarshal record.code: ATOM from pkt.data[pktLength].
[record.code, pktLength] ← Lupine.UnmarshalAtom[pkt, pktLength];
END; -- Unmarshal record.code.
BEGIN -- Unmarshal record.explanation: ROPE from pkt.data[pktLength].
[record.explanation, pktLength] ← Lupine.UnmarshalRope[pkt,
pktLength, FALSE];
END; -- Unmarshal record.explanation.
END; -- OPEN record: error.
END; -- Unmarshal error.
Lupine.CheckPktLength[pkt: pkt, pktLength: pktLength];
ERROR Error[error];
END; -- ErrorStub.
-- Marshall/Unmarshal procedures.
-- No module initialization.
END. -- ComputeServerCallbacksRpcClientImpl.