home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Windows Gam…ming Gurus (2nd Edition) / Disc2.iso / msdn_vcb / samples / vc98 / com / adosamp / server / adosamp_p.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-04-03  |  138.5 KB  |  4,369 lines
  1. /* this ALWAYS GENERATED file contains the proxy stub code */
  2.  
  3.  
  4. /* File created by MIDL compiler version 3.03.0110 */
  5. /* at Wed Feb 04 11:49:00 1998
  6.  */
  7. /* Compiler settings for .\ADOSamp.idl:
  8.     Os (OptLev=s), W1, Zp8, env=Win32, ms_ext, c_ext
  9.     error checks: none
  10. */
  11. //@@MIDL_FILE_HEADING(  )
  12.  
  13.  
  14. /* verify that the <rpcproxy.h> version is high enough to compile this file*/
  15. #ifndef __REDQ_RPCPROXY_H_VERSION__
  16. #define __REQUIRED_RPCPROXY_H_VERSION__ 440
  17. #endif
  18.  
  19.  
  20. #include "rpcproxy.h"
  21. #ifndef __RPCPROXY_H_VERSION__
  22. #error this stub requires an updated version of <rpcproxy.h>
  23. #endif // __RPCPROXY_H_VERSION__
  24.  
  25.  
  26. #include "ADOSamp.h"
  27.  
  28. #define TYPE_FORMAT_STRING_SIZE   1173                              
  29. #define PROC_FORMAT_STRING_SIZE   141                               
  30.  
  31. typedef struct _MIDL_TYPE_FORMAT_STRING
  32.     {
  33.     short          Pad;
  34.     unsigned char  Format[ TYPE_FORMAT_STRING_SIZE ];
  35.     } MIDL_TYPE_FORMAT_STRING;
  36.  
  37. typedef struct _MIDL_PROC_FORMAT_STRING
  38.     {
  39.     short          Pad;
  40.     unsigned char  Format[ PROC_FORMAT_STRING_SIZE ];
  41.     } MIDL_PROC_FORMAT_STRING;
  42.  
  43.  
  44. extern const MIDL_TYPE_FORMAT_STRING __MIDL_TypeFormatString;
  45. extern const MIDL_PROC_FORMAT_STRING __MIDL_ProcFormatString;
  46.  
  47.  
  48. /* Standard interface: __MIDL_itf_ADOSamp_0000, ver. 0.0,
  49.    GUID={0x00000000,0x0000,0x0000,{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}} */
  50.  
  51.  
  52. /* Object interface: IUnknown, ver. 0.0,
  53.    GUID={0x00000000,0x0000,0x0000,{0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}} */
  54.  
  55.  
  56. /* Object interface: IDispatch, ver. 0.0,
  57.    GUID={0x00020400,0x0000,0x0000,{0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}} */
  58.  
  59.  
  60. /* Object interface: IADOTier, ver. 0.0,
  61.    GUID={0x7A319993,0x48C0,0x11D0,{0xAE,0x70,0x00,0xC0,0x4F,0xD7,0xD0,0x6E}} */
  62.  
  63.  
  64. extern const MIDL_STUB_DESC Object_StubDesc;
  65.  
  66.  
  67. #pragma code_seg(".orpc")
  68.  
  69. /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE IADOTier_Open_Proxy( 
  70.     IADOTier __RPC_FAR * This,
  71.     /* [in] */ BSTR source,
  72.     /* [in] */ BSTR user,
  73.     /* [in] */ BSTR pwd)
  74. {
  75.  
  76.     HRESULT _RetVal;
  77.     
  78.     RPC_MESSAGE _RpcMessage;
  79.     
  80.     MIDL_STUB_MESSAGE _StubMsg;
  81.     
  82.     RpcTryExcept
  83.         {
  84.         NdrProxyInitialize(
  85.                       ( void __RPC_FAR *  )This,
  86.                       ( PRPC_MESSAGE  )&_RpcMessage,
  87.                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  88.                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
  89.                       7);
  90.         
  91.         
  92.         
  93.         RpcTryFinally
  94.             {
  95.             
  96.             _StubMsg.BufferLength = 4U + 11U + 11U;
  97.             NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
  98.                                       (unsigned char __RPC_FAR *)&source,
  99.                                       (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[24] );
  100.             
  101.             NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
  102.                                       (unsigned char __RPC_FAR *)&user,
  103.                                       (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[34] );
  104.             
  105.             NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
  106.                                       (unsigned char __RPC_FAR *)&pwd,
  107.                                       (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[44] );
  108.             
  109.             NdrProxyGetBuffer(This, &_StubMsg);
  110.             NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
  111.                                     (unsigned char __RPC_FAR *)&source,
  112.                                     (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[24] );
  113.             
  114.             NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
  115.                                     (unsigned char __RPC_FAR *)&user,
  116.                                     (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[34] );
  117.             
  118.             NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
  119.                                     (unsigned char __RPC_FAR *)&pwd,
  120.                                     (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[44] );
  121.             
  122.             NdrProxySendReceive(This, &_StubMsg);
  123.             
  124.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  125.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[0] );
  126.             
  127.             _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
  128.             
  129.             }
  130.         RpcFinally
  131.             {
  132.             NdrProxyFreeBuffer(This, &_StubMsg);
  133.             
  134.             }
  135.         RpcEndFinally
  136.         
  137.         }
  138.     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
  139.         {
  140.         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
  141.         }
  142.     RpcEndExcept
  143.     return _RetVal;
  144. }
  145.  
  146. void __RPC_STUB IADOTier_Open_Stub(
  147.     IRpcStubBuffer *This,
  148.     IRpcChannelBuffer *_pRpcChannelBuffer,
  149.     PRPC_MESSAGE _pRpcMessage,
  150.     DWORD *_pdwStubPhase)
  151. {
  152.     HRESULT _RetVal;
  153.     MIDL_STUB_MESSAGE _StubMsg;
  154.     void __RPC_FAR *_p_pwd;
  155.     void __RPC_FAR *_p_source;
  156.     void __RPC_FAR *_p_user;
  157.     BSTR pwd;
  158.     BSTR source;
  159.     BSTR user;
  160.     
  161. NdrStubInitialize(
  162.                      _pRpcMessage,
  163.                      &_StubMsg,
  164.                      &Object_StubDesc,
  165.                      _pRpcChannelBuffer);
  166.     _p_source = &source;
  167.     MIDL_memset(
  168.                _p_source,
  169.                0,
  170.                sizeof( BSTR  ));
  171.     _p_user = &user;
  172.     MIDL_memset(
  173.                _p_user,
  174.                0,
  175.                sizeof( BSTR  ));
  176.     _p_pwd = &pwd;
  177.     MIDL_memset(
  178.                _p_pwd,
  179.                0,
  180.                sizeof( BSTR  ));
  181.     RpcTryFinally
  182.         {
  183.         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  184.             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[0] );
  185.         
  186.         NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
  187.                                   (unsigned char __RPC_FAR * __RPC_FAR *)&_p_source,
  188.                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[24],
  189.                                   (unsigned char)0 );
  190.         
  191.         NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
  192.                                   (unsigned char __RPC_FAR * __RPC_FAR *)&_p_user,
  193.                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[34],
  194.                                   (unsigned char)0 );
  195.         
  196.         NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
  197.                                   (unsigned char __RPC_FAR * __RPC_FAR *)&_p_pwd,
  198.                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[44],
  199.                                   (unsigned char)0 );
  200.         
  201.         
  202.         *_pdwStubPhase = STUB_CALL_SERVER;
  203.         _RetVal = (((IADOTier *) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> Open(
  204.         (IADOTier *) ((CStdStubBuffer *)This)->pvServerObject,
  205.         source,
  206.         user,
  207.         pwd);
  208.         
  209.         *_pdwStubPhase = STUB_MARSHAL;
  210.         
  211.         _StubMsg.BufferLength = 4U;
  212.         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
  213.         *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
  214.         
  215.         }
  216.     RpcFinally
  217.         {
  218.         NdrUserMarshalFree( &_StubMsg,
  219.                             (unsigned char __RPC_FAR *)&source,
  220.                             &__MIDL_TypeFormatString.Format[24] );
  221.         
  222.         NdrUserMarshalFree( &_StubMsg,
  223.                             (unsigned char __RPC_FAR *)&user,
  224.                             &__MIDL_TypeFormatString.Format[34] );
  225.         
  226.         NdrUserMarshalFree( &_StubMsg,
  227.                             (unsigned char __RPC_FAR *)&pwd,
  228.                             &__MIDL_TypeFormatString.Format[44] );
  229.         
  230.         }
  231.     RpcEndFinally
  232.     _pRpcMessage->BufferLength = 
  233.         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
  234.     
  235. }
  236.  
  237.  
  238. /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE IADOTier_OpenRecordset_Proxy( 
  239.     IADOTier __RPC_FAR * This,
  240.     /* [in] */ VARIANT query)
  241. {
  242.  
  243.     HRESULT _RetVal;
  244.     
  245.     RPC_MESSAGE _RpcMessage;
  246.     
  247.     MIDL_STUB_MESSAGE _StubMsg;
  248.     
  249.     RpcTryExcept
  250.         {
  251.         NdrProxyInitialize(
  252.                       ( void __RPC_FAR *  )This,
  253.                       ( PRPC_MESSAGE  )&_RpcMessage,
  254.                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  255.                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
  256.                       8);
  257.         
  258.         
  259.         
  260.         RpcTryFinally
  261.             {
  262.             
  263.             _StubMsg.BufferLength = 4U;
  264.             NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
  265.                                       (unsigned char __RPC_FAR *)&query,
  266.                                       (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[988] );
  267.             
  268.             NdrProxyGetBuffer(This, &_StubMsg);
  269.             NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
  270.                                     (unsigned char __RPC_FAR *)&query,
  271.                                     (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[988] );
  272.             
  273.             NdrProxySendReceive(This, &_StubMsg);
  274.             
  275.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  276.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[14] );
  277.             
  278.             _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
  279.             
  280.             }
  281.         RpcFinally
  282.             {
  283.             NdrProxyFreeBuffer(This, &_StubMsg);
  284.             
  285.             }
  286.         RpcEndFinally
  287.         
  288.         }
  289.     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
  290.         {
  291.         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
  292.         }
  293.     RpcEndExcept
  294.     return _RetVal;
  295. }
  296.  
  297. void __RPC_STUB IADOTier_OpenRecordset_Stub(
  298.     IRpcStubBuffer *This,
  299.     IRpcChannelBuffer *_pRpcChannelBuffer,
  300.     PRPC_MESSAGE _pRpcMessage,
  301.     DWORD *_pdwStubPhase)
  302. {
  303.     HRESULT _RetVal;
  304.     MIDL_STUB_MESSAGE _StubMsg;
  305.     void __RPC_FAR *_p_query;
  306.     VARIANT query;
  307.     
  308. NdrStubInitialize(
  309.                      _pRpcMessage,
  310.                      &_StubMsg,
  311.                      &Object_StubDesc,
  312.                      _pRpcChannelBuffer);
  313.     _p_query = &query;
  314.     MIDL_memset(
  315.                _p_query,
  316.                0,
  317.                sizeof( VARIANT  ));
  318.     RpcTryFinally
  319.         {
  320.         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  321.             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[14] );
  322.         
  323.         NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
  324.                                   (unsigned char __RPC_FAR * __RPC_FAR *)&_p_query,
  325.                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[988],
  326.                                   (unsigned char)0 );
  327.         
  328.         
  329.         *_pdwStubPhase = STUB_CALL_SERVER;
  330.         _RetVal = (((IADOTier *) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> OpenRecordset((IADOTier *) ((CStdStubBuffer *)This)->pvServerObject,query);
  331.         
  332.         *_pdwStubPhase = STUB_MARSHAL;
  333.         
  334.         _StubMsg.BufferLength = 4U;
  335.         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
  336.         *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
  337.         
  338.         }
  339.     RpcFinally
  340.         {
  341.         NdrUserMarshalFree( &_StubMsg,
  342.                             (unsigned char __RPC_FAR *)&query,
  343.                             &__MIDL_TypeFormatString.Format[988] );
  344.         
  345.         }
  346.     RpcEndFinally
  347.     _pRpcMessage->BufferLength = 
  348.         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
  349.     
  350. }
  351.  
  352.  
  353. /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE IADOTier_CloseRecordset_Proxy( 
  354.     IADOTier __RPC_FAR * This)
  355. {
  356.  
  357.     HRESULT _RetVal;
  358.     
  359.     RPC_MESSAGE _RpcMessage;
  360.     
  361.     MIDL_STUB_MESSAGE _StubMsg;
  362.     
  363.     RpcTryExcept
  364.         {
  365.         NdrProxyInitialize(
  366.                       ( void __RPC_FAR *  )This,
  367.                       ( PRPC_MESSAGE  )&_RpcMessage,
  368.                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  369.                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
  370.                       9);
  371.         
  372.         
  373.         
  374.         RpcTryFinally
  375.             {
  376.             
  377.             _StubMsg.BufferLength = 0U;
  378.             NdrProxyGetBuffer(This, &_StubMsg);
  379.             NdrProxySendReceive(This, &_StubMsg);
  380.             
  381.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  382.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[20] );
  383.             
  384.             _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
  385.             
  386.             }
  387.         RpcFinally
  388.             {
  389.             NdrProxyFreeBuffer(This, &_StubMsg);
  390.             
  391.             }
  392.         RpcEndFinally
  393.         
  394.         }
  395.     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
  396.         {
  397.         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
  398.         }
  399.     RpcEndExcept
  400.     return _RetVal;
  401. }
  402.  
  403. void __RPC_STUB IADOTier_CloseRecordset_Stub(
  404.     IRpcStubBuffer *This,
  405.     IRpcChannelBuffer *_pRpcChannelBuffer,
  406.     PRPC_MESSAGE _pRpcMessage,
  407.     DWORD *_pdwStubPhase)
  408. {
  409.     HRESULT _RetVal;
  410.     MIDL_STUB_MESSAGE _StubMsg;
  411.     
  412. NdrStubInitialize(
  413.                      _pRpcMessage,
  414.                      &_StubMsg,
  415.                      &Object_StubDesc,
  416.                      _pRpcChannelBuffer);
  417.     RpcTryFinally
  418.         {
  419.         
  420.         *_pdwStubPhase = STUB_CALL_SERVER;
  421.         _RetVal = (((IADOTier *) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> CloseRecordset((IADOTier *) ((CStdStubBuffer *)This)->pvServerObject);
  422.         
  423.         *_pdwStubPhase = STUB_MARSHAL;
  424.         
  425.         _StubMsg.BufferLength = 4U;
  426.         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
  427.         *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
  428.         
  429.         }
  430.     RpcFinally
  431.         {
  432.         }
  433.     RpcEndFinally
  434.     _pRpcMessage->BufferLength = 
  435.         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
  436.     
  437. }
  438.  
  439.  
  440. /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE IADOTier_ExecuteConnection_Proxy( 
  441.     IADOTier __RPC_FAR * This,
  442.     /* [in] */ BSTR query,
  443.     /* [in] */ VARIANT_BOOL bChangeRec)
  444. {
  445.  
  446.     HRESULT _RetVal;
  447.     
  448.     RPC_MESSAGE _RpcMessage;
  449.     
  450.     MIDL_STUB_MESSAGE _StubMsg;
  451.     
  452.     RpcTryExcept
  453.         {
  454.         NdrProxyInitialize(
  455.                       ( void __RPC_FAR *  )This,
  456.                       ( PRPC_MESSAGE  )&_RpcMessage,
  457.                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  458.                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
  459.                       10);
  460.         
  461.         
  462.         
  463.         RpcTryFinally
  464.             {
  465.             
  466.             _StubMsg.BufferLength = 4U + 5U;
  467.             NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
  468.                                       (unsigned char __RPC_FAR *)&query,
  469.                                       (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[998] );
  470.             
  471.             NdrProxyGetBuffer(This, &_StubMsg);
  472.             NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
  473.                                     (unsigned char __RPC_FAR *)&query,
  474.                                     (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[998] );
  475.             
  476.             _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 1) & ~ 0x1);
  477.             *(( VARIANT_BOOL __RPC_FAR * )_StubMsg.Buffer)++ = bChangeRec;
  478.             
  479.             NdrProxySendReceive(This, &_StubMsg);
  480.             
  481.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  482.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[22] );
  483.             
  484.             _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
  485.             
  486.             }
  487.         RpcFinally
  488.             {
  489.             NdrProxyFreeBuffer(This, &_StubMsg);
  490.             
  491.             }
  492.         RpcEndFinally
  493.         
  494.         }
  495.     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
  496.         {
  497.         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
  498.         }
  499.     RpcEndExcept
  500.     return _RetVal;
  501. }
  502.  
  503. void __RPC_STUB IADOTier_ExecuteConnection_Stub(
  504.     IRpcStubBuffer *This,
  505.     IRpcChannelBuffer *_pRpcChannelBuffer,
  506.     PRPC_MESSAGE _pRpcMessage,
  507.     DWORD *_pdwStubPhase)
  508. {
  509.     HRESULT _RetVal;
  510.     MIDL_STUB_MESSAGE _StubMsg;
  511.     void __RPC_FAR *_p_query;
  512.     VARIANT_BOOL bChangeRec;
  513.     BSTR query;
  514.     
  515. NdrStubInitialize(
  516.                      _pRpcMessage,
  517.                      &_StubMsg,
  518.                      &Object_StubDesc,
  519.                      _pRpcChannelBuffer);
  520.     _p_query = &query;
  521.     MIDL_memset(
  522.                _p_query,
  523.                0,
  524.                sizeof( BSTR  ));
  525.     RpcTryFinally
  526.         {
  527.         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  528.             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[22] );
  529.         
  530.         NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
  531.                                   (unsigned char __RPC_FAR * __RPC_FAR *)&_p_query,
  532.                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[998],
  533.                                   (unsigned char)0 );
  534.         
  535.         _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 1) & ~ 0x1);
  536.         bChangeRec = *(( VARIANT_BOOL __RPC_FAR * )_StubMsg.Buffer)++;
  537.         
  538.         
  539.         *_pdwStubPhase = STUB_CALL_SERVER;
  540.         _RetVal = (((IADOTier *) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> ExecuteConnection(
  541.                      (IADOTier *) ((CStdStubBuffer *)This)->pvServerObject,
  542.                      query,
  543.                      bChangeRec);
  544.         
  545.         *_pdwStubPhase = STUB_MARSHAL;
  546.         
  547.         _StubMsg.BufferLength = 4U;
  548.         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
  549.         *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
  550.         
  551.         }
  552.     RpcFinally
  553.         {
  554.         NdrUserMarshalFree( &_StubMsg,
  555.                             (unsigned char __RPC_FAR *)&query,
  556.                             &__MIDL_TypeFormatString.Format[998] );
  557.         
  558.         }
  559.     RpcEndFinally
  560.     _pRpcMessage->BufferLength = 
  561.         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
  562.     
  563. }
  564.  
  565.  
  566. /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE IADOTier_ExecuteCommand_Proxy( 
  567.     IADOTier __RPC_FAR * This,
  568.     /* [in] */ VARIANT_BOOL bStoredProcedure,
  569.     /* [in] */ VARIANT_BOOL bChangeRec)
  570. {
  571.  
  572.     HRESULT _RetVal;
  573.     
  574.     RPC_MESSAGE _RpcMessage;
  575.     
  576.     MIDL_STUB_MESSAGE _StubMsg;
  577.     
  578.     RpcTryExcept
  579.         {
  580.         NdrProxyInitialize(
  581.                       ( void __RPC_FAR *  )This,
  582.                       ( PRPC_MESSAGE  )&_RpcMessage,
  583.                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  584.                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
  585.                       11);
  586.         
  587.         
  588.         
  589.         RpcTryFinally
  590.             {
  591.             
  592.             _StubMsg.BufferLength = 2U + 2U;
  593.             NdrProxyGetBuffer(This, &_StubMsg);
  594.             *(( VARIANT_BOOL __RPC_FAR * )_StubMsg.Buffer)++ = bStoredProcedure;
  595.             
  596.             *(( VARIANT_BOOL __RPC_FAR * )_StubMsg.Buffer)++ = bChangeRec;
  597.             
  598.             NdrProxySendReceive(This, &_StubMsg);
  599.             
  600.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  601.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[30] );
  602.             
  603.             _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
  604.             
  605.             }
  606.         RpcFinally
  607.             {
  608.             NdrProxyFreeBuffer(This, &_StubMsg);
  609.             
  610.             }
  611.         RpcEndFinally
  612.         
  613.         }
  614.     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
  615.         {
  616.         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
  617.         }
  618.     RpcEndExcept
  619.     return _RetVal;
  620. }
  621.  
  622. void __RPC_STUB IADOTier_ExecuteCommand_Stub(
  623.     IRpcStubBuffer *This,
  624.     IRpcChannelBuffer *_pRpcChannelBuffer,
  625.     PRPC_MESSAGE _pRpcMessage,
  626.     DWORD *_pdwStubPhase)
  627. {
  628.     HRESULT _RetVal;
  629.     MIDL_STUB_MESSAGE _StubMsg;
  630.     VARIANT_BOOL bChangeRec;
  631.     VARIANT_BOOL bStoredProcedure;
  632.     
  633. NdrStubInitialize(
  634.                      _pRpcMessage,
  635.                      &_StubMsg,
  636.                      &Object_StubDesc,
  637.                      _pRpcChannelBuffer);
  638.     RpcTryFinally
  639.         {
  640.         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  641.             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[30] );
  642.         
  643.         bStoredProcedure = *(( VARIANT_BOOL __RPC_FAR * )_StubMsg.Buffer)++;
  644.         
  645.         bChangeRec = *(( VARIANT_BOOL __RPC_FAR * )_StubMsg.Buffer)++;
  646.         
  647.         
  648.         *_pdwStubPhase = STUB_CALL_SERVER;
  649.         _RetVal = (((IADOTier *) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> ExecuteCommand(
  650.                   (IADOTier *) ((CStdStubBuffer *)This)->pvServerObject,
  651.                   bStoredProcedure,
  652.                   bChangeRec);
  653.         
  654.         *_pdwStubPhase = STUB_MARSHAL;
  655.         
  656.         _StubMsg.BufferLength = 4U;
  657.         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
  658.         *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
  659.         
  660.         }
  661.     RpcFinally
  662.         {
  663.         }
  664.     RpcEndFinally
  665.     _pRpcMessage->BufferLength = 
  666.         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
  667.     
  668. }
  669.  
  670.  
  671. /* [helpstring][id][propget] */ HRESULT STDMETHODCALLTYPE IADOTier_get_CommandText_Proxy( 
  672.     IADOTier __RPC_FAR * This,
  673.     /* [retval][out] */ BSTR __RPC_FAR *newVal)
  674. {
  675.  
  676.     HRESULT _RetVal;
  677.     
  678.     RPC_MESSAGE _RpcMessage;
  679.     
  680.     MIDL_STUB_MESSAGE _StubMsg;
  681.     
  682.     MIDL_memset(
  683.                newVal,
  684.                0,
  685.                sizeof( BSTR  ));
  686.     RpcTryExcept
  687.         {
  688.         NdrProxyInitialize(
  689.                       ( void __RPC_FAR *  )This,
  690.                       ( PRPC_MESSAGE  )&_RpcMessage,
  691.                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  692.                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
  693.                       12);
  694.         
  695.         
  696.         
  697.         RpcTryFinally
  698.             {
  699.             
  700.             _StubMsg.BufferLength = 0U;
  701.             NdrProxyGetBuffer(This, &_StubMsg);
  702.             NdrProxySendReceive(This, &_StubMsg);
  703.             
  704.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  705.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[36] );
  706.             
  707.             NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
  708.                                       (unsigned char __RPC_FAR * __RPC_FAR *)&newVal,
  709.                                       (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1016],
  710.                                       (unsigned char)0 );
  711.             
  712.             _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
  713.             _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
  714.             
  715.             }
  716.         RpcFinally
  717.             {
  718.             NdrProxyFreeBuffer(This, &_StubMsg);
  719.             
  720.             }
  721.         RpcEndFinally
  722.         
  723.         }
  724.     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
  725.         {
  726.         NdrClearOutParameters(
  727.                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  728.                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[1008],
  729.                          ( void __RPC_FAR * )newVal);
  730.         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
  731.         }
  732.     RpcEndExcept
  733.     return _RetVal;
  734. }
  735.  
  736. void __RPC_STUB IADOTier_get_CommandText_Stub(
  737.     IRpcStubBuffer *This,
  738.     IRpcChannelBuffer *_pRpcChannelBuffer,
  739.     PRPC_MESSAGE _pRpcMessage,
  740.     DWORD *_pdwStubPhase)
  741. {
  742.     BSTR _M0;
  743.     HRESULT _RetVal;
  744.     MIDL_STUB_MESSAGE _StubMsg;
  745.     BSTR __RPC_FAR *newVal;
  746.     
  747. NdrStubInitialize(
  748.                      _pRpcMessage,
  749.                      &_StubMsg,
  750.                      &Object_StubDesc,
  751.                      _pRpcChannelBuffer);
  752.     ( BSTR __RPC_FAR * )newVal = 0;
  753.     RpcTryFinally
  754.         {
  755.         newVal = &_M0;
  756.         MIDL_memset(
  757.                newVal,
  758.                0,
  759.                sizeof( BSTR  ));
  760.         
  761.         *_pdwStubPhase = STUB_CALL_SERVER;
  762.         _RetVal = (((IADOTier *) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> get_CommandText((IADOTier *) ((CStdStubBuffer *)This)->pvServerObject,newVal);
  763.         
  764.         *_pdwStubPhase = STUB_MARSHAL;
  765.         
  766.         _StubMsg.BufferLength = 4U + 11U;
  767.         NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
  768.                                   (unsigned char __RPC_FAR *)newVal,
  769.                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1016] );
  770.         
  771.         _StubMsg.BufferLength += 16;
  772.         
  773.         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
  774.         NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
  775.                                 (unsigned char __RPC_FAR *)newVal,
  776.                                 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1016] );
  777.         
  778.         _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
  779.         *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
  780.         
  781.         }
  782.     RpcFinally
  783.         {
  784.         NdrPointerFree( &_StubMsg,
  785.                         (unsigned char __RPC_FAR *)newVal,
  786.                         &__MIDL_TypeFormatString.Format[1008] );
  787.         
  788.         }
  789.     RpcEndFinally
  790.     _pRpcMessage->BufferLength = 
  791.         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
  792.     
  793. }
  794.  
  795.  
  796. /* [helpstring][id][propput] */ HRESULT STDMETHODCALLTYPE IADOTier_put_CommandText_Proxy( 
  797.     IADOTier __RPC_FAR * This,
  798.     /* [in] */ BSTR newVal)
  799. {
  800.  
  801.     HRESULT _RetVal;
  802.     
  803.     RPC_MESSAGE _RpcMessage;
  804.     
  805.     MIDL_STUB_MESSAGE _StubMsg;
  806.     
  807.     RpcTryExcept
  808.         {
  809.         NdrProxyInitialize(
  810.                       ( void __RPC_FAR *  )This,
  811.                       ( PRPC_MESSAGE  )&_RpcMessage,
  812.                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  813.                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
  814.                       13);
  815.         
  816.         
  817.         
  818.         RpcTryFinally
  819.             {
  820.             
  821.             _StubMsg.BufferLength = 4U;
  822.             NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
  823.                                       (unsigned char __RPC_FAR *)&newVal,
  824.                                       (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1026] );
  825.             
  826.             NdrProxyGetBuffer(This, &_StubMsg);
  827.             NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
  828.                                     (unsigned char __RPC_FAR *)&newVal,
  829.                                     (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1026] );
  830.             
  831.             NdrProxySendReceive(This, &_StubMsg);
  832.             
  833.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  834.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[42] );
  835.             
  836.             _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
  837.             
  838.             }
  839.         RpcFinally
  840.             {
  841.             NdrProxyFreeBuffer(This, &_StubMsg);
  842.             
  843.             }
  844.         RpcEndFinally
  845.         
  846.         }
  847.     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
  848.         {
  849.         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
  850.         }
  851.     RpcEndExcept
  852.     return _RetVal;
  853. }
  854.  
  855. void __RPC_STUB IADOTier_put_CommandText_Stub(
  856.     IRpcStubBuffer *This,
  857.     IRpcChannelBuffer *_pRpcChannelBuffer,
  858.     PRPC_MESSAGE _pRpcMessage,
  859.     DWORD *_pdwStubPhase)
  860. {
  861.     HRESULT _RetVal;
  862.     MIDL_STUB_MESSAGE _StubMsg;
  863.     void __RPC_FAR *_p_newVal;
  864.     BSTR newVal;
  865.     
  866. NdrStubInitialize(
  867.                      _pRpcMessage,
  868.                      &_StubMsg,
  869.                      &Object_StubDesc,
  870.                      _pRpcChannelBuffer);
  871.     _p_newVal = &newVal;
  872.     MIDL_memset(
  873.                _p_newVal,
  874.                0,
  875.                sizeof( BSTR  ));
  876.     RpcTryFinally
  877.         {
  878.         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  879.             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[42] );
  880.         
  881.         NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
  882.                                   (unsigned char __RPC_FAR * __RPC_FAR *)&_p_newVal,
  883.                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1026],
  884.                                   (unsigned char)0 );
  885.         
  886.         
  887.         *_pdwStubPhase = STUB_CALL_SERVER;
  888.         _RetVal = (((IADOTier *) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> put_CommandText((IADOTier *) ((CStdStubBuffer *)This)->pvServerObject,newVal);
  889.         
  890.         *_pdwStubPhase = STUB_MARSHAL;
  891.         
  892.         _StubMsg.BufferLength = 4U;
  893.         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
  894.         *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
  895.         
  896.         }
  897.     RpcFinally
  898.         {
  899.         NdrUserMarshalFree( &_StubMsg,
  900.                             (unsigned char __RPC_FAR *)&newVal,
  901.                             &__MIDL_TypeFormatString.Format[1026] );
  902.         
  903.         }
  904.     RpcEndFinally
  905.     _pRpcMessage->BufferLength = 
  906.         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
  907.     
  908. }
  909.  
  910.  
  911. /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE IADOTier_AppendParameter_Proxy( 
  912.     IADOTier __RPC_FAR * This,
  913.     /* [in] */ enum DataTypeEnum type,
  914.     /* [in] */ VARIANT value,
  915.     /* [in] */ enum ParameterDirectionEnum where,
  916.     /* [in] */ long size)
  917. {
  918.  
  919.     HRESULT _RetVal;
  920.     
  921.     RPC_MESSAGE _RpcMessage;
  922.     
  923.     MIDL_STUB_MESSAGE _StubMsg;
  924.     
  925.     RpcTryExcept
  926.         {
  927.         NdrProxyInitialize(
  928.                       ( void __RPC_FAR *  )This,
  929.                       ( PRPC_MESSAGE  )&_RpcMessage,
  930.                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  931.                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
  932.                       14);
  933.         
  934.         
  935.         
  936.         RpcTryFinally
  937.             {
  938.             
  939.             _StubMsg.BufferLength = 2U + 6U + 5U + 10U;
  940.             NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
  941.                                       (unsigned char __RPC_FAR *)&value,
  942.                                       (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1036] );
  943.             
  944.             NdrProxyGetBuffer(This, &_StubMsg);
  945.             NdrSimpleTypeMarshall(
  946.                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  947.                          ( unsigned char __RPC_FAR * )&type,
  948.                          13);
  949.             NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
  950.                                     (unsigned char __RPC_FAR *)&value,
  951.                                     (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1036] );
  952.             
  953.             NdrSimpleTypeMarshall(
  954.                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  955.                          ( unsigned char __RPC_FAR * )&where,
  956.                          13);
  957.             _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
  958.             *(( long __RPC_FAR * )_StubMsg.Buffer)++ = size;
  959.             
  960.             NdrProxySendReceive(This, &_StubMsg);
  961.             
  962.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  963.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[48] );
  964.             
  965.             _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
  966.             
  967.             }
  968.         RpcFinally
  969.             {
  970.             NdrProxyFreeBuffer(This, &_StubMsg);
  971.             
  972.             }
  973.         RpcEndFinally
  974.         
  975.         }
  976.     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
  977.         {
  978.         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
  979.         }
  980.     RpcEndExcept
  981.     return _RetVal;
  982. }
  983.  
  984. void __RPC_STUB IADOTier_AppendParameter_Stub(
  985.     IRpcStubBuffer *This,
  986.     IRpcChannelBuffer *_pRpcChannelBuffer,
  987.     PRPC_MESSAGE _pRpcMessage,
  988.     DWORD *_pdwStubPhase)
  989. {
  990.     HRESULT _RetVal;
  991.     MIDL_STUB_MESSAGE _StubMsg;
  992.     void __RPC_FAR *_p_value;
  993.     long size;
  994.     enum DataTypeEnum type;
  995.     VARIANT value;
  996.     enum ParameterDirectionEnum where;
  997.     
  998. NdrStubInitialize(
  999.                      _pRpcMessage,
  1000.                      &_StubMsg,
  1001.                      &Object_StubDesc,
  1002.                      _pRpcChannelBuffer);
  1003.     _p_value = &value;
  1004.     MIDL_memset(
  1005.                _p_value,
  1006.                0,
  1007.                sizeof( VARIANT  ));
  1008.     RpcTryFinally
  1009.         {
  1010.         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  1011.             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[48] );
  1012.         
  1013.         NdrSimpleTypeUnmarshall(
  1014.                            ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  1015.                            ( unsigned char __RPC_FAR * )&type,
  1016.                            13);
  1017.         NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
  1018.                                   (unsigned char __RPC_FAR * __RPC_FAR *)&_p_value,
  1019.                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1036],
  1020.                                   (unsigned char)0 );
  1021.         
  1022.         NdrSimpleTypeUnmarshall(
  1023.                            ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  1024.                            ( unsigned char __RPC_FAR * )&where,
  1025.                            13);
  1026.         _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
  1027.         size = *(( long __RPC_FAR * )_StubMsg.Buffer)++;
  1028.         
  1029.         
  1030.         *_pdwStubPhase = STUB_CALL_SERVER;
  1031.         _RetVal = (((IADOTier *) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> AppendParameter(
  1032.                    (IADOTier *) ((CStdStubBuffer *)This)->pvServerObject,
  1033.                    type,
  1034.                    value,
  1035.                    where,
  1036.                    size);
  1037.         
  1038.         *_pdwStubPhase = STUB_MARSHAL;
  1039.         
  1040.         _StubMsg.BufferLength = 4U;
  1041.         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
  1042.         *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
  1043.         
  1044.         }
  1045.     RpcFinally
  1046.         {
  1047.         NdrUserMarshalFree( &_StubMsg,
  1048.                             (unsigned char __RPC_FAR *)&value,
  1049.                             &__MIDL_TypeFormatString.Format[1036] );
  1050.         
  1051.         }
  1052.     RpcEndFinally
  1053.     _pRpcMessage->BufferLength = 
  1054.         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
  1055.     
  1056. }
  1057.  
  1058.  
  1059. /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE IADOTier_Update_Proxy( 
  1060.     IADOTier __RPC_FAR * This)
  1061. {
  1062.  
  1063.     HRESULT _RetVal;
  1064.     
  1065.     RPC_MESSAGE _RpcMessage;
  1066.     
  1067.     MIDL_STUB_MESSAGE _StubMsg;
  1068.     
  1069.     RpcTryExcept
  1070.         {
  1071.         NdrProxyInitialize(
  1072.                       ( void __RPC_FAR *  )This,
  1073.                       ( PRPC_MESSAGE  )&_RpcMessage,
  1074.                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  1075.                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
  1076.                       15);
  1077.         
  1078.         
  1079.         
  1080.         RpcTryFinally
  1081.             {
  1082.             
  1083.             _StubMsg.BufferLength = 0U;
  1084.             NdrProxyGetBuffer(This, &_StubMsg);
  1085.             NdrProxySendReceive(This, &_StubMsg);
  1086.             
  1087.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  1088.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[20] );
  1089.             
  1090.             _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
  1091.             
  1092.             }
  1093.         RpcFinally
  1094.             {
  1095.             NdrProxyFreeBuffer(This, &_StubMsg);
  1096.             
  1097.             }
  1098.         RpcEndFinally
  1099.         
  1100.         }
  1101.     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
  1102.         {
  1103.         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
  1104.         }
  1105.     RpcEndExcept
  1106.     return _RetVal;
  1107. }
  1108.  
  1109. void __RPC_STUB IADOTier_Update_Stub(
  1110.     IRpcStubBuffer *This,
  1111.     IRpcChannelBuffer *_pRpcChannelBuffer,
  1112.     PRPC_MESSAGE _pRpcMessage,
  1113.     DWORD *_pdwStubPhase)
  1114. {
  1115.     HRESULT _RetVal;
  1116.     MIDL_STUB_MESSAGE _StubMsg;
  1117.     
  1118. NdrStubInitialize(
  1119.                      _pRpcMessage,
  1120.                      &_StubMsg,
  1121.                      &Object_StubDesc,
  1122.                      _pRpcChannelBuffer);
  1123.     RpcTryFinally
  1124.         {
  1125.         
  1126.         *_pdwStubPhase = STUB_CALL_SERVER;
  1127.         _RetVal = (((IADOTier *) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> Update((IADOTier *) ((CStdStubBuffer *)This)->pvServerObject);
  1128.         
  1129.         *_pdwStubPhase = STUB_MARSHAL;
  1130.         
  1131.         _StubMsg.BufferLength = 4U;
  1132.         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
  1133.         *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
  1134.         
  1135.         }
  1136.     RpcFinally
  1137.         {
  1138.         }
  1139.     RpcEndFinally
  1140.     _pRpcMessage->BufferLength = 
  1141.         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
  1142.     
  1143. }
  1144.  
  1145.  
  1146. /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE IADOTier_Delete_Proxy( 
  1147.     IADOTier __RPC_FAR * This)
  1148. {
  1149.  
  1150.     HRESULT _RetVal;
  1151.     
  1152.     RPC_MESSAGE _RpcMessage;
  1153.     
  1154.     MIDL_STUB_MESSAGE _StubMsg;
  1155.     
  1156.     RpcTryExcept
  1157.         {
  1158.         NdrProxyInitialize(
  1159.                       ( void __RPC_FAR *  )This,
  1160.                       ( PRPC_MESSAGE  )&_RpcMessage,
  1161.                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  1162.                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
  1163.                       16);
  1164.         
  1165.         
  1166.         
  1167.         RpcTryFinally
  1168.             {
  1169.             
  1170.             _StubMsg.BufferLength = 0U;
  1171.             NdrProxyGetBuffer(This, &_StubMsg);
  1172.             NdrProxySendReceive(This, &_StubMsg);
  1173.             
  1174.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  1175.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[20] );
  1176.             
  1177.             _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
  1178.             
  1179.             }
  1180.         RpcFinally
  1181.             {
  1182.             NdrProxyFreeBuffer(This, &_StubMsg);
  1183.             
  1184.             }
  1185.         RpcEndFinally
  1186.         
  1187.         }
  1188.     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
  1189.         {
  1190.         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
  1191.         }
  1192.     RpcEndExcept
  1193.     return _RetVal;
  1194. }
  1195.  
  1196. void __RPC_STUB IADOTier_Delete_Stub(
  1197.     IRpcStubBuffer *This,
  1198.     IRpcChannelBuffer *_pRpcChannelBuffer,
  1199.     PRPC_MESSAGE _pRpcMessage,
  1200.     DWORD *_pdwStubPhase)
  1201. {
  1202.     HRESULT _RetVal;
  1203.     MIDL_STUB_MESSAGE _StubMsg;
  1204.     
  1205. NdrStubInitialize(
  1206.                      _pRpcMessage,
  1207.                      &_StubMsg,
  1208.                      &Object_StubDesc,
  1209.                      _pRpcChannelBuffer);
  1210.     RpcTryFinally
  1211.         {
  1212.         
  1213.         *_pdwStubPhase = STUB_CALL_SERVER;
  1214.         _RetVal = (((IADOTier *) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> Delete((IADOTier *) ((CStdStubBuffer *)This)->pvServerObject);
  1215.         
  1216.         *_pdwStubPhase = STUB_MARSHAL;
  1217.         
  1218.         _StubMsg.BufferLength = 4U;
  1219.         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
  1220.         *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
  1221.         
  1222.         }
  1223.     RpcFinally
  1224.         {
  1225.         }
  1226.     RpcEndFinally
  1227.     _pRpcMessage->BufferLength = 
  1228.         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
  1229.     
  1230. }
  1231.  
  1232.  
  1233. /* [helpstring][id][propget] */ HRESULT STDMETHODCALLTYPE IADOTier_get_Field_Proxy( 
  1234.     IADOTier __RPC_FAR * This,
  1235.     /* [in] */ VARIANT idx,
  1236.     /* [retval][out] */ VARIANT __RPC_FAR *newVal)
  1237. {
  1238.  
  1239.     HRESULT _RetVal;
  1240.     
  1241.     RPC_MESSAGE _RpcMessage;
  1242.     
  1243.     MIDL_STUB_MESSAGE _StubMsg;
  1244.     
  1245.     MIDL_memset(
  1246.                newVal,
  1247.                0,
  1248.                sizeof( VARIANT  ));
  1249.     RpcTryExcept
  1250.         {
  1251.         NdrProxyInitialize(
  1252.                       ( void __RPC_FAR *  )This,
  1253.                       ( PRPC_MESSAGE  )&_RpcMessage,
  1254.                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  1255.                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
  1256.                       17);
  1257.         
  1258.         
  1259.         
  1260.         RpcTryFinally
  1261.             {
  1262.             
  1263.             _StubMsg.BufferLength = 4U;
  1264.             NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
  1265.                                       (unsigned char __RPC_FAR *)&idx,
  1266.                                       (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1046] );
  1267.             
  1268.             NdrProxyGetBuffer(This, &_StubMsg);
  1269.             NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
  1270.                                     (unsigned char __RPC_FAR *)&idx,
  1271.                                     (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1046] );
  1272.             
  1273.             NdrProxySendReceive(This, &_StubMsg);
  1274.             
  1275.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  1276.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[60] );
  1277.             
  1278.             NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
  1279.                                       (unsigned char __RPC_FAR * __RPC_FAR *)&newVal,
  1280.                                       (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1064],
  1281.                                       (unsigned char)0 );
  1282.             
  1283.             _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
  1284.             _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
  1285.             
  1286.             }
  1287.         RpcFinally
  1288.             {
  1289.             NdrProxyFreeBuffer(This, &_StubMsg);
  1290.             
  1291.             }
  1292.         RpcEndFinally
  1293.         
  1294.         }
  1295.     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
  1296.         {
  1297.         NdrClearOutParameters(
  1298.                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  1299.                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[1056],
  1300.                          ( void __RPC_FAR * )newVal);
  1301.         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
  1302.         }
  1303.     RpcEndExcept
  1304.     return _RetVal;
  1305. }
  1306.  
  1307. void __RPC_STUB IADOTier_get_Field_Stub(
  1308.     IRpcStubBuffer *This,
  1309.     IRpcChannelBuffer *_pRpcChannelBuffer,
  1310.     PRPC_MESSAGE _pRpcMessage,
  1311.     DWORD *_pdwStubPhase)
  1312. {
  1313.     VARIANT _M1;
  1314.     HRESULT _RetVal;
  1315.     MIDL_STUB_MESSAGE _StubMsg;
  1316.     void __RPC_FAR *_p_idx;
  1317.     VARIANT idx;
  1318.     VARIANT __RPC_FAR *newVal;
  1319.     
  1320. NdrStubInitialize(
  1321.                      _pRpcMessage,
  1322.                      &_StubMsg,
  1323.                      &Object_StubDesc,
  1324.                      _pRpcChannelBuffer);
  1325.     _p_idx = &idx;
  1326.     MIDL_memset(
  1327.                _p_idx,
  1328.                0,
  1329.                sizeof( VARIANT  ));
  1330.     ( VARIANT __RPC_FAR * )newVal = 0;
  1331.     RpcTryFinally
  1332.         {
  1333.         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  1334.             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[60] );
  1335.         
  1336.         NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
  1337.                                   (unsigned char __RPC_FAR * __RPC_FAR *)&_p_idx,
  1338.                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1046],
  1339.                                   (unsigned char)0 );
  1340.         
  1341.         newVal = &_M1;
  1342.         MIDL_memset(
  1343.                newVal,
  1344.                0,
  1345.                sizeof( VARIANT  ));
  1346.         
  1347.         *_pdwStubPhase = STUB_CALL_SERVER;
  1348.         _RetVal = (((IADOTier *) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> get_Field(
  1349.              (IADOTier *) ((CStdStubBuffer *)This)->pvServerObject,
  1350.              idx,
  1351.              newVal);
  1352.         
  1353.         *_pdwStubPhase = STUB_MARSHAL;
  1354.         
  1355.         _StubMsg.BufferLength = 4U + 11U;
  1356.         NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
  1357.                                   (unsigned char __RPC_FAR *)newVal,
  1358.                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1064] );
  1359.         
  1360.         _StubMsg.BufferLength += 16;
  1361.         
  1362.         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
  1363.         NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
  1364.                                 (unsigned char __RPC_FAR *)newVal,
  1365.                                 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1064] );
  1366.         
  1367.         _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
  1368.         *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
  1369.         
  1370.         }
  1371.     RpcFinally
  1372.         {
  1373.         NdrUserMarshalFree( &_StubMsg,
  1374.                             (unsigned char __RPC_FAR *)&idx,
  1375.                             &__MIDL_TypeFormatString.Format[1046] );
  1376.         
  1377.         NdrPointerFree( &_StubMsg,
  1378.                         (unsigned char __RPC_FAR *)newVal,
  1379.                         &__MIDL_TypeFormatString.Format[1056] );
  1380.         
  1381.         }
  1382.     RpcEndFinally
  1383.     _pRpcMessage->BufferLength = 
  1384.         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
  1385.     
  1386. }
  1387.  
  1388.  
  1389. /* [helpstring][id][propput] */ HRESULT STDMETHODCALLTYPE IADOTier_put_Field_Proxy( 
  1390.     IADOTier __RPC_FAR * This,
  1391.     /* [in] */ VARIANT idx,
  1392.     /* [in] */ VARIANT newVal)
  1393. {
  1394.  
  1395.     HRESULT _RetVal;
  1396.     
  1397.     RPC_MESSAGE _RpcMessage;
  1398.     
  1399.     MIDL_STUB_MESSAGE _StubMsg;
  1400.     
  1401.     RpcTryExcept
  1402.         {
  1403.         NdrProxyInitialize(
  1404.                       ( void __RPC_FAR *  )This,
  1405.                       ( PRPC_MESSAGE  )&_RpcMessage,
  1406.                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  1407.                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
  1408.                       18);
  1409.         
  1410.         
  1411.         
  1412.         RpcTryFinally
  1413.             {
  1414.             
  1415.             _StubMsg.BufferLength = 4U + 11U;
  1416.             NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
  1417.                                       (unsigned char __RPC_FAR *)&idx,
  1418.                                       (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1074] );
  1419.             
  1420.             NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
  1421.                                       (unsigned char __RPC_FAR *)&newVal,
  1422.                                       (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1084] );
  1423.             
  1424.             NdrProxyGetBuffer(This, &_StubMsg);
  1425.             NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
  1426.                                     (unsigned char __RPC_FAR *)&idx,
  1427.                                     (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1074] );
  1428.             
  1429.             NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
  1430.                                     (unsigned char __RPC_FAR *)&newVal,
  1431.                                     (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1084] );
  1432.             
  1433.             NdrProxySendReceive(This, &_StubMsg);
  1434.             
  1435.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  1436.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[70] );
  1437.             
  1438.             _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
  1439.             
  1440.             }
  1441.         RpcFinally
  1442.             {
  1443.             NdrProxyFreeBuffer(This, &_StubMsg);
  1444.             
  1445.             }
  1446.         RpcEndFinally
  1447.         
  1448.         }
  1449.     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
  1450.         {
  1451.         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
  1452.         }
  1453.     RpcEndExcept
  1454.     return _RetVal;
  1455. }
  1456.  
  1457. void __RPC_STUB IADOTier_put_Field_Stub(
  1458.     IRpcStubBuffer *This,
  1459.     IRpcChannelBuffer *_pRpcChannelBuffer,
  1460.     PRPC_MESSAGE _pRpcMessage,
  1461.     DWORD *_pdwStubPhase)
  1462. {
  1463.     HRESULT _RetVal;
  1464.     MIDL_STUB_MESSAGE _StubMsg;
  1465.     void __RPC_FAR *_p_idx;
  1466.     void __RPC_FAR *_p_newVal;
  1467.     VARIANT idx;
  1468.     VARIANT newVal;
  1469.     
  1470. NdrStubInitialize(
  1471.                      _pRpcMessage,
  1472.                      &_StubMsg,
  1473.                      &Object_StubDesc,
  1474.                      _pRpcChannelBuffer);
  1475.     _p_idx = &idx;
  1476.     MIDL_memset(
  1477.                _p_idx,
  1478.                0,
  1479.                sizeof( VARIANT  ));
  1480.     _p_newVal = &newVal;
  1481.     MIDL_memset(
  1482.                _p_newVal,
  1483.                0,
  1484.                sizeof( VARIANT  ));
  1485.     RpcTryFinally
  1486.         {
  1487.         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  1488.             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[70] );
  1489.         
  1490.         NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
  1491.                                   (unsigned char __RPC_FAR * __RPC_FAR *)&_p_idx,
  1492.                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1074],
  1493.                                   (unsigned char)0 );
  1494.         
  1495.         NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
  1496.                                   (unsigned char __RPC_FAR * __RPC_FAR *)&_p_newVal,
  1497.                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1084],
  1498.                                   (unsigned char)0 );
  1499.         
  1500.         
  1501.         *_pdwStubPhase = STUB_CALL_SERVER;
  1502.         _RetVal = (((IADOTier *) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> put_Field(
  1503.              (IADOTier *) ((CStdStubBuffer *)This)->pvServerObject,
  1504.              idx,
  1505.              newVal);
  1506.         
  1507.         *_pdwStubPhase = STUB_MARSHAL;
  1508.         
  1509.         _StubMsg.BufferLength = 4U;
  1510.         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
  1511.         *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
  1512.         
  1513.         }
  1514.     RpcFinally
  1515.         {
  1516.         NdrUserMarshalFree( &_StubMsg,
  1517.                             (unsigned char __RPC_FAR *)&idx,
  1518.                             &__MIDL_TypeFormatString.Format[1074] );
  1519.         
  1520.         NdrUserMarshalFree( &_StubMsg,
  1521.                             (unsigned char __RPC_FAR *)&newVal,
  1522.                             &__MIDL_TypeFormatString.Format[1084] );
  1523.         
  1524.         }
  1525.     RpcEndFinally
  1526.     _pRpcMessage->BufferLength = 
  1527.         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
  1528.     
  1529. }
  1530.  
  1531.  
  1532. /* [helpstring][id][propget] */ HRESULT STDMETHODCALLTYPE IADOTier_get_FieldCount_Proxy( 
  1533.     IADOTier __RPC_FAR * This,
  1534.     /* [retval][out] */ long __RPC_FAR *newVal)
  1535. {
  1536.  
  1537.     HRESULT _RetVal;
  1538.     
  1539.     RPC_MESSAGE _RpcMessage;
  1540.     
  1541.     MIDL_STUB_MESSAGE _StubMsg;
  1542.     
  1543.     RpcTryExcept
  1544.         {
  1545.         NdrProxyInitialize(
  1546.                       ( void __RPC_FAR *  )This,
  1547.                       ( PRPC_MESSAGE  )&_RpcMessage,
  1548.                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  1549.                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
  1550.                       19);
  1551.         
  1552.         
  1553.         
  1554.         RpcTryFinally
  1555.             {
  1556.             
  1557.             _StubMsg.BufferLength = 0U;
  1558.             NdrProxyGetBuffer(This, &_StubMsg);
  1559.             NdrProxySendReceive(This, &_StubMsg);
  1560.             
  1561.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  1562.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[80] );
  1563.             
  1564.             *newVal = *(( long __RPC_FAR * )_StubMsg.Buffer)++;
  1565.             
  1566.             _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
  1567.             
  1568.             }
  1569.         RpcFinally
  1570.             {
  1571.             NdrProxyFreeBuffer(This, &_StubMsg);
  1572.             
  1573.             }
  1574.         RpcEndFinally
  1575.         
  1576.         }
  1577.     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
  1578.         {
  1579.         NdrClearOutParameters(
  1580.                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  1581.                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[1094],
  1582.                          ( void __RPC_FAR * )newVal);
  1583.         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
  1584.         }
  1585.     RpcEndExcept
  1586.     return _RetVal;
  1587. }
  1588.  
  1589. void __RPC_STUB IADOTier_get_FieldCount_Stub(
  1590.     IRpcStubBuffer *This,
  1591.     IRpcChannelBuffer *_pRpcChannelBuffer,
  1592.     PRPC_MESSAGE _pRpcMessage,
  1593.     DWORD *_pdwStubPhase)
  1594. {
  1595.     long _M2;
  1596.     HRESULT _RetVal;
  1597.     MIDL_STUB_MESSAGE _StubMsg;
  1598.     long __RPC_FAR *newVal;
  1599.     
  1600. NdrStubInitialize(
  1601.                      _pRpcMessage,
  1602.                      &_StubMsg,
  1603.                      &Object_StubDesc,
  1604.                      _pRpcChannelBuffer);
  1605.     ( long __RPC_FAR * )newVal = 0;
  1606.     RpcTryFinally
  1607.         {
  1608.         newVal = &_M2;
  1609.         
  1610.         *_pdwStubPhase = STUB_CALL_SERVER;
  1611.         _RetVal = (((IADOTier *) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> get_FieldCount((IADOTier *) ((CStdStubBuffer *)This)->pvServerObject,newVal);
  1612.         
  1613.         *_pdwStubPhase = STUB_MARSHAL;
  1614.         
  1615.         _StubMsg.BufferLength = 4U + 4U;
  1616.         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
  1617.         *(( long __RPC_FAR * )_StubMsg.Buffer)++ = *newVal;
  1618.         
  1619.         *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
  1620.         
  1621.         }
  1622.     RpcFinally
  1623.         {
  1624.         }
  1625.     RpcEndFinally
  1626.     _pRpcMessage->BufferLength = 
  1627.         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
  1628.     
  1629. }
  1630.  
  1631.  
  1632. /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE IADOTier_Close_Proxy( 
  1633.     IADOTier __RPC_FAR * This)
  1634. {
  1635.  
  1636.     HRESULT _RetVal;
  1637.     
  1638.     RPC_MESSAGE _RpcMessage;
  1639.     
  1640.     MIDL_STUB_MESSAGE _StubMsg;
  1641.     
  1642.     RpcTryExcept
  1643.         {
  1644.         NdrProxyInitialize(
  1645.                       ( void __RPC_FAR *  )This,
  1646.                       ( PRPC_MESSAGE  )&_RpcMessage,
  1647.                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  1648.                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
  1649.                       20);
  1650.         
  1651.         
  1652.         
  1653.         RpcTryFinally
  1654.             {
  1655.             
  1656.             _StubMsg.BufferLength = 0U;
  1657.             NdrProxyGetBuffer(This, &_StubMsg);
  1658.             NdrProxySendReceive(This, &_StubMsg);
  1659.             
  1660.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  1661.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[20] );
  1662.             
  1663.             _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
  1664.             
  1665.             }
  1666.         RpcFinally
  1667.             {
  1668.             NdrProxyFreeBuffer(This, &_StubMsg);
  1669.             
  1670.             }
  1671.         RpcEndFinally
  1672.         
  1673.         }
  1674.     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
  1675.         {
  1676.         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
  1677.         }
  1678.     RpcEndExcept
  1679.     return _RetVal;
  1680. }
  1681.  
  1682. void __RPC_STUB IADOTier_Close_Stub(
  1683.     IRpcStubBuffer *This,
  1684.     IRpcChannelBuffer *_pRpcChannelBuffer,
  1685.     PRPC_MESSAGE _pRpcMessage,
  1686.     DWORD *_pdwStubPhase)
  1687. {
  1688.     HRESULT _RetVal;
  1689.     MIDL_STUB_MESSAGE _StubMsg;
  1690.     
  1691. NdrStubInitialize(
  1692.                      _pRpcMessage,
  1693.                      &_StubMsg,
  1694.                      &Object_StubDesc,
  1695.                      _pRpcChannelBuffer);
  1696.     RpcTryFinally
  1697.         {
  1698.         
  1699.         *_pdwStubPhase = STUB_CALL_SERVER;
  1700.         _RetVal = (((IADOTier *) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> Close((IADOTier *) ((CStdStubBuffer *)This)->pvServerObject);
  1701.         
  1702.         *_pdwStubPhase = STUB_MARSHAL;
  1703.         
  1704.         _StubMsg.BufferLength = 4U;
  1705.         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
  1706.         *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
  1707.         
  1708.         }
  1709.     RpcFinally
  1710.         {
  1711.         }
  1712.     RpcEndFinally
  1713.     _pRpcMessage->BufferLength = 
  1714.         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
  1715.     
  1716. }
  1717.  
  1718.  
  1719. /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE IADOTier_First_Proxy( 
  1720.     IADOTier __RPC_FAR * This)
  1721. {
  1722.  
  1723.     HRESULT _RetVal;
  1724.     
  1725.     RPC_MESSAGE _RpcMessage;
  1726.     
  1727.     MIDL_STUB_MESSAGE _StubMsg;
  1728.     
  1729.     RpcTryExcept
  1730.         {
  1731.         NdrProxyInitialize(
  1732.                       ( void __RPC_FAR *  )This,
  1733.                       ( PRPC_MESSAGE  )&_RpcMessage,
  1734.                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  1735.                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
  1736.                       21);
  1737.         
  1738.         
  1739.         
  1740.         RpcTryFinally
  1741.             {
  1742.             
  1743.             _StubMsg.BufferLength = 0U;
  1744.             NdrProxyGetBuffer(This, &_StubMsg);
  1745.             NdrProxySendReceive(This, &_StubMsg);
  1746.             
  1747.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  1748.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[20] );
  1749.             
  1750.             _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
  1751.             
  1752.             }
  1753.         RpcFinally
  1754.             {
  1755.             NdrProxyFreeBuffer(This, &_StubMsg);
  1756.             
  1757.             }
  1758.         RpcEndFinally
  1759.         
  1760.         }
  1761.     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
  1762.         {
  1763.         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
  1764.         }
  1765.     RpcEndExcept
  1766.     return _RetVal;
  1767. }
  1768.  
  1769. void __RPC_STUB IADOTier_First_Stub(
  1770.     IRpcStubBuffer *This,
  1771.     IRpcChannelBuffer *_pRpcChannelBuffer,
  1772.     PRPC_MESSAGE _pRpcMessage,
  1773.     DWORD *_pdwStubPhase)
  1774. {
  1775.     HRESULT _RetVal;
  1776.     MIDL_STUB_MESSAGE _StubMsg;
  1777.     
  1778. NdrStubInitialize(
  1779.                      _pRpcMessage,
  1780.                      &_StubMsg,
  1781.                      &Object_StubDesc,
  1782.                      _pRpcChannelBuffer);
  1783.     RpcTryFinally
  1784.         {
  1785.         
  1786.         *_pdwStubPhase = STUB_CALL_SERVER;
  1787.         _RetVal = (((IADOTier *) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> First((IADOTier *) ((CStdStubBuffer *)This)->pvServerObject);
  1788.         
  1789.         *_pdwStubPhase = STUB_MARSHAL;
  1790.         
  1791.         _StubMsg.BufferLength = 4U;
  1792.         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
  1793.         *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
  1794.         
  1795.         }
  1796.     RpcFinally
  1797.         {
  1798.         }
  1799.     RpcEndFinally
  1800.     _pRpcMessage->BufferLength = 
  1801.         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
  1802.     
  1803. }
  1804.  
  1805.  
  1806. /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE IADOTier_Next_Proxy( 
  1807.     IADOTier __RPC_FAR * This)
  1808. {
  1809.  
  1810.     HRESULT _RetVal;
  1811.     
  1812.     RPC_MESSAGE _RpcMessage;
  1813.     
  1814.     MIDL_STUB_MESSAGE _StubMsg;
  1815.     
  1816.     RpcTryExcept
  1817.         {
  1818.         NdrProxyInitialize(
  1819.                       ( void __RPC_FAR *  )This,
  1820.                       ( PRPC_MESSAGE  )&_RpcMessage,
  1821.                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  1822.                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
  1823.                       22);
  1824.         
  1825.         
  1826.         
  1827.         RpcTryFinally
  1828.             {
  1829.             
  1830.             _StubMsg.BufferLength = 0U;
  1831.             NdrProxyGetBuffer(This, &_StubMsg);
  1832.             NdrProxySendReceive(This, &_StubMsg);
  1833.             
  1834.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  1835.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[20] );
  1836.             
  1837.             _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
  1838.             
  1839.             }
  1840.         RpcFinally
  1841.             {
  1842.             NdrProxyFreeBuffer(This, &_StubMsg);
  1843.             
  1844.             }
  1845.         RpcEndFinally
  1846.         
  1847.         }
  1848.     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
  1849.         {
  1850.         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
  1851.         }
  1852.     RpcEndExcept
  1853.     return _RetVal;
  1854. }
  1855.  
  1856. void __RPC_STUB IADOTier_Next_Stub(
  1857.     IRpcStubBuffer *This,
  1858.     IRpcChannelBuffer *_pRpcChannelBuffer,
  1859.     PRPC_MESSAGE _pRpcMessage,
  1860.     DWORD *_pdwStubPhase)
  1861. {
  1862.     HRESULT _RetVal;
  1863.     MIDL_STUB_MESSAGE _StubMsg;
  1864.     
  1865. NdrStubInitialize(
  1866.                      _pRpcMessage,
  1867.                      &_StubMsg,
  1868.                      &Object_StubDesc,
  1869.                      _pRpcChannelBuffer);
  1870.     RpcTryFinally
  1871.         {
  1872.         
  1873.         *_pdwStubPhase = STUB_CALL_SERVER;
  1874.         _RetVal = (((IADOTier *) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> Next((IADOTier *) ((CStdStubBuffer *)This)->pvServerObject);
  1875.         
  1876.         *_pdwStubPhase = STUB_MARSHAL;
  1877.         
  1878.         _StubMsg.BufferLength = 4U;
  1879.         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
  1880.         *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
  1881.         
  1882.         }
  1883.     RpcFinally
  1884.         {
  1885.         }
  1886.     RpcEndFinally
  1887.     _pRpcMessage->BufferLength = 
  1888.         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
  1889.     
  1890. }
  1891.  
  1892.  
  1893. /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE IADOTier_Last_Proxy( 
  1894.     IADOTier __RPC_FAR * This)
  1895. {
  1896.  
  1897.     HRESULT _RetVal;
  1898.     
  1899.     RPC_MESSAGE _RpcMessage;
  1900.     
  1901.     MIDL_STUB_MESSAGE _StubMsg;
  1902.     
  1903.     RpcTryExcept
  1904.         {
  1905.         NdrProxyInitialize(
  1906.                       ( void __RPC_FAR *  )This,
  1907.                       ( PRPC_MESSAGE  )&_RpcMessage,
  1908.                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  1909.                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
  1910.                       23);
  1911.         
  1912.         
  1913.         
  1914.         RpcTryFinally
  1915.             {
  1916.             
  1917.             _StubMsg.BufferLength = 0U;
  1918.             NdrProxyGetBuffer(This, &_StubMsg);
  1919.             NdrProxySendReceive(This, &_StubMsg);
  1920.             
  1921.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  1922.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[20] );
  1923.             
  1924.             _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
  1925.             
  1926.             }
  1927.         RpcFinally
  1928.             {
  1929.             NdrProxyFreeBuffer(This, &_StubMsg);
  1930.             
  1931.             }
  1932.         RpcEndFinally
  1933.         
  1934.         }
  1935.     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
  1936.         {
  1937.         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
  1938.         }
  1939.     RpcEndExcept
  1940.     return _RetVal;
  1941. }
  1942.  
  1943. void __RPC_STUB IADOTier_Last_Stub(
  1944.     IRpcStubBuffer *This,
  1945.     IRpcChannelBuffer *_pRpcChannelBuffer,
  1946.     PRPC_MESSAGE _pRpcMessage,
  1947.     DWORD *_pdwStubPhase)
  1948. {
  1949.     HRESULT _RetVal;
  1950.     MIDL_STUB_MESSAGE _StubMsg;
  1951.     
  1952. NdrStubInitialize(
  1953.                      _pRpcMessage,
  1954.                      &_StubMsg,
  1955.                      &Object_StubDesc,
  1956.                      _pRpcChannelBuffer);
  1957.     RpcTryFinally
  1958.         {
  1959.         
  1960.         *_pdwStubPhase = STUB_CALL_SERVER;
  1961.         _RetVal = (((IADOTier *) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> Last((IADOTier *) ((CStdStubBuffer *)This)->pvServerObject);
  1962.         
  1963.         *_pdwStubPhase = STUB_MARSHAL;
  1964.         
  1965.         _StubMsg.BufferLength = 4U;
  1966.         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
  1967.         *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
  1968.         
  1969.         }
  1970.     RpcFinally
  1971.         {
  1972.         }
  1973.     RpcEndFinally
  1974.     _pRpcMessage->BufferLength = 
  1975.         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
  1976.     
  1977. }
  1978.  
  1979.  
  1980. /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE IADOTier_Prev_Proxy( 
  1981.     IADOTier __RPC_FAR * This)
  1982. {
  1983.  
  1984.     HRESULT _RetVal;
  1985.     
  1986.     RPC_MESSAGE _RpcMessage;
  1987.     
  1988.     MIDL_STUB_MESSAGE _StubMsg;
  1989.     
  1990.     RpcTryExcept
  1991.         {
  1992.         NdrProxyInitialize(
  1993.                       ( void __RPC_FAR *  )This,
  1994.                       ( PRPC_MESSAGE  )&_RpcMessage,
  1995.                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  1996.                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
  1997.                       24);
  1998.         
  1999.         
  2000.         
  2001.         RpcTryFinally
  2002.             {
  2003.             
  2004.             _StubMsg.BufferLength = 0U;
  2005.             NdrProxyGetBuffer(This, &_StubMsg);
  2006.             NdrProxySendReceive(This, &_StubMsg);
  2007.             
  2008.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  2009.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[20] );
  2010.             
  2011.             _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
  2012.             
  2013.             }
  2014.         RpcFinally
  2015.             {
  2016.             NdrProxyFreeBuffer(This, &_StubMsg);
  2017.             
  2018.             }
  2019.         RpcEndFinally
  2020.         
  2021.         }
  2022.     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
  2023.         {
  2024.         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
  2025.         }
  2026.     RpcEndExcept
  2027.     return _RetVal;
  2028. }
  2029.  
  2030. void __RPC_STUB IADOTier_Prev_Stub(
  2031.     IRpcStubBuffer *This,
  2032.     IRpcChannelBuffer *_pRpcChannelBuffer,
  2033.     PRPC_MESSAGE _pRpcMessage,
  2034.     DWORD *_pdwStubPhase)
  2035. {
  2036.     HRESULT _RetVal;
  2037.     MIDL_STUB_MESSAGE _StubMsg;
  2038.     
  2039. NdrStubInitialize(
  2040.                      _pRpcMessage,
  2041.                      &_StubMsg,
  2042.                      &Object_StubDesc,
  2043.                      _pRpcChannelBuffer);
  2044.     RpcTryFinally
  2045.         {
  2046.         
  2047.         *_pdwStubPhase = STUB_CALL_SERVER;
  2048.         _RetVal = (((IADOTier *) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> Prev((IADOTier *) ((CStdStubBuffer *)This)->pvServerObject);
  2049.         
  2050.         *_pdwStubPhase = STUB_MARSHAL;
  2051.         
  2052.         _StubMsg.BufferLength = 4U;
  2053.         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
  2054.         *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
  2055.         
  2056.         }
  2057.     RpcFinally
  2058.         {
  2059.         }
  2060.     RpcEndFinally
  2061.     _pRpcMessage->BufferLength = 
  2062.         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
  2063.     
  2064. }
  2065.  
  2066.  
  2067. /* [helpstring][id][propget] */ HRESULT STDMETHODCALLTYPE IADOTier_get_EOF_Proxy( 
  2068.     IADOTier __RPC_FAR * This,
  2069.     /* [retval][out] */ VARIANT_BOOL __RPC_FAR *newVal)
  2070. {
  2071.  
  2072.     HRESULT _RetVal;
  2073.     
  2074.     RPC_MESSAGE _RpcMessage;
  2075.     
  2076.     MIDL_STUB_MESSAGE _StubMsg;
  2077.     
  2078.     RpcTryExcept
  2079.         {
  2080.         NdrProxyInitialize(
  2081.                       ( void __RPC_FAR *  )This,
  2082.                       ( PRPC_MESSAGE  )&_RpcMessage,
  2083.                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  2084.                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
  2085.                       25);
  2086.         
  2087.         
  2088.         
  2089.         RpcTryFinally
  2090.             {
  2091.             
  2092.             _StubMsg.BufferLength = 0U;
  2093.             NdrProxyGetBuffer(This, &_StubMsg);
  2094.             NdrProxySendReceive(This, &_StubMsg);
  2095.             
  2096.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  2097.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[86] );
  2098.             
  2099.             *newVal = *(( VARIANT_BOOL __RPC_FAR * )_StubMsg.Buffer)++;
  2100.             
  2101.             _StubMsg.Buffer += 2;
  2102.             _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
  2103.             
  2104.             }
  2105.         RpcFinally
  2106.             {
  2107.             NdrProxyFreeBuffer(This, &_StubMsg);
  2108.             
  2109.             }
  2110.         RpcEndFinally
  2111.         
  2112.         }
  2113.     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
  2114.         {
  2115.         NdrClearOutParameters(
  2116.                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  2117.                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[1098],
  2118.                          ( void __RPC_FAR * )newVal);
  2119.         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
  2120.         }
  2121.     RpcEndExcept
  2122.     return _RetVal;
  2123. }
  2124.  
  2125. void __RPC_STUB IADOTier_get_EOF_Stub(
  2126.     IRpcStubBuffer *This,
  2127.     IRpcChannelBuffer *_pRpcChannelBuffer,
  2128.     PRPC_MESSAGE _pRpcMessage,
  2129.     DWORD *_pdwStubPhase)
  2130. {
  2131.     VARIANT_BOOL _M3;
  2132.     HRESULT _RetVal;
  2133.     MIDL_STUB_MESSAGE _StubMsg;
  2134.     VARIANT_BOOL __RPC_FAR *newVal;
  2135.     
  2136. NdrStubInitialize(
  2137.                      _pRpcMessage,
  2138.                      &_StubMsg,
  2139.                      &Object_StubDesc,
  2140.                      _pRpcChannelBuffer);
  2141.     ( VARIANT_BOOL __RPC_FAR * )newVal = 0;
  2142.     RpcTryFinally
  2143.         {
  2144.         newVal = &_M3;
  2145.         
  2146.         *_pdwStubPhase = STUB_CALL_SERVER;
  2147.         _RetVal = (((IADOTier *) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> get_EOF((IADOTier *) ((CStdStubBuffer *)This)->pvServerObject,newVal);
  2148.         
  2149.         *_pdwStubPhase = STUB_MARSHAL;
  2150.         
  2151.         _StubMsg.BufferLength = 2U + 6U;
  2152.         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
  2153.         *(( VARIANT_BOOL __RPC_FAR * )_StubMsg.Buffer)++ = *newVal;
  2154.         
  2155.         _StubMsg.Buffer += 2;
  2156.         *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
  2157.         
  2158.         }
  2159.     RpcFinally
  2160.         {
  2161.         }
  2162.     RpcEndFinally
  2163.     _pRpcMessage->BufferLength = 
  2164.         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
  2165.     
  2166. }
  2167.  
  2168.  
  2169. /* [helpstring][id][propget] */ HRESULT STDMETHODCALLTYPE IADOTier_get_BOF_Proxy( 
  2170.     IADOTier __RPC_FAR * This,
  2171.     /* [retval][out] */ VARIANT_BOOL __RPC_FAR *newVal)
  2172. {
  2173.  
  2174.     HRESULT _RetVal;
  2175.     
  2176.     RPC_MESSAGE _RpcMessage;
  2177.     
  2178.     MIDL_STUB_MESSAGE _StubMsg;
  2179.     
  2180.     RpcTryExcept
  2181.         {
  2182.         NdrProxyInitialize(
  2183.                       ( void __RPC_FAR *  )This,
  2184.                       ( PRPC_MESSAGE  )&_RpcMessage,
  2185.                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  2186.                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
  2187.                       26);
  2188.         
  2189.         
  2190.         
  2191.         RpcTryFinally
  2192.             {
  2193.             
  2194.             _StubMsg.BufferLength = 0U;
  2195.             NdrProxyGetBuffer(This, &_StubMsg);
  2196.             NdrProxySendReceive(This, &_StubMsg);
  2197.             
  2198.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  2199.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[86] );
  2200.             
  2201.             *newVal = *(( VARIANT_BOOL __RPC_FAR * )_StubMsg.Buffer)++;
  2202.             
  2203.             _StubMsg.Buffer += 2;
  2204.             _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
  2205.             
  2206.             }
  2207.         RpcFinally
  2208.             {
  2209.             NdrProxyFreeBuffer(This, &_StubMsg);
  2210.             
  2211.             }
  2212.         RpcEndFinally
  2213.         
  2214.         }
  2215.     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
  2216.         {
  2217.         NdrClearOutParameters(
  2218.                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  2219.                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[1098],
  2220.                          ( void __RPC_FAR * )newVal);
  2221.         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
  2222.         }
  2223.     RpcEndExcept
  2224.     return _RetVal;
  2225. }
  2226.  
  2227. void __RPC_STUB IADOTier_get_BOF_Stub(
  2228.     IRpcStubBuffer *This,
  2229.     IRpcChannelBuffer *_pRpcChannelBuffer,
  2230.     PRPC_MESSAGE _pRpcMessage,
  2231.     DWORD *_pdwStubPhase)
  2232. {
  2233.     VARIANT_BOOL _M4;
  2234.     HRESULT _RetVal;
  2235.     MIDL_STUB_MESSAGE _StubMsg;
  2236.     VARIANT_BOOL __RPC_FAR *newVal;
  2237.     
  2238. NdrStubInitialize(
  2239.                      _pRpcMessage,
  2240.                      &_StubMsg,
  2241.                      &Object_StubDesc,
  2242.                      _pRpcChannelBuffer);
  2243.     ( VARIANT_BOOL __RPC_FAR * )newVal = 0;
  2244.     RpcTryFinally
  2245.         {
  2246.         newVal = &_M4;
  2247.         
  2248.         *_pdwStubPhase = STUB_CALL_SERVER;
  2249.         _RetVal = (((IADOTier *) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> get_BOF((IADOTier *) ((CStdStubBuffer *)This)->pvServerObject,newVal);
  2250.         
  2251.         *_pdwStubPhase = STUB_MARSHAL;
  2252.         
  2253.         _StubMsg.BufferLength = 2U + 6U;
  2254.         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
  2255.         *(( VARIANT_BOOL __RPC_FAR * )_StubMsg.Buffer)++ = *newVal;
  2256.         
  2257.         _StubMsg.Buffer += 2;
  2258.         *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
  2259.         
  2260.         }
  2261.     RpcFinally
  2262.         {
  2263.         }
  2264.     RpcEndFinally
  2265.     _pRpcMessage->BufferLength = 
  2266.         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
  2267.     
  2268. }
  2269.  
  2270.  
  2271. /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE IADOTier_ParamQuery_Proxy( 
  2272.     IADOTier __RPC_FAR * This,
  2273.     /* [in] */ BSTR query,
  2274.     /* [in] */ long idx1,
  2275.     /* [in] */ BSTR idx2,
  2276.     /* [in] */ BSTR idx3)
  2277. {
  2278.  
  2279.     HRESULT _RetVal;
  2280.     
  2281.     RPC_MESSAGE _RpcMessage;
  2282.     
  2283.     MIDL_STUB_MESSAGE _StubMsg;
  2284.     
  2285.     RpcTryExcept
  2286.         {
  2287.         NdrProxyInitialize(
  2288.                       ( void __RPC_FAR *  )This,
  2289.                       ( PRPC_MESSAGE  )&_RpcMessage,
  2290.                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  2291.                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
  2292.                       27);
  2293.         
  2294.         
  2295.         
  2296.         RpcTryFinally
  2297.             {
  2298.             
  2299.             _StubMsg.BufferLength = 4U + 11U + 7U + 11U;
  2300.             NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
  2301.                                       (unsigned char __RPC_FAR *)&query,
  2302.                                       (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1102] );
  2303.             
  2304.             NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
  2305.                                       (unsigned char __RPC_FAR *)&idx2,
  2306.                                       (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1112] );
  2307.             
  2308.             NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
  2309.                                       (unsigned char __RPC_FAR *)&idx3,
  2310.                                       (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1122] );
  2311.             
  2312.             NdrProxyGetBuffer(This, &_StubMsg);
  2313.             NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
  2314.                                     (unsigned char __RPC_FAR *)&query,
  2315.                                     (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1102] );
  2316.             
  2317.             _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
  2318.             *(( long __RPC_FAR * )_StubMsg.Buffer)++ = idx1;
  2319.             
  2320.             NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
  2321.                                     (unsigned char __RPC_FAR *)&idx2,
  2322.                                     (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1112] );
  2323.             
  2324.             NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
  2325.                                     (unsigned char __RPC_FAR *)&idx3,
  2326.                                     (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1122] );
  2327.             
  2328.             NdrProxySendReceive(This, &_StubMsg);
  2329.             
  2330.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  2331.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[92] );
  2332.             
  2333.             _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
  2334.             
  2335.             }
  2336.         RpcFinally
  2337.             {
  2338.             NdrProxyFreeBuffer(This, &_StubMsg);
  2339.             
  2340.             }
  2341.         RpcEndFinally
  2342.         
  2343.         }
  2344.     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
  2345.         {
  2346.         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
  2347.         }
  2348.     RpcEndExcept
  2349.     return _RetVal;
  2350. }
  2351.  
  2352. void __RPC_STUB IADOTier_ParamQuery_Stub(
  2353.     IRpcStubBuffer *This,
  2354.     IRpcChannelBuffer *_pRpcChannelBuffer,
  2355.     PRPC_MESSAGE _pRpcMessage,
  2356.     DWORD *_pdwStubPhase)
  2357. {
  2358.     HRESULT _RetVal;
  2359.     MIDL_STUB_MESSAGE _StubMsg;
  2360.     void __RPC_FAR *_p_idx2;
  2361.     void __RPC_FAR *_p_idx3;
  2362.     void __RPC_FAR *_p_query;
  2363.     long idx1;
  2364.     BSTR idx2;
  2365.     BSTR idx3;
  2366.     BSTR query;
  2367.     
  2368. NdrStubInitialize(
  2369.                      _pRpcMessage,
  2370.                      &_StubMsg,
  2371.                      &Object_StubDesc,
  2372.                      _pRpcChannelBuffer);
  2373.     _p_query = &query;
  2374.     MIDL_memset(
  2375.                _p_query,
  2376.                0,
  2377.                sizeof( BSTR  ));
  2378.     _p_idx2 = &idx2;
  2379.     MIDL_memset(
  2380.                _p_idx2,
  2381.                0,
  2382.                sizeof( BSTR  ));
  2383.     _p_idx3 = &idx3;
  2384.     MIDL_memset(
  2385.                _p_idx3,
  2386.                0,
  2387.                sizeof( BSTR  ));
  2388.     RpcTryFinally
  2389.         {
  2390.         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  2391.             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[92] );
  2392.         
  2393.         NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
  2394.                                   (unsigned char __RPC_FAR * __RPC_FAR *)&_p_query,
  2395.                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1102],
  2396.                                   (unsigned char)0 );
  2397.         
  2398.         _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
  2399.         idx1 = *(( long __RPC_FAR * )_StubMsg.Buffer)++;
  2400.         
  2401.         NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
  2402.                                   (unsigned char __RPC_FAR * __RPC_FAR *)&_p_idx2,
  2403.                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1112],
  2404.                                   (unsigned char)0 );
  2405.         
  2406.         NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
  2407.                                   (unsigned char __RPC_FAR * __RPC_FAR *)&_p_idx3,
  2408.                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1122],
  2409.                                   (unsigned char)0 );
  2410.         
  2411.         
  2412.         *_pdwStubPhase = STUB_CALL_SERVER;
  2413.         _RetVal = (((IADOTier *) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> ParamQuery(
  2414.               (IADOTier *) ((CStdStubBuffer *)This)->pvServerObject,
  2415.               query,
  2416.               idx1,
  2417.               idx2,
  2418.               idx3);
  2419.         
  2420.         *_pdwStubPhase = STUB_MARSHAL;
  2421.         
  2422.         _StubMsg.BufferLength = 4U;
  2423.         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
  2424.         *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
  2425.         
  2426.         }
  2427.     RpcFinally
  2428.         {
  2429.         NdrUserMarshalFree( &_StubMsg,
  2430.                             (unsigned char __RPC_FAR *)&query,
  2431.                             &__MIDL_TypeFormatString.Format[1102] );
  2432.         
  2433.         NdrUserMarshalFree( &_StubMsg,
  2434.                             (unsigned char __RPC_FAR *)&idx2,
  2435.                             &__MIDL_TypeFormatString.Format[1112] );
  2436.         
  2437.         NdrUserMarshalFree( &_StubMsg,
  2438.                             (unsigned char __RPC_FAR *)&idx3,
  2439.                             &__MIDL_TypeFormatString.Format[1122] );
  2440.         
  2441.         }
  2442.     RpcEndFinally
  2443.     _pRpcMessage->BufferLength = 
  2444.         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
  2445.     
  2446. }
  2447.  
  2448.  
  2449. /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE IADOTier_CallStoredProc_Proxy( 
  2450.     IADOTier __RPC_FAR * This,
  2451.     /* [in] */ long idx1,
  2452.     /* [in] */ BSTR idx2,
  2453.     /* [in] */ BSTR idx3)
  2454. {
  2455.  
  2456.     HRESULT _RetVal;
  2457.     
  2458.     RPC_MESSAGE _RpcMessage;
  2459.     
  2460.     MIDL_STUB_MESSAGE _StubMsg;
  2461.     
  2462.     RpcTryExcept
  2463.         {
  2464.         NdrProxyInitialize(
  2465.                       ( void __RPC_FAR *  )This,
  2466.                       ( PRPC_MESSAGE  )&_RpcMessage,
  2467.                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  2468.                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
  2469.                       28);
  2470.         
  2471.         
  2472.         
  2473.         RpcTryFinally
  2474.             {
  2475.             
  2476.             _StubMsg.BufferLength = 4U + 4U + 11U;
  2477.             NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
  2478.                                       (unsigned char __RPC_FAR *)&idx2,
  2479.                                       (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1132] );
  2480.             
  2481.             NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
  2482.                                       (unsigned char __RPC_FAR *)&idx3,
  2483.                                       (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1142] );
  2484.             
  2485.             NdrProxyGetBuffer(This, &_StubMsg);
  2486.             *(( long __RPC_FAR * )_StubMsg.Buffer)++ = idx1;
  2487.             
  2488.             NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
  2489.                                     (unsigned char __RPC_FAR *)&idx2,
  2490.                                     (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1132] );
  2491.             
  2492.             NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
  2493.                                     (unsigned char __RPC_FAR *)&idx3,
  2494.                                     (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1142] );
  2495.             
  2496.             NdrProxySendReceive(This, &_StubMsg);
  2497.             
  2498.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  2499.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[108] );
  2500.             
  2501.             _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
  2502.             
  2503.             }
  2504.         RpcFinally
  2505.             {
  2506.             NdrProxyFreeBuffer(This, &_StubMsg);
  2507.             
  2508.             }
  2509.         RpcEndFinally
  2510.         
  2511.         }
  2512.     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
  2513.         {
  2514.         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
  2515.         }
  2516.     RpcEndExcept
  2517.     return _RetVal;
  2518. }
  2519.  
  2520. void __RPC_STUB IADOTier_CallStoredProc_Stub(
  2521.     IRpcStubBuffer *This,
  2522.     IRpcChannelBuffer *_pRpcChannelBuffer,
  2523.     PRPC_MESSAGE _pRpcMessage,
  2524.     DWORD *_pdwStubPhase)
  2525. {
  2526.     HRESULT _RetVal;
  2527.     MIDL_STUB_MESSAGE _StubMsg;
  2528.     void __RPC_FAR *_p_idx2;
  2529.     void __RPC_FAR *_p_idx3;
  2530.     long idx1;
  2531.     BSTR idx2;
  2532.     BSTR idx3;
  2533.     
  2534. NdrStubInitialize(
  2535.                      _pRpcMessage,
  2536.                      &_StubMsg,
  2537.                      &Object_StubDesc,
  2538.                      _pRpcChannelBuffer);
  2539.     _p_idx2 = &idx2;
  2540.     MIDL_memset(
  2541.                _p_idx2,
  2542.                0,
  2543.                sizeof( BSTR  ));
  2544.     _p_idx3 = &idx3;
  2545.     MIDL_memset(
  2546.                _p_idx3,
  2547.                0,
  2548.                sizeof( BSTR  ));
  2549.     RpcTryFinally
  2550.         {
  2551.         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  2552.             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[108] );
  2553.         
  2554.         idx1 = *(( long __RPC_FAR * )_StubMsg.Buffer)++;
  2555.         
  2556.         NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
  2557.                                   (unsigned char __RPC_FAR * __RPC_FAR *)&_p_idx2,
  2558.                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1132],
  2559.                                   (unsigned char)0 );
  2560.         
  2561.         NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
  2562.                                   (unsigned char __RPC_FAR * __RPC_FAR *)&_p_idx3,
  2563.                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1142],
  2564.                                   (unsigned char)0 );
  2565.         
  2566.         
  2567.         *_pdwStubPhase = STUB_CALL_SERVER;
  2568.         _RetVal = (((IADOTier *) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> CallStoredProc(
  2569.                   (IADOTier *) ((CStdStubBuffer *)This)->pvServerObject,
  2570.                   idx1,
  2571.                   idx2,
  2572.                   idx3);
  2573.         
  2574.         *_pdwStubPhase = STUB_MARSHAL;
  2575.         
  2576.         _StubMsg.BufferLength = 4U;
  2577.         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
  2578.         *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
  2579.         
  2580.         }
  2581.     RpcFinally
  2582.         {
  2583.         NdrUserMarshalFree( &_StubMsg,
  2584.                             (unsigned char __RPC_FAR *)&idx2,
  2585.                             &__MIDL_TypeFormatString.Format[1132] );
  2586.         
  2587.         NdrUserMarshalFree( &_StubMsg,
  2588.                             (unsigned char __RPC_FAR *)&idx3,
  2589.                             &__MIDL_TypeFormatString.Format[1142] );
  2590.         
  2591.         }
  2592.     RpcEndFinally
  2593.     _pRpcMessage->BufferLength = 
  2594.         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
  2595.     
  2596. }
  2597.  
  2598.  
  2599. /* [helpstring][id][propput] */ HRESULT STDMETHODCALLTYPE IADOTier_put_StoredProc_Proxy( 
  2600.     IADOTier __RPC_FAR * This,
  2601.     /* [in] */ BSTR newVal)
  2602. {
  2603.  
  2604.     HRESULT _RetVal;
  2605.     
  2606.     RPC_MESSAGE _RpcMessage;
  2607.     
  2608.     MIDL_STUB_MESSAGE _StubMsg;
  2609.     
  2610.     RpcTryExcept
  2611.         {
  2612.         NdrProxyInitialize(
  2613.                       ( void __RPC_FAR *  )This,
  2614.                       ( PRPC_MESSAGE  )&_RpcMessage,
  2615.                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  2616.                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
  2617.                       29);
  2618.         
  2619.         
  2620.         
  2621.         RpcTryFinally
  2622.             {
  2623.             
  2624.             _StubMsg.BufferLength = 4U;
  2625.             NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
  2626.                                       (unsigned char __RPC_FAR *)&newVal,
  2627.                                       (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1152] );
  2628.             
  2629.             NdrProxyGetBuffer(This, &_StubMsg);
  2630.             NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
  2631.                                     (unsigned char __RPC_FAR *)&newVal,
  2632.                                     (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1152] );
  2633.             
  2634.             NdrProxySendReceive(This, &_StubMsg);
  2635.             
  2636.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  2637.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[120] );
  2638.             
  2639.             _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
  2640.             
  2641.             }
  2642.         RpcFinally
  2643.             {
  2644.             NdrProxyFreeBuffer(This, &_StubMsg);
  2645.             
  2646.             }
  2647.         RpcEndFinally
  2648.         
  2649.         }
  2650.     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
  2651.         {
  2652.         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
  2653.         }
  2654.     RpcEndExcept
  2655.     return _RetVal;
  2656. }
  2657.  
  2658. void __RPC_STUB IADOTier_put_StoredProc_Stub(
  2659.     IRpcStubBuffer *This,
  2660.     IRpcChannelBuffer *_pRpcChannelBuffer,
  2661.     PRPC_MESSAGE _pRpcMessage,
  2662.     DWORD *_pdwStubPhase)
  2663. {
  2664.     HRESULT _RetVal;
  2665.     MIDL_STUB_MESSAGE _StubMsg;
  2666.     void __RPC_FAR *_p_newVal;
  2667.     BSTR newVal;
  2668.     
  2669. NdrStubInitialize(
  2670.                      _pRpcMessage,
  2671.                      &_StubMsg,
  2672.                      &Object_StubDesc,
  2673.                      _pRpcChannelBuffer);
  2674.     _p_newVal = &newVal;
  2675.     MIDL_memset(
  2676.                _p_newVal,
  2677.                0,
  2678.                sizeof( BSTR  ));
  2679.     RpcTryFinally
  2680.         {
  2681.         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  2682.             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[120] );
  2683.         
  2684.         NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
  2685.                                   (unsigned char __RPC_FAR * __RPC_FAR *)&_p_newVal,
  2686.                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1152],
  2687.                                   (unsigned char)0 );
  2688.         
  2689.         
  2690.         *_pdwStubPhase = STUB_CALL_SERVER;
  2691.         _RetVal = (((IADOTier *) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> put_StoredProc((IADOTier *) ((CStdStubBuffer *)This)->pvServerObject,newVal);
  2692.         
  2693.         *_pdwStubPhase = STUB_MARSHAL;
  2694.         
  2695.         _StubMsg.BufferLength = 4U;
  2696.         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
  2697.         *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
  2698.         
  2699.         }
  2700.     RpcFinally
  2701.         {
  2702.         NdrUserMarshalFree( &_StubMsg,
  2703.                             (unsigned char __RPC_FAR *)&newVal,
  2704.                             &__MIDL_TypeFormatString.Format[1152] );
  2705.         
  2706.         }
  2707.     RpcEndFinally
  2708.     _pRpcMessage->BufferLength = 
  2709.         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
  2710.     
  2711. }
  2712.  
  2713.  
  2714. /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE IADOTier_ChangeParameter_Proxy( 
  2715.     IADOTier __RPC_FAR * This,
  2716.     /* [in] */ long idx,
  2717.     /* [in] */ enum DataTypeEnum type,
  2718.     /* [in] */ VARIANT value,
  2719.     /* [in] */ enum ParameterDirectionEnum where,
  2720.     /* [in] */ long size)
  2721. {
  2722.  
  2723.     HRESULT _RetVal;
  2724.     
  2725.     RPC_MESSAGE _RpcMessage;
  2726.     
  2727.     MIDL_STUB_MESSAGE _StubMsg;
  2728.     
  2729.     RpcTryExcept
  2730.         {
  2731.         NdrProxyInitialize(
  2732.                       ( void __RPC_FAR *  )This,
  2733.                       ( PRPC_MESSAGE  )&_RpcMessage,
  2734.                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  2735.                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
  2736.                       30);
  2737.         
  2738.         
  2739.         
  2740.         RpcTryFinally
  2741.             {
  2742.             
  2743.             _StubMsg.BufferLength = 4U + 2U + 6U + 5U + 10U;
  2744.             NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
  2745.                                       (unsigned char __RPC_FAR *)&value,
  2746.                                       (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1162] );
  2747.             
  2748.             NdrProxyGetBuffer(This, &_StubMsg);
  2749.             *(( long __RPC_FAR * )_StubMsg.Buffer)++ = idx;
  2750.             
  2751.             NdrSimpleTypeMarshall(
  2752.                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  2753.                          ( unsigned char __RPC_FAR * )&type,
  2754.                          13);
  2755.             NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
  2756.                                     (unsigned char __RPC_FAR *)&value,
  2757.                                     (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1162] );
  2758.             
  2759.             NdrSimpleTypeMarshall(
  2760.                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  2761.                          ( unsigned char __RPC_FAR * )&where,
  2762.                          13);
  2763.             _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
  2764.             *(( long __RPC_FAR * )_StubMsg.Buffer)++ = size;
  2765.             
  2766.             NdrProxySendReceive(This, &_StubMsg);
  2767.             
  2768.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  2769.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[126] );
  2770.             
  2771.             _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
  2772.             
  2773.             }
  2774.         RpcFinally
  2775.             {
  2776.             NdrProxyFreeBuffer(This, &_StubMsg);
  2777.             
  2778.             }
  2779.         RpcEndFinally
  2780.         
  2781.         }
  2782.     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
  2783.         {
  2784.         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
  2785.         }
  2786.     RpcEndExcept
  2787.     return _RetVal;
  2788. }
  2789.  
  2790. void __RPC_STUB IADOTier_ChangeParameter_Stub(
  2791.     IRpcStubBuffer *This,
  2792.     IRpcChannelBuffer *_pRpcChannelBuffer,
  2793.     PRPC_MESSAGE _pRpcMessage,
  2794.     DWORD *_pdwStubPhase)
  2795. {
  2796.     HRESULT _RetVal;
  2797.     MIDL_STUB_MESSAGE _StubMsg;
  2798.     void __RPC_FAR *_p_value;
  2799.     long idx;
  2800.     long size;
  2801.     enum DataTypeEnum type;
  2802.     VARIANT value;
  2803.     enum ParameterDirectionEnum where;
  2804.     
  2805. NdrStubInitialize(
  2806.                      _pRpcMessage,
  2807.                      &_StubMsg,
  2808.                      &Object_StubDesc,
  2809.                      _pRpcChannelBuffer);
  2810.     _p_value = &value;
  2811.     MIDL_memset(
  2812.                _p_value,
  2813.                0,
  2814.                sizeof( VARIANT  ));
  2815.     RpcTryFinally
  2816.         {
  2817.         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  2818.             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[126] );
  2819.         
  2820.         idx = *(( long __RPC_FAR * )_StubMsg.Buffer)++;
  2821.         
  2822.         NdrSimpleTypeUnmarshall(
  2823.                            ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  2824.                            ( unsigned char __RPC_FAR * )&type,
  2825.                            13);
  2826.         NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
  2827.                                   (unsigned char __RPC_FAR * __RPC_FAR *)&_p_value,
  2828.                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[1162],
  2829.                                   (unsigned char)0 );
  2830.         
  2831.         NdrSimpleTypeUnmarshall(
  2832.                            ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  2833.                            ( unsigned char __RPC_FAR * )&where,
  2834.                            13);
  2835.         _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
  2836.         size = *(( long __RPC_FAR * )_StubMsg.Buffer)++;
  2837.         
  2838.         
  2839.         *_pdwStubPhase = STUB_CALL_SERVER;
  2840.         _RetVal = (((IADOTier *) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> ChangeParameter(
  2841.                    (IADOTier *) ((CStdStubBuffer *)This)->pvServerObject,
  2842.                    idx,
  2843.                    type,
  2844.                    value,
  2845.                    where,
  2846.                    size);
  2847.         
  2848.         *_pdwStubPhase = STUB_MARSHAL;
  2849.         
  2850.         _StubMsg.BufferLength = 4U;
  2851.         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
  2852.         *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
  2853.         
  2854.         }
  2855.     RpcFinally
  2856.         {
  2857.         NdrUserMarshalFree( &_StubMsg,
  2858.                             (unsigned char __RPC_FAR *)&value,
  2859.                             &__MIDL_TypeFormatString.Format[1162] );
  2860.         
  2861.         }
  2862.     RpcEndFinally
  2863.     _pRpcMessage->BufferLength = 
  2864.         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
  2865.     
  2866. }
  2867.  
  2868.  
  2869. /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE IADOTier_Requery_Proxy( 
  2870.     IADOTier __RPC_FAR * This)
  2871. {
  2872.  
  2873.     HRESULT _RetVal;
  2874.     
  2875.     RPC_MESSAGE _RpcMessage;
  2876.     
  2877.     MIDL_STUB_MESSAGE _StubMsg;
  2878.     
  2879.     RpcTryExcept
  2880.         {
  2881.         NdrProxyInitialize(
  2882.                       ( void __RPC_FAR *  )This,
  2883.                       ( PRPC_MESSAGE  )&_RpcMessage,
  2884.                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  2885.                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
  2886.                       31);
  2887.         
  2888.         
  2889.         
  2890.         RpcTryFinally
  2891.             {
  2892.             
  2893.             _StubMsg.BufferLength = 0U;
  2894.             NdrProxyGetBuffer(This, &_StubMsg);
  2895.             NdrProxySendReceive(This, &_StubMsg);
  2896.             
  2897.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  2898.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[20] );
  2899.             
  2900.             _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
  2901.             
  2902.             }
  2903.         RpcFinally
  2904.             {
  2905.             NdrProxyFreeBuffer(This, &_StubMsg);
  2906.             
  2907.             }
  2908.         RpcEndFinally
  2909.         
  2910.         }
  2911.     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
  2912.         {
  2913.         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
  2914.         }
  2915.     RpcEndExcept
  2916.     return _RetVal;
  2917. }
  2918.  
  2919. void __RPC_STUB IADOTier_Requery_Stub(
  2920.     IRpcStubBuffer *This,
  2921.     IRpcChannelBuffer *_pRpcChannelBuffer,
  2922.     PRPC_MESSAGE _pRpcMessage,
  2923.     DWORD *_pdwStubPhase)
  2924. {
  2925.     HRESULT _RetVal;
  2926.     MIDL_STUB_MESSAGE _StubMsg;
  2927.     
  2928. NdrStubInitialize(
  2929.                      _pRpcMessage,
  2930.                      &_StubMsg,
  2931.                      &Object_StubDesc,
  2932.                      _pRpcChannelBuffer);
  2933.     RpcTryFinally
  2934.         {
  2935.         
  2936.         *_pdwStubPhase = STUB_CALL_SERVER;
  2937.         _RetVal = (((IADOTier *) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> Requery((IADOTier *) ((CStdStubBuffer *)This)->pvServerObject);
  2938.         
  2939.         *_pdwStubPhase = STUB_MARSHAL;
  2940.         
  2941.         _StubMsg.BufferLength = 4U;
  2942.         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
  2943.         *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
  2944.         
  2945.         }
  2946.     RpcFinally
  2947.         {
  2948.         }
  2949.     RpcEndFinally
  2950.     _pRpcMessage->BufferLength = 
  2951.         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
  2952.     
  2953. }
  2954.  
  2955.  
  2956. /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE IADOTier_ADORelease_Proxy( 
  2957.     IADOTier __RPC_FAR * This)
  2958. {
  2959.  
  2960.     HRESULT _RetVal;
  2961.     
  2962.     RPC_MESSAGE _RpcMessage;
  2963.     
  2964.     MIDL_STUB_MESSAGE _StubMsg;
  2965.     
  2966.     RpcTryExcept
  2967.         {
  2968.         NdrProxyInitialize(
  2969.                       ( void __RPC_FAR *  )This,
  2970.                       ( PRPC_MESSAGE  )&_RpcMessage,
  2971.                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  2972.                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
  2973.                       32);
  2974.         
  2975.         
  2976.         
  2977.         RpcTryFinally
  2978.             {
  2979.             
  2980.             _StubMsg.BufferLength = 0U;
  2981.             NdrProxyGetBuffer(This, &_StubMsg);
  2982.             NdrProxySendReceive(This, &_StubMsg);
  2983.             
  2984.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  2985.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[20] );
  2986.             
  2987.             _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
  2988.             
  2989.             }
  2990.         RpcFinally
  2991.             {
  2992.             NdrProxyFreeBuffer(This, &_StubMsg);
  2993.             
  2994.             }
  2995.         RpcEndFinally
  2996.         
  2997.         }
  2998.     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
  2999.         {
  3000.         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
  3001.         }
  3002.     RpcEndExcept
  3003.     return _RetVal;
  3004. }
  3005.  
  3006. void __RPC_STUB IADOTier_ADORelease_Stub(
  3007.     IRpcStubBuffer *This,
  3008.     IRpcChannelBuffer *_pRpcChannelBuffer,
  3009.     PRPC_MESSAGE _pRpcMessage,
  3010.     DWORD *_pdwStubPhase)
  3011. {
  3012.     HRESULT _RetVal;
  3013.     MIDL_STUB_MESSAGE _StubMsg;
  3014.     
  3015. NdrStubInitialize(
  3016.                      _pRpcMessage,
  3017.                      &_StubMsg,
  3018.                      &Object_StubDesc,
  3019.                      _pRpcChannelBuffer);
  3020.     RpcTryFinally
  3021.         {
  3022.         
  3023.         *_pdwStubPhase = STUB_CALL_SERVER;
  3024.         _RetVal = (((IADOTier *) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> ADORelease((IADOTier *) ((CStdStubBuffer *)This)->pvServerObject);
  3025.         
  3026.         *_pdwStubPhase = STUB_MARSHAL;
  3027.         
  3028.         _StubMsg.BufferLength = 4U;
  3029.         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
  3030.         *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
  3031.         
  3032.         }
  3033.     RpcFinally
  3034.         {
  3035.         }
  3036.     RpcEndFinally
  3037.     _pRpcMessage->BufferLength = 
  3038.         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
  3039.     
  3040. }
  3041.  
  3042.  
  3043. /* [helpstring][id][propget] */ HRESULT STDMETHODCALLTYPE IADOTier_get_Empty_Proxy( 
  3044.     IADOTier __RPC_FAR * This,
  3045.     /* [retval][out] */ VARIANT_BOOL __RPC_FAR *bEmpty)
  3046. {
  3047.  
  3048.     HRESULT _RetVal;
  3049.     
  3050.     RPC_MESSAGE _RpcMessage;
  3051.     
  3052.     MIDL_STUB_MESSAGE _StubMsg;
  3053.     
  3054.     RpcTryExcept
  3055.         {
  3056.         NdrProxyInitialize(
  3057.                       ( void __RPC_FAR *  )This,
  3058.                       ( PRPC_MESSAGE  )&_RpcMessage,
  3059.                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  3060.                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
  3061.                       33);
  3062.         
  3063.         
  3064.         
  3065.         RpcTryFinally
  3066.             {
  3067.             
  3068.             _StubMsg.BufferLength = 0U;
  3069.             NdrProxyGetBuffer(This, &_StubMsg);
  3070.             NdrProxySendReceive(This, &_StubMsg);
  3071.             
  3072.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  3073.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[86] );
  3074.             
  3075.             *bEmpty = *(( VARIANT_BOOL __RPC_FAR * )_StubMsg.Buffer)++;
  3076.             
  3077.             _StubMsg.Buffer += 2;
  3078.             _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
  3079.             
  3080.             }
  3081.         RpcFinally
  3082.             {
  3083.             NdrProxyFreeBuffer(This, &_StubMsg);
  3084.             
  3085.             }
  3086.         RpcEndFinally
  3087.         
  3088.         }
  3089.     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
  3090.         {
  3091.         NdrClearOutParameters(
  3092.                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  3093.                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[1098],
  3094.                          ( void __RPC_FAR * )bEmpty);
  3095.         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
  3096.         }
  3097.     RpcEndExcept
  3098.     return _RetVal;
  3099. }
  3100.  
  3101. void __RPC_STUB IADOTier_get_Empty_Stub(
  3102.     IRpcStubBuffer *This,
  3103.     IRpcChannelBuffer *_pRpcChannelBuffer,
  3104.     PRPC_MESSAGE _pRpcMessage,
  3105.     DWORD *_pdwStubPhase)
  3106. {
  3107.     VARIANT_BOOL _M5;
  3108.     HRESULT _RetVal;
  3109.     MIDL_STUB_MESSAGE _StubMsg;
  3110.     VARIANT_BOOL __RPC_FAR *bEmpty;
  3111.     
  3112. NdrStubInitialize(
  3113.                      _pRpcMessage,
  3114.                      &_StubMsg,
  3115.                      &Object_StubDesc,
  3116.                      _pRpcChannelBuffer);
  3117.     ( VARIANT_BOOL __RPC_FAR * )bEmpty = 0;
  3118.     RpcTryFinally
  3119.         {
  3120.         bEmpty = &_M5;
  3121.         
  3122.         *_pdwStubPhase = STUB_CALL_SERVER;
  3123.         _RetVal = (((IADOTier *) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> get_Empty((IADOTier *) ((CStdStubBuffer *)This)->pvServerObject,bEmpty);
  3124.         
  3125.         *_pdwStubPhase = STUB_MARSHAL;
  3126.         
  3127.         _StubMsg.BufferLength = 2U + 6U;
  3128.         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
  3129.         *(( VARIANT_BOOL __RPC_FAR * )_StubMsg.Buffer)++ = *bEmpty;
  3130.         
  3131.         _StubMsg.Buffer += 2;
  3132.         *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
  3133.         
  3134.         }
  3135.     RpcFinally
  3136.         {
  3137.         }
  3138.     RpcEndFinally
  3139.     _pRpcMessage->BufferLength = 
  3140.         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
  3141.     
  3142. }
  3143.  
  3144. extern const USER_MARSHAL_ROUTINE_QUADRUPLE UserMarshalRoutines[2];
  3145.  
  3146. static const MIDL_STUB_DESC Object_StubDesc = 
  3147.     {
  3148.     0,
  3149.     NdrOleAllocate,
  3150.     NdrOleFree,
  3151.     0,
  3152.     0,
  3153.     0,
  3154.     0,
  3155.     0,
  3156.     __MIDL_TypeFormatString.Format,
  3157.     0, /* -error bounds_check flag */
  3158.     0x20000, /* Ndr library version */
  3159.     0,
  3160.     0x303006e, /* MIDL Version 3.3.110 */
  3161.     0,
  3162.     UserMarshalRoutines,
  3163.     0,  /* Reserved1 */
  3164.     0,  /* Reserved2 */
  3165.     0,  /* Reserved3 */
  3166.     0,  /* Reserved4 */
  3167.     0   /* Reserved5 */
  3168.     };
  3169.  
  3170. CINTERFACE_PROXY_VTABLE(34) _IADOTierProxyVtbl = 
  3171. {
  3172.     &IID_IADOTier,
  3173.     IUnknown_QueryInterface_Proxy,
  3174.     IUnknown_AddRef_Proxy,
  3175.     IUnknown_Release_Proxy ,
  3176.     0 /* IDispatch_GetTypeInfoCount_Proxy */ ,
  3177.     0 /* IDispatch_GetTypeInfo_Proxy */ ,
  3178.     0 /* IDispatch_GetIDsOfNames_Proxy */ ,
  3179.     0 /* IDispatch_Invoke_Proxy */ ,
  3180.     IADOTier_Open_Proxy ,
  3181.     IADOTier_OpenRecordset_Proxy ,
  3182.     IADOTier_CloseRecordset_Proxy ,
  3183.     IADOTier_ExecuteConnection_Proxy ,
  3184.     IADOTier_ExecuteCommand_Proxy ,
  3185.     IADOTier_get_CommandText_Proxy ,
  3186.     IADOTier_put_CommandText_Proxy ,
  3187.     IADOTier_AppendParameter_Proxy ,
  3188.     IADOTier_Update_Proxy ,
  3189.     IADOTier_Delete_Proxy ,
  3190.     IADOTier_get_Field_Proxy ,
  3191.     IADOTier_put_Field_Proxy ,
  3192.     IADOTier_get_FieldCount_Proxy ,
  3193.     IADOTier_Close_Proxy ,
  3194.     IADOTier_First_Proxy ,
  3195.     IADOTier_Next_Proxy ,
  3196.     IADOTier_Last_Proxy ,
  3197.     IADOTier_Prev_Proxy ,
  3198.     IADOTier_get_EOF_Proxy ,
  3199.     IADOTier_get_BOF_Proxy ,
  3200.     IADOTier_ParamQuery_Proxy ,
  3201.     IADOTier_CallStoredProc_Proxy ,
  3202.     IADOTier_put_StoredProc_Proxy ,
  3203.     IADOTier_ChangeParameter_Proxy ,
  3204.     IADOTier_Requery_Proxy ,
  3205.     IADOTier_ADORelease_Proxy ,
  3206.     IADOTier_get_Empty_Proxy
  3207. };
  3208.  
  3209.  
  3210. static const PRPC_STUB_FUNCTION IADOTier_table[] =
  3211. {
  3212.     STUB_FORWARDING_FUNCTION,
  3213.     STUB_FORWARDING_FUNCTION,
  3214.     STUB_FORWARDING_FUNCTION,
  3215.     STUB_FORWARDING_FUNCTION,
  3216.     IADOTier_Open_Stub,
  3217.     IADOTier_OpenRecordset_Stub,
  3218.     IADOTier_CloseRecordset_Stub,
  3219.     IADOTier_ExecuteConnection_Stub,
  3220.     IADOTier_ExecuteCommand_Stub,
  3221.     IADOTier_get_CommandText_Stub,
  3222.     IADOTier_put_CommandText_Stub,
  3223.     IADOTier_AppendParameter_Stub,
  3224.     IADOTier_Update_Stub,
  3225.     IADOTier_Delete_Stub,
  3226.     IADOTier_get_Field_Stub,
  3227.     IADOTier_put_Field_Stub,
  3228.     IADOTier_get_FieldCount_Stub,
  3229.     IADOTier_Close_Stub,
  3230.     IADOTier_First_Stub,
  3231.     IADOTier_Next_Stub,
  3232.     IADOTier_Last_Stub,
  3233.     IADOTier_Prev_Stub,
  3234.     IADOTier_get_EOF_Stub,
  3235.     IADOTier_get_BOF_Stub,
  3236.     IADOTier_ParamQuery_Stub,
  3237.     IADOTier_CallStoredProc_Stub,
  3238.     IADOTier_put_StoredProc_Stub,
  3239.     IADOTier_ChangeParameter_Stub,
  3240.     IADOTier_Requery_Stub,
  3241.     IADOTier_ADORelease_Stub,
  3242.     IADOTier_get_Empty_Stub
  3243. };
  3244.  
  3245. CInterfaceStubVtbl _IADOTierStubVtbl =
  3246. {
  3247.     &IID_IADOTier,
  3248.     0,
  3249.     34,
  3250.     &IADOTier_table[-3],
  3251.     CStdStubBuffer_DELEGATING_METHODS
  3252. };
  3253.  
  3254. #pragma data_seg(".rdata")
  3255.  
  3256. static const USER_MARSHAL_ROUTINE_QUADRUPLE UserMarshalRoutines[2] = 
  3257.         {
  3258.             
  3259.             {
  3260.             BSTR_UserSize
  3261.             ,BSTR_UserMarshal
  3262.             ,BSTR_UserUnmarshal
  3263.             ,BSTR_UserFree
  3264.             },
  3265.             {
  3266.             VARIANT_UserSize
  3267.             ,VARIANT_UserMarshal
  3268.             ,VARIANT_UserUnmarshal
  3269.             ,VARIANT_UserFree
  3270.             }
  3271.  
  3272.         };
  3273.  
  3274.  
  3275. #if !defined(__RPC_WIN32__)
  3276. #error  Invalid build platform for this stub.
  3277. #endif
  3278.  
  3279. #if !(TARGET_IS_NT40_OR_LATER)
  3280. #error You need a Windows NT 4.0 or later to run this stub because it uses these features:
  3281. #error   [wire_marshal] or [user_marshal] attribute, more than 32 methods in the interface.
  3282. #error However, your C/C++ compilation flags indicate you intend to run this app on earlier systems.
  3283. #error This app will die there with the RPC_X_WRONG_STUB_VERSION error.
  3284. #endif
  3285.  
  3286.  
  3287. static const MIDL_PROC_FORMAT_STRING __MIDL_ProcFormatString =
  3288.     {
  3289.         0,
  3290.         {
  3291.             
  3292.             0x4d,        /* FC_IN_PARAM */
  3293. #ifndef _ALPHA_
  3294.             0x1,        /* x86, MIPS & PPC Stack size = 1 */
  3295. #else
  3296.             0x2,        /* Alpha Stack size = 2 */
  3297. #endif
  3298. /*  2 */    NdrFcShort( 0x18 ),    /* Type Offset=24 */
  3299. /*  4 */    
  3300.             0x4d,        /* FC_IN_PARAM */
  3301. #ifndef _ALPHA_
  3302.             0x1,        /* x86, MIPS & PPC Stack size = 1 */
  3303. #else
  3304.             0x2,        /* Alpha Stack size = 2 */
  3305. #endif
  3306. /*  6 */    NdrFcShort( 0x22 ),    /* Type Offset=34 */
  3307. /*  8 */    
  3308.             0x4d,        /* FC_IN_PARAM */
  3309. #ifndef _ALPHA_
  3310.             0x1,        /* x86, MIPS & PPC Stack size = 1 */
  3311. #else
  3312.             0x2,        /* Alpha Stack size = 2 */
  3313. #endif
  3314. /* 10 */    NdrFcShort( 0x2c ),    /* Type Offset=44 */
  3315. /* 12 */    0x53,        /* FC_RETURN_PARAM_BASETYPE */
  3316.             0x8,        /* FC_LONG */
  3317. /* 14 */    
  3318.             0x4d,        /* FC_IN_PARAM */
  3319. #ifndef _ALPHA_
  3320.             0x4,        /* x86, MIPS & PPC Stack size = 4 */
  3321. #else
  3322.             0x4,        /* Alpha Stack size = 4 */
  3323. #endif
  3324. /* 16 */    NdrFcShort( 0x3dc ),    /* Type Offset=988 */
  3325. /* 18 */    0x53,        /* FC_RETURN_PARAM_BASETYPE */
  3326.             0x8,        /* FC_LONG */
  3327. /* 20 */    0x53,        /* FC_RETURN_PARAM_BASETYPE */
  3328.             0x8,        /* FC_LONG */
  3329. /* 22 */    
  3330.             0x4d,        /* FC_IN_PARAM */
  3331. #ifndef _ALPHA_
  3332.             0x1,        /* x86, MIPS & PPC Stack size = 1 */
  3333. #else
  3334.             0x2,        /* Alpha Stack size = 2 */
  3335. #endif
  3336. /* 24 */    NdrFcShort( 0x3e6 ),    /* Type Offset=998 */
  3337. /* 26 */    0x4e,        /* FC_IN_PARAM_BASETYPE */
  3338.             0x6,        /* FC_SHORT */
  3339. /* 28 */    0x53,        /* FC_RETURN_PARAM_BASETYPE */
  3340.             0x8,        /* FC_LONG */
  3341. /* 30 */    0x4e,        /* FC_IN_PARAM_BASETYPE */
  3342.             0x6,        /* FC_SHORT */
  3343. /* 32 */    0x4e,        /* FC_IN_PARAM_BASETYPE */
  3344.             0x6,        /* FC_SHORT */
  3345. /* 34 */    0x53,        /* FC_RETURN_PARAM_BASETYPE */
  3346.             0x8,        /* FC_LONG */
  3347. /* 36 */    
  3348.             0x51,        /* FC_OUT_PARAM */
  3349. #ifndef _ALPHA_
  3350.             0x1,        /* x86, MIPS & PPC Stack size = 1 */
  3351. #else
  3352.             0x2,        /* Alpha Stack size = 2 */
  3353. #endif
  3354. /* 38 */    NdrFcShort( 0x3f0 ),    /* Type Offset=1008 */
  3355. /* 40 */    0x53,        /* FC_RETURN_PARAM_BASETYPE */
  3356.             0x8,        /* FC_LONG */
  3357. /* 42 */    
  3358.             0x4d,        /* FC_IN_PARAM */
  3359. #ifndef _ALPHA_
  3360.             0x1,        /* x86, MIPS & PPC Stack size = 1 */
  3361. #else
  3362.             0x2,        /* Alpha Stack size = 2 */
  3363. #endif
  3364. /* 44 */    NdrFcShort( 0x402 ),    /* Type Offset=1026 */
  3365. /* 46 */    0x53,        /* FC_RETURN_PARAM_BASETYPE */
  3366.             0x8,        /* FC_LONG */
  3367. /* 48 */    0x4e,        /* FC_IN_PARAM_BASETYPE */
  3368.             0xd,        /* FC_ENUM16 */
  3369. /* 50 */    
  3370.             0x4d,        /* FC_IN_PARAM */
  3371. #ifndef _ALPHA_
  3372.             0x4,        /* x86, MIPS & PPC Stack size = 4 */
  3373. #else
  3374.             0x4,        /* Alpha Stack size = 4 */
  3375. #endif
  3376. /* 52 */    NdrFcShort( 0x40c ),    /* Type Offset=1036 */
  3377. /* 54 */    0x4e,        /* FC_IN_PARAM_BASETYPE */
  3378.             0xd,        /* FC_ENUM16 */
  3379. /* 56 */    0x4e,        /* FC_IN_PARAM_BASETYPE */
  3380.             0x8,        /* FC_LONG */
  3381. /* 58 */    0x53,        /* FC_RETURN_PARAM_BASETYPE */
  3382.             0x8,        /* FC_LONG */
  3383. /* 60 */    
  3384.             0x4d,        /* FC_IN_PARAM */
  3385. #ifndef _ALPHA_
  3386.             0x4,        /* x86, MIPS & PPC Stack size = 4 */
  3387. #else
  3388.             0x4,        /* Alpha Stack size = 4 */
  3389. #endif
  3390. /* 62 */    NdrFcShort( 0x416 ),    /* Type Offset=1046 */
  3391. /* 64 */    
  3392.             0x51,        /* FC_OUT_PARAM */
  3393. #ifndef _ALPHA_
  3394.             0x1,        /* x86, MIPS & PPC Stack size = 1 */
  3395. #else
  3396.             0x2,        /* Alpha Stack size = 2 */
  3397. #endif
  3398. /* 66 */    NdrFcShort( 0x420 ),    /* Type Offset=1056 */
  3399. /* 68 */    0x53,        /* FC_RETURN_PARAM_BASETYPE */
  3400.             0x8,        /* FC_LONG */
  3401. /* 70 */    
  3402.             0x4d,        /* FC_IN_PARAM */
  3403. #ifndef _ALPHA_
  3404.             0x4,        /* x86, MIPS & PPC Stack size = 4 */
  3405. #else
  3406.             0x4,        /* Alpha Stack size = 4 */
  3407. #endif
  3408. /* 72 */    NdrFcShort( 0x432 ),    /* Type Offset=1074 */
  3409. /* 74 */    
  3410.             0x4d,        /* FC_IN_PARAM */
  3411. #ifndef _ALPHA_
  3412.             0x4,        /* x86, MIPS & PPC Stack size = 4 */
  3413. #else
  3414.             0x4,        /* Alpha Stack size = 4 */
  3415. #endif
  3416. /* 76 */    NdrFcShort( 0x43c ),    /* Type Offset=1084 */
  3417. /* 78 */    0x53,        /* FC_RETURN_PARAM_BASETYPE */
  3418.             0x8,        /* FC_LONG */
  3419. /* 80 */    
  3420.             0x51,        /* FC_OUT_PARAM */
  3421. #ifndef _ALPHA_
  3422.             0x1,        /* x86, MIPS & PPC Stack size = 1 */
  3423. #else
  3424.             0x2,        /* Alpha Stack size = 2 */
  3425. #endif
  3426. /* 82 */    NdrFcShort( 0x446 ),    /* Type Offset=1094 */
  3427. /* 84 */    0x53,        /* FC_RETURN_PARAM_BASETYPE */
  3428.             0x8,        /* FC_LONG */
  3429. /* 86 */    
  3430.             0x51,        /* FC_OUT_PARAM */
  3431. #ifndef _ALPHA_
  3432.             0x1,        /* x86, MIPS & PPC Stack size = 1 */
  3433. #else
  3434.             0x2,        /* Alpha Stack size = 2 */
  3435. #endif
  3436. /* 88 */    NdrFcShort( 0x44a ),    /* Type Offset=1098 */
  3437. /* 90 */    0x53,        /* FC_RETURN_PARAM_BASETYPE */
  3438.             0x8,        /* FC_LONG */
  3439. /* 92 */    
  3440.             0x4d,        /* FC_IN_PARAM */
  3441. #ifndef _ALPHA_
  3442.             0x1,        /* x86, MIPS & PPC Stack size = 1 */
  3443. #else
  3444.             0x2,        /* Alpha Stack size = 2 */
  3445. #endif
  3446. /* 94 */    NdrFcShort( 0x44e ),    /* Type Offset=1102 */
  3447. /* 96 */    0x4e,        /* FC_IN_PARAM_BASETYPE */
  3448.             0x8,        /* FC_LONG */
  3449. /* 98 */    
  3450.             0x4d,        /* FC_IN_PARAM */
  3451. #ifndef _ALPHA_
  3452.             0x1,        /* x86, MIPS & PPC Stack size = 1 */
  3453. #else
  3454.             0x2,        /* Alpha Stack size = 2 */
  3455. #endif
  3456. /* 100 */    NdrFcShort( 0x458 ),    /* Type Offset=1112 */
  3457. /* 102 */    
  3458.             0x4d,        /* FC_IN_PARAM */
  3459. #ifndef _ALPHA_
  3460.             0x1,        /* x86, MIPS & PPC Stack size = 1 */
  3461. #else
  3462.             0x2,        /* Alpha Stack size = 2 */
  3463. #endif
  3464. /* 104 */    NdrFcShort( 0x462 ),    /* Type Offset=1122 */
  3465. /* 106 */    0x53,        /* FC_RETURN_PARAM_BASETYPE */
  3466.             0x8,        /* FC_LONG */
  3467. /* 108 */    0x4e,        /* FC_IN_PARAM_BASETYPE */
  3468.             0x8,        /* FC_LONG */
  3469. /* 110 */    
  3470.             0x4d,        /* FC_IN_PARAM */
  3471. #ifndef _ALPHA_
  3472.             0x1,        /* x86, MIPS & PPC Stack size = 1 */
  3473. #else
  3474.             0x2,        /* Alpha Stack size = 2 */
  3475. #endif
  3476. /* 112 */    NdrFcShort( 0x46c ),    /* Type Offset=1132 */
  3477. /* 114 */    
  3478.             0x4d,        /* FC_IN_PARAM */
  3479. #ifndef _ALPHA_
  3480.             0x1,        /* x86, MIPS & PPC Stack size = 1 */
  3481. #else
  3482.             0x2,        /* Alpha Stack size = 2 */
  3483. #endif
  3484. /* 116 */    NdrFcShort( 0x476 ),    /* Type Offset=1142 */
  3485. /* 118 */    0x53,        /* FC_RETURN_PARAM_BASETYPE */
  3486.             0x8,        /* FC_LONG */
  3487. /* 120 */    
  3488.             0x4d,        /* FC_IN_PARAM */
  3489. #ifndef _ALPHA_
  3490.             0x1,        /* x86, MIPS & PPC Stack size = 1 */
  3491. #else
  3492.             0x2,        /* Alpha Stack size = 2 */
  3493. #endif
  3494. /* 122 */    NdrFcShort( 0x480 ),    /* Type Offset=1152 */
  3495. /* 124 */    0x53,        /* FC_RETURN_PARAM_BASETYPE */
  3496.             0x8,        /* FC_LONG */
  3497. /* 126 */    0x4e,        /* FC_IN_PARAM_BASETYPE */
  3498.             0x8,        /* FC_LONG */
  3499. /* 128 */    0x4e,        /* FC_IN_PARAM_BASETYPE */
  3500.             0xd,        /* FC_ENUM16 */
  3501. /* 130 */    
  3502.             0x4d,        /* FC_IN_PARAM */
  3503. #ifndef _ALPHA_
  3504.             0x4,        /* x86, MIPS & PPC Stack size = 4 */
  3505. #else
  3506.             0x4,        /* Alpha Stack size = 4 */
  3507. #endif
  3508. /* 132 */    NdrFcShort( 0x48a ),    /* Type Offset=1162 */
  3509. /* 134 */    0x4e,        /* FC_IN_PARAM_BASETYPE */
  3510.             0xd,        /* FC_ENUM16 */
  3511. /* 136 */    0x4e,        /* FC_IN_PARAM_BASETYPE */
  3512.             0x8,        /* FC_LONG */
  3513. /* 138 */    0x53,        /* FC_RETURN_PARAM_BASETYPE */
  3514.             0x8,        /* FC_LONG */
  3515.  
  3516.             0x0
  3517.         }
  3518.     };
  3519.  
  3520. static const MIDL_TYPE_FORMAT_STRING __MIDL_TypeFormatString =
  3521.     {
  3522.         0,
  3523.         {
  3524.             0x12, 0x0,    /* FC_UP */
  3525. /*  2 */    NdrFcShort( 0xc ),    /* Offset= 12 (14) */
  3526. /*  4 */    
  3527.             0x1b,        /* FC_CARRAY */
  3528.             0x1,        /* 1 */
  3529. /*  6 */    NdrFcShort( 0x2 ),    /* 2 */
  3530. /*  8 */    0x9,        /* 9 */
  3531.             0x0,        /*  */
  3532. /* 10 */    NdrFcShort( 0xfffffffc ),    /* -4 */
  3533. /* 12 */    0x6,        /* FC_SHORT */
  3534.             0x5b,        /* FC_END */
  3535. /* 14 */    
  3536.             0x17,        /* FC_CSTRUCT */
  3537.             0x3,        /* 3 */
  3538. /* 16 */    NdrFcShort( 0x8 ),    /* 8 */
  3539. /* 18 */    NdrFcShort( 0xfffffff2 ),    /* Offset= -14 (4) */
  3540. /* 20 */    0x8,        /* FC_LONG */
  3541.             0x8,        /* FC_LONG */
  3542. /* 22 */    0x5c,        /* FC_PAD */
  3543.             0x5b,        /* FC_END */
  3544. /* 24 */    0xb4,        /* FC_USER_MARSHAL */
  3545.             0x83,        /* 131 */
  3546. /* 26 */    NdrFcShort( 0x0 ),    /* 0 */
  3547. /* 28 */    NdrFcShort( 0x4 ),    /* 4 */
  3548. /* 30 */    NdrFcShort( 0x0 ),    /* 0 */
  3549. /* 32 */    NdrFcShort( 0xffffffe0 ),    /* Offset= -32 (0) */
  3550. /* 34 */    0xb4,        /* FC_USER_MARSHAL */
  3551.             0x83,        /* 131 */
  3552. /* 36 */    NdrFcShort( 0x0 ),    /* 0 */
  3553. /* 38 */    NdrFcShort( 0x4 ),    /* 4 */
  3554. /* 40 */    NdrFcShort( 0x0 ),    /* 0 */
  3555. /* 42 */    NdrFcShort( 0xffffffd6 ),    /* Offset= -42 (0) */
  3556. /* 44 */    0xb4,        /* FC_USER_MARSHAL */
  3557.             0x83,        /* 131 */
  3558. /* 46 */    NdrFcShort( 0x0 ),    /* 0 */
  3559. /* 48 */    NdrFcShort( 0x4 ),    /* 4 */
  3560. /* 50 */    NdrFcShort( 0x0 ),    /* 0 */
  3561. /* 52 */    NdrFcShort( 0xffffffcc ),    /* Offset= -52 (0) */
  3562. /* 54 */    
  3563.             0x12, 0x0,    /* FC_UP */
  3564. /* 56 */    NdrFcShort( 0x390 ),    /* Offset= 912 (968) */
  3565. /* 58 */    
  3566.             0x2b,        /* FC_NON_ENCAPSULATED_UNION */
  3567.             0x9,        /* FC_ULONG */
  3568. /* 60 */    0x7,        /* 7 */
  3569.             0x0,        /*  */
  3570. /* 62 */    NdrFcShort( 0xfffffff8 ),    /* -8 */
  3571. /* 64 */    NdrFcShort( 0x2 ),    /* Offset= 2 (66) */
  3572. /* 66 */    NdrFcShort( 0x10 ),    /* 16 */
  3573. /* 68 */    NdrFcShort( 0x2b ),    /* 43 */
  3574. /* 70 */    NdrFcLong( 0x3 ),    /* 3 */
  3575. /* 74 */    NdrFcShort( 0xffff8008 ),    /* Offset= -32760 (-32686) */
  3576. /* 76 */    NdrFcLong( 0x11 ),    /* 17 */
  3577. /* 80 */    NdrFcShort( 0xffff8002 ),    /* Offset= -32766 (-32686) */
  3578. /* 82 */    NdrFcLong( 0x2 ),    /* 2 */
  3579. /* 86 */    NdrFcShort( 0xffff8006 ),    /* Offset= -32762 (-32676) */
  3580. /* 88 */    NdrFcLong( 0x4 ),    /* 4 */
  3581. /* 92 */    NdrFcShort( 0xffff800a ),    /* Offset= -32758 (-32666) */
  3582. /* 94 */    NdrFcLong( 0x5 ),    /* 5 */
  3583. /* 98 */    NdrFcShort( 0xffff800c ),    /* Offset= -32756 (-32658) */
  3584. /* 100 */    NdrFcLong( 0xb ),    /* 11 */
  3585. /* 104 */    NdrFcShort( 0xffff8006 ),    /* Offset= -32762 (-32658) */
  3586. /* 106 */    NdrFcLong( 0xa ),    /* 10 */
  3587. /* 110 */    NdrFcShort( 0xffff8008 ),    /* Offset= -32760 (-32650) */
  3588. /* 112 */    NdrFcLong( 0x6 ),    /* 6 */
  3589. /* 116 */    NdrFcShort( 0xd6 ),    /* Offset= 214 (330) */
  3590. /* 118 */    NdrFcLong( 0x7 ),    /* 7 */
  3591. /* 122 */    NdrFcShort( 0xffff800c ),    /* Offset= -32756 (-32634) */
  3592. /* 124 */    NdrFcLong( 0x8 ),    /* 8 */
  3593. /* 128 */    NdrFcShort( 0xffffff80 ),    /* Offset= -128 (0) */
  3594. /* 130 */    NdrFcLong( 0xd ),    /* 13 */
  3595. /* 134 */    NdrFcShort( 0xca ),    /* Offset= 202 (336) */
  3596. /* 136 */    NdrFcLong( 0x9 ),    /* 9 */
  3597. /* 140 */    NdrFcShort( 0xd6 ),    /* Offset= 214 (354) */
  3598. /* 142 */    NdrFcLong( 0x2000 ),    /* 8192 */
  3599. /* 146 */    NdrFcShort( 0xe2 ),    /* Offset= 226 (372) */
  3600. /* 148 */    NdrFcLong( 0x24 ),    /* 36 */
  3601. /* 152 */    NdrFcShort( 0x2ec ),    /* Offset= 748 (900) */
  3602. /* 154 */    NdrFcLong( 0x4024 ),    /* 16420 */
  3603. /* 158 */    NdrFcShort( 0x2e6 ),    /* Offset= 742 (900) */
  3604. /* 160 */    NdrFcLong( 0x4011 ),    /* 16401 */
  3605. /* 164 */    NdrFcShort( 0x2e4 ),    /* Offset= 740 (904) */
  3606. /* 166 */    NdrFcLong( 0x4002 ),    /* 16386 */
  3607. /* 170 */    NdrFcShort( 0x2e2 ),    /* Offset= 738 (908) */
  3608. /* 172 */    NdrFcLong( 0x4003 ),    /* 16387 */
  3609. /* 176 */    NdrFcShort( 0x2e0 ),    /* Offset= 736 (912) */
  3610. /* 178 */    NdrFcLong( 0x4004 ),    /* 16388 */
  3611. /* 182 */    NdrFcShort( 0x2de ),    /* Offset= 734 (916) */
  3612. /* 184 */    NdrFcLong( 0x4005 ),    /* 16389 */
  3613. /* 188 */    NdrFcShort( 0x2dc ),    /* Offset= 732 (920) */
  3614. /* 190 */    NdrFcLong( 0x400b ),    /* 16395 */
  3615. /* 194 */    NdrFcShort( 0x2ca ),    /* Offset= 714 (908) */
  3616. /* 196 */    NdrFcLong( 0x400a ),    /* 16394 */
  3617. /* 200 */    NdrFcShort( 0x2c8 ),    /* Offset= 712 (912) */
  3618. /* 202 */    NdrFcLong( 0x4006 ),    /* 16390 */
  3619. /* 206 */    NdrFcShort( 0x2ce ),    /* Offset= 718 (924) */
  3620. /* 208 */    NdrFcLong( 0x4007 ),    /* 16391 */
  3621. /* 212 */    NdrFcShort( 0x2c4 ),    /* Offset= 708 (920) */
  3622. /* 214 */    NdrFcLong( 0x4008 ),    /* 16392 */
  3623. /* 218 */    NdrFcShort( 0x2c6 ),    /* Offset= 710 (928) */
  3624. /* 220 */    NdrFcLong( 0x400d ),    /* 16397 */
  3625. /* 224 */    NdrFcShort( 0x2c4 ),    /* Offset= 708 (932) */
  3626. /* 226 */    NdrFcLong( 0x4009 ),    /* 16393 */
  3627. /* 230 */    NdrFcShort( 0x2c2 ),    /* Offset= 706 (936) */
  3628. /* 232 */    NdrFcLong( 0x6000 ),    /* 24576 */
  3629. /* 236 */    NdrFcShort( 0x2c0 ),    /* Offset= 704 (940) */
  3630. /* 238 */    NdrFcLong( 0x400c ),    /* 16396 */
  3631. /* 242 */    NdrFcShort( 0x2be ),    /* Offset= 702 (944) */
  3632. /* 244 */    NdrFcLong( 0x10 ),    /* 16 */
  3633. /* 248 */    NdrFcShort( 0xffff8002 ),    /* Offset= -32766 (-32518) */
  3634. /* 250 */    NdrFcLong( 0x12 ),    /* 18 */
  3635. /* 254 */    NdrFcShort( 0xffff8006 ),    /* Offset= -32762 (-32508) */
  3636. /* 256 */    NdrFcLong( 0x13 ),    /* 19 */
  3637. /* 260 */    NdrFcShort( 0xffff8008 ),    /* Offset= -32760 (-32500) */
  3638. /* 262 */    NdrFcLong( 0x16 ),    /* 22 */
  3639. /* 266 */    NdrFcShort( 0xffff8008 ),    /* Offset= -32760 (-32494) */
  3640. /* 268 */    NdrFcLong( 0x17 ),    /* 23 */
  3641. /* 272 */    NdrFcShort( 0xffff8008 ),    /* Offset= -32760 (-32488) */
  3642. /* 274 */    NdrFcLong( 0xe ),    /* 14 */
  3643. /* 278 */    NdrFcShort( 0x2a2 ),    /* Offset= 674 (952) */
  3644. /* 280 */    NdrFcLong( 0x400e ),    /* 16398 */
  3645. /* 284 */    NdrFcShort( 0x2a8 ),    /* Offset= 680 (964) */
  3646. /* 286 */    NdrFcLong( 0x4010 ),    /* 16400 */
  3647. /* 290 */    NdrFcShort( 0x266 ),    /* Offset= 614 (904) */
  3648. /* 292 */    NdrFcLong( 0x4012 ),    /* 16402 */
  3649. /* 296 */    NdrFcShort( 0x264 ),    /* Offset= 612 (908) */
  3650. /* 298 */    NdrFcLong( 0x4013 ),    /* 16403 */
  3651. /* 302 */    NdrFcShort( 0x262 ),    /* Offset= 610 (912) */
  3652. /* 304 */    NdrFcLong( 0x4016 ),    /* 16406 */
  3653. /* 308 */    NdrFcShort( 0x25c ),    /* Offset= 604 (912) */
  3654. /* 310 */    NdrFcLong( 0x4017 ),    /* 16407 */
  3655. /* 314 */    NdrFcShort( 0x256 ),    /* Offset= 598 (912) */
  3656. /* 316 */    NdrFcLong( 0x0 ),    /* 0 */
  3657. /* 320 */    NdrFcShort( 0x0 ),    /* Offset= 0 (320) */
  3658. /* 322 */    NdrFcLong( 0x1 ),    /* 1 */
  3659. /* 326 */    NdrFcShort( 0x0 ),    /* Offset= 0 (326) */
  3660. /* 328 */    NdrFcShort( 0xffffffff ),    /* Offset= -1 (327) */
  3661. /* 330 */    
  3662.             0x15,        /* FC_STRUCT */
  3663.             0x7,        /* 7 */
  3664. /* 332 */    NdrFcShort( 0x8 ),    /* 8 */
  3665. /* 334 */    0xb,        /* FC_HYPER */
  3666.             0x5b,        /* FC_END */
  3667. /* 336 */    
  3668.             0x2f,        /* FC_IP */
  3669.             0x5a,        /* FC_CONSTANT_IID */
  3670. /* 338 */    NdrFcLong( 0x0 ),    /* 0 */
  3671. /* 342 */    NdrFcShort( 0x0 ),    /* 0 */
  3672. /* 344 */    NdrFcShort( 0x0 ),    /* 0 */
  3673. /* 346 */    0xc0,        /* 192 */
  3674.             0x0,        /* 0 */
  3675. /* 348 */    0x0,        /* 0 */
  3676.             0x0,        /* 0 */
  3677. /* 350 */    0x0,        /* 0 */
  3678.             0x0,        /* 0 */
  3679. /* 352 */    0x0,        /* 0 */
  3680.             0x46,        /* 70 */
  3681. /* 354 */    
  3682.             0x2f,        /* FC_IP */
  3683.             0x5a,        /* FC_CONSTANT_IID */
  3684. /* 356 */    NdrFcLong( 0x20400 ),    /* 132096 */
  3685. /* 360 */    NdrFcShort( 0x0 ),    /* 0 */
  3686. /* 362 */    NdrFcShort( 0x0 ),    /* 0 */
  3687. /* 364 */    0xc0,        /* 192 */
  3688.             0x0,        /* 0 */
  3689. /* 366 */    0x0,        /* 0 */
  3690.             0x0,        /* 0 */
  3691. /* 368 */    0x0,        /* 0 */
  3692.             0x0,        /* 0 */
  3693. /* 370 */    0x0,        /* 0 */
  3694.             0x46,        /* 70 */
  3695. /* 372 */    
  3696.             0x12, 0x0,    /* FC_UP */
  3697. /* 374 */    NdrFcShort( 0x1fc ),    /* Offset= 508 (882) */
  3698. /* 376 */    
  3699.             0x2a,        /* FC_ENCAPSULATED_UNION */
  3700.             0x49,        /* 73 */
  3701. /* 378 */    NdrFcShort( 0x18 ),    /* 24 */
  3702. /* 380 */    NdrFcShort( 0xa ),    /* 10 */
  3703. /* 382 */    NdrFcLong( 0x8 ),    /* 8 */
  3704. /* 386 */    NdrFcShort( 0x58 ),    /* Offset= 88 (474) */
  3705. /* 388 */    NdrFcLong( 0xd ),    /* 13 */
  3706. /* 392 */    NdrFcShort( 0x78 ),    /* Offset= 120 (512) */
  3707. /* 394 */    NdrFcLong( 0x9 ),    /* 9 */
  3708. /* 398 */    NdrFcShort( 0x94 ),    /* Offset= 148 (546) */
  3709. /* 400 */    NdrFcLong( 0xc ),    /* 12 */
  3710. /* 404 */    NdrFcShort( 0xbc ),    /* Offset= 188 (592) */
  3711. /* 406 */    NdrFcLong( 0x24 ),    /* 36 */
  3712. /* 410 */    NdrFcShort( 0x114 ),    /* Offset= 276 (686) */
  3713. /* 412 */    NdrFcLong( 0x800d ),    /* 32781 */
  3714. /* 416 */    NdrFcShort( 0x130 ),    /* Offset= 304 (720) */
  3715. /* 418 */    NdrFcLong( 0x10 ),    /* 16 */
  3716. /* 422 */    NdrFcShort( 0x148 ),    /* Offset= 328 (750) */
  3717. /* 424 */    NdrFcLong( 0x2 ),    /* 2 */
  3718. /* 428 */    NdrFcShort( 0x160 ),    /* Offset= 352 (780) */
  3719. /* 430 */    NdrFcLong( 0x3 ),    /* 3 */
  3720. /* 434 */    NdrFcShort( 0x178 ),    /* Offset= 376 (810) */
  3721. /* 436 */    NdrFcLong( 0x14 ),    /* 20 */
  3722. /* 440 */    NdrFcShort( 0x190 ),    /* Offset= 400 (840) */
  3723. /* 442 */    NdrFcShort( 0xffffffff ),    /* Offset= -1 (441) */
  3724. /* 444 */    
  3725.             0x1b,        /* FC_CARRAY */
  3726.             0x3,        /* 3 */
  3727. /* 446 */    NdrFcShort( 0x4 ),    /* 4 */
  3728. /* 448 */    0x19,        /* 25 */
  3729.             0x0,        /*  */
  3730. /* 450 */    NdrFcShort( 0x0 ),    /* 0 */
  3731. /* 452 */    
  3732.             0x4b,        /* FC_PP */
  3733.             0x5c,        /* FC_PAD */
  3734. /* 454 */    
  3735.             0x48,        /* FC_VARIABLE_REPEAT */
  3736.             0x49,        /* FC_FIXED_OFFSET */
  3737. /* 456 */    NdrFcShort( 0x4 ),    /* 4 */
  3738. /* 458 */    NdrFcShort( 0x0 ),    /* 0 */
  3739. /* 460 */    NdrFcShort( 0x1 ),    /* 1 */
  3740. /* 462 */    NdrFcShort( 0x0 ),    /* 0 */
  3741. /* 464 */    NdrFcShort( 0x0 ),    /* 0 */
  3742. /* 466 */    0x12, 0x0,    /* FC_UP */
  3743. /* 468 */    NdrFcShort( 0xfffffe3a ),    /* Offset= -454 (14) */
  3744. /* 470 */    
  3745.             0x5b,        /* FC_END */
  3746.  
  3747.             0x8,        /* FC_LONG */
  3748. /* 472 */    0x5c,        /* FC_PAD */
  3749.             0x5b,        /* FC_END */
  3750. /* 474 */    
  3751.             0x16,        /* FC_PSTRUCT */
  3752.             0x3,        /* 3 */
  3753. /* 476 */    NdrFcShort( 0x8 ),    /* 8 */
  3754. /* 478 */    
  3755.             0x4b,        /* FC_PP */
  3756.             0x5c,        /* FC_PAD */
  3757. /* 480 */    
  3758.             0x46,        /* FC_NO_REPEAT */
  3759.             0x5c,        /* FC_PAD */
  3760. /* 482 */    NdrFcShort( 0x4 ),    /* 4 */
  3761. /* 484 */    NdrFcShort( 0x4 ),    /* 4 */
  3762. /* 486 */    0x11, 0x0,    /* FC_RP */
  3763. /* 488 */    NdrFcShort( 0xffffffd4 ),    /* Offset= -44 (444) */
  3764. /* 490 */    
  3765.             0x5b,        /* FC_END */
  3766.  
  3767.             0x8,        /* FC_LONG */
  3768. /* 492 */    0x8,        /* FC_LONG */
  3769.             0x5b,        /* FC_END */
  3770. /* 494 */    
  3771.             0x21,        /* FC_BOGUS_ARRAY */
  3772.             0x3,        /* 3 */
  3773. /* 496 */    NdrFcShort( 0x0 ),    /* 0 */
  3774. /* 498 */    0x19,        /* 25 */
  3775.             0x0,        /*  */
  3776. /* 500 */    NdrFcShort( 0x0 ),    /* 0 */
  3777. /* 502 */    NdrFcLong( 0xffffffff ),    /* -1 */
  3778. /* 506 */    0x4c,        /* FC_EMBEDDED_COMPLEX */
  3779.             0x0,        /* 0 */
  3780. /* 508 */    NdrFcShort( 0xffffff54 ),    /* Offset= -172 (336) */
  3781. /* 510 */    0x5c,        /* FC_PAD */
  3782.             0x5b,        /* FC_END */
  3783. /* 512 */    
  3784.             0x1a,        /* FC_BOGUS_STRUCT */
  3785.             0x3,        /* 3 */
  3786. /* 514 */    NdrFcShort( 0x8 ),    /* 8 */
  3787. /* 516 */    NdrFcShort( 0x0 ),    /* 0 */
  3788. /* 518 */    NdrFcShort( 0x6 ),    /* Offset= 6 (524) */
  3789. /* 520 */    0x8,        /* FC_LONG */
  3790.             0x36,        /* FC_POINTER */
  3791. /* 522 */    0x5c,        /* FC_PAD */
  3792.             0x5b,        /* FC_END */
  3793. /* 524 */    
  3794.             0x11, 0x0,    /* FC_RP */
  3795. /* 526 */    NdrFcShort( 0xffffffe0 ),    /* Offset= -32 (494) */
  3796. /* 528 */    
  3797.             0x21,        /* FC_BOGUS_ARRAY */
  3798.             0x3,        /* 3 */
  3799. /* 530 */    NdrFcShort( 0x0 ),    /* 0 */
  3800. /* 532 */    0x19,        /* 25 */
  3801.             0x0,        /*  */
  3802. /* 534 */    NdrFcShort( 0x0 ),    /* 0 */
  3803. /* 536 */    NdrFcLong( 0xffffffff ),    /* -1 */
  3804. /* 540 */    0x4c,        /* FC_EMBEDDED_COMPLEX */
  3805.             0x0,        /* 0 */
  3806. /* 542 */    NdrFcShort( 0xffffff44 ),    /* Offset= -188 (354) */
  3807. /* 544 */    0x5c,        /* FC_PAD */
  3808.             0x5b,        /* FC_END */
  3809. /* 546 */    
  3810.             0x1a,        /* FC_BOGUS_STRUCT */
  3811.             0x3,        /* 3 */
  3812. /* 548 */    NdrFcShort( 0x8 ),    /* 8 */
  3813. /* 550 */    NdrFcShort( 0x0 ),    /* 0 */
  3814. /* 552 */    NdrFcShort( 0x6 ),    /* Offset= 6 (558) */
  3815. /* 554 */    0x8,        /* FC_LONG */
  3816.             0x36,        /* FC_POINTER */
  3817. /* 556 */    0x5c,        /* FC_PAD */
  3818.             0x5b,        /* FC_END */
  3819. /* 558 */    
  3820.             0x11, 0x0,    /* FC_RP */
  3821. /* 560 */    NdrFcShort( 0xffffffe0 ),    /* Offset= -32 (528) */
  3822. /* 562 */    
  3823.             0x1b,        /* FC_CARRAY */
  3824.             0x3,        /* 3 */
  3825. /* 564 */    NdrFcShort( 0x4 ),    /* 4 */
  3826. /* 566 */    0x19,        /* 25 */
  3827.             0x0,        /*  */
  3828. /* 568 */    NdrFcShort( 0x0 ),    /* 0 */
  3829. /* 570 */    
  3830.             0x4b,        /* FC_PP */
  3831.             0x5c,        /* FC_PAD */
  3832. /* 572 */    
  3833.             0x48,        /* FC_VARIABLE_REPEAT */
  3834.             0x49,        /* FC_FIXED_OFFSET */
  3835. /* 574 */    NdrFcShort( 0x4 ),    /* 4 */
  3836. /* 576 */    NdrFcShort( 0x0 ),    /* 0 */
  3837. /* 578 */    NdrFcShort( 0x1 ),    /* 1 */
  3838. /* 580 */    NdrFcShort( 0x0 ),    /* 0 */
  3839. /* 582 */    NdrFcShort( 0x0 ),    /* 0 */
  3840. /* 584 */    0x12, 0x0,    /* FC_UP */
  3841. /* 586 */    NdrFcShort( 0x17e ),    /* Offset= 382 (968) */
  3842. /* 588 */    
  3843.             0x5b,        /* FC_END */
  3844.  
  3845.             0x8,        /* FC_LONG */
  3846. /* 590 */    0x5c,        /* FC_PAD */
  3847.             0x5b,        /* FC_END */
  3848. /* 592 */    
  3849.             0x1a,        /* FC_BOGUS_STRUCT */
  3850.             0x3,        /* 3 */
  3851. /* 594 */    NdrFcShort( 0x8 ),    /* 8 */
  3852. /* 596 */    NdrFcShort( 0x0 ),    /* 0 */
  3853. /* 598 */    NdrFcShort( 0x6 ),    /* Offset= 6 (604) */
  3854. /* 600 */    0x8,        /* FC_LONG */
  3855.             0x36,        /* FC_POINTER */
  3856. /* 602 */    0x5c,        /* FC_PAD */
  3857.             0x5b,        /* FC_END */
  3858. /* 604 */    
  3859.             0x11, 0x0,    /* FC_RP */
  3860. /* 606 */    NdrFcShort( 0xffffffd4 ),    /* Offset= -44 (562) */
  3861. /* 608 */    
  3862.             0x2f,        /* FC_IP */
  3863.             0x5a,        /* FC_CONSTANT_IID */
  3864. /* 610 */    NdrFcLong( 0x2f ),    /* 47 */
  3865. /* 614 */    NdrFcShort( 0x0 ),    /* 0 */
  3866. /* 616 */    NdrFcShort( 0x0 ),    /* 0 */
  3867. /* 618 */    0xc0,        /* 192 */
  3868.             0x0,        /* 0 */
  3869. /* 620 */    0x0,        /* 0 */
  3870.             0x0,        /* 0 */
  3871. /* 622 */    0x0,        /* 0 */
  3872.             0x0,        /* 0 */
  3873. /* 624 */    0x0,        /* 0 */
  3874.             0x46,        /* 70 */
  3875. /* 626 */    
  3876.             0x1b,        /* FC_CARRAY */
  3877.             0x0,        /* 0 */
  3878. /* 628 */    NdrFcShort( 0x1 ),    /* 1 */
  3879. /* 630 */    0x19,        /* 25 */
  3880.             0x0,        /*  */
  3881. /* 632 */    NdrFcShort( 0x4 ),    /* 4 */
  3882. /* 634 */    0x1,        /* FC_BYTE */
  3883.             0x5b,        /* FC_END */
  3884. /* 636 */    
  3885.             0x1a,        /* FC_BOGUS_STRUCT */
  3886.             0x3,        /* 3 */
  3887. /* 638 */    NdrFcShort( 0x10 ),    /* 16 */
  3888. /* 640 */    NdrFcShort( 0x0 ),    /* 0 */
  3889. /* 642 */    NdrFcShort( 0xa ),    /* Offset= 10 (652) */
  3890. /* 644 */    0x8,        /* FC_LONG */
  3891.             0x8,        /* FC_LONG */
  3892. /* 646 */    0x4c,        /* FC_EMBEDDED_COMPLEX */
  3893.             0x0,        /* 0 */
  3894. /* 648 */    NdrFcShort( 0xffffffd8 ),    /* Offset= -40 (608) */
  3895. /* 650 */    0x36,        /* FC_POINTER */
  3896.             0x5b,        /* FC_END */
  3897. /* 652 */    
  3898.             0x12, 0x0,    /* FC_UP */
  3899. /* 654 */    NdrFcShort( 0xffffffe4 ),    /* Offset= -28 (626) */
  3900. /* 656 */    
  3901.             0x1b,        /* FC_CARRAY */
  3902.             0x3,        /* 3 */
  3903. /* 658 */    NdrFcShort( 0x4 ),    /* 4 */
  3904. /* 660 */    0x19,        /* 25 */
  3905.             0x0,        /*  */
  3906. /* 662 */    NdrFcShort( 0x0 ),    /* 0 */
  3907. /* 664 */    
  3908.             0x4b,        /* FC_PP */
  3909.             0x5c,        /* FC_PAD */
  3910. /* 666 */    
  3911.             0x48,        /* FC_VARIABLE_REPEAT */
  3912.             0x49,        /* FC_FIXED_OFFSET */
  3913. /* 668 */    NdrFcShort( 0x4 ),    /* 4 */
  3914. /* 670 */    NdrFcShort( 0x0 ),    /* 0 */
  3915. /* 672 */    NdrFcShort( 0x1 ),    /* 1 */
  3916. /* 674 */    NdrFcShort( 0x0 ),    /* 0 */
  3917. /* 676 */    NdrFcShort( 0x0 ),    /* 0 */
  3918. /* 678 */    0x12, 0x0,    /* FC_UP */
  3919. /* 680 */    NdrFcShort( 0xffffffd4 ),    /* Offset= -44 (636) */
  3920. /* 682 */    
  3921.             0x5b,        /* FC_END */
  3922.  
  3923.             0x8,        /* FC_LONG */
  3924. /* 684 */    0x5c,        /* FC_PAD */
  3925.             0x5b,        /* FC_END */
  3926. /* 686 */    
  3927.             0x1a,        /* FC_BOGUS_STRUCT */
  3928.             0x3,        /* 3 */
  3929. /* 688 */    NdrFcShort( 0x8 ),    /* 8 */
  3930. /* 690 */    NdrFcShort( 0x0 ),    /* 0 */
  3931. /* 692 */    NdrFcShort( 0x6 ),    /* Offset= 6 (698) */
  3932. /* 694 */    0x8,        /* FC_LONG */
  3933.             0x36,        /* FC_POINTER */
  3934. /* 696 */    0x5c,        /* FC_PAD */
  3935.             0x5b,        /* FC_END */
  3936. /* 698 */    
  3937.             0x11, 0x0,    /* FC_RP */
  3938. /* 700 */    NdrFcShort( 0xffffffd4 ),    /* Offset= -44 (656) */
  3939. /* 702 */    
  3940.             0x1d,        /* FC_SMFARRAY */
  3941.             0x0,        /* 0 */
  3942. /* 704 */    NdrFcShort( 0x8 ),    /* 8 */
  3943. /* 706 */    0x2,        /* FC_CHAR */
  3944.             0x5b,        /* FC_END */
  3945. /* 708 */    
  3946.             0x15,        /* FC_STRUCT */
  3947.             0x3,        /* 3 */
  3948. /* 710 */    NdrFcShort( 0x10 ),    /* 16 */
  3949. /* 712 */    0x8,        /* FC_LONG */
  3950.             0x6,        /* FC_SHORT */
  3951. /* 714 */    0x6,        /* FC_SHORT */
  3952.             0x4c,        /* FC_EMBEDDED_COMPLEX */
  3953. /* 716 */    0x0,        /* 0 */
  3954.             NdrFcShort( 0xfffffff1 ),    /* Offset= -15 (702) */
  3955.             0x5b,        /* FC_END */
  3956. /* 720 */    
  3957.             0x1a,        /* FC_BOGUS_STRUCT */
  3958.             0x3,        /* 3 */
  3959. /* 722 */    NdrFcShort( 0x18 ),    /* 24 */
  3960. /* 724 */    NdrFcShort( 0x0 ),    /* 0 */
  3961. /* 726 */    NdrFcShort( 0xa ),    /* Offset= 10 (736) */
  3962. /* 728 */    0x8,        /* FC_LONG */
  3963.             0x36,        /* FC_POINTER */
  3964. /* 730 */    0x4c,        /* FC_EMBEDDED_COMPLEX */
  3965.             0x0,        /* 0 */
  3966. /* 732 */    NdrFcShort( 0xffffffe8 ),    /* Offset= -24 (708) */
  3967. /* 734 */    0x5c,        /* FC_PAD */
  3968.             0x5b,        /* FC_END */
  3969. /* 736 */    
  3970.             0x11, 0x0,    /* FC_RP */
  3971. /* 738 */    NdrFcShort( 0xffffff0c ),    /* Offset= -244 (494) */
  3972. /* 740 */    
  3973.             0x1b,        /* FC_CARRAY */
  3974.             0x0,        /* 0 */
  3975. /* 742 */    NdrFcShort( 0x1 ),    /* 1 */
  3976. /* 744 */    0x19,        /* 25 */
  3977.             0x0,        /*  */
  3978. /* 746 */    NdrFcShort( 0x0 ),    /* 0 */
  3979. /* 748 */    0x1,        /* FC_BYTE */
  3980.             0x5b,        /* FC_END */
  3981. /* 750 */    
  3982.             0x16,        /* FC_PSTRUCT */
  3983.             0x3,        /* 3 */
  3984. /* 752 */    NdrFcShort( 0x8 ),    /* 8 */
  3985. /* 754 */    
  3986.             0x4b,        /* FC_PP */
  3987.             0x5c,        /* FC_PAD */
  3988. /* 756 */    
  3989.             0x46,        /* FC_NO_REPEAT */
  3990.             0x5c,        /* FC_PAD */
  3991. /* 758 */    NdrFcShort( 0x4 ),    /* 4 */
  3992. /* 760 */    NdrFcShort( 0x4 ),    /* 4 */
  3993. /* 762 */    0x12, 0x0,    /* FC_UP */
  3994. /* 764 */    NdrFcShort( 0xffffffe8 ),    /* Offset= -24 (740) */
  3995. /* 766 */    
  3996.             0x5b,        /* FC_END */
  3997.  
  3998.             0x8,        /* FC_LONG */
  3999. /* 768 */    0x8,        /* FC_LONG */
  4000.             0x5b,        /* FC_END */
  4001. /* 770 */    
  4002.             0x1b,        /* FC_CARRAY */
  4003.             0x1,        /* 1 */
  4004. /* 772 */    NdrFcShort( 0x2 ),    /* 2 */
  4005. /* 774 */    0x19,        /* 25 */
  4006.             0x0,        /*  */
  4007. /* 776 */    NdrFcShort( 0x0 ),    /* 0 */
  4008. /* 778 */    0x6,        /* FC_SHORT */
  4009.             0x5b,        /* FC_END */
  4010. /* 780 */    
  4011.             0x16,        /* FC_PSTRUCT */
  4012.             0x3,        /* 3 */
  4013. /* 782 */    NdrFcShort( 0x8 ),    /* 8 */
  4014. /* 784 */    
  4015.             0x4b,        /* FC_PP */
  4016.             0x5c,        /* FC_PAD */
  4017. /* 786 */    
  4018.             0x46,        /* FC_NO_REPEAT */
  4019.             0x5c,        /* FC_PAD */
  4020. /* 788 */    NdrFcShort( 0x4 ),    /* 4 */
  4021. /* 790 */    NdrFcShort( 0x4 ),    /* 4 */
  4022. /* 792 */    0x12, 0x0,    /* FC_UP */
  4023. /* 794 */    NdrFcShort( 0xffffffe8 ),    /* Offset= -24 (770) */
  4024. /* 796 */    
  4025.             0x5b,        /* FC_END */
  4026.  
  4027.             0x8,        /* FC_LONG */
  4028. /* 798 */    0x8,        /* FC_LONG */
  4029.             0x5b,        /* FC_END */
  4030. /* 800 */    
  4031.             0x1b,        /* FC_CARRAY */
  4032.             0x3,        /* 3 */
  4033. /* 802 */    NdrFcShort( 0x4 ),    /* 4 */
  4034. /* 804 */    0x19,        /* 25 */
  4035.             0x0,        /*  */
  4036. /* 806 */    NdrFcShort( 0x0 ),    /* 0 */
  4037. /* 808 */    0x8,        /* FC_LONG */
  4038.             0x5b,        /* FC_END */
  4039. /* 810 */    
  4040.             0x16,        /* FC_PSTRUCT */
  4041.             0x3,        /* 3 */
  4042. /* 812 */    NdrFcShort( 0x8 ),    /* 8 */
  4043. /* 814 */    
  4044.             0x4b,        /* FC_PP */
  4045.             0x5c,        /* FC_PAD */
  4046. /* 816 */    
  4047.             0x46,        /* FC_NO_REPEAT */
  4048.             0x5c,        /* FC_PAD */
  4049. /* 818 */    NdrFcShort( 0x4 ),    /* 4 */
  4050. /* 820 */    NdrFcShort( 0x4 ),    /* 4 */
  4051. /* 822 */    0x12, 0x0,    /* FC_UP */
  4052. /* 824 */    NdrFcShort( 0xffffffe8 ),    /* Offset= -24 (800) */
  4053. /* 826 */    
  4054.             0x5b,        /* FC_END */
  4055.  
  4056.             0x8,        /* FC_LONG */
  4057. /* 828 */    0x8,        /* FC_LONG */
  4058.             0x5b,        /* FC_END */
  4059. /* 830 */    
  4060.             0x1b,        /* FC_CARRAY */
  4061.             0x7,        /* 7 */
  4062. /* 832 */    NdrFcShort( 0x8 ),    /* 8 */
  4063. /* 834 */    0x19,        /* 25 */
  4064.             0x0,        /*  */
  4065. /* 836 */    NdrFcShort( 0x0 ),    /* 0 */
  4066. /* 838 */    0xb,        /* FC_HYPER */
  4067.             0x5b,        /* FC_END */
  4068. /* 840 */    
  4069.             0x16,        /* FC_PSTRUCT */
  4070.             0x3,        /* 3 */
  4071. /* 842 */    NdrFcShort( 0x8 ),    /* 8 */
  4072. /* 844 */    
  4073.             0x4b,        /* FC_PP */
  4074.             0x5c,        /* FC_PAD */
  4075. /* 846 */    
  4076.             0x46,        /* FC_NO_REPEAT */
  4077.             0x5c,        /* FC_PAD */
  4078. /* 848 */    NdrFcShort( 0x4 ),    /* 4 */
  4079. /* 850 */    NdrFcShort( 0x4 ),    /* 4 */
  4080. /* 852 */    0x12, 0x0,    /* FC_UP */
  4081. /* 854 */    NdrFcShort( 0xffffffe8 ),    /* Offset= -24 (830) */
  4082. /* 856 */    
  4083.             0x5b,        /* FC_END */
  4084.  
  4085.             0x8,        /* FC_LONG */
  4086. /* 858 */    0x8,        /* FC_LONG */
  4087.             0x5b,        /* FC_END */
  4088. /* 860 */    
  4089.             0x15,        /* FC_STRUCT */
  4090.             0x3,        /* 3 */
  4091. /* 862 */    NdrFcShort( 0x8 ),    /* 8 */
  4092. /* 864 */    0x8,        /* FC_LONG */
  4093.             0x8,        /* FC_LONG */
  4094. /* 866 */    0x5c,        /* FC_PAD */
  4095.             0x5b,        /* FC_END */
  4096. /* 868 */    
  4097.             0x1b,        /* FC_CARRAY */
  4098.             0x3,        /* 3 */
  4099. /* 870 */    NdrFcShort( 0x8 ),    /* 8 */
  4100. /* 872 */    0x7,        /* 7 */
  4101.             0x0,        /*  */
  4102. /* 874 */    NdrFcShort( 0xffffffd8 ),    /* -40 */
  4103. /* 876 */    0x4c,        /* FC_EMBEDDED_COMPLEX */
  4104.             0x0,        /* 0 */
  4105. /* 878 */    NdrFcShort( 0xffffffee ),    /* Offset= -18 (860) */
  4106. /* 880 */    0x5c,        /* FC_PAD */
  4107.             0x5b,        /* FC_END */
  4108. /* 882 */    
  4109.             0x1a,        /* FC_BOGUS_STRUCT */
  4110.             0x3,        /* 3 */
  4111. /* 884 */    NdrFcShort( 0x28 ),    /* 40 */
  4112. /* 886 */    NdrFcShort( 0xffffffee ),    /* Offset= -18 (868) */
  4113. /* 888 */    NdrFcShort( 0x0 ),    /* Offset= 0 (888) */
  4114. /* 890 */    0x6,        /* FC_SHORT */
  4115.             0x6,        /* FC_SHORT */
  4116. /* 892 */    0x38,        /* FC_ALIGNM4 */
  4117.             0x8,        /* FC_LONG */
  4118. /* 894 */    0x8,        /* FC_LONG */
  4119.             0x4c,        /* FC_EMBEDDED_COMPLEX */
  4120. /* 896 */    0x0,        /* 0 */
  4121.             NdrFcShort( 0xfffffdf7 ),    /* Offset= -521 (376) */
  4122.             0x5b,        /* FC_END */
  4123. /* 900 */    
  4124.             0x12, 0x0,    /* FC_UP */
  4125. /* 902 */    NdrFcShort( 0xfffffef6 ),    /* Offset= -266 (636) */
  4126. /* 904 */    
  4127.             0x12, 0x8,    /* FC_UP [simple_pointer] */
  4128. /* 906 */    0x2,        /* FC_CHAR */
  4129.             0x5c,        /* FC_PAD */
  4130. /* 908 */    
  4131.             0x12, 0x8,    /* FC_UP [simple_pointer] */
  4132. /* 910 */    0x6,        /* FC_SHORT */
  4133.             0x5c,        /* FC_PAD */
  4134. /* 912 */    
  4135.             0x12, 0x8,    /* FC_UP [simple_pointer] */
  4136. /* 914 */    0x8,        /* FC_LONG */
  4137.             0x5c,        /* FC_PAD */
  4138. /* 916 */    
  4139.             0x12, 0x8,    /* FC_UP [simple_pointer] */
  4140. /* 918 */    0xa,        /* FC_FLOAT */
  4141.             0x5c,        /* FC_PAD */
  4142. /* 920 */    
  4143.             0x12, 0x8,    /* FC_UP [simple_pointer] */
  4144. /* 922 */    0xc,        /* FC_DOUBLE */
  4145.             0x5c,        /* FC_PAD */
  4146. /* 924 */    
  4147.             0x12, 0x0,    /* FC_UP */
  4148. /* 926 */    NdrFcShort( 0xfffffdac ),    /* Offset= -596 (330) */
  4149. /* 928 */    
  4150.             0x12, 0x10,    /* FC_UP */
  4151. /* 930 */    NdrFcShort( 0xfffffc5e ),    /* Offset= -930 (0) */
  4152. /* 932 */    
  4153.             0x12, 0x10,    /* FC_UP */
  4154. /* 934 */    NdrFcShort( 0xfffffdaa ),    /* Offset= -598 (336) */
  4155. /* 936 */    
  4156.             0x12, 0x10,    /* FC_UP */
  4157. /* 938 */    NdrFcShort( 0xfffffdb8 ),    /* Offset= -584 (354) */
  4158. /* 940 */    
  4159.             0x12, 0x10,    /* FC_UP */
  4160. /* 942 */    NdrFcShort( 0xfffffdc6 ),    /* Offset= -570 (372) */
  4161. /* 944 */    
  4162.             0x12, 0x10,    /* FC_UP */
  4163. /* 946 */    NdrFcShort( 0x2 ),    /* Offset= 2 (948) */
  4164. /* 948 */    
  4165.             0x12, 0x0,    /* FC_UP */
  4166. /* 950 */    NdrFcShort( 0xfffffc4a ),    /* Offset= -950 (0) */
  4167. /* 952 */    
  4168.             0x15,        /* FC_STRUCT */
  4169.             0x7,        /* 7 */
  4170. /* 954 */    NdrFcShort( 0x10 ),    /* 16 */
  4171. /* 956 */    0x6,        /* FC_SHORT */
  4172.             0x2,        /* FC_CHAR */
  4173. /* 958 */    0x2,        /* FC_CHAR */
  4174.             0x38,        /* FC_ALIGNM4 */
  4175. /* 960 */    0x8,        /* FC_LONG */
  4176.             0x39,        /* FC_ALIGNM8 */
  4177. /* 962 */    0xb,        /* FC_HYPER */
  4178.             0x5b,        /* FC_END */
  4179. /* 964 */    
  4180.             0x12, 0x0,    /* FC_UP */
  4181. /* 966 */    NdrFcShort( 0xfffffff2 ),    /* Offset= -14 (952) */
  4182. /* 968 */    
  4183.             0x1a,        /* FC_BOGUS_STRUCT */
  4184.             0x7,        /* 7 */
  4185. /* 970 */    NdrFcShort( 0x20 ),    /* 32 */
  4186. /* 972 */    NdrFcShort( 0x0 ),    /* 0 */
  4187. /* 974 */    NdrFcShort( 0x0 ),    /* Offset= 0 (974) */
  4188. /* 976 */    0x8,        /* FC_LONG */
  4189.             0x8,        /* FC_LONG */
  4190. /* 978 */    0x6,        /* FC_SHORT */
  4191.             0x6,        /* FC_SHORT */
  4192. /* 980 */    0x6,        /* FC_SHORT */
  4193.             0x6,        /* FC_SHORT */
  4194. /* 982 */    0x4c,        /* FC_EMBEDDED_COMPLEX */
  4195.             0x0,        /* 0 */
  4196. /* 984 */    NdrFcShort( 0xfffffc62 ),    /* Offset= -926 (58) */
  4197. /* 986 */    0x5c,        /* FC_PAD */
  4198.             0x5b,        /* FC_END */
  4199. /* 988 */    0xb4,        /* FC_USER_MARSHAL */
  4200.             0x83,        /* 131 */
  4201. /* 990 */    NdrFcShort( 0x1 ),    /* 1 */
  4202. /* 992 */    NdrFcShort( 0x10 ),    /* 16 */
  4203. /* 994 */    NdrFcShort( 0x0 ),    /* 0 */
  4204. /* 996 */    NdrFcShort( 0xfffffc52 ),    /* Offset= -942 (54) */
  4205. /* 998 */    0xb4,        /* FC_USER_MARSHAL */
  4206.             0x83,        /* 131 */
  4207. /* 1000 */    NdrFcShort( 0x0 ),    /* 0 */
  4208. /* 1002 */    NdrFcShort( 0x4 ),    /* 4 */
  4209. /* 1004 */    NdrFcShort( 0x0 ),    /* 0 */
  4210. /* 1006 */    NdrFcShort( 0xfffffc12 ),    /* Offset= -1006 (0) */
  4211. /* 1008 */    
  4212.             0x11, 0x4,    /* FC_RP [alloced_on_stack] */
  4213. /* 1010 */    NdrFcShort( 0x6 ),    /* Offset= 6 (1016) */
  4214. /* 1012 */    
  4215.             0x13, 0x0,    /* FC_OP */
  4216. /* 1014 */    NdrFcShort( 0xfffffc18 ),    /* Offset= -1000 (14) */
  4217. /* 1016 */    0xb4,        /* FC_USER_MARSHAL */
  4218.             0x83,        /* 131 */
  4219. /* 1018 */    NdrFcShort( 0x0 ),    /* 0 */
  4220. /* 1020 */    NdrFcShort( 0x4 ),    /* 4 */
  4221. /* 1022 */    NdrFcShort( 0x0 ),    /* 0 */
  4222. /* 1024 */    NdrFcShort( 0xfffffff4 ),    /* Offset= -12 (1012) */
  4223. /* 1026 */    0xb4,        /* FC_USER_MARSHAL */
  4224.             0x83,        /* 131 */
  4225. /* 1028 */    NdrFcShort( 0x0 ),    /* 0 */
  4226. /* 1030 */    NdrFcShort( 0x4 ),    /* 4 */
  4227. /* 1032 */    NdrFcShort( 0x0 ),    /* 0 */
  4228. /* 1034 */    NdrFcShort( 0xfffffbf6 ),    /* Offset= -1034 (0) */
  4229. /* 1036 */    0xb4,        /* FC_USER_MARSHAL */
  4230.             0x83,        /* 131 */
  4231. /* 1038 */    NdrFcShort( 0x1 ),    /* 1 */
  4232. /* 1040 */    NdrFcShort( 0x10 ),    /* 16 */
  4233. /* 1042 */    NdrFcShort( 0x0 ),    /* 0 */
  4234. /* 1044 */    NdrFcShort( 0xfffffc22 ),    /* Offset= -990 (54) */
  4235. /* 1046 */    0xb4,        /* FC_USER_MARSHAL */
  4236.             0x83,        /* 131 */
  4237. /* 1048 */    NdrFcShort( 0x1 ),    /* 1 */
  4238. /* 1050 */    NdrFcShort( 0x10 ),    /* 16 */
  4239. /* 1052 */    NdrFcShort( 0x0 ),    /* 0 */
  4240. /* 1054 */    NdrFcShort( 0xfffffc18 ),    /* Offset= -1000 (54) */
  4241. /* 1056 */    
  4242.             0x11, 0x4,    /* FC_RP [alloced_on_stack] */
  4243. /* 1058 */    NdrFcShort( 0x6 ),    /* Offset= 6 (1064) */
  4244. /* 1060 */    
  4245.             0x13, 0x0,    /* FC_OP */
  4246. /* 1062 */    NdrFcShort( 0xffffffa2 ),    /* Offset= -94 (968) */
  4247. /* 1064 */    0xb4,        /* FC_USER_MARSHAL */
  4248.             0x83,        /* 131 */
  4249. /* 1066 */    NdrFcShort( 0x1 ),    /* 1 */
  4250. /* 1068 */    NdrFcShort( 0x10 ),    /* 16 */
  4251. /* 1070 */    NdrFcShort( 0x0 ),    /* 0 */
  4252. /* 1072 */    NdrFcShort( 0xfffffff4 ),    /* Offset= -12 (1060) */
  4253. /* 1074 */    0xb4,        /* FC_USER_MARSHAL */
  4254.             0x83,        /* 131 */
  4255. /* 1076 */    NdrFcShort( 0x1 ),    /* 1 */
  4256. /* 1078 */    NdrFcShort( 0x10 ),    /* 16 */
  4257. /* 1080 */    NdrFcShort( 0x0 ),    /* 0 */
  4258. /* 1082 */    NdrFcShort( 0xfffffbfc ),    /* Offset= -1028 (54) */
  4259. /* 1084 */    0xb4,        /* FC_USER_MARSHAL */
  4260.             0x83,        /* 131 */
  4261. /* 1086 */    NdrFcShort( 0x1 ),    /* 1 */
  4262. /* 1088 */    NdrFcShort( 0x10 ),    /* 16 */
  4263. /* 1090 */    NdrFcShort( 0x0 ),    /* 0 */
  4264. /* 1092 */    NdrFcShort( 0xfffffbf2 ),    /* Offset= -1038 (54) */
  4265. /* 1094 */    
  4266.             0x11, 0xc,    /* FC_RP [alloced_on_stack] [simple_pointer] */
  4267. /* 1096 */    0x8,        /* FC_LONG */
  4268.             0x5c,        /* FC_PAD */
  4269. /* 1098 */    
  4270.             0x11, 0xc,    /* FC_RP [alloced_on_stack] [simple_pointer] */
  4271. /* 1100 */    0x6,        /* FC_SHORT */
  4272.             0x5c,        /* FC_PAD */
  4273. /* 1102 */    0xb4,        /* FC_USER_MARSHAL */
  4274.             0x83,        /* 131 */
  4275. /* 1104 */    NdrFcShort( 0x0 ),    /* 0 */
  4276. /* 1106 */    NdrFcShort( 0x4 ),    /* 4 */
  4277. /* 1108 */    NdrFcShort( 0x0 ),    /* 0 */
  4278. /* 1110 */    NdrFcShort( 0xfffffbaa ),    /* Offset= -1110 (0) */
  4279. /* 1112 */    0xb4,        /* FC_USER_MARSHAL */
  4280.             0x83,        /* 131 */
  4281. /* 1114 */    NdrFcShort( 0x0 ),    /* 0 */
  4282. /* 1116 */    NdrFcShort( 0x4 ),    /* 4 */
  4283. /* 1118 */    NdrFcShort( 0x0 ),    /* 0 */
  4284. /* 1120 */    NdrFcShort( 0xfffffba0 ),    /* Offset= -1120 (0) */
  4285. /* 1122 */    0xb4,        /* FC_USER_MARSHAL */
  4286.             0x83,        /* 131 */
  4287. /* 1124 */    NdrFcShort( 0x0 ),    /* 0 */
  4288. /* 1126 */    NdrFcShort( 0x4 ),    /* 4 */
  4289. /* 1128 */    NdrFcShort( 0x0 ),    /* 0 */
  4290. /* 1130 */    NdrFcShort( 0xfffffb96 ),    /* Offset= -1130 (0) */
  4291. /* 1132 */    0xb4,        /* FC_USER_MARSHAL */
  4292.             0x83,        /* 131 */
  4293. /* 1134 */    NdrFcShort( 0x0 ),    /* 0 */
  4294. /* 1136 */    NdrFcShort( 0x4 ),    /* 4 */
  4295. /* 1138 */    NdrFcShort( 0x0 ),    /* 0 */
  4296. /* 1140 */    NdrFcShort( 0xfffffb8c ),    /* Offset= -1140 (0) */
  4297. /* 1142 */    0xb4,        /* FC_USER_MARSHAL */
  4298.             0x83,        /* 131 */
  4299. /* 1144 */    NdrFcShort( 0x0 ),    /* 0 */
  4300. /* 1146 */    NdrFcShort( 0x4 ),    /* 4 */
  4301. /* 1148 */    NdrFcShort( 0x0 ),    /* 0 */
  4302. /* 1150 */    NdrFcShort( 0xfffffb82 ),    /* Offset= -1150 (0) */
  4303. /* 1152 */    0xb4,        /* FC_USER_MARSHAL */
  4304.             0x83,        /* 131 */
  4305. /* 1154 */    NdrFcShort( 0x0 ),    /* 0 */
  4306. /* 1156 */    NdrFcShort( 0x4 ),    /* 4 */
  4307. /* 1158 */    NdrFcShort( 0x0 ),    /* 0 */
  4308. /* 1160 */    NdrFcShort( 0xfffffb78 ),    /* Offset= -1160 (0) */
  4309. /* 1162 */    0xb4,        /* FC_USER_MARSHAL */
  4310.             0x83,        /* 131 */
  4311. /* 1164 */    NdrFcShort( 0x1 ),    /* 1 */
  4312. /* 1166 */    NdrFcShort( 0x10 ),    /* 16 */
  4313. /* 1168 */    NdrFcShort( 0x0 ),    /* 0 */
  4314. /* 1170 */    NdrFcShort( 0xfffffba4 ),    /* Offset= -1116 (54) */
  4315.  
  4316.             0x0
  4317.         }
  4318.     };
  4319.  
  4320. const CInterfaceProxyVtbl * _ADOSamp_ProxyVtblList[] = 
  4321. {
  4322.     ( CInterfaceProxyVtbl *) &_IADOTierProxyVtbl,
  4323.     0
  4324. };
  4325.  
  4326. const CInterfaceStubVtbl * _ADOSamp_StubVtblList[] = 
  4327. {
  4328.     ( CInterfaceStubVtbl *) &_IADOTierStubVtbl,
  4329.     0
  4330. };
  4331.  
  4332. PCInterfaceName const _ADOSamp_InterfaceNamesList[] = 
  4333. {
  4334.     "IADOTier",
  4335.     0
  4336. };
  4337.  
  4338. const IID *  _ADOSamp_BaseIIDList[] = 
  4339. {
  4340.     &IID_IDispatch,
  4341.     0
  4342. };
  4343.  
  4344.  
  4345. #define _ADOSamp_CHECK_IID(n)    IID_GENERIC_CHECK_IID( _ADOSamp, pIID, n)
  4346.  
  4347. int __stdcall _ADOSamp_IID_Lookup( const IID * pIID, int * pIndex )
  4348. {
  4349.     
  4350.     if(!_ADOSamp_CHECK_IID(0))
  4351.         {
  4352.         *pIndex = 0;
  4353.         return 1;
  4354.         }
  4355.  
  4356.     return 0;
  4357. }
  4358.  
  4359. const ExtendedProxyFileInfo ADOSamp_ProxyFileInfo = 
  4360. {
  4361.     (PCInterfaceProxyVtblList *) & _ADOSamp_ProxyVtblList,
  4362.     (PCInterfaceStubVtblList *) & _ADOSamp_StubVtblList,
  4363.     (const PCInterfaceName * ) & _ADOSamp_InterfaceNamesList,
  4364.     (const IID ** ) & _ADOSamp_BaseIIDList,
  4365.     & _ADOSamp_IID_Lookup, 
  4366.     1,
  4367.     1
  4368. };
  4369.