LibreOffice Module bridges (master) 1
gcc3_linux_s390/uno2cpp.cxx
Go to the documentation of this file.
1/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2/*
3 * This file is part of the LibreOffice project.
4 *
5 * This Source Code Form is subject to the terms of the Mozilla Public
6 * License, v. 2.0. If a copy of the MPL was not distributed with this
7 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 *
9 * This file incorporates work covered by the following license notice:
10 *
11 * Licensed to the Apache Software Foundation (ASF) under one or more
12 * contributor license agreements. See the NOTICE file distributed
13 * with this work for additional information regarding copyright
14 * ownership. The ASF licenses this file to you under the Apache
15 * License, Version 2.0 (the "License"); you may not use this file
16 * except in compliance with the License. You may obtain a copy of
17 * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 */
19
20#include <sal/config.h>
21
22#include <exception>
23#include <malloc.h>
24#include <typeinfo>
25
26#include <com/sun/star/uno/Exception.hpp>
27#include <com/sun/star/uno/RuntimeException.hpp>
28#include <com/sun/star/uno/genfunc.hxx>
30#include <uno/data.h>
31
32#include "bridge.hxx"
33#include "types.hxx"
34#include "unointerfaceproxy.hxx"
35#include "vtables.hxx"
36
37#include "share.hxx"
38
39#include <stdio.h>
40#include <string.h>
41
42
43using namespace ::com::sun::star::uno;
44
45namespace
46{
47static sal_Int32
48invoke_count_words(char * pPT)
49{
50 sal_Int32 overflow = 0, gpr = 0, fpr = 0;
51
52 while (*pPT != 'X') {
53 // character of parameter type being decoded
54 const int c = *pPT;
55
56 switch (c) {
57 case 'D': /* type is double */
58 if (fpr < 2) fpr++; else overflow+=2;
59 break;
60
61 case 'F': /* type is float */
62 if (fpr < 2) fpr++; else overflow++;
63 break;
64
65 case 'H': /* type is long long */
66 if (gpr < 4) gpr+=2; else gpr=5, overflow+=2;
67 break;
68
69 case 'S':
70 case 'T':
71 case 'B':
72 case 'C':
73 if (gpr < 5) gpr++; else overflow++;
74 break;
75
76 default:
77 if (gpr < 5) gpr++; else overflow++;
78 break;
79 }
80 pPT++;
81 }
82 /* Round up number of overflow words to ensure stack
83 stays aligned to 8 bytes. */
84 return (overflow + 1) & ~1;
85}
86
87static void
88//invoke_copy_to_stack(sal_Int32 paramCount, sal_Int32 * pStackLongs, char * pPT, sal_Int32* d_ov, sal_Int32 overflow)
89invoke_copy_to_stack(sal_Int32 * pStackLongs, char * pPT, sal_Int32* d_ov, sal_Int32 overflow)
90{
91 sal_Int32 *d_gpr = d_ov + overflow;
92 sal_Int64 *d_fpr = (sal_Int64 *)(d_gpr + 5);
93 sal_Int32 gpr = 0, fpr = 0;
94
95 while (*pPT != 'X') {
96 const char c = *pPT;
97 switch (c) {
98 case 'D': /* type is double */
99 if (fpr < 2)
100 *((double*) d_fpr) = *((double *)pStackLongs), d_fpr++, fpr++;
101 else
102 *((double*) d_ov ) = *((double *)pStackLongs), d_ov+=2;
103
104 pStackLongs += 2;
105 break;
106
107 case 'F': /* type is float */
108 if (fpr < 2) {
109 *((sal_Int64*) d_fpr) = 0;
110 *((float*) d_fpr) = *((float *)pStackLongs), d_fpr++, fpr++;
111 }
112 else {
113 *((sal_Int64*) d_ov) = 0;
114 *((float*) d_ov ) = *((float *)pStackLongs), d_ov++;
115 }
116
117 pStackLongs += 1;
118 break;
119
120 case 'H': /* type is long long */
121 if (gpr < 4) {
122 *((sal_Int64*) d_gpr) = *((sal_Int64*) pStackLongs), d_gpr+=2, gpr+=2;
123 }
124 else {
125 *((sal_Int64*) d_ov ) = *((sal_Int64*) pStackLongs), d_ov+=2, gpr=5;
126 }
127 pStackLongs += 2;
128 break;
129
130 case 'S':
131 if (gpr < 5)
132 *((sal_uInt32*)d_gpr) = *((unsigned short*)pStackLongs), d_gpr++, gpr++;
133 else
134 *((sal_uInt32*)d_ov ) = *((unsigned short*)pStackLongs), d_ov++;
135 pStackLongs += 1;
136 break;
137
138 case 'T':
139 if (gpr < 5)
140 *((sal_Int32*)d_gpr) = *((signed short*)pStackLongs), d_gpr++, gpr++;
141 else
142 *((sal_Int32*)d_ov ) = *((signed short*)pStackLongs), d_ov++;
143 pStackLongs += 1;
144 break;
145
146 case 'B':
147 if (gpr < 5)
148 *((sal_uInt32*)d_gpr) = *((unsigned char*)pStackLongs), d_gpr++, gpr++;
149 else
150 *((sal_uInt32*)d_ov ) = *((unsigned char*)pStackLongs), d_ov++;
151 pStackLongs += 1;
152 break;
153
154 case 'C':
155 if (gpr < 5)
156 *((sal_Int32*)d_gpr) = *((signed char*)pStackLongs), d_gpr++, gpr++;
157 else
158 *((sal_Int32*)d_ov ) = *((signed char*)pStackLongs), d_ov++;
159 pStackLongs += 1;
160 break;
161
162 default:
163 if (gpr < 5)
164 *((sal_Int32*)d_gpr) = *pStackLongs, d_gpr++, gpr++;
165 else
166 *((sal_Int32*)d_ov ) = *pStackLongs, d_ov++;
167 pStackLongs += 1;
168 break;
169 }
170 pPT++;
171 }
172}
173
174static void callVirtualMethod(
175 void * pThis,
176 sal_Int32 nVtableIndex,
177 void * pRegisterReturn,
178 typelib_TypeClass eReturnType,
179 char * pPT,
180 sal_Int32 * pStackLongs,
181 sal_Int32 nStackLongs)
182{
183
184 // parameter list is mixed list of * and values
185 // reference parameters are pointers
186
187 // the basic idea here is to use gpr[5] as a storage area for
188 // the future values of registers r2 to r6 needed for the call,
189 // and similarly fpr[2] as a storage area for the future values
190 // of floating point registers f0 to f2
191
192 sal_Int32 *vtable = *(sal_Int32 **)pThis;
193// sal_Int32 method = vtable[nVtableIndex + 2];
194 sal_Int32 method = vtable[nVtableIndex];
195 sal_Int32 overflow = invoke_count_words (pPT);
196 sal_Int32 result;
197 volatile double dret; // temporary function return values
198 volatile float fret;
199 volatile int iret, iret2;
200
201 void * dummy = alloca(32); // dummy alloca to force r11 usage for exception handling
202
203 __asm__ __volatile__
204 (
205 "lr 7,15\n\t"
206 "ahi 7,-48\n\t"
207
208 "lr 3,%2\n\t"
209 "sll 3,2\n\t"
210 "lcr 3,3\n\t"
211 "l 2,0(15)\n\t"
212 "la 15,0(3,7)\n\t"
213 "st 2,0(15)\n\t"
214
215 "lr 2,%0\n\t"
216 "lr 3,%1\n\t"
217 "la 4,96(15)\n\t"
218 "lr 5,%2\n\t"
219 "basr 14,%3\n\t"
220
221 "ld 0,116(7)\n\t"
222 "ld 2,124(7)\n\t"
223 "lm 2,6,96(7)\n\t"
224 :
225 : "r" (pStackLongs),
226 "r" (pPT),
227 "r" (overflow),
228 "a" (invoke_copy_to_stack),
229 "a" (method),
230 "X" (dummy)
231 : "2", "3", "4", "5", "6", "7", "memory"
232 );
233// "basr 14,%8\n\t"
234
235 (*(void (*)())method)();
236
237 __asm__ __volatile__
238 (
239 "la 15,48(7)\n\t"
240
241 "lr %2,2\n\t"
242 "lr %3,3\n\t"
243 "ler %0,0\n\t"
244 "ldr %1,0\n\t"
245
246 : "=f" (fret), "=f" (dret), "=r" (iret), "=r" (iret2)
247 );
248
249 switch( eReturnType )
250 {
251 case typelib_TypeClass_HYPER:
252 case typelib_TypeClass_UNSIGNED_HYPER:
253// ((long*)pRegisterReturn)[0] = iret;
254 ((long*)pRegisterReturn)[1] = iret2;
255 case typelib_TypeClass_LONG:
256 case typelib_TypeClass_UNSIGNED_LONG:
257 case typelib_TypeClass_ENUM:
258 ((long*)pRegisterReturn)[0] = iret;
259 break;
260 case typelib_TypeClass_CHAR:
261 case typelib_TypeClass_SHORT:
262 case typelib_TypeClass_UNSIGNED_SHORT:
263 *(unsigned short*)pRegisterReturn = (unsigned short)iret;
264 break;
265 case typelib_TypeClass_BOOLEAN:
266 case typelib_TypeClass_BYTE:
267 *(unsigned char*)pRegisterReturn = (unsigned char)iret;
268 break;
269 case typelib_TypeClass_FLOAT:
270 *(float*)pRegisterReturn = fret;
271 break;
272 case typelib_TypeClass_DOUBLE:
273 *(double*)pRegisterReturn = dret;
274 break;
275 }
276}
277
278
279static void cpp_call(
282 typelib_TypeDescriptionReference * pReturnTypeRef,
283 sal_Int32 nParams, typelib_MethodParameter * pParams,
284 void * pUnoReturn, void * pUnoArgs[], uno_Any ** ppUnoExc )
285{
286 // max space for: [complex ret ptr], values|ptr ...
287 char * pCppStack =
288 (char *)alloca( sizeof(sal_Int32) + ((nParams+2) * sizeof(sal_Int64)) );
289 char * pCppStackStart = pCppStack;
290
291 // need to know parameter types for callVirtualMethod so generate a signature string
292 char * pParamType = (char *) alloca(nParams+2);
293 char * pPT = pParamType;
294
295 // return
296 typelib_TypeDescription * pReturnTypeDescr = 0;
297 TYPELIB_DANGER_GET( &pReturnTypeDescr, pReturnTypeRef );
298 assert(pReturnTypeDescr);
299
300 void * pCppReturn = 0; // if != 0 && != pUnoReturn, needs reconversion
301
302 if (pReturnTypeDescr)
303 {
304 if (bridges::cpp_uno::shared::isSimpleType( pReturnTypeDescr ))
305 {
306 pCppReturn = pUnoReturn; // direct way for simple types
307 }
308 else
309 {
310 // complex return via ptr
311 pCppReturn = *(void **)pCppStack = (bridges::cpp_uno::shared::relatesToInterfaceType( pReturnTypeDescr )
312 ? alloca( pReturnTypeDescr->nSize )
313 : pUnoReturn); // direct way
314 *pPT++ = 'I'; //signify that a complex return type on stack
315 pCppStack += sizeof(void *);
316 }
317 }
318 // push "this" pointer
319 void * pAdjustedThisPtr = reinterpret_cast< void ** >( pThis->getCppI() ) + aVtableSlot.offset;
320 *(void**)pCppStack = pAdjustedThisPtr;
321 pCppStack += sizeof( void* );
322 *pPT++ = 'I';
323
324 // stack space
325 static_assert(sizeof(void *) == sizeof(sal_Int32), "### unexpected size!");
326 // args
327 void ** pCppArgs = (void **)alloca( 3 * sizeof(void *) * nParams );
328 // indices of values this have to be converted (interface conversion cpp<=>uno)
329 sal_Int32 * pTempIndices = (sal_Int32 *)(pCppArgs + nParams);
330 // type descriptions for reconversions
331 typelib_TypeDescription ** ppTempParamTypeDescr = (typelib_TypeDescription **)(pCppArgs + (2 * nParams));
332
333 sal_Int32 nTempIndices = 0;
334
335 for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
336 {
337 const typelib_MethodParameter & rParam = pParams[nPos];
338 typelib_TypeDescription * pParamTypeDescr = 0;
339 TYPELIB_DANGER_GET( &pParamTypeDescr, rParam.pTypeRef );
340
341 if (!rParam.bOut && bridges::cpp_uno::shared::isSimpleType( pParamTypeDescr ))
342 {
343 uno_copyAndConvertData( pCppArgs[nPos] = pCppStack, pUnoArgs[nPos], pParamTypeDescr,
344 pThis->getBridge()->getUno2Cpp() );
345
346 switch (pParamTypeDescr->eTypeClass)
347 {
348
349 // we need to know type of each param so that we know whether to use
350 // gpr or fpr to pass in parameters:
351 // Key: I - int, long, pointer, etc means pass in gpr
352 // B - byte value passed in gpr
353 // S - short value passed in gpr
354 // F - float value pass in fpr
355 // D - double value pass in fpr
356 // H - long long int pass in proper pairs of gpr (3,4) (5,6), etc
357 // X - indicates end of parameter description string
358
359 case typelib_TypeClass_LONG:
360 case typelib_TypeClass_UNSIGNED_LONG:
361 case typelib_TypeClass_ENUM:
362 *pPT++ = 'I';
363 break;
364 case typelib_TypeClass_SHORT:
365 *pPT++ = 'T';
366 break;
367 case typelib_TypeClass_CHAR:
368 case typelib_TypeClass_UNSIGNED_SHORT:
369 *pPT++ = 'S';
370 break;
371 case typelib_TypeClass_BOOLEAN:
372 *pPT++ = 'B';
373 break;
374 case typelib_TypeClass_BYTE:
375 *pPT++ = 'C';
376 break;
377 case typelib_TypeClass_FLOAT:
378 *pPT++ = 'F';
379 break;
380 case typelib_TypeClass_DOUBLE:
381 *pPT++ = 'D';
382 pCppStack += sizeof(sal_Int32); // extra long
383 break;
384 case typelib_TypeClass_HYPER:
385 case typelib_TypeClass_UNSIGNED_HYPER:
386 *pPT++ = 'H';
387 pCppStack += sizeof(sal_Int32); // extra long
388 }
389
390 // no longer needed
391 TYPELIB_DANGER_RELEASE( pParamTypeDescr );
392 }
393 else // ptr to complex value | ref
394 {
395 if (! rParam.bIn) // is pure out
396 {
397 // cpp out is constructed mem, uno out is not!
399 *(void **)pCppStack = pCppArgs[nPos] = alloca( pParamTypeDescr->nSize ),
400 pParamTypeDescr );
401 pTempIndices[nTempIndices] = nPos; // default constructed for cpp call
402 // will be released at reconversion
403 ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
404 }
405 // is in/inout
406 else if (bridges::cpp_uno::shared::relatesToInterfaceType( pParamTypeDescr ))
407 {
409 *(void **)pCppStack = pCppArgs[nPos] = alloca( pParamTypeDescr->nSize ),
410 pUnoArgs[nPos], pParamTypeDescr, pThis->getBridge()->getUno2Cpp() );
411
412 pTempIndices[nTempIndices] = nPos; // has to be reconverted
413 // will be released at reconversion
414 ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
415 }
416 else // direct way
417 {
418 *(void **)pCppStack = pCppArgs[nPos] = pUnoArgs[nPos];
419 // no longer needed
420 TYPELIB_DANGER_RELEASE( pParamTypeDescr );
421 }
422 // KBH: FIXME: is this the right way to pass these
423 *pPT++='I';
424 }
425 pCppStack += sizeof(sal_Int32); // standard parameter length
426 }
427
428 // terminate the signature string
429 *pPT++='X';
430 *pPT=0;
431
432 try
433 {
434 assert( !( (pCppStack - pCppStackStart ) & 3) && "UNALIGNED STACK !!! (Please DO panic)" );
435 try {
437 pAdjustedThisPtr, aVtableSlot.index,
438 pCppReturn, pReturnTypeDescr->eTypeClass, pParamType,
439 (sal_Int32 *)pCppStackStart, (pCppStack - pCppStackStart) / sizeof(sal_Int32) );
440 } catch (css::uno::Exception &) {
441 throw;
442 } catch (std::exception & e) {
443 throw css::uno::RuntimeException(
444 "C++ code threw " + o3tl::runtimeToOUString(typeid(e).name()) + ": "
445 + o3tl::runtimeToOUString(e.what()));
446 } catch (...) {
447 throw css::uno::RuntimeException("C++ code threw unknown exception");
448 }
449 // NO exception occurred...
450 *ppUnoExc = 0;
451
452 // reconvert temporary params
453 for ( ; nTempIndices--; )
454 {
455 sal_Int32 nIndex = pTempIndices[nTempIndices];
456 typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndices];
457
458 if (pParams[nIndex].bIn)
459 {
460 if (pParams[nIndex].bOut) // inout
461 {
462 uno_destructData( pUnoArgs[nIndex], pParamTypeDescr, 0 ); // destroy uno value
463 uno_copyAndConvertData( pUnoArgs[nIndex], pCppArgs[nIndex], pParamTypeDescr,
464 pThis->getBridge()->getCpp2Uno() );
465 }
466 }
467 else // pure out
468 {
469 uno_copyAndConvertData( pUnoArgs[nIndex], pCppArgs[nIndex], pParamTypeDescr,
470 pThis->getBridge()->getCpp2Uno() );
471 }
472 // destroy temp cpp param => cpp: every param was constructed
473 uno_destructData( pCppArgs[nIndex], pParamTypeDescr, cpp_release );
474
475 TYPELIB_DANGER_RELEASE( pParamTypeDescr );
476 }
477 // return value
478 if (pCppReturn && pUnoReturn != pCppReturn)
479 {
480 uno_copyAndConvertData( pUnoReturn, pCppReturn, pReturnTypeDescr,
481 pThis->getBridge()->getCpp2Uno() );
482 uno_destructData( pCppReturn, pReturnTypeDescr, cpp_release );
483 }
484 }
485 catch (...)
486 {
487 // fill uno exception
489
490
491 // temporary params
492 for ( ; nTempIndices--; )
493 {
494 sal_Int32 nIndex = pTempIndices[nTempIndices];
495 // destroy temp cpp param => cpp: every param was constructed
496 uno_destructData( pCppArgs[nIndex], ppTempParamTypeDescr[nTempIndices], cpp_release );
497 TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndices] );
498 }
499 // return type
500 if (pReturnTypeDescr)
501 TYPELIB_DANGER_RELEASE( pReturnTypeDescr );
502 }
503}
504}
505
506namespace bridges::cpp_uno::shared {
507
509 uno_Interface * pUnoI, const typelib_TypeDescription * pMemberDescr,
510 void * pReturn, void * pArgs[], uno_Any ** ppException )
511{
512#if OSL_DEBUG_LEVEL > 2
513 fprintf(stderr, "unoInterfaceProxyDispatch\n");
514#endif
515
516
517 // is my surrogate
519 = static_cast< bridges::cpp_uno::shared::UnoInterfaceProxy *> (pUnoI);
520
521 switch (pMemberDescr->eTypeClass)
522 {
523 case typelib_TypeClass_INTERFACE_ATTRIBUTE:
524 {
525
526 VtableSlot aVtableSlot(
528 reinterpret_cast<
529 typelib_InterfaceAttributeTypeDescription const * >(
530 pMemberDescr)));
531
532 if (pReturn)
533 {
534 // dependent dispatch
535 cpp_call(
536 pThis, aVtableSlot,
537 ((typelib_InterfaceAttributeTypeDescription *)pMemberDescr)->pAttributeTypeRef,
538 0, 0, // no params
539 pReturn, pArgs, ppException );
540 }
541 else
542 {
543 // is SET
544 typelib_MethodParameter aParam;
545 aParam.pTypeRef =
546 ((typelib_InterfaceAttributeTypeDescription *)pMemberDescr)->pAttributeTypeRef;
547 aParam.bIn = sal_True;
548 aParam.bOut = sal_False;
549
550 typelib_TypeDescriptionReference * pReturnTypeRef = 0;
551 OUString aVoidName("void");
553 &pReturnTypeRef, typelib_TypeClass_VOID, aVoidName.pData );
554
555 // dependent dispatch
556 aVtableSlot.index += 1; //get then set method
557 cpp_call(
558 pThis, aVtableSlot,
559 pReturnTypeRef,
560 1, &aParam,
561 pReturn, pArgs, ppException );
562
564 }
565
566 break;
567 }
568 case typelib_TypeClass_INTERFACE_METHOD:
569 {
570
571 VtableSlot aVtableSlot(
573 reinterpret_cast<
574 typelib_InterfaceMethodTypeDescription const * >(
575 pMemberDescr)));
576 switch (aVtableSlot.index)
577 {
578 // standard calls
579 case 1: // acquire uno interface
580 (*pUnoI->acquire)( pUnoI );
581 *ppException = 0;
582 break;
583 case 2: // release uno interface
584 (*pUnoI->release)( pUnoI );
585 *ppException = 0;
586 break;
587 case 0: // queryInterface() opt
588 {
589 typelib_TypeDescription * pTD = 0;
590 TYPELIB_DANGER_GET( &pTD, reinterpret_cast< Type * >( pArgs[0] )->getTypeLibType() );
591 if (pTD)
592 {
593 uno_Interface * pInterface = 0;
594 (*pThis->pBridge->getUnoEnv()->getRegisteredInterface)(
595 pThis->pBridge->getUnoEnv(),
596 (void **)&pInterface, pThis->oid.pData, (typelib_InterfaceTypeDescription *)pTD );
597
598 if (pInterface)
599 {
600 ::uno_any_construct(
601 reinterpret_cast< uno_Any * >( pReturn ),
602 &pInterface, pTD, 0 );
603 (*pInterface->release)( pInterface );
604 TYPELIB_DANGER_RELEASE( pTD );
605 *ppException = 0;
606 break;
607 }
608 TYPELIB_DANGER_RELEASE( pTD );
609 }
610 } // else perform queryInterface()
611 default:
612 // dependent dispatch
613 cpp_call(
614 pThis, aVtableSlot,
615 ((typelib_InterfaceMethodTypeDescription *)pMemberDescr)->pReturnTypeRef,
616 ((typelib_InterfaceMethodTypeDescription *)pMemberDescr)->nParams,
617 ((typelib_InterfaceMethodTypeDescription *)pMemberDescr)->pParams,
618 pReturn, pArgs, ppException );
619 }
620 break;
621 }
622 default:
623 {
624 ::com::sun::star::uno::RuntimeException aExc(
625 "illegal member type description!",
627
628 Type const & rExcType = cppu::UnoType<decltype(aExc)>::get();
629 // binary identical null reference
630 ::uno_type_any_construct( *ppException, &aExc, rExcType.getTypeLibType(), 0 );
631 }
632 }
633}
634
635}
636
637/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
uno_Mapping * getUno2Cpp()
Definition: bridge.hxx:73
uno_ExtEnvironment * getUnoEnv()
Definition: bridge.hxx:70
uno_Mapping * getCpp2Uno()
Definition: bridge.hxx:72
A uno proxy wrapping a cpp interface.
com::sun::star::uno::XInterface * getCppI()
void SAL_CALL uno_destructData(void *pValue, typelib_TypeDescription *pTypeDescr, uno_ReleaseFunc release) SAL_THROW_EXTERN_C()
void SAL_CALL uno_constructData(void *pMem, typelib_TypeDescription *pTypeDescr) SAL_THROW_EXTERN_C()
void SAL_CALL uno_copyAndConvertData(void *pDest, void *pSource, typelib_TypeDescription *pTypeDescr, uno_Mapping *mapping) SAL_THROW_EXTERN_C()
char const * name
register sal_uInt32 r28 __asm__("%r28")
void callVirtualMethod(void *pThis, sal_uInt32 nVtableIndex, void *pRegisterReturn, typelib_TypeDescription *pReturnTypeDescr, bool bRegisterReturn, sal_uInt32 *pStack, sal_uInt32 nStack, sal_uInt32 *pGPR, double *pFPR) __attribute__((noinline))
static void cpp_call(bridges::cpp_uno::shared::UnoInterfaceProxy *pThis, bridges::cpp_uno::shared::VtableSlot aVtableSlot, typelib_TypeDescriptionReference *pReturnTypeRef, sal_Int32 nParams, typelib_MethodParameter *pParams, void *pUnoReturn, void *pUnoArgs[], uno_Any **ppUnoExc)
sal_Int32 nIndex
sal_uInt16 nPos
struct _typelib_TypeDescription typelib_TypeDescription
Definition: msvc/except.hxx:52
struct _uno_Any uno_Any
Definition: msvc/except.hxx:31
void fillUnoException(uno_Any *pExc, uno_Mapping *pCpp2Uno)
void unoInterfaceProxyDispatch(uno_Interface *pUnoI, const typelib_TypeDescription *pMemberDescr, void *pReturn, void *pArgs[], uno_Any **ppException)
VtableSlot getVtableSlot(typelib_InterfaceAttributeTypeDescription const *ifcMember)
Calculates the vtable slot associated with an interface attribute member.
Definition: vtables.cxx:132
bool isSimpleType(typelib_TypeClass typeClass)
Determines whether a type is a "simple" type (VOID, BOOLEAN, BYTE, SHORT, UNSIGNED SHORT,...
Definition: types.cxx:28
bool relatesToInterfaceType(typelib_TypeDescription const *type)
Determines whether a type relates to an interface type (is itself an interface type,...
Definition: types.cxx:41
Type
OUString runtimeToOUString(char const *runtimeString)
Represents a vtable slot of a C++ class.
Definition: vtables.hxx:60
sal_Int32 index
The index within the vtable.
Definition: vtables.hxx:76
sal_Int32 offset
The offset of the vtable.
Definition: vtables.hxx:68
void SAL_CALL typelib_typedescriptionreference_new(typelib_TypeDescriptionReference **ppTDR, typelib_TypeClass eTypeClass, rtl_uString *pTypeName) SAL_THROW_EXTERN_C()
void SAL_CALL typelib_typedescriptionreference_release(typelib_TypeDescriptionReference *pRef) SAL_THROW_EXTERN_C()
#define sal_True
#define sal_False
Any result