MICARS_P.C
上传用户:bangxh
上传日期:2007-01-31
资源大小:42235k
文件大小:28k
源码类别:

Windows编程

开发平台:

Visual C++

  1. /* this ALWAYS GENERATED file contains the proxy stub code */
  2. /* File created by MIDL compiler version 3.03.0110 */
  3. /* at Mon Mar 30 03:35:16 1998
  4.  */
  5. /* Compiler settings for micars.idl:
  6.     Os (OptLev=s), W1, Zp8, env=Win32, ms_ext, app_config, c_ext
  7.     error checks: none
  8. */
  9. //@@MIDL_FILE_HEADING(  )
  10. /* verify that the <rpcproxy.h> version is high enough to compile this file*/
  11. #ifndef __REDQ_RPCPROXY_H_VERSION__
  12. #define __REQUIRED_RPCPROXY_H_VERSION__ 440
  13. #endif
  14. #include "rpcproxy.h"
  15. #ifndef __RPCPROXY_H_VERSION__
  16. #error this stub requires an updated version of <rpcproxy.h>
  17. #endif // __RPCPROXY_H_VERSION__
  18. #include "micars.h"
  19. #define TYPE_FORMAT_STRING_SIZE   1                                 
  20. #define PROC_FORMAT_STRING_SIZE   9                                 
  21. typedef struct _MIDL_TYPE_FORMAT_STRING
  22.     {
  23.     short          Pad;
  24.     unsigned char  Format[ TYPE_FORMAT_STRING_SIZE ];
  25.     } MIDL_TYPE_FORMAT_STRING;
  26. typedef struct _MIDL_PROC_FORMAT_STRING
  27.     {
  28.     short          Pad;
  29.     unsigned char  Format[ PROC_FORMAT_STRING_SIZE ];
  30.     } MIDL_PROC_FORMAT_STRING;
  31. extern const MIDL_TYPE_FORMAT_STRING __MIDL_TypeFormatString;
  32. extern const MIDL_PROC_FORMAT_STRING __MIDL_ProcFormatString;
  33. /* Object interface: IUnknown, ver. 0.0,
  34.    GUID={0x00000000,0x0000,0x0000,{0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}} */
  35. /* Object interface: ICar, ver. 0.0,
  36.    GUID={0x0002da00,0x0000,0x0000,{0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}} */
  37. extern const MIDL_STUB_DESC Object_StubDesc;
  38. #pragma code_seg(".orpc")
  39. HRESULT STDMETHODCALLTYPE ICar_Shift_Proxy( 
  40.     ICar __RPC_FAR * This,
  41.     /* [in] */ short nGear)
  42. {
  43.     HRESULT _RetVal;
  44.     
  45.     RPC_MESSAGE _RpcMessage;
  46.     
  47.     MIDL_STUB_MESSAGE _StubMsg;
  48.     
  49.     RpcTryExcept
  50.         {
  51.         NdrProxyInitialize(
  52.                       ( void __RPC_FAR *  )This,
  53.                       ( PRPC_MESSAGE  )&_RpcMessage,
  54.                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  55.                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
  56.                       3);
  57.         
  58.         
  59.         
  60.         RpcTryFinally
  61.             {
  62.             
  63.             _StubMsg.BufferLength = 2U;
  64.             NdrProxyGetBuffer(This, &_StubMsg);
  65.             *(( short __RPC_FAR * )_StubMsg.Buffer)++ = nGear;
  66.             
  67.             NdrProxySendReceive(This, &_StubMsg);
  68.             
  69.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  70.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[0] );
  71.             
  72.             _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
  73.             
  74.             }
  75.         RpcFinally
  76.             {
  77.             NdrProxyFreeBuffer(This, &_StubMsg);
  78.             
  79.             }
  80.         RpcEndFinally
  81.         
  82.         }
  83.     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
  84.         {
  85.         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
  86.         }
  87.     RpcEndExcept
  88.     return _RetVal;
  89. }
  90. void __RPC_STUB ICar_Shift_Stub(
  91.     IRpcStubBuffer *This,
  92.     IRpcChannelBuffer *_pRpcChannelBuffer,
  93.     PRPC_MESSAGE _pRpcMessage,
  94.     DWORD *_pdwStubPhase)
  95. {
  96.     HRESULT _RetVal;
  97.     MIDL_STUB_MESSAGE _StubMsg;
  98.     short nGear;
  99.     
  100. NdrStubInitialize(
  101.                      _pRpcMessage,
  102.                      &_StubMsg,
  103.                      &Object_StubDesc,
  104.                      _pRpcChannelBuffer);
  105.     RpcTryFinally
  106.         {
  107.         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  108.             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[0] );
  109.         
  110.         nGear = *(( short __RPC_FAR * )_StubMsg.Buffer)++;
  111.         
  112.         
  113.         *_pdwStubPhase = STUB_CALL_SERVER;
  114.         _RetVal = (((ICar *) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> Shift((ICar *) ((CStdStubBuffer *)This)->pvServerObject,nGear);
  115.         
  116.         *_pdwStubPhase = STUB_MARSHAL;
  117.         
  118.         _StubMsg.BufferLength = 4U;
  119.         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
  120.         *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
  121.         
  122.         }
  123.     RpcFinally
  124.         {
  125.         }
  126.     RpcEndFinally
  127.     _pRpcMessage->BufferLength = 
  128.         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
  129.     
  130. }
  131. HRESULT STDMETHODCALLTYPE ICar_Clutch_Proxy( 
  132.     ICar __RPC_FAR * This,
  133.     /* [in] */ short nEngaged)
  134. {
  135.     HRESULT _RetVal;
  136.     
  137.     RPC_MESSAGE _RpcMessage;
  138.     
  139.     MIDL_STUB_MESSAGE _StubMsg;
  140.     
  141.     RpcTryExcept
  142.         {
  143.         NdrProxyInitialize(
  144.                       ( void __RPC_FAR *  )This,
  145.                       ( PRPC_MESSAGE  )&_RpcMessage,
  146.                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  147.                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
  148.                       4);
  149.         
  150.         
  151.         
  152.         RpcTryFinally
  153.             {
  154.             
  155.             _StubMsg.BufferLength = 2U;
  156.             NdrProxyGetBuffer(This, &_StubMsg);
  157.             *(( short __RPC_FAR * )_StubMsg.Buffer)++ = nEngaged;
  158.             
  159.             NdrProxySendReceive(This, &_StubMsg);
  160.             
  161.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  162.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[0] );
  163.             
  164.             _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
  165.             
  166.             }
  167.         RpcFinally
  168.             {
  169.             NdrProxyFreeBuffer(This, &_StubMsg);
  170.             
  171.             }
  172.         RpcEndFinally
  173.         
  174.         }
  175.     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
  176.         {
  177.         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
  178.         }
  179.     RpcEndExcept
  180.     return _RetVal;
  181. }
  182. void __RPC_STUB ICar_Clutch_Stub(
  183.     IRpcStubBuffer *This,
  184.     IRpcChannelBuffer *_pRpcChannelBuffer,
  185.     PRPC_MESSAGE _pRpcMessage,
  186.     DWORD *_pdwStubPhase)
  187. {
  188.     HRESULT _RetVal;
  189.     MIDL_STUB_MESSAGE _StubMsg;
  190.     short nEngaged;
  191.     
  192. NdrStubInitialize(
  193.                      _pRpcMessage,
  194.                      &_StubMsg,
  195.                      &Object_StubDesc,
  196.                      _pRpcChannelBuffer);
  197.     RpcTryFinally
  198.         {
  199.         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  200.             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[0] );
  201.         
  202.         nEngaged = *(( short __RPC_FAR * )_StubMsg.Buffer)++;
  203.         
  204.         
  205.         *_pdwStubPhase = STUB_CALL_SERVER;
  206.         _RetVal = (((ICar *) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> Clutch((ICar *) ((CStdStubBuffer *)This)->pvServerObject,nEngaged);
  207.         
  208.         *_pdwStubPhase = STUB_MARSHAL;
  209.         
  210.         _StubMsg.BufferLength = 4U;
  211.         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
  212.         *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
  213.         
  214.         }
  215.     RpcFinally
  216.         {
  217.         }
  218.     RpcEndFinally
  219.     _pRpcMessage->BufferLength = 
  220.         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
  221.     
  222. }
  223. HRESULT STDMETHODCALLTYPE ICar_Speed_Proxy( 
  224.     ICar __RPC_FAR * This,
  225.     /* [in] */ short nMph)
  226. {
  227.     HRESULT _RetVal;
  228.     
  229.     RPC_MESSAGE _RpcMessage;
  230.     
  231.     MIDL_STUB_MESSAGE _StubMsg;
  232.     
  233.     RpcTryExcept
  234.         {
  235.         NdrProxyInitialize(
  236.                       ( void __RPC_FAR *  )This,
  237.                       ( PRPC_MESSAGE  )&_RpcMessage,
  238.                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  239.                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
  240.                       5);
  241.         
  242.         
  243.         
  244.         RpcTryFinally
  245.             {
  246.             
  247.             _StubMsg.BufferLength = 2U;
  248.             NdrProxyGetBuffer(This, &_StubMsg);
  249.             *(( short __RPC_FAR * )_StubMsg.Buffer)++ = nMph;
  250.             
  251.             NdrProxySendReceive(This, &_StubMsg);
  252.             
  253.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  254.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[0] );
  255.             
  256.             _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
  257.             
  258.             }
  259.         RpcFinally
  260.             {
  261.             NdrProxyFreeBuffer(This, &_StubMsg);
  262.             
  263.             }
  264.         RpcEndFinally
  265.         
  266.         }
  267.     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
  268.         {
  269.         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
  270.         }
  271.     RpcEndExcept
  272.     return _RetVal;
  273. }
  274. void __RPC_STUB ICar_Speed_Stub(
  275.     IRpcStubBuffer *This,
  276.     IRpcChannelBuffer *_pRpcChannelBuffer,
  277.     PRPC_MESSAGE _pRpcMessage,
  278.     DWORD *_pdwStubPhase)
  279. {
  280.     HRESULT _RetVal;
  281.     MIDL_STUB_MESSAGE _StubMsg;
  282.     short nMph;
  283.     
  284. NdrStubInitialize(
  285.                      _pRpcMessage,
  286.                      &_StubMsg,
  287.                      &Object_StubDesc,
  288.                      _pRpcChannelBuffer);
  289.     RpcTryFinally
  290.         {
  291.         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  292.             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[0] );
  293.         
  294.         nMph = *(( short __RPC_FAR * )_StubMsg.Buffer)++;
  295.         
  296.         
  297.         *_pdwStubPhase = STUB_CALL_SERVER;
  298.         _RetVal = (((ICar *) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> Speed((ICar *) ((CStdStubBuffer *)This)->pvServerObject,nMph);
  299.         
  300.         *_pdwStubPhase = STUB_MARSHAL;
  301.         
  302.         _StubMsg.BufferLength = 4U;
  303.         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
  304.         *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
  305.         
  306.         }
  307.     RpcFinally
  308.         {
  309.         }
  310.     RpcEndFinally
  311.     _pRpcMessage->BufferLength = 
  312.         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
  313.     
  314. }
  315. HRESULT STDMETHODCALLTYPE ICar_Steer_Proxy( 
  316.     ICar __RPC_FAR * This,
  317.     /* [in] */ short nAngle)
  318. {
  319.     HRESULT _RetVal;
  320.     
  321.     RPC_MESSAGE _RpcMessage;
  322.     
  323.     MIDL_STUB_MESSAGE _StubMsg;
  324.     
  325.     RpcTryExcept
  326.         {
  327.         NdrProxyInitialize(
  328.                       ( void __RPC_FAR *  )This,
  329.                       ( PRPC_MESSAGE  )&_RpcMessage,
  330.                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  331.                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
  332.                       6);
  333.         
  334.         
  335.         
  336.         RpcTryFinally
  337.             {
  338.             
  339.             _StubMsg.BufferLength = 2U;
  340.             NdrProxyGetBuffer(This, &_StubMsg);
  341.             *(( short __RPC_FAR * )_StubMsg.Buffer)++ = nAngle;
  342.             
  343.             NdrProxySendReceive(This, &_StubMsg);
  344.             
  345.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  346.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[0] );
  347.             
  348.             _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
  349.             
  350.             }
  351.         RpcFinally
  352.             {
  353.             NdrProxyFreeBuffer(This, &_StubMsg);
  354.             
  355.             }
  356.         RpcEndFinally
  357.         
  358.         }
  359.     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
  360.         {
  361.         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
  362.         }
  363.     RpcEndExcept
  364.     return _RetVal;
  365. }
  366. void __RPC_STUB ICar_Steer_Stub(
  367.     IRpcStubBuffer *This,
  368.     IRpcChannelBuffer *_pRpcChannelBuffer,
  369.     PRPC_MESSAGE _pRpcMessage,
  370.     DWORD *_pdwStubPhase)
  371. {
  372.     HRESULT _RetVal;
  373.     MIDL_STUB_MESSAGE _StubMsg;
  374.     short nAngle;
  375.     
  376. NdrStubInitialize(
  377.                      _pRpcMessage,
  378.                      &_StubMsg,
  379.                      &Object_StubDesc,
  380.                      _pRpcChannelBuffer);
  381.     RpcTryFinally
  382.         {
  383.         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  384.             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[0] );
  385.         
  386.         nAngle = *(( short __RPC_FAR * )_StubMsg.Buffer)++;
  387.         
  388.         
  389.         *_pdwStubPhase = STUB_CALL_SERVER;
  390.         _RetVal = (((ICar *) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> Steer((ICar *) ((CStdStubBuffer *)This)->pvServerObject,nAngle);
  391.         
  392.         *_pdwStubPhase = STUB_MARSHAL;
  393.         
  394.         _StubMsg.BufferLength = 4U;
  395.         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
  396.         *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
  397.         
  398.         }
  399.     RpcFinally
  400.         {
  401.         }
  402.     RpcEndFinally
  403.     _pRpcMessage->BufferLength = 
  404.         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
  405.     
  406. }
  407. const CINTERFACE_PROXY_VTABLE(7) _ICarProxyVtbl = 
  408. {
  409.     &IID_ICar,
  410.     IUnknown_QueryInterface_Proxy,
  411.     IUnknown_AddRef_Proxy,
  412.     IUnknown_Release_Proxy ,
  413.     ICar_Shift_Proxy ,
  414.     ICar_Clutch_Proxy ,
  415.     ICar_Speed_Proxy ,
  416.     ICar_Steer_Proxy
  417. };
  418. static const PRPC_STUB_FUNCTION ICar_table[] =
  419. {
  420.     ICar_Shift_Stub,
  421.     ICar_Clutch_Stub,
  422.     ICar_Speed_Stub,
  423.     ICar_Steer_Stub
  424. };
  425. const CInterfaceStubVtbl _ICarStubVtbl =
  426. {
  427.     &IID_ICar,
  428.     0,
  429.     7,
  430.     &ICar_table[-3],
  431.     CStdStubBuffer_METHODS
  432. };
  433. /* Object interface: IUtility, ver. 0.0,
  434.    GUID={0x0002da01,0x0000,0x0000,{0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}} */
  435. extern const MIDL_STUB_DESC Object_StubDesc;
  436. #pragma code_seg(".orpc")
  437. HRESULT STDMETHODCALLTYPE IUtility_Offroad_Proxy( 
  438.     IUtility __RPC_FAR * This,
  439.     /* [in] */ short nGear)
  440. {
  441.     HRESULT _RetVal;
  442.     
  443.     RPC_MESSAGE _RpcMessage;
  444.     
  445.     MIDL_STUB_MESSAGE _StubMsg;
  446.     
  447.     RpcTryExcept
  448.         {
  449.         NdrProxyInitialize(
  450.                       ( void __RPC_FAR *  )This,
  451.                       ( PRPC_MESSAGE  )&_RpcMessage,
  452.                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  453.                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
  454.                       3);
  455.         
  456.         
  457.         
  458.         RpcTryFinally
  459.             {
  460.             
  461.             _StubMsg.BufferLength = 2U;
  462.             NdrProxyGetBuffer(This, &_StubMsg);
  463.             *(( short __RPC_FAR * )_StubMsg.Buffer)++ = nGear;
  464.             
  465.             NdrProxySendReceive(This, &_StubMsg);
  466.             
  467.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  468.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[0] );
  469.             
  470.             _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
  471.             
  472.             }
  473.         RpcFinally
  474.             {
  475.             NdrProxyFreeBuffer(This, &_StubMsg);
  476.             
  477.             }
  478.         RpcEndFinally
  479.         
  480.         }
  481.     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
  482.         {
  483.         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
  484.         }
  485.     RpcEndExcept
  486.     return _RetVal;
  487. }
  488. void __RPC_STUB IUtility_Offroad_Stub(
  489.     IRpcStubBuffer *This,
  490.     IRpcChannelBuffer *_pRpcChannelBuffer,
  491.     PRPC_MESSAGE _pRpcMessage,
  492.     DWORD *_pdwStubPhase)
  493. {
  494.     HRESULT _RetVal;
  495.     MIDL_STUB_MESSAGE _StubMsg;
  496.     short nGear;
  497.     
  498. NdrStubInitialize(
  499.                      _pRpcMessage,
  500.                      &_StubMsg,
  501.                      &Object_StubDesc,
  502.                      _pRpcChannelBuffer);
  503.     RpcTryFinally
  504.         {
  505.         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  506.             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[0] );
  507.         
  508.         nGear = *(( short __RPC_FAR * )_StubMsg.Buffer)++;
  509.         
  510.         
  511.         *_pdwStubPhase = STUB_CALL_SERVER;
  512.         _RetVal = (((IUtility *) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> Offroad((IUtility *) ((CStdStubBuffer *)This)->pvServerObject,nGear);
  513.         
  514.         *_pdwStubPhase = STUB_MARSHAL;
  515.         
  516.         _StubMsg.BufferLength = 4U;
  517.         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
  518.         *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
  519.         
  520.         }
  521.     RpcFinally
  522.         {
  523.         }
  524.     RpcEndFinally
  525.     _pRpcMessage->BufferLength = 
  526.         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
  527.     
  528. }
  529. HRESULT STDMETHODCALLTYPE IUtility_Winch_Proxy( 
  530.     IUtility __RPC_FAR * This,
  531.     /* [in] */ short nRpm)
  532. {
  533.     HRESULT _RetVal;
  534.     
  535.     RPC_MESSAGE _RpcMessage;
  536.     
  537.     MIDL_STUB_MESSAGE _StubMsg;
  538.     
  539.     RpcTryExcept
  540.         {
  541.         NdrProxyInitialize(
  542.                       ( void __RPC_FAR *  )This,
  543.                       ( PRPC_MESSAGE  )&_RpcMessage,
  544.                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  545.                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
  546.                       4);
  547.         
  548.         
  549.         
  550.         RpcTryFinally
  551.             {
  552.             
  553.             _StubMsg.BufferLength = 2U;
  554.             NdrProxyGetBuffer(This, &_StubMsg);
  555.             *(( short __RPC_FAR * )_StubMsg.Buffer)++ = nRpm;
  556.             
  557.             NdrProxySendReceive(This, &_StubMsg);
  558.             
  559.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  560.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[0] );
  561.             
  562.             _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
  563.             
  564.             }
  565.         RpcFinally
  566.             {
  567.             NdrProxyFreeBuffer(This, &_StubMsg);
  568.             
  569.             }
  570.         RpcEndFinally
  571.         
  572.         }
  573.     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
  574.         {
  575.         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
  576.         }
  577.     RpcEndExcept
  578.     return _RetVal;
  579. }
  580. void __RPC_STUB IUtility_Winch_Stub(
  581.     IRpcStubBuffer *This,
  582.     IRpcChannelBuffer *_pRpcChannelBuffer,
  583.     PRPC_MESSAGE _pRpcMessage,
  584.     DWORD *_pdwStubPhase)
  585. {
  586.     HRESULT _RetVal;
  587.     MIDL_STUB_MESSAGE _StubMsg;
  588.     short nRpm;
  589.     
  590. NdrStubInitialize(
  591.                      _pRpcMessage,
  592.                      &_StubMsg,
  593.                      &Object_StubDesc,
  594.                      _pRpcChannelBuffer);
  595.     RpcTryFinally
  596.         {
  597.         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  598.             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[0] );
  599.         
  600.         nRpm = *(( short __RPC_FAR * )_StubMsg.Buffer)++;
  601.         
  602.         
  603.         *_pdwStubPhase = STUB_CALL_SERVER;
  604.         _RetVal = (((IUtility *) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> Winch((IUtility *) ((CStdStubBuffer *)This)->pvServerObject,nRpm);
  605.         
  606.         *_pdwStubPhase = STUB_MARSHAL;
  607.         
  608.         _StubMsg.BufferLength = 4U;
  609.         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
  610.         *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
  611.         
  612.         }
  613.     RpcFinally
  614.         {
  615.         }
  616.     RpcEndFinally
  617.     _pRpcMessage->BufferLength = 
  618.         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
  619.     
  620. }
  621. const CINTERFACE_PROXY_VTABLE(5) _IUtilityProxyVtbl = 
  622. {
  623.     &IID_IUtility,
  624.     IUnknown_QueryInterface_Proxy,
  625.     IUnknown_AddRef_Proxy,
  626.     IUnknown_Release_Proxy ,
  627.     IUtility_Offroad_Proxy ,
  628.     IUtility_Winch_Proxy
  629. };
  630. static const PRPC_STUB_FUNCTION IUtility_table[] =
  631. {
  632.     IUtility_Offroad_Stub,
  633.     IUtility_Winch_Stub
  634. };
  635. const CInterfaceStubVtbl _IUtilityStubVtbl =
  636. {
  637.     &IID_IUtility,
  638.     0,
  639.     5,
  640.     &IUtility_table[-3],
  641.     CStdStubBuffer_METHODS
  642. };
  643. /* Object interface: ICruise, ver. 0.0,
  644.    GUID={0x0002da02,0x0000,0x0000,{0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}} */
  645. extern const MIDL_STUB_DESC Object_StubDesc;
  646. #pragma code_seg(".orpc")
  647. HRESULT STDMETHODCALLTYPE ICruise_Engage_Proxy( 
  648.     ICruise __RPC_FAR * This,
  649.     /* [in] */ BOOL bOnOff)
  650. {
  651.     HRESULT _RetVal;
  652.     
  653.     RPC_MESSAGE _RpcMessage;
  654.     
  655.     MIDL_STUB_MESSAGE _StubMsg;
  656.     
  657.     RpcTryExcept
  658.         {
  659.         NdrProxyInitialize(
  660.                       ( void __RPC_FAR *  )This,
  661.                       ( PRPC_MESSAGE  )&_RpcMessage,
  662.                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  663.                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
  664.                       3);
  665.         
  666.         
  667.         
  668.         RpcTryFinally
  669.             {
  670.             
  671.             _StubMsg.BufferLength = 4U;
  672.             NdrProxyGetBuffer(This, &_StubMsg);
  673.             *(( BOOL __RPC_FAR * )_StubMsg.Buffer)++ = bOnOff;
  674.             
  675.             NdrProxySendReceive(This, &_StubMsg);
  676.             
  677.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  678.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[4] );
  679.             
  680.             _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
  681.             
  682.             }
  683.         RpcFinally
  684.             {
  685.             NdrProxyFreeBuffer(This, &_StubMsg);
  686.             
  687.             }
  688.         RpcEndFinally
  689.         
  690.         }
  691.     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
  692.         {
  693.         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
  694.         }
  695.     RpcEndExcept
  696.     return _RetVal;
  697. }
  698. void __RPC_STUB ICruise_Engage_Stub(
  699.     IRpcStubBuffer *This,
  700.     IRpcChannelBuffer *_pRpcChannelBuffer,
  701.     PRPC_MESSAGE _pRpcMessage,
  702.     DWORD *_pdwStubPhase)
  703. {
  704.     HRESULT _RetVal;
  705.     MIDL_STUB_MESSAGE _StubMsg;
  706.     BOOL bOnOff;
  707.     
  708. NdrStubInitialize(
  709.                      _pRpcMessage,
  710.                      &_StubMsg,
  711.                      &Object_StubDesc,
  712.                      _pRpcChannelBuffer);
  713.     RpcTryFinally
  714.         {
  715.         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  716.             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[4] );
  717.         
  718.         bOnOff = *(( BOOL __RPC_FAR * )_StubMsg.Buffer)++;
  719.         
  720.         
  721.         *_pdwStubPhase = STUB_CALL_SERVER;
  722.         _RetVal = (((ICruise *) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> Engage((ICruise *) ((CStdStubBuffer *)This)->pvServerObject,bOnOff);
  723.         
  724.         *_pdwStubPhase = STUB_MARSHAL;
  725.         
  726.         _StubMsg.BufferLength = 4U;
  727.         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
  728.         *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
  729.         
  730.         }
  731.     RpcFinally
  732.         {
  733.         }
  734.     RpcEndFinally
  735.     _pRpcMessage->BufferLength = 
  736.         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
  737.     
  738. }
  739. HRESULT STDMETHODCALLTYPE ICruise_Adjust_Proxy( 
  740.     ICruise __RPC_FAR * This,
  741.     /* [in] */ BOOL bUpDown)
  742. {
  743.     HRESULT _RetVal;
  744.     
  745.     RPC_MESSAGE _RpcMessage;
  746.     
  747.     MIDL_STUB_MESSAGE _StubMsg;
  748.     
  749.     RpcTryExcept
  750.         {
  751.         NdrProxyInitialize(
  752.                       ( void __RPC_FAR *  )This,
  753.                       ( PRPC_MESSAGE  )&_RpcMessage,
  754.                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  755.                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
  756.                       4);
  757.         
  758.         
  759.         
  760.         RpcTryFinally
  761.             {
  762.             
  763.             _StubMsg.BufferLength = 4U;
  764.             NdrProxyGetBuffer(This, &_StubMsg);
  765.             *(( BOOL __RPC_FAR * )_StubMsg.Buffer)++ = bUpDown;
  766.             
  767.             NdrProxySendReceive(This, &_StubMsg);
  768.             
  769.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  770.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[4] );
  771.             
  772.             _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
  773.             
  774.             }
  775.         RpcFinally
  776.             {
  777.             NdrProxyFreeBuffer(This, &_StubMsg);
  778.             
  779.             }
  780.         RpcEndFinally
  781.         
  782.         }
  783.     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
  784.         {
  785.         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
  786.         }
  787.     RpcEndExcept
  788.     return _RetVal;
  789. }
  790. void __RPC_STUB ICruise_Adjust_Stub(
  791.     IRpcStubBuffer *This,
  792.     IRpcChannelBuffer *_pRpcChannelBuffer,
  793.     PRPC_MESSAGE _pRpcMessage,
  794.     DWORD *_pdwStubPhase)
  795. {
  796.     HRESULT _RetVal;
  797.     MIDL_STUB_MESSAGE _StubMsg;
  798.     BOOL bUpDown;
  799.     
  800. NdrStubInitialize(
  801.                      _pRpcMessage,
  802.                      &_StubMsg,
  803.                      &Object_StubDesc,
  804.                      _pRpcChannelBuffer);
  805.     RpcTryFinally
  806.         {
  807.         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  808.             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[4] );
  809.         
  810.         bUpDown = *(( BOOL __RPC_FAR * )_StubMsg.Buffer)++;
  811.         
  812.         
  813.         *_pdwStubPhase = STUB_CALL_SERVER;
  814.         _RetVal = (((ICruise *) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> Adjust((ICruise *) ((CStdStubBuffer *)This)->pvServerObject,bUpDown);
  815.         
  816.         *_pdwStubPhase = STUB_MARSHAL;
  817.         
  818.         _StubMsg.BufferLength = 4U;
  819.         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
  820.         *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
  821.         
  822.         }
  823.     RpcFinally
  824.         {
  825.         }
  826.     RpcEndFinally
  827.     _pRpcMessage->BufferLength = 
  828.         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
  829.     
  830. }
  831. static const MIDL_STUB_DESC Object_StubDesc = 
  832.     {
  833.     0,
  834.     NdrOleAllocate,
  835.     NdrOleFree,
  836.     0,
  837.     0,
  838.     0,
  839.     0,
  840.     0,
  841.     __MIDL_TypeFormatString.Format,
  842.     0, /* -error bounds_check flag */
  843.     0x10001, /* Ndr library version */
  844.     0,
  845.     0x303006e, /* MIDL Version 3.3.110 */
  846.     0,
  847.     0,
  848.     0,  /* Reserved1 */
  849.     0,  /* Reserved2 */
  850.     0,  /* Reserved3 */
  851.     0,  /* Reserved4 */
  852.     0   /* Reserved5 */
  853.     };
  854. const CINTERFACE_PROXY_VTABLE(5) _ICruiseProxyVtbl = 
  855. {
  856.     &IID_ICruise,
  857.     IUnknown_QueryInterface_Proxy,
  858.     IUnknown_AddRef_Proxy,
  859.     IUnknown_Release_Proxy ,
  860.     ICruise_Engage_Proxy ,
  861.     ICruise_Adjust_Proxy
  862. };
  863. static const PRPC_STUB_FUNCTION ICruise_table[] =
  864. {
  865.     ICruise_Engage_Stub,
  866.     ICruise_Adjust_Stub
  867. };
  868. const CInterfaceStubVtbl _ICruiseStubVtbl =
  869. {
  870.     &IID_ICruise,
  871.     0,
  872.     5,
  873.     &ICruise_table[-3],
  874.     CStdStubBuffer_METHODS
  875. };
  876. #pragma data_seg(".rdata")
  877. #if !defined(__RPC_WIN32__)
  878. #error  Invalid build platform for this stub.
  879. #endif
  880. static const MIDL_PROC_FORMAT_STRING __MIDL_ProcFormatString =
  881.     {
  882.         0,
  883.         {
  884. 0x4e, /* FC_IN_PARAM_BASETYPE */
  885. 0x6, /* FC_SHORT */
  886. /*  2 */ 0x53, /* FC_RETURN_PARAM_BASETYPE */
  887. 0x8, /* FC_LONG */
  888. /*  4 */ 0x4e, /* FC_IN_PARAM_BASETYPE */
  889. 0x8, /* FC_LONG */
  890. /*  6 */ 0x53, /* FC_RETURN_PARAM_BASETYPE */
  891. 0x8, /* FC_LONG */
  892. 0x0
  893.         }
  894.     };
  895. static const MIDL_TYPE_FORMAT_STRING __MIDL_TypeFormatString =
  896.     {
  897.         0,
  898.         {
  899. 0x0
  900.         }
  901.     };
  902. const CInterfaceProxyVtbl * _micars_ProxyVtblList[] = 
  903. {
  904.     ( CInterfaceProxyVtbl *) &_ICarProxyVtbl,
  905.     ( CInterfaceProxyVtbl *) &_IUtilityProxyVtbl,
  906.     ( CInterfaceProxyVtbl *) &_ICruiseProxyVtbl,
  907.     0
  908. };
  909. const CInterfaceStubVtbl * _micars_StubVtblList[] = 
  910. {
  911.     ( CInterfaceStubVtbl *) &_ICarStubVtbl,
  912.     ( CInterfaceStubVtbl *) &_IUtilityStubVtbl,
  913.     ( CInterfaceStubVtbl *) &_ICruiseStubVtbl,
  914.     0
  915. };
  916. PCInterfaceName const _micars_InterfaceNamesList[] = 
  917. {
  918.     "ICar",
  919.     "IUtility",
  920.     "ICruise",
  921.     0
  922. };
  923. #define _micars_CHECK_IID(n) IID_GENERIC_CHECK_IID( _micars, pIID, n)
  924. int __stdcall _micars_IID_Lookup( const IID * pIID, int * pIndex )
  925. {
  926.     IID_BS_LOOKUP_SETUP
  927.     IID_BS_LOOKUP_INITIAL_TEST( _micars, 3, 2 )
  928.     IID_BS_LOOKUP_NEXT_TEST( _micars, 1 )
  929.     IID_BS_LOOKUP_RETURN_RESULT( _micars, 3, *pIndex )
  930.     
  931. }
  932. const ExtendedProxyFileInfo micars_ProxyFileInfo = 
  933. {
  934.     (PCInterfaceProxyVtblList *) & _micars_ProxyVtblList,
  935.     (PCInterfaceStubVtblList *) & _micars_StubVtblList,
  936.     (const PCInterfaceName * ) & _micars_InterfaceNamesList,
  937.     0, // no delegation
  938.     & _micars_IID_Lookup, 
  939.     3,
  940.     1
  941. };