1 /* oleaut_p.c edited by Kevin Kofler to build with MinGW
2 *
3 * OLE Automation interface for TiEmu
4 *
5 * Copyright (c) 2006 Kevin Kofler
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
20 */
21
22
23 /* File created by MIDL compiler version 5.01.0164 */
24 /* at Fri Feb 03 11:12:41 2006
25 */
26 /* Compiler settings for oleaut.idl:
27 Os (OptLev=s), W1, Zp8, env=Win32, ms_ext, c_ext
28 error checks: allocation ref bounds_check enum stub_data
29 */
30 //@@MIDL_FILE_HEADING( )
31
32 #include "rpcproxy.h"
33
34 #include "oleaut.h"
35
36 #ifdef __MINGW32__
37 #include <excpt.h>
38 /* CAUTION: Ugly SEH hacks (technically invalid inline ASM) below!
39 Use -O0 -fno-omit-frame-pointer to minimize breakage! */
40 #define RpcTryExcept \
41 { \
42 asm volatile ("pushl %esp; pushl %ebp; pushl $100f\n" \
43 "pushl %fs:0; movl %esp,%fs:0; subl $32,%esp");
44 #define RpcExcept(guard) \
45 asm volatile ("movl %fs:0,%esp; popl %fs:0; addl $12,%esp"); \
46 } \
47 asm volatile ("jmp 101f\n" \
48 "100: pushl %ebp; movl %fs:0,%eax; movl 8(%eax),%ebp; movl %esp,8(%eax)"); \
49 if ((guard)) { \
50 volatile int _exception_code; \
51 asm volatile ("movl 8(%%esp),%%eax; movl %%fs:0,%%esp; popl %%fs:0; addl $8,%%esp; popl %%esp; movl (%%eax),%%eax; movl %%eax,%0; subl $32,%%esp":"=m"(_exception_code)::"eax");
52 #define RpcEndExcept \
53 } else { \
54 asm volatile ("movl %fs:0,%eax; movl 8(%eax),%esp; movl %ebp,8(%eax); popl %ebp; movl $1,%eax; ret");\
55 } \
56 asm volatile ("101:");
57 #define RpcTryFinally \
58 { \
59 asm volatile ("pushl $0; pushl %esp; pushl %ebp; pushl $200f\n" \
60 "pushl %fs:0; movl %esp,%fs:0; subl $32,%esp");
61 #define RpcFinally \
62 } \
63 asm volatile ("movl %fs:0,%eax; jmp 201f\n" \
64 "200: movl %fs:0,%eax; movl $1,16(%eax)\n" \
65 "201: pushl %ebp; movl 8(%eax),%ebp; movl %esp,8(%eax); subl $32,%esp");
66 #define RpcEndFinally \
67 asm volatile ("movl %%fs:0,%%eax; movl 8(%%eax),%%esp; movl %%ebp,8(%%eax); popl %%ebp; movl 16(%%eax),%%eax; testl %%eax,%%eax; je 202f; ret\n" \
68 "202: movl %%fs:0,%%esp; popl %%fs:0; addl $16,%%esp":::"eax");
69 #define RpcExceptionCode() (_exception_code)
70 #ifndef CINTERFACE_PROXY_VTABLE
71 #define CINTERFACE_PROXY_VTABLE(n) \
72 struct \
73 { \
74 CInterfaceProxyHeader header; \
75 void *Vtbl[n]; \
76 }
77 #endif
78 #define SECTION_ORPC __attribute__((section(".orpc")))
79 #define SECTION_RDATA __attribute__((section(".rdata")))
80 #else
81 #define SECTION_ORPC /**/
82 #define SECTION_RDATA /**/
83 #endif
84
85 #define TYPE_FORMAT_STRING_SIZE 63
86 #define PROC_FORMAT_STRING_SIZE 37
87
88 typedef struct _MIDL_TYPE_FORMAT_STRING
89 {
90 short Pad;
91 unsigned char Format[ TYPE_FORMAT_STRING_SIZE ];
92 } MIDL_TYPE_FORMAT_STRING;
93
94 typedef struct _MIDL_PROC_FORMAT_STRING
95 {
96 short Pad;
97 unsigned char Format[ PROC_FORMAT_STRING_SIZE ];
98 } MIDL_PROC_FORMAT_STRING;
99
100
101 extern const MIDL_TYPE_FORMAT_STRING __MIDL_TypeFormatString;
102 extern const MIDL_PROC_FORMAT_STRING __MIDL_ProcFormatString;
103
104
105 /* Standard interface: __MIDL_itf_oleaut_0000, ver. 0.0,
106 GUID={0x00000000,0x0000,0x0000,{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}} */
107
108
109 /* Object interface: IUnknown, ver. 0.0,
110 GUID={0x00000000,0x0000,0x0000,{0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}} */
111
112
113 /* Object interface: IDispatch, ver. 0.0,
114 GUID={0x00020400,0x0000,0x0000,{0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}} */
115
116
117 /* Object interface: ITiEmuOLE, ver. 0.0,
118 GUID={0xe9373bd9,0x7363,0x427f,{0xa2,0xa6,0x1e,0x8b,0xa9,0x1f,0xfb,0x3e}} */
119
120
121 extern const MIDL_STUB_DESC Object_StubDesc;
122
123
124 #ifndef __MINGW32__
125 #pragma code_seg(".orpc")
126 #endif
127
ITiEmuOLE_image_loaded_Proxy(ITiEmuOLE __RPC_FAR * This,VARIANT_BOOL __RPC_FAR * ret)128 SECTION_ORPC HRESULT STDMETHODCALLTYPE ITiEmuOLE_image_loaded_Proxy(
129 ITiEmuOLE __RPC_FAR * This,
130 /* [retval][out] */ VARIANT_BOOL __RPC_FAR *ret)
131 {
132
133 HRESULT _RetVal;
134
135 RPC_MESSAGE _RpcMessage;
136
137 MIDL_STUB_MESSAGE _StubMsg;
138
139 RpcTryExcept
140 {
141 NdrProxyInitialize(
142 ( void __RPC_FAR * )This,
143 ( PRPC_MESSAGE )&_RpcMessage,
144 ( PMIDL_STUB_MESSAGE )&_StubMsg,
145 ( PMIDL_STUB_DESC )&Object_StubDesc,
146 7);
147
148
149
150 if(!ret)
151 {
152 RpcRaiseException(RPC_X_NULL_REF_POINTER);
153 }
154 RpcTryFinally
155 {
156
157 _StubMsg.BufferLength = 0U;
158 NdrProxyGetBuffer(This, &_StubMsg);
159 NdrProxySendReceive(This, &_StubMsg);
160
161 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
162 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[0] );
163
164 *ret = *(( VARIANT_BOOL __RPC_FAR * )_StubMsg.Buffer);
165 _StubMsg.Buffer += sizeof( VARIANT_BOOL __RPC_FAR * );
166
167 _StubMsg.Buffer += 2;
168 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer);
169 _StubMsg.Buffer += sizeof( HRESULT __RPC_FAR * );
170
171 }
172 RpcFinally
173 {
174 NdrProxyFreeBuffer(This, &_StubMsg);
175
176 }
177 RpcEndFinally
178
179 }
180 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
181 {
182 NdrClearOutParameters(
183 ( PMIDL_STUB_MESSAGE )&_StubMsg,
184 ( PFORMAT_STRING )&__MIDL_TypeFormatString.Format[2],
185 ( void __RPC_FAR * )ret);
186 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
187 }
188 RpcEndExcept
189 return _RetVal;
190 }
191
ITiEmuOLE_image_loaded_Stub(IRpcStubBuffer * This,IRpcChannelBuffer * _pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD * _pdwStubPhase)192 SECTION_ORPC void __RPC_STUB ITiEmuOLE_image_loaded_Stub(
193 IRpcStubBuffer *This,
194 IRpcChannelBuffer *_pRpcChannelBuffer,
195 PRPC_MESSAGE _pRpcMessage,
196 DWORD *_pdwStubPhase)
197 {
198 VARIANT_BOOL _M0;
199 HRESULT _RetVal;
200 MIDL_STUB_MESSAGE _StubMsg;
201 VARIANT_BOOL __RPC_FAR *ret;
202
203 NdrStubInitialize(
204 _pRpcMessage,
205 &_StubMsg,
206 &Object_StubDesc,
207 _pRpcChannelBuffer);
208 ( VARIANT_BOOL __RPC_FAR * )ret = 0;
209 RpcTryFinally
210 {
211 ret = &_M0;
212
213 *_pdwStubPhase = STUB_CALL_SERVER;
214 _RetVal = (((ITiEmuOLE*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> image_loaded((ITiEmuOLE *) ((CStdStubBuffer *)This)->pvServerObject,ret);
215
216 *_pdwStubPhase = STUB_MARSHAL;
217
218 _StubMsg.BufferLength = 2U + 6U;
219 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
220 *(( VARIANT_BOOL __RPC_FAR * )_StubMsg.Buffer) = *ret;
221 _StubMsg.Buffer += sizeof( VARIANT_BOOL __RPC_FAR * );
222
223 _StubMsg.Buffer += 2;
224 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer) = _RetVal;
225 _StubMsg.Buffer += sizeof( HRESULT __RPC_FAR * );
226
227 }
228 RpcFinally
229 {
230 }
231 RpcEndFinally
232 _pRpcMessage->BufferLength =
233 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
234
235 }
236
237
ITiEmuOLE_emulated_calc_type_Proxy(ITiEmuOLE __RPC_FAR * This,int __RPC_FAR * ret)238 SECTION_ORPC HRESULT STDMETHODCALLTYPE ITiEmuOLE_emulated_calc_type_Proxy(
239 ITiEmuOLE __RPC_FAR * This,
240 /* [retval][out] */ int __RPC_FAR *ret)
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 if(!ret)
261 {
262 RpcRaiseException(RPC_X_NULL_REF_POINTER);
263 }
264 RpcTryFinally
265 {
266
267 _StubMsg.BufferLength = 0U;
268 NdrProxyGetBuffer(This, &_StubMsg);
269 NdrProxySendReceive(This, &_StubMsg);
270
271 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
272 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[6] );
273
274 *ret = *(( int __RPC_FAR * )_StubMsg.Buffer);
275 _StubMsg.Buffer += sizeof( int __RPC_FAR * );
276
277 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer);
278 _StubMsg.Buffer += sizeof( HRESULT __RPC_FAR * );
279
280 }
281 RpcFinally
282 {
283 NdrProxyFreeBuffer(This, &_StubMsg);
284
285 }
286 RpcEndFinally
287
288 }
289 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
290 {
291 NdrClearOutParameters(
292 ( PMIDL_STUB_MESSAGE )&_StubMsg,
293 ( PFORMAT_STRING )&__MIDL_TypeFormatString.Format[6],
294 ( void __RPC_FAR * )ret);
295 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
296 }
297 RpcEndExcept
298 return _RetVal;
299 }
300
ITiEmuOLE_emulated_calc_type_Stub(IRpcStubBuffer * This,IRpcChannelBuffer * _pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD * _pdwStubPhase)301 SECTION_ORPC void __RPC_STUB ITiEmuOLE_emulated_calc_type_Stub(
302 IRpcStubBuffer *This,
303 IRpcChannelBuffer *_pRpcChannelBuffer,
304 PRPC_MESSAGE _pRpcMessage,
305 DWORD *_pdwStubPhase)
306 {
307 int _M1;
308 HRESULT _RetVal;
309 MIDL_STUB_MESSAGE _StubMsg;
310 int __RPC_FAR *ret;
311
312 NdrStubInitialize(
313 _pRpcMessage,
314 &_StubMsg,
315 &Object_StubDesc,
316 _pRpcChannelBuffer);
317 ( int __RPC_FAR * )ret = 0;
318 RpcTryFinally
319 {
320 ret = &_M1;
321
322 *_pdwStubPhase = STUB_CALL_SERVER;
323 _RetVal = (((ITiEmuOLE*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> emulated_calc_type((ITiEmuOLE *) ((CStdStubBuffer *)This)->pvServerObject,ret);
324
325 *_pdwStubPhase = STUB_MARSHAL;
326
327 _StubMsg.BufferLength = 4U + 4U;
328 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
329 *(( int __RPC_FAR * )_StubMsg.Buffer) = *ret;
330 _StubMsg.Buffer += sizeof( int __RPC_FAR * );
331
332 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer) = _RetVal;
333 _StubMsg.Buffer += sizeof( HRESULT __RPC_FAR * );
334
335 }
336 RpcFinally
337 {
338 }
339 RpcEndFinally
340 _pRpcMessage->BufferLength =
341 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
342
343 }
344
345
ITiEmuOLE_emulated_hw_version_Proxy(ITiEmuOLE __RPC_FAR * This,int __RPC_FAR * ret)346 SECTION_ORPC HRESULT STDMETHODCALLTYPE ITiEmuOLE_emulated_hw_version_Proxy(
347 ITiEmuOLE __RPC_FAR * This,
348 /* [retval][out] */ int __RPC_FAR *ret)
349 {
350
351 HRESULT _RetVal;
352
353 RPC_MESSAGE _RpcMessage;
354
355 MIDL_STUB_MESSAGE _StubMsg;
356
357 RpcTryExcept
358 {
359 NdrProxyInitialize(
360 ( void __RPC_FAR * )This,
361 ( PRPC_MESSAGE )&_RpcMessage,
362 ( PMIDL_STUB_MESSAGE )&_StubMsg,
363 ( PMIDL_STUB_DESC )&Object_StubDesc,
364 9);
365
366
367
368 if(!ret)
369 {
370 RpcRaiseException(RPC_X_NULL_REF_POINTER);
371 }
372 RpcTryFinally
373 {
374
375 _StubMsg.BufferLength = 0U;
376 NdrProxyGetBuffer(This, &_StubMsg);
377 NdrProxySendReceive(This, &_StubMsg);
378
379 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
380 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[6] );
381
382 *ret = *(( int __RPC_FAR * )_StubMsg.Buffer);
383 _StubMsg.Buffer += sizeof( int __RPC_FAR * );
384
385 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer);
386 _StubMsg.Buffer += sizeof( HRESULT __RPC_FAR * );
387
388 }
389 RpcFinally
390 {
391 NdrProxyFreeBuffer(This, &_StubMsg);
392
393 }
394 RpcEndFinally
395
396 }
397 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
398 {
399 NdrClearOutParameters(
400 ( PMIDL_STUB_MESSAGE )&_StubMsg,
401 ( PFORMAT_STRING )&__MIDL_TypeFormatString.Format[6],
402 ( void __RPC_FAR * )ret);
403 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
404 }
405 RpcEndExcept
406 return _RetVal;
407 }
408
ITiEmuOLE_emulated_hw_version_Stub(IRpcStubBuffer * This,IRpcChannelBuffer * _pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD * _pdwStubPhase)409 SECTION_ORPC void __RPC_STUB ITiEmuOLE_emulated_hw_version_Stub(
410 IRpcStubBuffer *This,
411 IRpcChannelBuffer *_pRpcChannelBuffer,
412 PRPC_MESSAGE _pRpcMessage,
413 DWORD *_pdwStubPhase)
414 {
415 int _M2;
416 HRESULT _RetVal;
417 MIDL_STUB_MESSAGE _StubMsg;
418 int __RPC_FAR *ret;
419
420 NdrStubInitialize(
421 _pRpcMessage,
422 &_StubMsg,
423 &Object_StubDesc,
424 _pRpcChannelBuffer);
425 ( int __RPC_FAR * )ret = 0;
426 RpcTryFinally
427 {
428 ret = &_M2;
429
430 *_pdwStubPhase = STUB_CALL_SERVER;
431 _RetVal = (((ITiEmuOLE*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> emulated_hw_version((ITiEmuOLE *) ((CStdStubBuffer *)This)->pvServerObject,ret);
432
433 *_pdwStubPhase = STUB_MARSHAL;
434
435 _StubMsg.BufferLength = 4U + 4U;
436 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
437 *(( int __RPC_FAR * )_StubMsg.Buffer) = *ret;
438 _StubMsg.Buffer += sizeof( int __RPC_FAR * );
439
440 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer) = _RetVal;
441 _StubMsg.Buffer += sizeof( HRESULT __RPC_FAR * );
442
443 }
444 RpcFinally
445 {
446 }
447 RpcEndFinally
448 _pRpcMessage->BufferLength =
449 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
450
451 }
452
453
ITiEmuOLE_emulated_os_version_Proxy(ITiEmuOLE __RPC_FAR * This,BSTR __RPC_FAR * ret)454 SECTION_ORPC HRESULT STDMETHODCALLTYPE ITiEmuOLE_emulated_os_version_Proxy(
455 ITiEmuOLE __RPC_FAR * This,
456 /* [retval][out] */ BSTR __RPC_FAR *ret)
457 {
458
459 HRESULT _RetVal;
460
461 RPC_MESSAGE _RpcMessage;
462
463 MIDL_STUB_MESSAGE _StubMsg;
464
465 if(ret)
466 {
467 MIDL_memset(
468 ret,
469 0,
470 sizeof( BSTR ));
471 }
472 RpcTryExcept
473 {
474 NdrProxyInitialize(
475 ( void __RPC_FAR * )This,
476 ( PRPC_MESSAGE )&_RpcMessage,
477 ( PMIDL_STUB_MESSAGE )&_StubMsg,
478 ( PMIDL_STUB_DESC )&Object_StubDesc,
479 10);
480
481
482
483 if(!ret)
484 {
485 RpcRaiseException(RPC_X_NULL_REF_POINTER);
486 }
487 RpcTryFinally
488 {
489
490 _StubMsg.BufferLength = 0U;
491 NdrProxyGetBuffer(This, &_StubMsg);
492 NdrProxySendReceive(This, &_StubMsg);
493
494 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
495 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[12] );
496
497 NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
498 (unsigned char __RPC_FAR * __RPC_FAR *)&ret,
499 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[38],
500 (unsigned char)0 );
501
502 _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
503 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer);
504 _StubMsg.Buffer += sizeof( HRESULT __RPC_FAR * );
505
506 }
507 RpcFinally
508 {
509 NdrProxyFreeBuffer(This, &_StubMsg);
510
511 }
512 RpcEndFinally
513
514 }
515 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
516 {
517 NdrClearOutParameters(
518 ( PMIDL_STUB_MESSAGE )&_StubMsg,
519 ( PFORMAT_STRING )&__MIDL_TypeFormatString.Format[10],
520 ( void __RPC_FAR * )ret);
521 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
522 }
523 RpcEndExcept
524 return _RetVal;
525 }
526
ITiEmuOLE_emulated_os_version_Stub(IRpcStubBuffer * This,IRpcChannelBuffer * _pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD * _pdwStubPhase)527 SECTION_ORPC void __RPC_STUB ITiEmuOLE_emulated_os_version_Stub(
528 IRpcStubBuffer *This,
529 IRpcChannelBuffer *_pRpcChannelBuffer,
530 PRPC_MESSAGE _pRpcMessage,
531 DWORD *_pdwStubPhase)
532 {
533 BSTR _M3;
534 HRESULT _RetVal;
535 MIDL_STUB_MESSAGE _StubMsg;
536 BSTR __RPC_FAR *ret;
537
538 NdrStubInitialize(
539 _pRpcMessage,
540 &_StubMsg,
541 &Object_StubDesc,
542 _pRpcChannelBuffer);
543 ( BSTR __RPC_FAR * )ret = 0;
544 RpcTryFinally
545 {
546 ret = &_M3;
547 MIDL_memset(
548 ret,
549 0,
550 sizeof( BSTR ));
551
552 *_pdwStubPhase = STUB_CALL_SERVER;
553 _RetVal = (((ITiEmuOLE*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> emulated_os_version((ITiEmuOLE *) ((CStdStubBuffer *)This)->pvServerObject,ret);
554
555 *_pdwStubPhase = STUB_MARSHAL;
556
557 _StubMsg.BufferLength = 8U + 11U;
558 NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
559 (unsigned char __RPC_FAR *)ret,
560 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[38] );
561
562 _StubMsg.BufferLength += 16;
563
564 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
565 NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
566 (unsigned char __RPC_FAR *)ret,
567 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[38] );
568
569 _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
570 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer) = _RetVal;
571 _StubMsg.Buffer += sizeof( HRESULT __RPC_FAR * );
572
573 }
574 RpcFinally
575 {
576 NdrPointerFree( &_StubMsg,
577 (unsigned char __RPC_FAR *)ret,
578 &__MIDL_TypeFormatString.Format[10] );
579
580 }
581 RpcEndFinally
582 _pRpcMessage->BufferLength =
583 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
584
585 }
586
587
ITiEmuOLE_ready_for_transfers_Proxy(ITiEmuOLE __RPC_FAR * This,VARIANT_BOOL __RPC_FAR * ret)588 SECTION_ORPC HRESULT STDMETHODCALLTYPE ITiEmuOLE_ready_for_transfers_Proxy(
589 ITiEmuOLE __RPC_FAR * This,
590 /* [retval][out] */ VARIANT_BOOL __RPC_FAR *ret)
591 {
592
593 HRESULT _RetVal;
594
595 RPC_MESSAGE _RpcMessage;
596
597 MIDL_STUB_MESSAGE _StubMsg;
598
599 RpcTryExcept
600 {
601 NdrProxyInitialize(
602 ( void __RPC_FAR * )This,
603 ( PRPC_MESSAGE )&_RpcMessage,
604 ( PMIDL_STUB_MESSAGE )&_StubMsg,
605 ( PMIDL_STUB_DESC )&Object_StubDesc,
606 11);
607
608
609
610 if(!ret)
611 {
612 RpcRaiseException(RPC_X_NULL_REF_POINTER);
613 }
614 RpcTryFinally
615 {
616
617 _StubMsg.BufferLength = 0U;
618 NdrProxyGetBuffer(This, &_StubMsg);
619 NdrProxySendReceive(This, &_StubMsg);
620
621 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
622 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[0] );
623
624 *ret = *(( VARIANT_BOOL __RPC_FAR * )_StubMsg.Buffer);
625 _StubMsg.Buffer += sizeof( VARIANT_BOOL __RPC_FAR * );
626
627 _StubMsg.Buffer += 2;
628 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer);
629 _StubMsg.Buffer += sizeof( HRESULT __RPC_FAR * );
630
631 }
632 RpcFinally
633 {
634 NdrProxyFreeBuffer(This, &_StubMsg);
635
636 }
637 RpcEndFinally
638
639 }
640 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
641 {
642 NdrClearOutParameters(
643 ( PMIDL_STUB_MESSAGE )&_StubMsg,
644 ( PFORMAT_STRING )&__MIDL_TypeFormatString.Format[2],
645 ( void __RPC_FAR * )ret);
646 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
647 }
648 RpcEndExcept
649 return _RetVal;
650 }
651
ITiEmuOLE_ready_for_transfers_Stub(IRpcStubBuffer * This,IRpcChannelBuffer * _pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD * _pdwStubPhase)652 SECTION_ORPC void __RPC_STUB ITiEmuOLE_ready_for_transfers_Stub(
653 IRpcStubBuffer *This,
654 IRpcChannelBuffer *_pRpcChannelBuffer,
655 PRPC_MESSAGE _pRpcMessage,
656 DWORD *_pdwStubPhase)
657 {
658 VARIANT_BOOL _M4;
659 HRESULT _RetVal;
660 MIDL_STUB_MESSAGE _StubMsg;
661 VARIANT_BOOL __RPC_FAR *ret;
662
663 NdrStubInitialize(
664 _pRpcMessage,
665 &_StubMsg,
666 &Object_StubDesc,
667 _pRpcChannelBuffer);
668 ( VARIANT_BOOL __RPC_FAR * )ret = 0;
669 RpcTryFinally
670 {
671 ret = &_M4;
672
673 *_pdwStubPhase = STUB_CALL_SERVER;
674 _RetVal = (((ITiEmuOLE*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> ready_for_transfers((ITiEmuOLE *) ((CStdStubBuffer *)This)->pvServerObject,ret);
675
676 *_pdwStubPhase = STUB_MARSHAL;
677
678 _StubMsg.BufferLength = 2U + 6U;
679 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
680 *(( VARIANT_BOOL __RPC_FAR * )_StubMsg.Buffer) = *ret;
681 _StubMsg.Buffer += sizeof( VARIANT_BOOL __RPC_FAR * );
682
683 _StubMsg.Buffer += 2;
684 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer) = _RetVal;
685 _StubMsg.Buffer += sizeof( HRESULT __RPC_FAR * );
686
687 }
688 RpcFinally
689 {
690 }
691 RpcEndFinally
692 _pRpcMessage->BufferLength =
693 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
694
695 }
696
697
ITiEmuOLE_send_file_Proxy(ITiEmuOLE __RPC_FAR * This,BSTR filename,VARIANT_BOOL __RPC_FAR * ret)698 SECTION_ORPC HRESULT STDMETHODCALLTYPE ITiEmuOLE_send_file_Proxy(
699 ITiEmuOLE __RPC_FAR * This,
700 /* [in] */ BSTR filename,
701 /* [retval][out] */ VARIANT_BOOL __RPC_FAR *ret)
702 {
703
704 HRESULT _RetVal;
705
706 RPC_MESSAGE _RpcMessage;
707
708 MIDL_STUB_MESSAGE _StubMsg;
709
710 RpcTryExcept
711 {
712 NdrProxyInitialize(
713 ( void __RPC_FAR * )This,
714 ( PRPC_MESSAGE )&_RpcMessage,
715 ( PMIDL_STUB_MESSAGE )&_StubMsg,
716 ( PMIDL_STUB_DESC )&Object_StubDesc,
717 12);
718
719
720
721 if(!ret)
722 {
723 RpcRaiseException(RPC_X_NULL_REF_POINTER);
724 }
725 RpcTryFinally
726 {
727
728 _StubMsg.BufferLength = 8U;
729 NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
730 (unsigned char __RPC_FAR *)&filename,
731 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[52] );
732
733 NdrProxyGetBuffer(This, &_StubMsg);
734 NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
735 (unsigned char __RPC_FAR *)&filename,
736 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[52] );
737
738 NdrProxySendReceive(This, &_StubMsg);
739
740 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
741 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[18] );
742
743 *ret = *(( VARIANT_BOOL __RPC_FAR * )_StubMsg.Buffer);
744 _StubMsg.Buffer += sizeof( VARIANT_BOOL __RPC_FAR * );
745
746 _StubMsg.Buffer += 2;
747 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer);
748 _StubMsg.Buffer += sizeof( HRESULT __RPC_FAR * );
749
750 }
751 RpcFinally
752 {
753 NdrProxyFreeBuffer(This, &_StubMsg);
754
755 }
756 RpcEndFinally
757
758 }
759 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
760 {
761 NdrClearOutParameters(
762 ( PMIDL_STUB_MESSAGE )&_StubMsg,
763 ( PFORMAT_STRING )&__MIDL_TypeFormatString.Format[2],
764 ( void __RPC_FAR * )ret);
765 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
766 }
767 RpcEndExcept
768 return _RetVal;
769 }
770
ITiEmuOLE_send_file_Stub(IRpcStubBuffer * This,IRpcChannelBuffer * _pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD * _pdwStubPhase)771 SECTION_ORPC void __RPC_STUB ITiEmuOLE_send_file_Stub(
772 IRpcStubBuffer *This,
773 IRpcChannelBuffer *_pRpcChannelBuffer,
774 PRPC_MESSAGE _pRpcMessage,
775 DWORD *_pdwStubPhase)
776 {
777 VARIANT_BOOL _M5;
778 HRESULT _RetVal;
779 MIDL_STUB_MESSAGE _StubMsg;
780 void __RPC_FAR *_p_filename;
781 BSTR filename;
782 VARIANT_BOOL __RPC_FAR *ret;
783
784 NdrStubInitialize(
785 _pRpcMessage,
786 &_StubMsg,
787 &Object_StubDesc,
788 _pRpcChannelBuffer);
789 _p_filename = &filename;
790 MIDL_memset(
791 _p_filename,
792 0,
793 sizeof( BSTR ));
794 ( VARIANT_BOOL __RPC_FAR * )ret = 0;
795 RpcTryFinally
796 {
797 if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
798 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[18] );
799
800 NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
801 (unsigned char __RPC_FAR * __RPC_FAR *)&_p_filename,
802 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[52],
803 (unsigned char)0 );
804
805 ret = &_M5;
806
807 *_pdwStubPhase = STUB_CALL_SERVER;
808 _RetVal = (((ITiEmuOLE*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> send_file(
809 (ITiEmuOLE *) ((CStdStubBuffer *)This)->pvServerObject,
810 filename,
811 ret);
812
813 *_pdwStubPhase = STUB_MARSHAL;
814
815 _StubMsg.BufferLength = 2U + 6U;
816 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
817 *(( VARIANT_BOOL __RPC_FAR * )_StubMsg.Buffer) = *ret;
818 _StubMsg.Buffer += sizeof( VARIANT_BOOL __RPC_FAR * );
819
820 _StubMsg.Buffer += 2;
821 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer) = _RetVal;
822 _StubMsg.Buffer += sizeof( HRESULT __RPC_FAR * );
823
824 }
825 RpcFinally
826 {
827 NdrUserMarshalFree( &_StubMsg,
828 (unsigned char __RPC_FAR *)&filename,
829 &__MIDL_TypeFormatString.Format[52] );
830
831 }
832 RpcEndFinally
833 _pRpcMessage->BufferLength =
834 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
835
836 }
837
838
ITiEmuOLE_debug_file_Proxy(ITiEmuOLE __RPC_FAR * This,BSTR filename,VARIANT_BOOL __RPC_FAR * ret)839 SECTION_ORPC HRESULT STDMETHODCALLTYPE ITiEmuOLE_debug_file_Proxy(
840 ITiEmuOLE __RPC_FAR * This,
841 /* [in] */ BSTR filename,
842 /* [retval][out] */ VARIANT_BOOL __RPC_FAR *ret)
843 {
844
845 HRESULT _RetVal;
846
847 RPC_MESSAGE _RpcMessage;
848
849 MIDL_STUB_MESSAGE _StubMsg;
850
851 RpcTryExcept
852 {
853 NdrProxyInitialize(
854 ( void __RPC_FAR * )This,
855 ( PRPC_MESSAGE )&_RpcMessage,
856 ( PMIDL_STUB_MESSAGE )&_StubMsg,
857 ( PMIDL_STUB_DESC )&Object_StubDesc,
858 13);
859
860
861
862 if(!ret)
863 {
864 RpcRaiseException(RPC_X_NULL_REF_POINTER);
865 }
866 RpcTryFinally
867 {
868
869 _StubMsg.BufferLength = 8U;
870 NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
871 (unsigned char __RPC_FAR *)&filename,
872 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[52] );
873
874 NdrProxyGetBuffer(This, &_StubMsg);
875 NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
876 (unsigned char __RPC_FAR *)&filename,
877 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[52] );
878
879 NdrProxySendReceive(This, &_StubMsg);
880
881 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
882 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[18] );
883
884 *ret = *(( VARIANT_BOOL __RPC_FAR * )_StubMsg.Buffer);
885 _StubMsg.Buffer += sizeof( VARIANT_BOOL __RPC_FAR * );
886
887 _StubMsg.Buffer += 2;
888 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer);
889 _StubMsg.Buffer += sizeof( HRESULT __RPC_FAR * );
890
891 }
892 RpcFinally
893 {
894 NdrProxyFreeBuffer(This, &_StubMsg);
895
896 }
897 RpcEndFinally
898
899 }
900 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
901 {
902 NdrClearOutParameters(
903 ( PMIDL_STUB_MESSAGE )&_StubMsg,
904 ( PFORMAT_STRING )&__MIDL_TypeFormatString.Format[2],
905 ( void __RPC_FAR * )ret);
906 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
907 }
908 RpcEndExcept
909 return _RetVal;
910 }
911
ITiEmuOLE_debug_file_Stub(IRpcStubBuffer * This,IRpcChannelBuffer * _pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD * _pdwStubPhase)912 SECTION_ORPC void __RPC_STUB ITiEmuOLE_debug_file_Stub(
913 IRpcStubBuffer *This,
914 IRpcChannelBuffer *_pRpcChannelBuffer,
915 PRPC_MESSAGE _pRpcMessage,
916 DWORD *_pdwStubPhase)
917 {
918 VARIANT_BOOL _M6;
919 HRESULT _RetVal;
920 MIDL_STUB_MESSAGE _StubMsg;
921 void __RPC_FAR *_p_filename;
922 BSTR filename;
923 VARIANT_BOOL __RPC_FAR *ret;
924
925 NdrStubInitialize(
926 _pRpcMessage,
927 &_StubMsg,
928 &Object_StubDesc,
929 _pRpcChannelBuffer);
930 _p_filename = &filename;
931 MIDL_memset(
932 _p_filename,
933 0,
934 sizeof( BSTR ));
935 ( VARIANT_BOOL __RPC_FAR * )ret = 0;
936 RpcTryFinally
937 {
938 if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
939 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[18] );
940
941 NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
942 (unsigned char __RPC_FAR * __RPC_FAR *)&_p_filename,
943 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[52],
944 (unsigned char)0 );
945
946 ret = &_M6;
947
948 *_pdwStubPhase = STUB_CALL_SERVER;
949 _RetVal = (((ITiEmuOLE*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> debug_file(
950 (ITiEmuOLE *) ((CStdStubBuffer *)This)->pvServerObject,
951 filename,
952 ret);
953
954 *_pdwStubPhase = STUB_MARSHAL;
955
956 _StubMsg.BufferLength = 2U + 6U;
957 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
958 *(( VARIANT_BOOL __RPC_FAR * )_StubMsg.Buffer) = *ret;
959 _StubMsg.Buffer += sizeof( VARIANT_BOOL __RPC_FAR * );
960
961 _StubMsg.Buffer += 2;
962 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer) = _RetVal;
963 _StubMsg.Buffer += sizeof( HRESULT __RPC_FAR * );
964
965 }
966 RpcFinally
967 {
968 NdrUserMarshalFree( &_StubMsg,
969 (unsigned char __RPC_FAR *)&filename,
970 &__MIDL_TypeFormatString.Format[52] );
971
972 }
973 RpcEndFinally
974 _pRpcMessage->BufferLength =
975 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
976
977 }
978
979
ITiEmuOLE_reset_calc_Proxy(ITiEmuOLE __RPC_FAR * This,VARIANT_BOOL clearmem,VARIANT_BOOL __RPC_FAR * ret)980 SECTION_ORPC HRESULT STDMETHODCALLTYPE ITiEmuOLE_reset_calc_Proxy(
981 ITiEmuOLE __RPC_FAR * This,
982 /* [in] */ VARIANT_BOOL clearmem,
983 /* [retval][out] */ VARIANT_BOOL __RPC_FAR *ret)
984 {
985
986 HRESULT _RetVal;
987
988 RPC_MESSAGE _RpcMessage;
989
990 MIDL_STUB_MESSAGE _StubMsg;
991
992 RpcTryExcept
993 {
994 NdrProxyInitialize(
995 ( void __RPC_FAR * )This,
996 ( PRPC_MESSAGE )&_RpcMessage,
997 ( PMIDL_STUB_MESSAGE )&_StubMsg,
998 ( PMIDL_STUB_DESC )&Object_StubDesc,
999 14);
1000
1001
1002
1003 if(!ret)
1004 {
1005 RpcRaiseException(RPC_X_NULL_REF_POINTER);
1006 }
1007 RpcTryFinally
1008 {
1009
1010 _StubMsg.BufferLength = 2U;
1011 NdrProxyGetBuffer(This, &_StubMsg);
1012 *(( VARIANT_BOOL __RPC_FAR * )_StubMsg.Buffer) = clearmem;
1013 _StubMsg.Buffer += sizeof( VARIANT_BOOL __RPC_FAR * );
1014
1015 NdrProxySendReceive(This, &_StubMsg);
1016
1017 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
1018 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[28] );
1019
1020 *ret = *(( VARIANT_BOOL __RPC_FAR * )_StubMsg.Buffer);
1021 _StubMsg.Buffer += sizeof( VARIANT_BOOL __RPC_FAR * );
1022
1023 _StubMsg.Buffer += 2;
1024 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer);
1025 _StubMsg.Buffer += sizeof( HRESULT __RPC_FAR * );
1026
1027 }
1028 RpcFinally
1029 {
1030 NdrProxyFreeBuffer(This, &_StubMsg);
1031
1032 }
1033 RpcEndFinally
1034
1035 }
1036 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
1037 {
1038 NdrClearOutParameters(
1039 ( PMIDL_STUB_MESSAGE )&_StubMsg,
1040 ( PFORMAT_STRING )&__MIDL_TypeFormatString.Format[2],
1041 ( void __RPC_FAR * )ret);
1042 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
1043 }
1044 RpcEndExcept
1045 return _RetVal;
1046 }
1047
ITiEmuOLE_reset_calc_Stub(IRpcStubBuffer * This,IRpcChannelBuffer * _pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD * _pdwStubPhase)1048 SECTION_ORPC void __RPC_STUB ITiEmuOLE_reset_calc_Stub(
1049 IRpcStubBuffer *This,
1050 IRpcChannelBuffer *_pRpcChannelBuffer,
1051 PRPC_MESSAGE _pRpcMessage,
1052 DWORD *_pdwStubPhase)
1053 {
1054 VARIANT_BOOL _M7;
1055 HRESULT _RetVal;
1056 MIDL_STUB_MESSAGE _StubMsg;
1057 VARIANT_BOOL clearmem;
1058 VARIANT_BOOL __RPC_FAR *ret;
1059
1060 NdrStubInitialize(
1061 _pRpcMessage,
1062 &_StubMsg,
1063 &Object_StubDesc,
1064 _pRpcChannelBuffer);
1065 ( VARIANT_BOOL __RPC_FAR * )ret = 0;
1066 RpcTryFinally
1067 {
1068 if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
1069 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[28] );
1070
1071 clearmem = *(( VARIANT_BOOL __RPC_FAR * )_StubMsg.Buffer);
1072 _StubMsg.Buffer += sizeof( VARIANT_BOOL __RPC_FAR * );
1073
1074 ret = &_M7;
1075
1076 *_pdwStubPhase = STUB_CALL_SERVER;
1077 _RetVal = (((ITiEmuOLE*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> reset_calc(
1078 (ITiEmuOLE *) ((CStdStubBuffer *)This)->pvServerObject,
1079 clearmem,
1080 ret);
1081
1082 *_pdwStubPhase = STUB_MARSHAL;
1083
1084 _StubMsg.BufferLength = 2U + 6U;
1085 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
1086 *(( VARIANT_BOOL __RPC_FAR * )_StubMsg.Buffer) = *ret;
1087 _StubMsg.Buffer += sizeof( VARIANT_BOOL __RPC_FAR * );
1088
1089 _StubMsg.Buffer += 2;
1090 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer) = _RetVal;
1091 _StubMsg.Buffer += sizeof( HRESULT __RPC_FAR * );
1092
1093 }
1094 RpcFinally
1095 {
1096 }
1097 RpcEndFinally
1098 _pRpcMessage->BufferLength =
1099 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
1100
1101 }
1102
1103
ITiEmuOLE_execute_command_Proxy(ITiEmuOLE __RPC_FAR * This,BSTR command,VARIANT_BOOL __RPC_FAR * ret)1104 SECTION_ORPC HRESULT STDMETHODCALLTYPE ITiEmuOLE_execute_command_Proxy(
1105 ITiEmuOLE __RPC_FAR * This,
1106 /* [in] */ BSTR command,
1107 /* [retval][out] */ VARIANT_BOOL __RPC_FAR *ret)
1108 {
1109
1110 HRESULT _RetVal;
1111
1112 RPC_MESSAGE _RpcMessage;
1113
1114 MIDL_STUB_MESSAGE _StubMsg;
1115
1116 RpcTryExcept
1117 {
1118 NdrProxyInitialize(
1119 ( void __RPC_FAR * )This,
1120 ( PRPC_MESSAGE )&_RpcMessage,
1121 ( PMIDL_STUB_MESSAGE )&_StubMsg,
1122 ( PMIDL_STUB_DESC )&Object_StubDesc,
1123 15);
1124
1125
1126
1127 if(!ret)
1128 {
1129 RpcRaiseException(RPC_X_NULL_REF_POINTER);
1130 }
1131 RpcTryFinally
1132 {
1133
1134 _StubMsg.BufferLength = 8U;
1135 NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
1136 (unsigned char __RPC_FAR *)&command,
1137 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[52] );
1138
1139 NdrProxyGetBuffer(This, &_StubMsg);
1140 NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
1141 (unsigned char __RPC_FAR *)&command,
1142 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[52] );
1143
1144 NdrProxySendReceive(This, &_StubMsg);
1145
1146 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
1147 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[18] );
1148
1149 *ret = *(( VARIANT_BOOL __RPC_FAR * )_StubMsg.Buffer);
1150 _StubMsg.Buffer += sizeof( VARIANT_BOOL __RPC_FAR * );
1151
1152 _StubMsg.Buffer += 2;
1153 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer);
1154 _StubMsg.Buffer += sizeof( HRESULT __RPC_FAR * );
1155
1156 }
1157 RpcFinally
1158 {
1159 NdrProxyFreeBuffer(This, &_StubMsg);
1160
1161 }
1162 RpcEndFinally
1163
1164 }
1165 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
1166 {
1167 NdrClearOutParameters(
1168 ( PMIDL_STUB_MESSAGE )&_StubMsg,
1169 ( PFORMAT_STRING )&__MIDL_TypeFormatString.Format[2],
1170 ( void __RPC_FAR * )ret);
1171 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
1172 }
1173 RpcEndExcept
1174 return _RetVal;
1175 }
1176
ITiEmuOLE_execute_command_Stub(IRpcStubBuffer * This,IRpcChannelBuffer * _pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD * _pdwStubPhase)1177 SECTION_ORPC void __RPC_STUB ITiEmuOLE_execute_command_Stub(
1178 IRpcStubBuffer *This,
1179 IRpcChannelBuffer *_pRpcChannelBuffer,
1180 PRPC_MESSAGE _pRpcMessage,
1181 DWORD *_pdwStubPhase)
1182 {
1183 VARIANT_BOOL _M8;
1184 HRESULT _RetVal;
1185 MIDL_STUB_MESSAGE _StubMsg;
1186 void __RPC_FAR *_p_command;
1187 BSTR command;
1188 VARIANT_BOOL __RPC_FAR *ret;
1189
1190 NdrStubInitialize(
1191 _pRpcMessage,
1192 &_StubMsg,
1193 &Object_StubDesc,
1194 _pRpcChannelBuffer);
1195 _p_command = &command;
1196 MIDL_memset(
1197 _p_command,
1198 0,
1199 sizeof( BSTR ));
1200 ( VARIANT_BOOL __RPC_FAR * )ret = 0;
1201 RpcTryFinally
1202 {
1203 if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
1204 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[18] );
1205
1206 NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
1207 (unsigned char __RPC_FAR * __RPC_FAR *)&_p_command,
1208 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[52],
1209 (unsigned char)0 );
1210
1211 ret = &_M8;
1212
1213 *_pdwStubPhase = STUB_CALL_SERVER;
1214 _RetVal = (((ITiEmuOLE*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> execute_command(
1215 (ITiEmuOLE *) ((CStdStubBuffer *)This)->pvServerObject,
1216 command,
1217 ret);
1218
1219 *_pdwStubPhase = STUB_MARSHAL;
1220
1221 _StubMsg.BufferLength = 2U + 6U;
1222 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
1223 *(( VARIANT_BOOL __RPC_FAR * )_StubMsg.Buffer) = *ret;
1224 _StubMsg.Buffer += sizeof( VARIANT_BOOL __RPC_FAR * );
1225
1226 _StubMsg.Buffer += 2;
1227 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer) = _RetVal;
1228 _StubMsg.Buffer += sizeof( HRESULT __RPC_FAR * );
1229
1230 }
1231 RpcFinally
1232 {
1233 NdrUserMarshalFree( &_StubMsg,
1234 (unsigned char __RPC_FAR *)&command,
1235 &__MIDL_TypeFormatString.Format[52] );
1236
1237 }
1238 RpcEndFinally
1239 _pRpcMessage->BufferLength =
1240 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
1241
1242 }
1243
1244
ITiEmuOLE_turn_calc_on_Proxy(ITiEmuOLE __RPC_FAR * This,VARIANT_BOOL __RPC_FAR * ret)1245 SECTION_ORPC HRESULT STDMETHODCALLTYPE ITiEmuOLE_turn_calc_on_Proxy(
1246 ITiEmuOLE __RPC_FAR * This,
1247 /* [retval][out] */ VARIANT_BOOL __RPC_FAR *ret)
1248 {
1249
1250 HRESULT _RetVal;
1251
1252 RPC_MESSAGE _RpcMessage;
1253
1254 MIDL_STUB_MESSAGE _StubMsg;
1255
1256 RpcTryExcept
1257 {
1258 NdrProxyInitialize(
1259 ( void __RPC_FAR * )This,
1260 ( PRPC_MESSAGE )&_RpcMessage,
1261 ( PMIDL_STUB_MESSAGE )&_StubMsg,
1262 ( PMIDL_STUB_DESC )&Object_StubDesc,
1263 16);
1264
1265
1266
1267 if(!ret)
1268 {
1269 RpcRaiseException(RPC_X_NULL_REF_POINTER);
1270 }
1271 RpcTryFinally
1272 {
1273
1274 _StubMsg.BufferLength = 0U;
1275 NdrProxyGetBuffer(This, &_StubMsg);
1276 NdrProxySendReceive(This, &_StubMsg);
1277
1278 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
1279 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[0] );
1280
1281 *ret = *(( VARIANT_BOOL __RPC_FAR * )_StubMsg.Buffer);
1282 _StubMsg.Buffer += sizeof( VARIANT_BOOL __RPC_FAR * );
1283
1284 _StubMsg.Buffer += 2;
1285 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer);
1286 _StubMsg.Buffer += sizeof( HRESULT __RPC_FAR * );
1287
1288 }
1289 RpcFinally
1290 {
1291 NdrProxyFreeBuffer(This, &_StubMsg);
1292
1293 }
1294 RpcEndFinally
1295
1296 }
1297 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
1298 {
1299 NdrClearOutParameters(
1300 ( PMIDL_STUB_MESSAGE )&_StubMsg,
1301 ( PFORMAT_STRING )&__MIDL_TypeFormatString.Format[2],
1302 ( void __RPC_FAR * )ret);
1303 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
1304 }
1305 RpcEndExcept
1306 return _RetVal;
1307 }
1308
ITiEmuOLE_turn_calc_on_Stub(IRpcStubBuffer * This,IRpcChannelBuffer * _pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD * _pdwStubPhase)1309 SECTION_ORPC void __RPC_STUB ITiEmuOLE_turn_calc_on_Stub(
1310 IRpcStubBuffer *This,
1311 IRpcChannelBuffer *_pRpcChannelBuffer,
1312 PRPC_MESSAGE _pRpcMessage,
1313 DWORD *_pdwStubPhase)
1314 {
1315 VARIANT_BOOL _M9;
1316 HRESULT _RetVal;
1317 MIDL_STUB_MESSAGE _StubMsg;
1318 VARIANT_BOOL __RPC_FAR *ret;
1319
1320 NdrStubInitialize(
1321 _pRpcMessage,
1322 &_StubMsg,
1323 &Object_StubDesc,
1324 _pRpcChannelBuffer);
1325 ( VARIANT_BOOL __RPC_FAR * )ret = 0;
1326 RpcTryFinally
1327 {
1328 ret = &_M9;
1329
1330 *_pdwStubPhase = STUB_CALL_SERVER;
1331 _RetVal = (((ITiEmuOLE*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> turn_calc_on((ITiEmuOLE *) ((CStdStubBuffer *)This)->pvServerObject,ret);
1332
1333 *_pdwStubPhase = STUB_MARSHAL;
1334
1335 _StubMsg.BufferLength = 2U + 6U;
1336 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
1337 *(( VARIANT_BOOL __RPC_FAR * )_StubMsg.Buffer) = *ret;
1338 _StubMsg.Buffer += sizeof( VARIANT_BOOL __RPC_FAR * );
1339
1340 _StubMsg.Buffer += 2;
1341 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer) = _RetVal;
1342 _StubMsg.Buffer += sizeof( HRESULT __RPC_FAR * );
1343
1344 }
1345 RpcFinally
1346 {
1347 }
1348 RpcEndFinally
1349 _pRpcMessage->BufferLength =
1350 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
1351
1352 }
1353
1354
ITiEmuOLE_enter_debugger_Proxy(ITiEmuOLE __RPC_FAR * This,VARIANT_BOOL __RPC_FAR * ret)1355 SECTION_ORPC HRESULT STDMETHODCALLTYPE ITiEmuOLE_enter_debugger_Proxy(
1356 ITiEmuOLE __RPC_FAR * This,
1357 /* [retval][out] */ VARIANT_BOOL __RPC_FAR *ret)
1358 {
1359
1360 HRESULT _RetVal;
1361
1362 RPC_MESSAGE _RpcMessage;
1363
1364 MIDL_STUB_MESSAGE _StubMsg;
1365
1366 RpcTryExcept
1367 {
1368 NdrProxyInitialize(
1369 ( void __RPC_FAR * )This,
1370 ( PRPC_MESSAGE )&_RpcMessage,
1371 ( PMIDL_STUB_MESSAGE )&_StubMsg,
1372 ( PMIDL_STUB_DESC )&Object_StubDesc,
1373 17);
1374
1375
1376
1377 if(!ret)
1378 {
1379 RpcRaiseException(RPC_X_NULL_REF_POINTER);
1380 }
1381 RpcTryFinally
1382 {
1383
1384 _StubMsg.BufferLength = 0U;
1385 NdrProxyGetBuffer(This, &_StubMsg);
1386 NdrProxySendReceive(This, &_StubMsg);
1387
1388 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
1389 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[0] );
1390
1391 *ret = *(( VARIANT_BOOL __RPC_FAR * )_StubMsg.Buffer);
1392 _StubMsg.Buffer += sizeof( VARIANT_BOOL __RPC_FAR * );
1393
1394 _StubMsg.Buffer += 2;
1395 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer);
1396 _StubMsg.Buffer += sizeof( HRESULT __RPC_FAR * );
1397
1398 }
1399 RpcFinally
1400 {
1401 NdrProxyFreeBuffer(This, &_StubMsg);
1402
1403 }
1404 RpcEndFinally
1405
1406 }
1407 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
1408 {
1409 NdrClearOutParameters(
1410 ( PMIDL_STUB_MESSAGE )&_StubMsg,
1411 ( PFORMAT_STRING )&__MIDL_TypeFormatString.Format[2],
1412 ( void __RPC_FAR * )ret);
1413 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
1414 }
1415 RpcEndExcept
1416 return _RetVal;
1417 }
1418
ITiEmuOLE_enter_debugger_Stub(IRpcStubBuffer * This,IRpcChannelBuffer * _pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD * _pdwStubPhase)1419 SECTION_ORPC void __RPC_STUB ITiEmuOLE_enter_debugger_Stub(
1420 IRpcStubBuffer *This,
1421 IRpcChannelBuffer *_pRpcChannelBuffer,
1422 PRPC_MESSAGE _pRpcMessage,
1423 DWORD *_pdwStubPhase)
1424 {
1425 VARIANT_BOOL _M9;
1426 HRESULT _RetVal;
1427 MIDL_STUB_MESSAGE _StubMsg;
1428 VARIANT_BOOL __RPC_FAR *ret;
1429
1430 NdrStubInitialize(
1431 _pRpcMessage,
1432 &_StubMsg,
1433 &Object_StubDesc,
1434 _pRpcChannelBuffer);
1435 ( VARIANT_BOOL __RPC_FAR * )ret = 0;
1436 RpcTryFinally
1437 {
1438 ret = &_M9;
1439
1440 *_pdwStubPhase = STUB_CALL_SERVER;
1441 _RetVal = (((ITiEmuOLE*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> enter_debugger((ITiEmuOLE *) ((CStdStubBuffer *)This)->pvServerObject,ret);
1442
1443 *_pdwStubPhase = STUB_MARSHAL;
1444
1445 _StubMsg.BufferLength = 2U + 6U;
1446 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
1447 *(( VARIANT_BOOL __RPC_FAR * )_StubMsg.Buffer) = *ret;
1448 _StubMsg.Buffer += sizeof( VARIANT_BOOL __RPC_FAR * );
1449
1450 _StubMsg.Buffer += 2;
1451 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer) = _RetVal;
1452 _StubMsg.Buffer += sizeof( HRESULT __RPC_FAR * );
1453
1454 }
1455 RpcFinally
1456 {
1457 }
1458 RpcEndFinally
1459 _pRpcMessage->BufferLength =
1460 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
1461
1462 }
1463
1464 extern const USER_MARSHAL_ROUTINE_QUADRUPLE UserMarshalRoutines[1];
1465
1466 static const MIDL_STUB_DESC Object_StubDesc =
1467 {
1468 0,
1469 NdrOleAllocate,
1470 NdrOleFree,
1471 0,
1472 0,
1473 0,
1474 0,
1475 0,
1476 __MIDL_TypeFormatString.Format,
1477 1, /* -error bounds_check flag */
1478 0x20000, /* Ndr library version */
1479 0,
1480 0x50100a4, /* MIDL Version 5.1.164 */
1481 0,
1482 UserMarshalRoutines,
1483 0, /* notify & notify_flag routine table */
1484 1, /* Flags */
1485 0, /* Reserved3 */
1486 0, /* Reserved4 */
1487 0 /* Reserved5 */
1488 };
1489
1490 CINTERFACE_PROXY_VTABLE(18) _ITiEmuOLEProxyVtbl =
1491 {
1492 &IID_ITiEmuOLE,
1493 IUnknown_QueryInterface_Proxy,
1494 IUnknown_AddRef_Proxy,
1495 IUnknown_Release_Proxy ,
1496 0 /* IDispatch_GetTypeInfoCount_Proxy */ ,
1497 0 /* IDispatch_GetTypeInfo_Proxy */ ,
1498 0 /* IDispatch_GetIDsOfNames_Proxy */ ,
1499 0 /* IDispatch_Invoke_Proxy */ ,
1500 ITiEmuOLE_image_loaded_Proxy ,
1501 ITiEmuOLE_emulated_calc_type_Proxy ,
1502 ITiEmuOLE_emulated_hw_version_Proxy ,
1503 ITiEmuOLE_emulated_os_version_Proxy ,
1504 ITiEmuOLE_ready_for_transfers_Proxy ,
1505 ITiEmuOLE_send_file_Proxy ,
1506 ITiEmuOLE_debug_file_Proxy ,
1507 ITiEmuOLE_reset_calc_Proxy ,
1508 ITiEmuOLE_execute_command_Proxy ,
1509 ITiEmuOLE_turn_calc_on_Proxy ,
1510 ITiEmuOLE_enter_debugger_Proxy
1511 };
1512
1513
1514 static const PRPC_STUB_FUNCTION ITiEmuOLE_table[] =
1515 {
1516 STUB_FORWARDING_FUNCTION,
1517 STUB_FORWARDING_FUNCTION,
1518 STUB_FORWARDING_FUNCTION,
1519 STUB_FORWARDING_FUNCTION,
1520 ITiEmuOLE_image_loaded_Stub,
1521 ITiEmuOLE_emulated_calc_type_Stub,
1522 ITiEmuOLE_emulated_hw_version_Stub,
1523 ITiEmuOLE_emulated_os_version_Stub,
1524 ITiEmuOLE_ready_for_transfers_Stub,
1525 ITiEmuOLE_send_file_Stub,
1526 ITiEmuOLE_debug_file_Stub,
1527 ITiEmuOLE_reset_calc_Stub,
1528 ITiEmuOLE_execute_command_Stub,
1529 ITiEmuOLE_turn_calc_on_Stub,
1530 ITiEmuOLE_enter_debugger_Stub
1531 };
1532
1533 CInterfaceStubVtbl _ITiEmuOLEStubVtbl =
1534 {
1535 &IID_ITiEmuOLE,
1536 0,
1537 18,
1538 &ITiEmuOLE_table[-3],
1539 CStdStubBuffer_DELEGATING_METHODS
1540 };
1541
1542 #ifndef __MINGW32__
1543 #pragma data_seg(".rdata")
1544 #endif
1545
1546 SECTION_RDATA static const USER_MARSHAL_ROUTINE_QUADRUPLE UserMarshalRoutines[1] =
1547 {
1548
1549 {
1550 (USER_MARSHAL_SIZING_ROUTINE)BSTR_UserSize
1551 ,(USER_MARSHAL_MARSHALLING_ROUTINE)BSTR_UserMarshal
1552 ,(USER_MARSHAL_UNMARSHALLING_ROUTINE)BSTR_UserUnmarshal
1553 ,(USER_MARSHAL_FREEING_ROUTINE)BSTR_UserFree
1554 }
1555
1556 };
1557
1558
1559 #if !defined(__RPC_WIN32__)
1560 #error Invalid build platform for this stub.
1561 #endif
1562
1563 #if !(TARGET_IS_NT40_OR_LATER) && !defined(__MINGW32__)
1564 #error You need a Windows NT 4.0 or later to run this stub because it uses these features:
1565 #error [wire_marshal] or [user_marshal] attribute.
1566 #error However, your C/C++ compilation flags indicate you intend to run this app on earlier systems.
1567 #error This app will die there with the RPC_X_WRONG_STUB_VERSION error.
1568 #endif
1569
1570
1571 SECTION_RDATA static const MIDL_PROC_FORMAT_STRING __MIDL_ProcFormatString =
1572 {
1573 0,
1574 {
1575
1576 0x51, /* FC_OUT_PARAM */
1577 #ifndef _ALPHA_
1578 0x1, /* x86, MIPS & PPC Stack size = 1 */
1579 #else
1580 0x2, /* Alpha Stack size = 2 */
1581 #endif
1582 /* 2 */ NdrFcShort( 0x2 ), /* Type Offset=2 */
1583 /* 4 */ 0x53, /* FC_RETURN_PARAM_BASETYPE */
1584 0x8, /* FC_LONG */
1585 /* 6 */
1586 0x51, /* FC_OUT_PARAM */
1587 #ifndef _ALPHA_
1588 0x1, /* x86, MIPS & PPC Stack size = 1 */
1589 #else
1590 0x2, /* Alpha Stack size = 2 */
1591 #endif
1592 /* 8 */ NdrFcShort( 0x6 ), /* Type Offset=6 */
1593 /* 10 */ 0x53, /* FC_RETURN_PARAM_BASETYPE */
1594 0x8, /* FC_LONG */
1595 /* 12 */
1596 0x51, /* FC_OUT_PARAM */
1597 #ifndef _ALPHA_
1598 0x1, /* x86, MIPS & PPC Stack size = 1 */
1599 #else
1600 0x2, /* Alpha Stack size = 2 */
1601 #endif
1602 /* 14 */ NdrFcShort( 0xa ), /* Type Offset=10 */
1603 /* 16 */ 0x53, /* FC_RETURN_PARAM_BASETYPE */
1604 0x8, /* FC_LONG */
1605 /* 18 */
1606 0x4d, /* FC_IN_PARAM */
1607 #ifndef _ALPHA_
1608 0x1, /* x86, MIPS & PPC Stack size = 1 */
1609 #else
1610 0x2, /* Alpha Stack size = 2 */
1611 #endif
1612 /* 20 */ NdrFcShort( 0x34 ), /* Type Offset=52 */
1613 /* 22 */
1614 0x51, /* FC_OUT_PARAM */
1615 #ifndef _ALPHA_
1616 0x1, /* x86, MIPS & PPC Stack size = 1 */
1617 #else
1618 0x2, /* Alpha Stack size = 2 */
1619 #endif
1620 /* 24 */ NdrFcShort( 0x2 ), /* Type Offset=2 */
1621 /* 26 */ 0x53, /* FC_RETURN_PARAM_BASETYPE */
1622 0x8, /* FC_LONG */
1623 /* 28 */ 0x4e, /* FC_IN_PARAM_BASETYPE */
1624 0x6, /* FC_SHORT */
1625 /* 30 */
1626 0x51, /* FC_OUT_PARAM */
1627 #ifndef _ALPHA_
1628 0x1, /* x86, MIPS & PPC Stack size = 1 */
1629 #else
1630 0x2, /* Alpha Stack size = 2 */
1631 #endif
1632 /* 32 */ NdrFcShort( 0x2 ), /* Type Offset=2 */
1633 /* 34 */ 0x53, /* FC_RETURN_PARAM_BASETYPE */
1634 0x8, /* FC_LONG */
1635
1636 0x0
1637 }
1638 };
1639
1640 SECTION_RDATA static const MIDL_TYPE_FORMAT_STRING __MIDL_TypeFormatString =
1641 {
1642 0,
1643 {
1644 NdrFcShort( 0x0 ), /* 0 */
1645 /* 2 */
1646 0x11, 0xc, /* FC_RP [alloced_on_stack] [simple_pointer] */
1647 /* 4 */ 0x6, /* FC_SHORT */
1648 0x5c, /* FC_PAD */
1649 /* 6 */
1650 0x11, 0xc, /* FC_RP [alloced_on_stack] [simple_pointer] */
1651 /* 8 */ 0x8, /* FC_LONG */
1652 0x5c, /* FC_PAD */
1653 /* 10 */
1654 0x11, 0x4, /* FC_RP [alloced_on_stack] */
1655 /* 12 */ NdrFcShort( 0x1a ), /* Offset= 26 (38) */
1656 /* 14 */
1657 0x13, 0x0, /* FC_OP */
1658 /* 16 */ NdrFcShort( 0xc ), /* Offset= 12 (28) */
1659 /* 18 */
1660 0x1b, /* FC_CARRAY */
1661 0x1, /* 1 */
1662 /* 20 */ NdrFcShort( 0x2 ), /* 2 */
1663 /* 22 */ 0x9, /* Corr desc: FC_ULONG */
1664 0x0, /* */
1665 /* 24 */ NdrFcShort( 0xfffc ), /* -4 */
1666 /* 26 */ 0x6, /* FC_SHORT */
1667 0x5b, /* FC_END */
1668 /* 28 */
1669 0x17, /* FC_CSTRUCT */
1670 0x3, /* 3 */
1671 /* 30 */ NdrFcShort( 0x8 ), /* 8 */
1672 /* 32 */ NdrFcShort( 0xfffffff2 ), /* Offset= -14 (18) */
1673 /* 34 */ 0x8, /* FC_LONG */
1674 0x8, /* FC_LONG */
1675 /* 36 */ 0x5c, /* FC_PAD */
1676 0x5b, /* FC_END */
1677 /* 38 */ 0xb4, /* FC_USER_MARSHAL */
1678 0x83, /* 131 */
1679 /* 40 */ NdrFcShort( 0x0 ), /* 0 */
1680 /* 42 */ NdrFcShort( 0x4 ), /* 4 */
1681 /* 44 */ NdrFcShort( 0x0 ), /* 0 */
1682 /* 46 */ NdrFcShort( 0xffffffe0 ), /* Offset= -32 (14) */
1683 /* 48 */
1684 0x12, 0x0, /* FC_UP */
1685 /* 50 */ NdrFcShort( 0xffffffea ), /* Offset= -22 (28) */
1686 /* 52 */ 0xb4, /* FC_USER_MARSHAL */
1687 0x83, /* 131 */
1688 /* 54 */ NdrFcShort( 0x0 ), /* 0 */
1689 /* 56 */ NdrFcShort( 0x4 ), /* 4 */
1690 /* 58 */ NdrFcShort( 0x0 ), /* 0 */
1691 /* 60 */ NdrFcShort( 0xfffffff4 ), /* Offset= -12 (48) */
1692
1693 0x0
1694 }
1695 };
1696
1697 const CInterfaceProxyVtbl * _oleaut_ProxyVtblList[] =
1698 {
1699 ( CInterfaceProxyVtbl *) &_ITiEmuOLEProxyVtbl,
1700 0
1701 };
1702
1703 const CInterfaceStubVtbl * _oleaut_StubVtblList[] =
1704 {
1705 ( CInterfaceStubVtbl *) &_ITiEmuOLEStubVtbl,
1706 0
1707 };
1708
1709 PCInterfaceName const _oleaut_InterfaceNamesList[] =
1710 {
1711 "ITiEmuOLE",
1712 0
1713 };
1714
1715 const IID * _oleaut_BaseIIDList[] =
1716 {
1717 &IID_IDispatch,
1718 0
1719 };
1720
1721
1722 #define _oleaut_CHECK_IID(n) IID_GENERIC_CHECK_IID( _oleaut, pIID, n)
1723
_oleaut_IID_Lookup(const IID * pIID,int * pIndex)1724 SECTION_ORPC int __stdcall _oleaut_IID_Lookup( const IID * pIID, int * pIndex )
1725 {
1726
1727 if(!_oleaut_CHECK_IID(0))
1728 {
1729 *pIndex = 0;
1730 return 1;
1731 }
1732
1733 return 0;
1734 }
1735
1736 SECTION_RDATA const ExtendedProxyFileInfo oleaut_ProxyFileInfo =
1737 {
1738 (PCInterfaceProxyVtblList *) & _oleaut_ProxyVtblList,
1739 (PCInterfaceStubVtblList *) & _oleaut_StubVtblList,
1740 (const PCInterfaceName * ) & _oleaut_InterfaceNamesList,
1741 (const IID ** ) & _oleaut_BaseIIDList,
1742 & _oleaut_IID_Lookup,
1743 1,
1744 1,
1745 0, /* table of [async_uuid] interfaces */
1746 0, /* Filler1 */
1747 0, /* Filler2 */
1748 0 /* Filler3 */
1749 };
1750