-- Stub file  was translated on December 19, 1983 1:38 pm by Lupine of October 25, 1983 10:51 am
-- Source interface Lark came from file Lark.bcd, which was created on December 19, 1983 1:34 pm with version stamp 363B#357B#6104565341B from source of December 19, 1983 1:34 pm.

-- The RPC stub modules for Lark are:
--   LarkRpcControl.mesa;
--   LarkRpcClientImpl.mesa;
--   LarkRpcBinderImpl.mesa;
--   LarkRpcServerImpl.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 = TRUE
--   Warn about short POINTER ("MDS") allocations = TRUE
--   Maximum number of dynamic heap NEWs = 50, MDS NEWs = 50
--   Acceptable parameter protocols = VersionRange[1..1].

-- NOTE: Discard this module unless you use dynamic client binding.


DIRECTORY
  Lark,
  LarkRpcControl USING [InterfaceRecord, InterfaceRecordObject],
  LarkRpcClientImpl,
  RPC USING [InterfaceName, Zones],
  SafeStorage USING [EnableFinalization, EstablishFinalization, FinalizationQueue,
      FQEmpty, FQNext, NewFQ];


LarkRpcBinderImpl: MONITOR
  IMPORTS ClientPrototype: LarkRpcClientImpl, RTT: SafeStorage
  EXPORTS LarkRpcControl
  SHARES  Lark, LarkRpcControl
  = BEGIN OPEN RpcControl: LarkRpcControl, RpcPublic: RPC;


-- Dynamic instantiation and binding routines.

  ImportNewInterface: PUBLIC SAFE PROCEDURE [
        interfaceName: RpcPublic.InterfaceName,
        parameterStorage: RpcPublic.Zones ]
      RETURNS [interfaceRecord: RpcControl.InterfaceRecord] =
    TRUSTED BEGIN
    interfaceRecord _ NewInterface[];
    LupineDetails[interfaceRecord].module.ImportInterface [
        interfaceName: interfaceName,
        parameterStorage: parameterStorage
      ! UNWIND => FreeInterface[interfaceRecord] ];
    END;

  UnimportNewInterface: SAFE PROCEDURE [
      interfaceRecord: RpcControl.InterfaceRecord ] =
    TRUSTED BEGIN
    LupineDetails[interfaceRecord].module.UnimportInterface[];
    FreeInterface[interfaceRecord];
    END;

-- Utility routines for interface instantiation and caching.

  ConcreteLupineDetails: TYPE = REF LupineDetailsObject;

  LupineDetailsObject:  PUBLIC TYPE = RECORD [
        module: ClientModule_NIL,
        list: RpcControl.InterfaceRecord_NIL, --package reference
        next: RpcControl.InterfaceRecord_NIL --free list -- ];

  LupineDetails: PROCEDURE [abstractInterface: RpcControl.InterfaceRecord]
      RETURNS [ConcreteLupineDetails] =
    INLINE {RETURN[abstractInterface.lupineDetails]};

  ClientModule: TYPE = POINTER TO FRAME[LarkRpcClientImpl];


  clientInterfaceCache: RpcControl.InterfaceRecord _ NIL; -- free interface
      -- records
  clientInterfaceList: RpcControl.InterfaceRecord _ NIL; -- all interface
      -- records

  NewInterfaceRecord: PUBLIC SAFE PROCEDURE
    RETURNS [interfaceRecord: RpcControl.InterfaceRecord] =
    TRUSTED BEGIN
    interfaceRecord _ NEW[RpcControl.InterfaceRecordObject];
    END;

  NewInterface: PROCEDURE RETURNS [interface: RpcControl.InterfaceRecord]=
    BEGIN
    GetCachedInterface: ENTRY PROCEDURE
        RETURNS [cachedIR: RpcControl.InterfaceRecord] =
      INLINE BEGIN ENABLE UNWIND => NULL;
      IF (cachedIR_clientInterfaceCache) # NIL
        THEN clientInterfaceCache _ LupineDetails[clientInterfaceCache].next;
      END;
    ReclaimInterfaces[];
    IF (interface _ GetCachedInterface[]) = NIL
      THEN BEGIN
        ChainNewInterface: ENTRY PROCEDURE =
          INLINE BEGIN ENABLE UNWIND => NULL;
          interface.lupineDetails _ NEW[
            LupineDetailsObject _ [module: module, list: clientInterfaceList]];
          clientInterfaceList _ interface;
          END; -- ChainNewInterface.
        module: ClientModule = NEW ClientPrototype;
        interface _ NewInterfaceRecord[];
        interface^ _ [
            Reset: module.Reset, GenerateTones: module.GenerateTones, Feep:
            module.Feep, Commands: module.Commands, Connect: module.Connect,
            Disconnect: module.Disconnect, PleaseRegister: module.PleaseRegister,
            WhatIsStatus: module.WhatIsStatus, WhatAreConnections: module.WhatAreConnections,
            WhatAreTones: module.WhatAreTones, SetKeyTable: module.SetKeyTable,
            CommandString: module.CommandString, PleaseLogin: module.PleaseLogin,
            EchoSupression: module.EchoSupression, SetHostNumber: module.SetHostNumber];
        ChainNewInterface[];
        END;
    RTT.EnableFinalization[interface];
    END;

  FreeInterface: ENTRY PROCEDURE [interface: RpcControl.InterfaceRecord]=
    INLINE BEGIN ENABLE UNWIND => NULL;
    LupineDetails[interface].next _ clientInterfaceCache;
    clientInterfaceCache _ interface;
    END;


-- Finalization for dynamic interfaces.  Just cache and reuse for now.

  freedInterfaces: RTT.FinalizationQueue = RTT.NewFQ[20];

  ReclaimInterfaces: PROCEDURE =
    INLINE BEGIN
    WHILE ~RTT.FQEmpty[freedInterfaces] DO
      interface: RpcControl.InterfaceRecord =
        NARROW[RTT.FQNext[freedInterfaces]];
      IF interface.lupineDetails # NIL THEN
        UnimportNewInterface[interface];
      ENDLOOP;
    END;


-- Module initialization.

  RTT.EstablishFinalization[
    type: CODE[RpcControl.InterfaceRecordObject],
    npr: 1,  fq: freedInterfaces ];


END.  -- LarkRpcBinderImpl.