LibreOffice Module bridges (master) 1
gcc3_linux_hppa/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 <malloc.h>
21#include <rtl/alloc.h>
22
23#include <com/sun/star/uno/genfunc.hxx>
24#include <com/sun/star/uno/Exception.hpp>
25#include "com/sun/star/uno/RuntimeException.hpp"
27#include <uno/data.h>
28
29#include <bridge.hxx>
30#include <types.hxx>
31#include <unointerfaceproxy.hxx>
32#include <vtables.hxx>
33
34#include "share.hxx"
35
36#include <exception>
37#include <stdio.h>
38#include <string.h>
39#include <typeinfo>
40
41using namespace ::com::sun::star::uno;
42
43void callVirtualMethod(void * pThis, sal_uInt32 nVtableIndex,
44 void * pRegisterReturn, typelib_TypeDescription *pReturnTypeDescr, bool bRegisterReturn,
45 sal_uInt32 *pStack, sal_uInt32 nStack, sal_uInt32 *pGPR, double *pFPR);
46
47#define INSERT_INT32( pSV, nr, pGPR, pDS, bOverflow )\
48 if (nr < hppa::MAX_WORDS_IN_REGS) \
49 { \
50 pGPR[nr++] = *reinterpret_cast<sal_uInt32 *>( pSV ); \
51 } \
52 else \
53 bOverflow = true; \
54 if (bOverflow) \
55 *pDS++ = *reinterpret_cast<sal_uInt32 *>( pSV );
56
57#define INSERT_INT64( pSV, nr, pGPR, pDS, pStart, bOverflow )\
58 if ( (nr < hppa::MAX_WORDS_IN_REGS) && (nr % 2) ) \
59 { \
60 ++nr; \
61 } \
62 if ( nr < hppa::MAX_WORDS_IN_REGS ) \
63 { \
64 pGPR[nr++] = *reinterpret_cast<sal_uInt32 *>( pSV ); \
65 pGPR[nr++] = *(reinterpret_cast<sal_uInt32 *>( pSV ) + 1); \
66 } \
67 else \
68 bOverflow = true; \
69 if ( bOverflow ) \
70 { \
71 if ( (pDS - pStart) % 2) \
72 ++pDS; \
73 *pDS++ = reinterpret_cast<sal_uInt32 *>( pSV )[1]; \
74 *pDS++ = reinterpret_cast<sal_uInt32 *>( pSV )[0]; \
75 }
76
77#define INSERT_FLOAT( pSV, nr, pFPR, pDS, bOverflow ) \
78 if (nr < hppa::MAX_WORDS_IN_REGS) \
79 { \
80 sal_uInt32 *pDouble = (sal_uInt32 *)&(pFPR[nr++]); \
81 pDouble[0] = *reinterpret_cast<sal_uInt32 *>( pSV ); \
82 } \
83 else \
84 bOverflow = true; \
85 if (bOverflow) \
86 *pDS++ = *reinterpret_cast<sal_uInt32 *>( pSV );
87
88#define INSERT_DOUBLE( pSV, nr, pFPR, pDS, pStart, bOverflow ) \
89 if ( (nr < hppa::MAX_WORDS_IN_REGS) && (nr % 2) ) \
90 { \
91 ++nr; \
92 } \
93 if ( nr < hppa::MAX_WORDS_IN_REGS ) \
94 { \
95 sal_uInt32 *pDouble = (sal_uInt32 *)&(pFPR[nr+1]); \
96 pDouble[0] = *reinterpret_cast<sal_uInt32 *>( pSV ); \
97 pDouble[1] = *(reinterpret_cast<sal_uInt32 *>( pSV ) + 1); \
98 nr+=2; \
99 } \
100 else \
101 bOverflow = true; \
102 if ( bOverflow ) \
103 { \
104 if ( (pDS - pStart) % 2) \
105 ++pDS; \
106 *pDS++ = reinterpret_cast<sal_uInt32 *>( pSV )[1]; \
107 *pDS++ = reinterpret_cast<sal_uInt32 *>( pSV )[0]; \
108 }
109
110#define INSERT_INT16( pSV, nr, pGPR, pDS, bOverflow ) \
111 if ( nr < hppa::MAX_WORDS_IN_REGS ) \
112 pGPR[nr++] = *reinterpret_cast<sal_uInt16 *>( pSV ); \
113 else \
114 bOverflow = true; \
115 if (bOverflow) \
116 *pDS++ = *reinterpret_cast<sal_uInt16 *>( pSV );
117
118#define INSERT_INT8( pSV, nr, pGPR, pDS, bOverflow ) \
119 if ( nr < hppa::MAX_WORDS_IN_REGS ) \
120 pGPR[nr++] = *reinterpret_cast<sal_uInt8 *>( pSV ); \
121 else \
122 bOverflow = true; \
123 if (bOverflow) \
124 *pDS++ = *reinterpret_cast<sal_uInt8 *>( pSV );
125
126namespace hppa
127{
129 {
130 const typelib_CompoundTypeDescription * p
131 = reinterpret_cast< const typelib_CompoundTypeDescription * >(type);
132 for (sal_Int32 i = 0; i < p->nMembers; ++i)
133 {
134 if (p->ppTypeRefs[i]->eTypeClass == typelib_TypeClass_STRUCT ||
135 p->ppTypeRefs[i]->eTypeClass == typelib_TypeClass_EXCEPTION)
136 {
138 TYPELIB_DANGER_GET(&t, p->ppTypeRefs[i]);
139 bool b = is_complex_struct(t);
140 TYPELIB_DANGER_RELEASE(t);
141 if (b) {
142 return true;
143 }
144 }
145 else if (!bridges::cpp_uno::shared::isSimpleType(p->ppTypeRefs[i]->eTypeClass))
146 return true;
147 }
148 if (p->pBaseTypeDescription != 0)
149 return is_complex_struct(&p->pBaseTypeDescription->aBase);
150 return false;
151 }
152
153 bool isRegisterReturn( typelib_TypeDescriptionReference *pTypeRef )
154 {
156 return true;
157 else if (pTypeRef->eTypeClass == typelib_TypeClass_STRUCT || pTypeRef->eTypeClass == typelib_TypeClass_EXCEPTION)
158 {
159 typelib_TypeDescription * pTypeDescr = 0;
160 TYPELIB_DANGER_GET( &pTypeDescr, pTypeRef );
161
162 /* If the struct is larger than 8 bytes, then there is a buffer at r8 to stick the return value into */
163 bool bRet = pTypeDescr->nSize <= 8 && !is_complex_struct(pTypeDescr);
164
165 TYPELIB_DANGER_RELEASE( pTypeDescr );
166 return bRet;
167 }
168 return false;
169 }
170}
171
172
173namespace {
174
175static void cpp_call(
178 typelib_TypeDescriptionReference * pReturnTypeRef,
179 sal_Int32 nParams, typelib_MethodParameter * pParams,
180 void * pUnoReturn, void * pUnoArgs[], uno_Any ** ppUnoExc )
181{
182 // max space for: [complex ret ptr], values|ptr ...
183 sal_uInt32 * pStack = (sal_uInt32 *)__builtin_alloca(
184 sizeof(sal_Int32) + ((nParams+2) * sizeof(sal_Int64)) );
185 sal_uInt32 * pStackStart = pStack;
186
187 sal_uInt32 pGPR[hppa::MAX_GPR_REGS];
188 double pFPR[hppa::MAX_SSE_REGS];
189 sal_uInt32 nRegs=0;
190
191 // return
192 typelib_TypeDescription * pReturnTypeDescr = 0;
193 TYPELIB_DANGER_GET( &pReturnTypeDescr, pReturnTypeRef );
194 assert(pReturnTypeDescr);
195
196 void * pCppReturn = 0; // if != 0 && != pUnoReturn, needs reconversion
197 bool bOverflow = false;
198 bool bRegisterReturn = true;
199
200 if (pReturnTypeDescr)
201 {
202
203 bRegisterReturn = hppa::isRegisterReturn(pReturnTypeRef);
204 if (bRegisterReturn)
205 pCppReturn = pUnoReturn; // direct way for simple types
206 else
207 {
208 // complex return via ptr
209 pCppReturn = (bridges::cpp_uno::shared::relatesToInterfaceType( pReturnTypeDescr )
210 ? __builtin_alloca( pReturnTypeDescr->nSize )
211 : pUnoReturn); // direct way
212 }
213 }
214 // push this
215 void * pAdjustedThisPtr = reinterpret_cast< void ** >(pThis->getCppI())
216 + aVtableSlot.offset;
217 INSERT_INT32( &pAdjustedThisPtr, nRegs, pGPR, pStack, bOverflow );
218
219 // stack space
220 static_assert(sizeof(void *) == sizeof(sal_Int32), "### unexpected size!");
221 // args
222 void ** pCppArgs = (void **)alloca( 3 * sizeof(void *) * nParams );
223 // indices of values this have to be converted (interface conversion cpp<=>uno)
224 sal_Int32 * pTempIndices = (sal_Int32 *)(pCppArgs + nParams);
225 // type descriptions for reconversions
226 typelib_TypeDescription ** ppTempParamTypeDescr = (typelib_TypeDescription **)(pCppArgs + (2 * nParams));
227
228 sal_Int32 nTempIndices = 0;
229
230 for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
231 {
232 const typelib_MethodParameter & rParam = pParams[nPos];
233 typelib_TypeDescription * pParamTypeDescr = 0;
234 TYPELIB_DANGER_GET( &pParamTypeDescr, rParam.pTypeRef );
235
236 if (!rParam.bOut && bridges::cpp_uno::shared::isSimpleType( pParamTypeDescr ))
237 {
238 uno_copyAndConvertData( pCppArgs[nPos] = alloca(8), pUnoArgs[nPos],
239 pParamTypeDescr, pThis->getBridge()->getUno2Cpp() );
240
241 switch (pParamTypeDescr->eTypeClass)
242 {
243 case typelib_TypeClass_HYPER:
244 case typelib_TypeClass_UNSIGNED_HYPER:
245#if OSL_DEBUG_LEVEL > 2
246 fprintf(stderr, "hyper is %llx\n", *((long long*)pCppArgs[nPos]));
247#endif
248 INSERT_INT64( pCppArgs[nPos], nRegs, pGPR, pStack, pStackStart, bOverflow );
249 break;
250 case typelib_TypeClass_LONG:
251 case typelib_TypeClass_UNSIGNED_LONG:
252 case typelib_TypeClass_ENUM:
253#if OSL_DEBUG_LEVEL > 2
254 fprintf(stderr, "long is %x\n", pCppArgs[nPos]);
255#endif
256 INSERT_INT32( pCppArgs[nPos], nRegs, pGPR, pStack, bOverflow );
257 break;
258 case typelib_TypeClass_SHORT:
259 case typelib_TypeClass_CHAR:
260 case typelib_TypeClass_UNSIGNED_SHORT:
261 INSERT_INT16( pCppArgs[nPos], nRegs, pGPR, pStack, bOverflow );
262 break;
263 case typelib_TypeClass_BOOLEAN:
264 case typelib_TypeClass_BYTE:
265 INSERT_INT8( pCppArgs[nPos], nRegs, pGPR, pStack, bOverflow );
266 break;
267 case typelib_TypeClass_FLOAT:
268 INSERT_FLOAT( pCppArgs[nPos], nRegs, pFPR, pStack, bOverflow );
269 break;
270 case typelib_TypeClass_DOUBLE:
271 INSERT_DOUBLE( pCppArgs[nPos], nRegs, pFPR, pStack, pStackStart, bOverflow );
272 break;
273 default:
274 break;
275 }
276 // no longer needed
277 TYPELIB_DANGER_RELEASE( pParamTypeDescr );
278 }
279 else // ptr to complex value | ref
280 {
281 if (! rParam.bIn) // is pure out
282 {
283 // cpp out is constructed mem, uno out is not!
285 pCppArgs[nPos] = alloca( pParamTypeDescr->nSize ),
286 pParamTypeDescr );
287 pTempIndices[nTempIndices] = nPos; // default constructed for cpp call
288 // will be released at reconversion
289 ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
290 }
291 // is in/inout
292 else if (bridges::cpp_uno::shared::relatesToInterfaceType( pParamTypeDescr ))
293 {
295 pCppArgs[nPos] = alloca( pParamTypeDescr->nSize ),
296 pUnoArgs[nPos], pParamTypeDescr, pThis->getBridge()->getUno2Cpp() );
297
298 pTempIndices[nTempIndices] = nPos; // has to be reconverted
299 // will be released at reconversion
300 ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
301 }
302 else // direct way
303 {
304 pCppArgs[nPos] = pUnoArgs[nPos];
305 // no longer needed
306 TYPELIB_DANGER_RELEASE( pParamTypeDescr );
307 }
308 INSERT_INT32( &(pCppArgs[nPos]), nRegs, pGPR, pStack, bOverflow );
309 }
310 }
311
312 try
313 {
314 try {
316 pAdjustedThisPtr, aVtableSlot.index,
317 pCppReturn, pReturnTypeDescr, bRegisterReturn,
318 pStackStart,
319 (pStack - pStackStart), pGPR, pFPR);
320 } catch (css::uno::Exception &) {
321 throw;
322 } catch (std::exception & e) {
323 throw css::uno::RuntimeException(
324 "C++ code threw " + o3tl::runtimeToOUString(typeid(e).name()) + ": "
325 + o3tl::runtimeToOUString(e.what()));
326 } catch (...) {
327 throw css::uno::RuntimeException("C++ code threw unknown exception");
328 }
329
330 // NO exception occurred...
331 *ppUnoExc = 0;
332
333 // reconvert temporary params
334 for ( ; nTempIndices--; )
335 {
336 sal_Int32 nIndex = pTempIndices[nTempIndices];
337 typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndices];
338
339 if (pParams[nIndex].bIn)
340 {
341 if (pParams[nIndex].bOut) // inout
342 {
343 uno_destructData( pUnoArgs[nIndex], pParamTypeDescr, 0 ); // destroy uno value
344 uno_copyAndConvertData( pUnoArgs[nIndex], pCppArgs[nIndex], pParamTypeDescr,
345 pThis->getBridge()->getCpp2Uno() );
346 }
347 }
348 else // pure out
349 {
350 uno_copyAndConvertData( pUnoArgs[nIndex], pCppArgs[nIndex], pParamTypeDescr,
351 pThis->getBridge()->getCpp2Uno() );
352 }
353 // destroy temp cpp param => cpp: every param was constructed
354 uno_destructData( pCppArgs[nIndex], pParamTypeDescr, cpp_release );
355
356 TYPELIB_DANGER_RELEASE( pParamTypeDescr );
357 }
358 // return value
359 if (pCppReturn && pUnoReturn != pCppReturn)
360 {
361 uno_copyAndConvertData( pUnoReturn, pCppReturn, pReturnTypeDescr,
362 pThis->getBridge()->getCpp2Uno() );
363 uno_destructData( pCppReturn, pReturnTypeDescr, cpp_release );
364 }
365 }
366 catch (...)
367 {
368 // fill uno exception
370
371 // temporary params
372 for ( ; nTempIndices--; )
373 {
374 sal_Int32 nIndex = pTempIndices[nTempIndices];
375 // destroy temp cpp param => cpp: every param was constructed
376 uno_destructData( pCppArgs[nIndex], ppTempParamTypeDescr[nTempIndices], cpp_release );
377 TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndices] );
378 }
379
380 // return type
381 if (pReturnTypeDescr)
382 TYPELIB_DANGER_RELEASE( pReturnTypeDescr );
383 }
384}
385}
386
387namespace bridges::cpp_uno::shared {
388
390 uno_Interface * pUnoI, const typelib_TypeDescription * pMemberDescr,
391 void * pReturn, void * pArgs[], uno_Any ** ppException )
392{
393 // is my surrogate
395 = static_cast< bridges::cpp_uno::shared::UnoInterfaceProxy * >(pUnoI);
396#if OSL_DEBUG_LEVEL > 0
397 typelib_InterfaceTypeDescription * pTypeDescr = pThis->pTypeDescr;
398#endif
399
400 switch (pMemberDescr->eTypeClass)
401 {
402 case typelib_TypeClass_INTERFACE_ATTRIBUTE:
403 {
404#if OSL_DEBUG_LEVEL > 0
405 // determine vtable call index
406 sal_Int32 nMemberPos = ((typelib_InterfaceMemberTypeDescription *)pMemberDescr)->nPosition;
407 assert(nMemberPos < pTypeDescr->nAllMembers);
408#endif
409
410 VtableSlot aVtableSlot(
412 reinterpret_cast<typelib_InterfaceAttributeTypeDescription const *>
413 (pMemberDescr)));
414
415 if (pReturn)
416 {
417 // dependent dispatch
418 cpp_call(
419 pThis, aVtableSlot,
420 ((typelib_InterfaceAttributeTypeDescription *)pMemberDescr)->pAttributeTypeRef,
421 0, 0, // no params
422 pReturn, pArgs, ppException );
423 }
424 else
425 {
426 // is SET
427 typelib_MethodParameter aParam;
428 aParam.pTypeRef =
429 ((typelib_InterfaceAttributeTypeDescription *)pMemberDescr)->pAttributeTypeRef;
430 aParam.bIn = sal_True;
431 aParam.bOut = sal_False;
432
433 typelib_TypeDescriptionReference * pReturnTypeRef = 0;
434 OUString aVoidName("void");
436 &pReturnTypeRef, typelib_TypeClass_VOID, aVoidName.pData );
437
438 // dependent dispatch
439 aVtableSlot.index += 1;
440 cpp_call(
441 pThis, aVtableSlot, // get, then set method
442 pReturnTypeRef,
443 1, &aParam,
444 pReturn, pArgs, ppException );
445
447 }
448
449 break;
450 }
451 case typelib_TypeClass_INTERFACE_METHOD:
452 {
453#if OSL_DEBUG_LEVEL > 0
454 // determine vtable call index
455 sal_Int32 nMemberPos = ((typelib_InterfaceMemberTypeDescription *)pMemberDescr)->nPosition;
456 assert(nMemberPos < pTypeDescr->nAllMembers);
457#endif
458
459 VtableSlot aVtableSlot(
461 reinterpret_cast<typelib_InterfaceMethodTypeDescription const *>
462 (pMemberDescr)));
463
464 switch (aVtableSlot.index)
465 {
466 // standard calls
467 case 1: // acquire uno interface
468 (*pUnoI->acquire)( pUnoI );
469 *ppException = 0;
470 break;
471 case 2: // release uno interface
472 (*pUnoI->release)( pUnoI );
473 *ppException = 0;
474 break;
475 case 0: // queryInterface() opt
476 {
477 typelib_TypeDescription * pTD = 0;
478 TYPELIB_DANGER_GET( &pTD, reinterpret_cast< Type * >( pArgs[0] )->getTypeLibType() );
479 if (pTD)
480 {
481 uno_Interface * pInterface = 0;
482 (*pThis->getBridge()->getUnoEnv()->getRegisteredInterface)(
483 pThis->getBridge()->getUnoEnv(),
484 (void **)&pInterface, pThis->oid.pData, (typelib_InterfaceTypeDescription *)pTD );
485
486 if (pInterface)
487 {
488 ::uno_any_construct(
489 reinterpret_cast< uno_Any * >( pReturn ),
490 &pInterface, pTD, 0 );
491 (*pInterface->release)( pInterface );
492 TYPELIB_DANGER_RELEASE( pTD );
493 *ppException = 0;
494 break;
495 }
496
497 TYPELIB_DANGER_RELEASE( pTD );
498 }
499 } // else perform queryInterface()
500 default:
501 // dependent dispatch
502 cpp_call(
503 pThis, aVtableSlot,
504 ((typelib_InterfaceMethodTypeDescription *)pMemberDescr)->pReturnTypeRef,
505 ((typelib_InterfaceMethodTypeDescription *)pMemberDescr)->nParams,
506 ((typelib_InterfaceMethodTypeDescription *)pMemberDescr)->pParams,
507 pReturn, pArgs, ppException );
508 }
509 break;
510 }
511 default:
512 {
513 ::com::sun::star::uno::RuntimeException aExc(
514 "illegal member type description!",
516
517 Type const & rExcType = cppu::UnoType<decltype(aExc)>::get();
518 // binary identical null reference
519 ::uno_type_any_construct( *ppException, &aExc, rExcType.getTypeLibType(), 0 );
520 }
521 }
522}
523
524}
525
526/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
XPropertyListType t
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()
char const * name
#define INSERT_INT32(pSV, nr, pGPR, pDS, bOverflow)
#define INSERT_INT64(pSV, nr, pGPR, pDS, pStart, bOverflow)
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)
#define INSERT_FLOAT(pSV, nr, pFPR, pDS, bOverflow)
#define INSERT_INT16(pSV, nr, pGPR, pDS, bOverflow)
#define INSERT_DOUBLE(pSV, nr, pFPR, pDS, pStart, bOverflow)
#define INSERT_INT8( pSV, nr, pGPR, pDS, bOverflow)
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 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
int i
bool is_complex_struct(const typelib_TypeDescription *type)
bool isRegisterReturn(typelib_TypeDescriptionReference *pTypeRef)
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