-- Copyright (C) 1986 by Xerox Corporation. All rights reserved.
-- Stub file was translated on April 18, 1986 12:26:10 pm PST by Lupine of May 23, 1985 8:38:08 am PDT
-- Source interface ComputeServerCallbacks came from file ComputeServerCallbacks.bcd, which was created on April 18, 1986 12:25:46 pm PST with version stamp 30#377#27632646066 from source of April 18, 1986 12:25:33 pm PST.
-- 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,
Pup,
Rope,
RPC,
UserCredentials,
ComputeServerCallbacks,
ComputeServerCallbacksRpcControl USING [InterMdsCallsOnly, LupineProtocolVersion,
ProcedureIndex, SignalIndex],
RPCLupine --USING SOME OF [Call, DataLength, Dispatcher, ExportHandle,
-- ExportInterface, GetStubPkt, maxDataLength, maxPrincipalLength,
-- maxShortStringLength, pktOverhead, ReceiveExtraPkt, SendPrelimPkt,
-- StartCall, StartSignal, StubPkt, UnexportInterface]--,
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]--;
ComputeServerCallbacksRpcServerImpl: MONITOR
IMPORTS ComputeServerCallbacks, RpcPrivate: RPCLupine, Lupine: LupineRuntime,
Atom, Rope
EXPORTS ComputeServerCallbacksRpcControl
SHARES ComputeServerCallbacks, ComputeServerCallbacksRpcControl,
Rope
= BEGIN OPEN ComputeServerCallbacks, RpcControl: ComputeServerCallbacksRpcControl,
RpcPublic: RPC;
-- Standard remote binding routines.
bound: BOOLEAN ← FALSE;
myInterface: RpcPrivate.ExportHandle;
paramZones: RpcPublic.Zones ← RpcPublic.standardZones;
ExportInterface: PUBLIC ENTRY SAFE PROCEDURE [
interfaceName: RpcPublic.InterfaceName,
user: RpcPublic.Principal,
password: RpcPublic.EncryptionKey,
parameterStorage: RpcPublic.Zones ] =
TRUSTED BEGIN ENABLE UNWIND => NULL;
IsNull: PROCEDURE [string: Rope.ROPE] RETURNS [BOOLEAN] =
INLINE {RETURN[string.Length[] = 0]};
IF bound THEN Lupine.BindingError;
myInterface ← RpcPrivate.ExportInterface [
interface: [
type: IF ~IsNull[interfaceName.type]
THEN interfaceName.type ELSE "ComputeServerCallbacks~30#377#27632646066",
instance: interfaceName.instance,
version: interfaceName.version ],
user: user, password: password,
dispatcher: ServerDispatcher,
localOnly: RpcControl.InterMdsCallsOnly,
stubProtocol: RpcControl.LupineProtocolVersion ];
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 ];
bound ← TRUE;
END;
UnexportInterface: PUBLIC ENTRY SAFE PROCEDURE =
TRUSTED BEGIN ENABLE UNWIND => NULL;
IF ~bound THEN Lupine.BindingError;
myInterface ← RpcPrivate.UnexportInterface[myInterface];
paramZones ← RpcPublic.standardZones;
bound ← FALSE;
END;
-- Public procedure dispatcher and public signal and error catcher.
ServerDispatcher: --PROCEDURE [pkt: RPCPkt, callLength: DataLength,
-- lastPkt: BOOLEAN, localConversation: Conversation] RETURNS [returnLength:
-- DataLength]-- RpcPrivate.Dispatcher =
BEGIN
-- Catch public signals.
ENABLE BEGIN
Error --ERROR [error: FS.ErrorDesc]-- =>
BEGIN
ArgumentOverlay: TYPE = MACHINE DEPENDENT RECORD [
transferIndex (0): RpcControl.SignalIndex ← Error];
argPkt: LONG POINTER TO ArgumentOverlay = @pkt.data[0];
pktLength: RpcPrivate.DataLength ← 1;
lastPkt: BOOLEAN;
RpcPrivate.StartSignal[signalPkt: pkt];
argPkt.transferIndex ← Error;
BEGIN -- Marshal error: FS.ErrorDesc to pkt.data[pktLength].
pktLength ← Lupine.CopyToPkt[pkt: pkt, pktLength: pktLength,
dataAdr: @error, dataLength: SIZE[FS.ErrorDesc], alwaysOnePkt:
FALSE];
BEGIN OPEN record: error;
BEGIN -- Marshal record.code: ATOM to pkt.data[pktLength].
pktLength ← Lupine.MarshalAtom[record.code, pkt, pktLength];
END; -- Marshal record.code.
BEGIN -- Marshal record.explanation: ROPE to pkt.data[pktLength].
pktLength ← Lupine.MarshalRope[record.explanation, pkt,
pktLength, FALSE];
END; -- Marshal record.explanation.
END; -- OPEN record: error.
END; -- Marshal error.
[returnLength: , lastPkt: lastPkt] ←
RpcPrivate.Call[ pkt: pkt, callLength: pktLength,
maxReturnLength: 0];
Lupine.RuntimeError; -- Impossible to RESUME an ERROR.
END; -- Error.
END; -- Catch public signals.
-- Call public procedures (still in dispatcher).
SELECT LOOPHOLE[pkt.data[0], RpcControl.ProcedureIndex] FROM
rGeneric => RETURN[
rGenericStub[pkt: pkt, callLength: callLength, lastPkt: lastPkt,
localConversation: localConversation]];
rSetDefaultWDir => RETURN[
rSetDefaultWDirStub[pkt: pkt, callLength: callLength, lastPkt:
lastPkt, localConversation: localConversation]];
rGetDefaultWDir => RETURN[
rGetDefaultWDirStub[pkt: pkt, callLength: callLength, lastPkt:
lastPkt, localConversation: localConversation]];
rExpandName => RETURN[
rExpandNameStub[pkt: pkt, callLength: callLength, lastPkt:
lastPkt, localConversation: localConversation]];
rFileInfo => RETURN[
rFileInfoStub[pkt: pkt, callLength: callLength, lastPkt: lastPkt,
localConversation: localConversation]];
rStartEnumerateForInfo => RETURN[
rStartEnumerateForInfoStub[pkt: pkt, callLength: callLength,
lastPkt: lastPkt, localConversation: localConversation]];
rNextEnumerateForInfo => RETURN[
rNextEnumerateForInfoStub[pkt: pkt, callLength: callLength,
lastPkt: lastPkt, localConversation: localConversation]];
rStartEnumerateForNames => RETURN[
rStartEnumerateForNamesStub[pkt: pkt, callLength: callLength,
lastPkt: lastPkt, localConversation: localConversation]];
rNextEnumerateForNames => RETURN[
rNextEnumerateForNamesStub[pkt: pkt, callLength: callLength,
lastPkt: lastPkt, localConversation: localConversation]];
rDoneEnumerate => RETURN[
rDoneEnumerateStub[pkt: pkt, callLength: callLength, lastPkt:
lastPkt, localConversation: localConversation]];
rOpen => RETURN[
rOpenStub[pkt: pkt, callLength: callLength, lastPkt: lastPkt,
localConversation: localConversation]];
rCreate => RETURN[
rCreateStub[pkt: pkt, callLength: callLength, lastPkt: lastPkt,
localConversation: localConversation]];
rOpenOrCreate => RETURN[
rOpenOrCreateStub[pkt: pkt, callLength: callLength, lastPkt:
lastPkt, localConversation: localConversation]];
rGetClass => RETURN[
rGetClassStub[pkt: pkt, callLength: callLength, lastPkt: lastPkt,
localConversation: localConversation]];
rSameFile => RETURN[
rSameFileStub[pkt: pkt, callLength: callLength, lastPkt: lastPkt,
localConversation: localConversation]];
rGetName => RETURN[
rGetNameStub[pkt: pkt, callLength: callLength, lastPkt: lastPkt,
localConversation: localConversation]];
rGetInfo => RETURN[
rGetInfoStub[pkt: pkt, callLength: callLength, lastPkt: lastPkt,
localConversation: localConversation]];
rSetPageCount => RETURN[
rSetPageCountStub[pkt: pkt, callLength: callLength, lastPkt:
lastPkt, localConversation: localConversation]];
rSetByteCountAndCreatedTime => RETURN[
rSetByteCountAndCreatedTimeStub[pkt: pkt, callLength: callLength,
lastPkt: lastPkt, localConversation: localConversation]];
rRead => RETURN[
rReadStub[pkt: pkt, callLength: callLength, lastPkt: lastPkt,
localConversation: localConversation]];
rWrite => RETURN[
rWriteStub[pkt: pkt, callLength: callLength, lastPkt: lastPkt,
localConversation: localConversation]];
rClose => RETURN[
rCloseStub[pkt: pkt, callLength: callLength, lastPkt: lastPkt,
localConversation: localConversation]];
rCopy => RETURN[
rCopyStub[pkt: pkt, callLength: callLength, lastPkt: lastPkt,
localConversation: localConversation]];
rDelete => RETURN[
rDeleteStub[pkt: pkt, callLength: callLength, lastPkt: lastPkt,
localConversation: localConversation]];
rRename => RETURN[
rRenameStub[pkt: pkt, callLength: callLength, lastPkt: lastPkt,
localConversation: localConversation]];
rSetKeep => RETURN[
rSetKeepStub[pkt: pkt, callLength: callLength, lastPkt: lastPkt,
localConversation: localConversation]];
rBoolean => RETURN[
rBooleanStub[pkt: pkt, callLength: callLength, lastPkt: lastPkt,
localConversation: localConversation]];
rNumber => RETURN[
rNumberStub[pkt: pkt, callLength: callLength, lastPkt: lastPkt,
localConversation: localConversation]];
rToken => RETURN[
rTokenStub[pkt: pkt, callLength: callLength, lastPkt: lastPkt,
localConversation: localConversation]];
rListOfTokens => RETURN[
rListOfTokensStub[pkt: pkt, callLength: callLength, lastPkt:
lastPkt, localConversation: localConversation]];
rLine => RETURN[
rLineStub[pkt: pkt, callLength: callLength, lastPkt: lastPkt,
localConversation: localConversation]];
rGetProfileName => RETURN[
rGetProfileNameStub[pkt: pkt, callLength: callLength, lastPkt:
lastPkt, localConversation: localConversation]];
rGetState => RETURN[
rGetStateStub[pkt: pkt, callLength: callLength, lastPkt: lastPkt,
localConversation: localConversation]];
rGet => RETURN[
rGetStub[pkt: pkt, callLength: callLength, lastPkt: lastPkt,
localConversation: localConversation]];
OpenDebugStream => RETURN[
OpenDebugStreamStub[pkt: pkt, callLength: callLength, lastPkt:
lastPkt, localConversation: localConversation]];
OpenSourceViewer => RETURN[
OpenSourceViewerStub[pkt: pkt, callLength: callLength, lastPkt:
lastPkt, localConversation: localConversation]];
ENDCASE => RETURN[Lupine.DispatchingError[]];
END; -- ServerDispatcher
-- Public procedure dispatcher stubs.
rGenericStub: --PROCEDURE [requestCode: ATOM, requestString: ROPE]
-- RETURNS [resultCode: ATOM, resultString: ROPE]-- RpcPrivate.Dispatcher
=
BEGIN
requestCode: ATOM;
requestString: ROPE;
resultCode: ATOM;
resultString: ROPE;
pktLength: RpcPrivate.DataLength ← 1;
BEGIN -- Unmarshal requestCode: ATOM from pkt.data[pktLength].
[requestCode, pktLength] ← Lupine.UnmarshalAtom[pkt, pktLength];
END; -- Unmarshal requestCode.
BEGIN -- Unmarshal requestString: ROPE from pkt.data[pktLength].
[requestString, pktLength] ← Lupine.UnmarshalRope[pkt, pktLength,
FALSE];
END; -- Unmarshal requestString.
Lupine.CheckPktLength[pkt: pkt, pktLength: pktLength];
[resultCode, resultString] ←
rGeneric[requestCode, requestString];
pktLength ← 0;
BEGIN -- Marshal resultCode: ATOM to pkt.data[pktLength].
pktLength ← Lupine.MarshalAtom[resultCode, pkt, pktLength];
END; -- Marshal resultCode.
BEGIN -- Marshal resultString: ROPE to pkt.data[pktLength].
pktLength ← Lupine.MarshalRope[resultString, pkt, pktLength,
FALSE];
END; -- Marshal resultString.
RETURN[returnLength: pktLength];
END; -- rGenericStub.
rSetDefaultWDirStub: --PROCEDURE [dir: RPC.ShortROPE]-- RpcPrivate.Dispatcher
=
BEGIN
dir: RPC.ShortROPE;
pktLength: RpcPrivate.DataLength ← 1;
BEGIN -- Unmarshal dir: RPC.ShortROPE from pkt.data[pktLength].
[dir, pktLength] ← Lupine.UnmarshalRope[pkt, pktLength, TRUE];
END; -- Unmarshal dir.
Lupine.CheckPktLength[pkt: pkt, pktLength: pktLength];
rSetDefaultWDir[dir];
pktLength ← 0;
RETURN[returnLength: pktLength];
END; -- rSetDefaultWDirStub.
rGetDefaultWDirStub: --PROCEDURE RETURNS [anonP1id3742549: RPC.ShortROPE]--
RpcPrivate.Dispatcher =
BEGIN
anonP1id3742549: RPC.ShortROPE;
pktLength: RpcPrivate.DataLength;
Lupine.CheckPktLength[pkt: pkt, pktLength: 1];
[anonP1id3742549] ← rGetDefaultWDir[];
pktLength ← 0;
BEGIN -- Marshal anonP1id3742549: RPC.ShortROPE to pkt.data[pktLength].
pktLength ← Lupine.MarshalRope[anonP1id3742549, pkt, pktLength,
TRUE];
END; -- Marshal anonP1id3742549.
RETURN[returnLength: pktLength];
END; -- rGetDefaultWDirStub.
rExpandNameStub: --PROCEDURE [name: ROPE, wDir: RPC.ShortROPE] RETURNS
-- [fullFName: ROPE, cp: FS.ComponentPositions, dirOmitted: BOOLEAN]--
RpcPrivate.Dispatcher =
BEGIN
name: ROPE;
wDir: RPC.ShortROPE;
fullFName: ROPE;
ResultOverlay: TYPE = MACHINE DEPENDENT RECORD [
cp (0): FS.ComponentPositions, dirOmitted (12): BOOLEAN];
resPkt: LONG POINTER TO ResultOverlay;
pktLength: RpcPrivate.DataLength ← 1;
BEGIN -- Unmarshal name: ROPE from pkt.data[pktLength].
[name, pktLength] ← Lupine.UnmarshalRope[pkt, pktLength, FALSE];
END; -- Unmarshal name.
BEGIN -- Unmarshal wDir: RPC.ShortROPE from pkt.data[pktLength].
[wDir, pktLength] ← Lupine.UnmarshalRope[pkt, pktLength, TRUE];
END; -- Unmarshal wDir.
Lupine.CheckPktLength[pkt: pkt, pktLength: pktLength];
resPkt ← @pkt.data[0];
[fullFName, resPkt.cp, resPkt.dirOmitted] ←
rExpandName[name, wDir];
pktLength ← 13;
BEGIN -- Marshal fullFName: ROPE to pkt.data[pktLength].
pktLength ← Lupine.MarshalRope[fullFName, pkt, pktLength, FALSE];
END; -- Marshal fullFName.
RETURN[returnLength: pktLength];
END; -- rExpandNameStub.
rFileInfoStub: --PROCEDURE [name: ROPE, wantedCreatedTime: BasicTime.GMT,
-- remoteCheck: BOOLEAN, wDir: RPC.ShortROPE]
-- RETURNS [fullFName: ROPE, attachedTo: ROPE, keep: CARDINAL,
-- bytes: INT, created: BasicTime.GMT]-- RpcPrivate.Dispatcher
=
BEGIN
name: ROPE;
wantedCreatedTime: BasicTime.GMT;
remoteCheck: BOOLEAN;
wDir: RPC.ShortROPE;
fullFName: ROPE;
attachedTo: ROPE;
ArgumentOverlay: TYPE = MACHINE DEPENDENT RECORD [
transferIndex (0): RpcControl.ProcedureIndex, wantedCreatedTime
(1): BasicTime.GMT, remoteCheck (3): BOOLEAN];
ResultOverlay: TYPE = MACHINE DEPENDENT RECORD [
keep (0): CARDINAL, bytes (1): INT, created (3): BasicTime.GMT];
argPkt: LONG POINTER TO ArgumentOverlay = @pkt.data[0];
resPkt: LONG POINTER TO ResultOverlay;
pktLength: RpcPrivate.DataLength ← 4;
BEGIN -- OnePkt.
onePkt: BOOLEAN = lastPkt;
IF ~onePkt THEN BEGIN -- Must move statics from pkt now.
[wantedCreatedTime: wantedCreatedTime, remoteCheck: remoteCheck]
← argPkt↑;
END;
BEGIN -- Unmarshal name: ROPE from pkt.data[pktLength].
[name, pktLength] ← Lupine.UnmarshalRope[pkt, pktLength, FALSE];
END; -- Unmarshal name.
BEGIN -- Unmarshal wDir: RPC.ShortROPE from pkt.data[pktLength].
[wDir, pktLength] ← Lupine.UnmarshalRope[pkt, pktLength, TRUE];
END; -- Unmarshal wDir.
Lupine.CheckPktLength[pkt: pkt, pktLength: pktLength];
resPkt ← @pkt.data[0];
IF onePkt
THEN [fullFName, attachedTo, resPkt.keep, resPkt.bytes, resPkt.created]
←
rFileInfo[name, argPkt.wantedCreatedTime, argPkt.remoteCheck,
wDir]
ELSE [fullFName, attachedTo, resPkt.keep, resPkt.bytes, resPkt.created]
←
rFileInfo[name, wantedCreatedTime, remoteCheck, wDir];
END; -- OnePkt.
pktLength ← 5;
BEGIN -- Marshal fullFName: ROPE to pkt.data[pktLength].
pktLength ← Lupine.MarshalRope[fullFName, pkt, pktLength, FALSE];
END; -- Marshal fullFName.
BEGIN -- Marshal attachedTo: ROPE to pkt.data[pktLength].
pktLength ← Lupine.MarshalRope[attachedTo, pkt, pktLength, FALSE];
END; -- Marshal attachedTo.
RETURN[returnLength: pktLength];
END; -- rFileInfoStub.
rStartEnumerateForInfoStub: --PROCEDURE [listenerPupAddress: Pup.Address,
-- pattern: ROPE, wDir: RPC.ShortROPE]
-- RETURNS [fullFName: ROPE, attachedTo: ROPE, created: BasicTime.GMT,
-- bytes: INT, keep: CARDINAL, continue: BOOLEAN]-- RpcPrivate.Dispatcher
=
BEGIN
listenerPupAddress: Pup.Address;
pattern: ROPE;
wDir: RPC.ShortROPE;
fullFName: ROPE;
attachedTo: ROPE;
ArgumentOverlay: TYPE = MACHINE DEPENDENT RECORD [
transferIndex (0): RpcControl.ProcedureIndex, listenerPupAddress
(1): Pup.Address];
ResultOverlay: TYPE = MACHINE DEPENDENT RECORD [
created (0): BasicTime.GMT, bytes (2): INT, keep (4): CARDINAL,
continue (5): BOOLEAN];
argPkt: LONG POINTER TO ArgumentOverlay = @pkt.data[0];
resPkt: LONG POINTER TO ResultOverlay;
pktLength: RpcPrivate.DataLength ← 4;
BEGIN -- OnePkt.
onePkt: BOOLEAN = lastPkt;
IF ~onePkt THEN BEGIN -- Must move statics from pkt now.
[listenerPupAddress: listenerPupAddress] ← argPkt↑;
END;
BEGIN -- Unmarshal pattern: ROPE from pkt.data[pktLength].
[pattern, pktLength] ← Lupine.UnmarshalRope[pkt, pktLength, FALSE];
END; -- Unmarshal pattern.
BEGIN -- Unmarshal wDir: RPC.ShortROPE from pkt.data[pktLength].
[wDir, pktLength] ← Lupine.UnmarshalRope[pkt, pktLength, TRUE];
END; -- Unmarshal wDir.
Lupine.CheckPktLength[pkt: pkt, pktLength: pktLength];
resPkt ← @pkt.data[0];
IF onePkt
THEN [fullFName, attachedTo, resPkt.created, resPkt.bytes, resPkt.keep,
resPkt.continue] ←
rStartEnumerateForInfo[argPkt.listenerPupAddress, pattern,
wDir]
ELSE [fullFName, attachedTo, resPkt.created, resPkt.bytes, resPkt.keep,
resPkt.continue] ←
rStartEnumerateForInfo[listenerPupAddress, pattern, wDir];
END; -- OnePkt.
pktLength ← 6;
BEGIN -- Marshal fullFName: ROPE to pkt.data[pktLength].
pktLength ← Lupine.MarshalRope[fullFName, pkt, pktLength, FALSE];
END; -- Marshal fullFName.
BEGIN -- Marshal attachedTo: ROPE to pkt.data[pktLength].
pktLength ← Lupine.MarshalRope[attachedTo, pkt, pktLength, FALSE];
END; -- Marshal attachedTo.
RETURN[returnLength: pktLength];
END; -- rStartEnumerateForInfoStub.
rNextEnumerateForInfoStub: --PROCEDURE [listenerPupAddress: Pup.Address]
-- RETURNS [fullFName: ROPE, attachedTo: ROPE, created: BasicTime.GMT,
-- bytes: INT, keep: CARDINAL, continue: BOOLEAN]-- RpcPrivate.Dispatcher
=
BEGIN
fullFName: ROPE;
attachedTo: ROPE;
ArgumentOverlay: TYPE = MACHINE DEPENDENT RECORD [
transferIndex (0): RpcControl.ProcedureIndex, listenerPupAddress
(1): Pup.Address];
ResultOverlay: TYPE = MACHINE DEPENDENT RECORD [
created (0): BasicTime.GMT, bytes (2): INT, keep (4): CARDINAL,
continue (5): BOOLEAN];
argPkt: LONG POINTER TO ArgumentOverlay = @pkt.data[0];
resPkt: LONG POINTER TO ResultOverlay = @pkt.data[0];
pktLength: RpcPrivate.DataLength;
Lupine.CheckPktLength[pkt: pkt, pktLength: 4];
[fullFName, attachedTo, resPkt.created, resPkt.bytes, resPkt.keep,
resPkt.continue] ←
rNextEnumerateForInfo[argPkt.listenerPupAddress];
pktLength ← 6;
BEGIN -- Marshal fullFName: ROPE to pkt.data[pktLength].
pktLength ← Lupine.MarshalRope[fullFName, pkt, pktLength, FALSE];
END; -- Marshal fullFName.
BEGIN -- Marshal attachedTo: ROPE to pkt.data[pktLength].
pktLength ← Lupine.MarshalRope[attachedTo, pkt, pktLength, FALSE];
END; -- Marshal attachedTo.
RETURN[returnLength: pktLength];
END; -- rNextEnumerateForInfoStub.
rStartEnumerateForNamesStub: --PROCEDURE [listenerPupAddress: Pup.Address,
-- pattern: ROPE, wDir: RPC.ShortROPE]
-- RETURNS [fullFName: ROPE, continue: BOOLEAN]-- RpcPrivate.Dispatcher
=
BEGIN
listenerPupAddress: Pup.Address;
pattern: ROPE;
wDir: RPC.ShortROPE;
fullFName: ROPE;
ArgumentOverlay: TYPE = MACHINE DEPENDENT RECORD [
transferIndex (0): RpcControl.ProcedureIndex, listenerPupAddress
(1): Pup.Address];
ResultOverlay: TYPE = MACHINE DEPENDENT RECORD [
continue (0): BOOLEAN];
argPkt: LONG POINTER TO ArgumentOverlay = @pkt.data[0];
resPkt: LONG POINTER TO ResultOverlay;
pktLength: RpcPrivate.DataLength ← 4;
BEGIN -- OnePkt.
onePkt: BOOLEAN = lastPkt;
IF ~onePkt THEN BEGIN -- Must move statics from pkt now.
[listenerPupAddress: listenerPupAddress] ← argPkt↑;
END;
BEGIN -- Unmarshal pattern: ROPE from pkt.data[pktLength].
[pattern, pktLength] ← Lupine.UnmarshalRope[pkt, pktLength, FALSE];
END; -- Unmarshal pattern.
BEGIN -- Unmarshal wDir: RPC.ShortROPE from pkt.data[pktLength].
[wDir, pktLength] ← Lupine.UnmarshalRope[pkt, pktLength, TRUE];
END; -- Unmarshal wDir.
Lupine.CheckPktLength[pkt: pkt, pktLength: pktLength];
resPkt ← @pkt.data[0];
IF onePkt
THEN [fullFName, resPkt.continue] ←
rStartEnumerateForNames[argPkt.listenerPupAddress, pattern,
wDir]
ELSE [fullFName, resPkt.continue] ←
rStartEnumerateForNames[listenerPupAddress, pattern, wDir];
END; -- OnePkt.
pktLength ← 1;
BEGIN -- Marshal fullFName: ROPE to pkt.data[pktLength].
pktLength ← Lupine.MarshalRope[fullFName, pkt, pktLength, FALSE];
END; -- Marshal fullFName.
RETURN[returnLength: pktLength];
END; -- rStartEnumerateForNamesStub.
rNextEnumerateForNamesStub: --PROCEDURE [listenerPupAddress: Pup.Address]
-- RETURNS [fullFName: ROPE, continue: BOOLEAN]-- RpcPrivate.Dispatcher
=
BEGIN
fullFName: ROPE;
ArgumentOverlay: TYPE = MACHINE DEPENDENT RECORD [
transferIndex (0): RpcControl.ProcedureIndex, listenerPupAddress
(1): Pup.Address];
ResultOverlay: TYPE = MACHINE DEPENDENT RECORD [
continue (0): BOOLEAN];
argPkt: LONG POINTER TO ArgumentOverlay = @pkt.data[0];
resPkt: LONG POINTER TO ResultOverlay = @pkt.data[0];
pktLength: RpcPrivate.DataLength;
Lupine.CheckPktLength[pkt: pkt, pktLength: 4];
[fullFName, resPkt.continue] ←
rNextEnumerateForNames[argPkt.listenerPupAddress];
pktLength ← 1;
BEGIN -- Marshal fullFName: ROPE to pkt.data[pktLength].
pktLength ← Lupine.MarshalRope[fullFName, pkt, pktLength, FALSE];
END; -- Marshal fullFName.
RETURN[returnLength: pktLength];
END; -- rNextEnumerateForNamesStub.
rDoneEnumerateStub: --PROCEDURE [listenerPupAddress: Pup.Address]--
RpcPrivate.Dispatcher =
BEGIN
ArgumentOverlay: TYPE = MACHINE DEPENDENT RECORD [
transferIndex (0): RpcControl.ProcedureIndex, listenerPupAddress
(1): Pup.Address];
argPkt: LONG POINTER TO ArgumentOverlay = @pkt.data[0];
pktLength: RpcPrivate.DataLength;
Lupine.CheckPktLength[pkt: pkt, pktLength: 4];
rDoneEnumerate[argPkt.listenerPupAddress];
pktLength ← 0;
RETURN[returnLength: pktLength];
END; -- rDoneEnumerateStub.
rOpenStub: --PROCEDURE [listenerPupAddress: Pup.Address, name: ROPE,
-- lock: FS.Lock, wantedCreatedTime: BasicTime.GMT, remoteCheck:
-- BOOLEAN, wDir: RPC.ShortROPE, forceRemoteOpen: BOOL]
-- RETURNS [globalNameToOpen: ROPE, openFile: OpenFile]-- RpcPrivate.Dispatcher
=
BEGIN
listenerPupAddress: Pup.Address;
name: ROPE;
lock: FS.Lock;
wantedCreatedTime: BasicTime.GMT;
remoteCheck: BOOLEAN;
wDir: RPC.ShortROPE;
forceRemoteOpen: BOOL;
globalNameToOpen: ROPE;
ArgumentOverlay: TYPE = MACHINE DEPENDENT RECORD [
transferIndex (0): RpcControl.ProcedureIndex, listenerPupAddress
(1): Pup.Address, lock (4): FS.Lock, wantedCreatedTime (5): BasicTime.GMT,
remoteCheck (7): BOOLEAN, forceRemoteOpen (8): BOOL];
ResultOverlay: TYPE = MACHINE DEPENDENT RECORD [
openFile (0): OpenFile];
argPkt: LONG POINTER TO ArgumentOverlay = @pkt.data[0];
resPkt: LONG POINTER TO ResultOverlay;
pktLength: RpcPrivate.DataLength ← 9;
BEGIN -- OnePkt.
onePkt: BOOLEAN = lastPkt;
IF ~onePkt THEN BEGIN -- Must move statics from pkt now.
[listenerPupAddress: listenerPupAddress, lock: lock, wantedCreatedTime:
wantedCreatedTime, remoteCheck: remoteCheck, forceRemoteOpen:
forceRemoteOpen] ← argPkt↑;
END;
BEGIN -- Unmarshal name: ROPE from pkt.data[pktLength].
[name, pktLength] ← Lupine.UnmarshalRope[pkt, pktLength, FALSE];
END; -- Unmarshal name.
BEGIN -- Unmarshal wDir: RPC.ShortROPE from pkt.data[pktLength].
[wDir, pktLength] ← Lupine.UnmarshalRope[pkt, pktLength, TRUE];
END; -- Unmarshal wDir.
Lupine.CheckPktLength[pkt: pkt, pktLength: pktLength];
resPkt ← @pkt.data[0];
IF onePkt
THEN [globalNameToOpen, resPkt.openFile] ←
rOpen[argPkt.listenerPupAddress, name, argPkt.lock, argPkt.wantedCreatedTime,
argPkt.remoteCheck, wDir, argPkt.forceRemoteOpen]
ELSE [globalNameToOpen, resPkt.openFile] ←
rOpen[listenerPupAddress, name, lock, wantedCreatedTime,
remoteCheck, wDir, forceRemoteOpen];
END; -- OnePkt.
pktLength ← 2;
BEGIN -- Marshal globalNameToOpen: ROPE to pkt.data[pktLength].
pktLength ← Lupine.MarshalRope[globalNameToOpen, pkt, pktLength,
FALSE];
END; -- Marshal globalNameToOpen.
RETURN[returnLength: pktLength];
END; -- rOpenStub.
rCreateStub: --PROCEDURE [listenerPupAddress: Pup.Address, name:
-- ROPE, setPages: BOOLEAN, pages: INT, setKeep: BOOLEAN, keep: CARDINAL,
-- wDir: RPC.ShortROPE]
-- RETURNS [anonP1id3742907: OpenFile]-- RpcPrivate.Dispatcher
=
BEGIN
listenerPupAddress: Pup.Address;
name: ROPE;
setPages: BOOLEAN;
pages: INT;
setKeep: BOOLEAN;
keep: CARDINAL;
wDir: RPC.ShortROPE;
ArgumentOverlay: TYPE = MACHINE DEPENDENT RECORD [
transferIndex (0): RpcControl.ProcedureIndex, listenerPupAddress
(1): Pup.Address, setPages (4): BOOLEAN, pages (5): INT, setKeep
(7): BOOLEAN, keep (8): CARDINAL];
ResultOverlay: TYPE = MACHINE DEPENDENT RECORD [
anonP1id3742907 (0): OpenFile];
argPkt: LONG POINTER TO ArgumentOverlay = @pkt.data[0];
resPkt: LONG POINTER TO ResultOverlay;
pktLength: RpcPrivate.DataLength ← 9;
BEGIN -- OnePkt.
onePkt: BOOLEAN = lastPkt;
IF ~onePkt THEN BEGIN -- Must move statics from pkt now.
[listenerPupAddress: listenerPupAddress, setPages: setPages,
pages: pages, setKeep: setKeep, keep: keep] ← argPkt↑;
END;
BEGIN -- Unmarshal name: ROPE from pkt.data[pktLength].
[name, pktLength] ← Lupine.UnmarshalRope[pkt, pktLength, FALSE];
END; -- Unmarshal name.
BEGIN -- Unmarshal wDir: RPC.ShortROPE from pkt.data[pktLength].
[wDir, pktLength] ← Lupine.UnmarshalRope[pkt, pktLength, TRUE];
END; -- Unmarshal wDir.
Lupine.CheckPktLength[pkt: pkt, pktLength: pktLength];
resPkt ← @pkt.data[0];
IF onePkt
THEN [resPkt.anonP1id3742907] ← rCreate[argPkt.listenerPupAddress,
name, argPkt.setPages, argPkt.pages, argPkt.setKeep, argPkt.keep,
wDir]
ELSE [resPkt.anonP1id3742907] ← rCreate[listenerPupAddress, name,
setPages, pages, setKeep, keep, wDir];
END; -- OnePkt.
pktLength ← 2;
RETURN[returnLength: pktLength];
END; -- rCreateStub.
rOpenOrCreateStub: --PROCEDURE [listenerPupAddress: Pup.Address,
-- name: ROPE, keep: CARDINAL, pages: INT, wDir: RPC.ShortROPE]
-- RETURNS [anonP1id3742946: OpenFile]-- RpcPrivate.Dispatcher
=
BEGIN
listenerPupAddress: Pup.Address;
name: ROPE;
keep: CARDINAL;
pages: INT;
wDir: RPC.ShortROPE;
ArgumentOverlay: TYPE = MACHINE DEPENDENT RECORD [
transferIndex (0): RpcControl.ProcedureIndex, listenerPupAddress
(1): Pup.Address, keep (4): CARDINAL, pages (5): INT];
ResultOverlay: TYPE = MACHINE DEPENDENT RECORD [
anonP1id3742946 (0): OpenFile];
argPkt: LONG POINTER TO ArgumentOverlay = @pkt.data[0];
resPkt: LONG POINTER TO ResultOverlay;
pktLength: RpcPrivate.DataLength ← 7;
BEGIN -- OnePkt.
onePkt: BOOLEAN = lastPkt;
IF ~onePkt THEN BEGIN -- Must move statics from pkt now.
[listenerPupAddress: listenerPupAddress, keep: keep, pages: pages]
← argPkt↑;
END;
BEGIN -- Unmarshal name: ROPE from pkt.data[pktLength].
[name, pktLength] ← Lupine.UnmarshalRope[pkt, pktLength, FALSE];
END; -- Unmarshal name.
BEGIN -- Unmarshal wDir: RPC.ShortROPE from pkt.data[pktLength].
[wDir, pktLength] ← Lupine.UnmarshalRope[pkt, pktLength, TRUE];
END; -- Unmarshal wDir.
Lupine.CheckPktLength[pkt: pkt, pktLength: pktLength];
resPkt ← @pkt.data[0];
IF onePkt
THEN [resPkt.anonP1id3742946] ← rOpenOrCreate[argPkt.listenerPupAddress,
name, argPkt.keep, argPkt.pages, wDir]
ELSE [resPkt.anonP1id3742946] ← rOpenOrCreate[listenerPupAddress,
name, keep, pages, wDir];
END; -- OnePkt.
pktLength ← 2;
RETURN[returnLength: pktLength];
END; -- rOpenOrCreateStub.
rGetClassStub: --PROCEDURE [listenerPupAddress: Pup.Address, file:
-- OpenFile] RETURNS [anonP1id3742970: ATOM]-- RpcPrivate.Dispatcher
=
BEGIN
anonP1id3742970: ATOM;
ArgumentOverlay: TYPE = MACHINE DEPENDENT RECORD [
transferIndex (0): RpcControl.ProcedureIndex, listenerPupAddress
(1): Pup.Address, file (4): OpenFile];
argPkt: LONG POINTER TO ArgumentOverlay = @pkt.data[0];
pktLength: RpcPrivate.DataLength;
Lupine.CheckPktLength[pkt: pkt, pktLength: 6];
[anonP1id3742970] ← rGetClass[argPkt.listenerPupAddress, argPkt.file];
pktLength ← 0;
BEGIN -- Marshal anonP1id3742970: ATOM to pkt.data[pktLength].
pktLength ← Lupine.MarshalAtom[anonP1id3742970, pkt, pktLength];
END; -- Marshal anonP1id3742970.
RETURN[returnLength: pktLength];
END; -- rGetClassStub.
rSameFileStub: --PROCEDURE [listenerPupAddress: Pup.Address, file1:
-- OpenFile, file2: OpenFile]
-- RETURNS [anonP1id3742999: BOOLEAN]-- RpcPrivate.Dispatcher =
BEGIN
ArgumentOverlay: TYPE = MACHINE DEPENDENT RECORD [
transferIndex (0): RpcControl.ProcedureIndex, listenerPupAddress
(1): Pup.Address, file1 (4): OpenFile, file2 (6): OpenFile];
ResultOverlay: TYPE = MACHINE DEPENDENT RECORD [
anonP1id3742999 (0): BOOLEAN];
argPkt: LONG POINTER TO ArgumentOverlay = @pkt.data[0];
resPkt: LONG POINTER TO ResultOverlay = @pkt.data[0];
pktLength: RpcPrivate.DataLength;
Lupine.CheckPktLength[pkt: pkt, pktLength: 8];
[resPkt.anonP1id3742999] ← rSameFile[argPkt.listenerPupAddress,
argPkt.file1, argPkt.file2];
pktLength ← 1;
RETURN[returnLength: pktLength];
END; -- rSameFileStub.
rGetNameStub: --PROCEDURE [listenerPupAddress: Pup.Address, file:
-- OpenFile] RETURNS [fullFName: ROPE, attachedTo: ROPE]-- RpcPrivate.Dispatcher
=
BEGIN
fullFName: ROPE;
attachedTo: ROPE;
ArgumentOverlay: TYPE = MACHINE DEPENDENT RECORD [
transferIndex (0): RpcControl.ProcedureIndex, listenerPupAddress
(1): Pup.Address, file (4): OpenFile];
argPkt: LONG POINTER TO ArgumentOverlay = @pkt.data[0];
pktLength: RpcPrivate.DataLength;
Lupine.CheckPktLength[pkt: pkt, pktLength: 6];
[fullFName, attachedTo] ←
rGetName[argPkt.listenerPupAddress, argPkt.file];
pktLength ← 0;
BEGIN -- Marshal fullFName: ROPE to pkt.data[pktLength].
pktLength ← Lupine.MarshalRope[fullFName, pkt, pktLength, FALSE];
END; -- Marshal fullFName.
BEGIN -- Marshal attachedTo: ROPE to pkt.data[pktLength].
pktLength ← Lupine.MarshalRope[attachedTo, pkt, pktLength, FALSE];
END; -- Marshal attachedTo.
RETURN[returnLength: pktLength];
END; -- rGetNameStub.
rGetInfoStub: --PROCEDURE [listenerPupAddress: Pup.Address, file:
-- OpenFile] RETURNS [keep: CARDINAL, pages: INT, bytes: INT, created:
-- BasicTime.GMT, lock: FS.Lock]-- RpcPrivate.Dispatcher =
BEGIN
ArgumentOverlay: TYPE = MACHINE DEPENDENT RECORD [
transferIndex (0): RpcControl.ProcedureIndex, listenerPupAddress
(1): Pup.Address, 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];
argPkt: LONG POINTER TO ArgumentOverlay = @pkt.data[0];
resPkt: LONG POINTER TO ResultOverlay = @pkt.data[0];
pktLength: RpcPrivate.DataLength;
Lupine.CheckPktLength[pkt: pkt, pktLength: 6];
[resPkt.keep, resPkt.pages, resPkt.bytes, resPkt.created, resPkt.lock]
←
rGetInfo[argPkt.listenerPupAddress, argPkt.file];
pktLength ← 8;
RETURN[returnLength: pktLength];
END; -- rGetInfoStub.
rSetPageCountStub: --PROCEDURE [listenerPupAddress: Pup.Address,
-- file: OpenFile, pages: INT]-- RpcPrivate.Dispatcher =
BEGIN
ArgumentOverlay: TYPE = MACHINE DEPENDENT RECORD [
transferIndex (0): RpcControl.ProcedureIndex, listenerPupAddress
(1): Pup.Address, file (4): OpenFile, pages (6): INT];
argPkt: LONG POINTER TO ArgumentOverlay = @pkt.data[0];
pktLength: RpcPrivate.DataLength;
Lupine.CheckPktLength[pkt: pkt, pktLength: 8];
rSetPageCount[argPkt.listenerPupAddress, argPkt.file, argPkt.pages];
pktLength ← 0;
RETURN[returnLength: pktLength];
END; -- rSetPageCountStub.
rSetByteCountAndCreatedTimeStub: --PROCEDURE [listenerPupAddress:
-- Pup.Address, file: OpenFile, bytes: INT, created: BasicTime.GMT]--
RpcPrivate.Dispatcher =
BEGIN
ArgumentOverlay: TYPE = MACHINE DEPENDENT RECORD [
transferIndex (0): RpcControl.ProcedureIndex, listenerPupAddress
(1): Pup.Address, file (4): OpenFile, bytes (6): INT, created (8):
BasicTime.GMT];
argPkt: LONG POINTER TO ArgumentOverlay = @pkt.data[0];
pktLength: RpcPrivate.DataLength;
Lupine.CheckPktLength[pkt: pkt, pktLength: 10];
rSetByteCountAndCreatedTime[argPkt.listenerPupAddress, argPkt.file,
argPkt.bytes, argPkt.created];
pktLength ← 0;
RETURN[returnLength: pktLength];
END; -- rSetByteCountAndCreatedTimeStub.
rReadStub: --PROCEDURE [listenerPupAddress: Pup.Address, file: OpenFile,
-- from: INT, nPages: INT, pageBuffer: RESULTPageBuffer]-- RpcPrivate.Dispatcher
=
BEGIN
pageBuffer: RESULTPageBuffer;
ArgumentOverlay: TYPE = MACHINE DEPENDENT RECORD [
transferIndex (0): RpcControl.ProcedureIndex, listenerPupAddress
(1): Pup.Address, file (4): OpenFile, from (6): INT, nPages (8):
INT];
argPkt: LONG POINTER TO ArgumentOverlay = @pkt.data[0];
pktLength: RpcPrivate.DataLength ← 10;
MaxHeapAllocs: CARDINAL = 1;
heapAllocVector: ARRAY [1..MaxHeapAllocs] OF LONG POINTER←ALL[NIL];
BEGIN ENABLE UNWIND => BEGIN -- Free storage.
FOR ptr: CARDINAL IN [1..LENGTH[heapAllocVector]] DO
IF heapAllocVector[ptr] = NIL THEN EXIT;
paramZones.heap.FREE[@heapAllocVector[ptr]];
ENDLOOP;
END; -- Free storage.
BEGIN -- Unmarshal pageBuffer: RESULTPageBuffer from pkt.data[pktLength].
DescriptorType: TYPE = RECORD [SEQUENCE COMPUTED CARDINAL OF
WORD];
descLength: Lupine.SequenceHeader;
descLength ← Lupine.RpcPktDoubleWord[pkt, pktLength]↑;
pktLength ← pktLength + 2;
pageBuffer ← DESCRIPTOR[
(heapAllocVector[1] ← paramZones.heap.NEW[DescriptorType[Lupine.SHORT[descLength]]]),
Lupine.SHORT[descLength]];
NULL; -- Call by result, use uninitialized descriptor.
END; -- Unmarshal pageBuffer.
Lupine.CheckPktLength[pkt: pkt, pktLength: pktLength];
rRead[argPkt.listenerPupAddress, argPkt.file, argPkt.from, argPkt.nPages,
pageBuffer];
pktLength ← 0;
BEGIN -- Marshal pageBuffer: RESULTPageBuffer 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.
END; -- ENABLE UNWIND => Free storage.
FOR ptr: CARDINAL IN [1..LENGTH[heapAllocVector]] DO
IF heapAllocVector[ptr] = NIL THEN EXIT;
paramZones.heap.FREE[@heapAllocVector[ptr]];
ENDLOOP;
RETURN[returnLength: pktLength];
END; -- rReadStub.
rWriteStub: --PROCEDURE [listenerPupAddress: Pup.Address, file: OpenFile,
-- to: INT, nPages: INT, pageBuffer: VALUEPageBuffer]-- RpcPrivate.Dispatcher
=
BEGIN
listenerPupAddress: Pup.Address;
file: OpenFile;
to: INT;
nPages: INT;
pageBuffer: VALUEPageBuffer;
ArgumentOverlay: TYPE = MACHINE DEPENDENT RECORD [
transferIndex (0): RpcControl.ProcedureIndex, listenerPupAddress
(1): Pup.Address, file (4): OpenFile, to (6): INT, nPages (8):
INT];
argPkt: LONG POINTER TO ArgumentOverlay = @pkt.data[0];
pktLength: RpcPrivate.DataLength ← 10;
MaxHeapAllocs: CARDINAL = 1;
heapAllocVector: ARRAY [1..MaxHeapAllocs] OF LONG POINTER←ALL[NIL];
BEGIN ENABLE UNWIND => BEGIN -- Free storage.
FOR ptr: CARDINAL IN [1..LENGTH[heapAllocVector]] DO
IF heapAllocVector[ptr] = NIL THEN EXIT;
paramZones.heap.FREE[@heapAllocVector[ptr]];
ENDLOOP;
END; -- Free storage.
BEGIN -- OnePkt.
onePkt: BOOLEAN = lastPkt;
IF ~onePkt THEN BEGIN -- Must move statics from pkt now.
[listenerPupAddress: listenerPupAddress, file: file, to: to,
nPages: nPages] ← argPkt↑;
END;
BEGIN -- Unmarshal pageBuffer: VALUEPageBuffer 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;
pageBuffer ← DESCRIPTOR[
(heapAllocVector[1] ← paramZones.heap.NEW[DescriptorType[Lupine.SHORT[descLength]]]),
Lupine.SHORT[descLength]];
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];
IF onePkt
THEN rWrite[argPkt.listenerPupAddress, argPkt.file, argPkt.to,
argPkt.nPages, pageBuffer]
ELSE rWrite[listenerPupAddress, file, to, nPages, pageBuffer];
END; -- OnePkt.
pktLength ← 0;
END; -- ENABLE UNWIND => Free storage.
FOR ptr: CARDINAL IN [1..LENGTH[heapAllocVector]] DO
IF heapAllocVector[ptr] = NIL THEN EXIT;
paramZones.heap.FREE[@heapAllocVector[ptr]];
ENDLOOP;
RETURN[returnLength: pktLength];
END; -- rWriteStub.
rCloseStub: --PROCEDURE [listenerPupAddress: Pup.Address, file: OpenFile]--
RpcPrivate.Dispatcher =
BEGIN
ArgumentOverlay: TYPE = MACHINE DEPENDENT RECORD [
transferIndex (0): RpcControl.ProcedureIndex, listenerPupAddress
(1): Pup.Address, file (4): OpenFile];
argPkt: LONG POINTER TO ArgumentOverlay = @pkt.data[0];
pktLength: RpcPrivate.DataLength;
Lupine.CheckPktLength[pkt: pkt, pktLength: 6];
rClose[argPkt.listenerPupAddress, argPkt.file];
pktLength ← 0;
RETURN[returnLength: pktLength];
END; -- rCloseStub.
rCopyStub: --PROCEDURE [listenerPupAddress: Pup.Address, from: ROPE,
-- to: ROPE, setKeep: BOOLEAN, keep: CARDINAL, wantedCreatedTime:
-- BasicTime.GMT, remoteCheck: BOOLEAN, attach: BOOLEAN, wDir: RPC.ShortROPE]
-- RETURNS [toFName: ROPE]-- RpcPrivate.Dispatcher =
BEGIN
listenerPupAddress: Pup.Address;
from: ROPE;
to: ROPE;
setKeep: BOOLEAN;
keep: CARDINAL;
wantedCreatedTime: BasicTime.GMT;
remoteCheck: BOOLEAN;
attach: BOOLEAN;
wDir: RPC.ShortROPE;
toFName: ROPE;
ArgumentOverlay: TYPE = MACHINE DEPENDENT RECORD [
transferIndex (0): RpcControl.ProcedureIndex, listenerPupAddress
(1): Pup.Address, setKeep (4): BOOLEAN, keep (5): CARDINAL, wantedCreatedTime
(6): BasicTime.GMT, remoteCheck (8): BOOLEAN, attach (9): BOOLEAN];
argPkt: LONG POINTER TO ArgumentOverlay = @pkt.data[0];
pktLength: RpcPrivate.DataLength ← 10;
BEGIN -- OnePkt.
onePkt: BOOLEAN = lastPkt;
IF ~onePkt THEN BEGIN -- Must move statics from pkt now.
[listenerPupAddress: listenerPupAddress, setKeep: setKeep, keep:
keep, wantedCreatedTime: wantedCreatedTime, remoteCheck: remoteCheck,
attach: attach] ← argPkt↑;
END;
BEGIN -- Unmarshal from: ROPE from pkt.data[pktLength].
[from, pktLength] ← Lupine.UnmarshalRope[pkt, pktLength, FALSE];
END; -- Unmarshal from.
BEGIN -- Unmarshal to: ROPE from pkt.data[pktLength].
[to, pktLength] ← Lupine.UnmarshalRope[pkt, pktLength, FALSE];
END; -- Unmarshal to.
BEGIN -- Unmarshal wDir: RPC.ShortROPE from pkt.data[pktLength].
[wDir, pktLength] ← Lupine.UnmarshalRope[pkt, pktLength, TRUE];
END; -- Unmarshal wDir.
Lupine.CheckPktLength[pkt: pkt, pktLength: pktLength];
IF onePkt
THEN [toFName] ← rCopy[argPkt.listenerPupAddress, from, to, argPkt.setKeep,
argPkt.keep, argPkt.wantedCreatedTime, argPkt.remoteCheck, argPkt.attach,
wDir]
ELSE [toFName] ← rCopy[listenerPupAddress, from, to, setKeep,
keep, wantedCreatedTime, remoteCheck, attach, wDir];
END; -- OnePkt.
pktLength ← 0;
BEGIN -- Marshal toFName: ROPE to pkt.data[pktLength].
pktLength ← Lupine.MarshalRope[toFName, pkt, pktLength, FALSE];
END; -- Marshal toFName.
RETURN[returnLength: pktLength];
END; -- rCopyStub.
rDeleteStub: --PROCEDURE [listenerPupAddress: Pup.Address, name:
-- ROPE, wantedCreatedTime: BasicTime.GMT, wDir: RPC.ShortROPE]--
RpcPrivate.Dispatcher =
BEGIN
listenerPupAddress: Pup.Address;
name: ROPE;
wantedCreatedTime: BasicTime.GMT;
wDir: RPC.ShortROPE;
ArgumentOverlay: TYPE = MACHINE DEPENDENT RECORD [
transferIndex (0): RpcControl.ProcedureIndex, listenerPupAddress
(1): Pup.Address, wantedCreatedTime (4): BasicTime.GMT];
argPkt: LONG POINTER TO ArgumentOverlay = @pkt.data[0];
pktLength: RpcPrivate.DataLength ← 6;
BEGIN -- OnePkt.
onePkt: BOOLEAN = lastPkt;
IF ~onePkt THEN BEGIN -- Must move statics from pkt now.
[listenerPupAddress: listenerPupAddress, wantedCreatedTime: wantedCreatedTime]
← argPkt↑;
END;
BEGIN -- Unmarshal name: ROPE from pkt.data[pktLength].
[name, pktLength] ← Lupine.UnmarshalRope[pkt, pktLength, FALSE];
END; -- Unmarshal name.
BEGIN -- Unmarshal wDir: RPC.ShortROPE from pkt.data[pktLength].
[wDir, pktLength] ← Lupine.UnmarshalRope[pkt, pktLength, TRUE];
END; -- Unmarshal wDir.
Lupine.CheckPktLength[pkt: pkt, pktLength: pktLength];
IF onePkt
THEN rDelete[argPkt.listenerPupAddress, name, argPkt.wantedCreatedTime,
wDir]
ELSE rDelete[listenerPupAddress, name, wantedCreatedTime, wDir];
END; -- OnePkt.
pktLength ← 0;
RETURN[returnLength: pktLength];
END; -- rDeleteStub.
rRenameStub: --PROCEDURE [listenerPupAddress: Pup.Address, from:
-- ROPE, to: ROPE, setKeep: BOOLEAN, keep: CARDINAL, wantedCreatedTime:
-- BasicTime.GMT, wDir: RPC.ShortROPE]-- RpcPrivate.Dispatcher =
BEGIN
listenerPupAddress: Pup.Address;
from: ROPE;
to: ROPE;
setKeep: BOOLEAN;
keep: CARDINAL;
wantedCreatedTime: BasicTime.GMT;
wDir: RPC.ShortROPE;
ArgumentOverlay: TYPE = MACHINE DEPENDENT RECORD [
transferIndex (0): RpcControl.ProcedureIndex, listenerPupAddress
(1): Pup.Address, setKeep (4): BOOLEAN, keep (5): CARDINAL, wantedCreatedTime
(6): BasicTime.GMT];
argPkt: LONG POINTER TO ArgumentOverlay = @pkt.data[0];
pktLength: RpcPrivate.DataLength ← 8;
BEGIN -- OnePkt.
onePkt: BOOLEAN = lastPkt;
IF ~onePkt THEN BEGIN -- Must move statics from pkt now.
[listenerPupAddress: listenerPupAddress, setKeep: setKeep, keep:
keep, wantedCreatedTime: wantedCreatedTime] ← argPkt↑;
END;
BEGIN -- Unmarshal from: ROPE from pkt.data[pktLength].
[from, pktLength] ← Lupine.UnmarshalRope[pkt, pktLength, FALSE];
END; -- Unmarshal from.
BEGIN -- Unmarshal to: ROPE from pkt.data[pktLength].
[to, pktLength] ← Lupine.UnmarshalRope[pkt, pktLength, FALSE];
END; -- Unmarshal to.
BEGIN -- Unmarshal wDir: RPC.ShortROPE from pkt.data[pktLength].
[wDir, pktLength] ← Lupine.UnmarshalRope[pkt, pktLength, TRUE];
END; -- Unmarshal wDir.
Lupine.CheckPktLength[pkt: pkt, pktLength: pktLength];
IF onePkt
THEN rRename[argPkt.listenerPupAddress, from, to, argPkt.setKeep,
argPkt.keep, argPkt.wantedCreatedTime, wDir]
ELSE rRename[listenerPupAddress, from, to, setKeep, keep, wantedCreatedTime,
wDir];
END; -- OnePkt.
pktLength ← 0;
RETURN[returnLength: pktLength];
END; -- rRenameStub.
rSetKeepStub: --PROCEDURE [listenerPupAddress: Pup.Address, name:
-- ROPE, keep: CARDINAL, wDir: RPC.ShortROPE]-- RpcPrivate.Dispatcher
=
BEGIN
listenerPupAddress: Pup.Address;
name: ROPE;
keep: CARDINAL;
wDir: RPC.ShortROPE;
ArgumentOverlay: TYPE = MACHINE DEPENDENT RECORD [
transferIndex (0): RpcControl.ProcedureIndex, listenerPupAddress
(1): Pup.Address, keep (4): CARDINAL];
argPkt: LONG POINTER TO ArgumentOverlay = @pkt.data[0];
pktLength: RpcPrivate.DataLength ← 5;
BEGIN -- OnePkt.
onePkt: BOOLEAN = lastPkt;
IF ~onePkt THEN BEGIN -- Must move statics from pkt now.
[listenerPupAddress: listenerPupAddress, keep: keep] ← argPkt↑;
END;
BEGIN -- Unmarshal name: ROPE from pkt.data[pktLength].
[name, pktLength] ← Lupine.UnmarshalRope[pkt, pktLength, FALSE];
END; -- Unmarshal name.
BEGIN -- Unmarshal wDir: RPC.ShortROPE from pkt.data[pktLength].
[wDir, pktLength] ← Lupine.UnmarshalRope[pkt, pktLength, TRUE];
END; -- Unmarshal wDir.
Lupine.CheckPktLength[pkt: pkt, pktLength: pktLength];
IF onePkt
THEN rSetKeep[argPkt.listenerPupAddress, name, argPkt.keep, wDir]
ELSE rSetKeep[listenerPupAddress, name, keep, wDir];
END; -- OnePkt.
pktLength ← 0;
RETURN[returnLength: pktLength];
END; -- rSetKeepStub.
rBooleanStub: --PROCEDURE [listenerPupAddress: Pup.Address, key:
-- Rope.ROPE, default: BOOLEAN]
-- RETURNS [value: BOOLEAN]-- RpcPrivate.Dispatcher =
BEGIN
listenerPupAddress: Pup.Address;
key: Rope.ROPE;
default: BOOLEAN;
ArgumentOverlay: TYPE = MACHINE DEPENDENT RECORD [
transferIndex (0): RpcControl.ProcedureIndex, listenerPupAddress
(1): Pup.Address, default (4): BOOLEAN];
ResultOverlay: TYPE = MACHINE DEPENDENT RECORD [
value (0): BOOLEAN];
argPkt: LONG POINTER TO ArgumentOverlay = @pkt.data[0];
resPkt: LONG POINTER TO ResultOverlay;
pktLength: RpcPrivate.DataLength ← 5;
BEGIN -- OnePkt.
onePkt: BOOLEAN = lastPkt;
IF ~onePkt THEN BEGIN -- Must move statics from pkt now.
[listenerPupAddress: listenerPupAddress, default: default] ←
argPkt↑;
END;
BEGIN -- Unmarshal key: Rope.ROPE from pkt.data[pktLength].
[key, pktLength] ← Lupine.UnmarshalRope[pkt, pktLength, FALSE];
END; -- Unmarshal key.
Lupine.CheckPktLength[pkt: pkt, pktLength: pktLength];
resPkt ← @pkt.data[0];
IF onePkt
THEN [resPkt.value] ← rBoolean[argPkt.listenerPupAddress, key,
argPkt.default]
ELSE [resPkt.value] ← rBoolean[listenerPupAddress, key, default];
END; -- OnePkt.
pktLength ← 1;
RETURN[returnLength: pktLength];
END; -- rBooleanStub.
rNumberStub: --PROCEDURE [listenerPupAddress: Pup.Address, key: Rope.ROPE,
-- default: INT]
-- RETURNS [value: INT]-- RpcPrivate.Dispatcher =
BEGIN
listenerPupAddress: Pup.Address;
key: Rope.ROPE;
default: INT;
ArgumentOverlay: TYPE = MACHINE DEPENDENT RECORD [
transferIndex (0): RpcControl.ProcedureIndex, listenerPupAddress
(1): Pup.Address, default (4): INT];
ResultOverlay: TYPE = MACHINE DEPENDENT RECORD [
value (0): INT];
argPkt: LONG POINTER TO ArgumentOverlay = @pkt.data[0];
resPkt: LONG POINTER TO ResultOverlay;
pktLength: RpcPrivate.DataLength ← 6;
BEGIN -- OnePkt.
onePkt: BOOLEAN = lastPkt;
IF ~onePkt THEN BEGIN -- Must move statics from pkt now.
[listenerPupAddress: listenerPupAddress, default: default] ←
argPkt↑;
END;
BEGIN -- Unmarshal key: Rope.ROPE from pkt.data[pktLength].
[key, pktLength] ← Lupine.UnmarshalRope[pkt, pktLength, FALSE];
END; -- Unmarshal key.
Lupine.CheckPktLength[pkt: pkt, pktLength: pktLength];
resPkt ← @pkt.data[0];
IF onePkt
THEN [resPkt.value] ← rNumber[argPkt.listenerPupAddress, key,
argPkt.default]
ELSE [resPkt.value] ← rNumber[listenerPupAddress, key, default];
END; -- OnePkt.
pktLength ← 2;
RETURN[returnLength: pktLength];
END; -- rNumberStub.
rTokenStub: --PROCEDURE [listenerPupAddress: Pup.Address, key: Rope.ROPE,
-- default: Rope.ROPE]
-- RETURNS [value: Rope.ROPE]-- RpcPrivate.Dispatcher =
BEGIN
listenerPupAddress: Pup.Address;
key: Rope.ROPE;
default: Rope.ROPE;
value: Rope.ROPE;
ArgumentOverlay: TYPE = MACHINE DEPENDENT RECORD [
transferIndex (0): RpcControl.ProcedureIndex, listenerPupAddress
(1): Pup.Address];
argPkt: LONG POINTER TO ArgumentOverlay = @pkt.data[0];
pktLength: RpcPrivate.DataLength ← 4;
BEGIN -- OnePkt.
onePkt: BOOLEAN = lastPkt;
IF ~onePkt THEN BEGIN -- Must move statics from pkt now.
[listenerPupAddress: listenerPupAddress] ← argPkt↑;
END;
BEGIN -- Unmarshal key: Rope.ROPE from pkt.data[pktLength].
[key, pktLength] ← Lupine.UnmarshalRope[pkt, pktLength, FALSE];
END; -- Unmarshal key.
BEGIN -- Unmarshal default: Rope.ROPE from pkt.data[pktLength].
[default, pktLength] ← Lupine.UnmarshalRope[pkt, pktLength, FALSE];
END; -- Unmarshal default.
Lupine.CheckPktLength[pkt: pkt, pktLength: pktLength];
IF onePkt
THEN [value] ← rToken[argPkt.listenerPupAddress, key, default]
ELSE [value] ← rToken[listenerPupAddress, key, default];
END; -- OnePkt.
pktLength ← 0;
BEGIN -- Marshal value: Rope.ROPE to pkt.data[pktLength].
pktLength ← Lupine.MarshalRope[value, pkt, pktLength, FALSE];
END; -- Marshal value.
RETURN[returnLength: pktLength];
END; -- rTokenStub.
rListOfTokensStub: --PROCEDURE [listenerPupAddress: Pup.Address,
-- key: Rope.ROPE, default: LIST OF Rope.ROPE]
-- RETURNS [value: LIST OF Rope.ROPE]-- RpcPrivate.Dispatcher =
BEGIN
listenerPupAddress: Pup.Address;
key: Rope.ROPE;
default: LIST OF Rope.ROPE;
value: LIST OF Rope.ROPE;
ArgumentOverlay: TYPE = MACHINE DEPENDENT RECORD [
transferIndex (0): RpcControl.ProcedureIndex, listenerPupAddress
(1): Pup.Address];
argPkt: LONG POINTER TO ArgumentOverlay = @pkt.data[0];
pktLength: RpcPrivate.DataLength ← 4;
BEGIN -- OnePkt.
onePkt: BOOLEAN = lastPkt;
IF ~onePkt THEN BEGIN -- Must move statics from pkt now.
[listenerPupAddress: listenerPupAddress] ← argPkt↑;
END;
BEGIN -- Unmarshal key: Rope.ROPE from pkt.data[pktLength].
[key, pktLength] ← Lupine.UnmarshalRope[pkt, pktLength, FALSE];
END; -- Unmarshal key.
BEGIN -- Unmarshal default: LIST OF Rope.ROPE from pkt.data[pktLength].
lastNode: LIST OF Rope.ROPE ← (default ← NIL);
listLength: Lupine.ListHeader;
IF pktLength+2 > RpcPrivate.maxDataLength
THEN pktLength ← Lupine.FinishThisPkt[pkt: pkt, pktLength:
pktLength];
listLength ← Lupine.RpcPktDoubleWord[pkt, pktLength]↑;
pktLength ← pktLength + 2;
WHILE listLength > 0 DO
thisNode1: LIST OF Rope.ROPE = paramZones.gc.CONS[--DefaultValue--,NIL];
BEGIN -- Unmarshal thisNode1.first: Rope.ROPE from pkt.data[pktLength].
[thisNode1.first, pktLength] ← Lupine.UnmarshalRope[pkt,
pktLength, FALSE];
END; -- Unmarshal thisNode1.first.
IF lastNode # NIL
THEN lastNode ← (lastNode.rest ← thisNode1)
ELSE lastNode ← (default ← thisNode1);
listLength ← listLength - 1;
ENDLOOP; -- WHILE listLength > 0.
END; -- Unmarshal default.
Lupine.CheckPktLength[pkt: pkt, pktLength: pktLength];
IF onePkt
THEN [value] ← rListOfTokens[argPkt.listenerPupAddress, key,
default]
ELSE [value] ← rListOfTokens[listenerPupAddress, key, default];
END; -- OnePkt.
pktLength ← 0;
BEGIN -- Marshal value: LIST OF Rope.ROPE to pkt.data[pktLength].
thisNode1: LIST OF Rope.ROPE;
listLength: Lupine.ListHeader ← 0;
FOR thisNode1 ← value, thisNode1.rest UNTIL thisNode1 = NIL DO
listLength ← listLength + 1; ENDLOOP;
IF pktLength+2 > RpcPrivate.maxDataLength
THEN pktLength ← Lupine.StartNextPkt[pkt: pkt, pktLength: pktLength];
Lupine.RpcPktDoubleWord[pkt, pktLength]↑ ← listLength;
pktLength ← pktLength + 2;
FOR thisNode1 ← value, thisNode1.rest UNTIL thisNode1 = NIL DO
BEGIN -- Marshal thisNode1.first: Rope.ROPE to pkt.data[pktLength].
pktLength ← Lupine.MarshalRope[thisNode1.first, pkt, pktLength,
FALSE];
END; -- Marshal thisNode1.first.
ENDLOOP; -- FOR thisNode1.
END; -- Marshal value.
RETURN[returnLength: pktLength];
END; -- rListOfTokensStub.
rLineStub: --PROCEDURE [listenerPupAddress: Pup.Address, key: Rope.ROPE,
-- default: Rope.ROPE]
-- RETURNS [value: Rope.ROPE]-- RpcPrivate.Dispatcher =
BEGIN
listenerPupAddress: Pup.Address;
key: Rope.ROPE;
default: Rope.ROPE;
value: Rope.ROPE;
ArgumentOverlay: TYPE = MACHINE DEPENDENT RECORD [
transferIndex (0): RpcControl.ProcedureIndex, listenerPupAddress
(1): Pup.Address];
argPkt: LONG POINTER TO ArgumentOverlay = @pkt.data[0];
pktLength: RpcPrivate.DataLength ← 4;
BEGIN -- OnePkt.
onePkt: BOOLEAN = lastPkt;
IF ~onePkt THEN BEGIN -- Must move statics from pkt now.
[listenerPupAddress: listenerPupAddress] ← argPkt↑;
END;
BEGIN -- Unmarshal key: Rope.ROPE from pkt.data[pktLength].
[key, pktLength] ← Lupine.UnmarshalRope[pkt, pktLength, FALSE];
END; -- Unmarshal key.
BEGIN -- Unmarshal default: Rope.ROPE from pkt.data[pktLength].
[default, pktLength] ← Lupine.UnmarshalRope[pkt, pktLength, FALSE];
END; -- Unmarshal default.
Lupine.CheckPktLength[pkt: pkt, pktLength: pktLength];
IF onePkt
THEN [value] ← rLine[argPkt.listenerPupAddress, key, default]
ELSE [value] ← rLine[listenerPupAddress, key, default];
END; -- OnePkt.
pktLength ← 0;
BEGIN -- Marshal value: Rope.ROPE to pkt.data[pktLength].
pktLength ← Lupine.MarshalRope[value, pkt, pktLength, FALSE];
END; -- Marshal value.
RETURN[returnLength: pktLength];
END; -- rLineStub.
rGetProfileNameStub: --PROCEDURE [listenerPupAddress: Pup.Address]
-- RETURNS [anonP1id3743547: Rope.ROPE]-- RpcPrivate.Dispatcher =
BEGIN
anonP1id3743547: Rope.ROPE;
ArgumentOverlay: TYPE = MACHINE DEPENDENT RECORD [
transferIndex (0): RpcControl.ProcedureIndex, listenerPupAddress
(1): Pup.Address];
argPkt: LONG POINTER TO ArgumentOverlay = @pkt.data[0];
pktLength: RpcPrivate.DataLength;
Lupine.CheckPktLength[pkt: pkt, pktLength: 4];
[anonP1id3743547] ← rGetProfileName[argPkt.listenerPupAddress];
pktLength ← 0;
BEGIN -- Marshal anonP1id3743547: Rope.ROPE to pkt.data[pktLength].
pktLength ← Lupine.MarshalRope[anonP1id3743547, pkt, pktLength,
FALSE];
END; -- Marshal anonP1id3743547.
RETURN[returnLength: pktLength];
END; -- rGetProfileNameStub.
rGetStateStub: --PROCEDURE [listenerPupAddress: Pup.Address] RETURNS
-- [anonP1id3743566: UserCredentials.State]-- RpcPrivate.Dispatcher
=
BEGIN
ArgumentOverlay: TYPE = MACHINE DEPENDENT RECORD [
transferIndex (0): RpcControl.ProcedureIndex, listenerPupAddress
(1): Pup.Address];
ResultOverlay: TYPE = MACHINE DEPENDENT RECORD [
anonP1id3743566 (0): UserCredentials.State];
argPkt: LONG POINTER TO ArgumentOverlay = @pkt.data[0];
resPkt: LONG POINTER TO ResultOverlay = @pkt.data[0];
pktLength: RpcPrivate.DataLength;
Lupine.CheckPktLength[pkt: pkt, pktLength: 4];
[resPkt.anonP1id3743566] ← rGetState[argPkt.listenerPupAddress];
pktLength ← 1;
RETURN[returnLength: pktLength];
END; -- rGetStateStub.
rGetStub: --PROCEDURE [listenerPupAddress: Pup.Address] RETURNS [name:
-- Rope.ROPE, password: Rope.ROPE]-- RpcPrivate.Dispatcher =
BEGIN
name: Rope.ROPE;
password: Rope.ROPE;
ArgumentOverlay: TYPE = MACHINE DEPENDENT RECORD [
transferIndex (0): RpcControl.ProcedureIndex, listenerPupAddress
(1): Pup.Address];
argPkt: LONG POINTER TO ArgumentOverlay = @pkt.data[0];
pktLength: RpcPrivate.DataLength;
Lupine.CheckPktLength[pkt: pkt, pktLength: 4];
[name, password] ←
rGet[argPkt.listenerPupAddress];
pktLength ← 0;
BEGIN -- Marshal name: Rope.ROPE to pkt.data[pktLength].
pktLength ← Lupine.MarshalRope[name, pkt, pktLength, FALSE];
END; -- Marshal name.
BEGIN -- Marshal password: Rope.ROPE to pkt.data[pktLength].
pktLength ← Lupine.MarshalRope[password, pkt, pktLength, FALSE];
END; -- Marshal password.
RETURN[returnLength: pktLength];
END; -- rGetStub.
OpenDebugStreamStub: --PROCEDURE [listenerPupAddress: Pup.Address,
-- newListenerPupAddress: Pup.Address, name: Rope.ROPE, serverMachine:
-- Rope.ROPE]
-- RETURNS [byteStreamOK: BOOL]-- RpcPrivate.Dispatcher =
BEGIN
listenerPupAddress: Pup.Address;
newListenerPupAddress: Pup.Address;
name: Rope.ROPE;
serverMachine: Rope.ROPE;
ArgumentOverlay: TYPE = MACHINE DEPENDENT RECORD [
transferIndex (0): RpcControl.ProcedureIndex, listenerPupAddress
(1): Pup.Address, newListenerPupAddress (4): Pup.Address];
ResultOverlay: TYPE = MACHINE DEPENDENT RECORD [
byteStreamOK (0): BOOL];
argPkt: LONG POINTER TO ArgumentOverlay = @pkt.data[0];
resPkt: LONG POINTER TO ResultOverlay;
pktLength: RpcPrivate.DataLength ← 7;
BEGIN -- OnePkt.
onePkt: BOOLEAN = lastPkt;
IF ~onePkt THEN BEGIN -- Must move statics from pkt now.
[listenerPupAddress: listenerPupAddress, newListenerPupAddress:
newListenerPupAddress] ← argPkt↑;
END;
BEGIN -- Unmarshal name: Rope.ROPE from pkt.data[pktLength].
[name, pktLength] ← Lupine.UnmarshalRope[pkt, pktLength, FALSE];
END; -- Unmarshal name.
BEGIN -- Unmarshal serverMachine: Rope.ROPE from pkt.data[pktLength].
[serverMachine, pktLength] ← Lupine.UnmarshalRope[pkt, pktLength,
FALSE];
END; -- Unmarshal serverMachine.
Lupine.CheckPktLength[pkt: pkt, pktLength: pktLength];
resPkt ← @pkt.data[0];
IF onePkt
THEN [resPkt.byteStreamOK] ← OpenDebugStream[argPkt.listenerPupAddress,
argPkt.newListenerPupAddress, name, serverMachine]
ELSE [resPkt.byteStreamOK] ← OpenDebugStream[listenerPupAddress,
newListenerPupAddress, name, serverMachine];
END; -- OnePkt.
pktLength ← 1;
RETURN[returnLength: pktLength];
END; -- OpenDebugStreamStub.
OpenSourceViewerStub: --PROCEDURE [listenerPupAddress: Pup.Address,
-- name: Rope.ROPE, index: INT]-- RpcPrivate.Dispatcher =
BEGIN
listenerPupAddress: Pup.Address;
name: Rope.ROPE;
index: INT;
ArgumentOverlay: TYPE = MACHINE DEPENDENT RECORD [
transferIndex (0): RpcControl.ProcedureIndex, listenerPupAddress
(1): Pup.Address, index (4): INT];
argPkt: LONG POINTER TO ArgumentOverlay = @pkt.data[0];
pktLength: RpcPrivate.DataLength ← 6;
BEGIN -- OnePkt.
onePkt: BOOLEAN = lastPkt;
IF ~onePkt THEN BEGIN -- Must move statics from pkt now.
[listenerPupAddress: listenerPupAddress, index: index] ← argPkt↑;
END;
BEGIN -- Unmarshal name: Rope.ROPE from pkt.data[pktLength].
[name, pktLength] ← Lupine.UnmarshalRope[pkt, pktLength, FALSE];
END; -- Unmarshal name.
Lupine.CheckPktLength[pkt: pkt, pktLength: pktLength];
IF onePkt
THEN OpenSourceViewer[argPkt.listenerPupAddress, name, argPkt.index]
ELSE OpenSourceViewer[listenerPupAddress, name, index];
END; -- OnePkt.
pktLength ← 0;
RETURN[returnLength: pktLength];
END; -- OpenSourceViewerStub.
-- Marshall/Unmarshal procedures.
-- No module initialization.
END. -- ComputeServerCallbacksRpcServerImpl.