-- 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.