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