LibreOffice Module bridges (master) 1
gcc3_ios/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#ifdef __arm64
21
22#include <sal/config.h>
23
24#include <exception>
25#include <typeinfo>
26
27#include <com/sun/star/uno/Exception.hpp>
28#include <com/sun/star/uno/RuntimeException.hpp>
30
31#include "bridge.hxx"
32#include "types.hxx"
33#include "unointerfaceproxy.hxx"
34#include "vtables.hxx"
35
36#include "share.hxx"
37
38using namespace ::com::sun::star::uno;
39
40namespace arm
41{
42 bool is_hfa_struct(const typelib_TypeDescription * type)
43 {
44 const typelib_CompoundTypeDescription * p
45 = reinterpret_cast< const typelib_CompoundTypeDescription * >(type);
46 if (p->nMembers >= 4)
47 return false;
48 for (sal_Int32 i = 0; i < p->nMembers; ++i)
49 {
50 if ((p->ppTypeRefs[i]->eTypeClass != typelib_TypeClass_FLOAT &&
51 p->ppTypeRefs[i]->eTypeClass != typelib_TypeClass_DOUBLE) ||
52 p->ppTypeRefs[i]->eTypeClass != p->ppTypeRefs[0]->eTypeClass)
53 return false;
54 }
55 return true;
56 }
57
58 bool return_in_x8( typelib_TypeDescriptionReference *pTypeRef )
59 {
61 return false;
62 else if (pTypeRef->eTypeClass == typelib_TypeClass_STRUCT || pTypeRef->eTypeClass == typelib_TypeClass_EXCEPTION)
63 {
64 typelib_TypeDescription * pTypeDescr = 0;
65 TYPELIB_DANGER_GET( &pTypeDescr, pTypeRef );
66
67 // A Composite Type not larger than 16 bytes is returned in x0, x1
68 bool bRet = pTypeDescr->nSize > 16;
69
70 if (is_hfa_struct(pTypeDescr))
71 bRet = false;
72
73 TYPELIB_DANGER_RELEASE( pTypeDescr );
74 return bRet;
75 }
76 return true;
77 }
78}
79
80void MapReturn(sal_uInt64 *pGPR, double *pFPR, typelib_TypeDescriptionReference *pReturnType, sal_uInt64 *pRegisterReturn)
81{
82 switch( pReturnType->eTypeClass )
83 {
84 case typelib_TypeClass_HYPER:
85 case typelib_TypeClass_UNSIGNED_HYPER:
86 pRegisterReturn[1] = pGPR[1];
87 [[fallthrough]];
88 case typelib_TypeClass_LONG:
89 case typelib_TypeClass_UNSIGNED_LONG:
90 case typelib_TypeClass_ENUM:
91 case typelib_TypeClass_CHAR:
92 case typelib_TypeClass_SHORT:
93 case typelib_TypeClass_UNSIGNED_SHORT:
94 case typelib_TypeClass_BOOLEAN:
95 case typelib_TypeClass_BYTE:
96 pRegisterReturn[0] = pGPR[0];
97 break;
98 case typelib_TypeClass_FLOAT:
99 *(float*)pRegisterReturn = *(float*)&pFPR[0];
100 break;
101 case typelib_TypeClass_DOUBLE:
102 *(double*)pRegisterReturn = pFPR[0];
103 break;
104 case typelib_TypeClass_STRUCT:
105 case typelib_TypeClass_EXCEPTION:
106 if (!arm::return_in_x8(pReturnType))
107 {
108 pRegisterReturn[0] = pGPR[0];
109 pRegisterReturn[1] = pGPR[1];
110 }
111 break;
112 default:
113 break;
114 }
115}
116
117namespace
118{
120 void *pThis,
121 sal_Int32 nVtableIndex,
122 void *pRegisterReturn,
123 typelib_TypeDescriptionReference *pReturnType,
124 sal_uInt64 *pStack,
125 int nStack,
126 sal_uInt64 *pGPR,
127 double *pFPR)
128{
129 // never called
130 if (! pThis)
131 CPPU_CURRENT_NAMESPACE::dummy_can_throw_anything("xxx"); // address something
132
133 if ( nStack )
134 {
135 // 16-bytes aligned
136 sal_uInt32 nStackBytes = ( ( nStack + 3 ) >> 2 ) * 16;
137 sal_uInt32 *stack = (sal_uInt32 *) alloca( nStackBytes );
138 memcpy( stack, pStack, nStackBytes );
139 }
140
141 sal_uInt64 pMethod = *((sal_uInt64*)pThis);
142 pMethod += 8 * nVtableIndex;
143 pMethod = *((sal_uInt64 *)pMethod);
144
145 __asm__ __volatile__
146 (
147 // Assembly string
148 " ldp x0, x1, %[pgpr_0]\n"
149 " ldp x2, x3, %[pgpr_2]\n"
150 " ldp x4, x5, %[pgpr_4]\n"
151 " ldp x6, x7, %[pgpr_6]\n"
152 " ldr x8, %[pregisterreturn]\n"
153 " ldp d0, d1, %[pfpr_0]\n"
154 " ldp d2, d3, %[pfpr_2]\n"
155 " ldp d4, d5, %[pfpr_4]\n"
156 " ldp d6, d7, %[pfpr_6]\n"
157 " blr %[pmethod]\n"
158 " stp x0, x1, %[pgpr_0]\n"
159 " str d0, %[pfpr_0]\n"
160 // Input operands
161 :: [pgpr_0]"m" (pGPR[0]),
162 [pgpr_2]"m" (pGPR[2]),
163 [pgpr_4]"m" (pGPR[4]),
164 [pgpr_6]"m" (pGPR[6]),
165 [pregisterreturn]"m" (pRegisterReturn),
166 [pfpr_0]"m" (pFPR[0]),
167 [pfpr_2]"m" (pFPR[2]),
168 [pfpr_4]"m" (pFPR[4]),
169 [pfpr_6]"m" (pFPR[6]),
170 [pmethod]"r" (pMethod)
171 // Clobbers
172 : "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7", "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15", "x16", "x17",
173 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7"
174 );
175
176 MapReturn(pGPR, pFPR, pReturnType, (sal_uInt64 *) pRegisterReturn);
177}
178}
179
180#define INSERT_INT64( pSV, nr, pGPR, pDS ) \
181 if ( nr < arm::MAX_GPR_REGS ) \
182 pGPR[nr++] = *reinterpret_cast<sal_uInt64 *>( pSV ); \
183 else \
184 *pDS++ = *reinterpret_cast<sal_uInt64 *>( pSV );
185
186#define INSERT_INT32( pSV, nr, pGPR, pDS ) \
187 if ( nr < arm::MAX_GPR_REGS ) \
188 pGPR[nr++] = *reinterpret_cast<sal_uInt32 *>( pSV ); \
189 else \
190 *pDS++ = *reinterpret_cast<sal_uInt32 *>( pSV );
191
192#define INSERT_INT16( pSV, nr, pGPR, pDS ) \
193 if ( nr < arm::MAX_GPR_REGS ) \
194 pGPR[nr++] = *reinterpret_cast<sal_uInt16 *>( pSV ); \
195 else \
196 *pDS++ = *reinterpret_cast<sal_uInt16 *>( pSV );
197
198#define INSERT_INT8( pSV, nr, pGPR, pDS ) \
199 if ( nr < arm::MAX_GPR_REGS ) \
200 pGPR[nr++] = *reinterpret_cast<sal_uInt8 *>( pSV ); \
201 else \
202 *pDS++ = *reinterpret_cast<sal_uInt8 *>( pSV );
203
204#define INSERT_DOUBLE( pSV, nr, pFPR, pDS ) \
205 if ( nr < arm::MAX_FPR_REGS ) \
206 pFPR[nr++] = *reinterpret_cast<double *>( pSV ); \
207 else \
208 *pDS++ = *reinterpret_cast<double *>( pSV );
209
210#define INSERT_FLOAT( pSV, nr, pFPR, pDS ) \
211 INSERT_DOUBLE( pSV, nr, pGPR, pDS )
212
213namespace {
214static void cpp_call(
217 typelib_TypeDescriptionReference * pReturnTypeRef,
218 sal_Int32 nParams, typelib_MethodParameter * pParams,
219 void * pUnoReturn, void * pUnoArgs[], uno_Any ** ppUnoExc )
220{
221 // max space for: values|ptr ...
222 sal_uInt64 * pStack = (sal_uInt64 *)alloca( (nParams+2) * sizeof(sal_Int64) );
223 sal_uInt64 * pStackStart = pStack;
224
225 sal_uInt64 pGPR[arm::MAX_GPR_REGS];
226 int nGPR = 0;
227
228 // storage and counter for SIMD/FP registers
229 double pFPR[arm::MAX_FPR_REGS];
230 int nFPR = 0;
231
232 // return
233 typelib_TypeDescription * pReturnTypeDescr = 0;
234 TYPELIB_DANGER_GET( &pReturnTypeDescr, pReturnTypeRef );
235 assert( pReturnTypeDescr);
236
237 void * pCppReturn = 0; // if != 0 && != pUnoReturn, needs reconversion
238
239 if (pReturnTypeDescr)
240 {
241 if (!arm::return_in_x8( pReturnTypeRef ) )
242 pCppReturn = pUnoReturn; // direct way for simple types
243 else
244 {
245 // complex return via x8
246 pCppReturn = (bridges::cpp_uno::shared::relatesToInterfaceType( pReturnTypeDescr )
247 ? alloca( pReturnTypeDescr->nSize )
248 : pUnoReturn); // direct way
249 }
250 }
251 // push this
252 void * pAdjustedThisPtr = reinterpret_cast< void ** >(pThis->getCppI())
253 + aVtableSlot.offset;
254 INSERT_INT64( &pAdjustedThisPtr, nGPR, pGPR, pStack );
255
256 // stack space
257 // args
258 void ** pCppArgs = (void **)alloca( sizeof(void *) * nParams );
259
260 // indices of values this have to be converted (interface conversion cpp<=>uno)
261 int * pTempIndices = (int *)alloca( sizeof(int) * nParams );
262
263 // type descriptions for reconversions
264 typelib_TypeDescription ** ppTempParamTypeDescr = (typelib_TypeDescription **)alloca( sizeof(void *) * nParams );
265
266 sal_Int32 nTempIndices = 0;
267
268 for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
269 {
270 const typelib_MethodParameter & rParam = pParams[nPos];
271 typelib_TypeDescription * pParamTypeDescr = 0;
272 TYPELIB_DANGER_GET( &pParamTypeDescr, rParam.pTypeRef );
273
274 if (!rParam.bOut && bridges::cpp_uno::shared::isSimpleType( pParamTypeDescr ))
275 {
276 uno_copyAndConvertData( pCppArgs[nPos] = alloca(8), pUnoArgs[nPos],
277 pParamTypeDescr, pThis->getBridge()->getUno2Cpp() );
278
279 switch (pParamTypeDescr->eTypeClass)
280 {
281 case typelib_TypeClass_HYPER:
282 case typelib_TypeClass_UNSIGNED_HYPER:
283 INSERT_INT64( pCppArgs[nPos], nGPR, pGPR, pStack );
284 break;
285 case typelib_TypeClass_LONG:
286 case typelib_TypeClass_UNSIGNED_LONG:
287 case typelib_TypeClass_ENUM:
288 INSERT_INT32( pCppArgs[nPos], nGPR, pGPR, pStack );
289 break;
290 case typelib_TypeClass_SHORT:
291 case typelib_TypeClass_CHAR:
292 case typelib_TypeClass_UNSIGNED_SHORT:
293 INSERT_INT16( pCppArgs[nPos], nGPR, pGPR, pStack );
294 break;
295 case typelib_TypeClass_BOOLEAN:
296 case typelib_TypeClass_BYTE:
297 INSERT_INT8( pCppArgs[nPos], nGPR, pGPR, pStack );
298 break;
299 case typelib_TypeClass_FLOAT:
300 INSERT_FLOAT( pCppArgs[nPos], nFPR, pFPR, pStack );
301 break;
302 case typelib_TypeClass_DOUBLE:
303 INSERT_DOUBLE( pCppArgs[nPos], nFPR, pFPR, pStack );
304 break;
305 default:
306 break;
307 }
308 // no longer needed
309 TYPELIB_DANGER_RELEASE( pParamTypeDescr );
310 }
311 else // ptr to complex value | ref
312 {
313 if (! rParam.bIn) // is pure out
314 {
315 // cpp out is constructed mem, uno out is not!
317 pCppArgs[nPos] = alloca( pParamTypeDescr->nSize ),
318 pParamTypeDescr );
319 pTempIndices[nTempIndices] = nPos; // default constructed for cpp call
320 // will be released at reconversion
321 ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
322 }
323 // is in/inout
324 else if (bridges::cpp_uno::shared::relatesToInterfaceType( pParamTypeDescr ))
325 {
327 pCppArgs[nPos] = alloca( pParamTypeDescr->nSize ),
328 pUnoArgs[nPos], pParamTypeDescr, pThis->getBridge()->getUno2Cpp() );
329
330 pTempIndices[nTempIndices] = nPos; // has to be reconverted
331 // will be released at reconversion
332 ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
333 }
334 else // direct way
335 {
336 pCppArgs[nPos] = pUnoArgs[nPos];
337 // no longer needed
338 TYPELIB_DANGER_RELEASE( pParamTypeDescr );
339 }
340 INSERT_INT64( &(pCppArgs[nPos]), nGPR, pGPR, pStack );
341 }
342 }
343
344 assert( nGPR <= arm::MAX_GPR_REGS );
345 assert( nFPR <= arm::MAX_FPR_REGS );
346
347 try
348 {
349 try {
351 pAdjustedThisPtr, aVtableSlot.index,
352 pCppReturn, pReturnTypeRef,
353 pStackStart,
354 (pStack - pStackStart),
355 pGPR,
356 pFPR);
357 } catch (css::uno::Exception &) {
358 throw;
359 } catch (std::exception & e) {
360 throw css::uno::RuntimeException(
361 "C++ code threw " + o3tl::runtimeToOUString(typeid(e).name()) + ": "
362 + o3tl::runtimeToOUString(e.what()));
363 } catch (...) {
364 throw css::uno::RuntimeException("C++ code threw unknown exception");
365 }
366
367 // NO exception occurred...
368 *ppUnoExc = 0;
369
370 // reconvert temporary params
371 for ( ; nTempIndices--; )
372 {
373 sal_Int32 nIndex = pTempIndices[nTempIndices];
374 typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndices];
375
376 if (pParams[nIndex].bIn)
377 {
378 if (pParams[nIndex].bOut) // inout
379 {
380 uno_destructData( pUnoArgs[nIndex], pParamTypeDescr, 0 ); // destroy uno value
381 uno_copyAndConvertData( pUnoArgs[nIndex], pCppArgs[nIndex], pParamTypeDescr,
382 pThis->getBridge()->getCpp2Uno() );
383 }
384 }
385 else // pure out
386 {
387 uno_copyAndConvertData( pUnoArgs[nIndex], pCppArgs[nIndex], pParamTypeDescr,
388 pThis->getBridge()->getCpp2Uno() );
389 }
390 // destroy temp cpp param => cpp: every param was constructed
391 uno_destructData( pCppArgs[nIndex], pParamTypeDescr, cpp_release );
392
393 TYPELIB_DANGER_RELEASE( pParamTypeDescr );
394 }
395 // return value
396 if (pCppReturn && pUnoReturn != pCppReturn)
397 {
398 uno_copyAndConvertData( pUnoReturn, pCppReturn, pReturnTypeDescr,
399 pThis->getBridge()->getCpp2Uno() );
400 uno_destructData( pCppReturn, pReturnTypeDescr, cpp_release );
401 }
402 }
403 catch (...)
404 {
405 // fill uno exception
407
408 // temporary params
409 for ( ; nTempIndices--; )
410 {
411 sal_Int32 nIndex = pTempIndices[nTempIndices];
412 // destroy temp cpp param => cpp: every param was constructed
413 uno_destructData( pCppArgs[nIndex], ppTempParamTypeDescr[nTempIndices], cpp_release );
414 TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndices] );
415 }
416
417 // return type
418 if (pReturnTypeDescr)
419 TYPELIB_DANGER_RELEASE( pReturnTypeDescr );
420 }
421}
422}
423
424namespace bridges::cpp_uno::shared {
425
427 uno_Interface * pUnoI, const typelib_TypeDescription * pMemberDescr,
428 void * pReturn, void * pArgs[], uno_Any ** ppException )
429{
430 // is my surrogate
432 = static_cast< bridges::cpp_uno::shared::UnoInterfaceProxy * >(pUnoI);
433#if OSL_DEBUG_LEVEL > 0
434 typelib_InterfaceTypeDescription * pTypeDescr = pThis->pTypeDescr;
435#endif
436
437 switch (pMemberDescr->eTypeClass)
438 {
439 case typelib_TypeClass_INTERFACE_ATTRIBUTE:
440 {
441#if OSL_DEBUG_LEVEL > 0
442 // determine vtable call index
443 sal_Int32 nMemberPos = ((typelib_InterfaceMemberTypeDescription *)pMemberDescr)->nPosition;
444 assert( nMemberPos < pTypeDescr->nAllMembers && "### member pos out of range!");
445#endif
446
447 VtableSlot aVtableSlot(
449 reinterpret_cast<typelib_InterfaceAttributeTypeDescription const *>
450 (pMemberDescr)));
451
452 if (pReturn)
453 {
454 // dependent dispatch
455 cpp_call(
456 pThis, aVtableSlot,
457 ((typelib_InterfaceAttributeTypeDescription *)pMemberDescr)->pAttributeTypeRef,
458 0, 0, // no params
459 pReturn, pArgs, ppException );
460 }
461 else
462 {
463 // is SET
464 typelib_MethodParameter aParam;
465 aParam.pTypeRef =
466 ((typelib_InterfaceAttributeTypeDescription *)pMemberDescr)->pAttributeTypeRef;
467 aParam.bIn = sal_True;
468 aParam.bOut = sal_False;
469
470 typelib_TypeDescriptionReference * pReturnTypeRef = 0;
471 OUString aVoidName("void");
473 &pReturnTypeRef, typelib_TypeClass_VOID, aVoidName.pData );
474
475 // dependent dispatch
476 aVtableSlot.index += 1;
477 cpp_call(
478 pThis, aVtableSlot, // get, then set method
479 pReturnTypeRef,
480 1, &aParam,
481 pReturn, pArgs, ppException );
482
484 }
485
486 break;
487 }
488 case typelib_TypeClass_INTERFACE_METHOD:
489 {
490#if OSL_DEBUG_LEVEL > 0
491 // determine vtable call index
492 sal_Int32 nMemberPos = ((typelib_InterfaceMemberTypeDescription *)pMemberDescr)->nPosition;
493 assert(nMemberPos < pTypeDescr->nAllMembers && "### member pos out of range!");
494#endif
495
496 VtableSlot aVtableSlot(
498 reinterpret_cast<typelib_InterfaceMethodTypeDescription const *>
499 (pMemberDescr)));
500
501 switch (aVtableSlot.index)
502 {
503 // standard calls
504 case 1: // acquire uno interface
505 (*pUnoI->acquire)( pUnoI );
506 *ppException = 0;
507 break;
508 case 2: // release uno interface
509 (*pUnoI->release)( pUnoI );
510 *ppException = 0;
511 break;
512 case 0: // queryInterface() opt
513 {
514 typelib_TypeDescription * pTD = 0;
515 TYPELIB_DANGER_GET( &pTD, reinterpret_cast< Type * >( pArgs[0] )->getTypeLibType() );
516 if (pTD)
517 {
518 uno_Interface * pInterface = 0;
519 (*pThis->getBridge()->getUnoEnv()->getRegisteredInterface)(
520 pThis->getBridge()->getUnoEnv(),
521 (void **)&pInterface, pThis->oid.pData, (typelib_InterfaceTypeDescription *)pTD );
522
523 if (pInterface)
524 {
525 ::uno_any_construct(
526 reinterpret_cast< uno_Any * >( pReturn ),
527 &pInterface, pTD, 0 );
528 (*pInterface->release)( pInterface );
529 TYPELIB_DANGER_RELEASE( pTD );
530 *ppException = 0;
531 break;
532 }
533 TYPELIB_DANGER_RELEASE( pTD );
534 }
535 } // else perform queryInterface()
536 [[fallthrough]];
537 default:
538 // dependent dispatch
539 cpp_call(
540 pThis, aVtableSlot,
541 ((typelib_InterfaceMethodTypeDescription *)pMemberDescr)->pReturnTypeRef,
542 ((typelib_InterfaceMethodTypeDescription *)pMemberDescr)->nParams,
543 ((typelib_InterfaceMethodTypeDescription *)pMemberDescr)->pParams,
544 pReturn, pArgs, ppException );
545 }
546 break;
547 }
548 default:
549 {
550 ::com::sun::star::uno::RuntimeException aExc(
551 "illegal member type description!",
553
554 Type const & rExcType = cppu::UnoType<decltype(aExc)>::get();
555 // binary identical null reference
556 ::uno_type_any_construct( *ppException, &aExc, rExcType.getTypeLibType(), 0 );
557 }
558 }
559}
560
561}
562
563#endif
564
565/* 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()
typelib_InterfaceTypeDescription * pTypeDescr
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()
#define INSERT_INT64(pSV, pDS)
#define INSERT_FLOAT(pSV, nr, pFPR, pDS)
#define INSERT_DOUBLE(pSV, nr, pFPR, pDS)
#define INSERT_INT8(pSV, pDS)
#define INSERT_INT16(pSV, pDS)
#define INSERT_INT32(pSV, pDS)
char const * name
void MapReturn(long r0, typelib_TypeClass eTypeClass, sal_uInt64 *pRegisterReturn)
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
void * p
sal_uInt16 nPos
struct _typelib_TypeDescription typelib_TypeDescription
Definition: msvc/except.hxx:52
struct _uno_Any uno_Any
Definition: msvc/except.hxx:31
void dummy_can_throw_anything(char const *)
void fillUnoException(uno_Any *pExc, uno_Mapping *pCpp2Uno)
bool return_in_x8(typelib_TypeDescriptionReference *pTypeRef)
@ MAX_FPR_REGS
@ MAX_GPR_REGS
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
int i
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
ResultType type